O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Configurar o escalonamento automático horizontal de pods

Este documento descreve como configurar o escalonamento automático horizontal de pods para cargas de trabalho sem estado em execução no cluster. O escalonamento automático horizontal de pods ajusta automaticamente o número de pods em execução (réplicas) de um aplicativo com base na demanda em tempo real, removendo pods quando a carga diminui e adicionando pods quando a carga aumenta. Esse escalonamento é essencial para garantir a disponibilidade do aplicativo, o uso eficiente de recursos e a economia de custos, combinando a capacidade com precisão ao tráfego do usuário sem intervenção manual. À medida que os requisitos da carga de trabalho do contêiner evoluem, o escalonamento automático de pods elimina a necessidade de os operadores monitorarem constantemente o desempenho e ajustarem manualmente a contagem de pods.

Esta página é destinada a administradores, arquitetos e operadores que gerenciam o ciclo de vida da infraestrutura de tecnologia subjacente. Para saber mais sobre papéis comuns e tarefas de exemplo referenciados no Google Cloud content, consulte Funções e tarefas comuns do usuário do GKE e tarefas.

Escalonar uma implantação

Use a funcionalidade de escalonamento do Kubernetes para escalonar adequadamente a quantidade de pods em execução na implantação.

Escalonar automaticamente os pods de uma implantação

O Kubernetes oferece o escalonamento automático para eliminar a necessidade de atualizar manualmente a implantação quando a demanda evolui. Conclua as etapas a seguir para escalonar automaticamente os pods da implantação:

Para garantir que o escalonador automático horizontal de pods possa medir adequadamente a porcentagem de CPU, defina a solicitação de recursos de CPU na implantação.
Defina o escalonador automático horizontal de pods na implantação:
```
kubectl --kubeconfig CLUSTER_KUBECONFIG \
    -n NAMESPACE \
    autoscale deployment DEPLOYMENT_NAME \
    --cpu-percent=CPU_PERCENT \
    --min=MIN_NUMBER_REPLICAS \
    --max=MAX_NUMBER_REPLICAS
```
Substitua:
- CLUSTER_KUBECONFIG: o arquivo kubeconfig do cluster.
- NAMESPACE: o namespace. Para clusters compartilhados, esse precisa ser um namespace do projeto. Para clusters padrão, ele pode ser qualquer namespace.
- DEPLOYMENT_NAME: o nome da implantação a ser escalonada automaticamente.
- CPU_PERCENT: a utilização média da CPU de destino a ser solicitada, representada como uma porcentagem, em todos os pods.
- MIN_NUMBER_REPLICAS: o limite inferior para o número de pods que o escalonador automático pode provisionar.
- MAX_NUMBER_REPLICAS: o limite superior para o número de pods que o escalonador automático pode provisionar.

Verifique o status atual do escalonador automático horizontal de pods:

kubectl get hpa

O resultado será assim:

NAME              REFERENCE                          TARGET    MINPODS   MAXPODS   REPLICAS   AGE
DEPLOYMENT_NAME   Deployment/DEPLOYMENT_NAME/scale   0% / 50%  1         10        1          18s

Escalonar manualmente os pods de uma implantação

Se preferir escalonar uma implantação manualmente, execute:

kubectl --kubeconfig CLUSTER_KUBECONFIG \
    -n NAMESPACE \
    scale deployment DEPLOYMENT_NAME \
    --replicas NUMBER_OF_REPLICAS

Substitua:

CLUSTER_KUBECONFIG: o arquivo kubeconfig do cluster.
NAMESPACE: o namespace. Para clusters compartilhados, esse precisa ser um namespace do projeto. Para clusters padrão, ele pode ser qualquer namespace.
DEPLOYMENT_NAME: o nome da implantação em que o escalonamento automático será feito.
DEPLOYMENT_NAME: o número de objetos Pod replicados na implantação.

Usar métricas personalizadas do Prometheus para escalonamento automático

O escalonamento automático horizontal de pods usa métricas de recursos padrão, como utilização de CPU e memória, por padrão. As métricas padrão funcionam para escalonamento geral, mas não são úteis para cargas de aplicativos especializados.

Ao usar o escalonamento automático horizontal de pods com métricas personalizadas do Prometheus, é possível escalonar cargas de trabalho com base em métricas específicas do aplicativo, como taxas de solicitação HTTP, profundidade da fila e latência de processamento. O cluster pode responder com mais precisão à demanda real, aproveitando os dados avançados já coletados pela pilha de monitoramento do Prometheus.

