Docker Compose su Debian 11 – Guida tutorial e setup

Nell’articolo precedente abbiamo parlato di come installare Docker su Debian 11 . Con l’articolo di oggi chiudiamo il tema Docker su Debian e vediamo come installare Docker Compose su Debian 11.

Un’applicazione può essere costituita da molti containers che eseguono vari servizi. Creare, eseguire e connettere manualmente i container da file Docker distinti può essere noioso e può richiedere molto tempo. Per non parlare del fatto che comprometterà la produttività complessiva. Ecco perché Docker ha introdotto Docker Compose, uno strumento per la definizione e l’esecuzione di applicazioni Docker multi-container. Ed è proprio a questo che serve docker-compose, ovvero per creare, gestire e comporre applicazioni Docker multi container.

Infatti, Compose ti consente di definire i containers e le loro relazioni in un file YAML (l’ennesimo linguaggio di markup).

In questo articolo impareremo a conoscere Compose, le sue funzionalità e i suoi vantaggi. Impareremo anche come installare e utilizzare Docker Compose su un sistema Debian 11.

Indice dei contenuti

Let’s go

Cos’è Docker Compose

Si parla di Docker Compose come uno strumento per la definizione e l’esecuzione di applicazioni Docker multi-contenitore che viene utilizzato dagli sviluppatori per creare e orchestrare applicazioni distribuite.

Progettato per essere facile da usare, fornisce un linguaggio dichiarativo per specificare e configurare complesse applicazioni Docker multi-contenitore con il minimo sforzo. Docker Compose inoltre ti aiuta a gestire la configurazione dell’applicazione, quindi non è necessario copiare manualmente i file tra i contenitori. Rende più facile per gli sviluppatori e il personale operativo lavorare insieme sul processo di creazione e distribuzione di un’applicazione.Compose ti consente inoltre di creare nuove applicazioni dalla stessa base di codice il più velocemente possibile. Vale la pena aggiungere che è un’alternativa più potente alle immagini Docker.

Inoltre Compose permette anche di gestire più versioni della stessa applicazione o anche più versioni della stessa immagine. Aggiungerei che è un ottimo strumento per orchestrare applicazioni più complicate, ovvero composte da vari servizi. Consente inoltre di risparmiare una notevole quantità di tempo durante lo sviluppo e la manutenzione delle app.

Come installare Docker Compose su Debian 11

Iniziamo a entrare nel vivo dell’articolo e vediamo i passi necessari per installare Docker Compose su Debian 11.

Prerequisiti

Affinchè si possa procedere con l’istallazione del plugin Compose di Docker è necessario che siano rispettati alcuni prerequisiti fondamentali. Vediamo quali:

Come installare Docker Compose su Debian 11

Prima di iniziare, è importante aggiornare il tuo sistema per verificare che tutti i pacchetti siano allineati all’ultima versione:

sudo apt update
ShellScript

Aggiungere il repository Docker Compose

Utilizzare curl per scaricare il repository Compose nella directory /usr/local/bin/docker-compose. Puoi anche ottenere Docker Compose dal suo repository Github ufficiale.

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

L’output che dovrete aspettarvi sarà qualcosa di simile a:

