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.

Learn to interact with a Kubernetes cluster using kubectl, create a deployment, and expose it with a load balancer service. Access the service and verify its status using kubectl commands.

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.

Learn how to achieve high availability in a Kubernetes cluster by deploying multiple control planes with a load balancer, and compare stacked vs external etcd architectures.

Explore essential Kubernetes management tools like kubectl, kubeadm, and minikube, and learn how Helm, Compass, Compose, and Customize simplify deployment, configuration, and templating across clusters.

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

Learn how to perform a maintenance window by safely draining Kubernetes nodes, cordoning, and ignoring daemon sets, so pods gracefully evict and reschedule without downtime, with hands-on kubectl demonstrations.

Learn to upgrade a kubernetes cluster with kubeadm, draining the master, applying an upgrade plan, and rolling upgrades for worker nodes to modern versions.

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.

Execute a hands-on Kubernetes RBAC lab to add a dev user, create a role and role binding, and verify restricted access to ports in the development namespace.

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 pods and containers as the basic execution blocks, and learn to manage application configuration, container resources, health checks, and self-healing with auto restart, scaling, and auto recovery.

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.

Create a secret and a config map from files, mount them into an engine x pod as volumes, and verify password-based access to the service.

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.

Discover how Kubernetes scheduler assigns ports to worker nodes, using node selectors, node names, resource requests, and labels, with hands-on demonstrations and discussion of scheduling factors.

Observe a hands-on Kubernetes lab on pod scheduling with one master and two workers, using node selectors, labels, and resource requests to place pods.

Learn how daemon sets in Kubernetes automatically run a pod on every node, including new nodes, enabling monitoring, log and data collection, and proxy configuration through labels, tent and toleration.

Define a daemon set manifest on the Kubernetes master node with a selector and matching labels. Apply the manifest, deploy three pods across nodes, and verify readiness and label consistency.

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.

Demonstrates creating a replica set from a manifest with metadata, labels, and a selector. Shows scaling replicas with kubectl and label-based pod control.

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.

learn how to create and manage deployments in kubernetes, including crafting a deployment manifest, setting replicas and selectors, and understanding how deployments govern replica sets and rolling updates.

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.

Learn about CNI plugins and how they enable Kubernetes networking. Explore selecting and installing a CNI plugin like Calico to ensure cluster readiness and port connectivity.

Explore how Kubernetes DNS enables pod and service communication by resolving IPs to domain names via CoreDNS, within the kube-system namespace, and test DNS records across pods.

Explore how Kubernetes network policies control pod traffic with ingress and egress rules, port selectors, from and to selectors, and IP blocks, then apply policies via a board selector.

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.

Identify how Kubernetes assigns service DNS names and the fully qualified domain name to enable cross-namespace discovery. Explore service DNS names, the FQDN format, and namespace interactions.

Explore how Kubernetes services are discovered within and across namespaces by using cluster IPs, ports, and the fully qualified domain name to access services from pods.

Explore how an ingress controller manages external access to Kubernetes services, routing traffic by path and named ports, enabling SSL termination, load balancing, and name-based virtual hosting.

Learn to implement ingress in a Kubernetes cluster by deploying two engine x workloads, exposing them via services, and configuring host-based rules to route traffic to each service.

Explore how the container file system is ephemeral and how volumes enable external storage for stateful data, including persistent volumes and claims.

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 hostPath and emptyDir volumes in Kubernetes with a hands-on lab, mounting host directories and persisting data across container restarts.

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.

This lab demonstrates creating a local storage class, a persistent volume, and a persistent volume claim, binding them via a pod, and resizing with reclaim policy details.