Saltar al contenido

Plan de rollback antes de desplegar: versión, migraciones y verificación

En la práctica/ 10 min de lectura

Escribe la vuelta atrás antes del deploy: qué versión, una base que el código anterior aguante (expandir y contraer) y un script que decide. Probado en PGlite.

  • Bases de datos
  • Migración
  • QA
En este artículo (8)
  1. Por qué el plan de rollback se decide antes de desplegar
  2. Regla 1: una versión identificable y un camino de vuelta
  3. Regla 2: migraciones que el código anterior aguante (expandir y contraer)
  4. Regla 3: verificar después de desplegar
  5. Primero regresa, luego investiga
  6. Errores comunes
  7. Preguntas frecuentes
  8. Checklist

Un plan de rollback es una nota corta que escribes antes de desplegar: a qué versión vuelves, cómo vuelves, si la base de datos sigue funcionando con el código anterior y qué comprobaciones lo deciden. Unas pocas líneas escritas cuando nada está roto convierten un mal despliegue en un paso rutinario y no en una discusión.

Los ejemplos usan una app web en Node en una plataforma que conserva el build anterior, y una tabla pequeña de Postgres. El SQL corrió en PGlite (PostgreSQL 18.6 en WebAssembly) y el script contra un servidor local desechable; los pasos de la plataforma salen de su documentación y no los ejecutamos en un despliegue real. Es la misma nota que vas a necesitar para cada arreglo urgente durante un code freeze antes de Black Friday.

Por qué el plan de rollback se decide antes de desplegar

A las once de la noche, con el checkout devolviendo errores, nadie piensa bien. Hay que responder cuatro cosas a la vez: cuál fue la última versión buena, cómo volver a ella, si la base de datos funciona con ella y quién decide. Si las respuestas viven en la cabeza de alguien, los primeros diez minutos se van en encontrarlas. El plan las mueve a un momento tranquilo y se apoya en tres reglas: conocer la versión y el camino de vuelta, hacer migraciones compatibles con el código anterior y verificar con un script en lugar de una impresión.

Antes, conviene saber qué es un rollback. La guía de Railway para revertir un deploy malo y su página de acciones de deployment son un ejemplo público claro; otras plataformas difieren, así que lee la tuya con esta tabla al lado.

Qué¿Lo devuelve el rollback?Nota
La imagen de la appSíReactiva la imagen Docker de un deployment anterior como deployment nuevo, sin reconstruir
Las variables personalizadasSíVuelven como estaban, así que un cambio de variable malo también se revierte
Esquema y datos de la baseLa guía no lo describeNo menciona bases de datos ni migraciones: es cosa tuya (regla 2)
Deployments más viejos que la retenciónNoLa opción Rollback no aparece; Redeploy reconstruye desde el código original

Regla 1: una versión identificable y un camino de vuelta

Haz que cada deploy se pueda identificar: que /healthz devuelva un identificador de versión (el hash corto del commit sirve). Y nombra el destino con ese identificador, «la última versión que funcionó», no «el deploy anterior»: si salieron dos malos seguidos, el anterior también está roto.

un rollback es un deployment nuevo con la imagen anteriorservicio webdeploy 1imagen v1funcionadeploy 2imagen v2verify fallarollbackimagen v1+ variables v1deploy 3v2 corregidatras investigarreusa la imagen guardada, sin buildbase de datosel rollback no la tocaesquema v1migra a v2sigue en v2v2vuelven la imagen y las variables, no los datosretención en Railway: 24 h Free/Trial · 72 h Hobby · 120 h Pro · 360 h Enterprise

Desliza la figura para verla completa

Escribe el camino. En Railway, según su guía, se abre la pestaña Deployments del servicio, se busca el último deployment bueno y en el menú de tres puntos se elige Rollback. Restaura la imagen Docker y las variables personalizadas como un deployment nuevo y activo, sin reconstruir, así que tarda segundos, siempre que la plataforma aún guarde la imagen: 24 horas en Free/Trial, 72 en Hobby, 120 en Pro y 360 en Enterprise. Pasado ese plazo queda Redeploy, que reconstruye desde el código y las variables originales: es más lento y depende de que el build vuelva a salir bien.

No confundas el healthcheck con la verificación. Con una ruta de healthcheck, la plataforma cambia el tráfico solo tras un 200 y, si falla, el deployment anterior sigue sirviendo; pero la guía aclara que corre solo al desplegar. Un cambio que arranca bien y rompe la página de producto lo pasa sin problema.

La plantilla cabe en siete líneas:

  • Versión a la que vuelves: el identificador.
  • Cómo vuelves: los pasos exactos y quién tiene acceso.
  • Ventana: cuánto conserva la plataforma la imagen anterior.
  • Base de datos: la última migración y si ya se contrajo (regla 2).
  • Criterio: qué resultado dispara el rollback, por ejemplo «el script de verificación sale con código distinto de 0».
  • Quién decide: un nombre, con teléfono.
  • A quién se avisa: ventas, soporte, la agencia.

