Esta página se ha traducido con Cloud Translation API.

Ruta de aprendizaje: aplicaciones escalables - Crear un clúster

Autopilot

Este conjunto de tutoriales está dirigido a administradores de TI y operadores que quieran desplegar, ejecutar y gestionar entornos de aplicaciones modernas que se ejecuten en Google Kubernetes Engine (GKE). A lo largo de esta serie de tutoriales, aprenderás a configurar la monitorización y las alertas, a escalar cargas de trabajo y a simular errores. Todo ello con la aplicación de microservicios de ejemplo Cymbal Bank:

Crear un clúster y desplegar una aplicación de ejemplo (este tutorial)
Monitorizar con Google Cloud Managed Service para Prometheus
Escalar cargas de trabajo
Simular un fallo
Centralizar la gestión de cambios

Descripción general y objetivos

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

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

Crea un clúster de GKE que use Autopilot.
Despliega una aplicación de muestra basada en microservicios llamada Cymbal Bank.
Usa la Google Cloud consola para explorar los recursos de GKE que usa la aplicación de ejemplo de Cymbal Bank.

Costes

Si habilitas GKE y despliegas la aplicación de ejemplo Cymbal Bank para esta serie de tutoriales, se te aplicarán cargos por clúster de GKE en Google Cloud , tal como se indica en nuestra página de precios, hasta que inhabilites GKE o elimines el proyecto.

También eres responsable de otros Google Cloud costes que se generen al ejecutar la aplicación de ejemplo de Cymbal Bank, como los cargos de las máquinas virtuales de Compute Engine y los balanceadores de carga.

Antes de empezar

En este primer tutorial de la serie, completa todos los pasos de configuración de la sección "Empezar" antes de empezar. Solo tienes que completar los pasos de la sección "Antes de empezar" una vez.

Configurar el shell y las herramientas

En esta serie de tutoriales, usarás las siguientes herramientas para desplegar y gestionar tu entorno:

CLI de gcloud: crea y gestiona clústeres y flotas de GKE, así como otros Google Cloud servicios.
kubectl: gestiona Kubernetes, el sistema de orquestación de clústeres que usa GKE.

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

Cloud Shell

Para usar un terminal online con la CLI de gcloud y kubectl ya configurados, activa Cloud Shell:

En la parte inferior de esta página, se inicia una sesión de Cloud Shell y se muestra un mensaje de la 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:

Instala gcloud CLI.
Inicializa gcloud CLI.
Instala kubectlgcloud CLI:
```
gcloud components install kubectl
```

Configurar el proyecto

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

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

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

Ir a la página de Google Kubernetes Engine
Crea o selecciona un proyecto. Este es el proyecto en el que habilitarás GKE.
Si se te solicita, habilita la API de GKE.
Espera a que la API y los servicios relacionados se habiliten. Este proceso puede tardar varios minutos.
Verify that billing is enabled for your Google Cloud project.

Otorgar roles de gestión de identidades y accesos

Si eres el propietario del proyecto (por ejemplo, si lo has creado tú), ya tienes todos los permisos necesarios para completar estos tutoriales. Si no eres el propietario, asegúrate de que tu cuenta de Google Cloud tenga los roles de gestión de identidades y accesos necesarios en el proyecto seleccionado para este conjunto de tutoriales. De nuevo, es posible que necesites unGoogle Cloud administrador de tu organización para que te ayude a conceder los roles necesarios.

En los siguientes comandos, sustituye PROJECT_ID por el ID generado automáticamente del proyecto que has creado o seleccionado en la sección anterior. El ID de proyecto suele ser diferente del nombre del proyecto. Por ejemplo, tu proyecto podría llamarse scalable-apps, pero su ID podría 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:USER_IDENTIFIER" --role=ROLE

Replace the following:

PROJECT_ID: your project ID.
USER_IDENTIFIER: the identifier for your user account—for example, myemail@example.com.
ROLE: the IAM role that you grant to your user account.

Clonar 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

Una vez que hayas completado todos los pasos de los requisitos previos de las secciones anteriores, puedes empezar a crear un clúster de GKE e implementar una aplicación de ejemplo.

GKE es un servicio de Kubernetes gestionado que puedes usar para desplegar 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 tutoriales de esta serie:
```
gcloud container clusters create-auto scalable-apps \
  --project=PROJECT_ID \
  --location=CONTROL_PLANE_LOCATION
```
Haz los cambios siguientes:
- PROJECT_ID por el ID generado automáticamente del proyecto que has creado en la sección anterior. El ID del proyecto suele ser diferente del nombre del proyecto. Por ejemplo, tu proyecto podría llamarse scalable-apps, pero su ID podría ser scalable-apps-567123.
- CONTROL_PLANE_LOCATION: la región de Compute Engine del plano de control de tu clúster. Proporciona una región, como us-central1.
Se tarda unos minutos en crear el clúster y verificar que todo funciona correctamente.

