Docker Compose

Introduction à Compose

Compose est un outil pour définir et exécuter des applications Docker multi-conteneurs. Avec Compose, vous pouvez utiliser un fichier YML pour configurer tous les services dont votre application a besoin. Ensuite, avec une seule commande, vous pouvez créer et démarrer tous les services à partir de la configuration du fichier YML.

Si vous ne comprenez pas encore la configuration d'un fichier YML, vous pouvez d'abord lireTutoriel de démarrage YAML。

Les trois étapes utilisées par Compose :

  • Utilisez un Dockerfile pour définir l'environnement de l'application.

  • Utilisez docker-compose.yml pour définir les services qui composent votre application afin qu'ils puissent s'exécuter ensemble dans un environnement isolé.

  • Enfin, exécutez la commande docker-compose up pour démarrer et exécuter l'ensemble de l'application.

Un exemple de configuration docker-compose.yml est le suivant (les paramètres de configuration sont indiqués ci-dessous) :

Exemple

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

Installation de Compose

Sous Linux, nous pouvons télécharger son paquet binaire depuis Github pour l'utiliser. Adresse de la dernière version :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/v2.2.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Pour installer une autre version de Compose, remplacez v2.2.2.

Docker Compose est hébergé sur GitHub et n'est pas très stable.

Vous pouvez également installer Docker Compose rapidement en exécutant la commande suivante.

curl -L https://get.daocloud.io/docker/compose/releases/download/v2.4.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

Appliquez les permissions d'exécution au fichier binaire :

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

Créez un lien symbolique :

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

Testez si l'installation a réussi :

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

RemarquePour alpine, les paquets de dépendances suivants sont requis : py-pip, python-dev, libffi-dev, openssl-dev, gcc, libc-dev, et make.

macOS

Docker Desktop pour Mac et Docker Toolbox incluent déjà Compose et d'autres applications Docker, donc les utilisateurs de Mac n'ont pas besoin d'installer Compose séparément. Les instructions d'installation de Docker sont disponibles àInstallation de Docker sur MacOS。

PC Windows

Docker Desktop for Windows et Docker Toolbox incluent déjà 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 se trouvent àInstallation de Docker sous Windows。

Utilisation

1. Préparation

Créez un répertoire de test.

$ mkdir composetest
$ cd composetest

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

Code du fichier composetest/app.py

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)

Dans cet exemple, redis est le nom d'hôte du conteneur redis sur le réseau de l'application, et le port utilisé par cet hôte est 6379.

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

flask
redis

2. Créez un Dockerfile

Dans le répertoire composetest, créez un fichier nomméDockerfileavec 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: Construire l'image à partir de l'image Python 3.7.
  • WORKDIR /code: Définir le répertoire de travail sur /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, afin 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 (.) vers le répertoire de travail dans l'image (.).
  • CMD ["flask", "run"]: La commande d'exécution par défaut du conteneur est : flask run.

3. Créez docker-compose.yml

Dans le répertoire test, créez un fichier nommé docker-compose.yml, et collez le contenu suivant :

Fichier de configuration docker-compose.yml

# configuration yaml
version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
  redis:
    image: "redis:alpine"

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

  • web: Le service web utilise une image construite à partir du Dockerfile dans le répertoire courant. Il lie ensuite le conteneur et l'hôte au port exposé 5000. Ce service d'exemple utilise le port par défaut 5000 du serveur web Flask.
  • redis: Le service redis utilise l'image Redis publique de Docker Hub.

4. Utilisez les commandes Compose pour construire et exécuter votre application

Dans le répertoire test, exécutez la commande suivante pour lancer l'application :

docker-compose up

Si vous souhaitez exécuter le service en arrière-plan, vous pouvez ajouter-dParamètres :

docker-compose up -d

Référence des directives de configuration yml

version

Spécifiez la version de Compose à laquelle ce yml est conforme.

build

Spécifiez comme chemin de contexte de l'image de construction :

Par exemple, pour le service webapp, spécifiez l'image construite à partir du chemin de contexte ./dir/Dockerfile :

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

Ou, sous forme d'objet avec le chemin spécifié dans le contexte, et, en option, Dockerfile et args :

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 du contexte.
  • dockerfile : spécifie le nom de fichier Dockerfile utilisé pour construire l'image.
  • args : Ajoutez des arguments de construction, qui sont des variables d'environnement accessibles uniquement pendant le processus de construction.
  • labels: Définir les labels de l’image construite.
  • target: Construction multi-étapes, vous pouvez spécifier l’étape à construire.

cap_add，cap_drop

Ajouter ou supprimer les capacités du noyau hôte disponibles pour le conteneur.

cap_add:
  - ALL # 开启全部权限

cap_drop:
  - SYS_PTRACE # 关闭 ptrace权限

cgroup_parent

Spécifier le groupe cgroup parent du conteneur, ce qui signifie qu’il héritera des limites de ressources de ce groupe.

