Skip to content

About

Hardend private cloud stack with file synch, image hosting, music streaming and password vault. With tight budget in mind.

Topics

Resources

Stars

5 stars

Watchers

0 watching

Forks

Repository files navigation

Personal Cloud

Self-hosted replacements for the usual cloud subscriptions, in one docker compose:

  • Seafile — file sync (replaces Dropbox / iCloud Drive), with client-side encrypted libraries the server cannot read
  • Noodle Gallery — automatic iPhone camera-roll backup (replaces Google / iCloud Photos), with ML search running locally. A rebasing fork of Immich (see Photos: why the Gallery fork)
  • Vaultwarden — password manager with TOTP 2FA, compatible with the official Bitwarden apps and extensions
  • Navidrome — music streaming from your own MP3 library (replaces Spotify / Apple Music for the music you own), with album art, search, playlists, and Instant Mix and mood playlists from what the tracks sound like; works with any Subsonic player on Mac, Windows and iPhone. New music is uploaded from a browser and tagged by beets

behind a single Caddy reverse proxy with automatic HTTPS. The same base compose file runs locally and on a real server.

Configuration decisions are documented where they take effect — in the compose files, the Caddyfile, the env templates and the scripts. This README covers what the stack does and how to run it.

What this stack focuses on

  • Low running cost. Sized for a 4 GB VPS; the bulk photo/file blobs go on a CIFS share — a Hetzner Storage Box costs ≈ €3.20/TB vs ≈ €50/TB for block volumes — while databases and hot caches stay on local SSD. A 1 TB setup runs under €10/month.
  • Hardened containers. cap_drop: ALL, no-new-privileges and pinned images everywhere; 10 of 11 services run a read-only root filesystem, most non-root. Databases sit on egress-blocked internal networks, only Caddy publishes host ports, and admin passwords stay out of the runtime container environment.
  • Acceptance tests against the real client APIs. ./scripts/verify.sh hits the same endpoints the official clients use — including a small Bitwarden crypto client that registers an account, stores an encrypted secret, decrypts it back and enables 2FA.
  • The production storage path is testable locally. A throwaway Samba container stands in for the Storage Box, so docker compose up exercises the same CIFS mount path as production, transport encryption included.
  • Scripted operations. Daily consistent backups, a weekly check that proves them restorable, a watchdog that recovers a wedged CIFS mount, and a scripted restore.
                         ┌───────── Caddy (auto-HTTPS, only ingress) ─────────┐
  https://seafile.…    → │  seafile-server ─ seafile-db (mariadb) / -redis    │
       …/notification  → │    └ notification-server (real-time push, ws)      │
  https://immich.…     → │  immich-server ─ immich-db / immich-redis / -ml    │
  https://vault.…      → │  vaultwarden (sqlite)                              │
  https://music.…      → │  navidrome (sqlite) ─ navidrome-sonic (similarity) │
       …/upload        → │    └ navidrome-upload (tus uploads, beets)         │
                         └────────────────────────────────────────────────────┘
   databases live on internal-only networks · only Caddy publishes host ports

Production deployment

You need: a Linux host with Docker + Compose (4 GB RAM is enough), a CIFS share for the bulk storage (e.g. a Hetzner Storage Box with SMB enabled, in the same location as the server — traffic between them is free), and a domain with four names you can point at the server.

Production adds a separate env file (.env.production) and a small overlay (docker-compose.production.yml) that pins the latency-sensitive volumes onto an attached block volume, while the bulk blobs go to the Storage Box. The base docker-compose.yml is unchanged between local and production.

1. Configure. Generate .env.production (runtime secrets) and .env.production.setup (the initial admin accounts), then fill in your domains, the Let's Encrypt email, the Storage Box credentials and DATA_ROOT (a directory on the attached volume):

ENV_FILE=.env.production EXAMPLE=.env.production.example GEN_SB_PASSWORD=0 \
  ./scripts/init.sh             # writes .env.production + .env.production.setup
$EDITOR .env.production          # set domains, CADDY_TLS, SB_*, DATA_ROOT
$EDITOR .env.production.setup    # set the admin email(s) to your real address

Copy both to /root on the server, outside the deploy directory, so a re-deploy never touches or exposes them. .env.production is the only env file the server keeps; .env.production.setup is needed only until the first up (step 5):

scp .env.production .env.production.setup root@<server>:/root/
ssh root@<server> 'chmod 600 /root/.env.production /root/.env.production.setup'

.env.production.setup is setup-only — Compose does not load it at runtime (see Secrets: setup vs runtime). One source points every later command at production:

source scripts/prod.env          # sets COMPOSE_FILE / COMPOSE_ENV_FILES / ENV_FILE

2. DNS. Point each name at the server's public IP with an A record (AAAA too if the host has IPv6); Caddy then obtains and renews Let's Encrypt certs automatically. To deploy before DNS is ready, set CADDY_TLS=internal, then flip it to your email and docker compose up -d caddy once records resolve.

3. Ports / firewall. Expose TCP 80 and 443 only — port 80 for the Let's Encrypt HTTP challenge and the HTTP→HTTPS redirect. Nothing else publishes ports.

4. Prepare the host. One idempotent script installs the packages the backups and the CIFS mount need, adds swap, creates the data directories and Storage Box folders, and installs the systemd timers for the daily backup, the weekly restore check and the mount watchdog:

sudo -E ./scripts/prod-setup.sh

5. Bring it up. The first up adds the setup overlay + setup env file to seed the Seafile admin and open Vaultwarden signups; every later up omits both:

docker compose -f docker-compose.yml -f docker-compose.production.yml \
  -f docker-compose.setup.yml \
  --env-file /root/.env.production --env-file /root/.env.production.setup up -d
# register your Immich + Vaultwarden accounts now in a browser, while the setup overlay is up
./scripts/harden-seafile.sh      # Seahub security settings (after a fresh setup)
./scripts/verify.sh              # acceptance tests
rm /root/.env.production.setup   # setup done; keep it in your offline backup

# Day-to-day afterwards (prod.env already sourced):  docker compose up -d

The first Immich and Vaultwarden accounts work exactly as under Local quick start.

Storage layout

The big, cold blobs go on the CIFS/SMB share; databases and hot caches stay on the server's local SSD.

Never put a database on the Storage Box. Postgres / MariaDB / SQLite need low-latency POSIX locking that SMB cannot provide; they will corrupt or crawl. The split below keeps every database local on purpose.

Data Location Volume(s)
Immich originals + previews (library/, upload/, previews/) Storage Box (CIFS) immich_data
Immich thumbnails / transcoded video local SSD immich_thumbs, immich_encoded
Seafile object store + config (/shared/seafile) Storage Box (CIFS) seafile_box
Seafile logs local SSD seafile_logs
Music library (music/, plain files) Storage Box (CIFS) navidrome_music
Audio-similarity embeddings (rebuildable) local SSD navidrome_sonic_data
Music uploads waiting for import local SSD navidrome_upload_staging
All databases + Vaultwarden + Navidrome local SSD immich_db, seafile_db, vaultwarden_data, navidrome_data

immich-preview-mover is optional. Immich puts both of an asset's derivatives in one directory and separates them by filename, so no mount can split them. The service moves the previews — the large half — to the box and leaves a symlink, so the path Immich stored still resolves and only the thumbnails every grid scroll reads stay on local SSD. Leave it out if the SSD has room; nothing else depends on it. It also deletes previews on the box that nothing points at any more, monthly. To run that pass by hand — it deletes only when given --yes:

docker compose exec immich-preview-mover sh /scripts/immich-preview-mover.sh --reclaim

Mechanism and failure modes: scripts/immich-preview-mover.sh.

Seafile's real metadata — libraries, users, the file tree — lives in MariaDB and stays local; only the object store and config sit on the box.

The SMB3 connection uses transport encryption, so all host↔box traffic is encrypted on the wire. That is transport-only: blobs land on the box in plaintext, so snapshots hold plaintext and a restore needs no key. For encryption at rest, use a Seafile encrypted library (true client-side E2EE) or encrypt above the mount. The mount options and the reasoning behind each are in the volumes: block of docker-compose.yml.

Local quick start

Requirements: Docker + Docker Compose, node and python3 on the host (for the verification scripts), outbound internet.

./scripts/init.sh          # generate .env (runtime) + .env.setup (Seafile admin), run once

# FIRST start only — the setup overlay + setup env file seed the Seafile admin
# (and open Vaultwarden signups so you can register your first account):
docker compose -f docker-compose.yml -f docker-compose.storagebox-sim.yml \
  -f docker-compose.setup.yml --env-file .env --env-file .env.setup up -d

# register your Immich + Vaultwarden accounts now in a browser, while the setup
# overlay is up (see below)
./scripts/verify.sh        # run the four acceptance tests

# Day-to-day afterwards is just:  docker compose up -d

The initial Seafile and Navidrome admin passwords are setup-only secrets in .env.setup, which is not loaded at runtime (see Secrets: setup vs runtime). Immich and Vaultwarden store no admin password at all — register their first accounts in the browser.

Local URLs (the *.127.0.0.1.nip.io names resolve to 127.0.0.1 automatically):

App URL Login
Seafile https://seafile.127.0.0.1.nip.io:8443 [email protected] / see .env.setup
Immich https://immich.127.0.0.1.nip.io:8443 register the first account — see below
Vaultwarden https://vault.127.0.0.1.nip.io:8443 register the first account — see below
Navidrome https://music.127.0.0.1.nip.io:8443 admin / see .env.setup

First Immich account. The admin-sign-up page is open until the first admin exists, then closes itself — no toggle needed. Open the Immich URL while the stack is up and create your admin in the browser; nothing is stored on disk. verify.sh skips the photo test with a hint if that admin doesn't exist yet, and prompts for its email + password if it does.

First Vaultwarden account. At runtime Vaultwarden is API-only: signups closed, admin panel off, browser web vault disabled (the URL 404s). The setup overlay turns the web vault and signups back on for the first up — register your account then; the next plain docker compose up -d restores API-only. Daily use is through a Bitwarden browser extension or app pointed at the same server URL. (verify.sh uses its own short-lived toggle and cleans up after itself.)

Locally, Caddy serves its internal CA, so browsers warn about the certificate. Accept the warning, or trust the root — but read the root out of the running container rather than keeping a copy: Caddy silently generates a new CA whenever the caddy_data volume is recreated, and the Caddyfile header explains how a saved copy then goes stale without looking stale.

# curl: read the CA live, no file on disk
curl --cacert <(docker compose exec -T caddy cat /data/caddy/pki/authorities/local/root.crt) \
  https://immich.127.0.0.1.nip.io:8443/api/server/ping

To trust it in the macOS system keychain, use a temp file and delete it again. Re-run after any CA regeneration; add-trusted-cert replaces the previous entry for the same certificate:

docker compose exec -T caddy cat /data/caddy/pki/authorities/local/root.crt > /tmp/caddy-root.crt
sudo security add-trusted-cert -d -r trustRoot \
  -k /Library/Keychains/System.keychain /tmp/caddy-root.crt
rm /tmp/caddy-root.crt

The Storage Box simulator

docker-compose.storagebox-sim.yml runs a throwaway Samba container in place of the Storage Box, so a local docker compose up exercises the exact CIFS mount path production uses — only SB_HOST differs. Its Samba requires SMB encryption, so the local run also proves the encrypted-transport path. It is pulled in automatically by the COMPOSE_FILE line scripts/init.sh writes to .env. Confirm the mounts are real CIFS and encrypted:

docker exec pc-immich-server mount | grep ' /data '
docker exec pc-seafile mount | grep ' /shared/seafile '

What the verification proves

./scripts/verify.sh exercises each app over HTTPS through Caddy:

  1. Vaultwarden – scripts/vw-test.mjs is a tiny Bitwarden client (pure Node crypto: PBKDF2 / AES-CBC+HMAC / RSA): it registers an account, stores an encrypted login item, reads it back and decrypts it, and enables TOTP 2FA.
  2. Immich – logs in as the admin, uploads a photo through POST /api/assets (the endpoint the iOS app uses), then fetches the asset back.
  3. Seafile – logs in via the token API, creates a library, uploads a file and reads back identical bytes (the Web API the desktop/iOS clients use). Encrypted libraries are created in the app, not the API.
  4. Navidrome – logs in with Subsonic token auth, searches for an album, fetches its cover art and streams a track (the API every music client uses), then asks for tracks that sound like it.

Connecting the real clients

  • Seafile (iOS / desktop): server URL = your https://seafile.…, log in as [email protected] (see .env.setup). For E2EE, create an encrypted library and set a library password — it never leaves your device, so the server only ever stores ciphertext. The iOS app prompts for it to unlock.
  • Photos (iOS): App Store → Immich or Noodle Gallery → server URL = your https://immich.…, log in, enable background backup of your camera roll. The fork keeps Immich's API, so either app works; the Gallery app is the one that exposes the fork-only features.
  • Vaultwarden (Bitwarden apps): in any Bitwarden client set Self-hosted → Server URL = your https://vault.…, then log in. The first account is registered during setup (see Local quick start); afterwards Vaultwarden is API-only, so daily use is through the extension or apps. Enable 2FA under Settings → Security → Two-step login.
  • Music (Navidrome): log in at your https://music.… as admin with NAVIDROME_ADMIN_PASSWORD from the setup file. Then point any Subsonic client at the same URL with that login — e.g. Feishin (Mac, Windows), Supersonic (Mac, Windows), play:Sub, Amperfy or substreamer (iPhone). The web player works in any browser.

Music library

Navidrome streams the files in the music/ folder on the Storage Box; it never writes to it (its mount is read-only). Each library is one folder below music/: music/${NAVIDROME_LIBRARY}/ is the default one, and further libraries, such as one per user or a shared one, are sibling folders added under Settings → Libraries. Access is granted per library, so an album is shared by moving its folder into a library the other user can open; each library's default for new users flag decides what a new account sees. Add music by copying files into a library's folder — over SMB, SFTP or rsync, whichever the box offers — in any layout below it. Tags drive artist, album and track order; album art comes from a cover.*, folder.* or front.* image beside the tracks, or from the art embedded in the files.

Uploading from a browser. Logged in to Navidrome as an admin, open https://music.…/upload/, pick a library and drop audio files, folders or zip archives; images are not accepted. Uploads resume after a dropped connection, or when the same file is added again after a reload. beets sorts the tracks into albums by their tags, retags them from MusicBrainz where it is sure of the match, keeps the existing tags otherwise, and files them as Artist/Album; Navidrome then scans just those folders, also when the page was closed. Matched albums get a cover.jpg from the Cover Art Archive, the others show the art embedded in their files. A track already in any library (the same MusicBrainz recording, or the same title, album and artist) is not added again and is listed as skipped; that covers files copied onto the box too, once Navidrome has scanned them. Accepted types, size limits and the checks on uploaded files are in navidrome-upload.

New files appear after the next scan, which runs hourly, or at once with Scan library in the web UI. Files that reach the box from another machine never trigger the kernel's file watcher, which is why the scan is scheduled — see the navidrome service in docker-compose.yml.

Similar tracks and mood playlists. navidrome-sonic analyses the library and serves Instant Mix and per-user mood playlists through its sonic plugin. Navidrome loads the plugin disabled; enable it after the first start and after every plugin update, as Enabling the plugin describes.

Locally, the simulator's share is the storagebox_data volume:

docker run --rm -v private-cloud_storagebox_data:/s -v ~/Music:/in:ro \
  alpine:3.20 cp -r /in/. /s/music/owner/

Email (SMTP)

Outgoing mail is optional and off by default — an empty SMTP_HOST disables it and all three apps run fine without it (you just get no invite, password-reset or notification mail). One credential in the env file covers the stack, but it reaches each app differently, because the images differ:

App How it gets the config
Vaultwarden reads SMTP_* directly as container env vars
Seafile takes no env vars for mail — scripts/harden-seafile.sh writes it
Immich not env-driven — set SMTP in its web UI, stored in Immich's database
Timer alerts scripts/notify-failure.sh sends via curl; needs ALERT_EMAIL too

Set the keys in .env / .env.production, then apply:

docker compose up -d vaultwarden   # Vaultwarden picks it up on recreate
./scripts/harden-seafile.sh        # writes the mail settings into Seahub, restarts Seafile

harden-seafile.sh reads whichever env file ENV_FILE points at, so the password is written down once. Re-run it after any SMTP_* change.

Hardening

Every service: no-new-privileges, cap_drop: ALL plus only the capabilities its image genuinely needs, a pinned image, and no published ports except Caddy's. Databases sit on egress-blocked internal: networks; the unauthenticated immich-ml API is on its own network, reachable only from immich-server. The read-only root filesystem + tmpfs scratch is what satisfies "remove dev tools / package managers": the stock images still ship apt/apk, but nothing can be installed or persisted on a read-only, capability-stripped, no-new-privileges container. Scratch mounts are nosuid, nodev and — wherever the image tolerates it — noexec.

Verified on the live stack:

Service Non-root Read-only rootfs
caddy ✅ uid 1001 + only NET_BIND_SERVICE ✅ yes
vaultwarden ✅ uid 1000 ✅ yes
immich-db ✅ process drops to postgres ✅ yes
seafile-db ✅ process drops to mysql ✅ yes
immich-redis / seafile-redis ✅ uid 999 ✅ yes
immich-server ✅ uid 1000 (node) ✅ yes
seafile-server ⚠️ daemons uid 8000 (NON_ROOT); init/nginx stay root ❌ no
notification-server ✅ uid 8000, zero capabilities ✅ yes
immich-ml ✅ uid 1000 ✅ yes
navidrome ✅ uid 1002, music mounted read-only ✅ yes
navidrome-sonic ✅ uid 1002, music read-only, internal network only ✅ yes
navidrome-upload ✅ uid 1002, Navidrome admins only, uploads checked ✅ yes

seafile-server is the one exception, and a stock-image limitation: the image regenerates config and runs its own nginx across the filesystem. It keeps every other control and drops its data daemons to a non-root uid.

At the ingress, Caddy applies a shared security-header snippet to every site (HSTS, nosniff, a Referrer-Policy that keeps share-link tokens out of third-party Referer headers, Server stripped) and, as the edge, ignores any client-supplied X-Forwarded-For — so a forged header cannot poison the per-client login limiters in Immich and Vaultwarden. Directives and trade-offs are in caddy/Caddyfile.

Immich's admin-sign-up endpoint only ever creates the first admin, so it closes itself once you register. Immich's system settings stay editable in the admin UI rather than pinned to a config file — harden them there if you want.

After a fresh setup, ./scripts/harden-seafile.sh adds what the seafile-mc image won't take from compose environment: — secure cookies, password-strength and login-attempt limits, 2FA availability, bounded share/upload links, outgoing mail — and cuts Seahub's worker count to fit the memory budget. It is idempotent; edit the script, not the files it generates.

On the host, scripts/prod-setup.sh installs fail2ban and turns off X11, TCP and agent forwarding in sshd.

Photos: why the Gallery fork

The photo service runs Noodle Gallery (ghcr.io/open-noodle/gallery-server + -ml) rather than upstream Immich — a friendly fork that rebases onto every Immich release and keeps the same REST API, so the official Immich iOS/Android apps, the CLI and third-party clients all work unchanged. Service names, volumes, IMMICH_* variables, networks and the Caddy route are identical; only the two image names differ.

IMMICH_VERSION therefore carries the fork's version, not Immich's, and each release states the upstream version it is based on. Read the fork's release notes before bumping, and expect a geodata re-import — that boot-time import is what sizes immich-server's memory ceiling, so a version bump is the one routine event that stresses the memory budget.

Resource footprint

Tuned for a 4 GB machine (e.g. a Hetzner CX22). Every long-running service has a hard memory ceiling, so none can balloon and OOM the host; steady-state usage is ≈ 1.3–1.4 GB. The ceilings deliberately over-subscribe, because the peaks do not coincide, and prod-setup.sh adds a swap file so a rare overlap becomes a slowdown rather than an OOM kill. Each ceiling and its tuning (Postgres cache sizes, the ML model TTL, Seahub's worker count, …) is commented at the service it applies to in docker-compose.yml.

Secrets: setup vs runtime

Secrets are split by lifecycle, so the credentials Compose loads on every up never include human-account passwords:

Runtime secrets Setup-only secrets
File (local / prod) .env / /root/.env.production .env.setup / /root/.env.production.setup
Loaded by Compose, on every up only init.sh, verify.sh, and the first up
Contents DB / Redis / Storage Box / JWT machine creds the first Seafile and Navidrome admin accounts

scripts/init.sh generates both (each chmod 600, both gitignored). The base docker-compose.yml never references the setup file, so a normal up puts no admin credentials into any container: Seafile's and Navidrome's first-boot seeding vars live in docker-compose.setup.yml, applied only on the first up. That overlay also opens Vaultwarden's signups and web vault for that one run. Immich and Vaultwarden admins are registered in the browser, so they appear in neither file.

Once your accounts exist, the secret of record is the account itself: store the admin passwords in Vaultwarden and remove the setup file from the server. Runtime never reads it; verify.sh's Seafile and Navidrome logins do, so point SETUP_ENV_FILE at a copy for that run. Keep both files in your offline backup; losing the runtime file means losing the DB/JWT/box credentials.

Operations

docker compose ps                                   # status
docker compose logs -f <service>                    # logs
docker compose down                                 # stop (keeps volumes/data)
docker compose pull && docker compose up -d         # update images

What to back up. The fast volumes hold the databases and metadata (in production, under DATA_ROOT on the attached volume) — Seafile is useless without its MariaDB even though its blocks are on the box. The bulk blobs live on the Storage Box, and a live mount is not a backup: enable the box's scheduled snapshots so a deletion or ransomware event is recoverable. The env files hold the secrets — back them up securely and separately.

Automated backup (scripts/backup.sh): writes consistent dumps of the attached-volume state (Immich's Postgres, Seafile's three MariaDB databases, Vaultwarden's and Navidrome's SQLite + data folders, Caddy's TLS material) to the Storage Box, verifying each artifact before it replaces the previous one. It keeps a single latest set and relies on the box's free snapshots for dated history (so enable those); the bulk blobs are already on the box and are not re-copied. prod-setup.sh installs and enables the daily systemd timer:

systemctl list-timers pc-backup.timer        # next run (default 03:30 daily)
journalctl -u pc-backup.service -n 20         # last run
source scripts/prod.env && sudo -E ./scripts/backup.sh   # run on demand

Restore (scripts/restore.sh): reverses the backup, stopping only the services it touches. It is destructive, so it prompts for confirmation unless you pass --yes; restore a subset with ./scripts/restore.sh vaultwarden --yes:

source scripts/prod.env
sudo -E ./scripts/restore.sh --check        # verify-only: checksums + a trial load
                                            # of the dumps, WITHOUT changing anything
sudo -E ./scripts/restore.sh --yes          # restore everything

Restore check (restore.sh --check): a backup that exists but does not restore is worth nothing, so --check also runs on its own weekly timer (Sundays 05:00), installed by prod-setup.sh. It verifies checksums and gzip, loads the Immich dump into a throwaway scratch database, and integrity-checks the Vaultwarden and Navidrome SQLite snapshots — changing nothing live:

systemctl list-timers pc-restore-check.timer      # next run
journalctl -u pc-restore-check.service -n 20      # last result
systemctl start pc-restore-check.service          # check on demand

The scratch load runs inside the live pc-immich-db, which is why this is weekly rather than nightly, and why the check skips itself when DATA_ROOT has under 6 GB free (a skip exits 0 and says so in the journal).

Failed-timer alerts. With SMTP_HOST and ALERT_EMAIL both set, a failed pc-backup or pc-restore-check run mails you the unit's status and the tail of its journal, via OnFailure= and [email protected]. Leave either key empty and nothing is sent — the same off-by-default switch as the rest of the mail config. No MTA is installed; curl speaks SMTP directly.

Storage Box mount watchdog (scripts/mount-watchdog.sh): the kernel CIFS mount can wedge when the Storage Box migrates — the mount dies while the app still answers, so requests 502 silently. The Seafile and Immich healthchecks stat a path under the mount so a wedge reads as unhealthy, and a host systemd timer restarts a wedged container every 60s. Three consecutive failed recovery attempts mail an alert, once per incident, under the same SMTP_HOST + ALERT_EMAIL switch as the rest. prod-setup.sh installs and enables the timer; events go to the journal:

journalctl -u pc-mount-watchdog.service -n 20    # recent checks / restarts

Files

docker-compose.yml                 all services, hardening, networks, volumes
docker-compose.production.yml      overlay: fast volumes onto the attached volume
docker-compose.storagebox-sim.yml  overlay: local Samba stand-in for the Storage Box
docker-compose.setup.yml           overlay: first `up` only — seed admin, open signups
.env.example                       local config template      → .env
.env.production.example            production config template → .env.production
.env.setup.example                 setup-only secrets         → .env[.production].setup
caddy/Caddyfile                    reverse proxy + automatic HTTPS
scripts/init.sh                    generate the env files with fresh secrets
scripts/prod.env                   source to point compose + scripts at production
scripts/prod-setup.sh              one-time host prep (packages, swap, dirs, timers, sshd)
scripts/deploy.sh                  copy the working tree to the host and reconcile
scripts/backup.sh                  consistent backup to the Storage Box (daily timer)
scripts/restore.sh                 restore from it (--check verifies, weekly timer)
scripts/mount-watchdog.sh          recover a wedged CIFS mount (60s timer)
scripts/immich-preview-mover.sh    move Immich previews to the box, symlink them back
scripts/notify-failure.sh          mail an alert when a timer's unit fails
scripts/harden-seafile.sh          Seahub security settings + worker count (idempotent)
scripts/verify.sh                  the four acceptance tests + an env-file lint
scripts/vw-test.mjs                Bitwarden-client crypto for the password test
scripts/systemd/                   units for the backup, restore-check + watchdog timers
AGENTS.md                          conventions + decisions for changing this repo
CHANGES.md                         release history of this repo
LICENSE                            MIT — applies to this repo, not to the images

License

This repository — the compose files, Caddyfile, scripts and docs — is MIT licensed.

That covers the orchestration only. The applications it runs are separate projects, pulled as prebuilt container images (navidrome-sonic and navidrome-upload are built on the host from their repositories) and never redistributed here; each keeps its own license:

Component License
Noodle Gallery (Immich fork) AGPL-3.0
Seafile Community Edition (server core) AGPL-3.0
Vaultwarden AGPL-3.0
Navidrome GPL-3.0
navidrome-sonic GPL-3.0; models CC BY-NC-SA 4.0
navidrome-upload, beets, tusd, Uppy MIT
Caddy Apache-2.0
MariaDB GPL-2.0
Valkey BSD-3-Clause

Running those images does not put your copy of this configuration under their terms, but modifying and distributing the applications themselves does.

About

Hardend private cloud stack with file synch, image hosting, music streaming and password vault. With tight budget in mind.

Topics

Resources

Stars

5 stars

Watchers

0 watching

Forks

Releases

Contributors

Languages