Regla 2: migraciones que el código anterior aguante (expandir y contraer)

El rollback devuelve código, no esquema. En PGlite, con una tabla customers(id, email, name), ALTER TABLE customers RENAME COLUMN name TO full_name hizo que el código nuevo funcionara y que el viejo fallara con column "name" does not exist, al leer y al insertar. Un solo paso, y se acabó la vuelta atrás.

La salida es el patrón que Martin Fowler publica como parallel change, o expandir y contraer (texto de Danilo Sato, mayo de 2014): expandir añade lo nuevo junto a lo viejo, migrar mueve a los clientes y contraer quita lo viejo cuando nadie lo usa. El paso de expandir, antes del deploy:

ALTER TABLE customers ADD COLUMN full_name text;

CREATE FUNCTION customers_sync_name() RETURNS trigger AS $$
BEGIN
  IF TG_OP = 'INSERT' THEN
    NEW.full_name := COALESCE(NEW.full_name, NEW.name);
    NEW.name := COALESCE(NEW.name, NEW.full_name);
  ELSIF NEW.full_name IS DISTINCT FROM OLD.full_name THEN
    NEW.name := NEW.full_name;
  ELSIF NEW.name IS DISTINCT FROM OLD.name THEN
    NEW.full_name := NEW.name;
  END IF;
  RETURN NEW;
END $$ LANGUAGE plpgsql;

CREATE TRIGGER customers_sync_name
  BEFORE INSERT OR UPDATE ON customers
  FOR EACH ROW EXECUTE FUNCTION customers_sync_name();

UPDATE customers SET full_name = name WHERE full_name IS NULL;
  1. ADD COLUMN full_name text añade la columna sin valor por defecto; según la documentación de PostgreSQL, eso no reescribe la tabla.
  2. customers_sync_name mantiene las dos columnas iguales: en un INSERT rellena la que el código dejó vacía y en un UPDATE copia a la otra la que cambió.
  3. CREATE TRIGGER la ejecuta antes de cada INSERT o UPDATE, fila por fila.
  4. El UPDATE final copia las filas existentes. En una tabla grande, hazlo por lotes.
renombrar name a full_name sin romper el rollback1 · expandirADD COLUMN full_nametrigger sincronizaname y full_nameUPDATE: backfillv1 ok · v2 okantes del deploy2 · migrardeploy de v2:lee y escribefull_namev1 no se enterav1 ok · v2 okrollback seguro3 · contraerSET NOT NULLDROP TRIGGERDROP FUNCTIONDROP COLUMN namev1 rompe · v2 okya sin vuelta a v1contrae solo cuando ya no vas a volver a v1: pasado el plazo de rollbackcada paso es compatible con el código anteriorprobado en PGlite 0.5.10 (PostgreSQL 18.6): un RENAME directo rompe v1

Desliza la figura para verla completa

Luego desplegamos la versión nueva, que solo usa full_name. En cualquier orden, cada versión leyó bien las filas que escribió la otra, incluso al volver a la vieja con filas escritas por la nueva; las cuatro filas terminaron con name igual a full_name. Ahí el rollback es seguro. Sin el trigger no lo era: en un control, el insert de la versión nueva falló con null value in column "name" … violates not-null constraint y el update de la vieja dejó full_name desactualizada. El trigger es una versión mínima: pruébalo con tus propios escritores.

Contraer va al final, y solo cuando ya no vas a volver:

ALTER TABLE customers ALTER COLUMN full_name SET NOT NULL;
DROP TRIGGER customers_sync_name ON customers;
DROP FUNCTION customers_sync_name();
ALTER TABLE customers DROP COLUMN name;
  1. SET NOT NULL deja full_name como la columna obligatoria.
  2. DROP TRIGGER y DROP FUNCTION quitan la sincronización, que ya sobra.
  3. DROP COLUMN name elimina la vieja; la documentación aclara que queda invisible, pero el espacio no se libera de inmediato.

Después la versión vieja falla con column "name" does not exist: ya no hay vuelta a ella. Por eso contraer espera a que pase la ventana del rollback, y por eso el plan anota si ya se hizo.

Regla 3: verificar después de desplegar

Un deploy «terminado» solo significa que el proceso arrancó. Este script comprueba cuatro rutas, incluida la versión, y sale con código distinto de cero si algo falla, para que una persona o un pipeline actúen sin interpretar nada:

// Uso: node verify.mjs <url-base> <release-esperada>
const [base, release] = process.argv.slice(2);

const checks = [
  { path: "/healthz", status: 200, ok: (b) => JSON.parse(b).release === release },
  { path: "/", status: 200, ok: (b) => b.includes("<h1") },
  { path: "/products/blue-shirt", status: 200, ok: (b) => b.includes("Add to cart") },
  { path: "/this-page-does-not-exist", status: 404 },
];

