10 idee di progetti Docker: dai principianti agli esperti

Progetti Docker di livello intermedio

I seguenti progetti sono per chi ha una solida comprensione delle basi di Docker. Introdurranno concetti più complessi, come i multi-stage build e le tecniche di ottimizzazione.

Progetto 4: Multi-stage build per un'applicazione Node.js

I multi-stage build aiutano a ridurre le dimensioni delle immagini Docker separando gli ambienti di build e runtime. In questo progetto containerizzerai un'applicazione Node.js usando i multi-stage build.

Livello di difficoltà: Intermedio

Tecnologie utilizzate: Docker, Node.js, Nginx

Istruzioni passo passo

• Crea una semplice app Node.js: scrivi un server Node.js di base che restituisca un semplice messaggio. Ecco un esempio:

const express = require('express');
const app = express();
 
app.get('/', (req, res) => res.send('Hello from Node.js'));
 
app.listen(3000, () => console.log('Server running on port 3000'));

• Scrivi il Dockerfile con multi-stage build: la prima fase compila l'app, la seconda la esegue con un'immagine base più leggera.

# Stage 1: Build
FROM node:14 as build-stage
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
# Add the following line if there's a build step for the app
# RUN npm run build

# Stage 2: Run
FROM node:14-slim
WORKDIR /app
COPY --from=build-stage /app .
EXPOSE 3000
ENV NODE_ENV=production
CMD ["node", "server.js"]

• Crea l'immagine:

docker build -t node-multi-stage .

• Esegui il container:

docker run -p 3000:3000 node-multi-stage

Progetto 5: Dockerizzare un modello di machine learning con TensorFlow

Questo progetto prevede la containerizzazione di un modello di machine learning usando TensorFlow. L'obiettivo è creare un ambiente portabile in cui eseguire modelli TensorFlow su vari sistemi senza preoccuparti della configurazione sottostante.

Livello di difficoltà: Intermedio

Tecnologie utilizzate: Docker, TensorFlow, Python

Istruzioni passo passo

• Installa TensorFlow in uno script Python: crea uno script Python model.py che carica ed esegue un modello TensorFlow pre-addestrato:

import tensorflow as tf
model = tf.keras.applications.MobileNetV2(weights='imagenet')
print("Model loaded successfully")

• Scrivi il Dockerfile: definisci l'ambiente per TensorFlow dentro Docker:

FROM tensorflow/tensorflow:latest
WORKDIR /app
COPY . .
CMD ["python", "model.py"]

• Crea l'immagine:

docker build -t tensorflow-model .

• Esegui il container:

docker run tensorflow-model

Progetto 6: Creare un ambiente di data science con Jupyter e Docker

Questo progetto si concentra sulla creazione di un ambiente di data science riproducibile usando Docker e i notebook Jupyter. L'ambiente includerà librerie Python popolari come pandas, NumPy e scikit-learn.

Livello di difficoltà: Intermedio

Tecnologie utilizzate: Docker, Jupyter, Python, scikit-learn

Istruzioni passo passo

• Crea il file docker-compose.yml: definisci il servizio Jupyter Notebook e le librerie necessarie. Ecco un esempio:

version: '3'
services:
  jupyter:
    	image: jupyter/scipy-notebook
    	ports:
    	- "8888:8888"
    	volumes:
    	- ./notebooks:/home/joelwembo/work

• Avvia Jupyter Notebook: usa Docker Compose per avviare Jupyter Notebook.

docker-compose up

• Accedi a Jupyter Notebook: apri il browser e vai su http://localhost:8888.

Progetti Docker di livello avanzato

Questi progetti avanzati si concentrano su applicazioni reali e concetti Docker evoluti, come pipeline di deep learning e pipeline di dati automatizzate.

Progetto 7: Ridurre le dimensioni di un'immagine Docker per un'applicazione Python

In questo progetto ottimizzerai un'immagine Docker per un'applicazione Python usando immagini base minimali come Alpine Linux e implementando multi-stage build per mantenere l'immagine il più piccola possibile.

Livello di difficoltà: Avanzato

Tecnologie utilizzate: Docker, Python, Alpine Linux

Istruzioni passo passo

• Scrivi lo script Python: crea uno script che analizzi i dati usando pandas. Ecco un esempio:

import pandas as pd
df = pd.read_csv('data.csv')
print(df.head())

• Ottimizza il Dockerfile: usa multi-stage build e Alpine Linux per creare un'immagine leggera.

# Stage 1: Build stage
FROM python:3.9-alpine as build-stage
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY script.py .

# Stage 2: Run stage
FROM python:3.9-alpine
WORKDIR /app
COPY --from=build-stage /app/script.py .
CMD ["python", "script.py"]

• Crea l'immagine:

docker build -t optimized-python-app .

Progetto 8: Dockerizzare una pipeline di deep learning con PyTorch

Questo progetto prevede la containerizzazione di una pipeline di deep learning usando PyTorch. Il focus è ottimizzare il Dockerfile per prestazioni e dimensioni, rendendo facile eseguire modelli di deep learning in ambienti diversi.

