Pengantar

MLOps (Machine Learning Operations) adalah gabungan praktik DevOps yang diterapkan pada seluruh siklus hidup model AI. Dengan MLOps, tim dapat memindahkan model dari notebook eksperimen ke produksi secara reliable, terukur, dan otomatis. Artikel ini bakal ngasih blueprint praktis untuk developer, data scientist, dan platform engineer yang mau membangun sistem ML produksi.

Siklus Hidup MLOps End‑to‑End

Insight utama: Setiap tahap harus otomatis, ter‑versi, dan dapat dipantau. Kalau ada yang dilewatkan, bakal muncul tech debt yang bikin insiden produksi.

Komponen Inti MLOps & Rekomendasi Tools

Tips: Mulai dengan satu tool per komponen yang paling cocok dengan infrastruktur yang sudah ada. Nanti bisa ditambah atau diganti tanpa harus redesign seluruh pipeline.

Contoh Pipeline Praktis (MLflow + Kubeflow)

Prasyarat (Ubuntu 22.04, Python 3.11)

# System packages
sudo apt-get update && sudo apt-get install -y docker.io kind kubectl

# Python environment
python -m venv .venv && source .venv/bin/activate
pip install --upgrade pip
pip install \
    pandas scikit-learn \
    mlflow feast[sqlite] \
    kfp==2.5.0 \
    kserve==0.11.0 \
    prometheus-client \
    evidently==0.4.2

Untuk produksi, pakai managed K8s (EKS, GKE, AKS) dan backend Feast yang lebih kuat (Redis, BigQuery).

Langkah 1: Ingest & Register Fitur dengan Feast

# feature_repo/feature_store.py
import pandas as pd
from feast import FeatureStore, Entity, FeatureView, FileSource, ValueType

# 1️⃣ Source CSV lokal
source = FileSource(
    path="data/creditcard.csv",
    event_timestamp_column="Timestamp",
    created_timestamp_column="CreatedAt",
)

# 2️⃣ Entity – primary key
customer = Entity(name="customer_id", join_keys=["CustomerID"], value_type=ValueType.INT64)

# 3️⃣ FeatureView – definisi fitur
features = FeatureView(
    name="customer_features",
    entities=[customer],
    ttl=86400,
    schema=[
        ("Age", ValueType.INT64),
        ("Income", ValueType.FLOAT),
        ("CreditScore", ValueType.FLOAT),
        ("NumOpenAccounts", ValueType.INT64),
    ],
    source=source,
    online=True,
)

if __name__ == "__main__":
    store = FeatureStore(repo_path=".")
    store.apply([customer, features])
    store.materialize_incremental(end_date=pd.Timestamp.utcnow())

Jalankan python feature_repo/feature_store.py. Sekarang SQLite online_store.db berisi vektor fitur yang siap dipanggil saat inference.

Langkah 2: Tracking Eksperimen dengan MLflow

# training/train.py
import mlflow
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import roc_auc_score

mlflow.set_tracking_uri("http://localhost:5000")
mlflow.set_experiment("loan-default-prediction")

def main():
    df = pd.read_csv("data/creditcard.csv")
    X = df[["Age", "Income", "CreditScore", "NumOpenAccounts"]]
    y = df["Default"]
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42, stratify=y
    )
    with mlflow.start_run():
        mlflow.log_params({"n_estimators": 200, "learning_rate": 0.05, "max_depth": 3})
        model = GradientBoostingClassifier(
            n_estimators=200, learning_rate=0.05, max_depth=3, random_state=42
        )
        model.fit(X_train, y_train)
        preds = model.predict_proba(X_test)[:, 1]
        auc = roc_auc_score(y_test, preds)
        mlflow.log_metric("test_auc", auc)
        mlflow.sklearn.log_model(model, artifact_path="model")
        print(f"Run completed – Test AUC: {auc:.4f}")

if __name__ == "__main__":
    main()

Jalankan server MLflow di terminal terpisah:

mlflow server \
    --backend-store-uri sqlite:///mlflow.db \
    --default-artifact-root ./mlruns \
    --host 0.0.0.0 --port 5000

Setelah training selesai, buka http://localhost:5000 untuk lihat run, bandingkan metrik, dan daftarkan model terbaik ke registry:

from mlflow.tracking import MlflowClient
client = MlflowClient()
run_id = "YOUR_RUN_ID"
client.create_registered_model("loan-default-model")
client.create_model_version(
    name="loan-default-model",
    source=mlflow.get_artifact_uri(run_id) + "/model",
    run_id=run_id,
)

Langkah 3: Orkestrasi dengan Kubeflow Pipelines

# pipeline/pipeline.py
import kfp
from kfp import dsl
from kfp.dsl import ContainerOp

