Introduzione a Podman per il Machine Learning: semplificare i workflow MLOps

Ogni sviluppatore e ingegnere delle operazioni IT conosce Docker per creare e distribuire applicazioni, in locale o nel cloud. Tuttavia, come developer o ingegnere di MLOps, potresti voler ottimizzare le risorse, aumentare la sicurezza e migliorare l’integrazione con il sistema. Podman offre un’alternativa interessante. È uno strumento gratuito e open-source che funge da alternativa a Docker e Docker Desktop.

In questo tutorial, vedremo cos’è Podman, le differenze tra Podman e Docker e come installare e usare Podman. Inoltre, vedremo come addestrare, valutare e distribuire modelli di machine learning in locale utilizzando Dockerfile e i comandi Podman.

Immagine dell’autore

Che cos’è Podman?

Podman è uno strumento open-source per la gestione dei container, progettato per offrire a sviluppatori e ingegneri di machine learning un’esperienza fluida e sicura. A differenza di Docker, Podman funziona senza demone (daemonless), migliorando sicurezza e flessibilità grazie alla possibilità di eseguire container come processi rootless. Questa caratteristica chiave consente di eseguire i container senza privilegi di root, riducendo al minimo le potenziali vulnerabilità.

Podman è pienamente compatibile con gli standard OCI (Open Container Initiative), garantendo che container e immagini creati con Podman possano essere facilmente integrati con altri strumenti e piattaforme conformi a OCI come runc, Buildah e Skopeo. Inoltre, Podman supporta la creazione e la gestione dei pod, ovvero gruppi di container che condividono lo stesso namespace di rete, in modo simile ai pod di Kubernetes.

Uno degli aspetti migliori di Podman è che offre un’esperienza simile a Docker. La riga di comando è comparabile a quella di Docker e puoi anche scaricare immagini da Docker Hub. Questa somiglianza facilita la transizione per chi conosce già Docker, offrendo al contempo funzionalità avanzate in linea con le esigenze in evoluzione dello sviluppo e del deployment di applicazioni containerizzate.

Podman è solo uno degli strumenti nell’arsenale degli MLOps. Scopri tutti i tipi di tool usati nell’ecosistema MLOps leggendo il blog I 25 migliori strumenti MLOps da conoscere nel 2025.

Confronto Docker vs Podman

Docker e Podman sono strumenti di gestione dei container di primo piano, ciascuno con caratteristiche e capacità specifiche. Questo confronto esaminerà le differenze e ti aiuterà a decidere quale si adatta meglio alle tue esigenze.

La scelta tra Docker e Podman dipende in gran parte dai requisiti specifici del progetto, soprattutto in termini di sicurezza, compatibilità e esigenze di orchestrazione. 

Docker resta una scelta solida per pipeline CI/CD consolidate e una gestione completa dei container, mentre Podman offre un’alternativa sicura e leggera per ambienti che privilegiano sicurezza e operazioni rootless. Offre anche tempi di avvio più rapidi, ideali per deployment su larga scala. 

Scopri Docker per la Data Science leggendo il nostro articolo introduttivo, con codice di esempio ed esempi pratici.

Installare Podman 

Per prima cosa, scarica e installa il pacchetto Podman Desktop dal sito ufficiale. 

Fonte: Podman

L’installazione è semplice e veloce. In pochi minuti ti troverai nella schermata di avvio, dove ti verrà chiesto di installare estensioni opzionali. 

Se non hai WSL su Windows, lo installerà automaticamente.

Successivamente, configura la macchina Podman. 

Rispetto a Docker, non serve configurare una macchina. Tuttavia, con Podman puoi gestire più macchine che eseguono diversi container contemporaneamente, migliorando la gestione delle risorse. 

La nostra macchina è attiva e funzionante, pronta per creare immagini ed eseguire i container.

Per verificare che Podman funzioni correttamente, scaricheremo un’immagine di esempio da quay.io ed eseguiremo il container.

$ podman run quay.io/podman/hello

La macchina Podman ha scaricato correttamente l’immagine ed eseguito il container, mostrando i log.

