Cloud engineering on Google Cloud

Pulumi’s infrastructure as code SDK helps create, deploy, and manage Google Cloud Platform containers, serverless functions, and infrastructure using real programming languages.

Get started Try Pulumi Cloud

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

const bucket = new gcp.storage.Bucket("bucket", {
    location: "US",
});

export const bucketName = bucket.url;

package main

import (
    "github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/storage"
    "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
        bucket, err := storage.NewBucket(ctx, "my-bucket", &storage.BucketArgs{
            Location: pulumi.String("US"),
        })
        if err != nil {
            return err
        }

        ctx.Export("bucketName", bucket.Url)
        return nil
    })
}

using Pulumi;
using Pulumi.Gcp.Storage;

class MyStack : Stack
{
    public MyStack()
    {
        var bucket = new Bucket("my-bucket");

        // Export the DNS name of the bucket
        this.BucketName = bucket.Url;
    }

    [Output]
    public Output<string> BucketName { get; set; }
}

The benefits of using Pulumi

Tame cloud complexity

Deliver infrastructure from hundreds of cloud and SaaS providers. Pulumi’s SDKs provide a complete and consistent interface that offers full access to clouds and abstracts complexity.

Bring the cloud closer to application development

Build reusable cloud infrastructure and infrastructure platforms that empower developers to build modern cloud applications faster and with less overhead.

Use engineering practices with infrastructure

Replace inefficient, manual infrastructure processes with automation. Test and deliver infrastructure through CI/CD workflows or automate deployments with code at runtime.

Foster collaboration and innovate faster

Unite infrastructure teams, developers, and security teams around shared languages and tools so that everyone can ship products quickly and reliably.

Reduce your complexity with shared packages

Pulumi components let you define Google Cloud best practices once and reuse them everywhere. Wrap a Cloud Run service, its IAM bindings, and your organization’s defaults in a single component, then share it as a package that teammates can consume in the language of their choice, regardless of the language you authored it in.

Follow the component authoring guide to build and publish your own.

Build a component

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

interface PublicServiceArgs {
    location: pulumi.Input<string>;
    image: pulumi.Input<string>;
}

// A reusable component: a Cloud Run service that anyone can invoke.
class PublicService extends pulumi.ComponentResource {
    public readonly url: pulumi.Output<string>;

    constructor(name: string, args: PublicServiceArgs, opts?: pulumi.ComponentResourceOptions) {
        super("acme:gcp:PublicService", name, {}, opts);

        const service = new gcp.cloudrunv2.Service(name, {
            location: args.location,
            template: { containers: [{ image: args.image }] },
            deletionProtection: false,
        }, { parent: this });

        new gcp.cloudrunv2.ServiceIamMember(`${name}-invoker`, {
            name: service.name,
            location: service.location,
            role: "roles/run.invoker",
            member: "allUsers",
        }, { parent: this });

        this.url = service.uri;
        this.registerOutputs({ url: this.url });
    }
}

const hello = new PublicService("hello", {
    location: "us-central1",
    image: "us-docker.pkg.dev/cloudrun/container/hello",
});

export const url = hello.url;

import pulumi
import pulumi_gcp as gcp


class PublicService(pulumi.ComponentResource):
    """A reusable component: a Cloud Run service that anyone can invoke."""

    def __init__(self, name, location, image, opts=None):
        super().__init__("acme:gcp:PublicService", name, {}, opts)

        service = gcp.cloudrunv2.Service(
            name,
            location=location,
            template={"containers": [{"image": image}]},
            deletion_protection=False,
            opts=pulumi.ResourceOptions(parent=self),
        )

        gcp.cloudrunv2.ServiceIamMember(
            f"{name}-invoker",
            name=service.name,
            location=service.location,
            role="roles/run.invoker",
            member="allUsers",
            opts=pulumi.ResourceOptions(parent=self),
        )

        self.url = service.uri
        self.register_outputs({"url": self.url})


hello = PublicService(
    "hello",
    location="us-central1",
    image="us-docker.pkg.dev/cloudrun/container/hello",
)

pulumi.export("url", hello.url)

package main

