GNU/Linux >> Linux Esercitazione >  >> Panels >> Docker

Come usare Docker Compose

Cos'è Docker Compose?

Se l'applicazione Docker include più di un container (ad esempio, un server Web e un database in esecuzione in container separati), la creazione, l'esecuzione e la connessione dei container da Dockerfile separati è ingombrante e richiede molto tempo. Docker Compose risolve questo problema consentendo di utilizzare un file YAML per definire app multi-container. Puoi configurare tutti i contenitori che desideri, come devono essere costruiti e collegati e dove devono essere archiviati i dati. Quando il file YAML è completo, puoi eseguire un singolo comando per creare, eseguire e configurare tutti i contenitori.

Questa guida spiegherà come il docker-compose.yml il file è organizzato e mostra come utilizzarlo per creare diverse configurazioni di app di base.

Nota In genere i contenitori in un'applicazione creata utilizzando Docker Compose verranno eseguiti tutti sullo stesso host. La gestione dei container in esecuzione su host diversi di solito richiede uno strumento aggiuntivo, come Docker Swarm o Kubernetes.

Prima di iniziare

Installa Docker CE

Avrai bisogno di un Linode con Docker CE installato per seguire i passaggi di questa guida.

Per installare Docker CE (Community Edition), segui le istruzioni all'interno di una delle guide seguenti:

  • Installazione e utilizzo di Docker su Ubuntu e Debian

  • Installazione e utilizzo di Docker su CentOS e Fedora

Per istruzioni complete su ancora più distribuzioni Linux, fai riferimento alla sezione Installa Docker Engine della documentazione ufficiale di Docker.

Installa Docker Compose

  1. Scarica l'ultima versione di Docker Compose. Controlla la pagina dei rilasci e sostituisci 1.25.4 nel comando seguente con la versione contrassegnata come Ultima versione :

     sudo curl -L https://github.com/docker/compose/releases/download/1.25.4/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

  2. Imposta i permessi dei file:

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

Utilizzo di base

Questa sezione esaminerà un file Docker Compose di esempio tratto dalla documentazione ufficiale di Docker.

  1. Apri docker-compose.yml in un editor di testo e aggiungi il seguente contenuto:

    File:docker -compose.yml
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

    version: '3'

services:
   db:
     image: mysql:5.7
     volumes:
       - db_data:/var/lib/mysql
     restart: always
     environment:
       MYSQL_ROOT_PASSWORD: somewordpress
       MYSQL_DATABASE: wordpress
       MYSQL_USER: wordpress
       MYSQL_PASSWORD: wordpress

   wordpress:
     depends_on:
       - db
     image: wordpress:latest
     ports:
       - "8000:80"
     restart: always
     environment:
       WORDPRESS_DB_HOST: db:3306
       WORDPRESS_DB_USER: wordpress
       WORDPRESS_DB_PASSWORD: wordpress
volumes:
    db_data:

  2. Salva il file ed esegui Docker Compose dalla stessa directory:

    docker-compose up -d

    Questo creerà ed eseguirà il db e wordpress contenitori. Proprio come quando si esegue un singolo container con docker run , il -d flag avvia i contenitori in modalità scollegata.

  3. Ora hai un contenitore WordPress e un contenitore MySQL in esecuzione sul tuo host. Vai a 192.0.8.1:8000/wordpress in un browser web per vedere la tua applicazione WordPress appena installata. Puoi anche usare docker ps per esplorare ulteriormente la configurazione risultante:

    docker ps

  4. Ferma e rimuovi i contenitori:

    docker-compose down

Componi la sintassi del file

Un docker-compose.yml il file è organizzato in quattro sezioni:

Direttiva Usa
versione Specifica la versione della sintassi del file Componi. Questa guida utilizzerà la versione 3 in tutto.
servizi In Docker un servizio è il nome di un "Contenitore in produzione". Questa sezione definisce i contenitori che verranno avviati come parte dell'istanza Docker Compose.
reti Questa sezione viene utilizzata per configurare la rete per la tua applicazione. Puoi modificare le impostazioni della rete predefinita, connetterti a una rete esterna o definire reti specifiche per app.
volumi Monta un percorso collegato sulla macchina host che può essere utilizzato dal container.

La maggior parte di questa guida si concentrerà sulla configurazione dei contenitori utilizzando i services sezione. Di seguito sono riportate alcune delle direttive comuni utilizzate per impostare e configurare i container:

