New: Native support for Terraform and HCL

Unleash agents
on your infrastructure.

Ship infrastructure faster with tools that let agents do what they do best — without letting them go off the rails.

import * as aws from "@pulumi/aws";
import * as awsx from "@pulumi/awsx";

const vpc = new awsx.ec2.Vpc("vpc");
const azs = await aws.getAvailabilityZones({ state: "available" });

const subnets = azs.names.map((az, i) =>
  new aws.ec2.Subnet(`subnet-${i}`, {
    vpcId: vpc.vpcId,
    cidrBlock: `10.0.${i}.0/24`,
    availabilityZone: az,
  })
);

import pulumi_aws as aws
import pulumi_awsx as awsx

azs = aws.get_availability_zones(state="available")
vpc = awsx.ec2.Vpc("vpc")

for i, az in enumerate(azs.names):
    aws.ec2.Subnet(f"subnet-{i}",
        vpc_id=vpc.vpc_id,
        cidr_block=f"10.0.{i}.0/24",
        availability_zone=az,
    )

package main

import (
    "fmt"

    "github.com/pulumi/pulumi-aws/sdk/v6/go/aws"
    "github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
    awsx "github.com/pulumi/pulumi-awsx/sdk/v2/go/awsx/ec2"
    "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
        vpc, _ := awsx.NewVpc(ctx, "vpc", nil)
        azs, _ := aws.GetAvailabilityZones(ctx, &aws.GetAvailabilityZonesArgs{State: pulumi.StringRef("available")}, nil)

        for i, az := range azs.Names {
            ec2.NewSubnet(ctx, fmt.Sprintf("subnet-%d", i), &ec2.SubnetArgs{
                VpcId:            vpc.VpcId,
                CidrBlock:        pulumi.String(fmt.Sprintf("10.0.%d.0/24", i)),
                AvailabilityZone: pulumi.String(az),
            })
        }
        return nil
    })
}

using System.Linq;
using Pulumi;
using Pulumi.Aws;
using Pulumi.Aws.Ec2;

return await Deployment.RunAsync(() =>
{
    var vpc = new Pulumi.Awsx.Ec2.Vpc("vpc");
    var azs = GetAvailabilityZones.Invoke(new() { State = "available" });

    var subnets = azs.Apply(result =>
        result.Names.Select((az, i) =>
            new Subnet($"subnet-{i}", new()
            {
                VpcId = vpc.VpcId,
                CidrBlock = $"10.0.{i}.0/24",
                AvailabilityZone = az,
            })
        ).ToList()
    );
});

package myproject;

import com.pulumi.Pulumi;
import com.pulumi.aws.ec2.Vpc;
import com.pulumi.aws.ec2.Subnet;
import com.pulumi.aws.ec2.SubnetArgs;
import com.pulumi.aws.AwsFunctions;
import com.pulumi.aws.inputs.GetAvailabilityZonesPlainArgs;

public class App {
    public static void main(String[] args) {
        Pulumi.run(ctx -> {
            var vpc = new Vpc("vpc");

            var azs = AwsFunctions.getAvailabilityZonesPlain(
                GetAvailabilityZonesPlainArgs.builder()
                    .state("available")
                    .build()
            ).join();

            var names = azs.names();
            for (int i = 0; i < names.size(); i++) {
                new Subnet("subnet-" + i, SubnetArgs.builder()
                    .vpcId(vpc.id())
                    .cidrBlock("10.0." + i + ".0/24")
                    .availabilityZone(names.get(i))
                    .build());
            }
        });
    }
}

terraform {
  required_providers {
    aws = {
      source  = "pulumi/aws"
    }
    awsx = {
      source  = "pulumi/awsx"
    }
  }
}

resource "awsx_ec2_vpc" "vpc" {}

data "aws_availability_zones" "available" {
  state = "available"
}

