---
title: "Cómo instalar Node-RED en Ubuntu 24.04 con Nginx y HTTPS"
description: "Instala Node-RED en Ubuntu 24.04 con Node.js 22, ejecútalo como servicio systemd, protege el editor con contraseña y publícalo tras Nginx con HTTPS."
category: "Automatización del Hogar e IoT"
language: es
source: https://cubepath.com/es/docs/automatización-del-hogar-e-iot/instalacion-de-node-red-programacion-por-flujos
updated: 2026-09-25
---

# 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`:

```bash
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`:

```bash
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:

```bash
node --version
npm --version
```

```output
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:

```bash
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:

```bash
command -v node-red
```

```output
/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`:

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

Crea la unidad del servicio:

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

```ini
[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:

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

Comprueba el estado y el log de arranque:

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

```output
[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:

```bash
node-red admin hash-pw
```

```output
Password:
$2b$08$Vn0Wn7a0sHqX1C8nJz0uYOeB3o1t5m8kYyq7pA1QzL0nq4h1m2x6G
```

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

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

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

```javascript
    uiHost: "127.0.0.1",
```

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

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

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

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

```output
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:

```bash
sudo apt install nginx certbot python3-certbot-nginx
```

Crea el sitio:

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

```nginx
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:

```bash
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:

```bash
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:

```json
[
  {
    "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:

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

```output
{"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.