Configurar a escala automática horizontal de pods

Esta página mostra como dimensionar as suas implementações no Google Kubernetes Engine (GKE) ajustando automaticamente os seus recursos através de métricas como a atribuição de recursos, o tráfego do equilibrador de carga, as métricas personalizadas ou várias métricas em simultâneo. Esta página também fornece instruções passo a passo para configurar um perfil do Horizontal Pod Autoscaler (HPA), incluindo como ver, eliminar, limpar e resolver problemas do seu objeto HPA. Uma implementação é um objeto da API Kubernetes que lhe permite executar várias réplicas de pods distribuídas entre os nós num cluster.

Esta página destina-se a operadores e programadores que gerem o escalamento de aplicações no GKE e querem compreender como otimizar dinamicamente o desempenho e manter a eficiência de custos através do escalamento automático de pods horizontal. Para saber mais sobre as funções comuns e as tarefas de exemplo referenciadas no conteúdo, consulte o artigo Funções e tarefas comuns do utilizador do GKE. Google Cloud

Antes de começar

Antes de começar, certifique-se de que realizou as seguintes tarefas:

  • Ative a API Google Kubernetes Engine.
    • Ative a API Google Kubernetes Engine
  • Se quiser usar a CLI gcloud para esta tarefa, instale-a e, em seguida, inicialize-a. Se instalou anteriormente a CLI gcloud, execute o comando gcloud components update para obter a versão mais recente. As versões anteriores da CLI gcloud podem não suportar a execução dos comandos neste documento.

Versões da API para objetos HorizontalPodAutoscaler

Quando usa a Google Cloud consolaHorizontalPodAutoscaler, os objetos são criados através da API autoscaling/v2.

Quando usa kubectl para criar ou ver informações sobre um Horizontal Pod Autoscaler, pode especificar a API autoscaling/v1 ou a API autoscaling/v2.

  • apiVersion: autoscaling/v1 é a predefinição e permite o ajuste automático da escala com base apenas na utilização da CPU. Para criar uma escala automática com base noutras métricas, recomenda-se a utilização de apiVersion: autoscaling/v2. O exemplo em Crie a implementação de exemplo usa apiVersion: autoscaling/v1.

  • Recomendamos que use apiVersion: autoscaling/v2 para criar novos objetos HorizontalPodAutoscaler. Permite o dimensionamento automático com base em várias métricas, incluindo métricas personalizadas ou externas. Todos os outros exemplos nesta página usam apiVersion: autoscaling/v2.

Para verificar que versões da API são suportadas, use o comando kubectl api-versions.

Pode especificar que API usar quando visualizar detalhes sobre um redimensionador automático horizontal de pods que usa apiVersion: autoscaling/v2.

Crie a implementação de exemplo

Antes de poder criar um Horizontal Pod Autoscaler, tem de criar a carga de trabalho que monitoriza. Os exemplos nesta página aplicam diferentes configurações do Horizontal Pod Autoscaler à seguinte nginx implementação. Exemplos separados mostram um redimensionador automático horizontal de pods com base na utilização de recursos, com base numa métrica personalizada ou externa e com base em várias métricas.

Guarde o seguinte num ficheiro com o nome 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 manifesto especifica um valor para pedidos de CPU. Se quiser criar uma escala automática com base na utilização de um recurso como percentagem, tem de especificar pedidos para esse recurso. Se não especificar pedidos, pode criar uma escala automática apenas com base no valor absoluto da utilização do recurso, como milliCPUs para utilização da CPU.

Para criar a implementação, aplique o manifesto nginx.yaml:

kubectl apply -f nginx.yaml

A implementação tem spec.replicas definido como 3, pelo que são implementados três pods. Pode verificar isto com o comando kubectl get deployment nginx.

Cada um dos exemplos nesta página aplica um redimensionador automático horizontal de pods diferente a uma implementação do nginx de exemplo.

Escala automática com base na utilização de recursos

