# Docker Compose: come orchestrare app di container

Docker Compose contribuisce a semplificare la scalabilità e la distribuzione delle applicazioni in [Docker](https://www.ionos.it/digitalguide/server/know-how/cose-docker/) automatizzando la **gestione dei contenitori**. In questo tutorial, esamineremo approfonditamente la configurazione e l’uso di Docker Compose, per permetterti di sfruttarlo al meglio nel tuo ambiente di produzione.

## Che cos’è Docker Compose?

Docker Compose serve a gestire le applicazioni e ad aumentare l’efficienza nello sviluppo dei container. Gli elementi di configurazione vengono impostati in un singolo file YAML, rendendo le applicazioni facili da creare e da scalare. Docker Compose si utilizza soprattutto per configurare un ambiente locale. Può però anche far parte di un flusso di lavoro di **Continuous Integration / Continuous Delivery (CI/CD)**. Chi lavora con Docker Compose può definire una versione specifica dei container per i test o per una fase specifica della pipeline. In questo modo è più facile identificare i problemi e risolvere i bug prima che entrino in produzione.

## Docker Compose: requisiti di sistema

Per l’**orchestrazione di container** sono necessari sia Docker Engine che Docker Compose. Pertanto, occorre che il sistema disponga di uno dei seguenti elementi:

- **Docker Engine e Docker Compose**: possono essere installati come programmi binari autonomi.
- **Docker Desktop**: ambiente di sviluppo con interfaccia grafica che include già Docker Engine e Docker Compose.

Consiglio Scopri come installare Docker Compose su diversi sistemi operativi nei nostri tutorial:

- [Installare Docker Compose su Ubuntu](https://www.ionos.it/digitalguide/server/configurazione/docker-compose-su-ubuntu/)
- [Installare Docker Compose su macOS](https://www.ionos.it/digitalguide/server/configurazione/docker-compose-su-mac/)
- [Installare Docker Compose su Windows](https://www.ionos.it/digitalguide/server/configurazione/docker-compose-su-windows/)

## Come utilizzare Docker Compose: procedura guidata

Di seguito, dimostriamo i concetti di Docker Compose con una semplice **applicazione web Python** nella quale le visite vengono conteggiate con un contatore. Per farlo, ricorriamo al framework Python Flask e al database in-memory Redis. Non occorre installare Python o Redis, dato che vengono forniti come immagini Docker.

### Primo passaggio: creare un file di progetto

Apri il terminale e crea una nuova cartella per il progetto.

```shell
$ mkdir composedemo
```

Passa quindi alla directory.

```shell
$ cd composedemo
```

In questa cartella crea il file *app.py* e inserisci il seguente codice:

```python
import time
import redis
from flask import Flask
app = Flask(__name__)
cache = redis.Redis(host='redis', port=6379)
def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)
@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello World! I was here {} times.\n'.format(count)
```

Come nome host utilizziamo “Redis” e la porta predefinita “6379”. Specifichiamo inoltre che la funzione `get_hit_count()` deve fare diversi tentativi di connessione al servizio. È una scelta consigliata, perché Redis potrebbe non essere ancora disponibile all’avvio dell’applicazione o potrebbero verificarsi problemi di connessione nel corso dell’esecuzione.

Definisci ora il file *requirements.txt* con le dipendenze:

```plaintext
flask
redis
```

### Secondo passaggio: configurare il Dockerfile

Il **Dockerfile** è usato per l’immagine Docker. Tutte le dipendenze di cui l’applicazione Python ha bisogno sono specificate qui.

```shell
# syntax=docker/dockerfile:1
FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP=app.py
ENV FLASK_RUN_HOST=0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
EXPOSE 5000
COPY . .
CMD ["flask", "run"]
```

Docker viene così istruito a utilizzare l’immagine di Python 3.7. Impostiamo anche le variabili d’ambiente per il comando **flask**. Con `apk add` installiamo gcc e altre dipendenze. `EXPOSE` specifica che il contenitore deve monitorare la porta 5000. Mediante `COPY` il contenuto della cartella corrente viene copiato nella cartella di lavoro */code*. Come comando predefinito per il contenitore impostiamo `flask run`.

Verifica che il file Docker sia stato salvato senza estensione, perché alcuni editor aggiungono automaticamente il suffisso *.txt*.

### Terzo passaggio: generare il file YAML

Configuriamo i servizi “redis” e “web” in ***docker-compose.yml***.

```yaml
version: "3.9"
services:
    web:
        build: .
        ports:
            - "8000:5000"
    redis:
        image: "redis:alpine"
```

Il servizio web utilizza l’immagine creata dal Dockerfile. Associa il contenitore e il computer host alla porta 8000, mentre il server web **Flask** opera sulla porta 5000. L’immagine di Redis, invece, proviene semplicemente dall’hub ufficiale di Docker.

### Quarto passaggio: eseguire l’applicazione per mezzo di Compose

Avvia l’applicazione a partire dalla cartella del progetto.

```shell
docker compose up
```

Digita *http://localhost:8000* nel browser. Puoi immettere anche *http://127.0.0.1:8000*.

Dovrebbe apparire il seguente messaggio:

[![Immagine: Applicazione Docker Compose: output su browser del contatore delle visite](https://www.ionos.it/digitalguide/fileadmin/_processed_/d/1/csm_docker-compose-hit-counter_f6e8af7148.webp "Applicazione Docker Compose: output su browser del contatore delle visite")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-compose-hit-counter.png) Il browser ti mostrerà il numero delle visite. Ricarica la pagina. Ora le visite dovrebbero essere aumentate a 2.

[![Immagine: Nuova apertura dell’applicazione Docker Compose](https://www.ionos.it/digitalguide/fileadmin/_processed_/7/8/csm_docker-compose-hit-counter-updated_58c6be39f6.webp "Nuova apertura dell’applicazione Docker Compose")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-compose-hit-counter-updated.png) Il numero delle visite è aumentato di 1. Interrompi l’applicazione in questo modo:

```shell
$ docker compose down
```

In alternativa, usa la combinazione `Ctrl` + `C` nel terminale in cui hai avviato l’applicazione.

### Quinto passaggio: aggiungere un bind mount

È possibile aggiungere un **bind mount** al servizio web servendosi di *docker-compose.yml*.

```yaml
version: "3.9"
services:
    web:
        build: .
        ports:
            - "8000:5000"
        volumes:
            - .:/code
        environment:
            FLASK_DEBUG: "true"
    redis:
        image: "redis:alpine"
```

In **volumes** specifichiamo che la cartella del progetto corrente deve essere collegata alla cartella */code* all’interno del contenitore. Ciò consente di modificare il codice senza dover ricreare l’immagine. La variabile di ambiente `FLASK_DEBUG` indica a `flask run` di operare in modalità di sviluppo.

### Sesto passaggio: creare ed eseguire una nuova applicazione

Immetti il seguente comando nel terminale per ricostruire il file Compose:

```shell
docker compose up
```

### Settimo passaggio: aggiornare l’applicazione

Dal momento che stai utilizzando un bind mount per la tua applicazione, puoi modificare il tuo codice e vedere automaticamente le modifiche senza dover ricreare l’immagine.

Scrivi un nuovo test di benvenuto in ***app.py***.

```python
return ‘Hello from Docker! I was here {} times.\n’.format(count)
```

Aggiorna il browser per verificare che le modifiche siano state adottate.

[![Immagine: Applicazione Docker Compose: testo di benvenuto modificato](https://www.ionos.it/digitalguide/fileadmin/_processed_/9/3/csm_docker-compose-hit-counter-text-modified_a210964afe.webp "Applicazione Docker Compose: testo di benvenuto modificato")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2023/docker-compose-hit-counter-text-modified.png) Il testo di benvenuto dell’applicazione Python è stato opportunamente modificato. ### Ottavo passaggio: ulteriori comandi

L’opzione `--help` mostra un elenco di comandi disponibili per Docker Compose:

```shell
docker compose --help
```

Per eseguire Docker Compose in background, è possibile aggiungere l’argomento `-d`:

```shell
docker compose up -d
```

Con `down` vengono rimossi tutti i contenitori. L’opzione `--volumes` cancella anche i volumi utilizzati dal contenitore Redis.

```shell
docker compose down --volumes
```

Consiglio Per imparare a usare Docker puoi avvalerti di alcuni nostri articoli della Digital Guide, quali il [tutorial su Docker](https://www.ionos.it/digitalguide/server/configurazione/tutorial-di-docker/) e la panoramica sui [comandi Docker](https://www.ionos.it/digitalguide/server/know-how/comandi-docker/).


This is a markdown version of: [https://www.ionos.it/digitalguide/server/configurazione/docker-compose-tutorial/](https://www.ionos.it/digitalguide/server/configurazione/docker-compose-tutorial/) for AI/LLM consumption.