Certified Kubernetes Application Developer 2026

Explore the basics of container orchestration, including deployment, scaling, load balancing, and monitoring, and compare Docker Swarm, Kubernetes, and AWS EKS.

Learn the basics of Kubernetes: the control plane and worker nodes, how pods are scheduled, and how Kubernetes enables scaling, service discovery, load balancing, and self-healing in production.

Explore Kubernetes installation options, prioritizing local clusters with kind or Minikube, assess managed services like DigitalOcean and AWS EKS, and weigh costs and setup constraints for practicals.

Configure Kind on macOS and choose between brew install Kind and manual binary setup, ensuring Docker Desktop is running and the Kind binary is added to PATH.

Launch local Kubernetes clusters with kind, verify Docker readiness, and manage clusters via commands like kind create cluster, kind get clusters, and kind delete clusters.

Explore connectivity options to connect to the Kubernetes control plane using kubectl, curl, and the dashboard, with kubectl as the primary tool for creating and managing resources.

Learn how kubectl uses the kube config to connect to a cluster with the control plane DNS or IP and authentication credentials, defaulting to ~/.kube/config.

Install kubectl across Linux, macOS, and Windows by downloading the binary, making it executable, and adding it to your path. Consult kubernetes.io for curl-based or package-manager installation options.

Configure a local Kubernetes cluster with minikube on Linux, covering Docker setup, minikube installation, and kubectl validation to verify a running node.

Learn the basics of Kubernetes pods, including how a pod can host one or more containers that share network and storage, and how to manage pods with kubectl commands.

Discover two primary ways to create Kubernetes objects: kubectl run and manifest files. Learn how YAML manifests define desired state, enable version control, and deploy multiple objects with kubectl apply.

Explore Kubernetes resource types beyond pods, including secrets, and learn how to discover them with kubectl API resources for effective cluster lifecycle management.

Explore structure of a Kubernetes manifest file, including API version, kind, metadata, the pod spec with container name and image, and kubectl api resources for pods, deployments, and secrets.

Generate Kubernetes manifest files automatically using kubectl with dry-run=client and output YAML, enabling version-controlled, production-ready deployment objects.

Learn to create multi-container pods in Kubernetes by defining multiple containers in a pod manifest, sharing network and storage, and using kubectl exec with -c to target a specific container.

Discover how Kubernetes pod command and arguments override Dockerfile entrypoint and cmd, and learn practical examples linking Nginx and BusyBox scenarios to container startup.

Explore practical kubectl run usage to specify command and arguments, overriding entrypoint and cmd when needed. Create BusyBox pods, inspect logs, and apply command and argument YAML configurations.

Examine command and arguments in Kubernetes manifests, compare array versus multiline YAML lists, and learn how separating command and arguments improves clarity and overrides defaults when generating manifests.

Explore kubectl explain to view fields and descriptions for Kubernetes resources, complementing the API reference documentation. Inspect pod fields like spec and containers using kubectl explain.

Learn how the Dockerfile expose instruction documents which port an application listens on and guides port publishing with -p, enabling accurate container port mapping.

Expose a container port in a pod using ports and containerPort, mirroring Docker's expose behavior; kubectl explain confirms the port is informational.

Learn how to use labels and selectors in Kubernetes to organize resources by environment, such as dev and production, and filter pods, services, and deployments with kubectl.

Attach labels to Kubernetes pods and use selectors to filter them by environment or other label values. Explore creating, updating, and deleting labels via YAML metadata and practical examples.

Learn how replica sets maintain a stable set of pods in Kubernetes by keeping three nginx pods running, automatically recreating failed pods, and scaling as needed.

Create and manage a replica set via a manifest-based yaml, defining replicas, labels, selectors, and a pod template, then apply with kubectl and scale to observe pods and replica sets.

Explore the key challenges of replica sets, including update handling, lack of rollback, and label selector collisions, and see why deployments offer a robust alternative.

Explore how deployments sit atop replica sets to manage pods, enabling rolling updates, versioning, and rollbacks, and see demos of updating container images with kubectl.

