Dockerfile con Ubuntu: Guida completa dal principiante all’avanzato per creare immagini Docker

1. Introduzione

Cosa sono Docker e i Dockerfile?

Negli ultimi anni, Docker ha guadagnato rapidamente popolarità come modo efficiente per semplificare gli ambienti di sviluppo e il deployment delle applicazioni. Docker impacchetta le applicazioni e le loro dipendenze in un’unica unità chiamata “contenitore”, consentendo loro di funzionare in modo coerente su ambienti diversi.

Per costruire questi contenitori Docker è necessario un modello chiamato Dockerfile. Un Dockerfile è un file di testo che definisce l’immagine di base del sistema operativo, il software installato, le variabili d’ambiente e altri dettagli di configurazione. Gli sviluppatori possono usarlo per creare automaticamente ambienti personalizzati.

Perché usare Ubuntu come immagine di base?

Quando si crea un Dockerfile, il primo passo è selezionare un’immagine di sistema operativo di base. Tra le molte opzioni disponibili, Ubuntu è una delle più popolari. Ubuntu è una distribuzione Linux basata su Debian, nota per la sua facilità d’uso e per la configurazione flessibile dell’ambiente, supportata da un vasto ecosistema di pacchetti.

I Dockerfile basati su Ubuntu offrono diversi vantaggi:

• Documentazione ufficiale e della community molto ampia, con una curva di apprendimento ridotta
• Installazione semplice di pacchetti e strumenti tramite APT
• Immagini leggere e minimaliste fornite ufficialmente (come ubuntu:20.04 e ubuntu:24.04)

Scopo di questo articolo e pubblico di riferimento

Questo articolo si concentra sulla keyword “Dockerfile Ubuntu” e spiega come creare Dockerfile basati su Ubuntu in modo facile da comprendere per i principianti.

Copre tutto, dalla struttura di base di un Dockerfile alle istruzioni passo‑passo per costruire un ambiente Ubuntu, esempi di configurazione di ambienti applicativi come Python e gli errori più comuni con le relative soluzioni.

L’articolo è consigliato a:

• Chi vuole creare ambienti usando Dockerfile per la prima volta
• Sviluppatori che desiderano creare ambienti di sviluppo riproducibili su Ubuntu
• Chiunque voglia approfondire la propria comprensione, incluse le tecniche di troubleshooting

2. Struttura di base di un Dockerfile

Cos’è un Dockerfile e qual è il suo ruolo?

Un Dockerfile è come una ricetta per creare immagini Docker. Definisce quale sistema operativo di base usare, quale software installare e come configurare l’ambiente.

Eseguendo il comando docker build basato su questo file, è possibile creare facilmente ambienti di sviluppo e di runtime altamente riproducibili.

Vantaggi dell’uso dei Dockerfile:

• Configurazione automatizzata dell’ambiente (niente ripetizioni manuali)
• Elimina le incoerenze ambientali nello sviluppo di squadra
• Facile integrazione nei pipeline CI/CD

Istruzioni Dockerfile più comuni

Un Dockerfile è composto da più istruzioni (directive). Di seguito le più comunemente usate. Combinandole in modo appropriato, è possibile costruire un Dockerfile basato su Ubuntu.

Esempio minimale di Dockerfile basato su Ubuntu

Di seguito un esempio molto semplice di Dockerfile che utilizza Ubuntu come immagine di base.

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y \
    curl \
    vim

CMD ["/bin/bash"]

Questo Dockerfile usa Ubuntu 24.04 come immagine di base, installa le utility curl e vim e avvia una shell Bash quando il contenitore parte.

Selezionare il tag Ubuntu appropriato

Le immagini Docker di Ubuntu sono pubblicate nel repository ufficiale di Docker Hub. Specificare ubuntu:latest utilizzerà la versione più recente, ma è consigliato fissare esplicitamente una versione.

Ad esempio:

• ubuntu:22.04 (LTS: Long‑Term Support, focalizzata sulla stabilità)
• ubuntu:24.04 (Ultimo LTS, focalizzato su funzionalità più recenti)

Scegli la versione in base a se la stabilità o le nuove funzionalità sono la tua priorità.

3. Pratica: Creare un Dockerfile basato su Ubuntu

Installare i pacchetti richiesti in un ambiente Ubuntu

.Quando si crea un ambiente Ubuntu usando un Dockerfile, è spesso necessario installare pacchetti aggiuntivi. Ad esempio, le seguenti utility sono comunemente usate durante la configurazione di un ambiente di sviluppo:

