English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Docker Compose

Introduzione a Compose

Compose è uno strumento utilizzato per definire ed eseguire applicazioni Docker multi-container. Attraverso Compose, puoi utilizzare file YML per configurare tutti i servizi necessari per l'applicazione. Poi, con un comando, puoi creare e avviare tutti i servizi dalla configurazione YML.

Le tre fasi utilizzate da Compose:

  • Definisci l'ambiente dell'applicazione utilizzando Dockerfile.

  • Definisci i servizi che compongono l'applicazione utilizzando docker-compose.yml in modo che possano eseguire insieme in un ambiente isolato.

  • Infine, esegui il comando docker-compose up per avviare e eseguire l'applicazione completa.

Esegui la configurazione del caso docker-compose.yml come segue (parametri di configurazione di riferimento nel testo seguente):

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

Installazione di Compose

Linux

Sul Linux possiamo scaricare il pacchetto binario dal Github per utilizzarlo, l'indirizzo dell'ultima versione distribuita è:https://github.com/docker/compose/releases

Eseguire i seguenti comandi per scaricare la versione stabile attuale di 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

Per installare altre versioni di Compose, sostituire 1.24.1.

Applicare i permessi eseguibili al file binario:

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

Creare un link simbolico:

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

Testare se l'installazione è riuscita:

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

Attenzione:Per alpine, sono necessari i seguenti pacchetti dipendenza: py-pip, python-dev, libffi-dev, openssl-dev, gcc, libc-dev e make.

macOS

La versione desktop di Docker per Mac e Docker Toolbox includono Compose e altre applicazioni Docker, quindi gli utenti Mac non devono installare Compose separatamente. Le istruzioni di installazione di Docker possono essere consultate Installazione Docker su MacOS

PC Windows

La versione desktop di Docker per Windows e Docker Toolbox includono Compose e altre applicazioni Docker, quindi gli utenti Windows non devono installare Compose separatamente. Le istruzioni di installazione di Docker possono essere consultate Installazione Docker su Windows

Utilizzo

1. Preparazione

Crea una directory di test:

$ mkdir composetest
$ cd composetest

Crea un file chiamato app.py nella directory di test e incolla il seguente contenuto:

Codice del file 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! Ho visto {} volte.\n'.format(count)

In questo esempio, redis è il nome dell'host del container redis sulla rete dell'applicazione, che utilizza il porto 6379.

Nella directory composetest, crea un altro file chiamato requirements.txt con il seguente contenuto:

flask
redis

2. Crea il file Dockerfile

Nella directory composetest, crea un file chiamato Dockerfile con il seguente contenuto:

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"]

Spiegazione del contenuto del Dockerfile:

  • FROM python:3.7-alpine: Costruisci l'immagine partendo dall'immagine Python 3.7.

  • WORKDIR /code: Imposta la directory di lavoro su /code.

  • ENV FLASK_APP app.py
    ENV FLASK_RUN_HOST 0.0.0.0

    Imposta l'ambiente variabile utilizzato dal comando flask.

  • RUN apk add --no-cache gcc musl-dev linux-headers: Installa gcc per accelerare la compilazione di pacchetti Python come MarkupSafe e SQLAlchemy.

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

    Copia requirements.txt e installa le dipendenze Python.

  • COPY . .: Copia il directory corrente del progetto . nel directory di lavoro dell'immagine .

  • CMD ["flask", "run"]: Il container fornisce il comando di esecuzione predefinito: flask run.

3、Creare docker-compose.yml

Nel directory di test, creare un file chiamato docker-compose.yml e incollare il seguente contenuto:

file di configurazione docker-compose.yml

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

Il file Compose definisce due servizi: web e redis.

  • web:Il servizio web utilizza l'immagine costruita dal Dockerfile nel percorso corrente. Poi, binda il container e l'host all'porta esposta 5000. Questo esempio di servizio utilizza il portale web Flask per il portale predefinito 5000 .

  • redis:Il servizio redis utilizza l'immagine pubblica Redis di Docker Hub.

4、Utilizzare il comando Compose per costruire e eseguire la tua applicazione

Nel directory di test, eseguire i seguenti comandi per avviare l'applicazione:

docker-compose up

Se si desidera eseguire il servizio in background, è possibile aggiungere il parametro -d:

docker-compose up -d

yml configurazione delle istruzioni di riferimento

