Pulumi Blog: Native providers

Preview of .NET resource providers

Fraser Waters — Wed, 18 Jan 2023 00:00:00 +0000

Today we are pleased to announce the Preview of .NET support for custom resource providers. This means you can build custom providers using your favorite .NET language, including C#, F#, and VB.NET.

This is a first look preview release of the provider interface for .NET. It has minimal documentation but is feature complete. We hope to gather early feedback to refine the API and quickly bring this to a production quality release.

You will need to use version 3.52.0 to access the new APIs. You can install this in your project with:

dotnet add package Pulumi --version 3.52.0

You can see an example of using the new provider interface in the dotnet integration tests directory. This has replaced the old test provider that was written in Go.

Please view the provider interface and raise issues and discussions on GitHub or our Community Slack in the #dotnet channel — we can’t wait to hear what you think!

Announcing Pulumi 3.0

Luke Hoban — Tue, 20 Apr 2021 00:00:06 -0700

Today we’re excited to announce the availability of Pulumi 3.0, the next major version of the Pulumi open source project, and the foundation for Pulumi’s Cloud Engineering Platform.

Pulumi offers the most complete infrastructure as code platform for building, deploying and managing modern cloud infrastructure and applications. Pulumi enables cloud engineers to use familiar languages to describe their cloud infrastructure - bringing core software engineering tools and practices to bear on managing and getting the maximum value from their cloud platforms of choice - across dozens of cloud and SaaS providers.

Pulumi 3.0 includes dozens of significant new features and hundreds of improvements that build on this foundation. This release includes more than 200 contributions from over 150 members of the Pulumi community, and builds on feedback from working with thousands of Pulumi users and customers over the last year.

Some of the most exciting new features in this release include:

Pulumi Automation API: All the power of Pulumi, now available to embed within your own software and applications in Node.js, Python, Go and .NET - opening up a brand new wave of modern cloud infrastructure use cases, including self-service infrastructure portals, custom CLIs, and richer CI/CD workflows.
Native Pulumi Providers for Azure (GA) and Google Cloud (Preview): New providers with 100% platform coverage, same-day support for new features, and the exact same resource models defined by the cloud providers - the most complete and consistent way to manage cloud infrastructure in Azure and Google Cloud.
Pulumi Packages and Multi-Language Components: Take any Pulumi components written in your language of choice, and make them available as a Pulumi Package to users in all other Pulumi languages - bringing together each of the language ecosystems Pulumi supports into a single Pulumi component ecosystem.
Improved Go and Python SDKs: Updates to the core Go and Python SDKs make APIs simpler and more consistent, unlock more tooling support, and improve compile times - making it even easier to use all the benefits of your favorite programming language when building and managing cloud infrastructure.
New Integrations and Features in the Pulumi Service: Alongside Pulumi 3.0, users of the Pulumi Service also now have access to new dashboards for organization-level cloud infrastructure insights, a CI/CD Assistant for easy version control and CI/CD integration with just a few clicks, and new identity, access control, and auditing capabilities.

👉 Get started with Pulumi 3.0 today or check out the Pulumi 3.0 migration guide to update your existing Pulumi projects to Pulumi 3.0.

Pulumi Automation API

Pulumi’s Automation API was released in preview last year and is now GA as part of Pulumi 3.0. It provides an API for embedding Pulumi within your own applications, and supports all Pulumi languages including TypeScript/JavaScript, Python, Go, and C#. Instead of working with the pulumi CLI directly, or writing scripts to execute the CLI within your CI/CD environment, you can now build your own software solutions that build on top of Pulumi’s robust, desired state infrastructure as code deployment engine. It’s simple to embed Pulumi in your software-defined workflows with just a few lines of code.

This opens up so many exciting new opportunities for how your team can manage cloud infrastructure; we’ve seen amazing creativity as Pulumi’s customers and communities have created solutions on top of Automation API. In addition, Pulumi Automation API powers several other new features like the Pulumi Kubernetes Operator, the Pulumi GitHub Action v3, and Concourse CI support for Pulumi.

👉 Read more in the Pulumi Automation API blog post.

Native Providers for Azure and Google Cloud

