Cómo instalar Outline Wiki en Docker: guía completa 2025

Si quieres instalar Outline Wiki en Docker, esta guía lo cubre. Outline es una alternativa a Notion autoalojada: una base de conocimiento y wiki para documentos, especificaciones, notas de reuniones y respuestas de soporte en una infraestructura que tú controlas. Funciona sobre PostgreSQL y Redis, soporta almacenamiento local de archivos y tiene ~39,8k estrellas en GitHub con la última versión en v1.9.0.

Esta guía recorre una configuración completa de Docker Compose: autenticación con Slack u OIDC, SMTP para notificaciones por email, almacenamiento local de archivos, Cloudflare Tunnels, resolución de problemas y copias de seguridad. Si estás evaluando otras herramientas de notas autoalojadas, mira Docmost, otra wiki autoalojada o Memos para tomar notas más ligeras.

¿Qué es Outline Wiki? Una alternativa a Notion autoalojada

Outline es una plataforma de base de conocimiento y documentación creada para equipos. Se centra en una sola cosa: organizar y compartir documentos internos. No intenta ser un espacio de trabajo todo en uno como Notion.

Algunas cosas que debes saber antes de decidirte:

• Licencia: Outline usa la licencia BSL 1.1, con código disponible pero no totalmente open source. Para la mayoría de los equipos autoalojados esto no importa, pero conviene saberlo si el cumplimiento normativo es una preocupación.
• Sin autenticación por email+contraseña por diseño. Outline requiere un proveedor SSO (Slack, OIDC, Google, Microsoft, GitHub, Discord, GitLab, SAML, Passkeys o enlaces mágicos por email). Es deliberado, no una función que falte.
• Sin apps móviles nativas. Hay una PWA para iOS/Android y apps de escritorio para macOS/Windows, pero no aparece en la App Store ni en Play Store.

¿Cómo se compara con Notion? Outline tiene un alcance más reducido (solo documentos y base de conocimiento), es más sencillo de usar y puedes autoalojarlo. Notion tiene bases de datos, gestión de proyectos y un conjunto de funciones mucho más amplio; pero quedas atado a su nube.

Requisitos previos para instalar Outline Wiki en Docker

Antes de empezar, ten esto preparado:

Los precios de los VPS subieron en general en 2026 — si estás reconsiderando una máquina alquilada, mira qué cambió y cuándo gana un mini PC.

Lo que se instala: Outline (latest o una versión fijada), PostgreSQL 18 y Redis 7.

Para una comparativa de paneles de gestión de Docker, consulta los mejores paneles de servidor autoalojados. Si prefieres Traefik en lugar de Cloudflare Tunnels, tengo una guía completa sobre Traefik como proxy inverso en Docker.

Paso 1: Configurar la autenticación de Slack para Outline Wiki

Slack es gratis y la opción de autenticación más sencilla para equipos que ya lo usan. Así se configura.

1. Ve a Slack API Apps y haz clic en Create New App → From scratch.
2. Ponle un nombre (p. ej. “Outline Docs”) y selecciona tu workspace.
3. En OAuth & Permissions, añade la URL de redirección:

   https://docs.yourdomain.com/auth/slack.callback

4. En Basic Information, copia el Client ID y el Client Secret.

Los scopes necesarios son identity.avatar, identity.basic, identity.email e identity.team. Slack los solicita por defecto para Sign in with Slack.

Paso 2: Configurar SMTP para Outline Wiki (notificaciones por email e invitaciones)

SMTP se añade rápido. Necesitas estas variables de entorno:

Si usas un proveedor conocido (Mailgun, SendGrid, SES, Gmail), puedes sustituir SMTP_HOST/SMTP_PORT por SMTP_SERVICE=mailgun (o sendgrid, ses, gmail).

Las variables SMTP reales van en el archivo docker.env que se muestra en el Paso 3. Las he incluido como líneas comentadas que puedes descomentar.

Paso 3: Configuración de Docker Compose para Outline Wiki

Aquí está el docker-compose.yml completo y actualizado. Cambios clave respecto a versiones antiguas: sin campo version (obsoleto en Compose V2), imágenes fijadas de Postgres 18 y Redis 7 Alpine, ruta del volumen de Postgres corregida, healthchecks con condition: service_healthy y expose para los servicios internos.

