Ajuste de escala automático de los objetos Deployment con métricas de cargas de trabajo de GKE

En este instructivo, se muestra cómo realizar el ajuste de escala automático de tus cargas de trabajo de Google Kubernetes Engine (GKE) según las métricas personalizadas que emite tu aplicación (por ejemplo, la cantidad de cuentas a las que se accedió de forma activa o la cantidad de solicitudes de HTTP).

Usa la canalización de métricas de cargas de trabajo de GKE para recopilar las métricas que emite tu aplicación, enviarlas a Cloud Monitoring y, luego, usarlas para impulsar Horizontal Pod Autoscaler (HPA).

Objetivos

En este instructivo, se abarcan las siguientes tareas:

  1. Cómo implementar una aplicación de ejemplo que emita métricas de estilo Prometheus.
  2. Cómo implementar un recurso PodMonitor para recopilar las métricas de la aplicación y publicarlas en Cloud Monitoring.
  3. Cómo implementar el adaptador de métricas personalizadas
  4. Cómo consultar las métricas de cargas de trabajo con la API de métricas personalizadas de Kubernetes
  5. Cómo implementar un recurso de Horizontal Pod Autoscaler (HPA) para escalar tu aplicación según las métricas de cargas de trabajo recopiladas de tu aplicación.

Antes de comenzar

Sigue los pasos que se indican a continuación para habilitar la API de Kubernetes Engine:
  1. Consulta la página de Kubernetes Engine en Google Cloud Console.
  2. Crea o selecciona un proyecto.
  3. Espera a que la API y los servicios relacionados se habiliten. Esto puede tomar varios minutos.
  4. Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Descubre cómo confirmar que tienes habilitada la facturación en un proyecto.

Puedes seguir este instructivo mediante Cloud Shell, que viene preinstalado con las herramientas de línea de comandos de gcloud y kubectl, que se usan en este instructivo. Si usas Cloud Shell, no necesitas instalar estas herramientas de línea de comandos en tu estación de trabajo.

Para usar Cloud Shell, sigue estos pasos:

  1. Ve a Google Cloud Console.
  2. Haz clic en el botón Activar Cloud Shell Botón de activar Shell que se encuentra en la parte superior de la ventana de Cloud Console.

    Se abrirá una sesión de Cloud Shell en un marco nuevo en la parte inferior de Cloud Console, que mostrará una ventana de la línea de comandos.

    Sesión de Cloud Shell

Configura tu entorno

  1. Para crear un clúster nuevo con las métricas de cargas de trabajo habilitadas, usa el siguiente comando:

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

    Reemplaza lo siguiente:

    • CLUSTER_NAME: Es el nombre de tu clúster.
    • PROJECT_ID: El ID del proyecto de Google Cloud.
    • ZONE: elige la zona más cercana a ti.

    Esta acción requiere el permiso container.clusters.create en el proyecto.

  2. Para habilitar las métricas de cargas de trabajo en un clúster de Standard o Autopilot existente, modifica el clúster con el siguiente comando:

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

Implementa una aplicación de ejemplo que emita métricas de estilo Prometheus

Descarga el repositorio que contiene el código de la aplicación para este instructivo:

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

La aplicación de ejemplo para este instructivo genera dos métricas y las expone a través de un extremo integrado de Prometheus en localhost:1234/metrics:

  • example_requests_total: es un contador de solicitudes que genera el sondeo de la aplicación
  • example_random_numbers: es un histograma de números generados de forma aleatoria

El repositorio contiene un manifiesto de Kubernetes para implementar la aplicación en tu clúster:

# 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"
Implementa la aplicación en el clúster:

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

Después de esperar un momento a que se implemente la aplicación, todos los Pods alcanzan el estado Ready:

  kubectl -n gke-workload-metrics get pods

Resultado:

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

Implementa un recurso PodMonitor para recopilar las métricas de la aplicación de ejemplo

Para recopilar las métricas emitidas desde la aplicación de ejemplo, debes crear un recurso personalizado PodMonitor.

