Kubernetes on Dev & Platform Engineering Hub

Kubernetes Ep 15: Production Helm Charts & Package Deployment

Mon, 10 Aug 2026 01:15:00 +0000

Managing dozens of static YAML manifests across multiple environments (dev, staging, prod) leads to repetitive code and configuration drift. Helm is the official package manager for Kubernetes, enabling templating, parameterization, versioned releases, and one-click upgrades.

Kubernetes Ep 14: Health Checks & Zero-Downtime Rolling Updates

Mon, 10 Aug 2026 01:10:00 +0000

In production, a container might be in a Running state according to Docker, yet completely unable to serve HTTP traffic due to a deadlock, database connection timeout, or slow boot sequence. Probes and Rolling Updates guarantee zero-downtime application deployments.

Kubernetes Ep 13: RBAC, ServiceAccounts & Security

Mon, 10 Aug 2026 01:05:00 +0000

Security in Kubernetes follows the Principle of Least Privilege. Role-Based Access Control (RBAC) regulates who (Users, Groups, or ServiceAccounts) can perform which actions (verbs: get, list, create, delete) on which resources (nouns: pods, services, secrets).

Kubernetes Ep 12: Namespaces, Resource Quotas & LimitRanges

Mon, 10 Aug 2026 01:00:00 +0000

In enterprise environments, a single Kubernetes cluster is shared across multiple development teams, environments (dev, staging, prod), and microservices. Without resource governance, a single misbehaving application can consume all cluster CPU and memory, crashing critical workloads.

Kubernetes Ep 11: Jobs, CronJobs & Batch Processing

Mon, 10 Aug 2026 00:55:00 +0000

Unlike Deployments and StatefulSets—which are designed to keep long-running processes alive indefinitely—Jobs and CronJobs are designed for run-to-completion batch tasks. When the workload process terminates with exit code 0, Kubernetes marks the Pod as Completed.

Kubernetes Ep 10: DaemonSets & Cluster Node Agents

Mon, 10 Aug 2026 00:50:00 +0000

While Deployments distribute Pods across nodes based on available capacity, DaemonSets ensure that a copy of a specific Pod runs on all (or selected) worker nodes in the cluster. As nodes are added to or removed from the cluster, DaemonSet Pods are added or garbage-collected automatically.

Kubernetes Ep 9: StatefulSets & Stateful Database Deployments

Mon, 10 Aug 2026 00:45:00 +0000

While Deployments are designed for interchangeable, stateless application replicas, stateful workloads like PostgreSQL clusters, Redis Sentinels, Kafka brokers, and Elasticsearch nodes require stable network identities, dedicated persistent volumes per replica, and strict ordered deployment & scaling. This is where StatefulSets shine.

Kubernetes Ep 8: Persistent Volumes, PVCs & StorageClasses

Mon, 10 Aug 2026 00:40:00 +0000

Containers are designed to be stateless and ephemeral. To run stateful applications like PostgreSQL, MySQL, Redis, or Elasticsearch, Kubernetes provides storage abstractions that decouple persistent storage infrastructure from application workload definitions.

Kubernetes Ep 7: ConfigMaps, Secrets & Environment Variables

Mon, 10 Aug 2026 00:35:00 +0000

The Twelve-Factor App methodology mandates strict separation of application code from configuration settings. ConfigMaps store non-sensitive configuration data (URLs, log levels), while Secrets store sensitive values (passwords, API tokens, TLS keys).

Kubernetes Ep 6: Ingress Controllers & HTTP Path Routing

Mon, 10 Aug 2026 00:30:00 +0000

While L4 Kubernetes Services handle IP and port-level load balancing, modern web applications require Layer 7 HTTP/HTTPS routing features: URL path matching (/api vs /app), hostname routing (api.example.com), SSL/TLS termination, and header rewriting. This is handled by Ingress.

Kubernetes Ep 5: Networking Services (ClusterIP, NodePort, LoadBalancer)

Mon, 10 Aug 2026 00:25:00 +0000

Pods are ephemeral—they are created, destroyed, and rescheduled dynamically, causing their IP addresses to change constantly. A Kubernetes Service provides a stable, persistent virtual IP (VIP), DNS name, and load balancing frontend across a dynamic set of backend Pods.

