Forem: Pulumi Team

Superintelligence Infrastructure: Managing AI Workloads with General-Purpose Programming Languages

Pulumi Team — Wed, 17 Dec 2025 17:42:13 +0000

AI Infrastructure Is Outgrowing Static Configuration

AI systems no longer resemble traditional application stacks. Training large models, running distributed inference, and scaling GPU-backed services introduce infrastructure patterns that change constantly. Capacity shifts. Regions rebalance. New services appear and disappear based on demand.

Static configuration tools struggle in this environment. They assume infrastructure is declared once and applied repeatedly. AI workloads require infrastructure that behaves like software: adaptive, testable, and designed to evolve.

Superintelligence Infrastructure is built for that reality.

Infrastructure Defined with General-Purpose Programming Languages

Pulumi allows teams to define cloud infrastructure using general-purpose programming languages such as Python, TypeScript, and Go. For AI platforms, this unlocks capabilities that are difficult or impractical to express in declarative templates:

Conditional resource creation based on model type or environment
Loops for provisioning large, dynamic GPU fleets
Shared abstractions for training, tuning, and inference pipelines
Unit tests and previews before deploying infrastructure changes

Infrastructure becomes part of the application lifecycle instead of a separate, static artifact.

Designed for Large-Scale AI Environments

Superintelligence Infrastructure supports AI workloads operating at massive scale, including environments with tens of thousands of resources across regions and cloud providers.

Common use cases include:

Distributed training clusters with elastic GPU capacity
Multi-region inference services with low-latency routing
Automated teardown and rebuild of experimental environments
Policy-enforced deployments for security, cost, and compliance

These systems are defined, reviewed, and deployed using the same engineering workflows teams already use for application development.

AI-Native Operations with Pulumi

Pulumi integrates AI-assisted workflows directly into infrastructure management. Platform teams can use AI to explore infrastructure state, detect drift, generate updates, and apply changes safely under policy control.

This approach reduces manual intervention while keeping humans in the loop through previews, approvals, and audit trails.

Superintelligence Infrastructure combines automation with governance instead of trading one for the other.

A Practical Path to Production AI Infrastructure

For teams building AI platforms, the challenge is not experimentation. The challenge is turning prototypes into durable, repeatable production systems.

Pulumi provides a foundation that supports:
Rapid iteration during early model development
Controlled promotion into production environments
Ongoing evolution as models, data, and usage change

Learn how Superintelligence Infrastructure is used to manage AI systems.

What AWS’s 2025 AI and Cloud Updates Mean for Engineers Building Large Systems

Pulumi Team — Thu, 11 Dec 2025 15:58:12 +0000

AWS announced major changes this year that affect how teams design, train, and operate large-scale systems. If you work in AI infrastructure, MLOps, or cloud engineering, several releases stand out for their long-term impact.

Pulumi put together a full breakdown, but here is the technical signal behind the announcements.

Nova Forge and the new model training workflow

AWS is shifting model training toward a platform-based workflow. Nova Forge abstracts much of the orchestration, data movement, and scaling logic that teams previously had to build themselves. This is important because training pipelines are becoming too large and too complex for ad-hoc solutions.

For teams building specialized LLMs or domain-specific models, this lowers both time and operational overhead.

Trainium 3 and the next stage of high-throughput compute

Trainium 3 extends AWS’s hardware roadmap with higher throughput and deeper integration into the broader AI stack. The takeaway is that large-scale training is becoming more predictable and better supported by AWS-native services.

This matters for iteration speed and total cost at scale.

AgentCore’s move toward structured automation

AgentCore is evolving from helper APIs into a system that understands user intent and applies guardrails across environments. This is a step toward infrastructure that can participate in operations rather than simply expose endpoints.

For teams wrestling with multi-environment complexity, this points toward more automated operational patterns.

A shift in what cloud engineering workflows look like

The common pattern across these launches is integration. Compute, orchestration, training workflows, and automation are becoming parts of a single continuum rather than separate tools stitched together.

Pulumi’s analysis places these changes in the bigger shift toward adaptive infrastructure. Tools like Neo align with this direction by introducing AI-supported workflows into everyday development.

Read the full analysis

For a deeper look at how AWS is shaping AI and cloud infrastructure going into the next decade, read "AWS built an integrated AI Agent training pipeline and they want you to rent it".