version

Specificare quale versione di compose è stabilita da questa yml.

build

Specificare il percorso di contesto per costruire l'immagine:

Ad esempio, il servizio webapp, specificato come immagine costruita dal percorso ./dir/Dockerfile del contesto:

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

Ora, come oggetto con il percorso specificato nel contesto, e opzionale Dockerfile e args:

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

  • context:Percorso contestuale.

  • dockerfile:Specificare il nome del file Dockerfile per l'immagine di costruzione.

  • args:Aggiungere parametri di costruzione, che sono variabili d'ambiente accessibili solo durante il processo di costruzione.

  • labels:Impostare i tag dell'immagine di costruzione.

target:Costruzione multilivello, è possibile specificare quale livello costruire.

cap_add,cap_drop

cap_add: Aggiungere o rimuovere le funzionalità del kernel del host possedute dal container.
  - ALL # Aprire tutti i permessi
cap_drop:
  - SYS_PTRACE # Chiudere ptrace permessi

cgroup_parent

Specificare il gruppo cgroup padre per il container, il che significa che erediterà le limitazioni delle risorse di questo gruppo.

cgroup_parent: m-executor-abcd

command

Sovrascrivere il comando predefinito di avvio del container.

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

container_name

Specificare un nome di container personalizzato invece del nome predefinito generato.

container_name: my-web-container

depends_on

Impostare le dipendenze.

  • docker-compose up :Avvia i servizi in ordine di dipendenza. Nell'esempio seguente, db e redis vengono avviati prima di web.

  • docker-compose up SERVICE :Include automaticamente le dipendenze di SERVICE. Nell'esempio seguente, docker-compose up web creerà e avvierà anche db e redis.

  • docker-compose stop :Secondo l'ordine delle dipendenze fermare i servizi. Nell'esempio seguente, web viene fermato prima di db e redis.

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

Attenzione: il servizio web non aspetta che il redis db sia completamente avviato prima di avviarsi.

deploy

Specificare le configurazioni relative al部署eall'esecuzione del servizio. Ha senso solo in modalità 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

Parametri selezionabili:

endpoint_mode:modalità di accesso al servizio del cluster.

endpoint_mode: vip 
#UnVirtualIPperDockerClusterServiceunvirtualechericeveràtuttelerichiesteattraversoquestoIPvirtualeearriveràallemacchineinterne del servizio del cluster.
endpoint_mode: dnsrr
#DNSPolling(DNSRR)。Tutte le richieste verranno automaticamente rotolate per ottenere un indirizzo IP dalla lista IP del cluster.

labels:impostare etichette sul servizio. Può essere sovrascritto le etichette di container (configurazione a livello di deploy) per coprire le etichette di deploy.

mode:indicare il modello fornito dal servizio.

  • replicated:servizio replicato, copiare il servizio specificato sui computer del cluster.

  • global:servizio globale, il servizio verrà distribuito su ogni nodo del cluster.

  • Illustrazione: nei diagrammi sottostanti, i quadrati gialli rappresentano la situazione di esecuzione del modello replicated, mentre i quadrati grigi rappresentano la situazione di esecuzione del modello globale.

replicas:mode Per replicated, è necessario utilizzare questo parametro per configurare il numero di nodi specifici da eseguire.

resources:configurare i limiti di utilizzo delle risorse del server, ad esempio, come nell'esempio precedente, configurare la percentuale di cpu e l'uso della memoria necessari per l'esecuzione del cluster redis. Evitare di utilizzare troppi risorse per evitare problemi anomali.

restart_policy:configurare come riavviare il container al termine del suo utilizzo.

  • condition: opzionale none, on-failure o any (valore predefinito: any).

  • delay: impostare quanto tempo dopo il riavvio (valore predefinito: 0).

  • max_attempts:The number of times to try to restart the container. If the number of attempts exceeds, do not try again (default value: keep retrying).

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

rollback_config:Configure how the service should be rolled back in case of update failure.

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

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

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

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

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

  • order:The operation order during rollback. One of stop-first (serial rollback) or start-first (parallel rollback) (default stop-first ).

update_config:Configure how the service should be updated, which is very useful for configuration rolling updates.

  • parallelism:The number of containers updated at one time.

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

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

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

  • max_failure_ratio:The allowable failure rate during the update process.

  • order:The operation order during rollback. One of stop-first (serial rollback) or start-first (parallel rollback) (default stop-first).

