Skip to main content
Pulumi Delivery

Your release process, in code

Replace the release glue in your CI jobs with one Pulumi program — Delivery moves each release through your stages and approvals.

Replace release glue with one program

Teams with more than a few stacks end up writing release glue. A CI job updates the network stack, waits, updates the app stacks, then pauses for someone to check staging. Delivery replaces that glue with a Pulumi program you version and review like the rest of your code, and your CI goes back to building and testing.

A Pulumi Delivery pipeline in the Pulumi Cloud console. Release 42 passes dev and staging, waits at an approval gate for two approvers, then deploys to prod.
  • Review release changes in pull requests

    Adding a staging environment or a new region is now a pull request your team reviews and merges.
  • Define deploy order in code

    Delivery reads the stack references in your programs and updates dependencies first.
  • Require approval before production

    A release waits at the production stage until your approvers sign off in Pulumi Cloud.
Andesite

“At Andesite, we've been shipping every release out to ten separate customer environments by hand. It's a process that's struggling to scale. Delivery as code is the approach we've been looking for. Defining how a release gets to our customers in code means we can add customers without adding manual work.”

Ben MileticStaff Software Engineer
Pipelines

A release pipeline is a Pulumi program

Point the pipeline at a repository on GitHub, GitLab, Bitbucket, or Azure DevOps and define its stages. Run pulumi up to create it, then push to your branch to start a release.

index.ts
import * as delivery from "@pulumi/delivery";
const app = new delivery.GitHubSource("app", {
repository: "acme/shop",
branch: "main",
trigger: true,
});
const pipeline = new delivery.Pipeline("shop", {
program: { source: app, directory: "delivery" },
});
const dev = new delivery.Stage("dev", { pipeline });
const prod = new delivery.Stage("prod", {
pipeline,
from: [dev],
when: delivery.approval({ approvers: ["platform-leads"] }),
});
const devStacks = new delivery.Stacks("dev", {
stage: dev,
stacks: {
app: { stack: "shop-infra/dev", source: app, directory: "infra" },
},
});
new delivery.Job("smoke", {
stage: dev,
source: app,
directory: "delivery",
command: "sh smoke.sh",
environment: {
ENDPOINT: devStacks.outputs.apply(o => String(o["app"]["endpoint"])),
},
});
new delivery.Stacks("prod", {
stage: prod,
stacks: {
app: { stack: "shop-infra/prod", source: app, directory: "infra" },
},
});
  • Deploy every region with a loop

    Write a function that deploys one region and loop over your list of regions — adding a region is a one-line change.
  • Group dependent stacks

    Delivery updates the stacks in a group in order, and each stack gets fresh outputs from its dependencies.
  • Run releases on Pulumi Cloud

    Stack updates and jobs run on Pulumi-managed runners, and you can pin a container image to control CLI and language versions.
Stages and gates

Promote each release stage by stage

Every release has to pass staging, your smoke tests, and its approvals before it touches production. If anything fails, the release stops.

  • What you tested is what ships

    Each release locks its commit when it starts — production gets exactly the code that passed staging.
  • The right people sign off

    Choose who approves each stage, and they see a preview of every stack update before anything changes.
  • Catch problems before production

    Smoke tests after each stage stop a bad release early, and a manual gate holds it for a hands-on check.
  • Separate credentials for every stage

    Each stage gets its own Pulumi ESC environment with short-lived credentials, and staging never holds production keys.
Connected pipelines

Hand values from one pipeline to the next

When the platform team ships a new cluster endpoint to production, every app team's pipeline picks it up and redeploys on its own — no tickets or Slack pings between teams.

  • Only production-ready values

    Publish endpoints and image tags from a release, and other pipelines pick them up only after it reaches production.
  • Built for monorepos

    Each pipeline starts only when its own paths change, and one team's commit never redeploys another team's stacks.
  • Least privilege for every pipeline

    Each pipeline runs as its own service principal with access to just the stacks it deploys.
Operations

When a release fails, retry, roll back, or pause

A failed release waits for you — Delivery never retries on its own, and you choose the fix from the Pulumi Cloud console or the REST API.

  • Retry what failed

    Rerun just the updates and jobs that failed, on the same commit, instead of restarting the whole release.
  • Roll back a stage

    Put a stage back on any earlier release, and hold new runs until you're ready.
  • Pause and force-promote

    Pause a stage while you investigate, or force-promote an urgent fix past its gate.
  • Control who can ship

    Let someone edit a pipeline without letting them approve or force-promote, and see every approval and stage change in the audit log.

Build your first pipeline

Pulumi Delivery is in public preview. Set up a pipeline with a dev stage, a smoke test, and a prod stage behind an approval gate.

How Delivery works

Follow a release through every stage, from commit to production.

The infrastructure platform for humans and agents.