Kubeflow 2026: Chạy Pipeline ML Hoàn Chỉnh trên Kubernetes — Hướng Dẫn Từ Training đến Triển Khai Production

{{< resource-info >}}

Giới thiệu: Tại Sao ML Gốc Kubernetes Lại Quan Trọng #

Năm 2024, một đội ngũ tại công ty fintech vừa vào có 47 Jupyter notebooks rải rác trên laptop của các kỹ sư. Các mô hình được huấn luyện trên một máy, “được triển khai” bằng cách SCP các file pickle sang VM, và không ai có thể tái tạo một lần chạy training từ ba tuần trước. Khi lead data scientist rồi đi, ba tháng lặp đi lặp lại các thử nghiệm biến mất cùng với laptop của cô ấy.

Câu chuyện này lặp lại ở các công ty mọi quy mô. Nguyên nhân gốc rễ: workflow machine learning và hạ tầng vẫn bị tách rồi. Data scientist làm việc trong notebook. DevOps quản lý Kubernetes. Platform engineer cung cấp GPU. Và việc bàn giao giữa mỗi giai đoạn tạo ra ma sát, lỗi và mất dữ liệu.

Kubeflow tồn tại để giải quyết chính xác điều này. Ra đồi từ Google năm 2017 và mã nguồn mở năm 2018, Kubeflow là một bộ công cụ ML toàn diện được xây dựng riêng cho Kubernetes. Tính đến tháng 5/2026, dự án có khoảng 14,000 sao GitHub, phát hành theo chu kỳ hàng quý (v1.10.0 ra mắt tháng 4/2026), và cung cấp năng lượng cho workflow ML production tại các công ty từ Spotify đến Shopify.

Hướng dẫn này sẽ đưa bạn qua cài đặt Kubeflow trên cluster Kubernetes, xây dựng pipeline đầu tiên, chạy training phân tán, deploy mô hình với KServe, và cứng hóa mọi thứ cho production. Nếu bạn cần một cluster Kubernetes để bắt đầu, DigitalOcean cung cấp Kubernetes được quản lý với các GPU worker node khởi động trong vòng dưới 5 phút.

Kubeflow Là Gì? #

Kubeflow là một bộ công cụ machine learning mã nguồn mở cho Kubernetes đơn giản hóa toàn bộ vòng đồi ML — từ thử nghiệm và training đến deploy mô hình và giám sát — bằng cách chạy mọi thành phần như một workload containerized trên cluster K8s.

Thay vì quản lý các công cụ riêng biệt cho notebooks, training jobs, hyperparameter tuning, và model deployment, Kubeflow cung cấp một control plane thống nhất nơi mọi tác vụ ML đều là tài nguyên gốc Kubernetes. Điều này có nghĩa training jobs của bạn là các Pod, models của bạn là Custom Resources, và toàn bộ pipeline của bạn là một đồ thị không chu trình có hướng (DAG) của các bước containerized.

Kubeflow Hoạt Động Như Thế Nào: Tổng Quan Kiến Trúc #

Kiến trúc của Kubeflow tập trung vào nguyên tắc: mọi thứ chạy trên Kubernetes. Nền tảng bao gồm nhiều thành phần cốt lõi, mỗi thành phần đề cập đến một giai đoạn cụ thể của vòng đồi ML:

Kubeflow Pipelines (KFP) điều phối các workflow ML dưới dạng DAG dựa trên container. Mỗi bước trong pipeline là một Docker image; đầu vào và đầu ra được truyền qua các artifact store S3/MinIO/GCS. KFP sử dụng Argo Workflows làm engine thực thi bên dưới (mặc dù Tekton cũng được hỗ trợ như một lựa chọn thay thế).

Kubeflow Notebooks cung cấp các instance Jupyter, VS Code, và RStudio được quản lý chạy dưới dạng StatefulSets. Mỗi notebook server mount các persistent volume cho datasets và models, và có thể được cấu hình với quota tài nguyên CPU/GPU cụ thể.

KServe (được merge từ KFServing năm 2022) xử lý model serving với autoscaling serverless, canary rollouts, và A/B testing. Nó hỗ trợ TensorFlow, PyTorch, scikit-learn, XGBoost, ONNX, và các inference container tùy chỉnh.

