Pocket ID, autenticación sin contraseñas

Hasta ahora has visto dos formas de proteger tus servicios. Authelia: un guardián ligero que se sienta delante de tus aplicaciones y decide quién pasa. Configuración en YAML, políticas de acceso granulares, 2FA con TOTP y WebAuthn. Fiable, predecible, minimalista. Authentik: un proveedor de identidad completo. Flujos personalizables, OIDC, SAML, LDAP, outposts, panel de administración. Potente, flexible, pero pesado. Ocupa 2 GB de RAM antes de que hagas nada.

Ambos resuelven el problema de la autenticación. Pero ambos parten de la misma base: usuario y contraseña. Luego añades 2FA como capa extra. Primero demuestras que sabes algo (la contraseña), luego demuestras que tienes algo (el móvil, la llave). Es el modelo clásico. ¿Y si pudieras saltarte el primer paso?¿Y si no necesitaras recordar una contraseña, ni generarla, ni almacenarla de forma segura, ni preocuparte de que te la roben?

Eso es exactamente lo que hace Pocket ID. Pocket ID es un proveedor OIDC que solo acepta passkeys. No hay formulario de login con usuario y contraseña. No hay TOTP que configurar. No hay 2FA porque no hay 1FA tradicional. La autenticación es un solo gesto: tu huella en el móvil, tu cara en el portátil, tu llave USB conectada al equipo.Un toque y dentro.

En este capítulo vas a instalar Pocket ID desde cero con Docker Compose y Traefik, configurar tu primer passkey, conectar servicios con OIDC nativo, integrarlo con OAuth2 Proxy para proteger aplicaciones que no hablan OIDC, sincronizar usuarios desde LLDAP, y entender por qué este enfoque no es solo más cómodo, sino objetivamente más seguro que las contraseñas.

Y al final, compararás Pocket ID con Authelia y Authentik para decidir cuál encaja en tu infraestructura.

¿Qué es Pocket ID y por qué es diferente?

Pocket ID es un proveedor de identidad OpenID Connect (OIDC) desarrollado por Elias Schneider (stonith404). Su repositorio está en github.com/pocket-id/pocket-id y su página oficial en pocket-id.org.

La premisa es radicalmente simple: solo passkeys. Ni contraseñas, ni TOTP, ni códigos SMS, ni formularios de login tradicionales. Cuando abres un servicio protegido por Pocket ID, no ves un campo de usuario y contraseña. Ves un botón que dice «Iniciar sesión con passkey». Lo pulsas, tu sistema operativo te pide tu huella, tu cara o tu PIN, y ya estás dentro.

¿Por qué es diferente de Authelia y Authentik?

Authelia y Authentik son herramientas del siglo XX mejoradas. Ponen una capa de 2FA sobre el modelo usuario+contraseña. Siguen almacenando hashes de contraseñas. Siguen teniendo formularios de login. Siguen siendo vulnerables a phishing si el usuario pica (aunque el 2FA mitigue el daño).

Pocket ID elimina la contraseña de la ecuación. No hay nada que recordar, nada que escribir, nada que pueda ser interceptado por un keylogger. La autenticación es criptográfica: tu dispositivo firma un challenge con una clave privada que nunca sale de él, y Pocket ID verifica la firma con la clave pública que almacenó durante el registro.

No hay 2FA porque el primer factor ya es criptográficamente fuerte. La posesión del dispositivo (algo que tienes) se combina con la biometría o el PIN (algo que eres o sabes) en un solo gesto.

Es como tener un YubiKey, pero sin el YubiKey. Y sincronizado entre todos tus dispositivos vía iCloud, Google Password Manager o 1Password, para que no pierdas el acceso si se te rompe el móvil.

¿Para quién es Pocket ID?

Pocket ID no es para todos los escenarios.

Es perfecto para:

• Homelabs personales o familiares.
• Equipos pequeños donde todos se conocen.
• Entornos donde los usuarios usan dispositivos modernos (móviles, portátiles con Touch ID / Windows Hello).
• Proyectos donde quieres máxima seguridad con mínima fricción.

No es ideal para:

• Organizaciones grandes con requisitos de compliance (necesitan contraseñas + 2FA por normativa).
• Usuarios que comparten dispositivos públicos (bibliotecas, cibercafés).
• Servicios que requieren integración SAML (Pocket ID solo habla OIDC).
• Entornos donde necesitas políticas de acceso por ruta (Pocket ID no tiene un proxy forward-auth propio).

Dicho esto, para el 90% de los casos de uso de un homelab o una pequeña organización, Pocket ID no solo es suficiente. Es mejor.

Passkeys explicados

Antes de instalar nada, necesitas entender cómo funcionan los passkeys. No es magia. Es criptografía de clave pública bien aplicada.

El problema de las contraseñas

Las contraseñas tienen problemas fundamentales:

• Son débiles por naturaleza. Un humano no puede recordar una cadena de 128 bits aleatorios, así que las contraseñas son predecibles.
• Se reutilizan entre servicios. La filtración de un servicio compromete las cuentas en otros.
• Son phishables. Un correo con una página de login falsa y ya está.
• El servidor las almacena (hasheadas, pero las almacena). Si alguien roba la base de datos, puede probar combinaciones.

Los passkeys resuelven todo esto de un plumazo.

Cómo funciona un passkey

Un passkey es un par de claves criptográficas (pública y privada) asociadas a un dominio web.

Cuando registras un passkey en Pocket ID:

1. Tu navegador genera un par de claves RSA o ECDSA específico para auth.tudominio.com.
2. La clave privada se almacena de forma segura en tu dispositivo. En macOS, en el enclave seguro. En Windows, en el TPM. En iOS, en el Secure Enclave.
3. La clave pública se envía a Pocket ID, que la asocia a tu cuenta de usuario.

