Kubernetes and Cloud Native Associate (KCNA) + Practice Exam

Trace the evolution from bare metal to containers and discover how container orchestration solves efficiency, agility, and scalability with popular runtimes like Docker and containerd.

Explore the limitations of containers, including lack of self-healing, high availability and scaling challenges, load balancing, and storage constraints in production deployments.

Explore container orchestration and how orchestrators automate deployment, scaling, health checks, and self-healing to run containerized apps at scale, with Kubernetes, Swarm mode, and Mesos as examples.

Explore the features and capabilities of Kubernetes to orchestrate containers with high availability and self-healing, health checks, auto scaling, zero-downtime upgrades, and resource management.

Explore the evolution of containers, compare them to virtual machines, and learn how container orchestrators address their limitations, with a focused look at Kubernetes and its capabilities.

Discover how Kubernetes evolved from Borg and Omega to become the open-source, CNCF flagship project that powers containerized applications and scalable orchestration.

Master Kubernetes for container orchestration by leveraging open source community, portability across on-prem, cloud, and hybrid environments, and a rich ecosystem of monitoring, security, and ci/cd pipeline integrations.

Explore native, enterprise, and managed Kubernetes setups, including OpenShift, Rancher, Tanzu, Rakuten Cloud, EKS, AKS, and GKE. Compare control plane, security, networking, monitoring, and costs to choose the right option.

Review the history of Kubernetes, outline its advantages, and summarize the different setup options, then preview the architecture to be explored in detail in the next section.

Kubernetes architecture by examining control plane and node components, including the kube API server, etcd, controller manager, and scheduler, then review kubelet, kube proxy, and container runtimes.

Navigate the official Kubernetes documentation to explore cluster components, control plane and node components, add-ons, and features like automated rollout, service discovery, and storage orchestration for exam prep.

Explore an overview of Kubernetes components, and learn to navigate the official Kubernetes documentation; the next module covers installing a Kubernetes cluster with hands-on demonstration.

Set up a two-node kubernetes cluster with kubeadm by meeting master and worker prerequisites, installing cri-o and kubelet, kubeadm, and kubectl, deploying calico, and verifying with kubectl get nodes.

Initialize a two-node Kubernetes cluster using kubeadm on aws ec2 with master and worker nodes, Kubernetes 1.3, and configure security groups, ports, and Calico networking with cri-o.

Install a two-node Kubernetes cluster and prepare to explore various Kubernetes objects in the upcoming section.

Master kubectl basics for managing namespaces, pods, replica sets, deployments, and labels with commands like get, describe, and delete. Understand kubeadm's role in bootstrapping clusters and enabling cluster operations.

Explore core Kubernetes objects: namespaces for isolated, multi-user clusters; pods as the smallest deployable units; replica sets for high availability; and deployments for lifecycle management, rolling updates, and rollback.

Explore how namespaces isolate resources in a Kubernetes cluster, letting multiple teams share the same environment while enforcing resource quotas and using default namespaces to organize resources.

Demonstrates kubectl namespace operations, including listing, creating, describing, switching contexts, and deleting namespaces to isolate resources and improve clarity and security.

Learn how pods are the smallest deployable units in Kubernetes, housing one or more containers that share network, storage, and a node, with a lifecycle from creation to termination.

Learn to create and manage pods with kubectl, view details, run an interactive shell, inspect nginx logs, delete pods, and perform cross-namespace operations.

Explore replica sets in Kubernetes, learn how they self-heal and maintain a desired number of identical pods, and scale automatically to ensure high availability and reliability.

Demonstrates creating a replica set from a deployment using dry run, applying a YAML manifest, and scaling, viewing, describing, and self-healing replica sets with kubectl.

Understand how deployments provide declarative updates, manage rollouts, and scale applications with strategies like rolling updates and rollbacks, delivering near zero downtime.

