Learn Kubernetes

Kubernetes runs containers across many machines and keeps them in the state you declared.

The control plane (API server, etcd, scheduler, controllers) decides; kubelets on worker nodes run the containers.

Run a disposable Kubernetes cluster on your laptop to learn and test safely.

Use kubectl's get, describe, apply and delete verbs, and switch clusters and namespaces with contexts.

Describe objects in YAML with apiVersion, kind, metadata and spec, and manage them declaratively with apply.

Namespaces partition one cluster into named scopes for names, access control and quotas.

A pod is one or more containers that share a network namespace and volumes, scheduled together on one node.

Labels are key-value tags that selectors use to group objects; annotations hold non-identifying metadata.

A Deployment keeps N identical pods running through a ReplicaSet and manages rollouts between versions.

Run stateful apps with stable pod names, stable DNS and a dedicated volume per replica.

Run tasks to completion with Jobs, retries and parallelism, and on a schedule with CronJobs.

Run one copy of a pod on every node (or a selected set) for agents like log shippers and CNI plugins.

A Service gives a set of pods one stable virtual IP and DNS name, load-balancing across the ready ones.

Route external HTTP(S) traffic to Services by host and path with an Ingress or Gateway API resources.

Pods find Services by DNS names like api.shop.svc.cluster.local, served by CoreDNS.

Keep configuration and credentials outside the image and inject them as environment variables or files.

Pods request durable storage with a PersistentVolumeClaim; a StorageClass provisions the actual disk.

Customise plain YAML per environment with bases, overlays and patches, built into kubectl.

Inspect running apps with kubectl logs, exec, describe, events, port-forward and ephemeral debug containers.

Ship new versions with zero downtime using the RollingUpdate strategy, and undo bad ones with rollout undo.

Tell Kubernetes when a container is ready for traffic, when it is stuck, and how long it may take to start.

Requests reserve CPU and memory for scheduling; limits cap usage; together they set a pod's QoS class.

Scale pod counts on metrics with the HorizontalPodAutoscaler, right-size requests with VPA, and add nodes automatically.

Keep enough replicas up during voluntary disruptions like node upgrades with PodDisruptionBudgets.

Diagnose Pending, ImagePullBackOff, CrashLoopBackOff, OOMKilled and not-ready pods with a fixed routine.

Grant people and workloads exactly the API permissions they need with Roles, ClusterRoles and bindings.

Steer pods onto or away from nodes with node selectors, affinity, taints, tolerations and topology spread.

Restrict which pods may talk to which, starting from default-deny, enforced by the CNI plugin.

Run containers as non-root with minimal privileges, and enforce baseline or restricted standards per namespace.

How controllers use list-watch, informers and level-triggered reconcile loops, and why that design is resilient.

Extend the API with CustomResourceDefinitions and automate software operations with operator controllers.

Follow a request through authentication, authorization, admission and etcd, and understand field ownership with server-side apply.

How the kubelet turns a pod spec into containers via CRI, containerd, runc, cgroups and the pause sandbox.

How kube-proxy (iptables, IPVS, nftables) or eBPF dataplanes implement ClusterIPs on top of the CNI pod network.