Migración de base de datos sin tiempo de inactividad: un manual para producción
La mayoría de las caídas durante una migración nacen de un único error: desplegar un cambio de esquema y el código que depende de él en el mismo movimiento. Sepáralos, ejecuta lo viejo y lo nuevo en paralelo durante un tiempo y las partes que dan miedo se vuelven aburridas. Este es el manual que usamos para cambiar esquemas y mover bases de datos en producción sin una ventana de mantenimiento.
El esquema8
- Qué significa realmente "sin tiempo de inactividad"
- El patrón expand-contract es todo el juego
- Escritura dual: mantén ambas copias honestas
- Backfill sin fundir la base de datos
- Valida antes de confiar en la nueva copia
- El bloqueo es la verdadera fuente del tiempo de inactividad
- Moverse a una nueva base de datos: carga masiva, CDC, conmutación
- Dónde encaja esto con cómo trabajamos
Qué significa realmente "sin tiempo de inactividad"
Sin tiempo de inactividad no significa magia. Significa que nunca hay un momento en el que la aplicación en ejecución no pueda leer y escribir lo que necesita. La versión honesta, tomada de quienes mueven grandes bases de datos para ganarse la vida, es "conmutación casi sin interrupción": el nuevo estado refleja el viejo lo bastante de cerca como para que los usuarios nunca noten un hueco.
Dos problemas distintos se esconden bajo la misma frase, y necesitan tácticas distintas. El primero es la evolución del esquema: cambiar tablas, columnas, tipos y restricciones dentro de una base de datos que se queda donde está. El segundo es la reubicación: mover datos a una nueva base de datos, un nuevo motor o una nueva región. La regla que unifica ambos casos es la misma. Una migración debe completarse mientras el código antiguo de la aplicación sigue corriendo, y el código nuevo debe funcionar contra la forma vieja y la nueva durante el solapamiento. Desacopla el cambio de esquema del despliegue y todo el asunto deja de ser un único evento aterrador.
El patrón expand-contract es todo el juego
Casi todo cambio de esquema seguro es una variante de expand-contract, también llamado cambio paralelo. En lugar de una migración atómica que lo cambia todo de golpe, divides el trabajo en fases que se despliegan de forma independiente y cada una sigue siendo retrocompatible.
Expand: añade la nueva columna, tabla o índice junto a la antigua. Nada se rompe porque nada se elimina. La aplicación empieza a escribir en ambas representaciones (dual-write) pero sigue leyendo de la antigua.
Migrate: rellena las filas históricas con la nueva forma, luego verifica, luego conmuta las lecturas a la nueva columna mientras la escritura dual continúa.
Contract: deja de escribir en la columna antigua, renómbrala para que cualquier referencia olvidada falle de forma ruidosa, observa y solo entonces elimínala.
La razón por la que esto funciona es que la frontera entre fases es donde despliegas y observas. Si algo parece ir mal, la fase anterior sigue plenamente funcional. Puedes pausar indefinidamente en lugar de revertir un cambio aplicado a medias mientras suenan las alertas. Los cambios puramente aditivos son el caso fácil: el código antiguo simplemente ignora la nueva columna. La disciplina importa sobre todo cuando estás cambiando o eliminando algo de lo que depende la aplicación en vivo.
Escritura dual: mantén ambas copias honestas
Durante la ventana de solapamiento, cada escritura tiene que llegar tanto a la ubicación vieja como a la nueva o la nueva copia se queda atrás en silencio. Tienes dos maneras de hacerlo y la elección tiene consecuencias reales.
La escritura dual en la capa de aplicación significa que tu código escribe explícitamente en ambos sitios. Aparece en trazas y registros, así que cuando algo diverge puedes depurarlo con el stack de observabilidad en el que ya confías. Los triggers de base de datos pueden mantener las columnas sincronizadas con menos código de aplicación, pero el comportamiento ocurre dentro de la base de datos, donde tu instrumental normal no puede verlo, lo que vuelve miserable la depuración. Para la mayoría de los equipos, el pequeño coste de una escritura explícita de aplicación vale la trazabilidad.
El filo afilado de la escritura dual es que dos escrituras no son una única transacción atómica. Si la primera tiene éxito y la segunda falla, las copias se desvían. Para cualquier cosa donde eso importe, encamina las escrituras a través de un outbox transaccional o una propagación basada en colas, de modo que una única transacción confirmada sea la fuente de verdad y la segunda escritura derive de ella. Aquí también una herramienta como pgroll adopta un enfoque distinto en Postgres: expone vistas específicas de versión para que las versiones vieja y nueva de la app vean cada una el esquema que esperan, y maneja la lógica dual en la capa de base de datos en lugar de en tu código.
Backfill sin fundir la base de datos
Las nuevas escrituras van a ambas copias en el momento en que la escritura dual está activa, pero las filas históricas no se mueven solas. El backfill copia los datos existentes a la nueva forma. Hazlo en lotes, normalmente unos pocos miles de filas a la vez, con una pausa deliberada entre lotes para no saturar la E/S y privar de recursos al tráfico en vivo.
Mantén el backfill en un trabajo separado del cambio de esquema. Añadir una columna NOT NULL con un valor por defecto y rellenar millones de filas en la misma migración es como un cambio de dos segundos se convierte en un bloqueo de horas. En Postgres, añade una restricción NOT NULL como NOT VALID primero, lo cual es instantáneo porque omite el escaneo de la tabla, y luego ejecuta VALIDATE CONSTRAINT por separado, que toma un bloqueo más ligero que permite que las lecturas y escrituras continúen.
Programá los backfills pesados para ventanas de bajo tráfico, regúlalos y vigila tus réplicas. Si ejecutas réplicas de lectura, pueden llevar brevemente un esquema distinto al del primario, así que la app tiene que tolerar ese retraso durante la migración.
Valida antes de confiar en la nueva copia
Contar filas no es validar. Los conteos de filas pueden coincidir mientras los contenidos difieren. Antes de mover las lecturas, verifica con checksums o hashes en las tablas críticas y comprobaciones de invariantes sobre datos muestreados, no solo totales. Si ya estás leyendo de ambas copias para algunas consultas, una comparación a nivel de aplicación que marque discrepancias en tiempo real es la señal más fuerte que puedes obtener.
El backfill es también tu oportunidad de arreglar la calidad de los datos. Migrar filas históricas saca a la superficie las inconsistencias que producción ha estado tolerando en silencio durante años, así que trata el backfill como una pasada de limpieza, no solo como una copia.
No cortes la escritura dual demasiado pronto. Mantén ambas copias vivas y sincronizadas durante al menos un ciclo de negocio completo después de conmutar las lecturas. Desactivar el camino viejo antes de tiempo oculta discrepancias que aún no has detectado, y te quita tu rollback más barato.
El bloqueo es la verdadera fuente del tiempo de inactividad
La propia sentencia DDL suele ser rápida. La caída viene de la contención de bloqueos a su alrededor. Un fallo común: un ALTER solicita un bloqueo exclusivo, se queda atascado detrás de una transacción de larga duración o una sesión abierta olvidada, y cada consulta que llega después de él se encola tras el bloqueo. Un simple cambio de esquema escala hasta un parón a nivel de todo el servicio.
Defiéndete. Establece siempre un lock_timeout corto para que una DDL bloqueada falle rápido en lugar de atascar la cola. En Postgres, construye índices con CREATE INDEX CONCURRENTLY para que las escrituras prosigan durante la construcción, y recuerda que espera a las transacciones que comenzaron antes que él, así que mata primero las consultas largas perdidas. Postgres además envuelve la DDL en transacciones, así que una migración fallida hace rollback limpiamente.
En MySQL el panorama depende de la versión. Comprueba que tu cambio admite ALGORITHM=INPLACE, LOCK=NONE, y ten en cuenta que algunas operaciones antes de 8.0.29 reconstruyen toda la tabla y bloquean las escrituras. Para tablas con muchísimas filas donde incluso un ALTER online es arriesgado, recurre a una herramienta externa: gh-ost o pt-online-schema-change en MySQL, pgroll o pg_osc en Postgres. Construyen una copia sombra, la sincronizan por trozos e intercambian atómicamente mientras el original sigue plenamente utilizable.
Moverse a una nueva base de datos: carga masiva, CDC, conmutación
Reubicar una base de datos, entre motores, versiones o regiones, sigue tres fases. Primero, una carga masiva establece una línea base: un volcado y restauración nativos, o un snapshot, hacia el destino. Segundo, la captura de cambios (CDC) o la replicación lógica transmite cada inserción, actualización y borrado desde el origen al destino para que la brecha siga estrechándose hacia un retraso casi nulo. Para movimientos dentro del mismo motor, la replicación lógica de Postgres o la replicación de binlog de MySQL suele ser el camino más limpio, y la replicación lógica incluso abarca versiones mayores. Aplica el esquema en el destino primero, porque la replicación lógica no transporta DDL.
Tercero, la conmutación. Planifícala como una ventana de solo lectura de segundos, no de minutos: detén brevemente las escrituras en el origen, confirma que el retraso de replicación ha llegado a cero, luego redirige el tráfico cambiando la cadena de conexión, el DNS o la ruta del balanceador de carga. Vigila la deriva de secuencias y auto-incrementos: si la secuencia del destino va por detrás del origen, las nuevas inserciones chocan con los IDs replicados. Tras la conmutación, ejecuta VACUUM/ANALYZE u OPTIMIZE TABLE, y no apagues el origen. Mantenlo vivo, idealmente en solo lectura, durante al menos 24 horas como tu rollback. Antes de que nada de esto toque producción, haz una conmutación de prueba completa en staging contra datos a escala de producción, porque un cambio que tarda dos segundos en un portátil puede tardar horas con el volumen real.
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].
Dónde encaja esto con cómo trabajamos
Ninguno de estos pasos es difícil de forma aislada. El riesgo vive en secuenciarlos correctamente, saber en qué fase puedes pausar con seguridad y tener un rollback que de verdad funcione bajo presión. Eso es exactamente el tipo de trabajo para el que están hechos nuestros sprints de alcance fijo de 30 días: una migración claramente definida, planificada como expand-migrate-contract, con el runbook de backfill, validación y conmutación escrito y ensayado antes de que nada se despliegue.
Si estás migrando por completo fuera de un sistema antiguo en lugar de remodelar el actual, los mismos principios impulsan un desmantelamiento limpio: ejecución dual, demuestra el nuevo camino y luego retira el viejo en una línea de tiempo documentada. Y si prefieres que alguien sea dueño de la estrategia general de datos e infraestructura a lo largo de varios de estos cambios, eso es territorio de CTO fraccional. En cualquier caso, el objetivo es el mismo que el de todo este artículo: hacer que la migración sea aburrida.
¿Listo para lanzar?
Cuéntenos dónde está atascado. Lo revisaremos y le enviaremos una recomendación concreta en un día hábil.
Preguntas frecuentes
¿Puedo hacer una migración sin tiempo de inactividad en un solo despliegue?
No, no para nada que vaya más allá de un cambio puramente aditivo. Una migración segura que cambie o elimine una columna o tabla necesita al menos dos ciclos de versión: uno para añadir la nueva estructura, escribir en paralelo y rellenar, y otro posterior para conmutar las lecturas y eliminar la estructura antigua. Todo el sentido es mantener el código antiguo funcionando contra el nuevo esquema durante el solapamiento, algo que un único despliegue atómico no puede garantizar.
¿Debería vivir la escritura dual en la aplicación o en los triggers de la base de datos?
Prefiere la capa de aplicación en la mayoría de los casos. Las escrituras duales explícitas aparecen en tus trazas y registros, así que cuando las dos copias divergen puedes depurarlo con las herramientas de observabilidad que ya usas. Los triggers mantienen la lógica fuera de tu código pero se ejecutan dentro de la base de datos, donde tu trazado normal no puede verlos, lo que vuelve los incidentes mucho más difíciles de diagnosticar. Para escrituras críticas en atomicidad, encamina a través de un outbox transaccional o una cola para que la divergencia no pueda ocurrir en silencio.
¿Cómo verifico que los datos viejos y nuevos realmente coinciden?
No te fíes de los conteos de filas. Usa checksums o hashes en tus tablas críticas más comprobaciones de invariantes sobre filas muestreadas, porque los conteos pueden coincidir mientras los contenidos difieren. Si tu app ya lee de ambas copias para algunas consultas, añade una comparación en tiempo real que marque discrepancias. Mantén la escritura dual corriendo y reconcilia durante al menos un ciclo de negocio completo después de conmutar las lecturas antes de confiar solo en la nueva copia.
¿Por qué un cambio de esquema rápido aún provoca una caída?
Casi siempre es contención de bloqueos, no la DDL en sí. Un ALTER que necesita un bloqueo exclusivo puede atascarse detrás de una transacción de larga duración o una sesión abierta olvidada, y cada consulta que llega después se encola tras el bloqueo, convirtiendo un cambio rápido en un parón de todo el servicio. Establece un lock_timeout corto para que la DDL bloqueada falle rápido, usa CREATE INDEX CONCURRENTLY en Postgres y limpia las consultas largas perdidas antes de empezar.
¿Qué pasa con las tablas demasiado grandes para un ALTER normal?
Usa una herramienta de cambio de esquema online que construya una copia sombra y la intercambie. En MySQL, gh-ost o pt-online-schema-change copian datos por trozos e intercambian atómicamente mientras el original sigue utilizable. En Postgres, pgroll maneja el patrón expand-contract con vistas conscientes de la versión, o pg_osc maneja cambios grandes puntuales. Aún necesitas entender el bloqueo; las herramientas gestionan el archivo y la ejecución, pero lock_timeout, CONCURRENTLY y los pasos pequeños y seguros siguen siendo cosa tuya.
¿Cómo es un plan de rollback de verdad?
El rollback se vuelve más fácil cuanto más temprano estás en las fases. Desde la fase expand, la nueva columna es aditiva y no se usa para lecturas, así que simplemente eliminas el código de escritura dual y despliegas. En mitad de la conmutación, vuelve a poner el flag de lectura en la columna antigua, mantén la escritura dual corriendo e investiga sin perder los nuevos datos. Al reubicar a una nueva base de datos, mantén el origen vivo y en solo lectura durante al menos 24 horas después de la conmutación para poder redirigir el tráfico de vuelta si algo sale a la superficie.