Este exemplo cria um objeto HorizontalPodAutoscaler para ajustar automaticamente a escala da implementação nginx quando a utilização da CPU ultrapassa os 50% e garante que existe sempre um mínimo de 1 réplica e um máximo de 10 réplicas.

Pode criar um Horizontal Pod Autoscaler que segmente a CPU através da Google Cloud consola, do comandokubectl apply ou, apenas para a CPU média, do comando kubectl autoscale.

Consola

  1. Aceda à página Workloads na Google Cloud consola.

    Aceda a Cargas de trabalho

  2. Clique no nome da nginx implementação.

  3. Clique em Ações > Ajuste automático.

  4. Especifique os seguintes valores:

    • Número mínimo de réplicas: 1
    • Número máximo de réplicas: 10
    • Métrica de escala automática: CPU
    • Alvo: 50
    • Unidade: %

  5. Clique em Concluído.

  6. Clique em Ajuste automático da escala.

kubectl apply

Guarde o seguinte manifesto YAML como um ficheiro com o nome nginx-hpa.yaml:

apiVersion: autoscaling/v1
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
  # The target average CPU utilization percentage across all Pods.
  targetCPUUtilizationPercentage: 50

Para criar o HPA, aplique o manifesto através do seguinte comando:

kubectl apply -f nginx-hpa.yaml

kubectl autoscale

Para criar um objeto HorizontalPodAutoscaler que apenas segmente a utilização média da CPU, pode usar o comando kubectl autoscale:

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

Para obter uma lista de redimensionadores automáticos horizontais de pods no cluster, use o seguinte comando:

kubectl get hpa

O resultado é semelhante ao seguinte:

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

Para obter detalhes sobre o redimensionador automático horizontal de pods, pode usar a Google Cloud consola ou o comando kubectl.

Consola

  1. Aceda à página Workloads na Google Cloud consola.

    Aceda a Cargas de trabalho

  2. Clique no nome da nginx implementação.

  3. Veja a configuração da escala automática horizontal de pods na secção Escala automática.

  4. Veja mais detalhes sobre eventos de dimensionamento automático no separador Eventos.

kubectl get

Para obter detalhes sobre o redimensionador automático horizontal de pods, pode usar kubectl get hpa com a flag -o yaml. O campo status contém informações sobre o número atual de réplicas e quaisquer eventos de escalabilidade automática recentes.

kubectl get hpa nginx -o yaml

O resultado é semelhante ao seguinte:

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

Antes de seguir os restantes exemplos nesta página, elimine o HPA:

kubectl delete hpa nginx

Quando elimina um Horizontal Pod Autoscaler, o número de réplicas da implementação permanece o mesmo. Uma implementação não reverte automaticamente para o estado anterior à aplicação do redimensionador automático horizontal de pods.

Pode saber mais sobre como eliminar um Horizontal Pod Autoscaler.

Escala automática com base no tráfego do balanceador de carga

A escala automática baseada no tráfego é uma capacidade do GKE que integra sinais de utilização do tráfego de equilibradores de carga para criar uma escala automática de pods.

Usar o tráfego como um sinal de dimensionamento automático pode ser útil, uma vez que o tráfego é um indicador principal da carga complementar à CPU e à memória. A integração incorporada com o GKE garante que a configuração é fácil e que o dimensionamento automático reage rapidamente aos picos de tráfego para satisfazer a procura.

O dimensionamento automático baseado no tráfego é ativado pelo controlador de gateway e pelas respetivas capacidades de gestão de tráfego global. Para saber mais, consulte o artigo Ajuste de escala automático com base no tráfego.

O dimensionamento automático com base no tráfego do equilibrador de carga só está disponível para cargas de trabalho de gateway.

Requisitos

