[NEW] KCNA Kubernetes and Cloud Native Associate - Hands On!

Explore how cloud computing, containers, and Kubernetes empower on-demand resources and fast, global deployment in cloud native environments across IaaS, PaaS, and SaaS models.

Explore virtualization as the cornerstone of cloud computing, enabling multiple isolated operating systems on a single server under a hypervisor, with on-demand, scalable resources and disaster recovery and business continuity.

Master containerization basics, including portable container images, isolated processes, and efficient runtimes, with Docker and containerd under CNCF, and learn how Kubernetes orchestrates these containers in cloud native deployments.

Master docker, the backbone of containerization, by building images with dockerfiles, storing them on docker hub, and running them with runc and containerd, while understanding OCI and CNCF standards.

Explore container orchestration and Kubernetes, alongside Docker Swarm, Mesos, and managed services like EKS, AKS, and GKE, to automate deployment, scaling, and reliability of containerized apps.

Kubernetes (K8s) is an open source container orchestration platform that automates deployment, scaling, and management across public, private, and hybrid clouds, featuring self-healing, automatic scaling, service discovery, and rolling updates.

Discover cloud native computing as a paradigm for scalable, resilient apps across public, private, hybrid clouds. Practice containerization, orchestration, microservices, CI/CD, DevOps, GitOps, and FinOps to enable agile, cost-effective delivery.

Prepare your environment for hands-on labs by installing an IDE such as Visual Studio Code and Docker Desktop. Set up Minikube to run a Kubernetes cluster and practice with kubectl.

Explore json, the simple data interchange format used by APIs, and master its syntax: key-value pairs, strings, numbers, booleans, arrays, and objects with proper escaping.

Explore yaml basics as a human-friendly data serialization standard for templates and configuration files used in infrastructure as code, covering syntax like key: value, indentation rules, and multi-line blocks.

Master vim in Linux by installing vim, configuring vimrc with line numbers and syntax highlighting, and using core commands for inserting, editing, copying, pasting, and saving text.

Explore Docker fundamentals in a hands-on lab, including containerization, Docker Engine and daemon, Docker CLI, Docker Hub registry, and how to build, run, and manage containers with images.

Master docker fundamentals by installing, verifying, and running containers, pulling images from docker hub, and using core commands like docker run, docker ps, and docker rm for nginx and ubuntu.

Launch nginx containers in detached mode with Docker, map ports for local access, and inspect logs, exec into containers, and verify the default page with curl.

Clone a static website, run it in an nginx container, and map your local project to localhost:8888. Build a custom Docker image with a Dockerfile to serve it via nginx.

Understand Kubernetes architecture, from the control plane to worker nodes, including api server, etcd, scheduler, and kubelet, kube-proxy, and pods, using kubectl to deploy and manage.

Explore Kubernetes basics by spinning up a local minikube cluster with calico, then use kubectl to view nodes, pods, and cluster resources, and learn about kubeconfig contexts and namespaces.

Create, view, and delete pods in a Kubernetes cluster using kubectl, explore namespaces like kube-system and pod information with wide output, then deploy via YAML manifests and kubectl apply -f.

Explore the Kubernetes control plane, including the api server, etcd, scheduler, controller manager, and cloud controller manager, and learn how they manage desired cluster state and enable high availability.

Explore the Kubernetes API server as the central management entity, exposing a RESTful API for CRUD operations on resources, with API groups, CRDs, and RBAC and ABAC security.

Explore etcd, Kubernetes' distributed key-value store and source of truth that stores cluster data, state, configs, and object metadata, with raft replication, TLS, and authentication ensuring reliability and security.

Explore the kube scheduler, its three-step process: filtering, scoring, and assignment, and how node selectors, affinities, and taints shape pod placement for efficient, latency-conscious Kubernetes workloads.

Explore how the Kubernetes controller manager maintains the desired state by running control loops for deployments, jobs, and nodes, and how custom controllers extend cluster functionality.

Bridge Kubernetes with cloud provider APIs using the cloud controller manager to enable cross-provider operations. Provision resources, manage nodes, and enable networking across cloud environments with CCM.

Kube proxy on every worker node acts as a network proxy and load balancer, routing traffic to the correct pods and enabling service discovery via DNS or environment variables.

Learn how the kubelet on every node maintains pod state by starting, stopping, and restarting containers, allocating CPU, memory, and storage, and monitoring health with liveness probes.

