Updated on 2026-06-16 GMT+08:00

Kubeflow Add-on

With the increasing volume of models and data, efficiently building, deploying, and managing complex machine learning workflows becomes increasingly challenging.

  • There is no unified platform that can effectively manage complex machine learning tasks.
  • It is difficult to track and manage dependencies and data flows between various components.
  • Repeated execution of the same tasks wastes computing resources.
  • Workflows cannot be easily migrated between different computing environments, which lacks flexibility.

To address these challenges, CCE standard and Turbo clusters offer the Kubeflow add-on based on Kubeflow. Kubeflow is an open-source machine learning platform designed for Kubernetes, simplifying the development, deployment, and management of machine learning workflows. It offers developers and data scientists a consistent, scalable framework for running machine learning tasks and applications on Kubernetes. Backed on Kubeflow, this add-on offers the following features:

  • Simplified machine learning workflow development and management: You can quickly define and manage complex machine learning workflows through an intuitive UI and Python SDKs.
  • Improved resource utilization: Redundant computing is reduced through task parallelization and caching to enhance resource efficiency.
  • Enhanced workflow portability: You can easily migrate workflows between different environments using platform-neutral IR YAML definitions.
  • Enhanced management and visualization capabilities: This add-on provides robust tools for managing and visualizing workflows to help you track and optimize them more effectively.

Fundamental Concepts

Table 1 Basic concepts of the add-on

Concept

Description

Function

Pipeline

A sequence of machine learning steps, typically including data preprocessing, training, evaluation, and inference. The Kubeflow add-on uses pipelines to automate and manage the full machine learning lifecycle.

Workflows can be defined via GUI or YAML files, automating step execution and enabling efficient scheduling and execution of complex tasks on Kubernetes.

Run

An instance of pipeline execution, indicating the running of a specific workflow. Each run is an execution of the pipeline, recording its input parameters, execution status, and output results.

Runs execute machine learning tasks with varying inputs or datasets. They allow you to track execution progress and results, manage versions, and compare experiments.

Experiment

A logical group of multiple runs, usually with varied settings or hyperparameters for the same problem. You can use experiments to organize runs and compare results.

Experiments allow you to compare and track the execution results of different machine learning tasks. By organizing multiple runs, you can analyze the impact of various parameters and settings on model performance, enabling precise model and performance optimization.

Component

The smallest unit in a pipeline, representing a specific machine learning task or step, like data preprocessing, model training, or evaluation. Each component is a container holding the code and dependencies needed to execute the task.

Components enable independent definition and management of each pipeline step, which can be reused across different pipelines. This modular design simplifies pipeline building, debugging, and extension.

DAG

A graph that represents task dependencies in Kubeflow pipelines. It defines the execution sequence and component dependencies.

A DAG ensures tasks run in the correct order without cyclic dependencies. It enables Kubeflow pipelines to manage dependencies efficiently for optimal workflow execution.

For more details, see Kubeflow Pipeline Concepts.

Prerequisites

  • A CCE standard or Turbo cluster v1.29 or later is available. For details, see Buying a Standard/Turbo Cluster.
  • Before installing the add-on, ensure that the cluster's pods can access the Internet to download required images. You can configure an SNAT rule for the cluster to ensure that pods can access the Internet. You will be billed for the SNAT rule. For details, see NAT Gateway Price Calculator.
  • In the use case described in this section, a NodePort Service is required to access the Kubeflow web UI. Ensure an EIP is bound to any node in the cluster. The EIP will be billed. For details, see Elastic IP Price Calculator.

Notes and Constraints

  • Kubeflow pipelines run only on x86 nodes.
  • This add-on is in initial rollout. Check the console for supported regions.
  • This add-on is in OBT. You can access the latest features, but stability is not fully verified and no CCE SLA applies.

Installing the Add-on

  1. Log in to the CCE console and click the cluster name to access the cluster console.
  2. In the navigation pane, choose Add-ons. On the displayed page, locate Kubeflow and click Install.
  3. On the Install Add-on page, configure the add-on specifications.

    Table 2 Add-on settings

    Parameter

    Description

    Version

    Select a version as needed.

    Add-on Specifications

    Only the default specifications are supported.

  4. In the Parameters area, properly configure the parameters below based on applications.

    Parameter

    Format

    Description

    minioAK

    Length: at least 3 characters

    The client identity used for MinIO storage authentication. Use minio or a custom account.

    minioSK

    Length: at least 8 characters

    An important credential, which is used with the AK.

    mysqlPassword

    Complex, long password

    MySQL root password. The password for the MySQL root user. Use a strong password.

    mysqlUsername

    root (default value)

    Database user. Retain the default value.

  5. Click Install in the lower right corner. If the status is Running, the add-on has been installed.

Components

Component

Description

Resource Type

cache-deployer

Set up cache-related configurations, including PVCs and ConfigMaps, and inject them into the cluster to enable caching for pipeline runs.

