Verificar Docker:

docker --version
# Docker version 25.0.0

docker compose version
# Docker Compose version v2.24.0

Paso 1: Crear Estructura de Directorios

# Crear directorio del proyecto
mkdir -p ~/homelab/authelia-sso
cd ~/homelab/authelia-sso

# Crear subdirectorios
mkdir -p authelia lldap nginx secrets

# Estructura final:
# authelia-sso/
# ├── authelia/
# │   └── configuration.yml
# ├── lldap/
# ├── nginx/
# ├── secrets/
# └── docker-compose.yml

Paso 2: Generar Secretos Seguros

# Generar secretos aleatorios (64 chars hex)
openssl rand -hex 32 > secrets/authelia_jwt_secret
openssl rand -hex 32 > secrets/authelia_session_secret
openssl rand -hex 32 > secrets/authelia_storage_encryption_key
openssl rand -hex 32 > secrets/lldap_jwt_secret

# Crear passwords manuales
echo "SuperSecureAdminPassword2025!" > secrets/lldap_admin_password
echo "PostgresPassword123Secure!" > secrets/postgres_password
echo "SuperSecureAdminPassword2025!" > secrets/authelia_ldap_password

# Permisos restrictivos
chmod 600 secrets/*

# Verificar
ls -lah secrets/
# -rw------- 1 user user   65 Nov  7 secrets/authelia_jwt_secret
# ...

Paso 3: Docker Compose Completo

Crea docker-compose.yml:

version: '3.8'

services:
  # LLDAP - Backend de usuarios
  lldap:
    image: lldap/lldap:stable
    container_name: lldap
    restart: unless-stopped
    networks:
      - sso
    ports:
      - "17170:17170"  # Web UI
      - "3890:3890"    # LDAP port
    volumes:
      - lldap_data:/data
    environment:
      - TZ=Europe/Madrid
      - LLDAP_LDAP_BASE_DN=dc=homelab,dc=local
      - LLDAP_JWT_SECRET_FILE=/run/secrets/lldap_jwt_secret
      - LLDAP_LDAP_USER_PASS_FILE=/run/secrets/lldap_admin_password
      - LLDAP_HTTP_PORT=17170
      - LLDAP_LDAP_PORT=3890
    secrets:
      - lldap_jwt_secret
      - lldap_admin_password

  # Redis - Session store para Authelia
  redis:
    image: redis:7-alpine
    container_name: authelia-redis
    restart: unless-stopped
    networks:
      - sso
    volumes:
      - redis_data:/data
    command: redis-server --save 60 1 --loglevel warning

  # PostgreSQL - Storage para Authelia
  postgres:
    image: postgres:16-alpine
    container_name: authelia-postgres
    restart: unless-stopped
    networks:
      - sso
    environment:
      - POSTGRES_DB=authelia
      - POSTGRES_USER=authelia
      - POSTGRES_PASSWORD_FILE=/run/secrets/postgres_password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    secrets:
      - postgres_password

  # Authelia - Portal SSO
  authelia:
    image: authelia/authelia:latest
    container_name: authelia
    restart: unless-stopped
    networks:
      - sso
    ports:
      - "9091:9091"
    volumes:
      - ./authelia/configuration.yml:/config/configuration.yml:ro
      - authelia_data:/config
    environment:
      - TZ=Europe/Madrid
      - AUTHELIA_JWT_SECRET_FILE=/run/secrets/authelia_jwt_secret
      - AUTHELIA_SESSION_SECRET_FILE=/run/secrets/authelia_session_secret
      - AUTHELIA_STORAGE_ENCRYPTION_KEY_FILE=/run/secrets/authelia_storage_encryption_key
      - AUTHELIA_STORAGE_POSTGRES_PASSWORD_FILE=/run/secrets/postgres_password
      - AUTHELIA_AUTHENTICATION_BACKEND_LDAP_PASSWORD_FILE=/run/secrets/authelia_ldap_password
    secrets:
      - authelia_jwt_secret
      - authelia_session_secret
      - authelia_storage_encryption_key
      - postgres_password
      - authelia_ldap_password
    depends_on:
      - lldap
      - redis
      - postgres

networks:
  sso:
    driver: bridge

volumes:
  lldap_data:
  redis_data:
  postgres_data:
  authelia_data:

secrets:
  lldap_jwt_secret:
    file: ./secrets/lldap_jwt_secret
  lldap_admin_password:
    file: ./secrets/lldap_admin_password
  authelia_jwt_secret:
    file: ./secrets/authelia_jwt_secret
  authelia_session_secret:
    file: ./secrets/authelia_session_secret
  authelia_storage_encryption_key:
    file: ./secrets/authelia_storage_encryption_key
  postgres_password:
    file: ./secrets/postgres_password
  authelia_ldap_password:
    file: ./secrets/authelia_ldap_password

Paso 4: Configuración de Authelia

Crea authelia/configuration.yml:

---
theme: dark
default_redirection_url: https://home.homelab.local

server:
  address: 'tcp://0.0.0.0:9091'

log:
  level: 'info'

# Sesiones con Redis
session:
  name: 'authelia_session'
  domain: 'homelab.local'
  expiration: '1h'
  inactivity: '10m'
  
  redis:
    host: 'redis'
    port: 6379

# Storage con PostgreSQL
storage:
  postgres:
    address: 'tcp://postgres:5432'
    database: 'authelia'
    username: 'authelia'

# Backend LDAP (LLDAP)
authentication_backend:
  refresh_interval: '5m'
  
  ldap:
    implementation: 'custom'
    address: 'ldap://lldap:3890'
    timeout: '5s'
    start_tls: false
    
    base_dn: 'dc=homelab,dc=local'
    user: 'uid=admin,ou=people,dc=homelab,dc=local'
    
    username_attribute: 'uid'
    mail_attribute: 'mail'
    display_name_attribute: 'cn'
    
    additional_users_dn: 'ou=people'
    additional_groups_dn: 'ou=groups'
    
    users_filter: '(&({username_attribute}={input})(objectClass=person))'
    groups_filter: '(&(member={dn})(objectClass=groupOfUniqueNames))'
    group_name_attribute: 'cn'

# Control de acceso
access_control:
  default_policy: 'deny'
  
  rules:
    # Admins: acceso completo con 2FA
    - domain:
        - 'portainer.homelab.local'
        - 'proxmox.homelab.local'
      policy: 'two_factor'
      subject:
        - 'group:admins'
    
    # Users: apps multimedia con password
    - domain:
        - 'jellyfin.homelab.local'
        - 'nextcloud.homelab.local'
      policy: 'one_factor'
      subject:
        - 'group:users'

# Protección brute force
regulation:
  max_retries: 5
  find_time: '2m'
  ban_time: '5m'

# TOTP (Google Authenticator)
totp:
  issuer: 'homelab.local'
  period: 30
  skew: 1

# WebAuthn (YubiKey)
webauthn:
  display_name: 'Homelab Authelia'
  relying_party_id: 'homelab.local'

# Notificaciones por email (opcional)
notifier:
  filesystem:
    filename: '/config/notifications.txt'

Paso 5: Iniciar el Stack

# Iniciar servicios
docker compose up -d

# Verificar que todo está corriendo
docker compose ps

# Deberías ver:
# NAME                 STATUS
# lldap                Up
# authelia-redis       Up
# authelia-postgres    Up
# authelia             Up

# Ver logs en tiempo real
docker compose logs -f authelia

# Buscar líneas como:
# level=info msg="Authentication backend LDAP is ready"
# level=info msg="Session provider is ready"
# level=info msg="Storage backend is ready"

Paso 6: Configurar LLDAP

# Acceder a LLDAP
open http://localhost:17170

# Login:
# Usuario: admin
# Password: SuperSecureAdminPassword2025! (tu secrets/lldap_admin_password)

Crear usuarios:

1. Click «Create User»
2. Rellenar:

– Username: john

– Email: john@homelab.local

– Display Name: John Doe

– Password: JohnPassword123!

1. Click «Create»

Crear grupos:

1. Click «Create Group»
2. Rellenar:

– Group Name: admins

– Display Name: Administrators

1. Click «Create»
2. Repetir para grupos users y readonly

Añadir usuario a grupo:

1. Ir al grupo admins
2. Click «Add Member»
3. Seleccionar john
4. Click «Add»

Integración con Nginx/Traefik {#integracion}

Opción A: Nginx

Crear archivo /etc/nginx/conf.d/authelia-authrequest.conf:

# Verificación de autenticación
auth_request /authelia;

# Redirigir a Authelia si no autenticado (401)
error_page 401 =302 https://auth.homelab.local/?rd=$scheme://$http_host$request_uri;

# Headers de usuario autenticado
auth_request_set $user $upstream_http_remote_user;
auth_request_set $groups $upstream_http_remote_groups;
auth_request_set $email $upstream_http_remote_email;

# Pasar headers a la app
proxy_set_header Remote-User $user;
proxy_set_header Remote-Groups $groups;
proxy_set_header Remote-Email $email;

Crear archivo /etc/nginx/conf.d/authelia-location.conf:

location /authelia {
    internal;
    proxy_pass http://authelia:9091/api/verify;
    
    proxy_set_header X-Original-URL $scheme://$http_host$request_uri;
    proxy_set_header X-Forwarded-Method $request_method;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Forwarded-Host $http_host;
    proxy_set_header X-Forwarded-Uri $request_uri;
    proxy_set_header X-Forwarded-For $remote_addr;
    proxy_set_header Content-Length "";
    proxy_pass_request_body off;
}

Proteger servicio Jellyfin:

# /etc/nginx/sites-available/jellyfin.conf
server {
    listen 443 ssl http2;
    server_name jellyfin.homelab.local;
    
    # SSL config
    ssl_certificate /etc/nginx/ssl/cert.pem;
    ssl_certificate_key /etc/nginx/ssl/key.pem;
    
    # Incluir auth Authelia
    include /etc/nginx/conf.d/authelia-location.conf;
    
    location / {
        include /etc/nginx/conf.d/authelia-authrequest.conf;
        
        proxy_pass http://jellyfin:8096;
        proxy_set_header Host $host;
        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;
    }
}

# Portal de Authelia
server {
    listen 443 ssl http2;
    server_name auth.homelab.local;
    
    ssl_certificate /etc/nginx/ssl/cert.pem;
    ssl_certificate_key /etc/nginx/ssl/key.pem;
    
    location / {
        proxy_pass http://authelia:9091;
        proxy_set_header Host $host;
        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;
    }
}

Opción B: Traefik

Añadir labels al servicio Authelia en docker-compose.yml:

authelia:
    # ... configuración anterior ...
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.authelia.rule=Host(`auth.homelab.local`)"
      - "traefik.http.routers.authelia.tls=true"
      - "traefik.http.services.authelia.loadbalancer.server.port=9091"
      
      # Middleware para forward auth
      - "traefik.http.middlewares.authelia.forwardAuth.address=http://authelia:9091/api/verify?rd=https://auth.homelab.local"
      - "traefik.http.middlewares.authelia.forwardAuth.trustForwardHeader=true"
      - "traefik.http.middlewares.authelia.forwardAuth.authResponseHeaders=Remote-User,Remote-Groups,Remote-Email"

Proteger servicio Jellyfin con Traefik:

jellyfin:
    image: jellyfin/jellyfin:latest
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.jellyfin.rule=Host(`jellyfin.homelab.local`)"
      - "traefik.http.routers.jellyfin.tls=true"
      - "traefik.http.routers.jellyfin.middlewares=authelia@docker"
      - "traefik.http.services.jellyfin.loadbalancer.server.port=8096"

Resultado: Ahora al acceder a https://jellyfin.homelab.local, Traefik redirigirá automáticamente a Authelia si no estás autenticado.

Configurar 2FA (TOTP y WebAuthn) {#2fa}

TOTP con Google Authenticator

Flujo de registro:

1. Usuario se loguea por primera vez en https://auth.homelab.local
2. Authelia muestra QR code
3. Usuario abre Google Authenticator en móvil
4. Escanea QR code
5. Authelia pide código de 6 dígitos para verificar
6. Usuario introduce código
7. TOTP queda registrado ✅

Apps TOTP recomendadas:

• 📱 Google Authenticator (Android/iOS) – Simple
• 📱 Microsoft Authenticator (Android/iOS) – Backup en cloud
• 📱 Authy (Android/iOS/Desktop) – Multi-device
• 🔐 Bitwarden (Si usas password manager) – Todo en uno
• 🔐 1Password (Premium) – Elegante

Configuración avanzada TOTP:

# authelia/configuration.yml
totp:
  disable: false
  issuer: 'homelab.local'
  algorithm: 'sha1'     # o sha256 (más seguro pero menos compatible)
  digits: 6             # o 8 (más seguro pero menos compatible)
  period: 30            # Cambiar cada 30s (estándar)
  skew: 1               # Tolerancia ±30s (para relojes desincronizados)
  secret_size: 32       # Tamaño del secret (32 bytes = 256 bits)

WebAuthn con YubiKey

Hardware keys compatibles:

• 🔑 YubiKey 5 Series (USB-A, USB-C, NFC, Nano)
• 🔑 Google Titan Security Key (USB-A + NFC, USB-C)
• 🔑 Thetis FIDO U2F Key (Budget)
• 🔑 Cualquier llave FIDO2/WebAuthn certificada

Registrar YubiKey:

1. Usuario logueado en Authelia
2. Ir a Settings (icono engranaje)
3. Click «Register Security Key»
4. Introducir nombre: YubiKey 5C NFC
5. Insertar YubiKey en puerto USB
6. Tocar botón dorado de la YubiKey
7. Key registrada ✅

Login con YubiKey:

1. Usuario introduce username + password
2. Authelia detecta WebAuthn registrado
3. Navegador muestra popup: «Toque su llave de seguridad»
4. Usuario toca botón de YubiKey
5. Login completado en 2-3 segundos ⚡

Ventajas de WebAuthn vs TOTP:

• ✅ Resistente a phishing (verifica dominio)
• ✅ Más rápido (tocar botón vs escribir 6 dígitos)
• ✅ No requiere móvil (YubiKey en llavero)
• ✅ Hardware seguro (chip dedicado)

Configuración WebAuthn:

# authelia/configuration.yml
webauthn:
  disable: false
  timeout: '60s'
  display_name: 'Homelab SSO'
  attestation_conveyance_preference: 'indirect'
  user_verification: 'preferred'
  
  # IMPORTANTE: Cambiar por tu dominio (sin https://)
  relying_party_id: 'homelab.local'
  relying_party_display_name: 'Homelab Authelia'

Control de Acceso por Grupos {#control-acceso}

Políticas de Acceso

Authelia soporta 4 niveles de política:

Ejemplo: Homelab con 3 Grupos

Grupos en LLDAP:

• admins → Acceso total con 2FA obligatorio
• users → Apps multimedia sin 2FA
• readonly → Solo lectura

Configuración access_control:

access_control:
  default_policy: 'deny'  # Por defecto bloquear todo
  
  rules:
    # ADMINS: Acceso completo con 2FA
    - domain:
        - 'portainer.homelab.local'
        - 'proxmox.homelab.local'
        - 'nginx.homelab.local'
      policy: 'two_factor'
      subject:
        - 'group:admins'
    
    # USERS: Apps multimedia solo password
    - domain:
        - 'jellyfin.homelab.local'
        - 'nextcloud.homelab.local'
        - 'photoprism.homelab.local'
      policy: 'one_factor'
      subject:
        - 'group:users'
        - 'group:admins'  # Admins también tienen acceso
    
    # READONLY: Monitoring sin 2FA
    - domain: 'grafana.homelab.local'
      policy: 'one_factor'
      subject:
        - 'group:readonly'
      resources:
        - '^/dashboard$'  # Solo path /dashboard
    
    # PÚBLICO: Sin autenticación
    - domain: 'blog.homelab.local'
      policy: 'bypass'
    
    # RESTRINGIR POR PATH: /admin requiere 2FA
    - domain: 'nextcloud.homelab.local'
      policy: 'two_factor'
      resources:
        - '^/settings/admin([/?].*)?$'
      subject:
        - 'group:admins'

Restricción por Usuario Específico

# Solo el usuario john puede acceder
- domain: 'john-private.homelab.local'
  policy: 'two_factor'
  subject:
    - 'user:john'

Restricción por IP

# Solo desde red local
- domain: 'admin.homelab.local'
  policy: 'two_factor'
  subject:
    - 'group:admins'
  networks:
    - '192.168.1.0/24'
    - '10.0.0.0/8'

Troubleshooting: Errores Comunes {#troubleshooting}

Error 1: «LDAP connection failed»

Síntomas:

ERROR: Authentication backend LDAP is not ready
ERROR: Failed to connect to LDAP: connection refused

Causas:

• LLDAP no está corriendo
• Puerto 3890 bloqueado por firewall
• Red Docker incorrecta

Solución:

# 1. Verificar que LLDAP está corriendo
docker ps | grep lldap

# 2. Ver logs de LLDAP
docker logs lldap

# 3. Test de conexión LDAP
docker exec -it authelia ldapsearch \
  -x -H ldap://lldap:3890 \
  -D "uid=admin,ou=people,dc=homelab,dc=local" \
  -w "tu_password_admin" \
  -b "dc=homelab,dc=local"

# Si falla, verificar network
docker network inspect sso

# Asegurar que Authelia y LLDAP están en la misma red

Error 2: «Invalid credentials»

Síntomas:

• Login falla con mensaje «Invalid credentials»
• Usuario existe en LLDAP
• Password es correcto

Causas:

• Password de bind admin incorrecto en configuration.yml
• DN de bind incorrecto

Solución:

# Verificar en authelia/configuration.yml
authentication_backend:
  ldap:
    user: 'uid=admin,ou=people,dc=homelab,dc=local'
    # DEBE coincidir EXACTAMENTE con Base DN de LLDAP
    
    base_dn: 'dc=homelab,dc=local'
    # DEBE coincidir con LLDAP_LDAP_BASE_DN

Verificar desde command line:

# Login manual con ldapsearch
ldapsearch -x -H ldap://localhost:3890 \
  -D "uid=admin,ou=people,dc=homelab,dc=local" \
  -w "TU_PASSWORD_ADMIN" \
  -b "ou=people,dc=homelab,dc=local" \
  "(uid=john)"

# Si funciona, el problema está en secrets de Docker
# Verificar que secret existe:
docker exec authelia cat /run/secrets/authelia_ldap_password

Error 3: «Session cookie not set»

Síntomas:

• Login exitoso pero vuelve a pedir login
• Cookie no se establece en navegador

Causas:

• Dominio de sesión incorrecto
• Usando HTTP en lugar de HTTPS
• SameSite policy bloqueando cookie

Solución:

# configuration.yml
session:
  domain: 'homelab.local'  # Sin subdominios, solo raíz
  
  # Para testing con HTTP (NUNCA en producción)
  cookies:
    - domain: 'homelab.local'
      secure: false  # Solo para HTTP local
      sameSite: 'lax'

Verificar en navegador:

• F12 → Application/Storage → Cookies
• Debe existir cookie authelia_session
• Domain: .homelab.local
• Secure: true (si usas HTTPS)

Error 4: «User not found in LDAP»

Síntomas:

ERROR: User 'john' not found in LDAP directory

Solución:

# 1. Verificar que usuario existe en LLDAP
docker exec -it lldap sqlite3 /data/users.db \
  "SELECT * FROM users WHERE username='john';"

# 2. Verificar con ldapsearch
ldapsearch -x -H ldap://localhost:3890 \
  -D "uid=admin,ou=people,dc=homelab,dc=local" \
  -w "password_admin" \
  -b "ou=people,dc=homelab,dc=local" \
  "(uid=john)"

# 3. Verificar filtro en configuration.yml
users_filter: '(&({username_attribute}={input})(objectClass=person))'
# Debe coincidir con objectClass de LLDAP

Error 5: «Group permissions not working»

Síntomas:

• Usuario está en grupo admins en LLDAP
• Política group:admins no aplica

Solución:

# 1. Verificar membresía de grupo
ldapsearch -x -H ldap://localhost:3890 \
  -D "uid=admin,ou=people,dc=homelab,dc=local" \
  -w "password_admin" \
  -b "ou=groups,dc=homelab,dc=local" \
  "(cn=admins)"

# Debe aparecer:
# member: uid=john,ou=people,dc=homelab,dc=local

# 2. Verificar filtro de grupos en configuration.yml
groups_filter: '(&(member={dn})(objectClass=groupOfUniqueNames))'
group_name_attribute: 'cn'

# 3. Ver logs de Authelia durante login
docker logs authelia -f
# Buscar línea:
# level=info msg="User 'john' is member of groups: [admins, users]"

🔗 Artículos Relacionados

Continúa aprendiendo con estas guías complementarias:

• Nginx Proxy Manager: Reverse Proxy con UI Visual y SSL Automático (Guía Completa 2025) – Perfecto para combinar con Authelia
• Docker Compose: De 0 a Homelab Completo en 2025 – Stack base para este tutorial
• Portainer: Gestiona Docker con Interfaz Web (Guía Completa 2025) – Protege Portainer con Authelia
• TrueNAS Scale: NAS Potente con Docker y ZFS para tu Homelab (Guía Completa 2025) – Implementa SSO en TrueNAS Apps
• Nextcloud: Tu Google Drive Self-Hosted con LDAP – Integración Nextcloud + LLDAP
• Jellyfin: Media Server con Autenticación SSO – Protege Jellyfin con Authelia
• Home Assistant con Docker: Smart Home Self-Hosted en tu Homelab – Autenticación forward auth
• Uptime Kuma: Monitoreo Self-Hosted Gratis para tu Homelab – Monitorea Authelia y servicios

Preguntas Frecuentes {#faq}

¿Qué es SSO y por qué lo necesito en mi homelab?

SSO (Single Sign-On) significa «iniciar sesión una vez, acceder a todo». En lugar de gestionar 10-20 contraseñas diferentes para Jellyfin, Nextcloud, Portainer, etc., configuras un sistema centralizado donde te logueas una vez y tienes acceso automático a todos tus servicios durante una sesión.

Beneficios clave: Gestión simplificada de usuarios, 2FA centralizado, control de acceso granular por grupo/usuario, revocación instantánea de acceso, y logs centralizados de autenticación.

Tiempo de implementación: 30-60 minutos siguiendo esta guía.

¿Cuál es mejor: Authelia, Authentik o Keycloak?

Authelia es la mejor opción para homelabs con <50 usuarios que solo necesitan forward authentication. Es ligero (~100MB RAM), se configura en 10 minutos, y se integra perfectamente con Nginx/Traefik.

Usa Authentik si necesitas OAuth2/OIDC nativo (para apps como Grafana, Gitea) o prefieres UI web administrativa en lugar de archivos YAML.

Usa Keycloak solo si tienes requisitos enterprise como SAML, integración con Active Directory, o >500 usuarios. Consume ~1GB RAM y tiene curva de aprendizaje alta.

¿LLDAP es suficiente o necesito OpenLDAP?

LLDAP es más que suficiente para el 95% de homelabs. Soporta <1,000 usuarios, tiene interfaz web moderna, y consume solo 50MB RAM. OpenLDAP es necesario solo si requieres schemas LDAP personalizados, replicación multi-master, o más de 1,000 usuarios concurrentes.

Ventaja clave de LLDAP: Crear un usuario toma 30 segundos con UI web vs 15 minutos con archivos LDIF en OpenLDAP.

¿Cómo protejo servicios que ya están corriendo?

Para servicios en Docker: Añade labels de Traefik con middleware authelia@docker, o configura auth_request en Nginx.

Para servicios nativos (fuera de Docker): Crea un virtual host en Nginx/Traefik que haga proxy al servicio y añade autenticación Authelia. Ejemplo:

server {
    listen 443 ssl;
    server_name myapp.homelab.local;
    
    include /etc/nginx/conf.d/authelia-authrequest.conf;
    location / {
        proxy_pass http://192.168.1.100:8080;  # IP del servicio
    }
}

¿Funciona con Cloudflare Tunnel / Tailscale?

Sí, funciona perfectamente. Authelia valida autenticación independientemente de cómo llegue el tráfico (Cloudflare Tunnel, Tailscale, VPN, puerto 443 directo).

Cloudflare Tunnel: Configura el tunnel apuntando a auth.homelab.local:9091 y servicios protegidos con forward auth.

Tailscale: Authelia verifica autenticación en la capa HTTP, compatible con cualquier VPN mesh.

¿Cómo añado 2FA obligatorio solo para admins?

Configuración en access_control:

access_control:
  default_policy: 'one_factor'  # Por defecto solo password
  
  rules:
    # Admins: 2FA obligatorio
    - domain: '*'  # Todos los dominios
      policy: 'two_factor'
      subject:
        - 'group:admins'
    
    # Users regulares: solo password
    - domain: '*'
      policy: 'one_factor'
      subject:
        - 'group:users'

Resultado: Usuarios del grupo admins en LLDAP siempre verán prompt de 2FA (TOTP o WebAuthn).

¿Puedo usar Google/GitHub OAuth para login?

No, Authelia no soporta OAuth2/OIDC como Identity Provider. Solo soporta LDAP (como LLDAP) o archivo de usuarios local.

Alternativa: Usa Authentik que sí soporta proveedores externos (Google, GitHub, Microsoft, etc.) para login social.

¿Cómo hago backup de Authelia + LLDAP?

Backup de LLDAP (usuarios y grupos):

# Backup del volumen Docker
docker run --rm -v lldap_data:/data -v $(pwd):/backup \
  alpine tar czf /backup/lldap-backup-$(date +%Y%m%d).tar.gz /data

# Restaurar
docker run --rm -v lldap_data:/data -v $(pwd):/backup \
  alpine tar xzf /backup/lldap-backup-20251107.tar.gz -C /

Backup de Authelia (sessions, logs, config 2FA):

# Backup PostgreSQL
docker exec authelia-postgres pg_dump -U authelia authelia > authelia-db-$(date +%Y%m%d).sql

# Restaurar
docker exec -i authelia-postgres psql -U authelia authelia < authelia-db-20251107.sql

Automatizar con cron:

# Ejecutar diario a las 3 AM
0 3 * * * /home/user/homelab/backup.sh

¿Authelia consume muchos recursos?

No, es muy ligero:

• Authelia: ~100MB RAM, <5% CPU (idle)
• LLDAP: ~50MB RAM, <2% CPU
• Redis: ~30MB RAM
• PostgreSQL: ~50MB RAM

Total stack SSO: ~230MB RAM. Funciona perfectamente en Raspberry Pi 4 (8GB).

Comparativa:

• Authentik: ~300MB (2 contenedores)
• Keycloak: ~1GB+ (JVM)

¿Qué pasa si LLDAP se cae?

Si LLDAP falla:

• ❌ No se pueden hacer nuevos logins (Authelia no puede verificar credenciales)
• ✅ Sesiones activas siguen funcionando (cookies en Redis son válidas)
• ✅ Usuarios ya logueados pueden seguir accediendo por ~1h (expiration time)

Recomendación: Implementa monitoreo con Uptime Kuma para detectar caídas de LLDAP/Authelia.

¿Puedo migrar de archivos de usuarios a LLDAP después?

Sí, el proceso es manual pero sencillo:

1. Exporta usuarios de users_database.yml
2. Crea usuarios en LLDAP vía UI web (o API GraphQL)
3. Cambia configuración Authelia:

authentication_backend:
     ldap:  # Cambiar de file: a ldap:
       address: 'ldap://lldap:3890'

1. Reinicia Authelia: docker compose restart authelia

Nota: Contraseñas hasheadas NO son compatibles (Authelia file usa argon2, LLDAP usa bcrypt). Los usuarios deberán resetear passwords.

¿Cómo reseteo la contraseña de un usuario?

Opción 1: Desde LLDAP UI

1. Login como admin en http://lldap.homelab.local:17170
2. Ir a usuario
3. Click «Change Password»
4. Introducir nueva password
5. Click «Save»

Opción 2: Via SMTP notifications

Si configuraste SMTP en Authelia, los usuarios pueden usar «Forgot Password» desde el portal de login.

Opción 3: Command line

# Resetear password en LLDAP
docker exec -it lldap lldap_cli set_password \
  --base-dn "dc=homelab,dc=local" \
  --username john \
  --password "NewPassword123!"

¿Authelia funciona sin dominio (solo IP)?

Técnicamente sí, pero NO es recomendado. Authelia y WebAuthn requieren dominios para funcionalidad completa.

Solución para testing:

1. Edita /etc/hosts (Linux/Mac) o C:\Windows\System32\drivers\etc\hosts (Windows):

192.168.1.100 auth.local jellyfin.local nextcloud.local

1. Configura Authelia con domain: 'local'
2. Accede a http://jellyfin.local (sin HTTPS)