Environment Variables#
Most of what a deployment can be told lives in the build profile and is
rendered into config.yml. What is left over — secrets, and the handful of
choices that belong to the host a command runs on rather than to the
deployment — arrives from the environment. This page is what that is.
Secrets, and .env#
ANTHROPIC_API_KEY=sk-... # Or OPENAI_API_KEY, GOOGLE_API_KEY, etc.
Provider keys live in the deployment repository’s .env and are read from
there. No environment variable selects which deployment a command acts on:
every lifecycle verb finds the repository by walking up from the working
directory, and --repo DIRECTORY names another one.
.env.example, rendered into the repository by osprey build, is the
starting point: copy it to .env and fill in what you need. It carries the
variables the deployment supplies — the provider keys, whatever the
profile’s env.required / env.optional declares, and the tokens
osprey up mints for the services it starts. It is not an inventory of every
name the framework reads: the host-level knobs below are set in the environment
of the command you run, not in a file the build renders.
Host-level knobs#
Each of these belongs to the machine or the invocation rather than to the deployment, which is why none of them is a config key.
Variable |
What it does |
|---|---|
|
|
|
The two image axes for one build, outranking |
|
The site’s build settings — a CA bundle for a TLS-intercepting proxy, a
proxy bypass list, the package indexes pip resolves from, and the
registry standing in for docker.io — for one build,
outranking |
|
|
|
Path to a CA bundle for hosts behind a TLS-intercepting proxy, so
|
|
Path to a facility’s own component registry module, outranking the
|
|
Seconds a run waits for every MCP server the project declares to finish
connecting before it goes ahead without them, default |
|
The address |
OSPREY_SITE_CA and the PIP_* names are host-level knobs and Docker
build arguments at once: the Dockerfiles in
The Project Image declare an ARG of each name, and
osprey up supplies each one from the host variable, or from the
images.* key behind it. The PIP_* names come from your shell or that
key, never from .env or .env.shared: a line there is ignored with a
warning, like every launch variable (see
launch variables). One spelling for
one setting, whether the build is managed or a hand-run docker build.
What they configure is the build — a container that is already running reads
nothing from them.
The host’s profile variant#
OSPREY_PROFILE_VARIANT names the overlay profile, profiles/<name>.yml,
that a build of this checkout merges over profile.yml. Unlike the host-level
knobs, it is not read from the shell environment or the .env chain. The
build reads it only from the gitignored .env.variant file at the repository
root (see One repository, several hosts).
.env.variant: OSPREY_PROFILE_VARIANT=teststand
The archive pass#
osprey archive (CLI Reference) reads three of its options from a
variable when the flag is not given. The archive service’s compose file sets
all three for its container.
Variable |
What it does |
|---|---|
|
The sources tree, |
|
The existing archive root the day directories are written into. Stands
in for |
|
Seconds between passes under |
CANOPY payload#
A deployment that shows the CANOPY panel builds its images from a prebuilt
CANOPY payload (CANOPY). Two variables steer the
canopy-payload pre-build step that stages it.
Variable |
What it does |
|---|---|
|
The payload directory the canopy repository’s
|
|
|
Virtual accelerator source#
The virtual accelerator container serves the simulator view that
osprey build writes under its data mount; the image runs
osprey.services.virtual_accelerator.entrypoint by name. These variables,
rendered by the compose file, name the instance it serves as and the mount
points it reads.
Variable |
What it does |
|---|---|
|
Which instance the container serves as: |
|
The data root the simulator view sits under, read as
|
|
The period of the served model’s passes, in seconds, greater than
zero. Set by |
|
The fast period, at which the served model publishes its |
|
The directory holding the active scenarios |
|
The secret a model RPC write must present, passed through from the
project |
The Phoebus server’s overrides#
The phoebus MCP server reads these three from its own environment each
time a tool runs, and each one outranks a config key. They reach the server
from the environment of the process that starts the agent;
Environment Variables (the .env chain) covers how a deployment’s .env
gets there.
Variable |
What it does |
|---|---|
|
The agent bridge’s full base URL, outranking |
|
|
|
The archiver bound into generated Data Browser plots, outranking
|
Names the framework stamps#
A deployment’s containers carry more OSPREY variables than the ones above, and they are not settings. The build renders them: which user a container serves, which identity its audit records are filed under, which control target and write posture a session is running with. Setting one by hand does not reconfigure anything — it detaches a process from the thing that was tracking it, which is why the audit-critical names are stripped from every MCP server spec the build renders.
The audit identity ladder covers that set and why it is closed.
Three of them decide the account name a container’s control-system writes arrive under (The name uid 1000 writes under):
Variable |
What it carries |
|---|---|
|
The name the entrypoint gives uid 1000 at start. Rendered for a
personal card behind a login wall that sets |
|
The container path of the staged script that applies the name. Set
wherever |
|
Set by the entrypoint, to |
Three more tie a container’s launches to the agent record:
Variable |
What it carries |
|---|---|
|
The agent-record service’s base URL, as this container reaches it. A
launch sends its log events to |
|
The container’s own |
|
The terminal session a launch belongs to, written into its audit
records and sent as the |
See also
- Runtime Configuration — config.yml
The settings that arrive from
config.ymlrather than the environment.- Environment Variables (the .env chain)
Which
.envfile wins where, and how${VAR}placeholders in the compose files are resolved.