Direttiva Usa
immagine Imposta l'immagine che verrà utilizzata per costruire il contenitore. L'uso di questa direttiva presuppone che l'immagine specificata esista già sull'host o su Docker Hub.
crea Questa direttiva può essere usata al posto di image . Specifica la posizione del Dockerfile che verrà utilizzato per creare questo contenitore.
db Nel caso del file Dockercompose di esempio, db è una variabile per il contenitore che stai per definire.
riavvia Dice al contenitore di riavviarsi se il sistema si riavvia.
volumi Monta un percorso collegato sulla macchina host che può essere utilizzato dal container
ambiente Definire le variabili di ambiente da passare al comando di esecuzione Docker.
dipende da Imposta un servizio come dipendenza per il contenitore definito dal blocco corrente
porta Mappa una porta dal container all'host nel modo seguente:host:container
collegamenti Collega questo servizio a qualsiasi altro servizio nel file Docker Compose specificandone i nomi qui.

Sono disponibili molte altre direttive di configurazione. Per i dettagli, vedere il riferimento Compose File.

Attenzione L'esempio docker-compose.yml sopra utilizza l'environment direttiva per memorizzare le password utente MySQL direttamente nel file YAML da importare nel contenitore come variabili di ambiente. Questa operazione non è consigliata per le informazioni riservate negli ambienti di produzione. Invece, le informazioni sensibili possono essere archiviate in un .env separato file (che non viene archiviato nel controllo della versione o reso pubblico) e vi si accede da docker-compose.yml utilizzando il env_file direttiva.

Crea un'applicazione da zero

Crea un docker-compose.yml archiviare una sezione alla volta per illustrare i passaggi della creazione di un'applicazione multi-container.

Definisci un servizio semplice:

  1. Crea un nuovo docker-compose.yml in un editor di testo e aggiungi il seguente contenuto:

    File:docker -compose.yml
    1
2
3
4
5
6
7
8

    version: '3'

services:
  distro:
    image: alpine
    restart: always
    container_name: Alpine_Distro
    entrypoint: tail -f /dev/null

    Ogni voce nei services la sezione creerà un contenitore separato quando docker-compose è eseguito. A questo punto, la sezione contiene un unico contenitore basato sulla distribuzione ufficiale alpina:

    • Il restart viene utilizzata per indicare che il contenitore deve sempre essere riavviato (ad esempio dopo un arresto anomalo o un riavvio del sistema).
    • Il container_name viene utilizzata per sovrascrivere il nome del contenitore generato casualmente e sostituirlo con un nome più facile da ricordare e con cui lavorare.
    • I container Docker escono per impostazione predefinita se su di essi non è in esecuzione alcun processo. tail -f è un processo in corso, quindi verrà eseguito a tempo indeterminato e impedirà l'arresto del contenitore. Il entrypoint predefinito viene ignorato per mantenere in esecuzione il contenitore.

  2. Alza il tuo container:

    docker-compose up -d

  3. Controlla lo stato del tuo container:

     docker ps

    L'output dovrebbe essere simile al seguente:

    CONTAINER ID        IMAGE               COMMAND               CREATED             STATUS              PORTS               NAMES
967013c36a27        alpine              "tail -f /dev/null"   3 seconds ago       Up 2 seconds                            Alpine_Distro

  4. Abbassa il contenitore:

     docker-compose down

Aggiungi servizi aggiuntivi

Da qui puoi iniziare a costruire un ecosistema di container. Puoi definire come lavorano insieme e comunicano.

  1. Riapri docker-compos.yml e aggiungi il database servizio di seguito:

    File:docker -compose.yml
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

    version: '3'

services:
  distro:
    image: alpine
    container_name: Alpine_Distro
    restart: always
    entrypoint: tail -f /dev/null

  database:
    image: postgres:latest
    container_name: postgres_db
    volumes:
      - ../dumps:/tmp/
    ports:
      - "5432:5432"

    Sono ora definiti due servizi:

    • Distribuzione
    • Banca dati

    Il servizio Distro è lo stesso di prima. Il server del database contiene le istruzioni per un container postgres e le direttive:volumes: - ../dumps:/tmp e ports:-"5432:5432" , la prima direttiva mappa il contenitore /dumps cartella nel nostro /tmp locale cartella. La seconda direttiva associa le porte dei container alle porte dell'host locale.

  2. Controlla i contenitori in esecuzione:

    docker ps

    Questo comando mostra lo stato dei container, la mappatura delle porte, i nomi e l'ultimo comando in esecuzione su di essi. È importante notare che il contenitore postgres legge "docker-entrypoint…" sotto i comandi. Lo script PostgresDocker Entrypoint è l'ultima cosa che viene avviata all'avvio del contenitore.

    CONTAINER ID        IMAGE               COMMAND                  CREATED              STATUS              PORTS                    NAMES
ecc37246f6ef        postgres:latest     "docker-entrypoint..."   About a minute ago   Up About a minute   0.0.0.0:5432->5432/tcp   postgres_db
35dab3e712d6        alpine              "tail -f /dev/null"      About a minute ago   Up About a minute                            Alpine_Distro

  3. Abbatti entrambi i contenitori:

     docker-compose down

