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
  5. Centraliza la administración de cambios

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 todos los siguientes pasos de configuración para “comenzar” antes de comenzar. Solo necesitas completar los siguientes pasos “Antes de comenzar” 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 de Google Kubernetes Engine

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

  3. Si se te solicita, habilita la API de GKE Enterprise.

  4. Espera a que la API y los servicios relacionados se habiliten. Esto puede tomar varios minutos.

  5. Make sure that billing is enabled for your Google Cloud project.

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 GKE Enterprise y, luego, Confirmar.

Asigna roles de IAM

Si eres el propietario del proyecto (por ejemplo, si lo creaste tú mismo), 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 para 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 los roles necesarios.

En los siguientes comandos, reemplaza PROJECT_ID por el ID generado de forma automática del proyecto que creaste o seleccionaste en la sección anterior. El ID del proyecto a menudo es diferente del nombre del proyecto. Por ejemplo, tu proyecto puede ser sscaleable-apps, pero tu ID del proyecto puede ser scalable-apps-567123.

Grant roles to your user account. Run the following command once for each of the following IAM roles: 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_IDENTIFIER" --role=ROLE
  • Replace PROJECT_ID with your project ID.
  • Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.

  • Replace ROLE with each individual role.

Clona la aplicación de ejemplo

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

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

Crear un clúster

Una vez que hayas completado todos los pasos de los requisitos previos en las secciones anteriores, puedes comenzar a crear un clúster de Google Kubernetes Engine y, luego, implementar una aplicación de muestra.

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 ID generado de forma automática del proyecto que creaste en la sección anterior. El ID del proyecto a menudo es diferente del nombre del proyecto. Por ejemplo, tu proyecto puede ser sscaleable-apps, pero tu ID del proyecto puede ser scalable-apps-567123.
    • 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 en modo Autopilot y algunos rangos de direcciones IP predeterminados cuando crees clústeres. Una implementación de producción de tus propias aplicaciones requiere una planificación más cuidadosa de las 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 ejemplo 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 una página de acceso, una página de registro y una 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 Registros de todas las transacciones. Opción para prepropagar transacciones para usuarios de demostración.
user-service Python Administra las cuentas de usuario y la autenticación. Firma los JWT que usan otros servicios para la autenticación.
contacts Python Almacena una lista de otras cuentas asociadas con un usuario. Se usa para el menú desplegable en los formularios "Enviar pago" y "Depositar".
accounts-db PostgreSQL Base de datos de cuentas de usuario y datos asociados. Opción para prepropagar con usuarios de demostraciones.
loadgenerator Python/Locust Envía solicitudes de forma continua que imitan a los usuarios al frontend. 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 los 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 una resistencia de 4,096 bits:

    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 para tu plataforma.

  2. Un secreto 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 como parte de 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. Implementar 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 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 se aplican los manifiestos 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.5
                - 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.5@sha256:d72050f70d12383e4434ad04d189b681dc625f696087ddf0b5df641645c9dafa
              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 están asignando automáticamente 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. Toma unos minutos que todos los Pods estén en 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. Una vez más, todos los Pods tardan unos minutos en estar en el estado Running. Es normal que algunos de los Pods informen un estado READY de 0/1 hasta que Cymbal Bank esté listo para entregar tráfico de forma correcta.

  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 de 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 e implementar cargas de trabajo, es posible que necesites cambiar la configuración o revisar el rendimiento de tu 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 presentó 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. Por ejemplo, es posible que tengas varios clústeres que usan diferentes equipos, que contengan réplicas de aplicaciones en diferentes regiones para fines de latencia y confiabilidad, o que segmenten cargas de trabajo con diferentes requisitos de seguridad. Una flota ayuda a organizar grupos de estos clústeres relacionados.

La Descripción general de GKE Enterprise en la consola de Google Cloud te proporciona una vista de alto nivel de toda tu flota. Cuando creaste tu clúster de GKE, se registró automáticamente en la flota con 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 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 las configuraciones de red y seguridad del clúster. También puedes ver qué funciones de GKE están habilitadas en este clúster en la sección Funciones.

Observabilidad

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

  1. Selecciona tu clúster de 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, como CPU y Memoria. Esta vista te permite supervisar el rendimiento de las diferentes partes de las cargas de trabajo del clúster sin necesidad de implementar capacidades de supervisión adicionales.

  3. Para ver los registros que se transmiten desde tu clúster, selecciona la pestaña Registros. Puedes filtrar por Gravedad de los registros o crear tus propios filtros para ver espacios de nombres, servicios 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 tus 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 que los eventos registrados cuando 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 las cargas de trabajo y los espacios de nombres del clúster de GKE. Puedes filtrar por espacios de nombres para ver qué cargas de trabajo se ejecutan en cada uno.

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 abrirá la interfaz web de Cymbal Bank.

Realiza una limpieza

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. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

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