Demonstrates deploying a Mydb deployment with nginx:latest and three replicas, scaling to five, and verifying deployment, replica set, and pod status while illustrating self-healing and eventual deletion.

Learn how labels and selectors organize and target Kubernetes resources, using key value pairs to classify pods, deployments, and services, and match expressions to automate scaling and service exposure.

Explore labels and selectors in Kubernetes by creating a deployment with three nginx replicas, then verify deployments, replica sets, and pods and review the yaml for label and selector usage.

Learn the four essential Kubernetes objects - namespaces, pods, replica sets, and deployments - plus inbuilt labels, selectors, and practical kubectl tips for efficient cluster management.

Expose and access apps in pods with Kubernetes service objects, including cluster IP, NodePort, load balancer, and ingress options. Achieve decoupling, scalability, and stable communication via a single service endpoint.

Explore the cluster IP service type, the default in Kubernetes, enabling internal pod communication via IP or DNS hostnames while restricting access to inside the cluster.

Demonstrates creating a deployment with nginx, exposing it as a cluster IP service, verifying endpoints, and testing access from a BusyBox pod to ensure internal service discovery.

Explain how node port service exposes apps on a static port across all cluster nodes in the 30000–32767 range, routing external requests via firewall rules to the service.

Create a deployment named mid-depth using the nginx latest image, expose it as a node port service, and access it via the node IP and 31552.

Explore how the load balancer service type uses cloud provider load balancers to expose services to the internet. Distribute traffic across healthy pods using an external IP and health checks.

Demonstrates load balancer service type on GKE, deploying nginx, exposing via a load balancer, obtaining external IP, and cleaning up resources.

Explore Kubernetes networking by examining service types like cluster IP, nodeport, and load balancer, along with their configurations and use cases, plus troubleshooting deployments and services.

Explore Kubernetes api ecosystem and learn to build manifest files from official documentation. Create a pod manifest from scratch and deploy nginx with kubectl apply in the default namespace.

Discover how daemonsets run pods on every node, enable automatic updates, and support node affinity and scalability while also covering jobs, cron jobs, static pods, and configmaps and secrets.

Create a daemonset in Kubernetes by writing a YAML manifest and applying it with kubectl. DaemonSet pods run on each worker node, not on the master tainted node.

Explore how Kubernetes jobs manage batch processing with finite execution, pod management, parallelism, and completion tracking. Learn simple and parallel job types and use cases like data processing and migrations.

Create and manage Kubernetes jobs with an imperative workflow, using dry-run and YAML manifests to run a BusyBox task, verify completion, view logs, and clean up resources.

Explore how Kubernetes cron jobs enable scheduled recurring execution of tasks using cron syntax, with concurrency policy and time zone awareness for backups, report generation, and data processing.

Learn to create a cron job in Kubernetes with kubectl, using a dry-run YAML, and inspect jobs, pods, and logs to verify execution.

Kubelet manages static pods on each node, without relying on the API server, using manifest files in a node directory to run critical components for high availability with self-healing.

Demonstrates creating and managing static pods with the kubelet, using the static pod manifest directory to run core components and observe automatic pod recreation.

Store configuration in key-value pairs with configmaps in Kubernetes, enabling decoupled configurations, dynamic updates, and data sources like literals, files, and environment variables consumed via volume mounts or environment variables.

Walk through creating a config map to store the Postgres password, then wire it into a deployment using envFrom config map ref, and verify the pod runs.

Store and manage sensitive data with Kubernetes secrets, such as passwords, tokens, and ssh keys, and learn types like opaque, service account token, docker config, and tls.

Demonstrates creating a generic Kubernetes secret, encoding passwords in base64, injecting secrets into pods via env from secret, and deploying a Postgres container that uses secret for its superuser password.

Explore how daemonsets run pods on every node, manage one-time tasks with jobs and cron jobs, use static pods for node-level configurations, and secure data with configmaps and secrets.

