Actualizar Next.js no actualiza tu Node: cómo cambiarlo en Docker
Actualización/ 15 min de lectura
Node.js corrigió 22.x, 24.x y 26.x el 21 de octubre de 2026, pero npm no toca tu runtime. Cambia la imagen base, reconstruye con --pull y comprueba node -v.
- Node.js
- Seguridad
En este artículo (8)
Actualizar Next.js no cambia la versión de Node que corre tu app: el runtime viene de la imagen base de Docker o de tu plataforma, no de package.json. Para tomar los parches del 21 de octubre de 2026, sube la imagen a 22.23.4, 24.22.1 o 26.12.1, o posterior, reconstruye con --pull, despliega y comprueba con node -v.
Por mucho que actualices next, el Node que instala tu build puede salir de una imagen o de un archivo fijo. Aquí van los parches, por qué npm no toca el runtime, cómo cambiar la imagen en Docker y en otras plataformas, y qué hacer si sigues en Node 20.
Qué corrigió Node.js el 21 de octubre
El miércoles 21 de octubre de 2026, Node.js publicó versiones nuevas de las líneas 26.x, 24.x y 22.x que corrigen diez vulnerabilidades (cuatro altas, tres medias y tres bajas), según el aviso de seguridad de octubre de Node.js. Las versiones con parche son 22.23.4, 24.22.1 y 26.12.1.
La más seria es CVE-2026-111497 (alta), en el decodificador Brotli que viene con Node: según el aviso, si tu aplicación descomprime con node:zlib datos Brotli que manda un atacante, este puede corromper la memoria del proceso, con riesgo de un crash, de exponer memoria o de ejecución remota de código. Las otras tres altas son de red: dns.resolve con nombres que contienen un carácter NUL (CVE-2026-105482) y dos formas de saltarse la verificación del nombre de host en certificados TLS (CVE-2026-105483 y CVE-2026-106069). El parche también actualiza piezas que vienen dentro del binario, como c-ares, los certificados raíz, OpenSSL (3.5.9 en 22.23.4) y Undici. Nada de eso está en tu node_modules.
| Línea | Con parche (21 oct) | Última al 2 de noviembre | Estado | Fin de soporte |
|---|---|---|---|---|
| 26.x | 26.12.1 | 26.13.0 | Active LTS desde el 28 de octubre | 30 de abril de 2029 |
| 24.x | 24.22.1 | 24.22.2 | Maintenance LTS | 30 de abril de 2028 |
| 22.x | 22.23.4 | 22.23.4 | Maintenance LTS | 30 de abril de 2027 |
| 20.x | Ninguna | 20.20.2 (24 de marzo) | End-of-Life | 30 de abril de 2026 |
Node.js 26.13.0 (28 de octubre) marca el paso de 26.x a LTS y, según sus notas, no cambia nada más respecto a 26.12.1. 24.22.2, del mismo día, trae arreglos de V8 y contiene 24.22.1: lo comprobé comparando las etiquetas en GitHub. La columna «con parche» es la mínima; cualquier versión posterior de la línea sirve. Las fechas de fin de soporte vienen del calendario de releases de Node.js.
Desliza la figura para verla completa
Una confesión: mi computadora, donde probé el código de este artículo, tiene Node 22.22.3, anterior al parche. Pero el que importa es el de producción, y ese casi nadie lo revisa.
Por qué actualizar dependencias no cambia tu runtime
Node no es una dependencia de tu proyecto: es el programa que lo ejecuta. npm install next@… reescribe package.json, el lockfile y node_modules, y nada más; así se aplica el parche de Next.js del 3 de noviembre, que explico en qué hacer con el parche de seguridad de Next.js. Ni siquiera engines instala algo: la documentación de npm dice que, salvo que actives engine-strict, solo produce advertencias. El binario node está en la imagen base de Docker o en lo que instala tu plataforma durante el build.
En Docker se ve en las capas. La imagen oficial node:24.22.2-bookworm-slim tiene cinco: Debian bookworm, el usuario node, el binario de Node 24.22.2, Yarn 1.22.22 y el script de entrada. Encima van las tuyas, con node_modules y next. Actualizar next reescribe tus capas; la de Node solo cambia con la línea FROM.
Desliza la figura para verla completa
Puedes ver qué Node trae una etiqueta sin descargarla, porque la imagen guarda la versión en NODE_VERSION. Esto respondió el 2 de noviembre:
$ docker buildx imagetools inspect node:24-bookworm-slim --format '{{json (index .Image "linux/amd64").Config.Env}}'
[
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
"NODE_VERSION=24.22.2",
"YARN_VERSION=1.22.22"
]
docker buildx imagetools inspectmuestra los datos de una imagen en el registro (referencia del comando). No necesita el motor de Docker: en mi computadora no arranca y aun así respondió.--formates una plantilla de Go:index .Image "linux/amd64"elige una plataforma de la etiqueta multiplataforma, y.Config.Envson sus variables de entorno.NODE_VERSION=24.22.2es el Node de esa etiqueta ese día. Como es flotante, mañana puede ser otro.
Railway con Nixpacks: la versión mayor no basta
Si despliegas en Railway con Nixpacks ("builder": "NIXPACKS" en railway.json) y sin Dockerfile, el log del build solo muestra la versión mayor, con una línea como setup │ nodejs_24, npm-9_x, y un archivo .nixpacks/nixpkgs-<commit>.nix. El parche exacto no aparece en ningún lado.
Según el código del proveedor de Node de Nixpacks, con un rango abierto como "node": ">=18.18.0" elige la versión par más nueva que encaje, 24, y cada versión mayor está atada a un commit de nixpkgs: para 24, justo 23f9169c…. En ese commit, el archivo v24.nix de nixpkgs dice version = "24.10.0". La documentación de Nixpacks lo resume: solo se puede especificar una versión mayor.
O sea: según esos archivos, un build de Nixpacks con Node 24 instala Node 24.10.0, anterior a 24.22.1, por más que actualices next o vuelvas a desplegar. No lo des por hecho en tu caso: compruébalo con el log de arranque de más abajo, que imprime la versión real del contenedor. Hay dos salidas: Railpack, que Railway hizo su builder por defecto el 19 de septiembre de 2025 y que el README de Nixpacks recomienda como reemplazo, o un Dockerfile que fije la imagen. De la configuración de memoria de un servidor Next.js en Railway hablo en cómo bajé la memoria de mi servidor Next.js en Railway.
Cambiar la imagen base en tu Dockerfile
Con Docker, el cambio está en la línea FROM. Las imágenes oficiales de Node en Docker Hub tienen etiquetas de distinta precisión. Esto traía cada una el 2 de noviembre, según la API de Docker Hub:
| Etiqueta | Node | Cuándo cambia |
|---|---|---|
node:24.22.2-bookworm-slim | 24.22.2 | Nunca de Node; la imagen sí puede reconstruirse con paquetes nuevos de Debian |
node:24-bookworm-slim, node:24-alpine | 24.22.2 | Con cada versión de la línea 24, al reconstruir con --pull |
node:lts-slim | 26.13.0 | Con cada versión, y de mayor cuando cambia la LTS más reciente |
node:20-bookworm-slim | 20.20.2 | Ya no: su última actualización fue el 22 de abril de 2026 |
-slim trae solo lo mínimo para correr node; -alpine es más pequeña, pero usa musl en lugar de glibc; bookworm y trixie son versiones de Debian. Quédate con la variante que ya usas. Mi recomendación es la etiqueta exacta: el Dockerfile dice qué Node corre y cada cambio queda en un diff. Las buenas prácticas de Docker recuerdan que las etiquetas son mutables. Fijar el digest (el 2 de noviembre, node:24.22.2-bookworm-slim@sha256:c86ecead9e55a5210ac1727de38a4ca840bf03dcaf34dc9749addbf383b1920c) te da siempre la misma imagen, pero la misma guía advierte que así renuncias a las correcciones de seguridad automáticas.
Un Dockerfile de dos etapas para Next.js, con la versión en un solo lugar:
ARG NODE_VERSION=24.22.2
FROM node:${NODE_VERSION}-bookworm-slim AS build
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build
FROM node:${NODE_VERSION}-bookworm-slim
WORKDIR /app
ENV NODE_ENV=production
COPY --from=build --chown=node:node /app ./
USER node
CMD ["node", "node_modules/next/dist/bin/next", "start"]
ARG NODE_VERSIONva antes del primerFROM: según la referencia del Dockerfile, losFROMpueden usarlo. Cambias la versión en una línea, o pruebas otra con--build-arg NODE_VERSION=….- La etapa
buildinstala desde el lockfile connpm ciy compila connpm run build. - La segunda etapa parte de la misma imagen y trae lo compilado con
COPY --from=build: es un build multietapa. ENV NODE_ENV=productionmarca el entorno;--chown=node:nodeyUSER nodehacen que la app corra con el usuario sin privilegios de la imagen, no como root.CMDarrancanext startconnode, igual que el comando de arranque habitual de una app Next.js.
Añade un .dockerignore con node_modules y .next, para que COPY . . no pise lo que instaló npm ci. No construí este Dockerfile: en mi equipo el motor de Docker no arranca. Pruébalo en tu proyecto antes de producción.
Reconstruir y volver a desplegar (y comprobar con node -v)
Cambiar la etiqueta no basta si la imagen vieja sigue en caché:
docker build --pull -t mi-app .
docker build --pull --no-cache -t mi-app .
docker run --rm mi-app node -v
--pullintenta siempre bajar las imágenes referenciadas (referencia de docker build): busca una imagen base más nueva aunque tengas una en caché.--no-cachereconstruye todas las capas, pero no baja una imagen base nueva. Combínalo con--pullsi quieres las dos cosas.docker run --rm mi-app node -vimprime el Node de tu imagen y borra el contenedor. Ese es el número que cuenta, no el de tu computadora.
Luego despliega la imagen nueva. Si tu plataforma redespliega el build anterior, también te devuelve el Node anterior.
Desliza la figura para verla completa
Para no comparar a ojo, check-node.mjs revisa una versión contra la mínima corregida de su línea. Sin argumentos, revisa el Node que lo ejecuta:
// Lowest versions with the fixes from the Node.js security release of October 21, 2026.
const PATCHED = { 22: "22.23.4", 24: "24.22.1", 26: "26.12.1" };
const version = (process.argv[2] ?? process.version).trim().replace(/^v/, "");
const [major, minor, patch] = version.split(".").map((n) => parseInt(n, 10));
const min = PATCHED[major];
if (!min) {
console.error(`Node ${version}: ${major}.x is not one of the lines patched on October 21, 2026 (22, 24, 26).`);
process.exit(1);
}
const [, minMinor, minPatch] = min.split(".").map(Number);
if (minor < minMinor || (minor === minMinor && patch < minPatch)) {
console.error(`Node ${version} is older than ${min}: update the runtime, not just your dependencies.`);
process.exit(1);
}
console.log(`Node ${version} has the October 21, 2026 fixes (${min} or later).`);
PATCHEDguarda la mínima de cada línea según el aviso. En el próximo release de seguridad, actualizas esa línea.- Toma el argumento o
process.version, le quita lavinicial y lo separa en mayor, menor y parche. - Si la línea no tiene parche (20.x o una impar), o la versión es anterior a la mínima, avisa y sale con código 1.
- Si no, confirma y sale con 0, así que sirve como paso de CI que falla.
Lo corrí con Node 22.22.3 en Windows 11:
$ node check-node.mjs
Node 22.22.3 is older than 22.23.4: update the runtime, not just your dependencies.
$ node check-node.mjs 24.10.0
Node 24.10.0 is older than 24.22.1: update the runtime, not just your dependencies.
$ node check-node.mjs 26.13.0
Node 26.13.0 has the October 21, 2026 fixes (26.12.1 or later).
$ node check-node.mjs 20.20.2
Node 20.20.2: 20.x is not one of the lines patched on October 21, 2026 (22, 24, 26).
- Mi Node local, 22.22.3, no tiene los arreglos. Tampoco 24.10.0, la que según nixpkgs instala Nixpacks para la 24.
- 26.13.0 sí, porque es 26.12.1 con metadatos de LTS. 20.20.2 no está en ninguna línea con parche.
Con el binario oficial de Node 24.22.2 para Windows, con su SHA-256 verificado, sin argumentos sale con código 0.
Ver la versión en producción
En producción casi nunca tienes terminal. Lo más simple es que la app diga su versión al arrancar:
import { createServer } from "node:http";
console.log(`[startup] Node ${process.version} · ${process.platform}-${process.arch} · OpenSSL ${process.versions.openssl}`);
createServer((req, res) => {
if (req.url !== "/healthz") return res.writeHead(404).end();
res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" });
res.end(JSON.stringify({ status: "ok", node: process.version }));
}).listen(Number(process.env.PORT) || 3000);
- La línea
[startup]sale una vez en los logs, con Node, sistema, arquitectura y el OpenSSL de ese binario. /healthzresponde la versión en JSON y sin caché; cualquier otra ruta da404.- El puerto sale de
PORT, como lo pasan Railway y otras plataformas, o es 3000.
Con PORT=3123 node server.mjs y, en otra terminal, curl -s http://localhost:3123/healthz:
[startup] Node v22.22.3 · win32-x64 · OpenSSL 3.5.6
{"status":"ok","node":"v22.22.3"}
Con 24.22.2, la línea dice Node v24.22.2 · win32-x64 · OpenSSL 3.5.9: el OpenSSL nuevo llega con el Node nuevo. No dejes el endpoint abierto, porque le dice a cualquiera si estás sin parche; el log basta. En Next.js, esa línea va en register() de instrumentation.ts, que según la documentación de instrumentación se llama una vez al arrancar cada servidor, dentro de if (process.env.NEXT_RUNTIME === "nodejs"). Esa variante no la ejecuté.
En otras plataformas
Sin Dockerfile, la versión la elige tu plataforma. Esto dice la documentación de cada una:
| Plataforma | Dónde se elige | ¿Versión exacta? | Nota |
|---|---|---|---|
| Railway con Railpack | RAILPACK_NODE_VERSION, devEngines.runtime, engines.node, .nvmrc, .node-version, mise; si no, lts | La documentación solo muestra una mayor (22) | Revisa la versión en el log |
| Railway con Nixpacks | NIXPACKS_NODE_VERSION, engines.node o .nvmrc | No: solo la mayor | El parche lo fija nixpkgs |
| Railway con Dockerfile | Un Dockerfile en la raíz o RAILWAY_DOCKERFILE_PATH | Sí | El log dice Using detected Dockerfile! |
| Render | NODE_VERSION, .node-version, .nvmrc, engines, en ese orden | Sí, o un alias como lts | 24.22.1 por defecto en servicios creados desde el 21 de octubre |
| Fly.io | ARG NODE_VERSION en el Dockerfile que genera fly launch | Sí | Cambia el ARG y despliega |
| Vercel | Settings o engines.node | No: solo la mayor | Vercel aplica los parches por su cuenta |
| Heroku | engines.node | Sí, pero recomienda 24.x | Desaconseja rangos abiertos como >= 24.x |
Un detalle de Fly: según el código de dockerfile-node, el generador escribe en ARG NODE_VERSION la versión de Node de la computadora donde lo corriste. Si lo generaste con un Node viejo, ahí se quedó.
Si sigues en Node 20
Node 20 llegó a End-of-Life el 30 de abril de 2026; su última versión es 20.20.2, del 24 de marzo. Que el aviso de octubre no lo mencione no significa que esté a salvo: el mismo aviso dice que las versiones End-of-Life siempre están afectadas cuando hay un release de seguridad, y la página de End-of-Life de Node.js aclara que ya no reciben actualizaciones, ni siquiera de seguridad. En Docker Hub, node:20-bookworm-slim no cambia desde el 22 de abril. Es lo mismo que le pasa a Next.js 14, que se quedó sin parche para las RCE de octubre. El plan:
- Elige destino: 22.x tiene soporte hasta el 30 de abril de 2027, unos seis meses; 24.x, hasta abril de 2028; 26.x, LTS desde el 28 de octubre, hasta abril de 2029. La página de releases de Node.js pide usar en producción solo versiones Active LTS o Maintenance LTS.
- Prueba en una rama: instalación limpia, build, pruebas y los flujos críticos de tu tienda.
- Cambia la imagen o la versión en tu plataforma, reconstruye, despliega y confirma en el log de arranque.
- Si no puedes migrar ya, la página de EOL menciona soporte comercial de HeroDevs, NodeSource y TuxCare, como solución temporal.
Errores comunes
- Dar el runtime por actualizado. Ni
npm install, ninpm update, ni el parche de Next.js cambian Node. - Reconstruir sin
--pull. Con una etiqueta flotante en caché, el build sigue con la imagen vieja. - Redesplegar el build anterior. Trae la imagen anterior con su Node. Hace falta un build nuevo.
- Mirar
node -ven tu computadora. El que cuenta es el del contenedor en producción. - Confiar en un rango abierto. Con Nixpacks,
>=18.18.0termina en Node 24 con un parche fijado por nixpkgs. Render y Heroku desaconsejan rangos sin límite superior. - Esperar un parche para Node 20. Está en End-of-Life: no va a llegar.
Preguntas frecuentes
¿El parche de seguridad de Next.js también actualiza Node?
No. Cambia el paquete next en node_modules. Node viene de la imagen base o de tu plataforma. Son dos actualizaciones separadas: Node publicó la suya el 21 de octubre y Next.js la suya el 3 de noviembre.
¿Basta con poner la versión en engines de package.json?
Depende de dónde despliegues. npm solo da advertencias. Render, Heroku, Vercel y Railpack lo leen para elegir versión, cada uno con sus reglas; Nixpacks solo toma la mayor; en un Dockerfile no tiene efecto, porque manda la línea FROM.
¿Uso node:24 o la versión exacta?
Con node:24 recibes los parches de la línea cada vez que reconstruyes con --pull, pero no sabes qué versión corre sin revisarla. Con la etiqueta exacta, el Dockerfile lo dice y el cambio pasa por un diff, aunque te toca subirla en cada release de seguridad. Yo prefiero la exacta, con un recordatorio para el próximo parche.
¿Cómo sé qué Node corre en producción sin terminal en el contenedor?
Haz que la app imprima process.version al arrancar y búscalo en los logs. Vercel sugiere node -v en el comando de build y process.version dentro de la función. El log de build se puede quedar corto: con Nixpacks dice algo como nodejs_24, no la versión de parche.
Checklist
- Sabes qué Node corre en producción, por el log de arranque o por
node -ven el contenedor. - Es 22.23.4, 24.22.1, 26.12.1 o una posterior de la misma línea.
- La versión está en un solo lugar: el
ARGo la etiqueta deFROM, o la configuración de tu plataforma. - Reconstruiste con
docker build --pully desplegaste el build nuevo. - El log de arranque muestra la versión nueva.
- Si usas Nixpacks en Railway, tienes plan para Railpack o un Dockerfile.
- Si estás en Node 20, tienes fecha para pasar a 22, 24 o 26.
Revisar Node es parte del mismo trabajo que aplicar el parche de seguridad de Next.js del 3 de noviembre: uno arregla tu framework y el otro el programa que lo corre. Si tu proyecto sigue en una versión sin soporte, empieza por qué hacer si sigues en Next.js 14. Y si despliegas en Railway, revisa también la memoria: cómo bajé la memoria RAM de Next.js en Railway.
¿Viste esto en Instagram? Comenta NODE en el Reel y te mando la guía.
Escrito por

Publicado el 3 de noviembre de 2026