Cuando inicias sesión:

1. Pocket ID te envía un challenge: un string aleatorio.
2. Tu navegador firma ese challenge con tu clave privada.
3. Pocket ID verifica la firma con la clave pública que tiene almacenada.
4. Si la firma es válida, estás autenticado.

La clave privada nunca abandona tu dispositivo. Ni siquiera Pocket ID la conoce. Es matemáticamente imposible que alguien suplante tu identidad sin tener tu dispositivo físico y desbloquearlo.

¿Qué hace que un passkey sea resistente a phishing?

Cuando tu navegador genera un passkey, lo asocia al dominio exacto que está en la barra de direcciones. Si abres https://auth.tudominio.com, el passkey se vincula a auth.tudominio.com.

Si un atacante te envía un correo con un enlace a https://auth.tud0minio.com (con un cero en lugar de la o), tu navegador no te ofrecerá el passkey. El dominio no coincide. No puedes ser engañado.

Las contraseñas no tienen esta protección. Puedes escribir tu contraseña en cualquier sitio que tenga un formulario que se parezca al legítimo. Con passkeys, eso es imposible.

Passkeys sincronizados vs. ligados al dispositivo

Hay dos tipos de passkeys:

Passkeys sincronizados: se almacenan en el gestor de contraseñas del ecosistema (iCloud Keychain, Google Password Manager, 1Password, Bitwarden). Se sincronizan entre todos tus dispositivos mediante cifrado de extremo a extremo. Si pierdes el móvil, puedes usar el passkey desde tu portátil.

Passkeys ligados al dispositivo: se almacenan exclusivamente en el hardware de un dispositivo concreto. No se sincronizan. Si pierdes ese dispositivo, pierdes el passkey. Solo tiene sentido para llaves de seguridad físicas (YubiKey, SoloKey) o para entornos de alta seguridad.

Pocket ID soporta ambos. Puedes registrar un passkey desde tu iPhone (se sincroniza con tu Mac vía iCloud) y otro desde una YubiKey (ligado al dispositivo).

Diferencia con las llaves de seguridad (FIDO2 / WebAuthn)

Los passkeys son la evolución de WebAuthn. WebAuthn permitía usar llaves de seguridad USB para autenticación. Los passkeys extienden ese concepto a los autenticadores integrados en los dispositivos (Touch ID, Face ID, Windows Hello) y añaden la sincronización entre dispositivos.

Técnicamente, los passkeys usan el mismo estándar subyacente (WebAuthn / FIDO2). La diferencia está en la experiencia de usuario y en la portabilidad.

Instalación con Docker Compose y Traefik

Pocket ID es un solo contenedor. No necesita Redis, ni PostgreSQL, ni un worker separado. Usa SQLite como base de datos. Eso significa que ocupa muy pocos recursos y arranca en segundos.

Estructura de directorios

/home/lorenzo/docker/pocket-id/
├── docker-compose.yml
├── .env
└── data/

Creas la estructura con:

mkdir -p /home/lorenzo/docker/pocket-id/data
cd /home/lorenzo/docker/pocket-id

Variables de entorno (.env)

Pocket ID se configura con variables de entorno. Creas un archivo .env:

# Dominio público de Pocket ID
PUBLIC_APP_URL=https://auth.tudominio.com

# Clave de cifrado (genera una aleatoria)
ENCRYPTION_KEY=$(openssl rand -base64 32)

# Direcciones de confianza para proxies inversos
TRUSTED_PROXIES=172.16.0.0/12,10.0.0.0/8,192.168.0.0/16

# Email del administrador inicial
ADMIN_EMAIL=admin@tudominio.com

Las variables clave:

• PUBLIC_APP_URL: la URL pública donde se sirve Pocket ID. Obligatoria. Sin esta variable, Pocket ID no sabe qué dominio usa y falla al generar los passkeys.
• ENCRYPTION_KEY: clave para cifrar datos sensibles, incluyendo las claves privadas de los clientes OIDC. Debe ser una cadena aleatoria de 32 caracteres.
• TRUSTED_PROXIES: lista de rangos IP separados por comas que son proxies de confianza. Si usas Traefik, necesitas incluir las redes de Docker. Si no pones nada, PocketID solo confía en ::1 y 127.0.0.1, y las peticiones de Traefik se marcan como no seguras.
• ADMIN_EMAIL: el email del primer usuario administrador. Se crea automáticamente al arrancar.

Otras variables opcionales que puedes añadir:

# Puerto interno (por defecto 8080)
PORT=8080

# URL de la base de datos (por defecto SQLite local)
DATABASE_URL=data/pocket-id.db

# Nivel de log
LOG_LEVEL=info

docker-compose.yml

services:
  pocket-id:
    image: ghcr.io/pocket-id/pocket-id:latest
    container_name: pocket-id
    restart: unless-stopped
    volumes:
      - ./data:/app/backend/data
    env_file:
      - .env
    networks:
      - traefik
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.pocket-id.rule=Host(`auth.tudominio.com`)"
      - "traefik.http.routers.pocket-id.entrypoints=websecure"
      - "traefik.http.routers.pocket-id.tls=true"
      - "traefik.http.routers.pocket-id.tls.certresolver=letsencrypt"
      - "traefik.http.services.pocket-id.loadbalancer.server.port=8080"

networks:
  traefik:
    external: true

Fíjate en los detalles:

