docker-compose for large, multi-pod apps
This is a work in progress using the
docker_compose library. It's
a reimplementation of our internal, ad hoc tools using the new
docker-compose.yml version 2 format and Rust.
docker-compose.yml file?If you answer to one or more of these questions is "yes", then conductor
is probably for you. It provides development and deployment tools for
complex docker-compose apps, following
a convention over configuration philosophy.
To install, we recommend using rustup and cargo:
sh
curl https://sh.rustup.rs -sSf | sh
cargo install conductor
We also provide official binary releases for Mac OS X and for Linux. The Linux binaries are statically linked using musl-libc and rust-musl-builder, so they should work on any Linux distribution, including both regular distributions and stripped down distributions like Alpine. Just unzip the binaries and copy them to where you want them.
To see how to use conductor, run conductor --help (which may be newer
than this README during development):
``` conductor: Manage large, multi-pod docker-compose apps
Usage:
conductor [options]
conductor [options] new
Commands: new Create a directory containing a new sample project pull Pull Docker images used by project up Run project stop Stop all containers associated with project exec Run a command inside a container shell Run an interactive shell inside a running container test Run the tests associated with a service, if any repo list List all git repository aliases and URLs repo clone Clone a git repository using its short alias and mount it into the containers that use it
Arguments:
repo list)
pods/
Exec options:
-d Run command detached in background
--privileged Run a command with elevated privileges
--user
General options:
-h, --help Show this message
--version Show the version of conductor
--override=pods/overrides [default: development]
--default-tags=
Run conductor in a directory containing a pods subdirectory. For more
information, see https://github.com/faradayio/conductor.
```
A "pod" is a tightly-linked group of containers that are always deployed together. Kubernetes defines pods as:
A pod (as in a pod of whales or pea pod) is a group of one or more containers (such as Docker containers), the shared storage for those containers, and options about how to run the containers. Pods are always co-located and co-scheduled, and run in a shared context. A pod models an application-specific “logical host” - it contains one or more application containers which are relatively tightly coupled — in a pre-container world, they would have executed on the same physical or virtual machine.
If you're using Amazon's ECS, a pod corresponds to an ECS "task" or
"service". If you're using Docker Swarm, a pod corresponds to a single
docker-compose.xml file full of services that you always launch as a
single unit.
Pods typically talk to other pods using ordinary DNS lookups or service discovery. If a pod accepts outside network connections, it will often do so via a load balancer.
See examples/hello for a complete example.
hello
└── pods
├── common.env
├── frontend.yml
└── overrides
├── development
│ └── common.env
├── production
│ ├── common.env
│ └── frontend.yml
└── test
└── common.env