Dawarich with Docker Compose

What Dawarich needs

Only figures Dawarich's own documentation publishes, each linked to the page it is on. Where the project gives no number, this page does not invent one.

On top of this, Caddy (the reverse proxy in the file) is a single small container. Dawarich itself runs as 4 containers: dawarich-dawarich_redis, dawarich-dawarich_db, dawarich-dawarich_app, dawarich-dawarich_sidekiq.

Which hardware Dawarich has images for

Read from each image's manifest list in its registry (anonymous, read-only) when this page was built. An app counts for a CPU only if every one of its images lists it.

• x86-64 PC or NAS (linux/amd64): every image has a build.
• Raspberry Pi 4/5, 64-bit OS (linux/arm64): no image for dawarich_db. Dawarich's compose file names a second database image in a comment next to postgis/postgis:17-3.5-alpine, which is built for amd64 only: "If you're on ARM architecture, use this image instead", imresamu/postgis:17-3.5-alpine. It carries the same tag, PostgreSQL 17 with PostGIS 3.5 on Alpine, from another publisher. The builder does not write these into the file. Source: Dawarich: docker/docker-compose.yml (the commented ARM image for dawarich_db) checked 2026-10-08
• Raspberry Pi 3 or Zero 2 W, 32-bit OS (linux/arm/v7): no image for dawarich_db. No image for this hardware; the builder leaves the app out.

A manifest says an image exists for a CPU, not how well Dawarich runs on it: a build for arm64 or arm/v7 can still be too slow or need more memory than the board has. The RAM and disk Dawarich publishes are in the table above and, for a whole set of apps against a Raspberry Pi, on Will it run on my machine?. A tag like latest can move to a new digest after the date checked.

docker-compose.yml

This is exactly what the builder writes for Dawarich alone on example.org: the official definition with its published ports removed and Caddy added in front. Every ${VARIABLE} is defined in the .env below.

# docker-compose.yml built at dankhost.com for: Dawarich
# Each app block is its official compose definition. Only the names were prefixed with
# the app slug (services, containers, volumes, bind folders, .env variables) so any set of
# apps can share one file; other differences are listed under "Changed:" in each block.
# Only Caddy publishes ports. Secrets live in .env next to this file.