let failed = 0;
for (const c of checks) {
  try {
    const res = await fetch(base + c.path, { signal: AbortSignal.timeout(5000) });
    const body = await res.text();
    const pass = res.status === c.status && (!c.ok || c.ok(body));
    if (!pass) failed++;
    console.log((pass ? "ok   " : "FAIL ") + c.path + " " + res.status);
  } catch (err) {
    failed++;
    console.log("FAIL " + c.path + " " + err.name + ": " + err.message);
  }
}
console.log(failed ? failed + " check(s) failed: roll back" : "all checks passed");
process.exit(failed ? 1 : 0);
  1. Recibe la URL base y la versión que esperas; cambia las rutas por las de tu proyecto.
  2. Cada comprobación tiene una ruta, un estado esperado y, si hace falta, una prueba sobre el cuerpo. /healthz debe devolver la versión recién desplegada (así detecta que sigue sirviendo la vieja), la página de producto debe contener el botón «Add to cart» (no basta un 200) y una ruta inexistente debe dar 404 (así detecta un servidor que responde 200 a todo).
  3. El fetch expira a los cinco segundos; una petición que falla cuenta como fallo.
  4. Sale con 1 si algo falló y con 0 si todo pasó.

Lo corrimos en local contra un servidor de prueba en 127.0.0.1: versión nueva sana, código 0; página de producto con 500, código 1; versión vieja todavía sirviendo, código 1; nada escuchando, código 1. El servidor es una simulación, así que el script vale lo que valgan sus rutas. Para el flujo de compra completo, suma el smoke test del checkout.

verify.mjs después del deploy: cuatro rutas, un exit coderutaesperav2 sanav2 · 500aún v1/healthz200 + releaseokokFAIL/200 + <h1okokok/products/blue-shirt200 + botónokFAILok/this-page-does-not-exist404okokokexit code0 = sigue011un solo fallo da exit 1: regresa a la versión anteriormedido en local con Node 22.22.3 contra un servidor de prueba en 127.0.0.1

Desliza la figura para verla completa

Primero regresa, luego investiga

Si la verificación falla, vuelve primero y entiende después. La versión rota deja de servir y tú reproduces el fallo en una copia, con los registros delante, sin clientes pagando tu tiempo. Un arreglo improvisado sobre producción es otro deploy sin plan.

La excepción es la que justifica la regla 2: con una migración ya contraída no hay a dónde volver, solo un arreglo hacia adelante. Cuando hayas vuelto, anota qué pasó y qué cambias en el plan; el arreglo se despliega como cualquier otro, con su versión, su camino de vuelta y su verificación.

Errores comunes

  • Renombrar o borrar una columna en el mismo deploy que usa el nombre nuevo. Deja el rollback sin base compatible. Expande, migra y contrae por separado.
  • Dar por hecho que el rollback devuelve la base. La guía de la plataforma habla de imagen y variables, no de datos.
  • No saber cuánto dura la ventana. Con 24 horas de retención, un fallo del viernes descubierto el lunes ya no se revierte con un clic.
  • Verificar solo la portada. Un 200 en la portada no dice nada de la página de producto ni del carrito.
  • Tomar el healthcheck por verificación posterior. Corre al desplegar y no vuelve a mirar.

Preguntas frecuentes

¿Puedo hacer rollback si ya corrí una migración?

Sí, si es compatible con el código anterior. Una migración que solo expande (una columna nullable, una tabla, un índice) no impide volver; una que borra o renombra, sí.

¿Cuánto tiempo tengo para hacer rollback?

Depende de la plataforma. En Railway, según su guía, la imagen se conserva 24 horas en Free/Trial, 72 en Hobby, 120 en Pro y 360 en Enterprise. Después queda Redeploy.

¿Cuál es la diferencia entre rollback y redeploy?

El rollback reactiva una imagen ya construida, con las variables que tenía, sin build. El redeploy construye otra vez desde el código original: tarda más y puede fallar si el build ya no funciona.

¿Es lo mismo que hacer git revert?

No. Un git revert crea un commit nuevo que debe pasar otra vez por el build y el deploy. Primero vuelves con el rollback y después revierte el commit, para que la rama no vuelva a desplegar el cambio malo.

Checklist

  • Cada deploy se identifica: /healthz devuelve la versión.
  • El plan nombra la versión a la que vuelves y los pasos están escritos.
  • Sabes cuánto tiempo guarda tu plataforma la imagen anterior.
  • Las migraciones de este deploy solo expanden; contraer va en uno posterior.
  • El script de verificación cubre las rutas que dan dinero y comprueba la versión.
  • El criterio del rollback y quién decide están escritos.

Si Black Friday está cerca, cada arreglo urgente del code freeze debería llevar su plan. Y si el cambio es una imagen nueva, anota la anterior antes de tocar nada, como en actualizar Node en Docker.

¿Viste esto en Instagram? Comenta ROLLBACK en el Reel y te mando la guía.

Escrito por

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

Publicado el 12 de noviembre de 2026 · actualizado el 18 de noviembre de 2026

← Blog