A criação de uma escala automática com base no tráfego tem os seguintes requisitos:

  • Suportado nas versões 1.31 e posteriores do GKE.
  • A API Gateway está ativada no seu cluster do GKE.
  • Suportado para tráfego que passa por equilibradores de carga implementados através da API Gateway e da gke-l7-global-external-managed, gke-l7-regional-external-managed, gke-l7-rilb ou gke-l7-gxlb GatewayClass.

Limitações

O ajuste de escala automático com base no tráfego tem as seguintes limitações:

  • Não suportado pelas GatewayClasses de vários clusters (gke-l7-global-external-managed-mc, gke-l7-regional-external-managed-mc, gke-l7-rilb-mc e gke-l7-gxlb-mc).
  • Não é suportado para tráfego que usa serviços do tipo LoadBalancer.
  • Tem de existir uma relação clara e isolada entre os componentes envolvidos no dimensionamento automático baseado no tráfego. Um redimensionador automático horizontal de pods tem de ser dedicado ao redimensionamento de uma única implementação (ou qualquer recurso redimensionável) exposta por um único serviço.
  • Depois de configurar a capacidade do seu serviço através do campo maxRatePerEndpoint, aguarde tempo suficiente (normalmente, um minuto, mas potencialmente até 15 minutos em clusters grandes) para que o balanceador de carga seja atualizado com esta alteração antes de configurar o Horizontal Pod Autoscaler com métricas baseadas no tráfego. Isto garante que o seu serviço não vai ter temporariamente uma situação em que o cluster tenta usar a escala automática com base em métricas emitidas por um equilibrador de carga que ainda está a ser configurado.
  • Se a escalabilidade automática baseada no tráfego for usada num serviço servido por vários balanceadores de carga (por exemplo, por um Ingress e um Gateway, ou por dois Gateways), o HorizontalPodAutoscaler pode considerar o valor de tráfego mais elevado dos balanceadores de carga individuais para tomar decisões de escalamento, em vez da soma dos valores de tráfego de todos os balanceadores de carga.

Implemente o dimensionamento automático com base no tráfego

O exercício seguinte usa o HorizontalPodAutoscaler para ajustar automaticamente a escala da implementação store-autoscale com base no tráfego que recebe. Um gateway aceita tráfego de entrada da Internet para os pods. O escalador automático compara os sinais de trânsito do gateway com a capacidade de tráfego por pod configurada no recurso de serviço store-autoscale. Ao gerar tráfego para o gateway, influencia o número de pods implementados.

O diagrama seguinte demonstra como funciona o ajuste de escala automático baseado no tráfego:

O HorizontalPodAutoscaler dimensiona uma implementação com base no tráfego.

Para implementar o ajuste de escala automático com base no tráfego, siga estes passos:

  1. Para clusters padrão, confirme que as GatewayClasses estão instaladas no seu cluster. Para clusters do Autopilot, as GatewayClasses são instaladas por predefinição.

    kubectl get gatewayclass

    O resultado confirma que os recursos GatewayClass do GKE estão prontos a usar no seu cluster:

    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

    Se não vir este resultado, ative a API Gateway no seu cluster do GKE.

  2. Implemente a aplicação de exemplo e o balanceador de carga do gateway no seu cluster:

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

    A aplicação de exemplo cria:

    • Uma implementação com 2 réplicas.
    • Um serviço com uma definição GCPBackendPolicy associada maxRatePerEndpoint definida como 10. Para saber mais sobre as capacidades do Gateway, consulte o artigo Capacidades da GatewayClass.
    • Um gateway externo para aceder à aplicação na Internet. Para saber como usar os equilibradores de carga de gateway, consulte o artigo Implementar gateways.
    • Uma HTTPRoute que corresponde a todo o tráfego e o envia para o serviço store-autoscale.

    A capacidade de serviço é um elemento crítico quando usa o ajuste de escala automático baseado no tráfego porque determina a quantidade de tráfego por pod que aciona um evento de ajuste de escala automático. É configurado através de um campo maxRatePerEndpoint num GCPBackendPolicy associado ao serviço, que define o tráfego máximo que um serviço deve receber em pedidos por segundo, por pod. A capacidade do serviço é específica da sua aplicação.

    Para mais informações, consulte o artigo Determinar a capacidade do seu serviço.

  3. Guarde o seguinte manifesto 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

    Este manifesto descreve um HorizontalPodAutoscaler com as seguintes propriedades:

    • minReplicas e maxReplicas: define o número mínimo e máximo de réplicas para esta implementação. Nesta configuração, o número de pods pode ser dimensionado de 1 a 10 réplicas.
    • describedObject.name: store-autoscale: a referência ao serviço store-autoscale que define a capacidade de tráfego.
    • scaleTargetRef.name: store-autoscale: a referência à implementação store-autoscaleque define o recurso que é dimensionado pelo redimensionador automático horizontal de pods.
    • averageValue: 70: valor médio alvo de utilização da capacidade de 70%. Isto dá à escala automática horizontal de pods uma margem de crescimento para que os pods em execução possam processar o excesso de tráfego enquanto são criados novos pods.

