Deploying authentik outposts with Docker: when a Docker host needs its own outpost
If your applications run on Docker hosts and you want authentik to sit in front of them, you will likely need an *outpost*: a separate component that authentik runs alongside your services to enforce access checks. An outpost is the right path when the application cannot sign users in through OIDC or SAML itself and you protect it with a proxy, or when a service needs LDAP or RADIUS answers from a location close to it. Deploying the outpost as a Docker container on the same host as the application keeps the check close to the traffic it guards, and it is a reasonable choice when that host already runs your application stack in Docker.
authentik's Docker integration offers two routes. In the first, the integration creates the outpost containers for you as a background task, so the authentik server manages their lifecycle once the Docker connection is configured. In the second, you deploy the outpost yourself with Docker Compose and give it the outpost's token, which you copy from the outpost's entry in authentik. The managed route suits teams that want authentik to handle container creation. The manual route suits teams that already keep their Compose files in version control and want every container definition in one place. Confirm in the authentik outposts documentation which options your version exposes before you choose.
Before you pick a route, decide which Docker networks the outpost must join so it can reach both authentik and the protected application, and whether your hosts can pull images directly from the public registry. Managed outposts pull their images when the outpost controller creates containers, and the image source is controlled by container_image_base and each outpost's container_image. Teams in air-gapped networks need to plan an internal mirror for those images and should review the authentik air-gapped documentation first. Ask your authentik contact or confirm in your own environment which image tags each outpost version expects, so that the outpost and the authentik server stay on compatible releases.
Automatic Docker integration or manual Compose: how the two paths differ
With the Docker integration, authentik's outpost controller creates the outpost containers for you. The controller runs as a background task and connects to the Docker host you register with authentik. When you create or change an outpost in authentik, the controller reconciles the containers on that host, and the image is pulled when the controller creates the container. Your team still owns the Docker host, its network reachability to authentik, and the access that lets the controller reach the Docker API.
- Container creation: The controller creates the outpost containers, so you do not write service definitions for them.
- Image source: Images are controlled by
container_image_baseand each outpost'scontainer_image, which matters for air-gapped mirrors. - Host access: Your team must secure how authentik reaches the Docker host, since that path grants control over containers.
- Change flow: Outpost settings are changed in the authentik interface rather than in Compose files kept in your repository.
- Good fit: Teams that want authentik to manage outpost lifecycle and already run a dedicated Docker host.
Before you rely on this path, confirm the exact registration steps and the Docker API permissions with the current outposts documentation for your authentik version.
With a manual deployment, you write the Compose service for the outpost yourself and start it with the outpost's token, which you copy from authentik. Docker Compose then owns the container lifecycle: starting, restarting, updating the image tag and wiring networks. Authentik only receives the outpost's connection and reports its status. This keeps every container definition in version control next to the applications it protects.
- Container lifecycle: Your team starts, stops and upgrades the outpost containers through Compose.
- Token handling: The outpost token is a credential, so store it in a secret mechanism or environment file with restricted access, not in a committed file.
- Image tags: You choose the image tag and must move it along with the authentik server version.
- Networks: You define which networks the outpost joins so it can reach both authentik and the protected applications.
- Good fit: Teams that manage infrastructure as code, run Compose for their applications, or do not want authentik to hold Docker API access.
Compose is documented for test setups and small-scale production in the authentik guide, so size and back up the host accordingly.
The two paths give the same outpost function but different owners for the container. The choice usually depends on where your team wants the change record to live, who may touch the Docker host, and how often outposts are added. Neither path removes the need to keep the outpost version aligned with the authentik server, and both need the outpost to reach authentik and the applications behind it.
- Ownership: Automatic management leaves container changes with authentik's controller, while Compose leaves them with your repository and pipeline.
- Access surface: The integration needs Docker API reach from authentik, while Compose needs only a token on the host.
- Change auditing: Compose changes appear in version control, whereas integration changes appear in authentik's own records.
- Mixed estates: Some teams run the integration for shared outposts and Compose for isolated application stacks, if they can document both clearly.
- Ownership of upgrades: In either path, your team must plan the outpost version to match the server before each upgrade.
Confirm your chosen path with the outposts documentation and test it in a non-production environment first.
Which Docker outpost options fit which host setup
This table compares the Docker outpost choices, automatic container creation, manual Compose, the base image setting, per-outpost image overrides and network placement, against the host setups they suit. Read each row as a decision: find the setup that matches your hosts, then confirm the items in the last column before you commit.
| Choice | Fits when | Operator must confirm |
|---|---|---|
| Automatic container creation by the Docker integration | A single Docker host where authentik should create and update outpost containers as a background task | The authentik server and worker can reach the Docker API on the host, and the host can pull images from the registry you plan to use |
| Manual Compose deployment with an outpost token | You want the outpost defined in your own Compose files, under your change control and restart policy | The token is stored in a secret or environment file you manage, and the outpost container can reach authentik over the network |
| Shared image base via container_image_base | You want every managed outpost on a host or across hosts to follow one image source and version pattern | The base image path resolves to a registry your hosts reach, and the tag matches the authentik version you run |
| Per-outpost container_image override | One outpost needs a different image, such as a mirror, a pinned build or a test tag | The override is set on that outpost only, and you record the reason so the next upgrade does not silently change it |
| Air-gapped or private registry mirror | Hosts have no route to public registries and images must come from an internal mirror | Every image the outpost needs is mirrored, and the mirror path is what container_image_base or the override points to |
| Outpost on the same Docker network as the application | The reverse proxy reaches the application by container name and the outpost must be reached the same way | The network name is shared by the proxy, the application and the outpost, and no other service on it is exposed unintentionally |
| Outpost on a separate network with published ports | The proxy runs on a different host or network segment from the application | Firewall rules allow the proxy to reach the outpost port, and the outpost can still reach authentik on the server address |
Setting up an outpost on a Docker host, step by step
This sequence takes a Docker host from a confirmed authentik version to an outpost that is registered in authentik, attached to the application network, and able to reach both authentik and the protected application. Each step closes with a check you can run before moving on.
Confirm the authentik version and outpost image
Record the version your authentik server and worker containers run, and check it against the versions listed as supported in the security policy. The outpost image should match that version, so pull the tag that matches your server. Set the image source before deploying. The container_image_base setting controls the default image for managed outposts, and each outpost's container_image can override it. If your hosts cannot reach public registries, confirm the mirror path in the air-gapped documentation first. Check: the version shown in the admin interface matches the image tag you plan to pull.
Create the outpost and its provider in authentik
In the authentik admin interface, create the provider for the application first, such as a proxy provider for forward auth, and assign it to the application. Then create an outpost, attach the provider, and select Docker as the integration type. For manual deployments, copy the outpost's token from its settings and store it in a secrets location you control. Check: the new outpost appears in the outposts list with the provider attached.
Choose the Docker integration or a manual Compose file
With the Docker integration, authentik creates and manages the outpost containers as a background task on the host, so you do not write a service definition yourself. With a manual deployment, you write a Compose service for the outpost that uses the token and host settings from the outposts documentation. The managed path suits teams that want authentik to handle container lifecycle, while the manual path keeps the service definition in your own version control and change process. Confirm how authentik reaches the Docker engine on that host before you choose. Check: the chosen path is written down and matches your change process.
Supply the outpost token for manual deployments
Skip this step if you use the Docker integration. For a manual deployment, pass the token to the outpost container through the environment keys named in the outposts documentation, using a Compose secrets file or an environment file with restricted permissions. Keep the token out of files tracked in Git, out of shell history, and out of CI logs. Check: the container starts, and
docker compose logsshows the outpost reporting a connection to authentik, while a search of the repository finds no token value.Attach the outpost to the application network
Place the outpost on the same Docker network as the reverse proxy and the protected application, so the proxy can call the outpost and the outpost can reach the application by its container name. For managed outposts, confirm the network setting in the outpost configuration. Avoid publishing the outpost's port to the wider host network unless your proxy setup requires it. Check:
docker network inspectlists the outpost, proxy and application containers on the same network, and the outpost resolves the application's name.Verify the outpost reaches authentik and the application
Test the full path. Open the protected hostname in a private browser session and confirm the request redirects to the authentik login page through the proxy. Sign in and confirm the application loads with the identity headers you expect. Then confirm the application cannot be reached directly, bypassing the proxy. If a check fails, compare the outpost and server versions, and confirm the network membership from the previous step. Check: the outpost shows as healthy in the admin interface, and the sign-in appears in authentik's event log.
How networks and image sources shape an outpost deployment
The image source decides what your Docker host must be able to reach before an outpost ever runs. For managed Docker outposts, the outpost controller pulls the outpost image when it creates the container, so the first question is whether the host can pull from the public registry or must pull from an internal one. Authentik documents two settings that control this: container_image_base sets the default image base for outposts, and each outpost's container_image overrides it for that outpost. Check both in the authentik admin interface before the first deployment, and confirm the exact field names and defaults against the authentik outposts documentation, because the setting location can change between releases.
This matters most in air-gapped networks. If the host cannot reach a public registry, you must mirror the outpost image into an internal registry, point container_image_base or the outpost's container_image at that mirror, and make sure the tag you mirror matches the authentik version running in your core deployment. Mirroring the image is a recurring task, not a one-time step: each upgrade of authentik needs a matching outpost image in the mirror before the outpost is updated. The authentik air-gapped documentation describes the approach. Ask your team who owns the mirror, how often it syncs, and how an upgrade is blocked if the image is missing.
Network paths are the second half of the design. The outpost needs a route to the authentik server so it can fetch its configuration and report health, and the host or container needs a route to the protected application so that the proxy can forward authenticated requests. Users must also reach the outpost's listening port through your reverse proxy or load balancer. Map each of these flows on paper, including DNS names, ports and TLS trust for internal certificates, and confirm the required ports and the connection direction against the current authentik documentation for your version. Treat the network layout as something to verify in a test environment before you rely on it in production.
Security risks to design out of Docker outpost deployments
An outpost sits between users and your applications, and it holds a credential that can act on behalf of the authentik server. The controls below address where that credential lives, what can reach the outpost, which image runs, and how the outpost stays in step with the server.
Protect the outpost token
A manual Compose deployment uses the outpost's token to connect to the authentik server, so anyone who reads that token can impersonate the outpost. Keep the token out of Compose files committed to version control and out of shell history. Load it from a root-owned environment file or a secrets store on the host, restrict the file to the account that runs Compose, and rotate the token if a host, backup or repository exposes it.
Limit Docker socket access
The automatic Docker integration needs access to the Docker API so it can create and remove outpost containers. Access to the Docker socket is effectively root on the host, so treat the authentik server and its worker as privileged components. Confirm which container mounts the socket, keep that mount off every other service, and ask whether a rootless or socket-proxy setup is practical for your host before enabling the integration.
Keep the outpost behind the proxy
A proxy outpost should be reachable only through the reverse proxy that enforces authentication. Publish the outpost port on the internal Docker network rather than on the host interface, and do not give the application a route that bypasses the proxy. Test from outside the proxy path to confirm that a direct request to the application or the outpost port fails, because a header-trusting app will accept a forged identity from any client that can reach it.
Pin image versions
Every outpost container runs an image, and an unpinned tag such as latest can change under you during a pull. Pin the image tag in each Compose file or in the Docker integration settings, and set the image source explicitly, whether that is the default registry or an internal mirror. Record the digest your team tested and change it only through a planned review, so a restart never brings in an unreviewed build.
Match outpost and server versions
Outposts must run a version that matches the authentik server, and mismatches can break the connection or the protocol behavior the proxy depends on. After each server upgrade, update the outpost image in the same change window and confirm the outpost reports a healthy connection in the admin interface. Keep this step in the upgrade runbook so an outpost is never left behind on an older release.
Log outpost activity
Outpost container logs record connection, authorization and error events that the server log may not show, and they are the first place to look when access fails or behaves oddly. Forward container logs from every outpost host to your central log store, set a retention period that matches your policy, and alert on repeated authentication errors or on an outpost that drops its connection to the server.
Questions teams ask before deploying authentik outposts on Docker
Does authentik cost anything to run for outposts on Docker?
The open-source edition is free to use, and the authentik pricing page lists it as free with community support through Discord. Outposts are part of the open-source platform, so the software itself adds no license fee for a Docker deployment. The costs that remain are the infrastructure you run the outposts on, the time your team or a partner spends on setup, and any support contract you choose. The pricing page lists Enterprise at $5 per user per month billed annually, plus $0.02 per external user per month, with Enterprise-only features such as Google Workspace and Microsoft Entra ID integrations. Check your own feature needs against that list before assuming the free edition covers them.
What drives the effort of an authentik outpost deployment?
Effort depends on how many applications sit behind outposts, how many Docker hosts you run, and whether you use the automatic Docker integration or a manual Compose file. The main drivers are the number of providers and applications to configure in authentik, the reverse proxy routing for each protected application, network paths between each outpost and the authentik server, and the image source you use in an air-gapped or registry-controlled network. Ask any provider for a written scope that lists each host, each protected application, each network and each image source, because those items set the work.
Can our team deploy authentik outposts on Docker without outside help?
A team with working Docker and Compose skills, a running authentik instance, and an administrator who can create providers and applications can deploy outposts on its own. The authentik documentation covers both the managed Docker integration, where authentik creates outpost containers as a background task, and manual Compose deployments that use an outpost token. Teams without someone who owns the reverse proxy, the Docker hosts and the authentik configuration together often benefit from a partner for the first deployment. Confirm internally who will own each of those three areas before you decide.
How long does a typical authentik outpost deployment take?
No duration is fixed by the vendor for this work, so the length depends on your environment. A single host with one or two applications is a small change, while several hosts, several reverse proxies and an air-gapped image mirror take longer because each adds testing and approvals. Ask a provider to split the timeline into the authentik configuration, the outpost hosts, the reverse proxy changes, testing with real users, and handover. A timeline without those phases usually hides the parts that take the most calendar time, such as change windows and access reviews.
What does the team need to provide for an outpost deployment?
Plan for four inputs: Docker skills on the hosts that run the outposts, network access from each outpost to the authentik server and from the reverse proxy to the outpost, a container registry or image source that your hosts can reach, and an authentik administrator who can create providers, applications and outposts. The authentik Docker Compose guide asks for at least 2 CPU cores and 2 GB of RAM for the authentik host, so check that the Docker hosts meet the sizing for their role. In an air-gapped network, confirm how images are mirrored and which values in the outpost configuration point to the mirror.
Which parts of an authentik outpost setup are ongoing?
Outposts need continuing attention after the first deployment. The main recurring tasks are applying authentik version upgrades to the outposts so they match the server version, tracking security releases, checking image sources after updates, monitoring outpost health and logs, and updating reverse proxy routes when applications change. The authentik security policy lists 2026.5.x and 2026.8.x as the supported versions receiving security fixes, and security releases are announced at least 24 hours in advance, so assign someone to watch that schedule. Ask any provider whether these tasks are covered by a retainer or handed to your team.
What should we request in a written quote for this work?
Ask for a written scope that names each Docker host, each application to be protected, each reverse proxy change, the image source and registry plan, the network paths that must be opened, and the testing and handover steps. The quote should separate one-time work from recurring work such as upgrades and support, and state which items the client supplies. Ask how changes after scope agreement are priced and who approves them. DeployOpen works from a written, fixed scope with agreed deliverables and timelines, and it does not publish a price list, so the quote follows from that scope.
Does DeployOpen issue a compliance certificate for an outpost deployment?
No. DeployOpen plans, implements, hardens, documents and supports self-hosted platforms, and it can prepare systems and evidence for compliance assessments. It does not issue audit reports, attestations or certifications, which come from independent auditors and certification bodies. For an outpost deployment, the useful evidence includes the access configuration, the image versions in use, the logs from outposts, and the change records, and your assessor will tell you which of those they need.
Running and upgrading Docker outposts over time
Every Docker outpost must stay on the same authentik version as the server it connects to, so the recurring job starts whenever the server is upgraded. Treat the outpost image as part of the authentik release, not as an independent component. Before each change, read the authentik upgrade guidance for the target version, since it covers the sequential upgrade rule, breaking changes and outpost-specific steps. Then confirm which image each outpost uses: with managed Docker outposts, the controller's container_image_base setting and each outpost's container_image value decide what gets pulled, so an outdated override can keep an outpost on an old tag after the server has moved on.
Track the supported versions on the authentik security policy page. It lists which release lines receive security fixes, and the project announces security releases at least 24 hours in advance. Use that window to schedule the change rather than waiting for an emergency. Subscribe to the authentik releases page so you see new tags as they publish. Note that a release line outside the supported list will not receive fixes, so an outpost left on it carries the same exposure as the server. Confirm the current supported lines with the policy page before you plan each maintenance window, because they change over time.
Test every change on a staging host that runs the same Compose file, the same outpost token type and the same reverse proxy routes as production. Upgrade the server first, confirm the outpost reconnects in the admin interface, then pull and recreate the outpost containers. Recreating containers is what applies a new image, so a plain restart is not enough when the tag has changed. Keep the previous image tag and Compose file in version control so you can roll back the outpost quickly. Check that protected applications still redirect to login and pass identity headers after each step, because a successful container start does not prove that forward auth works.
What DeployOpen scopes for a Docker outpost engagement
A written scope is the document that turns an outpost project into something you can budget and verify. For Docker outposts, it should list every Docker host that will run an outpost, each application and the forward auth or proxy provider that protects it, the outpost instances and their token owners, the network paths between the outpost, the authentik server and each application, the image source for every container, and the checks that show the outposts are healthy and enforcing policy. DeployOpen agrees these items with your team before work starts, so the quote follows from the scope rather than from a generic package. Most engagements are fixed-scope, with deliverables and timelines confirmed in writing.
Cost splits into one-time and recurring parts. One-time work covers host preparation, the authentik outpost configuration, Compose or Docker integration setup, network and firewall changes, image mirroring if your registry is internal, test passes against each protected application, and handover documentation. Recurring work covers outpost image upgrades that follow authentik releases, reviewing the supported version lines listed in the authentik security policy, and any retainer you choose for ongoing support. Your own staff are paid for the access approvals, change windows and application owner time that the engagement depends on. Ask the quote to state which of these items it includes and which it assumes you provide.
The main drivers of effort are the number of hosts and applications, whether each application needs its own provider or shares a parent domain, how many network zones the outposts must cross, and whether your environment blocks pulls from public registries. Ask for the scope to name the exact image tags or the internal registry path that each outpost will use, since changing the source later means retesting every container. Before accepting a quote, confirm who owns the outpost tokens after handover, how credentials are rotated, and which verification steps must pass before the scope is considered complete.
How DeployOpen delivers authentik outposts on Docker
DeployOpen plans, builds and documents authentik outposts on Docker hosts inside your own infrastructure, starting from a written scope. The work covers the Docker integration or a manual Compose deployment, the network path to each protected application, and the image source your hosts can reach.
How we scope
- Inventory which applications sit behind Docker hosts and which need the proxy outpost
- Decide between automatic container creation and a manual Compose deployment with an outpost token
- Confirm network segments, reverse proxy placement and the image registry your hosts can pull from
- Agree the scope, deliverables and timeline in writing before any build work starts
How we build
- Configure the authentik Docker integration or write Compose files for each outpost
- Set container_image_base and per-outpost container_image values to match your approved image source
- Test authentication, redirects and header passing against each protected application
- Verify outpost reconnection after a restart and after an authentik server upgrade
How we hand over
- Document the outpost token handling, network layout and image source for your team
- Provide runbooks for adding an outpost, rotating its token and recovering a stopped container
- Walk your platform engineers through the test results and the open items for your sign-off
- Record the authentik version and PostgreSQL details each outpost was validated against
How we support
- Ongoing support, version upgrades and continuous testing are available as a retainer
- Outpost upgrades can be planned alongside authentik release changes and security releases
- Retainer scope is agreed in writing, so response expectations are set before an incident
- Ask for a quote based on your written scope, since DeployOpen does not publish a price list

