---
title: "Cómo autoalojar n8n en 2026 (Docker, Traefik y Dokploy)"
description: "Aprende a autoalojar n8n en 2026: Docker Compose listo para producción, configuraciones con Traefik y Dokploy, modo de cola con PostgreSQL, monitorización, copias de seguridad y consejos para actualizar a n8n 2.x."
date: 2025-08-02
categories: ["self-hosting"]
tags: ["n8n","workflow-automation","dokploy"]
---

import Button from "@components/widgets/Button.astro";
import Notice from "@components/widgets/Notice.astro";
import ListCheck from "@components/widgets/ListCheck.astro";
import Accordion from "@components/widgets/Accordion.astro";

Zapier cobra por tarea. Make cobra por operación. Si ejecutas más que un puñado de automatizaciones, la factura sube rápido. Autoalojar n8n te da ejecuciones ilimitadas en tu propio hardware por lo que cuesta un VPS.

**n8n** es una plataforma de automatización de flujos de trabajo de código abierto (fair-code, Sustainable Use License) en su versión estable 2.37.x, con más de 203 000 estrellas en GitHub y más de 100 millones de pulls en Docker. Puedes autoalojar n8n en un VPS barato con Docker Compose y obtener el mismo constructor visual de flujos de trabajo, más de 1 000 integraciones y disparadores webhook por los que cobran los servicios en la nube. n8n 3.0 está previsto para octubre de 2026 y convertirá Docker en el único método de autoalojamiento soportado. Si todavía ejecutas `npx n8n`, ahora es el momento de migrar.

Esta guía cubre cuatro opciones de instalación listas para producción: Docker Compose independiente, proxy inverso Traefik, despliegue con la interfaz gráfica de Dokploy y modo de cola con PostgreSQL para escalar.

## ¿Qué es n8n?

n8n (pronunciado «nodemation») es una plataforma visual de automatización de flujos de trabajo que conecta servicios y automatiza tareas mediante un editor basado en nodos. Piensa en ella como una alternativa autoalojada a Zapier o Make. Arrastras nodos a un lienzo, los conectas y los datos fluyen de uno al siguiente. La diferencia es que tú controlas la infraestructura y los datos nunca salen de tus servidores.

### Ventajas clave de n8n

<ListCheck>

- **Constructor visual de flujos de trabajo**: crea automatizaciones con una interfaz de arrastrar y soltar. No hace falta programar para la mayoría de las tareas.