Trying to pull quay.io/podman/hello:latest...
Getting image source signatures
Copying blob sha256:81df7ff16254ed9756e27c8de9ceb02a9568228fccadbf080f41cc5eb5118a44
Copying config sha256:5dd467fce50b56951185da365b5feee75409968cbab5767b9b59e325fb2ecbc0
Writing manifest to image destination
!... Hello Podman World ...!

         .--"--.
       / -     - \
      / (O)   (O) \
   ~~~| -=(,Y,)=- |
    .---. /`  \   |~~
 ~/  o  o \~~~~.----. ~~
  | =(X)= |~  / (O (O) \
   ~~~~~~~  ~| =(Y_)=-  |
  ~~~~    ~~~|   U      |~~

Project:   https://github.com/containers/podman
Website:   https://podman.io
Desktop:   https://podman-desktop.io
Documents: https://docs.podman.io
YouTube:   https://youtube.com/@Podman
X/Twitter: @Podman_io
Mastodon:  @Podman_io@fosstodon.org

Creare un progetto MLOps con Podman

In questo progetto MLOps, automatizzeremo l’addestramento e la valutazione del modello e lo esporremo tramite Dockerfile e Podman. Sarà simile a Docker, ma useremo la CLI di Podman per creare le immagini e poi eseguire il container. 

Se questi concetti sono nuovi per te, puoi imparare le basi di MLOps seguendo il corso MLOps Concepts.

1. Configurare il progetto di machine learning

Per configurare il progetto di machine learning, dobbiamo creare uno script di training e uno di serving, oltre a un file requirements.txt per installare i pacchetti Python.

Lo script di training in Python caricherà il dataset di classificazione del credit score, lo processerà, lo codificherà e addestrerà il modello. Eseguiremo anche la valutazione del modello. Alla fine salveremo la pipeline di preprocessing e training insieme al modello in formato pickle.

src/train.py: 

# src/train.py

import os
import pickle

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.ensemble import RandomForestClassifier
from sklearn.impute import SimpleImputer
from sklearn.metrics import (
    accuracy_score,
    classification_report,
    confusion_matrix,
    roc_auc_score,
)
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder


def load_data():
    data_path = "data/train.csv"
    df = pd.read_csv(data_path,low_memory=False)
    print("Data loaded successfully!")
    return df


def preprocess_data(df):
    # Drop unnecessary columns
    df = df.drop(columns=["ID", "Customer_ID", "SSN", "Name", "Month"])

    # Drop rows with missing values
    df = df.dropna()

    # Convert data types
    # Convert the 'Age' column to numeric, setting errors='coerce' to handle non-numeric values
    df["Age"] = pd.to_numeric(df["Age"], errors="coerce")

    # Filter the DataFrame to include only rows where 'Age' is between 1 and 60
    df = df[(df["Age"] >= 1) & (df["Age"] <= 60)]

    df["Annual_Income"] = pd.to_numeric(df["Annual_Income"], errors="coerce")
    df["Monthly_Inhand_Salary"] = pd.to_numeric(
        df["Monthly_Inhand_Salary"], errors="coerce"
    )

    # Separate features and target
    X = df.drop("Credit_Score", axis=1)
    y = df["Credit_Score"]

    print("Data preprocessed successfully!")
    return X, y


def encode_data(X):
    # Identify categorical and numerical features
    categorical_features = [
        "Occupation",
        "Credit_Mix",
        "Payment_of_Min_Amount",
        "Payment_Behaviour",
        "Type_of_Loan",
    ]
    numerical_features = X.select_dtypes(include=["int64", "float64"]).columns.tolist()

    # Define preprocessing steps
    numerical_transformer = SimpleImputer(strategy="median")

    categorical_transformer = Pipeline(
        steps=[
            ("imputer", SimpleImputer(strategy="most_frequent")),
            ("onehot", OneHotEncoder(handle_unknown="ignore")),
        ]
    )

    preprocessor = ColumnTransformer(
        transformers=[
            ("num", numerical_transformer, numerical_features),
            ("cat", categorical_transformer, categorical_features),
        ]
    )

    return preprocessor


def split_data(X, y):
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )
    return X_train, X_test, y_train, y_test


def train_model(X_train, y_train, preprocessor):
    # Create a pipeline with preprocessing and model
    clf = Pipeline(
        steps=[
            ("preprocessor", preprocessor),
            ("classifier", RandomForestClassifier(n_estimators=100)),
        ]
    )

    # Train the model
    clf.fit(X_train, y_train)

    # Return the trained model
    return clf


def evaluate_model(clf, X_test, y_test):
    # Predict and evaluate
    y_pred = clf.predict(X_test)
    acc = accuracy_score(y_test, y_pred)
    report = classification_report(y_test, y_pred, labels=["Poor", "Standard", "Good"])
    cm = confusion_matrix(y_test, y_pred, labels=["Poor", "Standard", "Good"])

    # Calculate AUC score
    y_test_encoded = y_test.replace({"Poor": 0, "Standard": 1, "Good": 2})
    y_pred_proba = clf.predict_proba(X_test)
    auc_score = roc_auc_score(y_test_encoded, y_pred_proba, multi_class="ovr")

    # Print metrics
    print("Model Evaluation Metrics:")
    print(f"Accuracy: {acc}")
    print(f"AUC Score: {auc_score}")
    print("Classification Report:")
    print(report)

    # Plot confusion matrix
    plt.figure(figsize=(8, 6))
    plt.imshow(cm, interpolation="nearest", cmap=plt.cm.Blues)
    plt.title("Confusion Matrix")
    plt.colorbar()
    tick_marks = np.arange(3)
    plt.xticks(tick_marks, ["Poor", "Standard", "Good"], rotation=45)
    plt.yticks(tick_marks, ["Poor", "Standard", "Good"])
    plt.ylabel("True label")
    plt.xlabel("Predicted label")
    plt.tight_layout()
    cm_path = os.path.join("model", "confusion_matrix.png")
    plt.savefig(cm_path)
    print(f"Confusion matrix saved to {cm_path}")


def save_model(clf):
    model_dir = "model"
    os.makedirs(model_dir, exist_ok=True)
    model_path = os.path.join(model_dir, "model.pkl")

    # Save the trained model
    with open(model_path, "wb") as f:
        pickle.dump(clf, f)
    print(f"Model saved to {model_path}")


def main():
    # Execute steps
    df = load_data()
    X, y = preprocess_data(df)
    preprocessor = encode_data(X)
    X_train, X_test, y_train, y_test = split_data(X, y)
    clf = train_model(X_train, y_train, preprocessor)
    evaluate_model(clf, X_test, y_test)
    save_model(clf)


if __name__ == "__main__":
    main()

Lo script di serving del modello caricherà la pipeline salvata tramite il file del modello, creerà una funzione per richieste POST che accetta una lista di dizionari dall’utente, la converte in un DataFrame, la fornisce al modello per generare le predizioni e poi restituisce l’etichetta prevista. Usiamo FastAPI come framework, che ci permette di servire il modello con poche righe di codice.

src/app.py:

# src/app.py

import pickle
from fastapi import FastAPI
from pydantic import BaseModel
import pandas as pd
import os

# Load the trained model
model_path = os.path.join("model", "model.pkl")
with open(model_path, "rb") as f:
    model = pickle.load(f)

app = FastAPI()


class InputData(BaseModel):
    data: list  # List of dictionaries representing feature values


@app.post("/predict")
def predict(input_data: InputData):
    # Convert input data to DataFrame
    X_new = pd.DataFrame(input_data.data)
    # Ensure the columns match the training data
    prediction = model.predict(X_new)
    # Return predictions
    return {"prediction": prediction.tolist()}

Dobbiamo creare un file requirements.txt che includa tutti i pacchetti Python necessari per eseguire gli script sopra. Questo file verrà usato per configurare un ambiente di esecuzione nel container Docker, assicurando che i nostri script Python girino senza problemi.

requirements.txt: 

fastapi
uvicorn[standard]
numpy
pandas
scikit-learn
pydantic
matplotlib

2. Creare un Dockerfile

Crea un “Dockerfile” e aggiungi il seguente codice. 

Ecco i passaggi eseguiti da questo Dockerfile:

1. Usa come base l’immagine Python 3.9 slim
2. Imposta /app come working directory
3. Installa le dipendenze Python da requirements.txt
4. Copia il codice sorgente e i file dei dati nel container
5. Crea la cartella model ed esegue lo script di training
6. Espone la porta 8000 per l’API
7. Avvia l’app FastAPI usando il server uvicorn sulla porta 8000

# Dockerfile

FROM python:3.9-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy the application code
COPY ./src/ ./src/
COPY ./data/ ./data/

# Ensure the model directory exists and is copied
RUN mkdir -p model

# Run the training script during the build
RUN python src/train.py

# Expose the port for the API
EXPOSE 8000


# Run the FastAPI app
CMD ["uvicorn", "src.app:app", "--host", "0.0.0.0", "--port", "8000"]

Il tuo workspace locale dovrebbe essere organizzato così: 

1. Una cartella data contenente tutti i file CSV
2. Una cartella models
3. Una cartella src che contiene gli script Python
4. Nella directory principale, includi un file requirements.txt e un Dockerfile

I file rimanenti sono componenti aggiuntivi per l’automazione e le operazioni con Git.

3. Creare l’immagine Docker con Podman

Creare l’immagine Docker è semplice: ti basta usare il comando build con il nome della tua immagine Docker e la directory corrente in cui si trova il Dockerfile.

$ podman build -t mlops_app .

Lo strumento di build eseguirà in sequenza tutti i comandi nel Dockerfile, dall’impostazione dell’ambiente fino al serving dell’applicazione di machine learning. 

Possiamo anche vedere nei log i risultati della valutazione del modello. Il modello ha un’accuratezza del 75% e un punteggio ROC AUC di 0,89, considerato nella media.

STEP 1/11: FROM python:3.9-slim
STEP 2/11: WORKDIR /app
--> Using cache 72ac9e49ae29da1ff19e118653efca17e7a489ae9e7ead917c83d942a3ea4e13
--> 72ac9e49ae29
STEP 3/11: COPY requirements.txt .
--> Using cache 3a05ca95caaf98c448c53a796714328bf9f7cff7896cce348f84a26b8d0dae61
--> 3a05ca95caaf
STEP 4/11: RUN pip install --no-cache-dir -r requirements.txt
--> Using cache 28109d1183449396a5df0006ab603dd5cf2aa2c06a810bdc6bcf0f843f855ee0
--> 28109d118344
STEP 5/11: COPY ./src/ ./src/
--> f814f699c58a
STEP 6/11: COPY ./data/ ./data/
--> 922550900cd0
STEP 7/11: RUN mkdir -p model
--> 36fc01f2d169
STEP 8/11: RUN python src/train.py
Data loaded successfully!
Data preprocessed successfully!
Data encoded successfully!
Data split successfully!
Model trained successfully!
Model Evaluation Metrics:
Accuracy: 0.7546181417149159
ROC AUC Score: 0.8897184704689612
Classification Report:
              precision    recall  f1-score   support

        Good       0.71      0.67      0.69      1769
        Poor       0.75      0.76      0.75      3403
    Standard       0.77      0.78      0.78      5709

    accuracy                           0.75     10881
   macro avg       0.74      0.74      0.74     10881
weighted avg       0.75      0.75      0.75     10881

Model saved to model/model.pkl
--> 5d4777c08580
STEP 9/11: EXPOSE 8000
--> 7bb09a613e7f
STEP 10/11: WORKDIR /app/src
--> 06b6394c2e2d
STEP 11/11: CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]
COMMIT mlops-app
--> 9a7a42b03664
Successfully tagged localhost/mlops-app:latest
9a7a42b03664f1e4631330cd682cb2de26e513c5d776fa2ce2042b3bb9455e14

Se apri l’applicazione Podman Desktop e clicchi sulla scheda “Images”, vedrai che l’immagine mlops_app è stata creata correttamente.

Dai un’occhiata alla cheat sheet Docker per la Data Science per imparare tutti i comandi Docker rilevanti. Ti basta sostituire il primo comando, docker, con podman.

4. Eseguire il container Docker con Podman

Useremo il comando run per avviare un container chiamato "mlops_container" dall’immagine mlops-app. Lo faremo in modalità detached (-d), mappando la porta 8000 del container sulla porta 8000 della macchina host. Questa configurazione consente di accedere all’app FastAPI dall’esterno del container. 

$ podman run -d --name mlops_container -p 8000:8000 mlops-app  

Per visualizzare tutti i log di "mlops_container", usa il comando logs.

$ podman logs -f mlops_container    

Output:                                                                  

INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
INFO:     10.88.0.1:36886 - "POST /predict HTTP/1.1" 200 OK

Puoi anche aprire l’app Podman Desktop e cliccare sulla scheda “Containers” per visualizzare i container in esecuzione.

Per vedere i log in Podman Desktop, clicca su “mlops_container” e poi seleziona la scheda “Terminal”.

5. Testare il server di inferenza ML

Testeremo ora l’applicazione distribuita accedendo alla Swagger UI interattiva all’indirizzo: http://localhost:8000/docs. La Swagger UI offre un’interfaccia intuitiva che permette di esplorare tutti gli endpoint disponibili.

Possiamo anche testare l’API usando il comando CURL nel terminale. 

$ curl -X POST "http://localhost:8000/predict" \
     -H "Content-Type: application/json" \
     -d '{
           "data": [
             {
               "Age": 35,
               "Occupation": "Engineer",
               "Annual_Income": 85000,
               "Monthly_Inhand_Salary": 7000,
               "Num_Bank_Accounts": 2,
               "Num_Credit_Card": 3,
               "Interest_Rate": 5,
               "Num_of_Loan": 1,
               "Type_of_Loan": "Personal Loan",
               "Delay_from_due_date": 2,
               "Num_of_Delayed_Payment": 1,
               "Changed_Credit_Limit": 15000,
               "Num_Credit_Inquiries": 2,
               "Credit_Mix": "Good",
               "Outstanding_Debt": 10000,
               "Credit_Utilization_Ratio": 30,
               "Credit_History_Age": 15,
               "Payment_of_Min_Amount": "Yes",
               "Total_EMI_per_month": 500,
               "Amount_invested_monthly": 1000,
               "Payment_Behaviour": "Regular",
               "Monthly_Balance": 5000
             }
           ]
         }'

Il server FastAPI funziona correttamente, elabora con successo l’input dell’utente e restituisce una predizione accurata.

{"prediction":["Good"]}

6. Arrestare e rimuovere il container

Dopo aver sperimentato con l’API, arresteremo il container usando il comando stop.

$ podman stop mlops_container 

Possiamo anche rimuovere il container con il comando rm, liberando risorse di sistema. Prima di poterlo rimuovere, il container deve essere arrestato. 

$ podman rm mlops_container     

7. Rimuovere l’immagine

Per rimuovere l’immagine del container memorizzata localmente chiamata "mlops-app" useremo il comando rmi.

$ podman rmi mlops-app 

Se riscontri problemi nell’eseguire il codice sopra o nel creare il tuo Dockerfile, consulta il repository GitHub kingabzpro/mlops-with-podman. Include una guida all’uso e tutti i file necessari per eseguire il codice sul tuo sistema.

Il prossimo passo nel tuo percorso di apprendimento è provare a realizzare 10 idee di progetti Docker, dal livello principiante all’avanzato, ma con Podman. Ti aiuterà a comprendere meglio l’ecosistema Podman.

Conclusione

Podman offre un’alternativa interessante a Docker per alcuni casi d’uso, ma molti sviluppatori continuano a preferire Docker Desktop e CLI, soprattutto grazie alle ampie integrazioni e agli strumenti user-friendly di Docker. 

Tuttavia, per un progetto MLOps semplice, gli ingegneri potrebbero optare per Podman, che offre un setup leggero e facile rispetto a Docker Desktop.

In questo tutorial, abbiamo esplorato Podman, un popolare strumento di gestione dei container, confrontandolo con Docker e mostrando come installare Podman Desktop. Ti guidiamo anche in un progetto MLOps con Podman, dalla creazione di un Dockerfile, alla build di un’immagine, fino all’esecuzione di un container. Iniziare con Podman è semplice e, se conosci già Docker, apprezzerai la transizione senza intoppi.

Segui il corso MLOps Deployment and LifeCycling per esplorare il moderno framework MLOps, analizzando il ciclo di vita e il deployment dei modelli di machine learning.