Quick Start Guide

B.2b Optional: Bootstrap Camel K (Pipe & Kamelet)

Required once per namespace before deploying Pipe or Kamelet examples (etl-pipe, s3-to-db-kamelet):

oc apply -f k8s/bootstrap/camel-k-platform.yaml

TOKEN=$(oc whoami -t)
oc create secret docker-registry camel-k-registry-auth \
  -n openshift-integration \
  --docker-server=image-registry.openshift-image-registry.svc:5000 \
  --docker-username=$(oc whoami) \
  --docker-password="$TOKEN" \
  --dry-run=client -o yaml | oc apply -f -

oc patch integrationplatform camel-k -n openshift-integration --type=merge \
  -p '{"spec":{"build":{"registry":{"secret":"camel-k-registry-auth"}}}}'

B.2c Optional: Deploy 8 GitOps Catalog Examples

Pre-built examples in k8s/examples/ exercise the full pipeline (Gitea → Tekton → Argo CD). Apply sequentially (~12s between flows to avoid Gitea contention):

for yaml in 01-rest-to-kafka 02-order-routing-cbr 03-parallel-enrichment \
  04-error-handling-dlq 05-s3-to-db-kamelet 06-etl-pipe \
  07-file-processor-workflow 08-saga-workflow; do
  oc apply -f "k8s/examples/${yaml}.yaml"
  sleep 12
done

oc get integrationflow -n openshift-integration

Expected result: all eight flows reach Running phase. Examples 01–04 and 07–08 are Camel routes (worker Deployments); 05–06 use Camel K (Kamelet/Pipe). Each flow uses spec.targeting.strategy: explicit and clusters: [local] for single-cluster Argo CD sync.

B.3 GitOps IntegrationFlow Examples

The platform supports 5 integration types: Camel Route, Kamelet, Pipe, Test, and SonataFlow. Below are production-ready examples for each type.

1. Camel Route — REST to Kafka

apiVersion: platform.io/v1alpha1
kind: IntegrationFlow
metadata:
  name: rest-to-kafka
  namespace: openshift-integration
spec:
  deploymentMode: GITOPS
  integrationType: CAMEL_ROUTE
  engine: CAMEL
  gitRepository: https://gitea.example.com/user1/rest-to-kafka
  branch: main
  targeting:
    strategy: explicit
    clusters: [local]
  kaotoDesign: |
    - route:
        id: rest-to-kafka
        from:
          uri: "platform-http:/api/ingest"
          steps:
            - log:
                message: "Received: ${body}"
            - to:
                uri: "kafka:integration-events?brokers=my-cluster-kafka-bootstrap:9092"

2. Camel Route — Content-Based Routing (CBR)

apiVersion: platform.io/v1alpha1
kind: IntegrationFlow
metadata:
  name: order-routing-cbr
  namespace: openshift-integration
spec:
  deploymentMode: GITOPS
  integrationType: CAMEL_ROUTE
  engine: CAMEL
  gitRepository: https://gitea.example.com/user1/order-routing-cbr
  branch: main
  targeting:
    strategy: explicit
    clusters: [local]
  kaotoDesign: |
    - route:
        id: order-routing-cbr
        from:
          uri: "platform-http:/api/orders"
          steps:
            - log:
                message: "Received order: ${body}"
            - unmarshal:
                json: {}
            - choice:
                when:
                  - simple: "${body[priority]} == 'high'"
                    steps:
                      - log:
                          message: "CRITICAL: order = fast-track"
                      - setHeader:
                          name: CamelKafkaTopic
                          simple: "orders-priority"
                otherwise:
                  steps:
                    - log:
                        message: "Standard order processing"
                    - setHeader:
                        name: CamelKafkaTopic
                        simple: "orders-standard"

3. Camel Route — Parallel Enrichment

apiVersion: platform.io/v1alpha1
kind: IntegrationFlow
metadata:
  name: parallel-enrichment
  namespace: openshift-integration
spec:
  deploymentMode: GITOPS
  integrationType: CAMEL_ROUTE
  engine: CAMEL
  gitRepository: https://gitea.example.com/user1/parallel-enrichment
  branch: main
  targeting:
    strategy: explicit
    clusters: [local]
  kaotoDesign: |
    - route:
        id: parallel-enrichment
        from:
          uri: "platform-http:/api/enrich"
          steps:
            - log:
                message: "Enriching: ${body}"
            - multicast:
                parallelProcessing: true
                steps:
                  - to: "direct:enrich-geo"
                  - to: "direct:enrich-credit"
                  - to: "direct:enrich-inventory"
            - log:
                message: "Enrichment complete"

4. Camel Route — Error Handling with DLQ

apiVersion: platform.io/v1alpha1
kind: IntegrationFlow
metadata:
  name: error-handling-dlq
  namespace: openshift-integration
