java.lang.Object
- com.pulumi.resources.Resource
- - com.pulumi.resources.CustomResource
  - - com.pulumi.aws.s3.BucketLifecycleConfiguration

public class BucketLifecycleConfiguration
extends com.pulumi.resources.CustomResource

Provides an independent configuration resource for S3 bucket [lifecycle configuration](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html). 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`](https://docs.aws.amazon.com/AmazonS3/latest/userguide/intro-lifecycle-rules.html). > S3 Buckets only support a single lifecycle configuration. Declaring multiple `aws.s3.BucketLifecycleConfiguration` resources to the same S3 Bucket will cause a perpetual difference in configuration. > Lifecycle configurations may take some time to fully propagate to all AWS S3 systems. Running Pulumi operations shortly after creating a lifecycle configuration may result in changes that affect configuration idempotence. See the Amazon S3 User Guide on [setting lifecycle configuration on a bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html). ## Example Usage ### With neither a filter nor prefix specified When you don't specify a filter or prefix, the lifecycle rule applies to all objects in the bucket. This has the same effect as setting an empty `filter` element.

 
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.s3.BucketLifecycleConfiguration;
 import com.pulumi.aws.s3.BucketLifecycleConfigurationArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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 BucketLifecycleConfiguration("example", BucketLifecycleConfigurationArgs.builder()
             .rules(BucketLifecycleConfigurationRuleArgs.builder()
                 .id("rule-1")
                 .status("Enabled")
                 .build())
             .bucket(bucket.bucket())
             .build());
 
     }
 }

### 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.BucketLifecycleConfiguration;
 import com.pulumi.aws.s3.BucketLifecycleConfigurationArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleFilterArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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 BucketLifecycleConfiguration("example", BucketLifecycleConfigurationArgs.builder()
             .rules(BucketLifecycleConfigurationRuleArgs.builder()
                 .filter(BucketLifecycleConfigurationRuleFilterArgs.builder()
                     .build())
                 .id("rule-1")
                 .status("Enabled")
                 .build())
             .bucket(bucket.bucket())
             .build());
 
     }
 }

### 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.BucketLifecycleConfiguration;
 import com.pulumi.aws.s3.BucketLifecycleConfigurationArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleFilterArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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 BucketLifecycleConfiguration("example", BucketLifecycleConfigurationArgs.builder()
             .rules(BucketLifecycleConfigurationRuleArgs.builder()
                 .filter(BucketLifecycleConfigurationRuleFilterArgs.builder()
                     .prefix("logs/")
                     .build())
                 .id("rule-1")
                 .status("Enabled")
                 .build())
             .bucket(bucket.bucket())
             .build());
 
     }
 }

If you want to apply a Lifecycle action to a subset of objects based on different key name prefixes, specify separate rules.

 
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.s3.BucketLifecycleConfiguration;
 import com.pulumi.aws.s3.BucketLifecycleConfigurationArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleFilterArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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 BucketLifecycleConfiguration("example", BucketLifecycleConfigurationArgs.builder()
             .rules(            
                 BucketLifecycleConfigurationRuleArgs.builder()
                     .filter(BucketLifecycleConfigurationRuleFilterArgs.builder()
                         .prefix("logs/")
                         .build())
                     .id("rule-1")
                     .status("Enabled")
                     .build(),
                 BucketLifecycleConfigurationRuleArgs.builder()
                     .filter(BucketLifecycleConfigurationRuleFilterArgs.builder()
                         .prefix("tmp/")
                         .build())
                     .id("rule-2")
                     .status("Enabled")
                     .build())
             .bucket(bucket.bucket())
             .build());
 
     }
 }

### 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.BucketLifecycleConfiguration;
 import com.pulumi.aws.s3.BucketLifecycleConfigurationArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleFilterArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleFilterTagArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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 BucketLifecycleConfiguration("example", BucketLifecycleConfigurationArgs.builder()
             .rules(BucketLifecycleConfigurationRuleArgs.builder()
                 .filter(BucketLifecycleConfigurationRuleFilterArgs.builder()
                     .tag(BucketLifecycleConfigurationRuleFilterTagArgs.builder()
                         .key("Name")
                         .value("Staging")
                         .build())
                     .build())
                 .id("rule-1")
                 .status("Enabled")
                 .build())
             .bucket(bucket.bucket())
             .build());
 
     }
 }

### 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.BucketLifecycleConfiguration;
 import com.pulumi.aws.s3.BucketLifecycleConfigurationArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleFilterArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleFilterAndArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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 BucketLifecycleConfiguration("example", BucketLifecycleConfigurationArgs.builder()
             .rules(BucketLifecycleConfigurationRuleArgs.builder()
                 .filter(BucketLifecycleConfigurationRuleFilterArgs.builder()
                     .and(BucketLifecycleConfigurationRuleFilterAndArgs.builder()
                         .tags(Map.ofEntries(
                             Map.entry("Key1", "Value1"),
                             Map.entry("Key2", "Value2")
                         ))
                         .build())
                     .build())
                 .id("rule-1")
                 .status("Enabled")
                 .build())
             .bucket(bucket.bucket())
             .build());
 
     }
 }

### 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.BucketLifecycleConfiguration;
 import com.pulumi.aws.s3.BucketLifecycleConfigurationArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleFilterArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleFilterAndArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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 BucketLifecycleConfiguration("example", BucketLifecycleConfigurationArgs.builder()
             .rules(BucketLifecycleConfigurationRuleArgs.builder()
                 .filter(BucketLifecycleConfigurationRuleFilterArgs.builder()
                     .and(BucketLifecycleConfigurationRuleFilterAndArgs.builder()
                         .prefix("logs/")
                         .tags(Map.ofEntries(
                             Map.entry("Key1", "Value1"),
                             Map.entry("Key2", "Value2")
                         ))
                         .build())
                     .build())
                 .id("rule-1")
                 .status("Enabled")
                 .build())
             .bucket(bucket.bucket())
             .build());
 
     }
 }

### Specifying a filter based on object size Object size values are in bytes. Maximum filter size is 5TB. Amazon S3 applies a default behavior to your Lifecycle configuration that prevents objects smaller than 128 KB from being transitioned to any storage class. You can allow smaller objects to transition by adding a minimum size (`objectSizeGreaterThan`) or a maximum size (`objectSizeLessThan`) filter that specifies a smaller size to the configuration. This example allows any object smaller than 128 KB to transition to the S3 Glacier Instant Retrieval storage class:

 
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.s3.BucketLifecycleConfiguration;
 import com.pulumi.aws.s3.BucketLifecycleConfigurationArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleFilterArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleTransitionArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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 BucketLifecycleConfiguration("example", BucketLifecycleConfigurationArgs.builder()
             .rules(BucketLifecycleConfigurationRuleArgs.builder()
                 .filter(BucketLifecycleConfigurationRuleFilterArgs.builder()
                     .objectSizeGreaterThan(1)
                     .build())
                 .transitions(BucketLifecycleConfigurationRuleTransitionArgs.builder()
                     .days(365)
                     .storageClass("GLACIER_IR")
                     .build())
                 .id("Allow small object transitions")
                 .status("Enabled")
                 .build())
             .bucket(bucket.bucket())
             .build());
 
     }
 }

### Specifying a filter based on object size range and prefix The `objectSizeGreaterThan` must be less than the `objectSizeLessThan`. 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.BucketLifecycleConfiguration;
 import com.pulumi.aws.s3.BucketLifecycleConfigurationArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleFilterArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleFilterAndArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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 BucketLifecycleConfiguration("example", BucketLifecycleConfigurationArgs.builder()
             .rules(BucketLifecycleConfigurationRuleArgs.builder()
                 .filter(BucketLifecycleConfigurationRuleFilterArgs.builder()
                     .and(BucketLifecycleConfigurationRuleFilterAndArgs.builder()
                         .prefix("logs/")
                         .objectSizeGreaterThan(500)
                         .objectSizeLessThan(64000)
                         .build())
                     .build())
                 .id("rule-1")
                 .status("Enabled")
                 .build())
             .bucket(bucket.bucket())
             .build());
 
     }
 }

### 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.Bucket;
 import com.pulumi.aws.s3.BucketArgs;
 import com.pulumi.aws.s3.BucketAcl;
 import com.pulumi.aws.s3.BucketAclArgs;
 import com.pulumi.aws.s3.BucketLifecycleConfiguration;
 import com.pulumi.aws.s3.BucketLifecycleConfigurationArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleExpirationArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleFilterArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleFilterAndArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleTransitionArgs;
 import com.pulumi.aws.s3.BucketVersioning;
 import com.pulumi.aws.s3.BucketVersioningArgs;
 import com.pulumi.aws.s3.inputs.BucketVersioningVersioningConfigurationArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleNoncurrentVersionExpirationArgs;
 import com.pulumi.aws.s3.inputs.BucketLifecycleConfigurationRuleNoncurrentVersionTransitionArgs;
 import com.pulumi.resources.CustomResourceOptions;
 import java.util.ArrayList;
 import java.util.Arrays;
 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()
             .bucket("my-bucket")
             .build());
 
         var bucketAcl = new BucketAcl("bucketAcl", BucketAclArgs.builder()
             .bucket(bucket.bucket())
             .acl("private")
             .build());
 
         var bucket_config = new BucketLifecycleConfiguration("bucket-config", BucketLifecycleConfigurationArgs.builder()
             .rules(            
                 BucketLifecycleConfigurationRuleArgs.builder()
                     .expiration(BucketLifecycleConfigurationRuleExpirationArgs.builder()
                         .days(90)
                         .build())
                     .filter(BucketLifecycleConfigurationRuleFilterArgs.builder()
                         .and(BucketLifecycleConfigurationRuleFilterAndArgs.builder()
                             .prefix("log/")
                             .tags(Map.ofEntries(
                                 Map.entry("rule", "log"),
                                 Map.entry("autoclean", "true")
                             ))
                             .build())
                         .build())
                     .transitions(                    
                         BucketLifecycleConfigurationRuleTransitionArgs.builder()
                             .days(30)
                             .storageClass("STANDARD_IA")
                             .build(),
                         BucketLifecycleConfigurationRuleTransitionArgs.builder()
                             .days(60)
                             .storageClass("GLACIER")
                             .build())
                     .id("log")
                     .status("Enabled")
                     .build(),
                 BucketLifecycleConfigurationRuleArgs.builder()
                     .filter(BucketLifecycleConfigurationRuleFilterArgs.builder()
                         .prefix("tmp/")
                         .build())
                     .expiration(BucketLifecycleConfigurationRuleExpirationArgs.builder()
                         .date("2023-01-13T00:00:00Z")
                         .build())
                     .id("tmp")
                     .status("Enabled")
                     .build())
             .bucket(bucket.bucket())
             .build());
 
         var versioningBucket = new Bucket("versioningBucket", BucketArgs.builder()
             .bucket("my-versioning-bucket")
             .build());
 
         var versioningBucketAcl = new BucketAcl("versioningBucketAcl", BucketAclArgs.builder()
             .bucket(versioningBucket.bucket())
             .acl("private")
             .build());
 
         var versioning = new BucketVersioning("versioning", BucketVersioningArgs.builder()
             .versioningConfiguration(BucketVersioningVersioningConfigurationArgs.builder()
                 .status("Enabled")
                 .build())
             .bucket(versioningBucket.bucket())
             .build());
 
         var versioning_bucket_config = new BucketLifecycleConfiguration("versioning-bucket-config", BucketLifecycleConfigurationArgs.builder()
             .rules(BucketLifecycleConfigurationRuleArgs.builder()
                 .filter(BucketLifecycleConfigurationRuleFilterArgs.builder()
                     .prefix("config/")
                     .build())
                 .noncurrentVersionExpiration(BucketLifecycleConfigurationRuleNoncurrentVersionExpirationArgs.builder()
                     .noncurrentDays(90)
                     .build())
                 .noncurrentVersionTransitions(                
                     BucketLifecycleConfigurationRuleNoncurrentVersionTransitionArgs.builder()
                         .noncurrentDays(30)
                         .storageClass("STANDARD_IA")
                         .build(),
                     BucketLifecycleConfigurationRuleNoncurrentVersionTransitionArgs.builder()
                         .noncurrentDays(60)
                         .storageClass("GLACIER")
                         .build())
                 .id("config")
                 .status("Enabled")
                 .build())
             .bucket(versioningBucket.bucket())
             .build(), CustomResourceOptions.builder()
                 .dependsOn(versioning)
                 .build());
 
     }
 }

## Import ### Identity Schema #### Required * `bucket` (String) S3 bucket name. #### Optional * `accountId` (String) AWS Account where this resource is managed. * `region` (String) Region where this resource is managed. If the owner (account ID) of the source bucket differs from the account used to configure the AWS Provider, import using the `bucket` and `expectedBucketOwner` separated by a comma (`,`): Using `pulumi import`, import an S3 bucket lifecycle configuration using the `bucket` or the `bucket` and `expectedBucketOwner` separated by a comma (`,`). For example: If the owner (account ID) of the source bucket is the same account used to configure the AWS Provider, import using the `bucket`: ```sh $ pulumi import aws:s3/bucketLifecycleConfiguration:BucketLifecycleConfiguration example bucket-name ``` If the owner (account ID) of the source bucket differs from the account used to configure the AWS Provider, import using the `bucket` and `expectedBucketOwner` separated by a comma (`,`): ```sh $ pulumi import aws:s3/bucketLifecycleConfiguration:BucketLifecycleConfiguration example bucket-name,123456789012 ```

Nested Class Summary
- Nested classes/interfaces inherited from class com.pulumi.resources.CustomResource
  com.pulumi.resources.CustomResource.CustomResourceInternal
- Nested classes/interfaces inherited from class com.pulumi.resources.Resource
  com.pulumi.resources.Resource.LazyField<T extends java.lang.Object>, com.pulumi.resources.Resource.LazyFields, com.pulumi.resources.Resource.ResourceInternal

Field Summary
- Fields inherited from class com.pulumi.resources.Resource
  childResources, remote

Constructor Summary

Constructors
Constructor	Description
`BucketLifecycleConfiguration(java.lang.String name)`
`BucketLifecycleConfiguration(java.lang.String name, BucketLifecycleConfigurationArgs args)`
`BucketLifecycleConfiguration(java.lang.String name, BucketLifecycleConfigurationArgs args, com.pulumi.resources.CustomResourceOptions options)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`com.pulumi.core.Output<java.lang.String>`	`bucket()`
`com.pulumi.core.Output<java.lang.String>`	`expectedBucketOwner()`
`static BucketLifecycleConfiguration`	`get(java.lang.String name, com.pulumi.core.Output<java.lang.String> id, BucketLifecycleConfigurationState state, com.pulumi.resources.CustomResourceOptions options)`	Get an existing Host resource's state with the given name, ID, and optional extra properties used to qualify the lookup.
`com.pulumi.core.Output<java.lang.String>`	`region()`
`com.pulumi.core.Output<java.util.Optional<java.util.List<BucketLifecycleConfigurationRule>>>`	`rules()`
`com.pulumi.core.Output<java.util.Optional<BucketLifecycleConfigurationTimeouts>>`	`timeouts()`
`com.pulumi.core.Output<java.lang.String>`	`transitionDefaultMinimumObjectSize()`

