kubernetes / kubernetes

What is Horizontal Pod Autoscaling (HPA)?

Horizontal Pod Autoscaling (HPA) is a Kubernetes feature that automatically scales the number of pods in a deployment or replica set based on resource utilization or other metrics. It allows you to adjust the number of pods running your application in response to changes in demand, ensuring optimal resource usage and performance.

Why is Horizontal Pod Autoscaling (HPA) important?

HPA is essential for:

  • Cost Optimization: By automatically scaling up and down based on demand, you can minimize resource usage and reduce cloud costs.
  • Performance Optimization: Ensuring that your application has the necessary resources to perform well, avoiding performance degradation during peak load periods.
  • High Availability: HPA ensures that sufficient pods are running to handle traffic spikes and maintain high availability.
  • Simplified Management: Automating scaling processes frees you from manually managing the number of pods, allowing you to focus on other aspects of your application.

How HPA Works

HPA works by continuously monitoring the specified metrics and comparing them to the target values you define. When the metrics exceed the target, HPA automatically scales up the number of pods. When the metrics fall below the target, HPA scales down the number of pods.

HPA Metrics

HPA supports various metrics for scaling:

  • CPU Utilization: The most common metric, it measures the average CPU usage of the pods in a deployment.
  • Memory Utilization: Measures the average memory usage of the pods in a deployment.
  • Custom Metrics: You can define your own custom metrics, allowing HPA to scale based on specific application-level metrics.

Using HPA

To use HPA, you need to create an HPA object in your Kubernetes cluster. The HPA object specifies the following:

  • Target: The deployment or replica set that you want to scale.
  • Metrics: The metrics that you want to use for scaling.
  • Target Values: The desired values for the specified metrics.
  • Min/Max Replicas: The minimum and maximum number of pods that HPA can scale to.

HPA Example

Here is an example of a basic HPA configuration using CPU utilization:

apiVersion: autoscaling/v2beta2
          kind: HorizontalPodAutoscaler
          metadata:
            name: my-app-hpa
          spec:
            scaleTargetRef:
              apiVersion: apps/v1
              kind: Deployment
              name: my-app
            minReplicas: 2
            maxReplicas: 6
            metrics:
            - type: Resource
              resource:
                name: cpu
                targetAverageUtilization: 80

This HPA configuration scales the my-app deployment based on CPU utilization. It maintains a minimum of 2 pods and a maximum of 6 pods. The target average CPU utilization is set to 80%. When the average CPU utilization exceeds 80%, HPA will automatically scale up the number of pods. When the average CPU utilization falls below 80%, HPA will scale down the number of pods.

Learn More

Contributing to HPA

You are welcome to contribute to the HPA project by providing feedback, reporting issues, or submitting pull requests. Please refer to the Kubernetes contributor guidelines for more information: https://github.com/kubernetes/community/blob/master/CONTRIBUTING.md

Top-Level Directory Explanations

api - This directory contains the Kubernetes API definition and implementation. It includes subdirectories like api-rules, discovery, and openapi-spec that define the API schema, discovery, and OpenAPI specification.

cluster - This directory contains the configuration and management scripts for Kubernetes clusters. It includes subdirectories like addons, gce, images, kubemark, log-dump, pre-existing, skeleton, and windows. The addons subdirectory contains Kubernetes add-ons, such as cloud controllers, network plugins, and storage plugins.

cmd - This directory contains the command-line interface (CLI) tools for Kubernetes, such as clicheck, cloud-controller-manager, dependencycheck, dependencyverifier, and kubectl.

hack - This directory contains development scripts and tools for the Kubernetes project. It includes subdirectories like boilerplate, conformance, e2e-internal, gen-swagger-doc, jenkins, lib, make-rules, testdata, and tools.

pkg - This directory contains the Go packages for Kubernetes components. It includes subdirectories like api, apis, auth, capabilities, client, cluster, controller, controlplane, credentialprovider, features, fieldpath, generated, kubeapiserver, kubectl, kubemark, printers, probe, proxy, quota, registry, routes, scheduler, security, serviceaccount, util, volume, and windows. These packages define and implement various Kubernetes features and components.

test - This directory contains the test scripts and configurations for Kubernetes components. It includes subdirectories like cmd, conformance, e2e, fixtures, fuzz, images, kubemark, e2e_kubeadm, e2e_node, and utils.