Docker Compose

Introduction à Compose

Compose est un outil utilisé pour définir et exécuter des applications Docker multi-conteneurs. Grâce à Compose, vous pouvez utiliser un fichier YML pour configurer tous les services nécessaires à l'application. Ensuite, avec une seule commande, vous pouvez créer et démarrer tous les services à partir de la configuration YML.

Les trois étapes utilisées par Compose :

• Définissez l'environnement de l'application à l'aide de Dockerfile.

• Utilisez docker-compose.yml définit les services composant l'application, de sorte qu'ils puissent s'exécuter ensemble dans un environnement isolé.

• Enfin, exécutez docker-Pour démarrer et exécuter l'application entière, utilisez la commande compose up.

docker-Voici un exemple de configuration de compose.yml (les paramètres de configuration sont détaillés ci-dessous) :

#　yaml　configuration exemple
version:　'3'
services:
　　web:
　　　　build: .
　　　　ports:
　　　　-　"5000:5000"
　　　　volumes:
　　　　-　.:/code
　　　　-　logvolume01:/var/log
　　　　liens:
　　　　-　redis
　　redis:
　　　　image: redis
volumes:
　　logvolume01:　{}

Installer Compose

Linux

Sur Linux, nous pouvons télécharger son paquet binaire à partir de Github pour l'utiliser, l'adresse de la dernière version publiée :https://github.com/docker/compose/releases.

Exécutez la commande suivante pour télécharger la version stable actuelle de Docker Compose :

$ sudo curl　-L "https://github.com/docker/compose/releases/download/1.24.1/docker-compose-$(uname　-s)-$(uname　-m)"　-o　/usr/local/bin/docker-compose

Pour installer une autre version de Compose, remplacez 1.24.1.

Appliquer les permissions exécutables aux fichiers binaires :

$ sudo chmod　+x　/usr/local/bin/docker-compose

Créer un lien symbolique :

$ sudo ln　-s　/usr/local/bin/docker-compose　/usr/bin/docker-compose

Vérifiez si l'installation a réussi :

$ docker-compose　--version
cker-version compose　1.24.1, build　4667896b

Attention：Pour alpine, les paquets dépendants suivants sont nécessaires : py-pip, python-dev, libffi-dev, openssl-dev, gcc, libc-dev, et make.

macOS

La version Desktop de Docker pour Mac et Docker Toolbox incluent Compose et d'autres applications Docker, donc les utilisateurs Mac n'ont pas besoin d'installer Compose séparément. Les instructions d'installation de Docker peuvent être consultées MacOS Docker Installation.

windows PC

La version Desktop de Docker pour Windows et Docker Toolbox incluent Compose et d'autres applications Docker, donc les utilisateurs Windows n'ont pas besoin d'installer Compose séparément. Les instructions d'installation de Docker peuvent être consultées Windows Docker Installation.

使用

1、准备

Créer un répertoire de test :

$ mkdir composetest
$ cd composetest

Dans le répertoire de test, créez un fichier nommé app.py et copiez-collez le contenu suivant :

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! J'ai été vu {} fois.\n'.format(count)

Dans cet exemple, redis est le nom d'hôte du conteneur redis sur le réseau d'application, utilisant le port 6379.

Dans le répertoire composetest, créez un autre fichier nommé requirements.txt, avec le contenu suivant :

flask
redis

2Créez un fichier Dockerfile

Dans le répertoire composetest, créez un fichier nommé Dockerfile, avec le contenu suivant :

FROM python:3.7-alpine
WORKDIR　/code
ENV FLASK_APP app.py
ENV FLASK_RUN_HOST 0.0.0.0
RUN apk add　--no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install　-r requirements.txt
COPY . .
CMD ["flask", "run"]

Explication du contenu du Dockerfile :

• FROM python:3.7-alpine: À partir de Python 3.7 : Commencez à construire l'image à partir de l'image Python.

• WORKDIR /code: Définissez le répertoire de travail : /code.

• ENV FLASK_APP app.py
  ENV FLASK_RUN_HOST 0.0.0.0

  Définissez les variables d'environnement utilisées par la commande flask.

• RUN apk add --no-cache gcc musl-dev linux-headers: Installez gcc pour que les paquets Python tels que MarkupSafe et SQLAlchemy puissent être compilés et accélérés.

• COPY requirements.txt requirements.txt
  RUN pip install　-r requirements.txt

  Copiez requirements.txt et installez les dépendances Python.

• COPY . .: Copiez le répertoire courant du projet . dans le répertoire de travail de l'image .

• CMD ["flask", "run"]: Le conteneur fournit la commande d'exécution par défaut : flask run.

3Créez docker-compose.yml

Créez un répertoire nommé docker dans le répertoire de test :-Le fichier compose.yml, puis collez le contenu suivant :