- **Más de 1 000 integraciones integradas**: conecta con Google Workspace, Microsoft 365, Slack, GitHub, bases de datos y APIs (más de 2 000 entradas en el [directorio de integraciones](https://n8n.io/integrations/) de n8n)

- **Nodos de JavaScript personalizados**: escribe código cuando los nodos predefinidos no cubran tu caso de uso

- **Soporte de webhooks**: dispara flujos de trabajo desde eventos externos: peticiones HTTP, cambios de archivos, llegada de correos

- **Control avanzado del flujo**: lógica condicional, bucles, manejo de errores y procesamiento en paralelo

- **Modo de cola**: distribuye el trabajo entre varios workers con PostgreSQL y Redis para operaciones de alto volumen

- **Gestión de credenciales**: almacenamiento cifrado de claves API, tokens y datos de autenticación

- **Privacidad del autoalojamiento**: mantén tus datos y la lógica de automatización en tus propios servidores

- **API extensa**: gestiona flujos de trabajo y configuraciones mediante APIs REST

- **Asistente de IA** (vista previa, 2.35+): construye flujos de trabajo con un asistente de IA usando tus propias claves API (Anthropic, OpenAI, OpenRouter)

</ListCheck>

Un par de funciones que conviene destacar: la integración con control de versiones Git y el soporte multi-entorno (desarrollo/staging/producción) requieren una licencia de pago. La edición Community cubre todo lo que necesita quien trabaja en solitario: flujos de trabajo, pasos, ejecuciones y usuarios ilimitados.

Puedes explorar el código en el [repositorio oficial de GitHub](https://github.com/n8n-io/n8n) o visitar [n8n.io](https://n8n.io) para consultar la documentación.

### Cómo funciona n8n

n8n usa nodos. Cada nodo representa una función o una integración de servicio. Creas flujos de trabajo conectando nodos en secuencia, y los datos fluyen de un nodo al siguiente.

| Tipo de componente | Propósito | Casos de uso |
|---------------|---------|-----------|
| **Nodos trigger** | Inician la ejecución del flujo de trabajo | Peticiones webhook, tareas programadas, cambios de archivos, llegada de correos |
| **Nodos regulares** | Realizan acciones | Llamadas a APIs, procesamiento de datos, operaciones con archivos |
| **Nodos de control** | Gestionan la lógica del flujo | Ramificaciones condicionales, bucles, manejo de errores, combinación de datos |
| **Nodos de código** | Ejecutan scripts personalizados | Cálculos complejos, transformaciones de datos |
| **Nodos de sub-flujo** | Referencian otros flujos de trabajo | Componentes reutilizables, diseño modular |

Este enfoque modular te permite construir desde simples tareas de sincronización de datos hasta complejos procesos de negocio de varios pasos.

### n8n 2.0 y 3.0: qué cambió para quienes se autoalojan

n8n 2.0 se lanzó en diciembre de 2025 e introdujo varios cambios disruptivos que afectan a los despliegues autoalojados:

- **Seguro por defecto**: los nodos Code ya no pueden acceder a las variables de entorno (`N8N_BLOCK_ENV_ACCESS_IN_NODE=true`). Los nodos de archivos están restringidos a `~/.n8n-files`.
- **Modelo Publicar/Guardar**: los flujos de trabajo ahora tienen un estado de borrador frente a publicado, que sustituye al antiguo interruptor activo/inactivo.
- **PostgreSQL recomendado**: el soporte de MySQL/MariaDB se eliminó por completo. PostgreSQL 17/18 es la base de datos recomendada para producción.
- **Task runners activados por defecto**: la ejecución de los nodos Code está aislada en procesos runner separados.
- **Informe de migración**: una herramienta integrada (Settings → Migration Report) que marca los flujos de trabajo afectados por cambios disruptivos antes de actualizar.

<Notice type="warning" title="n8n 3.0: el autoalojamiento solo con Docker llega en octubre de 2026">

n8n 3.0 eliminará el soporte para instalaciones con `npm` y `npx n8n`. Docker Compose será el único método de autoalojamiento soportado. Si hoy ejecutas n8n vía npm, migra a Docker ya. La versión 3.0 también elimina los nodos heredados Function/Function Item y el nodo AI Agent v1. Lee los [cambios disruptivos de la v3.0](https://docs.n8n.io/changelog/v30-breaking-changes) antes de actualizar.

</Notice>

**Tareas antes de actualizar:**
1. Ejecuta el informe de migración (Settings → Migration Report) para identificar los flujos de trabajo afectados
2. Lee los [cambios disruptivos de la v2.0](https://docs.n8n.io/changelog/v20-breaking-changes) y los [cambios disruptivos de la v3.0](https://docs.n8n.io/changelog/v30-breaking-changes)
3. Fija la etiqueta de tu imagen Docker. No dependas de `latest` en producción

## Requisitos del sistema y prerrequisitos de n8n

n8n es ligero, pero la RAM es el cuello de botella. El proceso de Node.js es de un solo hilo, y los flujos de trabajo complejos con grandes cargas JSON consumen memoria, no CPU. El modo de cola añade aproximadamente 1 GB para los workers.

**Especificaciones recomendadas:**

| Componente | Mínimo | Recomendado | Modo de cola |
|-----------|---------|-------------|------------|
| **CPU** | 2 vCPU | 4 vCPU | 4+ vCPU |
| **RAM** | 2 GB | 4 GB | 4 GB + 1 GB por worker |
| **Almacenamiento** | 20 GB SSD | 50 GB SSD | 100 GB NVMe |
| **Red** | 100 Mbps | 1 Gbps | 1 Gbps |

<Notice type="info" title="La RAM es el cuello de botella">

El proceso de Node.js de n8n es de un solo hilo. Los flujos de trabajo complejos con grandes cargas JSON consumen memoria, no CPU. Si ves terminaciones por OOM, aumenta la RAM antes de añadir núcleos.

</Notice>

<ListCheck>

**Prerrequisitos:**

- **Un VPS con Linux**: se recomienda Ubuntu 22.04+. [Hetzner Cloud](https://go.bitdoze.com/hetzner) (4-8 €/mes) o [Hostinger VPS](https://go.bitdoze.com/hostinger-vps) funcionan bien, o usa un [mini PC como servidor doméstico](https://www.bitdoze.com/best-mini-pc-home-server/)
- **Docker y Docker Compose** instalados en tu servidor
- **Un nombre de dominio** con el DNS apuntando a tu servidor (p. ej., `n8n.yourdomain.com`)
- **Un proxy inverso** para HTTPS: Traefik (consulta la [guía completa de Traefik como proxy inverso en Docker](https://www.bitdoze.com/traefik-proxy-docker/)) o deja que Dokploy lo gestione automáticamente

_Los precios de los VPS subieron en general en 2026: si estás reconsiderando un servidor alquilado, mira [qué cambió y cuándo gana un mini PC](/es/subidas-precios-vps/)._

</ListCheck>

## Opción de instalación 1: instalar n8n con Docker Compose (independiente)

Es la instalación más sencilla. Un solo contenedor n8n con SQLite. Buena para empezar, para desarrollo o para uso en solitario con un volumen moderado de flujos de trabajo.

<Notice type="info" title="¿Por qué sin Redis?">

La versión anterior de esta guía incluía Redis en el archivo compose independiente. Redis solo ayuda en modo de cola. Sin `EXECUTIONS_MODE=queue`, no hace nada salvo consumir ~100 MB de RAM. Esta configuración lo mantiene simple.

</Notice>

### Paso 1: crear el directorio del proyecto

```bash
mkdir -p ~/n8n-automation && cd ~/n8n-automation
```

### Paso 2: crear la configuración de Docker Compose

```yaml
services:
  n8n:
    image: docker.io/n8nio/n8n:2.37.7
    container_name: n8n-app
    restart: unless-stopped
    ports:
      - '5678:5678'
    environment:
      - N8N_EDITOR_BASE_URL=http://localhost:5678
      - N8N_WEBHOOK_URL=http://localhost:5678
      - GENERIC_TIMEZONE=UTC
      - TZ=UTC
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS=true
      - N8N_DEFAULT_BINARY_DATA_MODE=filesystem
      - N8N_LOG_LEVEL=info
      - N8N_LOG_OUTPUT=console
      - EXECUTIONS_DATA_PRUNE=true
      - EXECUTIONS_DATA_MAX_AGE=336
    volumes:
      - ./data:/home/node/.n8n
      - ./files:/files
    cap_drop:
      - ALL
    cap_add:
      - SETUID
      - SETGID
      - CHOWN
      - DAC_OVERRIDE
    healthcheck:
      test: ['CMD', 'wget', '--no-verbose', '--tries=1', '--spider', 'http://localhost:5678/healthz']
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
```

Cambios clave respecto al compose antiguo: se eliminó `version: '3.8'` (obsoleto en Compose v2), se eliminó `VUE_APP_URL_BASE_API` (sin efecto en Docker), se reemplazó `WEBHOOK_URL` por `N8N_WEBHOOK_URL`, se quitó Redis y se fijó la etiqueta de la imagen.

### Paso 3: inicializar la configuración

```bash
# Create required directories
mkdir -p {data,files}

# Generate a secure encryption key
echo "N8N_ENCRYPTION_KEY=$(openssl rand -base64 32)" > .env

# Set proper permissions
chmod 700 data
chmod 755 files
```

<Notice type="warning" title="Clave de cifrado">

Si pierdes `N8N_ENCRYPTION_KEY`, todas las credenciales almacenadas se vuelven indescifrables. Haz copia de seguridad del archivo `.env` junto con tus datos. Si usas secretos de Docker o un gestor de `.env`, n8n admite variantes con sufijo `_FILE` (p. ej., `N8N_ENCRYPTION_KEY_FILE`). Consulta [secretos de Docker Compose y alternativas seguras](https://www.bitdoze.com/docker-compose-secrets/) para ver las opciones.

</Notice>

### Paso 4: lanzar y verificar

```bash
# Launch the container
docker compose up -d

# Verify it's running
docker compose ps

# Check logs for issues (look for deprecation warnings)
docker compose logs -f n8n
```

Verifica el endpoint de salud:

```bash
curl -s http://localhost:5678/healthz
```

Deberías obtener una respuesta `200 OK`. Si los logs muestran una advertencia de deprecación de `WEBHOOK_URL`, usaste el nombre antiguo de la variable. Actualízalo a `N8N_WEBHOOK_URL`.

<Notice type="success" title="Verifica que funciona">

`/healthz` devuelve 200 y los logs muestran "Editor is now accessible". Todo correcto. Para uso en producción, ponlo detrás de un proxy inverso (opción 2) o usa Dokploy (opción 3).

</Notice>

### Paso 5: acceder a n8n

Ve a `http://localhost:5678` en tu navegador. Crea tu cuenta de administrador y empieza a construir flujos de trabajo.

## Opción de instalación 2: n8n detrás de un proxy inverso Traefik

Esta es la instalación de producción de instancia única: HTTPS automático vía Let's Encrypt, enrutado por dominio y gestión opcional con Dockge.

<Notice type="info" title="Prerrequisitos">

Necesitas Traefik funcionando con certificados wildcard. Sigue la [guía completa de Traefik como proxy inverso en Docker](https://www.bitdoze.com/traefik-proxy-docker/) y el [certificado wildcard gratuito de Let's Encrypt en Traefik con Cloudflare](https://www.bitdoze.com/traefik-wildcard-certificate/) para configurarlo primero. Puedes gestionar el stack con [Dockge, el gestor de Docker Compose para self-hosting](/es/instalar-dockge/).

</Notice>

### Paso 1: preparar la red de Traefik

```bash
# Create the Traefik network if it doesn't exist
docker network create traefik-net 2>/dev/null || echo "Network already exists"

# Verify
docker network ls | grep traefik-net
```

### Paso 2: Docker Compose con etiquetas de Traefik

```yaml
services:
  n8n:
    image: docker.io/n8nio/n8n:2.37.7
    container_name: n8n-production
    restart: unless-stopped
    environment:
      - N8N_EDITOR_BASE_URL=https://n8n.yourdomain.com
      - N8N_WEBHOOK_URL=https://n8n.yourdomain.com
      - N8N_PROXY_HOPS=1
      - GENERIC_TIMEZONE=UTC
      - TZ=UTC
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS=true
      - N8N_DEFAULT_BINARY_DATA_MODE=filesystem
      - N8N_LOG_LEVEL=warn
      - N8N_LOG_OUTPUT=file
      - N8N_METRICS=true
      - EXECUTIONS_DATA_PRUNE=true
      - EXECUTIONS_DATA_MAX_AGE=336
    volumes:
      - ./data:/home/node/.n8n
      - ./files:/files
    networks:
      - traefik-net
    cap_drop:
      - ALL
    cap_add:
      - SETUID
      - SETGID
      - CHOWN
      - DAC_OVERRIDE
    healthcheck:
      test: ['CMD', 'wget', '--no-verbose', '--tries=1', '--spider', 'http://localhost:5678/healthz']
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.n8n.rule=Host(`n8n.yourdomain.com`)"
      - "traefik.http.routers.n8n.entrypoints=https"
      - "traefik.http.routers.n8n.tls=true"
      - "traefik.http.routers.n8n.tls.certresolver=letsencrypt"
      - "traefik.http.services.n8n.loadbalancer.server.port=5678"
      - "traefik.http.routers.n8n.middlewares=security-headers@file"

networks:
  traefik-net:
    external: true
```

Cambios respecto a la versión anterior: se eliminó Redis (no hace falta sin modo de cola), se eliminó `VUE_APP_URL_BASE_API`, se reemplazó `WEBHOOK_URL` por `N8N_WEBHOOK_URL`, se añadió `N8N_PROXY_HOPS=1` para Cloudflare, se quitó la clave `version:` y se fijó la etiqueta de la imagen.

### Paso 3: desplegar con Dockge

Si usas Dockge para gestionar contenedores:

1. **Accede a Dockge**: abre tu instalación de Dockge
2. **Crea un nuevo stack**: haz clic en "Create Stack" y llámalo "n8n-production"
3. **Pega la configuración**: copia el contenido del Docker Compose de arriba
4. **Configura el entorno**: añade tu clave de cifrado y el dominio en el archivo `.env`
5. **Despliega el stack**: haz clic en deploy y vigila los logs

<Button text="Desplegar con Dockge" size="lg" color="green" variant="solid" icon="arrow-right" />

### Paso 4: configurar el DNS y verificar

Actualiza tus registros DNS:

| Tipo de registro | Nombre | Valor | TTL |
|-------------|------|-------|-----|
| A | n8n | YOUR_SERVER_IP | 300 |
| AAAA | n8n | YOUR_IPv6_ADDRESS | 300 |

<Notice type="info" title="Propagación del DNS">

Los cambios de DNS pueden tardar hasta 24 horas en propagarse globalmente. Usa `nslookup n8n.yourdomain.com` o un comprobador de DNS en línea para verificarlo.

</Notice>

Una vez propagado el DNS, verifica:

```bash
curl -I https://n8n.yourdomain.com/healthz
```

Debería devolver `200 OK`. Comprueba el panel de Traefik para confirmar que la ruta está activa.

## Opción de instalación 3: desplegar n8n con Dokploy

Dokploy ofrece el despliegue más sencillo, con una interfaz gráfica que gestiona el proxy inverso, el SSL y la configuración del entorno. Ahora incluye tanto una plantilla "n8n" como una plantilla "n8n Queue Mode" (con PostgreSQL).

### Paso 1: instalar Dokploy

Sigue la [guía de instalación de Dokploy](https://www.bitdoze.com/dokploy-install/) para configurar la plataforma en tu servidor.

### Paso 2: crear la aplicación n8n

1. **Accede al panel de Dokploy**: inicia sesión en tu instancia de Dokploy
2. **Crea un nuevo proyecto**: haz clic en "New Project" y llámalo "n8n-automation"
3. **Selecciona la plantilla**: elige "n8n" entre las plantillas disponibles (o "n8n Queue Mode" para producción con PostgreSQL)
4. **Configura los ajustes básicos**: define el nombre y la descripción de tu aplicación

![Creación de un nuevo servicio n8n en el panel de Dokploy](@assets/images/25/07/dokploy-createservice.png)
![Selección de la plantilla n8n en Dokploy](@assets/images/25/07/dokploy-SearXNG.png)

### Paso 3: configurar las variables de entorno

Define las variables de entorno esenciales:

| Variable | Valor | Descripción |
|----------|-------|-------------|
| `N8N_EDITOR_BASE_URL` | `https://n8n.yourdomain.com` | URL de la interfaz del editor |
| `N8N_WEBHOOK_URL` | `https://n8n.yourdomain.com` | Base del endpoint de webhooks |
| `GENERIC_TIMEZONE` | `UTC` | Zona horaria del servidor |
| `TZ` | `UTC` | Zona horaria del contenedor |
| `N8N_ENCRYPTION_KEY` | `your_generated_key` | Clave de cifrado para las credenciales |
| `N8N_DEFAULT_BINARY_DATA_MODE` | `filesystem` | Modo de almacenamiento de datos binarios |
| `N8N_LOG_LEVEL` | `info` | Nivel de detalle de los logs |
| `EXECUTIONS_DATA_PRUNE` | `true` | Activa la limpieza de ejecuciones |
| `EXECUTIONS_DATA_MAX_AGE` | `336` | Conserva las ejecuciones 14 días (horas) |

<Notice type="warning" title="Seguridad del entorno">

Nunca reutilices claves de cifrado entre instancias. n8n admite variantes con sufijo `_FILE` para los secretos (p. ej., `N8N_ENCRYPTION_KEY_FILE`, `DB_POSTGRESDB_PASSWORD_FILE`), que funcionan con secretos de Docker y gestores de `.env`.

</Notice>

### Paso 4: dominio y despliegue

1. **Añade el dominio**: en Dokploy, ve a los ajustes de tu aplicación n8n
2. **Configura el SSL**: activa la generación automática de certificados SSL
3. **Define el dominio**: introduce tu subdominio (p. ej., `n8n.yourdomain.com`)
4. **Despliega**: haz clic en el botón de despliegue y sigue el proceso

![Configuración del dominio y el SSL de n8n en Dokploy](@assets/images/25/07/dokploy-domain.png)
![Despliegue de n8n desde la interfaz de Dokploy](@assets/images/25/07/dokploy-deploy.png)

<Button text="Lanzar el despliegue de n8n" size="xl" color="blue" variant="solid" icon="arrow-right" />

Una vez desplegado, accede a tu instancia de n8n con el dominio configurado y crea tu cuenta de administrador.

## Opción de instalación 4: modo de cola de n8n con PostgreSQL

El modo de cola es para escalar. Si ejecutas más de ~50 ejecuciones concurrentes, necesitas escalado horizontal o quieres la robustez de PostgreSQL, esta es tu configuración.

<Notice type="info" title="¿Cuándo necesitas el modo de cola?">

Si trabajas en solitario con menos de 50 flujos de trabajo, las opciones 1-3 son suficientes. El modo de cola añade complejidad (PostgreSQL, Redis, contenedores de workers y runners separados), pero te permite distribuir el trabajo entre varios procesos. El modo de cola funciona en la edición Community. La *pestaña* de monitorización de workers es solo para Enterprise, pero los workers funcionan sin problema.

</Notice>

### Visión general de la arquitectura

En modo de cola, la instancia principal de n8n gestiona el editor, los webhooks y los triggers. Los workers procesan las ejecuciones desde una cola respaldada por Redis. Los runners se encargan del aislamiento de los nodos Code. PostgreSQL almacena todos los datos.

```
Internet → Traefik → n8n (main) ↔ PostgreSQL
                         ↓
                       Redis (queue)
                         ↓
                    n8n-worker ↔ n8n-runner
```

### Docker Compose para el modo de cola

```yaml
services:
  postgres:
    image: postgres:18
    restart: always
    environment:
      - POSTGRES_USER=${POSTGRES_USER}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_DB=${POSTGRES_DB}
    volumes:
      - pg-data:/var/lib/postgresql/data
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}']
      interval: 5s
      timeout: 5s
      retries: 10

  redis:
    image: redis:7-alpine
    restart: always
    command: redis-server --appendonly yes --maxmemory 512mb --maxmemory-policy allkeys-lru
    volumes:
      - redis-data:/data
    healthcheck:
      test: ['CMD', 'redis-cli', 'ping']
      interval: 15s
      timeout: 5s
      retries: 3

  n8n:
    image: docker.io/n8nio/n8n:2.37.7
    restart: always
    ports:
      - '5678:5678'
    environment:
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=${POSTGRES_DB}
      - DB_POSTGRESDB_USER=${POSTGRES_USER}
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
      - EXECUTIONS_MODE=queue
      - QUEUE_BULL_REDIS_HOST=redis
      - QUEUE_BULL_REDIS_PORT=6379
      - N8N_EDITOR_BASE_URL=https://n8n.yourdomain.com
      - N8N_WEBHOOK_URL=https://n8n.yourdomain.com
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - N8N_DEFAULT_BINARY_DATA_MODE=database
      - N8N_METRICS=true
      - GENERIC_TIMEZONE=UTC
      - TZ=UTC
    volumes:
      - n8n-data:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    healthcheck:
      test: ['CMD', 'wget', '--no-verbose', '--tries=1', '--spider', 'http://localhost:5678/healthz']
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  n8n-worker:
    image: docker.io/n8nio/n8n:2.37.7
    restart: always
    command: worker
    environment:
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=${POSTGRES_DB}
      - DB_POSTGRESDB_USER=${POSTGRES_USER}
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
      - EXECUTIONS_MODE=queue
      - QUEUE_BULL_REDIS_HOST=redis
      - QUEUE_BULL_REDIS_PORT=6379
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      - N8N_DEFAULT_BINARY_DATA_MODE=database
      - N8N_RUNNERS_MODE=external
      - N8N_RUNNERS_AUTH_TOKEN=${RUNNERS_AUTH_TOKEN}
      - N8N_RUNNERS_BROKER_LISTEN_ADDRESS=0.0.0.0
      - GENERIC_TIMEZONE=UTC
      - TZ=UTC
    volumes:
      - n8n-data:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy

  n8n-runner:
    image: docker.io/n8nio/runners:2.37.7
    restart: always
    environment:
      - N8N_RUNNERS_AUTH_TOKEN=${RUNNERS_AUTH_TOKEN}
      - N8N_RUNNERS_TASK_BROKER_URI=http://n8n:5679

volumes:
  pg-data:
  redis-data:
  n8n-data:
```

<Notice type="warning" title="Ubicación de la imagen de runners">

La imagen `n8nio/runners` solo está disponible en Docker Hub; NO está en `docker.n8n.io`. Usa `docker.io/n8nio/runners:2.37.7`. Las imágenes principales de n8n y del worker pueden usar cualquiera de los dos registros.

</Notice>

Crea el archivo `.env`:

```bash
cat > .env << 'EOF'
POSTGRES_USER=n8n
POSTGRES_PASSWORD=change_me_to_a_strong_password
POSTGRES_DB=n8n
N8N_ENCRYPTION_KEY=$(openssl rand -base64 32)
RUNNERS_AUTH_TOKEN=$(openssl rand -base64 32)
EOF
```

### Lanzar y verificar el modo de cola

```bash
docker compose up -d

# Verify all 5 containers are running
docker compose ps

# Check the health endpoint
curl -s http://localhost:5678/healthz

# Check worker logs for queue connection
docker compose logs n8n-worker
```

Los cinco contenedores deberían aparecer como healthy. Los logs del worker deberían mostrar que se conectó a Redis y está listo para procesar trabajos. Nota: la pestaña de monitorización de workers en la interfaz de n8n es solo para Enterprise, pero los workers procesan ejecuciones sin problema en Community.

## Monitorización, copias de seguridad y mantenimiento

Una vez que n8n está en marcha, hay que mantenerlo sano. Esta sección cubre comprobaciones de salud, métricas, copias de seguridad y un calendario de mantenimiento.

### Monitorización de la salud

n8n expone un endpoint `/healthz` por defecto (configurable vía `N8N_ENDPOINT_HEALTH`). Para una monitorización más profunda:

**Endpoint de métricas**: define `N8N_METRICS=true` para exponer `/metrics` en formato Prometheus. Recógelo con Prometheus y construye dashboards en Grafana.

<Notice type="info" title="Endpoint de métricas">

`N8N_METRICS=true` expone `/metrics` en formato Prometheus. Combínalo con la [monitorización con Beszel y Uptime Kuma en Dokploy](/es/beszel-uptime-kuma/) para un stack de monitorización completo.

</Notice>

**Trazas con OpenTelemetry**: disponible desde n8n 2.19 para trazar la ejecución de flujos de trabajo. Configurable desde la interfaz a partir de la 2.27. Las etiquetas de span personalizadas son una función Enterprise (2.22+).

**Logs estructurados**: define `N8N_LOG_OUTPUT=json` para logs procesables por máquinas que funcionan con herramientas de agregación de logs.

**Limpieza de ejecuciones**: `EXECUTIONS_DATA_PRUNE=true` con `EXECUTIONS_DATA_MAX_AGE=336` (14 días) es un buen valor por defecto. Añade `EXECUTIONS_DATA_PRUNE_MAX_COUNT=10000` para limitar el número total de ejecuciones almacenadas.

**Métricas clave a vigilar:**

| Métrica | Descripción | Umbral de alerta |
|--------|-------------|-----------------|
| Tiempo de respuesta | Latencia de `/healthz` | > 5 segundos |
| Uso de memoria | Memoria del contenedor | > 80 % |
| Espacio en disco | Uso del volumen de datos | > 90 % |
| Ejecuciones fallidas | Tasa de fallos de flujos | > 10 % |
| Longitud de la cola | Ejecuciones pendientes (modo de cola) | > 100 elementos |

### Estrategias de copia de seguridad

Dos caminos según tu base de datos:

**SQLite (opciones 1–3):**
```bash
#!/bin/bash
# n8n SQLite Backup Script
BACKUP_DIR="/backups/n8n"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p "$BACKUP_DIR"

# Stop n8n briefly for a consistent snapshot
docker compose stop n8n

# Back up data dir (includes SQLite DB + WAL + encryption key)
tar -czf "$BACKUP_DIR/n8n_data_$DATE.tar.gz" ./data

# Back up config
cp docker-compose.yml "$BACKUP_DIR/docker-compose_$DATE.yml"
cp .env "$BACKUP_DIR/env_$DATE.backup"

# Restart
docker compose start n8n

# Clean old backups (keep last 30 days)
find "$BACKUP_DIR" -name "*.tar.gz" -mtime +30 -delete

echo "Backup completed: n8n_data_$DATE.tar.gz"
```

**PostgreSQL (opción 4):**
```bash
#!/bin/bash
# n8n PostgreSQL Backup Script
BACKUP_DIR="/backups/n8n"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p "$BACKUP_DIR"

# Dump the database
docker compose exec -T postgres pg_dump -U ${POSTGRES_USER} ${POSTGRES_DB} | gzip > "$BACKUP_DIR/n8n_pg_$DATE.sql.gz"

# Back up .n8n volume (encryption key, logs)
tar -czf "$BACKUP_DIR/n8n_home_$DATE.tar.gz" ./n8n-data

# Back up config
cp docker-compose.yml "$BACKUP_DIR/docker-compose_$DATE.yml"
cp .env "$BACKUP_DIR/env_$DATE.backup"

# Clean old backups
find "$BACKUP_DIR" -name "*.gz" -mtime +30 -delete

echo "Backup completed: n8n_pg_$DATE.sql.gz"
```

<Notice type="warning" title="Prueba tus restauraciones">

Una copia de seguridad que no has probado no es una copia de seguridad. Tras restaurar, verifica que `N8N_ENCRYPTION_KEY` coincide con la que se usaba cuando se guardaron las credenciales; si no coincide, todas las credenciales guardadas son ilegibles. Envía copias cifradas fuera del servidor a S3, Backblaze B2 o Cloudflare R2. Consulta [Pluton: copias de seguridad autoalojadas con Restic y Rclone](/es/pluton-backup-autoalojado/) para montar copias externas automatizadas.

</Notice>

**Paquetes de flujos de trabajo**: n8n 2.27 introdujo los paquetes `.n8np` (vista previa): paquetes portátiles de flujos de trabajo que puedes exportar e importar entre instancias. Útiles para migrar flujos individuales sin restaurar toda la base de datos.

### Tareas de mantenimiento periódicas

**Semanal:**
- Revisa los logs de ejecución en busca de errores
- Comprueba el uso de disco del volumen de datos
- Verifica la integridad de las copias de seguridad

**Mensual:**
- Actualiza n8n a la última versión estable fijada (`docker compose pull && docker compose up -d`)
- Revisa los ajustes de limpieza de ejecuciones
- Audita el acceso de usuarios y las credenciales

**Trimestral:**
- Prueba una restauración completa desde la copia de seguridad
- Revisa el uso de recursos y escala si hace falta
- Comprueba los cambios disruptivos en el [changelog de n8n](https://docs.n8n.io/changelog/) antes de actualizar

## Precios de n8n: Community frente a Cloud

La edición Community es gratuita y está genuinamente completa para uso en solitario: flujos de trabajo, pasos, ejecuciones y usuarios ilimitados. El modo de cola funciona en Community; solo la *pestaña* de monitorización de workers requiere una licencia Enterprise.

**Precios de n8n Cloud (2026):**

| Plan | Precio | Ejecuciones/mes | Notas |
|------|-------|-----------------|-------|
| Starter | 20 €/mes | 2 500 | Alojado en la nube |
| Pro | 50 €/mes | 10 000 | Alojado en la nube |
| Business | 667 €/mes | 40 000 | Autoalojado con clave de licencia |
| Enterprise | Contactar con ventas | A medida | SSO, Insights, entornos Git, multi-main |

Sin límites de flujos activos en ningún plan: el precio se basa en las ejecuciones.

**Las cuentas de quien opera en solitario**: la edición Community + un VPS de [Hetzner Cloud](https://go.bitdoze.com/hetzner) a 4–8 €/mes supera con creces a Cloud Starter. La licencia de pago compra SSO, paneles de Insights, entornos basados en Git, gestión de secretos externos y alta disponibilidad multi-main. Para la mayoría de operadores en solitario, Community es suficiente.

<Notice type="info" title="Licencia fair-code">

n8n usa la [Sustainable Use License](https://docs.n8n.io/privacy-and-security/sustainable-use-license), no una licencia open source tradicional de la OSI. El uso interno es gratuito, pero la licencia restringe ofrecer n8n como servicio comercial competidor. Es gratis para tus propias automatizaciones; simplemente no intentes venderlo como tu propio SaaS.

</Notice>

## Solución de problemas comunes de n8n

Estos son los fallos que más veo con n8n autoalojado. Cada uno le ha quemado a alguien.

<Accordion label="Límites de descarga de la imagen Docker" group="troubleshooting">

La imagen Docker de n8n tiene más de 100 millones de pulls en Docker Hub. Los límites de pulls anónimos pueden afectarte, sobre todo en despliegues automatizados. En febrero de 2026, los usuarios reportaron errores `toomanyrequests` incluso en `docker.n8n.io` (el registro espejo propio de n8n).

**Solución**: usa `docker.io/n8nio/n8n` (Docker Hub) como registro por defecto. Fija las etiquetas de las imágenes para evitar pulls innecesarios. Para CI/CD, autentica tu puller de Docker Hub. Ten en cuenta que `n8nio/runners` solo está en Docker Hub: no está disponible en `docker.n8n.io`.

</Accordion>

<Accordion label="La clave de cifrado no coincide tras una restauración" group="troubleshooting">

Tras migrar o restaurar desde una copia de seguridad, todas las credenciales guardadas aparecen en blanco o lanzan errores de descifrado. Esto ocurre cuando `N8N_ENCRYPTION_KEY` no coincide con la clave que estaba en uso cuando se almacenaron las credenciales.

**Solución**: haz siempre copia de seguridad del `.env` junto con tu directorio de datos. En modo de cola, asegúrate de que la misma clave de cifrado está definida en la instancia principal y en todos los workers. Tras una restauración, verifica que puedes abrir una credencial guardada en el editor de n8n antes de pasar a producción.

</Accordion>

<Accordion label="Advertencias de deprecación en los logs" group="troubleshooting">

Si tus logs muestran una advertencia de deprecación de `WEBHOOK_URL` al arrancar, estás usando el nombre antiguo de la variable. Se deprecó en n8n 2.35.0 y fue reemplazada por `N8N_WEBHOOK_URL`. El nombre antiguo todavía funciona, pero se eliminará en una versión futura.

**Solución**: reemplaza `WEBHOOK_URL` por `N8N_WEBHOOK_URL` en tu archivo compose o en tus variables de entorno. Quita también `VUE_APP_URL_BASE_API` si está presente: no hace nada en Docker (solo se usa al compilar manualmente el paquete de la interfaz del editor).

</Accordion>

<Accordion label="Errores en nodos Code tras actualizar a 2.x" group="troubleshooting">

n8n 2.0 bloquea por defecto el acceso a variables de entorno dentro de los nodos Code (`N8N_BLOCK_ENV_ACCESS_IN_NODE=true`). Si tus flujos de trabajo usan `process.env` o `$evaluateExpression()` devuelve null en nodos Code, esta es la razón.

**Solución**: revisa los [cambios disruptivos de la v2.0](https://docs.n8n.io/changelog/v20-breaking-changes) para ver las soluciones documentadas. Si necesitas acceso a variables de entorno en nodos Code, define `N8N_BLOCK_ENV_ACCESS_IN_NODE=false`, pero entiende que esto reduce la seguridad.

</Accordion>

<Accordion label="Callbacks de OAuth fallan tras la actualización a 2.0" group="troubleshooting">

El valor por defecto de la autenticación del callback de OAuth cambió en n8n 2.0. Si los nodos conectados por OAuth (Google, Microsoft, etc.) empiezan a fallar tras una actualización, esta es probablemente la causa.

**Solución**: define `N8N_SKIP_AUTH_ON_OAUTH_CALLBACK=false` y vuelve a probar tus conexiones OAuth antes de pasar a producción.

</Accordion>

<Accordion label="El healthcheck falla en la imagen mínima 2.x" group="troubleshooting">

La imagen Docker de n8n 2.x es mínima (basada en Alpine, usuario `node` sin root). Herramientas como `wget` o `curl` pueden no estar presentes, lo que rompe los healthchecks que dependen de ellas.

**Solución**: verifica primero la disponibilidad de la herramienta:
```bash
docker run --rm --entrypoint sh n8nio/n8n:2.37.7 -c "which wget"
```
Si falta `wget`, cambia a un healthcheck basado en Node:
```yaml
healthcheck:
  test: ['CMD', 'node', '-e', "fetch('http://localhost:5678/healthz').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"]
  interval: 30s
  timeout: 10s
  retries: 3
  start_period: 40s
```

</Accordion>

## Conclusión

Autoalojar n8n te da automatización de flujos de trabajo ilimitada por lo que cuesta un VPS. Las cuatro opciones de esta guía cubren distintas necesidades:

1. **Docker Compose independiente**: la forma más rápida de empezar, SQLite, un solo contenedor
2. **Proxy inverso Traefik**: instancia única de producción con HTTPS automático y enrutado por dominio
3. **Dokploy**: despliegue con interfaz gráfica, proxy inverso integrado y gestión de SSL
4. **Modo de cola con PostgreSQL**: escalado horizontal con workers, cola Redis y runners externos

La edición Community es gratuita y cubre todo lo que necesita quien opera en solitario. Un VPS de [Hetzner Cloud](https://go.bitdoze.com/hetzner) a 4–8 €/mes es toda la infraestructura que la mayoría necesita. Con n8n 3.0 convirtiendo Docker en el único método de autoalojamiento soportado a partir de octubre de 2026, ahora es un buen momento para dejar lista tu configuración de Docker Compose.

<ListCheck>

- **Control total de los datos**: los flujos de trabajo y los datos permanecen en tus servidores
- **Sin costes por ejecución**: ejecuta tantos flujos de trabajo como soporte tu hardware
- **Listo para producción**: PostgreSQL, modo de cola, monitorización y copias de seguridad cubiertos
- **Preparado para el futuro**: Docker Compose es el método oficialmente recomendado y pronto el único soportado
- **Desarrollo activo**: más de 203 000 estrellas en GitHub, lanzamientos semanales, más de 1 000 integraciones

</ListCheck>

**Próximos pasos:**

1. Elige una opción de instalación y pon n8n en marcha esta misma noche
2. Construye un flujo de trabajo sencillo: un trigger webhook con una respuesta HTTP es un buen comienzo
3. Explora el [directorio de integraciones](https://n8n.io/integrations/) para tus servicios más usados
4. Configura las copias de seguridad antes de tener algo que merezca la pena perder
5. Escala al modo de cola cuando un solo contenedor se te quede pequeño

<Button text="Empieza tu camino en la automatización" size="xl" color="green" variant="solid" icon="arrow-right" />

Para más guías de autoalojamiento, consulta nuestras [guías de paneles autoalojados](https://www.bitdoze.com/best-self-hosted-panels/) y las [recomendaciones de contenedores Docker](/es/contenedores-docker-servidor-casa/). Si te interesa la búsqueda con IA para tus flujos del Asistente de IA de n8n, mira nuestra guía sobre [búsqueda autoalojada con SearXNG](https://www.bitdoze.com/searxng-self-host-privacy-search/).