Kube Architect

Kube Binpacking Exporter exposes Prometheus metrics that show how efficiently your cluster packs requested CPU and memory across nodes, groups, and DaemonSet overhead so you can measure fragmentation over time. More: https://ku.bz/VpnFlkz-0

Marc Campora explains the scenarios where containers are more effective than AWS Lambda for consistent, high-volume traffic. He covers how computational requirements like GPU and CPU-intensive workloads favor containers due to better control over underlying instances. Marc also discusses Lambda's cold start problem - where execution environments starting on demand create variable latency, especially with complex applications loading many libraries. Watch the full episode: https://ku.bz/5gMTkzLhV

This week on Learn Kubernetes Weekly 189: 🔥 Zero-Downtime Kubernetes Ingress Controllers on GCP 🏗️ Architecting GPUaaS for Enterprise AI On-Prem 📋 Conditions, Phases, and Declarative Phase Rules in Kubernetes Operators ⚙️ Container-Aware GOMAXPROCS 💀 Why Your Kubernetes Pod Was OOM Killed and Who Really Killed It Read it now: https://kube.today/issues/189 ⭐️ This issue is brought to you by Solanica - replace RDS with a self-hosted DBaaS on your own Kubernetes clusters with automated Day 2 operations and zero vendor lock-in https://ku.bz/NTszfwH40

Platform teams face a dilemma: standardize everything and frustrate developers, or give full autonomy and create chaos. Zain Malik from ExoStellar proposes a clear boundary: high-level APIs (pod specs, deployments) should be fully accessible to users, while low-level components (device plugins, scheduling plugins) must be standardized by the platform team. This approach gives developers the freedom they need while preventing teams from implementing conflicting topologies and scheduling policies. Watch the full interview: https://ku.bz/rwttMCncv

Stephan Schwarz, DevOps Engineer at iits-consulting, explains the performance implications of Kubernetes scaling delays and how to test for them effectively. He discusses how Horizontal Pod Autoscaler scaling isn't instantaneous - there are built-in delays between scaling events, and in larger environments, node scaling adds additional time. Stephan recommends a practical testing approach: if your deployment can handle 1,000 requests per second, deliberately overload it with 3,000 requests and measure how long Kubernetes takes to recover. This helps teams understand whether the scaling response time aligns with their SLA requirements and error budgets. He emphasizes that teams often overlook these timing constraints when planning capacity, noting that you may need more spare capacity if the scaling delays don't meet your availability requirements. Watch the full episode: https://ku.bz/yY-FnmGfH

Kogaro continuously validates Kubernetes config with 60+ checks across reference, resource, security, image, and network domains, catching silent failures before they impact production. More: https://ku.bz/_DdDJ5wzj

Calin Florescu discusses preventing a centralized Helm chart from becoming a single point of failure. He outlines a two-part strategy: using semantic versioning to control how services consume chart updates (patch, minor, major versions) and implementing thorough testing before releasing new versions. This approach helps teams manage dependencies safely across multiple microservices. Watch the full episode: https://kube.fmhttps://ku.bz/mcPtH5395

Hortator lets AI agents spawn sub-agents at runtime, with each agent running in its own pod with budget caps, network policies, PII redaction, and capability inheritance so children can never escalate beyond their parent's permissions. More: https://ku.bz/kh47Xb28t

"Never upgrade in production" - always use a test environment and run Pluto to detect deprecated APIs. Salman Iqbal on cluster upgrade best practices for Kubernetes platforms. Watch the full interview: https://ku.bz/vsVhFMNZN This interview is a reaction to Pierre Mavro's episode https://ku.bz/cVYyDRLqQ

This week on Learn Kubernetes Weekly 188: 🔥 When ipBlock Breaks HTTPS in Kubernetes: Debugging NetworkPolicy, Traefik, and Hairpin Routing 🔧 How Nginx's New resolve Directive Finally Fixed Our Kubernetes 502s ⚡ Before You Implement KEDA, Do This First 🤝 Why Your CI/CD Pipeline Failures Still Need a Human — And How We're Changing That 📊 Your SLOs Should Be Kubernetes Resources, Not Grafana Dashboards Read it now: https://kube.today/issues/188 ⭐️ 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/7py0zX-ct

