Otimize a escala automática de pods com base em métricas

Implementar 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.

kubectl create clusterrolebinding cluster-admin-binding \
    --clusterrole cluster-admin --user "$(gcloud config get-value account)"

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

gcloud projects add-iam-policy-binding projects/$PROJECT_ID \
  --role roles/monitoring.viewer \
  --member=principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/custom-metrics/sa/custom-metrics-stackdriver-adapter

kubectl create clusterrolebinding cluster-admin-binding \
    --clusterrole cluster-admin --user "$(gcloud config get-value account)"

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

kubectl create clusterrolebinding cluster-admin-binding \
    --clusterrole cluster-admin --user "$(gcloud config get-value account)"

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

gcloud projects add-iam-policy-binding projects/$PROJECT_ID \
  --role roles/monitoring.viewer \
  --member=principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/custom-metrics/sa/custom-metrics-stackdriver-adapter

kubectl create clusterrolebinding cluster-admin-binding \
    --clusterrole cluster-admin --user "$(gcloud config get-value account)"

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

Implementar uma aplicação com métricas

Transfira o repositório que contém o código da aplicação para este tutorial:

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

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

O repositório contém código que exporta métricas para o 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)

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 implementar a aplicação no seu cluster. 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:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: pubsub
spec:
  selector:
    matchLabels:
      app: pubsub
  template:
    metadata:
      labels:
        app: pubsub
    spec:
      serviceAccountName: pubsub-sa
      containers:
      - name: subscriber
        image: us-docker.pkg.dev/google-samples/containers/gke/pubsub-sample:v2

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

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: custom-metrics-gmp
  name: custom-metrics-gmp
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: custom-metrics-gmp
  template:
    metadata:
      labels:
        run: custom-metrics-gmp
    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

apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: "custom-metrics-exporter"
spec:
  selector:
    matchLabels:
      run: custom-metrics-gmp
  endpoints:
  - port: 8080
    path: /metrics
    interval: 15s

Implemente a aplicação no cluster:

kubectl apply -f custom-metrics-gmp.yaml

Depois de aguardar um momento para que a aplicação seja implementada, todos os pods atingem o estado Ready:

kubectl get pods

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

kubectl get pods

NAME                                  READY   STATUS    RESTARTS   AGE
custom-metrics-gmp-865dffdff9-x2cg9   1/1     Running   0          49s

Visualizar métricas no Cloud Monitoring

À medida que a aplicação é executada, escreve as suas métricas no Cloud Monitoring.

Para ver as métricas de um recurso monitorizado através do Metrics Explorer, faça o seguinte:

1. Na Google Cloud consola, aceda à página leaderboard Explorador de métricas:

   Aceda ao Metrics Explorer

   Se usar a barra de pesquisa para encontrar esta página, selecione o resultado cujo subtítulo é Monitorização.

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

3. Para filtrar as séries cronológicas apresentadas, use o elemento Filtro.

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

   Todas as séries cronológicas são apresentadas quando o primeiro menu do elemento Agregação está definido como Não agregado. As predefinições do elemento Agregação são determinadas pelo tipo de métrica que selecionou.

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

Consoante a métrica, pode ainda não ver muita atividade no Explorador de métricas do Cloud Monitoring. Não se surpreenda se a sua métrica não estiver a ser atualizada.

Criar um objeto HorizontalPodAutoscaler

Quando vir a sua métrica no Cloud Monitoring, pode implementar um HorizontalPodAutoscaler para redimensionar a sua implementação com base na métrica.

apiVersion: autoscaling/v2
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

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: custom-metrics-gmp-hpa
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: custom-metrics-gmp
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: prometheus.googleapis.com|custom_prometheus|gauge
      target:
        type: AverageValue
        averageValue: 20

Implemente o HorizontalPodAutoscaler no seu cluster:

kubectl apply -f deployment/pubsub-hpa.yaml

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

A gerar carga

Para algumas métricas, pode ter de gerar carga para observar o ajuste de escala automático:

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

Pode ter de aguardar alguns minutos para que o HorizontalPodAutoscaler responda às alterações das métricas.

Observar o aumento da escala do HorizontalPodAutoscaler

Pode verificar o número atual de réplicas da sua implementação executando o seguinte comando:

kubectl get deployments

Depois de dar algum tempo para a métrica se propagar, a implementação cria cinco pods para processar o backlog.

Também pode inspecionar o estado e a atividade recente do HorizontalPodAutoscaler executando o seguinte comando:

kubectl describe hpa