1.
DockerImage
mercoledì 12 novembre 2025
09:56
Perché creare una tua immagine Docker
Non esiste già un’immagine con ciò che ti serve su Docker Hub
Vuoi containerizzare un’applicazione sviluppata da te (es. un’app Flask, [Link],
Spring, ecc.)
Vuoi distribuire o condividere facilmente la tua app in ambienti diversi (test,
produzione, Kubernetes…)
Cosa fa un Dockerfile
Il Dockerfile è un semplice file di testo che spiega a Docker come costruire l’immagine.
Docker lo legge istruzione per istruzione, e crea una serie di layer (livelli).
Ogni istruzione (FROM, RUN, COPY, CMD, ecc.) crea un nuovo layer nella tua immagine.
Questo è fondamentale: i layer vengono cachati — quindi se modifichi solo il codice,
Docker ricostruisce solo gli ultimi layer (molto più veloce).
Struttura di base di un Dockerfile
# 1️⃣ Base image
FROM ubuntu:20.04
# 2️⃣ Aggiornamento e installazione dipendenze
RUN apt-get update && apt-get install -y python3 python3-pip
# 3️⃣ Copia del codice sorgente nel container
COPY . /opt/source-code
w
# 4️⃣ Imposta la directory di lavoro
WORKDIR /opt/source-code
# 5️⃣ Installa le dipendenze Python
RUN pip3 install -r [Link]
# 6️⃣ Comando di avvio
CMD ["python3", "[Link]"]
Costruzione dell’immagine
Una volta creato il file Dockerfile nella cartella del progetto, costruisci l’immagine con:
docker build -t miaapp:1.0 .
Spiegazione:
-t miaapp:1️.0 → assegna un nome e un tag all’immagine
. → indica che il Dockerfile si trova nella cartella corrente
Dopo pochi secondi, puoi verificarla con: docker images
Esecuzione dell’immagine come container
Lancia l’immagine appena creata: docker run -d -p 5000:5000 miaapp:1.0
La tua app Flask (nell’esempio) è accessibile sulla porta 5️000 del tuo host.
(Facoltativo) Pubblicare l’immagine su Docker Hub
Se vuoi renderla disponibile ad altri o a Kubernetes:
1️⃣ Fai login: docker login
2️⃣ Tagga l’immagine con il tuo nome utente Docker Hub: docker tag miaapp:1.0
tuo_utente/miaapp:1.0
3️⃣ Push l’immagine: docker push tuo_utente/miaapp:1.0
Ora sarà scaricabile da chiunque con: docker pull tuo_utente/miaapp:1.0
Layer caching — concetto chiave
Docker costruisce le immagini a layer.
Ogni istruzione nel Dockerfile → crea un layer indipendente.
👉 Se ricostruisci l’immagine dopo una modifica nel codice:
Docker riusa i layer precedenti (quelli che non sono cambiati)
Ricostruisce solo quelli successivi
⚡ Quindi è molto più veloce
Esempio:
Layer 1: FROM ubuntu ✅ cached
Layer 2: RUN apt install ✅ cached
Layer 3: COPY . /app ❌ cambiato → rebuild solo da qui in poi
Esempio : Costruiamo un immagine Docker con Flask e la avviamo in locale.
(Flask è un micro–framework web scritto in Python, usato per creare applicazioni web
e API in modo super semplice e veloce)
1. Creiamo una cartella di progetto :
mkdir $HOME\Desktop\myflaskapp
cd $HOME\Desktop\myflaskapp
2. Creiamo il file [Link] :
Tramite un editor creiamo questo file py con il codice dell applicazione flask.
from flask import Flask
app = Flask(__name__)
@[Link]("/")
def home():
return "Hello from my custom Docker image! 👋"
if __name__ == "__main__":
[Link](host="[Link]", port=5000)
3. Crea il file [Link] :
File di testo in cui elenchiamo le librerie Python di cui ha bisogno l'applicazione e che deve
installare per funzionare.
Nel nostro caso metteremo in questo file solo :
Flask==3.0.0
Service a Docker (e anche a chiunque userà l'app) per sapere : "questa applicazione
Python ha bisogno del pacchetto Flask, versione 3.0.0".
4. Crea il Dockerfile :
FROM python:3.11-alpine
# Imposta alcune variabili d'ambiente
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1
# Directory di lavoro nel container
WORKDIR /opt/app
# Copia le dipendenze e installale
COPY [Link] .
RUN pip install --no-cache-dir -r [Link]
# Copia il codice sorgente
COPY . .
# Espone la porta usata da Flask
EXPOSE 5000
# Comando per avviare l’app
CMD ["python", "[Link]"]
5. Build dell'immagine :
Apri la shell nella cartella del progetto, quindi cd myflaskapp.
Poi eseguiamo :
Docker build -t myflaskapp:1.0 .
(il punto finale del comando significa "usa il Dockerfile nella cartella corrente)
6. Esegui il container :
Dopo la build, lancia :
Docker run -d --name myflaskapp -p 5000:5000 myflaskapp:1.0
7. Ferma e rimuovi il container:
Docker stop myflaskapp
Docker rm myflaskapp
Se invece vuoi farlo ripartire Docker start myflaskapp
Oppure se lo vogliamo mettere in pausa momentaneamente : docker pause myflaskapp
docker unpause myflaskapp
Se vuoi verificare i container attivi : docker ps (solo quelli attivi)
docker ps -a (tutti anche quelli stoppati)
8. Eventualmente rimuovi anche l'immagine (se non viene usata da nessun
container fermo o in esecuzione) :
Docker rmi myflaskapp