Cloud Change Under Approval: The AWS and Azure Content Packs
Most cloud change today is approved in one place and executed in another. A ticket is approved; a pipeline, a console session or a script runs the change. The two are joined by a reference number and by trust. When an auditor asks what actually ran, the answer is a log somewhere, assembled after the fact.
The AWS and Azure content packs close that gap. A cloud operation becomes an OpsChain step: it runs under the approval policy bound to the estate path, with secrets resolved from vault custody and masked, and the result lands in the hash-chained evidence lane next to every other change.
What a content pack is
A content pack is a signed bundle of actions, scripts and the tool they drive, installed on the platform and gated by an entitlement in your licence. packs:aws and packs:azure are the two cloud packs. An installed pack version is visible to every template that pins it, and the platform shows what references a version before it lets you delete it.
The packs are not wrappers around a vendor CLI. Each ships a small tool, hand-built in Go on the vendor's own SDK, that the runner executes from the signed bundle. There is no interpreter to install and no shell to escape into.
The AWS pack
The AWS pack exposes the aws-sdk-go-v2 operation surface of ten services as governed actions: CloudFormation, EC2 (including VPC and EBS), EKS, ELBv2, IAM, Lambda, RDS, Route 53, S3 and STS. That is over 1,600 operation actions and more than 90 waiters, generated from the SDK and typed, so aws:ec2:run_instances or aws:rds:create_db_instance takes the inputs the API takes and publishes the outputs the API returns. A generic aws:api action reaches any allowlisted client for the cases the typed set does not name.
The Azure pack
The Azure pack does the same for the ARM management surface. azure:api reaches any resource provider by path or resource id; the generated typed actions cover the services your estates run on, with resource groups and deployments, Key Vault, SQL and compute among them, and long-running operations exposed with wait semantics. Beside the generated set sit the hand-written operations a platform team needs: ARM deployments with what-if, virtual-machine run commands, image builds and gallery versions, and Key Vault secrets.
Both packs are versioned independently of the platform and released through the same signed lane as the product.
Three things the 5.6.1 packs learned on a real estate
We provisioned our own hosted platform with the Azure pack in the week before the release, and three things that only a fleet teaches went into the packs that shipped.
- Every step is self-sufficient. A composed action's first step used to install the tool into the runner's cache and the next step dialled it by path. On a fleet, the two steps can land on different runners. Now every wrapper step ensures its own tool from the pack's bundle before it dials, so no runner group needs a shared cache or host affinity.
- Inputs reach the tool byte for byte. A JSON body, a parameters object or a multi-line script passed as an action input used to be spliced into a shell line, where its quotes closed the shell string. Inputs are now staged through quoted heredocs that the shell never re-parses, so a deployment's parameters arrive exactly as you wrote them.
- A long operation is never silent. An ARM deployment, a VM provisioning or a resource-group delete reports a progress line to the step log every thirty seconds, with the elapsed time, the operation's status and, for a deployment, which resources are running, succeeded and failed. The AWS waiters do the same.
What this looks like in a change
A platform engineer raises a change against prod/environments/au-east/assets/core-network that calls azure:deployment_apply with a Bicep template and its parameters. The approval policy on the production path holds it until two named approvers act; the requester cannot be one of them. On approval, a runner in the group bound to that environment executes the step: the pack's tool authenticates with the credential the vault resolves for that environment, submits the deployment, and reports progress until ARM settles. The step's outputs carry the deployment's results. The change, its approvals, the masked inputs, the step log and the outputs are one record in the evidence lane.
Nothing in that sequence depends on a console session, a personal credential or a pipeline the auditor cannot see.
Getting the packs
The packs are installed from their signed bundles with opschain admin packs install -f <bundle>, and the platform verifies the signature against the product keyring and checks your estate's entitlement before it accepts them. They ship with OpsChain 5.6.1, which is available by invitation. Request access, or book a demo and bring the cloud change you least like running by hand.
Key takeaway
A cloud operation is a governed step: approval on the path, secrets in custody, progress in the log and the result in the evidence lane. The AWS and Azure packs make that true for 1,600 AWS operations and the Azure ARM surface, signed and licence-gated.
Ready to see OpsChain in action?
Book a personalised demo and see how OpsChain can transform your operations.
Book a DemoFounder & CEO, LimePoint
Goran is the founder of LimePoint and the creator of OpsChain. He is passionate about helping enterprises automate and govern their operations at scale.