Kubernetes Ep 4: Deployments, ReplicaSets & Self-Healing Scaling

Mon, 10 Aug 2026 00:20:00 +0000

While Pods are the basic building blocks of Kubernetes, you should rarely deploy bare Pods directly. Instead, production applications use Deployments, a higher-level abstraction that manages ReplicaSets to guarantee high availability, self-healing, and seamless scaling.

Kubernetes Ep 3: kubectl CLI & Launching Your First Pod

Mon, 10 Aug 2026 00:15:00 +0000

The kubectl command-line interface is the primary tool platform engineers and developers use to interact with Kubernetes clusters. In this episode, we’ll configure kubectl and deploy our first atomic Kubernetes primitive: the Pod.

Kubernetes Ep 2: Architecture - Control Plane & Worker Nodes

Mon, 10 Aug 2026 00:10:00 +0000

A Kubernetes cluster consists of two primary logical layers: the Control Plane (the cluster’s brain) and Worker Nodes (the muscle that runs application containers). Understanding how these components communicate is crucial for cluster administration and troubleshooting.

Kubernetes Ep 1: Introduction to Kubernetes & Containers

Mon, 10 Aug 2026 00:05:00 +0000

The evolution of modern infrastructure has transitioned from physical bare-metal servers to Virtual Machines (VMs), lightweight OCI Containers, and ultimately automated Container Orchestration platforms like Kubernetes.

Kratix Ep 10: Observability and Operations

Sun, 09 Aug 2026 21:40:00 +0000

Operating a multi-cluster architecture introduces a massive observability challenge. If a Kratix Pipeline fails, the logs are in the Platform cluster. If the physical database fails, the logs are in the Worker cluster. In this episode, we build a centralized monitoring stack using Prometheus and Grafana.

Kratix Ep 9: Promise CI/CD with GitHub Actions

Sun, 09 Aug 2026 21:30:00 +0000

Platform Engineers write code too. When you build a complex Promise, you must compile the Pipeline container, lint the YAML, and safely deploy it to the Platform Cluster. In this episode, we build a robust GitHub Actions CI/CD pipeline to automate the lifecycle of Kratix Promises.

Kratix Ep 7: Secrets Management with ESO and Vault

Sun, 09 Aug 2026 21:10:00 +0000

GitOps has one fatal flaw: You cannot commit secrets to a Git repository. When Kratix generates a Redis password during a Pipeline execution, how does it securely deliver that password to the Worker Cluster? In this episode, we solve the GitOps secrets problem using HashiCorp Vault and ESO.

Kratix Ep 6: FluxCD GitOps Integration

Sun, 09 Aug 2026 21:00:00 +0000

If your organization prefers Flux over ArgoCD, Kratix supports it natively without any modifications to the Platform Cluster. Because Kratix simply writes standard YAML to a Git repository, any GitOps controller can act as the delivery agent. In this episode, we configure FluxCD on the Worker Cluster.

Kratix Ep 5: ArgoCD GitOps Integration

Sun, 09 Aug 2026 20:50:00 +0000

In this episode, we learn HOW to execute the GitOps pull model in practice. We will configure ArgoCD on a Worker Cluster to continuously sync the Redis StatefulSet YAML generated by our Kratix Pipeline, ensuring you understand the mechanics of the State Store.

Kratix Ep 4: Core Concepts Deep Dive (How-To)

Sun, 09 Aug 2026 20:40:00 +0000

Enough theory. It’s time to look at the YAML. In this episode, we build the E-Commerce Redis Promise line-by-line. We will examine the API schema, the Pipeline configuration, and the Destination selectors that make multi-cluster deployment possible, ensuring you understand exactly how Kratix executes your logic.

Kratix Ep 2: Multi-Cluster Architecture & IaC

Sun, 09 Aug 2026 20:20:00 +0000

In this episode, we deeply analyze the ‘Where’ of the 5W1H framework. We will map out the Hub and Spoke topology, learn why Kratix intentionally isolates the Platform Cluster from the Worker Clusters for security, and explore how traditional Infrastructure-as-Code (like Terraform) executes inside this GitOps-driven model.

Crossplane Ep 15: Building an IDP with Backstage