This repo contains 20+ tools that auto-generate Kubernetes architecture diagrams from manifests, Helm charts, or cluster state. More: https://ku.bz/VrpBRx5MF

Amine Hilaly, Software Development Engineer at Amazon Web Services (AWS), discusses practical strategies for maintaining operational consistency when scaling from a few Kubernetes clusters to dozens across multiple regions. He identifies 10 clusters in production as a critical threshold where organizations need to fundamentally change their approach from manual cluster management to process-driven automation. Watch the full interview: https://ku.bz/DVM_j_Qjw

Frédéric Gaudet, Senior SRE @ BlaBlaCar, breaks down the technical mechanics behind why Java applications experience slow startup times in Kubernetes environments. He quantifies the real-world impact: 1-1.5 minutes of degraded performance before applications reach optimal speed. This technical deep-dive provides essential context for understanding why Java workloads need special consideration in containerized environments and sets the foundation for discussing infrastructure solutions like service mesh-based pod warming strategies. Watch the full episode: https://ku.bz/grxcypt9j

Review quality tends to drop when changes move from code to configuration. Shivay Lamba argues that YAML and Helm updates often avoid the same level of automated testing and repeated execution paths that application code gets, which makes configuration defects easier to miss until the later deployment stages approach. Watch the full interview: https://ku.bz/lzl3pF_Ft

This tutorial shows how to secure east-west traffic in GKE using an Internal Regional Gateway with Envoy proxies, certificates, HTTP Routes with path rewriting, and a zero-trust architecture for service-to-service communication. More: https://ku.bz/VqqYrclKm

PostgreSQL on Kubernetes is no longer “can we?” but “how?” This guide covers the architecture choices that matter: operators, HA, PgBouncer, storage, monitoring, backups, and PITR. https://ku.bz/LvMcNf6KT

With k-inv, you can stress a Kubernetes cluster in a fun way and check its resilience by playing space invaders. More: https://ku.bz/chMMB0vF_

Molly Sheets, Director of Engineering, Kubernetes at Zynga, addresses the common fears teams have about multi-tenant Kubernetes and provides specific technical practices to make it work effectively. She explains why teams worry about sharing cluster space and outlines the essential safeguards needed for successful multi-tenancy. Molly emphasizes that CPU limits are more critical than memory limits for game workloads and stresses the importance of resource quotas. She also discusses monitoring strategies that cover both low-level resource usage and application-level metrics. A key insight is her focus on host-level requirements and shared agent dependencies - highlighting how disk space usage by shared components can impact all tenants if not properly managed. Watch the full episode: https://ku.bz/Rmpl8948_

This week on Learn Kubernetes Weekly 187: 🧠 Applying Kubernetes Patterns to LLM Workloads 🐢 Why Your Grafana is Slow on Kubernetes (and 3 Replicas Won't Fix It) 📊 Observability at Albert Heijn 🎬 Vibe Coding a Kubernetes Media Server: What I Learned About AI-First Engineering 🔌 Installing Kong Gateway Custom Plugins on Kubernetes using Helm Charts Read it now: https://kube.today/issues/187 ⭐️ This newsletter is brought to you by WeAreDevelopers World Congress — The World’s Largest Event for Developers, AI Builders & Tech Leaders https://ku.bz/cwnthSpPK

StormForge just received the patent for their HPA algorithm — four years after first applying. Yasmin Rajabi from CloudBolt Software explains what makes it unique: the algorithm adjusts CPU and memory requests while preserving your HPA scaling behavior by patching target utilization. Most vertical-right-sizing tools break horizontal scaling — StormForge's approach keeps them working together. Watch the announcement: https://ku.bz/BLhCGcbB9 Read the announcement: https://ku.bz/JrbVrpS_t