Ruta de aprendizaje: Aplicaciones escalables - Crea un clúster

Este conjunto de instructivos es para administradores y operadores de TI que deseen implementar, ejecutar y administrar entornos de aplicaciones modernos que se ejecutan en la edición Enterprise de Google Kubernetes Engine (GKE). A medida que avanzas con este conjunto de instructivos, aprenderás a configurar la supervisión y las alertas, escalar cargas de trabajo y simular fallas, todo con la aplicación de microservicios de muestra de Cymbal Bank:

  1. Crea un clúster y, luego, implementa una aplicación de ejemplo (este instructivo)
  2. Supervisa con Google Cloud Managed Service para Prometheus
  3. Escala las cargas de trabajo
  4. Simula una falla

Descripción general y objetivos

Cymbal Bank usa Python y Java para ejecutar los diversos servicios y, además, incluye un backend de PostgreSQL. No necesitas experiencia con estos lenguajes o plataformas de bases de datos para completar la serie de instructivos, ya que Cymbal Bank es solo una aplicación de ejemplo para mostrar cómo GKE Enterprise puede satisfacer las necesidades de tu empresa.

En este instructivo, aprenderás a crear un único clúster de GKE y a implementar una aplicación basada en microservicios de muestra llamada Cymbal Bank en un clúster de GKE. Aprenderás a completar las siguientes tareas:

  • Crear un clúster de GKE que use Autopilot.

  • Implementar una aplicación de muestra basada en microservicios llamada Cymbal Bank.

  • Usa la consola de Google Cloud para explorar los recursos de GKE que usa la aplicación de ejemplo de Cymbal Bank.

Costos

Habilitar GKE Enterprise e implementar la aplicación de ejemplo Cymbal Bank para esta serie de instructivos significa que se generan cargos por clúster para GKE Enterprise en Google Cloud, como se indica en nuestra página de precios hasta que inhabilites GKE Enterprise o borres el proyecto.

También eres responsable de otros costos de Google Cloud generados mientras ejecutas la aplicación de ejemplo de Cymbal Bank, como los cargos por las VMs de Compute Engine y los balanceadores de cargas.

Antes de comenzar

Los primeros instructivos de esta serie usan principalmente la funcionalidad principal disponible para todos los usuarios de GKE, pero a medida que avanzas por los instructivos, usas más de las funciones adicionales disponibles solo a través del nivel empresarial.

En este primer instructivo de la serie, completa algunos pasos de configuración iniciales antes de comenzar. Solo debes completar los siguientes pasos una vez.

Configura la shell y las herramientas

En esta serie de instructivos, usarás las siguientes herramientas para implementar y administrar tu entorno:

  • gcloud CLI: crea y administra clústeres y flotas de GKE, junto con otros servicios de Google Cloud.
  • kubectl: Administra Kubernetes, el sistema de organización de clústeres que usa GKE Enterprise.

Para ejecutar los comandos de esta página, configura Google Cloud CLI y kubectl en uno de los siguientes entornos de desarrollo:

Cloud Shell

Para usar una terminal en línea con gcloud CLI ykubectl ya configurada, activa Cloud Shell.

En la parte inferior de esta página, se inicia una sesión de Cloud Shell y se muestra una instrucción de línea de comandos. La sesión puede tardar unos segundos en inicializarse.

Shell local

Para usar un entorno de desarrollo local, sigue estos pasos:

Configura tu proyecto

Sigue estos pasos para configurar un proyecto de Google Cloud, incluida la habilitación de la facturación y los servicios de GKE. Este es el proyecto en el que habilitarás GKE Enterprise.

Es posible que necesites un administrador de Google Cloud en tu organización que te otorgue acceso para crear o usar un proyecto y habilitar las API.

  1. En la consola de Google Cloud, ve a la página Google Kubernetes Engine:

    Ir a la página Google Kubernetes Engine

  2. Crea o selecciona un proyecto. Este es el proyecto en el que habilitas GKE Enterprise.

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

