Cómo realizar el ajuste de escala automático de las implementaciones con métricas personalizadas

En este instructivo se muestra como escalar automáticamente tus cargas de trabajo de GKE según las métricas personalizadas exportadas a Stackdriver por los pods de Kubernetes. Para obtener información sobre cómo ajustar automáticamente la escala de las cargas de trabajo según otras métricas disponibles en Stackdriver, visita Cómo realizar el ajuste de escala automático de las implementaciones con métricas externas.

Objetivos

Para configurar un ajuste de escala automático con métricas personalizadas en GKE, debes seguir estos pasos:

  1. Implementar el adaptador de métricas personalizadas de Stackdriver.
  2. Exportar métricas personalizadas a Stackdriver.
  3. Implementar el recurso HorizontalPodAutoscaler (HPA) para escalar tu implementación según las métricas personalizadas.

Antes de comenzar

Sigue los pasos que se indican a continuación para habilitar la API de Kubernetes Engine:
  1. Visita la página de Kubernetes Engine en Google Cloud Platform Console.
  2. Crea o selecciona un proyecto.
  3. Espera a que la API y los servicios relacionados se habiliten. Esto puede tardar varios minutos.
  4. Comprueba que la facturación esté habilitada en tu proyecto.

    Descubre cómo puedes habilitar la facturación

Instala las siguientes herramientas de línea de comandos que se usan en este instructivo:

  • gcloud se usa para crear y borrar clústeres de Kubernetes Engine. gcloud se incluye en el SDK de Google Cloud.
  • kubectl se usa para administrar Kubernetes, el sistema de organización de clústeres que utiliza Kubernetes Engine. Puedes instalar kubectl mediante gcloud:
    gcloud components install kubectl

Establecer valores predeterminados para la herramienta de línea de comandos de gcloud

Para ahorrar tiempo en escribir las opciones de tu ID del proyecto y de la zona de Compute Engine en la herramienta de línea de comandos de gcloud, puedes establecer los valores predeterminados:
gcloud config set project [PROJECT_ID]
gcloud config set compute/zone us-central1-b

Crear el clúster y configurar la supervisión

Cómo elegir una métrica personalizada

Existen dos modos de realizar el ajuste de escala automático con métricas personalizadas:

  • Puedes exportar una métrica personalizada de cada pod en la implementación y establecer el valor promedio por pod.
  • Puedes exportar una métrica personalizada desde un único pod fuera de la implementación y establecer el valor total.

Dentro de límites determinados, una implementación puede escalar sus pods repetidos según el valor de la métrica. Las métricas con un valor objetivo total siempre deben definirse de manera tal que el escalamiento acerque el valor de la métrica al valor objetivo.

Por ejemplo, considera escalar una aplicación frontend según la métrica de consultas por segundo. Cuando el valor de la métrica aumenta, la cantidad de pods debería escalar. Como resultado, cada pod procesará una cantidad similar de tráfico como antes. Exportar el valor de las consultas por segundo para cada pod y configurar un promedio objetivo deseado da como resultado el comportamiento esperado. Sin embargo, exportar la cantidad total de consultas por segundo y establecer un valor objetivo total para esta métrica no produce el comportamiento deseado en este caso, ya que aumentar la cantidad de pods no reduce el tráfico total.

Otras métricas, como la latencia de solicitud promedio, se pueden usar directamente con el valor objetivo total para escalar las implementaciones, según el caso práctico.

Paso 1: implementar métricas personalizadas con el adaptador de Stackdriver

Para que los objetos GKE tengan acceso a las métricas almacenadas en Stackdriver, debes implementar el Adaptador de métricas personalizadas de Stackdriver. Para ejecutar el adaptador de métricas personalizadas, debes otorgar al usuario la capacidad de crear funciones de autorización requeridas mediante la ejecución del siguiente comando:

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

Para implementar el adaptador en tu clúster, ejecuta el siguiente comando:

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

Paso 2: exportar la métrica a Stackdriver

