Te damos la bienvenida al primer instructivo de una serie en la que se muestra cómo tomar un monolito (o una app monolítica), separarlo en módulos, crear contenedores para los módulos y, luego, implementar 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. Aprenderás lo que significan a medida que avances en la serie.
La ruta de aprendizaje consta de los siguientes instructivos:
- Descripción general
- Comprende la aplicación monolítica (este instructivo)
- Modulariza la aplicación monolítica
- Prepara la app modular para la organización en contenedores
- Crea contenedores para la app modular
- Implementa la app en un clúster de GKE
En este instructivo, aprenderás sobre el monolito realizando los siguientes pasos:
- Configurar la app en tu máquina local
- Explorar sus funciones en tu navegador
- Revisar el código
¿Qué es un monolito?
Antes de poner en funcionamiento el monolito de muestra de Cymbal Books, es importante que primero comprendas qué es un monolito.
Una aplicación monolítica es aquella en la que todos los componentes están interconectados y no se pueden escalar de forma independiente. Por ejemplo, si una gran cantidad de usuarios visita de repente la página de acceso de la app, no puedes ajustar la escala solo del componente de acceso de forma independiente. En cambio, debes escalar toda la aplicación, incluidos los componentes no relacionados, como el catálogo de productos o el sistema de procesamiento de pedidos.
En cambio, cuando una aplicación se divide en módulos independientes, cada módulo se puede escalar por separado según sus necesidades de recursos. Si alojas la app modular en un clúster de GKE, este puede incluso automatizar el escalamiento por ti.
El término monolítico no significa código mal organizado. Un monolito puede estar bien estructurado, y sus componentes se pueden implementar en áreas distintas del código. Lo que distingue a un monolito es que estos componentes no pueden ejecutarse ni escalarse de forma independiente.
Costos
Puedes completar este instructivo sin incurrir en cargos. Sin embargo, seguir los pasos del instructivo final de esta serie genera cargos en tu cuenta deGoogle Cloud . Los costos comienzan cuando habilitas GKE y, luego, implementas la app de Cymbal Books en un clúster de GKE. Estos costos incluyen los cargos por clúster de GKE, como se indica en la página de precios, y los 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
Este instructivo requiere la versión 3.13 de Python en tu máquina local. Para verificar 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.
Configura tu entorno
En esta serie de instructivos, ejecutarás diferentes versiones de la aplicación en distintos lugares:
- La versión monolítica en tu máquina local
- La versión modular en tu máquina local
- La versión alojada en contenedores en Cloud Shell y, luego, en un clúster de GKE
En esta sección, configurarás un entorno virtual en tu máquina local en el que se pueda ejecutar el monolito.
Descarga el código
Abre una terminal en tu máquina local.
Clona el repositorio de GitHub del instructivo en tu máquina local:
git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.gitLa carpeta
kubernetes-engine-samples/quickstarts/monolith-to-microservicescontiene las siguientes tres carpetas:monolith/,modular/ycontainerized/. En este instructivo, te enfocarás exclusivamente en los archivos de la carpetamonolith/.
Crea y activa un entorno virtual
Un entorno virtual proporciona un espacio aislado para ejecutar la app y evita que las bibliotecas de Python que necesitas instalar para la app interfieran en otros proyectos de Python en tu sistema.
Sigue estos pasos para crear y activar un entorno virtual:
En la terminal que abriste en la sección anterior, navega a la siguiente carpeta en el repositorio que clonaste en tu máquina anteriormente:
cd kubernetes-engine-samples/quickstarts/monolith-to-microservicesCrea un entorno virtual llamado
book-review-env:python3 -m venv book-review-envCrear un entorno virtual es una buena idea porque es un área en la que puedes ejecutar la app de forma aislada. Esto garantiza que las dependencias y configuraciones de la app no entren en conflicto con otro software o bibliotecas de tu sistema.
Activa el entorno virtual con el comando de tu sistema operativo:
macOS y Linux
source book-review-env/bin/activateWindows
book-review-env\Scripts\activateInstala las dependencias de Python para el monolito. Las dependencias son bibliotecas externas de Python de las que depende la app para funcionar correctamente. Estas bibliotecas se enumeran en el archivo
requirements.txt, y el siguiente comando las instala todas en tu entorno virtual:pip install -r monolith/requirements.txt
Ejecuta y explora Cymbal Books en el navegador
La app de Cymbal Books es intencionalmente sencilla y tiene las siguientes funciones:
- Una página principal que muestra todos los libros de la biblioteca
- Una página que muestra detalles sobre un libro.
- Un botón en la página de detalles que, cuando se hace clic en él, muestra reseñas de libros.
- La capacidad de mostrar imágenes de portadas de libros
En la página principal, se muestran tres libros y, con cada uno, aparece un botón Ver detalles:
Ahora que el entorno virtual está activo y las dependencias de la app están instaladas en ese entorno, ejecuta la app siguiendo estos pasos:
En tu máquina local, navega al directorio del monolito:
cd monolith/Inicia la app:
python3 mono.pyAbre tu navegador web y ve a la página principal de la app:
http://127.0.0.1:8080.Para ir a la página de detalles de un libro, haz clic en Ver detalles. En la página de detalles, se proporciona más información sobre un libro, como el autor y el año de publicación.
Para mostrar una lista de opiniones sobre el libro, en una página de detalles, haz clic en Mostrar opiniones. En la siguiente imagen, se muestra la página de detalles del libro El reloj de Zéfiro y la primera opinión sobre el libro:
Explora 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 portadas de libros, que se muestran en la app:fungi_frontier.jpgmelodic_mechanics.jpgzephyrs_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.jsonbook-1.json,book-2.json,book-3.json
Si bien las apps del mundo real suelen usar bases de datos, almacenar los datos de la app en archivos JSON simplifica su implementación. La app de ejemplo Cymbal Book usa archivos JSON para que no tengas que controlar código complejo. En su lugar, puedes enfocarte en el objetivo principal de esta serie de instructivos, que es aprender a modularizar y contener el monolito.
Puedes ignorar las siguientes carpetas porque los archivos que contienen son importantes para el diseño y la disposición de la app, pero no son directamente relevantes para su lógica:
static/: Contiene archivos CSS que definen el estilo de la app.templates/: Contiene archivos HTML que definen el diseño y el contenido de la app.
Comprende el monolito como una aplicación de Flask
El monolito de este instructivo se compila con Flask, que es una biblioteca de Python para compilar aplicaciones web. Sin embargo, Flask no se suele usar en entornos de producción porque no admite la simultaneidad, lo que puede generar cuellos de botella en el rendimiento con cargas pesadas. Una aplicación de Flask también carece de funciones sólidas de manejo de errores y escalabilidad.
La app de Cymbal Books usa Flask porque su simplicidad y configuración mínima facilitan la comprensión de los conceptos de modularización y contenedorización. Para 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 capacidades listas para la producción para satisfacer las demandas de las aplicaciones del mundo real.
Examina mono.py
Toda la lógica del monolito se encuentra en un solo archivo llamado mono.py. Este archivo crea una aplicación de Flask. Una aplicación de Flask se ejecuta dentro de un servidor web, escucha URLs específicas, que se denominan extremos, y responde a las solicitudes que se realizan a esas URLs. Cuando alguien solicita una de estas URLs, ya sea visitándola en un navegador web o realizando la solicitud de forma programática, Flask ejecuta el fragmento de código correspondiente para controlar esa solicitud.
En la siguiente captura de pantalla, se muestra el archivo mono.py. Los cuadros destacan los controladores de rutas de la app. Si bien un controlador entrega la página principal visible para el usuario, los demás se usan principalmente para la comunicación entre módulos, ya que entregan datos en formato JSON o archivos de imágenes estáticas. En las siguientes secciones, se proporcionan más detalles sobre estos extremos.
En la captura de pantalla, los cuadros destacan los controladores de rutas de la app. Un controlador de rutas consta de dos partes:
- La línea
@app.route()que define un patrón de URL (como/book/<id>/reviews). - Es la función que se ejecuta cuando se llama al extremo.
Un extremo 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 opiniones en la página de detalles de un libro, la app realiza una solicitud a http://localhost:8080/book/1/reviews. El controlador de rutas de opiniones de libros responde a esta solicitud realizando los siguientes pasos:
- Reconoce que esta URL coincide con su patrón
/book/<id>/reviews. - Obtiene las opiniones sobre el libro 1 de un archivo JSON.
- Envía esas opiniones al frontend en formato JSON.
Luego, el componente de detalles del libro muestra estas opiniones en formato legible 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 instructivo, verás que Flask y los controladores de rutas desempeñan un papel fundamental cuando aprendas cómo se convierte el monolito en una app modular.
Por qué los extremos del monolito son importantes para la modularización
Los endpoints desempeñan un papel fundamental en las aplicaciones de Flask, incluida la aplicación de Cymbal Books. Sin embargo, su importancia se extiende más allá del diseño monolítico, ya que comprender los endpoints es esencial para dividir la aplicación en módulos independientes. Esto se debe a los siguientes motivos:
- Funciones principales: Los extremos implementan las funciones principales de la app, como mostrar páginas o recuperar datos. Cada función está vinculada a un extremo específico.
- Modularización: Los extremos actúan como límites naturales, o líneas de falla, para dividir la app en módulos más pequeños. Como verás en el próximo instructivo, cada módulo de la versión modular de la app corresponde a una función con sus propios extremos.
- Comunicación: En un diseño modular, los extremos permiten que los módulos autónomos se comuniquen entre sí. Comprender cómo se implementan los extremos en
mono.pysienta las bases para modularizar la app de Cymbal Books en módulos independientes en el siguiente instructivo.
Prueba los controladores de rutas de la aplicación monolítica
Para ver qué tipo de datos devuelve cada controlador de rutas, visita los siguientes extremos en tu navegador:
- Controlador de rutas de la página principal: Visita
http://localhost:8080/para ver una página HTML completa que muestre el catálogo de libros. - Controlador de rutas de detalles del libro: Visita
http://localhost:8080/book/1para ver una página HTML que muestra detalles sobre un libro en particular. La página recupera datos JSON sobre un libro del servidor y los presenta de forma legible para los usuarios con una plantilla HTML. Intenta ver los detalles de otros libros cambiando el número de ID (1, 2 o 3) en la URL. - Controlador de rutas de opiniones sobre libros: Visita
http://localhost:8080/book/3/reviewspara ver los datos JSON de las opiniones sobre el libro. Estos datos se procesan en un formato legible cuando haces clic enShow Reviewsen la página de detalles del libro Melodic Mechanics. - Controlador de rutas de imágenes: Visita
http://localhost:8080/images/fungi_frontier.jpgpara ver un archivo de imagen. La página principal y las páginas de detalles de los libros llaman a este extremo para mostrar las imágenes de portada de los libros.
Resumen
En este instructivo, configuraste y ejecutaste la app monolítica Cymbal Books. Luego, aprendiste que el monolito se implementa como una aplicación de Flask, que escucha URLs específicas, llamadas extremos, y responde a las solicitudes que se realizan a esas URLs.
¿Qué sigue?
En el siguiente instructivo, Modulariza el monolito, verás cómo dividir el monolito en módulos independientes.