Skip to main content

Module release_statement

Module release_statement 

Source
Expand description

Release statements for stacks.

A signed release is a release/v2 statement from alien-signing. Its body names every workload exactly, for enforcers that build workloads one by one, and carries the whole stack, for enforcers that deploy from it. It also names its channel, the enforcer builds it runs with, and the digests of the setup templates rendered for it. release_body builds that body from a pushed stack; signed_stack reads the stack back out of a verified body and checks it agrees with the workloads beside it.

Structs§

ReleaseOptions
What a release carries beyond the stack.

Functions§

check_deployer_env_mappings
On the clouds a protected install delivers a deployer input’s value one of two ways: a secret input’s goes through the install’s deployer-secrets vault, any other input’s is read from the deployment’s store as plain env. A mapping that asks for the other way would drop the value (a text input mapped as a secret has no vault slot) or put a secret where management reads it, so the developer’s release build refuses it, where they see why. Kubernetes installs resolve each mapping’s type from the install’s own values and are not checked. Only the release build calls this: an install keeps running a release it already accepted.
code_image
The image a resource runs, for the resource types that run one.
code_image_mut
Mutable access to the image code_image returns.
gating_deployer_inputs
The deployer inputs whose value decides whether another input applies (its when names them). The install’s own store holds them, so whoever builds a signed config’s env reads these and passes them to signed_config_env and signed_deployer_env.
image_digest
The sha256:<hex> digest an image reference is pinned to, if it is.
release_body
The release/v2 body for stack on platform. Every image must be pinned by digest and built before the release, so source code, unpinned images and resource types nothing can check are refused here, where the developer sees why.
relocate_images
signed with each image moved to where carried says the same resource’s image is, when both name the same digest. A carrier may serve an image from another registry (a manager’s pull proxy, a site’s own registry), but only the bytes the developer signed.
sandbox_pinned_image
The image a signed sandbox boots, pinned by digest. A registry image is its own pin. An AWS sandbox’s code.image is an s3:// bundle with no digest of its own, so the pin is the container image the bundle is built from (bundled_from); the bundle’s key is a function of that image alone. An Azure catalog name or any unpinned reference is refused.
signed_config_env
The env a signed config sets on workload: the values of the release’s developer inputs, resolved through the signed stack’s env mappings (with each input’s default), then the config’s own env, which wins. A controller and the verifier that checks it, the machine agent and the Kubernetes operator all build the configured env with this, so an input signed by set-inputs reaches the worker the same way it does on an unprotected install. Deployer inputs and secret mappings are not here: they never travel in a signed config. deployer_values holds the install’s own values of gating_deployer_inputs: a developer input that is conditional on a deployer input applies as the customer set that input. A verifier reads them from the install’s store; a controller uses the deployment’s input values. A value that differs between the two only makes the verifier refuse the write.
signed_deployer_env
The env a workload takes from the release’s deployer inputs, resolved the way the cloud controllers resolve it: the install’s stored value, else the input’s signed default; left out when the input is optional, has neither, or does not apply (its signed when is off for the install’s gate values). A required input that applies and has neither is refused. Only values come from the install’s store (deployer_values); which inputs exist, apply, are required or have defaults is all signed. config_inputs are the signed config’s developer input values, which decide when for inputs that name a developer input. Secret mappings are not here: their values are never signed or sent.
signed_deployer_secrets
The deployer secrets workload reads from the install’s own deployer-secrets vault when it starts, from the signed stack alone: every secret input the deployer provides that applies and maps to the workload, in signed order. Whether a value exists is the vault’s answer when the workload starts (a required one that is missing stops it, an optional one is left unset), so nothing here reads the store. The control plane’s own list adds the secret store’s version of each value, which only restarts a workload on a rotation; this one has none, so a rotated value is read by the next start. A secret input only the developer provides has no value on a protected install and is not here.
signed_input_variables
The plain env mappings of the stack’s developer inputs, resolved from the values a signed config carries (defaults included). Each variable keeps its mapping’s target_resources. Deployer inputs never travel in a signed config: deployer_values only decides which inputs apply, when a developer input is conditional on one, and no deployer mapping is returned. Secret mappings are left out: their values are never signed.
signed_stack
The stack a verified release carries, after checking it is for platform and that each code-bearing resource runs exactly the image of the workload of the same name.
signed_workload_secrets
The secrets list a protected worker loads at start (WORKLOAD_SECRETS): the signed workload’s secrets names and its deployer secrets, with the release digest as the list’s hash. A controller writes it and the verifier checks what the controller wrote against it, so management never decides which vault keys load. None when the worker loads none.