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§
- Release
Options - 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-secretsvault, 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_imagereturns. - gating_
deployer_ inputs - The deployer inputs whose value decides whether another input applies (its
whennames them). The install’s own store holds them, so whoever builds a signed config’s env reads these and passes them tosigned_config_envandsigned_deployer_env. - image_
digest - The
sha256:<hex>digest an image reference is pinned to, if it is. - release_
body - The
release/v2body forstackonplatform. 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 signedwith each image moved to wherecarriedsays 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.imageis ans3://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 ownenv, 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 byset-inputsreaches 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_valuesholds the install’s own values ofgating_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
whenis 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_inputsare the signed config’s developer input values, which decidewhenfor inputs that name a developer input. Secret mappings are not here: their values are never signed or sent. - signed_
deployer_ secrets - The deployer secrets
workloadreads from the install’s owndeployer-secretsvault 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_valuesonly 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
platformand 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’ssecretsnames and its deployer secrets, with the releasedigestas 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.Nonewhen the worker loads none.