En este conjunto de tutoriales, se usan clústeres en modo Autopilot y algunos intervalos de direcciones IP predeterminados al crear clústeres. Para implementar en producción tus propias aplicaciones, debes planificar las direcciones IP con más cuidado. En el modo Autopilot, Google gestiona la configuración de tu clúster, incluidos el escalado automático, la seguridad y otros ajustes preconfigurados. 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 computación en función de tus manifiestos de Kubernetes.

Implementar Cymbal Bank

Empaquetas aplicaciones (también llamadas cargas de trabajo) en contenedores. Despliega conjuntos de contenedores como pods en tus nodos.

En esta serie de tutoriales, desplegarás una aplicación de ejemplo basada en microservicios llamada Cymbal Bank en uno o varios clústeres de GKE. Cymbal Bank usa Python y Java para ejecutar los distintos servicios, e incluye un backend de PostgreSQL. No es necesario que tengas experiencia con estos lenguajes o plataformas de bases de datos para completar la serie de tutoriales. Cymbal Bank es solo una aplicación de ejemplo para mostrar cómo puede GKE satisfacer las necesidades de tu empresa.

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

Servicio	Idioma	Descripción
`frontend`	Python	Expone un servidor HTTP para servir el sitio web. Contiene la página de inicio de sesión, la página de registro y la página principal.
`ledger-writer`	Java	Acepta y valida las transacciones entrantes antes de escribirlas en el libro de contabilidad.
`balance-reader`	Java	Proporciona una caché legible y eficiente de los saldos de los usuarios, tal como se lee en `ledger-db`.
`transaction-history`	Java	Proporciona una caché legible y eficiente de las transacciones anteriores, tal como se lee en `ledger-db`.
`ledger-db`	PostgreSQL	Registro de todas las transacciones. Opción para rellenar previamente con transacciones para usuarios de demostración.
`user-service`	Python	Gestiona las cuentas de usuario y la autenticación. Firma los JWTs que usan otros servicios para la autenticación.
`contacts`	Python	Almacena la lista de otras cuentas asociadas a un usuario. Se usa en los desplegables de los formularios "Enviar pago" y "Depósito".
`accounts-db`	PostgreSQL	Base de datos de cuentas de usuario y datos asociados. Opción para rellenar previamente con usuarios de demostración.
`loadgenerator`	Python/Locust	Envía continuamente solicitudes imitando a los usuarios al frontend. Crea periódicamente cuentas nuevas y simula transacciones entre ellas.

Para desplegar Cymbal Bank en tu clúster de GKE, sigue estos pasos:

Cymbal Bank usa tokens web JSON (JWTs) para gestionar la autenticación de usuarios. Los JWTs 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 inicia sesión, y los demás servicios utilizan la clave pública correspondiente para validar al usuario.

Crea un JWT RS256 con una longitud de 4096 bits:
```
openssl genrsa -out jwtRS256.key 4096
openssl rsa -in jwtRS256.key -outform PEM -pubout -out jwtRS256.key.pub
```
Si es necesario, descarga e instala las herramientas de OpenSSL para tu plataforma.
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 secreto para obtener los datos sensibles en lugar de codificarlos de forma rígida en la aplicación.

Crea un secreto de Kubernetes a partir del archivo de claves que has creado en el paso anterior para que Cymbal Bank lo use con las solicitudes de autenticación:
```
kubectl create secret generic jwt-key --from-file=./jwtRS256.key --from-file=./jwtRS256.key.pub
```

Despliega Cymbal Bank en tu clúster. El siguiente comando implementa todos los archivos de manifiesto del directorio kubernetes-manifests. Cada archivo de manifiesto despliega 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 la salida 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 especifiques en la configuración de tu carga de trabajo para configurar los nodos que ejecutan tus cargas de trabajo. Autopilot aplica solicitudes de recursos mínimas y máximas en función de la clase de computación o de la configuración de hardware que usen tus cargas de trabajo. Si no especificas solicitudes para algunos contenedores, Autopilot les asignará valores predeterminados para que puedan ejecutarse correctamente.

Consulta el siguiente archivo de manifiesto de ejemplo para el servicio 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.7
            - 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.7@sha256:6d92f3ce81a389738baf236477c6795831a0802c7a007697d7121f10eab9a2cc
          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 el frontendservicio solicita 100m de CPU y 64Mi, y establece límites de 250m de CPU y 128Mi por pod.

Cuando despliegas 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 de la clase de computación o la configuración de hardware seleccionadas (como las GPUs). Si tus solicitudes son inferiores al mínimo, Autopilot modificará automáticamente la configuración de tu carga de trabajo para que tus solicitudes se ajusten al intervalo permitido. Estos mensajes indican que se están asignando automáticamente los límites adecuados.

Espera a que los pods estén listos. Usa kubectl para comprobar el estado de los pods:

kubectl get pods

La columna STATUS cambia de Pending a ContainerCreating. Los pods tardan unos minutos en alcanzar el estado Running, como se muestra en el siguiente ejemplo de salida:

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. De nuevo, tardarán unos minutos en que todos los pods tengan el estado Running. Es normal que algunos pods tengan el estado READY0/1 hasta que Cymbal Bank esté listo para servir el tráfico correctamente.