Zero to Production with AI Agentic Workflows – Free Hands-On Course

Pulumi Team — Fri, 03 Oct 2025 22:08:38 +0000

Manual infrastructure tasks slow teams down. AI agents and agentic workflows offer a new way forward—reducing repetitive work, improving governance, and unlocking more time for strategy and innovation.

We’re launching a free, hands-on virtual course:
Zero to Production with AI Agentic Workflows
Starts October 14

Over the course of five interactive workshops, you’ll learn how to:

Apply AI agents to accelerate platform engineering
Streamline infrastructure provisioning with automation
Balance developer autonomy with governance at scale
Create reusable patterns and templates to boost productivity
Handle surges in infrastructure demand with intelligent automation

Each session includes live instruction, hands-on labs, and Q&A.
Recordings will be available only to registered participants. Participants who attend all the workshops will earn a completion badge to showcase their skills. Register for the course.

Meet Neo: Your Newest Platform Engineer

Pulumi Team — Thu, 11 Sep 2025 17:27:32 +0000

Infrastructure teams are drowning in demands. While your organization races to adopt AI, platform teams are stretched thin managing the infrastructure demands. What if there was a better way?

Meet Neo, your newest platform engineer teammate.

See what's possible when intelligence meets infrastructure.

Join us September 16th at 10:00 AM PT (UTC-7) for the exclusive introduction to Neo. Save the date now, don't miss out!

🚀 Pulumi AWS Provider 7.0: Multi-Region AWS IaC & IAM Role Chaining

Pulumi Team — Tue, 12 Aug 2025 15:41:29 +0000

Pulumi AWS Provider 7.0 is here, bringing major enhancements to AWS infrastructure as code workflows.

What’s New Highlights

Multi-region support from a single provider: Define resources in different AWS regions without duplicating provider configurations.
IAM role chaining: Securely assume multiple roles for complex cross-account deployments.
S3 resource simplification: Unified bucket resources for easier migration and management.

Why It Matters

These updates make it easier to manage scalable, secure, multi-region AWS deployments in general programming languages such as TypeScript, Python, Go, C#, or Java.

📖 Full release notes, migration guide, and code examples at Pulumi AWS Provider 7.0.

Kubernetes Best Practices I Wish I Had Known Before

Pulumi Team — Thu, 03 Apr 2025 18:23:36 +0000

Getting started with Kubernetes can feel like climbing Mount Everest in flip-flops. On the surface, it seems straightforward—deploy your containerized app and go. But then the iceberg hits: YAML sprawl, mysterious Pod evictions, and networking tangles that make you question everything.

After years wrangling Kubernetes in production, I’ve pulled together a shortlist of lessons I wish someone had handed me on Day 1. These aren't just tips—they're sanity savers.

🚨 Don't Skimp on Resource Requests & Limits
Skipping these? Say hello to throttling and unexpected Pod evictions. Use tools like Prometheus to fine-tune based on real usage.

📛 Namespace Like Your Life Depends on It
Namespaces are more than folders—they’re your key to organizing, securing, and scaling your workloads. Pair them with RBAC for a tighter ship.

🎯 Use Probes for Container Health
Liveness, readiness, and startup probes let Kubernetes know if your app is working. Without them, your cluster is flying blind.

🔐 Security: Non-Negotiable
Set RBAC from Day 1. Use Pod Security Standards. Store secrets securely (hint: not in environment variables—use tools like Pulumi ESC or external secrets stores).

📦 Don’t Handcraft YAML Forever
Use Helm, Kustomize, or tools like Pulumi to manage infra with code. Your future self (and teammates) will thank you.

📊 Monitor Everything
From metrics (Prometheus) to logs (Loki, EFK) and traces (Jaeger), observability is your safety net. Set alerts before things break.

⚙️ Automate Deployments
Embrace CI/CD and GitOps to avoid the “it works on my machine” dilemma. Tools like Argo CD or GitHub Actions are your friends.

This is just the tip of the iceberg. Want to avoid common Kubernetes pitfalls and keep your clusters running smoothly

👉 Read the full article: Kubernetes Best Practices I Wish I Had Known Before

The Cloud Container Iceberg - At least 105 ways to run a container in the cloud

Pulumi Team — Fri, 28 Feb 2025 16:45:57 +0000

