Guida a Docker Compose: semplifica lo sviluppo multi-contenitore

Docker Compose semplifica la gestione delle applicazioni Docker multi-contenitore, permettendo agli sviluppatori di scrivere ed eseguire app complesse senza sforzo.

Gli ingegneri DevOps di livello intermedio, gli sviluppatori backend e i cloud-native developer, soprattutto chi lavora con microservizi o architetture multi-servizio, affrontano spesso la sfida di gestire numerosi container interconnessi. Docker Compose risolve queste complessità, snellendo i flussi di lavoro di sviluppo e test. 

In questo articolo imparerai tutto ciò che ti serve per usare Docker Compose. Dai un'occhiata alla nostra Guida a Docker per principianti se stai appena iniziando con Docker. 

Che cos'è Docker Compose?

Docker Compose è uno strumento pensato per definire e orchestrare applicazioni Docker multi-contenitore tramite un unico file di configurazione YAML. 

Con Compose puoi specificare facilmente servizi, network, volumi, variabili d'ambiente e dipendenze. È ideale per lo sviluppo locale, i setup di test, il prototyping rapido e piccoli ambienti di produzione.

Casi d'uso comuni di Docker Compose includono la creazione di ambienti locali che rispecchiano sistemi reali, come le architetture a microservizi. Definendo chiaramente le interazioni tra i componenti, Compose offre coerenza, facilità d'uso e cicli di iterazione più rapidi.

Potresti chiederti perché non usare semplicemente Kubernetes. Innanzitutto, è eccessivo per progetti piccoli e test locali. Come scoprirai nel nostro tutorial Kubernetes vs. Docker, Kubernetes è più adatto alla gestione di più container su cluster. Il nostro corso Containerizzazione e Virtualizzazione con Docker e Kubernetes approfondisce come creare e distribuire applicazioni con Docker e Kubernetes. 

Perché usare Docker Compose invece di comandi Docker manuali?

Gestire più container singolarmente può diventare rapidamente caotico a causa di:

• Ordini di dipendenza complessi, 
• Ambienti incoerenti, e 
• Problemi di scalabilità. 

Con i comandi manuali rischi errori umani, drift di configurazione e flussi di lavoro inefficienti. 

Docker Compose aiuta a risolvere questi problemi definendo tutti i servizi dell'applicazione e le dipendenze in un unico file YAML. Questo porta coerenza, scalabilità e facilità nella gestione delle dipendenze, riducendo sensibilmente gli errori e aumentando la produttività.

Compose è più veloce che creare manualmente i container e connetterli. Inoltre, Compose crea una rete predefinita per la comunicazione tra tutti i container. Gestisce anche i volumi, assicurandone il riaggancio automatico in caso di sostituzione o riavvio del servizio. 

Puoi imparare a containerizzare applicazioni di machine learning con Docker e Kubernetes nel nostro tutorial How to Containerize an Application Using Docker. 

Qual è la differenza tra Docker e Docker Compose?

Mentre Docker è la piattaforma per creare, eseguire e gestire i container, Docker Compose è lo strumento che rende facile definire e gestire più container usando un file YAML, per lo più docker-compose.yml. 

Docker gestisce i singoli container, ma Docker Compose ti permette di impilarli in un unico servizio. Ad esempio, un'applicazione con backend, frontend, database, caching e così via. 

Puoi creare ed eseguire i tuoi container senza Docker Compose. Tuttavia, racchiudere tutto in un unico file docker-compose.yml rende più semplice gestire più container. Inoltre, permette di avviare la tua applicazione in qualsiasi ambiente con un solo comando. 

Capire Docker e Docker Compose è fondamentale per superare i prossimi colloqui. Assicurati di essere pronto esplorando le 26 migliori domande e risposte su Docker per il 2025. 

Fondamenti di Docker Compose

Prima di entrare nei dettagli pratici, è essenziale comprendere i principi e la sintassi di base di Docker Compose. Prima di usare Compose, assicurati di aver installato Docker seguendo le istruzioni nella nostra guida Installa Docker su Ubuntu: dall'installazione al primo container. 

Struttura concettuale