Pulumi offers packages for managing cloud infrastructure in more than 50 cloud and SaaS applications, with more than a dozen new providers added since Pulumi 2.0 including partnerships with Civo, Venafi, Okta, Auth0, Equinix Metal, Spot Ocean for Azure, and Splunk.

For the largest and most widely used cloud providers, we’ve created something new: Pulumi native providers, which give you the most complete and consistent interface for the modern cloud. These native providers are automatically generated from cloud provider APIs and resource models that are maintained directly by cloud provider service teams. This enables native providers to offer 100% API coverage, same-day support for new features, the exact same API designed by the provider service team, and fewer bugs and reliability issues. This makes native providers the best way to manage infrastructure in the supported cloud platforms, combining the benefits of Pulumi Infrastructure as Code with the resource models and pace of delivery of the cloud provider themselves.

Along with Pulumi 3.0, the new Azure Native provider, originally released in preview last year, is now generally available as version 1.0. The Azure Native provider is built on top of the Azure Resource Manager REST API specifications developed and maintained by Azure service teams. It supports more than 2x the number of resources, and 3x the number of resource properties as the classic Azure provider. Azure Native also supports every version of each resource API for maximum compatibility with your existing infrastructure. New versions of the Azure Native provider with support for the latest features of Azure are published every night, ensuring immediate availability of new features and improvements from the Azure service teams.

Today, we’re also excited to be releasing a preview of the new Google Cloud Native provider. This native provider offers 100% coverage of the Google Cloud platform, with 70% more resource properties supported compared to the existing provider. It also supports every version of each supported resource, including alpha, beta, and GA Google Cloud offerings.

👉 Read more in the Pulumi Native Providers blog post and the Pulumi Google Native Provider blog post. And of course, we haven’t forgotten AWS - an AWS Native provider is expected later this year.

Pulumi Packages and Multi-Language Components

Pulumi Packages are the core technology that enables cloud infrastructure resource provisioning to be defined once, and made available to users in all languages supported by Pulumi. If you’ve ever used a cloud provider in Pulumi, you’ve used a Pulumi Package. With Pulumi 3.0, we are extending Pulumi Packages to also support building and packaging Pulumi Components: higher-level abstractions over cloud infrastructure patterns described as normal Pulumi programs. This makes it easy to take a Pulumi program that defines a collection of resources and turn it into something reusable: a Pulumi Package that can be published and used by all Pulumi users, across all languages supported by Pulumi.

One example of building and packaging Pulumi Components as a Pulumi Package is the Pulumi EKS package. We originally released a component for easily building and managing production-ready EKS clusters nearly two years ago, but it was only available for Node.js users of Pulumi as an npm package. This component has been incredibly popular, as it abstracts away a lot of complexity in all the moving pieces that need to be managed to stand up an EKS cluster across both AWS resources and in-cluster Kubernetes resources. Recently, we turned this component into a Pulumi Package, making it available to users in Python, Go, and .NET as well, with just a single implementation. Pulumi EKS is just the first example of applying this technology; there’s a lot more in the works here in the coming months!

import pulumi
import pulumi_eks as eks

cluster = eks.Cluster("my-cluster")

pulumi.export("kubeconfig", cluster.kubeconfig)

package main

import (
 "github.com/pulumi/pulumi-eks/sdk/go/eks"
 "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
 pulumi.Run(func(ctx *pulumi.Context) error {
 cluster, err := eks.NewCluster(ctx, "my-cluster", nil)
 if err != nil {
 return err
 }
 ctx.Export("kubeconfig", cluster.Kubeconfig)
 return nil
 })
}

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

const cluster = new eks.Cluster("my-cluster");

export const kubeconfig = cluster.kubeconfig;

using Pulumi;
using Pulumi.Eks;

class MyStack : Stack
{
 [Output("kubeconfig")]
 public Output<object> Kubeconfig { get; set; }

 public MyStack()
 {
 var cluster = new Cluster("my-cluster");

 Kubeconfig = cluster.Kubeconfig;
 }
}

All Pulumi packages define a common Pulumi schema, which describes the resource model the package exposes and can be used to generate language-specific SDKs and documentation. There are several different types of Pulumi Package:

