Giới thiệu Podman cho Machine Learning: Tinh gọn quy trình MLOps

Hầu như mọi nhà phát triển và kỹ sư vận hành CNTT đều quen thuộc với Docker để xây dựng và triển khai ứng dụng, dù là cục bộ hay trên đám mây. Tuy nhiên, với vai trò nhà phát triển hoặc kỹ sư vận hành machine learning, bạn có thể đang tìm cách tối ưu tài nguyên, tăng cường bảo mật và cải thiện khả năng tích hợp hệ thống. Podman là một lựa chọn đáng cân nhắc. Đây là công cụ miễn phí, mã nguồn mở, thay thế cho Docker và Docker Desktop.

Trong hướng dẫn này, chúng ta sẽ tìm hiểu Podman là gì, sự khác nhau giữa Podman và Docker, cũng như cách cài đặt và sử dụng Podman. Ngoài ra, chúng ta sẽ thực hành huấn luyện, đánh giá và triển khai mô hình machine learning cục bộ bằng Dockerfile và các lệnh Podman.

Ảnh: Tác giả

Podman là gì?

Podman là công cụ quản lý container mã nguồn mở, mang đến trải nghiệm liền mạch và an toàn cho nhà phát triển và kỹ sư machine learning. Khác với Docker, Podman hoạt động không cần daemon (daemonless), tăng cường bảo mật và linh hoạt bằng cách cho phép chạy container dưới dạng tiến trình không cần quyền root (rootless). Tính năng then chốt này giúp Podman chạy container mà không yêu cầu đặc quyền root, từ đó giảm thiểu lỗ hổng tiềm ẩn.

Podman tương thích hoàn toàn với các tiêu chuẩn OCI (Open Container Initiative), đảm bảo container và image tạo bằng Podman có thể tích hợp dễ dàng với các công cụ và nền tảng tuân thủ OCI khác như runc, Buildah và Skopeo. Bên cạnh đó, Podman hỗ trợ tạo và quản lý pod, là nhóm các container chia sẻ cùng không gian tên mạng, tương tự pod trong Kubernetes.

Một điểm hấp dẫn khi dùng Podman là trải nghiệm rất giống Docker. Giao diện dòng lệnh tương đương Docker và bạn cũng có thể kéo (pull) image từ Docker Hub. Sự tương đồng này cho phép những ai quen Docker chuyển đổi dễ dàng, đồng thời vẫn có các tính năng nâng cao để đáp ứng nhu cầu phát triển và triển khai ứng dụng dạng container ngày càng cao.

Podman chỉ là một trong nhiều công cụ trong bộ công cụ MLOps. Tìm hiểu toàn bộ các loại công cụ trong hệ sinh thái MLOps qua bài viết 25 công cụ MLOps hàng đầu bạn cần biết vào năm 2025.

So sánh Docker và Podman

Docker và Podman là những công cụ quản lý container nổi bật, mỗi bên có đặc điểm và khả năng riêng. Phần so sánh này sẽ xem xét sự khác biệt và giúp bạn quyết định công cụ phù hợp nhất với nhu cầu của mình.

Việc lựa chọn giữa Docker và Podman phần lớn phụ thuộc vào yêu cầu cụ thể của dự án, đặc biệt về bảo mật, tính tương thích và nhu cầu điều phối. 

Docker vẫn là lựa chọn mạnh mẽ cho các pipeline CI/CD đã ổn định và quản lý container toàn diện, trong khi Podman mang lại lựa chọn thay thế an toàn, nhẹ cho môi trường ưu tiên bảo mật và vận hành rootless. Nó cũng cho thời gian khởi động nhanh hơn, lý tưởng cho triển khai quy mô lớn. 

Khám phá Docker cho Khoa học Dữ liệu qua bài viết nhập môn của chúng tôi, kèm mã mẫu và ví dụ.

Cài đặt Podman 

Đầu tiên, bạn tải và cài đặt gói Podman Desktop tại trang web chính thức. 

Nguồn: Podman

Quá trình cài đặt đơn giản và nhanh chóng. Chỉ sau vài phút, bạn sẽ thấy màn hình bắt đầu, nơi có thể cài thêm các tiện ích mở rộng tùy chọn. 

Nếu bạn chưa có WSL trên Windows, hệ thống sẽ tự động cài đặt WSL.

