Detailed explanation of docker compose usage

Docker Compose usage scenarios

When we develop, an application often depends on multiple services. Using the traditional docker run method, you need to start multiple services one by one, and even configure the corresponding network. The process is cumbersome and inconvenient. Docker compose aims to write the construction and dependencies of multiple services in docker-compose.yml , and then start and shut down the entire service cluster through the docker-compose command.

A basic demo

The demo function is a simple Python program that exposes a web service. This service is used to count the number of times the current service is accessed. The accumulation and storage of times are all based on redis. That is to say, in addition to its own services, the program itself also relies on a redis service. Here are the detailed steps

Find a directory and create a python file app.py in it

import time

import redis
from flask import Flask

app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)

def get_hit_count():
 retries = 5
 while True:
  try:
   return cache.incr('hits')
  except redis.exceptions.ConnectionError as exc:
   if retries == 0:
    raise exc
   retries -= 1
   time.sleep(0.5)

@app.route('/')
def hello():
 count = get_hit_count()
 return 'Hello World! I have been seen {} times.\n'.format(count)

In the same folder, create requirements.txt file

The requirements.txt file is used to declare the dependent libs that the Python program needs to use, which is a bit like the Maven pom file in Java. The components used in the above code are flask and redis. So the content of requirements.txt file is

flask
redis

In the same folder, create a Dockerfile

Dockerfile is used to build our program into a docker image. Generally, Dockerfile will define the basic environment for our code to run, program startup commands, execution ports, etc. The Dockerfile for this example is as follows

FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP=app.py
ENV FLASK_RUN_HOST=0.0.0.0
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
EXPOSE 5000
COPY . .
CMD ["flask", "run"]

In the same file, create a docker-compose.yml file

After completing the above steps, we have obtained the ability to execute our service in Docker form. But this service depends on the redis service. So we organize the dependencies of the services through docker-compose.yml, the content is as follows:

version: "3.8"
services:
 web:
 build: .
 ports:
  - "5000:5000"
 redis:
 image: "redis:alpine"

The file defines two services, web and redis build:. in web will build our code into an image based on the previously defined Dockerfile in the current directory. When it is started as a container, port 5000 will be exposed to the outside world and mapped to the port 5000 of the current host.

The redis service directly uses the ready-made image redis:alpine . No port is specified, and the default port of redis will be exposed.

Basic operation and maintenance

All docker-compose related commands must be executed in the path where docker-compose.yml is located.

Start the service based on docker-compose.yml

In the directory where docker-compose.yml is located, use the command docker-compose up . However, when the console is closed, the corresponding Docker service will also be closed. You can use docker-compose up -d to execute in background detach mode.

docker-compose up can also start a service and its dependencies in the compolse file separately

View the container service list corresponding to the compose service

docker-compose ps

Output example

# docker-compose ps
Name Command State Ports
--------------------------------------------------------------------------------------------
docker_compose_learn_redis_1 docker-entrypoint.sh redis ... Up 6379/tcp
docker_compose_learn_web_1 flask run Up 0.0.0.0:5000->5000/tcp

The service prefix docker_compose_learn is the name of the current project. The project name can be specified by the environment variable COMPOSE_PROJECT_NAME . If not specified, the default project name is the name of the folder where the compose file is located. In this example, the folder name is docker_compose_learn

Of course, a series of services in compose eventually start a series of containers. So you can also use docker container command family to manage them, but it is too troublesome.

Stop the service container

You need to use the command docker-compose stop in the path where docker-compose.yml is located.

Stop the service container and delete the corresponding container

You need to use the command in the path where docker-compose.yml is located.

docker-compose down

Stop the service container and delete the corresponding container and volumes data

You need to use the command in the path where docker-compose.yml is located.

docker-compose down --volumes

This command does not delete the mounted host operating system files.

How to log in to the corresponding service

To log in to Compose and run a specific service, use the following command:

docker-compose exec ***servicename*** bash

How to display the specified compose file

docker-compose -f docker-compose.yml -f docker-compose.admin.yml run backup_db

Difference between docker-compose up and docker-compose run

docker-compose up will start all services based on the compose file and expose the ports to the outside world
docker-compose run needs to specify a specific service to start. For example, docker-compose run web bash will only start the web service in the compolse file and its dependent services, and will not expose the port to the outside world to avoid conflicts with the service port started by docker-compose up.
docker-compose run is only used to temporarily start a service location problem

Some extended knowledge points

Environment variables

The content of docker-compose.yml itself can use variable placeholders, and its specific variable values ​​are defined in specific environment variables, so that the same docker-compose.yml file can have different execution behaviors in different environments. Typically, we want the tag version of the dependent service's image to vary from environment to environment.

Then we configure its tag with a placeholder in the corresponding service configuration of docker-compose.yml. The following uses ${TAG} to configure the image tag of the web service

web:
 image: "webapp:${TAG}"