• La imagen es ghcr.io/pocket-id/pocket-id:latest, no está en Docker Hub.
• El puerto interno es 8080.
• Montas ./data en /app/backend/data dentro del contenedor. Ahí se almacena la base de datos SQLite, las claves, las configuraciones.
• Usas env_file para cargar las variables, no las pongas directamente en el compose. Así es más seguro (las contraseñas no quedan en el YAML).

Primer arranque

cd /home/lorenzo/docker/pocket-id
docker compose up -d

Pocket ID tarda literalmente dos segundos en arrancar. No hay migraciones de base de datos que esperar, no hay inicialización de servicios externos.

Comprueba que está vivo:

docker compose logs pocket-id

Deberías ver algo como:

pocket-id  | [INFO] Pocket ID is running on http://0.0.0.0:8080

Abre https://auth.tudominio.com. No verás un formulario de login. Verás una pantalla con un mensaje: «Register your first passkey».

Consideraciones de seguridad

Pocket ID, al usar WebAuthn, requiere HTTPS. No funciona en HTTP. Ni siquiera en localhost sin HTTPS. Es un requisito del propio navegador, no de Pocket ID. Si intentas acceder por HTTP, el navegador simplemente no te deja crear ni usar passkeys.

Con Traefik y Let’s Encrypt esto no es problema. Pero si estás probando en un entorno de desarrollo local sin HTTPS, usa mkcert para generar un certificado autofirmado de confianza, o expón Pocket ID a través de Traefik con TLS aunque sea en local.

Configuración inicial

Vas a https://auth.tudominio.com y te encuentras con el asistente de configuración inicial.

Primer usuario y registro de passkey

El asistente te pide:

1. Tu nombre: el nombre que se mostrará en el perfil.
2. Tu email: debe coincidir con el ADMIN_EMAIL que pusiste en .env. Si no coincide, no te deja continuar.
3. Registrar tu passkey: aquí es donde ocurre la magia.

Cuando llegas al paso de registrar el passkey, tu navegador te muestra un diálogo nativo. En macOS, te pide Touch ID o la contraseña del equipo. En Windows, Windows Hello (huella, PIN o reconocimiento facial). En iOS, Face ID o Touch ID. En Android, huella o PIN.

No es un popup de página web. Es el diálogo nativo del sistema operativo. Eso significa que es fiable: sabes que es tu dispositivo el que está procesando la autenticación, no un script en la página.

Una vez registrado el passkey, ya tienes tu cuenta. Eres administrador. No hay contraseña que recordar, ni 2FA que configurar, ni correo de verificación que esperar.

El panel de administración

Una vez dentro, ves el panel de Pocket ID. Es limpio, moderno, con modo oscuro y claro. Las secciones principales:

• Dashboard: resumen de actividad, número de usuarios, número de clientes OIDC, últimas autenticaciones.
• Users: gestión de usuarios del sistema.
• Groups: gestión de grupos para control de acceso.
• OIDC Clients: aplicaciones que pueden usar Pocket ID como proveedor de identidad.
• Settings: configuración global del servidor.
• Audit Log: registro de eventos de autenticación.

No hay cientos de opciones. Es minimalista a propósito. Pocket ID está diseñado para ser simple.

Configurar el dominio base

En Settings, verifica que el campo Application URL coincide con tu PUBLIC_APP_URL. Si cambias de dominio, actualízalo aquí y en el .env.

También puedes configurar:

• Session duration: tiempo máximo de sesión. Por defecto 7 días. Puedes bajarlo a 24 horas o subirlo a 30 días.
• Allow automatic registration: si está activado, cualquier persona que acceda a Pocket ID puede crear su propia cuenta registrando un passkey. Para un homelab personal, puedes desactivarlo y crear usuarios manualmente.
• One-time login codes: puedes generar códigos de un solo uso para que alguien acceda desde un dispositivo que no tiene su passkey sincronizado.

Registrar un segundo passkey

Siempre, siempre, siempre registra un segundo passkey de respaldo.

Si solo tienes un passkey en tu móvil y se te pierde o se rompe, no puedes acceder a Pocket ID. Y sin Pocket ID, no puedes gestionar usuarios ni recuperar el acceso.

Vete a tu perfil (arriba a la derecha, tu nombre), busca Passkeys y pulsa Add passkey. Puedes registrar:

• El mismo tipo de passkey desde otro dispositivo (por ejemplo, el portátil además del móvil).
• Una llave de seguridad USB (YubiKey, SoloKey).
• Un passkey desde el gestor de contraseñas (Bitwarden, 1Password).

Con dos passkeys registrados, estás cubierto. Si pierdes uno, usas el otro.

Gestión de usuarios

Pocket ID tiene un sistema de usuarios sencillo pero funcional.

Crear usuarios

Desde Users, pulsas Add user. Rellenas:

• Username: nombre único para el usuario. Por ejemplo, ana, marcos.
• Display name: nombre que se muestra en el perfil.
• Email: obligatorio.
• Groups: grupos a los que pertenece.

Cuando creas un usuario, el sistema le asigna un ID interno. El usuario no tiene contraseña ni passkey todavía. Necesita registrar su primer passkey.

El flujo para el usuario nuevo

Hay dos formas de que un usuario nuevo registre su passkey:

Opción A: Código de un solo uso

Desde el panel de administración, en Users > One-time login codes, generas un código para ese usuario. Se lo envías (por correo, por mensaje). El usuario abre https://auth.tudominio.com, introduce el código, y el sistema le pide que registre su passkey.

Opción B: Registro automático

Si tienes activado Allow automatic registration en Settings, el usuario puede abrir https://auth.tudominio.com, pulsar «Register», y crear su cuenta con su email. Pero esto no es recomendable si quieres controlar quién accede.

