Como fazer escalonamento automático de implantações com métricas de carga de trabalho do GKE

Neste tutorial, demonstramos como fazer o escalonamento automático das cargas de trabalho do Google Kubernetes Engine (GKE) com base nas métricas personalizadas emitidas pelo aplicativo (por exemplo, o número de contas conectadas ativamente ou o número de solicitações HTTP).

Use o pipeline de métricas de carga de trabalho do GKE para coletar métricas emitidas pelo aplicativo, enviá-las ao Cloud Monitoring e usá-las para fornecer energia. O escalonador automático de pod horizontal (HPA, na sigla em inglês).

Objetivos

Este tutorial abrange as seguintes tarefas:

  1. Como implantar um aplicativo de exemplo que emite métricas no estilo do Prometheus.
  2. Como implantar um recurso PodMonitor para coletar as métricas do seu aplicativo e publicá-las no Cloud Monitoring.
  3. Como implantar o adaptador de métricas personalizadas.
  4. Como consultar métricas de carga de trabalho usando a API Kubernetes Custom Metrics.
  5. Como implantar um recurso de escalonador automático de pod horizontal (HPA, na sigla em inglês) para escalonar o aplicativo com base nas métricas de carga de trabalho extraídas do aplicativo.

Antes de começar

Siga estas etapas para ativar a API do Kubernetes Engine:
  1. Acesse a página do Kubernetes Engine no Console do Google Cloud.
  2. Crie ou selecione um projeto.
  3. Aguarde a ativação da API e dos serviços relacionados. Isso pode levar alguns minutos.
  4. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

Siga este tutorial usando o Cloud Shell, que vem pré-instalado com as ferramentas de linha de comando gcloud e kubectl usadas neste tutorial. Se você usa o Cloud Shell, não precisa instalar essas ferramentas de linha de comando na sua estação de trabalho.

Para usar o Cloud Shell:

  1. Acesse o Console do Google Cloud.
  2. Clique no botão Ativar o Cloud Shell Botão "Ativar shell" na parte superior da janela do Console do Cloud.

    Uma sessão do Cloud Shell é aberta dentro de um novo frame na parte inferior do Console do Cloud, e exibe um prompt de linha de comando.

    Sessão do Cloud Shell

Como configurar o ambiente

  1. Para criar um novo cluster com a Identidade da carga de trabalho ativada, use o seguinte comando:

    gcloud beta container clusters create CLUSTER_NAME \
        --project=PROJECT_ID \
        --zone=ZONE \
        --monitoring=SYSTEM,WORKLOAD
    

    Substitua:

    • CLUSTER_NAME: o nome do cluster.
    • PROJECT_ID: o ID do seu projeto do Google Cloud.
    • ZONE: escolha uma zona mais próxima de você.

    Essa ação requer a permissão container.clusters.create no projeto.

  2. Para ativar as métricas de carga de trabalho em um cluster padrão ou do Autopilot atual, modifique o cluster com o seguinte comando:

    gcloud beta container clusters update CLUSTER_NAME \
        --project=PROJECT_ID \
        --zone=ZONE \
        --monitoring=SYSTEM,WORKLOAD
    

Como implantar um aplicativo de exemplo que emite métricas no estilo do Prometheus

Faça o download do repositório que contém o código do aplicativo para este tutorial:

  git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
  cd kubernetes-engine-samples/workload-metrics

O aplicativo de exemplo deste tutorial gera duas métricas e as expõe por meio de um endpoint integrado do Prometheus em localhost:1234/metrics:

  • example_requests_total: um contador de solicitações geradas pelo próprio aplicativo de pesquisa
  • example_random_numbers: um histograma de números gerados aleatoriamente

O repositório contém um manifesto do Kubernetes para implantar o aplicativo no cluster:

# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: workload-metrics
  name: workload-metrics
  namespace: gke-workload-metrics
