Monolito vs. microservicios

  • Lección 28 de 40
  • 14 min
  • Intermedio
  • 12 pasos

¿Un solo código o muchos servicios? Qué te da cada opción, cuánto te cuesta y cómo pasar de una a otra sin frenar el negocio.

Despliegues
40/día
Un fallo tumba
una función
Saltos de red por página
2–4
Carga operativa
alta
compradoresAPIGatewayBalanceadorAPIGatewayAPIGatewayAPIGatewayAPI GatewayMonolitotodas las funcionesMonolitoMonolitotodas las funcionesMonolitouna base de datosUsuariosUsuariosCatálogoCatálogoPedidosPedidosPagosPagosBD usuariosBD catálogoBD pedidosBD pagosusuarios · catálogo · pedidos · pagos97%fuga en reportes · sin memoriacaído · el checkout tambiénuna sola puerta de entradatodos comparten las tablasUna base por serviciosin tablas compartidassin joins entre serviciosdatos ajenos: API o eventoscada equipo elige su motorllamada a la APIlenta · 2 stimeouttren de lanzamientos: los 4 juntosllamadas en cadenahistorial: 20 pedidos× 20 llamadascopia local: nombre · fotoProductChangedcontrato: usa currencyCI: rompe el contrato de Pedidoscontrato probadoMonolito vs. microserviciosMonolitoMicroserviciosEquiposuno o pocosmuchosDesplieguetodo juntoindependienteLlamadasen memoriapor red, fallanDatosuna base, joinsuna por servicioOperaciónsimplemás herramientasusuarios · catálogo · pedidostodo lo demás/api/payments/*nuevollamada a la API
  • petición
  • respuesta
  • petición lenta
  • evento
  • petición fallida

Paso 1 de 12

Concepto

Una aplicación, un despliegue

Tu tienda en línea es un monolito: un solo código con todas las funciones (cuentas, catálogo, pedidos y pagos) que se despliega como una unidad. Corren dos copias idénticas detrás de un balanceador y ambas usan la misma base de datos.

Con un equipo pequeño es una gran opción: una función llama a otra en memoria, un despliegue lo publica todo y una sola traza de error cuenta la historia completa.

Paso 2 de 12

Problema

Seis equipos, un solo código

El equipo crece a unas cincuenta personas repartidas en seis equipos (valores de ejemplo). Todo sale en un único lanzamiento semanal, así que el error de un equipo frena el trabajo de los demás.

Una fuga de memoria en el nuevo módulo de reportes agota la RAM y tumba el proceso entero, checkout incluido. Y si solo la búsqueda necesita más recursos, igual tienes que escalar todas las copias de todo.

Qué cambió

  • Seis equipos comparten un lanzamiento
  • Un fallo en reportes tumba el checkout
  • Para escalar una función escalas todo

Paso 3 de 12

Solución

Separar por capacidad de negocio

Partes la aplicación en microservicios siguiendo las áreas del negocio: Usuarios, Catálogo, Pedidos y Pagos. Cada uno es un programa aparte, con un equipo dueño y su propio ritmo de despliegue.

Un API gateway da a los clientes una sola puerta de entrada y envía cada petición al servicio que le toca. Por ahora, los cuatro siguen usando la misma base de datos.

Qué cambió

  • Monolito
  • Cuatro servicios, uno por equipo
  • API gateway

Paso 4 de 12

Técnica

Cada servicio es dueño de sus datos

Mientras compartan la base de datos, los servicios siguen atados: si un equipo cambia una tabla, puede romper a otros tres sin enterarse. Por eso cada servicio recibe su propia base de datos y nadie más la toca.

¿Pedidos necesita saber si un pago se aprobó? Se lo pregunta a Pagos por su API o escucha los eventos que Pagos publica.

Qué cambió

  • Base de datos compartida
  • Una base de datos por servicio
  • Pedidos → Pagos por su API

Paso 5 de 12

Problema

Ahora hay una red en medio

Para mostrar la página de un pedido, el gateway llama a Usuarios, Catálogo y Pedidos, y Pedidos llama a Pagos: 4 llamadas de red donde antes había llamadas en memoria. Cada salto suma latencia y puede fallar por su cuenta: aquí Pagos tarda 2 s (valor de ejemplo) y Pedidos se rinde por timeout.

Depurar ahora implica cuatro repositorios. Necesitas timeouts, reintentos, trazas distribuidas y buenos paneles (el módulo de Fiabilidad) solo para volver al punto donde empezaba el monolito.

Qué cambió

  • 4 llamadas de red por página
  • Pagos tarda y Pedidos corta por timeout
  • La página falla o se degrada

Paso 6 de 12

Problema

Caso: el monolito distribuido

Un caso típico (ilustrativo): una empresa parte su monolito en doce servicios, pero cada uno sigue leyendo las tablas de los demás, y cada función nueva exige cambiar cinco servicios y publicarlos juntos.

Se quedan con los costos de red de los microservicios y el acoplamiento del monolito. Los lanzamientos se vuelven más lentos, no más rápidos.

Qué cambió

  • Los servicios leen datos ajenos
  • Hay que publicarlos juntos
  • Lo peor de ambos mundos

Paso 7 de 12

Problema

Caso: el historial de pedidos

La página de historial muestra cada pedido con el nombre y la foto del producto. En el monolito era un solo JOIN en SQL; ahora los pedidos viven en Pedidos, los productos en Catálogo, y no hay joins entre bases de servicios distintos.

Entonces Pedidos llama a Catálogo una vez por pedido: con 20 pedidos son 20 llamadas más la de entrada (el problema N+1). La página se vuelve lenta y, si Catálogo se cae, el historial cae con él.

Qué cambió

  • El historial necesita datos de Catálogo
  • 20 llamadas a Catálogo por página

Paso 8 de 12

Solución

Guarda una copia local para leer

Pedidos guarda su propia copia de los pocos campos de catálogo que muestra: nombre y foto. Cada vez que cambian, Catálogo publica un evento ProductChanged y Pedidos actualiza su copia.

El historial vuelve a ser una consulta a la base de Pedidos y sigue funcionando aunque Catálogo esté caído. El precio ni siquiera se consulta: el que cuenta es el que se pagó, y ya quedó guardado en el pedido.

Qué cambió

  • Eventos ProductChanged
  • Copia de nombre y foto en Pedidos
  • Llamadas a Catálogo por página

Paso 9 de 12

Técnica

Caso: un cambio de API rompe al vecino

El equipo de Pagos renombra el campo currency a currency_code. Sus pruebas pasan, despliegan… y todos los checkouts de Pedidos empiezan a fallar. Desplegar por separado solo funciona si un equipo no puede romper a otro por accidente.

Con pruebas de contrato guiadas por el consumidor, Pedidos publica exactamente qué campos usa de la API de Pagos. El pipeline de Pagos verifica esos contratos antes de cada lanzamiento, y el cambio se frena en CI en lugar de en producción.

Qué cambió

  • Pedidos publica un contrato con la API de Pagos
  • El cambio incompatible se frena en CI

Paso 10 de 12

Compromiso

¿Cuál te conviene?

Un camino habitual: empezar con un monolito modular, un solo desplegable con límites internos estrictos entre módulos, y separar un módulo como servicio solo cuando un equipo de verdad necesita independencia.

Paso 11 de 12

Técnica

Migrar con el patrón strangler fig

No reescribas todo de una vez. Pon el gateway delante del monolito, construye un servicio nuevo (Pagos) y envía solo /api/payments/* hacia él. Todo lo demás sigue yendo al monolito.

Mueve una capacidad a la vez hasta que el monolito sea tan pequeño que puedas retirarlo. Cada paso se puede publicar y también revertir. Mientras tanto, un fallo grave en el monolito aún tumba casi todo: solo los pagos quedan a salvo.

Qué cambió

  • Gateway delante del monolito
  • Servicio de Pagos nuevo con su propia base
  • /api/payments/* → servicio nuevo

Paso 12 de 12

Resumen

Resumen

Un monolito es simple y rápido hasta que muchos equipos tienen que compartirlo.

Los microservicios se cortan por capacidad de negocio y cada uno es dueño de sus datos.

Lo pagas con llamadas de red, fallas parciales y más trabajo de operación.

Cambia los joins por copias locales y protege las APIs con pruebas de contrato.

Evita el monolito distribuido y migra poco a poco con el patrón strangler fig.

Aprenderás

  • En qué brilla un monolito y dónde duele
  • Dividir por capacidad de negocio
  • El costo de poner una red en medio
  • Consultas entre servicios con copias locales
  • Pruebas de contrato y el monolito distribuido
  • Migrar sin riesgo con el patrón strangler fig