Después de habilitar GKE, habilita la edición Enterprise de Google Kubernetes Engine (GKE):

  1. En la consola de Google Cloud, ve a la página GKE Enterprise:

    Ir a la página GKE Enterprise

  2. Selecciona Más información sobre Google Kubernetes Engine (GKE) Enterprise Edition.

  3. Si cumples con los requisitos, puedes marcar la opción Comenzar tu prueba gratuita de 90 días.

  4. Selecciona Habilitar la edición empresarial de Google Kubernetes Engine (GKE) y, luego, Confirmar.

Asigna roles de IAM

Si eres el propietario del proyecto (por ejemplo, si tú lo creaste), ya tienes todos los permisos necesarios para completar estos instructivos. Si no eres el propietario, asegúrate de que tu cuenta de Google Cloud tenga las funciones de IAM necesarias en el proyecto seleccionado para este conjunto de instructivos. Una vez más, es posible que necesites un administrador de Google Cloud en tu organización que te ayude a otorgar las funciones necesarias.

Otorga roles a tu Cuenta de Google. Ejecuta el siguiente comando una vez para cada uno de los siguientes roles de IAM: roles/resourcemanager.projectIamAdmin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/iam.securityAdmin, roles/serviceusage.serviceUsageAdmin, roles/container.admin, roles/logging.logWriter, roles/gkehub.admin, roles/viewer, roles/monitoring.viewer 

$ gcloud projects add-iam-policy-binding PROJECT_ID --member="user:EMAIL_ADDRESS" --role=ROLE
  • Reemplaza PROJECT_ID con el ID del proyecto.
  • Reemplaza EMAIL_ADDRESS por tu dirección de correo electrónico.
  • Reemplaza ROLE por cada rol individual.

Clona la aplicación de ejemplo

Clona el repositorio de Git que incluye todos los manifiestos de muestra de Cymbal Bank:

  git clone https://github.com/GoogleCloudPlatform/bank-of-anthos
  cd bank-of-anthos/

Crear un clúster

GKE es un servicio administrado de Kubernetes que puedes usar para implementar y operar aplicaciones en contenedores. Un entorno de GKE consta de nodos, que son máquinas virtuales (VMs) de Compute Engine, que se agrupan para formar un clúster.

Los clústeres de GKE también se pueden agrupar en flotas: grupos lógicos de clústeres que se pueden administrar juntos. Muchas funciones de GKE Enterprise, incluidas las que usarás más adelante en esta serie de instructivos, se basan en flotas y los principios de similitud y confianza que suponen las flotas.

  • Crea un clúster de GKE que usarás en el resto de los instructivos de esta serie:

    gcloud container clusters create-auto scalable-apps \
  --project=PROJECT_ID \
  --region=REGION \
  --enable-fleet

    Reemplaza lo siguiente:

    • PROJECT_ID por el nombre del proyecto que creaste en la sección anterior
    • REGION por la región en la que deseas crear el clúster, como us-central1.

    Tarda unos minutos en crear el clúster y verificar que todo funcione correctamente.

En este conjunto de instructivos, usarás clústeres del modo Autopilot y algunos rangos de direcciones IP predeterminados cuando creas clústeres. Una implementación de producción de tus propias aplicaciones requiere una planificación más cuidadosa de direcciones IP. En el modo Autopilot, Google administra la configuración de tu clúster, incluido el escalamiento, la seguridad y otros parámetros de configuración ya establecidos. Los clústeres en modo Autopilot están optimizados para ejecutar la mayoría de las cargas de trabajo de producción y aprovisionar recursos de procesamiento según tus manifiestos de Kubernetes.

Implementa Cymbal Bank

Empaquetas tus apps (también llamadas cargas de trabajo) en contenedores. Implementas conjuntos de contenedores como Pods en tus nodos.

En esta serie de instructivos, implementarás una aplicación de muestra basada en microservicios llamada Cymbal Bank en uno o más clústeres de GKE. Cymbal Bank usa Python y Java para ejecutar los diversos servicios y, además, incluye un backend de PostgreSQL. No necesitas experiencia con estos lenguajes o plataformas de base de datos para completar la serie de instructivos. Cymbal Bank es solo una aplicación de ejemplo para mostrar cómo Google Kubernetes Engine (GKE) Enterprise Edition puede satisfacer las necesidades de tu empresa.

