Pengantar Podman untuk Pembelajaran Mesin: Menyederhanakan Alur Kerja MLOps

Setiap developer dan engineer operasional di bidang TI sudah akrab dengan Docker untuk membangun dan menerapkan aplikasi, baik secara lokal maupun di cloud. Namun, sebagai developer atau engineer machine learning operations, Anda mungkin ingin mengoptimalkan sumber daya, meningkatkan keamanan, dan memperbaiki integrasi sistem. Podman menawarkan alternatif yang menarik. Ini adalah alat gratis dan open-source yang menjadi alternatif untuk Docker dan Docker Desktop.

Dalam tutorial ini, kita akan membahas apa itu Podman, perbedaan antara Podman dan Docker, serta cara menginstal dan menggunakan Podman. Selain itu, kita juga akan membahas cara melatih, mengevaluasi, dan menerapkan model machine learning secara lokal menggunakan Dockerfile dan perintah Podman.

Gambar oleh Penulis

Apa itu Podman?

Podman adalah alat manajemen kontainer open-source yang dirancang untuk memberikan pengalaman yang mulus dan aman bagi developer dan engineer machine learning. Berbeda dengan Docker, Podman berjalan tanpa daemon (daemonless), yang meningkatkan keamanan dan fleksibilitas dengan memungkinkan pengguna menjalankan kontainer sebagai proses tanpa root (rootless). Fitur kunci ini memungkinkan Podman menjalankan kontainer tanpa memerlukan hak istimewa root, sehingga meminimalkan potensi kerentanan.

Podman sepenuhnya kompatibel dengan standar OCI (Open Container Initiative), memastikan bahwa kontainer dan image yang dibuat dengan Podman dapat dengan mudah diintegrasikan dengan alat dan platform lain yang sesuai OCI seperti runc, Buildah, dan Skopeo. Selain itu, Podman mendukung pembuatan dan pengelolaan pod, yaitu grup kontainer yang berbagi namespace jaringan yang sama, mirip dengan pod Kubernetes.

Salah satu keunggulan menggunakan Podman adalah pengalamannya mirip dengan Docker. Antarmuka baris perintahnya sebanding dengan Docker, dan Anda juga dapat menarik image dari Docker Hub. Kemiripan ini memudahkan transisi bagi mereka yang terbiasa dengan Docker, sambil tetap menyediakan fitur lanjutan yang memenuhi kebutuhan pengembangan dan penerapan aplikasi berbasis kontainer yang terus berkembang.

Podman hanyalah salah satu alat dalam gudang MLOps. Pelajari semua jenis alat yang digunakan dalam ekosistem MLOps dengan membaca blog 25 Top MLOps Tools You Need to Know in 2025.

Perbandingan Docker vs Podman

Docker dan Podman adalah alat manajemen kontainer yang menonjol, masing-masing menawarkan fitur dan kapabilitas yang berbeda. Perbandingan ini akan meninjau perbedaannya dan membantu Anda memutuskan mana yang paling sesuai dengan kebutuhan Anda.

Pilihan antara Docker dan Podman sangat bergantung pada kebutuhan spesifik proyek, terutama terkait keamanan, kompatibilitas, dan kebutuhan orkestrasi. 

Docker tetap menjadi pilihan kuat untuk pipeline CI/CD yang mapan dan manajemen kontainer yang komprehensif, sementara Podman menawarkan alternatif yang aman dan ringan untuk lingkungan yang memprioritaskan keamanan dan operasi tanpa root. Podman juga menawarkan waktu mulai yang lebih cepat, yang ideal untuk penerapan berskala besar. 

Pelajari Docker untuk Data Science dengan membaca artikel pengantar kami, lengkap dengan contoh kode dan contoh penggunaan.

Menginstal Podman 

Pertama, Anda perlu mengunduh dan memasang paket Podman Desktop dengan mengunjungi situs resmi. 

Sumber: Podman

Instalasinya sederhana dan cepat. Dalam beberapa menit, Anda akan berada di layar mulai (getting started), di mana Anda akan diminta untuk memasang ekstensi opsional. 