spec:
  deploymentMode: GITOPS
  integrationType: CAMEL_ROUTE
  engine: CAMEL
  gitRepository: https://gitea.example.com/user1/error-handling-dlq
  branch: main
  targeting:
    strategy: explicit
    clusters: [local]
  kaotoDesign: |
    - route:
        id: error-handling-dlq
        from:
          uri: "platform-http:/api/process"
          steps:
            - doTry:
                steps:
                  - log:
                      message: "Processing: ${body}"
                  - to:
                      uri: "direct:risky-operation"
                doCatch:
                  - exception: [java.lang.Exception]
                    steps:
                      - log:
                          message: "Error! Sending to DLQ"
                      - to:
                          uri: "kafka:dead-letter-queue?brokers=my-cluster-kafka-bootstrap:9092"
                doFinally:
                  steps:
                    - log:
                        message: "Processing finished"

5. Kamelet — S3 to Database

apiVersion: platform.io/v1alpha1
kind: IntegrationFlow
metadata:
  name: s3-to-db-kamelet
  namespace: openshift-integration
spec:
  deploymentMode: GITOPS
  integrationType: CAMEL_KAMELET
  engine: CAMEL
  gitRepository: https://gitea.example.com/user1/s3-to-db-kamelet
  branch: main
  targeting:
    strategy: explicit
    clusters: [local]
  kaotoDesign: |
    - route:
        id: s3-to-db-kamelet
        from:
          uri: "kamelet:aws-s3-source"
          parameters:
            bucketNameOrArn: my-data-bucket
            region: us-east-1
            deleteAfterRead: true
          steps:
            - unmarshal:
                json:
                  unmarshalType: java.util.Map
            - log:
                message: "Processing S3 object: ${header.CamelAwsS3Key}"
            - to:
                uri: "kamelet:postgresql-sink"
                parameters:
                  serverName: postgres.svc
                  serverPort: "5432"
                  databaseName: integration_db
                  query: "INSERT INTO s3_imports(key, data, imported_at) VALUES (:#key, :#data, NOW())"

6. Pipe — ETL Pipeline

apiVersion: platform.io/v1alpha1
kind: IntegrationFlow
metadata:
  name: etl-pipe
  namespace: openshift-integration
spec:
  deploymentMode: GITOPS
  integrationType: CAMEL_PIPE
  engine: CAMEL
  gitRepository: https://gitea.example.com/user1/etl-pipe
  branch: main
  targeting:
    strategy: explicit
    clusters: [local]
  kaotoDesign: |
    - route:
        id: etl-pipe
        from:
          uri: "timer:etl-trigger"
          parameters:
            period: 60000
          steps:
            - to:
                uri: "sql:SELECT * FROM source_table WHERE processed = false?dataSource=sourceDS"
            - split:
                simple: "${body}"
                steps:
                  - marshal:
                      json: {}
                  - log:
                      message: "ETL row: ${body}"
                  - to:
                      uri: "sql:INSERT INTO target_table(data, etl_time) VALUES (:#data, NOW())?dataSource=targetDS"

7. Camel Route — File Processor with CSV + CBR

Reads CSV files from /data/inbox, unmarshals each row, and routes records by status using content-based routing (choice). Uses engine: CAMEL — the operator scaffolds a Quarkus Camel project.

apiVersion: platform.io/v1alpha1
kind: IntegrationFlow
metadata:
  name: file-processor-workflow
  namespace: openshift-integration
spec:
  deploymentMode: GITOPS
  integrationType: CAMEL_ROUTE
  engine: CAMEL
  gitRepository: https://gitea.example.com/user1/file-processor-workflow
  branch: main
  targeting:
    strategy: explicit
    clusters: [local]
  kaotoDesign: |
    - route:
        id: file-processor-workflow
        from:
          uri: "file:/data/inbox?noop=true&include=.*\\.csv"
          steps:
            - unmarshal:
                csv:
                  useMaps: true
            - split:
                simple: "${body}"
                steps:
                  - choice:
                      when:
                        - simple: "${body[status]} == 'ACTIVE'"
                          steps:
                            - log:
                                message: "Active record: ${body[id]} — ${body[name]}"
                            - to:
                                uri: "direct:process-active"
                        - simple: "${body[status]} == 'PENDING'"
                          steps:
                            - log:
                                message: "Pending record: ${body[id]} — queued for review"
                            - to:
                                uri: "direct:queue-review"
                      otherwise:
                        steps:
                          - log:
                              message: "Skipping inactive record: ${body[id]}"
                          - to:
                              uri: "file:/data/archive"

8. Camel Route — Saga Orchestration

Implements the Saga EIP for distributed transactions with automatic compensation. Each step defines a compensating action that runs if a later step fails.

apiVersion: platform.io/v1alpha1
kind: IntegrationFlow
metadata:
  name: saga-workflow
  namespace: openshift-integration