Explore how Kubernetes manages resources with requests and limits for CPU and memory in pods. See how the scheduler, Kubelet, and Cgroups enforce limits to prevent contention.

Explore how Kubernetes uses node name or node selector to place pods, bypassing the scheduler. Learn limitations when the node doesn't exist or lacks resources, and how changes affect names.

Demonstrates how to schedule a pod on a specific node using the node name field, create a deployment with nginx, edit YAML, and apply and scale on worker one.

Master the node selector in Kubernetes to schedule pods on labeled nodes. Labeling enables resource management, environment segregation, and workload isolation, with kubectl labeling examples for ssd storage.

Demonstrates using node selectors to schedule pods on specific nodes by labeling nodes and configuring deployment specs, and shows troubleshooting when a pod remains pending due to missing labels.

Explore taints and tolerations in Kubernetes to control pod scheduling on nodes, including how taints repel pods, tolerations permit scheduling, and effects: no schedule, prefer no schedule, and no execute.

Understand how pod disruption budgets (PDBs) ensure high availability in Kubernetes during voluntary and involuntary disruptions, while noting that deleting deployments or pods can bypass PDBs.

Demonstrates implementing pod disruption budgets (PDB) in a three-node Kubernetes cluster by deploying six pods and enforcing a minimum of four pods available during node drain.

Explore Kubernetes storage by examining volume types—ephemeral, persistent, and projected—and learn how PV, PVC, and storage classes enable persistent and shared storage with Hostpath, NFS, iSCSI, and secrets.

Demonstrates creating and mounting an empty dir ephemeral volume in Kubernetes, with pod-level volume creation and container mounting to a path like /data.

Demonstrates using a hostpath volume to persist data on a worker node by mounting /data into a pod, with a node selector targeting a production node.

Learn how persistent volumes and persistent volume claims enable storage independent of pods, with storage classes for dynamic provisioning and bound storage across pod lifecycles.

Provision shared NFS storage for a kubernetes cluster using persistent volumes and persistent volume claims, ensuring data persists across pod rescheduling and node changes.

Enable dynamic provisioning of persistent volumes with storage classes to create on-demand storage that matches application needs, via PVCs and automated PV binding.

Explore how StatefulSets manage stateful applications in Kubernetes, ensuring persistent volumes, volume claims, and ordered pod startup. Ensure stable identities and direct pod access via headless services.

Compare Kubernetes deployment and statefulset to understand stateless versus stateful applications. Contrast pod creation and termination patterns for deployment and statefulset, with stable naming and dedicated volumes.

Learn best practices for cloud native security in Kubernetes, applying the four C's—cloud, cluster, container, code—with CIS benchmarks, RBAC, network policies, and image scanning.

Demonstrate how to use kube-bench to run CIS benchmarks on a Kubernetes cluster and generate reports. Interpret control plane, etcd, and node checks and apply remediation.

Define and enforce Kubernetes network policies to control pod-to-pod traffic across namespaces with ingress and egress rules, securing cluster communication and enabling fine-grained, policy-driven traffic management.

Demonstrates how default all allow policy in Kubernetes enables pods and services to communicate, and how to verify with curl between Think Next one and Think Next two deployments.

Demonstrates an all deny network policy that blocks all traffic between pods in the default namespace, using net poll and policy types ingress and egress in a yaml file.

Create a namespace-scoped policy in think next ns with an egress rule allowing pod two to reach pod three. Test connectivity to think next three svc and clean up policies.

Explore role-based access control in Kubernetes by defining roles and role bindings within namespaces, and cluster roles and cluster role bindings for cluster-wide permissions.

Explore Kubernetes service accounts, non-human processes that authenticate to API server for cluster access. Learn their namespace scope, automatic pod linkage, and use cases like monitoring, CI/CD, and the dashboard.

Explore what service meshes are and how they decouple network logic from microservice business logic, using data plane proxies and a control plane to enable secure, observable inter-service communication.