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

BucketArgs

data class BucketArgs(val autoclass: Output<BucketAutoclassArgs>? = null, val cors: Output<List<BucketCorArgs>>? = null, val customPlacementConfig: Output<BucketCustomPlacementConfigArgs>? = null, val defaultEventBasedHold: Output<Boolean>? = null, val enableObjectRetention: Output<Boolean>? = null, val encryption: Output<BucketEncryptionArgs>? = null, val forceDestroy: Output<Boolean>? = null, val hierarchicalNamespace: Output<BucketHierarchicalNamespaceArgs>? = null, val labels: Output<Map<String, String>>? = null, val lifecycleRules: Output<List<BucketLifecycleRuleArgs>>? = null, val location: Output<String>? = null, val logging: Output<BucketLoggingArgs>? = null, val name: Output<String>? = null, val project: Output<String>? = null, val publicAccessPrevention: Output<String>? = null, val requesterPays: Output<Boolean>? = null, val retentionPolicy: Output<BucketRetentionPolicyArgs>? = null, val rpo: Output<String>? = null, val softDeletePolicy: Output<BucketSoftDeletePolicyArgs>? = null, val storageClass: Output<String>? = null, val uniformBucketLevelAccess: Output<Boolean>? = null, val versioning: Output<BucketVersioningArgs>? = null, val website: Output<BucketWebsiteArgs>? = null) : ConvertibleToJava<BucketArgs>

Creates a new bucket in Google cloud storage service (GCS). Once a bucket has been created, its location can't be changed. For more information see the official documentation and API. Note: If the project id is not set on the resource or in the provider block it will be dynamically determined which will require enabling the compute api.

Example Usage

