• Chase Lee

Provide an easy (enough) to use platform for application developers and data scientists to deploy applications (Node.js/Python/Ruby) or “Big Data” (MapReduce/Spark/Flint) jobs without having to set anything up locally.

Use cases:

ACM member A creates a Node.js App that needs MongoDB. If ACM member A's app becomes a hit on campus, A needs to scale the database, load balancing, etc to accommodate the new traffic.

ACM member B takes a Machine Learning class and decides they will use Apache Spark for analysis. B realizes that one standalone container for testing Spark is not powerful enough for the job and wishes to deploy a set of standalone containers (as in, YARN or Mesos on top of CoreOS/Docker) to tackle their job.

https://www.docker.com/

https://coreos.com/

https://wiki.archlinux.org/index.php/systemd

http://deis.io/overview/

https://github.com/CenturyLinkLabs/fig2coreos

https://github.com/rancherio/rancher

https://github.com/rancherio/cattle

https://github.com/progrium/dokku

https://github.com/dokku-alt/dokku-alt

http://mesosphere.com/

http://mesosphere.github.io/marathon/

https://tsuru.io/

https://github.com/jwilder/docker-gen

We will be experimenting with both docker and rkt container engines. The current cluster will most likely be reinstalled. We have briefly discussed the project over the weeks via listserv and SIG meetings. I think we will be settling on a master node to orchestrate the cluster. The master node will also host a master etcd server and a kubernetes-head server. The remaining nodes will be worker nodes.

1. Create cloud-config base for master and worker nodes.
   • Note to account for:
     • Bonded interface
     • Internal DHCP server bonded interface
     • external traffic interface
     • Starting master etcd instance on master node for other machines to sync off of.
     • Starting fleetctl
2. Install Kubernetes
3. Install Test load balancers
4. Install whatever else…

Kubernetes

Kubernetes is an open-source platform for automating deployment, scaling, and operations of application containers across clusters of hosts, providing container-centric infrastructure. Kubernetes is developed by Google. They have the concept of pods, which are a grouping of containers to run a given service. It seems to have a lot of support, as they are using this system on Google's Cloud Platform.

rkt (rock-it)

rkt is the next-generation container manager for Linux clusters. Actively developed from the people who develop CoreOS, rkt is designed for security, simplicity, and composability within modern cluster architectures, rkt discovers, verifies, fetches, and executes application containers with pluggable isolation. rkt can run the same container with varying degrees of protection, from lightweight, OS-level namespace and capabilities isolation to heavier, VM-level hardware virtualization.

Deis

Deis appears to be the easiest way for an single application to be deployed. Deis only focuses on the application container and not on the database container (something about the 12 factor app). Deis appears to have the most support out of all of the products looked at. This product would be great for a simple application developer but would fail for our fellow data scientists. With this solution, we might need to make use of CoreOS's Flannel.

Fig2CoreOS

Fig2CoreOS produces the exact end result of the project in that it allows a highly customize-able, highly-scale-able, and isolated deployment of an application. However, this still doesn't solve the ease of use for a non-sysadmin to deploy an application. I think fig is intuitive enough, but I am not sure about support from the outside world not.

Rancher

Rancher uses Github as an ACL but we can “simply” change the underlying technology to point to a (our) Gitlab server. This tool is really neat because it allows a group of people to modify a set of containers. This seems like a promising tool for monitoring and quick modification of containers, and interaction with the REST API would provide an easy way for scripts to manually scale applications. This seems like a solid fit for application with minimal one-time configurations and not so helpful for elastic services.

Shipyard

This product uses certs and publicly facing docker daemons which sounds pretty dangerous (check out docker's documentation for that one). The product doesn't really look all that different than Rancher and has a bit more logic (like RethinkDB over etcd).

Mesosphere

We can actually deploy this on top of CoreOS. If we run a global service, fleetctl can actively maintain the number of nodes needed for a given Mesos VM.

Marathon

This is a WebUI interface for administrating the Apache Mesos Cluster.

Dokku OR Dokku-alt

This will give up a Heroku like deployment for a simple application. Dokku-alt will give us the ease of deployment of MariaDB, PostgreSQL, MongoDB or Redis databases. However, the lack of a multi-tenant nature of Dokku is the problem that Deis solves. See ( this SO question)

Tsuru

Open Source PaaS solution. Might not have so much support later on but integrates Heroku buildpacks (like Dokku, etc) so ease of use for developers.

OpenStack w/ Heat