Simply Certify CKA - Certified Kubernetes Administrator

Explore Kubernetes cluster architecture, including the control plane and multiple worker nodes. Understand the roles of kubelet, kube-proxy, kube API Server, scheduler, and controller managers, plus etcd backup and restore.

Explore the pod creation flow in a Kubernetes cluster, from kube controller submitting the pod spec to the API server, kubelet starting the pod, and etcd updates.

Learn how Kubernetes uses TLS certificates from a CA to authenticate components to the api server, including kubelet, etcd, scheduler, controller manager, and kube-proxy.

Explore Kubernetes installation options—from Minikube for local learning to manual hardware setups and kubeadm bootstrapping—covering certificates, etcd, control planes, and DNS deployment.

Assemble a Kubernetes cluster with kubeadm by provisioning VMs, configuring a single control plane and two workers, disabling swap, installing container runtime, and setting required kernel modules.

Install kubeadm, kubelet, and kubectl on all nodes to create a Kubernetes cluster, updating package sources and applying consistent versions on the control plane and workers.

Learn to bootstrap a Kubernetes cluster with kubeadm by initializing the control plane, generating certificates, configuring the kubelet with systemd cgroup driver, applying a Calico CNI, and joining workers.

Understand kubeconfig by examining admin.config in /etc/kubernetes, exploring clusters, contexts, and users, and learn to view, filter, and export server addresses and certificates for kubectl and api access.

Manually add a worker node to a kubeadm cluster by configuring kubelet and containerd, creating kubeconfig and client certificates, and ensuring API server and CNI communication.

Add a worker node manually by building a kubeconfig on the node, defining cluster, user, and context with the API server address and embedded certs, then set the current context.

Connects a worker node to the master in a kubeadm-based cluster by troubleshooting kubelet, resolving container runtime address issues, and applying kubelet configuration for cgroup driver and CNI readiness.

Learn to manually add a worker node to a Kubernetes cluster by configuring kubelet and CNI paths, copying the CA certificate, restarting kubelet, and validating node status.

Explore Kubernetes workloads and namespaces, learn to create pods with resource limits and limit ranges, and review readiness and liveness probes, init containers, lifecycle hooks, and pod metrics.

Learn to create and manage Kubernetes pods using kubectl, view pod yaml definitions, and troubleshoot with describe, logs, and wide pod details.

Create pods with kubectl run using the names and images, watch with -w, sort pods by image name, then shell into a pod with kubectl exec to curl http localhost.

Organize Kubernetes pods with namespaces, including default, kube-system, green, and blue; list with -n, -A, and all-namespaces, and create or apply pods within a specific namespace.

Explore how to define and manage pod resource limits and requests in Kubernetes using yaml and kubectl, including cpu and memory values, limit ranges, and namespace inheritance.

Define commands and arguments to run scripts inside pod containers. Pass commands, arguments, or a combined one-liner to the container and observe printed environment variables like hostname and kubernetes port.

Explore emptyDir volumes, ephemeral storage that exists only during a pod’s life, shared by all containers and erased when the pod terminates.

Learn how to use an emptyDir volume to share data between multiple containers in a pod, enabling a sidecar to modify the nginx landing page and reflect changes across containers.

Explore liveness, readiness, and startup probes, including http health checks with a healthz endpoint, for maintaining pod health and orchestrating restarts using various probe types.

initContainer runs before the regular container in a pod and doesn't support liveness, readiness, or startup probes, as in an nginx pod fetching a landing page into a shared volume.

Explore container lifecycle hooks, especially postStart and preStop, to configure a container after creation and gracefully terminate it, with postStart gatekeeping pod startup.

Explore workloads and services by examining service object, service types, and service endpoints. Compare EndpointSlice, ExternalName service, and headless service to understand their roles.

learn how to create and test a kubernetes service object that load-balances between pods labeled app=my web in namespace green, using kubectl expose and curl tests.

Explore Kubernetes service types, including clusterIP as default, nodeport for external access via a worker node with ports 30000 to 32767, load balancer as cloud managed, and external name previewed.

Learn how a Kubernetes service with a selector automatically creates and updates an endpoint that maps pod IPs, enabling traffic redirection; explore services without selectors for external or cross-namespace use.

Connect to a redis server at 192.0.2.42:9376 from a cluster by creating a service with no selectors and a matching endpoint, then access via redis-svc.

Explore endpointSlices as the scalable alternative to endpoints for external storage services, boosting efficiency by grouping up to 100 endpoints per slice and reducing network and control plane load.

Explore headless services in Kubernetes by using clusterIP none to connect to all pods behind a service, enabling metrics collection, as shown with nslookup to headless-service versus mysvc.

Learn how to create a pod named myhttp with nginx on port 80, expose it as a nodePort service myservice on 8080, and adjust the service type with kubectl.

