Demo Tekton Pipelines

Tekton is a Kubernetes-native CI/CD system that runs entirely inside your cluster. Controllers, pipeline and task definitions, and their executions (TaskRuns and PipelineRuns) are Kubernetes custom resources — there is no separate external CI server to manage. Key concepts:

Resource	Purpose	Example
Task	A collection of sequential container steps (a single CI job)	`Task` that builds and tests an app
Pipeline	Composes Tasks and controls execution order	`Pipeline` that runs build then deploy
TaskRun / PipelineRun	Runtime instantiations that create pods and execute steps	`TaskRun` that executes a `Task`

Useful links:

Before creating Tasks and Pipelines, make sure Tekton Pipelines controllers and webhook are installed in the tekton-pipelines namespace and that you have a working tkn CLI. Also create the namespace you will use for your CI resources:

kubectl create namespace ci-pipelines

Verifying Tekton control plane

Check the Tekton Pipelines namespace to ensure the controllers and webhook pods are running:

kubectl get pods -n tekton-pipelines

Example output:

NAME                                              READY   STATUS    RESTARTS   AGE
tekton-dashboard-7c54d984dd-r9jgv                 1/1     Running   0          31m
tekton-events-controller-5cbc777ccd-hd47v         1/1     Running   0          31m
tekton-pipelines-controller-65f567589b-lgv9v      1/1     Running   0          31m
tekton-pipelines-webhook-75cd84877-mfnkj          1/1     Running   0          31m

That minimal set (controllers + webhook — dashboard optional) is required to run Tekton pipelines in your cluster.

Creating a minimal Task

Start with a simple Task that runs one step and prints a message. Save this as hello-task.yaml:

apiVersion: tekton.dev/v1beta1
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 and run a TaskRun using tkn:

kubectl apply -f hello-task.yaml
tkn task start hello-task -n ci-pipelines --showlog

Example sequence and output:

task.tekton.dev/hello-task created
TaskRun started: hello-task-run-qqx4n
Waiting for logs to be available...
[say-hello] Hello from Kodekloud!

This demonstrates a TaskRun: the runtime object that spawned a pod to execute the Task’s steps.

Parameterizing a Task

Make the Task reusable by adding a parameter. Update hello-task.yaml to include a message parameter:

apiVersion: tekton.dev/v1beta1
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

Start a TaskRun that uses the default parameter:

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

Output:

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

Pass a custom value using -p:

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

Output:

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

A Task with multiple steps

Real CI jobs typically include multiple sequential steps (clone, build, test). Group related steps into one Task when appropriate — here is build-task.yaml:

apiVersion: tekton.dev/v1beta1
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

Start a TaskRun and pass the app-name parameter:

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

Example output:

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

Steps run sequentially (top to bottom) within a Task.

Creating a deploy Task

Keep deployment logic separate as its own Task. Save as deploy-task.yaml:

apiVersion: tekton.dev/v1beta1
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 the Task:

kubectl apply -f deploy-task.yaml

Wiring Tasks together with a Pipeline

Compose build-task and deploy-task into a Pipeline so they run in sequence. Save as ci-pipeline.yaml:

apiVersion: tekton.dev/v1beta1
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
      taskRef:
        name: deploy-task
      runAfter:
        - build
      params:
        - name: app-name
          value: $(params.app-name)
        - name: environment
          value: $(params.target-env)

Apply the Pipeline:

kubectl apply -f ci-pipeline.yaml

Start a PipelineRun with parameters and follow logs:

tkn pipeline start ci-pipeline -n ci-pipelines \
  -p app-name="web-server" \
  -p target-env="production" \
  --showlog

You should see the build TaskRun run its clone, build, test steps first, then the deploy TaskRun execute. Example condensed output:

PipelineRun started: ci-pipeline-run-xxxxx
Waiting for logs to be available...
[build | clone] Cloning repo for web-server
[build | build] Building web-server
[build | test] Running tests for web-server
[deploy | deploy] Deploying web-server to production

Tekton Dashboard

Tekton provides a web dashboard where you can visualize Pipelines, PipelineRuns, Tasks, and TaskRuns. The dashboard lets you inspect logs, view parameters and statuses, and start runs from the UI.

The Dashboard displays pipelines, pipeline runs, tasks, and TaskRuns — everything you can manage from the CLI is visible here.

A screenshot of the Tekton Dashboard showing the Tasks page with three entries — build-task, deploy-task, and hello-task — all in the "ci-pipelines" namespace with their creation times. The left sidebar shows navigation items like Pipelines, PipelineRuns, StepActions, and Tasks.

You can click into runs to view logs, passed parameters, pod details, and more.

If your cluster uses strict RBAC or network policies, ensure the Tekton webhook and controllers have the required permissions. Webhook admission failures can prevent TaskRun and PipelineRun pods from being created.

Summary

Tasks group sequential steps executed in container images.
Parameters make Tasks reusable and configurable.
Pipelines compose Tasks and control ordering with runAfter and parameter/result wiring.
TaskRuns and PipelineRuns are runtime objects that create pods and execute steps.
The Tekton dashboard provides a visual interface to inspect and trigger runs.

References

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

Verifying Tekton control plane

Creating a minimal Task

Parameterizing a Task

A Task with multiple steps

Creating a deploy Task

Wiring Tasks together with a Pipeline

Tekton Dashboard

Summary

Watch Video

Practice Lab

​Verifying Tekton control plane

​Creating a minimal Task

​Parameterizing a Task

​A Task with multiple steps

​Creating a deploy Task

​Wiring Tasks together with a Pipeline

​Tekton Dashboard

​Summary

Watch Video

Practice Lab

Verifying Tekton control plane

Creating a minimal Task

Parameterizing a Task

A Task with multiple steps

Creating a deploy Task

Wiring Tasks together with a Pipeline

Tekton Dashboard

Summary