gcp.firebase.StorageBucket

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

const _default = new gcp.storage.Bucket("default", {
    name: "test_bucket",
    location: "US",
    uniformBucketLevelAccess: true,
});
const defaultStorageBucket = new gcp.firebase.StorageBucket("default", {
    project: "my-project-name",
    bucketId: _default.id,
});

import pulumi
import pulumi_gcp as gcp

default = gcp.storage.Bucket("default",
    name="test_bucket",
    location="US",
    uniform_bucket_level_access=True)
default_storage_bucket = gcp.firebase.StorageBucket("default",
    project="my-project-name",
    bucket_id=default.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := storage.NewBucket(ctx, "default", &storage.BucketArgs{
			Name:                     pulumi.String("test_bucket"),
			Location:                 pulumi.String("US"),
			UniformBucketLevelAccess: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = firebase.NewStorageBucket(ctx, "default", &firebase.StorageBucketArgs{
			Project:  pulumi.String("my-project-name"),
			BucketId: _default.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var @default = new Gcp.Storage.Bucket("default", new()
    {
        Name = "test_bucket",
        Location = "US",
        UniformBucketLevelAccess = true,
    });

    var defaultStorageBucket = new Gcp.Firebase.StorageBucket("default", new()
    {
        Project = "my-project-name",
        BucketId = @default.Id,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.firebase.StorageBucket;
import com.pulumi.gcp.firebase.StorageBucketArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var default_ = new Bucket("default", BucketArgs.builder()
            .name("test_bucket")
            .location("US")
            .uniformBucketLevelAccess(true)
            .build());

        var defaultStorageBucket = new StorageBucket("defaultStorageBucket", StorageBucketArgs.builder()
            .project("my-project-name")
            .bucketId(default_.id())
            .build());

    }
}

resources:
  default:
    type: gcp:storage:Bucket
    properties:
      name: test_bucket
      location: US
      uniformBucketLevelAccess: true
  defaultStorageBucket:
    type: gcp:firebase:StorageBucket
    name: default
    properties:
      project: my-project-name
      bucketId: ${default.id}

var storageBucketResource = new Gcp.Firebase.StorageBucket("storageBucketResource", new()
{
    BucketId = "string",
    Project = "string",
});

example, err := firebase.NewStorageBucket(ctx, "storageBucketResource", &firebase.StorageBucketArgs{
	BucketId: pulumi.String("string"),
	Project:  pulumi.String("string"),
})

var storageBucketResource = new StorageBucket("storageBucketResource", StorageBucketArgs.builder()
    .bucketId("string")
    .project("string")
    .build());

storage_bucket_resource = gcp.firebase.StorageBucket("storageBucketResource",
    bucket_id="string",
    project="string")

const storageBucketResource = new gcp.firebase.StorageBucket("storageBucketResource", {
    bucketId: "string",
    project: "string",
});

type: gcp:firebase:StorageBucket
properties:
    bucketId: string
    project: string