Katib tự động hóa hyperparameter tuning và neural architecture search sử dụng Kubernetes Jobs. Nó hỗ trợ Bayesian optimization, Hyperband, random search, và chiến lược early stopping.

Training Operator (trước đây là TFJob/PyTorchJob) quản lý distributed training trên nhiều node sử dụng MPI, Horovod, hoặc các chiến lược distributed native của framework.

Control plane bao gồm Istio cho service mesh, Dex hoặc OIDC cho xác thực, và Central Dashboard để điều hướng thống nhất trên tất cả các thành phần.

# Xem các thành phần ở cấp cao
kubectl get pods -n kubeflow
# Output dự kiến hiển thị pod cho:
# - ml-pipeline (KFP API server)
# - katib-controller, katib-db-manager
# - kserve-controller-manager
# - training-operator
# - centraldashboard
# - notebooks trong namespace kubeflow-user-example-com

Cài Đặt & Thiết Lập: Chạy trong 10 Phút #

Điều kiện tiên quyết #

• Cluster Kubernetes (v1.28+), tối thiểu 3 nodes cho workload production
• kubectl được cấu hình và xác thực
• kustomize v5.0+ hoặc Helm 3.12+
• 8 GB+ RAM khả dụng mỗi worker node, 1 GPU node cho workload training

Tùy chọn A: Triển khai với kustomize (Phương pháp chính thức) #

# Clone repo manifests
export KUBEFLOW_VERSION=v1.10.0
git clone https://github.com/kubeflow/manifests.git
cd manifests

# Checkout tag release
git checkout ${KUBEFLOW_VERSION}

# Cài đặt tất cả thành phần với một lệnh kustomize build
while ! kustomize build example | kubectl apply -f -; do
  echo "Retrying to apply resources..."
  sleep 10
done

# Kiểm tra các thành phần cốt lõi đang chạy
kubectl get pods -n kubeflow --watch
# Đợi cho đến khi tất cả pods hiển thị Running hoặc Completed
# Thường mất 5-10 phút trên cluster 3 nodes

# Port-forward để truy cập central dashboard
kubectl port-forward svc/istio-ingressgateway -n istio-system 8080:80

# Truy cập tại http://localhost:8080
# Thông tin đăng nhập mặc định: user@example.com / 12341234

Tùy chọn B: Triển khai với Helm (Nhanh hơn cho phát triển) #

# Thêm Helm repository của Kubeflow (được cộng đồng duy trì)
helm repo add kubeflow https://kubeflow.github.io/manifests/
helm repo update

# Cài đặt với profile tối thiểu
helm install kubeflow kubeflow/kubeflow \
  --namespace kubeflow \
  --create-namespace \
  --set pipeline.objectStore.minio.persistence.enabled=true

Tùy chọn C: DigitalOcean Kubernetes (Sẵn sàng Production) #

Để có cluster production-grade mà không cần quản lý control plane:

# Cài đặt doctl và xác thực
doctl kubernetes cluster create kubeflow-ml \
  --region nyc3 \
  --node-pool "name=cpu-pool;size=s-4vcpu-8gb;n-node=3" \
  --node-pool "name=gpu-pool;size=gpu-h100-1vcpu-8gb;n-node=2"

# Sau đó áp dụng Kubeflow manifests như được hiển thị trong Tùy chọn A

Đăng ký DigitalOcean và nhận $200 tín dụng cho 60 ngày đầu tiên — đủ để chạy một cluster Kubeflow với GPU trong một tháng đầy đủ thử nghiệm.

# Kiểm tra tất cả namespace được tạo bởi Kubeflow
kubectl get namespaces | grep kubeflow
# kubeflow          Active
# kubeflow-user-example-com  Active

Xây Dựng Pipeline ML Đầu Tiên Củ Bạn #

Kubeflow Pipelines (KFP) là nơi Kubeflow mang lại nhiều giá trị nhất. Đây là một pipeline hoàn chỉnh để tải xuống dữ liệu, train mô hình, và đánh giá:

# pipeline.py — Pipeline ML hoàn chỉnh sử dụng KFP SDK v2
import kfp
from kfp import dsl
from kfp.dsl import component, Input, Output, Dataset, Model, Metrics

