pulumi-aws-kotlin/com.pulumi.aws.s3.kotlin/BucketLifecycleConfigurationV2Args

BucketLifecycleConfigurationV2Args

data class BucketLifecycleConfigurationV2Args(val bucket: Output<String>? = null, val expectedBucketOwner: Output<String>? = null, val rules: Output<List<BucketLifecycleConfigurationV2RuleArgs>>? = null) : ConvertibleToJava<BucketLifecycleConfigurationV2Args>

Provides an independent configuration resource for S3 bucket lifecycle configuration. An S3 Lifecycle configuration consists of one or more Lifecycle rules. Each rule consists of the following:

  • Rule metadata (id and status)

  • Filter identifying objects to which the rule applies

  • One or more transition or expiration actions For more information see the Amazon S3 User Guide on Lifecycle Configuration Elements.

NOTE: S3 Buckets only support a single lifecycle configuration. Declaring multiple aws.s3.BucketLifecycleConfigurationV2 resources to the same S3 Bucket will cause a perpetual difference in configuration.

Example Usage

With neither a filter nor prefix specified

The Lifecycle rule applies to a subset of objects based on the key name prefix (""). This configuration is intended to replicate the default behavior of the lifecycle_rule parameter in the AWS Provider aws.s3.BucketV2 resource prior to v4.0.

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2Args;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleArgs;
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 example = new BucketLifecycleConfigurationV2("example", BucketLifecycleConfigurationV2Args.builder()
            .bucket(aws_s3_bucket.bucket().id())
            .rules(BucketLifecycleConfigurationV2RuleArgs.builder()
                .id("rule-1")
                .status("Enabled")
                .build())
            .build());
    }
}
Content copied to clipboard

Specifying an empty filter

The Lifecycle rule applies to all objects in the bucket.

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2Args;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleFilterArgs;
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 example = new BucketLifecycleConfigurationV2("example", BucketLifecycleConfigurationV2Args.builder()
            .bucket(aws_s3_bucket.bucket().id())
            .rules(BucketLifecycleConfigurationV2RuleArgs.builder()
                .id("rule-1")
                .filter()
                .status("Enabled")
                .build())
            .build());
    }
}
Content copied to clipboard

Specifying a filter using key prefixes

The Lifecycle rule applies to a subset of objects based on the key name prefix (logs/).

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2Args;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleFilterArgs;
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 example = new BucketLifecycleConfigurationV2("example", BucketLifecycleConfigurationV2Args.builder()
            .bucket(aws_s3_bucket.bucket().id())
            .rules(BucketLifecycleConfigurationV2RuleArgs.builder()
                .id("rule-1")
                .filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
                    .prefix("logs/")
                    .build())
                .status("Enabled")
                .build())
            .build());
    }
}
Content copied to clipboard

Specifying a filter based on an object tag

The Lifecycle rule specifies a filter based on a tag key and value. The rule then applies only to a subset of objects with the specific tag.

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2Args;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleFilterArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleFilterTagArgs;
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 example = new BucketLifecycleConfigurationV2("example", BucketLifecycleConfigurationV2Args.builder()
            .bucket(aws_s3_bucket.bucket().id())
            .rules(BucketLifecycleConfigurationV2RuleArgs.builder()
                .id("rule-1")
                .filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
                    .tag(BucketLifecycleConfigurationV2RuleFilterTagArgs.builder()
                        .key("Name")
                        .value("Staging")
                        .build())
                    .build())
                .status("Enabled")
                .build())
            .build());
    }
}
Content copied to clipboard

Specifying a filter based on multiple tags

The Lifecycle rule directs Amazon S3 to perform lifecycle actions on objects with two tags (with the specific tag keys and values). Notice tags is wrapped in the and configuration block.

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2Args;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleFilterArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleFilterAndArgs;
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 example = new BucketLifecycleConfigurationV2("example", BucketLifecycleConfigurationV2Args.builder()
            .bucket(aws_s3_bucket.bucket().id())
            .rules(BucketLifecycleConfigurationV2RuleArgs.builder()
                .id("rule-1")
                .filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
                    .and(BucketLifecycleConfigurationV2RuleFilterAndArgs.builder()
                        .tags(Map.ofEntries(
                            Map.entry("Key1", "Value1"),
                            Map.entry("Key2", "Value2")
                        ))
                        .build())
                    .build())
                .status("Enabled")
                .build())
            .build());
    }
}
Content copied to clipboard

