pulumi-aws-kotlin/com.pulumi.aws.rbin.kotlin/Rule

Rule

class Rule : KotlinCustomResource

Resource for managing an AWS RBin Rule.

Example Usage

Basic Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.rbin.Rule("example", {
    description: "example_rule",
    resourceType: "EBS_SNAPSHOT",
    resourceTags: [{
        resourceTagKey: "tag_key",
        resourceTagValue: "tag_value",
    }],
    retentionPeriod: {
        retentionPeriodValue: 10,
        retentionPeriodUnit: "DAYS",
    },
    tags: {
        test_tag_key: "test_tag_value",
    },
});

import pulumi
import pulumi_aws as aws
example = aws.rbin.Rule("example",
    description="example_rule",
    resource_type="EBS_SNAPSHOT",
    resource_tags=[{
        "resource_tag_key": "tag_key",
        "resource_tag_value": "tag_value",
    }],
    retention_period={
        "retention_period_value": 10,
        "retention_period_unit": "DAYS",
    },
    tags={
        "test_tag_key": "test_tag_value",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.Rbin.Rule("example", new()
    {
        Description = "example_rule",
        ResourceType = "EBS_SNAPSHOT",
        ResourceTags = new[]
        {
            new Aws.Rbin.Inputs.RuleResourceTagArgs
            {
                ResourceTagKey = "tag_key",
                ResourceTagValue = "tag_value",
            },
        },
        RetentionPeriod = new Aws.Rbin.Inputs.RuleRetentionPeriodArgs
        {
            RetentionPeriodValue = 10,
            RetentionPeriodUnit = "DAYS",
        },
        Tags =
        {
            { "test_tag_key", "test_tag_value" },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/rbin"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := rbin.NewRule(ctx, "example", &rbin.RuleArgs{
			Description:  pulumi.String("example_rule"),
			ResourceType: pulumi.String("EBS_SNAPSHOT"),
			ResourceTags: rbin.RuleResourceTagArray{
				&rbin.RuleResourceTagArgs{
					ResourceTagKey:   pulumi.String("tag_key"),
					ResourceTagValue: pulumi.String("tag_value"),
				},
			},
			RetentionPeriod: &rbin.RuleRetentionPeriodArgs{
				RetentionPeriodValue: pulumi.Int(10),
				RetentionPeriodUnit:  pulumi.String("DAYS"),
			},
			Tags: pulumi.StringMap{
				"test_tag_key": pulumi.String("test_tag_value"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.rbin.Rule;
import com.pulumi.aws.rbin.RuleArgs;
import com.pulumi.aws.rbin.inputs.RuleResourceTagArgs;
import com.pulumi.aws.rbin.inputs.RuleRetentionPeriodArgs;
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 Rule("example", RuleArgs.builder()
            .description("example_rule")
            .resourceType("EBS_SNAPSHOT")
            .resourceTags(RuleResourceTagArgs.builder()
                .resourceTagKey("tag_key")
                .resourceTagValue("tag_value")
                .build())
            .retentionPeriod(RuleRetentionPeriodArgs.builder()
                .retentionPeriodValue(10)
                .retentionPeriodUnit("DAYS")
                .build())
            .tags(Map.of("test_tag_key", "test_tag_value"))
            .build());
    }
}

resources:
  example:
    type: aws:rbin:Rule
    properties:
      description: example_rule
      resourceType: EBS_SNAPSHOT
      resourceTags:
        - resourceTagKey: tag_key
          resourceTagValue: tag_value
      retentionPeriod:
        retentionPeriodValue: 10
        retentionPeriodUnit: DAYS
      tags:
        test_tag_key: test_tag_value

Import

Using pulumi import, import RBin Rule using the id. For example:

$ pulumi import aws:rbin/rule:Rule example examplerule

Properties

arn

val arn: Output<String>

description

val description: Output<String>

The retention rule description.

val id: Output<String>

lockConfiguration

val lockConfiguration: Output<RuleLockConfiguration>?

Information about the retention rule lock configuration. See lock_configuration below.

lockEndTime

val lockEndTime: Output<String>

(Timestamp) The date and time at which the unlock delay is set to expire. Only returned for retention rules that have been unlocked and that are still within the unlock delay period.

lockState

val lockState: Output<String>

(Optional) The lock state of the retention rules to list. Only retention rules with the specified lock state are returned. Valid values are locked, pending_unlock, unlocked.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

resourceTags

val resourceTags: Output<List<RuleResourceTag>>

Specifies the resource tags to use to identify resources that are to be retained by a tag-level retention rule. See resource_tags below.

resourceType

val resourceType: Output<String>

The resource type to be retained by the retention rule. Valid values are EBS_SNAPSHOT and EC2_IMAGE.

retentionPeriod

val retentionPeriod: Output<RuleRetentionPeriod>

Information about the retention period for which the retention rule is to retain resources. See retention_period below. The following arguments are optional:

status

val status: Output<String>

(String) The state of the retention rule. Only retention rules that are in the available state retain resources. Valid values include pending and available.