Battle-tested Autoscaling Paradigms with KEDA
There are two kinds of autoscaling configurations: the ones that make for a great demo, and the ones that survive production. This session shares lessons from autoscaling strategies proven across thousands of production Kubernetes clusters.
Drawing from a broad KEDA user base, the session covers practical patterns for fine-tuning autoscaling behavior while improving resiliency: combining signals, avoiding noisy or overly reactive scaling decisions, and reducing the load autoscaling queries place on centralized monitoring systems through metric caching with OpenTelemetry.
In complex microservice architectures, autoscaling often spans multiple applications and infrastructure layers that must react in coordination. This session will discuss chained scaling patterns and practical ways to reduce delays between dependent scaling decisions, so teams can keep reliability and infrastructure costs predictable in production.
Efficient Kubernetes Autoscaling: News, Challenges, and Best Practices with KEDA
This session offers a comprehensive overview of recent KEDA news, highlighting new features and integrations designed to simplify Kubernetes autoscaling, as well as discussing upcoming enhancements and future roadmap items.
The talk will cover practical lessons and best practices drawn from hands-on experiences, addressing key challenges like metrics latency, overloaded infrastructure, and scaling trigger optimization. You will learn effective approaches for managing performance, minimizing scaling delays, and preventing bottlenecks. We will discuss the challenges of using (or misusing?) third-party monitoring and metrics providers for scaling decisions, exploring practical ways to overcome limitations without complex architectural changes.
Learn from our direct experiences about effective strategies, performance optimization techniques, and how to build resilient, cost-optimized autoscaling solutions with KEDA.
Spin-Up, Test, Tear-Down: How trivago Runs Developer Preview Environments at Scale
When developers write software, they need a place to run and test their code. Preview environments empower engineers to validate changes safely, but running hundreds of them at once can blow away your cloud budget and operational sanity. At trivago, 200+ engineers build services around the clock, so a reliable, cost-efficient platform is crucial.
In this session, we'll share how we designed our Kubernetes-based preview system for speed and efficiency, using KEDA to autoscale environments based on real demand. We'll cover the architecture, challenges, and why Kubernetes & KEDA fit this use case, along with the right metrics and safety checks to keep the system reliable. We collaborated with the KEDA community and maintainers to improve HTTP‑based scaling, especially scale‑to‑zero, so it's trustworthy at large scale. You'll leave with concrete ideas and a blueprint for running previews at scale, supporting rapid delivery while keeping waste low with CNCF projects.
From Reactive to Proactive: Forecast-Driven Scaling for Kubernetes
Picture this: you’re already using Karpenter to scale nodes and KEDA to scale workloads, now what? How do you know you’re getting the most out of both? In this talk, we will go beyond day-1 setup into day-2 operations - practical troubleshooting, cost optimization, and efficiency patterns that make autoscaling boringly reliable.
We’ll dive into advanced Karpenter strategies including Node Disruption Budgets, consolidation techniques to eliminate waste, NodeOverlays for specialized configurations, optimizing node bootstrap, and techniques for influencing pod scheduling. On the KEDA side, discover how to choose the right metrics and triggers, further optimise that using scaling modifiers to fine-tune the behaviour, and how to shift from reactive scaling to predictive workload sizing that anticipates demand.
This session delivers practical patterns and battle-tested techniques for running KEDA and Karpenter successfully in production.
Autoscaling Isn't Set-and-Forget: Tuning KEDA & Karpenter for Real Workloads
You've deployed KEDA and Karpenter, now what? Most talks stop at "it scales." This one starts there. We'll dive into the advanced configurations, failure modes, and optimization patterns that separate demo clusters from production workloads. On the Karpenter side: Node Disruption Budgets to control voluntary disruptions, how to survive Spot interruptions gracefully, and bootstrap optimizations that shave minutes off node startup. On KEDA: scaling modifiers that combine multiple metrics into smarter decisions, cooldown tuning to prevent thrashing, and the shift from reactive scaling to proactive workload sizing. We'll show how Karpenter and KEDA changes the equation: what you get out of the box, what you still need to configure, and how all of this fits into building an efficient Kubernetes cluster.
Double the Efficiency: Kubernetes Autoscaling with Karpenter and KEDA
Autoscaling in Kubernetes can be significantly simpler when you have the right tools to help you. Who doesn’t want a highly efficient Kubernetes cluster? You, me, and even our planet. The novel approach of Karpenter for node autoscaling helps many organisations reduce their spending by up to 70% on their cloud infrastructure. KEDA as an established standard for pod scaling plays an equally important role in the autoscaling ecosystem. How can these two technologies work together for even greater efficiency? This session offers practical insights from KEDA and Karpenter contributors into the current state of autoscaling, and it will give you a set of useful recommendations you can apply after leaving KubeCon.
Reverse K8s resources: from YAML to Go structs
In the Kubernetes world, it is a common use case to convert API resources written in Go to YAML manifests for further distribution whether as part of helm chart, kustomize template or other tools. How hard can it be to go the other way around, take a YAML manifest and generate a valid Go code from that? This session looks at Kubernetes codecs, scheme, Go reflections, and Go AST parsers from a little unusual perspective.
Learn You Some eBPF for Greater Good
Have you ever wondered how can you leverage the capabilities of eBPF for your Kubernetes clusters? Have you ever tried to start with eBPF but got lost in the complexity and ultimately found yourself discouraged to reach your goal? Advance your understanding by joining this workshop where you can learn how to write an eBPF program from scratch and deploy that into your cloud environment.
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top