Kubernetes Essentials: Core & Security Concepts + Practicals

Explore what pods are, their advantages, and pod cycles and phases. Learn about namespaces, labels, selectors, init containers, and pod networking, followed by a pod creation demo.

Explore the pod lifecycle in Kubernetes, including pending, running, succeeded, failed, and unknown states; understand how scheduling, node assignment, and container status affect troubleshooting in clusters.

Create your first pod using YAML and ad hoc commands, then monitor it with get, describe, and logs. Explore multi-container pods, exec into containers, and manage pod lifecycles.

Explore Kubernetes namespaces as logical separations for resources within a cluster, enabling environment-based organization (prod, dev, staging) and visible isolation for pods and services, including default, kube-system, and kube-public.

Learn how labels provide key-value metadata for identifying and filtering resources such as parts, services, and deployments, and how equality- and set-based selectors match by environment and namespace.

Learn to create and manage Kubernetes namespaces and labels, assign labels to pods, and delete namespaces or pods by label using kubectl commands and YAML files.

Explore init containers, which run sequentially before the main application, perform environment setup, config loading, and dependency checks, share networks and volumes, and block startup until success.

Demonstrates configuring init containers with an init pod yaml and a redis yaml to gate a main nginx container, using a Redis service on port 6379.

Learn how pod networking enables pod-to-pod communication in a Kubernetes cluster, how a CNI plugin assigns pod IPs and routes, and how services use IPs with kube-proxy and CoreDNS.

Learn how Kubernetes services route traffic to pods, expose apps externally, and provide an endpoint via a virtual ip and dns, using selectors and cluster ip, nodeport, and load balancer.

Explore cluster IP as the default service type for internal communication within the cluster, assigning a stable internal IP to services despite pod changes and rolling updates.

Demonstrates creating a cluster IP for pods with YAML and ad hoc kubectl commands, exposes the service via a port, and tests pod-to-pod communication with curl.

Explore NodePort, a Kubernetes service that exposes a static TCP port on every node, with kube-proxy routing to the cluster IP and internal load balancing; suitable for development, not production.

Demonstrate creating a nodeport service for pods with yaml and ad hoc kubectl commands, expose the app, and access it from a browser across all cluster nodes for development testing.

Explore how load balancers expose Kubernetes apps to external traffic across clouds, using external IPs and nodeport routing, with network or application load balancer types and ingress considerations.

Create and expose a Kubernetes load balancer for pods using ad hoc commands and YAML, then access apps via the load balancer DNS name and understand production use versus nodeport.

Explore replica sets and how they maintain stable replicated pods. See how they replace failed pods and coordinate with deployments, deployment strategies, rolling updates, and rollbacks.

Explore how to create and expose a replica set, scale replicas, and ensure availability across nodes with Kubernetes, using YAML and kubectl commands.

Explore deployments in Kubernetes to maintain application versions across pods, scale replicas, enable rolling updates, and manage revisions with self-healing using pod templates.

Create and expose Kubernetes deployments, scale replicas, and update container images with deployment yaml and kubectl; track live pods in prod and learn basic deployment creation.

Learn how rolling updates migrate from older to newer app versions with zero downtime by gradually replacing pods. See how rollbacks revert to a previous version when issues arise.

Learn how to perform rolling updates and rollbacks in Kubernetes, configure max unavailable, and use annotations and kubectl to manage revisions.

Compare recreate deployment, which terminates pods immediately and causes downtime, with blue-green deployment that uses two identical environments and a service selector for zero downtime during rollout.

Demonstrates the recreate deployment strategy in Kubernetes by applying a deployment YAML, updating the image, and observing simultaneous pod termination and recreation, noting downtime in development or testing.

demonstrates blue/green deployment by creating two identical deployments labeled blue and green, exposing them via a node-port service, and flipping traffic by updating the service selector.

Explore Kubernetes volumes and their types, from emptyDir and hostPath to config map and secret volumes. Learn how PVs and PVCs enable persistent storage and storage classes, with practical demos.

Demonstrates emptyDir in Kubernetes by mounting a volume to a pod, creating files in /data, and showing data disappears when the pod is deleted.

Explore HostPath volumes by mounting a host directory into a pod, creating files, and showing that the host directory persists on the worker node after the pod is deleted.

Persistent volumes provide cluster storage independent of pods for data persistence, with dynamic or static provisioning, while PVCs request capacity and access modes and Kubernetes binds PVs to PVCs.

Explore how to create a PV and a PVC, bind them, and attach the PVC to a pod, with guidance on access modes and reclaim policies.

Learn how storage classes in Kubernetes enable dynamic provisioning of persistent volumes, connecting PVCs to PVs and enabling pods to access storage via mounted volumes.

Demonstrates creating a storage class, binding a PVC to the storage class, and attaching the PVC to a pod, with emphasis on provisioner, volume binding mode, and PV dynamics.

discover how ingress and ingress controllers route external http and https traffic to Kubernetes services, including nginx ingress controller and HAProxy options, with load balancers, ssl termination, and routing rules.

Explore how to install an nginx ingress controller, configure domain-based and path-based routing with an ingress resource, and map domains to backend services via a load balancer and route53.

Discover how daemonsets guarantee a pod runs on every node, enable self-healing, dynamic node management, node selectors, and rolling updates, followed by a live demo.

Learn to create and update a daemon set, join a new worker node, and watch one pod run per node with rolling updates; compare daemon sets to deployments.

Explore how resource requests and limits manage cpu and memory for pods, guiding scheduling and demonstrating throttling and memory termination in a practical demo.

Explore how to configure CPU and memory requests and limits in Kubernetes pods, observe CPU throttling and out-of-memory behavior, and simulate resource pressure using YAML files.

Learn how the HPA in Kubernetes automatically scales deployments, replica sets, and stateful sets based on CPU or memory utilization, with a live demo.

Create the HPA, deploy sample PHP app, and generate load to trigger scaling; observe the HPA adjust pods between minimum and maximum replicas based on target CPU utilization of 50%.

Learn how configmaps store non-confidential data as key-value pairs and how secrets hold sensitive data in Kubernetes, with environment variables, command line arguments, and volume mounts for multiple pods.

Learn to create and deploy ConfigMaps and Secrets in Kubernetes, store data with base64 encoding, and consume them in pods as volumes and environment variables.