Kubernetes Made Easy: Learn Kubernetes From Scratch

Explore monolithic architecture, its three tiers, and the advantages and key drawbacks that paved the shift to microservices and container orchestration.

Explore microservices architecture: small, autonomous services that communicate via well-defined APIs, owned by independent teams, enabling flexible scaling and easy deployment compared with monolithic apps.

Explore containers: learn how packaging an app and its dependencies into portable containers with Docker or Rocket enables portability, isolation, speed, and scalable deployment across environments.

Compare physical servers, virtual machines, and containers, highlighting architecture, advantages, and when to stack containers on virtual machines to optimize resources.

Discover how Docker popularized containers, learn the build, ship, and run workflow, and explore Docker Hub, Docker Store, and the Docker Engine in the infrastructure stack.

Explore container orchestration engines that automate deploying, scaling, and managing containerized apps at scale, covering clustering, scheduling, scalability, load balancing, fault tolerance, and deployment strategies.

Explore the top three container orchestration engines— Marathon from Apache Mesos, Docker Swarm, and Kubernetes— and learn how to choose based on team size, containers, and cloud service needs.

Explore Kubernetes, the open source container orchestration engine that manages containers at scale with cluster management, scheduling, and service discovery.

Explore the core Kubernetes architecture, from master and worker nodes to pods and containers. Learn key components like API server, scheduler, etcd, kubelet, and kube-proxy to understand cluster operation.

Explore Kubernetes installation methods, from play with kids and mini cube to kubeadm, and cloud services like Google Kubernetes Engine, Amazon Elastic Container Service for Kubernetes, and Azure Kubernetes Service.

Explore the Play with Kubernetes playground to create a cluster in your browser, configure master and worker nodes, deploy a sample app, and verify readiness within four hours.

Demonstrates setting up a Kubernetes cluster on Play with Kate's with four VMs (one master, three workers), initializing the master, applying the Wave network plugin, and deploying nginx.

Learn how Minikube simplifies running Kubernetes locally by bundling VirtualBox, kubectl, and a preconfigured ISO; this video guides installation, setup, and basic testing of a single-node cluster.

Learn to set up a hypervisor like VirtualBox, install Minikube and kubectl, start a Kubernetes cluster in Minikube, and deploy a sample application for testing.

Explore Google Kubernetes Engine and learn to create a Kubernetes cluster and deploy a containerized app. See how the service manages master nodes, autoscaling, upgrades, and integrated logging.

Learn to create a Google Kubernetes Engine cluster with three workers, deploy a sample nginx app to test the setup, and explore the GKE dashboard and load balancer details.

Learn how to install and configure a Kubernetes cluster with kubeadm, including initializing the master, joining worker nodes, and setting up a flannel pod network, with Docker, kubelet, and kubectl.

Demonstrates installing a Kubernetes cluster from scratch with kubeadm, including master and three workers, using Docker, kubelet, kubeadm, and kubectl, with flannel networking and a sample nginx deployment.

Learn how kubectl, the Kubernetes command line tool, creates, gets, describes, deletes, logs, and executes on pods, deployments, and services using manifest files in yaml or json.

Explore pods as the basic scheduling unit in Kubernetes, distinguish them from containers, and learn inter-pod and intra-pod networking, multi-container pods, and pod manifests.

Deploy an Nginx pod from a manifest, validate with kubectl get pods and describe, expose it via nodeport, and access the page both externally and internally before cleanup.

Explore config maps in Kubernetes to separate configuration from containers, keeping apps portable. Create maps from directories, files, or literals, and use them in pods via volumes or env vars.

Explore how Kubernetes secrets protect small, sensitive data like passwords and tokens. Create and use secrets with kubectl or manifest files, decode them, and mount as volumes or environment variables.

Demonstrates managing Kubernetes secrets with kubectl and yaml by mounting in an nginx pod and using as environment variables in a Redis pod.

Learn how the replication controller maintains a specified number of pod replicas using labels and selectors, enabling high availability and load balancing.

