Come installare e utilizzare Docker Compose su Ubuntu 20.04

Introduzione

Docker semplifica il processo di gestione dei processi applicativi nei contenitori. Sebbene i container siano per certi versi simili alle macchine virtuali, sono più leggeri e rispettosi delle risorse. Ciò consente agli sviluppatori di suddividere un ambiente applicativo in più servizi isolati.

Per le applicazioni che dipendono da più servizi, l'orchestrazione di tutti i contenitori per l'avvio, la comunicazione e l'arresto insieme può diventare rapidamente ingombrante. Docker Compose è uno strumento che consente di eseguire ambienti applicativi multi-container in base alle definizioni impostate in un file YAML. Utilizza le definizioni dei servizi per creare ambienti completamente personalizzabili con più contenitori in grado di condividere reti e volumi di dati.

In questa guida dimostrerai come installare Docker Compose su un server Ubuntu 20.04 e come iniziare a utilizzare questo strumento.

Prerequisiti

Per seguire questo articolo, avrai bisogno di:

• Accesso a una macchina locale Ubuntu 20.04 o a un server di sviluppo come utente non root con privilegi sudo. Se stai utilizzando un server remoto, è consigliabile avere un firewall attivo installato. Per configurarli, fare riferimento alla nostra Guida all'installazione iniziale del server per Ubuntu 20.04.
• Docker installato sul tuo server o computer locale, seguendo i passaggi 1 e 2 di Come installare e utilizzare Docker su Ubuntu 20.04.

Nota: Questo tutorial ti guiderà attraverso l'installazione di Docker Compose v1, che utilizza docker-compose . A partire da Docker Compose v2, Docker è migrato verso l'utilizzo di compose Comando del plug-in CLI come documentato nella nostra ultima versione Ubuntu 22.04 di questo tutorial e lontano dall'originale docker-compose . Sebbene l'installazione sia diversa, in generale l'utilizzo effettivo comporta l'eliminazione del trattino da docker-compose chiamate per diventare docker compose . Per i dettagli completi sulla compatibilità, controlla la documentazione ufficiale di Docker sulla compatibilità dei comandi tra il nuovo compose e il vecchio docker-compose .

Passaggio 1:installazione di Docker Compose

Per assicurarti di ottenere la versione stabile più aggiornata di Docker Compose, scaricherai questo software dal suo repository Github ufficiale.

Innanzitutto, conferma l'ultima versione disponibile nella loro pagina delle versioni. Al momento in cui scrivo, la versione stabile più recente è 1.29.2 .

Il comando seguente scaricherà il 1.29.2 rilascia e salva il file eseguibile in /usr/local/bin/docker-compose , che renderà questo software accessibile a livello globale come docker-compose :

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

Quindi, imposta le autorizzazioni corrette in modo che docker-compose il comando è eseguibile:

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

Per verificare che l'installazione sia andata a buon fine, puoi eseguire:

docker-compose --version

Vedrai un output simile a questo:

Outputdocker-compose version 1.29.2, build 5becea4c

Docker Compose è ora installato correttamente sul tuo sistema. Nella prossima sezione, vedrai come configurare un docker-compose.yml file e ottieni un ambiente containerizzato attivo e funzionante con questo strumento.

Passaggio 2:configurazione di un docker-compose.yml File

Per dimostrare come impostare un docker-compose.yml file e lavorerai con Docker Compose, creerai un ambiente server Web utilizzando l'immagine Nginx ufficiale da Docker Hub, il registro Docker pubblico. Questo ambiente containerizzato servirà un singolo file HTML statico.

Inizia creando una nuova directory nella tua cartella Inizio, quindi spostati in essa:

mkdir ~/compose-demo
cd ~/compose-demo

In questa directory, imposta una cartella dell'applicazione che funga da root dei documenti per il tuo ambiente Nginx:

mkdir app

Utilizzando il tuo editor di testo preferito, crea un nuovo index.html file all'interno dell'app cartella:

nano app/index.html

Inserisci il seguente contenuto in questo file:

~/compose-demo/app/index.html