Specifying a filter based on both prefix and one or more tags

The Lifecycle rule directs Amazon S3 to perform lifecycle actions on objects with the specified prefix and two tags (with the specific tag keys and values). Notice both prefix and tags are wrapped in the and configuration block.

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2Args;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleFilterArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleFilterAndArgs;
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 example = new BucketLifecycleConfigurationV2("example", BucketLifecycleConfigurationV2Args.builder()
            .bucket(aws_s3_bucket.bucket().id())
            .rules(BucketLifecycleConfigurationV2RuleArgs.builder()
                .id("rule-1")
                .filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
                    .and(BucketLifecycleConfigurationV2RuleFilterAndArgs.builder()
                        .prefix("logs/")
                        .tags(Map.ofEntries(
                            Map.entry("Key1", "Value1"),
                            Map.entry("Key2", "Value2")
                        ))
                        .build())
                    .build())
                .status("Enabled")
                .build())
            .build());
    }
}
Content copied to clipboard

Specifying a filter based on object size

Object size values are in bytes. Maximum filter size is 5TB. Some storage classes have minimum object size limitations, for more information, see Comparing the Amazon S3 storage classes.

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2Args;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleFilterArgs;
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 example = new BucketLifecycleConfigurationV2("example", BucketLifecycleConfigurationV2Args.builder()
            .bucket(aws_s3_bucket.bucket().id())
            .rules(BucketLifecycleConfigurationV2RuleArgs.builder()
                .id("rule-1")
                .filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
                    .objectSizeGreaterThan(500)
                    .build())
                .status("Enabled")
                .build())
            .build());
    }
}
Content copied to clipboard

Specifying a filter based on object size range and prefix

The object_size_greater_than must be less than the object_size_less_than. Notice both the object size range and prefix are wrapped in the and configuration block.

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2Args;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleFilterArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleFilterAndArgs;
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 example = new BucketLifecycleConfigurationV2("example", BucketLifecycleConfigurationV2Args.builder()
            .bucket(aws_s3_bucket.bucket().id())
            .rules(BucketLifecycleConfigurationV2RuleArgs.builder()
                .id("rule-1")
                .filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
                    .and(BucketLifecycleConfigurationV2RuleFilterAndArgs.builder()
                        .prefix("logs/")
                        .objectSizeGreaterThan(500)
                        .objectSizeLessThan(64000)
                        .build())
                    .build())
                .status("Enabled")
                .build())
            .build());
    }
}
Content copied to clipboard

