---
title: "Cómo instalar Authentik con Docker Compose en Ubuntu 24.04"
description: "Instala el proveedor de identidad Authentik con Docker Compose y Nginx en Ubuntu 24.04, crea el administrador y registra tu primera aplicación OpenID Connect."
category: "Gestión de Identidad y Acceso"
language: es
source: https://cubepath.com/es/docs/gestión-de-identidad-y-acceso/instalacion-de-authentik-proveedor-de-identidad
updated: 2026-09-25
---

# Cómo instalar Authentik con Docker Compose en Ubuntu 24.04

Authentik es un proveedor de identidad open source que centraliza el inicio de sesión de tus aplicaciones mediante OpenID Connect, OAuth2, SAML, LDAP o un proxy de autenticación. Incluye interfaz web de administración, flujos de login configurables, MFA y gestión de usuarios y grupos. En este tutorial lo instalarás con Docker Compose en Ubuntu 24.04, lo publicarás detrás de Nginx con HTTPS, crearás la cuenta de administrador y registrarás una aplicación OpenID Connect restringida a un grupo.

## Requisitos previos

- Un servidor con Ubuntu 24.04 LTS, al menos 2 vCPU y 2 GB de RAM (4 GB si vas a tener muchos usuarios), por ejemplo un VPS de CubePath.
- Un usuario no root con privilegios `sudo`.
- Docker Engine y el plugin de Docker Compose instalados desde el repositorio oficial de Docker.
- Nginx y Certbot instalados: `sudo apt install nginx certbot python3-certbot-nginx`, y los puertos 80 y 443 abiertos con `sudo ufw allow 'Nginx Full'`.
- Un subdominio para Authentik, en esta guía **`auth.your_domain`**, con un registro DNS A apuntando a la IP del servidor.

## Paso 1: Descargar el archivo de Docker Compose

Authentik publica un archivo de Compose oficial con tres servicios: PostgreSQL (base de datos), `server` (interfaz web y API) y `worker` (tareas en segundo plano y gestión de outposts). Crea el directorio de trabajo y descárgalo:

```bash
sudo mkdir -p /opt/authentik
cd /opt/authentik
sudo curl -fsSL -o docker-compose.yml https://goauthentik.io/docker-compose.yml
```

Comprueba qué versión de Authentik fija el archivo:

```bash
grep -m1 AUTHENTIK_TAG docker-compose.yml
```

```output
    image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2026.8.3}
```

> Nota: el servicio `worker` monta `/var/run/docker.sock` para poder desplegar outposts (proxy, LDAP, RADIUS) como contenedores. Eso le da control total sobre Docker en el host. Si no vas a usar outposts gestionados por Authentik, puedes quitar esa línea del archivo.

## Paso 2: Generar los secretos y el archivo .env

Authentik necesita una contraseña para PostgreSQL y una clave secreta con la que firma cookies y tokens. Genera ambas directamente en el archivo `.env`, que Compose lee automáticamente:

```bash
echo "PG_PASS=$(openssl rand -base64 36 | tr -d '\n')" | sudo tee /opt/authentik/.env > /dev/null
echo "AUTHENTIK_SECRET_KEY=$(openssl rand -base64 60 | tr -d '\n')" | sudo tee -a /opt/authentik/.env > /dev/null
```

Añade el resto de ajustes abriendo el archivo:

```bash
sudo nano /opt/authentik/.env
```

Pega estas líneas debajo de las dos que ya existen:

```ini
# Publicar los puertos solo en localhost; Nginx hará de frontal
COMPOSE_PORT_HTTP=127.0.0.1:9000
COMPOSE_PORT_HTTPS=127.0.0.1:9443

# No enviar informes de errores a los desarrolladores
AUTHENTIK_ERROR_REPORTING__ENABLED=false

# Correo saliente para recuperación de contraseña y verificaciones
AUTHENTIK_EMAIL__HOST=smtp.your_domain
AUTHENTIK_EMAIL__PORT=587
AUTHENTIK_EMAIL__USERNAME=noreply@your_domain
AUTHENTIK_EMAIL__PASSWORD=your_smtp_password
AUTHENTIK_EMAIL__USE_TLS=true
AUTHENTIK_EMAIL__FROM=noreply@your_domain
```

Publicar los puertos en `127.0.0.1` es importante: Docker inserta sus propias reglas de iptables y se salta UFW, así que con el valor por defecto los puertos 9000 y 9443 quedarían abiertos a Internet. Si todavía no tienes servidor SMTP, omite las líneas `AUTHENTIK_EMAIL__*`; Authentik funciona igual, pero no podrá enviar correos.