La opción A es la más segura para un homelab. Generas el código, se lo das al usuario, y él mismo se da de alta con su passkey. No necesitas compartir ninguna contraseña temporal.

Grupos

Los grupos te permiten controlar qué usuarios pueden acceder a qué aplicaciones. En Groups, creas grupos como admins, usuarios, invitados.

Luego, en cada cliente OIDC (cada aplicación), puedes restringir el acceso a grupos específicos. Si un usuario no pertenece al grupo permitido, Pocket ID le deniega la autenticación aunque tenga un passkey válido.

Recuperación de acceso si pierdes el dispositivo

¿Y si pierdes el único dispositivo donde tienes el passkey?

Pocket ID tiene un sistema de códigos de recuperación.

Desde tu perfil, en Recovery Codes, puedes generar una lista de códigos de un solo uso. Cada código permite iniciar sesión una vez sin passkey. Los imprimes y los guardas en un lugar seguro (una caja fuerte, un sobre en casa de un familiar).

Si pierdes el acceso:

1. Abres https://auth.tudominio.com.
2. Pulsas «Use a recovery code».
3. Introduces uno de los códigos.
4. Pocket ID te deja entrar y te pide que registres un nuevo passkey.

Este es tu plan B. Si no generaste códigos de recuperación y pierdes el único dispositivo, la única opción es acceder al servidor por SSH y reiniciar la base de datos de Pocket ID para crear un nuevo administrador. No es divertido.

Audit Log

Pocket ID registra cada evento de autenticación en su Audit Log. Puedes ver:

• Inicios de sesión exitosos.
• Intentos fallidos.
• Registro de nuevos passkeys.
• Creación y eliminación de usuarios.
• Cambios en clientes OIDC.

Cada entrada muestra el usuario, el evento, la IP de origen, el agente de usuario, y la fecha. Esto te permite detectar actividad sospechosa.

Integración con Traefik vía OAuth2 Proxy

Aquí llega el punto más delicado. Pocket ID no tiene un forward-auth propio como Authelia o Authentik. No puedes poner Pocket ID delante de una aplicación y que decida si el usuario pasa o no.

Pocket ID es un proveedor OIDC. Las aplicaciones hablan con él directamente usando el protocolo OIDC. Si una aplicación soporta OIDC nativo (Grafana, Nextcloud, Home Assistant), la integración es directa y elegante.

Pero ¿y si la aplicación no soporta OIDC? Ahí necesitas un intermediario: OAuth2 Proxy.

¿Qué es OAuth2 Proxy?

OAuth2 Proxy es un servicio ligero que actúa como proxy inverso de autenticación. Se sienta delante de una aplicación que no soporta OIDC, y se encarga de:

1. Interceptar las peticiones.
2. Redirigir al usuario a Pocket ID para autenticarse.
3. Recibir el token OIDC de vuelta.
4. Establecer una cookie de sesión propia.
5. Pasar la petición autenticada a la aplicación de destino, inyectando cabeceras con la identidad del usuario (X-Forwarded-User, X-Forwarded-Email, etc.).

Es como el forward-auth de Authelia, pero usando OIDC en lugar de una API interna.

Estructura con OAuth2 Proxy + Traefik

El esquema es:

Usuario → Traefik → OAuth2 Proxy → Aplicación interna
                          ↓
                     Pocket ID (OIDC)

• Traefik recibe la petición.
• Traefik aplica un middleware ForwardAuth que apunta a OAuth2 Proxy.
• OAuth2 Proxy verifica si el usuario tiene cookie de sesión.
• Si no la tiene, redirige a Pocket ID para autenticarse.
• Pocket ID autentica al usuario con su passkey.
• Pocket ID redirige de vuelta a OAuth2 Proxy con un token OIDC.
• OAuth2 Proxy valida el token, establece la cookie de sesión, y reenvía la petición a la aplicación.
• La aplicación ve las cabeceras con la identidad del usuario.

Configuración de OAuth2 Proxy

Añades OAuth2 Proxy a tu infraestructura. Lo ideal es que esté en la misma red de Docker que Traefik y Pocket ID.

services:
  oauth2-proxy:
    image: quay.io/oauth2-proxy/oauth2-proxy:latest
    container_name: oauth2-proxy
    restart: unless-stopped
    command:
      - "--provider=oidc"
      - "--oidc-issuer-url=https://auth.tudominio.com"
      - "--client-id=el-client-id-de-tu-app"
      - "--client-secret=el-client-secret"
      - "--redirect-url=https://app.tudominio.com/oauth2/callback"
      - "--upstream=http://aplicacion-interna:8080"
      - "--email-domain=tudominio.com"
      - "--cookie-secret=$(openssl rand -base64 32)"
      - "--cookie-secure=true"
      - "--http-address=0.0.0.0:4180"
      - "--whitelist-domain=tudominio.com"
      - "--set-xauthrequest=true"
      - "--pass-authorization-header=true"
      - "--pass-access-token=true"
    networks:
      - traefik

Los parámetros clave:

• provider=oidc: usas OIDC genérico como proveedor.
• oidc-issuer-url: la URL de tu Pocket ID. OAuth2 Proxy consulta https://auth.tudominio.com/.well-known/openid-configuration para obtener los endpoints automáticamente.
• client-id y client-secret: los obtienes de Pocket ID creando un cliente OIDC.
• redirect-url: la URL donde Pocket ID redirige después de la autenticación. Debe coincidir exactamente con la configurada en Pocket ID.
• upstream: la dirección de la aplicación interna que quieres proteger.
• cookie-secret: secreto para cifrar las cookies de sesión. Genera uno aleatorio.
• set-xauthrequest=true: añade cabeceras X-Auth-Request-User, X-Auth-Request-Email, X-Auth-Request-Groups a las peticiones upstream.
• pass-authorization-header=true: pasa el token de acceso como cabecera Authorization.