Creating a Lifecycle Configuration for a bucket with versioning

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.BucketV2;
import com.pulumi.aws.s3.BucketAclV2;
import com.pulumi.aws.s3.BucketAclV2Args;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2;
import com.pulumi.aws.s3.BucketLifecycleConfigurationV2Args;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleExpirationArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleFilterArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleFilterAndArgs;
import com.pulumi.aws.s3.BucketVersioningV2;
import com.pulumi.aws.s3.BucketVersioningV2Args;
import com.pulumi.aws.s3.inputs.BucketVersioningV2VersioningConfigurationArgs;
import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationV2RuleNoncurrentVersionExpirationArgs;
import com.pulumi.resources.CustomResourceOptions;
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 BucketV2("bucket");
        var bucketAcl = new BucketAclV2("bucketAcl", BucketAclV2Args.builder()
            .bucket(bucket.id())
            .acl("private")
            .build());
        var bucket_config = new BucketLifecycleConfigurationV2("bucket-config", BucketLifecycleConfigurationV2Args.builder()
            .bucket(bucket.id())
            .rules(
                BucketLifecycleConfigurationV2RuleArgs.builder()
                    .id("log")
                    .expiration(BucketLifecycleConfigurationV2RuleExpirationArgs.builder()
                        .days(90)
                        .build())
                    .filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
                        .and(BucketLifecycleConfigurationV2RuleFilterAndArgs.builder()
                            .prefix("log/")
                            .tags(Map.ofEntries(
                                Map.entry("rule", "log"),
                                Map.entry("autoclean", "true")
                            ))
                            .build())
                        .build())
                    .status("Enabled")
                    .transitions(
                        BucketLifecycleConfigurationV2RuleTransitionArgs.builder()
                            .days(30)
                            .storageClass("STANDARD_IA")
                            .build(),
                        BucketLifecycleConfigurationV2RuleTransitionArgs.builder()
                            .days(60)
                            .storageClass("GLACIER")
                            .build())
                    .build(),
                BucketLifecycleConfigurationV2RuleArgs.builder()
                    .id("tmp")
                    .filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
                        .prefix("tmp/")
                        .build())
                    .expiration(BucketLifecycleConfigurationV2RuleExpirationArgs.builder()
                        .date("2023-01-13T00:00:00Z")
                        .build())
                    .status("Enabled")
                    .build())
            .build());
        var versioningBucket = new BucketV2("versioningBucket");
        var versioningBucketAcl = new BucketAclV2("versioningBucketAcl", BucketAclV2Args.builder()
            .bucket(versioningBucket.id())
            .acl("private")
            .build());
        var versioning = new BucketVersioningV2("versioning", BucketVersioningV2Args.builder()
            .bucket(versioningBucket.id())
            .versioningConfiguration(BucketVersioningV2VersioningConfigurationArgs.builder()
                .status("Enabled")
                .build())
            .build());
        var versioning_bucket_config = new BucketLifecycleConfigurationV2("versioning-bucket-config", BucketLifecycleConfigurationV2Args.builder()
            .bucket(versioningBucket.id())
            .rules(BucketLifecycleConfigurationV2RuleArgs.builder()
                .id("config")
                .filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
                    .prefix("config/")
                    .build())
                .noncurrentVersionExpiration(BucketLifecycleConfigurationV2RuleNoncurrentVersionExpirationArgs.builder()
                    .noncurrentDays(90)
                    .build())
                .noncurrentVersionTransitions(
                    BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArgs.builder()
                        .noncurrentDays(30)
                        .storageClass("STANDARD_IA")
                        .build(),
                    BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArgs.builder()
                        .noncurrentDays(60)
                        .storageClass("GLACIER")
                        .build())
                .status("Enabled")
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(versioning)
                .build());
    }
}
Content copied to clipboard

Import

S3 bucket lifecycle configuration can be imported in one of two ways. If the owner (account ID) of the source bucket is the same account used to configure the AWS Provider, the S3 bucket lifecycle configuration resource should be imported using the bucket e.g.,

$ pulumi import aws:s3/bucketLifecycleConfigurationV2:BucketLifecycleConfigurationV2 example bucket-name
Content copied to clipboard

If the owner (account ID) of the source bucket differs from the account used to configure the AWS Provider, the S3 bucket lifecycle configuration resource should be imported using the bucket and expected_bucket_owner separated by a comma (,) e.g.,

$ pulumi import aws:s3/bucketLifecycleConfigurationV2:BucketLifecycleConfigurationV2 example bucket-name,123456789012
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(bucket: Output<String>? = null, expectedBucketOwner: Output<String>? = null, rules: Output<List<BucketLifecycleConfigurationV2RuleArgs>>? = null)

Properties

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

Name of the source S3 bucket you want Amazon S3 to monitor.

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

Account ID of the expected bucket owner. If the bucket is owned by a different account, the request will fail with an HTTP 403 (Access Denied) error.

Link copied to clipboard
val rules: Output<List<BucketLifecycleConfigurationV2RuleArgs>>? = null

List of configuration blocks describing the rules managing the replication. See below.

Functions

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