Mastering Kubernetes From Scratch [Hands-On]

Begin with a high-level overview of Kubernetes architecture and learn to set up Kubernetes on your local machine, with a plan to revisit architecture mid-course.

Explore Kubernetes architecture and how a cluster's master, etcd, API server, scheduler, and controller manager coordinate workloads across nodes for high availability and reliability.

Explore how each node runs kubelet, Docker container runtime, and kube-proxy to manage containers and routing, while the master schedules workloads and restarts containers when health checks fail.

Set up a local Kubernetes environment by installing Docker Desktop, then install two tools, Kube CTL and Kind, and verify their versions.

Set up a local kubernetes learning cluster with kind and Cube CTL, creating a three-node cluster (one master, two workers) using docker containers and a yaml config.

Create a local kubernetes cluster with kind using a config file, clean docker state, locate the dot kube config, and verify the master and worker nodes with kubectl.

Explore a kind-based Kubernetes cluster in Docker, access the master and worker nodes via bash, and inspect API server, controller manager, scheduler, and etcd processes.

Learn how to update a running pod by applying a new image version, restarting the container with nginx 1.15. Discover why deployments automate pod updates behind the scenes.

Discover pod status in Kubernetes by the ready column and running vs desired containers, interpreting pending, container creating, running, image pull back off, completed, crash loop back off, and terminating.

Discover how to assign pod labels as key-value metadata in Kubernetes, organize multiple parts in a single YAML document, and query parts by department and team.

Learn to create and manage pods with labels in a running Kubernetes cluster, view individual pod details, and query pods by labels with kubectl get and describe.

Explore how Kubernetes schedules pods across worker nodes, view detailed pod information with kubectl using -o wide and -o yaml, and understand read-only status and basic fields.

Use Kubernetes port-forward to access a pod's engine x server by mapping localhost port 8080 to container port 80 for quick debugging. This method is not a production traffic solution.

Create a pod using an ubuntu image to demonstrate Kubernetes restart policies, observe the default always restart behavior, and configure never, on-failure, or always in yaml.

Master the difference between docker entrypoint and command, how overrides work, and the exact versus shell forms, including Kubernetes mapping of command and args.

Learn to pass commands and arguments to a container in a pod using the exec form in Kubernetes, with YAML examples showing string or list command specifications.

Explore pod args using shell form in Kubernetes by launching an Ubuntu container, opening a shell via a YAML file, and printing the PATH environment variable.

Learn to parse environment variables in a Kubernetes pod using a simple name-value array in the container spec, including keys like request_time and spring_profiles_active, and verify via logs.

Access and debug a pod in a remote cluster using docker exec and kubectl exec in interactive mode, explore the container filesystem, expose ports, and verify engine x via curl.

Discover whether you can use environment variables in Kubernetes YAML like in Docker Compose. Learn how Helm offers a workaround while we stay focused on core Kubernetes concepts.

Learn to run multiple containers in a single Kubernetes pod by configuring a multi-container yaml, observe startup, diagnose port binding errors, and use container-specific logs to troubleshoot.

Create a multi-container pod with engine x and a utility image, demonstrating shared pod networking and localhost behavior, plus debugging readiness and accessing containers with kubectl exec.

Understand real-life multi-container pods that run on a single node, using application and monitoring images as building blocks, and why one pod hosts one application, not for scaling.

Explore volume mapping in Kubernetes, contrasting it with Docker, and highlight how cluster infrastructure and cloud or on prem environments require deeper steps beyond the local machine.

Create a simple yaml pod with an image and on-failure restart policy, inspect logs, adjust environment variable to string and pass args, then recreate the assignment to verify it runs.

Learn how pods group one or more containers, with one application container and optional sidecars, and how kubectl commands monitor, describe, and manage pod lifecycles, logs, and port forwarding.

See how replica sets maintain the desired number of engine X parts across nodes, automatically replacing failed parts, and how deployments use replica sets behind the scenes with labels.

Understand how a replica set manages pods by using selectors and labels to maintain a desired count, creating or terminating pods via a pod template.

Demonstrates creating a Kubernetes replica set with three pods, monitoring with get all and watch, and shows how scaling and deleting pods or the replica set affect pods.

