Come imparare Docker da zero: una guida per i professionisti dei dati

Passo 3: Esegui il tuo primo container

Ora che Docker è installato, è il momento di eseguire il tuo primo container. Inizieremo con la semplice immagine hello-world, perfetta per i principianti.

1. Apri il terminale (o il Prompt dei comandi su Windows) ed esegui il seguente comando:

sudo docker run hello-world

Questo comando indica a Docker di cercare localmente l'immagine hello-world. Se non la trova, Docker scaricherà l'immagine da Docker Hub e poi la eseguirà.

Se Docker è installato correttamente, vedrai un messaggio che dice “Hello from Docker!” insieme ai dettagli su come funziona il processo Docker. Questo output conferma che Docker ha scaricato con successo l'immagine, creato un nuovo container ed eseguito il codice al suo interno.

Passo 4: Crea la tua prima immagine Docker

In questo passaggio, creerai un'immagine Docker personalizzata per un semplice progetto di data science. L'immagine includerà Python e librerie comuni per la data science come pandas, NumPy e scikit-learn.

1. Crea una nuova directory:

• • Inizia creando una nuova directory per il tuo progetto e spostati al suo interno:

mkdir my-data-science-app
cd my-data-science-app

2. Crea un Dockerfile:

All'interno di questa directory, crea un file chiamato Dockerfile (senza estensione):

# Use an official Python runtime as a parent image
FROM python:3.8-slim
 
# Set the working directory in the container
WORKDIR /app
 
# Copy the current directory contents into the container at /app
COPY . /app
 
# Install any needed packages specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt
 
# Make port 8888 available to the world outside this container
EXPOSE 8888
 
# Run a Jupyter notebook server when the container launches
CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]

Il Dockerfile fa quanto segue:

• FROM python:3.8-slim: imposta come base l'immagine Python 3.8 nella variante slim, una versione minima di Python, ideale per un ambiente di data science leggero.
• WORKDIR /app: imposta la directory di lavoro all'interno del container su /app. Tutti i comandi successivi verranno eseguiti in questa directory.
• COPY . /app: copia tutti i file dalla directory corrente della macchina host nella directory /app nel container. Tipicamente include gli script di data science e i file di configurazione.
• RUN pip install --no-cache-dir -r requirements.txt: installa le librerie Python elencate in requirements.txt. Le librerie comuni per la data science includono pandas, NumPy e scikit-learn.
• EXPOSE 8888: rende disponibile alla macchina host la porta 8888, la porta predefinita per i notebook Jupyter.
• CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]: avvia un server Jupyter Notebook all'avvio del container, rendendolo accessibile dal browser.

3. Crea un file requirements.txt:

Nella stessa directory, crea un file requirements.txt per elencare i pacchetti Python necessari alla tua applicazione:

pandas
numpy
scikit-learn
matplotlib

Questo file elenca le librerie Python che verranno installate all'interno del tuo container Docker.

4. Crea l'immagine Docker:

• Con Dockerfile e requirements.txt pronti, costruisci la tua immagine Docker con il seguente comando:

sudo docker build -t my-data-science-app .

Il comando sopra fa quanto segue:

• docker build: avvia il processo di costruzione di un'immagine Docker.
• -t my-data-science-app: l'opzione -t applica il tag “my-data-science-app” all'immagine.
• .: il punto finale specifica il contesto di build, cioè la directory corrente. Docker userà i file in questa directory per costruire l'immagine.

5. Esegui l'immagine Docker:

Una volta completata la build, puoi eseguire la nuova immagine Docker come container:

sudo docker run -p 8888:8888 my-data-science-app

Vediamo nel dettaglio il comando:

• docker run: esegue un container basato sull'immagine specificata.
• -p 8888:8888: l'opzione -p mappa la porta 8888 della tua macchina locale alla porta 8888 nel container, consentendoti di accedere al server Jupyter Notebook su localhost:8888 nel browser.
• my-data-science-app: specifica l'immagine da eseguire.