Docker Compose astrae la complessità dell'orchestrazione dei container per lo sviluppo locale e le distribuzioni più semplici. Con un file Compose in formato YAML, dichiari i servizi di cui hai bisogno, definisci le loro dipendenze, specifichi network, volumi, variabili d'ambiente e altro. Compose gestisce in modo efficiente l'avvio, l'arresto, lo scaling e l'interconnessione di questi servizi.

Sintassi core di Compose

Docker Compose ruota attorno a una sintassi YAML semplice. I componenti principali includono:

• services per definire applicazioni containerizzate
• images o contesti di build per specificare i container
• ports per esporre i servizi
• volumes per l'archiviazione persistente dei dati
• networks per la comunicazione tra servizi

Definizione dei servizi e architettura dell'applicazione

I file Compose rappresentano i servizi dell'applicazione e le loro connessioni.

Definire i servizi

I servizi sono il cuore di un file Compose. Puoi definire e nominare chiaramente più servizi (come web frontend, database e servizi di caching), specificando le dipendenze tramite parole chiave semplici come depends_on per controllare l'ordine di avvio dei container.

Nozioni di base sul networking

Docker Compose crea automaticamente network predefiniti per facilitare la comunicazione tra i servizi definiti. Gli sviluppatori possono anche specificare network personalizzati se necessario, per un'isolamento maggiore o requisiti di rete più dettagliati.

Gestione dei volumi

I volumi consentono la persistenza dei dati oltre il ciclo di vita dei container. Puoi specificare volumi con nome o montare directory dell'host nei container, assicurando che database, log o altri dati stateful persistano in modo coerente.

Variabili d'ambiente

Compose semplifica il passaggio sicuro di variabili d'ambiente e secret nei container. Supporta dichiarazioni dirette sotto i servizi e il riferimento a variabili archiviate in file env accanto ai file Compose per mantenere i valori sensibili al sicuro e separati dalle definizioni Docker.

Scaling e orchestrazione con Docker Compose

Docker Compose semplifica anche lo scaling e l'orchestrazione di base, particolarmente utili per scenari rapidi di load test o per valutare servizi in parallelo.

Scalare i servizi

Il flag "--scale" di Compose ti permette comodamente di avviare rapidamente più copie dei servizi. Ciò rende semplici scenari di test come valutare il load balancing o gestire richieste concorrenti.

Per esempio, scalare un container con un'app Flask può avvenire con un solo comando:

docker-compose up --scale flaskapp=4

Docker Compose vs Docker Swarm e Kubernetes

Sebbene Docker Compose eccella nello sviluppo locale e in setup di piccola scala, è limitato nell'orchestrazione multi-host e su scala produttiva. Per scenari di produzione complessi su numerosi host, orchestratori più robusti come Docker Swarm o Kubernetes sono appropriati, poiché offrono bilanciamento del carico potente, self-healing, networking avanzato e scalabilità su larga scala non disponibili in Compose.

Il nostro post Docker Compose vs. Kubernetes entra più nel dettaglio delle differenze chiave tra Docker Compose e Kubernetes.  

Tecniche di ottimizzazione per un uso efficiente di Compose

Un uso efficiente di Docker Compose include l'ottimizzazione dei build, l'aggiunta di health check e la gestione delle risorse dei servizi. In questa sezione scoprirai di più su queste tecniche di ottimizzazione.

Strategie di build efficienti

Usare build multi-stage nei Dockerfile aiuta a ridurre le dimensioni delle immagini Docker, mentre sfruttare esplicitamente la cache di build accelera in modo significativo lo sviluppo e i processi CI.

Health check e policy di riavvio

Compose ti permette di definire health check espliciti dei container per mantenere l'affidabilità dell'applicazione. Le policy di riavvio assicurano che i container falliti ripartano automaticamente, migliorando la resilienza.

Gestione dei limiti di risorse

Impostare limiti di CPU e memoria direttamente nelle definizioni YAML di Compose ti aiuta a controllare l'allocazione delle risorse, migliorando prevedibilità ed efficienza.

Un esempio di snippet per i limiti di risorse:

services:
  flaskapp:
    image: flask
    deploy:
      resources:
        limits:
          cpus: '0.50'
          memory: 512M