services:
  # ---- Caddy: the one reverse proxy, HTTPS certificates from Let's Encrypt ----
  # Source: https://caddyserver.com/docs/running (checked 2026-09-23)
  # Source: https://github.com/dani-garcia/vaultwarden/wiki/Using-Docker-Compose (checked 2026-09-23)
  # Caddyfile goes in ./caddy/Caddyfile. Fixed address 172.30.0.2 so apps can trust it exactly.
  caddy:
    image: "caddy:2"
    container_name: "caddy"
    restart: "unless-stopped"
    ports:
      - "80:80"
      - "443:443"
      - "443:443/udp"
    volumes:
      - "./caddy:/etc/caddy"
      - "caddy-data:/data"
      - "caddy-config:/config"
    networks:
      proxy:
        ipv4_address: "172.30.0.2"

  # ---- Dawarich (dawarich.example.org) ----
  # Source: https://github.com/Freika/dawarich/blob/master/docker/docker-compose.yml (checked 2026-10-08)
  # Source: https://dawarich.app/docs/intro (checked 2026-10-08)
  # Source: https://dawarich.app/docs/tutorials/reverse-proxy (checked 2026-10-08)
  # Source: https://dawarich.app/docs/tutorials/backup-and-restore (checked 2026-10-08)
  # Source: https://dawarich.app/docs/FAQ (checked 2026-10-08)
  # Changed: Removed the documented '${DAWARICH_APP_PORT:-3000}:3000' port and the four container_names; Caddy reaches dawarich-dawarich_app:3000 on the proxy network. Inside this app's own network the services keep their documented names, so dawarich_db and dawarich_redis resolve as in the file.
  #          Every ${VAR:-default} of the file is written out as its default, except two: the database password (password in the file) and SECRET_KEY_BASE (CHANGE_ME) are generated in .env; POSTGRES_PASSWORD and DATABASE_PASSWORD read the same value.
  #          As the reverse-proxy page asks, APPLICATION_HOSTS starts with the domain, dawarich.example.org, without http:// or https://, followed by the file's localhost,::1,127.0.0.1, in the app and the sidekiq service.
  #          Dawarich's own network allows outgoing traffic: the sidekiq worker, which is not on the proxy network, looks up places for your points (STORE_GEODATA).
  dawarich-dawarich_redis:
    image: "redis:7.4-alpine"
    container_name: "dawarich-dawarich_redis"
    command: "redis-server --save 900 1 --save 300 10 --appendonly no"
    volumes:
      - "dawarich-dawarich_shared:/data"
    restart: "always"
    healthcheck:
      test:
        - "CMD"
        - "redis-cli"
        - "--raw"
        - "incr"
        - "ping"
      interval: "10s"
      retries: 5
      start_period: "30s"
      timeout: "10s"
    networks:
      dawarich-backend:
        aliases:
          - "dawarich_redis"
  dawarich-dawarich_db:
    image: "postgis/postgis:17-3.5-alpine"
    container_name: "dawarich-dawarich_db"
    shm_size: "1G"
    volumes:
      - "dawarich-dawarich_db_data:/var/lib/postgresql/data"
      - "dawarich-dawarich_shared:/var/shared"
    environment:
      POSTGRES_USER: "postgres"
      POSTGRES_PASSWORD: "${DAWARICH_POSTGRES_PASSWORD}"
      POSTGRES_DB: "dawarich_development"
    restart: "always"
    healthcheck:
      test:
        - "CMD-SHELL"
        - "pg_isready -U postgres -d dawarich_development"
      interval: "10s"
      retries: 5
      start_period: "30s"
      timeout: "10s"
    networks:
      dawarich-backend:
        aliases:
          - "dawarich_db"
  dawarich-dawarich_app:
    image: "freikin/dawarich:latest"
    container_name: "dawarich-dawarich_app"
    volumes:
      - "dawarich-dawarich_public:/var/app/public"
      - "dawarich-dawarich_watched:/var/app/tmp/imports/watched"
      - "dawarich-dawarich_storage:/var/app/storage"
      - "dawarich-dawarich_db_data:/dawarich_db_data"
    stdin_open: true
    tty: true
    entrypoint: "web-entrypoint.sh"
    command:
      - "bin/rails"
      - "server"
      - "-p"
      - "3000"
      - "-b"
      - "::"
    restart: "unless-stopped"
    environment:
      RAILS_ENV: "production"
      REDIS_URL: "redis://dawarich_redis:6379"
      DATABASE_HOST: "dawarich_db"
      DATABASE_PORT: "5432"
      DATABASE_USERNAME: "postgres"
      DATABASE_PASSWORD: "${DAWARICH_POSTGRES_PASSWORD}"
      DATABASE_NAME: "dawarich_development"
      APPLICATION_HOSTS: "dawarich.example.org,localhost,::1,127.0.0.1"
      TIME_ZONE: "Europe/London"
      APPLICATION_PROTOCOL: "http"
      PROMETHEUS_EXPORTER_ENABLED: "false"
      SECRET_KEY_BASE: "${DAWARICH_SECRET_KEY_BASE}"
      RAILS_LOG_TO_STDOUT: "true"
      SELF_HOSTED: "true"
      STORE_GEODATA: "true"
      WEB_CONCURRENCY: "1"
    logging:
      driver: "json-file"
      options:
        max-size: "100m"
        max-file: "5"
    healthcheck:
      test:
        - "CMD-SHELL"
        - "wget -qO - http://127.0.0.1:3000/api/v1/health | grep -q '\"status\"\\s*:\\s*\"ok\"'"
      interval: "10s"
      retries: 30
      start_period: "30s"
      timeout: "10s"
    depends_on:
      dawarich-dawarich_db:
        condition: "service_healthy"
        restart: true
      dawarich-dawarich_redis:
        condition: "service_healthy"
        restart: true
    deploy:
      resources:
        limits:
          cpus: "0.50"
          memory: "4G"
    networks:
      proxy: {}
      dawarich-backend:
        aliases:
          - "dawarich_app"
  dawarich-dawarich_sidekiq:
    image: "freikin/dawarich:latest"
    container_name: "dawarich-dawarich_sidekiq"
    volumes:
      - "dawarich-dawarich_public:/var/app/public"
      - "dawarich-dawarich_watched:/var/app/tmp/imports/watched"
      - "dawarich-dawarich_storage:/var/app/storage"
    stdin_open: true
    tty: true
    entrypoint: "sidekiq-entrypoint.sh"
    command:
      - "sidekiq"
    restart: "unless-stopped"
    environment:
      RAILS_ENV: "production"
      REDIS_URL: "redis://dawarich_redis:6379"
      DATABASE_HOST: "dawarich_db"
      DATABASE_PORT: "5432"
      DATABASE_USERNAME: "postgres"
      DATABASE_PASSWORD: "${DAWARICH_POSTGRES_PASSWORD}"
      DATABASE_NAME: "dawarich_development"
      APPLICATION_HOSTS: "dawarich.example.org,localhost,::1,127.0.0.1"
      BACKGROUND_PROCESSING_CONCURRENCY: "3"
      APPLICATION_PROTOCOL: "http"
      PROMETHEUS_EXPORTER_ENABLED: "false"
      SECRET_KEY_BASE: "${DAWARICH_SECRET_KEY_BASE}"
      RAILS_LOG_TO_STDOUT: "true"
      SELF_HOSTED: "true"
      STORE_GEODATA: "true"
    logging:
      driver: "json-file"
      options:
        max-size: "100m"
        max-file: "5"
    healthcheck:
      test:
        - "CMD-SHELL"
        - "pgrep -f sidekiq"
      interval: "10s"
      retries: 30
      start_period: "30s"
      timeout: "10s"
    depends_on:
      dawarich-dawarich_db:
        condition: "service_healthy"
        restart: true
      dawarich-dawarich_redis:
        condition: "service_healthy"
        restart: true
      dawarich-dawarich_app:
        condition: "service_healthy"
        restart: true
    networks:
      dawarich-backend:
        aliases:
          - "dawarich_sidekiq"