Crear el cliente OIDC en Pocket ID

Desde el panel de Pocket ID, vas a OIDC Clients y pulsas Add client:

• Name: un nombre descriptivo, como «Mi Aplicación».
• Callback URLs: la URL de callback de OAuth2 Proxy: https://app.tudominio.com/oauth2/callback.
• Group restriction: (opcional) solo los usuarios de ciertos grupos pueden autenticarse.

Pocket ID te genera un Client ID y un Client Secret. Los copias y los pones en el command de OAuth2 Proxy.

Middleware en Traefik

Ahora configuras el middleware ForwardAuth en Traefik para que apunte a OAuth2 Proxy:

# /home/lorenzo/docker/traefik/rules/oauth2-proxy-middleware.yml
http:
  middlewares:
    oauth2-auth:
      forwardAuth:
        address: "http://oauth2-proxy:4180/oauth2/auth"
        trustForwardHeader: true
        authResponseHeaders:
          X-Auth-Request-User: username
          X-Auth-Request-Email: email
          X-Auth-Request-Groups: groups

Y proteges un servicio añadiendo el middleware:

labels:
  - "traefik.http.routers.mi-servicio.middlewares=oauth2-auth@file"
  - "traefik.http.routers.mi-servicio.rule=Host(`app.tudominio.com`)"

El punto crítico: el router de OAuth2 Proxy

Hay un detalle que no puedes olvidar.

OAuth2 Proxy necesita servir su propia ruta /oauth2/callback y /oauth2/auth sin estar protegido por el middleware. Si proteges todo el dominio, el propio callback de OAuth2 Proxy quedaría bloqueado.

La solución es tener dos routers en Traefik:

labels:
  # Router para el callback de OAuth2 Proxy (sin autenticación)
  - "traefik.http.routers.mi-servicio-oauth2.rule=Host(`app.tudominio.com`) && PathPrefix(`/oauth2/`)"
  - "traefik.http.routers.mi-servicio-oauth2.entrypoints=websecure"
  - "traefik.http.routers.mi-servicio-oauth2.tls=true"
  - "traefik.http.routers.mi-servicio-oauth2.tls.certresolver=letsencrypt"

  # Router para la aplicación (con autenticación)
  - "traefik.http.routers.mi-servicio.rule=Host(`app.tudominio.com`)"
  - "traefik.http.routers.mi-servicio.entrypoints=websecure"
  - "traefik.http.routers.mi-servicio.tls=true"
  - "traefik.http.routers.mi-servicio.tls.certresolver=letsencrypt"
  - "traefik.http.routers.mi-servicio.middlewares=oauth2-auth@file"

Como las reglas se evalúan por especificidad, el router con PathPrefix(/oauth2/) coincide primero para las rutas de OAuth2 Proxy y no aplica el middleware de autenticación.

Servicios con soporte OIDC nativo

La integración con OAuth2 Proxy es para aplicaciones que no hablan OIDC. Pero cada vez más servicios soportan OIDC nativo. Ahí es donde Pocket ID brilla.

La ventaja del OIDC nativo frente a OAuth2 Proxy es que la aplicación recibe la identidad del usuario directamente del proveedor. No necesita adivinar quién es por las cabeceras HTTP. Tiene un token firmado, con los claims del usuario, que puede verificar criptográficamente.

Veamos cuatro ejemplos prácticos.

Grafana con Pocket ID

Grafana tiene soporte nativo para OIDC genérico (lo llama Generic OAuth). Para conectarlo con Pocket ID, primero creas un cliente OIDC en Pocket ID:

1. Vas a OIDC Clients y pulsas Add client.
2. Name: Grafana.
3. Callback URL: https://grafana.tudominio.com/login/generic_oauth.
4. Guardas y anotas el Client ID y Client Secret.

Luego configuras Grafana con variables de entorno:

services:
  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    restart: unless-stopped
    environment:
      - GF_AUTH_GENERIC_OAUTH_ENABLED=true
      - GF_AUTH_GENERIC_OAUTH_NAME=Pocket ID
      - GF_AUTH_GENERIC_OAUTH_CLIENT_ID=el-client-id
      - GF_AUTH_GENERIC_OAUTH_CLIENT_SECRET=el-client-secret
      - GF_AUTH_GENERIC_OAUTH_SCOPES=openid profile email
      - GF_AUTH_GENERIC_OAUTH_AUTH_URL=https://auth.tudominio.com/authorize
      - GF_AUTH_GENERIC_OAUTH_TOKEN_URL=https://auth.tudominio.com/api/token
      - GF_AUTH_GENERIC_OAUTH_API_URL=https://auth.tudominio.com/api/userinfo
      - GF_AUTH_SIGNOUT_REDIRECT_URL=https://auth.tudominio.com
    networks:
      - traefik
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.grafana.rule=Host(`grafana.tudominio.com`)"
      - "traefik.http.routers.grafana.entrypoints=websecure"
      - "traefik.http.routers.grafana.tls=true"
      - "traefik.http.routers.grafana.tls.certresolver=letsencrypt"
      - "traefik.http.services.grafana.loadbalancer.server.port=3000"

Las URLs de los endpoints OIDC de Pocket ID son:

• Auth URL: https://auth.tudominio.com/authorize
• Token URL: https://auth.tudominio.com/api/token
• UserInfo URL: https://auth.tudominio.com/api/userinfo
• JWKS URL: https://auth.tudominio.com/.well-known/jwks.json

