Otimizar o escalonamento automático de pod com base em métricas

---

Neste tutorial, demonstramos como escalonar automaticamente as cargas de trabalho do Google Kubernetes Engine (GKE) com base nas métricas disponíveis no Cloud Monitoring.

Neste tutorial, você poderá configurar o escalonamento automático com base em uma das quatro métricas diferentes:

CPU

Uso de CPU

Escalone com base na porcentagem de utilização de CPUs em nós. Isso pode ser econômico, permitindo maximizar a utilização de recursos da CPU. No entanto, como o uso de CPU é uma métrica posterior, seus usuários podem ter latência enquanto um escalonamento vertical está em andamento.

Pub/Sub

Backlog do Pub/Sub

Escalone com base no número de mensagens não confirmadas restantes em uma inscrição do Pub/Sub. Essa prática pode reduzir a latência de maneira eficiente antes de se tornar um problema, mas talvez use relativamente mais recursos do que o escalonamento automático com base na utilização de CPU.

Métrica personalizada

Métrica personalizada do Cloud Monitoring

Escalone com base em uma métrica personalizada definida pelo usuário e exportada pelas bibliotecas de cliente do Cloud Monitoring. Para saber mais, consulte Como criar métricas personalizadas na documentação do Cloud Monitoring.

Prometheus personalizado

Métrica personalizada do Prometheus

Escalone com base em uma métrica personalizada definida pelo usuário e exportada no formato Prometheus. A métrica do Prometheus precisa ser do tipo Gauge (ambos em inglês) e não pode conter o prefixo custom.googleapis.com.

O escalonamento automático é basicamente sobre encontrar um equilíbrio aceitável entre custo e latência. Recomendamos fazer testes com uma combinação dessas e outras métricas para encontrar uma política que funcione para você.

Objetivos

Este tutorial abrange as seguintes tarefas:

1. Como implantar o adaptador de métricas personalizadas.
2. Como exportar métricas a partir do código do aplicativo.
3. Como visualizar as métricas na interface do Cloud Monitoring.
4. Como implantar um recurso HorizontalPodAutoscaler (HPA) para escalonar o aplicativo com base nas métricas do Cloud Monitoring.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

• GKE
• Pub/Sub

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

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 a cobrança está ativada para o seu projeto do Google Cloud.

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 Cloud Shell na parte superior da janela do Console do Google Cloud.

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

   

Como configurar o ambiente

1. Defina a zona padrão da Google Cloud CLI:

   gcloud config set compute/zone zone
   

   Substitua:

   • zone: escolha uma zona mais próxima de você. Para mais informações, consulte Regiões e zonas.

2. Defina a variável de ambiente PROJECT_ID para o ID do projeto do Google Cloud (project-id):

   export PROJECT_ID=project-id
   

3. Defina a zona padrão da Google Cloud CLI:

   gcloud config set project $PROJECT_ID
   

4. Criar um cluster do GKE

   gcloud container clusters create metrics-autoscaling
   

   Observação: este tutorial é específico para clusters que têm a federação de identidade da carga de trabalho para GKE desativada. Se o cluster tiver a federação de identidade da carga de trabalho para GKE ativada, você terá que executar mais etapas, conforme explicado nesta página do GitHub
   .

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 Cloud Monitoring.

CPU

Não aplicável: os escalonadores automáticos de pods horizontais podem escalonar nativamente com base na utilização de CPU. Portanto, o adaptador de métricas personalizadas não é necessário.

Pub/Sub

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)"

Implante o adaptador do novo modelo de recurso no cluster:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

Métrica personalizada

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)"

Implante o adaptador do modelo de recurso no cluster:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

Prometheus personalizado

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)"

Implante o adaptador do modelo de recurso legado no cluster:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter.yaml

Observação: há duas versões do adaptador, o modelo legado e o novo modelo de recurso. Para mais informações, acesse a página do GitHub (em inglês) sobre o adaptador.