Methods inherited from class com.pulumi.resources.CustomResource
getId, id, idFuture

Methods inherited from class com.pulumi.resources.Resource
getChildResources, getResourceName, getResourceType, getUrn, pulumiChildResources, pulumiResourceName, pulumiResourceType, urn

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - BucketLifecycleConfiguration
```
public BucketLifecycleConfiguration(java.lang.String name)
```
    Parameters:
    
    name - The _unique_ name of the resulting resource.
  - BucketLifecycleConfiguration
```
public BucketLifecycleConfiguration(java.lang.String name,
                                    BucketLifecycleConfigurationArgs args)
```
    Parameters:
    
    name - The _unique_ name of the resulting resource.
    
    args - The arguments to use to populate this resource's properties.
  - BucketLifecycleConfiguration
```
public BucketLifecycleConfiguration(java.lang.String name,
                                    BucketLifecycleConfigurationArgs args,
                                    @Nullable
                                    com.pulumi.resources.CustomResourceOptions options)
```
    Parameters:
    
    name - The _unique_ name of the resulting resource.
    
    args - The arguments to use to populate this resource's properties.
    
    options - A bag of options that control this resource's behavior.
- Method Detail
  - bucket
```
public com.pulumi.core.Output<java.lang.String> bucket()
```
    Returns:
    
    Name of the source S3 bucket you want Amazon S3 to monitor.
  - expectedBucketOwner