Passo 5: Usa Docker Compose

Docker Compose è uno strumento essenziale per gestire applicazioni multi-container. In un progetto di data science, potresti aver bisogno di container separati per componenti diversi, come un Jupyter Notebook, un database per l'archiviazione dei dati e uno strumento di visualizzazione.

Docker Compose ti permette di definire questi servizi in un unico file YAML, rendendo semplice avviare l'intero ambiente di data science con un solo comando.

1. Crea un file docker-compose.yml:

• Nella directory del progetto, crea un file chiamato docker-compose.yml e inserisci le seguenti righe nel file:

version: '3.8'
services:
  jupyter:
        image: jupyter/scipy-notebook:latest
        volumes:
        - ./notebooks:/home/joelwembo/work
        ports:
        - "8888:8888"
        environment:
        - JUPYTER_ENABLE_LAB=yes
 
  postgres:
        image: postgres:13-alpine
        environment:
        POSTGRES_USER: myuser
        POSTGRES_PASSWORD: mypassword
        POSTGRES_DB: mydatabase
        volumes:
        - postgres_data:/var/lib/postgresql/data
        ports:
        - "5432:5432"
 
  redis:
        image: redis:alpine
        ports:
        - "6379:6379"
 
volumes:
  postgres_data:
 

Vediamo cosa fa il file Docker Compose:

• version: '3.8': specifica la versione del formato del file Docker Compose. La 3.8 è una versione comunemente usata che supporta molte funzionalità.
• services:: la sezione services definisce i diversi container (servizi) che compongono l'applicazione.
• jupyter:: questo servizio rappresenta un ambiente Jupyter Notebook essenziale per l'analisi dati interattiva.
• image: jupyter/scipy-notebook:latest: specifica l'immagine Docker da usare per Jupyter Notebook, che include librerie popolari come NumPy, pandas e matplotlib.
• volumes: - ./notebooks:/home/joelwembo/work: monta la directory notebooks sulla tua macchina host in /home/joelwembo/work all'interno del container, permettendoti di preservare e condividere i notebook. Nota: questo è il mio percorso personale e il tuo sarà diverso.
• ports: - "8888:8888": mappa la porta 8888 della macchina host alla porta 8888 del container, la porta predefinita per Jupyter Notebook.
• environment: - JUPYTER_ENABLE_LAB=yes: abilita JupyterLab, un'interfaccia più potente per lavorare con i notebook Jupyter.
• postgres:: questo servizio esegue un database PostgreSQL, spesso usato per archiviare e gestire grandi dataset nei progetti di data science.
• image: postgres:13-alpine: specifica l'immagine Docker di PostgreSQL versione 13, basata sulla leggera distribuzione Alpine Linux.
• environment:: queste variabili d'ambiente configurano il database con utente, password e nome del database.
• volumes: - postgres_data:/var/lib/postgresql/data: monta un volume Docker per conservare i dati del database al di fuori del container, così i tuoi dati non andranno persi quando il container viene fermato.
• ports: - "5432:5432": mappa la porta 5432 della macchina host alla porta 5432 del container, la porta predefinita per PostgreSQL.
• redis:: questo servizio esegue un server Redis, utilizzabile come datastore o cache in-memory veloce.
• image: redis:alpine: specifica l'immagine Redis nella variante leggera Alpine.
• ports: - "6379:6379": mappa la porta 6379 della macchina host alla porta 6379 del container, la porta predefinita per Redis.
• volumes:: questa sezione definisce i volumi con nome che possono essere condivisi tra servizi o conservare i dati tra i riavvii dei container.
• postgres_data:: crea un volume con nome per la persistenza dei dati di PostgreSQL.

Per avviare la tua applicazione multi-container, esegui semplicemente:

sudo docker compose up