Creating A Private Bucket In Standard Storage, In The EU Region. Bucket Configured As Static Website And CORS Configurations

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const static_site = new gcp.storage.Bucket("static-site", {
    name: "image-store.com",
    location: "EU",
    forceDestroy: true,
    uniformBucketLevelAccess: true,
    website: {
        mainPageSuffix: "index.html",
        notFoundPage: "404.html",
    },
    cors: [{
        origins: ["http://image-store&#46;com"],
        methods: [
            "GET",
            "HEAD",
            "PUT",
            "POST",
            "DELETE",
        ],
        responseHeaders: ["*"],
        maxAgeSeconds: 3600,
    }],
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
static_site = gcp.storage.Bucket("static-site",
    name="image-store.com",
    location="EU",
    force_destroy=True,
    uniform_bucket_level_access=True,
    website={
        "main_page_suffix": "index.html",
        "not_found_page": "404.html",
    },
    cors=[{
        "origins": ["http://image-store&#46;com"],
        "methods": [
            "GET",
            "HEAD",
            "PUT",
            "POST",
            "DELETE",
        ],
        "response_headers": ["*"],
        "max_age_seconds": 3600,
    }])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var static_site = new Gcp.Storage.Bucket("static-site", new()
    {
        Name = "image-store.com",
        Location = "EU",
        ForceDestroy = true,
        UniformBucketLevelAccess = true,
        Website = new Gcp.Storage.Inputs.BucketWebsiteArgs
        {
            MainPageSuffix = "index.html",
            NotFoundPage = "404.html",
        },
        Cors = new[]
        {
            new Gcp.Storage.Inputs.BucketCorArgs
            {
                Origins = new[]
                {
                    "http://image-store.com",
                },
                Methods = new[]
                {
                    "GET",
                    "HEAD",
                    "PUT",
                    "POST",
                    "DELETE",
                },
                ResponseHeaders = new[]
                {
                    "*",
                },
                MaxAgeSeconds = 3600,
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"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, "static-site", &storage.BucketArgs{
			Name:                     pulumi.String("image-store.com"),
			Location:                 pulumi.String("EU"),
			ForceDestroy:             pulumi.Bool(true),
			UniformBucketLevelAccess: pulumi.Bool(true),
			Website: &storage.BucketWebsiteArgs{
				MainPageSuffix: pulumi.String("index.html"),
				NotFoundPage:   pulumi.String("404.html"),
			},
			Cors: storage.BucketCorArray{
				&storage.BucketCorArgs{
					Origins: pulumi.StringArray{
						pulumi.String("http://image-store.com"),
					},
					Methods: pulumi.StringArray{
						pulumi.String("GET"),
						pulumi.String("HEAD"),
						pulumi.String("PUT"),
						pulumi.String("POST"),
						pulumi.String("DELETE"),
					},
					ResponseHeaders: pulumi.StringArray{
						pulumi.String("*"),
					},
					MaxAgeSeconds: pulumi.Int(3600),
				},
			},
		})
		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.inputs.BucketWebsiteArgs;
import com.pulumi.gcp.storage.inputs.BucketCorArgs;
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 static_site = new Bucket("static-site", BucketArgs.builder()
            .name("image-store.com")
            .location("EU")
            .forceDestroy(true)
            .uniformBucketLevelAccess(true)
            .website(BucketWebsiteArgs.builder()
                .mainPageSuffix("index.html")
                .notFoundPage("404.html")
                .build())
            .cors(BucketCorArgs.builder()
                .origins("http://image-store.com")
                .methods(
                    "GET",
                    "HEAD",
                    "PUT",
                    "POST",
                    "DELETE")
                .responseHeaders("*")
                .maxAgeSeconds(3600)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  static-site:
    type: gcp:storage:Bucket
    properties:
      name: image-store.com
      location: EU
      forceDestroy: true
      uniformBucketLevelAccess: true
      website:
        mainPageSuffix: index.html
        notFoundPage: 404.html
      cors:
        - origins:
            - http://image-store.com
          methods:
            - GET
            - HEAD
            - PUT
            - POST
            - DELETE
          responseHeaders:
            - '*'
          maxAgeSeconds: 3600
Content copied to clipboard

Life Cycle Settings For Storage Bucket Objects

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const auto_expire = new gcp.storage.Bucket("auto-expire", {
    name: "auto-expiring-bucket",
    location: "US",
    forceDestroy: true,
    lifecycleRules: [
        {
            condition: {
                age: 3,
            },
            action: {
                type: "Delete",
            },
        },
        {
            condition: {
                age: 1,
            },
            action: {
                type: "AbortIncompleteMultipartUpload",
            },
        },
    ],
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
auto_expire = gcp.storage.Bucket("auto-expire",
    name="auto-expiring-bucket",
    location="US",
    force_destroy=True,
    lifecycle_rules=[
        {
            "condition": {
                "age": 3,
            },
            "action": {
                "type": "Delete",
            },
        },
        {
            "condition": {
                "age": 1,
            },
            "action": {
                "type": "AbortIncompleteMultipartUpload",
            },
        },
    ])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var auto_expire = new Gcp.Storage.Bucket("auto-expire", new()
    {
        Name = "auto-expiring-bucket",
        Location = "US",
        ForceDestroy = true,
        LifecycleRules = new[]
        {
            new Gcp.Storage.Inputs.BucketLifecycleRuleArgs
            {
                Condition = new Gcp.Storage.Inputs.BucketLifecycleRuleConditionArgs
                {
                    Age = 3,
                },
                Action = new Gcp.Storage.Inputs.BucketLifecycleRuleActionArgs
                {
                    Type = "Delete",
                },
            },
            new Gcp.Storage.Inputs.BucketLifecycleRuleArgs
            {
                Condition = new Gcp.Storage.Inputs.BucketLifecycleRuleConditionArgs
                {
                    Age = 1,
                },
                Action = new Gcp.Storage.Inputs.BucketLifecycleRuleActionArgs
                {
                    Type = "AbortIncompleteMultipartUpload",
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"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, "auto-expire", &storage.BucketArgs{
			Name:         pulumi.String("auto-expiring-bucket"),
			Location:     pulumi.String("US"),
			ForceDestroy: pulumi.Bool(true),
			LifecycleRules: storage.BucketLifecycleRuleArray{
				&storage.BucketLifecycleRuleArgs{
					Condition: &storage.BucketLifecycleRuleConditionArgs{
						Age: pulumi.Int(3),
					},
					Action: &storage.BucketLifecycleRuleActionArgs{
						Type: pulumi.String("Delete"),
					},
				},
				&storage.BucketLifecycleRuleArgs{
					Condition: &storage.BucketLifecycleRuleConditionArgs{
						Age: pulumi.Int(1),
					},
					Action: &storage.BucketLifecycleRuleActionArgs{
						Type: pulumi.String("AbortIncompleteMultipartUpload"),
					},
				},
			},
		})
		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.inputs.BucketLifecycleRuleArgs;
import com.pulumi.gcp.storage.inputs.BucketLifecycleRuleConditionArgs;
import com.pulumi.gcp.storage.inputs.BucketLifecycleRuleActionArgs;
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 auto_expire = new Bucket("auto-expire", BucketArgs.builder()
            .name("auto-expiring-bucket")
            .location("US")
            .forceDestroy(true)
            .lifecycleRules(
                BucketLifecycleRuleArgs.builder()
                    .condition(BucketLifecycleRuleConditionArgs.builder()
                        .age(3)
                        .build())
                    .action(BucketLifecycleRuleActionArgs.builder()
                        .type("Delete")
                        .build())
                    .build(),
                BucketLifecycleRuleArgs.builder()
                    .condition(BucketLifecycleRuleConditionArgs.builder()
                        .age(1)
                        .build())
                    .action(BucketLifecycleRuleActionArgs.builder()
                        .type("AbortIncompleteMultipartUpload")
                        .build())
                    .build())
            .build());
    }
}
Content copied to clipboard
resources:
  auto-expire:
    type: gcp:storage:Bucket
    properties:
      name: auto-expiring-bucket
      location: US
      forceDestroy: true
      lifecycleRules:
        - condition:
            age: 3
          action:
            type: Delete
        - condition:
            age: 1
          action:
            type: AbortIncompleteMultipartUpload
Content copied to clipboard

Life Cycle Settings For Storage Bucket Objects With Send_age_if_zero Disabled

When creating a life cycle condition that does not also include an age field, a default age of 0 will be set. Set the send_age_if_zero flag to false to prevent this and avoid any potentially unintended interactions.

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const no_age_enabled = new gcp.storage.Bucket("no-age-enabled", {
    name: "no-age-enabled-bucket",
    location: "US",
    forceDestroy: true,
    lifecycleRules: [{
        action: {
            type: "Delete",
        },
        condition: {
            daysSinceNoncurrentTime: 3,
            sendAgeIfZero: false,
        },
    }],
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
no_age_enabled = gcp.storage.Bucket("no-age-enabled",
    name="no-age-enabled-bucket",
    location="US",
    force_destroy=True,
    lifecycle_rules=[{
        "action": {
            "type": "Delete",
        },
        "condition": {
            "days_since_noncurrent_time": 3,
            "send_age_if_zero": False,
        },
    }])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var no_age_enabled = new Gcp.Storage.Bucket("no-age-enabled", new()
    {
        Name = "no-age-enabled-bucket",
        Location = "US",
        ForceDestroy = true,
        LifecycleRules = new[]
        {
            new Gcp.Storage.Inputs.BucketLifecycleRuleArgs
            {
                Action = new Gcp.Storage.Inputs.BucketLifecycleRuleActionArgs
                {
                    Type = "Delete",
                },
                Condition = new Gcp.Storage.Inputs.BucketLifecycleRuleConditionArgs
                {
                    DaysSinceNoncurrentTime = 3,
                    SendAgeIfZero = false,
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"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, "no-age-enabled", &storage.BucketArgs{
			Name:         pulumi.String("no-age-enabled-bucket"),
			Location:     pulumi.String("US"),
			ForceDestroy: pulumi.Bool(true),
			LifecycleRules: storage.BucketLifecycleRuleArray{
				&storage.BucketLifecycleRuleArgs{
					Action: &storage.BucketLifecycleRuleActionArgs{
						Type: pulumi.String("Delete"),
					},
					Condition: &storage.BucketLifecycleRuleConditionArgs{
						DaysSinceNoncurrentTime: pulumi.Int(3),
						SendAgeIfZero:           pulumi.Bool(false),
					},
				},
			},
		})
		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.inputs.BucketLifecycleRuleArgs;
import com.pulumi.gcp.storage.inputs.BucketLifecycleRuleActionArgs;
import com.pulumi.gcp.storage.inputs.BucketLifecycleRuleConditionArgs;
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 no_age_enabled = new Bucket("no-age-enabled", BucketArgs.builder()
            .name("no-age-enabled-bucket")
            .location("US")
            .forceDestroy(true)
            .lifecycleRules(BucketLifecycleRuleArgs.builder()
                .action(BucketLifecycleRuleActionArgs.builder()
                    .type("Delete")
                    .build())
                .condition(BucketLifecycleRuleConditionArgs.builder()
                    .daysSinceNoncurrentTime(3)
                    .sendAgeIfZero(false)
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  no-age-enabled:
    type: gcp:storage:Bucket
    properties:
      name: no-age-enabled-bucket
      location: US
      forceDestroy: true
      lifecycleRules:
        - action:
            type: Delete
          condition:
            daysSinceNoncurrentTime: 3
            sendAgeIfZero: false
Content copied to clipboard

Enabling Public Access Prevention

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const no_public_access = new gcp.storage.Bucket("no-public-access", {
    name: "no-public-access-bucket",
    location: "US",
    forceDestroy: true,
    publicAccessPrevention: "enforced",
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
no_public_access = gcp.storage.Bucket("no-public-access",
    name="no-public-access-bucket",
    location="US",
    force_destroy=True,
    public_access_prevention="enforced")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var no_public_access = new Gcp.Storage.Bucket("no-public-access", new()
    {
        Name = "no-public-access-bucket",
        Location = "US",
        ForceDestroy = true,
        PublicAccessPrevention = "enforced",
    });
});
Content copied to clipboard
package main
import (
	"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, "no-public-access", &storage.BucketArgs{
			Name:                   pulumi.String("no-public-access-bucket"),
			Location:               pulumi.String("US"),
			ForceDestroy:           pulumi.Bool(true),
			PublicAccessPrevention: pulumi.String("enforced"),
		})
		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 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 no_public_access = new Bucket("no-public-access", BucketArgs.builder()
            .name("no-public-access-bucket")
            .location("US")
            .forceDestroy(true)
            .publicAccessPrevention("enforced")
            .build());
    }
}
Content copied to clipboard
resources:
  no-public-access:
    type: gcp:storage:Bucket
    properties:
      name: no-public-access-bucket
      location: US
      forceDestroy: true
      publicAccessPrevention: enforced
Content copied to clipboard

Enabling Hierarchical Namespace

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const hns_enabled = new gcp.storage.Bucket("hns-enabled", {
    name: "hns-enabled-bucket",
    location: "US",
    forceDestroy: true,
    hierarchicalNamespace: {
        enabled: true,
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
hns_enabled = gcp.storage.Bucket("hns-enabled",
    name="hns-enabled-bucket",
    location="US",
    force_destroy=True,
    hierarchical_namespace={
        "enabled": True,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var hns_enabled = new Gcp.Storage.Bucket("hns-enabled", new()
    {
        Name = "hns-enabled-bucket",
        Location = "US",
        ForceDestroy = true,
        HierarchicalNamespace = new Gcp.Storage.Inputs.BucketHierarchicalNamespaceArgs
        {
            Enabled = true,
        },
    });
});
Content copied to clipboard
package main
import (
	"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, "hns-enabled", &storage.BucketArgs{
			Name:         pulumi.String("hns-enabled-bucket"),
			Location:     pulumi.String("US"),
			ForceDestroy: pulumi.Bool(true),
			HierarchicalNamespace: &storage.BucketHierarchicalNamespaceArgs{
				Enabled: 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.inputs.BucketHierarchicalNamespaceArgs;
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 hns_enabled = new Bucket("hns-enabled", BucketArgs.builder()
            .name("hns-enabled-bucket")
            .location("US")
            .forceDestroy(true)
            .hierarchicalNamespace(BucketHierarchicalNamespaceArgs.builder()
                .enabled(true)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  hns-enabled:
    type: gcp:storage:Bucket
    properties:
      name: hns-enabled-bucket
      location: US
      forceDestroy: true
      hierarchicalNamespace:
        enabled: true
Content copied to clipboard

Import

Storage buckets can be imported using the name or project/name. If the project is not passed to the import command it will be inferred from the provider block or environment variables. If it cannot be inferred it will be queried from the Compute API (this will fail if the API is not enabled).

  • {{project_id}}/{{bucket}}

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

$ pulumi import gcp:storage/bucket:Bucket default {{bucket}}
Content copied to clipboard
$ pulumi import gcp:storage/bucket:Bucket default {{project_id}}/{{bucket}}
Content copied to clipboard

false in state. If you've set it to true in config, run pulumi up to update the value set in state. If you delete this resource before updating the value, objects in the bucket will not be destroyed.

Constructors

Link copied to clipboard
constructor(autoclass: Output<BucketAutoclassArgs>? = null, cors: Output<List<BucketCorArgs>>? = null, customPlacementConfig: Output<BucketCustomPlacementConfigArgs>? = null, defaultEventBasedHold: Output<Boolean>? = null, enableObjectRetention: Output<Boolean>? = null, encryption: Output<BucketEncryptionArgs>? = null, forceDestroy: Output<Boolean>? = null, hierarchicalNamespace: Output<BucketHierarchicalNamespaceArgs>? = null, labels: Output<Map<String, String>>? = null, lifecycleRules: Output<List<BucketLifecycleRuleArgs>>? = null, location: Output<String>? = null, logging: Output<BucketLoggingArgs>? = null, name: Output<String>? = null, project: Output<String>? = null, publicAccessPrevention: Output<String>? = null, requesterPays: Output<Boolean>? = null, retentionPolicy: Output<BucketRetentionPolicyArgs>? = null, rpo: Output<String>? = null, softDeletePolicy: Output<BucketSoftDeletePolicyArgs>? = null, storageClass: Output<String>? = null, uniformBucketLevelAccess: Output<Boolean>? = null, versioning: Output<BucketVersioningArgs>? = null, website: Output<BucketWebsiteArgs>? = null)

Properties

Link copied to clipboard
val autoclass: Output<BucketAutoclassArgs>? = null

The bucket's Autoclass configuration. Structure is documented below.

Link copied to clipboard
val cors: Output<List<BucketCorArgs>>? = null

The bucket's Cross-Origin Resource Sharing (CORS) configuration. Multiple blocks of this type are permitted. Structure is documented below.

Link copied to clipboard
val customPlacementConfig: Output<BucketCustomPlacementConfigArgs>? = null

The bucket's custom location configuration, which specifies the individual regions that comprise a dual-region bucket. If the bucket is designated a single or multi-region, the parameters are empty. Structure is documented below.

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

Whether or not to automatically apply an eventBasedHold to new objects added to the bucket.

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

Enables object retention on a storage bucket.

Link copied to clipboard
val encryption: Output<BucketEncryptionArgs>? = null

The bucket's encryption configuration. Structure is documented below.

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

When deleting a bucket, this boolean option will delete all contained objects. If you try to delete a bucket that contains objects, the provider will fail that run.

Link copied to clipboard
val hierarchicalNamespace: Output<BucketHierarchicalNamespaceArgs>? = null

The bucket's hierarchical namespace policy, which defines the bucket capability to handle folders in logical structure. Structure is documented below. To use this configuration, uniform_bucket_level_access must be enabled on bucket.

Link copied to clipboard
val labels: Output<Map<String, String>>? = null

A map of key/value label pairs to assign to the bucket.

Link copied to clipboard
val lifecycleRules: Output<List<BucketLifecycleRuleArgs>>? = null

The bucket's Lifecycle Rules configuration. Multiple blocks of this type are permitted. Structure is documented below.

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

The GCS location.

Link copied to clipboard
val logging: Output<BucketLoggingArgs>? = null

The bucket's Access & Storage Logs configuration. Structure is documented below.

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

The name of the bucket.

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

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

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

Prevents public access to a bucket. Acceptable values are "inherited" or "enforced". If "inherited", the bucket uses public access prevention only if the bucket is subject to the public access prevention organization policy constraint. Defaults to "inherited".

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

Enables Requester Pays on a storage bucket.

Link copied to clipboard
val retentionPolicy: Output<BucketRetentionPolicyArgs>? = null

Configuration of the bucket's data retention policy for how long objects in the bucket should be retained. Structure is documented below.

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

The recovery point objective for cross-region replication of the bucket. Applicable only for dual and multi-region buckets. "DEFAULT" sets default replication. "ASYNC_TURBO" value enables turbo replication, valid for dual-region buckets only. See Turbo Replication for more information. If rpo is not specified at bucket creation, it defaults to "DEFAULT" for dual and multi-region buckets. NOTE If used with single-region bucket, It will throw an error.

Link copied to clipboard
val softDeletePolicy: Output<BucketSoftDeletePolicyArgs>? = null

The bucket's soft delete policy, which defines the period of time that soft-deleted objects will be retained, and cannot be permanently deleted. If it is not provided, by default Google Cloud Storage sets this to default soft delete policy

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

The Storage Class of the new bucket. Supported values include: STANDARD, MULTI_REGIONAL, REGIONAL, NEARLINE, COLDLINE, ARCHIVE.

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

Enables Uniform bucket-level access access to a bucket.

Link copied to clipboard
val versioning: Output<BucketVersioningArgs>? = null

The bucket's Versioning configuration. Structure is documented below.

Link copied to clipboard
val website: Output<BucketWebsiteArgs>? = null

Configuration if the bucket acts as a website. Structure is documented below.

Functions

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