Kubernetes On The Cloud & The CNCF CKA Certification

Set up a Google Cloud Platform account, start the free $300 credit trial, create a top-level project, and launch a VM instance in Compute Engine.

Explore how google cloud shell provides a browser-based, fully functional command line for managing gcp resources, setting a default project, and running gcloud commands to script and provision VMs.

Set up a single-node GKE cluster in US central via cloud shell, deploy the overdress WordPress container as a pod, and expose it with a load-balanced service for external traffic.

Kubernetes coordinates containers across a cluster with a master and worker nodes, using declarative manifests to allocate resources and enable auto healing, scaling, and load balancing toward the desired state.

Explain the master node’s role in the Kubernetes cluster and how the control plane—API server, cluster store, scheduler, and controller manager—maintains the desired state.

Understand how each node runs Kubelik, cube proxy, and a container engine to host one or more containers, while the control plane schedules and coordinates with container runtime interface (CROI).

Pods are the atomic units of deployment in a cluster, hosting one or more containers on a single node; higher level constructs provide healing, scaling, and stable access via services.

Launch a single-replica deployment from a container image and verify port readiness. Access a running shell in the Ingenix container to customize the served content.

Boards run on infrastructure within a cluster, with some instances forming the control plane and others hosting workloads that include the kubelet agent, a network proxy, and a container runtime.

Enable multiple containers in a pod, sharing the same sandbox, memory, and volumes, which tightly couples them. Use cases like front-end and back-end may justify this; avoid it for scaling.

Demonstrate a two-container pod with shared volumes, enforce memory and CPU limits, configure environment variables, and deploy WordPress and MySQL to learn resource management.

Explain how master nodes communicate in a communities cluster, focusing on secure cluster-to-master API server connections on port 443 and insecure master-to-cluster paths that require certificate verification and security measures.

Explore three ways to run Kubernetes: public clouds such as AWS, GCP, and Azure; on‑prem private clouds with cluster bootstrap tools; and local options like minicam.

Explore how Kubernetes enables a hybrid, multi-cloud world by federating clusters across on-prem and public clouds to deliver scalable, resilient workloads.

Explore how the Kubernetes control plane adapts to cloud versus bare metal deployments, guided by the controller manager and its cloud or cube controller manager, with deployments, replicas, and volumes.

Learn how Kubernetes command line tools translate your intent into restful api calls to the control plane, managing objects via declarative manifests and reconciling desired and actual states.

Create a pod declaratively with a yaml file, compare it to the imperative deployment, and verify with get ports, showing advantages of declarative config management.

Compare imperative commands, imperative object configuration, and decorative object configuration for Kubernetes objects. Decorative configuration using YAML or JSON with apply offers robustness and auditability, and mixing methods is discouraged.

Explore declarative file application in Kubernetes, distinguishing current live configuration, the declared manifest, and the last applied configuration; Learn primitive, map, and list field merging rules to avoid cluster confusion.

Evaluate the pros and cons of declarative and imperative object management, where declarative uses config files and apply to create or update, while imperative clearly specifies actions like delete.

Identify how Kubernetes objects are uniquely identified by names and UIDs, stored in the control plane, with client-specified names in yaml manifests, and strict per-kind name uniqueness.

Explore how namespaces create virtual clusters within a single Kubernetes cluster, with default, kube-system, and public namespaces; objects have unique names per namespace, while names can be reused across namespaces.

Explore how labels use key-value metadata to identify attributes across objects, enabling organization and subset selection with selectors and services, while allowing the same label across multiple objects.

Explore how labels and label selectors enable loose coupling between a service and backend pods, routing client requests to a matched subset based on zone and version.

Learn how annotations store metadata as key-value pairs on objects, distinct from labels for identification or selection, and when to attach data like phone numbers, git repositories, or large binaries.

Delete pods by identifying those managed by a deployment and deleting them directly, noting the deployment will recreate them, while pods created individually can be deleted mercilessly.

Edit deployment state directly in the cluster control plane via kubectl edit, adding environment and labels, while noting that such changes aren’t saved to YAML and can be risky.

Scale Kubernetes deployments by increasing replicas with a scale command, verifying the deployment now shows three replicas and understanding the ease of scaling and the deployment object.

Learn how volumes provide persistent storage beyond container lifetimes, allow sharing among containers in a pod, and distinguish between standard volumes and persistent volumes with cloud-specific types.

Demonstrate volumes with MPRDA volume pipe and an emptyDir volume. Mount ready storage in a YAML board and show emptyDir persists across container restarts within port, but not across lifetimes.

