Skip to content

The only tool you need to know what is happening and how to fix it.

add: duckdb docker

dduxac4882df517e
diff --git a/.github/workflows/release-traceway.yml b/.github/workflows/release-traceway.yml
index cc081070..362a958f 100644
--- a/.github/workflows/release-traceway.yml
+++ b/.github/workflows/release-traceway.yml
@@ -228,6 +228,23 @@ jobs:
cache-from: type=gha
cache-to: type=gha,mode=max
+ # amd64 only: DuckDB links prebuilt glibc static libraries via CGO, so the
+ # arm64 variant would have to compile under QEMU emulation, which is
+ # impractically slow. arm64 users build Dockerfile.duckdb natively.
+ - name: Build and push DuckDB image
+ id: docker_build_duckdb
+ uses: docker/build-push-action@v5
+ with:
+ context: .
+ file: ./Dockerfile.duckdb
+ platforms: linux/amd64
+ push: true
+ tags: |
+ ghcr.io/${{ github.repository_owner }}/traceway:v${{ inputs.version }}-duckdb
+ ghcr.io/${{ github.repository_owner }}/traceway:duckdb
+ cache-from: type=gha
+ cache-to: type=gha,mode=max
+
- name: Install Cosign
uses: sigstore/cosign-installer@v3
with:
@@ -251,6 +268,12 @@ jobs:
run: |
cosign sign --yes ghcr.io/${{ github.repository_owner }}/traceway@${{ steps.docker_build_sqlite.outputs.digest }}
+ - name: Sign DuckDB image
+ env:
+ COSIGN_EXPERIMENTAL: 1
+ run: |
+ cosign sign --yes ghcr.io/${{ github.repository_owner }}/traceway@${{ steps.docker_build_duckdb.outputs.digest }}
+
- name: Summary
run: |
echo "### Docker Images (signed with Cosign)" >> "$GITHUB_STEP_SUMMARY"
@@ -264,6 +287,9 @@ jobs:
echo "**SQLite Image** (embedded SQLite, single binary, no dependencies):" >> "$GITHUB_STEP_SUMMARY"
echo "\`ghcr.io/${{ github.repository_owner }}/traceway:v${{ inputs.version }}-sqlite\`" >> "$GITHUB_STEP_SUMMARY"
echo "" >> "$GITHUB_STEP_SUMMARY"
- echo "All images tagged with version, plus \`latest\`, \`minimal\`, and \`sqlite\` respectively." >> "$GITHUB_STEP_SUMMARY"
+ echo "**DuckDB Image** (embedded SQLite main DB + DuckDB columnar telemetry, no dependencies):" >> "$GITHUB_STEP_SUMMARY"
+ echo "\`ghcr.io/${{ github.repository_owner }}/traceway:v${{ inputs.version }}-duckdb\`" >> "$GITHUB_STEP_SUMMARY"
+ echo "" >> "$GITHUB_STEP_SUMMARY"
+ echo "All images tagged with version, plus \`latest\`, \`minimal\`, \`sqlite\`, and \`duckdb\` respectively." >> "$GITHUB_STEP_SUMMARY"
echo "" >> "$GITHUB_STEP_SUMMARY"
echo "See [DOCKER_SIGNATURES.md](https://github.com/${{ github.repository }}/blob/${{ github.ref_name }}/DOCKER_SIGNATURES.md) to verify image signatures." >> "$GITHUB_STEP_SUMMARY"
diff --git a/docker-compose.duckdb.yml b/docker-compose.duckdb.yml
new file mode 100644
index 00000000..258b7985
--- /dev/null
+++ b/docker-compose.duckdb.yml
@@ -0,0 +1,48 @@
+services:
+ traceway:
+ build:
+ context: .
+ dockerfile: Dockerfile.duckdb
+ ports:
+ - "80:80"
+ environment:
+ JWT_SECRET: "change-this-to-a-secure-secret-at-least-32-chars"
+ # APP_BASE_URL: "https://traceway.example.com"
+
+ # DuckDB sizes its memory budget from host RAM, not the container limit.
+ # On any memory-capped deployment set this to roughly half the
+ # container's RAM or the backend gets OOM-killed under ingest.
+ DUCKDB_MEMORY_LIMIT: "2GB"
+ # DUCKDB_THREADS: "4"
+ # Raise under sustained ingest to reduce WAL checkpoint stalls; costs a
+ # larger WAL and longer restart replay. DuckDB default is 16MB.
+ # DUCKDB_CHECKPOINT_THRESHOLD: "256MB"
+
+ # Optional retention knobs. Defaults are 30 days; set to "0" to disable.
+ # SQLITE_RETENTION_DAYS prunes telemetry rows (DuckDB telemetry included);
+ # SESSION_RECORDING_RETENTION_DAYS cleans on-disk recordings under
+ # STORAGE_PATH/recordings/. Both run hourly and on startup. The recording
+ # cleanup has no effect when STORAGE_TYPE=s3.
+ # SQLITE_RETENTION_DAYS: "30"
+ # SESSION_RECORDING_RETENTION_DAYS: "30"
+
+ # Optional: store blobs (source maps, session recordings, AI traces) in S3
+ # instead of the local /data/storage folder.
+ # STORAGE_TYPE: "s3"
+ # S3_BUCKET: "your-bucket"
+ # S3_REGION: "us-east-1"
+ # S3_ACCESS_KEY: "your-access-key"
+ # S3_SECRET_KEY: "your-secret-key"
+ # S3_ENDPOINT: "https://s3.example.com" # for MinIO / R2 / Spaces
+ volumes:
+ - traceway-data:/data
+ restart: unless-stopped
+ healthcheck:
+ test: ["CMD", "wget", "-qO-", "http://localhost/health"]
+ interval: 30s
+ timeout: 3s
+ start_period: 5s
+ retries: 3
+
+volumes:
+ traceway-data:
diff --git a/docs/components/DeploymentCards.jsx b/docs/components/DeploymentCards.jsx
index 1d20fda9..ba4e599a 100644
--- a/docs/components/DeploymentCards.jsx
+++ b/docs/components/DeploymentCards.jsx
@@ -30,6 +30,13 @@ const DEPLOYMENTS = [
description:
"Single Alpine container with embedded SQLite. No external databases needed. Optional S3 for source maps and recordings.",
},
+ {
+ title: "DuckDB",
+ href: "/server/duckdb",
+ subtitle: "Backend + Frontend + SQLite + DuckDB",
+ description:
+ "Single Debian container with a columnar telemetry store. Same zero-dependency setup as SQLite with far more dashboard headroom.",
+ },
{
title: "Local Setup",
href: "/server/local-setup",
diff --git a/docs/pages/learn/build-tags.mdx b/docs/pages/learn/build-tags.mdx
index cce7ba07..0fd6e236 100644
--- a/docs/pages/learn/build-tags.mdx
+++ b/docs/pages/learn/build-tags.mdx
@@ -8,16 +8,16 @@ The Traceway backend uses Go build tags to switch between storage backends and t
| Tag | Purpose |
|-----|---------|
-| *(none)* / `telemetry_sqlite` | **SQLite** telemetry store — embedded mode. This is the default; `telemetry_sqlite` is accepted as an explicit no-op spelling. |
-| `telemetry_duckdb` | **DuckDB** telemetry store — embedded mode with a columnar engine for much faster dashboard analytics. Requires `CGO_ENABLED=1`. |
-| `telemetry_ch` | **ClickHouse** telemetry store — standalone server mode. |
+| *(none)* / `telemetry_sqlite` | **SQLite** telemetry store: embedded mode. This is the default; `telemetry_sqlite` is accepted as an explicit no-op spelling. |
+| `telemetry_duckdb` | **DuckDB** telemetry store: embedded mode with a columnar engine for much faster dashboard analytics. Requires `CGO_ENABLED=1`. |
+| `telemetry_ch` | **ClickHouse** telemetry store: standalone server mode. |
### Transactional axis
| Tag | Purpose |
|-----|---------|
| *(none)* / `transactional_sqlite` | **SQLite** main database. This is the default; `transactional_sqlite` is accepted as an explicit no-op spelling. |
-| `transactional_pg` | **PostgreSQL** main database — standalone server mode. |
+| `transactional_pg` | **PostgreSQL** main database: standalone server mode. |
### Other
@@ -27,7 +27,7 @@ The Traceway backend uses Go build tags to switch between storage backends and t
## Supported combinations
-Only three combinations are supported, enforced by compile-time guard files in `backend/app/db/` — an unsupported combination fails the build with a descriptive identifier in the error message:
+Only three combinations are supported, enforced by compile-time guard files in `backend/app/db/`; an unsupported combination fails the build with a descriptive identifier in the error message:
| Mode | Tags | Databases |
|------|------|-----------|
@@ -41,7 +41,7 @@ The legacy `pgch` and `duckdb` tags were renamed to this scheme; passing them fa
### Embedded mode (SQLite)
-No tags needed — a plain `go build` gives you the embedded SQLite backend:
+No tags needed: a plain `go build` gives you the embedded SQLite backend:
```bash
cd backend && go build ./cmd/traceway
@@ -55,7 +55,7 @@ This is what library consumers get when they `go get github.com/tracewayapp/trac
cd backend && CGO_ENABLED=1 go build -tags telemetry_duckdb ./cmd/traceway
```
-DuckDB links prebuilt glibc static libraries, so this build needs CGO and a glibc-based image (Debian, not Alpine) when containerized — see `Dockerfile.duckdb`.
+DuckDB links prebuilt glibc static libraries, so this build needs CGO and a glibc-based image (Debian, not Alpine) when containerized; see `Dockerfile.duckdb` and the [DuckDB deployment guide](/server/duckdb).
### Standalone server (ClickHouse + PostgreSQL)
@@ -65,15 +65,18 @@ cd backend && go build -tags "transactional_pg telemetry_ch" ./cmd/traceway
Requires `CLICKHOUSE_SERVER`, `POSTGRES_HOST`, and the other environment variables to be configured.
-### Docker image
+### Docker images
-The Dockerfiles build the frontend and embed it into the Go binary with the standalone tags:
+Each Dockerfile pairs one of the supported tag combinations with a SvelteKit frontend build that gets embedded into the Go binary from `static/frontend/`:
-```bash
-go build -tags "transactional_pg telemetry_ch" ./cmd/traceway
-```
+| Dockerfile | Build tags | Published image |
+|------------|-----------|-----------------|
+| `Dockerfile` | `transactional_pg telemetry_ch` | `ghcr.io/tracewayapp/traceway:latest` (all-in-one: ClickHouse + PostgreSQL + backend under supervisord) |
+| `Dockerfile.minimal` | `transactional_pg telemetry_ch` | `ghcr.io/tracewayapp/traceway:minimal` (backend only, external ClickHouse/PostgreSQL) |
+| `Dockerfile.sqlite` | *(none)* | `ghcr.io/tracewayapp/traceway:sqlite` (embedded SQLite, Alpine, CGO-free) |
+| `Dockerfile.duckdb` | `telemetry_duckdb` | `ghcr.io/tracewayapp/traceway:duckdb` (SQLite main + DuckDB telemetry, Debian) |
-The frontend is embedded from `static/frontend/` which the Docker build populates from the SvelteKit build output. You don't need to embed the frontend for local development — run the frontend dev server separately with `cd frontend && npm run dev`.
+You don't need to embed the frontend for local development; run the frontend dev server separately with `cd frontend && npm run dev`.
## Running Tests
diff --git a/docs/pages/learn/contributing.mdx b/docs/pages/learn/contributing.mdx
index 350111e9..dfc796e8 100644
--- a/docs/pages/learn/contributing.mdx
+++ b/docs/pages/learn/contributing.mdx
@@ -62,9 +62,9 @@ Traceway uses Go build tags to switch between storage backends:
| Tag | Purpose |
|-----|---------|
-| *(none)* | **SQLite** — embedded mode, zero dependencies. This is the default. |
-| `telemetry_duckdb` | **DuckDB telemetry** — embedded mode with a columnar telemetry store. Requires `CGO_ENABLED=1`. |
-| `transactional_pg telemetry_ch` | **ClickHouse + PostgreSQL** — standalone server mode. |
+| *(none)* | **SQLite**: embedded mode, zero dependencies. This is the default. |
+| `telemetry_duckdb` | **DuckDB telemetry**: embedded mode with a columnar telemetry store. Requires `CGO_ENABLED=1`. |
+| `transactional_pg telemetry_ch` | **ClickHouse + PostgreSQL**: standalone server mode. |
| `localdist` | Embeds the pre-built frontend into the Go binary. Used in Docker builds. |
See the [Build Tags](/learn/build-tags) page for more details.
@@ -201,7 +201,7 @@ Two separate auth systems:
### Backend Patterns
-**Repositories** are singletons (`var FooRepository = &fooRepository{}`) organized on the two storage axes. Telemetry repositories have one implementation per backend under `backend/app/repositories/telemetry/{clickhouse,sqlite,duckdb}/`, selected by the `telemetry_*` build tags; transactional (relational) repositories live under `backend/app/repositories/transactional/{pg,sqlite}/`, selected by the `transactional_*` build tags. Each axis is re-exported through its facade package — callers import `app/repositories/telemetry` or `app/repositories/transactional` (e.g. `telemetry.SpanRepository`, `transactional.UserRepository`) and never a backend package directly.
+**Repositories** are singletons (`var FooRepository = &fooRepository{}`) organized on the two storage axes. Telemetry repositories have one implementation per backend under `backend/app/repositories/telemetry/{clickhouse,sqlite,duckdb}/`, selected by the `telemetry_*` build tags; transactional (relational) repositories live under `backend/app/repositories/transactional/{pg,sqlite}/`, selected by the `transactional_*` build tags. Each axis is re-exported through its facade package; callers import `app/repositories/telemetry` or `app/repositories/transactional` (e.g. `telemetry.SpanRepository`, `transactional.UserRepository`) and never a backend package directly.
**Controllers** use the Gin framework. PostgreSQL operations go through `middleware.Transactional` for automatic commit/rollback.
@@ -307,7 +307,7 @@ All pull requests require **at least one approving review** before merging. This
### What reviewers look at
- **Correctness** — does the code do what the PR says it does?
-- **Testing** — are the requirements in "Before submitting" met? Repository changes need the ClickHouse + PostgreSQL Docker tests to pass.
+- **Testing**: are the requirements in "Before submitting" met? Repository changes need the ClickHouse + PostgreSQL Docker tests to pass.
- **Patterns** — does the change follow the conventions in [CLAUDE.md](https://github.com/tracewayapp/traceway/blob/main/CLAUDE.md)? Reviewers will push back on divergence from established patterns.
- **Scope** — is the PR focused? A small, focused PR is always preferred over one that mixes unrelated changes.
diff --git a/docs/pages/learn/embedded-mode.mdx b/docs/pages/learn/embedded-mode.mdx
index 5575f8a7..7a452986 100644
--- a/docs/pages/learn/embedded-mode.mdx
+++ b/docs/pages/learn/embedded-mode.mdx
@@ -6,6 +6,8 @@ Embedded mode runs a full Traceway server inside your Go process — using **SQL
This is intended for **local development only**. For production, use the [Docker Compose](/server/docker-compose) or [minimal](/server/minimal) deployment.
+Telemetry storage follows your build tags: a plain `go build` embeds SQLite, and building your app with `-tags telemetry_duckdb` (CGO required) swaps the embedded telemetry store to DuckDB's columnar engine. See [Build Tags](/learn/build-tags).
+
<Callout type="info">
**Want to see it in action?** Check out the [full working example on
GitHub](https://github.com/tracewayapp/traceway/tree/main/examples/embedded-backend-otel)
diff --git a/docs/pages/learn/hardware-requirements.mdx b/docs/pages/learn/hardware-requirements.mdx
index 79198e84..b5a5617a 100644
--- a/docs/pages/learn/hardware-requirements.mdx
+++ b/docs/pages/learn/hardware-requirements.mdx
@@ -54,7 +54,9 @@ We benchmark the single-binary SQLite build on dedicated Hetzner CCX instances,
Where does SQLite actually stop being enough? We pushed the single-binary
build until it fell over and wrote up exactly where the cliff is and why:
[Breaking SQLite Traceway](https://tracewayapp.com/blog/break-sqlite-traceway).
- When you outgrow it, switch to the ClickHouse + PostgreSQL deployment below.
+ When you outgrow it, the DuckDB mode below keeps the single-container shape
+ with far more read headroom, and the ClickHouse + PostgreSQL deployment is
+ the full scale-out path.
</Callout>
### Disk
@@ -63,7 +65,7 @@ SQLite stores telemetry on local disk, so disk is the resource to watch, not RAM
## DuckDB mode (the small one that reads big)
-The DuckDB deployment (`Dockerfile.duckdb`) keeps the single-container shape: the main DB stays SQLite, only the telemetry store becomes DuckDB. You get the same zero-dependency operations with dramatically more read headroom - on a 2 vCPU / 8 GB box the metrics dashboard stays under the 5 s threshold at 100M stored points, where SQLite cliffs around 1M.
+The [DuckDB deployment](/server/duckdb) keeps the single-container shape: the main DB stays SQLite, only the telemetry store becomes DuckDB. You get the same zero-dependency operations with dramatically more read headroom - on a 2 vCPU / 8 GB box the metrics dashboard stays under the 5 s threshold at 100M stored points, where SQLite cliffs around 1M.
Two things differ from the SQLite sizing story:
diff --git a/docs/pages/server/_meta.json b/docs/pages/server/_meta.json
index 782f8e30..1517d254 100644
--- a/docs/pages/server/_meta.json
+++ b/docs/pages/server/_meta.json
@@ -4,6 +4,7 @@
"docker-compose": "Docker Compose",
"minimal": "Minimal Container",
"sqlite": "SQLite",
+ "duckdb": "DuckDB",
"local-setup": "Local Setup",
"storage": "Blob Storage",
"haloy": "Haloy",
diff --git a/docs/pages/server/duckdb.mdx b/docs/pages/server/duckdb.mdx
new file mode 100644
index 00000000..dbde2b7a
--- /dev/null
+++ b/docs/pages/server/duckdb.mdx
@@ -0,0 +1,102 @@
+# DuckDB
+
+The same single-container shape as the [SQLite deployment](/server/sqlite), but with the telemetry store swapped for DuckDB's columnar engine. The main database (users, organizations, projects, notification rules) stays SQLite; endpoints, spans, exceptions, metrics, and logs go into a DuckDB file next to it. No external Postgres or ClickHouse required.
+
+Pick this over the plain SQLite image when your dashboards slow down as data grows: on the same box, DuckDB keeps the dashboard responsive at 10 to 100 times more stored telemetry rows, and columnar compression makes the telemetry file several times smaller for the same data. See [Hardware Requirements](/learn/hardware-requirements#duckdb-mode-the-small-one-that-reads-big) for sizing guidance and benchmark numbers.
+
+Two operational differences from the SQLite image:
+
+- **The image is Debian, not Alpine.** The DuckDB engine links glibc static libraries, so this build cannot run on musl-based images.
+- **Set `DUCKDB_MEMORY_LIMIT` on memory-capped hosts.** DuckDB sizes its memory budget to roughly 80% of what it thinks is host RAM, and inside a container it sees the host, not the container limit. An uncapped DuckDB in a capped container is the one configuration that reliably gets the backend OOM-killed under ingest.
+
+## Quick Start
+
+Pull the pre-built image and run it with a persistent data volume:
+
+```bash
+docker pull ghcr.io/tracewayapp/traceway:duckdb
+
+docker run -d --name traceway \
+ -p 80:80 \
+ -v "$(pwd)/traceway-data:/data" \
+ -e JWT_SECRET="your-jwt-secret-min-32-characters-long" \
+ -e APP_BASE_URL="https://traceway.example.com" \
+ -e DUCKDB_MEMORY_LIMIT="2GB" \
+ ghcr.io/tracewayapp/traceway:duckdb
+```
+
+Set `DUCKDB_MEMORY_LIMIT` to roughly half the memory you give the container. On an uncapped dedicated host you can omit it and let DuckDB tune itself.
+
+After starting, open `http://localhost/register` to create your first account.
+
+## Build from Source
+
+Only needed if you want to run a custom or modified build:
+
+```bash
+docker build -f Dockerfile.duckdb -t traceway:duckdb .
+```
+
+Then use `traceway:duckdb` instead of `ghcr.io/tracewayapp/traceway:duckdb` in the commands above. The build needs CGO, so building outside Docker requires `CGO_ENABLED=1 go build -tags telemetry_duckdb ./cmd/traceway` on a glibc system; see [Build Tags](/learn/build-tags).
+
+## Blob storage
+
+Identical to the SQLite image: blobs (source maps, session recordings, AI traces) go to `/data/storage` by default, or to S3 with `STORAGE_TYPE=s3` plus the `S3_*` variables. See the [SQLite page](/server/sqlite#run-s3-storage) for the S3 example; every flag works the same here.
+
+## Configuration
+
+All [SQLite deployment variables](/server/sqlite#configuration) apply unchanged (`JWT_SECRET`, `APP_BASE_URL`, `SQLITE_PATH`, `STORAGE_*`, `S3_*`, `PORTS`, `SQLITE_RETENTION_DAYS`, `SESSION_RECORDING_RETENTION_DAYS`). The retention worker prunes the DuckDB telemetry tables on the same `SQLITE_RETENTION_DAYS` schedule and issues a `CHECKPOINT` afterwards so deleted rows are actually reclaimed from disk.
+
+On top of those, the DuckDB engine has three knobs:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `DUCKDB_MEMORY_LIMIT` | *(unset, DuckDB auto-tunes to ~80% of host RAM)* | Memory budget for the telemetry engine, e.g. `2GB`. Set it explicitly in any memory-capped container, to roughly half the container's RAM. |
+| `DUCKDB_THREADS` | *(unset, DuckDB uses all cores)* | Caps the engine's thread count, e.g. `4`. Useful on shared hosts. |
+| `DUCKDB_CHECKPOINT_THRESHOLD` | *(unset, DuckDB default 16MB)* | WAL size that triggers a checkpoint, e.g. `256MB`. Raise it under sustained ingest to reduce checkpoint stalls; the cost is a larger WAL on disk and a longer replay after a restart. |
+
+## Persistence
+
+Mount a host folder or a named volume at `/data` to keep everything across restarts:
+
+```
+/data/
+├── traceway.db # users, organizations, projects, ... (SQLite)
+├── traceway.db-wal # SQLite WAL
+├── traceway.db-shm # SQLite shared memory
+├── traceway_telemetry.duckdb # endpoints, exceptions, spans, metrics, ... (DuckDB)
+├── traceway_telemetry.duckdb.wal # DuckDB WAL
+└── storage/ # source maps, session recordings, AI traces (when STORAGE_TYPE=local)
+```
+
+Backup tip: the main database supports a hot backup with `sqlite3 traceway.db ".backup '/path/to/backup.db'"`. For the telemetry file, stop the container and copy `traceway_telemetry.duckdb` together with its `.wal` file; the WAL is required for crash recovery.
+
+## Switching from the SQLite image
+
+The two images share the same main database file, so users, projects, tokens, and settings carry over when you point the DuckDB image at an existing `/data` volume. Telemetry does not: the DuckDB image starts a fresh `traceway_telemetry.duckdb`, and the rows in the old `traceway_telemetry.db` are not migrated. Old telemetry ages out of view and the old file can be deleted once you no longer need it. Switching back to the SQLite image behaves the same way in reverse.
+
+## Access Points
+
+| URL | Description |
+|-----|-------------|
+| `http://localhost/` | Frontend dashboard |
+| `http://localhost/api/*` | Backend API |
+| `http://localhost/health` | Health check |
+| `http://localhost/api/health/deep` | Telemetry store introspection (authenticated): dropped rows, insert failures, db/WAL size, engine memory |
+
+## Useful Commands
+
+```bash
+# View logs
+docker logs traceway
+docker logs -f traceway
+
+# Enter container shell
+docker exec -it traceway bash
+
+# Health check
+curl http://localhost/health
+
+# Stop and remove (data survives in the mounted volume)
+docker stop traceway && docker rm traceway
+```
diff --git a/docs/pages/server/sqlite.mdx b/docs/pages/server/sqlite.mdx
index dab84c69..34d8b457 100644
--- a/docs/pages/server/sqlite.mdx
+++ b/docs/pages/server/sqlite.mdx
@@ -2,6 +2,8 @@
Smallest possible Traceway deployment: a single Alpine container that uses SQLite for both the main database and telemetry, with the frontend embedded into the Go binary. No external Postgres or ClickHouse required. Blob storage (source maps, session recordings, AI traces) is written to a local folder by default and can optionally be backed by S3.
+If your dashboards slow down as telemetry grows, the [DuckDB deployment](/server/duckdb) keeps this exact single-container setup but swaps the telemetry store for a columnar engine with far more read headroom.
+
All persistent state — both SQLite database files and blob storage — lives under `/data`. Bind-mount that single folder to keep your data across restarts.
## Quick Start