Cuando usas Cymbal Bank como parte de este conjunto de instructivos, los siguientes servicios se implementan en tu clúster de GKE:

Servicio Idioma Descripción
frontend Python Expone un servidor HTTP para entregar el sitio web. Contiene la página de acceso, la página de registro y la página principal.
ledger-writer Java Acepta y valida las transacciones entrantes antes de escribirlas en el registro.
balance-reader Java Proporciona una caché legible y eficiente de los saldos de usuario, como se lee desde ledger-db.
transaction-history Java Proporciona una caché legible y eficiente de las transacciones pasadas, como se lee desde ledger-db.
ledger-db PostgreSQL Lidera de todas las transacciones. Opción de prepropagar con transacciones para usuarios de demostración.
user-service Python Administra las cuentas de usuario y la autenticación. Firma JWT que otros servicios usan para la autenticación.
contacts Python Almacena una lista de otras cuentas asociadas con un usuario. Se utiliza para el menú desplegable en los formularios "Enviar pago" y "Depósito".
accounts-db PostgreSQL Base de datos para cuentas de usuario y datos asociados. Opción para prepropagar con los usuarios de demostración.
loadgenerator Python / Locust Envía solicitudes que imitan a los usuarios al frontend de forma continua. Crea cuentas nuevas de forma periódica y simula transacciones entre ellas.

Para implementar Cymbal Bank en tu clúster de GKE, completa los siguientes pasos:

  1. Cymbal Bank usa tokens web JSON (JWT) para controlar la autenticación de usuarios. Los JWT usan pares de claves asimétricas para firmar y verificar tokens. En Cymbal Bank, userservice crea y firma tokens con una clave privada RSA cuando un usuario accede, y los otros servicios usan la clave pública correspondiente para validar al usuario.

    Crea un JWT RS256 con 4,096 bits de intensidad:

    openssl genrsa -out jwtRS256.key 4096
openssl rsa -in jwtRS256.key -outform PEM -pubout -out jwtRS256.key.pub

    Si es necesario, descarga y, luego, instala las herramientas de OpenSSL en tu plataforma.

  2. Un Secret de Kubernetes puede almacenar datos sensibles, como claves o contraseñas. Las cargas de trabajo que se ejecutan en tu clúster pueden acceder al Secret para obtener los datos sensibles en lugar de codificarlos en la aplicación.

    Crea un Secret de Kubernetes a partir del archivo de claves que creaste en el paso anterior para que Cymbal Bank lo use con solicitudes de autenticación:

    kubectl create secret generic jwt-key --from-file=./jwtRS256.key --from-file=./jwtRS256.key.pub

  3. Implementa Cymbal Bank en tu clúster. Con el siguiente comando, se implementan todos los archivos de manifiesto en el directorio kubernetes-manifests. Cada archivo de manifiesto implementa y configura uno de los siguientes servicios:

    kubectl apply -f kubernetes-manifests/accounts-db.yaml
kubectl apply -f kubernetes-manifests/balance-reader.yaml
kubectl apply -f kubernetes-manifests/config.yaml
kubectl apply -f kubernetes-manifests/contacts.yaml
kubectl apply -f extras/postgres-hpa/kubernetes-manifests/frontend.yaml
kubectl apply -f kubernetes-manifests/ledger-db.yaml
kubectl apply -f kubernetes-manifests/ledger-writer.yaml
kubectl apply -f extras/postgres-hpa/loadgenerator.yaml
kubectl apply -f kubernetes-manifests/transaction-history.yaml
kubectl apply -f kubernetes-manifests/userservice.yaml

    Es posible que veas mensajes en el resultado de kubectl a medida que los manifiestos se aplican a tu clúster sobre los límites de Autopilot. Autopilot usa las solicitudes de recursos que especificas en la configuración de tu carga de trabajo para configurar los nodos que ejecutan tus cargas de trabajo. Autopilot aplica las solicitudes de recursos mínimas y máximas según la clase de procesamiento o la configuración de hardware que usan tus cargas de trabajo. Si no especificas solicitudes para algunos contenedores, Autopilot asigna valores predeterminados para permitir que esos contenedores se ejecuten de forma correcta.

    Revisa el siguiente manifiesto de muestra para el Service frontend:

    # Copyright 2024 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