Reinicias Grafana. Cuando accedes a https://grafana.tudominio.com, ves el botón «Iniciar sesión con Pocket ID». Lo pulsas, tu navegador te pide el passkey, y vuelves a Grafana autenticado.

Sin contraseñas, sin formularios, sin 2FA.

Nextcloud con Pocket ID

Nextcloud necesita la app OpenID Connect user backend del catálogo de apps. La instalas desde la interfaz de apps de Nextcloud (búscala como «openid connect»).

Después, en Settings > OpenID Connect, añades un proveedor:

• Identifier: pocket-id.
• Client ID: el que te da Pocket ID.
• Client Secret: el secreto correspondiente.
• Discovery URL: https://auth.tudominio.com/.well-known/openid-configuration.

La URL de discovery es importante. Nextcloud la usa para obtener automáticamente todos los endpoints OIDC. No necesitas configurar authorization, token y userinfo por separado.

En Pocket ID, el cliente OIDC para Nextcloud necesita estos callback URLs:

• https://nextcloud.tudominio.com/apps/oidc_login/oidc
• https://nextcloud.tudominio.com/index.php/apps/oidc_login/oidc

Cuando un usuario accede a Nextcloud, ve el botón «Iniciar sesión con Pocket ID». Pulsa, se autentica con su passkey, y Nextcloud le crea la cuenta automáticamente (si es la primera vez) o le deja entrar (si ya existe).

Home Assistant con Pocket ID

Home Assistant añadió soporte OIDC en la versión 2024.6. La configuración se hace en configuration.yaml:

homeassistant:
  auth_providers:
    - type: trusted_proxies
    - type: homeassistant
    - type: oidc
      client_id: el-client-id
      client_secret: el-client-secret
      discovery_url: "https://auth.tudominio.com/.well-known/openid-configuration"
      name: Pocket ID
      username_attribute: preferred_username
      id_token_algo: RS256

El orden de auth_providers importa. trusted_proxies primero permite que las peticiones desde Traefik (que ya viene de una red de confianza) no necesiten autenticación extra. Luego homeassistant para el login local (por si acaso). Luego oidc para el login con Pocket ID.

El id_token_algo debe ser RS256, que es el algoritmo que usa Pocket ID para firmar los tokens.

En Home Assistant, también puedes instalar un add-on específico de Pocket ID si usas Home Assistant OS. Pero la configuración YAML funciona igual en cualquier instalación.

MinIO con Pocket ID

MinIO soporta OIDC desde hace tiempo. Es un caso interesante porque MinIO no es una aplicación web típica, sino un servidor de objetos con su propia consola web.

La configuración se hace con variables de entorno:

services:
  minio:
    image: minio/minio:latest
    container_name: minio
    restart: unless-stopped
    environment:
      - MINIO_ROOT_USER=admin
      - MINIO_ROOT_PASSWORD=contraseña-local
      - MINIO_IDENTITY_OPENID_CONFIG_URL=https://auth.tudominio.com/.well-known/openid-configuration
      - MINIO_IDENTITY_OPENID_CLIENT_ID=el-client-id
      - MINIO_IDENTITY_OPENID_CLIENT_SECRET=el-client-secret
      - MINIO_IDENTITY_OPENID_DISPLAY_NAME=Pocket ID
      - MINIO_IDENTITY_OPENID_SCOPES=openid,profile,email
    networks:
      - traefik

En Pocket ID, el callback URL para MinIO es: https://minio.tudominio.com/oauth_callback

Cuando un usuario accede a la consola de MinIO, puede elegir «Iniciar sesión con Pocket ID». Se autentica con su passkey, y MinIO le asigna los permisos según los grupos configurados.

Integración con LLDAP

En el capítulo 11 montaste LLDAP como directorio central de usuarios. Pocket ID puede sincronizar usuarios y grupos desde LLDAP, igual que Authelia y Authentik.

Activar la integración LDAP

Desde el panel de Pocket ID, vas a Settings > LDAP y activas la integración.

Los campos que necesitas:

• Server URL: ldap://lldap:3890.
• Bind DN: uid=admin,ou=people,dc=tudominio,dc=com.
• Bind Password: la contraseña del admin de LLDAP.
• Base DN: dc=tudominio,dc=com.
• User search base: ou=people.
• User search filter: (&(objectClass=inetOrgPerson)(uid=%s)).
• Group search base: ou=groups.
• Group search filter: (objectClass=groupOfUniqueNames).

Pocket ID sincroniza los usuarios y grupos automáticamente al arrancar y cada hora después. También puedes forzar una sincronización manual desde el mismo panel.

Limitaciones de la sincronización

Los usuarios sincronizados desde LDAP no se pueden editar desde la interfaz web de Pocket ID. Solo puedes verlos. Para modificarlos, tienes que hacerlo en LLDAP y esperar la siguiente sincronización.

Los usuarios de LDAP no tienen passkeys hasta que registran uno. Cuando inician sesión por primera vez (usando un código de un solo uso que generes desde el panel), Pocket ID les pide que registren su passkey.

¿Usar Pocket ID con LLDAP o sin él?

Pocket ID puede funcionar perfectamente sin LDAP. Sus usuarios son independientes, se crean desde el panel y cada uno registra su passkey. Para un homelab de 2-5 personas, esto es más que suficiente.

¿Cuándo añadir LDAP?

• Cuando tienes más de 10 usuarios.
• Cuando ya usas LLDAP para otros servicios que hablan LDAP directamente.
• Cuando quieres un punto único de gestión de usuarios para todos tus sistemas.
• Cuando necesitas que los grupos se sincronicen automáticamente.

Para la mayoría de los homelabs personales, Pocket ID sin LDAP es la opción más simple y funciona perfectamente.