<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Docker Compose Demo</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/kognise/water.css@latest/dist/dark.min.css">
</head>
<body>

    <h1>This is a Docker Compose Demo Page.</h1>
    <p>This content is being served by an Nginx container.</p>

</body>
</html>

Salva e chiudi il file quando hai finito. Se stai usando nano , puoi farlo digitando CTRL+X , quindi Y e ENTER per confermare.

Quindi, crea il docker-compose.yml file:

nano docker-compose.yml

Inserisci il seguente contenuto nel tuo docker-compose.yml file:

docker-compose.yml

version: '3.7'
services:
  web:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - ./app:/usr/share/nginx/html

Il docker-compose.yml il file in genere inizia con la version definizione. Questo dirà a Docker Compose quale versione di configurazione stai utilizzando.

Quindi hai i services blocco, dove si impostano i servizi che fanno parte di questo ambiente. Nel tuo caso, hai un unico servizio chiamato web . Questo servizio utilizza il nginx:alpine image e imposta un reindirizzamento della porta con ports direttiva. Tutte le richieste sulla porta 8000 dell'host macchina (il sistema da cui stai eseguendo Docker Compose) verrà reindirizzato al web container sul porto 80 , dove verrà eseguito Nginx.

I volumes la direttiva creerà un volume condiviso tra la macchina host e il contenitore. Questo condividerà l'app locale cartella con il contenitore e il volume si troverà in /usr/share/nginx/html all'interno del contenitore, che sovrascriverà quindi la radice del documento predefinita per Nginx.

Salva e chiudi il file.

Hai impostato una pagina demo e un docker-compose.yml per creare un ambiente server Web containerizzato che lo servirà. Nel passaggio successivo, attiverai questo ambiente con Docker Compose.

Passaggio 3:esecuzione di Docker Compose

Con docker-compose.yml sul posto, ora puoi eseguire Docker Compose per far apparire il tuo ambiente. Il comando seguente scaricherà le immagini Docker necessarie, creerà un contenitore per il web servizio ed eseguire l'ambiente containerizzato in modalità background:

docker-compose up -d

Docker Compose cercherà prima l'immagine definita sul tuo sistema locale e, se non riesce a individuare l'immagine, scaricherà l'immagine da Docker Hub. Vedrai un output come questo:

OutputCreating network "compose-demo_default" with the default driver
Pulling web (nginx:alpine)...
alpine: Pulling from library/nginx
cbdbe7a5bc2a: Pull complete
10c113fb0c77: Pull complete
9ba64393807b: Pull complete
c829a9c40ab2: Pull complete
61d685417b2f: Pull complete
Digest: sha256:57254039c6313fe8c53f1acbf15657ec9616a813397b74b063e32443427c5502
Status: Downloaded newer image for nginx:alpine
Creating compose-demo_web_1 ... done

Nota: Se riscontri un errore di autorizzazione relativo al socket Docker, significa che hai saltato il passaggio 2 di Come installare e utilizzare Docker su Ubuntu 20.04. Tornare indietro e completare quel passaggio abiliterà le autorizzazioni per eseguire i comandi della finestra mobile senza sudo .

Il tuo ambiente è ora attivo e funzionante in background. Per verificare che il contenitore sia attivo, puoi eseguire:

docker-compose ps

Questo comando ti mostrerà le informazioni sui container in esecuzione e il loro stato, nonché eventuali reindirizzamenti delle porte attualmente in atto:

Output       Name                     Command               State          Ports        
----------------------------------------------------------------------------------
compose-demo_web_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:8000->80/tcp

Ora puoi accedere all'applicazione demo puntando il tuo browser su localhost:8000 se stai eseguendo questa demo sul tuo computer locale, o your_server_domain_or_IP:8000 se stai eseguendo questa demo su un server remoto.

Vedrai una pagina come questa:

Il volume condiviso che hai impostato in docker-compose.yml file conserva la tua app file delle cartelle sincronizzati con la radice del documento del contenitore. Se apporti modifiche a index.html file, verranno automaticamente prelevati dal contenitore e quindi riflessi sul tuo browser quando ricarichi la pagina.

