AWS sandbox connector documents and gateway network boundaries:
the operator role Lambda assumes to place the connector’s network interfaces, and the
AWS::Lambda::NetworkConnector those interfaces belong to.
The facts an AWS sandbox’s setup renders its scaffolding from. Setup applies them and the
runtime never re-reads them, so a change to any of them needs setup to run again.
Represents an artifact registry for storing container images and other build artifacts.
This is a high-level wrapper resource that provides a cloud-agnostic interface over
AWS ECR, GCP Artifact Registry, and Azure Container Registry.
The flow log on a VPC that Alien creates on AWS. The CloudFormation and Terraform network
emitters and the direct-setup network controller all build their flow log from this one
definition, and a parity test compares the rendered templates with it.
Represents a build resource that executes bash scripts to build code.
Builds are designed to be stateless and can be triggered on-demand to compile,
test, or package application code.
A waiting release whose setup change a Helm chart upgrade cannot carry. The
manager works this out from the release and the installed setup, so every
place that offers an upgrade agrees with the manager’s report handling.
A binding to an existing resource of a type an extension defines, such as a DNS zone the
customer already has. Its fields are the resource’s outputs, as the type’s descriptor declares
them in schemas.outputs.
Email infrastructure for sending and receiving mail on customer-owned
domains. On AWS this is backed by SES: a shared configuration set, optional
inbound/event wiring, and one email identity (Easy DKIM) per seed domain.
What an extension bundle’s core zip says about the extension: what a loader checks before it
runs anything. The zip’s own digest is not in it, since a file can’t hold its own digest; the
stack pins the zip by ExtensionManifest::digest.
A Gemini Agent Platform reasoning engine: the durable parent that sandbox
environment templates and sandboxes hang under. One per sandbox, provisioned
once and addressed by the server-assigned id its controller records.
A Frozen GCP sandbox’s image repository and the manager’s write access to it. Setup makes
them because the runtime identity may write images into the repository but cannot create
it or change who may; an image-only release then rolls without setup.
The answers a deployment gives to a stack’s inputs, with each input’s declared default
behind them. Resources that name an input read their value through this.
Represents a key-value storage resource that provides a minimal, platform-agnostic API
compatible across DynamoDB, Firestore, Redis, and Azure Table Storage.
A managed PostgreSQL database. The target platform decides the backend
(AWS Aurora Serverless v2, GCP Cloud SQL, Azure Flexible Server, or an
embedded native process on Local); the database is never publicly reachable.
Opt-in queue batching. Counts and windows are upper bounds, not guarantees.
Providers may deliver smaller batches. Delivery remains at least once and unordered.
Configuration for HTTP-based readiness probe.
This probe is executed after worker provisioning/update to verify the worker is ready to serve traffic.
Only works with workers that have Public ingress.
A managed, Redis-compatible in-memory store on a private network. The target
platform decides the backend (AWS ElastiCache for Valkey, GCP Memorystore for
Valkey, Azure Managed Redis, or the official Valkey image in Docker on Local). It is
never publicly reachable, and it is a single endpoint (not cluster mode), so
plain clients and multi-key scripts work.
Represents cross-account management access configuration for a stack deployed
on AWS, GCP, or Azure platforms. This resource sets up the necessary IAM/RBAC
configuration to allow another cloud account to manage the stack.
Represents a service activation that can be enabled on cloud platforms.
For GCP: enables project services (e.g., iam.googleapis.com, compute.googleapis.com).
For Azure: registers resource providers (e.g., Microsoft.DocumentDB, Microsoft.Storage).
Values a protected setup pins that come with the CLI build, not with the stack: the account
whose machine images machines may boot and the verifier image of each cloud. Renders that a release
records use SetupPins::compiled_in, so every build of one release renders the same
bytes; tests pin their own.
Where a setup package installs: the platform the deployment runs on and the cloud its
infrastructure lives in. They differ for managed Kubernetes (an EKS, GKE or AKS cluster runs
on Kubernetes, in the Aws, Gcp or Azure cloud).
A signed statement as it is stored and forwarded: the exact bytes that were
signed and the signatures over them. Carriers pass it through unchanged;
only enforcers verify it (see alien-signing).
A statement as it is stored and carried.
A protected install’s verifier, <prefix>-verifier: the only principal that changes what
runs. Worker controllers hand it the cloud writes they build, and machine rolls go through
it; it checks them against the signed release before anything is written.
Delivers matching object events to a queue in the same stack.
Rules on one Storage must not overlap: no object key may match two of them.
Delivery is at least once, so consumers must tolerate duplicates.
Per-lifecycle gateability of one resource type, derived from the ownership
table and the gate refusals. Serialized into the generated manifest the
TypeScript SDK’s surface test consumes.
Represents a serverless worker that executes code in response to triggers or direct invocations.
Workers are the primary compute resource in serverless applications, designed to be stateless and ephemeral.
Outbound network restriction enforced outside the container.
Internet access also permits this container’s own replicas on declared TCP ports,
own-service discovery, and the credential proxy for its own identity.
Absence preserves the runtime’s existing full-network behavior.
Cloud backend for a Postgres resource. Only Aurora Serverless v2 ships in v1;
the enum reserves the slot so provisioned RDS is an additive variant later.
Whose rules the registry’s replication configuration holds. The configuration is one
per account and region, and writing it replaces every rule. The setup that writes ours
reads the rules when it writes and keeps every rule that is not ours unchanged, so this
report is informational: it tells the operator which other rules the account has.
Resource-attribute key marking OTLP telemetry as Alien system-component
output (infrastructure daemons and internal runtimes) rather than user
workload. Log consumers — the CLI log viewer and the dashboard — hide
telemetry carrying this attribute by default. The value is the string
"true".
Recommended cluster parameter group values for Aurora PostgreSQL, for any setup template
or controller that creates or updates the group. Connections must use TLS, and pgaudit
logs schema (ddl) and permission (role) changes. shared_preload_libraries keeps
Aurora’s default pg_stat_statements for families 14 to 18. It is a static parameter, so
a running writer loads pgaudit at its next restart or its next resume from auto-pause.
log_min_error_statement = panic keeps the text of failing statements, which can hold a
password, out of the logs; the error message itself is still logged. It is dynamic and
applies to a running writer without a restart.
Days after which S3 aborts a multipart upload that was started and never completed. Every
S3 bucket Alien creates, whether setup (CloudFormation, Terraform) or the storage controller
creates it, carries this rule next to the app’s own lifecycle rules. It gives each bucket the
lifecycle configuration that compliance checks require and never expires a stored object.
SQS keeps messages for 4 days by default. A dead-lettered message keeps its original send
time, so a queue that receives them keeps messages for the SQS maximum of 14 days.
Most lifecycle rules S3 accepts on one bucket. The incomplete-upload rule is added only while
a bucket has room for it: a bucket at the limit already has a lifecycle configuration.
Days that every CloudWatch log group Alien creates keeps its events, whether setup
(CloudFormation, Terraform) or a runtime controller creates it. A year covers compliance
requirements to retain logs for twelve months. CloudWatch accepts only a fixed list of
values, and 365 is one of them.
Request headers an S3 CORS rule lets a browser send with a signed upload (PUT to a
presigned URL): the content headers a signer may bind, and x-amz-*, which covers the
checksums AWS SDKs add and x-amz-meta-*. S3 allows one * per header.
Azure Managed Redis Balanced SKUs in ascending order with their published memory in GB.
B0 is left out: the pricing page says B0 and B1 may lack some features, and B0 is half the
size of the smallest production tier. NoCluster caps a database at 25 GB, so B20 is the
largest. Sizes are the published figures; the live check of maxmemory is recorded in the
design notes.
Request headers an Azure Blob CORS rule lets a browser send with a signed upload (PUT
to a SAS URL). x-ms-* covers x-ms-blob-type, which Put Blob requires, the
x-ms-blob-content-* and x-ms-meta-* headers, and the x-ms-version and
x-ms-client-request-id headers the Azure SDK sends.
Deployment protocol written by actors with resumable protection, CORS and
database update states and retained deletion. Older readers must be fenced
before these states exist.
The binding’s own fields beside the outputs, which an outputs schema must not name: they would
read as the binding’s tag and service instead of outputs.
ElastiCache node types in ascending order with their published node memory in GiB.
One table for the controller, the CloudFormation emitter and the Terraform emitter.
Env var that carries a natively projected workload’s
DeployerSecretEnv list to its hosting controller, which resolves each
entry before the process starts (a secretKeyRef on Kubernetes, a vault
read on the local platform). It holds names only, never values.
What a caller is told when it asks a Google Cloud sandbox that has no egress gateway for a
per-sandbox outbound policy: none blocks everything and takes no policy, and internet
always has a gateway (a binding without one is refused, never opened).
What a GCP preview is, in the words every refusal and the docs use. The edge credential is
scoped to the whole sandbox and is accepted for :execute too, so a preview credential there
is command access and the two are never separable.
Headers a GCS CORS rule lists for a signed upload. GCS uses one list (responseHeader)
for both the request headers a browser may send and the response headers it may read,
and matches each name exactly, so x-goog-meta-* headers can’t be listed.
CloudFormation AllowedPattern for the setup parameter. Empty keeps the
role trust unchanged, so stacks created before the parameter existed can be
updated without one.
CloudFormation AllowedPattern for the setup parameter when a template
requires it: empty is refused, so every install and update sets the trust
condition.
Most availability zones a created network can span. The AWS network gives each zone a
/20 public subnet from x.x.0.0 and a /20 private subnet from x.x.128.0 of the /16, so a
ninth zone would overlap the private range.
The longest extension name every setup can name the extension’s identity with. The
CloudFormation role is ${AWS::StackName}-<name>-ext, which isn’t cut to fit, and a
generated stack’s prefix is at most 35 characters: 35 + 1 + 24 + 4 is IAM’s 64, as for a
permission profile’s -sa role on EKS.
Memorystore for Valkey node types in ascending order with their default usable memory in
GB (decimal), from the published node specification. The CUSTOM_* types are left out: they
exist only for cluster-disabled instances and have not been exercised against a real project.
The fixed inner database name for cloud Postgres backends.
AWS rejects hyphens in DatabaseName, and the cluster/instance/server name already
carries the resource id, so the inner database is a fixed label rather than the id.
Every cloud emitter and controller derives its database name from this single constant
so a frozen import always binds to a database that exists. (Local names its database
after the resource id and does not use this.)
Type prefixes no extension may use: alien/ is Alien’s own namespace, and experimental/
holds built-in types that are not stable yet, such as experimental/aws-opensearch.
The stems of the files Alien’s Terraform module writes besides one per resource: an
extension’s Terraform modifier writes <extension>.tf beside them. override is there too,
since Terraform merges override.tf into the module, and main, the file a module’s own
configuration conventionally sits in. alien-terraform checks its generator against the list.
Most snapshots a volume may hold at once. Azure Disk Backup keeps at most 450
scheduled snapshots per disk; the same limit applies everywhere so a stack is
portable across clouds.
Trait that defines the interface for all resource types in the Alien system.
This trait enables extensibility by allowing new resource types to be registered
and managed alongside built-in resources.
Trait that defines the interface for all resource output types in the Alien system.
This trait enables extensibility by allowing new resource output types to be registered
and managed alongside built-in resource outputs.
Resource observations may gain fields as providers and servers are upgraded.
Implementations should accept unknown output fields so older readers remain compatible;
user-authored resource configuration is validated separately.
Accept unchanged reports or the explicit upgrade to this writer protocol.
Never permit downgrade or unknown protocols. Provider setup prerequisites
remain separate from this checkpoint compatibility check.
Classifies a declared code.image for Azure, or None when it is neither kind. A bare
[A-Za-z0-9._-]+ is checked first and always a catalog name; anything else must carry /,
: or @ and parse as an OCI reference.
Whether a deployment environment variable with these target_resources applies to
resource_id: its targets match, and the resource is not one Alien adds itself.
The message for a database or cache that setup cannot place on an existing cluster’s network.
network_hint, when the deployer can bring the cluster’s own network, names how in the
caller’s terms.
The AWS role name setup gives an extension’s identity: <prefix>-<id>, cut to IAM’s 64
characters with a hash of the full name, as the Terraform template derives it.
The GCP service account id setup gives an extension’s identity, as the Terraform template
derives every service account’s: a readable stem and a hash of the full name, within GCP’s 30
characters.
What makes name unusable as an extension’s name, or None when it can be one. The name
prefixes each type the extension defines, names its identity in every setup and its file in
Alien’s Terraform module. alien extensions build, the SDK’s export! and alien release
all apply this rule.
Finds the boolean deployer input a gate references, for render-time
re-validation. The compile-time preflight enforces the same two rules;
generators repeat them so a caller that renders without preflights cannot
ship a template whose gate variable is undeclared or non-boolean.
Whether a resource may carry an .enabled() gate at all. None means
gateable. Lifecycle legality is not decided here — a lifecycle the type
does not allow is refused by the lifecycle rules regardless of gating.
Inputs scoped away from the platform always resolve false, even with a provided value.
The deployer’s answer for a live gate: the provided value, else the
input’s declared boolean default. The error is the reason, for the caller to wrap.
A gate value from the wire: JSON booleans stay booleans, and the
CloudFormation parameter strings “true”/“false” coerce — CloudFormation
has no boolean parameter type, so its registration payloads deliver gate
answers as strings. Anything else is None, refused loudly by callers.
Resources whose state is replaced by an automatic setup package import.
Application resources are managed through the installed identity and must
retain their controller state when that package is reimported.
Whether service names a cloud service Alien can enable on platform: a GCP API,
<name>.googleapis.com, or an Azure resource provider, Microsoft.<Namespace>. Azure
compares provider names without case, so the prefix may be in any case.
Whether name is a lowercase letter followed by lowercase letters, digits and dashes: the
form of an extension’s name and of the last segment of its permission sets’ ids. Such a name
is a single path segment, a Terraform file stem with no _override suffix, and a valid part
of every cloud’s identity names.
Whether the resource type is one a Kubernetes target runs on the cluster itself: a
ComputeCluster is a set of logical pools the Operator validates and a Sandbox is a pod.
Setup creates no cloud infrastructure for either, and runtime provisioning verifies them
through the Kubernetes controllers rather than a cloud controller.
Whether this resource is a cloud database (Postgres or Redis) whose private endpoint needs a
network of the cloud’s own. On a Kubernetes target a stack keeps a network for it in every
cluster mode; without one an existing cluster’s own network serves the workloads.
Whether value is a well-formed request key: 1..=64 characters of [A-Za-z0-9_-]. The
binding, the manager route and the verifier all call this one function.
Whether this resource keeps a network of the cloud’s own on a Kubernetes target, in every
cluster mode: a cloud database, or an extension type whose descriptor requires the network.
Architecture shared by source images built for this Kubernetes stack.
Unspecified pools and Workers inherit this build constraint, so their Pods
cannot land on incompatible nodes in a cluster with mixed architectures.
Match Pod placement to the architecture of the workload’s image.
The pool’s profile wins; otherwise a single built architecture recorded by
alien build for this workload (Stack::built_architectures_of) selects nodes; several built architectures
(a multi-architecture image) or none leave the Pod unconstrained, as releases
built before the build recorded it were.
This does not associate Workers with a compute pool or reserve node capacity.
What makes name unusable as an environment variable a link sets, or None when it can be
one: a letter or _ followed by letters, digits and _, outside the reserved prefixes.
The gate input of a runtime-created gated resource, None for anything
else. The mirror of frozen_gate_of — which side of the setup boundary a
gated resource falls on is decided in exactly these two places.
A live gate’s answer: the provided value, else the answer recorded when
the deployment was created (frozen dominance — a live resource sharing a
frozen-gating input follows the fixed answer, not the declared default),
else the declared default.
The oldest machine image protected installs boot: an image the cloud records as created
before this is refused even from the publisher, so a fixed image replaces every older one.
The CLI release workflow writes it (RFC 3339) into machine-image-minimum-created.txt with
the publisher; a build without it launches no machines on protected installs.
The 12-digit AWS account that publishes the machine images protected installs boot, if this
build has one. The CLI release workflow writes it into machine-image-publisher-aws.txt
before building, so every build of a release renders the same setup; source builds have none.
The public name of the Azure community gallery that publishes the machine images
protected installs boot (/CommunityGalleries/<name>/Images/...), if this build has one.
The CLI release workflow writes it into machine-image-publisher-azure.txt; source builds
have none.
The GCP project that publishes the machine images protected installs boot
(projects/<project>/global/images/<name>), if this build has one. The CLI release
workflow writes it into machine-image-publisher-gcp.txt; source builds have none.
Whether an installed AWS stack already has the machine workload grant on one
of its recorded service accounts. Having the secrets vault is not enough: a
worker gives an install the vault without the grant. Adding the grant to a
frozen profile blocks the release, and delivering secrets to a profile that
cannot read them breaks the workload, so setup and delivery share this signal.
Digest (sha256:<64 hex>) of the Operator image protected charts run, if this build has
one. The CLI release workflow writes it into operator-digest.txt with the other pins; it
is the operator digest a signed release names in components.
The deployer secret slots of a protected install: every one is read from the vault, since
the legacy delivery of a stored value is not available there. A secret input’s own value
plays no part, so what the signed release says and what setup grants agree whatever the
control plane stores for it.
Whether a Live Worker of stack is triggered by the Queue queue_id. (A setup-owned Worker’s
subscription is written by setup, which also grants on it directly.)
Whether the Queue queue_id is setup-owned (Frozen), has a dead-letter setting and is the
trigger of a Worker. A Worker’s push subscription on such a queue is not written by anything
that holds IAM write access at runtime, so setup grants the Pub/Sub service agent
roles/pubsub.subscriber for the project once (Google’s documented grant for dead-letter
subscriptions) instead. See queues_needing_project_push_subscriber.
The Queues of stack that need the project-level subscriber grant of the Pub/Sub service
agent, sorted. One grant serves all of them, so it stays while any of them remains.
Refuses an extension type that requires the network on an existing cluster when its input
also gates a frozen resource, for a setup that fixes the network when it is rendered
(CloudFormation). Declining that input drops the resource before the manager prepares the
stack, so the manager could expect no network while the setup still registers one.
The first resource setup would create that an existing cluster could not reach, as the error
a generator returns when it knows the cluster is existing. creates says whether setup
creates the resource: one the installer binds to infrastructure it already has is the
deployer’s, so it is not refused. A network the deployer names in the settings is theirs to
choose, so nothing is refused for it.
Remove mutable Live declines after mutations, retaining setup-owned node grants just as
derived service-account grants are retained. Later updates compare those Frozen configs
with the accepted render before applying Live declines. The setup digest uses this strip too.
Remove declined resources before mutations, including node grants that must name concrete
resources when the ComputeCluster mutation derives setup-owned node permissions.
Remove resources whose gate input is unavailable on this platform, including their links
and grants, plus any supplied container allocations. Unlike a mutable live decline,
these resources can never be enabled here.
Resolve defaults and validate only inputs that apply. Values for inactive
inputs are ignored, even when they would fail validation. Vault-native
secrets are checked in the deployer’s secret store instead.
The tags the template setups put on what they create for a resource, with the stack name
replaced by the resource prefix. A direct setup creating the same objects uses these.
Whether the setup is for an existing Kubernetes cluster: the cluster the source stack declares
decides; with none declared, the stack settings do. A setup that serves both modes (the
deployer picks at apply) is not “existing” here.
The prefix a rebuild’s new key still sits under: everything above the file name and the
version segment beneath it. None when nothing sits there, meaning no prefix can be granted
without also granting objects a rebuild never reads. Shared so both emitters agree on it.
Frozen-gate answers read off a stack whose Frozen declines were already stripped: a surviving
gated setup-created resource reads as yes, even when its gate was never answered. So a strip
built on it never drops what the real strip keeps: a digest can miss a match, never fake one.
Whether an environment variable with these target_resources reaches
resource_id: every resource when unset, else an exact id or a prefix*
pattern. Env delivery and the permissions that follow from it (such as
reading a deployer secret) share this one rule.
Refuse resources whose setup-owned scaffolding cannot yet be created by runtime.
Check both package generation and deployment planning, including later additions.
The AWS verifier image protected setups run, as <repository>@sha256:<64 hex> in the
publisher’s registry, if this build has one. The CLI release workflow writes it into
verifier-image-aws.txt with the publisher; setups run
<publisher>.dkr.ecr.<region>.amazonaws.com/<repository>@<digest>.
The Azure verifier image protected setups run as a Container App, as
<registry host>/<repository>@sha256:<64 hex> in a registry that serves it without
credentials, if this build has one. The CLI release workflow writes it into
verifier-image-azure.txt.
The GCP verifier image protected setups run on Cloud Run, as
<registry host>/<repository>@sha256:<64 hex>, if this build has one. The CLI release
workflow writes it into verifier-image-gcp.txt.