cgroup_parent: m-executor-abcd

command

Remplacer la commande par défaut pour le démarrage du conteneur.

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

container_name

Spécifier un nom de conteneur personnalisé, plutôt que le nom par défaut généré.

container_name: my-web-container

depends_on

Définir les relations de dépendance.

  • docker-compose up : Démarrer les services dans l'ordre des dépendances. Dans l'exemple suivant, db et redis sont démarrés avant web.
  • docker-compose up SERVICE : inclut automatiquement les dépendances de SERVICE. Dans l'exemple suivant, docker-compose up web créera et démarrera aussi db et redis.
  • docker-compose stop : Arrêter les services dans l'ordre des dépendances. Dans l'exemple suivant, web est arrêté avant db et redis.
version: "3.7"
services:
  web:
    build: .
    depends_on:
      - db
      - redis
  redis:
    image: redis
  db:
    image: postgres

Remarque : Le service web n'attendra pas que redis db soit entièrement démarré avant de démarrer.

deploy

Spécifiez la configuration liée au déploiement et à l'exploitation du service. Utile uniquement en mode 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

Paramètres facultatifs.

endpoint_mode: Comment accéder aux services du cluster.

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

labels: Définir des labels sur le service. Vous pouvez utiliser les labels du conteneur (configurations au même niveau que deploy) pour remplacer les labels sous deploy.

mode: Spécifier le mode fourni par le service.

  • replicated: Répliquer le service ; répliquer le service spécifié sur les machines du cluster.

  • global: Service global ; le service sera déployé sur chaque nœud du cluster.

  • Schéma : Dans la figure ci-dessous, les blocs jaunes montrent le fonctionnement du mode replicated, et les blocs gris montrent le fonctionnement du mode global.

replicas：modeLorsqu'il est défini sur replicated, ce paramètre est requis pour configurer le nombre précis de nœuds en cours d'exécution.

resources: Configurez les limites d'utilisation des ressources pour le serveur. Par exemple, dans l'exemple ci-dessus, configurez le pourcentage de CPU et l'utilisation de mémoire nécessaires au fonctionnement du cluster redis, afin d'éviter les exceptions causées par une utilisation excessive des ressources.

restart_policy: Configurez la façon dont le conteneur doit être redémarré lorsqu'il s'arrête.

  • condition : valeurs facultatives none, on-failure ou any (par défaut : any).
  • delay : Définit le temps d'attente avant le redémarrage (par défaut : 0).
  • max_attempts : Nombre de tentatives de redémarrage du conteneur. Une fois dépassé, il ne réessaiera plus (par défaut : réessayer indéfiniment).
  • window : Définit le délai d'attente de redémarrage du conteneur (par défaut : 0).

rollback_config: Configurez la façon dont le service doit être restauré en cas d'échec de mise à jour.

  • parallelism : Le nombre de conteneurs à restaurer en une seule fois. Si défini sur 0, tous les conteneurs sont restaurés simultanément.
  • delay : Le temps d'attente entre chaque retour arrière de groupe de conteneurs (par défaut : 0s).
  • failure_action : que faire si le retour arrière échoue. Soit continue, soit pause (par défaut pause).
  • monitor : Durée pendant laquelle continuer à observer si la mise à jour de chaque conteneur a échoué (ns|us|ms|s|m|h) (par défaut : 0s).
  • max_failure_ratio : Taux d'échec pouvant être toléré lors du rollback (par défaut : 0).
  • order : l'ordre des opérations lors du rollback. Soit stop-first (rollback en série) soit start-first (rollback en parallèle) (par défaut stop-first).

update_config: Configurez la manière dont le service doit être mis à jour, ce qui est utile pour configurer les mises à jour progressives.

  • parallelism : Le nombre de conteneurs mis à jour en même temps.
  • delay : Le temps d'attente entre la mise à jour d'un groupe de conteneurs.
  • failure_action : Que faire si la mise à jour échoue. L'une des valeurs suivantes : continue, rollback ou pause (par défaut : pause).
  • monitor : Durée pendant laquelle continuer à observer si la mise à jour de chaque conteneur a échoué (ns|us|ms|s|m|h) (par défaut : 0s).
  • max_failure_ratio : Le taux d'échec pouvant être toléré pendant le processus de mise à jour.
  • order : l'ordre des opérations lors du rollback. Soit stop-first (rollback en série) soit start-first (rollback en parallèle) (par défaut stop-first).

Remarque: Pris en charge uniquement dans V3.4 et versions ultérieures.

périphériques

Spécifiez la liste de mappage des périphériques.

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

dns

Serveur DNS personnalisé, peut être une valeur unique ou une liste de plusieurs valeurs.

dns: 8.8.8.8

dns:
  - 8.8.8.8
  - 9.9.9.9

dns_search