Sun, 09 Aug 2026 19:40:00 +0000

We have built the APIs, the translation engine, the GitOps pipeline, and the security webhooks. But developers still have to write YAML to request a database. In this final episode, we integrate Crossplane with Backstage to create the ultimate Internal Developer Portal (IDP).

Crossplane Ep 14: Custom Composition Webhooks

Sun, 09 Aug 2026 19:30:00 +0000

OpenAPI schema validation (like type: integer) is too basic for enterprise security. What if you need to enforce that a database’s storage size is an even number, or that the requested environment matches a specific regex? In this episode, we write a Kubernetes Validating Webhook in Go to intercept and inspect Crossplane Claims.

Crossplane Ep 13: Provider Families and Performance

Sun, 09 Aug 2026 19:20:00 +0000

If you install the monolithic provider-aws package into a small EKS cluster, your Kubernetes API server might crash. AWS has over 1,000 resources, meaning Crossplane will inject 1,000 CRDs and run a massive Go controller in memory. In this episode, we learn how to architect high-performance Crossplane clusters using Provider Families.

Crossplane Ep 12: GitOps with ArgoCD and Crossplane

Sun, 09 Aug 2026 19:10:00 +0000

If you are running kubectl apply -f my-database.yaml from your laptop, you are doing it wrong. In modern Platform Engineering, no human should ever talk directly to the Kubernetes API. In this episode, we configure ArgoCD to automatically deploy Crossplane XRs directly from a GitHub repository.

Crossplane Ep 11: Writing Composition Functions in Go

Sun, 09 Aug 2026 19:00:00 +0000

In Episode 10, we learned that Composition Functions allow us to escape the limitations of YAML. In this episode, we will write a custom Go program that dynamically generates an array of AWS Subnets based on a single integer provided by the Application Developer.

Crossplane Ep 10: Introduction to Composition Functions

Sun, 09 Aug 2026 18:40:00 +0000

YAML is excellent for configuration, but terrible for programming. As your Platform scales, you will inevitably need for loops, complex if/else logic, and external API calls. In this final intermediate episode, we introduce Composition Functions—the architecture that allows you to write Crossplane logic in Turing-complete languages.

Crossplane Ep 9: Troubleshooting Sync Errors

Sun, 09 Aug 2026 18:30:00 +0000

When you run terraform apply, you get immediate red text in your console if an AWS API call fails. Because Crossplane is an asynchronous control loop, kubectl apply always succeeds immediately. When a database fails to boot 10 minutes later, how do you find the error? In this episode, we learn the Crossplane troubleshooting cascade.

Crossplane Ep 8: Managing Dependencies Between Resources

Sun, 09 Aug 2026 18:20:00 +0000

If a Composition provisions both an AWS VPC and a Subnet, the Subnet physically cannot be created until the VPC exists and returns an ID. In Terraform, you use implicit dependency mapping (e.g., vpc_id = aws_vpc.main.id). In Crossplane, we manage this using Cross-Resource References and Selector matching.

Crossplane Ep 7: Environment Configs

Sun, 09 Aug 2026 18:10:00 +0000

If your company has three clusters (Development, Staging, and Production), you do not want to write three different Compositions for the same RDS database. In this episode, we learn how to use Crossplane EnvironmentConfigs to inject global context (like AWS Account IDs, VPC IDs, and Regions) dynamically into your Compositions.

Crossplane Ep 6: Patching and Transforms

Sun, 09 Aug 2026 18:00:00 +0000

In Episode 5, we hardcoded our RDS instance size to 20GB. If a developer asked for 50GB in their Claim, Crossplane ignored it. In this episode, we explore the Patcher, learning how to dynamically route data from the Composite Resource (XR) into the physical Managed Resources (MRs).

Crossplane Ep 5: Compositions

Sun, 09 Aug 2026 17:50:00 +0000

In Episode 4, we built an API (XRD) but it didn’t actually create any AWS infrastructure. In this final fundamental episode, we write a Composition. This is the ’translation engine’ that instructs Crossplane exactly which physical Managed Resources to create when a developer requests our custom API.

Crossplane Ep 4: Composite Resources (XR)

Sun, 09 Aug 2026 17:40:00 +0000

