Saltar al contenido principal
Home
HexagonalGuru

Monolito Modular: La Arquitectura Sensata que Nadie Vende

Avatar de HexagonalGuru

HexagonalGuru

Monolito Modular: La Arquitectura Sensata que Nadie Vende

En el artículo de microservicios dejamos caer el consejo: «monolito modular primero, distribución cuando duela». Es la frase que más preguntas ha generado, así que toca desarrollarla. Porque el monolito modular no es un monolito con buenas intenciones — es una arquitectura con reglas concretas, y la diferencia entre tenerlo y no tenerlo se nota el día que necesitas cambiar algo grande.

Vamos al detalle: qué es, cómo se estructura, cómo se evita que se degrade en la bola de barro de siempre y cómo se convierte en tu seguro de futuro, distribuyas o no.

Qué Es (y Qué No Es)

Un monolito modular es un sistema que se despliega como una sola unidad — un proceso, una base de datos, un despliegue — pero cuyo interior está dividido en módulos con fronteras explícitas. Cada módulo es dueño de un dominio: sus reglas de negocio, sus datos y su API pública interna. Los demás módulos solo pueden hablar con él a través de esa API.

Lo que no es:

  • Un monolito con carpetas ordenadas. Tener src/Invoicing/ y src/Catalog/ no es modularidad si cualquiera puede importar cualquier cosa de cualquiera. La frontera existe solo cuando se hace cumplir.
  • Un microservicio barato. No hay red, no hay despliegues independientes, no hay escalado por partes. Es un monolito: su gracia es que sus fronteras internas son tan limpias como las que exigiría un sistema distribuido.
  • Una etapa inferior que hay que superar. Muchos sistemas deberían quedarse aquí para siempre. La modularidad es un fin en sí misma; la distribución es opcional y a veces nunca llega.

Las Tres Reglas que lo Definen

Monolito enmarañado frente a monolito modular: a la izquierda llamadas cruzadas entre todos los módulos, a la derecha módulos que solo hablan entre sí a través de sus APIs públicas internas

Todo el monolito modular se reduce a tres reglas, y las tres se pueden verificar:

  1. Cada módulo tiene una API pública, y es la única puerta. Si el módulo de catálogo quiere saber si una factura existe, llama a InvoicingApi, no al repositorio de facturas. Lo que no está en la API pública es privado: entidades, repositorios, internals.
  2. Los datos tienen dueño. Cada tabla pertenece a un módulo. El resto no la toca: si necesitas datos ajenos, los pides por la API o los recibes por eventos internos. El JOIN que cruza módulos es el principio de la bola de barro.
  3. Las dependencias apuntan en una dirección. Catálogo puede depender de nada; facturación puede depender de catálogo; nunca al revés. Un grafo de dependencias acíclico entre módulos es lo que permite extraerlos mañana sin derramar nada.

Fíjate en lo importante: ninguna regla habla de frameworks ni de tecnología. Son reglas de estructura, y funcionan igual en Symfony, en Spring o en un monolito de Node.

Cómo se Hace Cumplir (Porque las Buenas Intenciones No Bastan)

Aquí es donde mueren la mayoría de los intentos: se dibujan las fronteras en una wiki y seis meses después todo el mundo las ha cruzado «porque era un método tonto». La solución es hacer que romper la frontera sea un error de build, no una discusión de code review:

  • Tests de arquitectura. Herramientas como ArchUnit (JVM), Deptrac (PHP) o dependency-cruiser (JS) permiten afirmar en un test: «nadie fuera de Invoicing puede importar Invoicing\Repository», «Catalog no puede depender de Invoicing». El CI falla cuando alguien cruza la línea. Sin esto, las fronteras son ficción.
  • La API pública explícita. Un directorio Api/ por módulo con las interfaces públicas, y el resto marcado como interno. Si tu lenguaje no lo fuerza, lo fuerza el test de arquitectura.
  • Eventos internos para lo que no encaja. Cuando facturación necesita reaccionar a «pedido confirmado» sin depender de pedidos, el evento interno rompe la dependencia. Es el primer peldaño de la escalera que vimos en CQRS y event-driven — y mañana, si hace falta, ese evento sale a un broker sin tocar el dominio.

El Seguro de Futuro

El retorno del monolito modular llega por tres vías, y solo una de ellas es la distribución:

  1. El cambio deja de dar miedo. Con fronteras claras, sabes qué toca cada cambio y qué no puede romper. Es la respuesta estructural al «cualquier cambio rompe algo lejano».
  2. El equipo se puede repartir. Cuando el equipo crece, cada persona o par puede ser dueño de un módulo sin pisar a los demás. La autonomía que prometen los microservicios, sin la red.
  3. Extraer es barato si algún día toca. Si mañana el procesador de imágenes necesita escalar por separado, la extracción es cambiar el transporte: la frontera, la API y los datos ya estaban separados. Lo que era una llamada de función pasa a ser HTTP — y ahí sí, empiezas a pagar el peaje distribuido con conocimiento de causa.

Y una ventaja silenciosa: la arquitectura hexagonal y el monolito modular se potencian. Puertos y adaptadores mantienen el dominio de cada módulo libre de infraestructura; las fronteras entre módulos mantienen libres unos dominios de otros. Es la combinación que hace que el sistema envejezca despacio.

Errores Comunes

  1. Modular por capas técnicas. «Módulo de controladores, módulo de servicios, módulo de repositorios» no es modularidad: es la bola de barro con estanterías. Los módulos se cortan por dominio — facturación, catálogo, pedidos — nunca por tipo de artefacto.
  2. El módulo «Common». Un cajón compartido donde todo el mundo mete utilidades acaba siendo el módulo del que todos dependen y al que todos temen tocar. Lo compartido debe ser pequeño, estable y de dominio neutro (fechas, dinero), no un vertedero.
  3. Fronteras sin enforcement. Ya lo hemos dicho, pero es el error más común: fronteras documentadas que nadie verifica. Si no falla el build, no existe la regla.
  4. La base de datos como excepción. «Solo un JOIN, es más rápido». Cada JOIN entre módulos es una soldadura entre ellos: el día que quieras separar, habrá que cortar con radial. Si el rendimiento exige leer datos ajenos, una proyección de solo lectura es mejor que tocar las tablas de otro.
  5. Modularizarlo todo de golpe. No hace falta un big-bang: se empieza por el módulo que más duele, se le dibuja frontera, se protege con tests de arquitectura y se sigue con el siguiente. La boy scout rule aplicada a la estructura.

En Resumen

El monolito modular es un solo despliegue con fronteras serias: cada módulo tiene su API pública, sus datos y su dirección de dependencias, y los tests de arquitectura lo garantizan en el CI. No es un microservicio pobre ni una fase de transición obligatoria: es la estructura que hace que un monolito envejezca bien y que, si algún día hace falta distribuir, la extracción sea cambiar el transporte y no reescribir el sistema. Fronteras hoy, red solo si mañana duele.

Si tu monolito se está convirtiendo en una bola de barro y quieres un plan para modularizarlo sin parar el negocio, podemos trazarlo contigo: qué módulos, en qué orden y con qué tests de protección. Hablemos →

Sigue leyendo: Qué es arquitectura hexagonal: guía práctica con un ejemplo real.

  • #arquitectura-hexagonal
  • #modular-monolith

Artículos relacionados

¿Empezamos?

¿Listo para construir algo que crezca con tu negocio?

Cuéntanos tus objetivos y trazaremos juntos la ruta de diseño, desarrollo y tecnología que te lleve de la visión a resultados medibles.