Creazione di immagini Docker personalizzate

Perché creare immagini personalizzate? Consentono di includere l'applicazione specifica, le relative dipendenze e la configurazione in un'unica unità portabile. Questo è fondamentale per garantire coerenza e semplificare la distribuzione.

Il modo in cui creare questa immagine viene definito in un file chiamato Dockerfile.

Containerizzeremo una semplicissima app web Python Flask. Quando si visita il suo indirizzo web, restituisce semplicemente «Hello from Docker!».

Immagini di avere questi file in una directory:

• app.py: il codice dell'applicazione Python
• requirements.txt: elenca le dipendenze Python
• Dockerfile: istruzioni per creare l'immagine

Questa è la nostra app Flask di base in Python. È in ascolto sulla porta 5000 e risponde con "Hello from Docker!".

Può eseguirla localmente (dopo aver installato Flask) per vederla in azione!

La nostra app ha bisogno della libreria Flask. La elenchiamo in requirements.txt. Questo file indica a Docker (e al gestore di pacchetti di Python, pip) cosa installare.

In questo modo l'immagine contiene tutte le librerie necessarie per eseguire l'app.

Un Dockerfile è un file di testo contenente le istruzioni per creare un'immagine. Ogni istruzione crea un layer. Ecco cosa useremo:

• FROM: specifica l'immagine di base (ad esempio, Python).
• WORKDIR: imposta la directory di lavoro all'interno del container.
• COPY: copia i file dal computer locale nell'immagine.
• RUN: esegue comandi (ad esempio, per installare le dipendenze).
• EXPOSE: informa Docker sulle porte su cui il container è in ascolto.
• CMD: definisce il comando predefinito da eseguire all'avvio del container.

Ecco il Dockerfile completo per la nostra app Flask. Inserisca questo file nella stessa directory di app.py e requirements.txt.

Ora creiamo la nostra immagine! Apra il terminale nella directory in cui si trovano il Dockerfile e i file dell'app.

Il flag -t assegna all'immagine un nome (my-flask-app) e una versione (1.0). Il punto . indica a Docker di usare la directory corrente come contesto di build.

docker build -t my-flask-app:1.0 .

Al termine della build, può verificare che la nuova immagine esista elencando tutte le immagini Docker locali.

Nell'output cerchi my-flask-app con il tag 1.0.

docker images

È il momento di vedere l'app in azione! Usi docker run per creare e avviare un container a partire dall'immagine.

-p 5000:5000 associa la porta 5000 del computer host alla porta 5000 all'interno del container. -d esegue il container in modalità detached (in background).

docker run -d -p 5000:5000 my-flask-app:1.0

Visiti http://localhost:5000 nel browser per visualizzare "Hello from Docker!".

I tag sono fondamentali per gestire diverse versioni delle immagini. Una pratica comune consiste nell'usare il versionamento semantico (ad esempio, 1.0.0, 2.1.5) e anche un tag latest.

Può aggiungere più tag a un'immagine usando docker tag:

docker tag my-flask-app:1.0 my-flask-app:latest

In questo modo può riferirsi alla stessa immagine con nomi diversi, rendendola più flessibile per i deployment.

Consideri il seguente Dockerfile e il comando di build:

# Dockerfile content
FROM alpine:latest
WORKDIR /app
COPY . .
CMD ["echo", "Hello"]

docker build -t my-app:v1 .

Quale delle seguenti affermazioni è VERA riguardo al comando docker build -t my-app:v1 .?

Ottimo lavoro! Ha imparato a:

• Preparare una semplice applicazione per la containerizzazione.
• Scrivere un Dockerfile di base usando istruzioni fondamentali (FROM, WORKDIR, COPY, RUN, EXPOSE, CMD).
• Creare un'immagine Docker personalizzata usando docker build -t.
• Verificare l'immagine con docker images.
• Eseguire un container dall'immagine personalizzata usando docker run -p.
• Comprendere l'importanza dell'assegnazione dei tag e del versionamento delle immagini.

Ora approfondiremo la struttura delle immagini Docker basata sui layer e le tecniche per ottimizzarne le dimensioni e i tempi di build!