Ruta de aprendizaje: transformar una aplicación monolítica en una aplicación de GKE - Desplegar la aplicación en un clúster de GKE

Este es el quinto y último tutorial de una ruta de aprendizaje que te enseña a modularizar y contenerizar una aplicación monolítica.

El recorrido de aprendizaje consta de los siguientes tutoriales:

  1. Descripción general
  2. Información sobre el monolito
  3. Modularizar el monolito
  4. Preparar la aplicación modular para la contenerización
  5. Contenerizar la aplicación modular
  6. Desplegar la aplicación en un clúster de GKE (este tutorial)

En el tutorial anterior, Contenerizar la aplicación modular, preparaste la aplicación modular Cymbal Books para su implementación. Has contenedorizado los módulos de la aplicación, has probado los contenedores resultantes y has enviado las imágenes de contenedor a Artifact Registry.

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

Costes

Si sigues los pasos de este tutorial, se aplicarán cargos a tu Google Cloud cuenta. Los costes empiezan cuando habilitas GKE e implementas la aplicación de ejemplo Cymbal Books. Estos costes incluyen los cargos por clúster de GKE, tal como se indica en la página de precios, y los cargos por ejecutar máquinas virtuales de Compute Engine.

Para evitar cargos innecesarios, inhabilita GKE o elimina el proyecto una vez que hayas completado este tutorial.

Antes de empezar

Antes de empezar este tutorial, asegúrate de haber completado los tutoriales anteriores de la serie. Para ver un resumen de toda la serie y enlaces a tutoriales específicos, consulta Plan de formación: transformar una aplicación monolítica en una aplicación de GKE (resumen).

En concreto, debes haber seguido los pasos del tutorial anterior, Contenerizar la aplicación modular.

Configurar el clúster de GKE

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

En este tutorial, usarás la CLI de gcloud para crear el clúster. También puedes usar la Google Cloud consola, que proporciona una interfaz gráfica de usuario (GUI) para crear y gestionar Google Cloudrecursos, como clústeres de GKE.

Crear y verificar un clúster de GKE

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

  1. Ve a la Google Cloud consola.

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

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

  3. Define tu proyecto predeterminado en Google Cloud CLI:

    gcloud config set project PROJECT_ID

    Sustituye PROJECT_ID por el ID del proyecto que has creado o seleccionado en la sección Seleccionar o crear un proyecto Google Cloud del tutorial anterior. Un ID de proyecto es una cadena única que diferencia tu proyecto de todos los demás proyectos de Google Cloud. Para encontrar el ID de proyecto, ve al selector de proyectos. En esa página, puede ver los IDs de cada uno de sus Google Cloud proyectos.

  4. Crea un clúster de GKE:

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

    Haz los cambios siguientes:

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

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

  5. Obtén 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 el archivo de configuración de Kubernetes, que se almacena de forma predeterminada en ~/.kube/config. Este archivo de configuración contiene las credenciales que necesita kubectl para interactuar con tu clúster de GKE.

  6. Comprueba 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 muestra los nodos de tu clúster de GKE. Como has creado 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.

Implementar la aplicación

Ahora que has creado un clúster de GKE, puedes desplegar la aplicación Cymbal Books en él. Para desplegar una aplicación en un clúster, aplica el manifiesto de Kubernetes al clúster.

Aplica el manifiesto de Kubernetes

En Cloud Shell, despliega la aplicación en el clúster de GKE ejecutando los siguientes comandos:

  1. Ve al directorio raíz de la aplicación en 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 indica a Kubernetes que cree los recursos especificados en el archivo kubernetes-manifest.yaml. Estos recursos incluyen servicios, una implementación y pods.

Has visto los servicios por primera vez en la sección Cambiar el código modular del tutorial Preparar la aplicación modular para la contenedorización. En ese tutorial, actualizaste el código de la aplicación para usar nombres de servicio en lugar de localhost. Esta actualización permite a Kubernetes enrutar solicitudes entre módulos y asegura que los módulos puedan comunicarse entre sí dentro de un clúster. Ahora, cuando apliques el manifiesto, Kubernetes creará los servicios dentro del clúster.

Un Deployment es un objeto de la API de Kubernetes que te permite ejecutar varias réplicas de pods distribuidas 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 tutorial anterior, creaste una imagen de contenedor para cada módulo de la aplicación 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 desplegar 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 en 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 necesitan los contenedores 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 computación al clúster. Kubernetes asigna automáticamente pods a los nodos y distribuye los pods entre los nodos del clúster para reducir el riesgo de sobrecargar un nodo concreto. Esta distribución ayuda al clúster a usar sus recursos de computación y memoria de forma eficiente.

Verificar la implementación

Después de aplicar el manifiesto de Kubernetes con el comando kubectl apply, comprueba que la aplicación se ha desplegado correctamente en el clúster. Para verificar la implementación, comprueba que los pods y los servicios se estén ejecutando correctamente.

Comprobar los pods

Para ver los pods de tu clúster, ejecuta el siguiente comando:

kubectl get pods

Este comando muestra los pods y su estado actual. Busca la columna ESTADO 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 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 periodo prolongado, es posible que el clúster no tenga suficientes recursos para que el pod pase a un estado Running correcto. Si un pod tiene el estado CrashLoopBackOff, puede que haya un problema con el contenedor. Los pasos para solucionar problemas se indican más adelante en el tutorial.

Comprobar los servicios

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

kubectl get services

La salida de este comando tiene el siguiente aspecto:

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

Estos son los campos clave que debes observar en el resultado:

  • TYPE: este campo indica cómo se expone el servicio. Los servicios de tipo LoadBalancer proporcionan acceso externo a la aplicación.
  • EXTERNAL-IP: en el caso de un servicio de tipo LoadBalancer, el campo EXTERNAL-IP muestra la dirección IP pública que los usuarios pueden introducir en su navegador web para acceder a la aplicación. En el caso de un servicio de tipo ClusterIP, este campo está vacío porque los servicios de tipo ClusterIP solo se pueden acceder desde el clúster.

Probar la implementación

Después de desplegar la aplicación Cymbal Books en el clúster de GKE, comprueba que se puede acceder a la aplicación y que los contenedores pueden comunicarse entre sí.

Acceder a la aplicación

Para confirmar que se puede acceder a la aplicación, 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 a home-app-service.

  2. Abre un navegador web e introduce la siguiente URL:

    http://EXTERNAL-IP

    Sustituye EXTERNAL-IP por la dirección IP que has encontrado en el paso anterior.

  3. Comprueba que la página principal de la aplicación Cymbal Books se carga correctamente.

Verificar la comunicación entre servicios

Los contenedores de la aplicación Cymbal Books dependen de los servicios para intercambiar información. Para asegurarte de que los contenedores pueden comunicarse de forma eficaz, sigue estos pasos:

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

  2. Usa la interfaz de la aplicación para probar las interacciones entre contenedores. Para ello, confirma que las siguientes funciones funcionan haciendo clic en todos los enlaces disponibles en la interfaz de la aplicación:

    • Comprueba las imágenes de portada de los libros: confirma que se cargan 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: vaya 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 book_details_app.
    • Ver reseñas de libros: haz clic en un enlace de reseña de un libro para verificar que el contenedor home_app puede comunicarse con el contenedor book_reviews_app.

Tu aplicación ahora se está ejecutando en un clúster de GKE.

¡Enhorabuena! Has visto cómo transformar una aplicación monolítica en un sistema modular en contenedores que se ejecuta en un clúster de GKE activo. Durante el proceso, has aprendido a dividir el código acoplado en módulos independientes, a compilar y enviar imágenes de contenedor a un repositorio, a definir manifiestos de Kubernetes y a desplegar tu aplicación desde el registro en GKE. Se trata de un gran logro que refleja los pasos que dan los equipos en el mundo real para modernizar las aplicaciones en la nube.

Solución de problemas

Si la aplicación no responde o los contenedores no se comunican, sigue estos pasos para diagnosticar y resolver problemas habituales.

Consultar el estado de tus pods

Empieza enumerando todos los pods de tu clúster para determinar si se están ejecutando 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 a fondo.

Inspeccionar los registros de pods

Si un Pod no gestiona las solicitudes correctamente, consulta sus registros para ver si hay algún mensaje de error:

kubectl logs POD_NAME

Sustituye POD_NAME por el nombre del pod que quieras 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, si está en 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

Sustituye POD_NAME por el nombre del pod del que quieras obtener información detallada.

La sección Events de la salida puede indicar que las limitaciones de recursos o los problemas con las extracciones de imágenes impiden que el pod se inicie correctamente.

Verificar la configuración del servicio

Asegúrate de que tus servicios estén configurados correctamente, sobre todo el servicio que expone el módulo de casa con una dirección IP externa. Lista los servicios con el siguiente comando:

kubectl get services

Si observas que el servicio del módulo de casa tiene una dirección EXTERNAL-IP que aparece como Pending, ejecuta el siguiente comando:

kubectl describe service SERVICE_NAME

Sustituye SERVICE_NAME por el nombre del servicio del módulo de casa.

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 u otros problemas de configuración.

Consultar eventos de 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 generales con los recursos o la red que afecten a tu implementación.

Eliminar los recursos

Ejecutar un clúster de GKE conlleva costes. Cuando hayas completado este tutorial, elimina los recursos para evitar que se te cobren cargos adicionales. Sigue estos pasos para eliminar el clúster y, opcionalmente, todo el proyecto.

Elimina el clúster de GKE

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

gcloud container clusters delete CLUSTER_NAME
    --location=CONTROL_PLANE_LOCATION

Haz los cambios siguientes:

  • CLUSTER_NAME: el nombre del clúster que has creado, 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 pida, confirma la eliminación.

Verificar que el clúster se ha eliminado

Para asegurarte de que el clúster se ha eliminado, ejecuta el siguiente comando:

gcloud container clusters list

El clúster ya no debería aparecer en la salida. Si es así, espera unos instantes y vuelve a intentarlo.

(Opcional) Eliminar el Google Cloud proyecto

Si has creado un Google Cloud proyecto específicamente para este tutorial y ya no lo necesitas, puedes eliminarlo por completo. Google Cloud Al eliminar 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 Gestionar recursos.
  2. Selecciona el proyecto que quieras eliminar.
  3. Haz clic en Eliminar proyecto y sigue las indicaciones para confirmar la acción.

Resumen de la serie

¡Enhorabuena! Al completar este plan de formación, has aprendido los conceptos básicos para convertir una aplicación monolítica en una aplicación modular y contenerizada que se ejecuta en un clúster de Kubernetes. En los siguientes pasos se resume el proceso:

  1. Información sobre el monolito

    • Hemos analizado la estructura de la aplicación monolítica de Cymbal Books.
    • Configurar un entorno de Python local para ejecutar el monolito y probar sus endpoints.
    • Ha adquirido conocimientos sobre la base de código de la aplicación para prepararla para la modularización.

  2. Modularizar el monolito

    • Has aprendido a dividir el código monolítico en módulos independientes. Cada módulo gestiona una función distinta, como mostrar los detalles o las reseñas de un libro.
    • Has visto cómo se implementan estos módulos como aplicaciones Flask independientes que se ejecutan en puertos diferentes.
    • Se ha probado la aplicación modularizada.

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

    • Hemos detectado que tenías que actualizar las URLs en home.py para usar nombres de servicio en lugar de localhost.
    • Has aprendido cómo el manifiesto de Kubernetes define los servicios que permiten que los módulos de la aplicación, que ya se comunican entre sí, se encuentren en el contexto de un clúster de Kubernetes.

  4. Contenerizar la aplicación modular

    • Configurar un Google Cloud proyecto y clonar la aplicación de GitHub en Cloud Shell.
    • Compiló imágenes de contenedor para cada módulo con Docker y probó los contenedores de forma local.
    • Ha enviado las imágenes de contenedor a Artifact Registry para preparar la aplicación para el despliegue en un clúster.
    • Se ha actualizado el manifiesto de Kubernetes para que haga referencia a las rutas de las imágenes de contenedor en Artifact Registry.

  5. Despliega la aplicación en un clúster de GKE (el tutorial en el que te encuentras ahora):

    • Has creado un clúster de GKE.
    • Se han desplegado las imágenes de contenedor de Artifact Registry en el clúster de GKE.
    • Hemos probado la versión final de la aplicación, que ahora es escalable y se ejecuta en un entorno de Kubernetes.

Siguientes pasos

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