Docmost Docker Compose Install: Self-Hosted Wiki for Teams

Docmost is an open-source collaborative wiki and documentation platform built as a self-hosted alternative to Confluence and Notion. With over 21,200 GitHub stars and an active community, it’s become one of the most popular self-hosted wiki options for teams that want to own their data.

Docmost gives you a real-time collaborative editor with rich text formatting, markdown support, page nesting, spaces for organizing content by team or project, and inline commenting. It runs on TypeScript with PostgreSQL and Redis, which makes the Docker Compose install straightforward. Three containers and you’re running.

This guide walks through a complete Docmost Docker Compose install on a Linux VPS: the updated compose configuration, environment variables, SSL with a reverse proxy, and the gotchas that trip people up (WebSocket headers, APP_SECRET length, database passwords).

If you want to monitor server resources like CPU, memory, and disk space after deployment, check how to monitor server and Docker resources.

If you are looking for other self-hosted documentation and note-taking apps, also check:

• How to Install Outline Wiki on Docker
• How to Install Memos with Docker Compose

What is Docmost? A self-hosted Confluence alternative

Docmost positions itself directly against Confluence and Notion. The difference: you host it yourself, you own the data, and the Community Edition is free under the AGPL 3.0 license.

The project is backed by a commercial company that sells Enterprise features (SSO, MFA, AI chat) on top of the open-source core. The Community Edition covers everything most teams need for a shared wiki: real-time editing, spaces, permissions, page history, attachments, and search.

Key features (Community vs Enterprise)

Community Edition (free, AGPL 3.0):

Enterprise Edition (paid):

SSO (SAML, OIDC, LDAP), MFA (TOTP), AI Chat with MCP support, page verification workflows, SCIM provisioning, PDF import, DOCX export, Typesense search, audit logs, and security controls.

Docmost Docker Compose installation guide

This is the full step-by-step Docmost installation guide with Docker Compose. The compose file below is based on the official template from the Docmost repository (v0.95.0, July 2025).

Prerequisites for Docker deployment

Before you start, make sure you have:

If you want to manage your Docker containers with a web UI, check Dockge: Docker Compose manager for self-hosting.

Docker Compose configuration

services:
  docmost:
    image: docmost/docmost:latest
    depends_on:
      - db
      - redis
    environment:
      APP_URL: 'https://docs.example.com'
      APP_SECRET: 'REPLACE_WITH_LONG_SECRET'
      DATABASE_URL: 'postgresql://docmost:STRONG_DB_PASSWORD@db:5432/docmost?schema=public'
      REDIS_URL: 'redis://redis:6379'
    ports:
      - "3000:3000"
    restart: unless-stopped
    volumes:
      - docmost:/app/data/storage

  db:
    image: postgres:18
    environment:
      POSTGRES_DB: docmost
      POSTGRES_USER: docmost
      POSTGRES_PASSWORD: STRONG_DB_PASSWORD
    restart: unless-stopped
    volumes:
      - db_data:/var/lib/postgresql

  redis:
    image: redis:8
    command: ["redis-server", "--appendonly", "yes", "--maxmemory-policy", "noeviction"]
    restart: unless-stopped
    volumes:
      - redis_data:/data

volumes:
  docmost:
  db_data:
  redis_data:

services:
  docmost:
    image: docmost/docmost:latest
    depends_on:
      - db
      - redis
    environment:
      APP_URL: "${APP_URL}"
      APP_SECRET: "${APP_SECRET}"
      DATABASE_URL: "postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}?schema=public"
      REDIS_URL: "redis://redis:6379"
    ports:
      - "3000:3000"
    restart: unless-stopped
    volumes:
      - docmost:/app/data/storage

  db:
    image: postgres:18
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    restart: unless-stopped
    volumes:
      - db_data:/var/lib/postgresql

  redis:
    image: redis:8
    command: ["redis-server", "--appendonly", "yes", "--maxmemory-policy", "noeviction"]
    restart: unless-stopped
    volumes:
      - redis_data:/data

volumes:
  docmost:
  db_data:
  redis_data:

APP_URL=https://docs.example.com
APP_SECRET=REPLACE_WITH_GENERATED_SECRET
POSTGRES_DB=docmost
POSTGRES_USER=docmost
POSTGRES_PASSWORD=STRONG_DB_PASSWORD

Three services:

1. docmost: the application. Maps port 3000 on the host. Mounts a named volume for file attachments at /app/data/storage.
2. db: PostgreSQL 18. Stores all wiki content, users, and metadata. Uses a named volume for data persistence.
3. redis: Redis 8. Handles caching and session state. Runs with appendonly yes for persistence and noeviction to prevent data loss under memory pressure.

Key changes from older Docmost Docker Compose guides: postgres:18 (non-Alpine, larger image but more compatible), redis:8 with explicit memory policy, named volumes instead of bind mounts, and no version: "3" line (deprecated in Docker Compose v2).

Environment variables explained

Generate the APP_SECRET:

openssl rand -hex 32

This produces a 64-character hex string (well above the 32-character minimum).

For production secrets, consider securely managing Docker Compose secrets rather than hardcoding them in the compose file.

MAIL_DRIVER: smtp
SMTP_HOST: smtp.example.com
SMTP_PORT: "587"
SMTP_USERNAME: your_username
SMTP_PASSWORD: your_password
SMTP_SECURE: "false"
MAIL_FROM_ADDRESS: hello@example.com
MAIL_FROM_NAME: Docmost

