Docs
PackagesTry AWS Native preview for resources not in the classic version.
AWS Classic v6.32.0 published on Friday, Apr 19, 2024 by Pulumi
aws.s3.BucketLifecycleConfigurationV2
Explore with Pulumi AI
Try AWS Native preview for resources not in the classic version.
AWS Classic v6.32.0 published on Friday, Apr 19, 2024 by Pulumi
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.
NOTE: S3 Buckets only support a single lifecycle configuration. Declaring multiple
aws.s3.BucketLifecycleConfigurationV2resources to the same S3 Bucket will cause a perpetual difference in configuration.
NOTE: 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.
This resource cannot be used with S3 directory buckets.
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.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.s3.BucketLifecycleConfigurationV2("example", {
bucket: bucket.id,
rules: [{
id: "rule-1",
status: "Enabled",
}],
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfigurationV2("example",
bucket=bucket["id"],
rules=[aws.s3.BucketLifecycleConfigurationV2RuleArgs(
id="rule-1",
status="Enabled",
)])
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfigurationV2(ctx, "example", &s3.BucketLifecycleConfigurationV2Args{
Bucket: pulumi.Any(bucket.Id),
Rules: s3.BucketLifecycleConfigurationV2RuleArray{
&s3.BucketLifecycleConfigurationV2RuleArgs{
Id: pulumi.String("rule-1"),
Status: pulumi.String("Enabled"),
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfigurationV2("example", new()
{
Bucket = bucket.Id,
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleArgs
{
Id = "rule-1",
Status = "Enabled",
},
},
});
});
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(bucket.id())
.rules(BucketLifecycleConfigurationV2RuleArgs.builder()
.id("rule-1")
.status("Enabled")
.build())
.build());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfigurationV2
properties:
bucket: ${bucket.id}
rules:
- id: rule-1
status: Enabled
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.BucketLifecycleConfigurationV2("example", {
bucket: bucket.id,
rules: [{
id: "rule-1",
filter: {},
status: "Enabled",
}],
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfigurationV2("example",
bucket=bucket["id"],
rules=[aws.s3.BucketLifecycleConfigurationV2RuleArgs(
id="rule-1",
filter=aws.s3.BucketLifecycleConfigurationV2RuleFilterArgs(),
status="Enabled",
)])
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfigurationV2(ctx, "example", &s3.BucketLifecycleConfigurationV2Args{
Bucket: pulumi.Any(bucket.Id),
Rules: s3.BucketLifecycleConfigurationV2RuleArray{
&s3.BucketLifecycleConfigurationV2RuleArgs{
Id: pulumi.String("rule-1"),
Filter: nil,
Status: pulumi.String("Enabled"),
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfigurationV2("example", new()
{
Bucket = bucket.Id,
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleArgs
{
Id = "rule-1",
Filter = null,
Status = "Enabled",
},
},
});
});
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(bucket.id())
.rules(BucketLifecycleConfigurationV2RuleArgs.builder()
.id("rule-1")
.filter()
.status("Enabled")
.build())
.build());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfigurationV2
properties:
bucket: ${bucket.id}
rules:
- id: rule-1
filter: {}
status: Enabled
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.BucketLifecycleConfigurationV2("example", {
bucket: bucket.id,
rules: [{
id: "rule-1",
filter: {
prefix: "logs/",
},
status: "Enabled",
}],
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfigurationV2("example",
bucket=bucket["id"],
rules=[aws.s3.BucketLifecycleConfigurationV2RuleArgs(
id="rule-1",
filter=aws.s3.BucketLifecycleConfigurationV2RuleFilterArgs(
prefix="logs/",
),
status="Enabled",
)])
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfigurationV2(ctx, "example", &s3.BucketLifecycleConfigurationV2Args{
Bucket: pulumi.Any(bucket.Id),
Rules: s3.BucketLifecycleConfigurationV2RuleArray{
&s3.BucketLifecycleConfigurationV2RuleArgs{
Id: pulumi.String("rule-1"),
Filter: &s3.BucketLifecycleConfigurationV2RuleFilterArgs{
Prefix: pulumi.String("logs/"),
},
Status: pulumi.String("Enabled"),
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfigurationV2("example", new()
{
Bucket = bucket.Id,
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleArgs
{
Id = "rule-1",
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterArgs
{
Prefix = "logs/",
},
Status = "Enabled",
},
},
});
});
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(bucket.id())
.rules(BucketLifecycleConfigurationV2RuleArgs.builder()
.id("rule-1")
.filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
.prefix("logs/")
.build())
.status("Enabled")
.build())
.build());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfigurationV2
properties:
bucket: ${bucket.id}
rules:
- id: rule-1
filter:
prefix: logs/
status: Enabled
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.BucketLifecycleConfigurationV2("example", {
bucket: bucket.id,
rules: [
{
id: "rule-1",
filter: {
prefix: "logs/",
},
status: "Enabled",
},
{
id: "rule-2",
filter: {
prefix: "tmp/",
},
status: "Enabled",
},
],
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfigurationV2("example",
bucket=bucket["id"],
rules=[
aws.s3.BucketLifecycleConfigurationV2RuleArgs(
id="rule-1",
filter=aws.s3.BucketLifecycleConfigurationV2RuleFilterArgs(
prefix="logs/",
),
status="Enabled",
),
aws.s3.BucketLifecycleConfigurationV2RuleArgs(
id="rule-2",
filter=aws.s3.BucketLifecycleConfigurationV2RuleFilterArgs(
prefix="tmp/",
),
status="Enabled",
),
])
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfigurationV2(ctx, "example", &s3.BucketLifecycleConfigurationV2Args{
Bucket: pulumi.Any(bucket.Id),
Rules: s3.BucketLifecycleConfigurationV2RuleArray{
&s3.BucketLifecycleConfigurationV2RuleArgs{
Id: pulumi.String("rule-1"),
Filter: &s3.BucketLifecycleConfigurationV2RuleFilterArgs{
Prefix: pulumi.String("logs/"),
},
Status: pulumi.String("Enabled"),
},
&s3.BucketLifecycleConfigurationV2RuleArgs{
Id: pulumi.String("rule-2"),
Filter: &s3.BucketLifecycleConfigurationV2RuleFilterArgs{
Prefix: pulumi.String("tmp/"),
},
Status: pulumi.String("Enabled"),
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfigurationV2("example", new()
{
Bucket = bucket.Id,
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleArgs
{
Id = "rule-1",
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterArgs
{
Prefix = "logs/",
},
Status = "Enabled",
},
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleArgs
{
Id = "rule-2",
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterArgs
{
Prefix = "tmp/",
},
Status = "Enabled",
},
},
});
});
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(bucket.id())
.rules(
BucketLifecycleConfigurationV2RuleArgs.builder()
.id("rule-1")
.filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
.prefix("logs/")
.build())
.status("Enabled")
.build(),
BucketLifecycleConfigurationV2RuleArgs.builder()
.id("rule-2")
.filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
.prefix("tmp/")
.build())
.status("Enabled")
.build())
.build());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfigurationV2
properties:
bucket: ${bucket.id}
rules:
- id: rule-1
filter:
prefix: logs/
status: Enabled
- id: rule-2
filter:
prefix: tmp/
status: Enabled
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.BucketLifecycleConfigurationV2("example", {
bucket: bucket.id,
rules: [{
id: "rule-1",
filter: {
tag: {
key: "Name",
value: "Staging",
},
},
status: "Enabled",
}],
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfigurationV2("example",
bucket=bucket["id"],
rules=[aws.s3.BucketLifecycleConfigurationV2RuleArgs(
id="rule-1",
filter=aws.s3.BucketLifecycleConfigurationV2RuleFilterArgs(
tag=aws.s3.BucketLifecycleConfigurationV2RuleFilterTagArgs(
key="Name",
value="Staging",
),
),
status="Enabled",
)])
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfigurationV2(ctx, "example", &s3.BucketLifecycleConfigurationV2Args{
Bucket: pulumi.Any(bucket.Id),
Rules: s3.BucketLifecycleConfigurationV2RuleArray{
&s3.BucketLifecycleConfigurationV2RuleArgs{
Id: pulumi.String("rule-1"),
Filter: &s3.BucketLifecycleConfigurationV2RuleFilterArgs{
Tag: &s3.BucketLifecycleConfigurationV2RuleFilterTagArgs{
Key: pulumi.String("Name"),
Value: pulumi.String("Staging"),
},
},
Status: pulumi.String("Enabled"),
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfigurationV2("example", new()
{
Bucket = bucket.Id,
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleArgs
{
Id = "rule-1",
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterArgs
{
Tag = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterTagArgs
{
Key = "Name",
Value = "Staging",
},
},
Status = "Enabled",
},
},
});
});
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(bucket.id())
.rules(BucketLifecycleConfigurationV2RuleArgs.builder()
.id("rule-1")
.filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
.tag(BucketLifecycleConfigurationV2RuleFilterTagArgs.builder()
.key("Name")
.value("Staging")
.build())
.build())
.status("Enabled")
.build())
.build());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfigurationV2
properties:
bucket: ${bucket.id}
rules:
- id: rule-1
filter:
tag:
key: Name
value: Staging
status: Enabled
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.BucketLifecycleConfigurationV2("example", {
bucket: bucket.id,
rules: [{
id: "rule-1",
filter: {
and: {
tags: {
Key1: "Value1",
Key2: "Value2",
},
},
},
status: "Enabled",
}],
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfigurationV2("example",
bucket=bucket["id"],
rules=[aws.s3.BucketLifecycleConfigurationV2RuleArgs(
id="rule-1",
filter=aws.s3.BucketLifecycleConfigurationV2RuleFilterArgs(
and_=aws.s3.BucketLifecycleConfigurationV2RuleFilterAndArgs(
tags={
"Key1": "Value1",
"Key2": "Value2",
},
),
),
status="Enabled",
)])
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfigurationV2(ctx, "example", &s3.BucketLifecycleConfigurationV2Args{
Bucket: pulumi.Any(bucket.Id),
Rules: s3.BucketLifecycleConfigurationV2RuleArray{
&s3.BucketLifecycleConfigurationV2RuleArgs{
Id: pulumi.String("rule-1"),
Filter: &s3.BucketLifecycleConfigurationV2RuleFilterArgs{
And: &s3.BucketLifecycleConfigurationV2RuleFilterAndArgs{
Tags: pulumi.StringMap{
"Key1": pulumi.String("Value1"),
"Key2": pulumi.String("Value2"),
},
},
},
Status: pulumi.String("Enabled"),
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfigurationV2("example", new()
{
Bucket = bucket.Id,
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleArgs
{
Id = "rule-1",
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterArgs
{
And = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterAndArgs
{
Tags =
{
{ "Key1", "Value1" },
{ "Key2", "Value2" },
},
},
},
Status = "Enabled",
},
},
});
});
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(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());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfigurationV2
properties:
bucket: ${bucket.id}
rules:
- id: rule-1
filter:
and:
tags:
Key1: Value1
Key2: Value2
status: Enabled
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.BucketLifecycleConfigurationV2("example", {
bucket: bucket.id,
rules: [{
id: "rule-1",
filter: {
and: {
prefix: "logs/",
tags: {
Key1: "Value1",
Key2: "Value2",
},
},
},
status: "Enabled",
}],
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfigurationV2("example",
bucket=bucket["id"],
rules=[aws.s3.BucketLifecycleConfigurationV2RuleArgs(
id="rule-1",
filter=aws.s3.BucketLifecycleConfigurationV2RuleFilterArgs(
and_=aws.s3.BucketLifecycleConfigurationV2RuleFilterAndArgs(
prefix="logs/",
tags={
"Key1": "Value1",
"Key2": "Value2",
},
),
),
status="Enabled",
)])
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfigurationV2(ctx, "example", &s3.BucketLifecycleConfigurationV2Args{
Bucket: pulumi.Any(bucket.Id),
Rules: s3.BucketLifecycleConfigurationV2RuleArray{
&s3.BucketLifecycleConfigurationV2RuleArgs{
Id: pulumi.String("rule-1"),
Filter: &s3.BucketLifecycleConfigurationV2RuleFilterArgs{
And: &s3.BucketLifecycleConfigurationV2RuleFilterAndArgs{
Prefix: pulumi.String("logs/"),
Tags: pulumi.StringMap{
"Key1": pulumi.String("Value1"),
"Key2": pulumi.String("Value2"),
},
},
},
Status: pulumi.String("Enabled"),
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfigurationV2("example", new()
{
Bucket = bucket.Id,
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleArgs
{
Id = "rule-1",
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterArgs
{
And = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterAndArgs
{
Prefix = "logs/",
Tags =
{
{ "Key1", "Value1" },
{ "Key2", "Value2" },
},
},
},
Status = "Enabled",
},
},
});
});
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(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());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfigurationV2
properties:
bucket: ${bucket.id}
rules:
- id: rule-1
filter:
and:
prefix: logs/
tags:
Key1: Value1
Key2: Value2
status: Enabled
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.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.s3.BucketLifecycleConfigurationV2("example", {
bucket: bucket.id,
rules: [{
id: "rule-1",
filter: {
objectSizeGreaterThan: "500",
},
status: "Enabled",
}],
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfigurationV2("example",
bucket=bucket["id"],
rules=[aws.s3.BucketLifecycleConfigurationV2RuleArgs(
id="rule-1",
filter=aws.s3.BucketLifecycleConfigurationV2RuleFilterArgs(
object_size_greater_than="500",
),
status="Enabled",
)])
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfigurationV2(ctx, "example", &s3.BucketLifecycleConfigurationV2Args{
Bucket: pulumi.Any(bucket.Id),
Rules: s3.BucketLifecycleConfigurationV2RuleArray{
&s3.BucketLifecycleConfigurationV2RuleArgs{
Id: pulumi.String("rule-1"),
Filter: &s3.BucketLifecycleConfigurationV2RuleFilterArgs{
ObjectSizeGreaterThan: pulumi.String("500"),
},
Status: pulumi.String("Enabled"),
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfigurationV2("example", new()
{
Bucket = bucket.Id,
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleArgs
{
Id = "rule-1",
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterArgs
{
ObjectSizeGreaterThan = "500",
},
Status = "Enabled",
},
},
});
});
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(bucket.id())
.rules(BucketLifecycleConfigurationV2RuleArgs.builder()
.id("rule-1")
.filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
.objectSizeGreaterThan(500)
.build())
.status("Enabled")
.build())
.build());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfigurationV2
properties:
bucket: ${bucket.id}
rules:
- id: rule-1
filter:
objectSizeGreaterThan: 500
status: Enabled
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.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.s3.BucketLifecycleConfigurationV2("example", {
bucket: bucket.id,
rules: [{
id: "rule-1",
filter: {
and: {
prefix: "logs/",
objectSizeGreaterThan: 500,
objectSizeLessThan: 64000,
},
},
status: "Enabled",
}],
});
import pulumi
import pulumi_aws as aws
example = aws.s3.BucketLifecycleConfigurationV2("example",
bucket=bucket["id"],
rules=[aws.s3.BucketLifecycleConfigurationV2RuleArgs(
id="rule-1",
filter=aws.s3.BucketLifecycleConfigurationV2RuleFilterArgs(
and_=aws.s3.BucketLifecycleConfigurationV2RuleFilterAndArgs(
prefix="logs/",
object_size_greater_than=500,
object_size_less_than=64000,
),
),
status="Enabled",
)])
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := s3.NewBucketLifecycleConfigurationV2(ctx, "example", &s3.BucketLifecycleConfigurationV2Args{
Bucket: pulumi.Any(bucket.Id),
Rules: s3.BucketLifecycleConfigurationV2RuleArray{
&s3.BucketLifecycleConfigurationV2RuleArgs{
Id: pulumi.String("rule-1"),
Filter: &s3.BucketLifecycleConfigurationV2RuleFilterArgs{
And: &s3.BucketLifecycleConfigurationV2RuleFilterAndArgs{
Prefix: pulumi.String("logs/"),
ObjectSizeGreaterThan: pulumi.Int(500),
ObjectSizeLessThan: pulumi.Int(64000),
},
},
Status: pulumi.String("Enabled"),
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.S3.BucketLifecycleConfigurationV2("example", new()
{
Bucket = bucket.Id,
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleArgs
{
Id = "rule-1",
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterArgs
{
And = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterAndArgs
{
Prefix = "logs/",
ObjectSizeGreaterThan = 500,
ObjectSizeLessThan = 64000,
},
},
Status = "Enabled",
},
},
});
});
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(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());
}
}
resources:
example:
type: aws:s3:BucketLifecycleConfigurationV2
properties:
bucket: ${bucket.id}
rules:
- id: rule-1
filter:
and:
prefix: logs/
objectSizeGreaterThan: 500
objectSizeLessThan: 64000
status: Enabled
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.BucketV2("bucket", {bucket: "my-bucket"});
const bucketAcl = new aws.s3.BucketAclV2("bucket_acl", {
bucket: bucket.id,
acl: "private",
});
const bucket_config = new aws.s3.BucketLifecycleConfigurationV2("bucket-config", {
bucket: bucket.id,
rules: [
{
id: "log",
expiration: {
days: 90,
},
filter: {
and: {
prefix: "log/",
tags: {
rule: "log",
autoclean: "true",
},
},
},
status: "Enabled",
transitions: [
{
days: 30,
storageClass: "STANDARD_IA",
},
{
days: 60,
storageClass: "GLACIER",
},
],
},
{
id: "tmp",
filter: {
prefix: "tmp/",
},
expiration: {
date: "2023-01-13T00:00:00Z",
},
status: "Enabled",
},
],
});
const versioningBucket = new aws.s3.BucketV2("versioning_bucket", {bucket: "my-versioning-bucket"});
const versioningBucketAcl = new aws.s3.BucketAclV2("versioning_bucket_acl", {
bucket: versioningBucket.id,
acl: "private",
});
const versioning = new aws.s3.BucketVersioningV2("versioning", {
bucket: versioningBucket.id,
versioningConfiguration: {
status: "Enabled",
},
});
const versioning_bucket_config = new aws.s3.BucketLifecycleConfigurationV2("versioning-bucket-config", {
bucket: versioningBucket.id,
rules: [{
id: "config",
filter: {
prefix: "config/",
},
noncurrentVersionExpiration: {
noncurrentDays: 90,
},
noncurrentVersionTransitions: [
{
noncurrentDays: 30,
storageClass: "STANDARD_IA",
},
{
noncurrentDays: 60,
storageClass: "GLACIER",
},
],
status: "Enabled",
}],
}, {
dependsOn: [versioning],
});
import pulumi
import pulumi_aws as aws
bucket = aws.s3.BucketV2("bucket", bucket="my-bucket")
bucket_acl = aws.s3.BucketAclV2("bucket_acl",
bucket=bucket.id,
acl="private")
bucket_config = aws.s3.BucketLifecycleConfigurationV2("bucket-config",
bucket=bucket.id,
rules=[
aws.s3.BucketLifecycleConfigurationV2RuleArgs(
id="log",
expiration=aws.s3.BucketLifecycleConfigurationV2RuleExpirationArgs(
days=90,
),
filter=aws.s3.BucketLifecycleConfigurationV2RuleFilterArgs(
and_=aws.s3.BucketLifecycleConfigurationV2RuleFilterAndArgs(
prefix="log/",
tags={
"rule": "log",
"autoclean": "true",
},
),
),
status="Enabled",
transitions=[
aws.s3.BucketLifecycleConfigurationV2RuleTransitionArgs(
days=30,
storage_class="STANDARD_IA",
),
aws.s3.BucketLifecycleConfigurationV2RuleTransitionArgs(
days=60,
storage_class="GLACIER",
),
],
),
aws.s3.BucketLifecycleConfigurationV2RuleArgs(
id="tmp",
filter=aws.s3.BucketLifecycleConfigurationV2RuleFilterArgs(
prefix="tmp/",
),
expiration=aws.s3.BucketLifecycleConfigurationV2RuleExpirationArgs(
date="2023-01-13T00:00:00Z",
),
status="Enabled",
),
])
versioning_bucket = aws.s3.BucketV2("versioning_bucket", bucket="my-versioning-bucket")
versioning_bucket_acl = aws.s3.BucketAclV2("versioning_bucket_acl",
bucket=versioning_bucket.id,
acl="private")
versioning = aws.s3.BucketVersioningV2("versioning",
bucket=versioning_bucket.id,
versioning_configuration=aws.s3.BucketVersioningV2VersioningConfigurationArgs(
status="Enabled",
))
versioning_bucket_config = aws.s3.BucketLifecycleConfigurationV2("versioning-bucket-config",
bucket=versioning_bucket.id,
rules=[aws.s3.BucketLifecycleConfigurationV2RuleArgs(
id="config",
filter=aws.s3.BucketLifecycleConfigurationV2RuleFilterArgs(
prefix="config/",
),
noncurrent_version_expiration=aws.s3.BucketLifecycleConfigurationV2RuleNoncurrentVersionExpirationArgs(
noncurrent_days=90,
),
noncurrent_version_transitions=[
aws.s3.BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArgs(
noncurrent_days=30,
storage_class="STANDARD_IA",
),
aws.s3.BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArgs(
noncurrent_days=60,
storage_class="GLACIER",
),
],
status="Enabled",
)],
opts=pulumi.ResourceOptions(depends_on=[versioning]))
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/s3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
bucket, err := s3.NewBucketV2(ctx, "bucket", &s3.BucketV2Args{
Bucket: pulumi.String("my-bucket"),
})
if err != nil {
return err
}
_, err = s3.NewBucketAclV2(ctx, "bucket_acl", &s3.BucketAclV2Args{
Bucket: bucket.ID(),
Acl: pulumi.String("private"),
})
if err != nil {
return err
}
_, err = s3.NewBucketLifecycleConfigurationV2(ctx, "bucket-config", &s3.BucketLifecycleConfigurationV2Args{
Bucket: bucket.ID(),
Rules: s3.BucketLifecycleConfigurationV2RuleArray{
&s3.BucketLifecycleConfigurationV2RuleArgs{
Id: pulumi.String("log"),
Expiration: &s3.BucketLifecycleConfigurationV2RuleExpirationArgs{
Days: pulumi.Int(90),
},
Filter: &s3.BucketLifecycleConfigurationV2RuleFilterArgs{
And: &s3.BucketLifecycleConfigurationV2RuleFilterAndArgs{
Prefix: pulumi.String("log/"),
Tags: pulumi.StringMap{
"rule": pulumi.String("log"),
"autoclean": pulumi.String("true"),
},
},
},
Status: pulumi.String("Enabled"),
Transitions: s3.BucketLifecycleConfigurationV2RuleTransitionArray{
&s3.BucketLifecycleConfigurationV2RuleTransitionArgs{
Days: pulumi.Int(30),
StorageClass: pulumi.String("STANDARD_IA"),
},
&s3.BucketLifecycleConfigurationV2RuleTransitionArgs{
Days: pulumi.Int(60),
StorageClass: pulumi.String("GLACIER"),
},
},
},
&s3.BucketLifecycleConfigurationV2RuleArgs{
Id: pulumi.String("tmp"),
Filter: &s3.BucketLifecycleConfigurationV2RuleFilterArgs{
Prefix: pulumi.String("tmp/"),
},
Expiration: &s3.BucketLifecycleConfigurationV2RuleExpirationArgs{
Date: pulumi.String("2023-01-13T00:00:00Z"),
},
Status: pulumi.String("Enabled"),
},
},
})
if err != nil {
return err
}
versioningBucket, err := s3.NewBucketV2(ctx, "versioning_bucket", &s3.BucketV2Args{
Bucket: pulumi.String("my-versioning-bucket"),
})
if err != nil {
return err
}
_, err = s3.NewBucketAclV2(ctx, "versioning_bucket_acl", &s3.BucketAclV2Args{
Bucket: versioningBucket.ID(),
Acl: pulumi.String("private"),
})
if err != nil {
return err
}
versioning, err := s3.NewBucketVersioningV2(ctx, "versioning", &s3.BucketVersioningV2Args{
Bucket: versioningBucket.ID(),
VersioningConfiguration: &s3.BucketVersioningV2VersioningConfigurationArgs{
Status: pulumi.String("Enabled"),
},
})
if err != nil {
return err
}
_, err = s3.NewBucketLifecycleConfigurationV2(ctx, "versioning-bucket-config", &s3.BucketLifecycleConfigurationV2Args{
Bucket: versioningBucket.ID(),
Rules: s3.BucketLifecycleConfigurationV2RuleArray{
&s3.BucketLifecycleConfigurationV2RuleArgs{
Id: pulumi.String("config"),
Filter: &s3.BucketLifecycleConfigurationV2RuleFilterArgs{
Prefix: pulumi.String("config/"),
},
NoncurrentVersionExpiration: &s3.BucketLifecycleConfigurationV2RuleNoncurrentVersionExpirationArgs{
NoncurrentDays: pulumi.Int(90),
},
NoncurrentVersionTransitions: s3.BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArray{
&s3.BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArgs{
NoncurrentDays: pulumi.Int(30),
StorageClass: pulumi.String("STANDARD_IA"),
},
&s3.BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArgs{
NoncurrentDays: pulumi.Int(60),
StorageClass: pulumi.String("GLACIER"),
},
},
Status: pulumi.String("Enabled"),
},
},
}, pulumi.DependsOn([]pulumi.Resource{
versioning,
}))
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var bucket = new Aws.S3.BucketV2("bucket", new()
{
Bucket = "my-bucket",
});
var bucketAcl = new Aws.S3.BucketAclV2("bucket_acl", new()
{
Bucket = bucket.Id,
Acl = "private",
});
var bucket_config = new Aws.S3.BucketLifecycleConfigurationV2("bucket-config", new()
{
Bucket = bucket.Id,
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleArgs
{
Id = "log",
Expiration = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleExpirationArgs
{
Days = 90,
},
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterArgs
{
And = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterAndArgs
{
Prefix = "log/",
Tags =
{
{ "rule", "log" },
{ "autoclean", "true" },
},
},
},
Status = "Enabled",
Transitions = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleTransitionArgs
{
Days = 30,
StorageClass = "STANDARD_IA",
},
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleTransitionArgs
{
Days = 60,
StorageClass = "GLACIER",
},
},
},
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleArgs
{
Id = "tmp",
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterArgs
{
Prefix = "tmp/",
},
Expiration = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleExpirationArgs
{
Date = "2023-01-13T00:00:00Z",
},
Status = "Enabled",
},
},
});
var versioningBucket = new Aws.S3.BucketV2("versioning_bucket", new()
{
Bucket = "my-versioning-bucket",
});
var versioningBucketAcl = new Aws.S3.BucketAclV2("versioning_bucket_acl", new()
{
Bucket = versioningBucket.Id,
Acl = "private",
});
var versioning = new Aws.S3.BucketVersioningV2("versioning", new()
{
Bucket = versioningBucket.Id,
VersioningConfiguration = new Aws.S3.Inputs.BucketVersioningV2VersioningConfigurationArgs
{
Status = "Enabled",
},
});
var versioning_bucket_config = new Aws.S3.BucketLifecycleConfigurationV2("versioning-bucket-config", new()
{
Bucket = versioningBucket.Id,
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleArgs
{
Id = "config",
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterArgs
{
Prefix = "config/",
},
NoncurrentVersionExpiration = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleNoncurrentVersionExpirationArgs
{
NoncurrentDays = 90,
},
NoncurrentVersionTransitions = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArgs
{
NoncurrentDays = 30,
StorageClass = "STANDARD_IA",
},
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArgs
{
NoncurrentDays = 60,
StorageClass = "GLACIER",
},
},
Status = "Enabled",
},
},
}, new CustomResourceOptions
{
DependsOn =
{
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.BucketV2Args;
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", BucketV2Args.builder()
.bucket("my-bucket")
.build());
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", BucketV2Args.builder()
.bucket("my-versioning-bucket")
.build());
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());
}
}
resources:
bucket:
type: aws:s3:BucketV2
properties:
bucket: my-bucket
bucketAcl:
type: aws:s3:BucketAclV2
name: bucket_acl
properties:
bucket: ${bucket.id}
acl: private
bucket-config:
type: aws:s3:BucketLifecycleConfigurationV2
properties:
bucket: ${bucket.id}
rules:
- id: log
expiration:
days: 90
filter:
and:
prefix: log/
tags:
rule: log
autoclean: 'true'
status: Enabled
transitions:
- days: 30
storageClass: STANDARD_IA
- days: 60
storageClass: GLACIER
- id: tmp
filter:
prefix: tmp/
expiration:
date: 2023-01-13T00:00:00Z
status: Enabled
versioningBucket:
type: aws:s3:BucketV2
name: versioning_bucket
properties:
bucket: my-versioning-bucket
versioningBucketAcl:
type: aws:s3:BucketAclV2
name: versioning_bucket_acl
properties:
bucket: ${versioningBucket.id}
acl: private
versioning:
type: aws:s3:BucketVersioningV2
properties:
bucket: ${versioningBucket.id}
versioningConfiguration:
status: Enabled
versioning-bucket-config:
type: aws:s3:BucketLifecycleConfigurationV2
properties:
bucket: ${versioningBucket.id}
rules:
- id: config
filter:
prefix: config/
noncurrentVersionExpiration:
noncurrentDays: 90
noncurrentVersionTransitions:
- noncurrentDays: 30
storageClass: STANDARD_IA
- noncurrentDays: 60
storageClass: GLACIER
status: Enabled
options:
dependson:
- ${versioning}
Create BucketLifecycleConfigurationV2 Resource
Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.
Constructor syntax
new BucketLifecycleConfigurationV2(name: string, args: BucketLifecycleConfigurationV2Args, opts?: CustomResourceOptions);@overload
def BucketLifecycleConfigurationV2(resource_name: str,
args: BucketLifecycleConfigurationV2Args,
opts: Optional[ResourceOptions] = None)
@overload
def BucketLifecycleConfigurationV2(resource_name: str,
opts: Optional[ResourceOptions] = None,
bucket: Optional[str] = None,
rules: Optional[Sequence[BucketLifecycleConfigurationV2RuleArgs]] = None,
expected_bucket_owner: Optional[str] = None)func NewBucketLifecycleConfigurationV2(ctx *Context, name string, args BucketLifecycleConfigurationV2Args, opts ...ResourceOption) (*BucketLifecycleConfigurationV2, error)public BucketLifecycleConfigurationV2(string name, BucketLifecycleConfigurationV2Args args, CustomResourceOptions? opts = null)
public BucketLifecycleConfigurationV2(String name, BucketLifecycleConfigurationV2Args args)
public BucketLifecycleConfigurationV2(String name, BucketLifecycleConfigurationV2Args args, CustomResourceOptions options)
type: aws:s3:BucketLifecycleConfigurationV2
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.
Parameters
- name string
- The unique name of the resource.
- args BucketLifecycleConfigurationV2Args
- The arguments to resource properties.
- opts CustomResourceOptions
- Bag of options to control resource's behavior.
- resource_name str
- The unique name of the resource.
- args BucketLifecycleConfigurationV2Args
- The arguments to resource properties.
- opts ResourceOptions
- Bag of options to control resource's behavior.
- ctx Context
- Context object for the current deployment.
- name string
- The unique name of the resource.
- args BucketLifecycleConfigurationV2Args
- The arguments to resource properties.
- opts ResourceOption
- Bag of options to control resource's behavior.
- name string
- The unique name of the resource.
- args BucketLifecycleConfigurationV2Args
- The arguments to resource properties.
- opts CustomResourceOptions
- Bag of options to control resource's behavior.
- name String
- The unique name of the resource.
- args BucketLifecycleConfigurationV2Args
- The arguments to resource properties.
- options CustomResourceOptions
- Bag of options to control resource's behavior.
Example
The following reference example uses placeholder values for all input properties.
var bucketLifecycleConfigurationV2Resource = new Aws.S3.BucketLifecycleConfigurationV2("bucketLifecycleConfigurationV2Resource", new()
{
Bucket = "string",
Rules = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleArgs
{
Id = "string",
Status = "string",
AbortIncompleteMultipartUpload = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleAbortIncompleteMultipartUploadArgs
{
DaysAfterInitiation = 0,
},
Expiration = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleExpirationArgs
{
Date = "string",
Days = 0,
ExpiredObjectDeleteMarker = false,
},
Filter = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterArgs
{
And = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterAndArgs
{
ObjectSizeGreaterThan = 0,
ObjectSizeLessThan = 0,
Prefix = "string",
Tags =
{
{ "string", "string" },
},
},
ObjectSizeGreaterThan = "string",
ObjectSizeLessThan = "string",
Prefix = "string",
Tag = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleFilterTagArgs
{
Key = "string",
Value = "string",
},
},
NoncurrentVersionExpiration = new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleNoncurrentVersionExpirationArgs
{
NewerNoncurrentVersions = "string",
NoncurrentDays = 0,
},
NoncurrentVersionTransitions = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArgs
{
StorageClass = "string",
NewerNoncurrentVersions = "string",
NoncurrentDays = 0,
},
},
Transitions = new[]
{
new Aws.S3.Inputs.BucketLifecycleConfigurationV2RuleTransitionArgs
{
StorageClass = "string",
Date = "string",
Days = 0,
},
},
},
},
ExpectedBucketOwner = "string",
});
example, err := s3.NewBucketLifecycleConfigurationV2(ctx, "bucketLifecycleConfigurationV2Resource", &s3.BucketLifecycleConfigurationV2Args{
Bucket: pulumi.String("string"),
Rules: s3.BucketLifecycleConfigurationV2RuleArray{
&s3.BucketLifecycleConfigurationV2RuleArgs{
Id: pulumi.String("string"),
Status: pulumi.String("string"),
AbortIncompleteMultipartUpload: &s3.BucketLifecycleConfigurationV2RuleAbortIncompleteMultipartUploadArgs{
DaysAfterInitiation: pulumi.Int(0),
},
Expiration: &s3.BucketLifecycleConfigurationV2RuleExpirationArgs{
Date: pulumi.String("string"),
Days: pulumi.Int(0),
ExpiredObjectDeleteMarker: pulumi.Bool(false),
},
Filter: &s3.BucketLifecycleConfigurationV2RuleFilterArgs{
And: &s3.BucketLifecycleConfigurationV2RuleFilterAndArgs{
ObjectSizeGreaterThan: pulumi.Int(0),
ObjectSizeLessThan: pulumi.Int(0),
Prefix: pulumi.String("string"),
Tags: pulumi.StringMap{
"string": pulumi.String("string"),
},
},
ObjectSizeGreaterThan: pulumi.String("string"),
ObjectSizeLessThan: pulumi.String("string"),
Prefix: pulumi.String("string"),
Tag: &s3.BucketLifecycleConfigurationV2RuleFilterTagArgs{
Key: pulumi.String("string"),
Value: pulumi.String("string"),
},
},
NoncurrentVersionExpiration: &s3.BucketLifecycleConfigurationV2RuleNoncurrentVersionExpirationArgs{
NewerNoncurrentVersions: pulumi.String("string"),
NoncurrentDays: pulumi.Int(0),
},
NoncurrentVersionTransitions: s3.BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArray{
&s3.BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArgs{
StorageClass: pulumi.String("string"),
NewerNoncurrentVersions: pulumi.String("string"),
NoncurrentDays: pulumi.Int(0),
},
},
Transitions: s3.BucketLifecycleConfigurationV2RuleTransitionArray{
&s3.BucketLifecycleConfigurationV2RuleTransitionArgs{
StorageClass: pulumi.String("string"),
Date: pulumi.String("string"),
Days: pulumi.Int(0),
},
},
},
},
ExpectedBucketOwner: pulumi.String("string"),
})
var bucketLifecycleConfigurationV2Resource = new BucketLifecycleConfigurationV2("bucketLifecycleConfigurationV2Resource", BucketLifecycleConfigurationV2Args.builder()
.bucket("string")
.rules(BucketLifecycleConfigurationV2RuleArgs.builder()
.id("string")
.status("string")
.abortIncompleteMultipartUpload(BucketLifecycleConfigurationV2RuleAbortIncompleteMultipartUploadArgs.builder()
.daysAfterInitiation(0)
.build())
.expiration(BucketLifecycleConfigurationV2RuleExpirationArgs.builder()
.date("string")
.days(0)
.expiredObjectDeleteMarker(false)
.build())
.filter(BucketLifecycleConfigurationV2RuleFilterArgs.builder()
.and(BucketLifecycleConfigurationV2RuleFilterAndArgs.builder()
.objectSizeGreaterThan(0)
.objectSizeLessThan(0)
.prefix("string")
.tags(Map.of("string", "string"))
.build())
.objectSizeGreaterThan("string")
.objectSizeLessThan("string")
.prefix("string")
.tag(BucketLifecycleConfigurationV2RuleFilterTagArgs.builder()
.key("string")
.value("string")
.build())
.build())
.noncurrentVersionExpiration(BucketLifecycleConfigurationV2RuleNoncurrentVersionExpirationArgs.builder()
.newerNoncurrentVersions("string")
.noncurrentDays(0)
.build())
.noncurrentVersionTransitions(BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArgs.builder()
.storageClass("string")
.newerNoncurrentVersions("string")
.noncurrentDays(0)
.build())
.transitions(BucketLifecycleConfigurationV2RuleTransitionArgs.builder()
.storageClass("string")
.date("string")
.days(0)
.build())
.build())
.expectedBucketOwner("string")
.build());
bucket_lifecycle_configuration_v2_resource = aws.s3.BucketLifecycleConfigurationV2("bucketLifecycleConfigurationV2Resource",
bucket="string",
rules=[aws.s3.BucketLifecycleConfigurationV2RuleArgs(
id="string",
status="string",
abort_incomplete_multipart_upload=aws.s3.BucketLifecycleConfigurationV2RuleAbortIncompleteMultipartUploadArgs(
days_after_initiation=0,
),
expiration=aws.s3.BucketLifecycleConfigurationV2RuleExpirationArgs(
date="string",
days=0,
expired_object_delete_marker=False,
),
filter=aws.s3.BucketLifecycleConfigurationV2RuleFilterArgs(
and_=aws.s3.BucketLifecycleConfigurationV2RuleFilterAndArgs(
object_size_greater_than=0,
object_size_less_than=0,
prefix="string",
tags={
"string": "string",
},
),
object_size_greater_than="string",
object_size_less_than="string",
prefix="string",
tag=aws.s3.BucketLifecycleConfigurationV2RuleFilterTagArgs(
key="string",
value="string",
),
),
noncurrent_version_expiration=aws.s3.BucketLifecycleConfigurationV2RuleNoncurrentVersionExpirationArgs(
newer_noncurrent_versions="string",
noncurrent_days=0,
),
noncurrent_version_transitions=[aws.s3.BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArgs(
storage_class="string",
newer_noncurrent_versions="string",
noncurrent_days=0,
)],
transitions=[aws.s3.BucketLifecycleConfigurationV2RuleTransitionArgs(
storage_class="string",
date="string",
days=0,
)],
)],
expected_bucket_owner="string")
const bucketLifecycleConfigurationV2Resource = new aws.s3.BucketLifecycleConfigurationV2("bucketLifecycleConfigurationV2Resource", {
bucket: "string",
rules: [{
id: "string",
status: "string",
abortIncompleteMultipartUpload: {
daysAfterInitiation: 0,
},
expiration: {
date: "string",
days: 0,
expiredObjectDeleteMarker: false,
},
filter: {
and: {
objectSizeGreaterThan: 0,
objectSizeLessThan: 0,
prefix: "string",
tags: {
string: "string",
},
},
objectSizeGreaterThan: "string",
objectSizeLessThan: "string",
prefix: "string",
tag: {
key: "string",
value: "string",
},
},
noncurrentVersionExpiration: {
newerNoncurrentVersions: "string",
noncurrentDays: 0,
},
noncurrentVersionTransitions: [{
storageClass: "string",
newerNoncurrentVersions: "string",
noncurrentDays: 0,
}],
transitions: [{
storageClass: "string",
date: "string",
days: 0,
}],
}],
expectedBucketOwner: "string",
});
type: aws:s3:BucketLifecycleConfigurationV2
properties:
bucket: string
expectedBucketOwner: string
rules:
- abortIncompleteMultipartUpload:
daysAfterInitiation: 0
expiration:
date: string
days: 0
expiredObjectDeleteMarker: false
filter:
and:
objectSizeGreaterThan: 0
objectSizeLessThan: 0
prefix: string
tags:
string: string
objectSizeGreaterThan: string
objectSizeLessThan: string
prefix: string
tag:
key: string
value: string
id: string
noncurrentVersionExpiration:
newerNoncurrentVersions: string
noncurrentDays: 0
noncurrentVersionTransitions:
- newerNoncurrentVersions: string
noncurrentDays: 0
storageClass: string
status: string
transitions:
- date: string
days: 0
storageClass: string
BucketLifecycleConfigurationV2 Resource Properties
To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.
Inputs
The BucketLifecycleConfigurationV2 resource accepts the following input properties:
- Bucket string
- Name of the source S3 bucket you want Amazon S3 to monitor.
- Rules
List<Bucket
Lifecycle Configuration V2Rule> - List of configuration blocks describing the rules managing the replication. See below.
- Expected
Bucket stringOwner - 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.
- Bucket string
- Name of the source S3 bucket you want Amazon S3 to monitor.
- Rules
[]Bucket
Lifecycle Configuration V2Rule Args - List of configuration blocks describing the rules managing the replication. See below.
- Expected
Bucket stringOwner - 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.
- bucket String
- Name of the source S3 bucket you want Amazon S3 to monitor.
- rules
List<Bucket
Lifecycle Configuration V2Rule> - List of configuration blocks describing the rules managing the replication. See below.
- expected
Bucket StringOwner - 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.
- bucket string
- Name of the source S3 bucket you want Amazon S3 to monitor.
- rules
Bucket
Lifecycle Configuration V2Rule[] - List of configuration blocks describing the rules managing the replication. See below.
- expected
Bucket stringOwner - 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.
- bucket str
- Name of the source S3 bucket you want Amazon S3 to monitor.
- rules
Sequence[Bucket
Lifecycle Configuration V2Rule Args] - List of configuration blocks describing the rules managing the replication. See below.
- expected_
bucket_ strowner - 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.
- bucket String
- Name of the source S3 bucket you want Amazon S3 to monitor.
- rules List<Property Map>
- List of configuration blocks describing the rules managing the replication. See below.
- expected
Bucket StringOwner - 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.
Outputs
All input properties are implicitly available as output properties. Additionally, the BucketLifecycleConfigurationV2 resource produces the following output properties:
- Id string
- The provider-assigned unique ID for this managed resource.
- Id string
- The provider-assigned unique ID for this managed resource.
- id String
- The provider-assigned unique ID for this managed resource.
- id string
- The provider-assigned unique ID for this managed resource.
- id str
- The provider-assigned unique ID for this managed resource.
- id String
- The provider-assigned unique ID for this managed resource.
Look up Existing BucketLifecycleConfigurationV2 Resource
Get an existing BucketLifecycleConfigurationV2 resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.
public static get(name: string, id: Input<ID>, state?: BucketLifecycleConfigurationV2State, opts?: CustomResourceOptions): BucketLifecycleConfigurationV2@staticmethod
def get(resource_name: str,
id: str,
opts: Optional[ResourceOptions] = None,
bucket: Optional[str] = None,
expected_bucket_owner: Optional[str] = None,
rules: Optional[Sequence[BucketLifecycleConfigurationV2RuleArgs]] = None) -> BucketLifecycleConfigurationV2func GetBucketLifecycleConfigurationV2(ctx *Context, name string, id IDInput, state *BucketLifecycleConfigurationV2State, opts ...ResourceOption) (*BucketLifecycleConfigurationV2, error)public static BucketLifecycleConfigurationV2 Get(string name, Input<string> id, BucketLifecycleConfigurationV2State? state, CustomResourceOptions? opts = null)public static BucketLifecycleConfigurationV2 get(String name, Output<String> id, BucketLifecycleConfigurationV2State state, CustomResourceOptions options)Resource lookup is not supported in YAML- name
- The unique name of the resulting resource.
- id
- The unique provider ID of the resource to lookup.
- state
- Any extra arguments used during the lookup.
- opts
- A bag of options that control this resource's behavior.
- resource_name
- The unique name of the resulting resource.
- id
- The unique provider ID of the resource to lookup.
- name
- The unique name of the resulting resource.
- id
- The unique provider ID of the resource to lookup.
- state
- Any extra arguments used during the lookup.
- opts
- A bag of options that control this resource's behavior.
- name
- The unique name of the resulting resource.
- id
- The unique provider ID of the resource to lookup.
- state
- Any extra arguments used during the lookup.
- opts
- A bag of options that control this resource's behavior.
- name
- The unique name of the resulting resource.
- id
- The unique provider ID of the resource to lookup.
- state
- Any extra arguments used during the lookup.
- opts
- A bag of options that control this resource's behavior.
- Bucket string
- Name of the source S3 bucket you want Amazon S3 to monitor.
- Expected
Bucket stringOwner - 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.
- Rules
List<Bucket
Lifecycle Configuration V2Rule> - List of configuration blocks describing the rules managing the replication. See below.
- Bucket string
- Name of the source S3 bucket you want Amazon S3 to monitor.
- Expected
Bucket stringOwner - 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.
- Rules
[]Bucket
Lifecycle Configuration V2Rule Args - List of configuration blocks describing the rules managing the replication. See below.
- bucket String
- Name of the source S3 bucket you want Amazon S3 to monitor.
- expected
Bucket StringOwner - 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.
- rules
List<Bucket
Lifecycle Configuration V2Rule> - List of configuration blocks describing the rules managing the replication. See below.
- bucket string
- Name of the source S3 bucket you want Amazon S3 to monitor.
- expected
Bucket stringOwner - 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.
- rules
Bucket
Lifecycle Configuration V2Rule[] - List of configuration blocks describing the rules managing the replication. See below.
- bucket str
- Name of the source S3 bucket you want Amazon S3 to monitor.
- expected_
bucket_ strowner - 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.
- rules
Sequence[Bucket
Lifecycle Configuration V2Rule Args] - List of configuration blocks describing the rules managing the replication. See below.
- bucket String
- Name of the source S3 bucket you want Amazon S3 to monitor.
- expected
Bucket StringOwner - 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.
- rules List<Property Map>
- List of configuration blocks describing the rules managing the replication. See below.
Supporting Types
BucketLifecycleConfigurationV2Rule, BucketLifecycleConfigurationV2RuleArgs
- Id string
- Unique identifier for the rule. The value cannot be longer than 255 characters.
- Status string
- Whether the rule is currently being applied. Valid values:
EnabledorDisabled. - Abort
Incomplete BucketMultipart Upload Lifecycle Configuration V2Rule Abort Incomplete Multipart Upload - Configuration block that specifies the days since the initiation of an incomplete multipart upload that Amazon S3 will wait before permanently removing all parts of the upload. See below.
- Expiration
Bucket
Lifecycle Configuration V2Rule Expiration - Configuration block that specifies the expiration for the lifecycle of the object in the form of date, days and, whether the object has a delete marker. See below.
- Filter
Bucket
Lifecycle Configuration V2Rule Filter - Configuration block used to identify objects that a Lifecycle Rule applies to. See below. If not specified, the
rulewill default to usingprefix. - Noncurrent
Version BucketExpiration Lifecycle Configuration V2Rule Noncurrent Version Expiration - Configuration block that specifies when noncurrent object versions expire. See below.
- Noncurrent
Version List<BucketTransitions Lifecycle Configuration V2Rule Noncurrent Version Transition> - Set of configuration blocks that specify the transition rule for the lifecycle rule that describes when noncurrent objects transition to a specific storage class. See below.
- Prefix string
- DEPRECATED Use
filterinstead. This has been deprecated by Amazon S3. Prefix identifying one or more objects to which the rule applies. Defaults to an empty string ("") iffilteris not specified. - Transitions
List<Bucket
Lifecycle Configuration V2Rule Transition> - Set of configuration blocks that specify when an Amazon S3 object transitions to a specified storage class. See below.
- Id string
- Unique identifier for the rule. The value cannot be longer than 255 characters.
- Status string
- Whether the rule is currently being applied. Valid values:
EnabledorDisabled. - Abort
Incomplete BucketMultipart Upload Lifecycle Configuration V2Rule Abort Incomplete Multipart Upload - Configuration block that specifies the days since the initiation of an incomplete multipart upload that Amazon S3 will wait before permanently removing all parts of the upload. See below.
- Expiration
Bucket
Lifecycle Configuration V2Rule Expiration - Configuration block that specifies the expiration for the lifecycle of the object in the form of date, days and, whether the object has a delete marker. See below.
- Filter
Bucket
Lifecycle Configuration V2Rule Filter - Configuration block used to identify objects that a Lifecycle Rule applies to. See below. If not specified, the
rulewill default to usingprefix. - Noncurrent
Version BucketExpiration Lifecycle Configuration V2Rule Noncurrent Version Expiration - Configuration block that specifies when noncurrent object versions expire. See below.
- Noncurrent
Version []BucketTransitions Lifecycle Configuration V2Rule Noncurrent Version Transition - Set of configuration blocks that specify the transition rule for the lifecycle rule that describes when noncurrent objects transition to a specific storage class. See below.
- Prefix string
- DEPRECATED Use
filterinstead. This has been deprecated by Amazon S3. Prefix identifying one or more objects to which the rule applies. Defaults to an empty string ("") iffilteris not specified. - Transitions
[]Bucket
Lifecycle Configuration V2Rule Transition - Set of configuration blocks that specify when an Amazon S3 object transitions to a specified storage class. See below.
- id String
- Unique identifier for the rule. The value cannot be longer than 255 characters.
- status String
- Whether the rule is currently being applied. Valid values:
EnabledorDisabled. - abort
Incomplete BucketMultipart Upload Lifecycle Configuration V2Rule Abort Incomplete Multipart Upload - Configuration block that specifies the days since the initiation of an incomplete multipart upload that Amazon S3 will wait before permanently removing all parts of the upload. See below.
- expiration
Bucket
Lifecycle Configuration V2Rule Expiration - Configuration block that specifies the expiration for the lifecycle of the object in the form of date, days and, whether the object has a delete marker. See below.
- filter
Bucket
Lifecycle Configuration V2Rule Filter - Configuration block used to identify objects that a Lifecycle Rule applies to. See below. If not specified, the
rulewill default to usingprefix. - noncurrent
Version BucketExpiration Lifecycle Configuration V2Rule Noncurrent Version Expiration - Configuration block that specifies when noncurrent object versions expire. See below.
- noncurrent
Version List<BucketTransitions Lifecycle Configuration V2Rule Noncurrent Version Transition> - Set of configuration blocks that specify the transition rule for the lifecycle rule that describes when noncurrent objects transition to a specific storage class. See below.
- prefix String
- DEPRECATED Use
filterinstead. This has been deprecated by Amazon S3. Prefix identifying one or more objects to which the rule applies. Defaults to an empty string ("") iffilteris not specified. - transitions
List<Bucket
Lifecycle Configuration V2Rule Transition> - Set of configuration blocks that specify when an Amazon S3 object transitions to a specified storage class. See below.
- id string
- Unique identifier for the rule. The value cannot be longer than 255 characters.
- status string
- Whether the rule is currently being applied. Valid values:
EnabledorDisabled. - abort
Incomplete BucketMultipart Upload Lifecycle Configuration V2Rule Abort Incomplete Multipart Upload - Configuration block that specifies the days since the initiation of an incomplete multipart upload that Amazon S3 will wait before permanently removing all parts of the upload. See below.
- expiration
Bucket
Lifecycle Configuration V2Rule Expiration - Configuration block that specifies the expiration for the lifecycle of the object in the form of date, days and, whether the object has a delete marker. See below.
- filter
Bucket
Lifecycle Configuration V2Rule Filter - Configuration block used to identify objects that a Lifecycle Rule applies to. See below. If not specified, the
rulewill default to usingprefix. - noncurrent
Version BucketExpiration Lifecycle Configuration V2Rule Noncurrent Version Expiration - Configuration block that specifies when noncurrent object versions expire. See below.
- noncurrent
Version BucketTransitions Lifecycle Configuration V2Rule Noncurrent Version Transition[] - Set of configuration blocks that specify the transition rule for the lifecycle rule that describes when noncurrent objects transition to a specific storage class. See below.
- prefix string
- DEPRECATED Use
filterinstead. This has been deprecated by Amazon S3. Prefix identifying one or more objects to which the rule applies. Defaults to an empty string ("") iffilteris not specified. - transitions
Bucket
Lifecycle Configuration V2Rule Transition[] - Set of configuration blocks that specify when an Amazon S3 object transitions to a specified storage class. See below.
- id str
- Unique identifier for the rule. The value cannot be longer than 255 characters.
- status str
- Whether the rule is currently being applied. Valid values:
EnabledorDisabled. - abort_
incomplete_ Bucketmultipart_ upload Lifecycle Configuration V2Rule Abort Incomplete Multipart Upload - Configuration block that specifies the days since the initiation of an incomplete multipart upload that Amazon S3 will wait before permanently removing all parts of the upload. See below.
- expiration
Bucket
Lifecycle Configuration V2Rule Expiration - Configuration block that specifies the expiration for the lifecycle of the object in the form of date, days and, whether the object has a delete marker. See below.
- filter
Bucket
Lifecycle Configuration V2Rule Filter - Configuration block used to identify objects that a Lifecycle Rule applies to. See below. If not specified, the
rulewill default to usingprefix. - noncurrent_
version_ Bucketexpiration Lifecycle Configuration V2Rule Noncurrent Version Expiration - Configuration block that specifies when noncurrent object versions expire. See below.
- noncurrent_
version_ Sequence[Buckettransitions Lifecycle Configuration V2Rule Noncurrent Version Transition] - Set of configuration blocks that specify the transition rule for the lifecycle rule that describes when noncurrent objects transition to a specific storage class. See below.
- prefix str
- DEPRECATED Use
filterinstead. This has been deprecated by Amazon S3. Prefix identifying one or more objects to which the rule applies. Defaults to an empty string ("") iffilteris not specified. - transitions
Sequence[Bucket
Lifecycle Configuration V2Rule Transition] - Set of configuration blocks that specify when an Amazon S3 object transitions to a specified storage class. See below.
- id String
- Unique identifier for the rule. The value cannot be longer than 255 characters.
- status String
- Whether the rule is currently being applied. Valid values:
EnabledorDisabled. - abort
Incomplete Property MapMultipart Upload - Configuration block that specifies the days since the initiation of an incomplete multipart upload that Amazon S3 will wait before permanently removing all parts of the upload. See below.
- expiration Property Map
- Configuration block that specifies the expiration for the lifecycle of the object in the form of date, days and, whether the object has a delete marker. See below.
- filter Property Map
- Configuration block used to identify objects that a Lifecycle Rule applies to. See below. If not specified, the
rulewill default to usingprefix. - noncurrent
Version Property MapExpiration - Configuration block that specifies when noncurrent object versions expire. See below.
- noncurrent
Version List<Property Map>Transitions - Set of configuration blocks that specify the transition rule for the lifecycle rule that describes when noncurrent objects transition to a specific storage class. See below.
- prefix String
- DEPRECATED Use
filterinstead. This has been deprecated by Amazon S3. Prefix identifying one or more objects to which the rule applies. Defaults to an empty string ("") iffilteris not specified. - transitions List<Property Map>
- Set of configuration blocks that specify when an Amazon S3 object transitions to a specified storage class. See below.
BucketLifecycleConfigurationV2RuleAbortIncompleteMultipartUpload, BucketLifecycleConfigurationV2RuleAbortIncompleteMultipartUploadArgs
- Days
After intInitiation - Number of days after which Amazon S3 aborts an incomplete multipart upload.
- Days
After intInitiation - Number of days after which Amazon S3 aborts an incomplete multipart upload.
- days
After IntegerInitiation - Number of days after which Amazon S3 aborts an incomplete multipart upload.
- days
After numberInitiation - Number of days after which Amazon S3 aborts an incomplete multipart upload.
- days_
after_ intinitiation - Number of days after which Amazon S3 aborts an incomplete multipart upload.
- days
After NumberInitiation - Number of days after which Amazon S3 aborts an incomplete multipart upload.
BucketLifecycleConfigurationV2RuleExpiration, BucketLifecycleConfigurationV2RuleExpirationArgs
- Date string
- Date the object is to be moved or deleted. The date value must be in RFC3339 full-date format e.g.
2023-08-22. - Days int
- Lifetime, in days, of the objects that are subject to the rule. The value must be a non-zero positive integer.
- Expired
Object boolDelete Marker - Indicates whether Amazon S3 will remove a delete marker with no noncurrent versions. If set to
true, the delete marker will be expired; if set tofalsethe policy takes no action.
- Date string
- Date the object is to be moved or deleted. The date value must be in RFC3339 full-date format e.g.
2023-08-22. - Days int
- Lifetime, in days, of the objects that are subject to the rule. The value must be a non-zero positive integer.
- Expired
Object boolDelete Marker - Indicates whether Amazon S3 will remove a delete marker with no noncurrent versions. If set to
true, the delete marker will be expired; if set tofalsethe policy takes no action.
- date String
- Date the object is to be moved or deleted. The date value must be in RFC3339 full-date format e.g.
2023-08-22. - days Integer
- Lifetime, in days, of the objects that are subject to the rule. The value must be a non-zero positive integer.
- expired
Object BooleanDelete Marker - Indicates whether Amazon S3 will remove a delete marker with no noncurrent versions. If set to
true, the delete marker will be expired; if set tofalsethe policy takes no action.
- date string
- Date the object is to be moved or deleted. The date value must be in RFC3339 full-date format e.g.
2023-08-22. - days number
- Lifetime, in days, of the objects that are subject to the rule. The value must be a non-zero positive integer.
- expired
Object booleanDelete Marker - Indicates whether Amazon S3 will remove a delete marker with no noncurrent versions. If set to
true, the delete marker will be expired; if set tofalsethe policy takes no action.
- date str
- Date the object is to be moved or deleted. The date value must be in RFC3339 full-date format e.g.
2023-08-22. - days int
- Lifetime, in days, of the objects that are subject to the rule. The value must be a non-zero positive integer.
- expired_
object_ booldelete_ marker - Indicates whether Amazon S3 will remove a delete marker with no noncurrent versions. If set to
true, the delete marker will be expired; if set tofalsethe policy takes no action.
- date String
- Date the object is to be moved or deleted. The date value must be in RFC3339 full-date format e.g.
2023-08-22. - days Number
- Lifetime, in days, of the objects that are subject to the rule. The value must be a non-zero positive integer.
- expired
Object BooleanDelete Marker - Indicates whether Amazon S3 will remove a delete marker with no noncurrent versions. If set to
true, the delete marker will be expired; if set tofalsethe policy takes no action.
BucketLifecycleConfigurationV2RuleFilter, BucketLifecycleConfigurationV2RuleFilterArgs
- And
Bucket
Lifecycle Configuration V2Rule Filter And - Configuration block used to apply a logical
ANDto two or more predicates. See below. The Lifecycle Rule will apply to any object matching all the predicates configured inside theandblock. - Object
Size stringGreater Than - Minimum object size (in bytes) to which the rule applies.
- Object
Size stringLess Than - Maximum object size (in bytes) to which the rule applies.
- Prefix string
- Prefix identifying one or more objects to which the rule applies. Defaults to an empty string (
"") if not specified. - Tag
Bucket
Lifecycle Configuration V2Rule Filter Tag - Configuration block for specifying a tag key and value. See below.
- And
Bucket
Lifecycle Configuration V2Rule Filter And - Configuration block used to apply a logical
ANDto two or more predicates. See below. The Lifecycle Rule will apply to any object matching all the predicates configured inside theandblock. - Object
Size stringGreater Than - Minimum object size (in bytes) to which the rule applies.
- Object
Size stringLess Than - Maximum object size (in bytes) to which the rule applies.
- Prefix string
- Prefix identifying one or more objects to which the rule applies. Defaults to an empty string (
"") if not specified. - Tag
Bucket
Lifecycle Configuration V2Rule Filter Tag - Configuration block for specifying a tag key and value. See below.
- and
Bucket
Lifecycle Configuration V2Rule Filter And - Configuration block used to apply a logical
ANDto two or more predicates. See below. The Lifecycle Rule will apply to any object matching all the predicates configured inside theandblock. - object
Size StringGreater Than - Minimum object size (in bytes) to which the rule applies.
- object
Size StringLess Than - Maximum object size (in bytes) to which the rule applies.
- prefix String
- Prefix identifying one or more objects to which the rule applies. Defaults to an empty string (
"") if not specified. - tag
Bucket
Lifecycle Configuration V2Rule Filter Tag - Configuration block for specifying a tag key and value. See below.
- and
Bucket
Lifecycle Configuration V2Rule Filter And - Configuration block used to apply a logical
ANDto two or more predicates. See below. The Lifecycle Rule will apply to any object matching all the predicates configured inside theandblock. - object
Size stringGreater Than - Minimum object size (in bytes) to which the rule applies.
- object
Size stringLess Than - Maximum object size (in bytes) to which the rule applies.
- prefix string
- Prefix identifying one or more objects to which the rule applies. Defaults to an empty string (
"") if not specified. - tag
Bucket
Lifecycle Configuration V2Rule Filter Tag - Configuration block for specifying a tag key and value. See below.
- and_
Bucket
Lifecycle Configuration V2Rule Filter And - Configuration block used to apply a logical
ANDto two or more predicates. See below. The Lifecycle Rule will apply to any object matching all the predicates configured inside theandblock. - object_
size_ strgreater_ than - Minimum object size (in bytes) to which the rule applies.
- object_
size_ strless_ than - Maximum object size (in bytes) to which the rule applies.
- prefix str
- Prefix identifying one or more objects to which the rule applies. Defaults to an empty string (
"") if not specified. - tag
Bucket
Lifecycle Configuration V2Rule Filter Tag - Configuration block for specifying a tag key and value. See below.
- and Property Map
- Configuration block used to apply a logical
ANDto two or more predicates. See below. The Lifecycle Rule will apply to any object matching all the predicates configured inside theandblock. - object
Size StringGreater Than - Minimum object size (in bytes) to which the rule applies.
- object
Size StringLess Than - Maximum object size (in bytes) to which the rule applies.
- prefix String
- Prefix identifying one or more objects to which the rule applies. Defaults to an empty string (
"") if not specified. - tag Property Map
- Configuration block for specifying a tag key and value. See below.
BucketLifecycleConfigurationV2RuleFilterAnd, BucketLifecycleConfigurationV2RuleFilterAndArgs
- Object
Size intGreater Than - Minimum object size to which the rule applies. Value must be at least
0if specified. - Object
Size intLess Than - Maximum object size to which the rule applies. Value must be at least
1if specified. - Prefix string
- Prefix identifying one or more objects to which the rule applies.
- Dictionary<string, string>
- Key-value map of resource tags. All of these tags must exist in the object's tag set in order for the rule to apply.
- Object
Size intGreater Than - Minimum object size to which the rule applies. Value must be at least
0if specified. - Object
Size intLess Than - Maximum object size to which the rule applies. Value must be at least
1if specified. - Prefix string
- Prefix identifying one or more objects to which the rule applies.
- map[string]string
- Key-value map of resource tags. All of these tags must exist in the object's tag set in order for the rule to apply.
- object
Size IntegerGreater Than - Minimum object size to which the rule applies. Value must be at least
0if specified. - object
Size IntegerLess Than - Maximum object size to which the rule applies. Value must be at least
1if specified. - prefix String
- Prefix identifying one or more objects to which the rule applies.
- Map<String,String>
- Key-value map of resource tags. All of these tags must exist in the object's tag set in order for the rule to apply.
- object
Size numberGreater Than - Minimum object size to which the rule applies. Value must be at least
0if specified. - object
Size numberLess Than - Maximum object size to which the rule applies. Value must be at least
1if specified. - prefix string
- Prefix identifying one or more objects to which the rule applies.
- {[key: string]: string}
- Key-value map of resource tags. All of these tags must exist in the object's tag set in order for the rule to apply.
- object_
size_ intgreater_ than - Minimum object size to which the rule applies. Value must be at least
0if specified. - object_
size_ intless_ than - Maximum object size to which the rule applies. Value must be at least
1if specified. - prefix str
- Prefix identifying one or more objects to which the rule applies.
- Mapping[str, str]
- Key-value map of resource tags. All of these tags must exist in the object's tag set in order for the rule to apply.
- object
Size NumberGreater Than - Minimum object size to which the rule applies. Value must be at least
0if specified. - object
Size NumberLess Than - Maximum object size to which the rule applies. Value must be at least
1if specified. - prefix String
- Prefix identifying one or more objects to which the rule applies.
- Map<String>
- Key-value map of resource tags. All of these tags must exist in the object's tag set in order for the rule to apply.
BucketLifecycleConfigurationV2RuleFilterTag, BucketLifecycleConfigurationV2RuleFilterTagArgs
BucketLifecycleConfigurationV2RuleNoncurrentVersionExpiration, BucketLifecycleConfigurationV2RuleNoncurrentVersionExpirationArgs
- Newer
Noncurrent stringVersions - Number of noncurrent versions Amazon S3 will retain. Must be a non-zero positive integer.
- Noncurrent
Days int - Number of days an object is noncurrent before Amazon S3 can perform the associated action. Must be a positive integer.
- Newer
Noncurrent stringVersions - Number of noncurrent versions Amazon S3 will retain. Must be a non-zero positive integer.
- Noncurrent
Days int - Number of days an object is noncurrent before Amazon S3 can perform the associated action. Must be a positive integer.
- newer
Noncurrent StringVersions - Number of noncurrent versions Amazon S3 will retain. Must be a non-zero positive integer.
- noncurrent
Days Integer - Number of days an object is noncurrent before Amazon S3 can perform the associated action. Must be a positive integer.
- newer
Noncurrent stringVersions - Number of noncurrent versions Amazon S3 will retain. Must be a non-zero positive integer.
- noncurrent
Days number - Number of days an object is noncurrent before Amazon S3 can perform the associated action. Must be a positive integer.
- newer_
noncurrent_ strversions - Number of noncurrent versions Amazon S3 will retain. Must be a non-zero positive integer.
- noncurrent_
days int - Number of days an object is noncurrent before Amazon S3 can perform the associated action. Must be a positive integer.
- newer
Noncurrent StringVersions - Number of noncurrent versions Amazon S3 will retain. Must be a non-zero positive integer.
- noncurrent
Days Number - Number of days an object is noncurrent before Amazon S3 can perform the associated action. Must be a positive integer.
BucketLifecycleConfigurationV2RuleNoncurrentVersionTransition, BucketLifecycleConfigurationV2RuleNoncurrentVersionTransitionArgs
- Storage
Class string - Class of storage used to store the object. Valid Values:
GLACIER,STANDARD_IA,ONEZONE_IA,INTELLIGENT_TIERING,DEEP_ARCHIVE,GLACIER_IR. - Newer
Noncurrent stringVersions - Number of noncurrent versions Amazon S3 will retain. Must be a non-zero positive integer.
- Noncurrent
Days int - Number of days an object is noncurrent before Amazon S3 can perform the associated action.
- Storage
Class string - Class of storage used to store the object. Valid Values:
GLACIER,STANDARD_IA,ONEZONE_IA,INTELLIGENT_TIERING,DEEP_ARCHIVE,GLACIER_IR. - Newer
Noncurrent stringVersions - Number of noncurrent versions Amazon S3 will retain. Must be a non-zero positive integer.
- Noncurrent
Days int - Number of days an object is noncurrent before Amazon S3 can perform the associated action.
- storage
Class String - Class of storage used to store the object. Valid Values:
GLACIER,STANDARD_IA,ONEZONE_IA,INTELLIGENT_TIERING,DEEP_ARCHIVE,GLACIER_IR. - newer
Noncurrent StringVersions - Number of noncurrent versions Amazon S3 will retain. Must be a non-zero positive integer.
- noncurrent
Days Integer - Number of days an object is noncurrent before Amazon S3 can perform the associated action.
- storage
Class string - Class of storage used to store the object. Valid Values:
GLACIER,STANDARD_IA,ONEZONE_IA,INTELLIGENT_TIERING,DEEP_ARCHIVE,GLACIER_IR. - newer
Noncurrent stringVersions - Number of noncurrent versions Amazon S3 will retain. Must be a non-zero positive integer.
- noncurrent
Days number - Number of days an object is noncurrent before Amazon S3 can perform the associated action.
- storage_
class str - Class of storage used to store the object. Valid Values:
GLACIER,STANDARD_IA,ONEZONE_IA,INTELLIGENT_TIERING,DEEP_ARCHIVE,GLACIER_IR. - newer_
noncurrent_ strversions - Number of noncurrent versions Amazon S3 will retain. Must be a non-zero positive integer.
- noncurrent_
days int - Number of days an object is noncurrent before Amazon S3 can perform the associated action.
- storage
Class String - Class of storage used to store the object. Valid Values:
GLACIER,STANDARD_IA,ONEZONE_IA,INTELLIGENT_TIERING,DEEP_ARCHIVE,GLACIER_IR. - newer
Noncurrent StringVersions - Number of noncurrent versions Amazon S3 will retain. Must be a non-zero positive integer.
- noncurrent
Days Number - Number of days an object is noncurrent before Amazon S3 can perform the associated action.
BucketLifecycleConfigurationV2RuleTransition, BucketLifecycleConfigurationV2RuleTransitionArgs
- Storage
Class string - Class of storage used to store the object. Valid Values:
GLACIER,STANDARD_IA,ONEZONE_IA,INTELLIGENT_TIERING,DEEP_ARCHIVE,GLACIER_IR. - Date string
- Date objects are transitioned to the specified storage class. The date value must be in RFC3339 full-date format e.g.
2023-08-22. - Days int
- Number of days after creation when objects are transitioned to the specified storage class. The value must be a positive integer. If both
daysanddateare not specified, defaults to0. Valid values depend onstorage_class, see Transition objects using Amazon S3 Lifecycle for more details.
- Storage
Class string - Class of storage used to store the object. Valid Values:
GLACIER,STANDARD_IA,ONEZONE_IA,INTELLIGENT_TIERING,DEEP_ARCHIVE,GLACIER_IR. - Date string
- Date objects are transitioned to the specified storage class. The date value must be in RFC3339 full-date format e.g.
2023-08-22. - Days int
- Number of days after creation when objects are transitioned to the specified storage class. The value must be a positive integer. If both
daysanddateare not specified, defaults to0. Valid values depend onstorage_class, see Transition objects using Amazon S3 Lifecycle for more details.
- storage
Class String - Class of storage used to store the object. Valid Values:
GLACIER,STANDARD_IA,ONEZONE_IA,INTELLIGENT_TIERING,DEEP_ARCHIVE,GLACIER_IR. - date String
- Date objects are transitioned to the specified storage class. The date value must be in RFC3339 full-date format e.g.
2023-08-22. - days Integer
- Number of days after creation when objects are transitioned to the specified storage class. The value must be a positive integer. If both
daysanddateare not specified, defaults to0. Valid values depend onstorage_class, see Transition objects using Amazon S3 Lifecycle for more details.
- storage
Class string - Class of storage used to store the object. Valid Values:
GLACIER,STANDARD_IA,ONEZONE_IA,INTELLIGENT_TIERING,DEEP_ARCHIVE,GLACIER_IR. - date string
- Date objects are transitioned to the specified storage class. The date value must be in RFC3339 full-date format e.g.
2023-08-22. - days number
- Number of days after creation when objects are transitioned to the specified storage class. The value must be a positive integer. If both
daysanddateare not specified, defaults to0. Valid values depend onstorage_class, see Transition objects using Amazon S3 Lifecycle for more details.
- storage_
class str - Class of storage used to store the object. Valid Values:
GLACIER,STANDARD_IA,ONEZONE_IA,INTELLIGENT_TIERING,DEEP_ARCHIVE,GLACIER_IR. - date str
- Date objects are transitioned to the specified storage class. The date value must be in RFC3339 full-date format e.g.
2023-08-22. - days int
- Number of days after creation when objects are transitioned to the specified storage class. The value must be a positive integer. If both
daysanddateare not specified, defaults to0. Valid values depend onstorage_class, see Transition objects using Amazon S3 Lifecycle for more details.
- storage
Class String - Class of storage used to store the object. Valid Values:
GLACIER,STANDARD_IA,ONEZONE_IA,INTELLIGENT_TIERING,DEEP_ARCHIVE,GLACIER_IR. - date String
- Date objects are transitioned to the specified storage class. The date value must be in RFC3339 full-date format e.g.
2023-08-22. - days Number
- Number of days after creation when objects are transitioned to the specified storage class. The value must be a positive integer. If both
daysanddateare not specified, defaults to0. Valid values depend onstorage_class, see Transition objects using Amazon S3 Lifecycle for more details.
Import
If the owner (account ID) of the source bucket differs from the account used to configure the AWS Provider, import using the bucket and expected_bucket_owner separated by a comma (,):
Using pulumi import to import S3 bucket lifecycle configuration using the bucket or using the bucket and expected_bucket_owner 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 expected_bucket_owner separated by a comma (,):
$ pulumi import aws:s3/bucketLifecycleConfigurationV2:BucketLifecycleConfigurationV2 example bucket-name,123456789012
To learn more about importing existing cloud resources, see Importing resources.
Package Details
- Repository
- AWS Classic pulumi/pulumi-aws
- License
- Apache-2.0
- Notes
- This Pulumi package is based on the
awsTerraform Provider.
Try AWS Native preview for resources not in the classic version.
AWS Classic v6.32.0 published on Friday, Apr 19, 2024 by Pulumi