On this page (6)
  1. Verified compose file
  2. Install steps
  3. Measured resources
  4. Gotchas, upgrade and backup
  5. What we did not measure
  6. Related

This authentik Docker Compose file runs authentik 2026.8.5 as three containers: PostgreSQL 16.15, the server and the worker. There is no Redis. You put two secrets in a .env file (PG_PASS and AUTHENTIK_SECRET_KEY), run docker compose up -d, open port 9000 and set the akadmin password in the browser. In our lab the stack idled at 1.0 GiB (range 840 to 1,071 MiB) and peaked at 1.1 GiB (918 to 1,113 MiB) under 60 password logins, medians of three runs, so by our sizing rule it needs 2 GB of RAM, the same as authentik’s own install page asks for. The one snag we hit: on a host whose kernel has IPv6 switched off, the server restarts in a loop until you set IPv4 listen addresses (see “The server restarts: Address family not supported”).

Measured readings

Test box: authentik 2026.8.5

Measured in our lab on : 3 full runs, each from a fresh stack. Each figure is the median, with the range over the runs under it. The numbers come from the raw result file.

Idle RAM
1.0 GiBrange 840 MiB–1.0 GiB · 3 runs all containers, median of 3 runs; each run is the mean over 30 s after the stack settled
Startup peak RAM
1.1 GiBrange 841 MiB–1.1 GiB · 3 runs highest total between healthy and settled
Peak RAM
1.1 GiBrange 918 MiB–1.1 GiB · 3 runs under load, median of the run peaks
Settled after
147 ssame when rounded in all 3 runs after the first healthy response
Idle CPU
2.9 %range 1.1–3.3 · 3 runs of one core, lab host
Startup
81 srange 78–83 · 3 runs to first healthy response
App version
2026.8.5
Tested
, 3 runs (compose file verified the same day)
How the figures are made
Each run starts a fresh stack and goes through setup, settling, the idle window and the load step. We publish the median over the runs and the lowest and highest value, because the lab host and some apps vary from run to run. Runs, median and range
Lab host
Intel(R) Xeon(R) 6975P-C, 2 cores, 7.6 GiB RAM, x86_64.Ubuntu 26.04.1 LTS, Docker 29.4.2. Measured in the same GitHub Actions job (run 42445712898) as Authelia; this app was number 1 of 2 in the run order, so an order effect is possible.
Disk for the images
About 3.2 GB with the containerd image store, the default on fresh installs of Docker Engine 29 and later (measured on this lab host, which used the containerd store; never below our estimate of unpacked plus compressed size, plus 10%). Plan for the larger figure. How we size disk
How idle was measured
After the stack was healthy and set up, we sampled total RAM until it stayed within max(2% of its mean, 10 MiB) over 60 s (at least 120 s, at most 600 s), then measured idle over the next 30 s. Rule in full
Peak RAM measured
Under load. One user (the admin account), over plain HTTP on the Compose network, from one Python script that plays the part of the reverse proxy (the proxy itself is not in the stack). First 60 password logins, 4 at a time, each from a fresh client with no cookies: the default authentication flow through the flow executor API (identification, password, login; about 6 requests), then one single sign-on handshake with the embedded outpost (3 requests: the outpost's start, the authorize call, the outpost's callback) so that the session can be used behind a forward-auth proxy. Then 3,000 authorisation checks, 8 at a time, spread evenly over the 60 sessions (50 each): GET /outpost.goauthentik.io/auth/traefik with the X-Forwarded-Method, -Proto, -Host and -URI headers and the proxy session cookie, which must answer 200. The Authelia app runs the same script with the same counts (60 logins, 4 at a time; 3,000 checks, 8 at a time). No browser, no MFA, no OAuth/OIDC clients, no LDAP or other sources, no policies beyond the defaults, one user. Just before the measured window (not counted) a pre-flight checks that a wrong password is refused, a right one logs in, an authorised check returns 200 with the user name and a check without a session is redirected.
Per-container figures for authentik: median over 3 runs, with the range
ContainerIdle RAMPeak RAM (under load)Image, compressed (download)Image, unpacked (disk, containerd store)
postgresql77 MiBrange 77–78 · 3 runs115 MiBrange 107–119 · 3 runs116 MB420 MB
server690 MiBrange 462–694 · 3 runs709 MiBrange 501–715 · 3 runs378 MB1.9 GB
worker300 MiBrange 299–301 · 3 runs309 MiBrange 301–310 · 3 runs378 MB (same image as server)1.9 GB (same image as server)
Total1.0 GiBrange 840 MiB–1.0 GiB · 3 runs1.1 GiBrange 918 MiB–1.1 GiB · 3 runs494 MB2.4 GB
Every run (3)
Total RAM, startup and CPU model of each run of authentik
RunIdle RAMPeak RAMStartup peakStartupLab host CPU
1840 MiB918 MiB841 MiB83 sIntel(R) Xeon(R) 6975P-C
21.0 GiB1.1 GiB1.1 GiB81 sIntel(R) Xeon(R) 6975P-C
3 (closest to median idle)1.0 GiB1.1 GiB1.1 GiB78 sIntel(R) Xeon(R) 6975P-C
Total RAM after the stack became healthy (10 s averages, run 3 of 3)
Total RAM across all containers in 10 s averages, from the moment the stack was healthy until the end of the idle window (180 s). Run 3 of 3, the one closest to the median idle. Highest 10 s average 1.0 GiB at 130 s, last 1.0 GiB at 180 s. Dashed line: the stack counted as settled at 147 s.