Explore the container runtime interface in Kubernetes, an abstraction enabling the kubelet to use multiple runtimes (containerd, cri-o, kata, firecracker) for flexible, secure container management, noting docker shim deprecation.

Master kubeconfig essentials to connect to Kubernetes clusters, detailing clusters, users, and contexts, and learn to manage authentication credentials and multiple environments via the ./config path.

Grasp semantic versioning (semver) in Kubernetes, using major.minor.patch to signal breaking changes, new features, or fixes, and recognize alpha, beta, and stable API levels for smooth production transitions.

Explore Kubernetes resources such as pods, services, deployments, and replica sets; compare declarative manifests with imperative commands and examine namespaces for multi-team environments.

Explore pods as the atomic unit of deployment in Kubernetes, explain single versus multi-container pods, lifecycle states, and restart policies, with a YAML example.

Use labels to identify, group, query, and manage Kubernetes objects across environments; attach annotations for essential metadata, release notes, and debugging context.

Explore replica sets and deployments in Kubernetes to ensure high availability, scalability, and zero-downtime updates, including rolling updates and rollbacks via deployment manifests and strategies.

Create and manage Kubernetes deployments with YAML, scale replicas, perform rolling updates, and track rollout history using kubectl, including annotations and observing pods across nodes.

Explore rolling updates and rollbacks in Kubernetes deployments, manage update strategies with max unavailable and max surge, inspect rollout history, and perform undo operations to keep your applications available.

Explore init containers and sidecar containers in Kubernetes, learning how init tasks prepare environments and how sidecars enable logging, monitoring, and data processing for resilient cloud-native workloads.

Master stateful sets in Kubernetes to manage stateful applications with persistent identities, hostnames, and storage, enabling ordered deployment and graceful scaling with rolling update or on delete strategies.

Create and manage a stateful set in Kubernetes using a headless service and three replicas to provide stable network identifiers, persistent storage, and ordered deployment.

Learn how a DaemonSet ensures a copy of a pod runs on every node, enabling cluster-wide services and system daemons, with rolling update and on delete strategies.

Deploy and manage daemonsets in Kubernetes by running an nginx pod on every node with a YAML manifest; experience self-healing and system-wide services.

Discover how Kubernetes jobs run tasks to completion with optional retries and a never or on-failure restart policy, and how cron jobs schedule tasks using crontab expressions and YAML manifests.

Learn to create and monitor kubernetes jobs that run to completion, deploying a pi calculation to 2000 decimals with ttl cleanup and logs access via kubectl.

Learn to schedule and monitor cron jobs in Kubernetes using a cron job YAML and a cron tab expression, applying configurations with kubectl to automate periodic tasks.

Explore config maps and secrets in Kubernetes to manage non-sensitive configuration data and sensitive credentials. Emphasize immutability for reliability and security, and mount them as environment variables or volumes.

Master Kubernetes config maps to manage app configurations, define key value pairs in a config map YAML, inject them as environment variables for pods, and learn about immutable options.

Create and inject Kubernetes secrets to store passwords and tokens with base64 yaml, reference in a pod, and enforce immutability while noting secrets are encoded, not encrypted, requiring etcd access.

Master Kubernetes scheduling by filtering, scoring, and assigning pods to nodes based on resource requirements. Use node name, node selectors, affinities and anti-affinities, and taints and tolerations to guide placement.

Master pod placement in Kubernetes by using node name, node selector, and node affinity to target or distribute pods, and apply taints, tolerations, and pod affinities for flexible scheduling.

Explore static pods, a kubelet-managed pod type for bootstrapping and node-specific tasks. Place the YAML manifest in the Etsy Kubernetes manifests directory for automatic startup, noting limited API server control.

Define and implement pod disruption budgets in Kubernetes to safeguard availability during voluntary disruptions, using min available or max unavailable to keep stateful apps resilient.

Master the four C's of cloud native security—cloud, cluster, containers, and code—by securing configurations, RBAC, network policies, image scanning, and secure coding, guided by Falco for real-time threat detection.

Learn Kubernetes authentication to gate API access using X509 certificates, static tokens, service account tokens, and OIDC, with kubectl and pods verifying identities against external providers like Azure AD.

Learn Kubernetes authorization methods—node authorization, ABAC, RBAC, and webhook authorization—and how OPA Gatekeeper enforces custom policies as an admission controller to strengthen security.

Learn how to implement role-based access control in Kubernetes by defining roles, cluster roles, role bindings, and cluster bindings to grant least privilege to users, groups, and service accounts.