@component(
    base_image="python:3.11-slim",
    packages_to_install=["pandas", "scikit-learn"]
)
def download_data(output_dataset: Output[Dataset]):
    """Download and preprocess the dataset."""
    import pandas as pd
    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split

    iris = load_iris(as_frame=True)
    df = iris.frame
    train, test = train_test_split(df, test_size=0.2, random_state=42)
    train.to_csv(f"{output_dataset.path}.csv", index=False)

@component(
    base_image="python:3.11-slim",
    packages_to_install=["pandas", "scikit-learn", "joblib"]
)
def train_model(
    input_dataset: Input[Dataset],
    output_model: Output[Model],
    n_estimators: int = 100
):
    """Train a Random Forest classifier."""
    import pandas as pd
    import joblib
    from sklearn.ensemble import RandomForestClassifier

    df = pd.read_csv(f"{input_dataset.path}.csv")
    X = df.drop("target", axis=1)
    y = df["target"]

    clf = RandomForestClassifier(
        n_estimators=n_estimators,
        random_state=42
    )
    clf.fit(X, y)
    joblib.dump(clf, f"{output_model.path}.joblib")

@component(
    base_image="python:3.11-slim",
    packages_to_install=["pandas", "scikit-learn", "joblib"]
)
def evaluate_model(
    input_model: Input[Model],
    input_dataset: Input[Dataset],
    metrics: Output[Metrics]
) -> str:
    """Evaluate the trained model and log metrics."""
    import pandas as pd
    import joblib
    from sklearn.metrics import accuracy_score, f1_score

    df = pd.read_csv(f"{input_dataset.path}.csv")
    X = df.drop("target", axis=1)
    y = df["target"]

    clf = joblib.load(f"{input_model.path}.joblib")
    predictions = clf.predict(X)

    accuracy = accuracy_score(y, predictions)
    f1 = f1_score(y, predictions, average="weighted")

    metrics.log_metric("accuracy", accuracy)
    metrics.log_metric("f1_score", f1)

    return f"Model accuracy: {accuracy:.4f}, F1: {f1:.4f}"

@dsl.pipeline(
    name="iris-training-pipeline",
    description="End-to-end iris classification pipeline"
)
def iris_pipeline(n_estimators: int = 100):
    download = download_data()
    train = train_model(
        input_dataset=download.outputs["output_dataset"],
        n_estimators=n_estimators
    )
    evaluate = evaluate_model(
        input_model=train.outputs["output_model"],
        input_dataset=download.outputs["output_dataset"]
    )

# Compile pipeline
if __name__ == "__main__":
    kfp.compiler.Compiler().compile(
        iris_pipeline,
        "iris_pipeline.yaml"
    )

# Compile và upload pipeline
python pipeline.py

# Upload lên KFP qua SDK
kfp pipeline create \
  --pipeline-name iris-classifier \
  --description "Iris classification training pipeline" \
  --engine argo \
  iris_pipeline.yaml

# Chạy pipeline từ CLI
kfp run create \
  --experiment-name default \
  --pipeline-id <PIPELINE_ID> \
  --display-name "iris-run-$(date +%s)"

Pipeline xuất hiện trong UI KFP với khả năng theo dõi dòng dõi đầy đủ — mọi artifact, tham số, và execution được tự động ghi lại. Bạn có thể click thông qua từ một model artifact trở lại dataset và phiên bản code chính xác đã tạo ra nó.

Training Phân Tán với Training Operator #

Đối với các workload không phù hợp với một GPU, Training Operator của Kubeflow quản lý các training job phân tán:

# pytorch-job.yaml — Training PyTorch phân tán
apiVersion: kubeflow.org/v1
kind: PyTorchJob
metadata:
  name: cifar10-distributed
  namespace: kubeflow-user-example-com
spec:
  pytorchReplicaSpecs:
    Master:
      replicas: 1
      restartPolicy: OnFailure
      template:
        spec:
          containers:
          - name: pytorch
            image: my-registry/cifar10-training:v1.2
            command: ["python", "-m", "torch.distributed.launch",
                      "--nproc_per_node=1", "train.py"]
            resources:
              limits:
                nvidia.com/gpu: 1
                memory: "16Gi"
                cpu: "8"
    Worker:
      replicas: 3
      restartPolicy: OnFailure
      template:
        spec:
          containers:
          - name: pytorch
            image: my-registry/cifar10-training:v1.2
            command: ["python", "-m", "torch.distributed.launch",
                      "--nproc_per_node=1", "train.py"]
            resources:
              limits:
                nvidia.com/gpu: 1
                memory: "16Gi"
                cpu: "8"

