Ruta de aprendizaje: transforma un monolito en una aplicación de GKE - Comprender el monolito

Te damos la bienvenida al primer tutorial de una serie que te muestra cómo convertir una aplicación monolítica en módulos, cómo crear contenedores para los módulos y cómo desplegar las imágenes de contenedor en un clúster de Google Kubernetes Engine (GKE). No te preocupes si no entiendes alguno de estos términos. Descubrirás qué significan a medida que avances en la serie.

El recorrido de aprendizaje consta de los siguientes tutoriales:

  1. Descripción general
  2. Entender el monolito (este tutorial)
  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

En este tutorial, aprenderás sobre el monolito realizando los siguientes pasos:

  1. Configurar la aplicación en tu máquina local.
  2. Explorar sus funciones en tu navegador.
  3. Revisar el código.

¿Qué es un monolito?

Antes de poner en marcha el monolito de ejemplo de Cymbal Books, es importante que sepas qué es un monolito.

Un monolito es una aplicación en la que todos los componentes están interconectados y no se pueden escalar de forma independiente. Por ejemplo, si un número de usuarios visita de repente la página de inicio de sesión de la aplicación, no puedes escalar solo el componente de inicio de sesión de forma independiente. En su lugar, debe escalar toda la aplicación, incluidos los componentes no relacionados, como el catálogo de productos o el sistema de procesamiento de pedidos.

Por el contrario, cuando una aplicación se divide en módulos independientes, cada módulo se puede escalar por separado en función de sus necesidades de recursos. Si alojas la aplicación modular en un clúster de GKE, GKE puede incluso automatizar el escalado por ti.

El término monolítico no significa que el código esté mal organizado. Un monolito puede estar bien estructurado y sus componentes se pueden implementar en distintas áreas del código. Lo que distingue a un monolito es que estos componentes no se pueden ejecutar ni escalar de forma independiente.

Costes

Puedes completar este tutorial sin incurrir en ningún cargo. Sin embargo, si sigues los pasos del último tutorial de esta serie, se aplicarán cargos a tu cuenta deGoogle Cloud . Los costes empiezan cuando habilitas GKE y despliegas la aplicación Cymbal Books en un clúster de GKE. 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

Para hacer este tutorial, necesitas la versión 3.13 de Python en tu máquina local. Para comprobar qué versión de Python tienes en tu máquina, ejecuta este comando:

python3 --version

Si tu versión de Python es anterior a la 3.13, descarga e instala la versión más reciente desde el sitio web oficial de Python.

Configurar un entorno

En esta serie de tutoriales, ejecutarás diferentes versiones de la aplicación en diferentes lugares:

  • La versión monolítica en tu máquina local
  • La versión modular en tu máquina local
  • La versión en contenedor en Cloud Shell y, a continuación, en un clúster de GKE

En esta sección, configurarás un entorno virtual en tu máquina local donde se pueda ejecutar el monolito.

Descargar el código

  1. Abre un terminal en tu máquina local.

  2. Clona el repositorio de GitHub del tutorial en tu máquina local:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git

    La carpeta kubernetes-engine-samples/quickstarts/monolith-to-microservices contiene las tres carpetas siguientes: monolith/, modular/ y containerized/. En este tutorial, te centrarás exclusivamente en los archivos de la carpeta monolith/.

Crear y activar un entorno virtual

Un entorno virtual proporciona un espacio aislado para ejecutar la aplicación. Evita que las bibliotecas de Python que necesitas instalar para la aplicación interfieran con otros proyectos de Python de tu sistema.

Sigue estos pasos para crear y activar un entorno virtual:

  1. En el terminal que has abierto en la sección anterior, ve a la siguiente carpeta del repositorio que has clonado en tu máquina:

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

  2. Crea un entorno virtual llamado book-review-env:

    python3 -m venv book-review-env

    Crear un entorno virtual es una buena idea porque es un área en la que puedes ejecutar la aplicación de forma aislada. De esta forma, te aseguras de que las dependencias y configuraciones de la aplicación no entren en conflicto con otro software o bibliotecas de tu sistema.

  3. Activa el entorno virtual con el comando de tu sistema operativo:

    macOS y Linux

    source book-review-env/bin/activate

    Windows

    book-review-env\Scripts\activate

  4. Instala las dependencias de Python del monolito. Las dependencias son bibliotecas de Python externas de las que depende la aplicación para funcionar correctamente. Estas bibliotecas se indican en el archivo requirements.txt y el siguiente comando las instala todas en tu entorno virtual:

    pip install -r monolith/requirements.txt