Aggiungi un servizio nginx

  1. Aggiungi un contenitore nginx in modo che la tua applicazione sia in grado di servire siti Web:

    File:docker -compose.yml
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

    version: '3'

services:
  distro:
    image: alpine
    container_name: Alpine_Distro
    restart: always
    entrypoint: tail -f /dev/null

  database:
    image: postgres:latest
    container_name: postgres_db
    volumes:
      - ../dumps:/tmp/
    ports:
      - "5432:5432"
  web:
    image: nginx:latest
    container_name: nginx
    volumes:
      - ./mysite.template:/etc/nginx/conf.d/mysite.template
    ports:
      - "8080:80"
    environment:
      - NGINX_HOST=example.com
      - NGINX_port=80
    links:
      - database:db
      - distro

    Questa docker-compose contiene alcune nuove direttive:ambiente e link . La prima direttiva imposta le opzioni a livello di runtime all'interno del contenitore. links crea una rete di dipendenze tra i contenitori. Il contenitore nginx dipende dagli altri due da eseguire. Inoltre, i contenitori corrispondenti saranno raggiungibili a un hostname indicato dall'alias. In questo caso, esegui il ping di db dal web container raggiungerà il database servizio. Anche se non hai bisogno dei links direttiva per far dialogare i contenitori, links può fungere da failsafe all'avvio dell'applicazione di composizione mobile.

  2. Avvia Docker Compose e controlla lo stato del contenitore:

     docker-compose up -d
 docker ps

    L'output dovrebbe essere simile a:

    CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
55d573674e49        nginx:latest        "nginx -g 'daemon ..."   3 minutes ago       Up 3 minutes        0.0.0.0:8080->80/tcp     nginx
ad9e48b2b82a        alpine              "tail -f /dev/null"      3 minutes ago       Up 3 minutes                                 Alpine_Distro
736cf2f2239e        postgres:latest     "docker-entrypoint..."   3 minutes ago       Up 3 minutes        0.0.0.0:5432->5432/tcp   postgres_db

  3. Prova nginx navigando verso l'indirizzo IP pubblico del tuo Linode, porta 8080 in un browser (ad esempio 192.0.2.0:8080 ). Dovresti vedere la pagina di destinazione predefinita di nginx visualizzata.

Archiviazione dati persistente

Non è consigliabile archiviare i dati PostgreSQL direttamente all'interno di un contenitore. I contenitori Docker devono essere trattati come temporanei:i contenitori dell'applicazione vengono creati da zero durante l'esecuzione di docker-compose up e distrutto durante l'esecuzione di docker-compose down . Inoltre, qualsiasi arresto anomalo o riavvio imprevisto del sistema provocherà la perdita di tutti i dati archiviati in un contenitore.

Per questi motivi è importante impostare un volume persistente sull'host che i contenitori del database utilizzeranno per archiviare i propri dati.

  1. Aggiungi un volumes sezione a docker-compose.yml e modifica il database servizio per fare riferimento al volume:

    File:docker -compose.yml
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

    version: '3'

services:
  distro:
    image: alpine
    container_name: Alpine_Distro
    restart: always
    entrypoint: tail -f /dev/null

  database:
    image: postgres:latest
    container_name: postgres_db
    volumes:
      - data:/var/lib/postgresql
    ports:
      - "5432:5432"
  web:
    image: nginx:latest
    container_name: nginx
    volumes:
      - ./mysite.template:/etc/nginx/conf.d/mysite.template
    ports:
      - "8080:80"
    environment:
      - NGINX_HOST=example.com
      - NGINX_port=80
    links:
      - database:db
      - distro
volumes:
  data:
    external: true

  2. external: true indica a Docker Compose di utilizzare un volume di dati esterno preesistente. Se nessun volume denominato data è presente, l'avvio dell'applicazione causerà un errore. Crea il volume:

    docker volume create --name=data

  3. Avvia l'applicazione come prima:

    docker-compose up -d

Passaggi successivi

Docker Compose è un potente strumento per orchestrare set di contenitori che possono lavorare insieme. Cose come un'app o un ambiente di sviluppo possono utilizzare Docker-compose. Il risultato è un ambiente modulare e configurabile che può essere distribuito ovunque.


Docker

  1. Come utilizzare le immagini Docker, i contenitori e i file Docker in modo approfondito

  2. Come collegare i contenitori Docker

  3. Come utilizzare i profili di servizio per semplificare gli stack in Docker Compose

  4. Come utilizzare il comando Ispeziona Docker

  5. Come elencare i contenitori Docker

Che cos'è Docker Compose e come lo usi?

Come utilizzare i criteri di riavvio di Docker per mantenere in esecuzione i contenitori

Come installare Docker Compose su Ubuntu

Come eseguire i contenitori Docker

Come rimuovere i contenitori Docker

Come fermare i container Docker