Deployment

cache-server

Provide caching to prevent repeated execution of completed pipeline steps, thereby improving running efficiency.

Deployment

metadata-envoy

Collect, process, and forward metadata to the specified metadata store during pipeline execution.

Deployment

ml_metadata_store_server

A metadata storage server that stores information related to pipeline execution, including inputs, outputs, and models.

Deployment

metadata-writer

Record pipeline execution metadata to the metadata store.

Deployment

minio

An object storage service used to store artifacts generated during pipeline execution, such as models and data.

Deployment

api-server

Provide REST and gRPC APIs to enable communication between the SDK, UI, and backend.

Deployment

persistenceagent

Store pipeline execution records in the database and restore running statuses.

Deployment

scheduledworkflow

Periodically trigger pipelines to automate workflow execution.

Deployment

ml-pipeline-ui

Provide a frontend web interface for you to view and manage pipelines and their execution records.

Deployment

viewer-crd-controller

Manage viewer Custom Resource Definitions (CRDs) and visualize artifacts such as images and tables on the UI.

Deployment

visualization-server

Used with the viewer to visualize data, including TensorBoard and ROC curves.

Deployment

mysql

The relational database used by Kubeflow Pipelines to store running records and user information.

Deployment

workflow-controller

The core component of Argo, which schedules and executes each task (step) in a pipeline.

Deployment

  • All preceding components are deployed in the kubeflow namespace.
  • Components like Minio and MySQL provide dependencies for Kubeflow Pipelines and can be replaced as needed.

MySQL and Minio backend PVs are bound to emptyDir volumes. If pods are migrated or restarted, unexpected results may occur.

Use Case

This case describes how to use the Kubeflow add-on to run a simple pipeline, as shown in Figure 1. The pipeline includes a whalesay task that runs an Alpine container executing echo "hello world" to stdout.

Figure 1 Execution process of the case
  1. Install kubectl on an existing ECS and use kubectl to access the target cluster. For details, see Accessing a Cluster Using kubectl.
  2. After the Kubeflow add-on is installed, CCE automatically creates the ml-pipeline-ui component to provide the frontend web interface. This component is automatically bound to a ClusterIP Service named ml-pipeline-ui. To access the UI, change the Service type of ml-pipeline-ui from ClusterIP to NodePort or LoadBalancer. The following uses a NodePort Service as an example.

    Run the following command to change the ClusterIP Service to a NodePort Service:
    kubectl edit svc ml-pipeline-ui -n kubeflow

    Set type to NodePort in the file and specify a node port that does not conflict with other services in the cluster. For details about NodePort Services, see NodePort.

    ...
    spec:
      ports:
        - name: http
          protocol: TCP
          port: 80
          targetPort: 3000
          nodePort: 30083 # Node port number
      selector:
        app: ml-pipeline-ui
        application-crd-id: kubeflow-pipelines
      clusterIP: 10.247.101.116
      clusterIPs:
        - 10.247.101.116
      type: NodePort # Change ClusterIP to NodePort.
      sessionAffinity: None
    ...

  3. Enter http://<EIP of the target node>:<Node port>/ in the address bar of a browser to access the Kubeflow UI. On the UI, you can create and manage machine learning pipelines, define complete workflows including data preprocessing, model training, evaluation, and deployment. You can also configure and launch runs, monitor task execution in real time, and view logs and visualizations. This enables the automatic orchestration and execution of machine learning workflows.

    If the following page is displayed, the UI has been accessed.

    Figure 2 Kubeflow add-on UI

  4. Create a pipeline.yaml file locally to configure a pipeline. This example deploys a pipeline that runs an Alpine container outputting "hello world" to verify your environment. For more information about pipelines, see Compile a Pipeline.

    pipeline.yaml file content:
    apiVersion: argoproj.io/v1alpha1
    kind: Workflow
    metadata:
      generateName: hello-world-
    spec:
      entrypoint: whalesay
      templates:
      - name: whalesay
        container:
          image: alpine
          command: [echo]
          args: ["hello world"]

  5. Return to the UI and click Upload pipeline in the upper right corner to upload the pipeline.yaml file. After the configuration is complete, click Create in the lower part to create a pipeline.

    Figure 3 Uploading a pipeline file

  6. After the pipeline is created, the whalesay task is automatically displayed on the UI. Click Create run in the upper right corner to create a run. After the configuration is complete, click Start in the lower part to run the pipeline.

    Figure 4 Creating a run

  7. Click whalesay to view its status.

    Figure 5 Viewing the task status

Release History

Table 3 Kubeflow add-on

Add-on Version

Supported Cluster Version

What's New

1.1.8

v1.29 or later

ML workflows can be defined and deployed.

1.1.6

  • v1.27
  • v1.28
  • v1.29
  • v1.30
  • v1.31

CCE standard and Turbo clusters support the Kubeflow add-on.

NOTE:

Only existing v1.27 and v1.28 clusters are supported.