Domaines de recherche DNS personnalisés. Peut être une seule valeur 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 d'un fichier. Peut être une seule valeur ou une liste de plusieurs valeurs.

env_file: .env

Il peut également être au format liste :

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

environment

Ajouter des variables d'environnement. Vous pouvez utiliser des tableaux ou des dictionnaires, ou n'importe quelles valeurs booléennes. Les valeurs booléennes doivent être entourées de guillemets pour garantir que l'analyseur YML ne les convertisse pas en True ou False.

environment:
  RACK_ENV: development
  SHOW: 'true'

expose

Exposer des ports, mais ne pas les mapper sur la machine hôte ; accessibles uniquement par les services connectés.

Seuls les ports internes peuvent être spécifiés comme paramètres :

expose:
 - "3000"
 - "8000"

extra_hosts

Ajoute des mappages de noms d'hôtes. Similaire à l'option --add-host du client Docker.

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

Ce qui précède créera une relation de mappage avec une adresse IP et un nom d'hôte dans le fichier /etc/hosts à l'intérieur du conteneur du service :

162.242.195.82  somehost
50.31.209.229   otherhost

healthcheck

Utilisé pour détecter si le service docker fonctionne correctement.

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost"] # 设置检测程序
  interval: 1m30s # 设置检测间隔
  timeout: 10s # 设置检测超时时间
  retries: 3 # 设置重试次数
  start_period: 40s # 启动后，多少秒开始启动检测程序

image

Spécifiez l'image que le conteneur exécute. Tous les formats suivants sont acceptables :

image: redis
image: ubuntu:14.04
image: tutum/influxdb
image: example-registry.com:4000/postgresql
image: a4bc65fd # 镜像id

logging

Configuration de journalisation pour le service.

driver : Spécifiez le pilote de journalisation pour le conteneur du service. La valeur par défaut est json-file. Il existe les trois options suivantes :

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

Ce n'est que sous le pilote json-file que les paramètres suivants peuvent être utilisés pour limiter le nombre et la taille des journaux.

logging:
  driver: json-file
  options:
    max-size: "200k" # 单个文件大小为200k
    max-file: "10" # 最多10个文件

Lorsque la limite de fichiers est atteinte, les anciens fichiers sont automatiquement supprimés.

Sous le pilote syslog, vous pouvez utiliser syslog-address pour spécifier l'adresse de réception des journaux.

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

network_mode

Définir le mode réseau.

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

networks

Configurer le réseau auquel le conteneur se connecte, en référençant les entrées sous les networks de niveau supérieur.

services:
  some-service:
    networks:
      some-network:
        aliases:
         - alias1
      other-network:
        aliases:
         - alias2
networks:
  some-network:
    # Use a custom driver
    driver: custom-driver-1
  other-network:
    # Use a custom driver which takes special options
    driver: custom-driver-2

aliases: Les autres conteneurs sur le même réseau peuvent utiliser le nom du service ou cet alias pour se connecter au service du conteneur correspondant.

restart

  • no: Il s'agit de la politique de redémarrage par défaut. Le conteneur ne sera redémarré en aucune circonstance.
  • always: Le conteneur est toujours redémarré.
  • on-failure: Le conteneur n'est redémarré que lorsqu'il se termine anormalement (statut de sortie non nul).
  • unless-stopped: Toujours redémarrer le conteneur lorsqu'il se termine, mais ne pas tenir compte des conteneurs qui étaient déjà arrêtés lorsque le démon Docker a démarré.
restart: "no"
restart: always
restart: on-failure
restart: unless-stopped

Remarque : En mode cluster swarm, veuillez plutôt utiliser restart_policy.

secrets

Stocker 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   # 设置容器的用户标签
  - label:role:ROLE   # 设置容器的角色标签
  - label:type:TYPE   # 设置容器的安全策略标签
  - label:level:LEVEL  # 设置容器的安全等级标签

stop_grace_period

Spécifier combien de temps attendre avant d'envoyer SIGKILL pour arrêter le conteneur s'il ne peut pas gérer SIGTERM (ou tout signal de stop_signal).

stop_grace_period: 1s # 等待 1 秒
stop_grace_period: 1m30s # 等待 1 分 30 秒

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

stop_signal

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

L'exemple suivant utilise SIGUSR1 pour remplacer SIGTERM afin d'arrêter le conteneur.

stop_signal: SIGUSR1

sysctls

Définir des paramètres du noyau dans le conteneur, peut utiliser un format tableau ou dictionnaire.

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

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

tmpfs

Monter un système de fichiers temporaire dans le conteneur. Peut être une valeur unique ou une liste de plusieurs valeurs.

tmpfs: /run

tmpfs:
  - /run
  - /tmp

ulimits

Remplacer la valeur ulimit par défaut du conteneur.

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

volumes

Monter les volumes de données ou les fichiers de l'hôte dans le conteneur.

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