Ruta de aprendizaje: Transforma un monolito en una app de GKE: Implementa la app en un clúster de GKE

Estándar

Este es el quinto y último instructivo de una ruta de aprendizaje que te enseña a modularizar y organizar en contenedores una app monolítica.

La ruta de aprendizaje consta de los siguientes instructivos:

1. Descripción general
2. Comprende la aplicación monolítica
3. Modulariza la aplicación monolítica
4. Prepara la app modular para la organización en contenedores
5. Crea un contenedor para la app modular
6. Implementa la app en un clúster de GKE (este instructivo)

En el instructivo anterior, Crea un contenedor para la app modular, preparaste la app modular de Cymbal Books para la implementación. Colocaste en contenedores los módulos de la app, probaste los contenedores resultantes y enviaste las imágenes de contenedor a Artifact Registry.

En este instructivo, implementarás la app alojada en contenedores en un clúster de Google Kubernetes Engine. Con este paso, se completa la transformación de la app de Cymbal Books en un sistema modular y escalable que se ejecuta en un clúster de Kubernetes.

Costos

Si sigues los pasos de este instructivo, se aplicarán cargos a tu cuenta de Google Cloud. Los costos comienzan cuando habilitas GKE y, luego, implementas la app de ejemplo de Cymbal Books. Estos costos incluyen cargos por clúster para GKE, como se describe en la página de precios, y cargos por ejecutar VMs de Compute Engine.

Para evitar cargos innecesarios, asegúrate de inhabilitar GKE o borrar el proyecto una vez que hayas completado este instructivo.

Antes de comenzar

Antes de comenzar con este instructivo, asegúrate de haber completado los instructivos anteriores de la serie. Para obtener una descripción general de toda la serie y vínculos a instructivos específicos, consulta Ruta de aprendizaje: Transforma un monolito en una app de GKE: Descripción general.

En particular, debes haber realizado los pasos del instructivo anterior, Crea un contenedor para la app modular.

Configura el clúster de GKE

Antes de implementar la app modular de Cymbal Books, primero debes crear un clúster de GKE. Este clúster proporciona la infraestructura en la que se ejecutarán los contenedores de tu app.

En este instructivo, usarás la CLI de gcloud para crear el clúster. Como alternativa, puedes usar la consola deGoogle Cloud , que proporciona una interfaz gráfica de usuario (GUI) para crear y administrar recursos de Google Cloud, como clústeres de GKE.

Crea y verifica un clúster de GKE

Un clúster de GKE proporciona los recursos de procesamiento necesarios para ejecutar tus contenedores en Kubernetes. Sigue estos pasos para crear un clúster con gcloud CLI.

1. Ve a la consola deGoogle Cloud .

2. En la consola, haz clic en el botón Activar Cloud Shell:

   Se abrirá una sesión de Cloud Shell dentro de un marco en la parte inferior en la consola.

3. Configura tu proyecto predeterminado en Google Cloud CLI:

   gcloud config set project PROJECT_ID
   

   Reemplaza PROJECT_ID por el ID del proyecto que creaste o seleccionaste en la sección Selecciona o crea un proyecto de Google Cloud del instructivo anterior. Un ID del proyecto es una cadena única que diferencia tu proyecto de todos los demás proyectos en Google Cloud. Para ubicar el ID del proyecto, ve al selector de proyectos. En esa página, puedes ver los IDs de cada uno de tus proyectos de Google Cloud.

4. Crea un clúster de GKE:

   gcloud container clusters create CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION \
       --num-nodes=2
   

   Reemplaza lo siguiente:

   • CLUSTER_NAME: Es un nombre para tu clúster, como cymbal-cluster.

   • CONTROL_PLANE_LOCATION: La ubicación de Compute Engine del plano de control de tu clúster. Proporciona una región para los clústeres regionales o una zona para los clústeres zonales, como us-central1 o europe-west1-b.

5. Recupera las credenciales del clúster para que la CLI de kubectl pueda conectarse al clúster:

   gcloud container clusters get-credentials CLUSTER_NAME \
       --location=CONTROL_PLANE_LOCATION
   

   Este comando actualiza tu archivo de configuración de Kubernetes, que se almacena de forma predeterminada en ~/.kube/config. Este archivo de configuración contiene las credenciales que kubectl requiere para interactuar con tu clúster de GKE.

6. Verifica que kubectl esté conectado al clúster enumerando los nodos del clúster:

   kubectl get nodes
   

   Si la configuración se realiza de forma correcta, este comando muestra los nodos en tu clúster de GKE. Como creaste el clúster con --num-nodes=2, deberías ver información sobre dos nodos, similar a la siguiente:

   NAME                                         STATUS    ROLES    AGE    VERSION
   gke-nov18-default-pool-6a8f9caf-bryg   Ready     <none>   30s    v1.30.8-gke.1128000
   gke-nov18-default-pool-6a8f9caf-ut0i   Ready     <none>   30s    v1.30.8-gke.1128000
   

   En este ejemplo, ambos nodos están en el estado Ready. Este estado significa que el clúster de GKE está listo para alojar tus cargas de trabajo alojadas en contenedores.