Tiếp theo, thiết lập máy Podman. 

So với Docker, bạn không cần thiết lập máy. Tuy vậy, trong Podman, bạn có thể quản lý nhiều máy xử lý các container khác nhau đồng thời, cho phép quản lý tài nguyên hiệu quả hơn. 

Máy của chúng ta đã khởi động, sẵn sàng tạo image và chạy container.

Để xác nhận Podman hoạt động chính xác, chúng ta sẽ kéo một image mẫu từ quay.io và chạy container.

$ podman run quay.io/podman/helloĐược hỗ trợ bởi

Máy Podman đã kéo image và chạy container thành công, hiển thị 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:  @[email protected]Được hỗ trợ bởi

Xây dựng dự án MLOps với Podman

Trong dự án MLOps này, chúng ta sẽ tự động hóa việc huấn luyện và đánh giá mô hình, đồng thời phục vụ mô hình bằng Dockerfile và Podman. Cách làm tương tự Docker, nhưng chúng ta sẽ dùng CLI của Podman để build image rồi chạy container. 

Nếu bạn mới làm quen các khái niệm, hãy học các nền tảng MLOps qua khóa học MLOps Concepts.

1. Thiết lập dự án machine learning

Để thiết lập dự án machine learning, chúng ta cần tạo script huấn luyện và phục vụ, cùng tệp requirements.txt để cài đặt các gói Python.

Script huấn luyện Python sẽ tải bộ dữ liệu phân loại điểm tín dụng, xử lý, mã hóa và huấn luyện mô hình. Chúng ta cũng sẽ đánh giá mô hình. Cuối cùng, lưu toàn bộ pipeline tiền xử lý và huấn luyện cùng mô hình dưới định dạng 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()
Được hỗ trợ bởi

Script phục vụ mô hình sẽ tải pipeline mô hình đã lưu, tạo hàm POST nhận danh sách các dictionary từ người dùng, chuyển thành DataFrame, đưa vào mô hình để sinh dự đoán, rồi trả về nhãn dự đoán. Chúng ta dùng FastAPI làm framework API, cho phép phục vụ mô hình chỉ với vài dòng mã.

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()}



Được hỗ trợ bởi

Chúng ta cần tạo tệp requirements.txt liệt kê tất cả gói Python cần thiết để chạy các script trên. Tệp này sẽ được dùng để thiết lập môi trường chạy trong container Docker, đảm bảo thực thi trơn tru các script Python.

requirements.txt: 

fastapi
uvicorn[standard]
numpy
pandas
scikit-learn
pydantic
matplotlibĐược hỗ trợ bởi

2. Tạo Dockerfile

Tạo tệp “Dockerfile” và thêm đoạn mã sau. 

Dockerfile này thực hiện các bước sau:

1. Dùng image Python 3.9 slim làm nền tảng
2. Thiết lập /app làm thư mục làm việc
3. Cài đặt phụ thuộc Python từ requirements.txt
4. Sao chép mã nguồn và dữ liệu vào container
5. Tạo thư mục model và chạy script huấn luyện
6. Mở cổng 8000 cho API
7. Khởi chạy ứng dụng FastAPI bằng máy chủ uvicorn trên cổng 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"]Được hỗ trợ bởi

Không gian làm việc cục bộ của bạn nên được tổ chức như sau: 

1. Thư mục data chứa tất cả tệp CSV
2. Thư mục models
3. Thư mục src chứa các script Python
4. Trong thư mục gốc, có requirements.txt và Dockerfile

Các tệp còn lại là thành phần bổ trợ cho tự động hóa và thao tác Git.

3. Build Docker image với Podman

Việc build Docker image rất đơn giản: chỉ cần dùng lệnh build với tên image Docker của bạn và thư mục hiện tại chứa Dockerfile.

$ podman build -t mlops_app .Được hỗ trợ bởi

Công cụ build sẽ thực thi tuần tự mọi lệnh trong Dockerfile, từ thiết lập môi trường đến phục vụ ứng dụng machine learning. 

Chúng ta cũng có thể thấy log chứa kết quả đánh giá mô hình. Mô hình đạt độ chính xác 75% và điểm ROC AUC là 0,89, được xem là mức trung bình.

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Được hỗ trợ bởi

