Docker Compose Cheatsheet - I comandi più utili con esempi

Ecco una scheda rapida su Docker Compose con esempi annotati per aiutarti a padroneggiare rapidamente i file e i comandi di Compose.

Questa guida fa parte di Strumenti per Sviluppatori: La Guida Completa ai Flussi di Lavoro di Sviluppo Moderno.

Prerequisiti

Docker Engine deve essere installato prima di utilizzare Compose. Su Ubuntu, segui Installare Docker su Ubuntu per scegliere il metodo di installazione corretto e impostare il plugin docker compose.

Riferimento File Compose: docker-compose.yml

Struttura principale:

version: '3'       # Versione del formato del file Compose

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Porta Host 8080:Porta Container 80
  db:
    image: postgres
    environment:            # Variabili d'ambiente
      POSTGRES_PASSWORD: example
    volumes:
      - db_data:/var/lib/postgresql/data

networks:          # Rete personalizzata
  appnet:
    driver: bridge

volumes:           # Volume denominato
  db_data:

• services: Ogni container nella tua applicazione multi-container. Nell’esempio sopra abbiamo due servizi: web e db. Per operazioni sui singoli container, vedi la Scheda Rapida Docker.
• networks & volumes: Definisci reti isolate e archiviazione persistente - qui abbiamo la rete appnet e il volume db_data.

Esempi

Servizio singolo con mappatura delle porte

services:
  app:
    build: .
    ports:
      - "8000:80"   # Porta Host 8000:Porta Container 80

Espone l’app sulla porta 8000 dell’host e crea l’immagine partendo dal Dockerfile nella directory corrente.

Multi-servizio con volume condiviso e rete personalizzata

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - type: bind
        source: ./app
        target: /app
    networks:
      - mynet
  db:
    image: postgres
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - mynet

networks:
  mynet:

volumes:
  db_data:

Web e DB sulla stessa rete; il DB utilizza un volume denominato persistente - db_data.

Utilizzo del contesto di build e del percorso del Dockerfile

Puoi costruire un’immagine Docker su richiesta dal Dockerfile specificato nel docker-compose.yml.

services:
  app:
    build:
      context: .
      dockerfile: docker/MyDockerfile

Condivisione dei dati tra servizi

services:
  web:
    image: nginx
    volumes:
      - shared_data:/usr/share/nginx/html
  worker:
    image: myworker
    volumes:
      - shared_data:/usr/src/app/data

volumes:
  shared_data:

Entrambi i servizi accedono allo stesso volume (per file statici o scambi di dati) - shared_data.

Opzioni Avanzate del File Compose

• environment: Imposta le variabili ENV per i container.
• depends_on: Controlla l’ordine di avvio dei servizi.
• deploy.replicas: Scala il servizio in modalità Swarm.

Esempio:

services:
  web:
    image: nginx
    deploy:
      replicas: 3
    depends_on:
      - db

Avvia 3 istanze web; controlla solo l’ordine di avvio (non la prontezza).

Comandi Essenziali di Docker Compose

Modelli Comuni di Compose

• Database con dati persistenti

  services:
    mysql:
      image: mysql
      environment:
        MYSQL_ROOT_PASSWORD: password
      volumes:
        - mysql_data:/var/lib/mysql
  
  volumes:
    mysql_data:
  

  I dati del DB persistono nel volume mysql_data attraverso i riavvii del container.

• Bind mounting del codice per lo sviluppo

  services:
    app:
      build: .
      volumes:
        - .:/app
  

  Modifica il codice in tempo reale sull’host, riflessa automaticamente nel container.

Flag Utili

• -d: Modalità distaccata (esecuzione in background).
• --build: Forza la ricostruzione delle immagini prima dell’avvio.
• --force-recreate: Ricrea i container anche se non sono cambiati.
• --remove-orphans: Rimuovi i container non definiti nel file Compose.

Definizione e Personalizzazione dei Servizi

Puoi definire e personalizzare servizi, reti e volumi in Docker Compose utilizzando il file docker-compose.yml, che centralizza tutte le esigenze di configurazione e orchestrazione della tua applicazione.

• I Servizi sono definiti sotto la chiave services.
• Ogni servizio rappresenta una configurazione del container, dove puoi impostare:
  • Image (Immagine): Seleziona un’immagine da Docker Hub o da un altro registro.
  • Ports (Porte): Mappa le porte del container alle porte dell’host.
  • Environment variables (Variabili d’ambiente): Passa i valori di configurazione.
  • Volumes (Volumi): Persiste i dati o condividi file/cartelle con l’host o altri servizi.
  • Networks (Reti): Controlla quali reti il servizio può accedere.

Esempio:

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Porta Host 8080:Porta Container 80
    environment:
      - NGINX_HOST=localhost
    volumes:
      - web_data:/usr/share/nginx/html
    networks:
      - frontend

  db:
    image: postgres:13
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - backend

• Qui, il servizio web utilizza l’immagine nginx, imposta una variabile d’ambiente, allega un volume, apre la porta 80 come 8080 sull’host e si connette alla rete frontend. Il servizio db fa qualcosa di simile per PostgreSQL.

Personalizzazione delle Reti

• Le Reti controllano quali servizi possono comunicare. Compose crea una rete predefinita, ma puoi definirne altre, specificare driver personalizzati, impostare opzioni e determinare quale servizio si connette a quale rete per un’isolamento dettagliato.
• Definisci le reti a livello superiore sotto networks, e elenca quali reti un servizio dovrebbe allegare utilizzando la chiave networks a livello di servizio.

Esempio:

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    driver_opts:
      com.docker.network.bridge.host_binding_ipv4: "127.0.0.1"

