Practical Kubernetes - Beyond CKA and CKAD | Hands-on

Trace the evolution from bare metal to containers, learn how container orchestration addresses limitations, and explore runtimes like Docker and containerd for scalable, efficient microservices.

Identify the key limitations of containers, including lack of self-healing, single point of failure, and storage constraints. See how container orchestration addresses these issues for reliable deployments.

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

Explore how container orchestration with Kubernetes delivers high availability, self-healing, auto-scaling, zero-downtime upgrades, and efficient resource management through scheduling, health checks, and integration with monitoring, logging, and CI/CD tools.

Explore why Kubernetes leads container orchestration through open source collaboration and a community, with portability across premises, cloud, and hybrid environments and an ecosystem for monitoring, logging, security, and ci/cd.

Explore native, enterprise, and managed Kubernetes options, weighing control, cost, and vendor support to pick a setup that aligns with expertise, project needs, and budget.

Explore the history and advantages of Kubernetes, and review different setup options, preparing you to explore its architecture in detail in the next section.

Explore Kubernetes architecture by distinguishing control plane and node components, including Kube API server, etcd, controller manager, and scheduler, with kubelet and kube proxy on nodes; navigate for exam prep.

Navigate the official Kubernetes documentation at kubernetes.io to explore concepts, components, features, and add-ons. Understand versioning, release history, and how to prepare for hands-on cluster installation.

Explore an overview of various Kubernetes components and learn to navigate the official Kubernetes documentation. Prepare to install a Kubernetes cluster with a hands on demonstration.

Set up a two-node Kubernetes cluster with kubeadm, covering master and worker prerequisites, container runtime cri-o, kubelet, kubeadm, kubectl, and Calico CNI deployment.

Demonstrates a two-node kubernetes cluster setup using kubeadm for version 1.30 on AWS EC2 master and worker nodes, with cri-o runtime, calico networking, and security group port configurations.

Install a two-node Kubernetes cluster and preview essential Kubernetes objects that will appear in the next section.

Explore core Kubernetes objects such as namespaces, pods, replica sets, deployments, and labels and selectors, and learn to use kubectl and kubeadm to manage clusters efficiently.

Explore how Kubernetes uses namespaces, pods, replica sets, and deployments as building blocks to create, configure, and scale applications with high availability, rolling updates, and rollback support.

Learn how Kubernetes namespaces isolate resources for multiple users or teams, enforce resource quotas, and organize objects; discover the default namespaces, including default, kube-node-lease, kube-public, and kube-system.

Demonstrate a hands-on approach to Kubernetes namespace operations using kubectl, including listing, creating, describing, switching context, and deleting namespaces to isolate resources and manage cluster security.

Discover how pods serve as the smallest installable units in Kubernetes by grouping one or more containers that share network, namespace, and storage, with a lifecycle from creation to termination.

Explore replica sets in Kubernetes as controllers that guarantee a desired number of identical pods, ensure high availability, and automatically self-heal and scale when pods fail.

Demonstrates creating a replica set from a dry-run deployment, scaling and self-healing behavior, and cleanly deleting the replica set to maintain application availability.

Explore how deployments provide declarative updates, rollouts, and scaling in Kubernetes, with rolling updates for near zero downtime and easy rollbacks. Compare recreate updates for faster but brief outages.

Observe a hands-on deployment of nginx:latest with three replicas, scale to five and back to two, and see how pods are recreated to maintain the desired replica count, demonstrating self-healing.

Discover how labels tag pods, deployments, and services, and how selectors filter resources by label expressions like app equals frontend to enable organization, targeting, and automation.

Explore labels and selectors by creating a three-replica nginx deployment named my test, then verify the deployment, its replica set, and pods, and inspect the app equal my test labels.

Explore how Kubernetes uses in-built node labels to define roles, and learn to view and modify labels with kubectl.

Demonstrates practical kubectl tips by creating a mydb deployment with nginx:latest and listing deployments, replica sets, and pods using short names.

Cover namespaces, pods, replica sets, and deployments, explore labels and selectors including inbuilt labels, apply practical kubectl tips, and preview service objects in Kubernetes.

Expose and access pods via a Kubernetes service, providing a stable endpoint and DNS name, and learn types like cluster IP, node port, load balancer, and ingress.