• curl : per scaricare file e testare le API
• vim : un editor di testo leggero
• git : sistema di controllo versione
• build-essential : strumenti essenziali per compilare programmi C/C++

Per installare questi pacchetti in un Dockerfile, utilizza l’istruzione RUN.

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y \
    curl \
    vim \
    git \
    build-essential

Eseguendo prima apt-get update ti assicuri che vengano recuperate le ultime liste dei pacchetti prima dell’installazione.

Configurare l’Installazione Non Interattiva

Su Ubuntu, apt-get install a volte richiede input da parte dell’utente. Tuttavia, le operazioni interattive non sono possibili durante le build di Docker. Per evitare ciò, è consigliato impostare una variabile d’ambiente e abilitare la modalità non interattiva.

ENV DEBIAN_FRONTEND=noninteractive

Questo sopprime richieste come la selezione della locale o del fuso orario e consente alle installazioni di procedere senza intoppi.

Ridurre le Dimensioni dell’Immagine Rimuovendo la Cache Inutile

Quando si usa APT, i file temporanei scaricati (cache) possono rimanere nell’immagine, aumentando la sua dimensione finale. È possibile ridurre le dimensioni dell’immagine rimuovendo la cache come mostrato di seguito:

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

Combinare più comandi in un’unica istruzione RUN aiuta anche a prevenire aumenti inutili dei layer dell’immagine.

Best Practice per Scrivere Dockerfile

Negli ambienti di sviluppo reali, le seguenti best practice per Dockerfile sono ampiamente raccomandate:

• Unire le istruzioni RUN quando possibile per ridurre il numero di layer
• Definire esplicitamente versioni e impostazioni usando ENV
• Utilizzare commenti per descrivere chiaramente lo scopo di ogni passaggio
• Evitare di lasciare file inutili usando rm e --no-install-recommends

Esempio:

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

Questo approccio produce un Dockerfile più leggero e più manutenibile.

4. Creare e Verificare le Immagini Docker

Creare un’Immagine Docker da un Dockerfile

Una volta che il tuo Dockerfile è pronto, il passo successivo è creare un’immagine Docker. Questo si fa con il comando docker build. Esegui il comando seguente nella directory che contiene il tuo Dockerfile:

docker build -t my-ubuntu-image .

• L’opzione -t assegna un nome (tag) all’immagine. In questo esempio, l’immagine è chiamata my-ubuntu-image.
• Il punto (.) si riferisce alla directory corrente contenente il Dockerfile.

Docker leggerà le istruzioni nel Dockerfile in ordine sequenziale e costruirà l’immagine di conseguenza.

Controllare l’Immagine Docker Creata

Dopo che l’immagine è stata costruita con successo, puoi verificarla usando il comando seguente:

docker images

Questo mostra un elenco delle immagini Docker memorizzate localmente, includendo le seguenti informazioni:

• REPOSITORY (nome dell’immagine)
• TAG
• IMAGE ID (identificatore unico)
• CREATED (data di creazione)
• SIZE

Esempio:

REPOSITORY        TAG       IMAGE ID       CREATED          SIZE
my-ubuntu-image   latest    abcd1234abcd   5 minutes ago    189MB

Questo conferma che l’immagine è stata registrata correttamente.

Eseguire un Container Docker per la Verifica

Per verificare che l’immagine creata funzioni come previsto, avvia un container Docker usando il comando seguente:

docker run -it my-ubuntu-image

• L’opzione -it avvia una sessione terminale interattiva.
• Se tutto va a buon fine, apparirà un prompt Bash, indicando che ti trovi all’interno del container Ubuntu.

All’interno del container, puoi verificare gli strumenti installati con comandi come:

curl --version
vim --version

Se questi comandi funzionano correttamente, il tuo Dockerfile è configurato correttamente.

Pulizia di Immagini e Contenitori Inutilizzati

Le compilazioni e gli esperimenti ripetuti possono lasciare immagini Docker e contenitori inutilizzati sul tuo sistema. Si consiglia di pulirli periodicamente usando i seguenti comandi:

• Rimuovere i contenitori arrestati:

  docker container prune
  

• Rimuovere le immagini inutilizzate:

  docker image prune
  

• Rimuovere tutti i dati inutilizzati (usare con cautela):

  docker system prune
  

Queste operazioni aiutano a risparmiare spazio su disco e prevenire potenziali problemi.

5. Avanzato: Creare un Ambiente Python

Abilitare Python in un Dockerfile basato su Ubuntu

Durante la creazione di un ambiente Ubuntu usando un Dockerfile, aggiungere un ambiente di runtime Python consente una vasta gamma di casi d’uso, inclusi sviluppo, test e machine learning. Sebbene Python possa già essere installato su Ubuntu per impostazione predefinita, è prassi comune configurarlo esplicitamente per una migliore gestione di versioni e pacchetti.