#
#     https://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: v1
kind: Service
metadata:
  labels:
    application: bank-of-anthos
    environment: development
    team: frontend
    tier: web
  name: frontend
spec:
  ports:
    - name: http
      port: 80
      targetPort: 8080
  selector:
    app: frontend
    application: bank-of-anthos
    environment: development
    team: frontend
    tier: web
  type: LoadBalancer
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    application: bank-of-anthos
    environment: development
    team: frontend
    tier: web
  name: frontend
spec:
  selector:
    matchLabels:
      app: frontend
      application: bank-of-anthos
      environment: development
      team: frontend
      tier: web
  template:
    metadata:
      annotations:
        proxy.istio.io/config: '{ "holdApplicationUntilProxyStarts": true }'
      labels:
        app: frontend
        application: bank-of-anthos
        environment: development
        team: frontend
        tier: web
    spec:
      containers:
        - env:
            - name: VERSION
              value: v0.6.4
            - name: PORT
              value: "8080"
            - name: ENABLE_TRACING
              value: "true"
            - name: SCHEME
              value: http
            - name: LOG_LEVEL
              value: info
            - name: DEFAULT_USERNAME
              valueFrom:
                configMapKeyRef:
                  key: DEMO_LOGIN_USERNAME
                  name: demo-data-config
            - name: DEFAULT_PASSWORD
              valueFrom:
                configMapKeyRef:
                  key: DEMO_LOGIN_PASSWORD
                  name: demo-data-config
            - name: REGISTERED_OAUTH_CLIENT_ID
              valueFrom:
                configMapKeyRef:
                  key: DEMO_OAUTH_CLIENT_ID
                  name: oauth-config
                  optional: true
            - name: ALLOWED_OAUTH_REDIRECT_URI
              valueFrom:
                configMapKeyRef:
                  key: DEMO_OAUTH_REDIRECT_URI
                  name: oauth-config
                  optional: true
          envFrom:
            - configMapRef:
                name: environment-config
            - configMapRef:
                name: service-api-config
          image: us-central1-docker.pkg.dev/bank-of-anthos-ci/bank-of-anthos/frontend:v0.6.4@sha256:f25db63509515fb6caf98c8c76e906f3c2868e345767d12565ab3750e52963f0
          livenessProbe:
            httpGet:
              path: /ready
              port: 8080
            initialDelaySeconds: 60
            periodSeconds: 15
            timeoutSeconds: 30
          name: front
          readinessProbe:
            httpGet:
              path: /ready
              port: 8080
            initialDelaySeconds: 10
            periodSeconds: 5
            timeoutSeconds: 10
          resources:
            limits:
              cpu: 250m
              memory: 128Mi
            requests:
              cpu: 100m
              memory: 64Mi
          securityContext:
            allowPrivilegeEscalation: false
            capabilities:
              drop:
                - all
            privileged: false
            readOnlyRootFilesystem: true
          volumeMounts:
            - mountPath: /tmp
              name: tmp
            - mountPath: /tmp/.ssh
              name: publickey
              readOnly: true
      securityContext:
        fsGroup: 1000
        runAsGroup: 1000
        runAsNonRoot: true
        runAsUser: 1000
      serviceAccountName: bank-of-anthos
      terminationGracePeriodSeconds: 5
      volumes:
        - emptyDir: {}
          name: tmp
        - name: publickey
          secret:
            items:
              - key: jwtRS256.key.pub
                path: publickey
            secretName: jwt-key

    Este manifiesto para frontend las solicitudes de Service 100m de CPU y 64Mi, y establece límites de 250m de CPU y 128Mi por Pod.

    Cuando implementas una carga de trabajo en un clúster de Autopilot, GKE valida la configuración de la carga de trabajo con los valores mínimos y máximos permitidos para la clase de procesamiento seleccionada o la configuración de hardware (como las GPU). Si tus solicitudes son menores que el mínimo, Autopilot modifica automáticamente la configuración de tu carga de trabajo para mover tus solicitudes dentro del rango permitido. Estos mensajes indican que se asignan de forma automática los límites adecuados.

  4. Espera a que los Pods estén listos. Usa kubectl para verificar el estado de los Pods:

    kubectl get pods

    La columna STATUS cambia de Pending a ContainerCreating. Todos los pods tardan unos minutos en estar en un estado Running, como se muestra en el siguiente resultado de ejemplo:

    NAME                                  READY   STATUS    RESTARTS   AGE
