This directory contains deployment assets for three distinct use cases:
- contributor-friendly local development;
- production container deployment for self-hosters (Docker Compose);
- production deployment on Kubernetes — see helm/README.md.
| File | Description |
|---|---|
docker-compose.dev.yml |
Local development stack: PostgreSQL, Valkey, RustFS, and optional app containers |
docker-compose.prod.yml |
Production stack: pulls pre-built images from DockerHub, no source checkout required |
docker-compose.e2e.yml |
End-to-end test stack mirroring production topology with fixed test credentials |
.env.dev.example |
Optional environment file for docker-compose.dev.yml (tunnel / custom domain) |
.env.production.example |
Example environment file for manual production deployments |
caddy/ |
Gateway container: Caddyfile (stock caddy:2-alpine image, no custom build needed) |
helm/ |
Kubernetes Helm chart — same stack, deployed via helm install instead of docker compose up |
Service container definitions live with each service:
The easiest way to run Paca without cloning the repository is via the install script
published with each release. It downloads the compose file and Caddyfile, walks you
through configuration interactively (database, storage, networking/HTTPS, AI agent),
generates a .env with strong random secrets, and starts the stack.
curl -fsSL https://github.com/Paca-AI/paca/releases/latest/download/install.sh -o install.sh
bash install.shThe installer supports:
| Option | Description |
|---|---|
| Bundled PostgreSQL | Starts a postgres container (default) |
| External PostgreSQL | Supply a DATABASE_URL; postgres container is suppressed |
| Bundled Valkey | Starts a Valkey container for cache and event streams (default) |
| External Redis/Valkey | Supply a REDIS_URL; valkey container is suppressed |
| Self-hosted RustFS | Starts a RustFS container for S3-compatible file storage (default) |
| AWS S3 | Supply AWS credentials; RustFS container is suppressed |
| HTTPS | Enabled by default — Let's Encrypt for a real domain, Caddy's local CA otherwise; can be disabled for plain HTTP |
| Agent Runner | Enabled by default; can be skipped to reduce resource usage. See docs/ai-agent/api-design.md for the agent REST API once it's running. |
Set PACA_YES=1 to skip every prompt. This is required, not just convenient,
for unattended use: without it, the script will eventually hit a read and block
waiting for terminal input — harmless for a human at a keyboard, but a hang for
anything driving the script programmatically. PACA_YES=1 alone guarantees a
complete, silent run: every field not given a value below falls back to a sane
default, generating fresh random secrets as needed.
PACA_YES=1 bash install.sh
# or, without a local copy of the script at all:
PACA_YES=1 bash <(curl -fsSL https://github.com/Paca-AI/paca/releases/latest/download/install.sh)AI agents: prefer this script over hand-rolling
docker-compose.yml/.envfrom the manual setup instructions below. It pins compatible image tags, generates every secret in the format the services expect, and stays in sync with what each release actually needs — a hand-built.envis much more likely to drift and fail in a way that's hard to diagnose from outside the repo.
Every other prompt can be steered with an environment variable instead of
accepting its default — set PACA_YES=1 plus whichever of these you care about.
Variables named after an actual .env key are written there verbatim; variables
prefixed PACA_ are installer-only choices with no direct .env equivalent.
| Variable | Purpose | Default |
|---|---|---|
PACA_DIR |
Installation directory | ./paca |
PACA_VERSION |
Release tag to install | latest |
PACA_START |
Pull images and start immediately after writing config (yes/no) |
yes |
ADMIN_USERNAME |
Admin login (min 3 chars) | admin |
ADMIN_PASSWORD |
Admin login (min 8 chars) | auto-generated |
ENCRYPTION_KEY |
64-char lowercase hex; must match the original if reconnecting to an existing DB | auto-generated |
DATABASE_URL |
Setting this selects external/managed PostgreSQL and suppresses the bundled container. Recommended managed option: Neon (free tier available) | unset → bundled PostgreSQL |
POSTGRES_PASSWORD |
Bundled PostgreSQL only | auto-generated |
REDIS_URL |
External Redis/Valkey connection URL (redis:// or rediss://); suppresses bundled Valkey |
unset/empty → bundled Valkey |
BACKUP_ENABLED |
true/false (bundled PostgreSQL only) |
true |
BACKUP_DIR |
Host directory for backup dumps | ./backups |
BACKUP_CRON |
5-field cron, UTC | 0 2 * * * |
BACKUP_RETENTION_DAYS |
Days of backups to keep | 7 |
STORAGE_PROVIDER |
rustfs/s3 |
rustfs |
STORAGE_REGION |
us-east-1 |
|
STORAGE_BUCKET |
Required if STORAGE_PROVIDER=s3 |
paca (rustfs only) |
STORAGE_ACCESS_KEY_ID |
Required if STORAGE_PROVIDER=s3 |
auto-generated (rustfs only) |
STORAGE_SECRET_ACCESS_KEY |
Required if STORAGE_PROVIDER=s3 |
auto-generated (rustfs only) |
PACA_ADDRESS |
Domain or IP Paca is reachable at | localhost |
PACA_HTTPS |
yes/no; ignored when PACA_ADDRESS=localhost |
yes |
GATEWAY_PORT |
Only used when serving plain HTTP | 80 |
PUBLIC_URL |
Full public URL, no trailing slash | derived from the above |
GIT_WEBHOOK_PUBLIC_URL |
Optional origin Git providers deliver webhooks to, when it differs from PUBLIC_URL. Existing hooks retain their URL: update each GitHub App's webhook URL or unlink and relink each repository, and remove any stale hooks |
PUBLIC_URL |
PASSKEY_RP_ID |
Optional WebAuthn relying-party ID for passkeys; override only to share passkeys across subdomains (use a parent domain of PUBLIC_URL's host). Passkeys are off when PUBLIC_URL is unset, and changing this invalidates every registered passkey |
host of PUBLIC_URL |
PACA_WEB |
bundled/external |
bundled |
PACA_AGENT_RUNNER |
Include the Agent Runner service (yes/no) |
yes |
INTERNAL_API_KEY |
API → Agent Runner pre-shared key | auto-generated |
VALKEY_PASSWORD |
Password (requirepass) of the bundled Valkey; URL-safe, embedded in the default REDIS_URL. Not needed with an external REDIS_URL |
auto-generated (a preset value is used as-is) |
JWT_SECRET |
auto-generated |
Fully unattended example — custom domain, S3, no Agent Runner:
PACA_YES=1 \
PACA_ADDRESS=paca.example.com \
STORAGE_PROVIDER=s3 STORAGE_BUCKET=my-bucket \
STORAGE_ACCESS_KEY_ID=AKIA... STORAGE_SECRET_ACCESS_KEY=... \
PACA_AGENT_RUNNER=no \
ADMIN_PASSWORD='a-strong-password' \
bash install.shAuto-generated secrets are printed at the end of a successful run and saved in
.env — nothing is silently left blank. If PACA_DIR already has a .env from
a previous run, the script keeps it by default (y on "Keep existing .env?")
rather than regenerating from your new variables; delete it first if you want a
clean re-run to pick up new values. See the comment header at the top of
scripts/install.sh for this same reference inline
with the script.
Download the two required files from the latest release:
mkdir -p paca/caddy && cd paca
curl -fsSL https://github.com/Paca-AI/paca/releases/latest/download/docker-compose.yml -o docker-compose.yml
curl -fsSL https://github.com/Paca-AI/paca/releases/latest/download/Caddyfile -o caddy/CaddyfileDownload the example environment file and edit it:
curl -fsSL https://github.com/Paca-AI/paca/releases/latest/download/docker-compose.yml -o docker-compose.yml
# Or use the .env.production.example from the repo as a reference:
# https://github.com/Paca-AI/paca/blob/master/deploy/.env.production.exampleCreate a .env with the required variables:
# Required: generate with 'openssl rand -hex 32'
JWT_SECRET=<strong-random-secret>
ADMIN_PASSWORD=<strong-password>
POSTGRES_PASSWORD=<strong-random-password>
# Required even if you don't plan to use Agent Runner (--scale agent-runner=0) —
# the api service itself refuses to start without this set, since it's also
# used to authenticate the api → agent-runner internal status/control calls.
# Generate with: openssl rand -hex 32
INTERNAL_API_KEY=<strong-random-secret>
# Required to encrypt LLM-type agents' API keys and plugin secrets at rest.
# Not enforced at startup, but leaving it empty stores those values in
# plaintext instead of failing — set it unless you're certain you don't need
# it (e.g. ACP-only agents, no plugins with stored secrets).
# Generate with: openssl rand -hex 32
ENCRYPTION_KEY=<64-char-hex>
PUBLIC_URL=http://your-domain-or-ipStart the full stack (bundled PostgreSQL + RustFS):
docker compose --env-file .env up -dWith HTTPS — set SITE_ADDRESS to any concrete domain or IP address and Caddy
handles certificates automatically, choosing the right kind for what you give it:
# In .env: set SITE_ADDRESS to your domain/IP, and PUBLIC_URL/COOKIE_SECURE to match.
SITE_ADDRESS=paca.example.com
PUBLIC_URL=https://paca.example.com
COOKIE_SECURE=truedocker compose --env-file .env up -d- A real domain name with DNS already pointed here gets a trusted Let's Encrypt certificate, renewed automatically. Ports 80 and 443 must both be reachable from the internet for the ACME challenge to succeed.
- An IP address,
localhost,*.localhost, or anything else that isn't a publicly resolvable domain gets a certificate from Caddy's own local certificate authority instead — traffic is still encrypted, but browsers will show a trust warning since that CA isn't publicly trusted.
Either way, certificates persist in the caddy_data volume across restarts.
Without SITE_ADDRESS (or set to a bare port like :80), the gateway serves plain
HTTP — the simplest option, and the right one when another proxy or load balancer in
front of this server already terminates TLS.
With SSH access (optional, off by default): lets a user ssh directly
into a running static environment's own real sshd for pair programming —
see
docs/ai-agent/environment-management.md's
"Terminal / SSH Access" section and
deploy/helm/README.md's own "SSH access" section
for the Kubernetes/Helm equivalent (same feature, same underlying Go code
in agent-runner, on both deployment targets). Each environment's SSH
port is published as a native Docker -p binding straight onto this
host — agent-runner decides which host port to assign, but nothing
relays traffic through its own process, so a real ssh client's full
feature set (agent forwarding, SFTP, further port-forwards) all just
work. Enabling it is setting a port range:
SSH_BASTION_PORT_RANGE_START=2200
SSH_BASTION_PORT_RANGE_END=2299A user connects with ssh -p <port> root@<this-host> once an environment
is running — its own Connect page shows the exact port once one's
assigned. Authentication is a public key they've already registered there,
pushed straight into that environment's own authorized_keys. Each
environment's sshd host key lives on that environment's own persisted
workspace volume, so it survives restarts the same way its files do — no
separate bastion-wide volume to lose. Leaving
SSH_BASTION_PORT_RANGE_START/_END unset (the default) means no
environment is ever assigned a port and nothing is ever published for it.
With port forwarding (optional, off by default): lets a user expose
any container port inside a running static environment (their own dev
server, most commonly) at <this-host>:<host_port> — the exact same
native-publish mechanism as SSH access above, just for a user-managed,
one-to-many set of forwards a user adds from the environment's Connect
page instead of a single auto-created port. See
docs/ai-agent/environment-management.md's
"Port Forwarding" section. Enabling it is the same shape as SSH access, a
disjoint port range so the two can never collide:
PORT_FORWARD_RANGE_START=2300
PORT_FORWARD_RANGE_END=2399Adding or removing a forward on a running environment requires clicking
"Restart" on its Connect page to apply — Docker has no way to add or
remove a -p binding on an already-running container, so the environment
is stopped, recreated from its same persisted volume (no data lost), and
started again with the updated set of published ports.
PORT_FORWARD_HOST (the api service's own ${PUBLIC_HOSTNAME:-localhost}
in docker-compose.dev.yml, or an explicit host you set yourself in
docker-compose.prod.yml — see that file's own comments) is passed to the
agent-runner service too, not just api: the agent itself is told each
forward's real <host>:<host_port> address in-conversation, so if it
starts a dev server on a forwarded port it can hand the user a working URL
directly instead of the user having to look it up on the Connect page.
With external PostgreSQL (suppress the bundled container):
# Set DATABASE_URL in .env to your managed connection string.
docker compose --env-file .env up -d --scale postgres=0💡 Looking for a managed PostgreSQL? Neon is a serverless Postgres platform with a generous free tier, instant branching, and autoscaling — a great fit for Paca. Create a database, copy the connection string, and set it as
DATABASE_URLin.env.
With external Redis/Valkey (suppress the bundled container):
# Fresh install: records the connection and skips the bundled container.
PACA_YES=1 REDIS_URL='rediss://user:password@cache.example.com:6380/0' bash install.sh
# Manual setup: set REDIS_URL in .env, then start with:
docker compose --env-file .env up -d --scale valkey=0The connection must be reachable from the API, realtime, and agent-runner
containers; localhost inside a container is not the Docker host. Use a
Redis-compatible service that supports Paca's cache, pub/sub, and streams
operations (GETDEL, so Redis 6.2+ or Valkey, is required for passkey
ceremonies). Percent-encode reserved characters in credentials. The installer
single-quotes the dotenv value to preserve literal $ characters and does not
print the connection URL. Keep that quoting when editing .env manually.
An unset/empty REDIS_URL keeps bundled Valkey. The saved .env is the source of
truth for Valkey scaling when re-running the installer or upgrading; to change
an existing installation, edit that file rather than exporting a temporary
REDIS_URL override to either script. The installer does not migrate existing
cache or stream data between servers; use the external service's migration
procedure if existing queued work must be preserved.
With AWS S3 (suppress RustFS):
# Set STORAGE_PROVIDER=s3 and real AWS credentials in .env.
docker compose --env-file .env up -d --scale rustfs=0Without Agent Runner:
docker compose --env-file .env up -d --scale agent-runner=0INTERNAL_API_KEY must still be set in .env even with Agent Runner scaled
to 0 — the api service requires it unconditionally at startup regardless of
whether agent-runner is actually running (see above).
Flags can be combined:
docker compose --env-file .env up -d --scale postgres=0 --scale rustfs=0Plugins can't reach private addresses by default. To connect one to a service on your LAN or VPN, such as a self-hosted GitLab, set PLUGIN_FETCH_PRIVATE_HOSTS in .env to a comma-separated list of exact hostnames and add the same host to the plugin's allowedOutboundDomains. On Helm, set api.plugins.fetchPrivateHosts. The service must use https with a certificate the API container trusts. Loopback and link-local addresses, including cloud metadata endpoints, stay blocked. Read the requirements and security notes in docs/plugins/backend-plugin-system.md first.
The Jev client (autofill, auto-assign, automations, and the config test) has the same guard: a project's Jev base URL can't point at a private address. If you host a Jev-compatible gateway on your LAN, VPN or inside the cluster's network, set JEV_PRIVATE_HOSTS in .env to a comma-separated list of exact hostnames. On Helm, set api.jev.privateHosts. Every other private address stays blocked; only list hosts whose exposure to project admins is acceptable, since any project's Jev base URL can then name them — requests still carry the project's own API key.
Recommended: upgrade script. From the directory where your docker-compose.yml and
.env live, run the same upgrade script published with each release. It backs up
docker-compose.yml, caddy/Caddyfile, and .env before overwriting them, refreshes
the compose file and Caddyfile, re-pins image versions when you request a specific
release, then pulls and restarts the stack:
curl -fsSL https://github.com/Paca-AI/paca/releases/latest/download/upgrade.sh -o upgrade.sh
bash upgrade.shPin to a specific release instead of latest:
PACA_VERSION=v1.2.3 bash upgrade.shCommon --scale choices from install time are detected and re-applied automatically —
external PostgreSQL (DATABASE_URL set), external Redis/Valkey (REDIS_URL set),
AWS S3 (STORAGE_PROVIDER=s3), an externally
hosted web app, and a disabled AI agent all stay scaled to 0 without you passing
anything. (Installs from before this was tracked get a one-time best-effort guess for
the web app / AI agent, based on whether a container for that service currently exists,
and the guess is then recorded in .env so it isn't re-guessed on the next upgrade —
check the printed messages and override with e.g. --scale web=1 if a guess is wrong.)
Only pass --scale yourself for scaling that isn't one of these, e.g. a custom
replica count:
bash upgrade.sh --scale web=0 --scale rustfs=0Still running the bundled MinIO container from before this release?
upgrade.shdetects it and refuses to proceed until you say which way you want it — migrate its data (see Migrating from MinIO to RustFS) or keep MinIO running for now withPACA_KEEP_MINIO=1(see that section's follow-up).
Non-interactive (CI, scripts, AI coding agents): set PACA_YES=1 — required for
unattended use, for the same reason as install.sh: without it, the script can block
on a prompt with nobody there to answer it. PACA_YES=1 proceeds with the upgrade and
takes the default (yes) on any conditional .env migration prompt (e.g. switching
AGENT_SERVER_IMAGE off the old upstream default). Override with PACA_UPDATE_AGENT_IMAGE=no
if you want to keep that value as-is. PACA_PROCEED=no gives a lightweight,
non-destructive version check — it prints current vs. target version and exits without
touching any files:
cd /path/to/your/paca/install
PACA_YES=1 bash upgrade.sh
# check what would change without upgrading:
PACA_YES=1 PACA_PROCEED=no bash upgrade.shAI agents: prefer this script over a manual
docker compose pull && up. It backs updocker-compose.yml/Caddyfile/.envfirst, only re-pins image tags when a specific version was requested, and backfills any.envvariables introduced since the install was created — a manual pull+restart skips all of that.
Manual: pull the latest images and restart the stack — this is enough when
docker-compose.yml and the Caddyfile haven't changed shape since your last upgrade:
docker compose pull
docker compose --env-file .env up -dDatabase migrations run automatically on API startup — no manual steps are required.
The compose project was renamed from paca-prod to paca in this release.
Docker Compose namespaces volumes by project name, so existing volumes
(paca-prod_postgres_data, paca-prod_minio_data, etc.) are not automatically
attached to the new stack. To migrate:
# 1. Stop the old stack (volumes are preserved on disk).
docker compose -p paca-prod --env-file .env down
# 2. Rename each volume you want to keep.
docker volume create paca_postgres_data
docker run --rm \
-v paca-prod_postgres_data:/from \
-v paca_postgres_data:/to \
alpine sh -c "cp -av /from/. /to/"
docker volume rm paca-prod_postgres_data
# Repeat for valkey_data and plugin volumes as needed the same way — a raw
# volume copy works for them since their on-disk format didn't change.
#
# The object-storage volume is a special case if you're also still on the
# bundled MinIO: it's named minio_data here, not rustfs_data — this release
# renamed the service, but MinIO's and RustFS's on-disk formats aren't
# compatible, so a raw copy like the postgres one above would just produce a
# rustfs_data volume full of files RustFS can't read. Use the dedicated
# mc-based migration in docs/deployment/README.md's "Migrating from MinIO to
# RustFS" section instead, before starting the new stack below.
# 3. Start the new stack.
docker compose --env-file .env up -dIf you are doing a fresh install (no data to keep), no migration is needed.
Set the image variables in .env to lock to a specific release:
PACA_API_IMAGE=pacaai/paca-api:1.2.3
PACA_WEB_IMAGE=pacaai/paca-web:1.2.3
PACA_REALTIME_IMAGE=pacaai/paca-realtime:1.2.3
PACA_AGENT_RUNNER_IMAGE=pacaai/paca-agent-runner:1.2.3A db-backup container runs alongside the stack and writes a gzip-compressed
pg_dump on a cron schedule you control, pruning dumps older than the
configured retention period. It works against the bundled postgres container
or an external DATABASE_URL.
Configure it in .env:
BACKUP_ENABLED=true # set to false to turn off backups permanently
BACKUP_DIR=./backups # host directory dumps are written to
BACKUP_CRON=0 2 * * * # standard 5-field cron syntax, default 02:00 daily
BACKUP_RETENTION_DAYS=7 # dumps older than this are deleted
# TZ=America/New_York # interpret BACKUP_CRON in this zone instead of UTCBACKUP_DIR is bind-mounted into the container, so it must be a path (relative
to wherever you run docker compose, or absolute) — not a bare name.
BACKUP_CRON accepts any standard cron expression, e.g. */30 * * * * (every
30 minutes) or 0 2 * * 0 (weekly, Sunday at 02:00). The install script prompts
for all four; existing installs get them backfilled by upgrade.sh with these
same defaults.
BACKUP_ENABLED is the persisted record of whether the service should run at
all — --scale db-backup=0 only suppresses it for a single up invocation,
so upgrade.sh reads BACKUP_ENABLED back on every upgrade to decide whether
to re-apply that scale flag automatically, rather than guessing from
DATABASE_URL alone. Set it (not just the scale flag) if you want a "no" to
backups during install to stay a "no" on every future upgrade.
Scheduling is handled by crond inside the container, which blocks until the
next due minute rather than polling, and the container is capped at 0.5 CPU /
256MB (see deploy.resources.limits on the service) — so it stays effectively
idle (well under 1MB RSS, 0% CPU observed) between runs and can't compete for
host resources during the brief dump window either. Raise the memory limit in
docker-compose.yml directly if you have an unusually large database.
Dumps are written by the container's root user, so deleting or moving them
directly on the host may require sudo.
Restore (bundled PostgreSQL container):
gunzip -c backups/paca-<timestamp>.sql.gz | docker compose exec -T postgres psql -U ${POSTGRES_USER:-paca} -d ${POSTGRES_DB:-paca}Restore (external PostgreSQL, using DATABASE_URL):
gunzip -c backups/paca-<timestamp>.sql.gz | psql "$DATABASE_URL"Disable automated backups (e.g. if a managed database already handles this):
docker compose --env-file .env up -d --scale db-backup=0To keep it disabled across future upgrade.sh runs as well, also set
BACKUP_ENABLED=false in .env — otherwise upgrade.sh has no record of the
choice and may re-enable it on the next upgrade.
Use docker-compose.dev.yml for local development and contributor onboarding.
When exposing the stack through a tunnel or reverse proxy, copy the example env file and set the public host:
cp deploy/.env.dev.example deploy/.env.dev
# Edit PUBLIC_HOST and VITE_ALLOWED_HOST in deploy/.env.dev
docker compose --env-file deploy/.env.dev -f deploy/docker-compose.dev.yml up -dStart the full local stack in containers (no tunnel, plain localhost):
docker compose -f deploy/docker-compose.dev.yml up -dOpen http://localhost:3000 once all services are healthy.
Start only shared dependencies:
docker compose -f deploy/docker-compose.dev.yml up -d postgres valkeyFor day-to-day coding, contributors can run the application services directly on the host and use Docker Compose only for PostgreSQL and Valkey.
| Service | Port | Notes |
|---|---|---|
| Gateway (Caddy) | 3000 | Main entry point — http://localhost:3000 |
| PostgreSQL | 5432 | Local database for development |
| Valkey | 6379 | Local cache / event streams |
| API | 8080 (internal) | Routed via gateway at /api/ |
| Web | 3000 (internal) | Routed via gateway at / |
| RustFS S3 API | 9000 | Local object store (S3-compatible) |
| RustFS Console | 9001 | RustFS web UI (credentials: rustfsadmin / rustfsadmin) |
| Static environment SSH | 2200-2299 | One port per running environment, on by default in dev — see the warning below |
| Static environment port forwards | 2300-2399 | One port per user-added forward, on by default in dev — see the warning below |
Unlike docker-compose.prod.yml (opt-in, empty by default), the two ranges
above are on by default in dev for convenience. Docker publishes them
on 0.0.0.0, so any environment you create against this dev stack is
reachable from your whole LAN, not just localhost, for as long as it's
running — fine on a trusted network, but worth knowing. Set
SSH_BASTION_PORT_RANGE_START/_END and PORT_FORWARD_RANGE_START/_END
empty in a local .env override if that's not your situation.
docker-compose.dev.yml includes the same db-backup service as production
(see Database backups above), pointed at the local
postgres container by default. It starts automatically with the rest of the
stack and writes dumps to deploy/backups/.
To test it without waiting for the cron schedule, trigger a dump on demand:
docker compose -f deploy/docker-compose.dev.yml exec db-backup run-backup.sh
ls deploy/backups/To test retention pruning, backdate a dummy file past the retention window and re-run the script:
docker compose -f deploy/docker-compose.dev.yml exec db-backup \
sh -c 'touch -t "$(date -d "@$(($(date +%s)-10*86400))" +%Y%m%d%H%M)" /backups/paca-fake.sql.gz'
docker compose -f deploy/docker-compose.dev.yml exec db-backup run-backup.sh
ls deploy/backups/ # paca-fake.sql.gz should be goneTo watch the cron schedule itself fire, override BACKUP_CRON in
deploy/.env.dev (e.g. */2 * * * * for every 2 minutes) and tail the logs:
docker compose --env-file deploy/.env.dev -f deploy/docker-compose.dev.yml up -d db-backup
docker compose -f deploy/docker-compose.dev.yml logs -f db-backupRestore a dump into the local dev database:
gunzip -c deploy/backups/paca-<timestamp>.sql.gz | docker compose -f deploy/docker-compose.dev.yml exec -T postgres psql -U paca -d pacaStop the development stack:
docker compose -f deploy/docker-compose.dev.yml downRemove the Postgres volume as well:
docker compose -f deploy/docker-compose.dev.yml down -vUse docker-compose.e2e.yml to spin up a full production-like
stack with fixed, test-safe credentials for running end-to-end tests:
docker compose -f deploy/docker-compose.e2e.yml up -d --build --wait
docker compose -f deploy/docker-compose.e2e.yml down -vAll secrets are intentionally weak and public — never use them outside a local E2E environment.