# Gửi training job
kubectl apply -f pytorch-job.yaml

# Giám sát tiến độ training
kubectl get pytorchjobs -n kubeflow-user-example-com -w
kubectl logs -f cifar10-distributed-master-0 \
  -n kubeflow-user-example-com

# Kiểm tra GPU utilization trên cluster
kubectl top nodes
nvidia-smi  # Chạy bên trong bất kỳ GPU pod nào

Model Serving với KServe #

KServe cung cấp model serving cấp production với autoscaling, traffic splitting, và các giao thức inference chuẩn:

# inference-service.yaml — Triển khai model đã train
apiVersion: serving.kserve.io/v1beta1
kind: InferenceService
metadata:
  name: iris-classifier
  namespace: kubeflow-user-example-com
  annotations:
    serving.kserve.io/deploymentMode: Serverless
spec:
  predictor:
    serviceAccountName: sa-default
    sklearn:
      storageUri: "s3://kubeflow-models/iris/v1/model.joblib"
      resources:
        limits:
          cpu: "1"
          memory: 2Gi
        requests:
          cpu: "100m"
          memory: 256Mi

# Áp dụng InferenceService
kubectl apply -f inference-service.yaml

# Đợi model sẵn sàng (scale từ zero)
kubectl get inferenceservices -n kubeflow-user-example-com -w

# Dự kiến: iris-classifier   True    100   http://iris-classifier...   Ready

# Test model đã deploy
curl -X POST http://iris-classifier.kubeflow-user-example-com.example.com/v1/models/iris-classifier:predict \
  -H "Content-Type: application/json" \
  -d '{"instances": [[5.1, 3.5, 1.4, 0.2]]}'

# Response: {"predictions": [0]}

Đối với canary deployments, KServe hỗ trợ traffic splitting:

# canary-rollout.yaml — Rollout dần dần của v2
apiVersion: serving.kserve.io/v1beta1
kind: InferenceService
metadata:
  name: iris-classifier
  namespace: kubeflow-user-example-com
spec:
  predictor:
    canaryTrafficPercent: 20
    sklearn:
      storageUri: "s3://kubeflow-models/iris/v2/model.joblib"

Hyperparameter Tuning với Katib #

Katib tự động hóa việc tìm kiếm các hyperparameter tối ưu bằng cách sử dụng các experiment gốc Kubernetes:

# katib-experiment.yaml — Tối ưu hóa hyperparameters Random Forest
apiVersion: kubeflow.org/v1beta1
kind: Experiment
metadata:
  namespace: kubeflow-user-example-com
  name: iris-hp-tuning
spec:
  objective:
    type: maximize
    goal: 0.99
    objectiveMetricName: accuracy
  algorithm:
    algorithmName: bayesianoptimization
  parallelTrialCount: 3
  maxTrialCount: 12
  maxFailedTrialCount: 3
  parameters:
    - name: n_estimators
      parameterType: int
      feasibleSpace:
        min: "50"
        max: "500"
    - name: max_depth
      parameterType: int
      feasibleSpace:
        min: "3"
        max: "20"
    - name: min_samples_split
      parameterType: double
      feasibleSpace:
        min: "0.01"
        max: "0.3"
  trialTemplate:
    primaryContainerName: training-container
    trialParameters:
      - name: nEstimators
        reference: n_estimators
      - name: maxDepth
        reference: max_depth
      - name: minSamplesSplit
        reference: min_samples_split
    trialSpec:
      apiVersion: batch/v1
      kind: Job
      spec:
        template:
          spec:
            containers:
              - name: training-container
                image: my-registry/iris-train:v1
                command: ["python", "train.py"]
                resources:
                  limits:
                    memory: "4Gi"
                    cpu: "2"
            restartPolicy: Never

# Khởi chạy experiment
kubectl apply -f katib-experiment.yaml