Explores cloud provider volumes such as elastic block store, azure disk, azure file, and GCE persistent disk, plus community-native volumes like config map, secret, and host.

Explore how persistent volumes extend data beyond pods in a Kubernetes cluster, compare static and dynamic provisioning, and understand storage classes and persistent volume claims.

Explore persistent volumes for Kubernetes, including AWS Elastic Block Store, Azure file or disk, and Google Compute Engine persistent disk; learn that volumes outlive pods and require region and zone.

Demonstrate configuring and mounting GCE persistent disks as Kubernetes volumes on a Google Cloud Platform cluster, linking three 100 GB disks to pods via a YAML volume definition and kubectl.

Explore five Kubernetes volume types: empty volume, config map volume, triple volume, host part volume, and secret volume, and understand how they share data across containers and persist content.

Learn to pass sensitive data into pods with a Kubernetes secret, encode values in base64, create the secret, and mount it as a volume to access username and password.

Create kubernetes secrets from files using kubectl from file parameter, storing username and password in separate files and referencing them in pod environment variables.

Learn how to create config maps in Kubernetes from files and literals, view them with kubectl, and use their data to set environment variables or mount as volumes in pods.

Explore how container images, typically docker images, are created and pulled into pods via registries, including private registries with authentication and options for node authentication, cached images, and pod secrets.

Apply declarative changes with kubectl apply to update a pod's labels and container image from Ingenix to BusyBox. Observe the control plane reconciling spec and status.

Identify the four information classes containers see: filesystem with image and both persistent and non-persistent volumes, container hostname, downward API env vars, and services with stable IPs or DNS.

Learn how to pass environment variables into containers in a Kubernetes cluster by configuring a YAML file and validating variables with an interactive shell.

Demonstrate the downward API to pass pod metadata, labels, and annotations into a container via volume files, complementing environment variables. See dynamic symbolic links refresh these values in real time.

Explore how containers react to lifecycle events using two life-cycle hooks, false start and stop, and implement hook handlers via exact commands or http requests while handling possible multiple invocations.

Explore how to handle container lifecycle events in Kubernetes with a declarative YAML demo, implementing postStart and preStop handlers that echo messages and write status to a file.

Navigate how the scheduler distributes boards across nodes, balancing resources and enabling high availability, and influence board assignment with node selectors and affinity/anti-affinity using node labels and predefined node attributes.

learn to associate pods with specific nodes using node selector and labels. label a node with disk type ssd and schedule via node selector.

Examine taints and tolerations to control scheduling on nodes with node selectors and affinities. Learn to apply hardware-specific taints and condition-based taints from the node controller for selective scheduling.

Use kubectl taint to taint a node and steer pods away from it, then deploy a multi-replica deployment and verify none of the new pods schedule on the tainted node.

Learn to use tolerations to schedule pods on tainted nodes by applying a deployment with key end, value F, and no schedule, then verify with the get pods command.

Use init containers to run preconditions before app containers, executing in order until completion, to block startup and clone a git repository via the downward API.

Explore init containers that prepare pod state by preloading files into an emptyDir volume, using a yaml manifest, BusyBox, and wget to seed the app container before startup.

Explore the pod lifecycle, the atomic unit containing one or more containers, with states pending, running, succeeded, failed, or unknown, and how restart policies and controllers enable healing and scaling.

Explore how container probes diagnose status within a port, including liveness and readiness checks, probe outcomes (success, failure, unknown), and how probes determine port health and traffic flow.

Demonstrate liveness probes in Kubernetes using HTTP and TCP checks with a Go server that returns 200 for the first 10 seconds and 500 afterward, using a port 8080 probe.

Use pod presets to inject information into pods during creation by labeling and selecting pods, applying preset objects containing secret volumes, volume mounts, and environment variables.

Learn how Kubernetes uses priority class objects to influence scheduling and preemption, with high-priority pods jumping queues and triggering graceful termination under a port disruption budget.

Discover how replica sets and deployments enable self-healing and auto scaling in Kubernetes, and learn how controllers reconcile desired and actual states through the control plane.

Understand how a ReplicaSet maintains a desired number of pods with a template and a selector. Compare Deployments, Jobs, and DaemonSets as higher-level alternatives.

Define and manage a replica set in Kubernetes by declaring labels, a selector, and a pod template to run three pods from a single object.

Learn to build and manage Kubernetes replica sets, scale and auto scale replicas, isolate or delete parts with cascade control, and use rolling updates and horizontal pod autoscaling for resilience.