Native Pulumi Provider Package: Use the full features of the Pulumi resource model to create a provider for a new cloud platform. Examples: the kubernetes, azure-native, and google-native packages.
Bridged Provider Package: Take an existing resource provider from another supported ecosystem (like a Terraform provider), and bridge it to be exposed as a Pulumi Package. Examples:the aws, tls, and cloudflare packages.
Component Package: Write a Pulumi Component in your language of choice and expose it to users in all languages supported by Pulumi. Example: the eks package.

Together, these options provide a combination of breadth and depth for the kinds of resources and components that can be exposed to Pulumi developers via Pulumi Packages.

👉 Read more in the Pulumi Packages blog post.

Improved Go and Python SDKs

Pulumi’s language SDKs bring the power of cloud infrastructure management into your language of choice in a natural and productive way, enabling you to use all of your existing software engineering knowledge and tools for your cloud infrastructure projects as well. In Pulumi 3.0, we’ve made improvements to the Go and Python SDKs to improve developer productivity and enable additional tooling.

For Go users, Pulumi 3.0 reduces binary sizes by 4x and improves build times by up to 3x, leading to a much faster infrastructure development loop. Along with this, the Go APIs for working with Pulumi Output values have been simplified to provide a single way of transforming outputs instead of three different options. This makes the Pulumi Go SDK more consistent and easier to get started with. You can learn more about these changes in the Pulumi 3.0 migration guide.

For Python users, Pulumi 3.0 brings a new, more strongly typed way to provide inputs to cloud resources, ensuring that users get completion lists, type checking, documentation, and more within their IDE of choice. Along with this, some inconsistencies in input property naming have also been removed; now, all property names follow a consistent and predictable naming convention. You can learn more about these changes in the Pulumi 3.0 migration guide.

New Integrations and Features in the Pulumi Service

In addition to the Pulumi 3.0 open source release, we’re also making available new features for users of the Pulumi Service: the simple and easy to use default backend for all Pulumi users, with additional features for teams and enterprises.

Integrating Pulumi into CI/CD systems is a key step in realizing the full benefits of modern infrastructure as code, and we’ve worked to make this easier than ever. Since 2.0, we’ve added partner integrations with Spinnaker, GitHub Actions and CodeFresh as well as a new Pulumi Kubernetes Operator. In addition, we’ve introduced a new CI/CD Assistant to the service to help configure version control and CI/CD integration for your Pulumi projects with just a few clicks.

For enterprise users, we’ve added several enhancements to SAML SSO and SCIM support. Pulumi’s SSO support now works seamlessly with Okta (as well as Google Identity, Azure Active Directory and more), users and groups can now be synced via SCIM support in your SAML provider, and new Team Admin roles make team management simpler for large organizations.

Lastly, the Pulumi Service now offers a dashboard landing page which brings insights about your infrastructure front-and-center whether you are an individual user, or part of a large organization.

👉 Read more in the Pulumi CI/CD Assistant blog post and the SAML SSO and SCIM blog post.

Keep exploring

Pulumi 3.0 is a significant new milestone for the Pulumi project and lays the foundations for the Pulumi Cloud Engineering Platform with support for the very best of the cloud via new Pulumi Native Providers, support for a unified ecosystem of reusable infrastructure components with Pulumi Packages, and support for a new era of cloud infrastructure management scenarios enabled by Pulumi Automation API. Each of these is just a start: there’s so much more to come on top of these foundations and we’re excited to work with our customers and community on the next wave of innovation in Cloud Engineering!

To learn more about each of the new areas - check out these blog posts with more details:

You can get started with Pulumi 3.0 today, or check out the Pulumi 3.0 migration guide to update your existing Pulumi projects to Pulumi 3.0.

We can’t wait to see what you build with Pulumi 3.0!

Model and program the cloud with Pulumi native providers

Alex Mullans — Tue, 20 Apr 2021 00:00:05 -0700

Pulumi native providers are a new type of Pulumi Package that give you the most complete and consistent interface for the modern cloud. Pulumi native providers bring the full power of the top cloud providers to the Pulumi Cloud Engineering Platform, faster and with more complete coverage than any other infrastructure as code offering. Today at PulumiUP, we announced native providers for Microsoft Azure (GA), Google Cloud (public preview), and AWS (later this year). Along with an existing native provider for Kubernetes, these providers enable you to build, deploy, and manage cloud infrastructure and applications for the most common cloud vendors and technologies. This best-in-class support for the major clouds joins our library of more than 50 cloud providers in the Registry and delivers on our promise of cloud engineering for any cloud, any architecture, and any language.

