Configuration¶
When you bring a processor to the Dory platform, you don't hand-write deployment manifests or wire up infrastructure. You describe your processor once as a template, and the platform runs it for you — provisioning it, connecting it to the event mesh, and keeping it healthy.
This page explains what goes into that template and what the platform supplies on your behalf.
The processor template¶
A processor template is the recipe the platform uses to run your processor. It captures everything specific to your application and nothing about the underlying infrastructure:
| You describe | What it means |
|---|---|
| Container image | The image that contains your processor code. |
| Resource needs | How much CPU and memory your processor requests (and optional ceilings), plus whether it needs a GPU. The platform places it on suitable hardware. |
| Health timing | How long to wait before checking your processor's health after it starts, and how often to re-check — tuned to how your processor warms up. |
| App environment | Any application-specific settings your code reads (log verbosity, feature flags, tuning knobs). |
| App secrets | References to credentials your processor needs, such as an application database or a third-party API, supplied securely rather than written in plain text. |
You provide these once. From there the platform owns the lifecycle: starting the processor, restarting it if it fails, moving it between machines, and preserving its state across moves.
flowchart LR
DEF["You define a<br/>processor template<br/>(image · resources · health · env)"] --> PLATFORM
subgraph PLATFORM[Dory platform]
RUN["Provisions & runs<br/>your processor"]
end
PLATFORM --> PROC[Running processor]
MSG[Messaging connectivity<br/>+ credentials] -. "auto-wired" .-> PROC
SEC[Your app secrets] -. "injected securely" .-> PROC
What the platform provides for you¶
The template above is deliberately small because the platform fills in everything that every processor needs but that isn't specific to your app.
Messaging connectivity — automatic¶
Processors communicate over a shared event mesh. You never configure broker hosts, ports, exchanges, or messaging credentials. The platform supplies that connectivity to every processor automatically, so your code can publish and subscribe to events from the moment it starts. If the platform's messaging settings change, every processor picks up the change without any edit to your template.
Identity and placement — automatic¶
Each running processor is given its own identity and is placed on hardware that fits the resource needs you declared (including GPU nodes when you ask for one). Sensor-bound processors are additionally handed the details of their assigned sensor so your code knows what it's processing. None of this is something you set up.
Observability — automatic¶
Logs, metrics, and distributed tracing are turned on platform-wide. Your processor's signals flow to the platform's dashboards without any wiring on your part. See Observability for what you get and the few optional hooks you can add.
Your application's own secrets¶
Some processors need credentials that belong to them — an application database or a third-party API key. You declare these in the template as references, not as literal values. The platform resolves each reference at startup and injects it securely, so secrets never live in plain text alongside the rest of your configuration.
This keeps a clean separation:
- Shared infrastructure credentials (messaging, telemetry) are the platform's responsibility — you never see or set them.
- App-specific secrets are yours to declare by reference; the platform delivers them to your processor safely.
- A sensor's device login is neither. The sensor's owner saves it with the sensor, and the platform keeps it: when a camera needs a login, the platform signs in to the camera on your processor's behalf, and your processor never receives the login. See Processor SDK: reaching a camera.
Edge vs. managed placement¶
When you define a processor you choose where it should run:
- Managed — the platform runs it on cloud capacity it provisions and scales for you. This is the default.
- Edge — the processor runs on your own edge hardware (for example, near a camera or sensor), and the platform still tracks its health and can fail it over to managed capacity if the edge node goes down. See Edge Failover.
Defaults you can rely on¶
You only specify what's unusual about your processor. Sensible defaults cover the rest — for example, a processor that doesn't declare resource needs or health timing simply gets the platform's standard values. Start minimal (image plus any app environment) and add resource, GPU, or health settings only when your workload calls for them.
See the HTTP API Reference and Metrics for the operational surfaces the platform exposes around your running processors.