Cómo instalar Node-RED en Ubuntu 24.04 con Nginx y HTTPS

Node-RED es una herramienta de programación por flujos basada en Node.js: conectas nodos en un editor web para enlazar APIs, dispositivos MQTT, bases de datos y servicios sin escribir una aplicación completa. En este tutorial instalarás Node-RED en Ubuntu 24.04 con Node.js 22 LTS, lo ejecutarás como servicio systemd con un usuario propio, protegerás el editor con contraseña y lo publicarás en tu dominio detrás de Nginx con HTTPS. Terminarás creando un flujo que expone un endpoint HTTP.

Requisitos previos

Un servidor con Ubuntu 24.04 LTS y al menos 1 GB de RAM, por ejemplo un VPS de CubePath.
Un usuario no root con privilegios sudo.
Un dominio o subdominio (en esta guía your_domain) con un registro DNS A apuntando a la IP del servidor.
UFW activo con SSH permitido.

Paso 1: Instalar Node.js 22 LTS

Node-RED 4 necesita Node.js 18 o superior. El paquete de Ubuntu 24.04 trae Node.js 18, que ya no recibe soporte, así que instalarás la rama 22 LTS desde el repositorio de NodeSource.

Descarga la clave del repositorio en /etc/apt/keyrings:

sudo apt update
sudo apt install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg

Añade el repositorio e instala Node.js, que incluye npm:

echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_22.x nodistro main" | sudo tee /etc/apt/sources.list.d/nodesource.list
sudo apt update
sudo apt install nodejs

Comprueba las versiones:

node --version
npm --version

v22.19.0
10.9.3

La versión menor puede ser distinta; debe empezar por v22.

Paso 2: Instalar Node-RED

Instala Node-RED de forma global con npm:

sudo npm install -g --unsafe-perm node-red

La opción --unsafe-perm permite que los módulos nativos se compilen correctamente al instalar como root. Comprueba dónde ha quedado el ejecutable, porque lo usarás en la unidad de systemd:

command -v node-red

/usr/bin/node-red

Paso 3: Crear el usuario y el servicio systemd

Node-RED no debe ejecutarse como root: los flujos pueden lanzar comandos del sistema con el nodo exec. Crea un usuario de sistema con su directorio de datos en /var/lib/node-red:

sudo useradd --system --create-home --home-dir /var/lib/node-red --shell /usr/sbin/nologin nodered

Crea la unidad del servicio:

sudo nano /etc/systemd/system/node-red.service

[Unit]
Description=Node-RED
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=nodered
Group=nodered
WorkingDirectory=/var/lib/node-red
Environment="NODE_OPTIONS=--max-old-space-size=512"
ExecStart=/usr/bin/node-red --userDir /var/lib/node-red
Restart=on-failure
KillSignal=SIGINT

[Install]
WantedBy=multi-user.target

--userDir indica dónde se guardan los flujos, las credenciales cifradas, los nodos instalados desde la paleta y el archivo settings.js. KillSignal=SIGINT permite que Node-RED se detenga de forma ordenada, y --max-old-space-size limita la memoria de Node.js en megabytes (ajústalo a tu servidor).

Arranca el servicio:

sudo systemctl daemon-reload
sudo systemctl enable --now node-red

Comprueba el estado y el log de arranque:

sudo journalctl -u node-red -n 20 --no-pager

[info] Node-RED version: v4.1.0
[info] Node.js  version: v22.19.0
[info] Settings file  : /var/lib/node-red/settings.js
[info] Flows file     : /var/lib/node-red/flows.json
[info] Server now running at http://127.0.0.1:1880/

En el primer arranque Node-RED copia su settings.js por defecto en /var/lib/node-red, que es el archivo que editarás ahora.

Paso 4: Escuchar solo en local y proteger el editor

Por defecto Node-RED escucha en todas las interfaces y el editor no pide contraseña: cualquiera que llegue al puerto 1880 podría ejecutar código en tu servidor. Vas a hacer que escuche solo en 127.0.0.1 y a activar la autenticación.

Genera el hash bcrypt de la contraseña del administrador con la herramienta de administración incluida:

node-red admin hash-pw

Password:
$2b$08$Vn0Wn7a0sHqX1C8nJz0uYOeB3o1t5m8kYyq7pA1QzL0nq4h1m2x6G

Copia la línea que empieza por $2b$ . Edita el archivo de configuración:

sudo nano /var/lib/node-red/settings.js

Busca la línea //uiHost: "127.0.0.1",, quita las dos barras para activarla:

    uiHost: "127.0.0.1",

Después busca el bloque adminAuth, que viene comentado, y sustitúyelo por este, pegando tu hash en password:

    adminAuth: {
        type: "credentials",
        users: [{
            username: "admin",
            password: "$2b$08$Vn0Wn7a0sHqX1C8nJz0uYOeB3o1t5m8kYyq7pA1QzL0nq4h1m2x6G",
            permissions: "*"
        }]
    },

Reinicia Node-RED y comprueba que ahora escucha solo en localhost:

sudo systemctl restart node-red
sudo ss -tlnp | grep 1880

LISTEN 0      511        127.0.0.1:1880       0.0.0.0:*    users:(("node-red",pid=5230,fd=21))

Paso 5: Publicar Node-RED con Nginx y HTTPS

Instala Nginx y Certbot:

sudo apt install nginx certbot python3-certbot-nginx