Jika Anda tidak memiliki WSL di Windows, WSL akan terpasang secara otomatis.

Selanjutnya, siapkan mesin Podman. 

Dibandingkan dengan Docker, Anda tidak perlu menyiapkan mesin. Namun, di Podman, Anda dapat mengelola beberapa mesin yang menangani kontainer berbeda secara bersamaan, yang memungkinkan manajemen sumber daya yang lebih baik. 

Mesin kita sudah aktif dan berjalan, siap membuat image dan menjalankan kontainer.

Untuk memverifikasi bahwa Podman berfungsi dengan benar, kita akan menarik image contoh dari quay.io dan mengeksekusi kontainernya.

$ podman run quay.io/podman/hello

Mesin Podman berhasil menarik image dan menjalankan kontainer, menampilkan 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

Membangun Proyek MLOps Dengan Podman

Dalam proyek MLOps ini, kita akan mengotomatisasi pelatihan dan evaluasi model serta menyajikan model menggunakan Dockerfile dan Podman. Ini akan mirip dengan Docker, tetapi kita akan menggunakan CLI Podman untuk membangun image dan kemudian menjalankan kontainer. 

Jika Anda baru mengenal konsep ini, Anda dapat mempelajari dasar-dasar MLOPs dengan mengikuti kursus MLOps Concepts.

1. Menyiapkan proyek machine learning

Untuk menyiapkan proyek machine learning, kita perlu membuat skrip pelatihan dan penyajian, serta berkas requirements.txt untuk memasang paket Python.

Skrip Python pelatihan akan memuat dataset klasifikasi skor kredit, memprosesnya, melakukan enkode, dan melatih model. Kita juga akan melakukan evaluasi model. Pada akhirnya, kita akan menyimpan pipeline prapemrosesan dan pelatihan beserta modelnya dalam format 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()

Skrip penyajian model akan memuat pipeline model yang disimpan menggunakan berkas model, membuat fungsi permintaan POST yang menerima daftar kamus dari pengguna, mengonversinya menjadi DataFrame, memberikannya ke model untuk menghasilkan prediksi, lalu mengembalikan label yang diprediksi. Kita menggunakan FastAPI sebagai kerangka kerja API, yang memungkinkan kita menyajikan model hanya dengan beberapa baris kode.

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

Kita perlu membuat berkas requirements.txt yang mencakup semua paket Python yang diperlukan untuk menjalankan skrip di atas. Berkas ini akan digunakan untuk menyiapkan lingkungan berjalan di dalam kontainer Docker, memastikan kita dapat mengeksekusi skrip Python dengan lancar.

requirements.txt: 

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

2. Membuat Dockerfile

Buat “Dockerfile” dan tambahkan kode berikut. 

Berikut langkah-langkah yang dilakukan Dockerfile ini:

1. Menggunakan image Python 3.9 slim sebagai basis
2. Menetapkan /app sebagai direktori kerja
3. Memasang dependensi Python dari requirements.txt
4. Menyalin kode sumber dan berkas data ke dalam kontainer
5. Membuat direktori model dan menjalankan skrip pelatihan
6. Membuka port 8000 untuk API
7. Menjalankan aplikasi FastAPI menggunakan server uvicorn pada port 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"]

Ruang kerja lokal Anda harus diorganisasi sebagai berikut: 

1. Sebuah folder data yang berisi semua berkas CSV
2. Sebuah folder models
3. Sebuah folder src yang menyimpan skrip Python
4. Di direktori utama, sertakan berkas requirements.txt dan Dockerfile

Berkas lainnya adalah komponen tambahan untuk automasi dan operasi Git.

3. Membangun image Docker dengan Podman

Membangun image Docker itu mudah: Cukup jalankan perintah build dengan nama image Docker Anda dan direktori saat ini tempat Dockerfile berada.

$ podman build -t mlops_app .

Alat build akan mengeksekusi semua perintah dalam Dockerfile secara berurutan, mulai dari menyiapkan lingkungan hingga menyajikan aplikasi machine learning. 

Kita juga dapat melihat bahwa log memuat hasil evaluasi model. Model memiliki akurasi 75% dan skor ROC AUC sebesar 0,89, yang tergolong rata-rata.

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