Learn practical deployment creation with kubectl and manifests, update images, track rollout history, undo changes, scale replicas, and clean up deployments.

Activate rolling updates by configuring max surge and max unavailable to regulate how many ports update concurrently, with practical examples and outcomes.

Discover how multiple worker nodes distribute pods across a Kubernetes cluster to boost capacity and fault tolerance, and learn to check nodes with kubectl get nodes in environments like DigitalOcean.

Learn how to add and manage multiple worker nodes in a DigitalOcean managed Kubernetes cluster by creating node pools with different sizes, deploying nginx, and observing pod distribution and scaling.

Learn how DaemonSet in Kubernetes guarantees a pod on every worker node, enabling antivirus, malware scanning, log collection, and monitoring agents across a multi-node cluster, aligned with PCI DSS compliance.

Create a daemonset in Kubernetes using minimal and custom yaml, deploying nginx across nodes, and observe how the daemonset adjusts to node changes with kubectl.

Understand how Kubernetes jobs and cron jobs automate one-time tasks and scheduled work. See how the job controller creates pods, ensures completion, retries on failure, and enables parallel execution.

Create and manage kubernetes jobs using kubectl, specify image and command, observe pod lifecycle from creation to completion, view logs, and customize job manifests with restart policies and dry-run yaml.

Cap a Kubernetes job’s runtime with the active deadline seconds, terminating overdue pods and marking the job as failed. Show a BusyBox demo enforcing a 30-second limit.

Learn how the backoff limit controls retries for Kubernetes jobs to handle transient failures like API outages, with default six retries and practical production best practices.

Learn to create and schedule Kubernetes cron jobs with kubectl, using cron format to trigger jobs and spawn pods, and manage manifests.

Explore how Kubernetes cron jobs use successful and failed jobs history limits to retain a set number of completed and failed jobs and their pods for auditing and trend analysis.

Learn how Kubernetes service acts as a gateway to load balance traffic across front-end and back-end pods, avoiding hard-coded IPs and adapting to pod changes and external exposure.

Master the basics of Kubernetes service and endpoints with a practical workflow: create a service, manually add endpoints, and test front-end to back-end routing using curl.

Use a selector to register service endpoints by matching pods labeled for the back-end app, enabling dynamic endpoints that update as pods come and go.

Learn how cluster ip provides a stable internal Kubernetes service within the cluster, with no external access, and how to create it via manifest or kubectl.

Learn how node port exposes a Kubernetes service by assigning a port on every worker node and routing external traffic to the backend pods, with internal cluster IP access.

address issues with node port in managed Kubernetes clusters by configuring a DigitalOcean Kubernetes cluster via the CLI on an Ubuntu server, and practice node port and load balancer services.

Create a node port service with kubectl and manifest to expose a backend nginx pod, then test access via the worker node IP and assigned node port.

Discover how the load balancer service type in Kubernetes enables production-ready external access by standing between users and node ports, with automatic cloud provider integration and DNS options.

Create a load balancer service in a managed kubernetes cluster with DigitalOcean integration to expose an nginx backend, then verify the external IP, endpoints, and node port.

See how Kubernetes ingress uses a single load balancer and ingress controller to route external requests to multiple services via defined ingress rules.

Describe how to create ingress rules with kubectl create ingress, route by host to backend services, and review related manifest structure with example rules.

Explore Helm, a Kubernetes package manager, to package, deploy, and manage multi-cluster applications with charts and repositories, including WordPress deployments and one-click uninstall of releases.

Install the helm binary on your workstation and configure your path to run helm from any terminal across macOS, Windows, and Ubuntu.

Master helm from a practical perspective by learning essential commands, using Artifact Hub to choose trusted charts, and deploying nginx with Bitnami while reviewing the generated Kubernetes manifest.

Learn how to use namespaces to isolate resources within a single Kubernetes cluster, creating development, QA, and staging environments that keep pods, configmaps, and secrets separate.

