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

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 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 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:

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.