Kubernetes

32 lessons · free to read

Run containers in production: pods, deployments, services, scaling and rollouts.

Take this course in the learning hub

Lessons

• What Kubernetes actually solvesKnow why teams stop running containers by hand and hand the job to a cluster instead.
• Cluster architectureKnow what the control plane, the worker nodes and the kubelet each do when you run a workload.
• Pods: the unit of schedulingUnderstand what a pod is, why it may hold more than one container, and why you rarely create one directly.
• kubectl and namespacesLearn the handful of commands you will use every day and how namespaces keep names from colliding.
• Deployments and ReplicaSetsKnow how a Deployment keeps N healthy copies of your app alive and what the ReplicaSet underneath is for.
• Rolling updates and rollbacksShip a new image with no downtime, and get back to the previous one with a single command.
• Services: ClusterIP, NodePort, LoadBalancerGive your pods a stable address and pick the Service type that matches the traffic you actually have.
• Ingress: HTTP routing into the clusterRoute many hostnames and paths through one entry point instead of one load balancer per service.
• ConfigMaps and SecretsKeep configuration out of the image, and understand exactly how much protection a Secret gives you.
• Liveness, readiness and startup probesTell Kubernetes when your container can take traffic, when it must be restarted, and how long to wait at boot.
• Resource requests and limitsSet CPU and memory so the scheduler can place your pods and the kernel does not kill them mid-request.
• Horizontal Pod AutoscalingAdd and remove pods automatically from CPU, memory or custom metrics, and learn what an HPA cannot do.
• Persistent volumes and claimsGive a pod storage that outlives it using PVCs, StorageClasses and the correct access mode.
• StatefulSets vs DeploymentsKnow when stable identity, ordering and per-pod disks push you off Deployments and onto StatefulSets.
• Deploying a Spring Boot appTake a Spring Boot jar all the way to a probed, configured, right-sized Deployment on a real cluster.
• Labels, selectors and annotationsGroup objects with labels, find them with selectors, and park everything else in annotations.
• Jobs and CronJobsRun work that is supposed to finish: migrations, nightly reports, scheduled cleanups.
• DaemonSets: one pod per nodeRun node-level agents such as log shippers and metric exporters on every node you own.
• Scheduling: affinity, taints, tolerationsSteer pods onto the nodes you meant, and keep everything else off the expensive ones.
• Pod lifecycle and graceful shutdownFollow a pod from Pending to gone, and stop dropping requests every time one is replaced.
• RBAC and ServiceAccountsGive people and pods only the API access they actually need, using Roles and bindings.
• NetworkPoliciesClose the flat cluster network so only the pods that should talk to each other can.
• Helm and KustomizeStop keeping one copy of every manifest per environment: template it or patch it.
• Troubleshooting a pod that will not runRead the status, then the events, then the logs. Most Kubernetes failures name themselves.
• CRDs and operatorsTeach the API server a new kind of object, then let a controller operate it for you.
• SecurityContext and Pod SecurityDrop root and capabilities in the pod, then let the namespace reject anything that did not.
• CPU limits, throttling and the JVMThe setting that most often makes a healthy service inexplicably slow.
• How a Service IP becomes a packetClusterIP is not a machine - it is a rule table, and that explains several oddities.
• What the scheduler is actually decidingFilter, score, bind - and why a pod sits Pending with capacity available.
• Rollouts, disruption budgets and draining safelyThe gap between a pod being terminated and traffic stopping.
• HPA behaviour and why scaling lagsThe algorithm, the delays in it, and why CPU is often the wrong signal.
• Control plane and cluster-scale failuresWhat still works when the API server does not, and how clusters actually fall over.