Implementa la app

Ahora que creaste un clúster de GKE, puedes implementar la app de Cymbal Books en él. Para implementar una app en un clúster, debes aplicar el manifiesto de Kubernetes al clúster.

Aplica el manifiesto de Kubernetes

En Cloud Shell, implementa la app en el clúster de GKE ejecutando los siguientes comandos:

1. Navega al directorio raíz de la aplicación alojada en contenedores:

   cd kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/
   

2. Aplica el manifiesto de Kubernetes:

   kubectl apply -f kubernetes_manifest.yaml
   

El comando anterior le indica a Kubernetes que cree los recursos especificados en el archivo kubernetes-manifest.yaml. Estos recursos incluyen Services, un Deployment y Pods.

Primero, encontraste los objetos Service en la sección Cambia el código modular del instructivo Prepara la app modular para la creación de contenedores. En ese instructivo, actualizaste el código de la app para usar nombres de servicio en lugar de localhost. Esa actualización permite que Kubernetes enrute solicitudes entre módulos y garantiza que los módulos puedan comunicarse entre sí dentro de un clúster. Ahora, cuando apliques el manifiesto, Kubernetes creará los Services dentro del clúster.

Un Deployment es un objeto de la API de Kubernetes que te permite ejecutar varias réplicas de Pods que se distribuyen entre los nodos de un clúster. En la siguiente sección, se explica qué son los Pods.

¿Qué es un Pod de Kubernetes?

En el instructivo anterior, creaste una imagen de contenedor para cada módulo de la app de Cymbal Books. Por ejemplo, creaste imágenes de contenedor basadas en los módulos home_app y book_details_app.

Cuando usas el comando kubectl apply para implementar el manifiesto de Kubernetes, Kubernetes extrae tus imágenes de contenedor de Artifact Registry al clúster. En el clúster, las imágenes de contenedor se convierten en contenedores, y los contenedores se ejecutan dentro de Pods.

Un Pod es un entorno aislado en el que se ejecutan los contenedores y realiza las siguientes tareas:

• Asigna CPU y memoria: Un Pod proporciona los recursos que los contenedores necesitan para funcionar.
• Proporciona redes: Cada Pod tiene su propia dirección IP. Esto permite que el Pod se comunique con otros Pods.

Los Pods se ejecutan en nodos, que son las máquinas que proporcionan potencia de procesamiento para el clúster. Kubernetes asigna automáticamente Pods a los nodos y los distribuye entre los nodos del clúster para reducir el riesgo de sobrecargar un solo nodo. Esta distribución ayuda al clúster a usar sus recursos de procesamiento y memoria de manera eficiente.

Verifica la Deployment

Después de aplicar el manifiesto de Kubernetes con el comando kubectl apply, verifica que la app se haya implementado correctamente en el clúster. Para verificar la Deployment, comprueba que los Pods y los servicios se ejecuten correctamente.

Verifica los Pods

Para ver los Pods en tu clúster, ejecuta el siguiente comando:

kubectl get pods

Este comando enumera los Pods y su estado actual. Busca la columna STATUS para confirmar que todos los Pods estén marcados como Running, lo que indica que se están ejecutando correctamente y están listos para entregar solicitudes. El resultado esperado es el siguiente:

NAME                             READY   STATUS    RESTARTS   AGE
home-app-67d59c6b6d-abcde        1/1     Running   0          30s
book-details-app-6d8bcbc58f-xyz  1/1     Running   0          30s
book-reviews-app-75db4c4d7f-def  1/1     Running   0          30s
images-app-7f8c75c79c-ghi        1/1     Running   0          30s

El estado de un Pod aparece inicialmente como Pending mientras se crea y sus contenedores están en proceso de inicio. Si un Pod permanece en estado Pending durante un período prolongado, es posible que el clúster no tenga suficientes recursos para que ese Pod entre en un estado Running correcto. Si un Pod tiene el estado CrashLoopBackOff, es posible que haya un problema con el contenedor. Los pasos para solucionar problemas se proporcionan más adelante en el instructivo.

Verifica los Servicios

Los servicios permiten la comunicación entre los Pods y permiten que los clientes externos (por ejemplo, usuarios, secuencias de comandos automatizadas o herramientas de supervisión) accedan a la app. Para ver los servicios en tu clúster, ejecuta el siguiente comando:

kubectl get services