Como implantar um aplicativo com métricas

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

CPU

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/quickstarts/hello-app

Pub/Sub

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/databases/cloud-pubsub

Métrica personalizada

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/observability/custom-metrics-autoscaling/direct-to-sd

Prometheus personalizado

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/observability/custom-metrics-autoscaling/prometheus-to-sd

O repositório contém um código que exporta métricas para o Cloud Monitoring:

CPU

Este aplicativo responde "Hello, world!" para qualquer solicitação da Web na porta 8080. As métricas de CPU do Compute Engine são coletadas automaticamente pelo Cloud Monitoring.

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)

func main() {
	// register hello function to handle all requests
	mux := http.NewServeMux()
	mux.HandleFunc("/", hello)

	// use PORT environment variable, or default to 8080
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	// start the web server on port and accept requests
	log.Printf("Server listening on port %s", port)
	log.Fatal(http.ListenAndServe(":"+port, mux))
}

// hello responds to the request with a plain-text "Hello, world" message.
func hello(w http.ResponseWriter, r *http.Request) {
	log.Printf("Serving request: %s", r.URL.Path)
	host, _ := os.Hostname()
	fmt.Fprintf(w, "Hello, world!\n")
	fmt.Fprintf(w, "Version: 1.0.0\n")
	fmt.Fprintf(w, "Hostname: %s\n", host)
}

Pub/Sub

Este aplicativo pesquisa uma inscrição do Pub/Sub para novas mensagens, reconhecendo-as assim que chegam. As métricas de inscrição do Pub/Sub são coletadas automaticamente pelo Cloud Monitoring.

from google import auth
from google.cloud import pubsub_v1

def main():
    """Continuously pull messages from subsciption"""

    # read default project ID
    _, project_id = auth.default()
    subscription_id = 'echo-read'

    subscriber = pubsub_v1.SubscriberClient()
    subscription_path = subscriber.subscription_path(
        project_id, subscription_id)

    def callback(message: pubsub_v1.subscriber.message.Message) -> None:
        """Process received message"""
        print(f"Received message: ID={message.message_id} Data={message.data}")
        print(f"[{datetime.datetime.now()}] Processing: {message.message_id}")
        time.sleep(3)
        print(f"[{datetime.datetime.now()}] Processed: {message.message_id}")
        message.ack()

    streaming_pull_future = subscriber.subscribe(
        subscription_path, callback=callback)
    print(f"Pulling messages from {subscription_path}...")

    with subscriber:
        try:
            streaming_pull_future.result()
        except Exception as e:
            print(e)

Métrica personalizada

Este aplicativo exporta uma métrica de valor constante usando as bibliotecas de cliente do Cloud Monitoring.

func exportMetric(stackdriverService *monitoring.Service, metricName string,
	metricValue int64, metricLabels map[string]string, monitoredResource string, resourceLabels map[string]string) error {
	dataPoint := &monitoring.Point{
		Interval: &monitoring.TimeInterval{
			EndTime: time.Now().Format(time.RFC3339),
		},
		Value: &monitoring.TypedValue{
			Int64Value: &metricValue,
		},
	}
	// Write time series data.
	request := &monitoring.CreateTimeSeriesRequest{
		TimeSeries: []*monitoring.TimeSeries{
			{
				Metric: &monitoring.Metric{
					Type:   "custom.googleapis.com/" + metricName,
					Labels: metricLabels,
				},
				Resource: &monitoring.MonitoredResource{
					Type:   monitoredResource,
					Labels: resourceLabels,
				},
				Points: []*monitoring.Point{
					dataPoint,
				},
			},
		},
	}
	projectName := fmt.Sprintf("projects/%s", resourceLabels["project_id"])
	_, err := stackdriverService.Projects.TimeSeries.Create(projectName, request).Do()
	return err
}

Prometheus personalizado

Este aplicativo exporta uma métrica de valor constante usando o formato Prometheus.

metric := prometheus.NewGauge(
	prometheus.GaugeOpts{
		Name: *metricName,
		Help: "Custom metric",
	},
)
prometheus.MustRegister(metric)
metric.Set(float64(*metricValue))

http.Handle("/metrics", promhttp.Handler())
log.Printf("Starting to listen on :%d", *port)
err := http.ListenAndServe(fmt.Sprintf(":%d", *port), nil)

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

CPU

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloweb
  labels:
    app: hello
spec:
  selector:
    matchLabels:
      app: hello
      tier: web
  template:
    metadata:
      labels:
        app: hello
        tier: web
    spec:
      containers:
      - name: hello-app
        image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: 200m

Pub/Sub

apiVersion: apps/v1
kind: Deployment
metadata:
  name: pubsub
spec:
  selector:
    matchLabels:
      app: pubsub
  template:
    metadata:
      labels:
        app: pubsub
    spec:
      volumes:
      - name: google-cloud-key
        secret:
          secretName: pubsub-key
      containers:
      - name: subscriber
        image: us-docker.pkg.dev/google-samples/containers/gke/pubsub-sample:v2
        volumeMounts:
        - name: google-cloud-key
          mountPath: /var/secrets/google
        env:
        - name: GOOGLE_APPLICATION_CREDENTIALS
          value: /var/secrets/google/key.json

Métrica personalizada

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: custom-metric-sd
  name: custom-metric-sd
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: custom-metric-sd
  template:
    metadata:
      labels:
        run: custom-metric-sd
    spec:
      containers:
      - command: ["./sd-dummy-exporter"]
        args:
        - --use-new-resource-model=true
        - --use-old-resource-model=false
        - --metric-name=custom-metric
        - --metric-value=40
        - --pod-name=$(POD_NAME)
        - --namespace=$(NAMESPACE)
        image: us-docker.pkg.dev/google-samples/containers/gke/sd-dummy-exporter:v0.3.0
        name: sd-dummy-exporter
        resources:
          requests:
            cpu: 100m
        env:
        # save Kubernetes metadata as environment variables for use in metrics
        - name: POD_NAME
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: metadata.name
        - name: NAMESPACE
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: metadata.namespace

Prometheus personalizado

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: custom-metric-prometheus-sd
  name: custom-metric-prometheus-sd
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: custom-metric-prometheus-sd
  template:
    metadata:
      labels:
        run: custom-metric-prometheus-sd
    spec:
      containers:
      # sample container generating custom metrics
      - name: prometheus-dummy-exporter
        image: us-docker.pkg.dev/google-samples/containers/gke/prometheus-dummy-exporter:v0.2.0
        command: ["./prometheus-dummy-exporter"]
        args:
        - --metric-name=custom_prometheus
        - --metric-value=40
        - --port=8080
      # pre-built 'prometheus-to-sd' sidecar container to export prometheus
      # metrics to Stackdriver
      - name: prometheus-to-sd
        image: gcr.io/google-containers/prometheus-to-sd:v0.5.0
        command: ["/monitor"]
        args:
        - --source=:http://localhost:8080
        - --stackdriver-prefix=custom.googleapis.com
        - --pod-id=$(POD_ID)
        - --namespace-id=$(POD_NAMESPACE)
        env:
        # save Kubernetes metadata as environment variables for use in metrics
        - name: POD_ID
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: metadata.uid
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace

Implante o aplicativo no cluster:

CPU

kubectl apply -f manifests/helloweb-deployment.yaml

Pub/Sub

Ative a API Pub/Sub no seu projeto:

gcloud services enable cloudresourcemanager.googleapis.com pubsub.googleapis.com

Crie um tópico e uma inscrição do Pub/Sub:

gcloud pubsub topics create echo
gcloud pubsub subscriptions create echo-read --topic=echo

Crie uma conta de serviço com acesso ao Pub/Sub:

gcloud iam service-accounts create autoscaling-pubsub-sa
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member "serviceAccount:autoscaling-pubsub-sa@$PROJECT_ID.iam.gserviceaccount.com" \
  --role "roles/pubsub.subscriber"

Observação: as configurações da conta de serviço acima pressupõem que o cluster tem a federação de identidade da carga de trabalho para o GKE desativada. Se o cluster tiver a federação de identidade da carga de trabalho para GKE ativada, será necessário executar outras etapas específicas da conta de serviço, conforme explicado nesta página do GitHub.

Faça o download do arquivo de chave da conta de serviço:

gcloud iam service-accounts keys create key.json \
  --iam-account autoscaling-pubsub-sa@$PROJECT_ID.iam.gserviceaccount.com

Importe a chave da conta de serviço para o cluster como um Secret:

kubectl create secret generic pubsub-key --from-file=key.json=./key.json

Implante o aplicativo no cluster:

kubectl apply -f deployment/pubsub-with-secret.yaml

Métrica personalizada

kubectl apply -f custom-metrics-sd.yaml

Prometheus personalizado

kubectl apply -f custom-metrics-prometheus-sd.yaml

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

CPU

kubectl get pods

Saída:

NAME                        READY   STATUS    RESTARTS   AGE
helloweb-7f7f7474fc-hzcdq   1/1     Running   0          10s

Pub/Sub

kubectl get pods

Saída:

NAME                     READY   STATUS    RESTARTS   AGE
pubsub-8cd995d7c-bdhqz   1/1     Running   0          58s

Métrica personalizada

kubectl get pods

Saída:

NAME                                READY   STATUS    RESTARTS   AGE
custom-metric-sd-58dbf4ffc5-tm62v   1/1     Running   0          33s

Prometheus personalizado

kubectl get pods

Saída:

NAME                                           READY   STATUS    RESTARTS   AGE
custom-metric-prometheus-sd-697bf7c7d7-ns76p   2/2     Running   0          49s

Como ver métricas no Cloud Monitoring

Durante a execução do aplicativo, ele grava as métricas no Cloud Monitoring.

Para visualizar as métricas de um recurso monitorado usando o Metrics Explorer, faça o seguinte:

1. No painel de navegação do console do Google Cloud, selecione Monitoramento e  Metrics Explorer:

   Acesse o Metrics explorer

2. No elemento Métrica, expanda o menu Selecionar uma métrica e escolha um tipo de recurso e de métrica. Por exemplo, para gerar um gráfico do uso da CPU de uma máquina virtual, faça o seguinte:
   1. Opcional: para reduzir as opções do menu, insira parte do nome da métrica na Barra de filtros. Neste exemplo, digite utilization.
   2. No menu Recursos ativos, selecione Instância de VM.
   3. No menu Categorias de métrica ativas, selecione Instância.
   4. No menu Métricas ativas, selecione Utilização de CPU e clique em Aplicar.

3. Para filtrar as séries temporais de texto, use o elemento Filtro.

4. Para combinar séries temporais, use os menus no elemento Agregação. Por exemplo, para exibir a utilização da CPU para suas VMs, com base na zona, defina o primeiro menu como Média e o segundo como zona.

   Todas as séries temporais são exibidas quando o primeiro menu do elemento Agregação está definido como Não agregado. As configurações padrão do elemento Agregação são determinadas pelo tipo de métrica selecionada.

O tipo de recurso e as métricas são os seguintes:

CPU

Metrics Explorer

Tipo de recurso: gce_instance

Métrica: compute.googleapis.com/instance/cpu/utilization

Pub/Sub

Metrics Explorer

Tipo de recurso: pubsub_subscription

Métrica: pubsub.googleapis.com/subscription/num_undelivered_messages

Métrica personalizada

Metrics Explorer

Tipo de recurso: k8s_pod

Métrica: custom.googleapis.com/custom-metric

Prometheus personalizado

Metrics Explorer

Tipo de recurso: gke_container

Métrica: custom.googleapis.com/custom_prometheus

Observação: dependendo da métrica, talvez você ainda não veja muita atividade no Metrics Explorer do Cloud Monitoring. Não se surpreenda se a métrica não for atualizada.

Como criar um objeto HorizontalPodAutoscaler

Depois de ver a métrica no Cloud Monitoring, será possível implantar um HorizontalPodAutoscaler para redimensionar a implantação com base na métrica.

CPU

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: cpu
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: helloweb
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 30

Pub/Sub

apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: pubsub
spec:
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - external:
      metric:
       name: pubsub.googleapis.com|subscription|num_undelivered_messages
       selector:
         matchLabels:
           resource.labels.subscription_id: echo-read
      target:
        type: AverageValue
        averageValue: 2
    type: External
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: pubsub

Métrica personalizada

apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: custom-metric-sd
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: custom-metric-sd
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: custom-metric
      target:
        type: AverageValue
        averageValue: 20

Prometheus personalizado

apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: custom-prometheus-hpa
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: custom-metric-prometheus-sd
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: custom_prometheus
      target:
        type: AverageValue
        averageValue: 20

Implante o HorizontalPodAutoscaler no cluster:

CPU

kubectl apply -f manifests/helloweb-hpa.yaml

Pub/Sub

kubectl apply -f deployment/pubsub-hpa.yaml

Métrica personalizada

kubectl apply -f custom-metrics-sd-hpa.yaml

Prometheus personalizado

kubectl apply -f custom-metrics-prometheus-sd-hpa.yaml

Como gerar carga

Para algumas métricas, pode ser necessário gerar carga para monitorar o escalonamento automático:

CPU

Simule 10.000 solicitações para o servidor helloweb:

 kubectl exec -it deployments/helloweb -- /bin/sh -c \
     "for i in $(seq -s' ' 1 10000); do wget -q -O- localhost:8080; done"

Pub/Sub

Publique 200 mensagens no tópico do Pub/Sub:

for i in {1..200}; do gcloud pubsub topics publish echo --message="Autoscaling #${i}"; done

Métrica personalizada

Não aplicável: o código usado na amostra exporta um valor constante de 40 para a métrica personalizada. O HorizontalPodAutoscaler é definido com um valor de destino de 20. Portanto, ele tenta escalonar a implantação automaticamente e de forma vertical.

Prometheus personalizado

Não aplicável: o código usado na amostra exporta um valor constante de 40 para a métrica personalizada. O HorizontalPodAutoscaler é definido com um valor de destino de 20. Portanto, ele tenta escalonar a implantação automaticamente e de forma vertical.

Observação: talvez seja necessário aguardar alguns minutos para que o HorizontalPodAutoscaler responda às alterações de métrica.

Como observar o escalonamento vertical do HorizontalPodAutoscaler

É possível verificar o número atual de réplicas da sua implantação, basta executar:

kubectl get deployments

Após algum tempo para a métrica se propagar, a implantação cria cinco pods para lidar com o backlog.

Também é possível inspecionar o estado e a atividade recente do HorizontalPodAutoscaler, basta executar:

kubectl describe hpa

Limpeza

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.

CPU

Exclua seu Cluster do GKE:

 gcloud container clusters delete metrics-autoscaling

Pub/Sub

1. Remova a inscrição e o tópico do Pub/Sub:

   gcloud pubsub subscriptions delete echo-read
   gcloud pubsub topics delete echo
   

2. Exclua seu Cluster do GKE:

   gcloud container clusters delete metrics-autoscaling
   

Métrica personalizada

Exclua seu Cluster do GKE:

 gcloud container clusters delete metrics-autoscaling

Prometheus personalizado

Exclua seu Cluster do GKE:

 gcloud container clusters delete metrics-autoscaling

A seguir

• Saiba mais sobre métricas personalizadas e externas para escalonar cargas de trabalho.

• Explore outros tutoriais do Kubernetes Engine.