Discover how Kubernetes service accounts authenticate pods using mounted tokens, differentiating user and service accounts, and managing permissions to access the cluster.

Explore how Kubernetes auto-creates a default service account per namespace and how pods inherit its permissions. Learn to assign custom service accounts to pods and understand RBAC and token access.

Learn how to create service accounts with kubectl and mount a custom service account to a pod by specifying the serviceAccountName in the pod spec, then verify with kubectl.

Configure Kubernetes network policies to control pod traffic by using pod, namespace, and IP block selectors; enforce allowed connections such as app to database while denying others.

Explore the structure of a Kubernetes network policy, including api version, kind, and metadata, then learn how pod selectors, policy types, and ingress and egress rules control traffic.

Master practical network policies in kubernetes by configuring ingress and egress rules, pod and namespace selectors, match labels, and ip block restrictions across multiple examples.

Explore how Kubernetes secrets securely centralize sensitive data like database credentials, avoiding hard-coded values, and how pods access secrets via mounted volumes and base64-encoded data.

Learn to create and manage Kubernetes secrets with kubectl, mount them into pods via volumes or environment variables, and handle secret data securely in applications.

Learn how Kubernetes uses resource requests and limits to guarantee memory and CPU for pods and prevent resource contention on nodes, improving scheduling, fairness, and stability in production.

Explore limit ranges in Kubernetes to automatically apply default requests and limits and enforce minimum and maximum thresholds at the container level, preventing overprovisioning and scheduling issues within a namespace.

Explore resource quotas in Kubernetes that limit total CPU and memory in a namespace, plus storage and object counts, to prevent a single team from exhausting the cluster.

Set up and validate namespace-level resource quotas in Kubernetes, covering compute limits (CPU and memory) and object counts, with practical pod creation tests and explicit requests and limits.

This lecture explains the five Kubernetes pod lifecycle phases—pending, running, succeeded, failed, unknown—and how the status may not map directly, with practical demos of scheduling, image pull errors, and restarts.

Learn how Kubernetes restart policies provide self-healing by restarting containers: always (default), on failure, and never, with practical examples in nginx and busybox pods.

Learn how environment variables replace hard-coded secrets by storing db host and db password as os-level key-value pairs for production-ready environment configurations across Linux and Windows.

Explore how to set and access environment variables in Kubernetes pods by defining env in the pod manifest, testing with BusyBox, and using ConfigMaps or Secrets for sensitive data.

Understand how readiness probes prevent traffic from reaching not ready pods under a load balancer, while liveness probes keep running containers from being killed.

Understand how Docker logging drivers route standard output and standard error. Learn how to view logs with Docker logs and how Docker inspect reveals log paths.

Discover how the metrics server provides CPU and memory usage data for pods and nodes by feeding the Kubernetes metrics API, enabling kubectl top pods and kubectl top nodes.

Configure and verify the metrics server in a Kubernetes cluster, install it via repository or helm, and use kubectl top pods and kubectl top nodes to monitor CPU and memory.

Explore how Kubernetes events capture state changes, errors, and messages, view them with kubectl, and note one-hour retention and namespace scoping.

Learn how field selectors filter Kubernetes resources by resource fields, such as metadata.namespace, to exclude the default namespace and target specific ports, events, or names.

Explore how Kubernetes volumes solve data persistence and shared storage challenges by using ephemeral and persistent volumes and volume mounts across multi-container pods.

Learn how emptyDir volumes enable temporary, shared storage for multi-container pods, enabling writer and reader containers to share files, with memory or disk options and pod deletion behavior.

Learn how the host path volume mounts the host node file system into a pod. Access worker node logs, configuration files, and persistent data through volume mounts.

Explore how Kubernetes uses persistent volumes and claims to separate storage provisioning from pods, enabling developers to reference PVCs while admins manage PVs and dynamic provisioning.

Create two host path persistent volumes, then request a two GB PVC with manual storage class; Kubernetes binds a suitable PV and attaches the data volume to the pod.

