Por qué una pasarela de autenticación en el reverse proxy
Sin una pasarela centralizada, cada servicio gestiona su propio login: Grafana tiene su base de usuarios, Nextcloud la suya, Portainer la suya. El resultado: contraseñas distintas en todos lados, sin MFA coherente y una superficie de ataque multiplicada. Authelia resuelve esto interceptando el flujo HTTP: tu reverse proxy (Nginx, Traefik, Caddy) le envía cada solicitud antes de reenviarla, y Authelia decide — según la identidad, el grupo, la ruta solicitada y el nivel de MFA requerido — si la solicitud debe pasar. La aplicación protegida solo ve una solicitud autenticada con cabeceras de identidad inyectadas (Remote-User, Remote-Groups).
Qué te aporta Authelia auto-alojada
- Autenticación centralizada para todos tus servicios sin modificar su código
- MFA nativo: TOTP (Google Authenticator, Aegis), WebAuthn/passkey (llaves físicas, Touch ID, Windows Hello), Duo
- Proveedor OIDC en producción desde v4.34: tus apps compatibles con OIDC delegan la auth a Authelia
- Control de acceso granular por dominio, ruta, grupo de usuarios y nivel de autenticación
- Integración nativa con Traefik (forwardAuth), Nginx (auth_request), Caddy (forward_auth)
- Soporte LDAP/Active Directory para gestión de equipos, compatible con LLDAP
- Binario Go único (~30 MB), imagen Docker ligera, bajo consumo de memoria
- Logs JSON estructurados y métricas Prometheus para observabilidad
Requisitos previos
Antes de desplegar Authelia, verifica que tu entorno esté listo. Necesitas un VPS con Linux con Docker y Docker Compose instalados, un reverse proxy existente (Traefik v2/v3 o Nginx), un nombre de dominio con certificado TLS válido (Let's Encrypt recomendado), y una instancia Redis accesible por Authelia para almacenar sesiones (obligatorio en producción). Para el almacenamiento de usuarios, puedes empezar con un archivo YAML local o conectar un servidor LDAP como LLDAP. Authelia también requiere una clave JWT, una clave de cifrado de sesión y un secreto OIDC si activas ese modo: genéralos con openssl rand -hex 32.
Desplegar Authelia con Docker Compose
Crear la estructura de directorios
Crea
/opt/authelia/config/para los archivos de configuración y/opt/authelia/data/para el almacenamiento SQLite y las claves. Establece los permisos:mkdir -p /opt/authelia/{config,data} && chown -R 1000:1000 /opt/authelia.Escribir el archivo configuration.yml
Crea
/opt/authelia/config/configuration.yml. Definedefault_redirection_url,jwt_secret,session.secret,storage.encryption_key, configura el backend de autenticación (archivo o LDAP), Redis para las sesiones y la política de acceso por defecto (denyrecomendado).Crear el archivo users_database.yml (backend archivo)
Para un inicio rápido, crea
/opt/authelia/config/users_database.ymlcon tus usuarios. Las contraseñas deben estar hasheadas con Argon2id:docker run --rm authelia/authelia:latest authelia crypto hash generate argon2 --password 'TuContraseña'. Copia el hash generado en el archivo.Configurar Redis para las sesiones
Añade Redis a tu
docker-compose.yml. Enconfiguration.yml, definesession.redis.host: redisysession.redis.port: 6379. Redis es indispensable para que las sesiones sobrevivan a los reinicios de Authelia.Escribir el docker-compose.yml
Define los servicios
autheliayredis, y si usas Traefik añade las etiquetas apropiadas. Monta/opt/authelia/configde solo lectura y/opt/authelia/datade lectura-escritura. Expón el puerto 9091 internamente, nunca directamente a Internet.Configurar Traefik con forwardAuth
Crea un middleware de Traefik apuntando a
http://authelia:9091/api/authz/forward-auth. Aplica este middleware a los routers de los servicios a proteger. Para Nginx, usaauth_request /autheliacon las directivasproxy_passadecuadas.Configurar el dominio de sesión
En
configuration.yml, definesession.domaincon tu dominio raíz (ej:midominio.com) para que la cookie se comparta entre subdominios. Esta es la causa más frecuente de bucles de redirección.Arrancar y validar
Arranca con
docker compose up -d. Revisa los logs:docker compose logs -f authelia. Accede ahttps://auth.midominio.compara ver el portal de login. Prueba accediendo a un servicio protegido: debes ser redirigido al portal y devuelto al servicio tras autenticarte.Activar el proveedor OIDC (opcional)
Desde v4.34, el proveedor OIDC está listo para producción. Añade la sección
identity_providers.oidca tu configuración con tus clientes (Nextcloud, Grafana, Gitea…). Cada cliente tiene unid, unsecret(hasheado con Argon2id) y susredirect_urisautorizadas.
Usar Authelia como proveedor OIDC para un SSO real
El modo proveedor OIDC convierte Authelia en un SSO real: el usuario se conecta una vez en el portal Authelia, y todas las aplicaciones configuradas como clientes OIDC recuperan la identidad sin volver a pedir contraseña. Nextcloud, Grafana, Gitea, Portainer, Outline… todas soportan OIDC. Configura cada cliente con client_id, client_secret, y apunta la URL de descubrimiento a https://auth.midominio.com/.well-known/openid-configuration. El scope groups permite transmitir los grupos Authelia a las aplicaciones cliente para la gestión de roles.
Reglas de control de acceso: ejemplos concretos
La sección access_control es el corazón de la lógica de Authelia. Desde v4.37, las políticas han sido rediseñadas. Acceso público sin auth: {domain: 'status.midominio.com', policy: bypass}. Acceso MFA fuerte restringido a admins: {domain: 'portainer.midominio.com', subject: 'group:admins', policy: two_factor}. Ruta de API sin auth (webhooks): {domain: 'n8n.midominio.com', resources: ['^/webhook/.*'], policy: bypass}. El resto de N8N con MFA simple: {domain: 'n8n.midominio.com', policy: one_factor}. default_policy: deny garantiza que todo lo no listado queda bloqueado. El orden de las reglas importa: se aplica la primera que coincida.
MFA: TOTP, WebAuthn/passkey y Duo
Authelia soporta tres métodos de segundo factor, cada uno con sus ventajas.
TOTP (Contraseña de un solo uso basada en tiempo) es el método más universal: el usuario escanea un código QR con una app como Aegis (Android), Raivo (iOS) o Bitwarden Authenticator. Un código de 6 dígitos cambia cada 30 segundos. Simple de desplegar, compatible con todos los dispositivos, pero vulnerable al phishing si el código se intercepta.
WebAuthn/passkey es el método más robusto, soportado nativamente por Authelia desde v4.36. El usuario registra una llave física (YubiKey, Nitrokey) o un autenticador de plataforma (Touch ID en macOS, Windows Hello, Face ID en iOS). La criptografía de clave pública hace el phishing imposible: la clave privada nunca sale del dispositivo. Authelia implementa la especificación WebAuthn Level 2 completa, incluyendo passkeys sincronizadas vía iCloud Keychain o Google Password Manager.
Duo delega el segundo factor al servicio cloud Duo Security: push móvil, SMS o llamada telefónica. Práctico para equipos que ya usan Duo, pero introduce dependencia en un servicio externo.
Para la mayoría de stacks auto-alojados, la combinación recomendada es TOTP como método base y WebAuthn como método preferido para usuarios con YubiKey o dispositivo Apple/Windows reciente.
Migración a LLDAP: gestión de equipos
El backend archivo (users_database.yml) sirve para un usuario o familia pequeña, pero se vuelve difícil de gestionar con más de 5-10 usuarios. LLDAP (Light LDAP) es una implementación LDAP ligera escrita en Rust, con una interfaz web simple, que se integra perfectamente con Authelia.
Despliega LLDAP añadiendo su servicio a tu docker-compose.yml con las variables LLDAP_JWT_SECRET y LLDAP_LDAP_BASE_DN (ej: dc=midominio,dc=com). Crea tus grupos en la interfaz LLDAP (admins, users, devops…), luego modifica configuration.yml para cambiar del backend file al backend ldap.
Atención al breaking change de v4.35: el campo se llamaba authentification_backend (con error tipográfico) antes de v4.35 y fue corregido a authentication_backend. Verifica tu configuración si migras desde una versión anterior.
Actualizar Authelia: evitar los breaking changes
Authelia sigue un versionado semántico estricto y documenta sus breaking changes por versión. Los cambios notables:
v4.34: el proveedor OIDC pasa a producción. Si lo usabas en modo experimental, verifica los cambios de nombre de opciones.
v4.35: corrección authentification_backend → authentication_backend — cualquier configuración con el nombre antiguo impide el arranque con un error de validación.
v4.37: rediseño de políticas access_control — la sintaxis de las reglas se volvió más explícita. Consulta el changelog oficial antes de actualizar desde v4.36 o anterior.
v4.38.x (versión actual): estabilización, sin breaking changes mayores desde v4.37.
Procedimiento de actualización recomendado: (1) lee el changelog desde tu versión actual; (2) haz backup de /opt/authelia/config/ y /opt/authelia/data/; (3) prueba la configuración nueva con docker run --rm -v /opt/authelia/config:/config authelia/authelia:4.38.x authelia validate-config antes de reiniciar; (4) actualiza el tag en docker-compose.yml y reinicia.
Monitoreo: logs y métricas Prometheus
Authelia expone sus métricas Prometheus en /metrics (puerto configurable, por defecto 9959). Actívalas en configuration.yml con telemetry.metrics.enabled: true y telemetry.metrics.address: 'tcp://0.0.0.0:9959'. No expongas este puerto públicamente: límitalo a tu stack de monitorización interno (Prometheus/Grafana).
Métricas clave a vigilar: authelia_authn_requests_total (intentos de autenticación, etiquetados por éxito/fallo), authelia_authn_duration_seconds (latencia), y las métricas de Redis para la salud de las sesiones. Para los logs, Authelia soporta formato JSON estructurado (log.format: json), ideal para ingestión en Loki o un SIEM. Usa log.level: info en producción (evita debug, que registra headers completos). Los logs de autenticación incluyen la IP origen, nombre de usuario, servicio objetivo y resultado — muy útiles para detectar ataques de fuerza bruta antes de que tengan éxito.
Authelia vs Authentik: ¿cuál elegir?
Desplace la tabla
| Criterio | Authelia | Authentik |
|---|---|---|
| Huella Docker | ~30 MB (binario Go) | ~1,5 GB (Python/Django + worker) |
| RAM mínima | ~50 MB | ~512 MB recomendados |
| Proveedor OIDC | Sí, desde v4.34 | Sí, maduro y rico |
| Proveedor SAML | No | Sí |
| Interfaz de administración | Solo configuración YAML | Interfaz web completa |
| Proxy de aplicaciones | No | Sí (túneles Authentik) |
| Aprovisionamiento SCIM | No | Sí |
| Caso de uso ideal | Stack ligero, reverse proxy puro, config as code | IAM completo, SSO empresarial, necesidades SAML/SCIM |
Solución de errores frecuentes
Bucle de redirección infinito. El usuario rebota entre el servicio y el portal Authelia. Causa más frecuente: session.domain no coincide con el dominio del servicio. Si el servicio está en app.misite.com y session.domain es otro dominio, la cookie de sesión nunca se envía. Verifica también que el middleware forwardAuth está bien aplicado y que default_redirection_url apunta a una URL válida.
Cookie domain mismatch. session.domain debe ser el dominio padre común (misite.com), no un subdominio. Verifica con DevTools (Application > Cookies) que authelia_session tiene el dominio correcto.
Redis inalcanzable. Authelia arranca pero las sesiones no persisten. Verifica que el contenedor Redis está en la misma red Docker, que host en configuration.yml coincide con el nombre del servicio (no localhost), y que Redis no está protegido por contraseña no configurada en Authelia.
Configuración inválida al arrancar. Desde v4.35, el esquema de configuración se valida estrictamente. Usa authelia validate-config antes de cualquier reinicio. Los errores más comunes: authentification_backend (typo antiguo), indentación YAML incorrecta, o client_secret OIDC que debe hashearse con Argon2id desde v4.37.
MFA no solicitado a pesar de two_factor en las reglas. Verifica que el usuario ha registrado un segundo factor en su perfil. Sin dispositivo MFA registrado, Authelia puede aplicar un fallback a one_factor según default_2fa_method.
Consejo final: empieza simple, evoluciona progresivamente
Despliega primero Authelia con el backend archivo, una única regla two_factor para tus servicios más expuestos y TOTP como método MFA. Una vez estable, migra a LLDAP para la gestión de equipos, activa el proveedor OIDC para el SSO, luego añade WebAuthn para usuarios con llave física o dispositivo que soporte passkeys. Esta progresión evita depurar varios componentes nuevos simultáneamente y te permite validar cada capa de forma independiente.