# Giám sát các trials
kubectl get trials -n kubeflow-user-example-com
# Hiển thị 12 trials với giá trị metric mục tiêu

# Xem trial tốt nhất
kubectl get experiment iris-hp-tuning \
  -n kubeflow-user-example-com \
  -o jsonpath='{.status.currentOptimalTrial}'

Benchmark & Các Trường Hợp Sử Dụng Thực Tế #

So Sánh Thông Lượng Training #

*Giá cloud xấp xỉ, tháng 5/2026

Chi Phí Thực Thi Pipeline #

Chi phí điều phối KFP luôn luôn dưới 3% tổng thờ gian chạy pipeline, ngay cả đối với các workflow multi-step phức tạp.

Các Mẫu Áp Dụng Thực Tế #

• Spotify sử dụng Kubeflow Pipelines để điều phối hơn 2,000 job training hàng tuần cho các hệ thống recommendation
• Shopify xử lý 50 TB dữ liệu feature mỗi ngày thông qua pipeline Kubeflow để phát hiện gian lận
• CERN chạy Kubeflow trên các cluster Kubernetes on-premise cho workload ML vật lý hạt nhân, quản lý hơn 400 GPU nodes

Sử Dụng Nâng Cao / Cứng Hóa Production #

GPU Scheduling và Resource Quotas #

# gpu-quota.yaml — Thực thi giới hạn GPU cho mỗi namespace
apiVersion: v1
kind: ResourceQuota
metadata:
  name: gpu-quota
  namespace: data-science-team
spec:
  hard:
    requests.nvidia.com/gpu: 8
    limits.nvidia.com/gpu: 16

# Áp dụng quota
kubectl apply -f gpu-quota.yaml

# Kiểm tra phân bổ GPU cho mỗi namespace
kubectl describe resourcequota gpu-quota -n data-science-team

Persistent Storage cho Datasets #

# dataset-pvc.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: training-datasets
  namespace: kubeflow-user-example-com
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 500Gi
  storageClassName: nfs-client  # Hoặc efs-sc trên AWS

# Mount vào notebook server qua UI Kubeflow
# Hoặc tham chiếu trong các thành phần pipeline:
# dsl.VolumeOp(name="create-dataset-volume",
#              resource_name="training-datasets",
#              size="500Gi",
#              modes=dsl.VOLUME_MODE_RWM)

Xác Thực và RBAC #

# Tạo user profile với giới hạn tài nguyên
kubectl apply -f - <<EOF
apiVersion: kubeflow.org/v1
kind: Profile
metadata:
  name: team-ml-platform
spec:
  owner:
    kind: User
    name: ml-engineer@company.com
  resourceQuotaSpec:
    hard:
      cpu: "64"
      memory: 256Gi
      nvidia.com/gpu: "8"
      pods: "50"
EOF

Backup và Khôi Phục Sau Thảm Họa #

# Backup cơ sở dữ liệu metadata MySQL (KFP experiments/runs)
kubectl exec -it ml-pipeline-mysql-0 -n kubeflow -- \
  mysqldump -u root -p$mysqlpassword mlpipeline \
  > kubeflow-metadata-backup.sql

# Backup artifact store MinIO
mc mirror myminio/kubeflow-pipelines/ \
  s3-backup/kubeflow-pipelines-backup/

Giám Sát với Prometheus và Grafana #

# Kubeflow expose các Prometheus metrics trên nhiều thành phần
kubectl apply -f \
  https://raw.githubusercontent.com/kubeflow/manifests/v1.10.0/contrib/prometheus/kustomization.yaml

# Các chỉ số chính cần cảnh báo:
# - kubeflow_pipelines_run_count (tổng pipeline runs)
# - kubeflow_pipelines_run_latency_seconds (thờ gian thực thi pipeline)
# - nvidia_gpu_utilization_gpu (GPU utilization mỗi pod)
# - container_memory_working_set_bytes (phát hiện OOM)

So Sánh với Các Giải Pháp Thay Thế #

Khi chọn Kubeflow: Bạn đã chạy Kubernetes, cần quản lý vòng đồi ML end-to-end, muốn quản lý tài nguyên gốc Kubernetes cho training và serving, và ưa thích open-source không phụ thuộc vendor.