Note:Only supports version 3.4 and above.

devices

Specify the device mapping list.

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

dns

Customize the DNS server, which can be a single value or multiple values in a list.

dns: 8.8.8.8
dns:
  - 8.8.8.8
  - 9.9.9.9

dns_search

Customize the DNS search domain. It can be a single value or a list.

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

entrypoint

Cover the default entrypoint of the container.

entrypoint: /code/entrypoint.sh

Può essere anche nel seguente formato:

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

Aggiungere variabili d'ambiente da file. Può essere un singolo valore o più valori in una lista.

env_file: .env

Può essere anche in formato elenco:

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

environment

Aggiungere variabili d'ambiente. Puoi usare un array o un dizionario, qualsiasi valore booleano, il valore booleano deve essere racchiuso tra virgolette per assicurare che il parser YAML non lo converta in True o False.

environment:
  RACK_ENV: development
  SHOW: 'true'

 

expose

Esporre la porta, ma non mappare l'host di sistema, solo il servizio connesso può accedervi.

Puoi specificare solo il numero di porta interno come parametro:

expose:
 - "3000"
 - "8000"

extra_hosts

Aggiungere mapping di nomi host. Simile a docker client --add-host.

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

Verrà creato un mapping di indirizzo IP e nome host all'interno del container di questo servizio /etc/hosts:

162.242.195.82 somehost
50.31.209.229 otherhost

healthcheck

Usato per controllare se il servizio docker è in esecuzione in modo sano.

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost"] # Impostare il programma di controllo
  interval: 1m30s # Impostare l'intervallo di controllo
  timeout: 10s # Impostare il tempo di scadenza del controllo
  retries: 3 # Impostare il numero di tentativi di ripristino
  start_period: 40s # Dopo l'avvio, dopo quanti secondi avviare il programma di controllo

image

Specificare l'immagine di esecuzione del container. Il formato può essere il seguente:

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

logging

服务的日志记录配置。

driver:指定服务容器的日志记录驱动程序,默认值为json-file。有以下三个选项

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

仅在 json-file 驱动程序下,可以使用以下参数,限制日志的数量和大小。

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

当达到文件限制上限时,会自动删除旧的文件。

在 syslog 驱动程序下,可以使用 syslog-address 指定日志接收地址。

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

network_mode

设置网络模式。

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

networks

配置容器连接的网络,引用顶级 networks 下的条目。

services:
  some-service:
    networks:
      some-network:
        aliases:
         - alias1
      other-network:
        aliases:
         - alias2
networks:
  some-network:
    # 使用自定义驱动程序
    driver: custom-driver-1
  other-network:
    # 使用自定义驱动程序,该驱动程序接受特殊选项
    driver: custom-driver-2

aliases :其他容器可以使用服务名称或此别名来连接到对应容器的服务。

restart

  • no:是默认的重启策略,在任何情况下都不会重启容器。

  • always:容器总是重新启动。

  • on-failure:在容器非正常退出时(退出状态非0),才会重启容器。

  • unless-stopped:在容器退出时总是重启容器,但是不考虑在Docker守护进程启动时就已经停止了的容器

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

注:swarm 集群模式,请改用 restart_policy。

secrets

存储敏感数据,例如密码:

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

修改容器默认的 schema 标签。

security-opt:
  - label:user:USER  # 设置容器的用户标签
  - label:role:ROLE  # 设置容器的角色标签
  - label:type:TYPE  # 设置容器的安全策略标签
  - label:level:LEVEL  # 设置容器的安全等级标签

stop_grace_period

指定在容器无法处理 SIGTERM (或者任何 stop_signal 的信号),等待多久后发送 SIGKILL 信号关闭容器。

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

默认的等待时间是 10 秒。

stop_signal

设置停止容器的代替信号。默认情况下使用 SIGTERM。

以下示例,使用 SIGUSR1 代替信号 SIGTERM 来停止容器。

stop_signal: SIGUSR1

sysctls

设置容器中的内核参数,可以使用数组或字典格式。

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

tmpfs

Installa un file system temporaneo nel container. Può essere un singolo valore o una lista di valori multipli.

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

ulimits

Copia i limiti ulimit di default del container.

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

volumes

Monta il volume dati del host o il file su un container.

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