spec:
  deploymentMode: GITOPS
  integrationType: CAMEL_ROUTE
  engine: CAMEL
  gitRepository: https://gitea.example.com/user1/saga-workflow
  branch: main
  targeting:
    strategy: explicit
    clusters: [local]
  kaotoDesign: |
    - route:
        id: saga-workflow
        from:
          uri: "platform-http:/api/orders/create"
          steps:
            - saga:
                propagation: REQUIRED
                completionMode: AUTO
                steps:
                  - to:
                      uri: "direct:reserve-inventory"
                  - to:
                      uri: "direct:charge-payment"
                  - to:
                      uri: "direct:schedule-shipping"
            - log:
                message: "Saga completed for order: ${header.orderId}"
    - route:
        id: reserve-inventory
        from:
          uri: "direct:reserve-inventory"
          steps:
            - log:
                message: "Reserving inventory for ${header.orderId}"
            - saga:
                option:
                  - key: compensate
                    value: "direct:cancel-inventory"
            - to:
                uri: "http://inventory-service:8080/api/reserve"
    - route:
        id: cancel-inventory
        from:
          uri: "direct:cancel-inventory"
          steps:
            - log:
                message: "COMPENSATING: releasing inventory for ${header.orderId}"
            - to:
                uri: "http://inventory-service:8080/api/release"

Ephemeral Quick Try (see Track A)

Use k8s/examples/09-ephemeral-demo.yaml or the console Quick Try toggle — covered in Track A.

Promote Ephemeral to GitOps

When an ephemeral flow is running, click Promote to GitOps in the console plugin (or call the REST API). The operator creates a Git repository, pushes the scaffolded source, and converts the CR to deploymentMode: GITOPS — triggering Tekton build and ArgoCD sync automatically.

# REST API equivalent
curl -X POST "https://<operator>/api/flows/ephemeral-camel-demo/promote-to-gitops"   -H "Content-Type: application/json"   -d '{"gitRepository":"https://gitea.example.com/user1/my-flow","branch":"main"}'

Multicluster with Label Selector

apiVersion: platform.io/v1alpha1
kind: IntegrationFlow
metadata:
  name: multicluster-flow
  namespace: openshift-integration
spec:
  deploymentMode: GITOPS
  integrationType: CAMEL_ROUTE
  engine: CAMEL
  gitRepository: https://gitea.example.com/user1/multicluster-flow
  branch: main
  targeting:
    strategy: selector
    clusterSelector:
      matchLabels:
        env: production
        region: us-east
  kaotoDesign: |
    - route:
        id: multicluster-flow
        from:
          uri: "timer:tick?period=30000"
          steps:
            - log:
                message: "Running on production clusters in us-east"

Apply any example with:

oc apply -f integrationflow.yaml

# Watch reconciliation progress
oc get integrationflows -n openshift-integration -w

Expected status phases: Scaffolding → Building → Deploying → Running.

B.4 Verify Deployment

Confirm the operator, CRD, and IntegrationFlow status:

# Check operator pods
oc get pods -n openshift-integration

# Verify CRD is registered
oc get crd integrationflows.platform.io

# Watch IntegrationFlow status
oc get integrationflows -n openshift-integration
oc describe integrationflow sample-camel-flow -n openshift-integration

# Check Tekton PipelineRun
oc get pipelineruns -n openshift-integration -l platform.io/component=build

# Verify worker deployment (after ArgoCD sync)
oc get deployments -n openshift-integration

Expected status phases: Scaffolding → Building → Deploying → Running.

B.5 Access the Console Plugin

The OpenShift Console plugin adds an Integration Platform section with Integration Flows navigation.

# Verify ConsolePlugin is enabled
oc get consoleplugin -n openshift-integration

# Check plugin pod status
oc get pods -n openshift-integration -l app.kubernetes.io/component=console-plugin

Open the OpenShift Console and navigate to Integration Platform → Integration Flows.

List Page Features

• Browse Templates — Pick from 250+ ready flows in the create form (backed by flow-catalog.json)
• Search — Filter by name, repository URL, or status message
• Filters — Filter by integration type (CAMEL_ROUTE, CAMEL_KAMELET, etc.) and phase (Running, Building, Error)
• Summary badges — Click on Running/Building/Error counts to quick-filter
• Pagination — Navigate large lists of flows with page controls
• Resource links — Direct links to Pods, Tekton PipelineRuns, and ArgoCD Applications per flow

Flow Detail Page

• Visual Flow — SVG-based diagram with branching logic (choice, multicast, doTry), click a node to highlight the corresponding YAML section
• YAML Editor — View and edit the raw kaotoDesign YAML
• Kaoto Designer — Embedded drag-and-drop Kaoto canvas (for Camel flows)
• SonataFlow Console — Embedded SonataFlow Management Console (for SonataFlow workflows)
• Logs — Live worker pod logs with container selector, tail lines, and follow mode (GitOps and ephemeral flows)
• Telemetry Overlay — Real-time SSE metrics per node with green/amber/red status
• Quick Try UI — Ephemeral badge with TTL countdown, extend TTL, and promote to GitOps modals on ephemeral flows

Direct routes:

• /integration-flows — List all IntegrationFlows
• /integration-flows/<name> — Flow designer with visual flow, Kaoto, and telemetry