pulumi-gcp-kotlin/com.pulumi.gcp.storage.kotlin/ManagedFolderArgs

ManagedFolderArgs

data class ManagedFolderArgs(val bucket: Output<String>? = null, val forceDestroy: Output<Boolean>? = null, val name: Output<String>? = null) : ConvertibleToJava<ManagedFolderArgs>

A Google Cloud Storage Managed Folder. You can apply Identity and Access Management (IAM) policies to managed folders to grant principals access only to the objects within the managed folder, which lets you more finely control access for specific data sets and tables within a bucket. You can nest managed folders up to 15 levels deep, including the parent managed folder. Managed folders can only be created in buckets that have uniform bucket-level access enabled. To get more information about ManagedFolder, see:

Example Usage

Storage Managed Folder Basic

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,
});
const folder = new gcp.storage.ManagedFolder("folder", {
    bucket: bucket.name,
    name: "managed/folder/name/",
    forceDestroy: true,
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
bucket = gcp.storage.Bucket("bucket",
    name="my-bucket",
    location="EU",
    uniform_bucket_level_access=True)
folder = gcp.storage.ManagedFolder("folder",
    bucket=bucket.name,
    name="managed/folder/name/",
    force_destroy=True)
Content copied to clipboard
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,
    });
    var folder = new Gcp.Storage.ManagedFolder("folder", new()
    {
        Bucket = bucket.Name,
        Name = "managed/folder/name/",
        ForceDestroy = true,
    });
});
Content copied to clipboard
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, "bucket", &storage.BucketArgs{
			Name:                     pulumi.String("my-bucket"),
			Location:                 pulumi.String("EU"),
			UniformBucketLevelAccess: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = storage.NewManagedFolder(ctx, "folder", &storage.ManagedFolderArgs{
			Bucket:       bucket.Name,
			Name:         pulumi.String("managed/folder/name/"),
			ForceDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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.ManagedFolder;
import com.pulumi.gcp.storage.ManagedFolderArgs;
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)
            .build());
        var folder = new ManagedFolder("folder", ManagedFolderArgs.builder()
            .bucket(bucket.name())
            .name("managed/folder/name/")
            .forceDestroy(true)
            .build());
    }
}
Content copied to clipboard
resources:
  bucket:
    type: gcp:storage:Bucket
    properties:
      name: my-bucket
      location: EU
      uniformBucketLevelAccess: true
  folder:
    type: gcp:storage:ManagedFolder
    properties:
      bucket: ${bucket.name}
      name: managed/folder/name/
      forceDestroy: true
Content copied to clipboard

Import

ManagedFolder can be imported using any of these accepted formats:

  • {{bucket}}/managedFolders/{{name}}

  • {{bucket}}/{{name}} When using the pulumi import command, ManagedFolder can be imported using one of the formats above. For example:

$ pulumi import gcp:storage/managedFolder:ManagedFolder default {{bucket}}/managedFolders/{{name}}
Content copied to clipboard
$ pulumi import gcp:storage/managedFolder:ManagedFolder default {{bucket}}/{{name}}
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(bucket: Output<String>? = null, forceDestroy: Output<Boolean>? = null, name: Output<String>? = null)

Properties

Link copied to clipboard
val bucket: Output<String>? = null

The name of the bucket that contains the managed folder.

Link copied to clipboard
val forceDestroy: Output<Boolean>? = null

Allows the deletion of a managed folder even if contains objects. If a non-empty managed folder is deleted, any objects within the folder will remain in a simulated folder with the same name.

Link copied to clipboard
val name: Output<String>? = null

The name of the managed folder expressed as a path. Must include trailing '/'. For example, example_dir/example_dir2/.

Functions

Link copied to clipboard
open override fun toJava(): ManagedFolderArgs