Kubernetes for Linux System Administrators

Coordinate the control plane as the brain of the cluster, which accepts requests, stores cluster information, and decides placement, while worker nodes run containers, report health, and execute applications.

Explore how the API server and scheduler coordinate to manage Kubernetes workloads, enforcing authentication, authorization with RBAC, admission, and etcd state, and deciding pod placement on nodes.

Discover how kubelet and kube-proxy run on every worker node, coordinating with the API server, container runtimes, probes, and network rules to keep pods healthy and services reachable.

Kubernetes makes decisions by continuously comparing the desired state stored in etcd via the API server with the actual cluster state using controllers, the control loop, scheduler, and kubelet.

Learn local Kubernetes practice with Minikube and kubeadm on a single system, practicing pods, services, and deployments while understanding cluster initialization and node joining for realistic learning.

Explore how YAML defines Kubernetes configurations for pods, deployments, and services with key-value data, indentation, and lists, and apply these files to declare the desired state.

Assess local Kubernetes readiness by confirming 4GB RAM, two CPU cores, 20GB SSD storage, and enabling virtualization on a 64-bit Linux system with a container runtime.

Download and install VirtualBox on Windows to create a Linux virtual machine, following steps from the download page to the installer, license agreement, default settings, and VirtualBox opens after installation.

Set up a VirtualBox virtual machine and install CentOS Stream 10 from the ISO, configure hardware and network, enable root access, create a user, and connect via PuTTY SSH.

Install Minikube to run Kubernetes locally by downloading the latest linux-amd64 setup with curl, placing it in /usr/local/bin, and verifying the version and commit information.

Install kubectl to manage your local Minikube Kubernetes cluster, download the official Linux 64-bit binary from dl.k8s.io, set 0755 permissions, place it in /usr/local/bin, and verify the client version.

Create a Kubernetes cluster locally with minikube using the docker driver, verify with minikube status, and connect kubectl to manage resources.

Learn how kubectl uses kubeconfig to securely connect to a Kubernetes cluster and manage resources by defining cluster details, credentials, and context.

Configure access control in Kubernetes by creating a dev namespace, a dev-reader service account, and a pod-reader role with read-only permissions, then bind them and verify access with can-i commands.

Create, stop, start, and delete minikube clusters with the docker driver, then manage multiple profiles like lab1 and lab2, switch the active cluster, and verify kubectl context.

Set up a production-style kubeadm cluster on two nodes master and worker by disabling swap, enabling permissive SELinux, configuring containerd and crictl, and opening ports 6443, 2379–2380, and 10250.

Install kubeadm and core Kubernetes components after configuring the repository, enable the kubelet service, and initialize the control plane to prepare master and worker nodes for cluster joining.

Initialize the Kubernetes control plane on the master, set hostnames, configure kubectl for the iafzl user, and apply flannel with CIDR 10.2.44.0.0.16 for pod networking via CNI.

Join the worker node to the Kubernetes cluster with kubeadm join, update /etc/hosts to map master and worker IPs, and verify readiness with kubectl get nodes -o wide.

Deploy a sample nginx application on the Kubernetes cluster with kubectl create deployment, then expose it via a node-port service and verify access on port 30154.

Build and deploy a production-style Kubernetes cluster for Linux system administrators through a hands-on lab, applying practical cluster construction and deployment workflows.

Define a two-container pod with nginx and busybox, sharing network and storage and communicating via localhost, scheduled on a worker node using a yaml pod definition applied by kubectl.

Demonstrates the pod life cycle from creation to termination, using watch mode to monitor status, and observes kubelet and container processes across master and worker nodes.

Learn how Kubernetes restart policies govern pod behavior when a container fails, using YAML examples for restart never and restart onfailure with a busybox container.

Analyze pod logs and Kubernetes events to understand container activity and diagnose failures, using a log-demo pod with a busy box image and kubectl logs, follow, and describe.

Intentionally break pods to observe image pull errors and crash loops, then analyze logs and events to practice real Kubernetes troubleshooting and failure handling.

Learn how Kubernetes automatically manages pods and maintains the required replicas with deployments and replica sets to hold the desired state for stable, scalable, and self-healing apps.

Scale applications in Kubernetes by increasing or decreasing pod replicas to scale out or scale in, and verify the deployment's desired state with pods and replica sets.

Learn how Kubernetes performs rolling updates to upgrade a deployment's container image without downtime, gradually replacing old pods with new ones and monitoring the rollout.

Learn to rollback a Kubernetes deployment by reviewing rollout history, simulating a failed update with an invalid image, and performing a rollback to restore the previous working version.

Learn how to configure a Kubernetes deployment with two replicas and use liveness and readiness probes to route traffic only to healthy pods and automatically restart unhealthy containers.

Learn how Kubernetes enforces memory and CPU with resource requests and limits, triggers OOM killed events, and drives pods through crash loop back off.

Explore how Kubernetes scheduling assigns a pod to the most suitable node based on resources and cluster conditions, using a node selector to place a pod on the worker node.

Explore pod-to-pod communication in the Kubernetes cluster network using two busybox pods (pod-a and pod-b) in the deep namespace, and verify reachability with ping after firewall adjustments.

Discover how a cluster IP service provides a stable internal IP for pod-to-pod access and forwards traffic to back-end nginx pods, with a practical port fix from 9999 to 80.

Learn how a node port service in Kubernetes opens a port on every node to forward external requests to backend pods, enabling access via node ip and node port.

Learn how a Kubernetes load balancer service exposes an application to external users by assigning an external ip address and routing traffic to back-end pods.

Explore how Kubernetes treats containers as ephemeral, showing that data inside a deleted or recreated pod does not persist and highlighting the need for persistent storage for reliable applications.

Learn how volumes in Kubernetes provide persistent storage for pods, keeping data safe even when containers restart by attaching storage to a mounted path via a host path.

Create a persistent volume in Kubernetes with a YAML file and verify one gig host path storage is available for data to persist across pod restarts.

Create a pvc.yaml named my-pvc to request one gig with read, write once, then Kubernetes binds the pvc to a matching pv for pod access.

Explore storage classes in Kubernetes to automatically provision storage for a PVC, linking PVs and PVCs, and validating dynamic provisioning with a local path provisioner.

Compare host path storage, which uses a node's local folder, to dynamic provisioning that creates storage automatically via a storage class when a PVC is requested in Kubernetes.

Learn how config maps provide non-sensitive settings and secrets securely supply sensitive data to Kubernetes pods, using environment variables and tests to verify permissions.

Compare environment variables and mounted configuration files in Kubernetes, using a config map to pass settings into containers, showing app color and app mode as env vars and files.

Explore Kubernetes RBAC basics by creating users, cert-based authentication, and namespace-scoped roles to grant read or full pod access, then test permissions across user1, user2, and user3.

Learn how Docker Hub stores and shares container images, how Kubernetes pulls images from Docker Hub to deploy apps, and how to create and use a Docker Hub account.

Explore Podman, a secure, lightweight container tool for creating, running, and managing containers without a background service, enabling rootless operation and compatibility with Kubernetes.

Create a production-like workflow by building a container image from a simple website, pushing it to Docker Hub, and deploying it on Kubernetes with a deployment, service, and namespace.