Khi chọn MLflow thay thế: Bạn cần tracking thử nghiệm nhẹ, không dùng Kubernetes, hoặc muốn một công cụ đơn giản hơn tích hợp với hạ tầng hiện có.

Khi chọn Airflow: Các pipeline của bạn là workload kỹ thuật dữ liệu tổng quát (không chuyên về ML) và bạn cần scheduling, backfill, và điều phối xuyên hệ thống đã chín chắn.

Khi chọn SageMaker: Bạn hoàn toàn dùng AWS, thích hạ tầng được quản lý, và tối ưu chi phí ít quan trọng hơn thờ gian ra thị trường.

Hạn Chế / Đánh Giá Trung Thực #

Kubeflow mạnh mẽ nhưng không phải không có thách thức:

Độ phức tạp cài đặt: Cài đặt Kubeflow đầy đủ yêu cầu hơn 30 microservices. Ngay cả các operator Kubernetes có kinh nghiệm cũng cần 2-4 giờ cho lần deploy production đầu tiên. Các công cụ như Kubeflow on GCP (Vertex AI) hoặc AWS làm đơn giản hóa điều này nhưng tạo ra sự phụ thuộc vào vendor.

Phân mảnh tài liệu: Các thành phần khác nhau (KFP, KServe, Katib) duy trì các trang tài liệu riêng biệt. Các ví dụ tích hợp xuyên thành phần đôi khi đã lỗi thờ. Luôn kiểm chứng với tài liệu v1.10.0 hoặc mới hơn.

Hạn chế GPU scheduling: Kubeflow dựa vào NVIDIA Device Plugin và Kubernetes scheduler để phân bổ GPU. Time-slicing GPU (vGPU/MIG) yêu cầu cấu hình bổ sung và không tự động.

Cộng đồng nhỏ so với quy mô: Mặc dù có khoảng 14,000 sao, cơ sở contributor tích cực nhỏ hơn Airflow hoặc MLflow. Một số thành phần nhận được cập nhật không thường xuyên — KServe và KFP được duy trì tích cực nhất.

Khả năng tương thích phiên bản: Nâng cấp giữa các phiên bản Kubeflow thường yêu cầu cài đặt lại hoàn toàn. Không có đường dẫn upgrade tại chỗ cho các thành phần control plane.

Các Câu Hỏi Thường Gặp #

Q: Chi phí chạy Kubeflow trên nhà cung cấp cloud là bao nhiêu? A: Một cluster production tối thiểu (3 CPU nodes + 2 GPU nodes) có giá khoảng $800-1,200/tháng trên DigitalOcean hoặc GCP, tùy thuộc vào loại GPU. Cluster thử nghiệm chỉ CPU có thể chạy thấp đến $200/tháng.

Q: Có thể dùng Kubeflow mà không có GPU không? A: Có. Kubeflow hoạt động hoàn toàn trên CPU nodes. Training Operator, KFP, và KServe đều hoạt động mà không cần GPU. Tuy nhiên, training deep learning sẽ chậm đáng kể. Đối với cluster chỉ CPU, giảm nvidia.com/gpu resource requests trong tất cả các manifest xuống zero.

Q: Kubeflow so với Kubernetes thuần + script tùy chỉnh như thế nào? A: Kubernetes thuần cho bạn toàn quyền kiểm soát nhưng yêu cầu xây dựng engine pipeline, artifact tracking, experiment management, và model serving layer riêng. Kubeflow cung cấp tất cả những điều này out-of-the-box, tiết kiệm ước tính 3-6 tháng nỗ lực platform engineering. Đánh đổi là chấp nhận các lựa chọn thiết kế của Kubeflow về cách các thành phần tương tác.

Q: Có thể tích hợp Kubeflow với hệ thống CI/CD hiện có không? A: Có. Kubeflow Pipelines có thể được kích hoạt từ GitHub Actions, GitLab CI, Jenkins, hoặc bất kỳ hệ thống nào có thể thực hiện các HTTP API call. Nhiều đội thực hiện một pattern trong đó merge vào main tự động trigger một pipeline run để train, evaluate, và điều kiện deploy một model.