networks:
  # Pinned so the trusted-proxy address given to each app (172.30.0.2) is exact.
  # If "docker compose up" reports "Pool overlaps", change 172.30.0 here, in Caddy's
  # ipv4_address and in every trusted-proxy value to a free 172.x.0 range.
  proxy:
    ipam:
      config:
        - subnet: "172.30.0.0/24"
          ip_range: "172.30.0.128/25"
          gateway: "172.30.0.1"
  dawarich-backend: {}

volumes:
  caddy-data:
  caddy-config:
  dawarich-dawarich_db_data:
  dawarich-dawarich_shared:
  dawarich-dawarich_public:
  dawarich-dawarich_watched:
  dawarich-dawarich_storage:

Caddyfile save as caddy/Caddyfile

Caddy gets and renews the HTTPS certificate for dawarich.example.org by itself once the DNS record points at your server and ports 80 and 443 reach it.

# Caddyfile built at dankhost.com. Save it as ./caddy/Caddyfile next to docker-compose.yml.
# Caddy gets and renews a Let's Encrypt certificate for each name below by itself,
# once the DNS records point at this server and ports 80 and 443 reach it.

# Dawarich
dawarich.example.org {
	reverse_proxy dawarich-dawarich_app:3000
}

Already running nginx, Nginx Proxy Manager, Caddy or Traefik? The reverse-proxy settings Dawarich needs, for all four, each cited to Dawarich's own docs.

.env

The secrets are left blank here on purpose: a password printed on a public page is the same for everyone who copies it. The builder fills them with random letters and digits made in your browser.