spec:
  selector:
    matchLabels:
      app: workload-metrics
  template:
    metadata:
      labels:
        app: workload-metrics
    spec:
      containers:
      - image: us-docker.pkg.dev/google-samples/containers/workload-metrics:1.0
        imagePullPolicy: Always
        name: workload-metrics
        ports:
        - name: metrics-port
          containerPort: 1234
        command:
        - "/workload-metrics"
        - "--process-metrics"
        - "--go-metrics"
Implante o aplicativo no cluster:

  kubectl create namespace gke-workload-metrics
  kubectl apply -f manifests/workload-metrics-deployment.yaml

Depois de aguardar um momento pela implantação do aplicativo, todos os pods alcançam o estado Ready:

  kubectl -n gke-workload-metrics get pods

Saída:

  NAME                                READY   STATUS    RESTARTS   AGE
  workload-metrics-74fb6c56df-9djq7   1/1     Running   0          1m

Como implantar um recurso PodMonitor para coletar as métricas do aplicativo de exemplo

Para coletar as métricas emitidas do aplicativo de exemplo, você precisa criar um recurso personalizado PodMonitor.

O repositório contém um manifesto do Kubernetes para implantar o PodMonitor no cluster:

# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Note that this PodMonitor is in the monitoring.gke.io domain,
# rather than the monitoring.coreos.com domain used with the
# Prometheus Operator
apiVersion: monitoring.gke.io/v1alpha1
kind: PodMonitor
metadata:
  name: workload-metrics-podmon
# spec describes how to monitor a set of pods in a cluster.
spec:
  # namespaceSelector determines which namespace is searched for pods. Required
  namespaceSelector:
    matchNames:
    - gke-workload-metrics
  # selector determines which pods are monitored.  Required
  # This example matches pods with the `app: workload-metrics-example` label
  selector:
    matchLabels:
      app: workload-metrics
  podMetricsEndpoints:
    # port is the name of the port of the container to be scraped.
  - port: metrics-port
    # path is the path of the endpoint to be scraped.
    # Default /metrics
    path: /metrics
    # scheme is the scheme of the endpoint to be scraped.
    # Default http
    scheme: http
    # interval is the time interval at which metrics should
    # be scraped. Default 60s
    interval: 20s
Implante o PodMonitor no cluster:

  kubectl apply -f manifests/workload-metrics-podmon.yaml

Como implantar o adaptador de métricas personalizadas

O adaptador de métricas personalizadas permite que o cluster envie e receba métricas com o Monitoring.

  1. Permita que o usuário crie os papéis de autorização necessários:

    kubectl create clusterrolebinding cluster-admin-binding \
        --clusterrole cluster-admin --user "$(gcloud config get-value account)"
    
  2. Se você estiver usando um cluster do Autopilot ou um cluster com a Identidade da carga de trabalho ativada, faça o seguinte:

    1. Crie um namespace para o adaptador:

      kubectl create namespace custom-metrics
      
    2. Crie uma conta de serviço do Kubernetes para o adaptador:

      kubectl create serviceaccount --namespace custom-metrics \
      custom-metrics-stackdriver-adapter
      
    3. Crie uma conta de serviço do Google com permissão para visualizar as métricas do Monitoring:

      gcloud iam service-accounts create GSA_NAME
      
      gcloud projects add-iam-policy-binding PROJECT_ID \
          --member "serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
          --role "roles/monitoring.viewer"
      

      Substitua:

      • PROJECT_ID: é seu ID do projeto no Google Cloud.
      • GSA_NAME: o nome da conta de serviço do Google
    4. Permita que a conta de serviço do Kubernetes atue como a conta de serviço do Google criando uma vinculação de política do IAM:

      gcloud iam service-accounts add-iam-policy-binding \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]" \
        GSA_NAME@PROJECT_ID.iam.gserviceaccount.com
      
    5. Anote a conta de serviço do Kubernetes para indicar a vinculação:

      kubectl annotate serviceaccount \
        --namespace custom-metrics custom-metrics-stackdriver-adapter \
        iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID.iam.gserviceaccount.com
      
  3. Implante o adaptador do novo modelo de recurso no cluster:

    kubectl apply -f manifests/adapter_new_resource_model.yaml
    
  4. Verifique se o adaptador de métricas personalizadas está implantado e no estado Ready:

    kubectl -n custom-metrics get pods
    

    Saída:

    NAME                                                 READY   STATUS    RESTARTS   AGE
    custom-metrics-stackdriver-adapter-6d4fc94699-zqndq  1/1     Running   0          2m
    