Jika Anda membuka aplikasi Podman Desktop dan mengeklik tab “Images”, Anda akan melihat bahwa image mlops_app Anda telah berhasil dibuat.

Lihat juga cheat sheet Docker untuk Data Science untuk mempelajari semua perintah Docker yang relevan. Cukup ganti perintah pertama, docker, dengan podman.

4. Menjalankan Kontainer Docker dengan Podman

Kita akan menggunakan perintah run untuk memulai kontainer bernama "mlops_container" dari image mlops-app. Ini akan dijalankan dalam mode detached (-d), memetakan port 8000 pada kontainer ke port 8000 pada mesin host. Pengaturan ini akan memungkinkan akses ke aplikasi FastAPI dari luar kontainer. 

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

Untuk melihat semua log dari "mlops_container", gunakan perintah logs.

$ podman logs -f mlops_container    

Keluaran:                                                                  

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

Anda juga dapat membuka aplikasi Podman Desktop dan mengeklik tab “Containers” untuk melihat kontainer yang sedang berjalan.

Untuk melihat log di aplikasi Podman Desktop, klik “mlops_container” lalu pilih tab “Terminal”.

5. Menguji server inferensi ML

Sekarang kita akan menguji aplikasi yang diterapkan dengan mengakses Swagger UI interaktif di: http://localhost:8000/docs. Swagger UI menawarkan antarmuka yang ramah pengguna yang memungkinkan Anda mengeksplorasi semua endpoint API yang tersedia.

Kita juga dapat menguji API menggunakan perintah CURL di 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
             }
           ]
         }'

Server FastAPI berfungsi dengan benar, berhasil memproses masukan pengguna dan mengembalikan prediksi yang akurat.

{"prediction":["Good"]}

6. Menghentikan dan menghapus kontainer

Setelah bereksperimen dengan API, kita akan menghentikan kontainer menggunakan perintah stop.

$ podman stop mlops_container 

Kita juga dapat menghapus kontainer menggunakan perintah rm, sehingga membebaskan sumber daya sistem. Kontainer harus dihentikan terlebih dahulu sebelum dapat dihapus. 

$ podman rm mlops_container     

7. Menghapus Image

Untuk menghapus image kontainer yang tersimpan secara lokal bernama "mlops-app" kita akan menggunakan perintah rmi.

$ podman rmi mlops-app 

Jika Anda mengalami masalah saat menjalankan kode di atas atau membuat Docker file Anda sendiri, silakan periksa repositori GitHub kingabzpro/mlops-with-podman. Repositori ini mencakup panduan penggunaan dan semua berkas yang diperlukan agar Anda dapat mengeksekusi kode di sistem Anda.

Langkah berikutnya dalam perjalanan belajar Anda adalah mencoba membangun 10 ide proyek Docker, mulai dari tingkat pemula hingga lanjutan, tetapi dengan Podman. Ini akan membantu Anda memahami ekosistem Podman dengan lebih baik.

Kesimpulan

Podman menawarkan alternatif yang menarik untuk Docker pada kasus penggunaan tertentu, namun banyak developer yang tetap menyukai Docker Desktop dan CLI. Preferensi ini terutama karena integrasi Docker yang luas dan alat yang mudah digunakan. 

Namun, untuk proyek MLOps yang sederhana, engineer mungkin memilih Podman, yang menyediakan penyiapan yang ringan dan mudah dibandingkan Docker Desktop.

Dalam tutorial ini, kita mengeksplorasi Podman, alat manajemen kontainer populer, dengan membandingkannya dengan Docker dan mendemonstrasikan cara menginstal Podman Desktop. Kami juga memandu Anda melalui proyek MLOps menggunakan Podman, mencakup pembuatan Dockerfile, membangun image, dan menjalankan kontainer. Memulai dengan Podman itu mudah, dan jika Anda sudah terbiasa dengan Docker, Anda akan menghargai transisi yang mulus.

Ikuti kursus MLOps Deployment and LifeCycling untuk mengeksplorasi kerangka kerja MLOps modern, menelusuri siklus hidup dan penerapan model machine learning.