O redimensionador automático horizontal de pods resulta no seguinte comportamento de tráfego:

  • O número de agrupamentos é ajustado entre 1 e 10 réplicas para atingir 70% da taxa máxima por ponto final. Isto resulta em 7 RPS por pod quando maxRatePerEndpoint=10.
  • Com mais de 7 RPS por agrupamento, os agrupamentos são dimensionados até atingirem o máximo de 10 réplicas ou até o tráfego médio ser de 7 RPS por agrupamento.
  • Se o tráfego for reduzido, os pods são reduzidos a uma taxa razoável através do algoritmo de escala automática horizontal de pods.

Também pode implementar um gerador de tráfego para validar o comportamento do ajuste de escala automático baseado no tráfego.

A 30 RPS, a implementação é dimensionada para 5 réplicas, de modo que cada réplica receba, idealmente, 6 RPS de tráfego, o que corresponderia a uma utilização de 60% por pod. Isto está abaixo da utilização alvo de 70% e, por isso, os pods são dimensionados adequadamente. Consoante as flutuações de tráfego, o número de réplicas com escalamento automático também pode flutuar. Para uma descrição mais detalhada de como o número de réplicas é calculado, consulte o comportamento do ajuste de escala automático.

Ajuste automático com base numa métrica personalizada ou externa

Para criar redimensionadores automáticos de pods horizontais para métricas personalizadas e métricas externas, consulte o artigo Otimize a escala automática de pods com base em métricas.

Escala automática com base em várias métricas

Este exemplo cria um redimensionador automático horizontal de pods que é redimensionado automaticamente com base na utilização da CPU e numa métrica personalizada denominada packets_per_second.

Se seguiu o exemplo anterior e ainda tem um Horizontal Pod Autoscaler com o nome nginx, elimine-o antes de seguir este exemplo.

Este exemplo requer apiVersion: autoscaling/v2. Para mais informações acerca das APIs disponíveis, consulte Versões da API para objetos HorizontalPodAutoscaler.

Guarde este manifesto YAML como um ficheiro com o nome 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

Aplique o manifesto YAML:

kubectl apply -f nginx-multiple.yaml

Quando criado, o Horizontal Pod Autoscaler monitoriza a implementação para a utilização média da CPU, a utilização média da memória e (se tiver retirado o comentário) a métrica personalizada.nginxpackets_per_second O redimensionador automático horizontal de pods redimensiona automaticamente a implementação com base na métrica cujo valor criaria o evento de redimensionamento automático maior.

Configure o perfil HPA de desempenho

O perfil de HPA de desempenho melhora o tempo de reação do Horizontal Pod Autoscaler, o que lhe permite recalcular rapidamente um grande número de objetos HorizontalPodAutoscaler (até 1000 objetos nas versões secundárias 1.31-1.32 e 5000 objetos na versão 1.33 ou posterior).