In addition to the variables specified above, there are several Docker built-in variables that can be set. They are used to configure the execution behavior of Docker or Docker Compose. These built-in variables are

• COMPOSE_API_VERSION
• COMPOSE_CONVERT_WINDOWS_PATHS
• COMPOSE_FILE
• COMPOSE_HTTP_TIMEOUT
• COMPOSE_TLS_VERSION
• COMPOSE_PROJECT_NAME
• DOCKER_CERT_PATH
• DOCKER_HOST
• DOCKER_TLS_VERIFY

For specific meanings, see; https://docs.docker.com/compose/reference/envvars/

Taking the placeholder TAG as an example, there are several ways to explain the setting of variables:

Execute in docker-compose.yml

In the compolse file, specify it through environment configuration item

web:
 image: "webapp:${TAG}"
 environment:
 - TAG=dev

Set shell environment variables before executing docker-compose command

$ export TAG=v2.0
$ docker-compose up

Setting via env_file

By default, docker-compose up will look for the .env file in the command execution path to find the value of the variable replacement. The .env file is configured in the form of key=value. For example

TAG=dev

If the name of the environment variable is not .env or is not in the path of the current command execution, you can use --env-file parameter to explicitly load it.

docker-compose --env-file ./config/.env.dev up

Directly in the compose file, specify the env_file to load

version: '3'
services:
 API:
 image: 'node:6-alpine'
 env_file:
  - ./Docker/api/api.env
 environment:
  - NODE_ENV=production

The above variable value settings have priority from high to low

View the final effective environment variables

If you are not sure what the final effective environment variables are, you can use the following command to view

docker-compose run web env

Project name setting

A group of services corresponding to a compose has a common project name, which will be reflected in the container name prefix and network prefix of the compose service.
The project name can be specified by the environment variable COMPOSE_PROJECT_NAME . If not specified, the default project name is the name of the folder where the compose file is located.

network

Default Network

By default, multiple services in compose will join a network called default. These services are interconnected in the default network. The full name of the default network is prefixed with the name of the folder where the compose file is located. For example, the folder is hello_world's compose. The network name corresponding to one set of services is: hello_world_default. This group of services communicate in this network using the second group of ports in the compose file.

version: "3"
services:
 web:
 build: .
 ports:
  - "8000:8000"
 db:
 image: postgres
 ports:
  - "8001:5432"

For example, in the above configuration, in the hello_world_default network, the web service uses port 8000 to communicate with the db service on port 5432. The first group of ports 8000 and 8001 are the ports used by the host to access web and db services.

Independent configuration of the default network

If you want to change the default network configuration, you can change it separately through the networks item in the compose file, such as changing the default network driver as follows

networks:
 default:
 # Use a custom driver
 driver: custom-driver-1

Configuring and using non-default networks

Define multiple networks and use

version: "3"
services:

 proxy:
 build: ./proxy
 networks:
  -frontend
 app:
 build: ./app
 networks:
  -frontend
  - backend
 db:
 image: postgres
 networks:
  - backend

networks:
 frontend:
 # Use a custom driver
 driver: custom-driver-1
 backend:
 # Use a custom driver which takes special options
 driver: custom-driver-2
 driver_opts:
  foo: "1"
  bar: "2"

The above configuration defines two networks, frontend and backend. The app can access both networks, the proxy service can only access the frontend network, and the db can only access the backend network.

Execution order of multiple services

Multiple services in a compose may have dependencies. For example, the web service depends on the db service. We hope to start the db service first and then the web service. This startup order can also be specified in the compose file using depends_on

version: "2"
services:
 web:
 build: .
 ports:
  - "80:8000"
 depends_on:
  - "db"
 command: ["./wait-for-it.sh", "db:5432", "--", "python", "app.py"]
 db:
 image: postgres

Installation of Docker Compose

Both the Mac and Windows versions of Docker come with Docker Compose by default. Only the Linux version needs to be installed separately

Similarities and differences between docker compose and docker stack

• The main goal of docker compose is to start and manage multiple services on the same machine
• Docker stack is mainly used to start and manage multiple services on multiple machines.
• Both docker compose and docker stack can use docker-compose.yml files. Both parties will automatically ignore configurations that are not effective for them.
• Docker Compose services can be dynamically built using build, while Docker Stack services can only be built based on images.

References

https://docs.docker.com/compose/gettingstarted/
https://docs.docker.com/compose/
https://stackoverflow.com/questions/43099408/whats-the-difference-between-a-stack-file-and-a-compose-file
https://nickjanetakis.com/blog/docker-tip-23-docker-compose-vs-docker-stack
https://vsupalov.com/difference-docker-compose-and-docker-stack/
https://stackoverflow.com/questions/33066528/should-i-use-docker-compose-up-or-run

This is the end of this article about the usage of docker compose. For more relevant content on the usage of docker compose, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope you will support 123WORDPRESS.COM in the future!