100% API coverage, same-day access

Legacy infrastructure as code tools rely on providers that are often hand-coded. These providers have fairly broad coverage of the modern cloud ecosystem, but they can’t always keep up with the pace of innovation of that ecosystem. That can leave you stuck with an awkward choice: wait until the provider is updated and miss out on the first-mover advantage, or try out the new infrastructure directly without any of the control, repeatability, or scalability you expect from infrastructure as code.

With Pulumi native providers, you don’t need to make that choice. Native providers are built directly and automatically from the cloud provider’s API. As a result, you can trust that these new native providers give you access to 100% of the resources covered by the cloud provider’s API and same-day access to feature updates and new services. When you see a new resource at AWS re:Invent, Microsoft Build, or Google Cloud Next, you can be sure that it’ll be available for use in Pulumi the same day that it’s added to the provider’s API. You can get productive with that new resource quickly because native providers also pull documentation from the API. As with all Pulumi providers, you get the full benefits of code completion, syntax highlighting, and everything else you expect from your programming language and development environment. That means you can start using those new services as soon as you hear about them without losing any of the benefits and protections of your infrastructure as code. And of course, like Pulumi itself, Pulumi native providers are open source, so you can see the code, file issues, and contribute fixes and new features.

Azure Native is generally available

Microsoft delivers new value to the Azure platform quickly and frequently, with hundreds of new resources, features, and improvements just this year. As those updates became available, we added them to the Pulumi Azure Native provider. Since we announced Azure Native last September, we’ve maintained its 100% coverage of the Azure Resource Manager API surface by adding the 166 new resources (e.g. new service or features within existing services) added to the ARM APIs. Those new resources have been contained in the 279 daily builds of the provider we’ve released since that announcement. These releases guarantee same-day coverage of Azure updates, so you don’t have to wait to use new Azure features and updates.

Since the release of Azure Native, many Azure Classic provider users have already started using it in their projects and filing bugs and feature requests. We’ve been fixing those issues, and today we’re excited to make Azure Native generally available at version 1.0.0. Azure Native is your best choice for any new project that uses resources from Azure; you can also mix in new resources from Azure Native in a project that uses the Azure Classic provider today. If you’d like, you can migrate existing projects to use Azure Native using the migration guide. However, the Azure Classic provider remains fully supported.

A great example of the unique value you get from the Pulumi native provider approach is Consumption Budgets. Consumption Budgets allow you to control your Azure spend proactively, so you’re not surprised when your bill arrives. Consumption Budgets are covered by the Azure Resource Manager API, so you can create a Consumption Budget with Azure Native right now. In contrast, Consumption Budgets has been a pending feature request for over 2 years in the Terraform provider used by the Azure Classic provider.

With the Azure platform evolving as rapidly as it does, you might worry that it’ll be hard to manage API versions or know which APIs are stable and ready to use. But fear not! Each major version of the Azure Native provider exposes a top-level namespace with a consistent set of stable APIs. Any breaking changes made in the Azure APIs will be released in a new major version of the Azure Native provider. If you need a different version of an API, you have access to that as well: every API version is exposed as a separate namespace in the provider.

👉 Get started with Azure Native

Public preview: a native provider for Google Cloud Platform

Google Cloud Platform is also growing at a rapid pace, with new features and updates almost every day. To track that growth, today at PulumiUP, we announced a public preview of GCP-Native, a Pulumi native provider for the Google Cloud Platform. Just like the Azure Native provider, GCP-Native gives you 100% coverage of every Google Cloud Platform API, so you can do things that aren’t possible with the current Terraform-based Google Cloud provider. And just like the Azure Native provider, Google Native is updated with a new release every time those APIs are updated, so you have access to new GCP features as soon as they’re released.

👉 Read the GCP-Native public preview announcement

AWS later this year, and more to come

Of course, we’re not stopping with native providers for Azure, Google Cloud, and Kubernetes. Later this year, we’ll release a native provider for Amazon Web Services. Just like the Azure Native and Google Cloud Native providers, the AWS Native provider will support 100% of CloudFormation resources and give you same-day access when new resources are released.

Pulumi native providers are the best way to build, deploy, and manage resources in AWS, Azure, GCP, and Kubernetes, but you’re not limited to just those clouds. Pulumi’s broad library of more than 50 cloud providers in the Registry remains available and ready to use.

You can help us decide which providers to build next! Add your vote to existing provider requests here or request a provider.

👉 See all the cloud providers you can use with Pulumi

A peek under the hood

Native providers fulfill a core promise of the Pulumi Cloud Engineering Platform: to be your most complete and consistent interface to model and program the cloud. Here’s how we deliver on that promise of 100% API coverage and same-day updates.

Full API coverage via automated nightly updates

Automation in GitHub Actions checks the Azure, Google, and Amazon API specifications every night and automatically generates a pull request to update the corresponding native provider Pulumi Package with any changes. That pull request updates the Pulumi Package’s schema (the metadata file that defines the resources, inputs, and outputs that make up the native provider), re-generates all four language SDKs, and creates a new minor version of the provider. That new minor version contains:

New namespaces for any new API versions, so you can access new features, even if they’re behind a preview API version
All non-breaking updates to the top-level APIs, so you get bug fixes and non-breaking improvements as soon as they’re ready

Periodically, we also create a new major version release of the provider that promotes new API major versions to the top-level namespace. This ensures that new APIs become part of the “default” set available in the top-level namespace.

If you want to dive deeper into how we keep the native provider Pulumi Packages up to date, you can see Azure Native’s automation in GitHub Actions and an example pull request.

Going beyond the API

Sometimes, a cloud provider doesn’t cover some scenarios or resources in their primary API. For example, the Azure Resource Manager API doesn’t currently include support for managing Azure Key Vault secrets and keys. In these cases, to provide the best experience, we hand-author extensions to the native provider Pulumi Package to cover these scenarios.

Keep exploring

These native provider announcements are just one part of Pulumi’s Cloud Engineering Platform. Watch the PulumiUP event for more.

👉 PulumiUP

Google Cloud Native provider: full coverage of Google Cloud

Alex Mullans — Tue, 20 Apr 2021 00:00:04 -0700

Today at PulumiUP, we announced the public preview of our Google Cloud Native provider. Google Cloud usage amongst Pulumi users has grown rapidly in the past year and Google Cloud has been adding new features and updates almost every day. The new native provider gives Pulumi users the best support possible for Google Cloud in Pulumi.

The Google Cloud Native provider works directly with the Google Cloud APIs, as surfaced by the Google API Discovery Service, instead of depending on a handwritten layer like other current infrastructure as code technologies. This new approach is similar to that which we’ve taken for our Kubernetes and Azure Native providers and ensures higher quality and complete coverage of the resources available in GCP.

Full API coverage

Google Cloud Native covers 100% of the resources available in the Google Cloud APIs. The new provider supports 508 resource types at launch, 10% more than the number supported by the previous Google Cloud provider, and over 70% more properties, each of which represents a new capability or feature exposed by Google Cloud but unavailable in other infrastructure as code tools. Every property of each resource is represented in the SDKs. In addition, every version of each resource is available, providing access to each version of beta and GA features in a stable way from a single provider.

Like our other native providers, the new SDKs include 100% coverage of Google Cloud resources.

Always up-to-date

Unlike the original Google Cloud provider, which requires manual work to keep updated, the new provider is always up-to-date with additions and changes to the Google Cloud APIs. This also ensures very high quality since a human doesn’t need to manually implement support for all of those services and features.

We generate Pulumi SDKs for Google Cloud Native automatically using updates from the Google API Discovery Service. This has been designed to enable an automated pipeline to release updated resources within hours after any current API specifications are merged. That pipeline will publish daily updates via automated builds and minor SDK versions every two weeks.

By generating the SDKs directly from the Google Cloud APIs, the Google Cloud Native provider is robust and reliable, with fewer moving parts involved and fewer sources of potential bugs and incompatibilities. For example, when Google’s new GKE Autopilot feature shipped, early builds of this provider supported it within hours, compared to over a month for legacy infrastructure as code tools.

Excited about a new service announced by Google? Chances are it’s already in the latest Google Cloud Native package!

Every language

Google Cloud Native is available in public preview today for all Pulumi languages. Because it’s built on the Pulumi Packages technology, every update to Google Cloud Native is available in all languages on the day of release. The new Google Cloud Native SDKs are open source on GitHub and available on npm, NuGet.org, PyPI, and Go modules.

import * as pulumi from "@pulumi/pulumi";
import * as google from "@pulumi/google-native";

const config = new pulumi.Config("google-native");
const project = config.require("project");

const region = "us-central1";
const clusterName = "gke-native";

const cluster = new google.container.v1.Cluster("cluster", {
 projectsId: project,
 locationsId: region,
 clustersId: clusterName,
 name: clusterName,
 parent: `projects/${project}/locations/${region}`,
 autopilot: { enabled: true }
});

import pulumi
from pulumi_google_native.container import v1 as container

config = pulumi.Config('google-native')
project = config.require('project')

region = "us-central1"
cluster_name = "gke-native"

cluster = container.Cluster(
 "cluster",
 projects_id=project,
 locations_id=region,
 clusters_id=cluster_name,
 name=cluster_name,
 autopilot=container.AutopilotArgs(enabled=True))

package main

import (
 container "github.com/pulumi/pulumi-google-native/sdk/go/google/container/v1"
 "github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
 "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
 const region = "us-central1"
 const clusterName = "gke-native"

 pulumi.Run(func(ctx *pulumi.Context) error {
 conf := config.New(ctx, "google-native")
 project := conf.Require("project")
 cluster, err := container.NewCluster(ctx, "cluster", &container.ClusterArgs{
 Name: pulumi.StringPtr(clusterName),
 ClustersId: pulumi.String(clusterName),
 LocationsId: pulumi.String(region),
 ProjectsId: pulumi.String(project),
 Autopilot: container.AutopilotArgs{
 Enabled: pulumi.Bool(true),
 },
 })
 if err != nil {
 return err
 }

 ctx.Export("clusterSelfLink", cluster.SelfLink)

 return nil
 })
}

using System.Threading.Tasks;
using Pulumi;
using Pulumi.GoogleNative.Container.V1;
using Pulumi.GoogleNative.Container.V1.Inputs;

class Program
{
 static Task<int> Main() => Deployment.RunAsync(() =>
 {
 var config = new Config("google-native");
 var project = config.Require("project");

 var region = "us-central1";
 var clusterName = "gke-native";

 var cluster = new Cluster("cluster", new ClusterArgs
 {
 ProjectsId = project,
 LocationsId = region,
 ClustersId = clusterName,
 Name = clusterName,
 Autopilot = new AutopilotArgs { Enabled = true }
 });
 });
}

API documentation is available in our API reference.

Works side-by-side with the existing Pulumi GCP Provider

We will continue to invest in the existing Google Cloud provider. Pulumi users can use either provider or use both providers side-by-side in their applications.

A single Pulumi project can use both providers. The outputs of a resource from one provider can flow to inputs of a resource from the other provider. In both cases, they are the values available from Google Cloud itself, such as the name or ID of a Google Cloud resource.

If you have existing projects using the current Pulumi GCP provider, you can continue to use that provider, and Pulumi will continue to update it indefinitely. You can add new cloud resources using the existing provider or start creating new infrastructure with the new provider. At a later date in the preview, we will publish a migration guide to help you move existing projects from GCP to Google Cloud Native.

New Pulumi projects for Google Cloud will default to using Google Cloud Native once it reaches general availability later this year.

Getting started

New Pulumi templates are available for the Google Cloud Native provider:

$ pulumi new google-native-typescript

$ pulumi new google-native-python

$ pulumi new google-native-csharp

$ pulumi new google-native-go

Several more extensive examples are also available in the Pulumi Examples repo:

Containerized Ruby on Rails App Delivery using the Google Native Pulumi Provider: TypeScript
Google Cloud Functions: TypeScript

The preview of the Google Cloud Native provider is ready for you to try. It’s easy to get started by trying one of our examples. We look forward to hearing your feedback! We look forward to hearing your feedback! Please file any bugs and feature requests on GitHub or ask questions in the Pulumi Community Slack. We are eager to hear your feedback and how we can help.

Keep exploring

The Google Cloud Native announcement is just one part of Pulumi’s Cloud Engineering Platform. Watch the PulumiUP event for more.

👉 PulumiUP 👉 Google Cloud Native API reference