Ce fichier Compose définit deux services : web et redis.

• web： Ce service web utilise l'image construite à partir du répertoire actuel du Dockerfile. Ensuite, il lie le conteneur et l'hôte aux ports exposés 5000。Ce service d'exemple utilise le port par défaut du serveur web Flask 5000 。

• redis： Ce service redis utilise l'image publique Redis de Docker Hub.

4、 Utilisez la commande Compose pour construire et exécuter votre application

Dans le répertoire de test, exécutez les commandes suivantes pour démarrer l'application :

docker-compose up

Si vous souhaitez exécuter ce service en arrière-plan, vous pouvez l'ajouter -d paramètre :

docker-compose up　-d

Référence des instructions de configuration de yml

version

Spécifier la version de compose que cette yml est conforme.

build

Spécifier le chemin d'accès de contexte pour la construction de l'image :

Par exemple, le service webapp, spécifié comme étant à partir du chemin d'accès de contexte ./dir/L'image construite par Dockerfile :

version:　"3.7"
services:
　　webapp:
　　　　build: ./dir

ou, en tant qu'objet avec le chemin d'accès spécifié dans le contexte, ainsi que Dockerfile et args optionnels :

version:　"3.7"
services:
　　webapp:
　　　　build:
　　　　　　context: ./dir
　　　　　　dockerfile: Dockerfile-alternate
　　　　　　args:
　　　　　　　　buildno:　1
　　　　　　labels:
　　　　　　　　-　"com.example.description=Accounting webapp"
　　　　　　　　-　"com.example.department=Finance"
　　　　　　　　-　"com.example.label-with-empty-value"
　　　　　　target: prod

• context : Chemin d'contexte.

• dockerfile : Spécifier le nom de fichier Dockerfile pour l'image de construction.

• args : Ajouter des paramètres de construction, c'est un environnement variable accessible uniquement pendant le processus de construction.

• labels : Définir les étiquettes de l'image de construction.

• target : Construction en plusieurs couches, il est possible de spécifier quelle couche construire.

cap_add, cap_drop

Ajouter ou supprimer les fonctionnalités du noyau de l'hôte que le conteneur possède.

cap_add:
　　-　ALL # Activer toutes les permissions
cap_drop:
　　-　SYS_PTRACE # Désactiver les permissions ptrace

cgroup_parent

Définir le groupe cgroup parent pour le conteneur signifie qu'il héritera des limitations de ressources de ce groupe.

cgroup_parent: m-executor-abcd

command

覆盖容器启动的默认命令。

command: ["bundle", "exec", "thin", "-p", "3000"]

container_name

指定自定义容器名称，而不是生成的默认名称。

container_name: my-web-container

depends_on

设置依赖关系。

• docker-compose up ：以依赖性顺序启动服务。在以下示例中，先启动 db 和 redis ，才会启动 web。

• docker-compose up SERVICE ：自动包含 SERVICE 的依赖项。在以下示例中，docker-compose up web 还将创建并启动 db 和 redis。

• docker-compose stop ：按依赖关系顺序停止服务。在以下示例中，web 在 db 和 redis 之前停止。

version:　"3.7"
services:
　　web:
　　　　build: .
　　　　depends_on:
　　　　　　-　db
　　　　　　-　redis
　　redis:
　　　　image: redis
　　db:
　　　　image: postgres

注意：web 服务不会等待 redis db 完全启动 之后才启动。

deploy

指定与服务的部署和运行有关的配置。只在 swarm 模式下才会有用。

version:　"3.7"
services:
　　redis:
　　　　image: redis:alpine
　　　　deploy:
　　　　　　mode：replicated
　　　　　　replicas:　6
　　　　　　endpoint_mode: dnsrr
　　　　　　labels:　
　　　　　　　　description: "This redis service label"
　　　　　　resources:
　　　　　　　　limits:
　　　　　　　　　　cpus: '0.50'
　　　　　　　　　　memory:　50M
　　　　　　　　reservations:
　　　　　　　　　　cpus: '0.25'
　　　　　　　　　　memory:　20M
　　　　　　restart_policy:
　　　　　　　　condition: on-failure
　　　　　　　　delay:　5s
　　　　　　　　max_attempts:　3
　　　　　　　　window:　120s

可以选参数：

endpoint_mode：访问集群服务的方式。

endpoint_mode: vip　
# Docker 集群服务一个对外的虚拟 ip。所有的请求都会通过这个虚拟 ip 到达集群服务内部的机器。
endpoint_mode: dnsrr
# DNS 轮询 (DNSRR)。所有的请求会自动轮询获取到集群 ip 列表中的一个 ip 地址。

labelsSet labels on the service. You can override the labels under deploy with labels on the container (labels at the same level as deploy configuration).

modeThe mode provided by the specified service.