# .env for Dawarich, from dankhost.com/app/dawarich/. Fill the blank secrets before starting.
# Keep this file private (chmod 600).

# Dawarich
# 32 random letters and digits: the builder fills this in your browser
DAWARICH_POSTGRES_PASSWORD=
# 128 random letters and digits: the builder fills this in your browser
DAWARICH_SECRET_KEY_BASE=

Changes from the official file

Besides prefixing every service, container, volume, folder and variable with dawarich (so any set of apps can share one file), these are all the differences from what the project documents:

• Removed the documented '${DAWARICH_APP_PORT:-3000}:3000' port and the four container_names; Caddy reaches dawarich-dawarich_app:3000 on the proxy network. Inside this app's own network the services keep their documented names, so dawarich_db and dawarich_redis resolve as in the file.
• Every ${VAR:-default} of the file is written out as its default, except two: the database password (password in the file) and SECRET_KEY_BASE (CHANGE_ME) are generated in .env; POSTGRES_PASSWORD and DATABASE_PASSWORD read the same value.
• As the reverse-proxy page asks, APPLICATION_HOSTS starts with the domain, dawarich.example.org, without http:// or https://, followed by the file's localhost,::1,127.0.0.1, in the app and the sidekiq service.
• Dawarich's own network allows outgoing traffic: the sidekiq worker, which is not on the proxy network, looks up places for your points (STORE_GEODATA).

Notes for Dawarich behind the proxy

• Sign in at https://dawarich.example.org with the default account, demo@dawarich.app and the password safepassword (README), and change both straight away in the account settings: they are the same on every install.
• Phones send their location to this address through one of the apps the README lists (Dawarich for iOS or Android, OwnTracks, Overland, GPSLogger, PhoneTrack, Home Assistant); each needs the API key from your account settings.
• The database image is postgis/postgis:17-3.5-alpine; the file names imresamu/postgis:17-3.5-alpine for ARM machines instead.
• The app container is capped at half a CPU and 4G of memory, the file's defaults; raise deploy.resources.limits for big imports.
• Both app images are on latest.

Back it up

Dawarich's Backup & Restore page: a complete backup is a database dump plus the file volumes (storage, public, watched imports) and Redis, taken with the app, the worker and Redis stopped, and your .env with SECRET_KEY_BASE.

Below is the BACKUP.md the builder writes next to the compose file above: which of its folders and volumes hold data, the dump command the project documents, rewritten for this file's service names, what to copy with which container stopped, and a restore check. Pick more apps in the builder and it covers them all in one file.

# BACKUP.md built at dankhost.com for: Dawarich

What to copy from the docker-compose.yml built with this file, the database dump each project documents (rewritten for the service names in that file), what to copy with which container stopped, and how to check the result. Run every command in the folder that holds docker-compose.yml.

The folders are owned by the containers' users: put sudo in front of tar if it says "Permission denied". Named volumes live under /var/lib/docker/volumes, not next to the compose file, so they are copied through a throwaway ubuntu container (Docker's documented --volumes-from method). tar makes a full copy each run; for large folders an incremental tool (restic, borg, rsync) saves time and space.

Never run "docker compose down -v" on this file: it deletes the named volumes of every app in it.

## Before you start

    BACKUP=/mnt/backup/selfhost   # change this: a disk or machine other than this server's system disk
    mkdir -p "$BACKUP"

## Every time: the three stack files

    tar czf "$BACKUP/stack-files.tar.gz" docker-compose.yml .env caddy

.env holds the database passwords and secret keys the apps were set up with; keep this archive as private as the data.

## Caddy (the reverse proxy)

Caddy's docs: 'The data directory must not be treated as a cache.' It holds the TLS certificates and their private keys; without it Caddy has to ask Let's Encrypt for every certificate again.

- caddy-data (named volume, /data in caddy)
  BACK UP: TLS certificates, private keys, OCSP staples.
- caddy-config (named volume, /config in caddy)
  SKIP: the last active configuration, kept for 'caddy run --resume', which this setup does not use: it starts from the Caddyfile.
- ./caddy (/etc/caddy in caddy)
  IN stack-files.tar.gz: the Caddyfile, copied with the stack files above.

Copy (Caddy keeps serving while you copy):

    docker run --rm --volumes-from caddy -v "$BACKUP":/backup ubuntu tar cvf /backup/caddy-data.tar /data

Restore check:

    tar tf "$BACKUP/caddy-data.tar" > /dev/null && echo OK
    docker run --rm --volumes-from caddy -v "$BACKUP":/backup ubuntu bash -c "cd /data && tar xvf /backup/caddy-data.tar --strip 1"

Sources:
- Caddy docs: Conventions, Data directory: https://caddyserver.com/docs/conventions#data-directory (checked 2026-09-24)
- Docker docs: Volumes, Back up, restore, or migrate data volumes: https://docs.docker.com/engine/storage/volumes/#back-up-restore-or-migrate-data-volumes (checked 2026-09-24)

## Dawarich

Dawarich's Backup & Restore page: a complete backup is a database dump plus the file volumes (storage, public, watched imports) and Redis, taken with the app, the worker and Redis stopped, and your .env with SECRET_KEY_BASE.

What this compose mounts:
- dawarich-dawarich_shared (named volume, /data in dawarich-dawarich_redis)
  OPTIONAL: Redis data: pending and scheduled background jobs, and cache.
- dawarich-dawarich_db_data (named volume, /var/lib/postgresql/data in dawarich-dawarich_db)
  COVERED BY THE COMMAND BELOW: PostgreSQL: accounts, points, trips, settings and attachment records. The page: "Use a database dump, not a copy of a running database's files."
- dawarich-dawarich_shared (named volume, /var/shared in dawarich-dawarich_db)
  OPTIONAL: Redis data: pending and scheduled background jobs, and cache.
- dawarich-dawarich_public (named volume, /var/app/public in dawarich-dawarich_app)
  BACK UP: exports from older releases and custom files; generated assets share it.
- dawarich-dawarich_watched (named volume, /var/app/tmp/imports/watched in dawarich-dawarich_app)
  BACK UP: files waiting for automatic import.
- dawarich-dawarich_storage (named volume, /var/app/storage in dawarich-dawarich_app)
  BACK UP: uploaded imports, generated exports and raw-data archives.
- dawarich-dawarich_db_data (named volume, /dawarich_db_data in dawarich-dawarich_app)
  COVERED BY THE COMMAND BELOW: PostgreSQL: accounts, points, trips, settings and attachment records. The page: "Use a database dump, not a copy of a running database's files."
- dawarich-dawarich_public (named volume, /var/app/public in dawarich-dawarich_sidekiq)
  BACK UP: exports from older releases and custom files; generated assets share it.
- dawarich-dawarich_watched (named volume, /var/app/tmp/imports/watched in dawarich-dawarich_sidekiq)
  BACK UP: files waiting for automatic import.
- dawarich-dawarich_storage (named volume, /var/app/storage in dawarich-dawarich_sidekiq)
  BACK UP: uploaded imports, generated exports and raw-data archives.

1. Stop dawarich-dawarich_app, dawarich-dawarich_sidekiq, dawarich-dawarich_redis. The page stops the web app, the worker and Redis first, "so the database and files cannot change independently".

    docker compose stop dawarich-dawarich_app dawarich-dawarich_sidekiq dawarich-dawarich_redis

2. Database dump for dawarich-dawarich_db:

    docker compose exec -T dawarich-dawarich_db pg_dumpall --clean --if-exists --username=postgres | gzip > "$BACKUP/dump.sql.gz"

   The page's command, with this file's service name.

3. Copy while dawarich-dawarich_app, dawarich-dawarich_sidekiq, dawarich-dawarich_redis are stopped:

    docker run --rm --volumes-from dawarich-dawarich_app -v "$BACKUP":/backup ubuntu tar cvf /backup/dawarich-dawarich_public.tar /var/app/public
    docker run --rm --volumes-from dawarich-dawarich_app -v "$BACKUP":/backup ubuntu tar cvf /backup/dawarich-dawarich_watched.tar /var/app/tmp/imports/watched
    docker run --rm --volumes-from dawarich-dawarich_app -v "$BACKUP":/backup ubuntu tar cvf /backup/dawarich-dawarich_storage.tar /var/app/storage
    docker run --rm --volumes-from dawarich-dawarich_sidekiq -v "$BACKUP":/backup ubuntu tar cvf /backup/dawarich-dawarich_public.tar /var/app/public
    docker run --rm --volumes-from dawarich-dawarich_sidekiq -v "$BACKUP":/backup ubuntu tar cvf /backup/dawarich-dawarich_watched.tar /var/app/tmp/imports/watched
    docker run --rm --volumes-from dawarich-dawarich_sidekiq -v "$BACKUP":/backup ubuntu tar cvf /backup/dawarich-dawarich_storage.tar /var/app/storage

4. Start it again:

    docker compose start dawarich-dawarich_app dawarich-dawarich_sidekiq dawarich-dawarich_redis

Restore check:

    gunzip -c "$BACKUP/dump.sql.gz" | grep -c 'PostgreSQL database cluster dump complete'   # 1 means pg_dumpall finished
    tar tf "$BACKUP/dawarich-dawarich_public.tar" > /dev/null && echo OK
    tar tf "$BACKUP/dawarich-dawarich_watched.tar" > /dev/null && echo OK
    tar tf "$BACKUP/dawarich-dawarich_storage.tar" > /dev/null && echo OK
    tar tf "$BACKUP/dawarich-dawarich_public.tar" > /dev/null && echo OK
    tar tf "$BACKUP/dawarich-dawarich_watched.tar" > /dev/null && echo OK
    tar tf "$BACKUP/dawarich-dawarich_storage.tar" > /dev/null && echo OK

Put a copy back (with dawarich-dawarich_app, dawarich-dawarich_sidekiq, dawarich-dawarich_redis stopped):

    docker run --rm --volumes-from dawarich-dawarich_app -v "$BACKUP":/backup ubuntu bash -c "cd /var/app/public && tar xvf /backup/dawarich-dawarich_public.tar --strip 3"
    docker run --rm --volumes-from dawarich-dawarich_app -v "$BACKUP":/backup ubuntu bash -c "cd /var/app/tmp/imports/watched && tar xvf /backup/dawarich-dawarich_watched.tar --strip 5"
    docker run --rm --volumes-from dawarich-dawarich_app -v "$BACKUP":/backup ubuntu bash -c "cd /var/app/storage && tar xvf /backup/dawarich-dawarich_storage.tar --strip 3"
    docker run --rm --volumes-from dawarich-dawarich_sidekiq -v "$BACKUP":/backup ubuntu bash -c "cd /var/app/public && tar xvf /backup/dawarich-dawarich_public.tar --strip 3"
    docker run --rm --volumes-from dawarich-dawarich_sidekiq -v "$BACKUP":/backup ubuntu bash -c "cd /var/app/tmp/imports/watched && tar xvf /backup/dawarich-dawarich_watched.tar --strip 5"
    docker run --rm --volumes-from dawarich-dawarich_sidekiq -v "$BACKUP":/backup ubuntu bash -c "cd /var/app/storage && tar xvf /backup/dawarich-dawarich_storage.tar --strip 3"

The page restores into a fresh install with the same .env: create the containers without starting the app, copy the file volumes back, start only the database, then load the dump. Its database step with this file's names:

    docker compose up -d dawarich-dawarich_db
    gunzip -c "$BACKUP/dump.sql.gz" | sed "s/SELECT pg_catalog.set_config('search_path', '', false);/SELECT pg_catalog.set_config('search_path', 'public, pg_catalog', true);/g" | docker compose exec -T dawarich-dawarich_db psql --username=postgres
    docker compose up -d