If it connects to the internet, someone has tried running a container on it. From AWS racks packed with phones to quantum computers, the world of container deployment extends far beyond the usual cloud providers. You might think you know where containers run—but that’s just the tip of the iceberg.

At the surface, there are the well-known cloud platforms: AWS, Azure, and Google Cloud, with services like Kubernetes, Fargate, and Cloud Run. But below the waterline? That’s where things get interesting.

Beyond the Surface: The Hidden Depths of Container Hosting

Just below the mainstream, you’ll find alternative cloud platforms and regional providers—some offering K8s with local flair, others designed for hyper-specific workloads. Venture deeper, and you’ll discover serverless platforms that use containers in unexpected ways, experimental multi-cloud orchestration, and hybrid deployments that let you run containers across data centers, IoT devices, and even mail-delivered hardware.

And if you're willing to go all the way down? Containers at the edge—running on factory equipment, Raspberry Pis, and, yes, even smart toasters.

How Deep Does the Iceberg Go?

The Usual Suspects – The mainstream cloud container services you already know.
The Lesser-Known Options – Specialized K8s providers, regional cloud giants, and alternative deployment platforms.
The Experimental Zone – Serverless containerized workloads, hybrid-cloud solutions, and multi-cloud orchestration nightmares.
The Abyss – Containers in places they should never be: quantum computers, edge devices, and mobile test farms.

The world of container hosting is far bigger than it seems. What starts with Kubernetes in the cloud quickly spirals into a rabbit hole of specialized services, hybrid solutions, and experimental edge cases.

Want to see the full breakdown?

🔗 Dive into the complete article here: The Cloud Container Iceberg

Introducing Azure Native 2.0

Pulumi Team — Wed, 14 Jun 2023 21:32:19 +0000

We are thrilled to announce the beta release of the Pulumi Azure Native Provider 2.0, a significant upgrade to Pulumi’s native provider for Microsoft Azure. The Azure Native provider offers the most complete support for Azure possible - with same day access to the entire surface area of the Azure features from Azure Resource Manager. Every property of each module is always represented in the SDKs. The 2.0 release brings a host of exciting features and improvements for performance and usability that will enhance your experience with managing Azure resources and empower you to build robust and scalable cloud infrastructure more efficiently.

At Pulumi, we understand the importance of keeping up with the ever-evolving cloud landscape. The Pulumi Azure Native Provider 2.0 represents our commitment to providing you with the best tools to harness the full power of Microsoft Azure. With automatic generation from Azure API specs, we are able to provide you with same-day access to the entire Azure API surface including all available properties. Let’s dive into some of the key enhancements in this release!

Reduced SDK Size for Faster Development

We’ve listened to your feedback and have made significant optimizations to the Azure Native Provider SDKs. With careful fine-tuning and restructuring, we have achieved a significant decrease in size of over 50% for SDKs with multi-versioned modules. This improvement translates into faster development times, reduced resource consumption, and an overall smoother experience when working with the provider.

So, how did we accomplish this? For starters, we’ve removed all deprecated Azure API modules up to the 2.0 release date. The bigger impact was made by identifying and removing all forward-compatible module versions. That is to say we’ve excluded any redundant versions and kept only the versions that introduce breaking changes. Where these versions are not the current latest and new default, they remain available as explicit versions.

You may be wondering about the significance between explicit and default versions. Well, when Azure releases new features they often create a new version of a service API. These versions are named using dates such as “2021-01-02” or “2022-05-08-preview”. There’s many versions of each module in the SDK, so we pick a version of each module for the top-level default. To learn more about module versions, visit the Azure Native Version Guide.

Refreshed Default Module Versions

In the latest release, we have refreshed the default module versions to align with the latest Azure API versions from Microsoft. With our continued commitment to same-day access to Azure API surface, you always have access to the most up-to-date features and capabilities offered by Azure services. By leveraging the latest module versions, you can take advantage of the latest and most desired features directly from Azure while building your infrastructure with Pulumi.

If you would like to upgrade to 2.x, but continue using the same Azure API version that was used in your 1.x, you can do that by specifying the compatible explicit version available in the 2.x provider. Shown below are examples of how that change might look.

(TypeScript)

- import { EventSubscription } from "@pulumi/azure-native/eventgrid";
+ import { EventSubscription } from "@pulumi/azure-native/eventgrid/v20200601";

Expanded Top-Level Default Module Coverage

We’re excited to expand our top-level default version coverage by 226 resources, 274 functions, and 5526 input properties in this release, bringing the total to 1,637, 2,015, and 30,652 respectively. With this extensive collection of modules at your disposal, you can easily provision and manage the full range of Azure services using Pulumi. Whether you’re working with virtual machines, databases, networking, or any other Azure service, the Azure Native Provider has you covered.

Resolved Title Case Inconsistency

For a consistent and predictable experience across the provider, we have resolved an issue with title case inconsistencies across resources and functions. All previous resource names have been aliased, and do not require any changes to the Pulumi program. However, functions that have a corrected name will need to be updated. This enhancement ensures a unified and predictable experience while working across resource types, making it easier for you to navigate and understand the provider’s capabilities.

Simplified User Assigned Identity Inputs

We have simplified the representation of user assigned identity inputs by recognizing them as string arrays. This change provides a more intuitive and clear approach when configuring user assigned identities for your Azure modules. You can now reference these as UserAssignedIdentities: [exampleUserAssignedIdentity.id] without jumping through any hoops.

import * as resources from "@pulumi/azure-native/resources";
import * as managedidentity from "@pulumi/azure-native/managedidentity";
import * as storage from "@pulumi/azure-native/storage";

// Create a resource group
const resourceGroup = new resources.ResourceGroup("my-resource-group");

// Create a user-assigned managed identity
const userAssignedIdentity = new managedidentity.UserAssignedIdentity("my-user-assigned-identity", {
    resourceGroupName: resourceGroup.name,
});

// Create a storage account that references the user-assigned managed identity
const storageAccount = new storage.StorageAccount("mystorageaccount", {
    resourceGroupName: resourceGroup.name,
    kind: "StorageV2",
    location: resourceGroup.location,
    identity: {
        type: "UserAssigned",
        userAssignedIdentities: [userAssignedIdentity.id],
    },
    sku: {
        name: "Standard_LRS",
    },
});

Before this change, the identity block would need to use an apply as follows:

user_assigned_identity.id.apply(lambda id: {id: {}})
Migrating from 1.x to 2.x

We recommend you update to the latest version of Azure Native 1.x prior to moving to 2.x. This will enable you to address existing deprecations and see the recommended substitutions ahead of the major version upgrade. Head over to the migration guide which outlines the necessary steps to update your existing Pulumi projects and ensuring a smooth migration experience.

Current users of the Pulumi Azure Classic Provider can follow the classic to native migration guide to take advantage of all the latest and greatest features available in Pulumi the Azure Native Provider.

While you can immediately start leveraging the improved performance, you may need to make some changes in order to continue using specific Azure API module versions or user assigned identity inputs. Use the Pulumi Azure Native Provider documentation within your IDE to determine the explicit API version that is available and fully compatible with your existing deployment.

The Pulumi Azure Native Provider 2.0 beta is available today for Pulumi programs using TypeScript, Python, .NET, and Go. To learn more about the Pulumi Azure Native Provider 2.0 and explore its capabilities, check out our updated documentation and resources. We value your feedback and encourage you to reach out in community slack or open an issue for any questions or suggestions.

Try out the Pulumi Azure Native Provider 2.0 beta today and take the next step in your journey with infrastructure as code on Microsoft Azure!

Review Stacks: Collaborate in the Cloud

Pulumi Team — Wed, 14 Jun 2023 21:24:50 +0000

Today we’re excited to announce Review Stacks – dedicated cloud environments that get created automatically every time a pull request is opened, all powered by Pulumi Deployments. Open a pull request, and Pulumi Deployments will stand up a stack with your changes and the Pulumi GitHub App will add a PR comment with the outputs from your deployment. Merge the PR and Pulumi Deployments will destroy the stack and free up the associated resources. It has never been simpler to pick up an unfamiliar codebase, make changes to both application and infrastructure code, and share a live environment for review with your teammates.