Nếu mở ứng dụng Podman Desktop và vào thẻ “Images”, bạn sẽ thấy image mlops_app đã được tạo thành công.

Xem cheat sheet Docker cho Khoa học Dữ liệu để học các lệnh Docker liên quan. Chỉ cần thay lệnh đầu tiên, docker, bằng podman.

4. Chạy Docker Container với Podman

Chúng ta sẽ dùng lệnh run để khởi chạy một container tên "mlops_container" từ image mlops-app. Lệnh chạy ở chế độ nền (-d), ánh xạ cổng 8000 của container sang cổng 8000 trên máy chủ. Thiết lập này cho phép truy cập ứng dụng FastAPI từ bên ngoài container. 

$ podman run -d --name mlops_container -p 8000:8000 mlops-app  Được hỗ trợ bởi

Để xem toàn bộ log của "mlops_container", hãy dùng lệnh logs.

$ podman logs -f mlops_container    Được hỗ trợ bởi

Kết quả:                                                                  

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Được hỗ trợ bởi

Bạn cũng có thể mở ứng dụng Podman Desktop và vào thẻ “Containers” để xem các container đang chạy.

Để xem log trong ứng dụng Podman Desktop, nhấp vào “mlops_container” rồi chọn thẻ “Terminal”.

5. Kiểm thử máy chủ suy luận ML

Giờ chúng ta sẽ kiểm thử ứng dụng đã triển khai bằng cách truy cập giao diện Swagger tương tác tại: http://localhost:8000/docs. Swagger UI cung cấp giao diện thân thiện để bạn khám phá mọi endpoint API sẵn có.

Chúng ta cũng có thể kiểm thử API bằng lệnh CURL trong terminal. 

$ 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
             }
           ]
         }'Được hỗ trợ bởi

Máy chủ FastAPI hoạt động đúng, xử lý thành công đầu vào của người dùng và trả về dự đoán chính xác.

{"prediction":["Good"]}Được hỗ trợ bởi

6. Dừng và xóa container

Sau khi thử nghiệm API, chúng ta sẽ dừng container bằng lệnh stop.

$ podman stop mlops_container Được hỗ trợ bởi

Bạn cũng có thể xóa container bằng lệnh rm để giải phóng tài nguyên hệ thống. Container phải được dừng trước khi xóa. 

$ podman rm mlops_container     Được hỗ trợ bởi

7. Xóa image

Để xóa image container lưu trữ cục bộ tên "mlops-app", chúng ta sẽ dùng lệnh rmi.

$ podman rmi mlops-app Được hỗ trợ bởi

Nếu bạn gặp vấn đề khi chạy mã trên hoặc tự tạo Docker file, vui lòng xem kho GitHub kingabzpro/mlops-with-podman. Repository này có hướng dẫn sử dụng và mọi tệp cần thiết để bạn chạy mã trên hệ thống của mình.

Bước tiếp theo trong lộ trình học tập của bạn là thử xây dựng 10 ý tưởng dự án Docker, từ cơ bản đến nâng cao, nhưng với Podman. Điều này sẽ giúp bạn hiểu rõ hơn hệ sinh thái Podman.

Kết luận

Podman là lựa chọn thay thế hấp dẫn cho Docker trong một số trường hợp, tuy nhiên nhiều nhà phát triển vẫn ưa chuộng Docker Desktop và CLI nhờ hệ sinh thái tích hợp phong phú và công cụ thân thiện. 

Tuy vậy, với dự án MLOps đơn giản, các kỹ sư có thể chọn Podman vì thiết lập gọn nhẹ và dễ dàng hơn so với Docker Desktop.

Trong hướng dẫn này, chúng ta đã khám phá Podman, một công cụ quản lý container phổ biến, bằng cách so sánh với Docker và trình bày cách cài đặt Podman Desktop. Chúng ta cũng hướng dẫn một dự án MLOps với Podman, bao gồm tạo Dockerfile, build image và chạy container. Bắt đầu với Podman khá đơn giản, và nếu bạn đã quen Docker, bạn sẽ thấy quá trình chuyển đổi rất mượt mà.

Học khóa MLOps Deployment and LifeCycling để khám phá khung MLOps hiện đại, vòng đời và triển khai mô hình machine learning.