Store non-sensitive configuration data in config maps and fetch it into pods. Learn to create, edit, and configure pods to use the appropriate config map, avoiding hard-coded credentials.

Learn to create ConfigMap resources in Kubernetes using kubectl with from literal, from file, and from directory approaches, including data keys, YAML manifests, and multi-line values.

Explore how to use config maps in pods with volume mounts and environment variables, mounting config map data as files under etc/config and exposing keys as environment variables.

Explore security context in Kubernetes, showing how run as user, run as group, and FS group enforce non-root containers and limit host access to prevent container breakout.

Understand when privileged pods access host resources, devices, and kernel capabilities. Learn to use securityContext and the --privileged flag, and to grant only necessary capabilities for safer production.

Explore multi-container pod design patterns, including sidecar, ambassador, and adapter patterns, with shared volumes, proxying, and log transformation using tools like Fluentd.

Explore the ambassador pattern, a sidecar proxy that handles sharding and read replicas separate from the application. See port 80 proxying to a 9080 legacy app in Kubernetes.

Standardize logs across applications with an adapter container that transforms outputs into a common format, enabling centralized monitoring with fluentd and a config map.

Explore init containers that run before the main app in a pod, fetch data from external storage via a shared volume, and coordinate with kubelet and pod manifests.

Explore Kubernetes deployment strategies, including recreate and rolling update, and how they shift production traffic between versioned pods. Gain practical skills with kubectl and yaml to safely deploy updates.

Implement blue-green deployments in Kubernetes by running two environments (blue version one, green version two) and switch traffic with a service selector to version two or back to version one.

Learn how canary deployments release a new version to a small user group, split traffic between stable and newer versions, and gradually increase rollout while enabling easy rollback.

Learn to implement a canary deployment with five pods, routing 20 percent of traffic to one canary httpd pod while four nginx pods remain stable, using a shared service.

Explore how to define and use custom resources in Kubernetes with custom resource definitions (CRDs), create CRDs, apply them, and run kubectl commands to manage database and HTTP route resources.

Explore how Kubernetes authenticates users and services through multiple methods—static token files, bootstrap tokens, X509 client certificates, and service account tokens—plus OpenID Connect.

Learn how Kubernetes applies authentication before authorization, using RBAC policies to grant or deny access to resources like pods and secrets, with always allow and always deny as testing modes.

Explore how RBAC in Kubernetes controls access by binding roles to subjects, restricting actions like listing pods to specific namespaces.

Generate a token tied to a service account to test RBAC policies, extend token duration via the duration flag, and export it as an environment variable for curl requests.

Learn how to define and bind Kubernetes roles with practical demos, covering manifest structure, api groups, resources, verbs, and role bindings using kubectl and curl.

Create a Kubernetes secret named app-secret in the default namespace and expose db username and db password as environment variables app db user and app db password inside a pod.

Upgrade an old deployment manifest to apps/v1 by updating apiVersion and adding a selector that matches labels. Diagnose container failures with kubectl logs and save errors to error-container.txt.

Explore creating a Kubernetes pod in the limits namespace with CPU and memory requests and limits, and a never restart policy to guarantee completion.

Grant the pod listener service account permission to list pods by binding it to the pod reader role in the default namespace, then verify with kubectl logs.

Showcases a Kubernetes canary deployment: run nginx with five replicas, implement a 40/60 canary using httpd, then expose both deployments via a cluster IP service with a common label.

Configure a security context for a BusyBox latest image pod in default namespace, setting run as user 1001, run as group 2002, and disabling privilege escalation via the pod YAML.

Create a Kubernetes cron job manifest in default namespace using BusyBox, running every two minutes with active deadline 25 seconds, starting deadline 30 seconds, history limits and restart on failure.

Master rolling updates for a three-replica Kubernetes deployment by keeping at least two pods available and allowing one extra pod, with max search and max unavailable set to one.

Enforce a 500 Mi memory limit and 25 CPU default in test namespace, then deploy a half mem nginx pod and expose it with a NodePort 32000 to port 80.