BucketLifecycleConfigurationV2 class
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 (
idandstatus) - 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.
> 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.
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.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.s3.BucketLifecycleConfiguration("example", {
rules: [{
id: "rule-1",
status: "Enabled",
}],
bucket: bucket.bucket,
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfiguration("example",
rules=[{
"id": "rule-1",
"status": "Enabled",
}],
bucket=bucket["bucket"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfiguration("example", new()
{
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleArgs
{
Id = "rule-1",
Status = "Enabled",
},
},
Bucket = bucket.Bucket,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfiguration(ctx, "example", &s3.BucketLifecycleConfigurationArgs{
Rules: s3.BucketLifecycleConfigurationRuleArray{
&s3.BucketLifecycleConfigurationRuleArgs{
Id: pulumi.String("rule-1"),
Status: pulumi.String("Enabled"),
},
},
Bucket: pulumi.Any(bucket.Bucket),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_s3_bucketlifecycleconfiguration" "example" {
rules {
id = "rule-1"
status = "Enabled"
}
# ... other transition/expiration actions ...
bucket = bucket.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 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());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfiguration
properties:
rules:
- id: rule-1
status: Enabled
bucket: ${bucket.bucket}
Specifying an empty filter
The Lifecycle rule applies to all objects in the bucket.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.s3.BucketLifecycleConfiguration("example", {
rules: [{
filter: {},
id: "rule-1",
status: "Enabled",
}],
bucket: bucket.bucket,
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfiguration("example",
rules=[{
"filter": {},
"id": "rule-1",
"status": "Enabled",
}],
bucket=bucket["bucket"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfiguration("example", new()
{
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleArgs
{
Filter = null,
Id = "rule-1",
Status = "Enabled",
},
},
Bucket = bucket.Bucket,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfiguration(ctx, "example", &s3.BucketLifecycleConfigurationArgs{
Rules: s3.BucketLifecycleConfigurationRuleArray{
&s3.BucketLifecycleConfigurationRuleArgs{
Filter: &s3.BucketLifecycleConfigurationRuleFilterArgs{},
Id: pulumi.String("rule-1"),
Status: pulumi.String("Enabled"),
},
},
Bucket: pulumi.Any(bucket.Bucket),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_s3_bucketlifecycleconfiguration" "example" {
rules {
filter = {}
id = "rule-1"
status = "Enabled"
}
# ... other transition/expiration actions ...
bucket = bucket.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());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfiguration
properties:
rules:
- filter: {}
id: rule-1
status: Enabled
bucket: ${bucket.bucket}
Specifying a filter using key prefixes
The Lifecycle rule applies to a subset of objects based on the key name prefix (logs/).
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.s3.BucketLifecycleConfiguration("example", {
rules: [{
filter: {
prefix: "logs/",
},
id: "rule-1",
status: "Enabled",
}],
bucket: bucket.bucket,
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfiguration("example",
rules=[{
"filter": {
"prefix": "logs/",
},
"id": "rule-1",
"status": "Enabled",
}],
bucket=bucket["bucket"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfiguration("example", new()
{
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleArgs
{
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterArgs
{
Prefix = "logs/",
},
Id = "rule-1",
Status = "Enabled",
},
},
Bucket = bucket.Bucket,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfiguration(ctx, "example", &s3.BucketLifecycleConfigurationArgs{
Rules: s3.BucketLifecycleConfigurationRuleArray{
&s3.BucketLifecycleConfigurationRuleArgs{
Filter: &s3.BucketLifecycleConfigurationRuleFilterArgs{
Prefix: pulumi.String("logs/"),
},
Id: pulumi.String("rule-1"),
Status: pulumi.String("Enabled"),
},
},
Bucket: pulumi.Any(bucket.Bucket),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_s3_bucketlifecycleconfiguration" "example" {
rules {
filter = {
prefix = "logs/"
}
id = "rule-1"
status = "Enabled"
}
# ... other transition/expiration actions ...
bucket = bucket.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()
.prefix("logs/")
.build())
.id("rule-1")
.status("Enabled")
.build())
.bucket(bucket.bucket())
.build());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfiguration
properties:
rules:
- filter:
prefix: logs/
id: rule-1
status: Enabled
bucket: ${bucket.bucket}
If you want to apply a Lifecycle action to a subset of objects based on different key name prefixes, specify separate rules.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.s3.BucketLifecycleConfiguration("example", {
rules: [
{
filter: {
prefix: "logs/",
},
id: "rule-1",
status: "Enabled",
},
{
filter: {
prefix: "tmp/",
},
id: "rule-2",
status: "Enabled",
},
],
bucket: bucket.bucket,
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfiguration("example",
rules=[
{
"filter": {
"prefix": "logs/",
},
"id": "rule-1",
"status": "Enabled",
},
{
"filter": {
"prefix": "tmp/",
},
"id": "rule-2",
"status": "Enabled",
},
],
bucket=bucket["bucket"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfiguration("example", new()
{
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleArgs
{
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterArgs
{
Prefix = "logs/",
},
Id = "rule-1",
Status = "Enabled",
},
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleArgs
{
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterArgs
{
Prefix = "tmp/",
},
Id = "rule-2",
Status = "Enabled",
},
},
Bucket = bucket.Bucket,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfiguration(ctx, "example", &s3.BucketLifecycleConfigurationArgs{
Rules: s3.BucketLifecycleConfigurationRuleArray{
&s3.BucketLifecycleConfigurationRuleArgs{
Filter: &s3.BucketLifecycleConfigurationRuleFilterArgs{
Prefix: pulumi.String("logs/"),
},
Id: pulumi.String("rule-1"),
Status: pulumi.String("Enabled"),
},
&s3.BucketLifecycleConfigurationRuleArgs{
Filter: &s3.BucketLifecycleConfigurationRuleFilterArgs{
Prefix: pulumi.String("tmp/"),
},
Id: pulumi.String("rule-2"),
Status: pulumi.String("Enabled"),
},
},
Bucket: pulumi.Any(bucket.Bucket),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_s3_bucketlifecycleconfiguration" "example" {
rules {
filter = {
prefix = "logs/"
}
id = "rule-1"
status = "Enabled"
}
rules {
filter = {
prefix = "tmp/"
}
id = "rule-2"
status = "Enabled"
}
# ... other transition/expiration actions ...
# ... other transition/expiration actions ...
bucket = bucket.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()
.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());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfiguration
properties:
rules:
- filter:
prefix: logs/
id: rule-1
status: Enabled
- filter:
prefix: tmp/
id: rule-2
status: Enabled
bucket: ${bucket.bucket}
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.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.s3.BucketLifecycleConfiguration("example", {
rules: [{
filter: {
tag: {
key: "Name",
value: "Staging",
},
},
id: "rule-1",
status: "Enabled",
}],
bucket: bucket.bucket,
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfiguration("example",
rules=[{
"filter": {
"tag": {
"key": "Name",
"value": "Staging",
},
},
"id": "rule-1",
"status": "Enabled",
}],
bucket=bucket["bucket"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfiguration("example", new()
{
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleArgs
{
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterArgs
{
Tag = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterTagArgs
{
Key = "Name",
Value = "Staging",
},
},
Id = "rule-1",
Status = "Enabled",
},
},
Bucket = bucket.Bucket,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfiguration(ctx, "example", &s3.BucketLifecycleConfigurationArgs{
Rules: s3.BucketLifecycleConfigurationRuleArray{
&s3.BucketLifecycleConfigurationRuleArgs{
Filter: &s3.BucketLifecycleConfigurationRuleFilterArgs{
Tag: &s3.BucketLifecycleConfigurationRuleFilterTagArgs{
Key: pulumi.String("Name"),
Value: pulumi.String("Staging"),
},
},
Id: pulumi.String("rule-1"),
Status: pulumi.String("Enabled"),
},
},
Bucket: pulumi.Any(bucket.Bucket),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_s3_bucketlifecycleconfiguration" "example" {
rules {
filter = {
tag = {
key = "Name"
value = "Staging"
}
}
id = "rule-1"
status = "Enabled"
}
# ... other transition/expiration actions ...
bucket = bucket.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 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());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfiguration
properties:
rules:
- filter:
tag:
key: Name
value: Staging
id: rule-1
status: Enabled
bucket: ${bucket.bucket}
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.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.s3.BucketLifecycleConfiguration("example", {
rules: [{
filter: {
and: {
tags: {
Key1: "Value1",
Key2: "Value2",
},
},
},
id: "rule-1",
status: "Enabled",
}],
bucket: bucket.bucket,
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfiguration("example",
rules=[{
"filter": {
"and_": {
"tags": {
"Key1": "Value1",
"Key2": "Value2",
},
},
},
"id": "rule-1",
"status": "Enabled",
}],
bucket=bucket["bucket"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfiguration("example", new()
{
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleArgs
{
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterArgs
{
And = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterAndArgs
{
Tags =
{
{ "Key1", "Value1" },
{ "Key2", "Value2" },
},
},
},
Id = "rule-1",
Status = "Enabled",
},
},
Bucket = bucket.Bucket,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfiguration(ctx, "example", &s3.BucketLifecycleConfigurationArgs{
Rules: s3.BucketLifecycleConfigurationRuleArray{
&s3.BucketLifecycleConfigurationRuleArgs{
Filter: &s3.BucketLifecycleConfigurationRuleFilterArgs{
And: &s3.BucketLifecycleConfigurationRuleFilterAndArgs{
Tags: pulumi.StringMap{
"Key1": pulumi.String("Value1"),
"Key2": pulumi.String("Value2"),
},
},
},
Id: pulumi.String("rule-1"),
Status: pulumi.String("Enabled"),
},
},
Bucket: pulumi.Any(bucket.Bucket),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_s3_bucketlifecycleconfiguration" "example" {
rules {
filter = {
and = {
tags = {
"Key1" = "Value1"
"Key2" = "Value2"
}
}
}
id = "rule-1"
status = "Enabled"
}
# ... other transition/expiration actions ...
bucket = bucket.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 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());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfiguration
properties:
rules:
- filter:
and:
tags:
Key1: Value1
Key2: Value2
id: rule-1
status: Enabled
bucket: ${bucket.bucket}
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.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.s3.BucketLifecycleConfiguration("example", {
rules: [{
filter: {
and: {
prefix: "logs/",
tags: {
Key1: "Value1",
Key2: "Value2",
},
},
},
id: "rule-1",
status: "Enabled",
}],
bucket: bucket.bucket,
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfiguration("example",
rules=[{
"filter": {
"and_": {
"prefix": "logs/",
"tags": {
"Key1": "Value1",
"Key2": "Value2",
},
},
},
"id": "rule-1",
"status": "Enabled",
}],
bucket=bucket["bucket"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfiguration("example", new()
{
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleArgs
{
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterArgs
{
And = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterAndArgs
{
Prefix = "logs/",
Tags =
{
{ "Key1", "Value1" },
{ "Key2", "Value2" },
},
},
},
Id = "rule-1",
Status = "Enabled",
},
},
Bucket = bucket.Bucket,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfiguration(ctx, "example", &s3.BucketLifecycleConfigurationArgs{
Rules: s3.BucketLifecycleConfigurationRuleArray{
&s3.BucketLifecycleConfigurationRuleArgs{
Filter: &s3.BucketLifecycleConfigurationRuleFilterArgs{
And: &s3.BucketLifecycleConfigurationRuleFilterAndArgs{
Prefix: pulumi.String("logs/"),
Tags: pulumi.StringMap{
"Key1": pulumi.String("Value1"),
"Key2": pulumi.String("Value2"),
},
},
},
Id: pulumi.String("rule-1"),
Status: pulumi.String("Enabled"),
},
},
Bucket: pulumi.Any(bucket.Bucket),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_s3_bucketlifecycleconfiguration" "example" {
rules {
filter = {
and = {
prefix = "logs/"
tags = {
"Key1" = "Value1"
"Key2" = "Value2"
}
}
}
id = "rule-1"
status = "Enabled"
}
# ... other transition/expiration actions ...
bucket = bucket.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 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());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfiguration
properties:
rules:
- filter:
and:
prefix: logs/
tags:
Key1: Value1
Key2: Value2
id: rule-1
status: Enabled
bucket: ${bucket.bucket}
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:
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.s3.BucketLifecycleConfiguration("example", {
rules: [{
filter: {
objectSizeGreaterThan: 1,
},
transitions: [{
days: 365,
storageClass: "GLACIER_IR",
}],
id: "Allow small object transitions",
status: "Enabled",
}],
bucket: bucket.bucket,
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfiguration("example",
rules=[{
"filter": {
"object_size_greater_than": 1,
},
"transitions": [{
"days": 365,
"storage_class": "GLACIER_IR",
}],
"id": "Allow small object transitions",
"status": "Enabled",
}],
bucket=bucket["bucket"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfiguration("example", new()
{
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleArgs
{
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterArgs
{
ObjectSizeGreaterThan = 1,
},
Transitions = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleTransitionArgs
{
Days = 365,
StorageClass = "GLACIER_IR",
},
},
Id = "Allow small object transitions",
Status = "Enabled",
},
},
Bucket = bucket.Bucket,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfiguration(ctx, "example", &s3.BucketLifecycleConfigurationArgs{
Rules: s3.BucketLifecycleConfigurationRuleArray{
&s3.BucketLifecycleConfigurationRuleArgs{
Filter: &s3.BucketLifecycleConfigurationRuleFilterArgs{
ObjectSizeGreaterThan: pulumi.Int(1),
},
Transitions: s3.BucketLifecycleConfigurationRuleTransitionArray{
&s3.BucketLifecycleConfigurationRuleTransitionArgs{
Days: pulumi.Int(365),
StorageClass: pulumi.String("GLACIER_IR"),
},
},
Id: pulumi.String("Allow small object transitions"),
Status: pulumi.String("Enabled"),
},
},
Bucket: pulumi.Any(bucket.Bucket),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_s3_bucketlifecycleconfiguration" "example" {
rules {
filter = {
object_size_greater_than = 1
}
transitions {
days = 365
storage_class = "GLACIER_IR"
}
id = "Allow small object transitions"
status = "Enabled"
}
bucket = bucket.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 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());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfiguration
properties:
rules:
- filter:
objectSizeGreaterThan: 1
transitions:
- days: 365
storageClass: GLACIER_IR
id: Allow small object transitions
status: Enabled
bucket: ${bucket.bucket}
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.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.s3.BucketLifecycleConfiguration("example", {
rules: [{
filter: {
and: {
prefix: "logs/",
objectSizeGreaterThan: 500,
objectSizeLessThan: 64000,
},
},
id: "rule-1",
status: "Enabled",
}],
bucket: bucket.bucket,
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfiguration("example",
rules=[{
"filter": {
"and_": {
"prefix": "logs/",
"object_size_greater_than": 500,
"object_size_less_than": 64000,
},
},
"id": "rule-1",
"status": "Enabled",
}],
bucket=bucket["bucket"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfiguration("example", new()
{
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleArgs
{
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterArgs
{
And = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterAndArgs
{
Prefix = "logs/",
ObjectSizeGreaterThan = 500,
ObjectSizeLessThan = 64000,
},
},
Id = "rule-1",
Status = "Enabled",
},
},
Bucket = bucket.Bucket,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfiguration(ctx, "example", &s3.BucketLifecycleConfigurationArgs{
Rules: s3.BucketLifecycleConfigurationRuleArray{
&s3.BucketLifecycleConfigurationRuleArgs{
Filter: &s3.BucketLifecycleConfigurationRuleFilterArgs{
And: &s3.BucketLifecycleConfigurationRuleFilterAndArgs{
Prefix: pulumi.String("logs/"),
ObjectSizeGreaterThan: pulumi.Int(500),
ObjectSizeLessThan: pulumi.Int(64000),
},
},
Id: pulumi.String("rule-1"),
Status: pulumi.String("Enabled"),
},
},
Bucket: pulumi.Any(bucket.Bucket),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_s3_bucketlifecycleconfiguration" "example" {
rules {
filter = {
and = {
prefix = "logs/"
object_size_greater_than = 500
object_size_less_than = 64000
}
}
id = "rule-1"
status = "Enabled"
}
# ... other transition/expiration actions ...
bucket = bucket.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 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());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfiguration
properties:
rules:
- filter:
and:
prefix: logs/
objectSizeGreaterThan: 500
objectSizeLessThan: 64000
id: rule-1
status: Enabled
bucket: ${bucket.bucket}
Creating a Lifecycle Configuration for a bucket with versioning
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const bucket = new aws.s3.Bucket("bucket", {bucket: "my-bucket"});
const bucketAcl = new aws.s3.BucketAcl("bucket_acl", {
bucket: bucket.bucket,
acl: "private",
});
const bucket_config = new aws.s3.BucketLifecycleConfiguration("bucket-config", {
rules: [
{
expiration: {
days: 90,
},
filter: {
and: {
prefix: "log/",
tags: {
rule: "log",
autoclean: "true",
},
},
},
transitions: [
{
days: 30,
storageClass: "STANDARD_IA",
},
{
days: 60,
storageClass: "GLACIER",
},
],
id: "log",
status: "Enabled",
},
{
filter: {
prefix: "tmp/",
},
expiration: {
date: "2023-01-13T00:00:00Z",
},
id: "tmp",
status: "Enabled",
},
],
bucket: bucket.bucket,
});
const versioningBucket = new aws.s3.Bucket("versioning_bucket", {bucket: "my-versioning-bucket"});
const versioningBucketAcl = new aws.s3.BucketAcl("versioning_bucket_acl", {
bucket: versioningBucket.bucket,
acl: "private",
});
const versioning = new aws.s3.BucketVersioning("versioning", {
versioningConfiguration: {
status: "Enabled",
},
bucket: versioningBucket.bucket,
});
const versioning_bucket_config = new aws.s3.BucketLifecycleConfiguration("versioning-bucket-config", {
rules: [{
filter: {
prefix: "config/",
},
noncurrentVersionExpiration: {
noncurrentDays: 90,
},
noncurrentVersionTransitions: [
{
noncurrentDays: 30,
storageClass: "STANDARD_IA",
},
{
noncurrentDays: 60,
storageClass: "GLACIER",
},
],
id: "config",
status: "Enabled",
}],
bucket: versioningBucket.bucket,
}, {
dependsOn: [versioning],
});
import pulumi
import pulumi_aws as aws
bucket = aws.s3.Bucket("bucket", bucket="my-bucket")
bucket_acl = aws.s3.BucketAcl("bucket_acl",
bucket=bucket.bucket,
acl="private")
bucket_config = aws.s3.BucketLifecycleConfiguration("bucket-config",
rules=[
{
"expiration": {
"days": 90,
},
"filter": {
"and_": {
"prefix": "log/",
"tags": {
"rule": "log",
"autoclean": "true",
},
},
},
"transitions": [
{
"days": 30,
"storage_class": "STANDARD_IA",
},
{
"days": 60,
"storage_class": "GLACIER",
},
],
"id": "log",
"status": "Enabled",
},
{
"filter": {
"prefix": "tmp/",
},
"expiration": {
"date": "2023-01-13T00:00:00Z",
},
"id": "tmp",
"status": "Enabled",
},
],
bucket=bucket.bucket)
versioning_bucket = aws.s3.Bucket("versioning_bucket", bucket="my-versioning-bucket")
versioning_bucket_acl = aws.s3.BucketAcl("versioning_bucket_acl",
bucket=versioning_bucket.bucket,
acl="private")
versioning = aws.s3.BucketVersioning("versioning",
versioning_configuration={
"status": "Enabled",
},
bucket=versioning_bucket.bucket)
versioning_bucket_config = aws.s3.BucketLifecycleConfiguration("versioning-bucket-config",
rules=[{
"filter": {
"prefix": "config/",
},
"noncurrent_version_expiration": {
"noncurrent_days": 90,
},
"noncurrent_version_transitions": [
{
"noncurrent_days": 30,
"storage_class": "STANDARD_IA",
},
{
"noncurrent_days": 60,
"storage_class": "GLACIER",
},
],
"id": "config",
"status": "Enabled",
}],
bucket=versioning_bucket.bucket,
opts = pulumi.ResourceOptions(depends_on=[versioning]))
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var bucket = new Aws.S3.Bucket("bucket", new()
{
BucketName = "my-bucket",
});
var bucketAcl = new Aws.S3.BucketAcl("bucket_acl", new()
{
Bucket = bucket.BucketName,
Acl = "private",
});
var bucket_config = new Aws.S3.BucketLifecycleConfiguration("bucket-config", new()
{
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleArgs
{
Expiration = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleExpirationArgs
{
Days = 90,
},
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterArgs
{
And = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterAndArgs
{
Prefix = "log/",
Tags =
{
{ "rule", "log" },
{ "autoclean", "true" },
},
},
},
Transitions = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleTransitionArgs
{
Days = 30,
StorageClass = "STANDARD_IA",
},
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleTransitionArgs
{
Days = 60,
StorageClass = "GLACIER",
},
},
Id = "log",
Status = "Enabled",
},
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleArgs
{
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterArgs
{
Prefix = "tmp/",
},
Expiration = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleExpirationArgs
{
Date = "2023-01-13T00:00:00Z",
},
Id = "tmp",
Status = "Enabled",
},
},
Bucket = bucket.BucketName,
});
var versioningBucket = new Aws.S3.Bucket("versioning_bucket", new()
{
BucketName = "my-versioning-bucket",
});
var versioningBucketAcl = new Aws.S3.BucketAcl("versioning_bucket_acl", new()
{
Bucket = versioningBucket.BucketName,
Acl = "private",
});
var versioning = new Aws.S3.BucketVersioning("versioning", new()
{
VersioningConfiguration = new Aws.S3.Inputs.BucketVersioningVersioningConfigurationArgs
{
Status = "Enabled",
},
Bucket = versioningBucket.BucketName,
});
var versioning_bucket_config = new Aws.S3.BucketLifecycleConfiguration("versioning-bucket-config", new()
{
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleArgs
{
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleFilterArgs
{
Prefix = "config/",
},
NoncurrentVersionExpiration = new Aws.S3.Inputs.BucketLifecycleConfigurationRuleNoncurrentVersionExpirationArgs
{
NoncurrentDays = 90,
},
NoncurrentVersionTransitions = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleNoncurrentVersionTransitionArgs
{
NoncurrentDays = 30,
StorageClass = "STANDARD_IA",
},
new Aws.S3.Inputs.BucketLifecycleConfigurationRuleNoncurrentVersionTransitionArgs
{
NoncurrentDays = 60,
StorageClass = "GLACIER",
},
},
Id = "config",
Status = "Enabled",
},
},
Bucket = versioningBucket.BucketName,
}, new CustomResourceOptions
{
DependsOn =
{
versioning,
},
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
bucket, err := s3.NewBucket(ctx, "bucket", &s3.BucketArgs{
Bucket: pulumi.String("my-bucket"),
})
if err != nil {
return err
}
_, err = s3.NewBucketAcl(ctx, "bucket_acl", &s3.BucketAclArgs{
Bucket: bucket.Bucket,
Acl: pulumi.String("private"),
})
if err != nil {
return err
}
_, err = s3.NewBucketLifecycleConfiguration(ctx, "bucket-config", &s3.BucketLifecycleConfigurationArgs{
Rules: s3.BucketLifecycleConfigurationRuleArray{
&s3.BucketLifecycleConfigurationRuleArgs{
Expiration: &s3.BucketLifecycleConfigurationRuleExpirationArgs{
Days: pulumi.Int(90),
},
Filter: &s3.BucketLifecycleConfigurationRuleFilterArgs{
And: &s3.BucketLifecycleConfigurationRuleFilterAndArgs{
Prefix: pulumi.String("log/"),
Tags: pulumi.StringMap{
"rule": pulumi.String("log"),
"autoclean": pulumi.String("true"),
},
},
},
Transitions: s3.BucketLifecycleConfigurationRuleTransitionArray{
&s3.BucketLifecycleConfigurationRuleTransitionArgs{
Days: pulumi.Int(30),
StorageClass: pulumi.String("STANDARD_IA"),
},
&s3.BucketLifecycleConfigurationRuleTransitionArgs{
Days: pulumi.Int(60),
StorageClass: pulumi.String("GLACIER"),
},
},
Id: pulumi.String("log"),
Status: pulumi.String("Enabled"),
},
&s3.BucketLifecycleConfigurationRuleArgs{
Filter: &s3.BucketLifecycleConfigurationRuleFilterArgs{
Prefix: pulumi.String("tmp/"),
},
Expiration: &s3.BucketLifecycleConfigurationRuleExpirationArgs{
Date: pulumi.String("2023-01-13T00:00:00Z"),
},
Id: pulumi.String("tmp"),
Status: pulumi.String("Enabled"),
},
},
Bucket: bucket.Bucket,
})
if err != nil {
return err
}
versioningBucket, err := s3.NewBucket(ctx, "versioning_bucket", &s3.BucketArgs{
Bucket: pulumi.String("my-versioning-bucket"),
})
if err != nil {
return err
}
_, err = s3.NewBucketAcl(ctx, "versioning_bucket_acl", &s3.BucketAclArgs{
Bucket: versioningBucket.Bucket,
Acl: pulumi.String("private"),
})
if err != nil {
return err
}
versioning, err := s3.NewBucketVersioning(ctx, "versioning", &s3.BucketVersioningArgs{
VersioningConfiguration: &s3.BucketVersioningVersioningConfigurationArgs{
Status: pulumi.String("Enabled"),
},
Bucket: versioningBucket.Bucket,
})
if err != nil {
return err
}
_, err = s3.NewBucketLifecycleConfiguration(ctx, "versioning-bucket-config", &s3.BucketLifecycleConfigurationArgs{
Rules: s3.BucketLifecycleConfigurationRuleArray{
&s3.BucketLifecycleConfigurationRuleArgs{
Filter: &s3.BucketLifecycleConfigurationRuleFilterArgs{
Prefix: pulumi.String("config/"),
},
NoncurrentVersionExpiration: &s3.BucketLifecycleConfigurationRuleNoncurrentVersionExpirationArgs{
NoncurrentDays: pulumi.Int(90),
},
NoncurrentVersionTransitions: s3.BucketLifecycleConfigurationRuleNoncurrentVersionTransitionArray{
&s3.BucketLifecycleConfigurationRuleNoncurrentVersionTransitionArgs{
NoncurrentDays: pulumi.Int(30),
StorageClass: pulumi.String("STANDARD_IA"),
},
&s3.BucketLifecycleConfigurationRuleNoncurrentVersionTransitionArgs{
NoncurrentDays: pulumi.Int(60),
StorageClass: pulumi.String("GLACIER"),
},
},
Id: pulumi.String("config"),
Status: pulumi.String("Enabled"),
},
},
Bucket: versioningBucket.Bucket,
}, pulumi.DependsOn([]pulumi.Resource{
versioning,
}))
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_s3_bucket" "bucket" {
bucket = "my-bucket"
}
resource "aws_s3_bucketacl" "bucket_acl" {
bucket = aws_s3_bucket.bucket.bucket
acl = "private"
}
resource "aws_s3_bucketlifecycleconfiguration" "bucket-config" {
rules {
expiration = {
days = 90
}
filter = {
and = {
prefix = "log/"
tags = {
"rule" = "log"
"autoclean" = "true"
}
}
}
transitions {
days = 30
storage_class = "STANDARD_IA"
}
transitions {
days = 60
storage_class = "GLACIER"
}
id = "log"
status = "Enabled"
}
rules {
filter = {
prefix = "tmp/"
}
expiration = {
date = "2023-01-13T00:00:00Z"
}
id = "tmp"
status = "Enabled"
}
bucket = aws_s3_bucket.bucket.bucket
}
resource "aws_s3_bucket" "versioning_bucket" {
bucket = "my-versioning-bucket"
}
resource "aws_s3_bucketacl" "versioning_bucket_acl" {
bucket = aws_s3_bucket.versioning_bucket.bucket
acl = "private"
}
resource "aws_s3_bucketversioning" "versioning" {
versioning_configuration = {
status = "Enabled"
}
bucket = aws_s3_bucket.versioning_bucket.bucket
}
resource "aws_s3_bucketlifecycleconfiguration" "versioning-bucket-config" {
depends_on = [aws_s3_bucketversioning.versioning]
rules {
filter = {
prefix = "config/"
}
noncurrent_version_expiration = {
noncurrent_days = 90
}
noncurrent_version_transitions {
noncurrent_days = 30
storage_class = "STANDARD_IA"
}
noncurrent_version_transitions {
noncurrent_days = 60
storage_class = "GLACIER"
}
id = "config"
status = "Enabled"
}
bucket = aws_s3_bucket.versioning_bucket.bucket
}
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());
}
}
resources:
bucket:
type: aws:s3:Bucket
properties:
bucket: my-bucket
bucketAcl:
type: aws:s3:BucketAcl
name: bucket_acl
properties:
bucket: ${bucket.bucket}
acl: private
bucket-config:
type: aws:s3:BucketLifecycleConfiguration
properties:
rules:
- expiration:
days: 90
filter:
and:
prefix: log/
tags:
rule: log
autoclean: 'true'
transitions:
- days: 30
storageClass: STANDARD_IA
- days: 60
storageClass: GLACIER
id: log
status: Enabled
- filter:
prefix: tmp/
expiration:
date: 2023-01-13T00:00:00Z
id: tmp
status: Enabled
bucket: ${bucket.bucket}
versioningBucket:
type: aws:s3:Bucket
name: versioning_bucket
properties:
bucket: my-versioning-bucket
versioningBucketAcl:
type: aws:s3:BucketAcl
name: versioning_bucket_acl
properties:
bucket: ${versioningBucket.bucket}
acl: private
versioning:
type: aws:s3:BucketVersioning
properties:
versioningConfiguration:
status: Enabled
bucket: ${versioningBucket.bucket}
versioning-bucket-config:
type: aws:s3:BucketLifecycleConfiguration
properties:
rules:
- filter:
prefix: config/
noncurrentVersionExpiration:
noncurrentDays: 90
noncurrentVersionTransitions:
- noncurrentDays: 30
storageClass: STANDARD_IA
- noncurrentDays: 60
storageClass: GLACIER
id: config
status: Enabled
bucket: ${versioningBucket.bucket}
options:
dependsOn:
- ${versioning}
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:
$ pulumi import aws:s3/bucketLifecycleConfigurationV2:BucketLifecycleConfigurationV2 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 (,):
$ pulumi import aws:s3/bucketLifecycleConfigurationV2:BucketLifecycleConfigurationV2 example bucket-name,123456789012
Constructors
- BucketLifecycleConfigurationV2(String name, {BucketLifecycleConfigurationV2Args? args, CustomResourceOptions? options})
-
Creates a new BucketLifecycleConfigurationV2.
nameThe Pulumi resource name.argsArguments used to configure this BucketLifecycleConfigurationV2. The set of arguments for BucketLifecycleConfigurationV2.optionsResource options controlling this resource's behavior. - BucketLifecycleConfigurationV2.reference(String urn)
- Creates a typed reference to an existing BucketLifecycleConfigurationV2 resource.
Properties
-
bucket
↔ Output<
String> -
Name of the source S3 bucket you want Amazon S3 to monitor.
latefinal
-
childResources
→ Set<
Resource> -
finalinherited
-
completionSources
↔ Map<
String, IOutputCompletionSource> -
latefinalinherited
-
expectedBucketOwner
↔ Output<
String> -
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.
latefinal
- hashCode → int
-
The hash code for this object.
no setterinherited
-
id
↔ Output<
String> -
getter/setter pairinherited
- isCustom → bool
-
Returns whether this resource is provider-managed.
no setterinherited
- isProtected → bool
-
Returns whether this resource is protected from deletion.
no setterinherited
- isRemote → bool
-
Whether this resource is registered as remote.
no setterinherited
- isResourceReference → bool
-
Whether this instance represents a resource value returned over RPC.
finalinherited
-
region
↔ Output<
String> -
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
-
resourceTransforms
→ List<
ResourceTransform> -
Inherited/explicit async transforms.
no setterinherited
-
rules
↔ Output<
List< BucketLifecycleConfigurationV2Rule> ?> -
List of configuration blocks describing the rules managing the replication. See below.
latefinal
- runtimeType → Type
-
A representation of the runtime type of the object.
no setterinherited
-
timeouts
↔ Output<
BucketLifecycleConfigurationV2Timeouts?> -
latefinal
-
transformations
→ List<
ResourceTransformation> -
Inherited/explicit legacy transformations.
no setterinherited
-
transitionDefaultMinimumObjectSize
↔ Output<
String> -
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 afilterthat specifies a customobjectSizeGreaterThanorobjectSizeLessThanvalue. Custom filters always take precedence over the default transition behavior.latefinal -
urn
↔ Output<
String> -
latefinalinherited
Methods
-
failId(
Object error) → void -
Completes this resource ID with an error when registration fails.
inherited
-
failOutputs(
Object error) → void -
Completes all output properties with
error.inherited -
failUrn(
Object error) → void -
Completes this resource URN with an error when registration fails.
inherited
-
getProvider(
String moduleMember) → ProviderResource? -
Returns provider for
moduleMember's package, if configured.inherited -
getResourceName(
) → String -
Returns this resource's logical name.
inherited
-
getResourceType(
) → String -
Returns this resource's Pulumi type token.
inherited
-
noSuchMethod(
Invocation invocation) → dynamic -
Invoked when a nonexistent method or property is accessed.
inherited
-
registerOutput<
T> (String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output< T> -
Registers a dynamic output property for this resource.
inherited
-
resolveId(
String? value, {required bool isKnown}) → void -
Resolves the provider-assigned ID for this resource.
inherited
-
resolveOutputs(
Struct outputs) → void -
Resolves all output properties from a monitor response payload.
inherited
-
resolveUrn(
String value) → void -
Resolves this resource's URN once assigned by the engine.
inherited
-
serializeProperties(
Map< String, dynamic> properties) → Future<Struct> -
Serializes resource properties for RPC transmission.
inherited
-
toString(
) → String -
A string representation of this object.
inherited
Operators
-
operator ==(
Object other) → bool -
The equality operator.
inherited
Static Methods
-
get(
String name, Input< String> id, {BucketLifecycleConfigurationV2State? state, CustomResourceOptions? options}) → BucketLifecycleConfigurationV2 -
Gets an existing BucketLifecycleConfigurationV2 resource's state with the given
nameandid.