Demo Customizing Component Image

Welcome — in this lesson you’ll build a Kubeflow Pipeline (KFP) component that trains a simple classifier on the classic Iris dataset, run the component locally (each component executes in its own container), and learn how to customize the component image by installing additional Python packages. This guide covers:

A minimal KFP component that trains a DecisionTree on the Iris dataset.
How to run the component locally using Docker.
The common failure when required packages are missing and how to fix it with packages_to_install.
A fully working script and expected runtime behavior.

Relevant links:

Dataset overview

The Iris dataset contains feature vectors (iris.data) and class labels (iris.target).
In this example we train a DecisionTreeClassifier and predict the class for a single sample.

Minimal KFP component (initial example)

This minimal component uses the python:3.10-slim base image. Many minimal Python images do not include scientific libraries such as scikit-learn, so this example may fail unless scikit-learn is available in the image.

from kfp import dsl

@dsl.component(
    base_image="python:3.10-slim",
)
def classify_iris() -> str:
    from sklearn.datasets import load_iris
    from sklearn.tree import DecisionTreeClassifier

    # Load data
    iris = load_iris()

    # Train a simple model
    model = DecisionTreeClassifier()
    model.fit(iris.data, iris.target)

    # Predict one flower
    flower = [[5.1, 3.5, 1.4, 0.2]]
    prediction = model.predict(flower)[0]

    result = iris.target_names[prediction]

    print(f"Prediction: {result}")

    return result

Run the component locally using Docker

During development it’s convenient to run KFP components locally. Use kfp.local with DockerRunner() so each component runs in its own Docker container.

from kfp import local

# Tell KFP to execute components using Docker
local.init(
    runner=local.DockerRunner()
)

# Invoke the component (this will execute it in a container)
task = classify_iris()

# Print the final result of the component execution
print(f"\nFinal result: {task.output}")

What happens when a required package is missing

If the base image doesn’t include scikit-learn, the component container will fail with a ModuleNotFoundError. Typical error lines:

ModuleNotFoundError: No module named 'sklearn'
Traceback (most recent call last):
  File "/tmp/tmp.../ephemeral_component.py", line 8, in classify_iris
    from sklearn.datasets import load_iris
ModuleNotFoundError: No module named 'sklearn'

Cause

The python:3.10-slim image is intentionally minimal and does not ship with many ML libraries.

Fix

The @dsl.component decorator accepts a packages_to_install argument. KFP will run pip install for the listed packages inside the component container at startup. Use packages_to_install to install scikit-learn (or any other required packages) before your component code executes.

Use packages_to_install when your component imports libraries that are not included in the base image. This runs pip install inside the component container at startup.

Corrected full script (working version)

Below is the complete working script that initializes the local Docker runner and installs scikit-learn inside the component container before execution.

from kfp import dsl, local

# Tell KFP to execute components using Docker
local.init(
    runner=local.DockerRunner()
)

@dsl.component(
    base_image="python:3.10-slim",
    packages_to_install=["scikit-learn"]
)
def classify_iris() -> str:
    from sklearn.datasets import load_iris
    from sklearn.tree import DecisionTreeClassifier

    # Load data
    iris = load_iris()

    # Train a simple model
    model = DecisionTreeClassifier()
    model.fit(iris.data, iris.target)

    # Predict one flower
    flower = [[5.1, 3.5, 1.4, 0.2]]
    prediction = model.predict(flower)[0]

    result = iris.target_names[prediction]

    print(f"Prediction: {result}")

    return result

# Run the component locally
task = classify_iris()

# Print the final result (the output parameter)
print(f"\nFinal result: {task.output}")

Expected runtime behavior

When you run the corrected script:

KFP pulls the python:3.10-slim base image (if not already present).
KFP installs scikit-learn inside the container (via pip).
The component code runs and prints the prediction.
The component returns the result as an output parameter.

Example summarized output:

Pulling image python:3.10-slim ...
Installing packages: scikit-learn ...
Prediction: setosa

Final result: setosa

Local output parameter (JSON):

{"parameterValues": {"Output": "setosa"}}

Quick reference

Topic	Description	Example
Base image	Minimal container image to run the component	`base_image="python:3.10-slim"`
Install packages	Packages installed at component startup via pip	`packages_to_install=["scikit-learn"]`
Local execution	Run components locally, each in its own Docker container	`local.init(runner=local.DockerRunner())`
Output parameter	The returned value from the component (accessible as `task.output`)	`{"parameterValues": {"Output": "setosa"}}`

Summary

Define components with @dsl.component(base_image=...).
If your component imports packages not present in the base image, add them to packages_to_install=[...].
Use kfp.local plus DockerRunner() to run and test components locally before deploying to a cluster.

Course Introduction

Fundamentals of Kubeflow

Working With Kubeflow

KServe and Katib

Profiles and Multi-Tenancy

Bringing It All Together

Demo Customizing Component Image

Dataset overview

Minimal KFP component (initial example)

Run the component locally using Docker

What happens when a required package is missing

Cause

Fix

Corrected full script (working version)

Expected runtime behavior

Quick reference

Summary

Links and references

Watch Video

​Dataset overview

​Minimal KFP component (initial example)

​Run the component locally using Docker

​What happens when a required package is missing

​Cause

​Fix

​Corrected full script (working version)

​Expected runtime behavior

​Quick reference

​Summary

​Links and references

Watch Video

Dataset overview

Minimal KFP component (initial example)

Run the component locally using Docker

What happens when a required package is missing

Cause

Fix

Corrected full script (working version)

Expected runtime behavior

Quick reference

Summary

Links and references