STORAGE_DRIVER: s3
AWS_S3_ACCESS_KEY_ID: "your-key"
AWS_S3_SECRET_ACCESS_KEY: "your-secret"
AWS_S3_REGION: "auto"
AWS_S3_BUCKET: "docmost-attachments"
AWS_S3_ENDPOINT: "https://your-s3-endpoint.com"  # for non-AWS providers
AWS_S3_FORCE_PATH_STYLE: "true"  # required for most S3-compatible providers

STORAGE_DRIVER: azure
AZURE_STORAGE_ACCOUNT_NAME: "your-account"
AZURE_STORAGE_ACCOUNT_KEY: "your-key"
AZURE_STORAGE_CONTAINER: "docmost-attachments"

Deploying the stack

Once you have your compose file ready (and .env file if using that approach), deploy with:

docker compose up -d

This pulls the images, creates the containers, and starts them in the background. First startup takes 60-90 seconds because Docmost runs database migrations before accepting connections.

Note: the command is docker compose (v2 plugin, no hyphen). The old docker-compose (v1) still works as an alias on most systems, but the official docs use the v2 syntax.

Verifying your installation

After docker compose up -d, run these checks:

# All 3 services should show "Up"
docker compose ps

Expected output:

NAME                IMAGE                  STATUS
docmost-app-1       docmost/docmost:latest Up
docmost-db-1        postgres:18            Up
docmost-redis-1     redis:8                Up

Check the application logs for migration progress:

docker compose logs -f docmost

Once you see the app listening on port 3000, test the health endpoint:

curl http://localhost:3000/api/health

Should return OK. Then open your APP_URL in a browser. You should see the setup page to create your admin account.

Reverse proxy and SSL for Docmost

Docmost needs a reverse proxy for TLS termination and domain routing. There’s one critical requirement that catches most people:

Cloudflare Tunnel setup with WebSocket support

Cloudflare Tunnels support WebSocket connections by default. No extra configuration needed. This is the simplest SSL approach.

Go to Access > Tunnels in the Cloudflare dashboard, choose your tunnel, and add a hostname:

• Hostname: docs.yourdomain.com
• Service: http://127.0.0.1:3000

You can also use CloudPanel reverse proxy with Docker for a different approach.

Nginx reverse proxy configuration

For Nginx with Let’s Encrypt SSL (via certbot), create this server block:

server {
    listen 80;
    server_name docs.example.com;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Then get the SSL certificate with certbot:

certbot --nginx -d docs.example.com

The proxy_http_version 1.1, Upgrade, and Connection "upgrade" lines are the mandatory WebSocket headers. Without them, the editor loads read-only.

Traefik integration with Docker labels

If you use Traefik (v3.6+), add these labels to the docmost service in your compose file. Traefik natively supports WebSockets — no extra configuration needed.

  docmost:
    image: docmost/docmost:latest
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.docmost.rule=Host(`docs.example.com`)"
      - "traefik.http.routers.docmost.entrypoints=websecure"
      - "traefik.http.routers.docmost.tls.certresolver=letsencrypt"
      - "traefik.http.services.docmost.loadbalancer.server.port=3000"
    # ... rest of service config

For a full Traefik setup with Docker, see Traefik as a reverse proxy in Docker.

Upgrading your Docmost Docker installation

If you’re running an older version of Docmost, upgrading is usually straightforward:

cd ~/docmost
docker compose pull
docker compose up -d

This pulls the latest images and restarts the containers. Docmost handles database migrations automatically on startup.

Backup and restore for your self-hosted wiki

Backup the database:

docker compose exec db pg_dump -U docmost docmost > docmost-backup-$(date +%Y%m%d).sql

Automate with a cron job (daily at 3 AM):

0 3 * * * cd /path/to/docmost && docker compose exec db pg_dump -U docmost docmost > /backups/docmost-$(date +\%Y\%m\%d).sql

Backup file attachments:

If using local storage (the default), the attachments live in the docmost named volume. Back it up with:

docker run --rm -v docmost_docmost:/data -v /backups:/backup alpine tar czf /backup/docmost-files-$(date +%Y%m%d).tar.gz -C /data .

If using S3 or Azure storage, your attachments are already off-server — just make sure your bucket has versioning enabled.

Restore the database:

docker compose exec -T db psql -U docmost docmost < docmost-backup-20250708.sql

Off-server storage: Copy your backups to a separate server or S3-compatible storage. A backup on the same disk is not a backup.

Troubleshooting common Docmost Docker issues

proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";

openssl rand -hex 32
# Copy the output, replace APP_SECRET in your compose file or .env
docker compose up -d

# Check logs for the exact error
docker compose logs db
docker compose logs docmost

docker compose down -v  # WARNING: deletes all data volumes
# Fix the password in your compose file
docker compose up -d

docker compose ps       # Check if docmost is "Up"
docker compose logs docmost  # Check for startup errors

journalctl -u cloudflared -f

Conclusion

Docmost is a solid self-hosted wiki and documentation platform. With over 21,200 GitHub stars, active development (current version v0.95.0), and a real feature set for team collaboration, it’s one of the strongest Confluence alternatives you can run yourself.

The Docker Compose install is three containers — app, PostgreSQL, and Redis. The main gotchas are:

• APP_SECRET must be 32+ characters (generate with openssl rand -hex 32)
• APP_URL must include https:// for auth cookies to work
• WebSocket headers must be configured in your reverse proxy or the editor is read-only
• Database passwords must match between DATABASE_URL and POSTGRES_PASSWORD

Set up backups from day one. A pg_dump cron job costs nothing and saves you when things go wrong.

For more self-hosted Docker containers for your home server, check out the full list of Docker containers for home server.