Demo Tekton Pipelines

Tekton is a Kubernetes-native CI/CD system. Rather than running an external CI server, Tekton runs as custom resources inside your cluster: controllers, Pipelines, Tasks, TaskRuns, and PipelineRuns all live in Kubernetes. Key concepts at a glance:

Resource	Purpose	Example / Notes
Task	A unit of work composed of one or more steps (containers or scripts).	Use for build/test/deploy steps.
Pipeline	A sequence that wires Tasks together and passes parameters between them.	Orchestrates Tasks and their ordering.
TaskRun / PipelineRun	Concrete executions (instances) of a Task or Pipeline.	`tkn` shows logs and status for runs.

In this guide you’ll:

Verify Tekton is running in your cluster.
Create a minimal Task and run it.
Make the Task reusable with parameters.
Build a multi-step Task (clone → build → test).
Add a deploy Task and wire everything into a Pipeline.
Run the Pipeline and view logs.

You need kubectl access to the cluster and the tkn CLI installed/configured to follow the examples that use tkn commands and --showlog. See the Tekton docs and Kubernetes docs linked in the References section below.

Examples assume resources are created in the ci-pipelines namespace. Create it beforehand if it doesn’t exist: kubectl create namespace ci-pipelines. Ensure your user has the necessary RBAC permissions to create Tekton resources and view logs.

Verify Tekton Pipelines is running

Check the Tekton pods in the tekton-pipelines namespace:

kubectl get pods -n tekton-pipelines

Example output:

NAME                                         READY   STATUS    RESTARTS   AGE
tekton-dashboard-7c54d984dd-rj9gv            1/1     Running   0          31m
tekton-events-controller-5cbc777ccd-hd47v    1/1     Running   0          31m
tekton-pipelines-controller-5f567589-1g9v    1/1     Running   0          31m
tekton-pipelines-webhook-75cd84877-mfknj     1/1     Running   0          31m

If the controllers and webhook are up and Running, you’re ready to create Tasks.

Create a minimal Task

Create hello-task.yaml with a single step that prints a message:

apiVersion: tekton.dev/v1
kind: Task
metadata:
  name: hello-task
  namespace: ci-pipelines
spec:
  steps:
    - name: say-hello
      image: alpine:3.18
      script: |
        echo "Hello from KodeKloud!"

Apply the Task:

kubectl apply -f hello-task.yaml
# task.tekton.dev/hello-task created

Start the Task and stream logs with tkn:

tkn task start hello-task -n ci-pipelines --showlog

Example output:

TaskRun started: hello-task-run-qxq4n
Waiting for logs to be available...
[say-hello] Hello from KodeKloud!

This TaskRun is an instantiation of the Task we defined.

Make the Task reusable with a parameter

Replace the hard-coded message with a message parameter so the Task can be reused:

apiVersion: tekton.dev/v1
kind: Task
metadata:
  name: hello-task
  namespace: ci-pipelines
spec:
  params:
    - name: message
      type: string
      default: "Hello from KodeKloud!"
  steps:
    - name: say-hello
      image: alpine:3.18
      script: |
        echo "$(params.message)"

Apply the updated Task:

kubectl apply -f hello-task.yaml
# task.tekton.dev/hello-task configured

Start the Task without passing a parameter — it will use the default:

tkn task start hello-task -n ci-pipelines --showlog

Output:

TaskRun started: hello-task-run-qx4h
Waiting for logs to be available...
[say-hello] Hello from KodeKloud!

Pass a custom message using -p:

tkn task start hello-task -n ci-pipelines -p message="Hello from Nourhan!" --showlog

Output:

TaskRun started: hello-task-run-rzjzf
Waiting for logs to be available...
[say-hello] Hello from Nourhan!

Note: the -p parameter format is -p name="value".

Create a multi-step build Task

A realistic CI Task runs multiple sequential steps (clone → build → test). Define a build-task that accepts an app-name parameter and runs three steps that print indicative messages: build-task.yaml:

apiVersion: tekton.dev/v1
kind: Task
metadata:
  name: build-task
  namespace: ci-pipelines
spec:
  params:
    - name: app-name
      type: string
  steps:
    - name: clone
      image: alpine:3.18
      script: |
        echo "Cloning repo for $(params.app-name)"
    - name: build
      image: alpine:3.18
      script: |
        echo "Building $(params.app-name)"
    - name: test
      image: python:3.11-alpine
      script: |
        echo "Running tests for $(params.app-name)"