Como consultar métricas de carga de trabalho usando a API Custom Metrics do Kubernetes

Use a API Kubernetes Custom Metrics para verificar se as métricas da carga de trabalho ficam visíveis para o GKE.

As métricas de carga de trabalho do GKE são exportadas para o Monitoring com o prefixo workload.googleapis.com. O servidor da API Custom Metrics do Kubernetes não é compatível com o caractere / nos caminhos de métricas. Portanto, você precisa substituir todos os caracteres / por |. Portanto, você precisa usar workload.googleapis.com|example_request_total para o nome da métrica.

Depois de aguardar alguns instantes para que as métricas dos aplicativos sejam enviadas ao Monitoring, execute o seguinte comando para consultar a métrica workload.googleapis.com|example_request_total:

   kubectl get --raw  \
   "/apis/custom.metrics.k8s.io/v1beta2/namespaces/gke-workload-metrics/pods/*/workload.googleapis.com|example_requests_total"

Saída:

  {"kind":"MetricValueList","apiVersion":"custom.metrics.k8s.io/v1beta2",
  "metadata":{"selfLink":"/apis/custom.metrics.k8s.io/v1beta2/namespaces/
  gke-workload-metrics/pods/%2A/workload.googleapis.com%7Cexample_requests_total"},
  "items":[{"describedObject":{"kind":"Pod","namespace":"gke-workload-metrics",
  "name":"prom-example-74fb6c56df-9djq7","apiVersion":"/__internal"},"metric":
  {"name":"workload.googleapis.com|example_requests_total","selector":null},"timestamp ":
  "2021-08-23T10:48:45Z","value":"1199m"}]}

Como implantar um objeto HorizontalPodAutoscaler

Depois de ver a métrica workload.googleapis.com|example_requests_total no payload de resposta da API Custom Metrics na etapa anterior, você pode implantar um escalonador automático de pod horizontal (HPA) para redimensionar a implantação com base nessa métrica de dados.

O repositório contém um manifesto do Kubernetes para implantar o HPA no cluster:

# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: workload-metrics-hpa
  namespace: gke-workload-metrics
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: workload-metrics
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: workload.googleapis.com|example_requests_total
      target:
        type: AverageValue
        averageValue: 1
Esse HPA define as réplicas mínima de pods como 1 e o máximo como 5. Ele escalona a implantação para garantir que o valor médio de workload.googleapis.com|example_request_total em todos os pods seja 1.

Implante o HorizontalPodAutoscaler no cluster:

  kubectl apply -f manifests/workload-metrics-hpa.yaml

Como observar o escalonamento vertical do HorizontalPodAutoscaler

Verifique periodicamente o número de réplicas na sua implantação e veja-o escalonar para cinco réplicas executando o seguinte comando:

  kubectl -n gke-workload-metrics get pods

Saída:

  NAME                                READY   STATUS    RESTARTS   AGE
  workload-metrics-74fb6c56df-9djq7   1/1     Running   0          5m
  workload-metrics-74fb6c56df-frzbv   1/1     Running   0          7m
  workload-metrics-74fb6c56df-h26rw   1/1     Running   0          8m
  workload-metrics-74fb6c56df-kwvx9   1/1     Running   0          10m
  workload-metrics-74fb6c56df-vvtnn   1/1     Running   0          11m

Também é possível inspecionar o estado e a atividade do escalonador automático horizontal de pods executando o seguinte comando:

  kubectl -n gke-workload-metrics describe hpa workload-metrics-hpa

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

A seguir