Nel passaggio successivo, vedrai come gestire il tuo ambiente containerizzato con i comandi Docker Compose.

Passaggio 4:acquisire familiarità con i comandi Docker Compose

Hai visto come impostare un docker-compose.yml file e apri il tuo ambiente con docker-compose up . Ora vedrai come utilizzare i comandi Docker Compose per gestire e interagire con il tuo ambiente containerizzato.

Per controllare i log prodotti dal tuo container Nginx, puoi usare i logs comando:

docker-compose logs

Vedrai un output simile a questo:

OutputAttaching to compose-demo_web_1
web_1  | /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
web_1  | /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
web_1  | 10-listen-on-ipv6-by-default.sh: Getting the checksum of /etc/nginx/conf.d/default.conf
web_1  | 10-listen-on-ipv6-by-default.sh: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
web_1  | /docker-entrypoint.sh: Configuration complete; ready for start up
web_1  | 172.22.0.1 - - [02/Jun/2020:10:47:13 +0000] "GET / HTTP/1.1" 200 353 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36" "-"

Se desideri sospendere l'esecuzione dell'ambiente senza modificare lo stato corrente dei tuoi contenitori, puoi utilizzare:

docker-compose pause

OutputPausing compose-demo_web_1 ... done

Per riprendere l'esecuzione dopo aver emesso una pausa:

docker-compose unpause

OutputUnpausing compose-demo_web_1 ... done

La stop comando interromperà l'esecuzione del contenitore, ma non distruggerà alcun dato associato ai tuoi contenitori:

docker-compose stop

OutputStopping compose-demo_web_1 ... done

Se desideri rimuovere i container, le reti e i volumi associati a questo ambiente containerizzato, utilizza il down comando:

docker-compose down

OutputRemoving compose-demo_web_1 ... done
Removing network compose-demo_default

Nota che questo non rimuoverà l'immagine di base utilizzata da Docker Compose per avviare il tuo ambiente (nel tuo caso, nginx:alpine ). In questo modo, ogni volta che riaprirai il tuo ambiente con un docker-compose up , il processo sarà molto più veloce poiché l'immagine è già sul tuo sistema.

Nel caso in cui desideri rimuovere anche l'immagine di base dal tuo sistema, puoi utilizzare:

docker image rm nginx:alpine

OutputUntagged: nginx:alpine
Untagged: nginx@sha256:b89a6ccbda39576ad23fd079978c967cecc6b170db6e7ff8a769bf2259a71912
Deleted: sha256:7d0cdcc60a96a5124763fddf5d534d058ad7d0d8d4c3b8be2aefedf4267d0270
Deleted: sha256:05a0eaca15d731e0029a7604ef54f0dda3b736d4e987e6ac87b91ac7aac03ab1
Deleted: sha256:c6bbc4bdac396583641cb44cd35126b2c195be8fe1ac5e6c577c14752bbe9157
Deleted: sha256:35789b1e1a362b0da8392ca7d5759ef08b9a6b7141cc1521570f984dc7905eb6
Deleted: sha256:a3efaa65ec344c882fe5d543a392a54c4ceacd1efd91662d06964211b1be4c08
Deleted: sha256:3e207b409db364b595ba862cdc12be96dcdad8e36c59a03b7b3b61c946a5741a

Nota :Fare riferimento alla nostra guida su Come installare e utilizzare Docker per un riferimento più dettagliato sui comandi Docker.

Conclusione

In questa guida, hai visto come installare Docker Compose e configurare un ambiente containerizzato basato su un'immagine del server web Nginx. Hai anche visto come gestire questo ambiente utilizzando i comandi Componi.

Per un riferimento completo di tutti i docker-compose disponibili comandi, controlla la documentazione ufficiale.

Se sei interessato a ulteriori utilizzi di Docker Compose, consulta Come installare WordPress con Docker Compose e anche Come proteggere un'applicazione Node.js containerizzata con Nginx, Let's Encrypt e Docker Compose.