Esempio pratico: applicazione multi-contenitore

Ecco un esempio reale semplificato che coinvolge un'applicazione Python Flask abbinata a Redis:

services:
  redis:
    image: redis:7
    container_name: redis
    ports:
      - "6379:6379"
    restart: always
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 5s
      retries: 3
  web:
    build: .
    container_name: flask_app
    command: gunicorn app:app --worker-class gevent --bind 0.0.0.0:5000 --timeout 3000
    ports:
      - "5000:5000"
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379/0
    env_file:
      - .env
    volumes:
      - ./shorts:/app/shorts
      - ./temp_uploads:/app/temp_uploads
      - ./uploads:/app/uploads
    restart: always

  worker:
    build: .
    container_name: celery_worker
    command: celery -A celery_worker.celery worker --loglevel=info
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379/0
    env_file:
      - .env
    volumes:
      - ./shorts:/app/shorts
      - ./temp_uploads:/app/temp_uploads
      - ./uploads:/app/uploads
    restart: always

Il file Docker Compose definisce un'app multi-contenitore con tre servizi:

1. redis
2. web (app Flask con Gunicorn)
3. worker (Celery worker)

Per il servizio redis:

• Usa l'immagine ufficiale Redis 7.
• Imposta il nome del container su redis.
• Mappa la porta 6379 all'interno del container sulla 6379 dell'host.
• Si riavvia sempre in caso di crash (restart: always).
• Definisce un healthcheck che esegue il ping di redis-cli ogni 30 secondi, va in timeout dopo 5 secondi e riprova 3 volte prima di dichiarare il container non sano.

Per il servizio web:

• Compila l'immagine dalla directory corrente (build: .).
• Assegna al container il nome flask_app.
• Esegue il comando gunicorn app:app usando worker gevent, in bind a 0.0.0.0:5000, con un timeout lungo di 3000 secondi
• Mappa la porta 5000 del container sulla 5000 dell'host.
• Dichiara una dipendenza dal servizio redis, assicurando che Redis si avvii per primo.
• Imposta una variabile d'ambiente REDIS_URL che punta al container Redis interno.
• Carica ulteriori variabili d'ambiente dal file .env.
• Monta tre cartelle locali nel container:
• ./shorts in /app/shorts,
• ./temp_uploads in /app/temp_uploads 
• ./uploads in /app/uploads
• Configurato per riavviarsi sempre in caso di crash.

Per il servizio worker:

• Compila anch'esso l'immagine dalla directory corrente (build: .), riutilizzando lo stesso Dockerfile del servizio web.
• Assegna al container il nome: celery_worker.
• Esegue il comando celery -A celery_worker.celery worker --loglevel=info che avvia un Celery worker per elaborare job in background.
• Dichiara una dipendenza dal servizio redis, assicurando che Redis si avvii per primo.
• Imposta la stessa variabile d'ambiente REDIS_URL per connettersi al broker Redis.
• Carica altre variabili d'ambiente dal file .env.
• Monta le stesse tre cartelle del servizio web, permettendo a entrambe, app web e worker, di condividere file e upload.
• Configurato per riavviarsi sempre in caso di crash.

Esplora altre idee di progetto Docker nel nostro tutorial 10 idee di progetti Docker. 

Creare ed eseguire applicazioni multi-contenitore

Docker Compose offre un set di strumenti semplice per le attività di routine sui container:

Creare le immagini

Usa docker compose build per generare le immagini dei container in base ai Dockerfile definiti. Trovi ulteriori informazioni sulla creazione di immagini Docker nel nostro tutorial Come imparare Docker da zero: guida per i professionisti dei dati. 

Eseguire i servizi

Usare docker compose up  avvia tutti i servizi definiti nel file Compose. Per la modalità detached, usa docker compose up -d. Il nostro corso Introduzione a Docker approfondisce l'esecuzione di un container in background. 

Vedere i container in esecuzione

Per visualizzare i container attivi e il loro stato, usa docker compose ps per elencare tutti i servizi in esecuzione.

Arrestare i servizi

Usa docker compose down per fermare i servizi in esecuzione. 