Questo comando crea le immagini (se necessario) e avvia i container definiti nel tuo file docker-compose.yml. Avvia sia l'applicazione web sia il servizio Redis, consentendo loro di comunicare come definito.

Hai appena distribuito la tua prima applicazione Docker! Non è fantastico? Ora, vediamo un piano per il tuo apprendimento continuo.

Un esempio di piano di apprendimento per Docker

Ecco un piano settimana per settimana che puoi seguire. Sentiti libero di adattarlo alle tue esigenze specifiche. 

Se ti serve un percorso più definito, lo skill track Containerization and Virtualization with Docker and Kubernetes è perfetto per te. Contiene quattro corsi essenziali.

Settimana 1: Familiarizza con le basi di Docker

• Obiettivo: comprendere i concetti chiave di Docker e i comandi di base.
• Attività:
• Installa Docker e configura Docker Desktop.
• Impara i comandi Docker: docker run, docker ps, docker stop, docker rm, ecc.
• Esegui container semplici per strumenti di esplorazione dati come Ubuntu o Alpine e prova i comandi di base.
• Esplora le immagini Docker ufficiali ed esegui container per strumenti di visualizzazione di base (ad es. un semplice container con matplotlib).
• Risorse: corso Containerization and Virtualization Concepts, corso Introduction to Docker.

Settimana 2: Crea ed esegui immagini Docker per gli strumenti dati

• Obiettivo: imparare a creare e gestire immagini Docker personalizzate.
• Attività:
• Scrivi un Dockerfile per un ambiente base di analisi dati (ad es. Python con Pandas e NumPy).
• Crea l'immagine Docker usando docker build.
• Esegui container dalla tua immagine personalizzata e testa strumenti come Jupyter Notebook.
• Crea Dockerfile per TensorFlow e PostgreSQL, assicurando corretta configurazione e collegamento.
• Risorse: corso Introduction to Docker.

Settimana 3: Esplora Docker Compose

• Obiettivo: comprendere e utilizzare Docker Compose per setup multi-container.
• Attività:
• Installa Docker Compose e apprendi le basi.
• Scrivi file docker-compose.yml per definire applicazioni multi-container.
• Fai pratica con esempi come configurare un'app web con un database backend (ad es. un'app Flask con PostgreSQL).
• Sperimenta con configurazioni diverse e dipendenze tra servizi.
• Risorse: corso Intermediate Docker.

Settimana 4: Approfondisci reti e volumi in Docker

• Obiettivo: padroneggiare le funzionalità di rete e storage di Docker.
• Attività:
• Impara le reti Docker e come crearle (bridge, host, overlay).
• Esercitati a creare reti personalizzate e a collegarvi i container.
• Esplora i volumi Docker per lo storage persistente ed esercitati a crearli e gestirli.
• Implementa una configurazione in cui i container comunicano su una rete personalizzata e usano volumi per la persistenza dei dati.
• Risorse: Intermediate Docker.

Settimana 5: Distribuisci e gestisci container Docker in produzione

• Obiettivo: comprendere il deploy e la gestione dei container in produzione.
• Attività:
• Impara le best practice per distribuire container Docker (ad es. usando Docker Hub o un registro privato).
• Esplora l'orchestrazione con Docker Swarm: creazione e gestione dei servizi.
• Comprendi come scalare i container e gestire i log.
• Sperimenta il deploy di un'applicazione containerizzata in un ambiente di staging o produzione.
• Risorse: Intermediate Docker.

Settimana 6: Introduzione a Kubernetes per l'orchestrazione dei container

• Obiettivo: familiarizzare con Kubernetes per scalare e gestire applicazioni containerizzate.
• Attività:
• Installa e configura un ambiente Kubernetes locale (ad es. Minikube o Kind).
• Impara le basi di Kubernetes: pod, servizi, deployment e namespace.
• Distribuisci una semplice applicazione containerizzata su Kubernetes.
• Esplora come scalare e gestire applicazioni con Kubernetes, concentrandoti sulla gestione di uno strumento containerizzato come Jupyter.
• Risorse: corso Introduction to Kubernetes.