El servicio frontend expone un servidor HTTP para servir el sitio web de Cymbal Bank, incluidas las páginas de inicio y registro de sesión, así como la página principal. Un objeto Ingress define reglas para dirigir el tráfico HTTP o HTTPS a las aplicaciones que se ejecutan en un clúster mediante un Google Cloud balanceador de carga HTTP o HTTPS.

Obtén la dirección IP externa del frontendIngress:
```
kubectl get ingress frontend | awk '{print $4}'
```
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 rellenan automáticamente, por lo que puedes iniciar sesión en la aplicación y consultar algunas de las transacciones y los saldos de ejemplo. No tienes que hacer nada más que confirmar que Cymbal Bank se ejecuta correctamente. Puede que los servicios tarden un minuto o dos en comunicarse correctamente y permitirte iniciar sesión.

Analizar el despliegue

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

Clústeres

En este tutorial, has creado un clúster de GKE y has desplegado las cargas de trabajo de Cymbal Bank.

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

Ir a la página Clústeres
Haz clic en el clúster scalable-apps que acabas de desplegar. En la página de detalles del clúster que se abre, puedes ver información básica sobre el clúster, así como sus configuraciones de red y de seguridad. También puedes ver qué funciones de GKE están habilitadas en este clúster en la sección Funciones.

Observabilidad

Puede ver métricas básicas sobre el estado y el rendimiento de su clúster. En el siguiente tutorial de esta serie, habilitarás Google Cloud Managed Service para Prometheus para disfrutar de una monitorización y una observabilidad más detalladas.

Selecciona tu clúster en la página Clústeres de Google Kubernetes Engine de la consola deGoogle Cloud y, a continuación, ve a la pestaña Observabilidad.
Consulta algunos de los gráficos de métricas, como CPU y Memoria. Esta vista te permite monitorizar el rendimiento de las diferentes partes de las cargas de trabajo de tu clúster sin necesidad de implementar funciones de monitorización adicionales.
Para ver los registros transmitidos 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 combinada de los registros de tu clúster puede ayudarte a depurar problemas rápidamente mediante la Google Cloud consola.

Es normal ver entradas de registro cuando se implementa Cymbal Bank por primera vez, ya que algunos servicios aún no pueden comunicarse.
Selecciona la pestaña Errores de la aplicación. Mientras se ejecutan tus cargas de trabajo, puedes ver las advertencias y los eventos recopilados en la Google Cloud consola. Este enfoque puede ayudarte a depurar problemas sin tener que conectarte al clúster, los nodos o los pods individualmente.

De nuevo, es normal ver eventos registrados cuando se implementa Cymbal Bank por primera vez, ya que algunos servicios aún no pueden comunicarse.

Cargas de trabajo

La página de GKE de la consola 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. Google Cloud

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

Ve a la página Cargas de trabajo.

En la pestaña Resumen 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.

Services e Ingresses

La vista Servicios e Ingress muestra los recursos Service e Ingress del proyecto. Un servicio expone un conjunto de pods como un servicio de red con un endpoint, mientras que un Ingress gestiona el acceso externo a los servicios de un clúster.

En la página Google Kubernetes Engine de la Google Cloud consola, ve a la página Gateways, Services & Ingress (Gateways, servicios y entrada).

Ir a la página Gateways, Services & Ingress
Para encontrar el ingreso de Cymbal Bank, haz clic en la pestaña Ingreso y busca el ingreso con el nombre frontend. Un recurso Ingress gestiona el tráfico entrante de tu aplicación. Puede ver información sobre el balanceador de carga, los puertos y los endpoints externos.
Haz clic en la dirección IP de la entrada frontend, como 198.51.100.143:80. Esta dirección abre la interfaz web de Cymbal Bank.

Limpieza

El conjunto de tutoriales de Cymbal Bank está diseñado para completarse uno después del otro. A medida que avances en el conjunto de tutoriales, adquirirás nuevas habilidades y usarás más Google Cloud productos y servicios.

Si quieres hacer un descanso antes de pasar al siguiente tutorial y evitar que se te cobren los recursos utilizados en este tutorial en tu cuenta, elimina el proyecto que has creado. Google Cloud

Precaución: Eliminar un proyecto tiene los siguientes efectos:

Se elimina todo el contenido del proyecto. Si has usado un proyecto que ya existía para las tareas de este documento, cuando lo elimines, también se eliminará cualquier otro trabajo que hayas realizado en él.
Se pierden los IDs de proyecto personalizados. Cuando creaste este proyecto, es posible que hayas creado un ID de proyecto personalizado que quieras usar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, elimina los recursos seleccionados dentro del proyecto en lugar de eliminar todo el proyecto.

Si tienes previsto consultar varias arquitecturas, tutoriales o guías de inicio rápido, reutilizar los proyectos puede ayudarte a no superar los límites de cuota de proyectos.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Siguientes pasos

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