Kubernetes with HELM: Kubernetes for Absolute Beginners

Discover how Kubernetes automates deployment, health, scaling, and recovery for containerized apps. Learn why it reduces manual work and supports on-prem, cloud, and hybrid deployments, including secret and configuration management.

Explore the Kubernetes architecture, from master and worker nodes to the control plane, and learn how the API server, scheduler, and seed database manage cluster state.

Install Kubernetes using mini Kube single-node deployment for development, contrast with a high-availability three-node setup (master and two workers), and practice deployments and services on a Digital Ocean VM.

Explore Kubernetes management fundamentals, including high availability concepts, tools, and a cluster setup with one master and two workers. Learn draining resources, resource management, upgrades without downtime, and backup strategies.

Set up a Kubernetes high availability cluster with three nodes (one master, two workers) using kubeadm, Calico networking, and token-based worker join commands.

Master kubectl for Kubernetes object management with get, describe, create, apply, delete, and exec, compare apply and create, and view JSON or YAML outputs via Minikube.

Discover kubernetes access management with role based access control (rbac). Define roles and cluster roles, apply role bindings, and scope permissions to namespaces or the entire cluster.

Learn to create a service account in a Kubernetes cluster and bind it to roles for API access. See namespace scope, cluster vs role bindings, and yaml manifests.

Explore how to manage dynamic application configuration in Kubernetes using config maps and secrets, wire them to containers via environment variables or configuration volumes, with hands-on kubectl guidance.

Learn how to manage application configuration in Kubernetes by creating config maps and secrets from yaml, and pass them as environment variables to containers.

Mount config map and secret data as volumes in a pod to pass dynamic configuration to containers, replacing environment variables, by mounting at defined paths and reading key values.

Discover how the POSIX config map automatically creates environment variables for each key, and how to configure ports using config map references to pass values into containers.

Learn to define resource requests and limits in Kubernetes to control container CPU and memory, how the scheduler uses requests for scheduling, and how limits throttle or terminate at runtime.

Learn to monitor Kubernetes containers with liveness, startup, and readiness probes, configure health checks, and run hands-on labs on initial delay, period, timeout, and failure thresholds.

Learn to implement Kubernetes liveness and startup probes with both exec-based and http get health checks, triggering container restarts and validating startup readiness in a practical lab.

Learn to configure liveness, startup, and readiness probes in Kubernetes with a hands-on lab, defining ports and containers and validating readiness before routing traffic.

Explore Kubernetes container restart policies, including always, on failure, and never, and learn how default policies, liveness probes, and use cases shape robust pod behavior.

Explore Kubernetes pod restart policies by applying always, on-failure, and never configurations with alpine sleep tests to observe automatic restarts, completions, and non-restarts.

Explore creating multiple containers in a single pod in kubernetes, sharing network and a common volume for inter-container communication, while noting the best practice to keep one container per pod.

Discover how Kubernetes init containers run before the main application container to set up your app, block startup until preconditions are met, and keep the main application container lightweight.

Explore init containers in Kubernetes, wiring service dependencies and ensuring the main app starts only after the two init containers succeed and the required services are available.

Explore static pods in Kubernetes, managed directly by kubelet on each node, independent of the control plane, with YAML manifests and mirror pods for status monitoring.

Place a manifest in /etc/kubernetes/manifests on a worker node, restart kubelet, and observe a static pod running there; deletion via API fails due to the mirror pod.

Explore node affinity and node selector in Kubernetes, and how port scheduling uses hard and soft affinity, including required during scheduling and ignore during execution, with a hands-on demo.

Learn to configure node affinity and anti-affinity in Kubernetes using manifest files and node labels. See how required during scheduling versus ignore during execution guides pod placement on specific workers.

Learn how to scale applications in Kubernetes by comparing stateless and stateful workloads, explore vertical and horizontal scaling, and use replication controller for manual scaling and deployments for automation.

Learn how to scale a Kubernetes application horizontally using a replication controller, define replicas, and maintain desired state by creating and managing pod templates and labels.

Explore replica sets in Kubernetes, learn how they scale applications and maintain a stable set of pods, with enhanced selector features and comparisons to replication controllers.

Explore deployments as the top-level Kubernetes abstraction that manages replica sets and ports via a declarative manifest to achieve desired state, including create, update with rolling upgrades, rollback, and pause-resume.

Master rolling updates and rollbacks for Kubernetes deployments and compare deployments with replica sets. Use rollout status, history, undo, pause, resume, and scale to control updates.

Explore Kubernetes networking concepts and the network model, detailing how pods obtain unique IPs and communicate across nodes using IP or DNS, with Calico as a common supported network.

Explore kubernetes network policies with calico by creating two pods in network-policy namespace, engine X, and a busy box, and verify ingress and egress connectivity before and after applying policy.

Explore Kubernetes service types, including cluster IP, node port, load balancer, and external name, and see how each exposes applications inside or outside the cluster with a hands-on demo.

Deploy a three-replica application in a minikube cluster, expose it with a cluster ip service, then enable external access via a node port and verify endpoints.

Define and mount Kubernetes volumes to persist data across containers, configuring volumes and volume mounts in pod specifications, and explore hostPath and emptyDir volumes shared in a hands-on lab.

Explore how a shared empty air volume in a multi-container pod enables real-time file sharing between an engine container and a Debian container, mounting and updating a common index.html.