Dockerfile: creazione e struttura del file

2.1 Concetti principali di Dockerfile

Dockerfile — è un file di testo che contiene una sequenza di comandi che Docker usa per creare un'immagine. Funziona come una sorta di "ricetta", descrivendo come deve essere costruita l'immagine – dallo strato base allo stato finale. Capire la struttura e il processo di creazione di un Dockerfile è importante per utilizzare Docker in modo efficace.

Concetti principali di Dockerfile:

1. Idempotenza: i comandi in un Dockerfile devono essere idempotenti – la loro esecuzione ripetuta dà lo stesso risultato.
2. Sequenzialità: i comandi vengono eseguiti in sequenza dall'alto verso il basso. L'ordine è importante, poiché ogni comando crea un nuovo livello dell'immagine.
3. Struttura a strati: praticamente ogni istruzione aggiunge un nuovo strato all'immagine. Questi strati vengono memorizzati nella cache, il che permette di ottimizzare il processo di costruzione.

Struttura di un Dockerfile:

Il Dockerfile è composto da istruzioni, ognuna delle quali svolge una funzione specifica. Ecco le principali:

1. FROM: imposta l'immagine di base che sarà utilizzata per creare la nuova immagine.
2. MAINTAINER: definisce l'autore del Dockerfile (deprecata, ma utile come informazione).
3. RUN: esegue comandi nel container e crea un nuovo livello.
4. COPY: copia file e directory dal contesto di costruzione nel filesystem del container.
5. ADD: copia file e directory, supporta l'estrazione di archivi e il download di file tramite URL.
6. WORKDIR: imposta la directory di lavoro per i comandi successivi.
7. ENV: definisce variabili di ambiente.
8. CMD: definisce il comando predefinito che viene eseguito al momento dell'avvio del container.
9. ENTRYPOINT: imposta il comando da eseguire quando il container viene avviato, con la possibilità di passare argomenti.
10. EXPOSE: specifica le porte utilizzate dal container.
11. VOLUME: crea un punto di montaggio per volumi esterni.

2.2 Creazione di un Dockerfile

Esempio di creazione di un Dockerfile

Vediamo un esempio semplice di creazione di un Dockerfile per un'app web su Node.js.

Step 1: Creare un Dockerfile di base

Crea un file chiamato Dockerfile nella root del tuo progetto e aggiungi le seguenti righe:

# Utilizziamo un'immagine base di Node.js
FROM node:14

# Impostiamo la directory di lavoro
WORKDIR /app

# Copiamo package.json e package-lock.json
COPY package*.json ./

# Installiamo le dipendenze
RUN npm install

# Copiamo tutti i file del progetto
COPY . .

# Specifica la porta che l'applicazione utilizzerà 
EXPOSE 3000

# Definiamo il comando per avviare l'applicazione
CMD ["node", "app.js"]

Questo Dockerfile esegue i seguenti passaggi:

1. FROM node:14: utilizza l'immagine ufficiale di Node.js versione 14 come base.
2. WORKDIR /app: imposta la directory di lavoro per i comandi successivi.
3. COPY package*.json ./: copia i file package.json e package-lock.json nella directory di lavoro.
4. RUN npm install: installa le dipendenze da package.json.
5. COPY . .: copia tutti i file del progetto nella directory di lavoro del container.
6. EXPOSE 3000: specifica che l'applicazione utilizzerà la porta 3000.
7. CMD ["node", "app.js"]: definisce il comando per avviare l'applicazione.

Step 2: Creazione dell'immagine

Dopo aver creato il Dockerfile, costruisci l'immagine usando il comando docker build:

docker build -t my-node-app .

Questo comando creerà un'immagine chiamata my-node-app, utilizzando il Dockerfile dalla directory corrente.

Step 3: Avviare il container

Avvia il container basato sull'immagine creata usando il comando docker run:

docker run -d -p 3000:3000 my-node-app

Questo esempio avvia il container in modalità detached, mappeggiando la porta 3000 del container sulla porta 3000 della macchina host. Ora puoi accedere all'applicazione tramite http://localhost:3000.

2.3 Istruzioni aggiuntive in Dockerfile

1. Impostazione delle variabili di ambiente

Puoi impostare variabili di ambiente che saranno disponibili nel container utilizzando l'istruzione ENV.

ENV NODE_ENV=production

2. Utilizzo di più comandi RUN

A volte conviene combinare più comandi in un'unica istruzione RUN per ridurre il numero di layer, diminuire la dimensione dell'immagine e accelerare il build.

RUN apt-get update && apt-get install -y \
  curl \
  git \
  && rm -rf /var/lib/apt/lists/*

Utile! Se un comando non entra in una sola riga, puoi usare il simbolo \ per continuarlo nella riga successiva. Questo verrà interpretato come un unico comando.

Utile! Per scrivere più comandi in una riga puoi usare &&: command1 && command2 && command3. Questo permette di eseguire più comandi consecutivamente.

Ottimizzazione dell'ordine dei comandi

Per utilizzare efficacemente la cache di Docker, copia prima i file che cambiano raramente (come package.json) e installa le dipendenze prima di aggiungere il resto dei file del progetto.

Esempio di Dockerfile avanzato

In progetti più complessi potrebbe essere necessario un Dockerfile avanzato con configurazioni aggiuntive.

# Utilizziamo un'immagine base minimale di Node.js
FROM node:14-alpine

# Impostiamo la directory di lavoro
WORKDIR /usr/src/app

# Copiamo package.json e installiamo le dipendenze
COPY package*.json ./
RUN npm install --only=production

# Copiamo il codice sorgente
COPY . .

# Indichiamo la porta da utilizzare
EXPOSE 8080

# Impostiamo variabili di ambiente
ENV NODE_ENV=production

# Avviamo l'applicazione
CMD ["node", "server.js"]