Managed Resources (MRs) are too low-level for application developers. In this episode, we learn how to define a Composite Resource Definition (XRD). This allows Platform Engineers to design a brand new, highly abstracted Custom Kubernetes API tailored exactly to their company’s needs.

Crossplane Ep 3: Managed Resources (MR)

Sun, 09 Aug 2026 17:30:00 +0000

A Managed Resource (MR) is the foundational building block of Crossplane. It is a 1-to-1 representation of a physical cloud object (like an S3 Bucket or an RDS Instance) stored as a Custom Resource in Kubernetes. In this episode, we provision our first AWS resource directly via kubectl.

Crossplane Ep 2: Providers and Credentials

Sun, 09 Aug 2026 17:20:00 +0000

Crossplane is useless on its own. To orchestrate AWS, Azure, or GCP, we must install Providers. In this episode, we install the official Upbound AWS Provider, configure Kubernetes Secrets to store our IAM credentials, and bind them to a ProviderConfig.

Crossplane Ep 1: The Kubernetes Native Control Plane

Sun, 09 Aug 2026 17:10:00 +0000

To understand Crossplane, you must first understand the Kubernetes Control Loop. In this episode, we explore the theoretical difference between CLI-driven IaC (Terraform) and Control Plane IaC (Crossplane). We will then install Crossplane into a local cluster using Helm.

CKS Deep Guide: Cluster Hardening & Runtime Security

Sun, 09 Aug 2026 16:15:00 +0000

The Certified Kubernetes Security Specialist (CKS) is the pinnacle performance exam testing your ability to secure containerized workloads, harden Kubernetes clusters, and detect runtime attacks.

CKAD Deep Guide: Application Design & Deployment Strategies

Sun, 09 Aug 2026 16:10:00 +0000

The Certified Kubernetes Application Developer (CKAD) exam tests your ability to design, build, expose, and troubleshoot cloud-native applications running inside Kubernetes clusters.

CKA Deep Guide: Cluster Architecture, Installation & etcd Backup

Sun, 09 Aug 2026 16:05:00 +0000

The Certified Kubernetes Administrator (CKA) exam is a 100% performance-based practical exam. You must execute complex administrative tasks directly inside Linux terminal command lines within a 2-hour window.

KCNA Deep Guide: Cloud Native Architecture & Exam Mastery

Sun, 09 Aug 2026 16:00:00 +0000

The Kubernetes and Cloud Native Associate (KCNA) certification tests your foundational understanding of the Cloud Native ecosystem, CNCF project landscape, and Kubernetes control plane mechanics.

CKAD Ep 1: Multi-Container Pod Patterns & Design

Sun, 09 Aug 2026 14:00:00 +0000

Multi-container Pod patterns allow containers to share storage and network namespaces to extend functionality without modifying application source code. Designing these patterns under time pressure is a core domain of the CKAD exam.

KCNA Ep 3: Container Orchestration & Workload Primitives

Sun, 09 Aug 2026 13:15:00 +0000

Workload resources define how application containers are scheduled, scaled, and managed across a Kubernetes cluster. Understanding when to choose a Deployment vs a StatefulSet, DaemonSet, or Job is essential for the KCNA exam.

KCNA Ep 2: Kubernetes Fundamentals & Architecture

Sun, 09 Aug 2026 13:10:00 +0000

A Kubernetes cluster is divided into a Control Plane (the brain) and Worker Nodes (the muscle). Understanding how these components communicate via the declarative REST API is a core requirement for the KCNA exam.

KCNA Ep 1: CNCF Ecosystem & Cloud Native Architecture

Sun, 09 Aug 2026 13:05:00 +0000

The Kubernetes and Cloud Native Associate (KCNA) exam is a multiple-choice certification designed to test your foundational knowledge of the cloud-native ecosystem. In this first episode, we explore the CNCF landscape, cloud-native architecture patterns, and containerization principles.

K8s Ep 1: Architecture & Your First Multi-Node Local Cluster Setup

Sun, 09 Aug 2026 08:10:00 +0000

Many Kubernetes tutorials overwhelm you with hours of theory before ever touching a terminal. Here, we embrace the HowToForge philosophy: we build it first, then we dissect how it works.