Visualizzare i log

Usa docker compose logs per controllare i log. Puoi specificare un container da cui vedere i log usando docker logs container_name. Per trasmettere i log in streaming, usa docker compose -f container_name. 

La nostra guida Le 18 migliori command Docker per creare, eseguire e gestire i container spiega altri comandi Docker per gestire con sicurezza le applicazioni tra diversi ambienti. 

Casi d'uso avanzati di Docker Compose 

I flussi di lavoro con Compose si adattano a setup di sviluppo più complessi o a configurazioni di ambiente differenti.

Configurazione multi-ambiente

Più file Compose o file di override facilitano setup diversi (sviluppo, test, produzione). Ciò mantiene le definizioni manutenibili e leggibili, consentendo modifiche rapide senza configurazioni disordinate.

Gestione delle dipendenze

Sebbene depends_on gestisca l'ordine di avvio di base, scenari complessi possono incorporare script di inizializzazione (come "wait-for-it"), assicurando che i container partano solo dopo che sono soddisfatte condizioni specifiche, ad esempio la disponibilità del database.

Integrazione con CI/CD

Compose si integra facilmente nei flussi di integrazione continua, automatizzando setup completi di ambienti per il testing. Piattaforme come GitLab CI e GitHub Actions offrono approcci nativi o semplici per integrare Compose, snellendo i test automatizzati.

Best practice e sfide comuni

Puoi evitare insidie comuni e costruire configurazioni manutenibili organizzando e strutturando con cura le definizioni Compose.

Organizzazione dei file Compose

Mantieni i tuoi file Compose chiari e modulari. Per progetti più semplici può bastare un singolo file, ma per applicazioni più grandi considera di suddividere la configurazione in più file Compose usando la funzionalità di override. Questo permette di:

• Separare logicamente i componenti (ad es., docker-compose.backend.yml, docker-compose.frontend.yml)
• Personalizzare più facilmente gli ambienti locale vs. produzione
• Snellire il versionamento e la collaborazione, poiché le modifiche a un servizio non impattano l'intero file

Usa nomi di servizio significativi e un'indentazione coerente per rendere i file più leggibili e navigabili.

Possibili insidie

Fai attenzione a questi errori comuni:

• Usare tag latest per le immagini: introduce imprevedibilità, poiché la versione reale dell'immagine può cambiare nel tempo. Blocca sempre le versioni delle immagini in modo esplicito (ad es., postgres:15.1) per garantire coerenza tra ambienti.
• Inserire secret in chiaro: non includere mai dati sensibili (ad es., API key, password) direttamente nei file Compose. Usa invece variabili d'ambiente, file .env (esclusi dal controllo versione) o strumenti di gestione dei secret come Docker Secrets per un trattamento sicuro.
• Definizioni di servizio troppo complesse: evita di stipare troppa logica o troppe responsabilità in un singolo container. Segui il principio della singola responsabilità e prediligi la semplicità quando possibile.
• Trascurare il networking esplicito: definisci network personalizzati in Compose invece di fare affidamento sul comportamento predefinito. Questo offre un controllo migliore sulla comunicazione tra servizi, riduce conflitti di porta e migliora i confini di sicurezza.

Adottando queste pratiche, i flussi di lavoro basati su Compose saranno più robusti, sicuri e facili da mantenere in ambienti collaborativi o in evoluzione.

Conclusione

Docker Compose semplifica notevolmente la creazione, la gestione e l'esecuzione di applicazioni multi-contenitore per gli sviluppatori. Le sue definizioni chiare basate su YAML, la facilità di orchestrazione e lo scaling lineare lo rendono prezioso per scenari di sviluppo locale e architetture di deployment più semplici. Sebbene orchestratori avanzati come Docker Swarm e Kubernetes siano più adatti a carichi di lavoro di produzione su larga scala, Compose resta un punto di ingresso essenziale per comprendere le basi dell'orchestrazione dei container e migliorare i flussi di lavoro degli sviluppatori.

Dai un'occhiata ai nostri corsi su Docker per imparare:

• Containerizzazione e virtualizzazione con Docker e Kubernetes 
• Docker intermedio