Apply the Task:

kubectl apply -f build-task.yaml
# task.tekton.dev/build-task created

Start the TaskRun and pass app-name:

tkn task start build-task -n ci-pipelines -p app-name="web-server" --showlog

Output (steps run sequentially):

TaskRun started: build-task-run-sk277
Waiting for logs to be available...
[clone] Cloning repo for web-server
[build] Building web-server
[test] Running tests for web-server

Each step runs in sequence; choose images tailored to the step (e.g., a git image for clone, build tool images for compilation, test runners for tests).

Create a deploy Task

Create a Task that deploys a named app to an environment. It accepts app-name and environment (default staging). deploy-task.yaml:

apiVersion: tekton.dev/v1
kind: Task
metadata:
  name: deploy-task
  namespace: ci-pipelines
spec:
  params:
    - name: app-name
      type: string
    - name: environment
      type: string
      default: staging
  steps:
    - name: deploy
      image: alpine:3.18
      script: |
        echo "Deploying $(params.app-name) to $(params.environment)"

Apply it:

kubectl apply -f deploy-task.yaml
# task.tekton.dev/deploy-task created

Wire Tasks into a Pipeline

Create a Pipeline that runs build-task first, then deploy-task. The Pipeline accepts app-name and target-env, and passes them into the Tasks. pipeline.yaml:

apiVersion: tekton.dev/v1
kind: Pipeline
metadata:
  name: ci-pipeline
  namespace: ci-pipelines
spec:
  params:
    - name: app-name
      type: string
    - name: target-env
      type: string
      default: staging
  tasks:
    - name: build
      taskRef:
        name: build-task
      params:
        - name: app-name
          value: $(params.app-name)
    - name: deploy
      runAfter:
        - build
      taskRef:
        name: deploy-task
      params:
        - name: app-name
          value: $(params.app-name)
        - name: environment
          value: $(params.target-env)

Apply the Pipeline:

kubectl apply -f pipeline.yaml
# pipeline.tekton.dev/ci-pipeline created

Start a PipelineRun and stream logs:

tkn pipeline start ci-pipeline \
  -n ci-pipelines \
  -p app-name="webserver" \
  -p target-env="prod" \
  --showlog

Expected output:

PipelineRun started: ci-pipeline-run-vjx7b
Waiting for logs to be available...
[build : clone] Cloning repo for webserver
[build : build] Building webserver
[build : test] Running tests for webserver
[deploy : deploy] Deploying webserver to prod

The image displays the Tekton Dashboard with a list of tasks, showing task names, namespaces, and creation times. It includes options for filtering and managing tasks in a CI pipeline context.

The PipelineRun executed the build Task (three sequential steps) followed by the deploy Task. You can inspect TaskRun logs and statuses from the CLI or Dashboard.

Tekton Dashboard

Tekton provides a Dashboard UI for visualizing pipelines and runs. From the Dashboard you can:

View Pipelines, PipelineRuns, Tasks, and TaskRuns.
Inspect logs, parameters, statuses, and related Pods.
Instantiate TaskRuns and PipelineRuns (subject to cluster RBAC).

The Dashboard complements CLI workflows and is useful for debugging and auditing CI/CD runs.

Course Introduction

Platform Architecture and Infrastructure

GitOps and Continuous Delivery

Platform APIs and Self-Service Capabilities

Observability and Operations

Security and Policy Enforcement

Conclusion

Demo Tekton Pipelines

Verify Tekton Pipelines is running

Create a minimal Task

Make the Task reusable with a parameter

Create a multi-step build Task

Create a deploy Task

Wire Tasks into a Pipeline

Tekton Dashboard

Next steps and extensions

Links and References

Watch Video

Practice Lab

​Verify Tekton Pipelines is running

​Create a minimal Task

​Make the Task reusable with a parameter

​Create a multi-step build Task

​Create a deploy Task

​Wire Tasks into a Pipeline

​Tekton Dashboard

​Next steps and extensions

​Links and References

Watch Video

Practice Lab

Verify Tekton Pipelines is running

Create a minimal Task

Make the Task reusable with a parameter

Create a multi-step build Task

Create a deploy Task

Wire Tasks into a Pipeline

Tekton Dashboard

Next steps and extensions

Links and References