Kubernetes for Beginners: Learn Fundamentals + Hands-On Labs

Explore the fundamentals of Kubernetes, including masters, nodes, pods, and deployments, and review installs from Google Container Engine to laptop setups and on-prem bare metal.

Kubernetes originated at Google, was open sourced in 2014, and was handed to the Cloud Native Computing Foundation; it is one of the biggest open source infrastructure projects.

Explore how Kubernetes orchestrates containerised apps at scale, treating the data center as a single compute resource. See how declarative manifests simplify running and managing thousands of containers.

Develop a big-picture understanding of Kubernetes, covering masters and nodes, the atomic pod, services for reliable networking with stable IP addresses, and deployments for managing apps.

Gain a big-picture view of Kubernetes architecture, where masters orchestrate containers across a cluster, and deployments are defined in YAML to manage ports and replicas.

Explore how Kubernetes master components orchestrate clusters, focusing on the API server, etcd cluster store, controller manager, and scheduler, and how manifests drive desired state to nodes.

The kubelet on a Linux node registers the host with the cluster, coordinates with the container runtime, watches the API server for work, and reports status to the master.

Learn Kubernetes declarative model and the concept of desired state using manifest files. The control plane executes reconciliation loops to align the actual cluster state with the desired state.

Discover how pods are the atomic unit in Kubernetes, hosting one or more containers with shared IPs and volumes, including side containers, and how deployments manage replicas.

Learn how Kubernetes services provide a stable IP and DNS for backend pods, enabling load balancing and reliable updates, using labels to connect services to the correct pods.

Learn how deployments replace replication controllers with replica sets to manage pods declaratively, enabling versioned, scalable rollouts and easy rollbacks through blue-green and canary deployment strategies.

Explore how Kubernetes orchestrates containerized apps via a master control plane and worker nodes, using the API server, etcd cluster store, pods, services, and load balancing for scalable deployments.

Take a hands-on module to spin up a cluster, starting with a simple local development environment on your laptop and progressing to Google Cloud, AWS, and on-prem manual installs.

Spin up a local Kubernetes cluster with minikube on Mac, Windows, or Linux, using kubectl and a VirtualBox driver for a quick, production-like development environment.

Spin up a production-grade Kubernetes cluster on Google Cloud using Kubernetes Engine, configure a three-node cluster, and access it via kubectl and the dashboard.

Install and configure the AWS CLI and IAM credentials, then install eksctl and kubectl. Deploy a three-node Amazon EKS cluster and verify readiness with kubectl get nodes.

Manually install a three-node Kubernetes cluster by installing Docker, kubeadm, kubectl, and CNI, initialize the cluster, create a pod overlay network, and join worker nodes.

Explore native Kubernetes installation options from local minicam environments to cloud managed clusters on Google Bernardes engine, using kubectl and kubeadm to create clusters and join nodes.

Discover how pods act as the atomic scheduling unit in Kubernetes, housing one or more containers with a shared network namespace and single IP, deployed via manifests to a node.

Create and deploy your first pod by writing a simple YAML manifest, apply it with kubectl, and verify pod readiness on a three-node cluster.

Deploy pods with a replication controller by defining a YAML RC with 10 replicas and a pod template, then apply and describe to verify, and scale to 20.

Demonstrate that pods are the smallest deployable unit, defined in YAML or JSON and deployed atomically, while replication controllers enforce the desired state by maintaining pod replicas.

Explore how Kubernetes service objects expose apps to the outside world, understand how they work, and implement them iteratively—then compare imperative and declarative approaches with real-world examples.

Explore how Kubernetes services provide a stable endpoint with a virtual IP and DNS, using label selectors to balance load from inside the cluster and from outside.

expose a pod set in Kubernetes by iteratively creating a service from a replication controller, then access the app via a node port in the 30000–32767 range and cluster IP.

Demonstrate creating a Kubernetes service declaratively with a YAML manifest, explaining cluster IP, node port, and load balancer types, and validating with kubectl describe and endpoints.

Learn how pod and service labels enable load balancing and zero-downtime updates in a Kubernetes cluster, using selectors to switch versions and revert if needed for blue-green or canary deployments.

Learn how services provide stable networking endpoints for pods, protect apps from port churn, and expose ports to outside world through basic port-service mappings and cloud native load balancer concepts.

Deployment theory explains how deployments manage replica sets and pods to enable rolling updates and simple rollbacks, with YAML-driven changes pushed to the API server and backed by readiness probes.

Create your first Kubernetes deployment from a YAML file with kubectl, adopting a declarative, 10-replica rolling update. Keep the existing service exposing port 30001 and review replica sets and deployments.

Update a Kubernetes deployment by pushing a new image with a rolling update, monitor rollout, use record for history, and rollback to a previous revision if needed.

Move from imperative to declarative Kubernetes workflows, learn YAML and JSON, and explore high-availability control planes, continuous deployment, and networking with load balancers and ingress options.