```
public com.pulumi.core.Output<java.lang.String> expectedBucketOwner()
```
    Returns:
    
    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.
  - region
```
public com.pulumi.core.Output<java.lang.String> region()
```
    Returns:
    
    Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
  - rules
```
public com.pulumi.core.Output<java.util.Optional<java.util.List<BucketLifecycleConfigurationRule>>> rules()
```
    Returns:
    
    List of configuration blocks describing the rules managing the replication. See below.
  - timeouts
```
public com.pulumi.core.Output<java.util.Optional<BucketLifecycleConfigurationTimeouts>> timeouts()
```
  - transitionDefaultMinimumObjectSize
```
public com.pulumi.core.Output<java.lang.String> transitionDefaultMinimumObjectSize()
```
    Returns:
    
    Default minimum object size behavior applied to the lifecycle configuration. Valid values: `all_storage_classes_128K` (default), `variesByStorageClass`. To customize the minimum object size for any transition you can add a `filter` that specifies a custom `objectSizeGreaterThan` or `objectSizeLessThan` value. Custom filters always take precedence over the default transition behavior.
  - get
```
public static BucketLifecycleConfiguration get(java.lang.String name,
                                               com.pulumi.core.Output<java.lang.String> id,
                                               @Nullable
                                               BucketLifecycleConfigurationState state,
                                               @Nullable
                                               com.pulumi.resources.CustomResourceOptions options)
```
    Get an existing Host resource's state with the given name, ID, and optional extra properties used to qualify the lookup.
    
    Parameters:
    
    name - The _unique_ name of the resulting resource.
    
    id - The _unique_ provider ID of the resource to lookup.
    
    state -
    
    options - Optional settings to control the behavior of the CustomResource.

Class BucketLifecycleConfiguration

Nested Class Summary

Nested classes/interfaces inherited from class com.pulumi.resources.CustomResource

Nested classes/interfaces inherited from class com.pulumi.resources.Resource

Field Summary

Fields inherited from class com.pulumi.resources.Resource

Constructor Summary

Method Summary

Methods inherited from class com.pulumi.resources.CustomResource

Methods inherited from class com.pulumi.resources.Resource

Methods inherited from class java.lang.Object

Constructor Detail

BucketLifecycleConfiguration

BucketLifecycleConfiguration

BucketLifecycleConfiguration

Method Detail

bucket

expectedBucketOwner

region

rules

timeouts

transitionDefaultMinimumObjectSize

get