Principle:SeldonIO Seldon core Pipeline Deployment Execution

Field	Value
Principle Name	Pipeline Deployment Execution
Overview	The process of registering and activating an inference pipeline on the Seldon Core 2 scheduler.
Domains	MLOps, Kubernetes
Related Implementation	SeldonIO_Seldon_core_Seldon_Pipeline_Load
Last Updated	2026-02-13 00:00 GMT

Description

Deploying a pipeline submits the Pipeline CRD to the scheduler, which validates that all referenced model steps are available, creates Kafka topics for inter-step data flow, and activates the pipeline for inference requests. This is the transition from a declarative pipeline definition (YAML) to a running, inference-ready system.

The deployment process involves several coordinated actions:

• Validation: The scheduler validates the Pipeline CRD structure, ensuring that the DAG is acyclic, all referenced model names correspond to loaded models, and tensor mappings reference valid output tensor names.
• Topic Creation: For each edge in the pipeline DAG, the scheduler creates (or reuses) Kafka topics that carry inference data between steps. Each topic is named according to the pipeline and step names.
• State Reconciliation: The scheduler continuously reconciles the desired state (Pipeline CRD) with the actual state (running pipeline infrastructure). If a referenced model becomes unavailable, the pipeline transitions to an unhealthy state.
• Version Management: Each pipeline load creates a new pipeline version. The scheduler tracks version history and supports rollback.

Theoretical Basis

Pipeline deployment follows the same declarative reconciliation pattern as models but at a higher level of abstraction. The scheduler must resolve all step dependencies before the pipeline becomes ready. This is an application of the Kubernetes reconciliation loop pattern:

• Desired State Declaration: The Pipeline CRD expresses the desired state (what models should be connected, how data should flow).
• Actual State Observation: The scheduler observes the current state of models, Kafka topics, and pipeline versions.
• Reconciliation: The scheduler takes actions to bring actual state in line with desired state (create topics, wire connections, update versions).
• Dependency Resolution: Unlike model deployment (which is self-contained), pipeline deployment has external dependencies on model availability. The scheduler must check that all spec.steps[].name references resolve to loaded models.

This two-level abstraction (models as primitives, pipelines as compositions) follows the composite pattern from software engineering, where complex structures are built from well-defined components with clear interfaces.

When to Use

Use this principle after defining a Pipeline CRD and ensuring all component models are deployed:

• When activating a newly created pipeline definition.
• When updating an existing pipeline's topology (the scheduler creates a new version).
• When redeploying a pipeline after a model update or infrastructure change.
• When migrating pipelines between environments (dev, staging, production).

Structure

The deployment execution sequence:

1. Submit Pipeline CRD: Use seldon pipeline load or kubectl apply to submit the manifest.
2. Scheduler Validation: The scheduler validates the DAG structure and model references.
3. Infrastructure Provisioning: Kafka topics are created for inter-step communication.
4. Pipeline Activation: The pipeline transitions through states: Creating then PipelineReady (or Failed if validation or provisioning fails).
5. Readiness Confirmation: Verify the pipeline is ready before sending inference requests.

Related Pages

• SeldonIO_Seldon_core_Seldon_Pipeline_Load - implements - Concrete CLI tool for submitting pipeline manifests to the scheduler.
• SeldonIO_Seldon_core_Component_Model_Deployment - prerequisite - All component models must be deployed before pipeline activation.
• SeldonIO_Seldon_core_Pipeline_Topology_Definition - prerequisite - The pipeline topology must be defined before deployment.
• SeldonIO_Seldon_core_Pipeline_Readiness_Verification - next step - Confirming the pipeline is ready after deployment.

Implementation:SeldonIO_Seldon_core_Seldon_Pipeline_Load