Files
PilotVault/Docker-AIO/docker-compose.seaweedfs.split.yml
T
tajniak81andClaude Opus 5.5 3962530841 Docker-AIO: S3 and SeaweedFS variants, matching DriverVault
Docker-AIO gets the same deployment shapes as DriverVault: plain,
SeaweedFS, SeaweedFS split into its roles, and an external S3 endpoint,
each as a build-from-source and a prod compose file with an .env example
of the same name, plus a README. The from-source SeaweedFS files run the
store as side containers; the prod ones build Dockerfile.seaweedfs or
Dockerfile.seaweedfs.split, which bake `weed server -s3` or its five
separate roles into the image under supervisord.

The image is rebuilt around PilotVault's real layout. The old Dockerfile
copied "Web App/ui" and "Web App/main.go", which no longer exist, and
pinned PocketBase 0.22.21, which cannot run the migrations; it now builds
"Web App/web" + "Web App/server" and pins 0.39.11. Unlike DriverVault's
nginx front, the Go BFF keeps serving the UI on 8090. Every process runs
as an unprivileged user, plugins.json gets an /app/data volume, the
container is healthy only when every process answers, and no default
superuser credentials are baked in.

Verified on Docker from an empty database: plain, both SeaweedFS
from-source and both baked prod variants come up healthy, document
uploads land in the bucket and download back. The external-S3 files are
checked with `docker compose config` only.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 18:08:53 +01:00

303 lines
14 KiB
YAML

name: pilotvault-aio
# Single all-in-one container, with SeaweedFS split into its four roles:
# PocketBase + API Server + Web App (Go BFF) in one image, beside master,
# volume, filer, S3 gateway and the SeaweedFS admin UI as separate containers.
# Self-contained — one file, nothing to layer.
#
# cp .env.seaweedfs.split.example .env (then edit it)
# docker compose -f docker-compose.seaweedfs.split.yml up -d --build
#
# The build context is the project root so the Dockerfile can reach both "API
# Server/" and "Web App/".
#
# This is docker-compose.seaweedfs.yml with the storage layer taken apart. `weed
# server -s3` runs master, volume, filer and gateway as goroutines in one
# process; here each is its own container. What that buys:
#
# • the admin UI (weed admin) — a cluster view, and Object Store → Users,
# where S3 identities are created and revoked without touching a file;
# • per-role restart, upgrade and Prometheus metrics;
# • room to add a second volume server later, on this host or another.
#
# What it costs: five containers beside the all-in-one instead of one, and five
# healthchecks to keep the boot order honest. If none of the above is wanted,
# use docker-compose.seaweedfs.yml — the S3 behaviour is identical.
#
# None of them run inside the all-in-one image, for the same reason the single
# gateway does not: keeping the object store in that image, on the volume the
# files are being moved off, would defeat the point and would mean rebuilding.
#
# The on-disk layout is deliberately the same as the single-process file's:
# master, volume and filer share one /data mount, exactly as `weed server -dir`
# lays it out (master raft state, volume .dat/.idx, the filer's filerldb2/ — no
# filename overlap). So the two files are interchangeable on the same volume,
# with no migration either way. A *second* volume server would need its own.
#
# Before turning this on for a stack that already has uploads: PocketBase does
# NOT copy existing files into the bucket. See README.md.
services:
# --- SeaweedFS: master -----------------------------------------------------
# Keeps the volume/topology metadata and hands out file ids. -ip is the name
# the other roles are told to reach it by, so it must be the service name and
# not the container IP the process would otherwise detect.
seaweedfs-master:
image: "${SEAWEED_IMAGE:-chrislusf/seaweedfs:4.45}"
container_name: pilotvault-aio-seaweedfs-master
restart: unless-stopped
command: >
master -ip=seaweedfs-master -ip.bind=0.0.0.0 -mdir=/data
-volumeSizeLimitMB=1024 -metricsPort=9324
volumes:
- seaweed_data:/data
ports:
# Master UI / API. Useful while developing; the admin UI below covers the
# same ground with a nicer face.
- "${SEAWEED_MASTER_PORT:-9333}:9333"
healthcheck:
test: ["CMD-SHELL", "wget -qO- http://127.0.0.1:9333/cluster/status || exit 1"]
interval: 10s
timeout: 3s
retries: 12
start_period: 15s
# --- SeaweedFS: volume server ---------------------------------------------
# Where the bytes actually land. -max=0 lets it size itself from free disk
# rather than the default cap of 8 volumes.
seaweedfs-volume:
image: "${SEAWEED_IMAGE:-chrislusf/seaweedfs:4.45}"
container_name: pilotvault-aio-seaweedfs-volume
restart: unless-stopped
command: >
volume -master=seaweedfs-master:9333 -ip=seaweedfs-volume -ip.bind=0.0.0.0
-port=8080 -dir=/data -max=0 -metricsPort=9325
depends_on:
seaweedfs-master:
condition: service_healthy
volumes:
- seaweed_data:/data
ports:
# This port serves file content by file id with NO authentication — the S3
# credentials do not apply to it. Publish it only where you would be
# willing to publish the bucket itself.
- "${SEAWEED_VOLUME_PORT:-8081}:8080"
healthcheck:
test: ["CMD-SHELL", "wget -qO- http://127.0.0.1:8080/healthz || exit 1"]
interval: 10s
timeout: 3s
retries: 12
start_period: 15s
# --- SeaweedFS: filer ------------------------------------------------------
# Gives the flat volume store a directory tree — buckets, object keys — and
# holds the S3 identities the admin UI writes. -defaultStoreDir is where its
# embedded leveldb goes; without it that would be the container's working
# directory, and the identities would not survive a recreate.
seaweedfs-filer:
image: "${SEAWEED_IMAGE:-chrislusf/seaweedfs:4.45}"
container_name: pilotvault-aio-seaweedfs-filer
restart: unless-stopped
command: >
filer -master=seaweedfs-master:9333 -ip=seaweedfs-filer -ip.bind=0.0.0.0
-port=8888 -defaultStoreDir=/data -metricsPort=9326
depends_on:
seaweedfs-volume:
condition: service_healthy
volumes:
- seaweed_data:/data
ports:
- "${SEAWEED_FILER_PORT:-8888}:8888"
healthcheck:
test: ["CMD-SHELL", "wget -qO- http://127.0.0.1:8888/healthz || exit 1"]
interval: 10s
timeout: 3s
retries: 12
start_period: 15s
# --- SeaweedFS: bucket and identity seed ----------------------------------
# Runs once and exits, before the gateway starts. Two jobs:
#
# 1. create the bucket — PocketBase never issues a CreateBucket of its own;
# 2. write PocketBase's S3 identity into the filer's IAM store.
#
# (2) is why this stack does not set AWS_ACCESS_KEY_ID on the gateway, the way
# docker-compose.seaweedfs.yml does. Those env vars are the *lowest* priority
# credential source in SeaweedFS: they are read only while the filer's store
# is empty, so the first identity added in the admin UI would silently
# displace them and lock PocketBase out. Seeding the store the admin UI itself
# writes leaves one source of truth, and the key PocketBase uses appears under
# Object Store → Users like any other.
#
# Both commands update in place, so every later boot re-applies the values
# from .env and changes nothing else — which is also how a rotated
# PB_S3_SECRET reaches the gateway.
#
# The closing grep is the gate: an empty IAM store means the gateway would
# come up in its allow-anyone default, so this fails loudly instead and the
# gateway below never starts. No `|| true` here, deliberately.
seaweedfs-init:
image: "${SEAWEED_IMAGE:-chrislusf/seaweedfs:4.45}"
container_name: pilotvault-aio-seaweedfs-init
restart: "no"
depends_on:
seaweedfs-filer:
condition: service_healthy
environment:
# Passed as env and expanded by the shell inside the container, so the
# secret stays out of the container's argv.
PB_S3_BUCKET: "${PB_S3_BUCKET:-pilotvault}"
PB_S3_ACCESS_KEY: "${PB_S3_ACCESS_KEY:?set PB_S3_ACCESS_KEY in .env}"
PB_S3_SECRET: "${PB_S3_SECRET:?set PB_S3_SECRET in .env}"
entrypoint: ["/bin/sh", "-c"]
command:
- |
set -e
printf '%s\n' \
"s3.bucket.create -name $$PB_S3_BUCKET" \
"s3.configure -user pilotvault -access_key $$PB_S3_ACCESS_KEY -secret_key $$PB_S3_SECRET -actions Admin -apply" \
| weed shell -master=seaweedfs-master:9333 -filer=seaweedfs-filer:8888
echo "s3.configure" \
| weed shell -master=seaweedfs-master:9333 -filer=seaweedfs-filer:8888 \
| grep -q "$$PB_S3_ACCESS_KEY"
# --- SeaweedFS: S3 gateway -------------------------------------------------
# The endpoint PocketBase talks to. No -config file: with only -filer given,
# credentials come from the filer's IAM store, which is what lets the admin UI
# add and revoke identities without a restart. A config file would take
# priority over that store and make the admin UI's users inert.
seaweedfs-s3:
image: "${SEAWEED_IMAGE:-chrislusf/seaweedfs:4.45}"
container_name: pilotvault-aio-seaweedfs-s3
restart: unless-stopped
command: >
s3 -filer=seaweedfs-filer:8888 -ip.bind=0.0.0.0 -port=8333
-metricsPort=9327
depends_on:
seaweedfs-filer:
condition: service_healthy
# Never serve before an identity exists — see seaweedfs-init above.
seaweedfs-init:
condition: service_completed_successfully
# No published port: the stack reaches the gateway over the compose network.
healthcheck:
test: ["CMD-SHELL", "wget -qO- http://127.0.0.1:8333/healthz || exit 1"]
interval: 10s
timeout: 3s
retries: 12
start_period: 15s
# --- SeaweedFS: admin UI ---------------------------------------------------
# http://localhost:23646 — cluster topology, volumes, buckets, maintenance
# tasks, and Object Store → Users, where S3 access keys are minted and
# revoked. It finds the filer through the master, so -master is all it needs.
#
# An unauthenticated panel that can mint credentials for the bucket *is* the
# bucket, so the password is required rather than defaulted — weed leaves auth
# off entirely when it is empty. It is read from WEED_ADMIN_* rather than a
# flag, which keeps it off the process command line. -dataDir persists the
# session key and the maintenance-task settings.
seaweedfs-admin:
image: "${SEAWEED_IMAGE:-chrislusf/seaweedfs:4.45}"
container_name: pilotvault-aio-seaweedfs-admin
restart: unless-stopped
command: >
admin -port=23646 -master=seaweedfs-master:9333 -dataDir=/data
-metricsPort=9328
depends_on:
seaweedfs-master:
condition: service_healthy
environment:
WEED_ADMIN_USER: "${SEAWEED_ADMIN_USER:-admin}"
WEED_ADMIN_PASSWORD: "${SEAWEED_ADMIN_PASSWORD:?set SEAWEED_ADMIN_PASSWORD in .env}"
volumes:
- seaweed_admin:/data
ports:
- "${SEAWEED_ADMIN_PORT:-23646}:23646"
healthcheck:
test: ["CMD-SHELL", "wget -qO- http://127.0.0.1:23646/health || exit 1"]
interval: 10s
timeout: 3s
retries: 12
start_period: 15s
pilotvault:
build:
# Project root (one level up from this compose file).
context: ..
dockerfile: Docker-AIO/Dockerfile
args:
# Bare name = pass through only when set in the environment, so an unset
# PB_VERSION leaves the Dockerfile pin in place instead of overriding it
# with an empty string (which would resolve "latest" at build time).
- PB_VERSION
image: pilotvault-aio
container_name: pilotvault-aio
restart: unless-stopped
depends_on:
# PocketBase — inside this container — is the process that reads and
# writes the objects, so the gateway has to be serving first, and the
# bucket has to exist before the API Server points PocketBase at it.
seaweedfs-s3:
condition: service_healthy
seaweedfs-init:
condition: service_completed_successfully
environment:
# Superuser (also used by the API Server to authenticate to PocketBase).
POCKETBASE_ADMIN_EMAIL: "${POCKETBASE_ADMIN_EMAIL:?set POCKETBASE_ADMIN_EMAIL in .env}"
POCKETBASE_ADMIN_PASSWORD: "${POCKETBASE_ADMIN_PASSWORD:?set POCKETBASE_ADMIN_PASSWORD in .env}"
# Match CORS to the web origin (only used if a browser calls the API
# directly).
CORS_ALLOW_ORIGINS: "${CORS_ALLOW_ORIGINS:-http://localhost:8090}"
# Probed by the panel status page. The Web App BFF listens on 8090 inside
# this container too. Override WEBAPP_URL in .env to make a change from
# the panel permanent; the panel alone only holds it for the container's
# life.
WEBAPP_URL: "${WEBAPP_URL:-http://127.0.0.1:8090}"
# --- File storage --------------------------------------------------
# supervisord passes these through to the API Server, which writes them
# into PocketBase's settings on every boot, idempotently. Only record
# files move — the document store's blobs. The database and PocketBase's
# own backups stay on pb_data.
PB_S3_ENABLED: "true"
PB_S3_BUCKET: "${PB_S3_BUCKET:-pilotvault}"
# The gateway's service name: a server-to-server call inside the compose
# network.
PB_S3_ENDPOINT: "http://seaweedfs-s3:8333"
# SeaweedFS ignores the region; PocketBase insists on having one.
PB_S3_REGION: "${PB_S3_REGION:-us-east-1}"
PB_S3_ACCESS_KEY: "${PB_S3_ACCESS_KEY}"
PB_S3_SECRET: "${PB_S3_SECRET}"
# Path style, because a self-hosted gateway has no per-bucket DNS.
PB_S3_FORCE_PATH_STYLE: "true"
ports:
- "${WEB_PORT:-8090}:8090" # Web App (Go BFF)
- "${PB_PORT:-8070}:8070" # PocketBase admin UI / API
- "${API_PORT:-8080}:8080" # API Server + panel (root /)
volumes:
# Named volumes by default; set any of them to a host path in .env for a
# bind mount. PB_DATA: the database and PocketBase's backups. API_DATA:
# the API Server's plugins.json (plugin enable-state + config). Back up
# PB_DATA and SEAWEED_DATA together — from here on the documents live in
# the second, not the first.
- "${PB_DATA:-pb_data}:/pb/pb_data"
- "${API_DATA:-api_data}:/app/data"
healthcheck:
# All three processes must answer. Declared here as well as in the image
# so the check is visible, and works against an older pulled image.
test: ["CMD-SHELL", "wget -qO- http://127.0.0.1:8070/api/health >/dev/null && wget -qO- http://127.0.0.1:8080/healthz >/dev/null && wget -qO- http://127.0.0.1:8090/ >/dev/null || exit 1"]
interval: 30s
timeout: 5s
retries: 3
start_period: 60s
volumes:
pb_data:
api_data:
# Shared by master, volume and filer — the same layout `weed server -dir`
# writes, so this file and docker-compose.seaweedfs.yml can swap places on it.
seaweed_data:
# The admin UI's own session key and maintenance-task state. Small, and no
# part of the object store.
seaweed_admin: