De monolito a microservicios: una estrategia de migración paso a paso
La mayoría de las migraciones a microservicios fracasan por las mismas pocas razones: límites equivocados, una reescritura de golpe y una capa de datos que nadie planificó. Aquí tienes un manual secuenciado que entrega valor cada pocas semanas y te permite parar cuando los números dejen de cuadrar.
En esta página7
- Primero, decide si deberías migrar siquiera
- Usa el patrón strangler fig, no una reescritura de golpe
- Traza los límites por dominio de negocio, no por capa técnica
- Empieza por los bordes, luego avanza hacia el interior
- Divide los datos con CDC, no con escrituras duales
- Haz la transición de una funcionalidad a la vez y verifica en paralelo
- Fija plazos realistas y una condición de parada
Primero, decide si deberías migrar siquiera
La respuesta honesta para muchos equipos es: todavía no. La encuesta CNCF 2025 halló que alrededor del 42% de las organizaciones que adoptaron microservicios están devolviendo algunos servicios a unidades más grandes porque el coste operativo superó al beneficio. Un umbral común entre profesionales: por debajo de unos 30 desarrolladores o un monolito de menos de 100.000 líneas, los microservicios suelen añadir coste con poco rendimiento. Migra cuando varios equipos estén bloqueados editando la misma base de código, cuando una funcionalidad tenga necesidades de escalado genuinamente distintas del resto, o cuando una capacidad necesite su propio equipo dedicado y cadencia de lanzamiento. Si el motivo es solo que «los monolitos se sienten anticuados», arregla primero la modularidad dentro del monolito (un monolito modular) y sáltate el impuesto de los sistemas distribuidos.
Usa el patrón strangler fig, no una reescritura de golpe
Las reescrituras completas son la forma más fiable de fracasar: plazos largos, facturas de nube triplicadas y fallos en producción que nadie puede aislar porque todo cambió a la vez. El patrón strangler fig, bautizado por Martin Fowler allá por 2004, hace crecer el nuevo sistema alrededor del viejo y retira el monolito pieza por pieza. Introduces una fachada (normalmente tu puerta de enlace de API o una capa de enrutamiento como Istio o un proxy basado en Envoy) que intercepta cada solicitud. Al principio dirige casi todo al monolito. A medida que extraes cada funcionalidad, cambias su ruta al nuevo servicio. Los usuarios nunca ven un día de corte. Y en cada paso la ruta de código antigua sigue ahí, que es tu reversión instantánea si el nuevo servicio se comporta mal.
Traza los límites por dominio de negocio, no por capa técnica
La causa número uno de migraciones fallidas es dividir por capa técnica: un servicio de UI, un servicio de lógica, un servicio de base de datos. Eso produce un monolito distribuido, toda la sobrecarga de red sin nada de la independencia. Divide por capacidad de negocio en su lugar: Pedidos, Inventario, Pagos, Notificaciones. La forma más rápida de encontrar esas líneas es un taller de Event Storming (la técnica de Alberto Brandolini): reúne a expertos de dominio e ingenieros en una sala, mapea lo que ocurre en el sistema como una línea temporal de eventos y luego agrúpalos. Los contextos delimitados emergen donde cambia el lenguaje. «Producto» en un contexto de catálogo (nombre, imágenes, SEO) es algo distinto de «Producto» en inventario (SKU, almacén, umbral de reposición). Dimensiónalos en torno al comportamiento, no a las entidades, o acabarás con servicios anémicos que no hacen nada por sí solos.
Empieza por los bordes, luego avanza hacia el interior
El instinto es extraer primero el núcleo «fácil»: autenticación, gestión de usuarios, el modelo de dominio central. Resístelo. Esas son justamente las piezas de las que todo lo demás depende, así que romperlas rompe el sistema entero. Empieza por los bordes, las funcionalidades hoja con pocas dependencias entrantes y límites de API claros. Un endpoint de informes, un worker de notificaciones, un trabajo de PDF o de exportación, una API pública de solo lectura. Estas te dan una victoria real en producción, prueban el pipeline (enrutamiento de la puerta de enlace, despliegue, observabilidad) y construyen el respaldo ejecutivo que necesitas para terminar. Elegir una primera porción de bajo riesgo es también lo que evita que una migración se estanque en un Frankenstein permanente a medias, la forma más común en que estos proyectos mueren en silencio.
Divide los datos con CDC, no con escrituras duales
Los datos son la parte más difícil de toda migración, y las escrituras duales (que la app escriba tanto en la base de datos antigua como en la nueva) son una trampa: las escrituras concurrentes pierden datos en silencio y no tienes garantía de transacción entre dos almacenes. Usa captura de cambios de datos basada en log en su lugar. Debezium (2.x y posteriores, con conectores para PostgreSQL, MySQL, MongoDB, SQL Server y Oracle) lee el log de transacciones de la base de datos y emite un evento por cada cambio confirmado, de modo que el nuevo servicio puede construir y mantener sincronizado su propio almacén sin tocar la ruta de escritura del monolito. Las versiones recientes añadieron instantáneas incrementales sin bloqueo y mejor semántica de exactamente-una-vez. Para los nuevos servicios que necesitan publicar sus propios eventos de forma fiable, combina CDC con el patrón outbox: escribe la fila de negocio y la fila de evento en una sola transacción local, y deja que CDC la propague. Y acepta de antemano el verdadero compromiso: las transacciones ACID entre servicios desaparecen. Donde antes envolvías todo en una transacción, ahora diseñas para consistencia eventual con sagas.
Haz la transición de una funcionalidad a la vez y verifica en paralelo
Por funcionalidad, el bucle es: extrae el servicio, apunta una pequeña porción de tráfico hacia él a través de la puerta de enlace y ejecuta las rutas antigua y nueva en paralelo mientras comparas resultados. Las herramientas de división de tráfico (Istio, Linkerd o una puerta de enlace Envoy) te permiten desplazar el 1%, luego el 10% y luego el 100%, y revertir en segundos deshaciendo la ruta. Levanta la observabilidad antes de la extracción, no después del primer incidente: logs estructurados, trazado distribuido (OpenTelemetry) y métricas por servicio en Prometheus o el APM que prefieras. La razón por la que los equipos se arrepienten de los microservicios suele ser operativa: reemplazar una app por cincuenta significa unas cincuenta veces los despliegues, logs y paneles, así que la plataforma tiene que estar lista antes de que lleguen los servicios. Una vez que una funcionalidad haya funcionado limpiamente a pleno tráfico, elimina la ruta de código muerta en el monolito. Solo cuando salga la última funcionalidad desmantelas el monolito. La meta es un final claro, no dos sistemas que cuidas para siempre.
Fija plazos realistas y una condición de parada
Análisis independientes de migraciones empresariales sitúan el plazo típico de extremo a extremo en unos 18-36 meses para un sistema grande, con un puñado de factores de riesgo (límites, datos, madurez operativa) responsables de la mayoría de los fracasos. Presupuesta el trabajo de plataforma, no solo los servicios: CI/CD, orquestación de contenedores, trazado y guardias deben madurar en paralelo. Igual de importante, define una condición de parada de antemano. Como el enfoque strangler entrega software funcional cada pocas semanas, se te permite pausar una vez que las partes dolorosas estén fuera y el resto del monolito esté bien donde está. La migración parcial es un resultado legítimo, a menudo óptimo. El fracaso no es parar pronto; es batallar con servicios que nunca necesitaron moverse.
Reciba ideas sobre operaciones cada semana
Únase a los responsables de empresas de servicios que reciben cada semana una idea práctica sobre operaciones, automatización y crecimiento.
Sin spam. Cancele cuando quiera.
¡Ya está suscrito! Busque nuestro próximo número en su bandeja de entrada.
No se pudo enviar. Inténtelo de nuevo o escriba a [email protected].
Preguntas frecuentes
¿Qué es el patrón strangler fig en una migración?
Es un enfoque incremental en el que haces crecer nuevos servicios alrededor del monolito existente y lo retiras pieza por pieza. Una capa de enrutamiento (normalmente tu puerta de enlace de API) se sitúa delante, envía la mayor parte del tráfico al monolito, y cambias la ruta de cada funcionalidad a un nuevo servicio una vez que está lista y verificada. No hay día de corte, y la ruta de código antigua es tu reversión en cada paso.
¿Cuánto tarda una migración de monolito a microservicios?
Para un sistema empresarial grande, análisis independientes sitúan el plazo típico en unos 18-36 meses de extremo a extremo, incluyendo el trabajo de plataforma (CI/CD, orquestación, observabilidad) del que dependen los servicios. Como el enfoque strangler entrega valor cada pocas semanas, obtienes beneficios mucho antes de que la migración completa esté hecha, y puedes parar una vez que los servicios de alto valor estén fuera.
¿Cómo se divide una base de datos compartida entre servicios?
Evita las escrituras duales, que pierden datos bajo concurrencia. Usa captura de cambios de datos basada en log (por ejemplo Debezium leyendo el log de transacciones) para que un nuevo servicio pueda construir y sincronizar su propio almacén sin tocar las escrituras del monolito. Combínalo con el patrón outbox para una publicación de eventos fiable, y diseña para consistencia eventual con sagas en lugar de transacciones entre servicios.
¿Qué servicio debería extraer primero?
Empieza por los bordes, no por el núcleo. Elige una funcionalidad hoja con pocas dependencias entrantes y un límite limpio, como informes, notificaciones o un trabajo de exportación. Extraer primero la autenticación o el modelo de dominio central es arriesgado porque todo depende de ello. Una victoria temprana y de bajo riesgo prueba el pipeline y evita que la migración se estanque.
¿Debería migrar a microservicios siquiera?
Solo si tienes un problema real que los microservicios resuelvan: varios equipos bloqueados en una base de código, una funcionalidad con necesidades de escalado genuinamente distintas, o una capacidad que necesite su propio equipo y cadencia. Alrededor del 42% de los adoptantes (CNCF 2025) están consolidando servicios de vuelta. Si tu equipo es pequeño o el monolito es modesto, un monolito modular suele entregar la mayor parte del beneficio sin nada de la sobrecarga de los sistemas distribuidos.
¿Por qué fracasan la mayoría de las migraciones a microservicios?
Tres causas recurrentes: dividir por capa técnica en lugar de por dominio de negocio (creando un monolito distribuido), intentar una reescritura de golpe donde ningún fallo se puede aislar, y subestimar la complejidad de datos y operativa. Los límites equivocados son lo más común. Usa Event Storming para encontrar los límites de dominio, el patrón strangler para migrar de forma incremental y levanta la observabilidad antes de extraer nada.
¿Listo para lanzar?
Cuéntenos dónde está atascado. Lo revisaremos y le enviaremos una recomendación concreta en un día hábil.