Principle:Vespa engine Vespa Cloud Deployment Context
| Knowledge Sources | |
|---|---|
| Domains | Cloud_API, Dependency_Injection |
| Last Updated | 2026-02-09 00:00 GMT |
Overview
A dependency-injection pattern that provides running Vespa application components with immutable, structured information about their deployment context including application identity, zone, cloud provider, cluster, and node.
Description
Cloud Deployment Context is the principle of making deployment metadata available to application code through a clean, injectable API rather than environment variables or configuration files. In the Vespa Cloud platform, this is realized through the ai.vespa.cloud package, which provides a hierarchy of immutable value objects:
- SystemInfo — the root injectable, aggregating all context
- ApplicationId — tenant, application, and instance identity
- Zone — deployment environment (dev, staging, perf, prod) and region
- Cloud — the cloud provider hosting the deployment
- Cluster — cluster topology (id, size, node indices)
- Node — the specific node this container runs on
The principle solves the problem of environment-aware application behavior: code that should route differently in production vs staging, partition work across cluster nodes, or identify itself for logging and metrics. By providing this context as injectable objects, applications remain testable (context can be mocked) and decoupled from the deployment platform.
Usage
Apply this principle when building Vespa Cloud applications that need to:
- Behave differently across environments (dev, staging, prod)
- Route traffic based on region proximity
- Distribute work across cluster nodes
- Log or report deployment identity
- Make decisions based on cloud provider capabilities
The context is accessed by declaring a constructor dependency on SystemInfo with the @Inject annotation.
Theoretical Basis
The Cloud Deployment Context follows the Inversion of Control (IoC) pattern, specifically Constructor Injection:
Pseudo-code Logic:
# Abstract algorithm description (NOT real implementation)
# 1. Platform constructs context from deployment metadata
context = SystemInfo(
application = ApplicationId(tenant, app, instance),
zone = Zone(environment, region),
cloud = Cloud(provider_name),
cluster_name = from_services_xml(),
node = Node(index)
)
# 2. Container injects context into components
component = UserComponent(context) # constructor injection
# 3. Component uses context for decisions
if context.zone.environment == PROD:
component.use_production_settings()
else:
component.use_relaxed_settings()
The key design properties are:
- Immutability — all context objects are immutable value types with proper equals/hashCode
- Composability — SystemInfo composes ApplicationId, Zone, Cloud, and Node
- Testability — all classes have public constructors, enabling test mocks
- Null safety — constructors validate non-null with Objects.requireNonNull