• replicatedReplicated service, replicate the specified service to the machines in the cluster.

• globalGlobal service, the service will be deployed to each node of the cluster.

• Illustration: In the figure below, the yellow blocks represent the running status of the replicated mode, and the gray blocks represent the running status of the global mode.

replicas: mode For replicated, this parameter needs to be used to configure the specific number of nodes to run.

resourcesHow to configure the limit of server resource usage, for example, in the above instance, configure the percentage of cpu and memory usage required for the redis cluster to run. Avoid using too much resource to cause exceptions.

restart_policyHow to configure the restart of the container when exiting the container.

• condition: Optional none, on-failure or any (default value: any).

• delay: Set how long after to restart (default value: 0).

• max_attempts: The number of times to try to restart the container. If the number exceeds, it will no longer try (default value: keep retrying).

• window: Set the container restart timeout time (default value: 0).

rollback_configHow to configure the rollback of the service in case of update failure.

• parallelism: The number of containers to roll back at one time. If set to 0, all containers will rollback simultaneously.

• delay: The time to wait between rolling back each container group (default is 0s).

• failure_action: What to do if the rollback fails. One of continue or pause (default pause).

• monitor: The time (ns|us|ms|s|m|h) to continuously observe whether the container has failed after each update (default is 0s).

• max_failure_ratio: The allowable failure rate during rollback (default is 0).

• order：l'ordre des opérations pendant le rollback. L'une d'elles est stop-first（rollback séquentiel），ou start-first (parallel rollback) (default stop-first ).

update_configHow to configure the update of the service, which is very useful for rolling updates.

• parallelism: The number of containers to update at one time.

• delay: The time to wait between updating a group of containers.

• failure_action: What to do if the update fails. One of continue, rollback, or pause (default: pause).

• monitor: The time (ns|us|ms|s|m|h) to continuously observe whether the container has failed after each update (default is 0s).

• max_failure_ratio：le taux de défaillance toléré pendant la mise à jour.

• order：l'ordre des opérations pendant le rollback. L'une d'elles est stop-first（rollback séquentiel），ou start-first（rollback en parallèle）（par défaut stop-first）.

Remarque：Ne prend en charge que V3.4 et versions supérieures.

devices

Spécifier la liste des mappages de périphériques.

devices:
　　-　"/dev/ttyUSB0:/dev/ttyUSB0"

dns

Personnaliser le serveur DNS, cela peut être une valeur unique ou plusieurs valeurs de liste.

dns:　8.8.8.8
dns:
　　-　8.8.8.8
　　-　9.9.9.9

dns_search

Personnaliser le domaine de recherche DNS. Cela peut être une valeur unique ou une liste.

dns_search: example.com
dns_search:
　　-　dc1.example.com
　　-　dc2.example.com

entrypoint

Remplacer l'entrypoint par défaut du conteneur.

entrypoint:　/code/entrypoint.sh

Il peut également être au format suivant :

entrypoint:
　　　　-　php
　　　　-　-d
　　　　-　zend_extension=/usr/local/lib/php/extensions/no-debug-non-zts-20100525/xdebug.so
　　　　-　-d
　　　　-　memory_limit=-1
　　　　-　vendor/bin/phpunit

env_file

Ajouter des variables d'environnement à partir de fichiers. Cela peut être une valeur unique ou plusieurs valeurs de liste.

env_file: .env

Il peut également être au format liste :

env_file:
　　-　./common.env
　　-　./apps/web.env
　　-　/opt/secrets.env

environnement

Ajouter des variables d'environnement. Vous pouvez utiliser un tableau ou un dictionnaire, n'importe quel booléen, le booléen doit être entre guillemets pour s'assurer que l'analyseur YAML ne le convertit pas en True ou False.

environment:
　　RACK_ENV: 'development'
　　SHOW: 'true'

expose

Exposer les ports, mais ne pas les mapper sur l'hôte hôte, uniquement accessible par les services connectés.

Seulement les ports internes peuvent être spécifiés en tant que paramètres :

expose:
　-　"3000"
　-　"8000"

extra_hosts

Ajouter une correspondance de nom d'hôte. Similaire au client docker --ajouter-hôte.

extra_hosts:
　-　"somehost:162.242.195.82"
　-　"otherhost:50.31.209.229"

ceci se trouvera dans le conteneur interne de ce service : /etc/hosts crée une correspondance entre l'adresse IP et le nom d'hôte :

162.242.195.82　　somehost
50.31.209.229　　　otherhost

healthcheck

Used to check if the docker service is running healthily.

healthcheck:
　　test: ["CMD", "curl", "-f", "http://localhost"] # Set the detection program
　　interval:　1minutes30s # Set the detection interval
　　timeout:　10s # Set the detection timeout time
　　retries:　3　# Set the number of retries
　　start_period:　40s # How many seconds after startup to start the detection program

