Ruta de aprendizaje: Transforma un monolítico en una app de GKE: Implementa la app en un clúster de GKE

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 contenedores 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 Cymbal Books para la implementación. Contenerizaste 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 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: 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 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 \
    --zone=ZONE \
    --num-nodes=2

    Reemplaza lo siguiente:

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

    • ZONE: Es la zona en la que deseas crear el clúster, como us-central1-a o europe-west1-b. Para obtener una lista completa de las zonas disponibles, consulta Regiones y zonas.

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

    gcloud container clusters get-credentials CLUSTER_NAME \
    --zone=ZONE

    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 correctamente, este comando enumera los nodos de 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 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, ejecuta los siguientes comandos para implementar la app en el clúster de GKE:

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

    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 servicios, una Deployment y Pods.

Viste los servicios por primera vez en la sección Cambia el código modular del instructivo Prepara la app modular para la contenerización. 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 próxima 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 las 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 operar.
  • 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 implementación

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 atender solicitudes. El resultado esperado es similar al 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 el Pod entre en un estado Running en buen estado. 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 servicio. 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 de tipo 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

Para confirmar que se puede acceder a la app, sigue estos pasos:

  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 con 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. Para asegurarte de que los contenedores puedan comunicarse de manera eficaz, sigue estos pasos:

  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 contenedores. Para ello, haz clic en todos los vínculos disponibles en la interfaz de la app y confirma que funcionen las siguientes funciones:

    • 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 en contenedores que se ejecuta en un clúster de GKE activo. En el proceso, aprendiste a dividir el código estrechamente acoplado en módulos independientes, compilar y enviar imágenes de contenedores a un repositorio, definir manifiestos de Kubernetes y, luego, implementar tu app desde el registro en GKE. Este es un logro importante 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 los Pods

Comienza por enumerar todos los Pods de tu clúster para determinar si se ejecutan según lo previsto:

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 a fondo.

Inspecciona los registros del Pod

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 servicios estén configurados correctamente, en especial el servicio que expone el módulo principal con una dirección IP externa. Crea una lista de 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 retrasos 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, borra los 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
    --zone=ZONE

Reemplaza lo siguiente:

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

  • ZONE: Es la zona en la que se creó el clúster, como us-central1-a.

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 segundos 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 borrar todo el proyecto de Google Cloud . 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! Cuando completes esta ruta de aprendizaje, habrás aprendido 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 separados. Cada módulo controla una función distinta, como mostrar los detalles o las opiniones de un libro.
    • Viste cómo se implementan estos módulos como apps de Flask independientes que se ejecutan en diferentes puertos.
    • Probamos 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 servicio en lugar de localhost.
    • Aprendiste cómo el manifiesto de Kubernetes define los servicios que habilitan los módulos de la app, que ya se comunican entre sí, para encontrarse dentro del contexto de un clúster de Kubernetes.

  4. Crea contenedores para la app modular

    • Configuraste un proyecto de Google Cloud y clonaste la app de GitHub en Cloud Shell.
    • Se compilaron imágenes de contenedor para cada módulo con Docker y se probaron los contenedores de forma local.
    • Se enviaron 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 que haga 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):

    • Se creó 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.