El resultado de este comando es similar al siguiente:

NAME               TYPE           CLUSTER-IP      EXTERNAL-IP       PORT(S)        AGE
home-app-service   LoadBalancer   10.12.3.4       35.185.1.2        80:30837/TCP   30s
details-service    ClusterIP      10.12.3.5       <none>            80/TCP         30s
reviews-service    ClusterIP      10.12.3.6       <none>            80/TCP         30s
images-service     LoadBalancer   10.12.3.7       34.125.6.3        80:32014/TCP   30s

Los campos clave que se deben observar en el resultado son los siguientes:

• TYPE: Este campo indica cómo se expone el Service. Los servicios de tipo LoadBalancer proporcionan acceso externo a la app.
• EXTERNAL-IP: Para un Service de tipo LoadBalancer, el campo EXTERNAL-IP muestra la dirección IP pública que los usuarios pueden ingresar en su navegador web para acceder a la app. Para un Service de tipo ClusterIP, este campo está vacío porque solo se puede acceder a los Services ClusterIP dentro del clúster.

Prueba la implementación

Después de implementar la app de Cymbal Books en el clúster de GKE, verifica que se pueda acceder a ella y que los contenedores puedan comunicarse entre sí.

Accede a la app

Sigue estos pasos para confirmar que se pueda acceder a la app:

1. Recupera la dirección IP externa de home-app-service:

   kubectl get services
   

   Busca la columna **EXTERNAL-IP** en el resultado y anota la dirección IP asociada a home-app-service.

2. Abre un navegador web y, luego, ingresa la siguiente URL:

   http://EXTERNAL-IP
   

   Reemplaza EXTERNAL-IP por la dirección IP que encontraste en el paso anterior.

3. Verifica que la página principal de la app de Cymbal Books se cargue correctamente.

Verifica la comunicación entre servicios

Los contenedores de la app de Cymbal Books dependen de los servicios para intercambiar información. Sigue estos pasos para asegurarte de que los contenedores puedan comunicarse de manera eficaz:

1. Recupera la dirección IP externa de home-app-service como se describió anteriormente.

2. Usa la interfaz de la app para probar las interacciones entre los contenedores. Para ello, haz clic en todos los vínculos disponibles en la interfaz de la app y confirma que las siguientes funciones funcionen:

   • Verifica las imágenes de las portadas de los libros: Confirma que las imágenes de las portadas de los libros se carguen correctamente tanto en la página principal como en la página de detalles del libro. Si es así, los contenedores home_app y book_details_app se comunican correctamente con el contenedor images_app.
   • Ver detalles del libro: Navega a la página de detalles de un libro desde la página principal. Si ves los detalles de un libro, significa que el contenedor home_app se comunica correctamente con el book_details_app.
   • Ver opiniones sobre libros: Haz clic en un vínculo de opinión sobre un libro para verificar que el contenedor home_app pueda comunicarse con el contenedor book_reviews_app.

Tu app ahora se ejecuta en un clúster de GKE.

¡Felicitaciones! Viste cómo transformar una app monolítica en un sistema modular y contenerizado que se ejecuta en un clúster de GKE activo. En el camino, aprendiste a dividir el código con acoplamiento alto en módulos independientes, a compilar y enviar imágenes de contenedores a un repositorio, a definir manifiestos de Kubernetes y a implementar tu app desde el registro en GKE. Este es un gran logro y refleja los pasos reales que siguen los equipos para modernizar las aplicaciones para la nube.

Soluciona problemas

Si la app no responde o los contenedores no se comunican, usa los siguientes pasos de solución de problemas para diagnosticar y resolver problemas comunes.

Verifica el estado de tus Pods

Comienza por enumerar todos los Pods de tu clúster para determinar si se ejecutan como se espera:

kubectl get pods

Revisa el resultado para confirmar que cada Pod esté en el estado Running. Si algún Pod no se está ejecutando, anota su nombre para inspeccionarlo más adelante.

Inspecciona los registros de Pods

Si un Pod no controla las solicitudes correctamente, revisa sus registros para buscar mensajes de error:

kubectl logs POD_NAME

Reemplaza POD_NAME con el nombre del pod que deseas inspeccionar. Este comando es útil para identificar problemas de inicio o errores de tiempo de ejecución.

Describe un Pod para obtener información detallada

Si un Pod permanece en un estado que no es Running durante más de cinco minutos (por ejemplo, está en un estado Pending, ContainerCreating o CrashLoopBackOff), puedes ver información detallada sobre el estado y los eventos del Pod con el siguiente comando:

kubectl describe pod POD_NAME

Reemplaza POD_NAME por el nombre del Pod del que deseas obtener información detallada.

La sección Events del resultado podría indicar que las restricciones de recursos o los problemas con las extracciones de imágenes impiden que el Pod se inicie correctamente.

Verifica la configuración del servicio

Asegúrate de que tus Services estén configurados correctamente, en especial el Service que expone el módulo de inicio con una dirección IP externa. Enumera los Services con el siguiente comando:

kubectl get services

Si observas que el módulo Service for the home tiene una dirección EXTERNAL-IP que aparece como Pending, ejecuta el siguiente comando:

kubectl describe service SERVICE_NAME

Reemplaza SERVICE_NAME por el nombre del servicio del módulo principal.

Este comando proporciona más detalles sobre la configuración del servicio y te ayuda a identificar demoras en la asignación de la dirección IP externa o cualquier otro problema de configuración.

Verifica los eventos del clúster

Puedes examinar los eventos del clúster para determinar si un problema afecta a varios componentes del clúster:

kubectl get events

Este comando puede determinar si hay problemas más amplios de recursos o de red que afectan tu implementación.

Limpia los recursos

Ejecutar un clúster de GKE genera costos. Después de completar este instructivo, limpia tus recursos para evitar cargos adicionales. Sigue estos pasos para quitar el clúster y, de manera opcional, todo el proyecto.

Borra el clúster de GKE

Para borrar el clúster de GKE, usa el siguiente comando:

gcloud container clusters delete CLUSTER_NAME
    --location=CONTROL_PLANE_LOCATION

Reemplaza lo siguiente:

• CLUSTER_NAME: Es el nombre del clúster que creaste, como cymbal-cluster.

• CONTROL_PLANE_LOCATION: La ubicación de Compute Engine del plano de control de tu clúster. Proporciona una región para los clústeres regionales o una zona para los clústeres zonales.

Cuando se te solicite, confirma la eliminación.

Verifica que se haya borrado el clúster

Para asegurarte de que se borró el clúster, ejecuta el siguiente comando:

gcloud container clusters list

El clúster ya no debería aparecer en el resultado. Si es así, espera unos momentos y vuelve a intentarlo.

Borra el Google Cloud proyecto (opcional)

Si creaste un proyecto de Google Cloud específicamente para este instructivo y ya no lo necesitas, puedes borrarlo por completo Google Cloud . Si borras el proyecto, se quitarán todos los recursos y se detendrá la facturación del proyecto:

1. En la Google Cloud consola, abre la página Administrar recursos.
2. Selecciona el proyecto que deseas borrar.
3. Haz clic en Borrar proyecto y sigue las indicaciones para confirmar.

Resumen de la serie

¡Felicitaciones! Tras completar este programa de aprendizaje, aprendiste los conceptos básicos para convertir una app monolítica en una app modular alojada en contenedores que se ejecuta en un clúster de Kubernetes. En los siguientes pasos, se resume el proceso:

1. Comprende la aplicación monolítica

   • Exploraste la estructura de la app monolítica de Cymbal Books.
   • Configuraste un entorno local de Python para ejecutar el monolito y probaste sus extremos.
   • Obtuviste una comprensión de la base de código de la app para prepararla para la modularización.

2. Modulariza la aplicación monolítica

   • Aprendiste a dividir el código monolítico en módulos independientes. Cada módulo controla una función distinta, como mostrar detalles o reseñas de libros.
   • Vimos cómo se implementan estos módulos como apps de Flask independientes que se ejecutan en diferentes puertos.
   • Probé la app modularizada.

3. Prepara el código modular para la contenerización

   • Aprendiste que debías actualizar las URLs en home.py para usar nombres de Service en lugar de localhost.
   • Aprendiste cómo el manifiesto de Kubernetes define los servicios que permiten que los módulos de la app, que ya se comunican entre sí, se encuentren dentro del contexto de un clúster de Kubernetes.

4. Aloja la app modular en contenedores

   • Configuraste un proyecto de Google Cloud y clonaste la app de GitHub en Cloud Shell.
   • Crear imágenes de contenedor para cada módulo con Docker y probar los contenedores de forma local
   • Envió las imágenes de contenedor a Artifact Registry para preparar la app para la implementación en un clúster.
   • Se actualizó el manifiesto de Kubernetes para hacer referencia a las rutas de acceso de las imágenes de contenedor en Artifact Registry.

5. Implementa la app en un clúster de GKE (el instructivo en el que te encuentras ahora):

   • Creaste un clúster de GKE.
   • Implementaste las imágenes de contenedor de Artifact Registry en el clúster de GKE.
   • Probamos la versión final de la app, que ahora es escalable y se ejecuta en un entorno de Kubernetes.

¿Qué sigue?

Para obtener más capacitación práctica sobre cómo crear clústeres, consulta nuestra serie Ruta de aprendizaje: Aplicaciones escalables.