Ephemeral environments for front-end development and static websites have become commonplace in recent years, but infrastructure and complex systems have been unsupported up until this point. Review Stacks enable you to iterate on both application code changes and infrastructure code changes at the same time. Making changes to HTML, CSS, Next.js, Go APIs, Pulumi configuration, subnet configuration, databases, and load balancers are all possible with Review Stacks. No more fumbling with out-of-date READMEs and developer documentation. Just open a pull request and you can start testing changes against everything from simple static websites to API servers, microservices, data pipelines, Kubernetes clusters, and any other piece of infrastructure across Pulumi’s 100+ cloud providers.

Review Stacks manage the full lifecycle of your cloud development environment including creating it when the PR is opened, updating it every time a new commit is pushed, and destroying and cleaning up all cloud resources when the pull request is merged or closed. They even integrate with GitHub checks so that you can gate your pull requests on successful Review Stack deployments.

Pulumi customers already using Review Stacks find that it saves their developers time. Having a standardized process for development environments and change management makes it easier to onboard new developers, and load-balance teammates onto unfamiliar projects and codebases. It also makes it substantially easier for developers to work on multiple feature branches and bug fixes at the same time, as they don’t have to worry about manually maintaining and juggling development environments.

“Pulumi allows every engineer to build and update infrastructure instead of only our infrastructure team, which enables us to ship faster than if we were using a domain-specific language,” said Aaron Gibralter, head of engineering, Mighty. “With Pulumi Deployments, we could easily set up a standardized CI/CD infrastructure workflow for every engineer that immediately makes them productive. Review Stacks automates the work of managing our own ephemeral infrastructure and makes our lives easier.”

Review Stacks also provide an avenue for optimizing cloud costs. Rather than keeping development infrastructure running 24/7, Review Stacks only exist as long as an engineer works on a feature. Since Review Stacks are flexible and built on Pulumi IaC, it is also possible to configure it to deploy to multi-tenant environments that share development infrastructure to further streamline costs.

“At GitHub, we are constantly seeking to improve the developer experience and our partner ecosystem plays a big role in that.” said Matthew Manning, Senior Business Development Manager for GitHub Actions, “The launch of Pulumi Review Stacks with GitHub makes it easier for teams to review and test their products before shipping which ultimately improves the developer experience.”

Configuring Review Stacks

Configuring Review Stacks is a simple three-step process:

Create a new stack, by convention named pr, and corresponding Pulumi.pr.yaml configuration file - this config will be copied into every review stack that gets created, and can even be modified within a PR.
Configure Deployment Settings for the stack - this specifies how to acquire source code, cloud credentials and more when deploying via Pulumi Deployments.
Set the pullRequestTemplate Deployment Setting to true - this indicates that all pull requests against this stack’s branch should reference this stack as a Review Stack template.

You can use an existing stack as a Review Stack template, as long as it has Deployment Settings configured. This will result in Review Stacks being deployed into the same cloud account. If you want to separate the cloud resources in your production stack from the resources created via Review Stacks then you can create a separate stack and template that references a different cloud account (AWS, Azure, GCP, etc).

Review Stacks and Deployment Settings can be configured via the Pulumi Cloud console, the Pulumi Cloud REST API, or within a Pulumi Program using the Pulumi Cloud Resource Provider.

Pulumi Cloud UI

It is just one click to turn on Review Stacks via the Pulumi Cloud console.

REST API

You can programmatically configure Review Stacks and Deployment Settings at scale across thousands of projects using the Deployments REST API.

curl -i -XPOST -H "Content-Type: application/json" -H "Authorization: token $PULUMI_ACCESS_TOKEN" \
--location "https://api.pulumi.com/api/preview/org/project/stack/deployment/settings" \
-d '{
  "gitHub":{
    "pullRequestTemplate": true
    }
}'

Pulumi Cloud Resource Provider

You can use Pulumi to manage and code review Deployment Settings and Review Stacks with the Pulumi Cloud Provider.

import * as pulumiservice from "@pulumi/pulumiservice";

const deploymentSettings = new pulumiservice.DeploymentSettings("deploymentSettings", {
    organization: pulumi.getOrganization(),
    project: "your project",
    stack: "your stack",
    github: {
        deployCommits: true,
        previewPullRequests: true,
        pullRequestTemplate: true,
        repository: "pulumi/deployment-automation",
    },
    sourceContext: {
        git: {
            branch: "refs/heads/main",
            repoDir: "pulumi-pet-shop",
        },
    },
});

Collaborate in the Cloud

At Pulumi, our engineering team writes a ton of code. We have hundreds of repositories with programs managing thousands of stacks and tens of thousands of cloud resources. These tools and services power production workloads, internal tools, business intelligence and process, and more. And of course we use Pulumi to ship all of it. When you’re an engineer working in one of these repositories, making a code change is the easy part. The hard part is figuring out how to get a tight dev loop going—in particular, faithfully verifying your changes before merging and deploying them. Are there instructions in the README for running locally? A Docker Compose file? Or maybe standalone dev environments? Can I figure out what config and upstream stack references are required to stand up a fresh dev stack? And what about service dependencies? Pulumi makes it incredibly easy to build in the cloud and write prolific amounts of code, however, with that increase in development velocity comes a need to standardize the entire process by which we develop, test, review, and ship our code.

We’ve heard similar stories from hundreds of customers. From startup teams of five to enterprises of thousands, they’re all looking for the same thing - so we went ahead and built it. With Review Stacks and Pulumi Deployments, you can ship with greater velocity, confidence, and collaboration.

Check out these resources and get started today:

*Review Stacks documentation
*Learn more about Pulumi Deployments
*Join us in the #pulumi-deployments community slack channel
🚀🚀🚀 Happy building! 🚀🚀🚀

Property Search: Enhanced Resource Search in Pulumi Cloud

Pulumi Team — Wed, 14 Jun 2023 21:15:55 +0000

Two months ago we launched Resource Search for Pulumi Cloud to offer multi-cloud resource search and analytics across every cloud environment in your organization. Today, we’re excited to announce that we are taking this a step further and exposing a much larger set of data to search over: resource properties.

Including property names and values in your resource searches enables you to search on an even richer variety of dimensions, everything from instance type, to database version, to region and availability zone, to whether resources are open to the internet. By searching on property data, in addition to overall resource metadata, you can craft expressive queries that serve key compliance, operational and diagnostic use cases.

Pulumi Resource Search, including the ability to search on property data, is applicable across all cloud resources, whether they reside in AWS, Google Cloud, Azure, or any of Pulumi’s 100+ cloud providers. Support for querying on property data is available in the Enterprise and Business Critical editions of Pulumi Cloud.

Feature Overview

Cloud resources come with various properties that define their behavior, performance, location, and more. You can now use Pulumi Resource Search to search based on these properties in addition to other resource metadata across 100+ clouds. Whether you’re trying to find resources running in a specific region, instances with a particular tag, or databases running a certain engine version, searching over properties with Pulumi Cloud streamlines and simplifies your tasks.

Using the new feature is simple and straightforward. Go to the Pulumi console, navigate to the search bar, and start typing the property you’re interested in. For example, if you’re searching for all AWS RDS instances running MySQL with a particular engine version, simply type .engineVersion:5.7 and press enter.

The ability to search for resources based on their properties is a powerful tool for optimizing cloud resource management. It provides deeper insights into your infrastructure and aids in identifying resources that are misconfigured, out-of-date, or not adhering to your organization’s best practices. Essentially, it’s a significant step towards more proactive, informed, and efficient management of your cloud environment.Customers like Alkira, a company that reinvents networking for the cloud era, have found it to be a significant step towards more proactive, informed, and efficient management of the cloud.

“I’m making developers at Alkira significantly more productive while also making my job easier using Pulumi’s IaC platform and features like Pulumi Insights and Deployments,” said Santosh Dornal, Head of Software Test & DevOps, Alkira. “I can get developers using IaC immediately with Pulumi Deployments and its GitHub integration, while Pulumi Insights makes it really easy to find idle developer environments that need to be shut down, which reduces our cloud costs.”

Example queries

Before Property Search, using just Resource Search, you were able to find resources by their name, type, URN, parent, the team they are in, and so on… but today, any property on your resource will be indexed by Pulumi Cloud and searchable after each stack update. Let’s walk through some examples of the types of queries you can now perform.

AI Assist & properties

Pulumi AI Assist allows you to use natural language to search for resources. AI Assist works by converting natural language to a query in our search syntax. This becomes even more valuable with property search. Resources can have dozens of properties, and remembering exactly how to search for property values can be challenging, especially when they change depending on the provider. AI Assist is going to step in so that you don’t have to remember everything.

Here is a list of example natural language queries we have seen customers use and the AI Assist output:

Search syntax