Explore declarative objects in Kubernetes and apply practical concepts of deployments, Horizontal Pod Autoscaler (HPA), StatefulSet, DaemonSet, rolling updates, and rollbacks.

Deployments provide declarative updates for pods and replica sets, maintain a desired number of pod replicas, and recreate pods to sustain three replicas through a Kubernetes service for load balancing.

Learn to scale Kubernetes deployments by adjusting replicas with kubectl scale and patch, and understand horizontal pod autoscaling to automatically adjust replicas based on CPU usage.

Explore how statefulset differs from deployment by attaching per-pod persistent storage, giving unique pod names, and creating pods sequentially with reverse-order deletion.

Learn how a daemonset ensures one pod per node to collect logs or metrics, with fluentd as a typical example, and see how it differs from deployments.

Explore rolling updates in Kubernetes, upgrading deployment and daemonset images with version v1 to v2 while managing max surge and max unavailable, using kubectl rollout, patch, and rollback.

Explore section six on config maps and secrets, and learn practical techniques for creating and managing these resources.

pass environment variables to a pod with the env field, then decouple them by creating a config map and mapping keys to pod env vars using kubectl.

Map an entire config map to a pod to auto populate environment variables, and mount it as a volume to pass a file, such as redis config, into the container.

Create a configmap in green namespace with color one and color two, deploy an nginx pod that mounts it as a volume at /work to show configmap usage in kubernetes.

Learn how Kubernetes secrets store sensitive data, create secrets with literals or files, base64 encoding, and pass secret values to pods via secret key references.

Generate an ssh key pair named my-rsa, create a Kubernetes secret from the keys, and mount the secret as files in a Redis pod at /etc/foo.

Explore persistent volumes and persistent volume claims, configure storage class options, and practice enabling volume expansion.

Create a hostPath volume on worker nodes, provision a 5 Gi persistent volume task-pv-volume, set up namespace yellow, create a task-pvc-volume PVC, and attach it to task-pv-pod at /usr/local/apache2/htdocs/.

Provision storage on demand with storage classes to dynamically create persistent volumes for PVCs, using provisioners and reclaim policies, illustrated with NFS, AWS EBS, and GCP examples.

Enable the allow volume expansion feature in a storage class to grow PVCs, by editing the storage class to true and then increasing the PVC volume (grow only, not shrink).

Explore authentication and authorization in Kubernetes, and practically implement authentication, create client certificates, and configure RBAC and service accounts.

Explore authentication and authorization for the Kubernetes API server, focusing on X.509 client certificates, CSR creation, CA certificates, and kubeconfig setup for workers and masters.

Create a user1 x509 certificate, generate and sign a csr using Kubernetes csr, and configure kubectl contexts for user authentication and authorization.

Learn role based access control (rbac) by creating a role and a role binding to grant a user pod read permissions in the default namespace, using kubectl and yaml definitions.

Create a Kubernetes service account, bind it to a role, and test API server access from a pod using the service account's secret token.

Explore section nine scheduling concepts, including node labels, node selector, node affinity, pod affinity and pod anti affinity, taint and tolerance, and drain, cordon, and uncordon.

Explore node labels in Kubernetes, including Kubernetes.io/hostname, listing labels with the label command and get nodes --show-labels, creating disktype with SSD, and removing labels from nodes.

Use node selector to schedule a pod on a worker-1 node with disktype ssd label; the pod runs when the label exists and becomes pending when the label is removed.

Explore node affinity in Kubernetes, using hard 'required during scheduling' and soft 'preferred during scheduling' rules to place pods on nodes labeled by node type and disktype.

Explore node affinity with soft rule expressions and weighted scoring, using weights 50, 30, 40 and labels server=data, node type high CPU, disktype pd to guide pod placement.

Demonstrates pod affinity and anti affinity, using topology key kubernetes.io/hostname and labels to place web and cache pods on compatible nodes with hard and soft rules.

Explore taint and tolerance in Kubernetes, learning how taints prevent pod scheduling and how tolerations permit it, including no schedule, prefer no schedule, and no execute.

Master cordon, drain, and uncordon in Kubernetes maintenance. Drain evicts pods to other nodes; cordon blocks new scheduling; uncordon restores scheduling, with ignore daemonset handling for daemonset pods.

Learn practical Kubernetes high availability topology and setup, upgrade a kubeadm cluster, and backup and restore the ETCD cluster.

Explore Kubernetes upgrade and backup within a high-availability topology, including etcd replication across multiple control planes, load balancers, and bootstrapping a multi-master cluster with disaster recovery.

Drain and upgrade a kubeadm high-availability cluster from 1.25.x to 1.27.x, upgrading primary then secondary control planes, then workers, with kubeadm upgrade plan and kubeadm, kubelet, kubectl upgrades.

Back up and restore the etcd cluster in a kubeadm environment using snapshot save and snapshot restore, secure with encrypted snapshots, and manage endpoints, certificates, and cluster health.