Este perfil é ativado automaticamente em clusters do Autopilot elegíveis com um plano de controlo que executa a versão 1.32 ou posterior do GKE. Para clusters padrão, o perfil é ativado automaticamente em clusters elegíveis com um plano de controlo que executa a versão 1.33 ou posterior do GKE.

Um cluster padrão está isento da ativação automática do perfil de HPA de desempenho se cumprir todas as seguintes condições:

  • O cluster está a ser atualizado de uma versão anterior para a versão 1.33 ou posterior.
  • O cluster tem, pelo menos, um conjunto de nós com qualquer um dos seguintes tipos de máquinas: e2-micro, e2-custom-micro, g1-small e f1-micro.
  • A administração de contas automática de nós não está ativada.

Também pode ativar o perfil HPA de desempenho em clusters existentes se estes cumprirem os requisitos.

Requisitos

Para ativar o perfil de HPA de desempenho, verifique se os clusters do Autopilot e padrão cumprem os seguintes requisitos:

Ative o perfil HPA de desempenho

Para ativar o perfil HPA de desempenho no cluster, use o seguinte comando:

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

Substituição:

  • CLUSTER_NAME: o nome do cluster.
  • LOCATION: zona ou região de computação (por exemplo, us-central1-a ou us-central1) para o cluster.
  • PROJECT_ID: o ID do seu Google Cloud projeto.

Desative o perfil HPA de desempenho

Para desativar o perfil de HPA de desempenho num cluster, use o seguinte comando:

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

Substituição:

  • CLUSTER_NAME: o nome do cluster.
  • LOCATION: zona ou região de computação (por exemplo, us-central1-a ou us-central1) para o cluster.
  • PROJECT_ID: o ID do seu Google Cloud projeto.

Ver detalhes acerca de um redimensionador automático horizontal de pods

Para ver a configuração e as estatísticas de um Horizontal Pod Autoscaler, use o seguinte comando:

kubectl describe hpa HPA_NAME

Substitua HPA_NAME pelo nome do seu objeto HorizontalPodAutoscaler.

Se o Horizontal Pod Autoscaler usar apiVersion: autoscaling/v2 e se basear em várias métricas, o comando kubectl describe hpa só mostra a métrica de CPU. Para ver todas as métricas, use o seguinte comando:

kubectl describe hpa.v2.autoscaling HPA_NAME

Substitua HPA_NAME pelo nome do seu objeto HorizontalPodAutoscaler.

O estado atual de cada escala automática horizontal de pods é apresentado no campo Conditions e os eventos de escala automática são apresentados no campo Events.

O resultado é semelhante ao seguinte:

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>

Eliminar um redimensionador automático horizontal de pods

Pode eliminar um Horizontal Pod Autoscaler através da Google Cloud consola ou do comando kubectl delete.

Consola

Para eliminar o nginx redimensionador automático horizontal de pods:

  1. Aceda à página Workloads na Google Cloud consola.

    Aceda a Cargas de trabalho

  2. Clique no nome da nginx implementação.

  3. Clique em Ações > Ajuste automático.

  4. Clique em Eliminar.

kubectl delete

Para eliminar o nginx Horizontal Pod Autoscaler, use o seguinte comando:

kubectl delete hpa nginx

Quando elimina um Horizontal Pod Autoscaler, a implementação (ou outro objeto de implementação) permanece na sua escala existente e não reverte para o número de réplicas no manifesto original da implementação. Para dimensionar manualmente a implementação de volta para três pods, pode usar o comando kubectl scale:

kubectl scale deployment nginx --replicas=3

Limpar

  1. Elimine o redimensionador automático horizontal de pods, se ainda não o tiver feito:

    kubectl delete hpa nginx

  2. Elimine a nginx implementação:

    kubectl delete deployment nginx

  3. Opcionalmente, elimine o cluster.

Resolução de problemas

Para obter aconselhamento sobre a resolução de problemas, consulte o artigo Resolva problemas de escalabilidade automática de pods horizontal.

O que se segue?