import (
    "github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/cloudrunv2"
    "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// PublicService is a reusable component: a Cloud Run service that anyone can invoke.
type PublicService struct {
    pulumi.ResourceState
    Url pulumi.StringOutput
}

func NewPublicService(ctx *pulumi.Context, name, location, image string, opts ...pulumi.ResourceOption) (*PublicService, error) {
    c := &PublicService{}
    if err := ctx.RegisterComponentResource("acme:gcp:PublicService", name, c, opts...); err != nil {
        return nil, err
    }

    service, err := cloudrunv2.NewService(ctx, name, &cloudrunv2.ServiceArgs{
        Location: pulumi.String(location),
        Template: &cloudrunv2.ServiceTemplateArgs{
            Containers: cloudrunv2.ServiceTemplateContainerArray{
                &cloudrunv2.ServiceTemplateContainerArgs{Image: pulumi.String(image)},
            },
        },
        DeletionProtection: pulumi.Bool(false),
    }, pulumi.Parent(c))
    if err != nil {
        return nil, err
    }

    _, err = cloudrunv2.NewServiceIamMember(ctx, name+"-invoker", &cloudrunv2.ServiceIamMemberArgs{
        Name:     service.Name,
        Location: service.Location,
        Role:     pulumi.String("roles/run.invoker"),
        Member:   pulumi.String("allUsers"),
    }, pulumi.Parent(c))
    if err != nil {
        return nil, err
    }

    c.Url = service.Uri
    return c, ctx.RegisterResourceOutputs(c, pulumi.Map{"url": c.Url})
}

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
        hello, err := NewPublicService(ctx, "hello", "us-central1", "us-docker.pkg.dev/cloudrun/container/hello")
        if err != nil {
            return err
        }
        ctx.Export("url", hello.Url)
        return nil
    })
}

Create your own GKE cluster

Pulumi supports programming against Kubernetes — Minikube, custom on-premises, or cloud-hosted custom clusters or in managed clusters such as Google GKE. This code defines a GKE cluster with configurable settings that could be packaged in a module and then used to deploy an app to the cluster.

Learn more about GKE with Pulumi

import * as gcp from "@pulumi/gcp";
import * as k8s from "@pulumi/kubernetes";
import * as pulumi from "@pulumi/pulumi";

const name = "demo";

const engineVersion = gcp.container.getEngineVersions().then(v => v.latestMasterVersion);

const cluster = new gcp.container.Cluster(name, {
    initialNodeCount: 2,
    minMasterVersion: engineVersion,
    nodeVersion: engineVersion,
    nodeConfig: {
        machineType: "n1-standard-1",
        oauthScopes: [
            "https://www.googleapis.com/auth/compute",
            "https://www.googleapis.com/auth/devstorage.read_only",
            "https://www.googleapis.com/auth/logging.write",
            "https://www.googleapis.com/auth/monitoring",
        ],
    },
});

export const clusterName = cluster.name;

import pulumi
import pulumi_gcp as gcp

engine_version = gcp.container.get_engine_versions().latest_master_version

cluster = gcp.container.Cluster("demo",
    initial_node_count=2,
    min_master_version=engine_version,
    node_version=engine_version,
    node_config=gcp.container.ClusterNodeConfigArgs(
        machine_type="n1-standard-1",
        oauth_scopes=[
            "https://www.googleapis.com/auth/compute",
            "https://www.googleapis.com/auth/devstorage.read_only",
            "https://www.googleapis.com/auth/logging.write",
            "https://www.googleapis.com/auth/monitoring",
        ],
    ))

pulumi.export("cluster_name", cluster.name)

package main

import (
    "github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/container"
    "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
        engineVersions, err := container.GetEngineVersions(ctx, nil, nil)
        if err != nil {
            return err
        }
        cluster, err := container.NewCluster(ctx, "demo", &container.ClusterArgs{
            InitialNodeCount: pulumi.Int(2),
            MinMasterVersion: pulumi.String(engineVersions.LatestMasterVersion),
            NodeVersion:      pulumi.String(engineVersions.LatestMasterVersion),
            NodeConfig: &container.ClusterNodeConfigArgs{
                MachineType: pulumi.String("n1-standard-1"),
                OauthScopes: pulumi.StringArray{
                    pulumi.String("https://www.googleapis.com/auth/compute"),
                    pulumi.String("https://www.googleapis.com/auth/devstorage.read_only"),
                    pulumi.String("https://www.googleapis.com/auth/logging.write"),
                    pulumi.String("https://www.googleapis.com/auth/monitoring"),
                },
            },
        })
        if err != nil {
            return err
        }
        ctx.Export("clusterName", cluster.Name)
        return nil
    })
}

Need help with Google Cloud?

Learn how top engineering teams are using Pulumi’s SDK to create, deploy, and manage Google Cloud resources.

Request a demo

Get started with Pulumi and Google Cloud

Deploy your first Google Cloud project in minutes. Follow our quickstart guide, or talk to our team about your specific needs.

Get started