The cluster IP service type, the default in Kubernetes, exposes apps only within the cluster for internal pod communication via DNS or the service IP, not accessible outside, boosting security.

Demonstrates creating a deployment with nginx, exposing it via a cluster IP service, and validating access to the service from within the cluster using BusyBox, including endpoint inspection.

NodePort exposes your app on a static port across all nodes, using range 30000 to 32767, accessible from outside via each node IP, with firewall routing and no load balancer.

Demonstrates exposing a deployment with a NodePort service, and accessing the app from outside the cluster via a worker node IP and node port 31552, using nginx.

Configure a load balancer service type to expose your Kubernetes service using cloud provider load balancers, obtain an external IP, and distribute traffic across healthy pods with health checks.

Demonstrates deploying an nginx app on a GKE cluster and exposing it with a load balancer service to obtain an external IP and access the app in a browser.

Demonstrates creating a deployment named Mydb with nginx and a cluster IP service, shows how labels connect them, fixes endpoints by aligning selectors, and verifies access from a BusyBox pod.

Master Kubernetes networking by examining service types: cluster IP, NodePort, and LoadBalancer, detailing configurations and use cases, and applying troubleshooting for deployments and services to ensure seamless operations.

Explore the Kubernetes API ecosystem and learn to develop Kubernetes object manifest files from scratch using the official documentation, focusing on API version, kind, metadata, spec, and status.

Demonstrates deployment creation and management with replicas, labels, and a pod template. Creates a nodeport service that routes traffic to nginx pods and reveals selectors and endpoints.

Demonstrate creating Kubernetes resources with kubectl, generating yaml via dry-run, and saving deployment and nodeport service manifests; align selectors, apply the manifests, and verify endpoints.

Explore using kubectl explain and kubectl api resources to read Kubernetes documentation and distinguish namespace versus cluster wide resources. Generate YAMLs for pods and deployments with practical CLI demonstrations.

Explore object definitions in the Kubernetes API, including YAML basics, deployment and service object files, and efficient YAML creation methods, with kubectl explain for object insights.

Learn how recreate and rolling update deployment strategies refresh pods with new images, balance downtime, and route traffic to updated pods. Explore rollback to a prior version via rollout history.

Demonstrates rolling update of a Kubernetes deployment from v1 to v2 while monitoring rollout status and history. Annotates changes and performs a rollback to version v1.

Demonstrate the recreate deployment strategy by deploying a v1 image, generating YAML with dry-run, then updating to v2 to observe old pods terminate and new ones start, with downtime.

Explore deployment strategies and rollbacks in Kubernetes, then prepare for essential cluster maintenance tasks in the next section.

Scale out a Kubernetes cluster by provisioning new worker nodes, configuring cri-o, kubelet, kubeadm, kubectl, and calico, then join them with a fresh token; drain, cordon, and restore etcd.

Scale out a Kubernetes cluster by provisioning and cloning a worker node on AWS EC2, configuring networking, installing cri-o, and joining the new node with kubeadm.

Cordons mark a node unschedulable during planned maintenance or upgrades, letting existing pods continue while new pods are not scheduled; uncordon restores schedulability with kubectl cordon and kubectl uncordon.

Demonstration shows how to cordon and uncordon a worker node while deploying and scaling an nginx replica set across two nodes, and verifying pod placement with kubectl.

Drain a node with kubectl drain to evict pods gracefully and reschedule them on other nodes during maintenance, optionally using --ignore-daemonsets=true to bypass daemonsets.

Demonstrates draining a Kubernetes node with kubectl drain, cordon, and eviction of pods while ignoring daemonset pods, balancing a Mydb nginx deployment across workers.

Back up etcd with etcdctl, verify the snapshot, and restore by updating the data directory and etcd manifest to use the backup.

Demonstrates backing up and restoring etcd in a Kubernetes cluster using etcdctl, including creating a snapshot, securing with certificates, and restoring data.

Drain the node with kubectl drain node --ignore-daemonsets=true to evict pods, reset the node with kubeadm reset, and delete it from the cluster to scale in while minimizing downtime.

Demonstrates scaling a K8s cluster by draining a worker, evicting pods while preserving daemonsets, and restarting kubelet to recover pending pods to running after config errors.

Scale out and in a Kubernetes cluster to handle workloads and optimize resources, and perform safe pod evictions and etcd backups for maintenance and recoverability.