Pré-requisitos para usar o Prometheus com o escalonamento automático horizontal de pods

Antes de ativar o recurso, as seguintes condições precisam ser atendidas:

Servidor Prometheus atual: um servidor Prometheus já precisa estar implantado e acessível pela rede de dentro do cluster. O controlador HPA não gerencia a instância do Prometheus. Para mais informações, consulte Como implantar e configurar o operador do Prometheus no Kubernetes.
Permissões administrativas: você precisa ter as permissões necessárias para modificar o recurso personalizado do cluster.
Sem conflitos de API: uma verificação de simulação verifica se nenhum outro componente já registrou um APIService para custom.metrics.k8s.io. Se houver um conflito, o adaptador não poderá ser ativado.

Ativar e configurar o Prometheus

O processo envolve a definição de regras de métricas e a atualização da configuração do cluster:

Crie um ou mais ConfigMaps de regras de métricas.

Defina as regras baseadas em PromQL para suas métricas personalizadas em um ou mais ConfigMaps no namespace do cluster de destino. O controlador monitora esses ConfigMaps, os mescla e os aplica automaticamente ao adaptador.

Para mais informações sobre como definir regras, consulte Configuração de descoberta e apresentação de métricas em kubernetes-sigs/prometheus-adapter.

O exemplo a seguir mostra um ConfigMap com regras definidas para http_requests_per_second no campo data:

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-app-rules
  namespace: <cluster-namespace>
data:
  config.yaml: |
    rules:
    - seriesQuery: 'http_requests_total'
      resources:
        overrides:
          namespace_name: {resource: "namespace"}
          pod_name: {resource: "pod"}
      name:
        matches: "^(.*)_total$"
        as: "${1}_per_second"
      metricsQuery: 'sum(rate(<<.Series>>{<<.LabelMatchers>>}[5m])) by (<<.GroupBy>>)'

Se o servidor Prometheus exigir autenticação, como o Transport Layer Security (mTLS) mútuo, crie um secret do Kubernetes no formato kubeconfig que contenha as credenciais necessárias.

O exemplo a seguir mostra um secret que oferece suporte à autenticação básica:
```
apiVersion: v1
kind: Secret
metadata:
  name: prometheus-auth-secret
  namespace: <cluster-namespace>
  annotations:
    baremetal.cluster.gke.io/mark-source: "true"
type: Opaque
stringData:
  config: authentication-credentials
```

Atualize o recurso personalizado do cluster:

Adicione a preview.baremetal.cluster.gke.io/metrics-adapter: "true" anotação ao metadata do recurso personalizado do cluster.

Adicione a seção spec.metricsAdapter para definir o URL do Prometheus e referenciar os ConfigMaps de regras.

apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: <cluster-name>
  namespace: <cluster-namespace>
  annotations:
    preview.baremetal.cluster.gke.io/metrics-adapter: "true"
spec:
  # ... other existing cluster configurations ...
  metricsAdapter:
    prometheus:
      url: "http://prometheus-k8s.monitoring.svc.cluster.local:9090"
      orgID: "production-environment"
      auth:
        configSecretRef:
          name: prometheus-auth-secret
          key: config # This is the key within the Secret's 'data' field
    rules:
      configMapKeyRefs:
        - name: my-app-rules
          key: config.yaml # This is the key within the ConfigMap's 'data' field
        # - name: base-system-rules
        #   key: config.yaml

Se a instância do Prometheus não exigir autenticação, omita a seção metricsAdapter.prometheus.auth da especificação do cluster.

Aplique o recurso personalizado do cluster atualizado.

O controlador implanta automaticamente o adaptador do Prometheus no namespace kube-system.

Use as métricas personalizadas para o escalonamento automático horizontal de pods criando um recurso HorizontalPodAutoscaler que tenha como destino as métricas personalizadas definidas nos campos rules do ConfigMaps.

O exemplo de ConfigMap de uma etapa anterior definiu uma métrica personalizada http_requests_per_second. Para usar essa métrica, o recurso HorizontalPodAutoscaler precisa ser semelhante ao exemplo a seguir:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: <name>
  namespace: <namespace>
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: <workload-name>
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Pods
    pods:
      metric:
        name: http_requests_per_second
      target:
        type: AverageValue
        averageValue: 10

Desativar o Prometheus

Para desativar o uso do Prometheus com o escalonamento automático horizontal de pods, remova a seção spec.metricsAdapter do recurso personalizado do cluster.

Configurar o escalonamento automático horizontal de pods Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.