Puedes exportar tus métricas a Stackdriver directamente desde tu aplicación, o exponiéndolas en formato Prometheus y agregando el adaptador Prometheus-to-Stackdriver a los contenedores de tu pod.

Puedes ver las métricas exportadas desde el explorador de métricas si buscas custom/[METRIC_NAME] (como custom/foo).

Cómo exportar métricas desde la aplicación

Puedes crear métricas personalizadas y exportarlas directamente a Stackdriver desde el código de tu aplicación. Para obtener más información, visita Cómo crear métricas personalizadas en la Documentación de Stackdriver Monitoring. También puedes aprovechar la función creación automática de métricas personalizadas de Stackdriver.

Tu métrica debe cumplir con los siguientes requisitos:

  • La clase de métrica debe ser GAUGE
  • El tipo de métrica debe ser DOUBLE o INT64
  • El nombre de la métrica debe comenzar con el prefijo custom.googleapis.com/ seguido de un nombre simple.
  • El tipo de recurso debe ser "gke_container"
  • Las etiquetas del recurso deben incluir:
    • pod_id configurado en UID de pod, que puede obtenerse mediante Downward API
    • container_name = ""
    • project_id, zone, cluster_name, que la aplicación puede obtener desde el servidor de metadatos. Para obtener valores, puedes usar el cliente de metadatos de procesamiento de Google Cloud.
    • namespace_id, instance_id, que pueden configurarse en cualquier valor.

En el siguiente archivo de manifiesto se describe una implementación que ejecuta una instancia única de una aplicación de Go que exporta métricas mediante las bibliotecas cliente Stackdriver:

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: ["./direct-to-sd"]
        args: ["--metric-name=foo", "--metric-value=40", "--pod-id=$(POD_ID)"]
        image: gcr.io/google-samples/sd-dummy-exporter:latest
        name: sd-dummy-exporter
        resources:
          requests:
            cpu: 100m
        env:
          - name: POD_ID
            valueFrom:
              fieldRef:
                apiVersion: v1
                fieldPath: metadata.uid

Cómo exportar mediante Prometheus

Puedes exportar métricas en tu aplicación en formato Prometheus y, luego, implementar el adaptador Prometheus-to-Stackdriver, que recopila las métricas y las exporta a Stackdriver. Para ver ejemplos de cómo exponer las métricas en formato Prometheus, visita la Guía de instrumentación de Kubernetes.

Tu métrica debe cumplir con los siguientes requisitos:

  • El tipo de métrica debe ser Gauge
  • El nombre de la métrica debe contener el prefijo custom.googleapis.com

Implementa Prometheus como un contenedor del pod desde el cual exportas las métricas y transfiere los siguientes marcadores al contenedor.

  • pod-id y namespace-id: establecidos en UID de espacio de nombres y pod, obtenido mediante Downward API
  • source=http://localhost:[PORT], en el que [PORT] es el puerto en el que se expondrán tus métricas.
  • stackdriver-prefix=custom.googleapis.com

En el siguiente archivo de manifiesto se describe un pod con una aplicación de Go que expone métricas mediante las bibliotecas cliente Prometheus y un contenedor de adaptador:

apiVersion: v1
kind: Pod
metadata:
  name: custom-metric-prometheus-sd
spec:
  containers:
  - command:
    - /bin/sh
    - -c
    - ./prometheus-dummy-exporter --metric-name=foo --metric-value=40 --port=8080
    image: gcr.io/google-samples/prometheus-dummy-exporter:latest
    imagePullPolicy: Always
    name: prometheus-dummy-exporter
    resources:
      requests:
        cpu: 100m
  - name: prometheus-to-sd
    image: gcr.io/google-containers/prometheus-to-sd:v0.2.3
    command:
    - /monitor
    - --source=:http://localhost:8080
    - --stackdriver-prefix=custom.googleapis.com
    - --pod-id=$(POD_ID)
    - --namespace-id=$(POD_NAMESPACE)
    env:
    - name: POD_ID
      valueFrom:
        fieldRef:
          apiVersion: v1
          fieldPath: metadata.uid
    - name: POD_NAMESPACE
      valueFrom:
        fieldRef:
          fieldPath: metadata.namespace

Paso 3: crear el objeto HorizontalPodAutoscaler

Una vez que hayas exportado las métricas a Stackdriver, puedes implementar un HPA para escalar tu implementación según las métricas.

Los pasos siguientes dependen de cómo elegiste recopilar y exportar tus métricas.

Ajuste de escala automático basado en las métricas de todos los pods

El HPA usa las métricas para calcular un promedio y compararlo con el valor promedio objetivo.

En el ejemplo de exportación application-to-Stackdriver, una implementación contiene pods que exportan métricas. En el siguiente archivo de manifiesto se describe un objeto HorizontalPodAutoscaler que escala una implementación según el valor promedio objetivo para la métrica:

apiVersion: autoscaling/v2beta1
kind: HorizontalPodAutoscaler
metadata:
  name: custom-metric-sd
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1beta1
    kind: Deployment
    name: custom-metric-sd
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metricName: foo
      targetAverageValue: 20

Ajuste de escala automático basado en las métricas de un único pod

El HPA compara de forma directa el valor expuesto por un único pod con el valor objetivo especificado. Este pod no tiene que estar vinculado con el flujo de trabajo escalado.

En el ejemplo de exportación Prometheus-to-Stackdriver, un único pod exporta la métrica. En el siguiente archivo de manifiesto se describe una implementación y un HPA que escala una implementación según el valor objetivo para la métrica:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dummy-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      k8s-app: dummy-deployment
  template:
    metadata:
      labels:
        k8s-app: dummy-deployment
    spec:
      containers:
      - name: long
        image: busybox
        command: ["/bin/sh",  "-c", "sleep 180000000"]
---
apiVersion: autoscaling/v2beta1
kind: HorizontalPodAutoscaler
metadata:
  name: dummy-deployment-hpa
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1beta1
    kind: Deployment
    name: dummy-deployment
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Object
    object:
      target:
        kind: Pod
        name: custom-metric-prometheus-sd
      metricName: foo
      targetValue: 20

Limpieza

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud Platform por los recursos que usaste en este instructivo:

Borra tu clúster de GKE mediante la ejecución del siguiente comando:

gcloud container clusters delete [CLUSTER_NAME]

Solución de problemas

Si tienes problemas con este instructivo, realiza los siguientes pasos de depuración:

  1. Ejecuta kubectl api-versions y verifica que la API custom.metrics.k8s.io/v1beta1 esté registrada. Si no ves esta API en la lista, asegúrate de que el Adaptador de métricas personalizadas (implementado en el Paso 1) se esté ejecutando en el clúster.
  2. Visita el Explorador de métricas y verifica que tu métrica personalizada se esté exportando a Stackdriver. Busca las métricas que comienzan con custom.googleapis.com/[NAME]. Si no ves tu métrica en la lista:

    • Asegúrate de que la implementación del exportador (implementada en el Paso 2) se esté ejecutando.
    • Si personalizaste la cuenta de servicio de tus nodos con --service-account, asegúrate de que tenga la función IAM del Escritor de métricas de supervisión(roles/monitoring.metricWriter).
    • Si personalizaste el alcance de tus nodos con --scopes, asegúrate de que tengan el alcance monitoring.
  3. Ejecuta kubectl describe hpa [DEPLOYMENT_NAME] y verifica que el HPA esté leyendo tu métrica personalizada. Si observas errores:

    • Asegúrate de que la implementación escalada (implementada en el Paso 2) se esté ejecutando.
    • Si personalizaste la cuenta de servicio con tus nodos con --service-account, asegúrate de que tenga la función IAM del Lector de supervisión (roles/monitoring.viewer).

Qué sigue

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Instructivos de Kubernetes Engine