El repositorio contiene un manifiesto de Kubernetes para implementar PodMonitor en el clúster:

# 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
Implementa PodMonitor en el clúster:

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

Implementa el adaptador de métricas personalizadas

El adaptador de métricas personalizadas permite que tu clúster envíe y reciba métricas mediante Monitoring.

  1. Otórgale al usuario la capacidad de crear las funciones de autorización requeridas:

    kubectl create clusterrolebinding cluster-admin-binding \
        --clusterrole cluster-admin --user "$(gcloud config get-value account)"
    
  2. Si usas un clúster de Autopilot o un clúster con Workload Identity habilitado, haz lo siguiente:

    1. Crea un espacio de nombres para el adaptador:

      kubectl create namespace custom-metrics
      
    2. Crea una cuenta de servicio de Kubernetes para el adaptador:

      kubectl create serviceaccount --namespace custom-metrics \
      custom-metrics-stackdriver-adapter
      
    3. Crea una cuenta de servicio de Google con permiso para ver las métricas de 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"
      

      Reemplaza lo siguiente:

      • PROJECT_ID: Es el ID de tu proyecto de Google Cloud.
      • GSA_NAME: es el nombre de tu cuenta de servicio de Google.
    4. Para permitir que la cuenta de servicio de Kubernetes actúe en nombre de la cuenta de servicio de Google, crea una vinculación de política de 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. Anota la cuenta de servicio de Kubernetes para indicar la vinculación:

      kubectl annotate serviceaccount \
        --namespace custom-metrics custom-metrics-stackdriver-adapter \
        iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID.iam.gserviceaccount.com
      
  3. Implementa el adaptador del modelo de recursos nuevo en el clúster:

    kubectl apply -f manifests/adapter_new_resource_model.yaml
    
  4. Verifica que el adaptador de métricas personalizadas esté implementado y en el estado Ready:

    kubectl -n custom-metrics get pods
    

    Resultado:

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

Consulta las métricas de cargas de trabajo mediante la API de métricas personalizadas de Kubernetes

Puedes usar la API de métricas personalizadas de Kubernetes a fin de verificar que las métricas de tus cargas de trabajo sean visibles para GKE.

Las métricas de cargas de trabajo de GKE se exportan a Monitoring con el prefijo workload.googleapis.com. El servidor de la API de métricas personalizadas de Kubernetes no admite el carácter / en las rutas de acceso de las métricas, por lo que debes reemplazar todos los caracteres / por |. Por lo tanto, debes usar workload.googleapis.com|example_request_total para el nombre de la métrica.

Después de esperar unos minutos para que las métricas de las aplicaciones se envíen a Monitoring, ejecuta el siguiente comando a fin de consultar la 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"

Resultado:

  {"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"}]}

Implementa un objeto HorizontalPodAutoscaler

Una vez que veas la métrica workload.googleapis.com|example_requests_total en la carga útil de respuesta de la API de métricas personalizadas en el paso anterior, puedes implementar Horizontal Pod Autoscaler (HPA) para cambiar el tamaño de tu implementación según esa métrica.

El repositorio contiene un manifiesto de Kubernetes para implementar HPA en tu clúster:

# 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
Este HPA establece las réplicas mínimas de Pod en 1 y máximas en 5. Escala tu implementación para garantizar que el valor promedio de workload.googleapis.com|example_request_total en todos los Pods sea 1.

Implementa HorizontalPodAutoscaler en el clúster:

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

Observa el escalamiento vertical de HorizontalPodAutoscaler

Puedes verificar la cantidad de réplicas en tu implementación de forma periódica y mirar cómo se escala a 5 réplicas mediante la ejecución del siguiente comando:

  kubectl -n gke-workload-metrics get pods

Resultado:

  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

También puedes inspeccionar el estado y la actividad de Horizontal Pod Autoscaler mediante la ejecución del siguiente comando:

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

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

¿Qué sigue?