Skip to content
This repository has been archived by the owner on Jan 30, 2020. It is now read-only.

Commit

Permalink
Merge pull request #1478 from joshix/fleetvk8s
Browse files Browse the repository at this point in the history 
Documentation: Add comparison of fleet to Kubernetes
  • Loading branch information
@jonboulle
jonboulle committed Mar 9, 2016
2 parents 49ca5fb + 9d9a06a commit 5021cd5
Show file tree
Hide file tree
Showing 3 changed files with 60 additions and 22 deletions.
4 changes: 1 addition & 3 deletions Documentation/deployment-and-configuration.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,9 +21,7 @@ If your etcd cluster has [TLS authentication][etcd-security] enabled, you will n
Environment="FLEET_ETCD_CAFILE=/etc/ssl/etcd/ca.pem"
Environment="FLEET_ETCD_CERTFILE=/etc/ssl/etcd/client.pem"
Environment="FLEET_ETCD_KEYFILE=/etc/ssl/etcd/client-key.pem"
Environment="FLEET_ETCD_SERVERS=https://172.16.0.101:2379,https://172.16.0.102:2379,https://172.16.0.103:2379"
Environment="FLEET_METADATA=hostname=server1"
Environment="FLEET_PUBLIC_IP=172.16.0.101"
Environment="FLEET_ETCD_SERVERS=https://192.0.2.12:2379"
```

#### Using CoreOS Cloud Config
Expand Down
33 changes: 33 additions & 0 deletions Documentation/fleet-k8s-compared.md
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,33 @@
# fleet Compared to Kubernetes

This table briefly compares key features of `fleet` to those in Kubernetes:

|Feature|Description|fleet|kubernetes|
|------------|-----------|-----|----------|
| Load balancer | Kubernetes has built-in *services* abstraction. Fleet doesn't provide this feature directly, but it can [deploy a stacked solution][service-discovery] built atop app containers and external load-balancer software. | - | x |
| Systemd service management | Kubernetes runs only containers grouped in *pods*. Fleet can manage [several kinds][fleet-unit-types] of [systemd units][systemd-units]. | x | - |
| Runs rkt or Docker containers | Kubernetes uses the [Docker API][docker-api] to schedule Docker containers on cluster nodes, and uses the standard host-level [systemd-nspawn][systemd-nspawn] to execute rkt containers. Fleet uses [systemd units][systemd-units] to run containers or any other processes on cluster nodes. | x | x |
| DNS integration | Kubernetes includes a cluster-internal [DNS service][k8s-skydns] for container use. In fleet, such a solution would be constructed from [sidekicks][sidekick] app containers and [service discovery][service-discovery]. | - | x |
| Graphical user interface (GUI) | The Kubernetes [dashboard][k8s-dashboard] provides a minimal cluster mangement GUI, and commercial solutions like [Tectonic][tectonic] elaborate this graphical management. Fleet also has an external [dashboard][fleet-ui] project. | - | x |
| Schedule jobs depending on system resources | Kubernetes uses the [compute resources][compute-resources] abstraction to decide how to distribute load across the cluster. Fleet simply schedules systemd units. | - | x |
| Access Control and ACLs | Kubernetes has built-in [roles][k8s-roles] to provide access restrictions. Fleet doesn't have ACLs, and [by design everyone who has access to the etcd cluster can manage fleet units][security]. | - | x |
| Rolling updates | Kubernetes has built-in [rolling update][k8s-rolling-update] functionality to automate the deployment of new app versions on the cluster. With fleet, new units are scheduled and old ones destroyed manually. | - | x |
| Labels / metadata | Both Kubernetes and Fleet can schedule units depending on hosts' [labels][k8s-node-label] or basic [metadata][metadata]. | x | x |


[compute-resources]: https://github.com/kubernetes/kubernetes/blob/master/docs/user-guide/compute-resources.md
[docker-api]: https://docs.docker.com/engine/reference/api/docker_remote_api/
[fleet-ui]: https://github.com/purpleworks/fleet-ui
[fleet-unit-types]: unit-files-and-scheduling.md#unit-requirements
[k8s-dashboard]: https://github.com/kubernetes/kubernetes/tree/master/cluster/addons/dashboard
[k8s-node-label]: https://github.com/kubernetes/kubernetes/tree/master/docs/user-guide/node-selection
[k8s-roles]: https://github.com/kubernetes/kubernetes/blob/master/docs/design/security.md#roles
[k8s-rolling-update]: https://github.com/kubernetes/kubernetes/blob/master/docs/user-guide/kubectl/kubectl_rolling-update.md
[k8s-skydns]: https://github.com/kubernetes/kubernetes/tree/master/cluster/addons/dns
[metadata]: unit-files-and-scheduling.md#user-defined-requirements
[security]: architecture.md#security
[service-discovery]: examples/service-discovery.md
[sidekick]: https://github.com/coreos/docs/blob/master/fleet/launching-containers-fleet.md#run-a-simple-sidekick
[systemd-nspawn]: https://www.freedesktop.org/software/systemd/man/systemd-nspawn.html
[systemd-units]: https://www.freedesktop.org/software/systemd/man/systemd.unit.html
[tectonic]: https://tectonic.com
45 changes: 26 additions & 19 deletions README.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,40 +3,40 @@
[![Build Status](https://travis-ci.org/coreos/fleet.png?branch=master)](https://travis-ci.org/coreos/fleet)
[![Build Status](https://semaphoreci.com/api/v1/coreos/fleet/branches/master/badge.svg)](https://semaphoreci.com/coreos/fleet)

fleet ties together [systemd](http://coreos.com/using-coreos/systemd) and [etcd](https://github.com/coreos/etcd) into a simple distributed init system. Think of it as an extension of systemd that operates at the cluster level instead of the machine level.
fleet ties together [systemd][coreos-systemd] and [etcd][etcd] into a simple distributed init system. Think of it as an extension of systemd that operates at the cluster level instead of the machine level.

**This project is very low level and is designed as a foundation for higher order orchestration.** fleet is oriented around systemd units and is not a container manager or orchestration system. fleet supports very basic scheduling of systemd units in a cluster. Those looking for more complex scheduling requirements or a first-class container orchestration system should check out [Kubernetes](http://kubernetes.io).
**This project is quite low-level, and is designed as a foundation for higher order orchestration.** fleet is a cluster-wide elaboration on systemd units, and is not a container manager or orchestration system. fleet supports basic scheduling of systemd units across nodes in a cluster. Those looking for more complex scheduling requirements or a first-class container orchestration system should check out [Kubernetes][kubernetes]. The [fleet and kubernetes comparison table][fleet-vs-k8s] has more information about the two systems.

## Current status

fleet has seen production use for some time and is largely considered stable.
However, there are known [scalability limitations](Documentation/fleet-scaling.md) with its architecture.
fleet has seen production use for some time and is largely considered stable.
However, there are known [scalability limitations][fleet-scaling] with its architecture.
As such, it is not recommended to run fleet clusters larger than 100 nodes or with more than 1000 services.
The fleet project is being maintained for bug fixes but the existing maintainers do not intend to add additional major features or significantly rework fleet to address these limitations.

If you are a developer and wish to help maintain fleet and improve its scalability, please email the [maintainers](MAINTAINERS).
If you are a developer and wish to help maintain fleet and improve its scalability, please email the [maintainers][maintainers].

## Using fleet

Launching a unit with fleet is as simple as running `fleetctl start`:

```
```sh
$ fleetctl start examples/hello.service
Unit hello.service launched on 113f16a7.../172.17.8.103
```