(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
100 24.7M  100 24.7M    0     0  17.4M      0  0:00:01  0:00:01 --:--:-- 24.1M
ShellScript

Dopo aver scaricato Docker Compose, lanciamo il seguente comando per concedere l’autorizzazione e rendere eseguibile il file scaricato:

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

Verificare la versione di Docker Compose

A questo punto, andiamo a controllore la versione docker-compose per assicuraci che l’installazione sia andata a buon fine:

docker-compose --version
ShellScript

L’output atteso dovrebbe essere qualcosa di simile a:

Docker Compose version v2.0.1
ShellScript

Questo risultato mostra che Docker Compose è stato installato correttamente.

Come si usa Docker Compose

Per utilizzare docker compose, è assolutamente necessario creare un file chiamato docker-compose.yml. I containers che compongono lo stack della tua applicazione sono descritti in dettaglio proprio all’interno di questo file.
Ad esempio, nel docker-compose.yml potremo specificare le reti, le variabili di ambiente, le associazioni delle porte e i volumi dei tuoi containers.
I containers configurati all’interno del file docker-compose.yml si uniscono, e quindi si “parlano”, immediatamente allo stesso stack. Si trovano nella stessa rete Docker e comunicano tra loro utilizzando i loro nomi di servizio come nomi host.

Configurare il file docker-compose.yml

Per dimostrare come creare un file docker-compose.yml e utilizzare Docker Compose, andiamo a creare una configurazione di server Web di esempio utilizzando l’immagine Nginx ufficiale da Docker Hub.
Innanzitutto, utilizziamo i seguenti comandi per creare e andare alla directory dedicata a Docker Compose, che nel nostro esempio chiameremo compose-demo.

Andiamo nella nostra home directory e lanciamo i seguenti comandi:

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

Ora entriamo nella nostra nuova directory e creiamo la cartella che conterrà la nostra docroot di Nginx, con il relativo file index.html:

mkdir app
vi app/index.html
ShellScript

Inseriamo un contenuto di test per la nostra homepage:

<p>Docker Compose Nginx Demo Application - iegri.com </p>
<h2>This is a Docker Compose nginx Demo - iegri.com </h2>
<p>Questa pagina è erogata da un container Nginx.</p>
HTML

Salviamo il file e usciamo dall’editori vi con :wq!.

Andiamo finalmente a creare il nostro file docker-compose.yml all’interno della cartella ~/compose-demo. Vi ricordo che la tilde (~) rappresenta la home directory del nostro utente.

Diciamo che la nostra home directory sia /home/fabio, andremo a creare il docker.compose.yml, nella cartella /home/fabio/compose-demo/.

vi docker-compose.yml
ShellScript

e inseriamo all’interno del file le seguenti righe:

version: '3.8'
services:
  web:
    hostname: web
    container_name: web
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./app:/usr/share/nginx/html
YAML

Ogni nodo definisce la sua immagine.

Cioè, puoi definire l’ambiente o la porta.

In particolare, un volume denota un volume condiviso condiviso dall’host e dal coll’esempio precedente, il container Web (riga 3) utilizzerà l’immagine nginx:alpine (riga 4), verrà eseguito sulla porta 80 (riga 6 ) e verrà esposto pubblicamente sulla porta 80, utilizzando il volume condiviso./app:/usr/share/nginx/html (riga 8).
Salva e chiudi il file.
Considerato ciò, vediamo ora come startare l’applicazione e come testarla.

Distribuire l’applicazione

Se ricordate bene, a inizio articolo vi abbiamo elencato i prerequisiti per utilizzare docker compose su Debian 11. Uno di questi era che ci fosse un’installazione attiva di Docker. Prima di lanciare il comando, assicuratevi che docker stia girando sulla vostra macchina. Per farlo, potete lanciare il comando:

sudo systemctl status docker

Nel caso il processo docker non sia in running, leggete la nostra guida su come installare docker su Debian 11.

Per far partire l’applicazione sarà sufficiente lanciare il comando:

sudo docker-compose up -d
ShellScript

Ecco l’output:

docker@debian11:~/compose-demo$ sudo docker-compose up -d
[+] Running 8/8
  web Pulled                                                                                                    3.9s
    63b65145d645 Pull complete                                                                                  0.8s
    8c7e1fd96380 Pull complete                                                                                  1.3s
    86c5246c96db Pull complete                                                                                  1.4s
    b874033c43fb Pull complete                                                                                  1.5s
    dbe1551bd73f Pull complete                                                                                  1.6s
    0d4f6b3f3de6 Pull complete                                                                                  1.7s
    2a41f256c40f Pull complete                                                                                  3.0s
[+] Running 2/2
  Network compose-demo_default  Created                                                                         0.1s
  Container compose-demo-web-1  Started                                                                         1.3s
docker@debian11:~/compose-demo$ 
ShellScript

Questo avvierà un container web e scaricherà la libreria Nginx.

Particolarmente utile, per confermare che la distribuzione è stata eseguita correttamente, risulta essere il comando:

sudo docker-compose ps -a
ShellScript

che ci dovrebbe restituire il seguente output:

docker@debian11:~/compose-demo$ sudo docker-compose ps -a
NAME                 COMMAND                  SERVICE             STATUS              PORTS
compose-demo-web-1   "/docker-entrypoint.…"   web                 running             0.0.0.0:80->80/tcp, :::80->80/tcp
ShellScript

Pertanto, a questo punto, richiamando l’ip del nostro server sulla porta 80, dovremmo vedere la pagina html scritta in precedenza. Vediamo se funziona:

docker compose nginx test page
docker compose nginx test page on Debian 11

Quindi, possiamo dire che la nostra prima applicazione con Docker Compose sta funzionando correttamente.

Comandi utili docker compose su debian 11

La nostra applicazione sta ora girando correttamente, infatti è correttamente raggiungibile dal nostro browser.

Relativamente al punto vista funzionale quindi possiamo dire che non abbiamo problemi. In aggiunta a quanto fatto finora però, ci risulterà utile poter monitorare i logs, così come poter stoppare l’applicazione.

Entriamo quindi nel dettaglio e vediamo:

Eseguire lo stop di un container:

sudo docker-compose stop
sudo docker-compose down
ShellScript

Allo stesso modo, volendo stoppare solo il container che chiamato web:

sudo docker-compose web stop
ShellScript

Questo comando ci risulterà particolarmente utile in applicazioni più complesse, dove il nostro docker-compose.yml conterrà più applicazioni.

Considerando invece l’aspetto del monitoraggio, vediamo come leggere i logs di un container:

sudo docker-compose logs
ShellScript

Docker Compose su Debian – Video Contributo

A titolo di esempio, e come approfondimento, vi riporto un utile video tutorial che ho trovato particolarmente utile

Docker Compose su Debian 11 – Conclusione

Ora che hai imparato come installare e utilizzare Docker Compose su Debian 11, puoi accelerare il tuo sviluppo e utilizzarlo per distribuire le tue applicazioni.

Particolarmente utile ti risulterà la possibilità di inserire più applicazione nello stesso file di configurazione. Questo ti porterà motevoli vantaggi, come ad esempio la possibilità di creare legati e dipendenze tra le applicazioni.
Per riassumere, Docker Compose è uno strumento che ti consente di definire l’intera applicazione in un singolo file, che può quindi essere eseguito in più containers.

Se avete dei dubbi o se volete condividere il vostro punto di vista, scrivete nei commenti e cercherò di rispondere al più presto.

Detto ciò , vi auguro una Buona lettura.

Se volete restare in contatto, vi lascio anche il link della mia newsletter di LinkedIn.

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *