Configura el Ajuste de escala automático horizontal de Pods

Puedes escalar automáticamente las réplicas de cargas de trabajo en Google Kubernetes Engine (GKE) en función del uso de CPU o memoria, el tráfico del balanceador de cargas o las métricas personalizadas y externas configurando el escalado automático horizontal de Pods. En este documento, se muestra cómo crear y administrar HorizontalPodAutoscalers para cargas de trabajo que ejecutan Pods replicados, como Deployments, para ayudar a mantener el rendimiento de las aplicaciones y reducir los costos de procesamiento. Si administras cientos de HorizontalPodAutoscalers, también puedes configurar el perfil de HPA de rendimiento a nivel del clúster.

Para obtener más información sobre cómo funcionan los cálculos de escalamiento, consulta Escalamiento automático horizontal de Pods.

Este documento está dirigido a desarrolladores y operadores que administran el escalamiento de aplicaciones en GKE. Para obtener más información sobre los roles comunes y las tareas de ejemplo a las que hacemos referencia en el contenido de Google Cloud , consulta Roles y tareas comunes del usuario de GKE.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

  • Habilita la API de Google Kubernetes Engine.
  • Habilitar la API de Google Kubernetes Engine
  • Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa la gcloud CLI. Si ya instalaste gcloud CLI, ejecuta el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos de este documento.

Versiones de la API para HorizontalPodAutoscalers

Cuando usas la consola de Google Cloud , los HorizontalPodAutoscalers se crean con la API de autoscaling/v2. La API de autoscaling/v1 aún es compatible, pero ya no se recomienda y no admite funciones como el escalado desde y hacia cero con HPA.

Crea la implementación de ejemplo

Antes de que puedas crear un HorizontalPodAutoscaler, debes crear la carga de trabajo que supervisa. Un Deployment es un objeto de la API de Kubernetes que te permite ejecutar varias réplicas de Pods que se distribuyen entre los nodos de un clúster. En los ejemplos de este documento, se aplican diferentes configuraciones de HPA al siguiente Deployment de nginx. En ejemplos separados, se muestra un HPA basado en el uso de recursos, en una métrica personalizada o externa y en varias métricas.

Guarda lo siguiente en un archivo llamado nginx.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
  namespace: default
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.7.9
        ports:
        - containerPort: 80
        resources:
          # You must specify requests for CPU to autoscale
          # based on CPU utilization
          requests:
            cpu: "250m"

Este manifiesto especifica un valor para las solicitudes de CPU. Si deseas ajustar la escala automática según el uso de un recurso como un porcentaje, debes especificar solicitudes para ese recurso. Si no especificas solicitudes, puedes ajustar la escala automática solo en función del valor absoluto del uso del recurso, como milicorazones para el uso de CPU.

Para crear el Deployment, aplica el manifiesto nginx.yaml:

kubectl apply -f nginx.yaml

El Deployment tiene spec.replicas establecido en 3, por lo que se implementan tres Pods. Puedes verificar esto con el comando kubectl get deployment nginx.

En cada uno de los ejemplos de esta página, se aplica un objeto de HPA diferente a un ejemplo de Deployment de nginx.

Ajuste de escala automático según el uso de recursos

En este ejemplo, se crea un objeto de HPA para realizar un ajuste de escala automático de la implementación nginx cuando el uso de CPU supera el 50% y ayuda a garantizar que siempre haya un mínimo de 1 réplica y un máximo de 10 réplicas.

Puedes crear un HPA orientado a la CPU con la consola de Google Cloud , el comando kubectl apply o el comando kubectl autoscale solo para la CPU promedio.

Console

  1. Accede a la página Cargas de trabajo de la consola de Google Cloud .

    Ir a Cargas de trabajo

  2. Haz clic en el nombre del Deployment nginx.

  3. Haz clic en Acciones > Editar el ajuste de escala automático.

  4. En la sección Ajuste de escala automático horizontal de Pods, haz clic en Seleccionar y configurar.

  5. Especifica los siguientes valores:

    • Cantidad mínima de réplicas: 1
    • Cantidad máxima de réplicas: 10
    • Métrica de ajuste de escala automático: CPU
    • Objetivo: 50
    • Unidad: CPU
  6. Haz clic en Enviar.

kubectl apply

Guarda el siguiente manifiesto YAML como un archivo llamado nginx-hpa.yaml.

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: nginx
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nginx
  # Set the minimum and maximum number of replicas the Deployment can scale to.
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      # The target average CPU utilization percentage across all Pods.
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50

Si creas un manifiesto para que coincida con detalles específicos de tu propio proyecto, asegúrate de no incluir datos sensibles en los campos del escalador automático horizontal de Pods.

Para crear el HPA, aplica el manifiesto con el siguiente comando:

kubectl apply -f nginx-hpa.yaml

kubectl autoscale

Para crear un objeto HPA que solo apunte al uso promedio de CPU, puedes usar el comando kubectl autoscale.

kubectl autoscale deployment nginx --cpu-percent=50 --min=1 --max=10

Para obtener una lista de los HPA en el clúster, usa el siguiente comando:

kubectl get hpa

El resultado es similar a lo siguiente:

NAME    REFERENCE          TARGETS   MINPODS   MAXPODS   REPLICAS   AGE
nginx   Deployment/nginx   0%/50%    1         10        3          61s

Para obtener detalles sobre el HPA, puedes usar la consola de Google Cloud o el comando kubectl.

Console

  1. Accede a la página Cargas de trabajo de la consola de Google Cloud .

    Ir a Cargas de trabajo

  2. Haz clic en el nombre del Deployment nginx.

  3. Haz clic en la pestaña Escalamiento.

kubectl get

Para obtener detalles sobre el HPA, puedes usar kubectl get hpa con la marca -o yaml. El campo status contiene información sobre la cantidad actual de réplicas y los eventos de ajuste de escala automático recientes.

kubectl get hpa nginx -o yaml

El resultado es similar a lo siguiente:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  annotations:
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"autoscaling/v2","kind":"HorizontalPodAutoscaler","metadata":{"annotations":{},"name":"nginx","namespace":"default"},"spec":{"maxReplicas":10,"metrics":[{"resource":{"name":"cpu","target":{"averageUtilization":50,"type":"Utilization"}},"type":"Resource"}],"minReplicas":1,"scaleTargetRef":{"apiVersion":"apps/v1","kind":"Deployment","name":"nginx"}}}
  creationTimestamp: "2025-10-30T19:42:43Z"
  name: nginx
  namespace: default
  resourceVersion: "220050"
  selfLink: /apis/autoscaling/v2/namespaces/default/horizontalpodautoscalers/nginx
  uid: 70d1067d-fb4d-11e9-8b2a-42010a8e013f
spec:
  maxReplicas: 10
  minReplicas: 1
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nginx
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50
status:
  conditions:
  - lastTransitionTime: "2025-10-30T19:42:59Z"
    message: recent recommendations were higher than current one, applying the highest recent recommendation
    reason: ScaleDownStabilized
    status: "True"
    type: AbleToScale
  - lastTransitionTime: "2025-10-30T19:42:59Z"
    message: the HPA was able to successfully calculate a replica count from cpu resource utilization (percentage of request)
    reason: ValidMetricFound
    status: "True"
    type: ScalingActive
  - lastTransitionTime: "2025-10-30T19:42:59Z"
    message: the desired count is within the acceptable range
    reason: DesiredWithinRange
    status: "False"
    type: ScalingLimited
  currentMetrics:
  - type: Resource
    resource:
      name: cpu
      current:
        averageUtilization: 0
        averageValue: "0"
  currentReplicas: 3
  desiredReplicas: 3

Si creas un manifiesto para que coincida con detalles específicos de tu propio proyecto, asegúrate de no incluir datos sensibles en los campos del escalador automático horizontal de Pods.

Antes de seguir los ejemplos restantes en esta página, borra el HPA:

kubectl delete hpa nginx

Cuando borras un objeto de HPA, la cantidad de réplicas de la Deployment sigue igual. Un Deployment no vuelve automáticamente a su estado anterior a la aplicación del HPA.

Puedes obtener más información sobre cómo borrar un HPA.

Ajuste de escala automático en función de una métrica personalizada o externa

Cualquier métrica que emita tu carga de trabajo o que puedas consultar desde una fuente externa se puede usar para el ajuste de escala automático. GKE tiene compatibilidad integrada con el ajuste de escala automático basado en métricas personalizadas y métricas externas en muchas situaciones, y Kubernetes admite adaptadores de métricas adicionales, como KEDA y el adaptador de Prometheus.

Ajuste de escala automático basado en el tráfico del balanceador de cargas

El ajuste de escala automático basado en el tráfico es una función de GKE que integra señales de uso de tráfico de los balanceadores de cargas para ajustar automáticamente la escala de los Pods.

El uso del tráfico como una señal para el ajuste de escala automático puede ser útil porque es un indicador principal de carga que se complementa con la CPU y la memoria. La integración incorporada en GKE ayuda a garantizar que la configuración sea sencilla y que el ajuste de escala automático reaccione rápidamente a los aumentos repentinos de tráfico para satisfacer la demanda.

El controlador de Gateway y sus funciones de administración del tráfico global habilitan el ajuste de escala automático basado en el tráfico. Para obtener más información, consulta Ajuste de escala automático basado en el tráfico.

El ajuste de escala automático basado en el tráfico del balanceador de cargas solo está disponible para las cargas de trabajo de Gateway.

Requisitos

El ajuste de escala automático basado en el tráfico tiene los siguientes requisitos:

  • Es compatible con las versiones 1.31 y posteriores de GKE.
  • La API de Gateway debe estar habilitada en tu proyecto.
  • Compatible con el tráfico que pasa por los balanceadores de cargas implementados mediante la API de Gateway y la GatewayClass gke-l7-global-external-managed, gke-l7-regional-external-managed, gke-l7-rilb o gke-l7-gxlb.

Limitaciones

El ajuste de escala automático basado en el tráfico tiene las siguientes limitaciones:

  • No es compatible con las GatewayClasses de varios clústeres (gke-l7-global-external-managed-mc, gke-l7-regional-external-managed-mc, gke-l7-rilb-mc y gke-l7-gxlb-mc).
  • No es compatible para el tráfico con Services de tipo LoadBalancer.
  • Debe haber una relación clara y aislada entre los componentes involucrados en el ajuste de escala automático basado en el tráfico. Un objeto de HPA debe dedicarse a escalar un solo Deployment (o cualquier recurso escalable) expuesto por un solo Service.
  • Después de configurar la capacidad de tu Service con el campo maxRatePerEndpoint, espera el tiempo suficiente (por lo general, un minuto, pero puede tardar hasta 15 minutos en clústeres grandes) para que el balanceador de cargas se actualice con este cambio antes de configurar el HPA con métricas basadas en el tráfico. Este enfoque ayuda a garantizar que tu servicio no experimente de forma temporal una situación en la que el clúster intente realizar un ajuste de escala automático según las métricas que emite un balanceador de cargas que aún se está configurando.
  • Si se usa el ajuste de escala automático basado en el tráfico en un Service que se entrega a través de varios balanceadores de cargas (por ejemplo, un Ingress y una Gateway, o dos Gateways), el HPA podría considerar el valor de tráfico más alto de los balanceadores de cargas individuales para tomar decisiones de escalado, en lugar de la suma de los valores de tráfico de todos los balanceadores de cargas.

Implementa el ajuste de escala automático basado en el tráfico

En el siguiente ejercicio, se usa el HPA para ajustar automáticamente la escala del objeto Deployment store-autoscale en función del tráfico que recibe. Una Gateway acepta el tráfico de entrada de Internet para los Pods. El escalador automático compara las señales de tráfico de la Gateway con la capacidad de tráfico por Pod configurada en el recurso de Service store-autoscale. Cuando generas tráfico a la Gateway, influyes en la cantidad de Pods implementados.

En el siguiente diagrama, se muestra cómo funciona el ajuste de escala automático basado en el tráfico:

HorizontalPodAutoscaler que escala un Deployment según el tráfico.

Para implementar el ajuste de escala automático basado en el tráfico, sigue estos pasos:

  1. Para los clústeres estándar, confirma que las GatewayClasses estén instaladas en tu clúster. En los clústeres de Autopilot, las GatewayClasses se instalan de forma predeterminada.

    kubectl get gatewayclass
    

    El resultado confirma que los recursos GatewayClass de GKE están listos para usarse en tu clúster:

    NAME                               CONTROLLER                  ACCEPTED   AGE
    gke-l7-global-external-managed     networking.gke.io/gateway   True       16h
    gke-l7-regional-external-managed   networking.gke.io/gateway   True       16h
    gke-l7-gxlb                        networking.gke.io/gateway   True       16h
    gke-l7-rilb                        networking.gke.io/gateway   True       16h
    

    Si no ves este resultado, habilita la API de Gateway en el clúster de GKE.

  2. Implementa la aplicación de muestra y el balanceador de cargas de Gateway en tu clúster:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-networking-recipes/master/gateway/docs/store-autoscale.yaml
    

    La aplicación de muestra crea lo siguiente:

    • Una Deployment con 2 réplicas.
    • Un Service con un parámetro de configuración GCPBackendPolicy asociado maxRatePerEndpoint establecido en 10. Para obtener más información sobre las capacidades de la puerta de enlace, consulta Capacidades de GatewayClass.
    • Una Gateway externa para acceder a la aplicación en Internet. Para obtener más información sobre cómo usar los balanceadores de cargas de Gateway, consulta Implementa puertas de enlace.
    • Una HTTPRoute que hace coincidir todo el tráfico y lo envía al Service store-autoscale.

    La capacidad del Service es un elemento fundamental cuando se usa el ajuste de escala automático basado en el tráfico, ya que determina la cantidad de tráfico por Pod que activa un evento de ajuste de escala automático. Se configura con un campo maxRatePerEndpoint en una GCPBackendPolicy asociada al Service, que define el tráfico máximo que un Service debe recibir en solicitudes por segundo, por Pod. La capacidad del Service es específica de tu aplicación.

    Para obtener más información, consulta Determina la capacidad de tu Service.

  3. Guarda el siguiente manifiesto como hpa.yaml:

    apiVersion: autoscaling/v2
    kind: HorizontalPodAutoscaler
    metadata:
      name: store-autoscale
    spec:
      scaleTargetRef:
        apiVersion: apps/v1
        kind: Deployment
        name: store-autoscale
      # Set the minimum and maximum number of replicas the Deployment can scale to.
      minReplicas: 1
      maxReplicas: 10
      # This section defines that scaling should be based on the fullness of load balancer
      # capacity, using the following configuration.
      metrics:
      - type: Object
        object:
          describedObject:
            kind: Service
            name: store-autoscale
          metric:
            # The name of the custom metric which measures how "full" a backend is
            # relative to its configured capacity.
            name: "autoscaling.googleapis.com|gclb-capacity-fullness"
          target:
            # The target average value for the metric. The autoscaler adjusts the number
            # of replicas to maintain an average capacity fullness of 70% across all Pods.
            averageValue: 70
            type: AverageValue
    

    En este manifiesto, se describe un objeto de HPA con las siguientes propiedades:

    • minReplicas y maxReplicas: Establecen la cantidad mínima y máxima de réplicas para esta Deployment. En esta configuración, la cantidad de Pods puede escalar de 1 a 10 réplicas (o de 0 réplicas si configuras el escalamiento hacia y desde cero con el HPA).
    • describedObject.name: store-autoscale: Es la referencia al Service store-autoscale que define la capacidad de tráfico.
    • scaleTargetRef.name: store-autoscale: Es la referencia al Deployment store-autoscale que define el recurso que escala el HPA.
    • averageValue: 70: Es el valor objetivo promedio del 70% del uso de capacidad. Esto le da al HPA un margen de crecimiento para que los Pods en ejecución puedan procesar el tráfico excesivo mientras se crean Pods nuevos.

    Si creas un manifiesto para que coincida con detalles específicos de tu propio proyecto, asegúrate de no incluir datos sensibles en los campos del escalador automático horizontal de Pods.

El HPA tiene como resultado el siguiente comportamiento de tráfico:

  • La cantidad de Pods se ajusta entre 1 y 10 réplicas para alcanzar el 70% de la tasa máxima por extremo. Esto da como resultado 7 RPS por Pod cuando se configura maxRatePerEndpoint=10.
  • A más de 7 RPS por Pod, los Pods se escalan verticalmente hasta alcanzar su máximo de 10 réplicas o hasta que el tráfico promedio sea de 7 RPS por Pod.
  • Si se reduce el tráfico, los Pods reducen la escala verticalmente a una tasa razonable con el algoritmo del HPA.

También puedes implementar un generador de tráfico para validar el comportamiento del ajuste de escala automático basado en el tráfico.

A 30 RPS, la Deployment se escala a 5 réplicas para que cada réplica reciba, de manera ideal, 6 RPS de tráfico, que sería un 60% de uso por Pod. Esto está por debajo del uso objetivo del 70%, por lo que los Pods se escalan de manera adecuada. Según las fluctuaciones del tráfico, la cantidad de réplicas con ajuste de escala automático también puede fluctuar. Para obtener una descripción más detallada de cómo se calcula la cantidad de réplicas, consulta Comportamiento del ajuste de escala automático.

Ajuste de escala automático en función de varias métricas

En este ejemplo, se crea un objeto de HPA que se escala automáticamente según el uso de CPU y una métrica personalizada llamada packets_per_second.

Si seguiste el ejemplo anterior y aún tienes un objeto HPA llamado nginx, bórralo antes de seguir este ejemplo.

En este ejemplo, se necesita apiVersion: autoscaling/v2. A fin de obtener más información sobre las API disponibles, consulta las versiones de la API para objetos HPA.

Guarda este manifiesto YAML como un archivo llamado nginx-multiple.yaml:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: nginx
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nginx
  minReplicas: 1
  maxReplicas: 10
  metrics: # The metrics to base the autoscaling on.
  - type: Resource
    resource:
      name: cpu # Scale based on CPU utilization.
      target:
        type: Utilization
        averageUtilization: 50
        # The HPA will scale the replicas to try and maintain an average
        # CPU utilization of 50% across all Pods.
  - type: Resource
    resource:
      name: memory # Scale based on memory usage.
      target:
        type: AverageValue
        averageValue: 100Mi
        # The HPA will scale the replicas to try and maintain an average
        # memory usage of 100 Mebibytes (MiB) across all Pods.
  # Uncomment these lines if you create the custom packets_per_second metric and
  # configure your app to export the metric.
  # - type: Pods
  #   pods:
  #     metric:
  #       name: packets_per_second
  #     target:
  #       type: AverageValue
  #       averageValue: 100

Si creas un manifiesto para que coincida con detalles específicos de tu propio proyecto, asegúrate de no incluir datos sensibles en los campos del escalador automático horizontal de Pods.

Aplica el manifiesto YAML:

kubectl apply -f nginx-multiple.yaml

Cuando se crea, el HPA supervisa el Deployment nginx para obtener el uso promedio de CPU, el uso promedio de memoria y (si quitaste el comentario) la métrica packets_per_second personalizada. El HPA ajusta la escala del Deployment de forma automática según la métrica cuyo valor crearía el evento de ajuste de escala automático más grande.

Escala desde y hacia cero

A partir de la versión 1.37 de GKE, puedes configurar el HPA para que reduzca la escala de un Deployment a cero (0) réplicas cuando no haya demanda de carga de trabajo y vuelva a aumentarla con escalado automático cuando aumente la demanda. Cuando se escala verticalmente desde cero, GKE omite las verificaciones de tolerancia de métricas estándar para activar los Pods sin demora.

Para configurar el escalamiento desde y hacia cero con HPA, debes hacer lo siguiente:

  1. Asegúrate de que tu clúster ejecute la versión 1.37 o posterior de GKE.
  2. Configura al menos una métrica personalizada o externa con el recurso AutoscalingMetric.
  3. Establece el par de valor de campo minReplicas: 0 en un manifiesto de HPA que use la API de autoscaling/v2.

Para obtener instrucciones paso a paso, consulta Escala cargas de trabajo de GKE hacia y desde cero con HPA.

Configura el perfil de HPA de rendimiento

El perfil de HPA de rendimiento mejora el tiempo de reacción del escalado automático horizontal de Pods, lo que ayuda a mejorar la capacidad del HPA para controlar una gran cantidad de objetos (hasta 1,000 objetos en las versiones secundarias 1.31-1.32 y 5,000 objetos en la versión 1.33 o posterior).

Este perfil se habilita automáticamente en los clústeres de Autopilot que cumplen con los requisitos y tienen un plano de control que ejecuta GKE 1.32 o una versión posterior. En los clústeres de Standard, el perfil se habilita automáticamente en los clústeres que cumplen con los requisitos y tienen un plano de control que ejecuta la versión 1.33 o posterior de GKE.

Un clúster de Standard está exento de la habilitación automática del perfil de HPA de rendimiento si cumple con todas las condiciones siguientes:

  • El clúster se actualiza de una versión anterior a la versión 1.33 o posterior.
  • El clúster tiene, al menos, un grupo de nodos con cualquiera de los siguientes tipos de máquina: e2-micro, e2-custom-micro, g1-small y f1-micro.
  • El aprovisionamiento automático de nodos no está habilitado.

También puedes habilitar el perfil de HPA de rendimiento en los clústeres existentes si cumplen con los requisitos.

Requisitos

Para habilitar el perfil de HPA de rendimiento, verifica que tus clústeres de Autopilot y Standard cumplan con los siguientes requisitos:

Habilita el perfil de HPA de rendimiento

Para habilitar el perfil de HPA de rendimiento en tu clúster, usa el siguiente comando:

gcloud container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID \
    --hpa-profile=performance

Reemplaza lo siguiente:

  • CLUSTER_NAME: Es el nombre del clúster.
  • LOCATION: Es la zona de procesamiento o región (p.ej., us-central1-a o us-central1) del clúster.
  • PROJECT_ID: Es el ID del proyecto de Google Cloud .

Inhabilita el perfil de HPA de rendimiento

Para inhabilitar el perfil de HPA de rendimiento en un clúster, usa el siguiente comando:

gcloud container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID \
    --hpa-profile=none

Reemplaza lo siguiente:

  • CLUSTER_NAME: Es el nombre del clúster.
  • LOCATION: Es la zona de procesamiento o región (p.ej., us-central1-a o us-central1) del clúster.
  • PROJECT_ID: Es el ID del proyecto de Google Cloud .

Visualiza detalles sobre un HorizontalPodAutoscaler

Para ver la configuración y las estadísticas de un HPA, usa el siguiente comando:

kubectl describe hpa HPA_NAME

Reemplaza HPA_NAME por el nombre de tu objeto de HPA.

El estado actual de cada objeto de HPA se muestra en el campo Conditions, y los eventos de ajuste de escala automático se enumeran en el campo Events.

El resultado es similar a lo siguiente:

Name:                                                  nginx
Namespace:                                             default
Labels:                                                <none>
Annotations:                                           kubectl.kubernetes.io/last-applied-configuration:
                                                         {"apiVersion":"autoscaling/v2","kind":"HorizontalPodAutoscaler","metadata":{"annotations":{},"name":"nginx","namespace":"default"},"s...
CreationTimestamp:                                     Tue, 05 May 2020 20:07:11 +0000
Reference:                                             Deployment/nginx
Metrics:                                               ( current / target )
  resource memory on pods:                             2220032 / 100Mi
  resource cpu on pods  (as a percentage of request):  0% (0) / 50%
Min replicas:                                          1
Max replicas:                                          10
Deployment pods:                                       1 current / 1 desired
Conditions:
  Type            Status  Reason              Message
  ----            ------  ------              -------
  AbleToScale     True    ReadyForNewScale    recommended size matches current size
  ScalingActive   True    ValidMetricFound    the HPA was able to successfully calculate a replica count from memory resource
  ScalingLimited  False   DesiredWithinRange  the desired count is within the acceptable range
Events:                                                <none>

Borra un HorizontalPodAutoscaler

Puedes borrar un objeto de HPA con la consola de Google Cloud o el comando kubectl delete.

Console

Para borrar el objeto de HPA nginx, haz lo siguiente:

  1. Accede a la página Cargas de trabajo de la consola de Google Cloud .

    Ir a Cargas de trabajo

  2. Haz clic en el nombre del Deployment nginx.

  3. Haz clic en Acciones > Ajuste de escala automático.

  4. Haz clic en Borrar.

kubectl delete

Para borrar el objeto de HPA nginx, usa el siguiente comando:

kubectl delete hpa nginx

Cuando borras un objeto de HPA, el Deployment (u otro objeto de implementación) permanece en su escala existente y no vuelve a la cantidad de réplicas en el manifiesto original del Deployment. Para volver a escalar manualmente el Deployment a tres Pods, puedes usar el comando kubectl scale:

kubectl scale deployment nginx --replicas=3

Realiza una limpieza

  1. Borra el objeto HPA, si aún no lo hiciste:

    kubectl delete hpa nginx
    
  2. Borra el Deployment nginx:

    kubectl delete deployment nginx
    
  3. Si lo deseas, borra el clúster.

Soluciona problemas

Para obtener asesoramiento sobre la solución de problemas, consulta Soluciona problemas del escalado automático horizontal de Pods.

¿Qué sigue?