Installare Python usando APT

Il metodo più semplice è installare Python usando i pacchetti APT. Di seguito un esempio:

FROM ubuntu:24.04

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

Questo metodo fornisce una versione stabile di Python di sistema (come Python 3.10 o 3.12, a seconda della versione di Ubuntu). È inoltre possibile installare pacchetti Python aggiuntivi usando il comando pip.

Gestire le versioni di Python con pyenv

Se ti serve una versione specifica di Python o vuoi passare tra più versioni, usare pyenv è altamente consigliato.

Il seguente esempio mostra come installare Python 3.11.6 usando pyenv in un Dockerfile:

FROM ubuntu:24.04

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y \
    git \
    curl \
    make \
    build-essential \
    libssl-dev \
    zlib1g-dev \
    libbz2-dev \
    libreadline-dev \
    libsqlite3-dev \
    wget \
    llvm \
    libncurses5-dev \
    libncursesw5-dev \
    xz-utils \
    tk-dev \
    libffi-dev \
    liblzma-dev \
    && rm -rf /var/lib/apt/lists/*

# Install pyenv
RUN git clone https://github.com/pyenv/pyenv.git ~/.pyenv

ENV PYENV_ROOT="$HOME/.pyenv"
ENV PATH="$PYENV_ROOT/bin:$PATH"

RUN echo 'eval "$(pyenv init --path)"' >> ~/.bashrc

# Install a specific Python version
RUN pyenv install 3.11.6 && pyenv global 3.11.6

Questa configurazione fornisce un ambiente Python flessibile e ben controllato.

Gestire i pacchetti con requirements.txt

La maggior parte dei progetti reali richiede molteplici librerie Python. Queste dipendenze sono comunemente gestite usando un file requirements.txt.

Per prima cosa, crea un file requirements.txt nella radice del tuo progetto:

flask==2.3.2
requests>=2.25.1
pandas

Quindi fai riferimento ad esso nel tuo Dockerfile come segue:

COPY requirements.txt /app/requirements.txt
WORKDIR /app

RUN pip install --no-cache-dir -r requirements.txt

Questo consente di installare tutte le librerie richieste in una volta sola e migliora notevolmente la riproducibilità dell’ambiente.

Buone pratiche

• Quando si usa Python, creare un ambiente virtuale con virtualenv o venv aiuta a prevenire conflitti di dipendenze.
• Usare opzioni di soppressione della cache come --no-cache-dir riduce le dimensioni dell’immagine Docker.
• Eseguire pip install --upgrade pip prima di installare i pacchetti può aiutare a evitare errori di installazione.

6. Problemi comuni e risoluzione

Errori di permessi

Esempio:

Permission denied

Questo errore si verifica quando i file copiati non hanno i permessi di esecuzione o quando la proprietà dei file e gli utenti di esecuzione sono configurati in modo errato.

Soluzione:

• Rendere il file eseguibile:

  RUN chmod +x script.sh
  

• Cambiare la proprietà del file se necessario:

  RUN chown root:root /path/to/file
  

Pacchetto non trovato o fallimento dell’installazione

Esempio:

E: Unable to locate package xxx

Questo errore si verifica tipicamente quando non è stato eseguito apt-get update o quando il nome del pacchetto è errato.

Soluzione:

• Esegui sempre apt-get update prima di installare i pacchetti:

  RUN apt-get update && apt-get install -y curl
  

• Verifica i nomi dei pacchetti e controlla eventuali errori di battitura

Errori Relativi alla Rete

Esempio:

Temporary failure resolving 'deb.debian.org'

Questo errore indica un problema di risoluzione DNS durante il processo di build.

Soluzione:

• Riavviare il demone Docker potrebbe risolvere il problema:

  sudo systemctl restart docker
  

• Controlla le impostazioni DNS di Docker aggiungendo server DNS in /etc/docker/daemon.json :

  {
    "dns": ["8.8.8.8", "8.8.4.4"]
  }
  

Build con Cache Obsoleta

Docker utilizza caching basato su layer per velocizzare le build. Di conseguenza, le modifiche a un Dockerfile potrebbero non essere sempre riflesse immediatamente.

Soluzione:

• Ricostruisci senza cache:

  docker build --no-cache -t my-image .
  

Il Container Esce Immediatamente o il Comando di Avvio Non Viene Eseguito

Cause:

• Il comando specificato in CMD o ENTRYPOINT contiene un errore
• Usare CMD ["/bin/bash"] senza modalità interattiva provoca l’uscita immediata

Soluzione:

• Avvia il container in modalità debug:

  docker run -it my-image /bin/bash
  

• Comprendi le differenze tra CMD e ENTRYPOINT e usale in modo appropriato

Affrontando e risolvendo questi problemi, le tue capacità di progettazione dei Dockerfile miglioreranno costantemente. Quando si verificano errori, leggi attentamente i messaggi di errore e identifica quale istruzione e layer hanno causato il problema.

7. Riepilogo

Punti Chiave per Creare Dockerfile Basati su Ubuntu

Questo articolo ha fornito una spiegazione passo‑passo su come creare ambienti Ubuntu usando i Dockerfile, coprendo sia argomenti fondamentali che avanzati. Rivediamo i punti principali:

• Comprendere i fondamenti dei Dockerfile è il primo passo. Istruzioni come FROM, RUN, CMD e ENV consentono la creazione automatizzata di ambienti.
• Ubuntu è un’immagine base stabile e flessibile. Il suo ampio ecosistema di pacchetti, la grande base di utenti e le versioni LTS lo rendono ideale per ambienti di sviluppo.
• Gestione pratica dei pacchetti permette l’installazione degli strumenti e delle librerie necessarie. Un uso corretto di apt-get, la pulizia della cache e l’installazione non interattiva sono essenziali.
• Costruire ambienti pratici come Python è pienamente supportato dai Dockerfile. Strumenti come pyenv, pip e requirements.txt garantiscono configurazioni riproducibili.
• Le competenze di troubleshooting influiscono direttamente sulla stabilità. Comprendere permessi, rete e comportamento della cache di build migliora notevolmente la produttività.

Prossimi Passi nell’Apprendimento dei Dockerfile

Una volta che ti senti a tuo agio con i Dockerfile, puoi estendere le tue competenze oltre lo sviluppo, verso test e distribuzioni in produzione. Considera di approfondire i seguenti argomenti:

• Gestione di configurazioni multi‑container con Docker Compose
• Integrazione con strumenti CI/CD come GitHub Actions e GitLab CI
• Lavorare con piattaforme di orchestrazione di container come Kubernetes

Documentazione Ufficiale e Link di Riferimento

• Documentazione Ufficiale di Docker (Giappone)
• Docker Hub – Immagini Ufficiali di Ubuntu
• Repository GitHub di pyenv

8. FAQ (Domande Frequenti)

Q1. Quale versione di Ubuntu dovrei scegliere in un Dockerfile?

A1. Nella maggior parte dei casi, è consigliato scegliere una versione LTS (Long Term Support) per stabilità e manutenzione a lungo termine. Versioni come ubuntu:22.04 e ubuntu:20.04 sono ampiamente usate e supportate per cinque anni.

Se ti servono i pacchetti più recenti o versioni più nuove di linguaggi, puoi optare per una release più recente come ubuntu:24.04, ma è consigliato effettuare test approfonditi.

Q2. Perché apt-get install segnala “package not found”?

A2. Il motivo più comune è il mancato avvio di apt-get update in precedenza. Senza aggiornare l’elenco dei pacchetti, APT non può localizzare i pacchetti richiesti.

Esempio corretto:

RUN apt-get update && apt-get install -y curl

Assicurati inoltre che i nomi dei pacchetti siano corretti e non deprecati (ad esempio, usa python3 invece di python).

Q3. Come impostare variabili d’ambiente in un Dockerfile?

A3. Usa l’istruzione ENV per definire variabili d’ambiente disponibili sia durante il tempo di build che durante l’esecuzione del container.

Esempio:

ENV DEBIAN_FRONTEND=noninteractive

Questo è comunemente usato per sopprimere i prompt interattivi durante le installazioni APT. Le variabili d’ambiente sono anche utili per la configurazione delle applicazioni e le chiavi API.

Q4. Qual è la differenza tra CMD e ENTRYPOINT?

A4. Entrambe specificano i comandi eseguiti quando un container si avvia, ma il loro comportamento differisce.

Esempio:

CMD ["python3", "app.py"]
# vs
ENTRYPOINT ["python3"]
CMD ["app.py"]

Nel secondo caso, puoi passare argomenti usando docker run my-image another_script.py.

Q5. Perché le modifiche al mio Dockerfile non vengono riflesse?

A5. Docker utilizza la cache di build, che può causare il riutilizzo di layer non modificati anche dopo la modifica del Dockerfile.

Soluzione:

docker build --no-cache -t my-image .

Questo forza una ricostruzione completa e garantisce che tutte le modifiche vengano applicate.