accounts-db-6f589464bc-6r7b7          1/1     Running   0          99s
balancereader-797bf6d7c5-8xvp6        1/1     Running   0          99s
contacts-769c4fb556-25pg2             1/1     Running   0          98s
frontend-7c96b54f6b-zkdbz             1/1     Running   0          98s
ledger-db-5b78474d4f-p6xcb            1/1     Running   0          98s
ledgerwriter-84bf44b95d-65mqf         1/1     Running   0          97s
loadgenerator-559667b6ff-4zsvb        1/1     Running   0          97s
transactionhistory-5569754896-z94cn   1/1     Running   0          97s
userservice-78dc876bff-pdhtl          1/1     Running   0          96s

    Cuando todos los Pods estén en el estado Running, continúa con el siguiente paso.

  5. El servicio frontend expone un servidor HTTP para entregar el sitio web de Cymbal Bank, incluida la página de acceso, la página de registro y la página principal. Un objeto Ingress define reglas para enrutar el tráfico HTTP(S) a las aplicaciones que se ejecutan en un clúster mediante un balanceador de cargas de HTTP(S) de Google Cloud.

    Obtén la dirección IP externa del Ingress frontend:

    kubectl get ingress frontend | awk '{print $4}'

  6. En una ventana del navegador web, abre la dirección IP que se muestra en el resultado del comando kubectl get ingress para acceder a tu instancia de Cymbal Bank.

    Las credenciales predeterminadas se propagan automáticamente, de modo que puedas acceder a la app y explorar algunas de las transacciones y los saldos de muestra. No hay que realizar ninguna acción específica, excepto para confirmar que Cymbal Bank se ejecuta de forma correcta. Es posible que todos los objetos Service demoren uno o dos minutos en comunicarse de forma correcta y permitirte acceder.

Explora tu implementación

Después de crear un clúster de GKE y de implementar las cargas de trabajo, es posible que debas cambiar la configuración o revisar el rendimiento de la aplicación. En esta sección, aprenderás a usar la consola de Google Cloud para revisar los recursos que forman parte de tu clúster y la aplicación de ejemplo de Cymbal Bank.

Como se explicó cuando creaste tu clúster, las capacidades de GKE Enterprise se basan en la idea de la flota: una agrupación lógica de clústeres de Kubernetes que se pueden administrar juntos. La Descripción general de GKE Enterprise en la consola de Google Cloud te proporciona una vista de alto nivel de toda la flota. Cuando creaste el clúster de GKE, se registró de forma automática en la flota mediante el parámetro --enable-fleet.

Para ver la información de GKE Enterprise y la flota, ve a la página Descripción general en la consola de Google Cloud:

Ir a la descripción general de GKE Enterprise

En la página Descripción general, se muestra la siguiente información:

  • Cantidad de clústeres en tu flota y si están en buen estado.
  • El uso de recursos de tu flota, incluido el uso de CPU, memoria y disco, agregado por flota y por clúster.
  • Cualquier problema de seguridad identificado para tu flota, la cobertura de Policy Controller en toda la flota y el estado de sincronización de tus paquetes del Sincronizador de configuración. Agrega el Policy Controller y el Sincronizador de configuración a tu clúster en instructivos futuros de esta serie.

En la página Clústeres de GKE, se muestran todos los clústeres de tu proyecto. Los clústeres registrados en una flota tienen su flota enumerada en la columna Flota.

En las siguientes secciones, analizarás con más detalle los recursos de GKE de Cymbal Bank.

Clústeres

