Deployment

Operations guide for running the PRIOR engine in production. PRIOR ships as a single immutable container with a native Rust serving path: no Python, no Node, and no external calls at inference time. Default port 8089.

This supersedes any older "Python gateway on port 8000" material. Production is the native engine.

1. The container model

The image bakes everything needed to enforce policy except the generation weights (which are large and shared, so you mount them):

Writable state (the license identity record, the SQLite governance DB, and live re-calibration output) lives under /app/state, the only directory the non-root prior user owns. Mount a volume there. It is not optional on a node-locked tier: the identity record is what binds this license to this node, and a container that starts from an empty state volume derives a fresh node identity, which seat enforcement reads as a second node. The activation is then denied and the engine degrades to unsteered passthrough. You also lose your admin keys and audit log.

Minimal run (docker compose)

MODELS_DIR=/srv/models MODEL=Llama-3.2-3B-Instruct-Q4_K_M.gguf \
  docker compose up -d

Minimal run (docker run)

docker run -d --name prior \
  -p 127.0.0.1:8089:8089 \
  -e PRIOR_NATIVE_MODEL=/models/Llama-3.2-3B-Instruct-Q4_K_M.gguf \
  -v /srv/models:/models:ro \
  -v prior-state:/app/state \
  ghcr.io/eagle-logic/prior:slim-cpu

GPU

Use the CUDA image and offload layers to the GPU:

docker run -d --name prior --gpus all \
  -p 127.0.0.1:8089:8089 \
  -e PRIOR_NATIVE_MODEL=/models/Llama-3.2-3B-Instruct-Q4_K_M.gguf \
  -e PRIOR_NATIVE_NGL=99 \
  -v /srv/models:/models:ro -v prior-state:/app/state \
  ghcr.io/eagle-logic/prior:slim

The reference 7–8B model at 4-bit needs ~6 GB VRAM; run one model per GPU.

2. Network exposure & auth

The published port is loopback-only by default. docker-compose.yml publishes to 127.0.0.1:8089, which is reachable for local testing but not on the network. This is intentional: the /v1 endpoint is unauthenticated by default.

To expose the engine on a LAN or the internet, do both:

1. Publish on a routable interface: PRIOR_PUBLISH_ADDR=0.0.0.0.
2. Require a key on /v1: PRIOR_REQUIRE_AUTH=1 (then create keys via /admin/keys).

Put TLS termination (a reverse proxy / load balancer) in front for anything internet-facing.

3. Licensing (node-locked)

The engine verifies an ED25519-signed license bound to the host's hardware fingerprint before enabling steering. Eagle Logic's public key is baked into the published image, so it verifies locally and never calls home in the inference path, and you do not supply a key. (Connected tiers make a periodic background license check-in; the air-gapped tier makes none and runs fully offline (see Licensing).) You only mount your license.bin:

docker run -d --name prior --gpus all \
  -p 127.0.0.1:8089:8089 \
  -e PRIOR_NATIVE_MODEL=/models/model.gguf \
  -v /srv/models:/models:ro \
  -v /path/to/license.bin:/app/license.bin:ro \
  -v prior-state:/app/state \
  ghcr.io/eagle-logic/prior:slim

• Without a valid license, PRIOR degrades to plain inference with no gate actuation (x-prior-steering: disabled) rather than failing to boot.
• There is no bypass. A license verifies or it does not load, local development included.
• A license binds customer id, hardware id, tier, expiry, and capabilities. Expired, tampered, or wrong-host licenses are rejected. Full details in Licensing.

4. Environment variable reference

Everything is optional except where noted. Defaults shown are the container defaults.

Server & network

Model & engine

Auth & license

Storage & state

Observability & safety

Policy ingest (extractor)

Only needed to use POST /admin/packs/ingest. Unconfigured ⇒ a clear 400, never a silent dial.

5. Health, readiness & Kubernetes

livenessProbe:
  httpGet: { path: /health, port: 8089 }
  periodSeconds: 10
startupProbe:
  httpGet: { path: /health, port: 8089 }
  failureThreshold: 120     # tolerate a cold-node model load
  periodSeconds: 5

Because the engine is stateless per request, scale horizontally by running more replicas behind a load balancer; each replica needs its own node-locked license (or a cluster license; see Licensing).

6. Observability

• Metrics. GET /metrics is Prometheus exposition: zone distribution (GREEN/YELLOW/RED), refusal counts, and latency / token / injection histograms. Scrape it directly.
• Structured logs. Set PRIOR_JSON_LOGS for one JSON object per line on stdout, ready for Datadog / Splunk / ELK. Routing decisions and steering-apply events are structured fields.
• Safety audit. GET /admin/audit/safety is the durable, queryable trail of every gate decision (prompt hashes only, never text or completions). Pair x-prior-decision-id from a response with the matching audit row for end-to-end traceability.

7. Upgrades

The container is the atomic unit. To upgrade, pull the new image and replace the container; mount the same /app/state volume and the same license.bin. Policy packs authored through ingest live under your state/packs volume, so persist that volume and your custom policies survive replacement.

See also: Getting Started · API Reference · Licensing.