This code tool converts JSON files into Kubernetes resource manifests, allowing you to use JSON/jsonnet workflows while still generating valid YAML for Kubernetes.

More: https://ku.bz/Vbm_rFw4y

Karpenter can consolidate nodes and reduce cloud costs. But without Pod Disruption Budgets, those savings can expose workloads to avoidable downtime.

Ahmad Asmar from Zencity explains how they use Kyverno to generate PDBs automatically instead of relying on every developer to remember the required configuration.

You will learn:

- Why Karpenter consolidation and Spot instances make PDB coverage critical
- How Kyverno detects existing PDBs through workload labels
- Why percentage-based budgets work better for scaling workloads
- How ClusterRole aggregation extends Kyverno without modifying its Helm chart

Watch: https://ku.bz/xrlPJg54D

🌟 This episode is sponsored by LearnKube. Download the free book, The Technical Guide to Kubernetes Rightsizing, to understand what Prometheus and Grafana cannot tell you about safely reducing requests and limits. https://learnkube.com/kubernetes-rightsizing

With @Birthmarkb

New from LearnKube: Setting the right requests and limits in Kubernetes.

CPU and memory requests and limits appear together in a Pod manifest, but Kubernetes and Linux use them at different stages.

You will learn:

• How the scheduler compares requests with node allocatable capacity
• Why actual usage can exceed a request
• How CPU quotas cause throttling even when average CPU looks low
• Why an OOM kill is different from a node-pressure eviction
• How requests and limits determine Kubernetes QoS classes

The article is the first chapter of The Technical Guide to Kubernetes Rightsizing, co-authored by Gulcan and Daniele Polencic.

Read the chapter:
https://learnkube.com/setting-cpu-memory-limits-requests

Download the free technical guide:
https://learnkube.com/kubernetes-rightsizing

This book was made possible by CloudBolt Software.

Rolling your worker nodes during a Kubernetes upgrade sounds straightforward… until your PDBs get ignored.

Jason Deal explains why PDB-aware tooling matters: if your infrastructure provider doesn't respect Pod Disruption Budgets, those constraints won't protect your workloads during a node rollout. Karpenter and EKS Auto Mode are built to respect PDBs natively, evicting nodes only when doing so won't violate availability constraints.



Watch the full interview: https://ku.bz/1_-DTgLsg

This tutorial shows how to make Kubernetes HPA scale to zero with a Redis queue and external metrics, plus the production limits to watch for.

More: https://ku.bz/gccDrpDsg

This week on Learn Kubernetes Weekly 196:

🛠️ How I Rebuilt YouTube’s Load Balancing Algorithm in Go
💾 When ETCD Crashes, Check Your Disks First: A Pod CrashLoopBack Debugging Story
🧩 We Blamed CoreDNS for Weeks. The Real Culprit Was a Default We Never Questioned
🚚 Zero-Downtime EKS Migration: Production-Grade Kubernetes at Scale
⚡ Deterministic Routing: The Hidden Key to Low Latency

Read it now: https://kube.today/issues/196

⭐️ This newsletter is brought to you by LearnKube — master Kubernetes with hands-on training designed for engineers who want to learn the smart way https://ku.bz/hypSbyc-V

wellcake is a Kubernetes operator for Valkey that runs standalone, replication, sentinel and cluster topologies from one CRD, with failover, rolling restarts, S3 backups and secret rotation.

More: https://ku.bz/CvRxFcJkG

This article reads the HPA as a proportional controller from control theory, showing why the deadband, high gain and slow response trade-offs are unavoidable, and what dead time and pod quantization do to a PID version of it.

More: https://ku.bz/FdGgBK2q8

KSolver is a Kubernetes cost optimizer that uses CP-SAT constraint programming to find cheaper node fleets, explain blockers, simulate changes, and rank safe savings actions.

More: https://ku.bz/Xlk2fDVR4

Agent Substrate is a Kubernetes runtime for stateful agents that packs many mostly idle agents onto a few worker pods while keeping each agent's memory, filesystem state and routing intact.

More: https://ku.bz/YjGjp1VDr

Yoke is an IaC tool inspired by Helm that leverages WebAssembly and Go to dynamically deploy Kubernetes packages with executable runtime capabilities.

It supports revision tracking, rollback, and inspection.

More: https://ku.bz/-BsGSRxdD

This article opens up Xatastor, the storage system Xata built for millions of Postgres databases, explaining why they chose ZFS zvols over NVMe-oF instead of Ceph or Longhorn, and how their Kubernetes operator drives it.

More: https://ku.bz/LcBp9Pl1h

This article explains Kubernetes operators as feedback controllers, connecting reconciliation, informers, queues, spec/status, and self-healing behavior to database operations.

More: https://ku.bz/93cbkRmhc

This article opens up Volcano's controllers to show how gang scheduling avoids the deadlock where half a distributed job holds resources, following the PodGroup and Job state machines with real cluster logs.

More: https://ku.bz/20Fv1tPVM

Nicholaos Mouzourakis, Staff Product Security Engineer at Gusto, explains how Joel Spolsky's "Law of Leaky Abstractions" applies to Kubernetes environments. He emphasizes the profound concept that "abstraction saves us time working, but does not save us time learning" and introduces the idea of learning debt that must eventually be paid when abstractions leak.

Nicholaos describes how Kubernetes administrators often face complex problems with incomplete information and tight deadlines. He explains:

- Every lower-level technology you don't understand creates a learning debt
- Understanding the layers beneath your abstractions reduces troubleshooting time
- Modern containerized environments (often lacking shells for security) make this understanding even more critical
- Not understanding how layers interact creates security vulnerabilities like injection attacks

Watch the full episode: https://kube.fmhttps://ku.bz/S-2vQ_j-4

This tutorial shows how GoReplay replays real production traffic in Kubernetes so you can test a new Go service before sending users to it.

More: https://ku.bz/q9XdR4mlz

An SRE compares Istio, Linkerd and Cilium after eighteen months of running Istio in production, on operational cost, performance overhead, security model and observability.
The verdict: most teams should start with Linkerd, or no mesh at all.

More: https://ku.bz/0zHlrMG9F

This tutorial shows how KEDA scales workloads on queue depth instead of CPU, with a full RabbitMQ example: install, TriggerAuthentication, ScaledObject and a load test that proves the scaling works.

More: https://ku.bz/h98Gv_lXp

This article explains why CPU is the wrong scaling signal for Pub/Sub consumers, since pods look healthy while the backlog grows, and argues for scaling on queue depth with KEDA instead.

More: https://ku.bz/DSn2WpFDD

CI updates Git while Argo CD updates the cluster.

At WSC Sports, Elad Cohen separates delivery responsibilities: CI patches a values file, and Argo CD reconciles the cluster. Self-healing keeps Git as the declared state.

- Why CI and CD need separate roles
- How ApplicationSets create shadow deployments
- How AppProjects restrict team access
- Why shared Helm charts reduce one-offs

Watch: https://ku.bz/wX5H5Mjwv

This episode is sponsored by LearnKube. Download the free book, The Technical Guide to Kubernetes Rightsizing, to understand what Prometheus and Grafana cannot tell you about safely reducing requests and limits.

Hosted by Bart Farrell.