def data_preprocess_op():
    return ContainerOp(
        name="Preprocess",
        image="python:3.11-slim",
        command=["python", "-c"],
        arguments=["""
import pandas as pd
df = pd.read_csv('/data/creditcard.csv')
df.to_parquet('/output/features.parquet')
"""],
        file_outputs={"features": "/output/features.parquet"},
        pvolumes={"/data": kfp.dsl.PipelineVolume(pvc="data-pvc"),
                  "/output": kfp.dsl.PipelineVolume(pvc="output-pvc")}
    )

def train_op(features_path: str):
    return ContainerOp(
        name="Train",
        image="python:3.11-slim",
        command=["python", "-m", "training.train"],
        arguments=["--features", features_path],
        pvolumes={"/data": kfp.dsl.PipelineVolume(pvc="output-pvc")}
    )

@dsl.pipeline(
    name="Loan Default Prediction",
    description="Dari CSV mentah → feature store → model registry → endpoint KServe"
)
def loan_default_pipeline():
    preprocess = data_preprocess_op()
    train = train_op(preprocess.outputs["features"])

if __name__ == "__main__":
    kfp.Client(host="http://localhost:8080").create_run_from_pipeline_func(
        loan_default_pipeline, arguments={}
    )

Port‑forward UI Kubeflow (kubectl port-forward svc/ml-pipeline-ui 8080:80) dan jalankan pipeline lewat http://localhost:8080.

Langkah 4: Deploy Model dengan KServe

# kserve/loan-default.yaml
apiVersion: "serving.kserve.io/v1beta1"
kind: "InferenceService"
metadata:
  name: loan-default
spec:
  predictor:
    sklearn:
      storageUri: "gs://my-bucket/mlflow/loan-default-model/1/model"
      resources:
        requests:
          cpu: "500m"
          memory: "1Gi"

Apply file:

kubectl apply -f kserve/loan-default.yaml

Uji endpoint:

curl -X POST http:///v1/models/loan-default:predict \
  -H "Content-Type: application/json" \
  -d '{"instances": [[45, 72000, 680, 3]]}'

Anda akan menerima JSON dengan probabilitas default.

Langkah 5: Monitoring & Retraining Otomatis

• Prometheus Exporter – tambahkan sidecar pada pod KServe untuk expose latency & request count.
• Evidently Drift Dashboard – job harian bandingkan distribusi fitur live vs baseline.
• Alertmanager – jika evidently_data_drift_score > 0.2 selama 3 kali berturut‑turut, webhook akan memicu pipeline Kubeflow kembali.

# alertmanager/rules.yml
groups:
- name: mlops-retrain
  rules:
  - alert: DataDriftDetected
    expr: evidently_data_drift_score > 0.2
    for: 15m
    labels:
      severity: critical
    annotations:
      summary: "Data drift exceeds threshold"
      runbook_url: "https://github.com/yourorg/mlops-runbooks#retrain"

Pemilihan Tools – Matriks Perbandingan

Kesalahan Umum & Cara Menghindarinya

Dampak Karir & Bisnis dari MLOps

Checklist Praktis

• ✅ Tentukan dan implementasikan feature store (misal Feast).
• ✅ Pasang MLflow sebagai satu‑satunya registry model.
• ✅ Pilih orchestrator (Kubeflow bila pakai K8s, atau Airflow).
• ✅ Containerize kode training & inference, simpan image di registry privat.
• ✅ Deploy model dengan KServe atau Seldon, expose metrik Prometheus.
• ✅ Tambahkan monitoring drift & bias (Evidently) + alerting.
• ✅ Dokumentasikan runbook rollback, pengecekan kualitas data, dan audit trail.

Kesimpulan

MLOps bukan sekadar kumpulan tools, melainkan budaya yang mengikat data engineering, pengembangan model, dan operasi DevOps. Dengan mengikuti alur lifecycle, memakai stack yang direkomendasikan, dan menyiapkan monitoring otomatis, tim dapat ship model lebih cepat, lebih aman, dan lebih terukur.

Mulai dari hal kecil – misalnya gunakan MLflow untuk tracking dan Feast untuk feature store – lalu tingkatkan secara bertahap ke Kubeflow & KServe. Setiap iterasi akan memberi feedback loop yang memperbaiki kualitas model dan proses.

Ready to level‑up your ML pipelines? Implementasikan checklist di atas, dan lihat bagaimana tim Anda bertransformasi menjadi tim MLOps yang tangguh.

Meta Description: Panduan praktis MLOps 2025: cara menggabungkan DevOps dengan Machine Learning, contoh pipeline MLflow + Kubeflow, tool terbaik, dan checklist produksi.

Focus Keywords: MLOps, DevOps untuk Machine Learning, pipeline MLOps, MLflow, Kubeflow, Feast, KServe, monitoring model