Sources:
- Dawarich docs: Backup & Restore (pg_dumpall, storage, public, watched, redis): https://dawarich.app/docs/tutorials/backup-and-restore (checked 2026-10-08)
- Docker docs: Volumes, Back up, restore, or migrate data volumes: https://docs.docker.com/engine/storage/volumes/#back-up-restore-or-migrate-data-volumes (checked 2026-10-08)

Update it

What docker compose pull does depends only on how each image line in the compose file above is tagged. For Dawarich as this page writes it:

What Dawarich's docs say about updating

Dawarich's introduction, Update your Dawarich instance; the README adds: back up before upgrading. From the folder holding the compose file:

docker compose down
docker compose pull
docker compose up -d

Source: Dawarich docs: Introduction (requirements, setup, update, default credentials) checked 2026-10-08

The steps

1. Back up first, as in Back it up above. An update can migrate Dawarich's data on its first start; the copy is the way back.
2. Download the new images. Running containers are not touched yet:

   docker compose pull

3. Recreate the containers whose image changed. Volumes and bind-mounted folders stay as they are:

   docker compose up -d

4. Watch Dawarich start (Ctrl+C stops following the log, not the app):

   docker compose logs -f dawarich-dawarich_app

5. Optional: remove the old images the pull left without a tag. This covers every stack on the machine, not only this one:

   docker image prune

Docker's reference for these commands: Docker docs: docker compose pull checked 2026-09-30; Docker docs: docker compose up (recreates changed containers, keeps volumes) checked 2026-09-30; Docker docs: docker image prune checked 2026-09-30

Locked out? Reset the admin password

Dawarich's FAQ changes a user's password in the Rails console.

1. Open the Rails console in the app container (the FAQ's "How to enter Dawarich console?", with this file's service name): Source: Dawarich docs: FAQ (Rails console; How to update user's password?) read 2026-10-08; Docker docs: docker compose exec read 2026-10-03

   docker compose exec dawarich-dawarich_app bin/rails console

2. Set the new password for your account (the FAQ's "How to update user's password?"), then leave with exit: Source: Dawarich docs: FAQ (Rails console; How to update user's password?) read 2026-10-08

   User.find_by(email: '<your email>').update(password: '<new password>', password_confirmation: '<new password>')

Run the commands in the folder that holds docker-compose.yml. Words in angle brackets are placeholders: replace them, brackets included. docker compose exec runs the command in the container that is already running: Docker docs: docker compose exec read 2026-10-03

Sources

Every page below was fetched on the date shown.

• Dawarich on GitHub (repository description) checked 2026-10-08 (what it does)
• Dawarich docs: Introduction (requirements, setup, update, default credentials) checked 2026-10-08 (hardware requirements, compose definition and proxy settings, update notes)
• Dawarich: docker/docker-compose.yml (redis, postgis, app, sidekiq) checked 2026-10-08 (compose definition and proxy settings)
• Dawarich docs: Setting Up Reverse Proxy (APPLICATION_HOSTS, nginx example) checked 2026-10-08 (compose definition and proxy settings)
• Dawarich docs: Backup & Restore (pg_dumpall, storage, public, watched, redis) checked 2026-10-08 (compose definition and proxy settings, backup plan)
• Dawarich docs: FAQ (Rails console; How to update user's password?) checked 2026-10-08 (compose definition and proxy settings)
• Caddy docs: Keep Caddy running (Docker Compose section) checked 2026-09-23 (Caddy)
• Vaultwarden wiki: Caddy with HTTP challenge (uses the caddy:2 image) checked 2026-09-23 (Caddy)
• Docker docs: Volumes, Back up, restore, or migrate data volumes checked 2026-10-08 (backup plan)
• Caddy docs: Conventions, Data directory checked 2026-09-24 (backup plan)
• Docker docs: docker compose pull checked 2026-09-30 (update steps)
• Docker docs: docker compose up (recreates changed containers, keeps volumes) checked 2026-09-30 (update steps)
• Docker docs: docker image prune checked 2026-09-30 (update steps)

Add Dawarich to the builder All one hundred apps