En este instructivo, creaste un clúster de GKE e implementaste las cargas de trabajo de Cymbal Bank.

  1. En la página de Google Kubernetes Engine de la consola de Google Cloud, ve a la página Clústeres.

    Ir a la página Clústeres

  2. Haz clic en el clúster scalable-apps recién implementado. En la página de detalles del clúster que se abre, puedes ver los detalles básicos del clúster junto con la configuración de red y de seguridad del clúster. También puedes ver qué características de GKE están habilitadas en este clúster en la sección Funciones.

Observabilidad

Puedes ver las métricas básicas sobre el estado y el rendimiento de tu clúster. En el siguiente instructivo de esta serie, habilitarás Google Cloud Managed Service para Prometheus a fin de obtener una supervisión y una observabilidad más detalladas.

  1. Selecciona tu clúster en la página Clústeres de Google Kubernetes Engine de la consola de Google Cloud y, luego, ve a la pestaña Observabilidad.

  2. Examina algunos de los gráficos de métricas para elementos como CPU y Memoria. Esta vista te permite supervisar el rendimiento de las diferentes partes de las cargas de trabajo de tu clúster sin necesidad de implementar capacidades de supervisión adicionales.

  3. Para ver los registros transmitidos desde el clúster, selecciona la pestaña Registros. Puedes filtrar por Gravedad de registros o crear tus propios filtros para ver espacios de nombres, Services o Pods específicos. Al igual que con las advertencias y los eventos de Pods, esta vista recopilada de los registros de tu clúster puede ayudar a depurar problemas con rapidez mediante la consola de Google Cloud.

    Es normal ver entradas de registro, ya que Cymbal Bank se implementa por primera vez cuando algunos servicios aún no pueden comunicarse.

  4. Selecciona la pestaña Errores de app. A medida que se ejecutan las cargas de trabajo, puedes ver las advertencias y los eventos recopilados en la consola de Google Cloud. Este enfoque puede ayudar a depurar problemas sin tener que conectarse al clúster, los nodos o los pods de forma individual.

    Una vez más, es normal ver eventos registrados a medida que Cymbal Bank se implementa por primera vez cuando algunos servicios aún no pueden comunicarse.

Cargas de trabajo

La página de GKE de la consola de Google Cloud tiene una sección Cargas de trabajo que muestra una vista agregada de las cargas de trabajo que se ejecutan en todos tus clústeres de GKE.

  1. En la página de Google Kubernetes Engine de la consola de Google Cloud, ve a la página Cargas de trabajo.

    Ir a la página Cargas de trabajo

    En la pestaña Descripción general, se muestra una lista de cargas de trabajo y espacios de nombres del clúster de GKE. Puedes filtrar por espacios de nombres para ver qué cargas de trabajo se ejecutan en cada espacio de nombres.

Ingress y Service

En la vista Ingress y Service, se muestran los recursos Ingress y Service del proyecto. Un Service expone un conjunto de pods como un servicio de red con un extremo, mientras que un Ingress administra el acceso externo a los servicios en un clúster.

  1. En la página de Google Kubernetes Engine de la consola de Google Cloud, ve a la página Puertas de enlace, Ingress y servicios.

    Dirígete a la página Gateways, Ingress y Services

  2. Para encontrar la entrada de Cymbal Bank, haz clic en la pestaña “Ingress” y busca la entrada con el nombre frontend. Un objeto Ingress administra el tráfico entrante para tu aplicación. Puedes ver información sobre el balanceador de cargas, los puertos y los extremos externos.

  3. Haz clic en la dirección IP para la entrada frontend, como 198.51.100.143:80. Esta dirección se abre en la interfaz web de Cymbal Bank.

Limpia

El conjunto de instructivos para Cymbal Bank está diseñado para completarse uno tras otro. A medida que avanzas en el conjunto de instructivos, adquieres habilidades nuevas y usas productos y servicios adicionales de Google Cloud.

Si deseas tomar un descanso antes de continuar con el siguiente instructivo y evitar que se generen cargos en tu cuenta de Google Cloud por los recursos que se usaron en este instructivo, borra el proyecto que creaste.

  1. En la consola de Google Cloud, ve a la página Administrar recursos.

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?

Aprende a supervisar tus cargas de trabajo en GKE Enterprise con Google Cloud Managed Service para Prometheus y Cloud Monitoring en el siguiente instructivo.