Q: Backend lưu trữ được khuyến nghị cho artifacts là gì? A: Đối với deployment on-premise, MinIO (được bao gồm trong Kubeflow manifests) cung cấp lưu trữ tương thích S3. Đối với cloud deployment, sử dụng native object store: GCS trên GCP, S3 trên AWS, hoặc Azure Blob Storage. Đảm bảo bucket của bạn có lifecycle policies để ngăn chi phí lưu trữ artifact tăng vô hạn — các pipeline run cũ có thể tích lũy hàng trăm gigabyte mỗi tháng.

Q: Làm thế nào để debug một pipeline step bị lỗi? A: Mỗi KFP step chạy như một Kubernetes Pod. Sử dụng kubectl logs <pod-name> -n <namespace> để kiểm tra container logs. UI KFP hiển thị pod names và links đến logs. Để debug lâu dài, thêm chính sách dsl.Retry vào component của bạn hoặc sử dụng kubectl describe pod để kiểm tra resource limits, image pull errors, hoặc PVC mount failures.

Kết Luận: Bắt Đầu Xây Dựng Pipeline ML Production Ngay Hôm Nay #

Kubeflow vẫn là nền tảng mã nguồn mở toàn diện nhất để chạy workload ML trên Kubernetes. Mặc dù thiết lập ban đầu yêu cầu đầu tư, phần thưởng là một hạ tầng ML có thể tái tạo, có thể mở rộng, và có thể kiểm toán phát triển cùng với đội của bạn. Bản release v1.10.0 (tháng 4/2026) mang đến hiệu suất KServe được cải thiện, SDK KFP v2 được tinh giản, và GPU scheduling tốt hơn — đây là thờ điểm tốt nhất để áp dụng Kubeflow nếu bạn nghiêm túc về ML production.

Bắt đầu với một pipeline duy nhất trên cluster nhỏ, lặp lại workflow, và mở rộng từng thành phần. Con đường từ “notebook trên laptop” đến “pipeline ML hoàn toàn tự động” là tăng dần — và Kubeflow cung cấp các công cụ cho mỗi bước.

Sẵn sàng deploy? Nhận $200 credit trên DigitalOcean và khởi chạy cluster Kubeflow của bạn ngay hôm nay. Tham gia nhóm Telegram của chúng tôi để được hỗ trợ thờ gian thực từ các ML engineer đang chạy Kubeflow trong production.

Hosting Và Hạ Tầng Được Đề Xuất #

Trước khi triển khai các công cụ trên vào production, bạn cần hạ tầng vững chắc. Hai lựa chọn dibi8 đang dùng:

• DigitalOcean — Credit miễn phí $200 trong 60 ngày, 14+ khu vực toàn cầu. Lựa chọn mặc định cho dev chạy AI tools open source.
• HTStack — VPS Hong Kong, độ trễ thấp khi truy cập từ Trung Quốc. Cùng IDC đang host dibi8.com.

Liên kết tiếp thị — không tăng chi phí của bạn, giúp dibi8.com hoạt động.

Nguồn & Tài Liệu Tham Khảo #

1. Kubeflow Official Documentation — https://www.kubeflow.org/docs/ (v1.10.0)
2. Kubeflow Pipelines SDK v2 Guide — https://www.kubeflow.org/docs/components/pipelines/v2/
3. KServe Documentation — https://kserve.github.io/website/latest/
4. Katib Hyperparameter Tuning — https://www.kubeflow.org/docs/components/katib/
5. Kubeflow Training Operator — https://www.kubeflow.org/docs/components/training/
6. Kubeflow GitHub Repository — https://github.com/kubeflow/kubeflow (14,000+ stars)
7. Kubeflow Manifests — https://github.com/kubeflow/manifests
8. “Kubeflow: Tackling ML Complexity on Kubernetes” — KubeCon EU 2025 presentation
9. Kubernetes — Hướng dẫn liên quan về Kubernetes cơ bản
10. MLflow — Hướng dẫn liên quan về ML experiment tracking

Tuyên bố tiếp thị liên kết: Bài viết này chứa các liên kết tiếp thị liên kết đến DigitalOcean. Nếu bạn đăng ký qua các liên kết này, dibi8.com nhận được hoa hồng mà không phát sinh chi phí bổ sung cho bạn. Chúng tôi chỉ giới thiệu các dịch vụ mà chúng tôi sử dụng cho chính hạ tầng của mình.