Properties can be used in your queries by using a . prefix. For example, if you want to see all resources with an Instance Type property, you type in the search bar .instanceType:. If you want to only look at a specific value, you can search for the value behind the colon. In this case our query would become .instanceType:t3.large.

Here are some query examples we have seen customers use:

*project:pulumi-service stack:staging .instanceType:
*type:aws:rds/cluster:Cluster .engine:aurora .engineVersion:8
*type:aws:s3/bucket:Bucket stack:production .acl:public-read
*team:data package:snowflake .availabilityZone:us-west-2a
*vpc created:2023-06-12 .tags.Environment:production

Use the REST API

In addition to searching for resources you can also export them to perform analytics: whether that is something simple like opening it in a spreadsheet or something more sophisticated, like if you want to regularly ingest it to your data warehouse. You can download a CSV from the console or get the data using the Data Export API.

But the value of Resource Search is not limited to what you do in the console and for analytics. You can also leverage the Resource Search API to create automation and workflows off of search results. Find below details on how to use the API.

TypeScript

const headers = {
  Accept: "application/json",
  Authorization: "token pul-abc123",
};

const body = await(
  await fetch("https://api.pulumi.com/api/orgs/{org}/search/resources?properties=true?query=.instanceType", {
    method: "GET",
    headers: headers,
  }),
).json();

console.log(body);

Wrapping it all up

We are excited to be extending Pulumi Resource Search with access to search over every property of your resources. We can’t wait to see what new capabilities it unlocks for your organization. As always, submit any feedback on the feature in the Pulumi Cloud Requests repository.

Happy searching!

Converting Full Terraform Programs to Pulumi

Pulumi Team — Wed, 14 Jun 2023 21:03:51 +0000

Over the last 2 years, we’ve seen an increasing trend of cloud development teams migrating to Pulumi from Terraform. These teams often have experience with and meaningful investment in Terraform, but have also typically run into limits of expressivity, productivity, scalability, or reliability with their existing tools. One of the first questions we hear when they decide to move to Pulumi is “how will I migrate my existing Terraform projects over?”.

Today, we’re excited to announce new support for converting whole Terraform projects to Pulumi via the pulumi convert command in the Pulumi CLI. The new Terraform converter includes support for Terraform modules, core features of Terraform 1.4, and the majority of Terraform built-in functions, converting to Pulumi TypeScript, Python, Go, or C#. The new converter can significantly reduce the amount of time it takes to migrate Terraform to Pulumi. Let’s dig in to learn more about the new converter and how to use it.

Historically, we have offered a separate tf2pulumi tool to convert small snippets of Terraform to Pulumi. The new converter is no longer a separate tool. As of v3.71.0, you can run the new converter directly from the Pulumi CLI with the pulumi convert --from terraform command. And you can convert more than small snippets – the new converter supports converting full Terraform programs.

The new support in pulumi convert builds upon Pulumi’s CrossCode foundations for providing universal infrastructure as code support across a wide variety of programming languages and conversion tooling between them. It also introduces a new concept of converter plugin in the Pulumi engine, which allows conversion tools from other Infrastructure as Code platforms to be integrated into the same pulumi convert experience in the future, both as part of the core project, as well as by other ecosystem partners and contributors.

Several common use cases are supported via the new pulumi convert --from terraform support in the Pulumi CLI:

*Converting your organization’s existing Terraform projects to Pulumi
*Converting your organization’s existing Terraform modules to Pulumi, to be consumed as part of existing Pulumi projects
*Converting 3rd party open source Terraform modules or projects which address a use case you want to incorporate into your existing Pulumi projects

Supported Terraform Features

The following major features are supported:

*Variables, outputs, resources, and data sources
*Terraform modules are converted to Pulumi components
*Almost all HCL2 expression syntax

In cases where the converter does not yet support a feature, the pulumi convert command succeeds but generates a TODO in the form of a call to a notImplemented function that will need to be filled in manually. For most projects, the converter should be able to convert 90-95% of the code without any TODOs, with only a small percentage of items to address manually, significantly reducing migration time compared to doing an entire migration by hand. We are actively improving the converter by adding support for missing features and improving the overall quality of the converted code to reduce the amount of manual fix-ups required.

Converting a Real World Program

