github/linuxkit
1
0
Fork 0
mirror of https://github.com/linuxkit/linuxkit.git synced 2025-09-07 01:41:22 +00:00
Code Issues Projects Releases Wiki Activity

add compose dynamic

Browse Source 
Signed-off-by: Avi Deitcher <avi@deitcher.net>
This commit is contained in:
Avi Deitcher
2017-06-01 20:06:46 +03:00
parent abb19f847d
commit e4512864ac
11 changed files with 356 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
projects/compose/README.md Normal file
View File

@@ -0,0 +1,57 @@
# Compose Project
The purpose of this project is to show how moby and linuxkit can be used to build a runnable linuxkit image with compose-style apps ready-to-run.
The apps are simple:
* nginx serving app A
* nginx serving app B
* traefik routing on the basis of hostname between apps A and B
## Compose Methods
We provide samples of two methods for using compose: dynamic and static.
Both methods use the image `linuxkit/compose`. The image does the following:
1. Wait for compose to be ready.
2. If there are any tar files available in `/images/*.tar`, treat them as tarred up docker images and load them into docker via `docker load ...`
3. Run `docker compose ...`
The only difference between dynamic and static is whether or not container images are pre-loaded in the linuxkit image.
* Compose: the `linuxkit/compose` image looks for a compose file at `/compose/docker-compose.yml`
* Images: the `linuxkit/compose` image looks for tarred container images at `/compose/images/*.tar`
### Dynamic
Dynamic loads the _compose_ config into the linuxkit image at build time. Container images are not pre-loaded, and thus docker loads the container images from the registry **at run-time**. This is no different than doing the following:
1. Using the docker linuxkit image
2. Connecting remotely via the docker API
3. Running the compose file remotely
Except that the compose is run at launch time, and there is no need for a remote connection to the docker API.
It works by loading the `docker-compose.yml` file onto the linuxkit image, and making it available to the `compose` container image via a bind-mount.
To build a dynamic image, do `make dynamic`. To run it, do `make run-dynamic`.
### Static
Static loads the _compose_ config **and** the container _images_ into the linuxkit image at build time. When run, docker loads the images from its local cache and does not depend on access to a registry.
It works by loading the `docker-compose.yml` file onto the linuxkit image and tarred up container image files. It then makes them available to the `compose` container image via bind-mounts.
To build a static image, do `make static`. To run it, do `make run-static`.
Static images pre-load them by doing:
1. Download the image locally `docker image pull <image>`
2. Save the image to a local tar file `docker image save -o <image> <imagename>.tar`
3. copy the tar file to the container image
4. When starting the container from the image with the files, load the images into docker before running compose: `docker image load -i <image> && rm -f <imagename>.tar`
### Conversion
A final option would be converting all of the containers defined in a `docker-compose.yml` into linuxkit `services`. It also would require setting up appropriate networks and other services provided by docker when running compose.
An example may be added in the future.