Comparativa detallada: Pocket ID vs Authelia vs Authentik

Has visto las tres herramientas en profundidad. Llega el momento de compararlas cara a cara.

Tabla comparativa

Pocket ID:

• Propósito: proveedor OIDC exclusivamente con passkeys.
• Autenticación: solo passkeys (WebAuthn). Sin contraseñas.
• Recursos: ~50-100 MB RAM. Un solo contenedor. SQLite.
• Protocolos: OIDC (como proveedor).
• Forward-auth: no tiene. Necesita OAuth2 Proxy externo.
• Gestión de usuarios: panel web. Opcionalmente LDAP.
• Políticas de acceso: solo grupos por aplicación. No hay políticas por ruta.
• 2FA: no aplica. El passkey es el único factor.
• Panel de usuario: básico (perfil, passkeys, códigos de recuperación).
• SAML: no.
• LDAP: como fuente de usuarios (sincronización).
• Curva de aprendizaje: muy baja.
• Ideal para: homelab personal o familiar. Equipos pequeños. Máxima seguridad con mínima fricción.

Authelia:

• Propósito: forward-auth gateway + proveedor OIDC básico.
• Autenticación: usuario+contraseña + 2FA (TOTP, WebAuthn, códigos).
• Recursos: ~100-150 MB RAM. Authelia + Redis + (SQLite o PostgreSQL).
• Protocolos: forward-auth, OIDC básico (como proveedor).
• Forward-auth: nativo, integrado en el router.
• Gestión de usuarios: archivo YAML o LDAP.
• Políticas de acceso: granulares (dominio, ruta, método, red, usuario, grupo).
• 2FA: TOTP, WebAuthn, códigos de respaldo.
• Panel de usuario: mínimo (solo cambiar 2FA y ver sesiones).
• SAML: no.
• LDAP: como fuente de usuarios.
• Curva de aprendizaje: baja-media.
• Ideal para: homelab con servicios que no soportan OIDC. Necesidad de políticas por ruta.

Authentik:

• Propósito: IdP completo.
• Autenticación: usuario+contraseña + múltiples opciones 2FA.
• Recursos: ~1-2 GB RAM. Server + Worker + PostgreSQL + Redis.
• Protocolos: OIDC, OAuth2, SAML, LDAP, RADIUS, forward-auth.
• Forward-auth: nativo mediante outpost proxy.
• Gestión de usuarios: panel web, LDAP, SCIM, Google, Azure AD.
• Políticas de acceso: flujos personalizables con stages, policies y binds.
• 2FA: TOTP, WebAuthn, SMS, email, Duo, códigos de respaldo.
• Panel de usuario: completo (aplicaciones, 2FA, perfil, actividad, sesiones).
• SAML: sí.
• LDAP: como fuente y como proveedor (expone directorio LDAP).
• Curva de aprendizaje: media-alta.
• Ideal para: múltiples servicios. SSO real. Equipos. Integración corporativa. Necesidad de SAML.

¿Cuándo elegir Pocket ID?

Elige Pocket ID cuando:

• Quieres eliminar las contraseñas de tu infraestructura por completo.
• Tus usuarios tienen dispositivos modernos con Touch ID, Face ID o Windows Hello.
• Tus aplicaciones soportan OIDC nativo (o estás dispuesto a usar OAuth2 Proxy).
• Valoras la simplicidad. Un solo contenedor, sin dependencias externas.
• No necesitas políticas de acceso por ruta ni métodos HTTP.
• No necesitas SAML.
• Quieres la máxima seguridad posible (passkeys son resistentes a phishing) con la mínima fricción para el usuario.
• Tu servidor tiene recursos limitados.

¿Cuándo elegir Authelia?

Elige Authelia cuando:

• Necesitas proteger aplicaciones que no soportan OIDC con forward-auth nativo, sin complicarte con OAuth2 Proxy.
• Necesitas políticas de acceso granulares (por ruta, por método HTTP, por red).
• Tus usuarios no tienen dispositivos compatibles con passkeys.
• Prefieres configuración declarativa en YAML.
• Tienes recursos limitados pero necesitas más control que el que da Pocket ID.
• Necesitas 2FA con TOTP (para compartir códigos de acceso temporal, por ejemplo).

¿Cuándo elegir Authentik?

Elige Authentik cuando:

• Necesitas un proveedor de identidad completo con soporte SAML.
• Necesitas exponer un directorio LDAP.
• Quieres flujos de autenticación personalizados con políticas condicionales.
• Gestionas equipos u organizaciones, no solo tu homelab.
• Necesitas integración con fuentes de identidad externas (Google, Azure AD).
• Quieres un catálogo de aplicaciones con SSO real.
• Tienes RAM de sobra (2 GB disponibles).

La recomendación personal

Si solo puedes elegir una, y tu homelab es personal o familiar, elige Pocket ID. Es la opción más segura (sin contraseñas que robar), la más simple de mantener (un contenedor), y la más cómoda para los usuarios (un toque de huella y dentro). Si necesitas proteger aplicaciones que no soportan OIDC sin montar OAuth2 Proxy, o necesitas políticas de acceso por ruta, elige Authelia. Es el equilibrio perfecto entre potencia y simplicidad. Si tu infraestructura crece, tienes muchos usuarios, o necesitas SAML, LDAP como servicio o integración corporativa, elige Authentik. Pero prepárate para dedicar tiempo a aprenderlo y recursos a ejecutarlo.

Verificación

Has instalado Pocket ID, creado usuarios, configurado clientes OIDC. Ahora toca verificar que todo funciona.

Probar login con passkey desde varios dispositivos

