gcp.storage.Folder

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

const bucket = new gcp.storage.Bucket("bucket", {
    name: "my-bucket",
    location: "EU",
    uniformBucketLevelAccess: true,
    hierarchicalNamespace: {
        enabled: true,
    },
});
const folder = new gcp.storage.Folder("folder", {
    bucket: bucket.name,
    name: "parent-folder/",
});
const subfolder = new gcp.storage.Folder("subfolder", {
    bucket: bucket.name,
    name: pulumi.interpolate`${folder.name}subfolder/`,
});

import pulumi
import pulumi_gcp as gcp

bucket = gcp.storage.Bucket("bucket",
    name="my-bucket",
    location="EU",
    uniform_bucket_level_access=True,
    hierarchical_namespace={
        "enabled": True,
    })
folder = gcp.storage.Folder("folder",
    bucket=bucket.name,
    name="parent-folder/")
subfolder = gcp.storage.Folder("subfolder",
    bucket=bucket.name,
    name=folder.name.apply(lambda name: f"{name}subfolder/"))

package main

import (
	"fmt"

	"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 {
		bucket, err := storage.NewBucket(ctx, "bucket", &storage.BucketArgs{
			Name:                     pulumi.String("my-bucket"),
			Location:                 pulumi.String("EU"),
			UniformBucketLevelAccess: pulumi.Bool(true),
			HierarchicalNamespace: &storage.BucketHierarchicalNamespaceArgs{
				Enabled: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		folder, err := storage.NewFolder(ctx, "folder", &storage.FolderArgs{
			Bucket: bucket.Name,
			Name:   pulumi.String("parent-folder/"),
		})
		if err != nil {
			return err
		}
		_, err = storage.NewFolder(ctx, "subfolder", &storage.FolderArgs{
			Bucket: bucket.Name,
			Name: folder.Name.ApplyT(func(name string) (string, error) {
				return fmt.Sprintf("%vsubfolder/", name), nil
			}).(pulumi.StringOutput),
		})
		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 bucket = new Gcp.Storage.Bucket("bucket", new()
    {
        Name = "my-bucket",
        Location = "EU",
        UniformBucketLevelAccess = true,
        HierarchicalNamespace = new Gcp.Storage.Inputs.BucketHierarchicalNamespaceArgs
        {
            Enabled = true,
        },
    });

    var folder = new Gcp.Storage.Folder("folder", new()
    {
        Bucket = bucket.Name,
        Name = "parent-folder/",
    });

    var subfolder = new Gcp.Storage.Folder("subfolder", new()
    {
        Bucket = bucket.Name,
        Name = folder.Name.Apply(name => $"{name}subfolder/"),
    });

});

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.storage.inputs.BucketHierarchicalNamespaceArgs;
import com.pulumi.gcp.storage.Folder;
import com.pulumi.gcp.storage.FolderArgs;
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 bucket = new Bucket("bucket", BucketArgs.builder()
            .name("my-bucket")
            .location("EU")
            .uniformBucketLevelAccess(true)
            .hierarchicalNamespace(BucketHierarchicalNamespaceArgs.builder()
                .enabled(true)
                .build())
            .build());

        var folder = new Folder("folder", FolderArgs.builder()
            .bucket(bucket.name())
            .name("parent-folder/")
            .build());

        var subfolder = new Folder("subfolder", FolderArgs.builder()
            .bucket(bucket.name())
            .name(folder.name().applyValue(name -> String.format("%ssubfolder/", name)))
            .build());

    }
}

resources:
  bucket:
    type: gcp:storage:Bucket
    properties:
      name: my-bucket
      location: EU
      uniformBucketLevelAccess: true
      hierarchicalNamespace:
        enabled: true
  folder:
    type: gcp:storage:Folder
    properties:
      bucket: ${bucket.name}
      name: parent-folder/
  subfolder:
    type: gcp:storage:Folder
    properties:
      bucket: ${bucket.name}
      name: ${folder.name}subfolder/

var gcpFolderResource = new Gcp.Storage.Folder("gcpFolderResource", new()
{
    Bucket = "string",
    ForceDestroy = false,
    Name = "string",
});

example, err := storage.NewFolder(ctx, "gcpFolderResource", &storage.FolderArgs{
	Bucket:       pulumi.String("string"),
	ForceDestroy: pulumi.Bool(false),
	Name:         pulumi.String("string"),
})

var gcpFolderResource = new Folder("gcpFolderResource", FolderArgs.builder()
    .bucket("string")
    .forceDestroy(false)
    .name("string")
    .build());

gcp_folder_resource = gcp.storage.Folder("gcpFolderResource",
    bucket="string",
    force_destroy=False,
    name="string")

const gcpFolderResource = new gcp.storage.Folder("gcpFolderResource", {
    bucket: "string",
    forceDestroy: false,
    name: "string",
});

type: gcp:storage:Folder
properties:
    bucket: string
    forceDestroy: false
    name: string