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/v7/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 50+ 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 Packages enable you to define cloud infrastructure once and then consume that package in any supported Pulumi language. You can easily reduce boilerplate code, define best practices, and allow teammates to use your package in the language of their choice, regardless of the language you authored the package with.

Pulumi Registry is the central location where you can find all of the Pulumi Packages you can use.

Browse the registry →

import * as pulumi from "@pulumi/pulumi";
import * as cloudrun from "@pulumi/gcp-global-cloudrun";

const conf = new pulumi.Config()
const project = conf.require("project")

const deployment = new cloudrun.Deployment("my-sample-deployment", {
    projectId: project,
    imageName: "gcr.io/ahmetb-public/zoneprinter",
    serviceName: "demo-service-ts"
});

export const ip = deployment.ipAddress;

import pulumi
import pulumi_gcp_global_cloudrun as cloudrun

config = pulumi.Config()
project = config.require("project")

deployment = cloudrun.Deployment("my-sample-deployment",
                                project_id=project,
                                image_name="gcr.io/ahmetb-public/zoneprinter",
                                service_name="demo-service-py")

pulumi.export('ip', deployment.ip_address)

package main

import (
  "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
  "github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
  cloudrun "github.com/pulumi/pulumi-gcp-global-cloudrun/sdk/go/gcp"
)

func main() {
  pulumi.Run(func(ctx *pulumi.Context) error {
    c := config.New(ctx, "")
    project := c.Require("project")

    deployment, err := cloudrun.NewDeployment(ctx, "demo-deployment-go", &cloudrun.DeploymentArgs{
      ImageName:   pulumi.String("gcr.io/ahmetb-public/zoneprinter"),
      ServiceName: "demo-service-ts",
      ProjectId:   project,
    })
    if err != nil {
      return err
    }

    ctx.Export("ip", deployment.IpAddress)

    return nil
  })
}

name: gcp-cloud-run
runtime: yaml
description: A simple Pulumi program.
configuration:
  project:
    type: String
    default: "project"
resources:
  deployment:
    type: gcp-global-cloudrun:index:Deployment
    properties:
      imageName: "gcr.io/ahmetb-public/zoneprinter"
      serviceName: "demo-service-yaml"
      projectId: ${project}
outputs:
  ip: ${deployment.ipAddress}

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/v7/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