resource "aws_subnet" "subnet" {
  count             = length(data.aws_availability_zones.available.names)
  vpc_id            = awsx_ec2_vpc.vpc.vpc_id
  cidr_block        = "10.0.${count.index}.0/24"
  availability_zone = data.aws_availability_zones.available.names[count.index]
}

variables:
  azs:
    fn::invoke:
      function: aws:getAvailabilityZones
      arguments:
        state: available

resources:
  vpc:
    type: awsx:ec2:Vpc

  subnet-0:
    type: aws:ec2:Subnet
    properties:
      vpcId: ${vpc.vpcId}
      cidrBlock: "10.0.0.0/24"
      availabilityZone: ${azs.names[0]}

  subnet-1:
    type: aws:ec2:Subnet
    properties:
      vpcId: ${vpc.vpcId}
      cidrBlock: "10.0.1.0/24"
      availabilityZone: ${azs.names[1]}

Trusted by over 4,000 innovative companies

The infrastructure platform for humans and agents

Coding agents have reset the pace at which we build software. Pulumi brings that same agent-driven velocity to infrastructure.

Open source and powered by languages agents know well, Pulumi is software-driven infrastructure that gives humans and agents the tools they need to build and scale infrastructure — safely.

Explore the platform

Use your language of choice

Build infrastructure with modern languages like TypeScript, Python, Go, C#, and more — or config languages like YAML and HCL.

Keep it secure at every step

Meet compliance requirements with encrypted secrets, dynamic credentials, policy as code, and full audit trails. Pulumi is SOC 2 Type II certified.

Bring full context to agents

Use our open-source skills with any coding agent — or use Pulumi Neo — to automate workflows with best practices and full organizational context.

"Pulumi helped our team to ship a new product faster. We needed one tool to set up and manage multi-cloud, multi-region Kubernetes clusters that infrastructure and applications teams could use collaboratively."

Justin Fitzhugh

VP of Cloud Platform Engineering

Don't just write IaC — compose it

Take full advantage of your preferred language to build reusable components and share them with package managers like npm, PyPI, and NuGet. Get all of the benefits of your IDE, including type checking, code navigation, inline docs, testing, and more.

Learn more about IaC

Meet Neo, your AI platform engineer

The first AI agent built for infrastructure, Pulumi Neo understands your code and organizational context, respects your policies, and executes complex tasks end-to-end — with or without a human in the loop. And it works alongside the coding agents you already use.

Learn more about Neo

Centralized configuration & secrets

A single interface across all of your secrets. Pull in Vault, AWS Secrets Manager, Azure Key Vault, and more, plus support for short-lived creds with OIDC.

Learn more about Pulumi ESC

Discovery & governance

Use natural language queries to find managed and unmanaged resources — even across clouds. Enforce policies, track compliance in real-time, and find vulnerabilities before they become incidents.

Learn more about Discovery & governance

Self-service infrastructure

Define golden paths for approved infrastructure with configurable components and customizable templates that enable developers while keeping platform teams in control.

Learn more about IDP

Trusted by 4,000+ innovative companies

See how engineering teams use Pulumi to ship infrastructure faster, improve security, and reduce cloud complexity.

Read our customer stories

“There’s no question that, if we had gone down the traditional infrastructure automation route, it would have taken us a week or a week and a half to do one deployment of the cluster […] When we demonstrated to people that what used to take a week and a half now, with Pulumi, took under a day, they were shocked.”

Raman Hariharan, Director of Cloud Platform Engineering, Snowflake

“The infrastructure team acts as groundkeepers of our Pulumi practices, not gatekeepers, but promoters for the entire org.”

Paul Cioanca, Platform Engineer at Supabase

“Pulumi supercharged our infrastructure team by helping us create reusable building blocks that developers can leverage to provision new resources and enforce organizational policies for logging, permissions, resource tagging, and security."

Igor Shapiro, Principal Engineer, Lemonade

“Terraform relies on HCL and lacks support for concepts like classes, objects and inheritance. An equivalent deployment would take more lines of code while yielding IaC that is less reusable.”