kubeflow
**Kubeflow** is the **cloud-native machine learning toolkit for Kubernetes that provides standardized components for ML pipelines, model serving, and notebook management** — enabling organizations running Kubernetes to orchestrate ML workflows (data prep → training → evaluation → serving) as containerized pipeline steps with the Kubeflow Pipelines engine and serve models at scale with KServe.
**What Is Kubeflow?**
- **Definition**: An open-source ML platform for Kubernetes created by Google in 2017 — providing a suite of components that run natively on Kubernetes for each stage of the ML lifecycle: Jupyter notebook servers (Notebooks), pipeline orchestration (Kubeflow Pipelines), and production model serving (KServe).
- **Kubernetes-Native Philosophy**: Every Kubeflow component is a Kubernetes custom resource — training jobs, pipeline runs, and model servers are all expressed as K8s manifests, enabling GitOps deployment, RBAC, and native integration with cluster autoscaling.
- **Kubeflow Pipelines (KFP)**: The pipeline orchestration engine — define ML workflows as Python functions decorated with @component, compile to a pipeline YAML, and submit to the KFP server which runs each step as an isolated Kubernetes Pod.
- **KServe**: A standardized model inference platform on Kubernetes — deploy models (PyTorch, TensorFlow, scikit-learn, ONNX, HuggingFace) as InferenceService custom resources with autoscaling-to-zero, canary rollouts, and custom transformers/explainers.
- **Reputation**: Powerful and comprehensive but operationally complex — "Day 2 operations" (upgrades, cert management, multi-user isolation) require significant Kubernetes expertise.
**Why Kubeflow Matters for AI**
- **Kubernetes Integration**: Organizations already running Kubernetes for application workloads use Kubeflow to run ML workloads on the same cluster — GPU nodes, storage classes, networking, and RBAC policies all reuse existing K8s infrastructure.
- **Standardized ML Pipelines**: KFP provides a reproducible, versioned pipeline format — each step runs in its own container with explicit inputs/outputs, enabling component reuse across pipelines and teams.
- **Multi-User Environment**: Kubeflow provides namespace-based multi-user isolation — each data scientist or team gets their own namespace with separate notebook servers, pipelines, and compute quotas enforced by Kubernetes RBAC.
- **KServe Autoscaling**: KServe integrates with KEDA and Knative to scale model servers from zero to N replicas based on request volume — enabling serverless-style model serving on Kubernetes with GPU support.
- **Google Cloud Integration**: Google Cloud's Vertex AI Pipelines is built on KFP — pipelines written for Kubeflow Pipelines run on both self-hosted Kubeflow and managed Vertex AI Pipelines with minimal changes.
**Kubeflow Core Components**
**Kubeflow Pipelines (KFP)**:
from kfp import dsl, compiler
@dsl.component(base_image="python:3.11", packages_to_install=["scikit-learn", "pandas"])
def preprocess(raw_data_path: str, output_path: dsl.Output[dsl.Dataset]):
import pandas as pd
df = pd.read_csv(raw_data_path)
df_clean = df.dropna()
df_clean.to_csv(output_path.path, index=False)
@dsl.component(base_image="pytorch/pytorch:2.0-cuda11.7-cudnn8-runtime")
def train_model(
dataset: dsl.Input[dsl.Dataset],
model_output: dsl.Output[dsl.Model],
learning_rate: float = 0.001
):
# Training code — runs in isolated Pod on GPU node
model = train(dataset.path, lr=learning_rate)
model.save(model_output.path)
@dsl.pipeline(name="ml-training-pipeline")
def training_pipeline(raw_data: str, lr: float = 0.001):
preprocess_task = preprocess(raw_data_path=raw_data)
train_task = train_model(
dataset=preprocess_task.outputs["output_path"],
learning_rate=lr
).set_accelerator_type("NVIDIA_TESLA_A100").set_gpu_limit(1)
compiler.Compiler().compile(training_pipeline, "pipeline.yaml")
**Kubeflow Training Operator**:
- Manages distributed training jobs as Kubernetes custom resources
- Supports: PyTorchJob (PyTorch DDP), TFJob (TensorFlow distributed), MXJob, XGBoostJob
- Handles worker Pod lifecycle, restart on failure, and gradient communication
**KServe (Model Serving)**:
apiVersion: serving.kserve.io/v1beta1
kind: InferenceService
metadata:
name: llama-server
spec:
predictor:
model:
modelFormat:
name: pytorch
storageUri: "s3://models/llama-3-8b"
resources:
limits:
nvidia.com/gpu: "1"
# Autoscales from 0 to 10 replicas based on traffic
**Kubeflow Notebooks**:
- Kubernetes-managed JupyterLab instances
- GPU-accelerated notebooks for experimentation
- PVC (Persistent Volume) for notebook file persistence
- Multi-user isolation via Kubernetes namespaces
**Kubeflow Operational Complexity**
**What It Requires**:
- Working Kubernetes cluster (EKS, GKE, AKS, or on-premises)
- Knative Serving for KServe autoscaling
- Cert-manager for TLS certificates
- Dex / OIDC for authentication
- Istio (optional) for advanced traffic management
**Managed Alternatives**:
- Vertex AI Pipelines (GCP): Managed KFP, no cluster management
- AWS SageMaker Pipelines: Managed alternative on AWS
- Databricks: Managed alternative without K8s knowledge required
**Kubeflow vs Alternatives**
| Tool | K8s Required | Setup Complexity | GPU Support | Best For |
|------|-------------|-----------------|------------|---------|
| Kubeflow | Yes | Very High | Excellent | K8s-native orgs |
| Airflow | Optional | High | Via operators | Complex ETL + ML |
| Prefect | Optional | Low | Via K8s worker | Python-first teams |
| Vertex AI | No | Low | Managed | Google Cloud users |
| SageMaker | No | Medium | Managed | AWS users |
Kubeflow is **the Kubernetes-native ML platform for organizations that need deep cloud-infrastructure integration for their AI workflows** — by expressing every ML step as a Kubernetes-native resource with containerized execution, Kubeflow enables teams already invested in Kubernetes to run reproducible, scalable ML pipelines without adopting a separate orchestration system outside their existing infrastructure.