47 episodes
Learning Kubernetes - Pre-Requisite Skills Before Learning Kubernetes
In this episode, we will explore Kubernetes, a container orchestration technology. However, before diving in, what skills do you need to master before learning Kubernetes?
Learning Kubernetes - Understanding the History of Application Deployment and Kubernetes
In this episode, we will explore the history of application deployment from infrastructure, the transition from VMs to containers, from monolithic to microservice deployment, and the history of Kubernetes.
Learning Kubernetes - Understanding Kubernetes Concepts and Architecture
In this episode, we will explore the concepts and architecture of a Kubernetes Cluster, from the Control Plane (Master Node) to the Data Plane (Worker Node).
Learning Kubernetes - Installing Kubernetes Cluster (Master & Worker Nodes)
In this episode, we'll start hands-on practice by installing a Kubernetes Cluster using various methods: Minikube, Kind, K3s, and manual K8s installation using kubeadm.
Learning Kubernetes - Introduction and Explanation of Node Object
In this episode, we'll discuss one of the objects in Kubernetes called Node. We'll learn more deeply about what a Node is in the context of Kubernetes.
Learning Kubernetes - Introduction and Explanation of Pod Object
In this episode, we'll discuss one of the objects in Kubernetes called Pod. We'll learn more deeply about what a Pod is in the context of Kubernetes.
Learning Kubernetes - Introduction and Explanation of Label Object
In this episode, we'll discuss one of the most important concepts in Kubernetes called Labels. We'll learn how to use Labels to organize, identify, and manage Kubernetes objects effectively.
Learning Kubernetes - Introduction and Explanation of Annotation Object
In this episode, we'll discuss another important concept in Kubernetes called Annotations. We'll learn how to use Annotations to attach arbitrary metadata to Kubernetes objects.
Learning Kubernetes - Introduction and Explanation of Namespace Object
In this episode, we'll discuss an important concept in Kubernetes called Namespaces. We'll learn how to use Namespaces to divide cluster resources between multiple users or teams.
Learning Kubernetes - Deleting Pods in Kubernetes
In this episode, we'll discuss various methods for deleting Pods in Kubernetes. We'll learn how to delete Pods by name, label selector, namespace, and other advanced techniques.
Learning Kubernetes - Introduction and Explanation of Probe
In this episode, we'll discuss an important concept in Kubernetes called Probes. We'll learn about Liveness, Readiness, and Startup Probes to ensure application health and availability.
Learning Kubernetes - Introduction and Explanation of ReplicationController
In this episode, we'll discuss an important concept in Kubernetes called ReplicationController. We'll learn how ReplicationController ensures a specified number of Pod replicas are running at any given time.
Learning Kubernetes - Introduction and Explanation of ReplicaSet
In this episode, we'll discuss the modern replacement for ReplicationController called ReplicaSet. We'll learn about set-based selectors, matchLabels, matchExpressions, and how ReplicaSet is used by Deployments.
Learning Kubernetes - Introduction and Explanation of DaemonSet
In this episode, we'll discuss an important Kubernetes controller called DaemonSet. We'll learn how DaemonSet ensures that a copy of a Pod runs on all (or some) nodes in the cluster.
Learning Kubernetes - Introduction and Explanation of Job
In this episode, we'll discuss Kubernetes Job, a controller designed for running tasks to completion. We'll learn how Job manages batch processing, one-time tasks, and parallel execution in Kubernetes.
Learning Kubernetes - Introduction and Explanation of CronJob
In this episode, we'll discuss Kubernetes CronJob, a controller for running Jobs on a time-based schedule. We'll learn how CronJob enables scheduled tasks, recurring operations, and automated maintenance in Kubernetes.
Learning Kubernetes - Introduction and Explanation of Node Selector
In this episode, we'll discuss Kubernetes Node Selector, a simple mechanism for controlling Pod placement on specific nodes. We'll learn how to use labels and node selectors to schedule Pods on nodes with specific characteristics.
Learning Kubernetes - Working with All Resources in Kubernetes
In this episode, we'll discuss the kubectl all keyword for managing multiple Kubernetes resources at once. We'll learn how to use kubectl get all, kubectl delete all, and understand what resources are included in all.
Learning Kubernetes - Introduction and Explanation of Service
In this episode, we'll discuss Kubernetes Service, the fundamental networking abstraction for exposing applications. We'll learn about Service types, how they enable Pod communication, and best practices for service discovery.
Learning Kubernetes - Introduction and Explanation of Ingress
In this episode, we'll discuss Kubernetes Ingress, the API object for managing external HTTP/HTTPS access to services. We'll learn about Ingress controllers, routing rules, TLS termination, and best practices for exposing applications.
Learning Kubernetes - Ingress with Gateway API
In this episode, we'll explore the latest update to Kubernetes Ingress using API Gateway. Learn how to leverage the new Gateway API for more advanced routing, traffic management, and modern ingress patterns.
Learning Kubernetes - Multi-Container Pod Patterns
In this episode, we'll discuss multi-container Pods in Kubernetes and common design patterns. We'll learn about sidecar, ambassador, adapter patterns, and how containers share resources within a Pod.
Learning Kubernetes - Introduction and Explanation of Volume
In this episode, we'll discuss Kubernetes Volumes for persistent data storage. We'll learn about different volume types, how to mount volumes in Pods, and best practices for data persistence.
Learning Kubernetes - PersistentVolume and PersistentVolumeClaim
In this episode, we'll deep-dive into PersistentVolume (PV) and PersistentVolumeClaim (PVC) in Kubernetes. You'll learn how Kubernetes abstracts storage, how PVs are provisioned, and how applications claim storage through PVCs.
Learning Kubernetes - Secret
In this episode, we'll explore Kubernetes Secrets — the native mechanism for storing and consuming sensitive data like passwords, API keys, and TLS certificates. You'll learn how Secrets work, their types, security limitations, and how to use them safely in production.
Learning Kubernetes - Sharing Volume Between Pods
In this episode, we'll discuss how to share volumes between Pods in Kubernetes. We'll learn about PersistentVolumes, PersistentVolumeClaims, StorageClasses, and strategies for sharing data across Pods.
Learning Kubernetes - Environment Variable
In this episode, we'll discuss Environment Variables in Kubernetes. We'll learn how to set environment variables, use ConfigMaps and Secrets, reference Pod fields, and best practices for configuration management.
Learning Kubernetes - Downward API
In this episode, we'll discuss the Downward API in Kubernetes. We'll learn how to expose Pod and container metadata to applications, use fieldRef and resourceFieldRef, and practical use cases.
Learning Kubernetes - Managing Kubernetes Objects
In this episode, we'll discuss managing Kubernetes objects using imperative and declarative approaches. We'll learn the differences, when to use each method, and best practices for object management.
Learning Kubernetes - Introduction and Explanation of Deployment
In this episode, we'll discuss Kubernetes Deployment for managing application rollouts. We'll learn about rolling updates, rollbacks, scaling strategies, and best practices for production deployments.
Learning Kubernetes - Introduction and Explanation of StatefulSet
In this episode, we'll discuss Kubernetes StatefulSet for managing stateful applications. We'll learn about stable network identities, persistent storage, ordered deployment, and best practices for databases and stateful workloads.
Learning Kubernetes - Introduction and Explanation of Kubernetes Dashboard
In this episode, we'll discuss Kubernetes Dashboard for managing clusters through a web UI. We'll learn how to install Dashboard v2.7.0, create admin users, access the dashboard, and best practices for secure dashboard deployment.
Learning Kubernetes - Introduction and Explanation of Computational Resources
In this episode, we'll discuss Kubernetes computational resources management. We'll learn why we should always specify CPU and memory requests and limits, how resource allocation works, and best practices for resource management.
Learning Kubernetes - Introduction and Explanation of Horizontal Pod Autoscaler
In this episode, we'll discuss Kubernetes Horizontal Pod Autoscaler (HPA) for automatic scaling. We'll learn how HPA works, how to configure autoscaling based on CPU, memory, and custom metrics, and best practices for production autoscaling.
Learning Kubernetes - Introduction and Explanation of Vertical Pod Autoscaler
In this episode, we'll discuss Kubernetes Vertical Pod Autoscaler (VPA) for automatic resource sizing. We'll learn how VPA works, how to install and configure it, update modes, and best practices for right-sizing Pod resources automatically.
Learning Kubernetes - Introduction and Explanation of ServiceAccount
In this episode, we'll discuss Kubernetes ServiceAccount for Pod identity and authentication. We'll learn how ServiceAccounts work, how to create and use them, token management, and best practices for secure Pod authentication.
Learning Kubernetes - Introduction and Explanation of RBAC and RoleBinding
In this episode, we'll discuss Kubernetes RBAC (Role-Based Access Control) and RoleBinding for authorization. We'll learn about Roles, ClusterRoles, RoleBindings, ClusterRoleBindings, and best practices for implementing fine-grained access control.
Learning Kubernetes - Introduction and Explanation of Taints and Tolerations
In this episode, we'll discuss Kubernetes Taints and Tolerations for node affinity control. We'll learn how taints repel Pods, how tolerations allow Pods to be scheduled on tainted nodes, and best practices for workload placement.
Learning Kubernetes - Introduction and Explanation of Affinity and Anti-Affinity
In this episode, we'll discuss Kubernetes Affinity and Anti-Affinity for intelligent Pod scheduling. We'll learn how Node Affinity, Pod Affinity, and Pod Anti-Affinity work, and best practices for workload placement.
Learning Kubernetes - Introduction and Explanation of Network Policy
In this episode, we'll discuss Kubernetes NetworkPolicy for fine-grained network traffic control. We'll learn how to implement network segmentation, zero-trust networking, and best practices for securing Pod communication.
Learning Kubernetes - Introduction and Explanation of Pod Security Context
In this episode, we'll discuss Kubernetes Pod Security Context for controlling Pod and container security settings. We'll learn how to run Pods as non-root users, set capabilities, enforce read-only filesystems, and best practices for Pod security.
Learning Kubernetes - Introduction and Explanation of Helm Charts
In this episode, we'll discuss Helm Charts for packaging and deploying Kubernetes applications. We'll learn how to create, customize, and deploy Helm charts, manage dependencies, and best practices for Helm.
Learning Kubernetes - Introduction and Explanation of Kustomize
In this episode, we'll discuss Kustomize for customizing Kubernetes manifests without templating. We'll learn how to use overlays, patches, bases, and best practices for managing multiple environments.
Learning Kubernetes - Introduction and Explanation of GitOps
In this episode, we'll discuss GitOps for managing Kubernetes deployments using Git as the source of truth. We'll learn GitOps principles, tools like ArgoCD and Flux, and best practices for implementing GitOps workflows.
Learning Kubernetes - Introduction and Explanation of External Secret Manager
In this episode, we'll discuss External Secret Manager like HashiCorp Vault for managing secrets in Kubernetes. We'll learn how to store, retrieve, and rotate secrets securely, and best practices for secret management.
Learning Kubernetes - Introduction and Explanation of Observability
In this episode, we'll discuss Observability for monitoring, logging, and tracing Kubernetes applications. We'll learn about metrics, logs, traces, and best practices for implementing observability in Kubernetes.
Learning Kubernetes - Introduction and Explanation of Service Mesh
In this episode, we'll discuss Service Mesh for managing service-to-service communication in Kubernetes. We'll learn about Istio, Linkerd, traffic management, security, and observability features of service meshes.