The `fleetctl start` command waits for the unit to get scheduled and actually start somewhere in the cluster.
`fleetctl list-unit-files` tells you the desired state of your units and where they are currently scheduled:

```
```sh
$ fleetctl list-unit-files
UNIT HASH DSTATE STATE TMACHINE
hello.service e55c0ae launched launched 113f16a7.../172.17.8.103
```

`fleetctl list-units` exposes the systemd state for each unit in your fleet cluster:

```
```sh
$ fleetctl list-units
UNIT MACHINE ACTIVE SUB
hello.service 113f16a7.../172.17.8.103 active running
Expand All @@ -55,20 +55,15 @@ fleet is not intended to be an all-purpose orchestration system, and as such sup

These patterns are all defined using [custom systemd unit options][unit-files].

[unit-files]: https://github.com/coreos/fleet/blob/master/Documentation/unit-files-and-scheduling.md#fleet-specific-options

## Getting Started

Before you can deploy units, fleet must be [deployed and configured][deploy-and-configure] on each host in your cluster. (If you are running CoreOS, fleet is already installed.)

After you have machines configured (check `fleetctl list-machines`), get to work with the [client][using-the-client.md].

[using-the-client.md]: https://github.com/coreos/fleet/blob/master/Documentation/using-the-client.md
[deploy-and-configure]: https://github.com/coreos/fleet/blob/master/Documentation/deployment-and-configuration.md

### Building

fleet must be built with Go 1.4+ on a Linux machine. Simply run `./build` and then copy the binaries out of bin/ onto each of your machines. The tests can similarly be run by simply invoking `./test`.
fleet must be built with Go 1.4+ on a Linux machine. Simply run `./build` and then copy the binaries out of `bin/` directory onto each of your machines. The tests can similarly be run by simply invoking `./test`.

If you're on a machine without Go 1.4+ but you have Docker installed, run `./build-docker` to compile the binaries instead.

Expand All @@ -79,18 +74,30 @@ If you're on a machine without Go 1.4+ but you have Docker installed, run `./bui
The fleet API uses JSON over HTTP to manage units in a fleet cluster.
See the [API documentation][api-doc] for more information.

[api-doc]: https://github.com/coreos/fleet/blob/master/Documentation/api-v1.md

### Release Notes

See the [releases tab](https://github.com/coreos/fleet/releases) for more information on each release.
See the [releases tab][releases] for more information on each release.

### Contributing

See [CONTRIBUTING](CONTRIBUTING.md) for details on submitting patches and contacting developers via IRC and mailing lists.
See [CONTRIBUTING][contributing] for details on submitting patches and contacting developers via IRC and mailing lists.

### License

fleet is released under the Apache 2.0 license. See the [LICENSE](LICENSE) file for details.
fleet is released under the Apache 2.0 license. See the [LICENSE][license] file for details.

Specific components of fleet use code derivative from software distributed under other licenses; in those cases the appropriate licenses are stipulated alongside the code.

[api-doc]: Documentation/api-v1.md
[contributing]: CONTRIBUTING.md
[coreos-systemd]: https://github.com/coreos/docs/blob/master/os/getting-started-with-systemd.md
[deploy-and-configure]: Documentation/deployment-and-configuration.md
[etcd]: https://github.com/coreos/etcd
[fleet-scaling]: Documentation/fleet-scaling.md
[fleet-vs-k8s]: Documentation/fleet-k8s-compared.md
[kubernetes]: http://kubernetes.io
[license]: LICENSE
[maintainers]: MAINTAINERS
[releases]: https://github.com/coreos/fleet/releases
[unit-files]: Documentation/unit-files-and-scheduling.md#fleet-specific-options
[using-the-client.md]: Documentation/using-the-client.md

0 comments on commit 5021cd5

Please sign in to comment.