Explore kubernetes security with rbac, granting permissions to users and groups via cluster roles and role bindings, and verify access through kubectl to pods and secrets.

Explore Kubernetes networking, including CNI plugins, cluster DNS, pod IPs, services, and ingress, and learn how network policies control ingress and egress traffic.

Explore Kubernetes networking by deploying a front-end and back-end across three nodes in a minikube cluster, verify pod communication, and implement a network policy to restrict access.

Explore how Kubernetes services provide stable endpoints, enable service discovery and load balancing across pods, and support cluster IP, node port, load balancer, external name, and headless service types.

Explore ingress as the gateway for external traffic into a Kubernetes cluster, enabling TLS termination, path-based routing, and virtual hosting to securely expose multiple services under a single ingress controller.

Create an nginx pod, expose it with a service, and access it via fully qualified domain names such as mypod-svc.default.svc.cluster.local, enabling internal and external communication in Kubernetes.

Deploy an nginx application with three replicas and expose it using cluster IP and node port services, validating access from within and across nodes.

Explore how a service mesh manages east-west traffic, with a control plane and data plane using sidecar proxies to secure, observe, and route inter-service communication.

Master Kubernetes storage concepts, from ephemeral emptyDir volumes for temporary pod data to persistent storage with iSCSI and NFS, with CCNa exam pointers.

Learn how persistent volumes and persistent volume claims enable stateful apps in Kubernetes by abstracting storage, binding PVCs to PVs, and applying reclaim policies and storage classes for dynamic provisioning.

Create a pod yaml with an alpine container, mount an emptyDir volume named tmp at /tmp, and write random.txt to demonstrate ephemeral volume data in a Kubernetes pod.

Create a Kubernetes deployment with an emptyDir volume for three Alpine pods and a sleep infinity to keep them running; each pod's scratch volume is unique and cleared on deletion.

Explore how Kubernetes manages storage with persistent volumes and persistent volume claims, including storage classes, reclaim policies, dynamic provisioning, and binding PVs to PVCs in practical hands-on steps.

Explore the container storage interface and how Kubernetes communicates with diverse storage solutions, enabling snapshots, cloning, and volume resizing with improved portability.

Learn how Kubernetes autoscalers optimize resources with horizontal, vertical, and cluster autoscalers. Explore event-driven scaling with Keda and proactive scaling with Karpenter, plus metrics and monitoring best practices.

Discover how Helm and Helm charts simplify deploying, managing, and upgrading Kubernetes applications with versioned, reusable charts that package templates, configurations, and dependencies for consistent deployments.

Cloud native computing moves from monolithic apps to dynamic, scalable architectures using containers and Kubernetes, with microservices, CI/CD, DevOps, GitOps, and FinOps across public, private, or hybrid clouds.

Explore microservices architecture within cloud native environments, leveraging containerization and Kubernetes to deploy loosely coupled services that scale and empower small teams.

Explore serverless computing, where the cloud provider manages servers and you deploy event-driven functions on platforms like AWS Lambda that scale automatically and cost only when used.

Explore how the cloud native computing foundation drives open source collaboration through a diverse global community, governance by consensus, and inclusive processes that shape CNCF projects and events.

Explore the CNCF landscape map to discover Kubernetes, containers, and cloud native tools, from orchestration to monitoring, across sandbox, incubating, and graduated maturity levels.

Explore open standards in the cloud native landscape and how they enable interoperability. See OCI, CRI, CNI, CSI, service mesh interface (SMI) standardize containers, runtimes, networking, and storage.

Explore cloud native roles and personas, from application developers to SREs and FinOps, and learn how SLA, SLO, and SLI guide reliable, secure, and cost-conscious cloud ecosystems.

Explore telemetry and observability in Kubernetes and cloud native ecosystems, using metrics, logs, and traces to monitor health and optimize performance with Prometheus, Grafana, Elk stack, Jaeger, and Zipkin.

Discover how Prometheus enables robust observability in Kubernetes with a pull-based monitoring server, exporters, and alert manager. Use PromQL to query metrics for auto scaling and proactive reliability.

Explore Grafana's role in observability by transforming raw metrics from multiple data sources into dynamic dashboards, alerts, and templated visuals for cloud-native systems.

Learn cost management in Kubernetes by right-sizing resources, enabling auto scaling, and tagging for cost allocation, while balancing reserved and spot instances and using cloud anomaly detection.