Consigli e modi per imparare Docker

Infine, ecco alcuni consigli e best practice per accelerare il tuo percorso di apprendimento di Docker.

Esercitati regolarmente

La chiave per padroneggiare Docker è la pratica costante e concreta. Inizia lavorando su progetti personali, come containerizzare un semplice sito web o configurare un ambiente di sviluppo locale. 

Man mano che prendi confidenza, mettiti alla prova con attività più complesse, come creare un'applicazione multi-container o distribuire un web server. 

La sperimentazione regolare con casi d'uso diversi — ad esempio creare immagini Docker personalizzate o configurare una pipeline CI/CD — approfondirà la comprensione e ti aiuterà a consolidare i concetti chiave. Inoltre, partecipare a challenge o esercizi online su Docker è un ottimo modo per testare e migliorare le tue competenze in modo strutturato e orientato agli obiettivi.

Usa le risorse online

Le risorse online sono preziose per imparare Docker. La documentazione ufficiale di Docker è un ottimo punto di partenza, con informazioni autorevoli e aggiornate. 

Oltre a questo, ci sono molti corsi completi disponibili su piattaforme come DataCamp, che possono guidarti nel percorso di apprendimento. 

Per chi preferisce imparare in modo visivo, i tutorial su YouTube del canale ufficiale di Docker e di altri formatori offrono contenuti utili e accessibili per rafforzare la comprensione.

Unisciti alla community di Docker

Interagire con la community di Docker è un altro modo potente per far progredire l'apprendimento. Partecipa a forum come Docker Community Forums e Reddit per scambiare idee, fare domande e condividere esperienze con altri studenti e professionisti. 

Partecipare a meetup, webinar o conferenze su Docker è anche un ottimo modo per restare aggiornato sulle tendenze del settore e ampliare la tua rete.

Lavora su progetti open-source

Contribuire a progetti open-source che utilizzano Docker può essere un ottimo modo per acquisire esperienza pratica e reale. 

Siti come GitHub offrono opportunità per collaborare a progetti legati a Docker, permettendoti di imparare dagli altri e applicare le tue competenze in contesti diversi. La collaborazione insita nel lavoro open-source ti espone a approcci e soluzioni differenti, favorendo una comprensione più profonda delle capacità di Docker.

Resta aggiornato

Infine, restare aggiornato con gli ultimi sviluppi di Docker è essenziale per mantenere la padronanza. Tieni d'occhio il blog ufficiale di Docker e le note di rilascio per novità su funzionalità o cambiamenti. Partecipare alle discussioni della community su forum e social media ti informerà anche su tendenze emergenti e best practice, aiutandoti a perfezionare continuamente le tue competenze su Docker.

Con pratica regolare, coinvolgimento attivo nella community e apprendimento continuo, costruirai una solida base su Docker e resterai pronto a gestire gli ultimi sviluppi nel campo.

Conclusione

Docker ha rivoluzionato il deploy delle applicazioni e la gestione dei dati impacchettando applicazioni e dipendenze in container isolati. Questo risolve problemi comuni come le incongruenze dell'ambiente e garantisce flussi di lavoro coerenti, scalabili ed efficienti per i professionisti dei dati.

Questa guida ti ha fornito i passaggi fondamentali per padroneggiare Docker, dai concetti chiave alla pratica sul campo. Per approfondire ulteriormente, valuta di esplorare risorse aggiuntive come i corsi Introduction to Docker e Intermediate Docker su DataCamp. Man mano che avanzi, ampliare le competenze con strumenti di orchestrazione come Kubernetes è altrettanto importante — dai un'occhiata al corso Introduction to Kubernetes per iniziare.

Esercitandoti regolarmente, usando le risorse disponibili e restando attivo nella community, sbloccherai tutto il potenziale di Docker per gestire ambienti dati complessi.