Learn how to deploy and manage a replication controller in Kubernetes, including nginx pods, labels and selectors, scaling replicas, and handling node failures with kubectl.

Discover how replica sets ensure a specified number of pod replicas are always running in Kubernetes, using labels and selectors to manage pods and support set-based and equality-based selectors.

Explore replica sets in Kubernetes through a six-step demo, from manifest to creating and validating pods, including scaling and rescheduling on node failure with kubectl.

learn how deployments in kubernetes enable seamless upgrades, rollbacks, and scaling of app replicas, using strategies like rolling updates, canary, and blue-green with manifest files.

Demonstrates a seven-step deployment workflow that creates three Nginx pods via a deployment and validates their status. Shows rolling updates, rollback, scaling, and cleanup with kubectl across a multi-node cluster.

Discover how daemonset deploys one pod per node in a Kubernetes cluster, with use cases for monitoring and log collection using Fluentd and kubectl.

Learn how to use Kubernetes daemonsets by deploying Fluentd on all worker nodes, then deploy a Nginx daemonset on a labeled subset, and clean up the objects.

Learn how Kubernetes jobs manage tasks by run-to-completion pods or scheduled cron jobs; create, run, validate, and clean up the job manifest with kubectl.

Demonstrates creating and validating a Kubernetes countdown job using a manifest; deploys a countdown pod that prints numbers 1-9, verifies completion with kubectl commands, and cleanly deletes resources.

Explore how Kubernetes services connect front-end and back-end pods, enable service discovery and load balancing, and expose apps with cluster IP, node port, and load balancer.

Expose a web app using a nodeport service, detailing node ip, node port, and the port and target port roles; then create, test, and clean up the manifest.

Demonstrates exposing an nginx app on Kubernetes with a NodePort service. Create deployment and NodePort manifests, launch them, test access via node IP and port, then clean up.

Learn how to expose a multi-node Kubernetes app to the internet using a load balancer service, including manifest creation, deployment, and obtaining the external public IP.

Expose an nginx deployment with a load balancer service in Kubernetes. Learn to use manifest files, kubectl commands, and test via external IP and node port.

Learn how cluster ip restricts backend databases inside Kubernetes and connects frontend apps to a Redis database via deployments and cluster ip services, demonstrated with the guestbook app.

Deploy a three-tier Kubernetes demo: set up Redis master and slaves with a cluster IP service, then expose a PHP guestbook front end via a load balancer on GKE.

Explore how Kubernetes storage volumes persist data beyond pod lifecycles, enable sharing among containers, and categorize into ephemeral and durable types, including empty dir, hostpath, and persistent disk.

Master empty dir volumes in Kubernetes by creating a pod on a worker node for temporary scratch space shared by containers, validated via a demo with a manifest and kubectl.

Review a pod manifest with an emptyDir volume and deploy an nginx pod with a test mount. Validate the mount and clean up the pod to restore cluster state.

Explore hostpath volumes in Kubernetes: understand what hostpath is, how to attach it via a pod manifest, test mounting and data persistence, and cautions for production.

Demonstrates how to use a hostpath volume in a Kubernetes pod, from manifest creation and kubectl deployment to data persistence after pod deletion.

Mount a GCE persistent disk inside a pod to persist data across pod restarts, configure ext4, and verify persistence with a live demo.

Explore how to use GCE persistent disks with Kubernetes on GKE: create and format ten gig disk, mount it in a pod, test data persistence across pod lifecycles, clean up.

Learn how persistent volumes (PV) and persistent volume claims (PVC) standardize storage in Kubernetes, covering static and dynamic provisioning, the PV lifecycle, and using volumes in pods.

Demonstrates static volume provisioning with a GCE persistent disk on a three-node GKE cluster, creating PV, PVC, and a pod, then testing data persistence and cleanup.

Explore dynamic volume provisioning in Kubernetes, creating storage classes, PVCs, and pods to dynamically provision and bind persistent volumes, then test data persistence across pod restarts.

Explore dynamic volume provisioning in Kubernetes by creating a fast storage class on GKE, provisioning PVCs, mounting them in a pod, testing data persistence, and cleaning up.