Let’s walk through converting a Terraform codebase to Pulumi. Avant Terraform Vault Setup is an open source project that provides a high-availability installation of Vault using a variety of managed AWS services. It defines a fairly complex installation with dozens of AWS resources in over 1,000 lines of Terraform HCL, including the main program and a Vault module. Let’s convert it to Pulumi.

First, clone the repo and cd into the directory containing the Terraform project:

git clone https://github.com/avantoss/vault-infra.git cd vault-infra/terraform/main

Next, run the converter:

TypeScript

pulumi convert --from terraform --language typescript --out pulumi

The converted code is generated in the specified pulumi output directory. A complete Pulumi project is generated, including two primary code files specific to this this program’s conversion:

*index.ts contains the converted code for the main program
*vault.ts contains the Vault Pulumi component, converted from the Terraform module

Addressing TODOs

The file for the Vault component makes up the bulk of the implementation and contains some TODOs emitted by the converter that must be addressed manually.

For example, the converter doesn’t yet support the replace, element, and split built-in functions.

TypeScript

const plainDomain = notImplemented("replace(element(split(\":\",var.vault_dns_address),1),\"////\",\"\")");

We can fill in an implementation. Note that we get to use the full expressiveness of the native and familiar string manipulation libraries in our target programming language, instead of the relatively constrained options of the Terraform DSL.

TypeScript

const plainDomain = pulumi.output(args.vaultDnsAddress) .apply(a => a.split(":")[1].replace("//", ""));

Wrapping Up

After addressing the remaining TODOs and some other tweaks so that the code compiles, we can now run the converted program with pulumi up to provision the Vault installation with Pulumi.

The converter has saved us a ton of time, converting over 1,000 lines of Terraform to a modern Pulumi language, with only a small number of manual fix-ups required. From here, we can leverage our IDE and compiler to further refactor and improve the code, one of the many benefits of Pulumi!

Importing State

It’s great that the new converter can migrate Terraform projects to Pulumi for new deployments, but what if you want to import existing resource states from a .tfstate file to avoid unnecessarily recreating your infrastructure?

If you’re using TypeScript or Go, there is some additional code that can be added to your converted Pulumi program to import resource states from a .tfstate file. See the Importing Resources reference documentation for more details.

We’re working to make this even more seamless with built-in support for importing state from .tfstate files in a future update coming soon.

Get Started

Support for the new pulumi convert --from terraform command is now available in v3.71.0 of the Pulumi CLI. Download the latest Pulumi CLI and give the new converter a try today. If you run into any issues, please let us know or reach out in the Pulumi Community Slack with any questions!

Announcing the Pulumi Challenge

Pulumi Team — Tue, 06 Sep 2022 18:32:17 +0000

Introducing the Pulumi Challenge, launching today! We think Pulumi is an amazing IaC tool that increases developer velocity and handles the scale of the cloud with ease. Try it out for yourself by taking a Pulumi Challenge! You’ll build something cool, and we’ll send you some super secret swag in return. We promise it’s better than a t-shirt.

The Pulumi Challenge is a series of specialized tutorials, released monthly. Each challenge will guide you through building a real-world application, some of them useful and some of them silly, showcasing the varied ways Pulumi can be a lifesaver for your team at work or your side-projects at home. At the end, you’ll have something you can use, and we’ll send you swag unique to each challenge too!

How it Works

Work through the Challenge tutorial to build a real-world application, personalizing it as you go. You’ll learn how Pulumi works to ease integration and infrastructure deployment through providers for major cloud providers, Kubernetes, observability tools, CI/CD systems, dynamic providers, reusable component resources, and more.

Once a Challenge is complete, our swag provider will kick off and send you the unique item for that Challenge. Every challenge offers something different, so complete them all as we release them!

There’s another way to get more swag, though: Write a 500-word blog article or post a 3-minute video about your Pulumi Challenge project, and we’ll send you something even nicer.

The First Challenge

Our inaugural Pulumi Challenge is Startup in a Box. We’ll walk you through building a customizable landing page for your startup, side-project, current hyperfixation, or pet, all deployed to AWS S3 with Cloudfront for a CDN and Checkly for monitoring! You’ll learn about interacting with AWS services through Pulumi, deploying to S3, building reusable components, using Providers with Checkly, and building Dynamic Providers.

Try it for yourself, and follow us on Twitter to get a heads up when a new one launches!