Abre https://auth.tudominio.com en una ventana de incógnito. No deberías ver ningún formulario de login. Solo un botón «Iniciar sesión con passkey».

Pulsa el botón. Tu navegador te pide que te autentiques. Usa Touch ID, Face ID, Windows Hello o tu llave USB. Si tienes el passkey sincronizado, puedes hacerlo desde cualquier dispositivo.

Repite la prueba desde otro dispositivo (el móvil, otro portátil). Si sincronizaste el passkey, deberías poder iniciar sesión desde cualquier lugar.

Probar que no hay formulario de contraseña

Este es el test definitivo. Inspecciona la página de login de Pocket ID. No hay campo de usuario. No hay campo de contraseña. No hay botón de «Olvidé mi contraseña». Solo hay un botón para usar el passkey.

Si ves algo más que eso, algo está mal.

Probar SSO entre servicios

Si has configurado dos servicios con OIDC (por ejemplo, Grafana y Nextcloud):

1. Abre una ventana de incógnito.
2. Accede a https://grafana.tudominio.com.
3. Pulsa «Iniciar sesión con Pocket ID».
4. Autentícate con tu passkey.
5. Vuelves a Grafana. Cierra la pestaña.
6. Abre https://nextcloud.tudominio.com.
7. Pulsa «Iniciar sesión con Pocket ID».
8. No te pide el passkey otra vez. Pocket ID recuerda tu sesión y te redirige directamente a Nextcloud autenticado.

Eso es SSO funcionando. Una sola autenticación, dos servicios.

Probar OAuth2 Proxy

Si has configurado OAuth2 Proxy para una aplicación que no soporta OIDC:

1. Abre https://app.tudominio.com en una ventana de incógnito.
2. Eres redirigido a Pocket ID para autenticarte.
3. Usas tu passkey.
4. Vuelves a la aplicación, autenticado.

Verifica que la aplicación recibe las cabeceras de identidad. Puedes comprobarlo desde los logs de la aplicación o desde la interfaz si muestra el nombre del usuario.

Verificar los logs de autenticación

Desde el panel de Pocket ID, ve a Audit Log. Deberías ver las entradas de tus pruebas:

• Logged in con tu nombre de usuario y la IP desde la que te conectaste.
• Passkey registered cuando registraste un nuevo passkey.
• si algo falla, verás Failed login attempt con el motivo.

Health check

Pocket ID expone un endpoint de salud:

https://auth.tudominio.com/health

Si devuelve {"status": "ok"}, Pocket ID está funcionando.

Puedes comprobar los recursos que consume:

docker stats pocket-id --no-stream

Probablemente veas algo como 0.5% CPU y 50 MB RAM. Pocket ID es increíblemente ligero.

Probar la recuperación de acceso

Si generaste códigos de recuperación, haz una prueba controlada:

1. Cierra sesión en Pocket ID.
2. Pulsa «Use a recovery code».
3. Introduce uno de los códigos.
4. Pocket ID te deja entrar sin passkey.
5. Te pide que registres un nuevo passkey.
6. Registras uno nuevo.

Si has llegado hasta aquí sin problemas, tu infraestructura de autenticación con Pocket ID está lista.

Resumen

Pocket ID no es un sustituto de Authelia ni de Authentik. Es una alternativa con una filosofía diferente. Donde Authelia construye un muro con contraseñas y 2FA, y Authentik construye una ciudad con flujos, políticas y protocolos, Pocket ID construye una puerta que solo se abre con tu cara, tu huella o tu llave.

Es más seguro porque no hay contraseñas que robar. Es más simple porque no hay formularios que rellenar. Es más cómodo porque tu dispositivo es tu identidad.

En este capítulo has visto:

• Qué es Pocket ID y por qué los passkeys son más seguros que las contraseñas tradicionales.
• Cómo funcionan los passkeys: par de claves criptográficas, challenge-response, resistencia a phishing.
• La instalación completa con Docker Compose y Traefik, con un solo contenedor y SQLite.
• La configuración inicial: registro del primer passkey, panel de administración.
• La gestión de usuarios, grupos y la recuperación de acceso con códigos de un solo uso.
• La integración con Traefik mediante OAuth2 Proxy para aplicaciones que no soportan OIDC.
• El OIDC nativo con Grafana, Nextcloud, Home Assistant y MinIO.
• La integración con LLDAP como fuente de usuarios.
• La comparativa detallada con Authelia y Authentik para elegir la herramienta adecuada.
• Cómo verificar que todo funciona: login multi-dispositivo, SSO, logs, health check.

¿Y ahora qué? Ahora tienes tres herramientas de autenticación en tu caja de herramientas. Cada una para un escenario. Cada una con sus fortalezas.

En el próximo capítulo cambiamos de tercio. Cerrar la puerta está bien, pero asegurarte de que nadie la está forzando es mejor. Vamos a montar un sistema de monitorización de accesos y detección de intrusiones para mantener un ojo en todo lo que pasa en tu servidor.

---

Más información,

• Documentación oficial de Pocket ID: pocket-id.org/docs
• Repositorio de Pocket ID en GitHub: github.com/pocket-id/pocket-id
• Documentación de WebAuthn (W3C): w3.org/TR/webauthn
• Documentación de OAuth2 Proxy: oauth2-proxy.github.io/oauth2-proxy
• Documentación de ForwardAuth en Traefik v3: doc.traefik.io/traefik/middlewares/http/forwardauth
• Tutorial de Traefik v3 en atareao.es
• Podcast «Autenticación sin contraseñas con Passkeys y Pocket ID» en atareao.es: atareao.es/podcast/autenticacion-sin-contrasenas-con-passkeys-y-pocket-id