Configure replica set labels correctly by aligning pod template metadata labels with the match label, diagnose yaml errors, and use multiple labels when needed.

Demonstrate multiple replica sets and how each replica set manages its own pods. Learn when replica sets claim unowned parts and why deployments handle replica sets behind the scenes.

Explore match expressions in Kubernetes replica set selectors to filter labels using in and not in operators. Assess practical use cases, and contrast with simple match labels for beginners.

Explore replica sets, their desired pod count, and automatic creation, termination, and restart policy to maintain service availability, then learn how deployments and labels simplify managing a springboard microservice.

Explore the difference between create and apply: create builds resources from yaml in directory or a url, erroring if they exist; apply updates resources when yaml changes and ignores no-change.

Learn to roll out changes and roll back deployments in Kubernetes using a deployment yaml, tracking v1, v2, and v3 revisions through rollout history.

Learn how to roll out multiple Kubernetes versions and rollback to a previous revision using rollout history, undo, and specific revisions, with annotations and change cost tracking.

Learn to inspect rollout history and revisions for deployments, and identify changes such as Docker image updates, port changes, and environment variable updates.

Explore the minimum ready seconds setting in deployment yaml to account for slow startup, and compare hardcoded waits with health checks and probes to ensure app readiness.

Explore how to deploy new versions using recreate or rolling update. Learn how max surge, max unavailable, and replicas control deployment during upgrades.

Demonstrates a rolling update using maxUnavailable to keep at least two replicas available while deploying a new version.

Deploy a dockerized spring application with Redis to a local kubernetes cluster, configure spring host and port, and expose the app on port 88 for a hands-on demo.

Shows solving the Kubernetes assignment by creating a radius deployment in yaml, exposing port 6379, and wiring an app deployment on port 8080, then port-forward to access the restaurant locator.

Demonstrate load balancing with a three-replica engine x deployment and a cluster service, then test routing from a debug pod to verify which pod handles each request.

Balance the load among all parts using a service, verify distribution with curl requests, and observe that requests are distributed randomly across parts rather than by round robin.

Set up a Redis service in Kubernetes by duplicating the app assignment and creating a release. Apply the deploys and verify the restaurant locator page via port forwarding to localhost:88.

Explains cluster IP, node port, and load balancer service types and their roles in private versus external access. Describes cloud auto-creation of load balancers and docker-based demo limitations.

We use Ingress to expose apps outside the cluster, enabling path-based routing, as an optional alternative to NodePort or LoadBalancer services.

Recreate a kind cluster with extra port mappings, linking container port 30001 to host port 30001 on the master node, using the cluster yaml and config file.

Expose the app with a NodePort service by explicitly setting the type and mapping port 30001 to allow outside access, while remaining reachable via cluster IP.

Demonstrates rolling update deployment in Kubernetes with a service and load balancing, updating replicas from v1 to v3 one by one and rolling back to previous versions.

Understand how a service abstracts microservice parts with labels and selectors, routes via kube-proxy, and maps one deployment yaml to one service.

Kubernetes namespaces partition a cluster into virtual environments, isolating resources for dev, test, and prod. Learn to separate teams and applications with dedicated namespaces to avoid conflicts.

Explore Kubernetes namespaces you can list, create, and manage with kubectl, learn how to target resources in default, dev, and system namespaces, and apply configurations to a chosen namespace.

Explore the kube-system namespace and master components—the API server, controller manager, and scheduler—while understanding container networking with CNI plug-ins like kindnet and CoreDNS.

Assign resources to a specific namespace by embedding the namespace in the resource metadata, letting kubectl apply place the resource in dev without specifying the namespace in the command.

Explore Kubernetes namespaces as logical resource groups, enabling dev environment separation, team isolation, and admin access control across clusters and namespaces.

Kubernetes probes act as health checks to confirm an app inside a pod is alive and ready, using health endpoints and preventing premature rollouts during updates.

Compare startup, liveness, and readiness probes, learn how startup probes verify app startup, how liveness probes ensure the app is alive, and how readiness probes gate traffic to services.

Learn how Kubernetes probes—startup, liveness, and readiness—use http get, tcp socket, or exec checks with configurable initial delay, period, timeout, and success and failure thresholds.