image

Specify the image that the container runs. The following formats are all acceptable:

image: redis
image: ubuntu:14.04
image: tutum/influxdb
image: example-registry.com:4000/postgresql
image: a4bc65fd # Image ID

logging

Service logging configuration.

driver: Specify the logging driver for the service container, the default value is json-file. There are three options

driver: "json"-file"
driver: "syslog"
driver: "none"

Only in json-Under the file driver, you can use the following parameters to limit the number and size of logs.

logging:
　　driver: "json"-file
　　options:
　　　　max-size: "200k"# The size of a single file is200k
　　　　max-file: "10"# Maximum10files

When the file limit is reached, old files will be automatically deleted.

Under the syslog driver, you can use syslog-The address specifies the receiving address of the log.

logging:
　　driver: "syslog"
　　options:
　　　　syslog-address: "tcp://192.168.0.42:123"

network_mode

Set the network mode.

network_mode: "bridge"
network_mode: "host"
network_mode: "none"
network_mode: "service:[service name]"
network_mode: "container:[container name/id]"

networks

Configure the network connection of the container, referencing the entries under the top-level networks.

services:
　　some-service:
　　　　networks:
　　　　　　some-network:
　　　　　　　　aliases:
　　　　　　　　　-　alias1
　　　　　　other-network:
　　　　　　　　aliases:
　　　　　　　　　-　alias2
networks:
　　some-network:
　　　　# Utiliser un pilote personnalisé
　　　　driver: custom-driver-1
　　other-network:
　　　　# Utiliser un pilote personnalisé qui prend des options spéciales
　　　　driver: custom-driver-2

aliases : Les autres conteneurs sur le même réseau peuvent se connecter au service correspondant à l'aide du nom de service ou de cet alias.

restart

• no : C'est la stratégie de redémarrage par défaut, le conteneur ne sera pas redémarré dans toutes les situations.

• always : Le conteneur est toujours redémarré.

• on-failure : Redémarre le conteneur uniquement si le conteneur quitte anormalement (état de sortie non 0).

• unless-stopped : Redémarre toujours le conteneur à la sortie du conteneur, mais ne tient pas compte des conteneurs déjà arrêtés au démarrage du service Docker.

restart: "no"
restart: always
restart: on-failure
restart: unless-stopped

Remarque : dans le mode de cluster swarm, utilisez restart_policy.

secrets

Stocke des données sensibles, telles que les mots de passe :

version:　"3.1"
services:
mysql:
　　image: mysql
　　environment:
　　　　MYSQL_ROOT_PASSWORD_FILE:　/run/secrets/my_secret
　　secrets:
　　　　-　my_secret
secrets:
　　my_secret:
　　　　file: ./my_secret.txt

security_opt

Modifier l'étiquette de schéma par défaut du conteneur.

security-opt:
　　-　label:user:USER # Définir l'étiquette d'utilisateur du conteneur
　　-　label:role:ROLE # Définir l'étiquette de rôle du conteneur
　　-　label:type:TYPE # Définir l'étiquette de stratégie de sécurité du conteneur
　　-　label:level:LEVEL # Définir l'étiquette de niveau de sécurité du conteneur

stop_grace_period

Spécifier combien de temps attendre avant d'envoyer le signal SIGKILL pour fermer le conteneur si le conteneur ne peut pas traiter SIGTERM (ou tout autre signal stop_signal).

stop_grace_period:　1s # Attente　1　secondes
stop_grace_period:　1minutes30s # Attente　1　minutes　30 secondes

Le temps d'attente par défaut est 10 secondes.

stop_signal

Définir le signal de remplacement pour arrêter le conteneur. Par défaut, SIGTERM est utilisé.

Dans l'exemple suivant, utiliser SIGUSR1 Remplacer le signal SIGTERM pour arrêter le conteneur.

stop_signal:　SIGUSR1

sysctls

Set kernel parameters in the container, which can be in array or dictionary format.

sysctls:
　　net.core.somaxconn:　1024
　　net.ipv4.tcp_syncookies:　0
sysctls:
　　-　net.core.somaxconn=1024
　　-　net.ipv4.tcp_syncookies=0

tmpfs

Install a temporary filesystem inside the container. It can be a single value or a list of multiple values.

tmpfs:　/run
tmpfs:
　　-　/run
　　-　/tmp

ulimits

Override the default ulimit of the container.

ulimits:
　　nproc:　65535
　　nofile:
　　　　soft:　20000
　　　　hard:　40000

volumes

Mount the host's data volume or file to the container.

version:　"3.7"
services:
　　db:
　　　　image:　postgres:latest
　　　　volumes:
　　　　　　-　"/localhost/postgres.sock:/var/run/postgres/postgres.sock"
　　　　　　-　"/localhost/data:/var/lib/postgresql/data"