Delete a replica set triggers auto healing, recreating pods to match the desired state. Use a delete switch to remove the replica set without affecting the underlying pods.

Learn how deleting a replica set with cascade=false leaves pods running, demonstrating loss of control without cascading and the need to recreate the replica set.

Explain how a replica set uses a template and a label selector to govern boards with matching labels, and why this coupling remains loose for cascading deletes and governance reassignment.

Enable automatic scaling of deployment replica sets with the horizontal pod autoscaler, based on target CPU utilization and min/max replicas, with downscale and upscale delays and support for custom metrics.

Examine how a replica set governs pods through its label selectors, and how changing pod labels or isolating a pod causes the replica set to recreate and reassign pods.

Scale a replica set declaratively by editing the replicas field in the YAML and applying with kubectl apply -f, increasing replicas from three to five.

Explore how replication controllers, replica sets, and deployments enable rolling updates and versioning, and why replication controllers are obsolete versus deployments and replica sets with equality-based selectors.

Explore how a replication controller—now deprecated—provides auto healing and auto scaling, compare it to a replica set, and walk through creating, describing, and verifying three replicas using a yaml file.

Learn how deleting a replication controller in Kubernetes affects its pods. Deleting pods themselves are resurrected by the RC, while deleting the RC removes the RC and its pods.

Delete a replication controller by setting the cascade flag to false, leaving its three pods intact and unprotected by auto healing.

Explains loose coupling between a replication controller and its pods by editing pod labels to isolate or detach, while the replication controller maintains three replicas.

Explore how Kubernetes deployments manage pods via replica sets and templates, enable rolling updates with new container versions, and provide easy rollback through revision history.

Discover seven deployment use cases in Kubernetes, including creating, updating, rolling back, scaling, pausing, monitoring status, and cleaning up old replica sets.

Create a deployment by defining YAML with apiVersion, kind, metadata, replicas, a replica set, and template, using selectors and a rollout strategy with max unavailable and max surge.

Demonstrate kubectl run to create a deployment, explore replicas and the embedded replica set, and verify the Ingenix image in a cloud Kubernetes cluster.

Learn how to manage Kubernetes deployments with YAML files, comparing declarative and imperative methods, using kubectl apply -f and create -f to deploy, inspect, and delete a deployment.

Understand how deployment revisions are automatically tracked and how template changes trigger new revisions; roll back to a previous revision with a single command, affecting only changed parts.

Pause and resume Kubernetes deployments using imperative commands or declarative templates, and learn that pausing prevents changes from triggering, with resume required to re-enable updates.

Apply a cautious clean-up policy by managing the revision history limit to prevent buildup of old replicas, but remember that setting it to zero disables rollback.

Explore scaling deployments in Kubernetes using imperative commands, declarative templates, and horizontal pod autoscalers, including proportional scaling during rolling updates and canary deployments.

Update the deployment by editing the yaml and reapplying with kubectl, set replicas to three, and observe the control plane scale to three, then revert to one without warnings.

Update a deployment's container image with kubectl set image from Ingenix 1.7.9 to 1.9.1, and verify updates via describe, illustrating imperative vs declarative modes.

Roll back a deployment with a simple command, verify the image reverts to Ingenix 1.7.9, and learn how to target a specific previous version.

Imperatively scale a deployment with kubectl scale deployments to three replicas and verify by listing the deployment to see three ports and matching desired and actual replicas.

Explore rolling deployments in a Kubernetes cluster, pausing and resuming updates, switching images, and using rollout status to monitor old and new replicas until the deployment completes.

statefulsets provide unique, non interchangeable pods with persistent storage and stable network identities, supporting ordered deployment, scaling, and graceful deletion, with sequential creation and ordinal indices.

Launch a stateful set in kubernetes using a yaml with two replicas, note ordinal pod names (0 and 1), and their ordered creation, port exposure, and scale to four (0–3).

Use a daemon set to run a copy on all nodes or a labeled subset, with automatic garbage collection cleaning up the parts it has created.

Understand run-to-completion jobs in Kubernetes, which create pods, ensure a target number completes, and clean up afterward. Explore single-run, fixed-count, and work-queue patterns, and how active deadlines prevent infinite loops.

Cron jobs let you run tasks once or on a schedule with a cron-like specification; due to internal system details, reruns generally should not lead to bad system behavior.

Learn to use Kubernetes job objects for batch processing, define a pi-calculation container in a YAML job, and monitor and retrieve completed jobs.