Restringe los permisos del archivo, ya que contiene la contraseña de la base de datos:

```bash
sudo chmod 600 /opt/authentik/.env
```

## Paso 3: Arrancar Authentik

Descarga las imágenes y levanta los contenedores:

```bash
cd /opt/authentik
sudo docker compose pull
sudo docker compose up -d
```

El primer arranque tarda uno o dos minutos porque Authentik crea el esquema de la base de datos. Comprueba el estado:

```bash
sudo docker compose ps
```

```output
NAME                      IMAGE                                COMMAND                  SERVICE      STATUS                   PORTS
authentik-postgresql-1    docker.io/library/postgres:16-alpine "docker-entrypoint.s…"   postgresql   Up 2 minutes (healthy)   5432/tcp
authentik-server-1        ghcr.io/goauthentik/server:2026.8.3  "dumb-init -- ak ser…"   server       Up 2 minutes (healthy)   127.0.0.1:9000->9000/tcp, 127.0.0.1:9443->9443/tcp
authentik-worker-1        ghcr.io/goauthentik/server:2026.8.3  "dumb-init -- ak wor…"   worker       Up 2 minutes (healthy)
```

Cuando los tres servicios aparecen como `healthy`, verifica que la interfaz responde en local:

```bash
curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:9000/if/flow/initial-setup/
```

```output
200
```

Si algún contenedor se reinicia, revisa sus registros con `sudo docker compose logs server --tail 50`.

## Paso 4: Publicar Authentik con Nginx y HTTPS

Authentik usa WebSockets para la interfaz de administración y la comunicación con los outposts, así que Nginx debe reenviar las cabeceras `Upgrade` y `Connection`. Crea el sitio:

```bash
sudo nano /etc/nginx/sites-available/auth.your_domain
```

```nginx
map $http_upgrade $connection_upgrade_keepalive {
    default upgrade;
    ''      '';
}

server {
    listen 80;
    server_name auth.your_domain;

    client_max_body_size 25m;

    location / {
        proxy_pass http://127.0.0.1:9000;
        proxy_http_version 1.1;
        proxy_set_header Host $http_host;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade_keepalive;
    }
}
```

Activa el sitio y valida la configuración:

```bash
sudo ln -s /etc/nginx/sites-available/auth.your_domain /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx
```

Obtén el certificado de Let's Encrypt. Certbot añade al bloque `server` la configuración TLS y la redirección de HTTP a HTTPS:

```bash
sudo certbot --nginx -d auth.your_domain
```

```output
Successfully deployed certificate for auth.your_domain to /etc/nginx/sites-enabled/auth.your_domain
Congratulations! You have successfully enabled HTTPS on https://auth.your_domain
```

## Paso 5: Crear la cuenta de administrador

Authentik crea un usuario administrador llamado `akadmin` sin contraseña y lo completa mediante un flujo de configuración inicial. Abre en el navegador (la barra final es necesaria):

```text
https://auth.your_domain/if/flow/initial-setup/
```

Introduce un correo y una contraseña robusta para `akadmin` y confirma. Authentik inicia la sesión y te lleva a la interfaz de usuario. Pulsa **Admin interface** para entrar en el panel de administración, que también está en `https://auth.your_domain/if/admin/`.

> Advertencia: completa este paso justo después de publicar Authentik. Hasta que lo hagas, cualquiera que llegue a esa URL puede fijar la contraseña del administrador.

Como buena práctica, crea después tu propio usuario administrador en **Directory > Users**, añádelo al grupo `authentik Admins` y usa esa cuenta en el día a día.

## Paso 6: Crear usuarios y un grupo

Las aplicaciones se restringen normalmente por grupo. En el panel de administración:

1. Ve a **Directory > Groups > Create**, escribe `devops` como nombre y guarda.
2. Ve a **Directory > Users > Create**, rellena el nombre de usuario, el nombre visible y el correo, y guarda.
3. Abre el usuario, pulsa **Set password** para asignarle una contraseña (o **Send recovery link** si configuraste SMTP).
4. En la pestaña **Groups** del usuario, pulsa **Add to existing group** y selecciona `devops`.

## Paso 7: Registrar una aplicación OpenID Connect

En Authentik, una **aplicación** es lo que ve el usuario y un **proveedor** define el protocolo (OAuth2/OIDC, SAML, LDAP, proxy). El asistente crea ambos a la vez:

1. Ve a **Applications > Applications** y pulsa **Create with provider**.
2. En **Application**, pon el nombre `Grafana` y el slug `grafana`. El slug forma parte de las URLs del proveedor.
3. En **Choose a Provider**, selecciona **OAuth2/OpenID Provider**.
4. En **Configure Provider**:
   - **Authorization flow**: `default-provider-authorization-implicit-consent`, para que el usuario no tenga que aceptar un consentimiento en cada login.
   - **Client type**: `Confidential`.
   - **Redirect URIs**: modo `Strict` y la URL de callback de tu aplicación, por ejemplo `https://grafana.your_domain/login/generic_oauth`.
   - Copia el **Client ID** y el **Client Secret**, los necesitarás en la aplicación.
5. En **Configure Bindings**, pulsa **Bind existing group** y elige `devops`. Solo los miembros de ese grupo podrán usar la aplicación.
6. Revisa el resumen y pulsa **Submit**.

Authentik expone un documento de descubrimiento OpenID Connect por aplicación. Compruébalo desde el servidor:

```bash
curl -s https://auth.your_domain/application/o/grafana/.well-known/openid-configuration | python3 -m json.tool | head -8
```

```output
{
    "issuer": "https://auth.your_domain/application/o/grafana/",
    "authorization_endpoint": "https://auth.your_domain/application/o/authorize/",
    "token_endpoint": "https://auth.your_domain/application/o/token/",
    "userinfo_endpoint": "https://auth.your_domain/application/o/userinfo/",
    "end_session_endpoint": "https://auth.your_domain/application/o/grafana/end-session/",
    "introspection_endpoint": "https://auth.your_domain/application/o/introspect/",
    "revocation_endpoint": "https://auth.your_domain/application/o/revoke/",
```

Estos son los valores que pide cualquier cliente OIDC. Si la aplicación admite descubrimiento automático, basta con indicarle el `issuer`, el Client ID y el Client Secret, y los ámbitos `openid email profile`.

Para probar el acceso, abre `https://auth.your_domain` en una ventana privada e inicia sesión con el usuario del paso 6: la aplicación `Grafana` aparece en su biblioteca. Un usuario fuera del grupo `devops` no la verá y recibirá un error de permisos si intenta usarla.

## Paso 8: Hacer copias de seguridad y actualizar

Todo el estado de Authentik (usuarios, proveedores, flujos) vive en PostgreSQL, y los certificados y archivos subidos en `/opt/authentik/data` y `/opt/authentik/certs`. Para volcar la base de datos:

```bash
cd /opt/authentik
sudo docker compose exec -T postgresql pg_dump -U authentik -d authentik | gzip > ~/authentik-$(date +%F).sql.gz
```

Guarda también una copia de `/opt/authentik/.env`: sin `AUTHENTIK_SECRET_KEY` no podrás restaurar las sesiones ni algunos datos cifrados.

Para actualizar, lee primero las notas de la versión en la documentación de Authentik, descarga de nuevo `docker-compose.yml` con el mismo comando del paso 1 y ejecuta:

```bash
sudo docker compose pull
sudo docker compose up -d
```

Authentik aplica las migraciones de base de datos al arrancar. No saltes varias versiones mayores de golpe.

## Solución de problemas

**La interfaz de administración carga a medias o muestra errores de conexión.** Falta el reenvío de WebSockets. Revisa que el bloque `location` tiene `proxy_http_version 1.1` y las cabeceras `Upgrade` y `Connection`, y recarga Nginx.

**Las URLs de los proveedores aparecen con `http://` en lugar de `https://`.** Nginx no está enviando `X-Forwarded-Proto`. Comprueba la cabecera en el bloque `location` del sitio.

**Has perdido la contraseña de `akadmin`.** Genera un enlace de recuperación válido durante 10 minutos:

```bash
cd /opt/authentik
sudo docker compose run --rm server create_recovery_key 10 akadmin
```

El comando imprime una ruta que debes abrir añadiéndola a `https://auth.your_domain`.

**Un contenedor no arranca tras cambiar `.env`.** Compose solo relee el archivo al recrear los contenedores. Ejecuta `sudo docker compose up -d --force-recreate` y revisa `sudo docker compose logs server worker --tail 50`.

## Conclusión

Tienes Authentik funcionando con Docker Compose detrás de Nginx con HTTPS, con una cuenta de administrador, un grupo de usuarios y una aplicación OpenID Connect restringida a ese grupo. Como siguientes pasos puedes activar MFA con TOTP o WebAuthn en el flujo de autenticación por defecto, proteger aplicaciones sin soporte OIDC con un proveedor de tipo **Proxy** y el outpost integrado, o exponer un servidor LDAP con un outpost LDAP para equipos de red y aplicaciones heredadas.