Docker Compose Cheat Sheet - Comandi più utili con esempi

Ecco un Docker Compose cheat sheet con esempi annotati per aiutarti a padroneggiare rapidamente i file e i comandi di Compose.

Riferimento al 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 nominato
  db_data:

• services: Ogni container nel tuo’applicazione multi-container. Nell’esempio sopra abbiamo due servizi: web e db.
• networks & volumes: Definisci reti isolate e archiviazione persistente - qui abbiamo la rete appnet e il volume db_data.

Esempi

Singolo servizio con mappatura delle porte

services:
  app:
    build: .
    ports:
      - "8000:80"   # Porta host 8000:Porta container 80

Espone l’app sulla porta host 8000 e costruisce 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; DB utilizza un volume nominato persistente - db_data.

Utilizzo del contesto di costruzione e del percorso del Dockerfile

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

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

Condivisione di 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 d’ambiente 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 del web; controlla solo l’ordine di avvio (non la prontezza).

Comandi essenziali di Docker Compose

Pattern 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 anche dopo il riavvio dei container.

• Montaggio bind per lo sviluppo

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

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

Flag utili

• -d: Modalità detach (esegui in background).
• --build: Forza il rebuild delle immagini prima di avviare.
• --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 sfruttando il file docker-compose.yml, che centralizza tutte le tue configurazioni e esigenze di orchestrazione dell’applicazione.

• I servizi vengono definiti sotto la chiave services.
• Ogni servizio rappresenta una configurazione del container, dove puoi impostare:
  • Image: Seleziona un’immagine da Docker Hub o da un altro registro.
  • Ports: Mappa le porte del container alle porte dell’host.
  • Variabili d’ambiente: Passa valori di configurazione.
  • Volumi: Persisti dati o condividi file/cartelle con l’host o altri servizi.
  • 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, collega 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

• Reti controllano quali servizi possono comunicare. Compose crea una rete predefinita, ma puoi definirne di più, specificare driver personalizzati, impostare opzioni e determinare quali servizi si collegano a quali reti per un isolamento fine.
• Definisci le reti al livello superiore sotto networks, e elenca quali reti un servizio deve collegarsi 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"

• Collega le reti ai servizi:

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

• Questa configurazione consente al servizio app di accedere a entrambi gli utenti sulla rete frontend e backend, mentre db è accessibile solo all’interno di backend.

Personalizzazione dei volumi

• Volumi vengono definiti al livello superiore sotto la chiave volumes. Montali sui container utilizzando la chiave volumes sotto un servizio.
• I volumi possono essere nominati, utilizzare driver personalizzati e essere condivisi tra diversi servizi per la persistenza dei dati e la condivisione.

Esempio:

volumes:
  web_data:                # Volume nominato per il contenuto web
  db_data:                 # Volume nominato 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 per qualsiasi container che lo monta. db_data assicura che i dati del database non vengano persi al momento della ricreazione del container.
• Puoi definire montaggi bind con opzioni personalizzate del driver per casi avanzati:

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

• Questa configurazione crea un montaggio bind dal percorso host /data/db_data all’interno del container.

Riepilogo delle migliori pratiche:

• Utilizza il nome del servizio come hostname DNS per la comunicazione tra servizi.
• Collega i servizi a più reti necessarie per controllare l’accesso.
• Utilizza volumi nominati per l’archiviazione persistente e la condivisione dei dati.
• Definisci tutto utilizzando YAML, abilitando il controllo delle versioni e gli script di distribuzione facili.

File Compose multipli

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

1. Struttura base e file di sovrascrittura

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

Esempio della struttura dei file:

/project-directory
|-- docker-compose.yml           # Configurazione base
|-- docker-compose.override.yml  # Sovrascritture locali/dev (caricate automaticamente)
|-- docker-compose.prod.yml      # Sovrascritture per produzione
|-- docker-compose.test.yml      # Sovrascritture per test (se necessario)

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

2. Come funzionano le sovrascritture dei file

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

Esempio di fusione:

• 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 base che la porta, più la variabile d’ambiente sovrascritta DEBUG.

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: Utilizza i flag -f per controllare quali file vengono fusi e nell’ordine specifico:

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

  • Questo ignora la sovrascrittura predefinita e utilizza le impostazioni specifiche per la produzione.

4. Strategie pratiche per l’organizzazione

• Separazione per ambiente: Utilizza un sovrascrittura per ogni ambiente: dev, test, prod, ecc.
• Microservizi e team: Suddividi la configurazione in file separati per diversi servizi o team, e combinali quando necessario.
• Toggle delle funzionalità: File aggiuntivi possono introdurre o rimuovere servizi o configurazioni opzionali per esigenze temporanee (es. un compose.debug.yml per il logging extra).

5. Vantaggi

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

6. Esempio: Passare tra gli ambienti

Sviluppo:

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

Produzione:

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

Ogni ambiente riceve solo la configurazione necessaria, con tutto il resto nel file base.

Organizzare le configurazioni complesse di Compose con più file - e sfruttare il sistema di sovrascrittura/fusione - garantisce modularità, personalizzazione specifica per ambiente e scalabilità per grandi applicazioni Docker multi-servizio.

Link utili

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