0 s to 180 s after healthy; the line spans 0 to 1.0 GiB. Dashed line: settled.

Timeline as a table
Total RAM, 10 s average ending at each time, every 30 s after healthy
Seconds after healthyTotal RAM
301.0 GiB
601.0 GiB
901.0 GiB
1201.0 GiB
1501.0 GiB
1801.0 GiB

RAM is MiB (220 bytes); image sizes are MB (106 bytes). The unpacked column is what our lab host's Docker reported; see Disk for the images for other setups. Per-container peaks happen at different moments, so they do not add up to the total peak. Medians of separate columns need not add up either.

Lab notes (10)
  • Redis: not used and not in the stack. authentik 2025.10 removed it ("authentik no longer uses Redis at all", https://docs.goauthentik.io/releases/2025.10/); the official 2026.8 compose file (https://docs.goauthentik.io/compose.yml) has PostgreSQL, server and worker only. Caching, sessions, tasks and websocket messaging now run on PostgreSQL, which is why PostgreSQL is part of the footprint.
  • Compose file: the official 2026.8 file with the image tag pinned to 2026.8.5 (the file's own default), PostgreSQL pinned to 16.15-alpine (the file says 16-alpine, the same image today), the ./data, ./certs and ./custom-templates folders turned into named volumes, and the first-start values in .env. The worker keeps the Docker socket mount of the official file.
  • First start without a browser: AUTHENTIK_BOOTSTRAP_PASSWORD, AUTHENTIK_BOOTSTRAP_TOKEN and AUTHENTIK_BOOTSTRAP_EMAIL in .env (https://docs.goauthentik.io/install-config/automated-install/); the published .env has the password, token and secret key lines commented out.
  • The embedded outpost (the forward-auth endpoint) runs INSIDE the server container, so its memory is part of the server's number. A separate proxy outpost container would be one more container.
  • Password hashing: authentik's own settings set no PASSWORD_HASHERS (authentik/root/settings.py at version/2026.8.4), so Django's default applies: PBKDF2 with SHA-256 and, in Django 5.2 (5.2.17 in this image, per its uv.lock), 1,000,000 iterations. The authentik docs do not state the parameters. The second setup step reads the algorithm and iteration count of the admin user's stored hash from the database (never the salt or the hash).
  • Same load as the Authelia app: 60 password logins, 4 at a time, then 3,000 authorisation checks, 8 at a time, spread over the 60 sessions (50 each); the counts are in the test.yaml of both apps and a test fails if they differ. A pre-flight of a few requests (one wrong password, one login, two checks) runs just before the measured window and is not counted.
  • NOT equivalent, on purpose and recorded: (1) one authentik login is the default authentication flow through the flow executor API, about 6 HTTP requests, plus a single sign-on handshake with the embedded outpost (3 requests) so that the session works behind a forward-auth proxy: 9 requests per login against Authelia's 1. (2) authentik's check goes to /outpost.goauthentik.io/auth/traefik (the embedded outpost inside the server container, https://docs.goauthentik.io/add-secure-apps/providers/proxy/server_traefik/) and needs the proxy session cookie the handshake sets; Authelia's check uses the one session cookie. (3) The two apps need very different time for the same counts, so the load window of this app is minutes and Authelia's is seconds. The memory peak is the highest simultaneous sample either way.
  • Why the forward-auth endpoint and not only the flow API for the checks: the outpost endpoint is what a reverse proxy (Traefik, Caddy, nginx) calls for every request to a protected site, as Authelia's /api/authz/forward-auth is. Both were checked to work headless (plain HTTP with X-Forwarded-* headers, no browser).
  • Setup order matters: a proxy provider keeps only the scope mappings (openid, profile, email, entitlements, proxy) that exist when it is saved (authentik/providers/proxy/models.py set_oauth_defaults), and the worker makes them in the system blueprints, not with the default flows. Without them the outpost's check answers 200 with an empty X-authentik-username. The setup step waits for the five mappings before it creates the provider and verifies that the provider carries them.
  • Startup: the server answers its readiness endpoint only after it has applied the database migrations on the first start (about 3 minutes on a 4-vCPU box), and the worker applies the blueprints (default flows, outposts) after that; the setup step waits for them. The stack is busy for several minutes after healthy, which the settle rule waits for.

Tested 2026.8.5, the newest stable release. It is marked “Latest” on the authentik releases page and is the default image tag in the official compose file, both read Nov 1, 2026; the registry has no newer stable tag. The 2026.8.5 notes list five fixes (a MultipleObjectsReturned error in endpoints, the Microsoft Entra provider skipping members already in a group, a bump of certificate-related dependencies, web stage type errors and an agents tab that flashed without a license) and label none as security, memory or breaking. Security matters more one patch earlier. 2026.8.2 (Sep 9, 2026) is the release that fixes three High advisories published that day: MFA bypass through the email authenticator’s recipient override (CVE-2026-94606), privilege escalation through delegated group and user management (CVE-2026-94609) and a denial of service through malformed SAML messages (CVE-2026-94613, SAML users only). Each lists 2026.8.1 and earlier as affected and 2026.8.2 as patched. The 2026.8.2 notes list five security patches in all; we matched three to advisories and read nothing on the other two. If you run 2026.8.1 or older, update to 2026.8.5. We did not test any of the advisories and say nothing about whether your setup is exposed. The 2026.8 line also changed one default that can break a proxy setup (see “Behind a reverse proxy”), and its notes say a Base URL setting becomes required in 2026.11 (see “Set the Base URL now”).

Verified compose file

Three services and four named volumes. The file is the official 2026.8 compose file (docs.goauthentik.io/compose.yml, install guide) with three differences, all marked in the file’s comments: PostgreSQL is pinned to 16.15-alpine (the official file says 16-alpine, which was the same image when we tested), the ./data, ./certs and ./custom-templates folders are named volumes, and the first-start values for the admin account can come from .env. The official file reads the image from AUTHENTIK_TAG; ours writes 2026.8.5 on the two image lines, with the tested digest in a comment.

compose.yamlVerified 2026-11-08 · authentik 2026.8.5Download compose.yaml for authentik
# Verified compose for authentik, tested 2026-11-08 by the SelfHostBench lab (3 runs; the figures are the median).
# Lab host: Intel(R) Xeon(R) 6975P-C, 2 vCPU, 7.6 GiB RAM, x86_64, Docker 29.4.2.
# Floating image tags below were replaced by the version resolved at test time;
# the registry digest is in the comment on each image line.
# Measurements: authentik.json (schema 3).
# Companion env file: authentik.env (save it as .env next to this file).
# Secrets are not published: the lab's values are public. In authentik.env:
#   PG_PASS is commented out. Uncomment it and set your own value (the comment above it explains how).
#   AUTHENTIK_SECRET_KEY is commented out. Uncomment it and set your own value (the comment above it explains how).
#   AUTHENTIK_BOOTSTRAP_PASSWORD is commented out. Uncomment it and set your own value (the comment above it explains how).
#   AUTHENTIK_BOOTSTRAP_TOKEN is commented out. Uncomment it and set your own value (the comment above it explains how).

# authentik 2026.8.5 (identity provider and SSO): PostgreSQL, the server and the worker. No Redis.
# This is the official compose file for 2026.8 (https://docs.goauthentik.io/compose.yml, which pins 2026.8.5 as the default of
# AUTHENTIK_TAG; install guide https://docs.goauthentik.io/install-config/install/docker-compose/), with these differences, all marked below:
#   - PostgreSQL is pinned to 16.15-alpine (the official file says 16-alpine, which today is the same image);
#   - ./data, ./certs and ./custom-templates are named volumes here (the official file bind-mounts folders next to the compose file);
#   - the .env file has first-start values for the admin account (AUTHENTIK_BOOTSTRAP_*), so the first start needs no browser.
# Redis: authentik "no longer uses Redis at all" since 2025.10 (https://docs.goauthentik.io/releases/2025.10/), so there is no redis service.
# There is no TLS and no reverse proxy in this file. Put one in front before you expose it.
name: authentik

services:
  postgresql:
    env_file:
      - .env
    environment:
      POSTGRES_DB: ${PG_DB:-authentik}
      POSTGRES_PASSWORD: ${PG_PASS:?database password required}
      POSTGRES_USER: ${PG_USER:-authentik}
    healthcheck:
      interval: 30s
      retries: 5
      start_period: 20s
      test:
        - CMD-SHELL
        - pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}
      timeout: 5s
    # Official file: postgres:16-alpine (a floating tag). 16.15-alpine is the same image today (same digest), pinned so a re-test uses the same PostgreSQL.
    image: docker.io/library/postgres:16.15-alpine  # sha256:aa6cb33cf4c19c765cefcf48d96176258800870a9a1e930ad126200f9d825139  (version 16.15, from exec)
    restart: unless-stopped
    volumes:
      - database:/var/lib/postgresql/data

  server:
    command: server
    depends_on:
      postgresql:
        condition: service_healthy
    env_file:
      - .env
    environment:
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY:?secret key required}
    image: ghcr.io/goauthentik/server:2026.8.5  # sha256:602227a86455d6772e3d16b7d852713c4f864f40df5df894abd1285bb53979a5  (version 2026.8.5, from exec)
    ports:
      - ${COMPOSE_PORT_HTTP:-9000}:9000
      - ${COMPOSE_PORT_HTTPS:-9443}:9443
    restart: unless-stopped
    shm_size: 512mb
    volumes:
      # Official file: ./data:/data and ./custom-templates:/templates (folders next to the compose file).
      - data:/data
      - custom-templates:/templates

  worker:
    command: worker
    depends_on:
      postgresql:
        condition: service_healthy
    env_file:
      - .env
    environment:
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY:?secret key required}
    image: ghcr.io/goauthentik/server:2026.8.5  # sha256:602227a86455d6772e3d16b7d852713c4f864f40df5df894abd1285bb53979a5  (version 2026.8.5, from exec)
    restart: unless-stopped
    shm_size: 512mb
    user: root
    volumes:
      # Lets the worker manage Docker outposts. The install guide says to remove this mount (or put a Docker socket proxy
      # in front of it) if you do not want authentik to control Docker.
      - /var/run/docker.sock:/var/run/docker.sock
      # Official file: ./data, ./certs and ./custom-templates.
      - data:/data
      - certs:/certs
      - custom-templates:/templates

volumes:
  database:
    driver: local
  data:
  certs:
  custom-templates:

What the settings do:

  • server and worker are one image run with two commands. The server answers web requests and runs the embedded outpost, the part that answers a reverse proxy’s forward-auth checks. The worker runs background tasks. Both need PostgreSQL and the secret key.
  • Ports 9000 and 9443 are authentik’s HTTP and HTTPS listeners (install guide). Set COMPOSE_PORT_HTTP and COMPOSE_PORT_HTTPS in .env to publish other host ports; the guide’s example is 80 and 443. Not run in our lab. 9443 serves a certificate we could not verify: curl without -k failed with verify result 18 (self-signed), so it is for the proxy-to-authentik hop at best, not for your browser.
  • No Redis. The 2025.10 release notes say “authentik no longer uses Redis at all”: caching, tasks, the embedded outpost’s session store and WebSockets moved to PostgreSQL, which the notes say means roughly 50% more database connections. That is why PostgreSQL is part of the footprint in the table below.
  • env_file: .env on all three services hands every line of .env to each container, PostgreSQL included. That is how the official file is written and we did not change it. It is also why the extra lines in “The server restarts” below work from .env.
  • PG_PASS and AUTHENTIK_SECRET_KEY are required. The file uses :?, so Compose refuses to start with required variable PG_PASS is missing a value: database password required (we ran that), and the same for the secret key. PG_DB and PG_USER default to authentik.
  • shm_size: 512mb is from the official file. We did not test without it.
  • The worker runs as root and mounts the Docker socket, as in the official file. See “The Docker socket” below.

The .env holds the optional first-start values and three commented-out lines for the secrets:

.envVerified 2026-11-08 · authentik 2026.8.5Download .env for authentik
# PostgreSQL password. Choose your own; the stack does not start without it (the compose file says: database password required).
# Generate one with:  openssl rand -base64 36 | tr -d '\n'   (PostgreSQL does not support passwords longer than 99 characters)
# PG_PASS=

# authentik secret key. Choose your own; the stack does not start without it. The docs say it signs session cookies and backs several other cryptographic operations, and that changing it ends every active session (https://docs.goauthentik.io/security/security-hardening/). Keep it with your backups and do not rotate it as routine maintenance.
# A placeholder would be a known key, so the lab's value is not published and this line is commented out.
# Generate one with:  openssl rand -base64 60 | tr -d '\n'
# AUTHENTIK_SECRET_KEY=

# Optional: the password of the default admin user akadmin, read on the FIRST start only (https://docs.goauthentik.io/install-config/automated-install/).
# Leave the three AUTHENTIK_BOOTSTRAP_* lines out and authentik asks for the password in the browser instead, at http://<host>:9000/if/flow/initial-setup/.
# The lab's value is public, so this line is commented out. Choose your own if you want a non-interactive start.
# AUTHENTIK_BOOTSTRAP_PASSWORD=
# Optional: an API token for akadmin, created on the first start only. The value is the token itself, so keep it secret. Choose your own long random string.
# AUTHENTIK_BOOTSTRAP_TOKEN=
AUTHENTIK_BOOTSTRAP_EMAIL=akadmin@selfhostbench.test

The published .env has no secrets, on purpose. The lab ran with its own values, but they sit in our public test config, and a placeholder left in place would become a known password or a known key. So PG_PASS, AUTHENTIK_SECRET_KEY, AUTHENTIK_BOOTSTRAP_PASSWORD and AUTHENTIK_BOOTSTRAP_TOKEN are commented out, and the compose file refuses to start until the first two are set. The files you download are not byte for byte the files the lab ran: the .env has the lab’s values removed, one comment line was reworded after the run (see the update log), and the compose file has a block of comment lines at the top and the image digests as comments. AUTHENTIK_BOOTSTRAP_EMAIL is a placeholder on the .test domain: set it to your address or delete the line. The docs say it sets the email of the akadmin user.

Install steps

We ran these in a scratch folder in our sandbox on Nov 1, 2026 (Docker 29.9.2, Compose 5.6.1, Ubuntu 24.04.5, 4 vCPUs), with the same image digests as the lab. The raw output is in lab/notes/authentik-compose-2026-11-01.md in the lab repository. The sandbox kernel has IPv6 switched off, which stops the published file from running as it is (next section), so steps 3 and 4 include the fix.

  1. Install Docker Engine with the Compose plugin. The install guide asks for “at least 2 CPU cores and 2 GB of RAM”.

  2. Make a folder and save the two files above as compose.yaml and .env in it. The download links are on each block. Replace akadmin@selfhostbench.test in .env with your email.

  3. Add your two secrets to .env. The last two are the install guide’s own commands; they append a line each, below the commented-out ones. The first adds a blank line so the new values cannot be glued onto the last line of the file if your editor left off the final newline (our sandbox run did not need it). The guide says PostgreSQL does not support passwords longer than 99 characters, and openssl rand -base64 36 stays under that.

    bash
    echo >> .env
    echo "PG_PASS=$(openssl rand -base64 36 | tr -d '\n')" >> .env
    echo "AUTHENTIK_SECRET_KEY=$(openssl rand -base64 60 | tr -d '\n')" >> .env

    Only if your kernel has IPv6 off (the sandbox’s /proc/cmdline has ipv6.disable=1), add the listen lines too. Skip this on a normal host.

    bash
    echo "AUTHENTIK_LISTEN__HTTP=0.0.0.0:9000" >> .env
    echo "AUTHENTIK_LISTEN__HTTPS=0.0.0.0:9443" >> .env
    echo "AUTHENTIK_LISTEN__METRICS=0.0.0.0:9300" >> .env
  4. Start the stack. The first start downloads about 494 MB of images (compressed, see below) and applies the database migrations. --wait returns when all three containers report healthy.

    bash
    docker compose up -d --wait

    In the sandbox this returned after 85 s on the first start, with the images already pulled. The lab’s own measure, the server answering /-/health/ready/, took a median of 104 s (99 to 105 s) after docker compose up -d, and the stack needed a median of 155 s (151 to 161 s) after that to settle. The lab’s notes say the worker applies its default flows for a while after the server answers, and the settle rule waits for that. Expect a few minutes before it is quiet.

  5. Check the containers.

    bash
    docker compose ps

    Our output, shortened to the columns that matter:

    text
    NAME                     STATUS                        PORTS
    authentik-postgresql-1   Up About a minute (healthy)   5432/tcp
    authentik-server-1       Up About a minute (healthy)   0.0.0.0:9000->9000/tcp, 0.0.0.0:9443->9443/tcp
    authentik-worker-1       Up About a minute (healthy)

    5432/tcp is the container’s own port with no host mapping: PostgreSQL is not published. All three showed 0 restarts in docker inspect.

  6. Open http://<host>:9000/ and set the akadmin password. The install guide says you are “prompted to set a password for the akadmin user”. Do this before anyone else can reach the port: the setup page asks for no login, so whoever opens it first sets the admin password (our reading; we did not test a second visitor), and on a remote server it is plain HTTP, so the password crosses the network unencrypted. On a VPS, open it through an SSH tunnel (ssh -L 9000:127.0.0.1:9000 user@server, then browse to http://127.0.0.1:9000/) or set the bootstrap variables below instead. Not run in our lab: the tunnel. Our scripts drove the same flow over HTTP instead of a browser: / answered 302 to /setup, /if/flow/initial-setup/ answered 200, the flow asked for an email, a password, the password again and a base URL, and posting an email and a password (no base URL) returned a redirect to /. A login with that password through the default authentication flow then succeeded. Not run in our lab: the browser pages. The troubleshooting page names /if/flow/initial-setup/ as the initial setup flow.

  7. Check health from the host. Both returned 200 in the sandbox. The second is the lab’s own health check.

    bash
    curl -s -o /dev/null -w "%{http_code}\n" http://127.0.0.1:9000/-/health/live/
    curl -s -o /dev/null -w "%{http_code}\n" http://127.0.0.1:9000/-/health/ready/

To stop the stack, docker compose down removes the containers and keeps the volumes; docker compose down -v deletes them, with your users and settings.

Skipping the browser on the first start

The automated install page lists variables for the worker container, “only read on the first startup”: AUTHENTIK_BOOTSTRAP_PASSWORD_HASH, AUTHENTIK_BOOTSTRAP_PASSWORD, AUTHENTIK_BOOTSTRAP_TOKEN (the token key for an API token of akadmin) and AUTHENTIK_BOOTSTRAP_EMAIL. The lab used the plaintext password variable, which is the one the commented lines in our .env name, so no browser was needed. The docs warn that it “stores plaintext passwords in environment variables” and tell you to use the hash instead: docker compose run --rm server hash_password prompts for the password and prints the hash, and since 2026.8 it no longer takes the password as an argument. Hashes contain $, so in a .env file wrap the value in single quotes. Setting both password variables is an error, and none of these can use the file:// syntax. Not run in our lab: the hash variable. We did not run the bootstrap variables in the sandbox either; the lab did. Lab-automation observation, not part of the install steps: our setup script creates the proxy provider through the API. If that happens before the worker has applied authentik’s system blueprints, the provider is saved without the default scope mappings, because set_oauth_defaults in authentik/providers/proxy/models.py (version 2026.8.5) attaches only those of the five scope mappings that exist in the database when it runs, and ProxyProviderSerializer in the same folder’s api.py calls it on create and on update (we read the source; we did not test the update path). When our script saved a provider without them, the embedded outpost’s check answered 200 with an empty username header (a failed lab run and a local reproduction on Nov 8; we did not save the raw output as a lab note, and the published figures come from runs that passed the user check). The lab’s setup now waits for the mappings and checks that the provider carries five. We did not try the web interface, so we cannot say whether it can hit this. If you script the API, wait until the scope mappings are listed before you create the provider.

Measured resources

Source: authentik.json, three runs on Nov 8, 2026, each from a fresh stack, on a GitHub Actions ubuntu-latest runner (2 vCPU Intel Xeon 6975P-C, 7.6 GiB RAM, Ubuntu 26.04.1, Docker 29.4.2), in one job with Authelia, authentik first (GitHub Actions run 42445712898). Every figure is the median of the three runs, with the lowest to highest run in brackets (why we repeat runs). Idle is the mean of 30 s after the total memory had settled, with nobody logged in. The load was one Python script playing a reverse proxy over plain HTTP: 60 password logins of the admin account, 4 at a time, then 3,000 forward-auth checks, 8 at a time, spread over the 60 sessions. All 60 logins and all 3,000 checks succeeded in each run, with no restart or out-of-memory kill. Peak is the highest total sample during the load. The lab ran the published compose file with no override; its script reached the server by service name over the Compose network, not through the published ports.

Measure authentik 2026.8.5 Source
Idle RAM, stack, MiB 1,066.59 (840.34 to 1,070.89) Tested
Idle RAM by container, MiB server 689.97 (462.00 to 693.84), worker 299.77 (299.26 to 300.70), PostgreSQL 77.37 (77.27 to 77.64) Tested
Startup peak RAM, MiB (healthy to settled) 1,084.31 (840.72 to 1,086.29) Tested
Peak RAM under load, stack, MiB 1,108.60 (918.40 to 1,112.90) Tested
Peak RAM by container (each its own highest sample), MiB server 708.90, worker 309.00, PostgreSQL 114.70 Tested
RAM reading used for sizing (highest run), MiB 1,112.90 Tested
Idle CPU, % of one core, lab host 2.92 (1.08 to 3.27) Tested
Healthy after docker compose up -d, s 80.8 (78.0 to 82.9) Tested
Settled after healthy, s 146.8 (146.8 to 146.9) Tested
Images, distinct, compressed / unpacked, MB 493.6 / 2,360.0 Tested

What the numbers say:

  • By our sizing rule (how we size) it needs 2 GB. The highest run reading, 1,112.9 MiB, times 1.5 is 1,669 MiB, 1.63 GiB, and 2 GB is the next tier up: 379 MiB under the line. That agrees with the install guide’s minimum of 2 GB. We did not test a smaller host or a memory limit.
  • The server is the big one, and its idle figure moves. The server idled at 462.00, 693.84 and 689.97 MiB in the three runs, each settled under the lab’s rule; the worker held at about 300 MiB and PostgreSQL at about 77 MiB in all three. We did not find why one run sat about 230 MiB lower, so treat 1,067 MiB as the figure to plan for and 840 MiB as the lowest we saw. Two earlier sets of three runs on other hosts had medians of 836 MiB (2026.8.5, Oct 30, Intel Xeon Platinum 8370C) and 942 MiB (2026.8.4, Oct 20, AMD EPYC 7763); we do not know whether the host, the version or chance caused the differences, and the release notes do not mention memory.
  • Images. The server and worker share one image (377.5 MB compressed, 1,940 MB unpacked), and PostgreSQL adds 116.1 MB compressed and 420 MB unpacked. The unpacked sizes are from the containerd image store of Docker 29, which counts differently from overlay2; the Test box gives the figure for the host it was measured on. Your data comes on top, and we did not measure its growth over days.
  • Logins are slow on two cores, checks are fast. Each login was about 9 HTTP requests: the default authentication flow, then a single sign-on handshake with the embedded outpost. At 4 in flight the median login took 4.25 s (p95 4.80 s) and the median check 59.6 ms, with the stack using about 190% of the host’s 200% CPU in both phases (lab/notes/sso-pair-2026-11.md). These are lab-host figures with the load script on the same two vCPUs. We never timed one login alone, and we did not test a larger host. The reasons for the cost are not established; Authentik vs Authelia separates what we measured from what we infer.
  • CPU model. The runner’s CPU model changes between runs of the whole lab, and the latency differed between the two sets: the median login took 6.46 s on an Intel Xeon Platinum 8370C (Oct 30) and 4.25 s on the Intel Xeon 6975P-C of the table above (Nov 8). All three runs of each set were on one CPU model. Authentik vs Authelia ran authentik and Authelia in one job on that same CPU model.

What we did not measure: real users, OIDC, SAML, LDAP, email, a second factor, an outpost other than the embedded one, TLS, a reverse proxy, a memory limit, and Arm hardware. For how it compares with a lighter login server, measured in the same job on the same host (authentik first; the other order was not tested), see Authentik vs Authelia.

Gotchas, upgrade and backup

The checks in this section were run once in our sandbox on Nov 1, 2026, on image 2026.8.5, unless a line says “researched” or “Not run in our lab”. The sandbox is not the lab runner: 4 vCPUs, Docker 29.9.2, cgroup v1, and a kernel booted with IPv6 off.

The server restarts: Address family not supported

With both secrets set and nothing else changed, docker compose up -d --wait returned after 188 s with container authentik-worker-1 is unhealthy. The server container kept exiting with code 0 and restarting (3 restarts at the first check, 5 a minute later; it never stayed up long enough to be healthy), and the worker stayed unhealthy. The server’s log ends each start with this error:

text
Error:
   0: Errors encountered: [
         0: Address family not supported by protocol (os error 97)
      Location:
         packages/ak-axum/src/server.rs:33

The spans name the listeners it was opening: [::]:9300, [::]:9000 and the HTTPS one on 9443. The configuration page gives those as the defaults ([::]:9000 for AUTHENTIK_LISTEN__HTTP, [::]:9443 for AUTHENTIK_LISTEN__HTTPS, [::]:9300 for AUTHENTIK_LISTEN__METRICS), and our kernel has IPv6 disabled (ipv6.disable=1 on its command line, no /proc/net/if_inet6). We added these three lines to .env, took the stack down with -v and started it again:

text
AUTHENTIK_LISTEN__HTTP=0.0.0.0:9000
AUTHENTIK_LISTEN__HTTPS=0.0.0.0:9443
AUTHENTIK_LISTEN__METRICS=0.0.0.0:9300

All three containers were healthy after 85 s, with 0 restarts. The docs describe AUTHENTIK_LISTEN__METRICS as the Prometheus listener and say an empty value disables it; we set an address rather than testing the empty value. The same failure is upstream issue #24303, opened Jul 22, 2026 against 2026.5.4 and closed as not planned the next day. The reporter’s workaround is the same three variables, and a maintainer replied that it is the correct workaround and that the project will not support legacy-only environments out of the box (we read the issue; we did not test other versions). We did not test other ways to get IPv6 working. If your host has IPv6, you will not see any of this. The lab runner did not: its three runs had 0 restarts on the published file’s images.

The Docker socket

The worker runs as root with /var/run/docker.sock mounted. The install guide says this lets authentik deploy and manage outposts automatically and that it “comes with some inherent security risks”. It suggests a Docker socket proxy in front, or removing the mount and managing outposts by hand. We kept the mount, as the official file does, and did not test either alternative. In the sandbox the socket inside the worker was owned by root with group docker, and the worker ran as user 0. If you use only the embedded outpost, the lab’s forward-auth path, nothing we ran needed the mount; we did not run without it.

Behind a reverse proxy

Not run in our lab. The file has no TLS and no proxy, and the reverse proxy page lists what authentik needs from one:

  • Headers. The proxy sets X-Forwarded-Host or Host, X-Forwarded-Proto and X-Forwarded-For from the original request and overwrites any the client sent. It also forwards Connection: Upgrade and Upgrade: WebSocket: authentik uses WebSockets to talk to outposts, and the page says HTTP/1.0 proxies are not supported.
  • Trusted proxies, and the 2026.8 change. authentik only uses forwarded headers from a trusted proxy network. The default list is 127.0.0.0/8, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, fe80::/10 and ::1/128. The 2026.8 release notes call this a change: earlier versions did not apply the restriction consistently, and the notes tell you to check, before upgrading, that every address your proxy connects from is covered by AUTHENTIK_LISTEN__TRUSTED_PROXY_CIDRS. Setting that variable replaces the default list. On Traefik in Docker the page says the shared network is within the defaults unless you use a custom address pool.
  • Wrong client IP or http:// links are the symptoms the page gives for an untrusted proxy address.
  • Binding to one address. The file publishes 9000 and 9443 on all interfaces. When the proxy runs on the same host, put an address in front of the host port in the ports: lines, which Compose’s short syntax allows (we ran that form on a different file, the port 53 lines in the Pi-hole guide). Not run on this file.

For HTTPS in front of a Compose stack, the working Caddy setup is in the Vaultwarden Docker Compose guide and the Home Assistant guide; neither is authentik-specific. The vendor’s proxy pages, which we read but did not run, are on the reverse proxy page, with Traefik and Caddy forward auth separate.

Set the Base URL now

The 2026.8 notes add a Base URL system setting: the external URL where the instance is reachable, “scheme and host” only. It “will become required starting with authentik 2026.11”, and they recommend setting it now. You can set it under System > Settings, through the API, or with AUTHENTIK_WEB__BASE_URL during installation; the configuration page says the variable is copied into the setting on first start if the setting is empty and never overwrites one you set. In the sandbox the first-run setup flow had a base URL field, which we left empty. Not run in our lab: the variable, or a start with the setting filled in.

Lost admin password

The docs’ login troubleshooting page gives a recovery command for Compose. We ran it on the sandbox stack:

bash
docker compose run --rm server create_recovery_key 10 akadmin

It printed “Store this link safely, as it will allow anyone to access authentik as akadmin.”, “This recovery token is valid for 10 minutes.” and a path of the form /recovery/use-token/<token>/. We did not open the link. Treat it like a password.

Update

The tag is pinned on two lines, server and worker, so an update is an edit: change both to the new version and delete the stale digest comments. The upgrade page says: back up the database first; do not skip directly from an older major version to the newest, and within a release line move to the latest patch before the next line (its example runs 2025.2.1, then the last 2025.2.x, then 2025.4.x); authentik does not support downgrading; and server and outpost versions must match, so upgrade outposts together with the instance. Its Compose steps are to download the new compose.yml, run docker compose pull, then docker compose up -d. Downloading would overwrite the named-volume changes in our file, so edit the tags instead. Not run in our lab: an upgrade of a running stack. We started fresh 2026.8.5 stacks.

bash
docker compose pull
docker compose up -d

Back up

The docs’ backup page calls the PostgreSQL database “the most important part of an authentik backup” and lists the static directories to keep: /data, /certs if you use certificate files, /custom-templates if you changed the look, and /blueprints if you use custom ones. It names pg_dump and pg_restore but gives no command for Compose, so these are ours. We ran them on the sandbox stack: a custom-format dump of 3.06 MB, restored into a scratch database in the same container with pg_restore, and the restored copy had the same 3 users and 230 tables as the live one. We did not start authentik on the restored copy, and did not test the volumes.

bash
docker compose exec -T postgresql sh -c 'pg_dump -U "$POSTGRES_USER" -Fc "$POSTGRES_DB"' > authentik.dump

Not run in our lab: restoring into a fresh stack. Keep your .env with the backup: the stack does not start without the secret key and database password, and the docs’ backup page does not mention the key. The docs’ security hardening page says AUTHENTIK_SECRET_KEY “signs session cookies and backs several other cryptographic operations”, and that rotating it ends every active session, so change it if it leaks, not as routine maintenance. The configuration page lists only cookie signing. We do not know what else depends on the key, so treat a lost or changed key as possible damage beyond a logout; we did not test changing it.

Time zone

The install guide warns that all internal operations use UTC and that you must not mount or update /etc/timezone or /etc/localtime in the authentik containers, because that can cause problems with OAuth and SAML. The file does neither.

What we did not measure

  • Anything through the published ports in the lab: its script used the Compose network. We reached the ports from the sandbox host once, with the IPv4 listen lines.
  • A reverse proxy, TLS, OIDC or SAML applications, LDAP, email, second factors, an Enterprise license, any outpost but the embedded one, and a browser login.
  • The AUTHENTIK_BOOTSTRAP_* variables in the sandbox (the lab used them), the hash variant, and the Base URL variable.
  • An upgrade from an older tag, a restore into a fresh stack, a larger host than 2 vCPU, and memory or database growth over days.
  • Arm hardware.

Where to run it

  • Hardware. authentik idled at 1.0 GiB and peaked at 1.1 GiB under load (medians of 3 runs) in our lab. The highest reading in any run was 1.1 GiB. Plan for at least 2 GB of RAM, sized from the highest run. See how much RAM self-hosted apps use.
  • VPS. The smallest plan that runs this comfortably has 2 GB of RAM, plus disk for your data and the images. Plan for about 3.2 GB for the images (Docker's containerd image store, the default on fresh installs of Docker 29 and later).
  • Keep it safe. Back up the data volume before you rely on it, and put the app behind a reverse proxy with HTTPS before you expose it to the internet. See backing up self-hosted apps.

How we size: recommended RAM is the highest reading in any of our runs (under load or during startup, not the median) times 1.5, rounded up to the next of 1, 2, 4, 8, 16 or 32 GB. The extra half covers the operating system, Docker, file cache and spikes our sampling can miss. Your own data and extra apps need more. Disk for images: Docker Engine 29 and later uses the containerd image store on fresh installs, which keeps each image twice (as downloaded and unpacked); older installs use overlay2, which keeps it unpacked only. We plan for the larger figure: unpacked plus compressed size, plus 10%, rounded up. Your data volumes and growth come on top.

Update log

  • Measured figures replaced by authentik's three runs of Nov 8, 2026 (GitHub Actions run 42445712898, same version 2026.8.5, run in one job before Authelia on an Intel Xeon 6975P-C, Ubuntu 26.04.1, Docker 29.4.2). Idle 1,066.6 MiB (was 835.7), load peak 1,108.6 (was 1,013.9), sizing reading 1,112.9 (was 1,116.7), still the 2 GB tier; login p50 4.25 s (was 6.46), healthy after 80.8 s (was 104.1). The lab's setup now waits for authentik's default scope mappings before it creates the proxy provider, and a one-line note on that was added to the automation section. The compose file is unchanged except the PostgreSQL image digest recorded in a comment (same 16.15-alpine tag). The figures are in lab/notes/sso-pair-2026-11.md.
  • First published. authentik 2026.8.5, the newest stable release on Nov 1, 2026: the measured figures are the lab's three runs of Oct 30, 2026 on a GitHub Actions runner. The published file itself, with its ports mapped, was run once in our sandbox on Nov 1 (raw output in lab/notes/authentik-compose-2026-11-01.md), where it only worked after IPv4 listen addresses were added, because the sandbox kernel has IPv6 switched off. The facts about variables, ports, the first-run setup, proxy headers, upgrades and backups are from the official authentik documentation, read Nov 1, 2026. Also changed the comment above AUTHENTIK_SECRET_KEY in the published .env, which said the key encrypts stored values; the documentation says it signs session cookies and backs several other cryptographic operations, and does not say it encrypts stored values.