Study guide
11.1 Cloud Native CI/CD Pipelines & Build Tooling
Kubernetes and Cloud Native Associate KCNA
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Introduction & Exam Overview
1.1 About the KCNA Exam & Certification Path 1.2 How to Use This Study Guide
2 Chapter 2: Kubernetes Fundamentals - Cluster Architecture & the API
2.1 Kubernetes Architecture & Control Plane Components 2.2 Worker Node Architecture & Node Components 2.3 Kubernetes API, Declarative Management & kubectl 2.4 Kubernetes Releases, API Versioning & Deprecation Policy
3 Chapter 3: Kubernetes Fundamentals - Workloads & Configuration
3.1 Core Workload Objects (Pods, Deployments & ReplicaSets) 3.2 Advanced Controllers (StatefulSets, DaemonSets, Jobs & CronJobs) 3.3 Namespaces, Labels, Selectors & Annotations 3.4 ConfigMaps, Secrets & Application Configuration 3.5 Pod & Container Lifecycle, Restart Policies & Graceful Termination
4 Chapter 4: Kubernetes Fundamentals - Scheduling & Autoscaling
4.1 Scheduling, Resource Management & Node Selection 4.2 Advanced Scheduling: Affinity, Topology Spread, Priority & Disruption Budgets 4.3 Autoscaling Workloads & Clusters (HPA, VPA, Cluster Autoscaler, KEDA)
5 Chapter 5: Kubernetes Fundamentals - Cluster Administration & Extensibility
5.1 Kubernetes Distributions, Installation Tools & Managed Services 5.2 Cluster Administration: Node Maintenance, Upgrades & etcd Backup 5.3 Extending Kubernetes: CRDs, Operators & the Controller Pattern
6 Chapter 6: Kubernetes Fundamentals - Containerization
6.1 Container Fundamentals, Runtimes & Registries 6.2 Container Image Anatomy: Layers, Tags, Digests & Pull Policy
7 Chapter 7: Container Orchestration - Networking & Service Discovery
7.1 Kubernetes Networking, Services & Ingress 7.2 Cluster DNS & Service Discovery with CoreDNS 7.3 NetworkPolicies, Zero-Trust Segmentation & the Gateway API
8 Chapter 8: Container Orchestration - Storage
8.1 Storage Concepts (PVs, PVCs, StorageClasses & CSI) 8.2 Volume Types, Snapshots & Stateful Storage Operations
9 Chapter 9: Container Orchestration - Security
9.1 Kubernetes Security & Access Control (RBAC & ServiceAccounts) 9.2 The 4C's of Cloud Native Security & Supply-Chain Trust 9.3 Service Mesh, mTLS & Zero-Trust Service Identity
10 Chapter 10: Container Orchestration - Troubleshooting
10.1 Container Troubleshooting & Health Probes 10.2 Cluster & Node-Level Troubleshooting
11 Chapter 11: Cloud Native Application Delivery
11.1 Cloud Native CI/CD Pipelines & Build Tooling 11.2 GitOps & Package Management (Helm, Kustomize, Argo CD & Flux) 11.3 Deployment Strategies & Release Management 11.4 Progressive Delivery Automation: Argo Rollouts, Flagger & Feature Flags 11.5 Application Debugging & Developer Workflows in Kubernetes 11.6 Platform Engineering & Developer Self-Service
12 Chapter 12: Cloud Native Architecture - Observability & Principles
12.1 Cloud Native Observability (Logging, Metrics & Tracing) 12.2 Cloud Native Principles & Architecture Patterns 12.3 Serverless, FaaS & Event-Driven Architecture
13 Chapter 13: Cloud Native Architecture - CNCF Ecosystem & Community
13.1 The CNCF Landscape, Governance & Project Lifecycle 13.2 Cloud Native Community, Collaboration & Contribution
11.1 Cloud Native CI/CD Pipelines & Build Tooling
Key Takeaways Explain This Topic AI
Continuous integration builds and tests every commit, continuous delivery keeps every build releasable behind a manual approval, and continuous deployment releases automatically with no human gate.
Tekton and Argo Workflows are CNCF pipeline engines that model pipeline steps as Kubernetes custom resources executed in Pods.
Building images inside a cluster without a privileged Docker daemon uses daemonless builders such as Kaniko, Buildah, or BuildKit in rootless mode.
Cloud Native Buildpacks turn source code into an OCI image without a Dockerfile and can rebase a base-image security patch without a full rebuild.
A CI system holding cluster credentials is a high-value target, which is why pull-based GitOps and short-lived OIDC federation have replaced long-lived kubeconfig secrets.
Last updated: August 2026
11.1 Cloud Native CI/CD Pipelines & Build Tooling
Quick Answer: Continuous Integration builds and tests every commit. Continuous Delivery keeps every successful build deployable, releasing on a human decision. Continuous Deployment removes that decision and ships automatically. In Kubernetes, pipelines increasingly run as Kubernetes objects — Tekton Task / Pipeline and Argo Workflows — and images are built without a privileged Docker daemon using Kaniko , Buildah , BuildKit , or Cloud Native Buildpacks .
The official curriculum lists Application Delivery as a competency in its own right. This section covers the build-and-promote half; section 11.2 covers the GitOps half that puts the result into a cluster.
- 1. CI, CD, and CD — Three Different Things commit ──► BUILD ──► TEST ──► PACKAGE ──► [approval] ──► DEPLOY
- └──────── Continuous Integration ────────┘
- └───────────── Continuous Delivery ──────────────────┘
- (approval gate present)
- └───────────── Continuous Deployment ────────────────┘
- (no approval gate)
Term What is automated Where it stops
Continuous Integration Merge, build, unit and integration tests, static analysis, artifact creation At a tested artifact
Continuous Delivery Everything above, plus deployment machinery that is proven to work At a human approval before production
Continuous Deployment Everything, including the production release Nowhere — every green commit reaches production
Both CD variants abbreviate to "CD", which is why the exam-relevant discriminator is always the presence or absence of the manual gate .
2. A Cloud Native Pipeline End to End [1] Commit to the application repository
[2] CI triggers:
- unit tests, linting, static analysis (SAST)
- dependency vulnerability scan
- build an OCI image (reproducible, multi-arch)
- generate an SBOM (Syft / Trivy)
- scan the image for CVEs (Trivy / Grype)
- sign the image digest (Cosign) + attach provenance
- push to the registry
- [3] CI updates the image digest in the CONFIG repository
- [4] An in-cluster GitOps controller notices the change
- [5] Admission verifies the signature, then the rollout proceeds
The deliberate split between an application repository (source) and a configuration repository (manifests) is what allows CI to hold no cluster credentials at all — it writes a commit, and the cluster pulls. That is the security argument for GitOps as much as the workflow argument.
3. Kubernetes-Native Pipeline Engines
Traditional CI servers run pipelines on their own agents. Kubernetes-native engines model the pipeline itself as custom resources reconciled by a controller (the CRD pattern from section 5.3), so every step runs in a Pod with the cluster's own RBAC, quotas, scheduling, and autoscaling.
Engine Model Notes
Tekton Task , TaskRun , Pipeline , PipelineRun CRDs; each Step is a container A CD Foundation project. Reusable Task s are shared via Tekton Hub.
Argo Workflows Workflow CRD expressing a DAG or step sequence CNCF graduated, part of the Argo project. Strong for data, ML, and batch pipelines as well as CI.
Jenkins X / Jenkins Kubernetes plugin Dynamic agents scheduled as Pods Bridges an existing Jenkins estate onto Kubernetes
GitHub Actions / GitLab CI Hosted runners, optionally self-hosted in-cluster The most common starting point; not Kubernetes-native by default apiVersion: tekton.dev/v1
kind: Task
metadata:
name: build-and-push
spec:
params:
- name: image
steps:
- name: build
- image: gcr.io/kaniko-project/executor:latest
args:
- --dockerfile=Dockerfile
- --destination=$(params.image)
The advantage is uniformity: pipeline capacity autoscales like any other workload, secrets come from the same Secret objects, and there is no second permission model to maintain.
4. Building Images Without a Docker Daemon
Building an image inside a cluster used to mean mounting the node's Docker socket into a build Pod — effectively granting root on that node , since anything that can talk to the daemon can start a privileged container. Daemonless builders exist precisely to remove that:
Tool How it works
Kaniko Executes Dockerfile instructions entirely in userspace inside a container; no daemon, no privileged mode
Buildah Daemonless, rootless-capable builder from the Podman ecosystem; can build with or without a Dockerfile
BuildKit (rootless) The modern Docker build engine, runnable standalone with parallel stage execution and better caching
Cloud Native Buildpacks No Dockerfile at all — detects the language, applies a build image and a run image, and outputs an OCI image
Why Buildpacks Matter
Buildpacks (a CNCF project, driven by the pack CLI and used by Heroku, Google Cloud, and Paketo) invert the responsibility model. Developers stop writing and maintaining Dockerfiles; the platform team maintains the base images. The killer feature is rebase : when a CVE lands in the base OS layer, buildpacks swap the run image underneath thousands of applications without rebuilding or re-testing any of them , because the application layer is unchanged.
5. Testing Stages
- Stage Runs against Typical tooling
- Unit Individual functions, no dependencies Language test frameworks
- Integration Real dependencies in throwaway containers Testcontainers, kind clusters in CI
- Contract The agreed interface between two services Pact and similar
- End-to-end A deployed environment Cypress, Playwright, k6
- Policy / manifest The YAML itself, before it ever reaches a cluster kubeconform , conftest , Kyverno CLI
- Security Source, dependencies, and the built image SAST, SCA, Trivy, Grype
Validating manifests in CI is disproportionately valuable: a schema error or a policy violation caught in a pull request costs seconds, while the same error caught at admission costs a failed rollout.
6. Securing the Pipeline
CI is a privileged system that writes the artifacts your cluster runs. Treat it as production:
Risk Control
Long-lived cluster credentials in CI Use pull-based GitOps so CI never touches the cluster, or OIDC federation for short-lived tokens
Compromised dependency injected at build Pin versions with lockfiles, verify checksums, use a curated internal proxy
- Tampering between build and deploy Sign the digest with Cosign and verify at admission
- "Which pipeline built this?" Emit SLSA provenance / in-toto attestations
Secrets leaking into logs or layers Use build secrets that are never committed to a layer; scan for leaked credentials
A malicious pull request running privileged CI Require approval before running workflows from forks; isolate build runners
The recurring theme is that the pipeline is part of the attack surface . An attacker who can modify a pipeline definition does not need to break into the cluster at all — the cluster will happily deploy whatever the pipeline produces, which is exactly why signature verification at admission is the control that matters.