services:
  outline:
    image: docker.getoutline.com/outlinewiki/outline:latest
    env_file: ./docker.env
    ports:
      - "3000:3000"
    volumes:
      - ./storage-data:/var/lib/outline/data
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    env_file: ./docker.env
    expose:
      - "6379"
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 30s
      retries: 3
    restart: unless-stopped

  postgres:
    image: postgres:18
    env_file: ./docker.env
    expose:
      - "5432"
    volumes:
      - ./database-data:/var/lib/postgresql
    healthcheck:
      test: ["CMD", "pg_isready", "-d", "outline", "-U", "user"]
      interval: 30s
      timeout: 20s
      retries: 3
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: outline
      PGSSLMODE: disable
    restart: unless-stopped

Qué cambió respecto a la versión antigua:

1. Se eliminó version: "3.2" (obsoleto en Docker Compose V2)
2. Se cambió el volumen de Postgres de /var/lib/postgresql/data a /var/lib/postgresql (cambio incompatible de Postgres 18)
3. Se fijaron postgres:18 y redis:7-alpine en lugar de :latest sin fijar
4. Se añadió condition: service_healthy a depends_on, para que Outline espere a que Postgres y Redis estén listos
5. Se cambió ports por expose en los servicios internos (Redis y Postgres no necesitan mapeo de puertos al host)
6. Se añadió PGSSLMODE: disable al entorno de Postgres
7. Se añadió env_file: ./docker.env a todos los servicios (patrón de archivo env compartido de la documentación oficial)
8. Se eliminaron container_name y hostname (el DNS integrado de Docker gestiona el descubrimiento de servicios)
9. Se eliminó el montaje del volumen redis.conf (no es necesario para un uso básico de Outline)
10. Se añadió restart: unless-stopped a Postgres y Redis

El archivo docker.env explicado

Crea un archivo docker.env en el mismo directorio que tu docker-compose.yml:

# PostgreSQL
POSTGRES_USER=user
POSTGRES_PASSWORD=pass
POSTGRES_DB=outline
PGSSLMODE=disable

# Outline
URL=https://docs.yourdomain.com
SECRET_KEY=generate_with_openssl_rand_hex_32
UTILS_SECRET=generate_with_openssl_rand_hex_32
PORT=3000

# Conexión a la base de datos
DATABASE_URL=postgres://user:pass@postgres:5432/outline
REDIS_URL=redis://redis:6379

# Almacenamiento de archivos
FILE_STORAGE=local
FILE_STORAGE_LOCAL_ROOT_DIR=/var/lib/outline/data
FILE_STORAGE_UPLOAD_MAX_SIZE=26214400

# Auth — Slack
SLACK_CLIENT_ID=your_slack_client_id
SLACK_CLIENT_SECRET=your_slack_client_secret

# Auth — OIDC (alternativa a Slack, elige una)
# OIDC_CLIENT_ID=your_oidc_client_id
# OIDC_CLIENT_SECRET=your_oidc_client_secret
# OIDC_AUTH_URI=https://auth.yourdomain.com/application/o/authorize/
# OIDC_TOKEN_URI=https://auth.yourdomain.com/application/o/token/
# OIDC_USERINFO_URI=https://auth.yourdomain.com/application/o/userinfo/
# OIDC_USERNAME_CLAIM=preferred_username
# OIDC_DISPLAY_NAME=SSO Login
# OIDC_SCOPES=openid profile email

# SMTP (necesario para invitaciones y notificaciones por email)
# SMTP_HOST=smtp.example.com
# SMTP_PORT=465
# SMTP_USERNAME=your_username
# SMTP_PASSWORD=your_password
# SMTP_FROM_EMAIL=Outline <[email protected]>
# SMTP_SECURE=true

# Opcional pero recomendado
FORCE_HTTPS=true
# RATE_LIMITER_MULTIPLIER=1.0
# LOG_LEVEL=debug  # solo para depurar

Genera ambos secretos con:

openssl rand -hex 32

Variables clave explicadas:

• URL: debe coincidir exactamente con tu dominio público (incluido el https://). Outline la usa para las URLs de callback y los enlaces a recursos.
• FORCE_HTTPS: ponlo en true cuando estés detrás de un proxy inverso que gestiona el TLS. Ponlo en false para pruebas locales sin TLS. Configurarlo mal provoca bucles de redirección.
• DATABASE_URL: el hostname (postgres) debe coincidir con el nombre del servicio en docker-compose.yml, no localhost.
• RATE_LIMITER_MULTIPLIER: valor en punto flotante, 1.0 por defecto. Auméntalo para equipos más grandes que alcancen los límites de peticiones.
• LOG_LEVEL=debug: activa el registro detallado temporalmente al diagnosticar problemas de arranque.

Para más información sobre la gestión del entorno en Docker Compose, consulta las variables de entorno de Docker en Compose y la gestión de secretos en Docker Compose.

Configuración de los servicios PostgreSQL y Redis

Postgres 18 está fijado porque la imagen de Docker cambió su directorio de datos interno. Usar la ruta antigua /var/lib/postgresql/data con Postgres 18+ provoca: Error: Postgres detected data in /var/lib/postgresql/data (unused mount/volume). La solución es usar /var/lib/postgresql sin el sufijo /data.

Redis 7 Alpine es una imagen pequeña (~10 MB) que funciona sin configuración para Outline. No hace falta un redis.conf personalizado.

expose frente a ports: los servicios internos (Postgres, Redis) usan expose. Son accesibles para otros contenedores en la red de Docker pero no se mapean a puertos del host. Solo el puerto 3000 de Outline se expone al host. Es más seguro que mapear los tres servicios a puertos del host.

Paso 4: Desplegar y verificar tu instalación de Outline Wiki

Despliega con:

docker compose up -d

Comprueba que todos los contenedores están en marcha

docker compose ps

Los tres servicios deberían mostrar “Up” y estado healthy:

NAME              STATUS                    PORTS
outline-app       Up (healthy)              0.0.0.0:3000->3000/tcp
outline-postgres  Up (healthy)              5432/tcp
outline-redis     Up (healthy)              6379/tcp

Revisa los logs de Outline para ver los mensajes de arranque y migración:

docker compose logs outline

Busca Server started on port 3000 y los mensajes de migración. Si ves errores de conexión a Postgres o Redis, comprueba que los nombres de servicio en DATABASE_URL y REDIS_URL coinciden con tu docker-compose.yml.

Corrige los permisos de subida de archivos

Outline se ejecuta como UID 1001 dentro del contenedor. Sin los permisos correctos, las subidas de imágenes fallan silenciosamente:

chown 1001 ./storage-data

Verifica: abre Outline en tu navegador, crea un documento y sube una imagen. Si funciona, ya está.

Prueba la conectividad WebSocket

Abre el mismo documento en dos pestañas del navegador. Escribe en una. Los cambios deberían aparecer en la otra en un segundo. Esto confirma que las conexiones WebSocket funcionan a través de tu proxy inverso.

Si la sincronización en tiempo real no funciona, es probable que tu proxy inverso no esté reenviando las cabeceras de upgrade de WebSocket. Consulta la sección de resolución de problemas más abajo.

Opcional: Configurar autenticación OIDC para Outline Wiki

Tienes dos formas de configurar OIDC: endpoints manuales o descubrimiento automático mediante la URL del emisor (issuer).

OIDC_CLIENT_ID=your_oidc_client_id
OIDC_CLIENT_SECRET=your_oidc_client_secret
OIDC_AUTH_URI=https://auth.yourdomain.com/application/o/authorize/
OIDC_TOKEN_URI=https://auth.yourdomain.com/application/o/token/
OIDC_USERINFO_URI=https://auth.yourdomain.com/application/o/userinfo/
OIDC_USERNAME_CLAIM=preferred_username
OIDC_DISPLAY_NAME=SSO Login
OIDC_SCOPES=openid profile email

https://docs.yourdomain.com/auth/oidc.callback

OIDC_CLIENT_ID=your_oidc_client_id
OIDC_CLIENT_SECRET=your_oidc_client_secret
OIDC_ISSUER_URL=https://auth.yourdomain.com/application/o/your-app/
OIDC_DISPLAY_NAME=SSO Login
OIDC_SCOPES=openid profile email

Otros proveedores de autenticación que soporta Outline: Discord, GitLab, GitHub, Google Workspace, Microsoft, SAML, Passkeys (biométricas/claves de seguridad) y enlaces mágicos por email. Outline nunca tendrá autenticación por email+contraseña. Es una decisión de diseño deliberada.

Tras activar OIDC, reinicia Outline (docker compose restart outline) y prueba el flujo de inicio de sesión. El botón de OIDC debería aparecer en la página de login.

Opcional: Configurar Cloudflare Tunnels para Outline Wiki

Para exponer Outline mediante Cloudflare Tunnels:

1. Ve al panel de Cloudflare → Access → Tunnels
2. Selecciona tu túnel → Configure → Public Hostname → Add a public hostname
3. Define el dominio a tu subdominio (p. ej. docs.yourdomain.com)
4. Define el servicio como http://localhost:3000 (o tu puerto mapeado)

Define FORCE_HTTPS=true en tu docker.env cuando uses Cloudflare Tunnels (gestiona el TLS en el edge).

Si prefieres gestionar los túneles de forma autoalojada, echa un vistazo a Pangolin como alternativa autoalojada a Cloudflare Tunnels.

Resolución de problemas comunes de Outline Wiki en Docker

Para un registro más detallado durante la depuración, añade temporalmente LOG_LEVEL=debug a tu docker.env y reinicia el contenedor.

Cómo hacer copia de seguridad y actualizar Outline Wiki en Docker

Copia de seguridad de la base de datos y los archivos

Tres cosas necesitan copias de seguridad periódicas:

1. Base de datos Postgres:

docker exec outline-postgres pg_dump -U user outline > backup_$(date +%F).sql

2. Directorio de almacenamiento de archivos:

cp -r ./storage-data ./storage-data-backup-$(date +%F)

3. Archivo docker.env:

Contiene SECRET_KEY y UTILS_SECRET. Sin SECRET_KEY, todos los datos cifrados de la base de datos son irrecuperables. Guárdalo junto con el volcado de tu base de datos.

Para una estrategia de copias de seguridad más robusta, puedes enviar los volcados de la base de datos y el almacenamiento de archivos a un almacenamiento compatible con S3. Mira cómo limpiar el espacio en disco de Docker si tus volúmenes de copias de seguridad consumen demasiado disco.

Actualizar Outline Wiki a la última versión

El proceso de actualización:

# 1. Haz copia de seguridad primero
docker exec outline-postgres pg_dump -U user outline > backup_$(date +%F).sql

# 2. Descarga las nuevas imágenes
docker compose pull

# 3. Reinicia con las nuevas imágenes
docker compose up -d

# 4. Revisa los logs para ver la salida de las migraciones
docker compose logs -f outline

Las migraciones se ejecutan automáticamente al arrancar el contenedor. No hay paso de migración manual — pero esto también significa que las migraciones son irreversibles. Si una actualización rompe algo, necesitas una copia de seguridad de la base de datos para volver atrás.

Fijar la versión en producción: en lugar de :latest, usa un tag específico como outline:1.9.0. Así controlas cuándo se aplican las actualizaciones y evitas roturas inesperadas al redesplegar.

image: docker.getoutline.com/outlinewiki/outline:1.9.0

Para una guía detallada sobre cómo actualizar contenedores de Docker Compose, consulta cómo actualizar contenedores Docker Compose.

Conclusiones sobre autoalojar Outline Wiki

Outline ha madurado mucho — v1.9.0 con ~39,8k estrellas en GitHub, soporte OIDC nativo, apps de escritorio, una PWA para móvil y un editor colaborativo pulido. Es una de las mejores plataformas de documentación autoalojadas si quieres algo enfocado y limpio en lugar del enfoque de Notion de querer meterlo todo.

Puntos clave de esta configuración:

• Fija las versiones de las imágenes en producción para evitar roturas inesperadas al redesplegar
• Haz copia de seguridad de docker.env junto con tu base de datos — perder SECRET_KEY significa perder todos los datos cifrados
• Configura SMTP pronto — sin él, las invitaciones y notificaciones fallan silenciosamente
• Fija Postgres en la 18 y usa la ruta de volumen /var/lib/postgresql (no /var/lib/postgresql/data)
• Usa docker compose (plugin V2), no docker-compose (obsoleto)

Outline usa la licencia BSL 1.1 — código disponible pero no totalmente open source. Para la mayoría de los equipos autoalojados está bien, pero conviene saberlo.

Nota: el vídeo de arriba se grabó con una versión anterior. Los pasos son similares, pero algunos comandos y configuraciones se han actualizado en esta guía.

Para más apps Docker autoalojadas, echa un vistazo a las mejores apps Docker autoalojadas para empresas y a los contenedores Docker autoalojados para tu servidor doméstico.