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 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 la plataforma 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 puede satisfacer las necesidades de tu empresa.

En este instructivo, aprenderás a crear un solo clúster de GKE y a implementar una aplicación de muestra basada en microservicios 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.

  • Implementa 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 e implementar la aplicación de ejemplo Cymbal Bank para esta serie de instructivos significa que se generan cargos por clúster para GKE en Google Cloud, como se indica en nuestra página de precios hasta que inhabilites GKE 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

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.

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 los pasos que se indican a continuación 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.

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

  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.

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

  5. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

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 scalable-apps, pero tu ID del proyecto puede ser scalable-apps.

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/

Crea un clúster

Una vez que hayas completado todos los pasos de requisitos previos de las secciones anteriores, puedes comenzar a crear un clúster de GKE 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.

  • 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

    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 scalable-apps, pero tu ID del proyecto puede ser scalable-apps.
    • 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 ni la plataforma de bases de datos para completar la serie de instructivos. Cymbal Bank es solo una aplicación de ejemplo para mostrar cómo GKE puede satisfacer las necesidades de tu empresa.

Cuando usas Cymbal Bank como parte de este conjunto de instructivos, se implementan los siguientes servicios 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.

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 los Pods, esta vista recopilada de los registros de tu clúster puede ayudar a depurar problemas rápidamente con la consola de Google Cloud.

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

  4. Selecciona la pestaña Errores de la 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 Entrada 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. 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?

En el siguiente instructivo, aprenderás a supervisar tus cargas de trabajo en GKE con Google Cloud Managed Service para Prometheus y Cloud Monitoring.