Docker Compose

The basic idea behind Docker Compose is to save you a lot of typing when creating, configuring, stopping, rebuilding or inspecting your containers. We create a docker-compose,yml file to define our docker resources, such as containers (called services in this context), networks and volumes. Then we use a single command to spin everything up or tear it all down.

Using Docker Compose is good for development or maybe staging, but for production there are better alternatives.

Installing Docker Compose

If you installed Docker Desktop/Toolbox for either Windows or Mac, you already have Docker Compose. If you are on a Linux machine, you will need to install Docker Compose using the instructions here.

Creating docker-compose.yml

You can define all kinds of configurations for your services, such as builds, environments, images, networks, ports, volumes.

At the root of the app project, create a file named docker-compose.yml.

1
version: "3.8"
2

3
services:  # aka containers
4
  app:   # name of your container
5
    image: node:12-alpine
6
    command: sh -c "yarn install && yarn run dev"
7
    ports:
8
      - 3000:3000
9
    working_dir: /app
10
    volumes:
11
      - ./:/app
12
    environment:
13
      MYSQL_HOST: mysql   # we can use mysql as hostname here because we defined 'mysql' as a service
14
      MYSQL_USER: root
15
      MYSQL_PASSWORD: secret
16
      MYSQL_DB: todos
17

18
  mysql:
19
    image: mysql:5.7
20
    volumes:
21
      - todo-mysql-data:/var/lib/mysql
22
    environment:
23
      MYSQL_ROOT_PASSWORD: secret
24
      MYSQL_DATABASE: todos
25

26
volumes:
27
  todo-mysql-data:

We can pick any name for the service. The name will automatically become a network alias, which will be useful when defining our MySQL service: See how we use mysql as a value for MYSQL_HOST ? That’s possible because we defined mysql as service name.

By default, Docker Compose automatically creates a network specifically for the application stack, which is why we didn’t define one in the compose file explicitly.

You can use environment variables in docker-compose.yml and forward a environment file to your containers/services: If your are using Linux then you first have to export APP_ENV=development and then:

1
myservice:
2
  env_file:
3
    - ./path/to/app.${APP_ENV}.env

Building images

1
# Build or rebuild services defined in docker-compose.yml
2
docker-compose build
3

4
# Build specific service
5
docker-compose build my-service

Do I need a Dockerfile when I use docker-compose.yml?

Docker Compose lets you choose between the two options:

• build the container from a specified image (without the need of a Dockerfile):

1
services:
2
  example:
3
    image: your/imagename

• build the container out of a Dockerfile:

1
services:
2
  example:
3
    build:
4
      context: path/to/Dockerfile/dir
5
      dockerfile: Dockerfile #here you specify the name of your Dockerfile file

Starting and stopping your services with Docker Compose

1
# Start services (detached)
2
docker-compose up -d
3

4
# Only rebuild 'node' image, not its dependencies
5
docker-compose up --no-deps node

1
# Stop and remove services
2
docker-compose down
3

4
# Stop but do not remove services
5
docker-compose stop
6

7
# Stop and remove services and remove images and volumes
8
docker-compose down --rmi all --volumes
9

10
# Remove services
11
docker-compose rm

By default, named volumes in your compose file are NOT removed when running docker-compose down. If you want to remove the volumes, you will need to add the --volumes flag.

Inspecting services

1
# show running services
2
docker-compose ps
3

4
# show all services
5
docker-compose ps -a
6

7
# You’ll see the logs from each of the services interleaved into a single stream
8
docker-compose logs -f
9

10
# To see the logs of a single service run
11
docker-compose logs -f my-service

Waiting for other containers to start up

When the app is starting up, it actually sits and waits for MySQL to be up and ready before trying to connect to it. Docker doesn’t have any built-in support to wait for another container to be fully up, running, and ready before starting another container. For Node-based projects, you can use the wait-port dependency. Similar projects exist for other languages/frameworks.

Migrating from Docker Compose to Kubernetes

Two options: Compose on Kubernetes (Part of Docker Desktop) and Kompose. After installation of Kompose you can simply run kompose convert in your project root folder and it will create Kubernetes YAML files for you.