Learn to configure a startup probe using httpGet in a Kubernetes pod, specifying path / and port 80, and tune periodSeconds and failureThreshold to verify app startup.

Demonstrate configuring a startup probe with a tcp socket to check MongoDB on port 27017, applying the manifest, and observing startup failure and eventual success as the port opens.

Explain how startup, liveness, and readiness probes operate in Kubernetes, using http get, exec, or tcp socket checks, and how startup triggers restart until the app starts.

Demonstrate configuring startup and liveness probes in Kubernetes using a modified engine x image, showing how probes restart containers when the live file is removed.

Explore how a readiness probe governs traffic to a Kubernetes service by linking a labeled pod to a service, and observe how the endpoint disappears when the pod isn’t ready.

Understand the three Kubernetes health probes—startup, liveness, and readiness—and how they manage container restarts, service traffic, and rolling updates, using http get, tcp socket, and exec checks.

Learn how to separate configuration from the application using Kubernetes ConfigMap and Secret. Store non-sensitive properties as key-value pairs or files and inject them into containers.

Learn how to create and view a simple config map in Kubernetes, using key-value pairs like application url and timeout, with kubectl apply, get, and describe.

Inject all data from a config map as environment variables by using the config map reference, replacing single-key injections, then apply updates and verify the app URL.

Store a multi-line string in a config map and inject it as a file inside a Docker container using YAML pipe notation, with file names like application.properties.

Injects config map data as a file into a container by mounting a config volume, referencing the config map up properties, and placing the file at the target path.

explore how kubernetes secrets store sensitive data like ssh keys, credentials, and config maps. learn that secret values are base64 encoded, not encrypted, and how RBAC protects access.

Create and inject Kubernetes secrets as environment variables using a yaml approach with an app secret containing username and password.

Learn to inject a secret as a file into a Kubernetes pod by using a secret volume, base64 encoding, and decoding the content inside the container.

Create Kubernetes resources (deployments, services, config maps, secrets, probes) to replicate the docker compose setup for Mongo and Mongo Express in a kind cluster, exposing the UI on port 8081.

Construct a zero eight solution directory, create secrets for mongoose and express, set environment variables, and use a config map to inject data.js into the MongoDB deployment.

Configure MongoDB deployment in Kubernetes by injecting env from a secret, using a config map for init js, mounting a data volume, and exposing port 27017 with cluster IP service.

Create a Mongo Express deployment and service in kubernetes, wiring it to mongodb via a secret-sourced env variable, and expose port 8081 for browser access via port forwarding.

Learn how to handle express restarts by simulating the startup order, noting that the app may restart until MongoDB is ready, then delete everything when ready.

Learn how Kubernetes config maps and secrets store non-sensitive and sensitive data as key-value pairs or files, with optional base64 encoding and RBAC protection.

Explore persistent volume claims and storage classes in Kubernetes, and compare dynamic versus static provisioning, highlighting how PVs attach to stateful pods like MongoDB for durable storage.

Understand storage class as an interface with provider-specific implementations and parameters; learn how PVCs use a default standard class in kind clusters, with real storage demo in GCP.

Create your first PVC in Kubernetes with a simple pvc.yaml, setting storage class, access modes, and size. Wait for the first consumer to use it as Kubernetes provisions the PV.

Delete the part to remove the workload, then delete the PVC to remove the PV under the delete reclaim policy; or set reclaim to retain to keep the PV.

Explore deploying three replicas with a persistent volume claim, attach the PVC to containers, and use a startup probe to write each pod's host name to a shared index.html.

Demonstrates a simple stateful set with three replicas, pod indexing, and graceful upgrades, showing how kubectl apply manages replicas and an image upgrade from 1.14 to 1.15.

Understand how a stateful set with a headless service creates multiple PVCs via volumeClaimTemplates, giving each pod its own dynamically provisioned storage.

Learn to deploy MongoDB as a stateful set with persistent storage, initialize the database once, and mount init and data volumes via a volume claim template.

Provision worker nodes to run stateless apps in a Kubernetes cluster, and manage storage with persistent volumes, storage classes, and persistent volume claims.