Crea el sitio:

sudo nano /etc/nginx/sites-available/node-red

map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}

server {
    listen 80;
    listen [::]:80;
    server_name your_domain;

    location / {
        proxy_pass http://127.0.0.1:1880;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

El editor mantiene una conexión WebSocket en /comms para mostrar el estado de los nodos y los mensajes de depuración; por eso son necesarias las cabeceras Upgrade y Connection.

Activa el sitio, comprueba la sintaxis y abre HTTP y HTTPS:

sudo ln -s /etc/nginx/sites-available/node-red /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default
sudo nginx -t
sudo systemctl reload nginx
sudo ufw allow 'Nginx Full'

Solicita el certificado. Certbot modifica el sitio para servir HTTPS y redirigir HTTP:

sudo certbot --nginx -d your_domain

Abre https://your_domain en el navegador. Node-RED debe mostrar la pantalla de inicio de sesión; entra con el usuario admin y la contraseña que usaste para generar el hash.

Paso 6: Crear un flujo con un endpoint HTTP

Vas a crear un flujo que responde con JSON en GET /hola. En el editor, abre el menú (tres rayas, arriba a la derecha), elige Importar y pega este flujo:

[
  {
    "id": "f1a0c0de00000001",
    "type": "http in",
    "name": "GET /hola",
    "url": "/hola",
    "method": "get",
    "upload": false,
    "swaggerDoc": "",
    "x": 130,
    "y": 80,
    "wires": [["f1a0c0de00000002"]]
  },
  {
    "id": "f1a0c0de00000002",
    "type": "function",
    "name": "Construir respuesta",
    "func": "msg.payload = {\n    mensaje: \"Hola desde Node-RED\",\n    nombre: msg.req.query.nombre || \"anónimo\",\n    hora: new Date().toISOString()\n};\nreturn msg;",
    "outputs": 1,
    "x": 340,
    "y": 80,
    "wires": [["f1a0c0de00000003"]]
  },
  {
    "id": "f1a0c0de00000003",
    "type": "http response",
    "name": "",
    "statusCode": "",
    "headers": {},
    "x": 530,
    "y": 80,
    "wires": []
  }
]

Pulsa Importar, coloca los nodos en el lienzo y haz clic en Desplegar (Deploy). El nodo http in recibe la petición, el nodo function construye el objeto msg.payload y el nodo http response lo devuelve como JSON.

Prueba el endpoint desde tu equipo:

curl -s "https://your_domain/hola?nombre=Ana"

{"mensaje":"Hola desde Node-RED","nombre":"Ana","hora":"2026-09-24T10:31:07.412Z"}

Importante

los endpoints creados con nodos http in son públicos; adminAuth solo protege el editor. Si un endpoint no debe ser accesible para cualquiera, valida un token en el nodo function o activa la opción httpNodeAuth en settings.js.

Paso 7: Instalar nodos adicionales

Node-RED se amplía con nodos de la comunidad. Instálalos desde el editor en Menú > Gestionar paleta > Instalar, que los descarga en /var/lib/node-red/node_modules con el usuario correcto. Algunos útiles para IoT:

Paquete	Para qué sirve
`@flowfuse/node-red-dashboard`	Paneles web con gráficas, botones e indicadores (Dashboard 2.0).
`node-red-contrib-influxdb`	Escribir y leer series temporales en InfluxDB.
`node-red-node-sqlite`	Guardar datos en una base SQLite local.

Los nodos MQTT (mqtt in y mqtt out) vienen incluidos de serie: solo necesitas configurar la dirección del broker, el puerto y las credenciales.

Copias de seguridad

Todo el estado de Node-RED está en /var/lib/node-red: flows.json, flows_cred.json (credenciales cifradas), settings.js, package.json con los nodos instalados y el archivo .config.runtime.json, que contiene la clave con la que se cifran las credenciales. Haz copia del directorio completo; sin esa clave, flows_cred.json no se puede descifrar en otro servidor.

Solución de problemas

La página de inicio de sesión no aparece y el editor está abierto: adminAuth sigue comentado o hay un error de sintaxis en settings.js. Revisa el arranque con sudo journalctl -u node-red -n 50 --no-pager; un error de JavaScript impide cargar el archivo.

El editor muestra "Lost connection to server": Nginx no reenvía el WebSocket de /comms. Comprueba el bloque map y las cabeceras Upgrade y Connection, y ejecuta sudo nginx -t.

502 Bad Gateway: Node-RED no está en marcha o no escucha en 127.0.0.1:1880. Comprueba systemctl status node-red y la línea uiHost.

Un nodo de la paleta no se instala: algunos paquetes compilan código nativo y necesitan herramientas de compilación. Instálalas con sudo apt install build-essential python3 y vuelve a intentarlo.

Conclusión

Tienes Node-RED ejecutándose como servicio systemd con un usuario sin privilegios, con el editor protegido por contraseña, accesible solo por HTTPS y con un primer flujo que expone una API. Las actualizaciones se hacen con sudo npm install -g --unsafe-perm node-red@latest seguido de sudo systemctl restart node-red.

Como siguientes pasos puedes:

Conectar Node-RED a un broker MQTT como Mosquitto para recibir datos de sensores.
Guardar esas lecturas en una base de datos de series temporales y visualizarlas en Grafana.
Crear un panel con @flowfuse/node-red-dashboard para controlar dispositivos desde el navegador.

On this page