This article explains why scaling GPU inference services on Kubernetes is challenging and presents a multi‑layer control architecture, metric upgrades, and production‑ready implementations using HPA, KEDA, KServe, and Karpenter to achieve stable, cost‑effective autoscaling.
This article walks through a systematic, bottom‑up performance tuning process for Kubernetes clusters—covering kernel parameters, container runtime, kubelet, scheduler, and pod resource settings—backed by a real‑world e‑commerce case study that reduced latency by over 80% and cut OOM events by 97.5%.
Horizontal Pod Autoscaler (HPA) in Kubernetes automatically scales pod replicas based on metrics like CPU, memory, or custom indicators, and this guide explains its core principles, configuration pitfalls, step‑by‑step troubleshooting commands, and advanced considerations such as API versions, stabilization windows, and integration with Cluster Autoscaler.
This guide explains why Deployments are essential in Kubernetes, walks through a full production‑grade YAML, and covers replica control, rolling updates, health probes, anti‑affinity, scaling, and rollback best practices for resilient cloud‑native applications.
This guide walks you through a complete, 30‑minute implementation of Kubernetes node autoscaling using Horizontal Pod Autoscaler (HPA) with custom Prometheus metrics, covering prerequisites, anti‑pattern warnings, environment matrix, step‑by‑step deployment, core principles, observability, troubleshooting, best practices, and FAQ.
ACK One Fleet, Alibaba Cloud's enterprise multi‑cluster solution, provides inventory‑aware elastic GPU scheduling, cross‑region resource sharing, multi‑cluster HPA and model distribution, allowing AI inference and training workloads to scale efficiently, reduce costs, and maximize GPU utilization.
This article explains the internal architecture and source‑code flow of Kubernetes Horizontal Pod Autoscaler, detailing how components like HorizontalController and ReplicaCalculator compute desired replicas, why a default 10% tolerance can prevent scaling even when CPU exceeds the target, and how behavior policies and scaling limits influence HPA decisions.
This guide explains why resource limits are essential in Kubernetes, how to configure Namespace‑level ResourceQuota and Pod‑level Requests/Limits, and provides a practical case study with YAML examples to prevent a single service from exhausting cluster CPU and memory.
This guide walks you through the complete Kubernetes service deployment workflow, covering Docker image creation with multi‑stage builds, pushing to a registry, defining Deployment and Service resources, applying and monitoring them, managing configuration, implementing horizontal pod autoscaling, and integrating logging and monitoring solutions.
This guide explains how to use cAdvisor‑provided container network traffic counters as custom metrics for Kubernetes HPA, covering metric collection, Prometheus‑adapter configuration, verification, and a complete HPA testing workflow for elastic scaling of non‑CPU‑intensive workloads.
This guide explains what Kubernetes Horizontal Pod Autoscaler (HPA) is, how it works, its key features, and provides step‑by‑step configuration, verification, and scaling policy details with practical code examples for cloud‑native applications.
This guide walks through Kubernetes Deployment controllers, showing how to generate YAML templates, manage replica counts, apply dynamic scaling with Horizontal Pod Autoscaler, and perform rolling image upgrades and rollbacks, all with practical command‑line examples.
This guide shows how to enable Horizontal Pod Autoscaling for traffic‑driven workloads by leveraging cAdvisor's container network receive and transmit byte counters, converting them to per‑second rates with Prometheus‑adapter, and validating the custom metric through Kubernetes commands and console views.
This article explains how to configure Kubernetes Horizontal Pod Autoscaler (HPA) for automatic pod scaling, covering core concepts, metric selection, and two detailed YAML examples that demonstrate scaling based on CPU utilization and custom data‑processing rates.
Vivo’s container platform combats oversized resource requests by first applying static coefficient‑based overcommit at deployment and then using a dynamic recommender that continuously gathers usage metrics, builds exponential histograms with a half‑life sliding‑window model, and adjusts CPU (and optionally memory) requests, improving packing efficiency, reducing billing, and boosting CPU utilization by up to eight percent while maintaining HPA accuracy.
The QQ image storage platform was fully migrated from VM‑based servers to Tencent Cloud’s Kubernetes Engine, consolidating services into containers, adding health checks, anti‑affinity, and autoscaling, which cut costs by 26%, reduced ops effort 30%, and improved scalability and reliability.
This article summarizes Zhang He’s Bilibili SRE talk on building a capacity‑management system that visualizes resource usage, reduces costs, improves stability, and leverages Kubernetes VPA, HPA, pooling, and quota management to support massive live‑stream events and rapid feature releases.
This article explores Kubernetes horizontal pod autoscaling mechanisms, comparing HPA and KEDA, their implementation principles, limitations, and practical deployment scenarios for cloud-native applications.
This article explains pod‑level elasticity in Kubernetes by detailing the principles, metric types, and limitations of the Horizontal Pod Autoscaler (HPA) and then introduces KEDA as an event‑driven extension that adds true scale‑to‑zero capabilities, complete with configuration examples and code snippets.
The article explains Kubernetes’ built‑in Horizontal Pod Autoscaler, then details the custom Water Pod Autoscaler (WPA) that extends HPA with dual‑signal (load and SOA registration) detection, dual‑threshold scaling, noise filtering, configurable cooldown, frequency limits, tolerance buffers, and integrated alerting for reliable elastic scaling.
This article walks through the entire lifecycle of deploying an application on Kubernetes, explaining how Docker containers differ from virtual machines, the role of Pods, ReplicationControllers, Deployments, and how automatic scaling with HPA and VPA keeps services reliable and efficient.
The article details a Tencent‑led, end‑to‑end cost‑optimization project for large‑scale Kubernetes/TKE clusters that collected extensive workload metrics, applied VPA/HPA enhancements, custom scheduling and node‑downscaling via the open‑source Crane platform, ultimately delivering up to 70% CPU and 50% memory savings with zero‑fault deployments.
This article explains three frequent misunderstandings about Kubernetes Horizontal Pod Autoscaler—dead zones, misuse of utilization calculations, and perceived lag in scaling—while detailing HPA’s inner workings, metric sources, calculation methods, and behavior configuration to help you avoid scaling pitfalls.
This presentation details Huolala's end‑to‑end cloud‑native cost‑optimization strategy, covering the company's infrastructure basics, Kubernetes‑based server cost‑saving techniques, a tailored optimization roadmap, practical Spot Instance usage, and a custom CronHPA‑driven scheduled scaling solution to boost resource utilization.
This article presents a comprehensive, data‑driven case study of how Tencent’s internal Kubernetes/TKE platform reduced monthly CPU usage by up to 70% and memory usage by 50% through systematic cost data collection, VPA/HPA enhancements, custom scheduling, node‑level over‑commit, and safe node decommissioning, while maintaining zero‑incident reliability.
This article explains the background, benefits, and measurement criteria of Kubernetes Horizontal‑Pod‑Autoscaler (HPA), describes the creation of metric tables and SQL queries for collecting scaling events and CPU usage, and presents a Python‑based workflow that aggregates the data, stores daily reports, validates results, and sends automated email summaries.
This article explains how to use Kubernetes native autoscaling components—HPA, VPA, Cluster Autoscaler—and cloud‑native extensions such as Alibaba Cloud's Virtual Node, Elastic Container Instance, Elastic Workload, and the open‑source OpenKruise to build a cost‑effective, highly elastic architecture on ACK clusters.
Kubernetes 1.23 GA adds over 45 enhancements—including dual‑stack networking, CronJobs, new ephemeral volume types, an updated HPA API, several deprecated APIs, beta‑graduated features, and new alpha capabilities—each described with configuration details and example manifests for immediate production use.
This article explains the principles behind Knative Autoscaler, compares Knative Pod Autoscaler (KPA) with Kubernetes Horizontal Pod Autoscaler (HPA), and provides step‑by‑step configuration and demo instructions for achieving true serverless scaling on Kubernetes.
This article reviews the current state of Kubernetes horizontal and vertical autoscaling, compares HPA, VPA, and KNative KPA, discusses their limitations, and proposes short‑ and long‑term ideas for a more dynamic, low‑ops scheduling system.
This article explains how Kubernetes' built‑in autoscaling mechanisms—Horizontal Pod Autoscaler, Vertical Pod Autoscaler, and Cluster Autoscaler—work, when to use each, and best‑practice tips to reduce cloud costs while maintaining application performance.
This article explains Knative’s traffic‑driven autoscaling and gray‑release capabilities, detailing the request flow architecture, the roles of Service, Configuration, Route and Revision, and walks through built‑in scaling strategies such as KPA, HPA, scheduled‑HPA, event‑gateway and custom plugins, with practical examples.
This guide walks you through configuring Kubernetes Horizontal Pod Autoscaler using both autoscaling/v1 (CPU‑only) and autoscaling/v2beta1 (custom metrics), covering template creation, deployment, Metrics Server migration, custom metrics adapter setup, load testing, and verification of scaling behavior.
This article explains the core principles of Kubernetes Horizontal Pod Autoscaler, walks through a concrete scaling example, discusses noise handling, cooldown periods, boundary calculations, and traces the evolution of HPA across API versions with practical YAML snippets.
The article examines the limitations of traditional threshold‑based autoscaling in Kubernetes, explains three core challenges—percentage fragmentation, capacity‑planning pitfalls, and resource‑utilization dilemmas—then expands the autoscaling concept across four workload types and outlines the cloud‑native components that address them.