Ejecutar y explorar libros de Cymbal en el navegador

La aplicación Cymbal Books es sencilla y tiene las siguientes funciones:

  • Una página principal que muestra todos los libros de la biblioteca.
  • Página que muestra los detalles de un libro.
  • Un botón en la página de detalles que, al hacer clic en él, muestra las reseñas del libro.
  • La posibilidad de mostrar imágenes de portadas de libros.

En la página principal se muestran tres libros y, junto a cada uno, aparece el botón Ver detalles:

Página principal de la aplicación de reseñas de libros

Ahora que el entorno virtual está activo y las dependencias de la aplicación se han instalado en ese entorno, ejecuta la aplicación siguiendo estos pasos:

  1. En tu máquina local, ve al directorio del monolito:

    cd monolith/

  2. Inicia la aplicación:

    python3 mono.py

  3. Abre tu navegador web y ve a la página principal de la aplicación: http://127.0.0.1:8080.

  4. Para ir a la página de detalles de un libro, haz clic en Ver detalles. En la página de detalles se ofrece más información sobre un libro, como el autor y el año de publicación.

  5. Para mostrar una lista de reseñas del libro, en la página de detalles, haz clic en Mostrar reseñas. En la siguiente imagen se muestra la página de detalles del libro El reloj de Céfiro y la primera reseña:

    Diagrama que muestra los detalles y las reseñas de un libro

Explorar los archivos de la carpeta /monolith

Dedica un momento a examinar los archivos de la carpeta /monolith:

monolith/
├── mono.py
├── data/
│   ├── book-1.json
│   ├── book-2.json
│   ├── book-3.json
│   ├── reviews-1.json
│   ├── reviews-2.json
│   └── reviews-3.json
├── images/
│   ├── fungi_frontier.jpg
│   ├── melodic_mechanics.jpg
│   └── zephyrs_timepiece.jpg
├── static/
│   ├── styles_for_details.css
│   └── styles_for_home.css
└── templates/
    ├── book_details.html
    └── home.html

Las carpetas y los archivos clave son los siguientes:

  • La carpeta images/ contiene las siguientes imágenes de portada de libros, que se muestran en la aplicación:

    • fungi_frontier.jpg
    • melodic_mechanics.jpg
    • zephyrs_timepiece.jpg

  • La carpeta data/ contiene los siguientes archivos JSON. Estos archivos contienen reseñas de los tres libros de la biblioteca de Cymbal Books y detalles sobre cada libro:

    • reviews-1.json, reviews-2.json, reviews-3.json
    • book-1.json, book-2.json, book-3.json

Aunque las aplicaciones reales suelen usar bases de datos, almacenar los datos de la aplicación en archivos JSON simplifica su implementación. La aplicación de ejemplo Cymbal Book usa archivos JSON para que no tengas que gestionar código complejo. En su lugar, puedes centrarte en el objetivo principal de esta serie de tutoriales, que es aprender a modularizar y contenerizar el monolito.

Puedes ignorar las siguientes carpetas porque los archivos que contienen son importantes para el diseño de la aplicación, pero no son directamente relevantes para su lógica:

  • static/: contiene archivos CSS que definen el estilo de la aplicación.
  • templates/: contiene archivos HTML que definen el diseño y el contenido de la aplicación.

Entender el monolito como una aplicación de Flask

El monolito de este tutorial se ha creado con Flask, una biblioteca de Python para crear aplicaciones web. Sin embargo, Flask no se suele usar en entornos de producción porque no admite la simultaneidad, lo que puede provocar cuellos de botella en el rendimiento cuando la carga es elevada. Una aplicación Flask tampoco tiene funciones sólidas de gestión de errores ni de escalabilidad.

La aplicación Cymbal Books usa Flask porque su sencillez y su configuración mínima facilitan la comprensión de los conceptos de modularización y contenedorización. En el caso de las aplicaciones de nivel de producción que usan Python, considera alternativas a Flask, como FastAPI o Django. También puedes usar frameworks diseñados para otros lenguajes, como Spring Boot para Java o Express.js para Node.js. Estos frameworks pueden ofrecer una mejor simultaneidad, escalabilidad y funciones listas para producción para satisfacer las demandas de las aplicaciones del mundo real.

Examinar mono.py

Toda la lógica del monolito se encuentra en un solo archivo llamado mono.py. Este archivo crea una aplicación Flask. Una aplicación Flask se ejecuta en un servidor web, escucha URLs específicas (llamadas endpoints) y responde a las solicitudes que se hacen a esas URLs. Cuando alguien solicita una de estas URLs (ya sea visitándola en un navegador web o haciendo la solicitud de forma programática), Flask ejecuta el fragmento de código correspondiente para gestionar esa solicitud.

En la siguiente captura de pantalla se muestra el archivo mono.py. Los recuadros resaltan los controladores de ruta de la aplicación. Mientras que un controlador sirve la página principal visible para el usuario, los demás se usan principalmente para la comunicación entre módulos, es decir, para enviar datos en formato JSON o archivos de imagen estáticos. En las siguientes secciones se ofrecen más detalles sobre estos endpoints.

Diagrama que muestra recuadros alrededor de los distintos controladores de rutas del código monolítico

En la captura de pantalla, los recuadros resaltan los controladores de ruta de la aplicación. Un controlador de ruta consta de dos partes:

  • La línea @app.route() que define un patrón de URL (como /book/<id>/reviews).
  • Función que se ejecuta cuando se llama al endpoint.

Un endpoint es una URL que coincide con el patrón definido en la línea @app.route().

Por ejemplo, cuando un usuario hace clic en Mostrar reseñas en la página de detalles de un libro, la aplicación envía una solicitud a http://localhost:8080/book/1/reviews. El controlador de la ruta de reseñas de libros responde a esta solicitud siguiendo estos pasos:

  1. Reconoce que esta URL coincide con su patrón /book/<id>/reviews.
  2. Obtiene las reseñas del libro 1 de un archivo JSON.
  3. Envía esas reseñas al frontend en formato JSON.

A continuación, el componente de detalles del libro muestra estas reseñas en un formato legible para humanos en la página web. El monolito de Cymbal Books usa una biblioteca de Python llamada Flask para simplificar la implementación de controladores de rutas. En el siguiente tutorial, verás que Flask y los controladores de rutas desempeñan un papel fundamental cuando aprendas cómo se convierte el monolito en una aplicación modular.

Por qué son importantes los endpoints del monolito para la modularización

Los endpoints desempeñan un papel fundamental en las aplicaciones de Flask, incluida la aplicación Cymbal Books. Sin embargo, su importancia va más allá del diseño monolítico, ya que es esencial entender los endpoints para dividir la aplicación en módulos independientes. Estos son los motivos:

  • Funciones principales: los endpoints implementan las funciones principales de la aplicación, como mostrar páginas o recuperar datos. Cada función está vinculada a un endpoint específico.
  • Modularización: los endpoints actúan como límites naturales o líneas de falla para dividir la aplicación en módulos más pequeños. Como verás en el siguiente tutorial, cada módulo de la versión modular de la aplicación corresponde a una función con sus propios endpoints.
  • Comunicación: en un diseño modular, los endpoints permiten que los módulos autónomos se comuniquen entre sí. Entender cómo se implementan los endpoints en mono.py sienta las bases para modularizar la aplicación Cymbal Books en módulos independientes en el siguiente tutorial.

Probar los controladores de ruta del monolito

Para ver qué tipo de datos devuelve cada controlador de ruta, visita los siguientes endpoints en tu navegador:

  • Controlador de ruta de la página principal: visita http://localhost:8080/ para ver una página HTML completa que muestra el catálogo de libros.
  • Controlador de ruta de detalles del libro: visita http://localhost:8080/book/1 para ver una página HTML con detalles sobre un libro concreto. La página obtiene datos JSON sobre un libro del servidor y los presenta en un formato legible por humanos mediante una plantilla HTML. Prueba a ver los detalles de otros libros cambiando el número de ID (1, 2 o 3) en la URL.
  • Controlador de ruta de reseñas de libros: visita http://localhost:8080/book/3/reviews para ver los datos JSON de las reseñas del libro. Estos datos se procesan en un formato legible cuando haces clic en Show Reviews en la página de detalles del libro Melodic Mechanics.
  • Gestor de rutas de imágenes: visita http://localhost:8080/images/fungi_frontier.jpg para ver un archivo de imagen. La página principal y las páginas de detalles de los libros llaman a este endpoint para mostrar las imágenes de portada de los libros.

Resumen

En este tutorial, has configurado y ejecutado la aplicación monolítica Cymbal Books. Después, has aprendido que el monolito se implementa como una aplicación Flask que escucha URLs específicas, llamadas endpoints, y responde a las solicitudes que se realizan a esas URLs.

Siguientes pasos

En el siguiente tutorial, Modularizar el monolito, verás cómo dividir el monolito en módulos independientes.