• Allega le reti ai servizi:

services:
  app:
    networks:
      - frontend
      - backend
  db:
    networks:
      - backend

• Questa configurazione consente al servizio app di accedere sia agli utenti nella rete frontend che nella backend, mentre db è accessibile solo all’interno della backend.

Personalizzazione dei Volumi

• I Volumi sono definiti sotto la chiave a livello superiore volumes. Montali nei container utilizzando la chiave volumes sotto un servizio.
• I volumi possono essere denominati, utilizzare driver personalizzati e essere condivisi tra più servizi per la persistenza e la condivisione dei dati.

Esempio:

volumes:
  web_data:                # Volume denominato per il contenuto web
  db_data:                 # Volume denominato per il database

services:
  web:
    volumes:
      - web_data:/usr/share/nginx/html

  db:
    volumes:
      - db_data:/var/lib/postgresql/data

• In questo esempio, web_data è persistente e disponibile a qualsiasi container che lo monta. db_data assicura che i dati del database non vengano mai persi in caso di ricreazione del container.
• Puoi definire bind-mount con opzioni del driver personalizzate per casi avanzati:

volumes:
  db_data:
    driver: local
    driver_opts:
      type: none
      device: /data/db_data
      o: bind

• Questa configurazione imposta un bind-mount dal percorso dell’host /data/db_data all’interno del container.

Riepilogo delle Best Practices:

• Usa il nome del servizio come hostname DNS per la comunicazione tra servizi.
• Allega i servizi a più reti secondo necessità per controllare l’accesso.
• Usa volumi denominati per l’archiviazione persistente e la condivisione dei dati.
• Definisci tutto utilizzando YAML, abilitando il controllo versione e script di deployment facili.
• Per la gestione e la visualizzazione dei container, considera Installare Portainer su Linux.

File Compose Multipli

Per organizzare configurazioni complesse multi-servizio in Docker Compose, puoi utilizzare file compose multipli e file di override, consentendo configurazioni modulari, specifiche per ambiente e scalabili. Ecco come funziona:

1. Struttura File Base e Override

• Crea un file base (compose.yaml o docker-compose.yml) contenente tutte le definizioni di servizio comuni e predefinite.
• Aggiungi file di override specifici per ambiente (es. docker-compose.override.yml, docker-compose.dev.yml, docker-compose.prod.yml).

Esempio struttura file:

/directory-progetto
|-- docker-compose.yml           # Configurazione base
|-- docker-compose.override.yml  # Override locali/dev (applicati automaticamente)
|-- docker-compose.prod.yml      # Override produzione
|-- docker-compose.test.yml      # Override test (se necessario)

La configurazione base definisce i servizi principali, mentre ogni override personalizza le impostazioni per un ambiente o un caso specifico.

2. Come Funzionano gli Override dei File

• Unione (Merging): Quando esegui docker compose up, Docker Compose unisce il file base con eventuali override in ordine; i file successivi sovrascrivono, estendono o aggiungono impostazioni ai file precedenti.
• Sovrascrittura dei Campi: Se un servizio o un campo è definito in più file, viene utilizzato il valore dell’ultimo file specificato. I nuovi campi vengono aggiunti.

Esempio unione:

• docker-compose.yml:

  services:
    web:
      image: myapp
      ports:
        - "8000:80"
  

• docker-compose.override.yml:

  services:
    web:
      environment:
        - DEBUG=true
  

• Risultato: Il servizio web utilizza sia l’immagine e la porta base, più la variabile d’ambiente DEBUG sovrascritta.

3. Utilizzo dei Comandi per File Multipli

• Comportamento predefinito: Se presente, Docker Compose carica automaticamente docker-compose.override.yml insieme a docker-compose.yml quando esegui qualsiasi comando.
• Specificare i file manualmente: Usa i flag -f per controllare quali file vengono uniti e in quale ordine:

  docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d
  

  • Questo ignora l’override predefinito e utilizza le impostazioni specifiche per la produzione.

4. Strategie Pratiche di Organizzazione

• Separazione degli ambienti: Usa un override per ogni ambiente: dev, test, prod, ecc.
• Microservizi e team: Dividi la configurazione in file separati per diversi servizi o team, e combinale secondo necessità.
• Interruttori di funzionalità (Feature toggles): File aggiuntivi possono introdurre o rimuovere servizi o configurazioni opzionali per esigenze temporanee (es. un compose.debug.yml per logging aggiuntivo).

5. Vantaggi

• Chiarezza: Mantiene i singoli file piccoli e focalizzati.
• Scalabilità: Aggiungi facilmente nuovi servizi, ambienti o impostazioni.
• Manutenibilità: Modifica o revisiona solo le sezioni rilevanti per un dato deployment.

6. Esempio: Cambio Ambienti

Sviluppo:

docker compose -f docker-compose.yml -f docker-compose.dev.yml up

Produzione:

docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

Ogni ambiente riceve solo la configurazione necessaria per esso, con tutta la configurazione condivisa nel file base.

Organizzare configurazioni Compose complesse con file multipli - e sfruttare il sistema di override/unione - garantisce modularità, personalizzazione specifica per ambiente e facile scalabilità per grandi applicazioni Docker multi-servizio.

Per il deployment in produzione su un singolo host Linux — avvio all’avvio, shutdown pulito, aggiornamenti e rotazione dei log — vedi Eseguire Docker Compose come Servizio Linux con systemd.

Link Utili

• https://docs.docker.com/compose/
• Scheda Rapida Docker
• Scheda Rapida Kubernetes
• Dockerizzazione di un’app Flutter Web con build Flutter dockerizzata e Nginx
• Installare Portainer su Linux