Livello di difficoltà: Avanzato

Tecnologie utilizzate: Docker, PyTorch, Python

Istruzioni passo passo

• Installa PyTorch in uno script Python: crea uno script che carichi un modello PyTorch pre-addestrato ed esegua inferenza. Ecco un esempio:

import torch
model = torch.hub.load('pytorch/vision', 'resnet18', pretrained=True)
print("Model loaded successfully")

• Scrivi il Dockerfile: definisci l'ambiente per PyTorch:

FROM pytorch/pytorch:1.9.0-cuda11.1-cudnn8-runtime
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY model.py .
CMD ["python", "model.py"]

• Crea l'immagine:

docker build -t pytorch-model .

• Esegui il container:

docker run pytorch-model 

Progetto 9: Automatizzare pipeline di dati con Apache Airflow e Docker

In questo progetto configurerai e containerizzerai un ambiente Apache Airflow per automatizzare pipeline di dati. Apache Airflow è uno strumento popolare per orchestrare workflow complessi, ampiamente usato nel data engineering.

Livello di difficoltà: Avanzato

Tecnologie utilizzate: Docker, Apache Airflow, Python, PostgreSQL

Istruzioni passo passo

• Crea il file docker-compose.yml: definisci i servizi Airflow e il database PostgreSQL:

version: '3'
services:
  postgres:
    image: postgres:latest
    environment:
      POSTGRES_USER: airflow
      POSTGRES_PASSWORD: airflow
      POSTGRES_DB: airflow
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  webserver:
    image: apache/airflow:latest
    environment:
      AIRFLOW__CORE__SQL_ALCHEMY_CONN: postgresql+psycopg2://airflow:airflow@postgres/airflow
      AIRFLOW__CORE__EXECUTOR: LocalExecutor
    depends_on:
      - postgres
    ports:
      - "8080:8080"
    volumes:
      - ./dags:/opt/airflow/dags
    command: ["webserver"]

  scheduler:
    image: apache/airflow:latest
    environment:
      AIRFLOW__CORE__SQL_ALCHEMY_CONN: postgresql+psycopg2://airflow:airflow@postgres/airflow
      AIRFLOW__CORE__EXECUTOR: LocalExecutor
    depends_on:
      - postgres
      - webserver
    volumes:
      - ./dags:/opt/airflow/dags
    command: ["scheduler"]

volumes:
  postgres_data:

• Avvia l'ambiente Airflow: usa Docker Compose per avviare l'ambiente Airflow:

docker-compose up

• Accedi alla UI di Airflow: Apri il browser e vai su http://localhost:8080.

Progetto 10: Distribuire un'API di data science con FastAPI e Docker

Crea e distribuisci un'API di data science usando FastAPI. Containerizzerai l'API con Docker concentrandoti sull'ottimizzazione per ambienti di produzione.

Livello di difficoltà: Avanzato

Tecnologie utilizzate: Docker, FastAPI, Python, scikit-learn

Istruzioni passo passo

• Scrivi l'applicazione FastAPI: crea una semplice API che usa un modello di machine learning per le predizioni. Ecco un esempio:

from fastapi import FastAPI
import pickle
 
app = FastAPI()
with open("model.pkl", "rb") as f:
   model = pickle.load(f)
 
@app.post("/predict/")
def predict(data: list):
   return {"prediction": model.predict(data)}

• Scrivi il Dockerfile: crea un Dockerfile che definisca l'ambiente per FastAPI:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

• Crea l'immagine:

docker build -t fastapi-app .

• Esegui il container:

docker run -p 8000:8000 fastapi-app

Consigli per lavorare sui progetti Docker

Mentre affronti questi progetti, tieni a mente i seguenti suggerimenti:

• Parti in piccolo: inizia con progetti non troppo complessi e poi passa a compiti più articolati. Costruire fiducia con attività più semplici è fondamentale.
• Documenta i tuoi progressi: tieni un registro dettagliato dei progetti per monitorare l'apprendimento e usarlo come riferimento in futuro.
• Unisciti alle community Docker: partecipa a forum online e meetup locali per condividere esperienze, fare domande e imparare dagli altri.
• Sperimenta e personalizza: non aver paura di modificare i progetti, provare approcci diversi ed esplorare nuove funzionalità di Docker.
• Continua a imparare: Amplia le tue conoscenze su Docker esplorando argomenti e strumenti avanzati come Kubernetes, Docker Swarm o l'architettura a microservizi.

Conclusione

Padroneggiare Docker significa andare oltre i soli comandi e configurazioni. Si tratta di capire come Docker si inserisce nello sviluppo di applicazioni moderne, nei flussi di lavoro di data science e nella gestione dell'infrastruttura.

I progetti che ho condiviso in questa guida offrono spunti per costruire le competenze di base e l'esperienza pratica necessarie per eccellere in scenari reali.

A questo punto, ti suggerisco di consolidare le conoscenze seguendo questi corsi:

• Intermediate Docker
• Introduction to Kubernetes