dlm

package
v4.16.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 17, 2021 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type LifecyclePolicy 

type LifecyclePolicy struct {
	pulumi.CustomResourceState

	// Amazon Resource Name (ARN) of the DLM Lifecycle Policy.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// A description for the DLM lifecycle policy.
	Description pulumi.StringOutput `pulumi:"description"`
	// The ARN of an IAM role that is able to be assumed by the DLM service.
	ExecutionRoleArn pulumi.StringOutput `pulumi:"executionRoleArn"`
	// See the `policyDetails` configuration block. Max of 1.
	PolicyDetails LifecyclePolicyPolicyDetailsOutput `pulumi:"policyDetails"`
	// Whether the lifecycle policy should be enabled or disabled. `ENABLED` or `DISABLED` are valid values. Defaults to `ENABLED`.
	State pulumi.StringPtrOutput `pulumi:"state"`
	// Key-value map of resource tags. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
}

Provides a [Data Lifecycle Manager (DLM) lifecycle policy](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/snapshot-lifecycle.html) for managing snapshots.

## Example Usage

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/dlm"
"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/iam"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		dlmLifecycleRole, err := iam.NewRole(ctx, "dlmLifecycleRole", &iam.RoleArgs{
			AssumeRolePolicy: pulumi.Any(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "  \"Version\": \"2012-10-17\",\n", "  \"Statement\": [\n", "    {\n", "      \"Action\": \"sts:AssumeRole\",\n", "      \"Principal\": {\n", "        \"Service\": \"dlm.amazonaws.com\"\n", "      },\n", "      \"Effect\": \"Allow\",\n", "      \"Sid\": \"\"\n", "    }\n", "  ]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		_, err = iam.NewRolePolicy(ctx, "dlmLifecycle", &iam.RolePolicyArgs{
			Role:   dlmLifecycleRole.ID(),
			Policy: pulumi.Any(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "   \"Version\": \"2012-10-17\",\n", "   \"Statement\": [\n", "      {\n", "         \"Effect\": \"Allow\",\n", "         \"Action\": [\n", "            \"ec2:CreateSnapshot\",\n", "            \"ec2:CreateSnapshots\",\n", "            \"ec2:DeleteSnapshot\",\n", "            \"ec2:DescribeInstances\",\n", "            \"ec2:DescribeVolumes\",\n", "            \"ec2:DescribeSnapshots\"\n", "         ],\n", "         \"Resource\": \"*\"\n", "      },\n", "      {\n", "         \"Effect\": \"Allow\",\n", "         \"Action\": [\n", "            \"ec2:CreateTags\"\n", "         ],\n", "         \"Resource\": \"arn:aws:ec2:*::snapshot/*\"\n", "      }\n", "   ]\n", "}\n")),
		})
		if err != nil {
			return err
		}
		_, err = dlm.NewLifecyclePolicy(ctx, "example", &dlm.LifecyclePolicyArgs{
			Description:      pulumi.String("example DLM lifecycle policy"),
			ExecutionRoleArn: dlmLifecycleRole.Arn,
			State:            pulumi.String("ENABLED"),
			PolicyDetails: &dlm.LifecyclePolicyPolicyDetailsArgs{
				ResourceTypes: pulumi.StringArray{
					pulumi.String("VOLUME"),
				},
				Schedules: dlm.LifecyclePolicyPolicyDetailsScheduleArray{
					&dlm.LifecyclePolicyPolicyDetailsScheduleArgs{
						Name: pulumi.String("2 weeks of daily snapshots"),
						CreateRule: &dlm.LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs{
							Interval:     pulumi.Int(24),
							IntervalUnit: pulumi.String("HOURS"),
							Times: pulumi.String{
								"23:45",
							},
						},
						RetainRule: &dlm.LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs{
							Count: pulumi.Int(14),
						},
						TagsToAdd: pulumi.StringMap{
							"SnapshotCreator": pulumi.String("DLM"),
						},
						CopyTags: pulumi.Bool(false),
					},
				},
				TargetTags: pulumi.StringMap{
					"Snapshot": pulumi.String("true"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

DLM lifecyle policies can be imported by their policy ID

```sh 

$ pulumi import aws:dlm/lifecyclePolicy:LifecyclePolicy example policy-abcdef12345678901

```

func GetLifecyclePolicy 

func GetLifecyclePolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *LifecyclePolicyState, opts ...pulumi.ResourceOption) (*LifecyclePolicy, error)

GetLifecyclePolicy gets an existing LifecyclePolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewLifecyclePolicy 

func NewLifecyclePolicy(ctx *pulumi.Context,
	name string, args *LifecyclePolicyArgs, opts ...pulumi.ResourceOption) (*LifecyclePolicy, error)

NewLifecyclePolicy registers a new resource with the given unique name, arguments, and options.

func (*LifecyclePolicy) ElementType 

func (*LifecyclePolicy) ElementType() reflect.Type

func (*LifecyclePolicy) ToLifecyclePolicyOutput 

func (i *LifecyclePolicy) ToLifecyclePolicyOutput() LifecyclePolicyOutput

func (*LifecyclePolicy) ToLifecyclePolicyOutputWithContext 

func (i *LifecyclePolicy) ToLifecyclePolicyOutputWithContext(ctx context.Context) LifecyclePolicyOutput

func (*LifecyclePolicy) ToLifecyclePolicyPtrOutput 

func (i *LifecyclePolicy) ToLifecyclePolicyPtrOutput() LifecyclePolicyPtrOutput

func (*LifecyclePolicy) ToLifecyclePolicyPtrOutputWithContext 

func (i *LifecyclePolicy) ToLifecyclePolicyPtrOutputWithContext(ctx context.Context) LifecyclePolicyPtrOutput

type LifecyclePolicyArgs 

type LifecyclePolicyArgs struct {
	// A description for the DLM lifecycle policy.
	Description pulumi.StringInput
	// The ARN of an IAM role that is able to be assumed by the DLM service.
	ExecutionRoleArn pulumi.StringInput
	// See the `policyDetails` configuration block. Max of 1.
	PolicyDetails LifecyclePolicyPolicyDetailsInput
	// Whether the lifecycle policy should be enabled or disabled. `ENABLED` or `DISABLED` are valid values. Defaults to `ENABLED`.
	State pulumi.StringPtrInput
	// Key-value map of resource tags. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapInput
}

The set of arguments for constructing a LifecyclePolicy resource.

func (LifecyclePolicyArgs) ElementType 

func (LifecyclePolicyArgs) ElementType() reflect.Type

type LifecyclePolicyArray 

type LifecyclePolicyArray []LifecyclePolicyInput

func (LifecyclePolicyArray) ElementType 

func (LifecyclePolicyArray) ElementType() reflect.Type

func (LifecyclePolicyArray) ToLifecyclePolicyArrayOutput 

func (i LifecyclePolicyArray) ToLifecyclePolicyArrayOutput() LifecyclePolicyArrayOutput

func (LifecyclePolicyArray) ToLifecyclePolicyArrayOutputWithContext 

func (i LifecyclePolicyArray) ToLifecyclePolicyArrayOutputWithContext(ctx context.Context) LifecyclePolicyArrayOutput

type LifecyclePolicyArrayInput 

type LifecyclePolicyArrayInput interface {
	pulumi.Input

	ToLifecyclePolicyArrayOutput() LifecyclePolicyArrayOutput
	ToLifecyclePolicyArrayOutputWithContext(context.Context) LifecyclePolicyArrayOutput
}

LifecyclePolicyArrayInput is an input type that accepts LifecyclePolicyArray and LifecyclePolicyArrayOutput values. You can construct a concrete instance of `LifecyclePolicyArrayInput` via: 

LifecyclePolicyArray{ LifecyclePolicyArgs{...} }

type LifecyclePolicyArrayOutput 

type LifecyclePolicyArrayOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyArrayOutput) ElementType 

func (LifecyclePolicyArrayOutput) ElementType() reflect.Type

func (LifecyclePolicyArrayOutput) Index 

func (o LifecyclePolicyArrayOutput) Index(i pulumi.IntInput) LifecyclePolicyOutput

func (LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutput 

func (o LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutput() LifecyclePolicyArrayOutput

func (LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutputWithContext 

func (o LifecyclePolicyArrayOutput) ToLifecyclePolicyArrayOutputWithContext(ctx context.Context) LifecyclePolicyArrayOutput

type LifecyclePolicyInput 

type LifecyclePolicyInput interface {
	pulumi.Input

	ToLifecyclePolicyOutput() LifecyclePolicyOutput
	ToLifecyclePolicyOutputWithContext(ctx context.Context) LifecyclePolicyOutput
}

type LifecyclePolicyMap 

type LifecyclePolicyMap map[string]LifecyclePolicyInput

func (LifecyclePolicyMap) ElementType 

func (LifecyclePolicyMap) ElementType() reflect.Type

func (LifecyclePolicyMap) ToLifecyclePolicyMapOutput 

func (i LifecyclePolicyMap) ToLifecyclePolicyMapOutput() LifecyclePolicyMapOutput

func (LifecyclePolicyMap) ToLifecyclePolicyMapOutputWithContext 

func (i LifecyclePolicyMap) ToLifecyclePolicyMapOutputWithContext(ctx context.Context) LifecyclePolicyMapOutput

type LifecyclePolicyMapInput 

type LifecyclePolicyMapInput interface {
	pulumi.Input

	ToLifecyclePolicyMapOutput() LifecyclePolicyMapOutput
	ToLifecyclePolicyMapOutputWithContext(context.Context) LifecyclePolicyMapOutput
}

LifecyclePolicyMapInput is an input type that accepts LifecyclePolicyMap and LifecyclePolicyMapOutput values. You can construct a concrete instance of `LifecyclePolicyMapInput` via: 

LifecyclePolicyMap{ "key": LifecyclePolicyArgs{...} }

type LifecyclePolicyMapOutput 

type LifecyclePolicyMapOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyMapOutput) ElementType 

func (LifecyclePolicyMapOutput) ElementType() reflect.Type

func (LifecyclePolicyMapOutput) MapIndex 

func (o LifecyclePolicyMapOutput) MapIndex(k pulumi.StringInput) LifecyclePolicyOutput

func (LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutput 

func (o LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutput() LifecyclePolicyMapOutput

func (LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutputWithContext 

func (o LifecyclePolicyMapOutput) ToLifecyclePolicyMapOutputWithContext(ctx context.Context) LifecyclePolicyMapOutput

type LifecyclePolicyOutput 

type LifecyclePolicyOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyOutput) ElementType 

func (LifecyclePolicyOutput) ElementType() reflect.Type

func (LifecyclePolicyOutput) ToLifecyclePolicyOutput 

func (o LifecyclePolicyOutput) ToLifecyclePolicyOutput() LifecyclePolicyOutput

func (LifecyclePolicyOutput) ToLifecyclePolicyOutputWithContext 

func (o LifecyclePolicyOutput) ToLifecyclePolicyOutputWithContext(ctx context.Context) LifecyclePolicyOutput

func (LifecyclePolicyOutput) ToLifecyclePolicyPtrOutput 

func (o LifecyclePolicyOutput) ToLifecyclePolicyPtrOutput() LifecyclePolicyPtrOutput

func (LifecyclePolicyOutput) ToLifecyclePolicyPtrOutputWithContext 

func (o LifecyclePolicyOutput) ToLifecyclePolicyPtrOutputWithContext(ctx context.Context) LifecyclePolicyPtrOutput

type LifecyclePolicyPolicyDetails 

type LifecyclePolicyPolicyDetails struct {
	// A list of resource types that should be targeted by the lifecycle policy. `VOLUME` is currently the only allowed value.
	ResourceTypes []string `pulumi:"resourceTypes"`
	// See the `schedule` configuration block.
	Schedules []LifecyclePolicyPolicyDetailsSchedule `pulumi:"schedules"`
	// A map of tag keys and their values. Any resources that match the `resourceTypes` and are tagged with _any_ of these tags will be targeted.
	TargetTags map[string]string `pulumi:"targetTags"`
}

type LifecyclePolicyPolicyDetailsArgs 

type LifecyclePolicyPolicyDetailsArgs struct {
	// A list of resource types that should be targeted by the lifecycle policy. `VOLUME` is currently the only allowed value.
	ResourceTypes pulumi.StringArrayInput `pulumi:"resourceTypes"`
	// See the `schedule` configuration block.
	Schedules LifecyclePolicyPolicyDetailsScheduleArrayInput `pulumi:"schedules"`
	// A map of tag keys and their values. Any resources that match the `resourceTypes` and are tagged with _any_ of these tags will be targeted.
	TargetTags pulumi.StringMapInput `pulumi:"targetTags"`
}

func (LifecyclePolicyPolicyDetailsArgs) ElementType 

func (LifecyclePolicyPolicyDetailsArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsOutput 

func (i LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsOutput() LifecyclePolicyPolicyDetailsOutput

func (LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsOutputWithContext 

func (i LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsOutput

func (LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsPtrOutput 

func (i LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsPtrOutput() LifecyclePolicyPolicyDetailsPtrOutput

func (LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsPtrOutputWithContext 

func (i LifecyclePolicyPolicyDetailsArgs) ToLifecyclePolicyPolicyDetailsPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsPtrOutput

type LifecyclePolicyPolicyDetailsInput 

type LifecyclePolicyPolicyDetailsInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsOutput() LifecyclePolicyPolicyDetailsOutput
	ToLifecyclePolicyPolicyDetailsOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsOutput
}

LifecyclePolicyPolicyDetailsInput is an input type that accepts LifecyclePolicyPolicyDetailsArgs and LifecyclePolicyPolicyDetailsOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsInput` via: 

LifecyclePolicyPolicyDetailsArgs{...}

type LifecyclePolicyPolicyDetailsOutput 

type LifecyclePolicyPolicyDetailsOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsOutput) ElementType 

func (LifecyclePolicyPolicyDetailsOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsOutput) ResourceTypes 

func (o LifecyclePolicyPolicyDetailsOutput) ResourceTypes() pulumi.StringArrayOutput

A list of resource types that should be targeted by the lifecycle policy. `VOLUME` is currently the only allowed value.

func (LifecyclePolicyPolicyDetailsOutput) Schedules 

func (o LifecyclePolicyPolicyDetailsOutput) Schedules() LifecyclePolicyPolicyDetailsScheduleArrayOutput

See the `schedule` configuration block.

func (LifecyclePolicyPolicyDetailsOutput) TargetTags 

func (o LifecyclePolicyPolicyDetailsOutput) TargetTags() pulumi.StringMapOutput

A map of tag keys and their values. Any resources that match the `resourceTypes` and are tagged with _any_ of these tags will be targeted.

func (LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsOutput 

func (o LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsOutput() LifecyclePolicyPolicyDetailsOutput

func (LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsOutputWithContext 

func (o LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsOutput

func (LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsPtrOutput 

func (o LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsPtrOutput() LifecyclePolicyPolicyDetailsPtrOutput

func (LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsPtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsOutput) ToLifecyclePolicyPolicyDetailsPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsPtrOutput

type LifecyclePolicyPolicyDetailsPtrInput 

type LifecyclePolicyPolicyDetailsPtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsPtrOutput() LifecyclePolicyPolicyDetailsPtrOutput
	ToLifecyclePolicyPolicyDetailsPtrOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsPtrOutput
}

LifecyclePolicyPolicyDetailsPtrInput is an input type that accepts LifecyclePolicyPolicyDetailsArgs, LifecyclePolicyPolicyDetailsPtr and LifecyclePolicyPolicyDetailsPtrOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsPtrInput` via: 

        LifecyclePolicyPolicyDetailsArgs{...}

or:

        nil

func LifecyclePolicyPolicyDetailsPtr 

func LifecyclePolicyPolicyDetailsPtr(v *LifecyclePolicyPolicyDetailsArgs) LifecyclePolicyPolicyDetailsPtrInput

type LifecyclePolicyPolicyDetailsPtrOutput 

type LifecyclePolicyPolicyDetailsPtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsPtrOutput) Elem 

func (o LifecyclePolicyPolicyDetailsPtrOutput) Elem() LifecyclePolicyPolicyDetailsOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) ElementType 

func (LifecyclePolicyPolicyDetailsPtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsPtrOutput) ResourceTypes 

func (o LifecyclePolicyPolicyDetailsPtrOutput) ResourceTypes() pulumi.StringArrayOutput

A list of resource types that should be targeted by the lifecycle policy. `VOLUME` is currently the only allowed value.

func (LifecyclePolicyPolicyDetailsPtrOutput) Schedules 

func (o LifecyclePolicyPolicyDetailsPtrOutput) Schedules() LifecyclePolicyPolicyDetailsScheduleArrayOutput

See the `schedule` configuration block.

func (LifecyclePolicyPolicyDetailsPtrOutput) TargetTags 

func (o LifecyclePolicyPolicyDetailsPtrOutput) TargetTags() pulumi.StringMapOutput

A map of tag keys and their values. Any resources that match the `resourceTypes` and are tagged with _any_ of these tags will be targeted.

func (LifecyclePolicyPolicyDetailsPtrOutput) ToLifecyclePolicyPolicyDetailsPtrOutput 

func (o LifecyclePolicyPolicyDetailsPtrOutput) ToLifecyclePolicyPolicyDetailsPtrOutput() LifecyclePolicyPolicyDetailsPtrOutput

func (LifecyclePolicyPolicyDetailsPtrOutput) ToLifecyclePolicyPolicyDetailsPtrOutputWithContext 

func (o LifecyclePolicyPolicyDetailsPtrOutput) ToLifecyclePolicyPolicyDetailsPtrOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsPtrOutput

type LifecyclePolicyPolicyDetailsSchedule 

type LifecyclePolicyPolicyDetailsSchedule struct {
	// Copy all user-defined tags on a source volume to snapshots of the volume created by this policy.
	CopyTags *bool `pulumi:"copyTags"`
	// See the `createRule` block. Max of 1 per schedule.
	CreateRule LifecyclePolicyPolicyDetailsScheduleCreateRule `pulumi:"createRule"`
	// A name for the schedule.
	Name string `pulumi:"name"`
	// See the `retainRule` block. Max of 1 per schedule.
	RetainRule LifecyclePolicyPolicyDetailsScheduleRetainRule `pulumi:"retainRule"`
	// A map of tag keys and their values. DLM lifecycle policies will already tag the snapshot with the tags on the volume. This configuration adds extra tags on top of these.
	TagsToAdd map[string]string `pulumi:"tagsToAdd"`
}

type LifecyclePolicyPolicyDetailsScheduleArgs 

type LifecyclePolicyPolicyDetailsScheduleArgs struct {
	// Copy all user-defined tags on a source volume to snapshots of the volume created by this policy.
	CopyTags pulumi.BoolPtrInput `pulumi:"copyTags"`
	// See the `createRule` block. Max of 1 per schedule.
	CreateRule LifecyclePolicyPolicyDetailsScheduleCreateRuleInput `pulumi:"createRule"`
	// A name for the schedule.
	Name pulumi.StringInput `pulumi:"name"`
	// See the `retainRule` block. Max of 1 per schedule.
	RetainRule LifecyclePolicyPolicyDetailsScheduleRetainRuleInput `pulumi:"retainRule"`
	// A map of tag keys and their values. DLM lifecycle policies will already tag the snapshot with the tags on the volume. This configuration adds extra tags on top of these.
	TagsToAdd pulumi.StringMapInput `pulumi:"tagsToAdd"`
}

func (LifecyclePolicyPolicyDetailsScheduleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArgs) ToLifecyclePolicyPolicyDetailsScheduleOutput 

func (i LifecyclePolicyPolicyDetailsScheduleArgs) ToLifecyclePolicyPolicyDetailsScheduleOutput() LifecyclePolicyPolicyDetailsScheduleOutput

func (LifecyclePolicyPolicyDetailsScheduleArgs) ToLifecyclePolicyPolicyDetailsScheduleOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleArgs) ToLifecyclePolicyPolicyDetailsScheduleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleOutput

type LifecyclePolicyPolicyDetailsScheduleArray 

type LifecyclePolicyPolicyDetailsScheduleArray []LifecyclePolicyPolicyDetailsScheduleInput

func (LifecyclePolicyPolicyDetailsScheduleArray) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleArray) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArray) ToLifecyclePolicyPolicyDetailsScheduleArrayOutput 

func (i LifecyclePolicyPolicyDetailsScheduleArray) ToLifecyclePolicyPolicyDetailsScheduleArrayOutput() LifecyclePolicyPolicyDetailsScheduleArrayOutput

func (LifecyclePolicyPolicyDetailsScheduleArray) ToLifecyclePolicyPolicyDetailsScheduleArrayOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleArray) ToLifecyclePolicyPolicyDetailsScheduleArrayOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArrayOutput

type LifecyclePolicyPolicyDetailsScheduleArrayInput 

type LifecyclePolicyPolicyDetailsScheduleArrayInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleArrayOutput() LifecyclePolicyPolicyDetailsScheduleArrayOutput
	ToLifecyclePolicyPolicyDetailsScheduleArrayOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleArrayOutput
}

LifecyclePolicyPolicyDetailsScheduleArrayInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleArray and LifecyclePolicyPolicyDetailsScheduleArrayOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleArrayInput` via: 

LifecyclePolicyPolicyDetailsScheduleArray{ LifecyclePolicyPolicyDetailsScheduleArgs{...} }

type LifecyclePolicyPolicyDetailsScheduleArrayOutput 

type LifecyclePolicyPolicyDetailsScheduleArrayOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleArrayOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleArrayOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleArrayOutput) Index 

func (o LifecyclePolicyPolicyDetailsScheduleArrayOutput) Index(i pulumi.IntInput) LifecyclePolicyPolicyDetailsScheduleOutput

func (LifecyclePolicyPolicyDetailsScheduleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleArrayOutput 

func (o LifecyclePolicyPolicyDetailsScheduleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleArrayOutput() LifecyclePolicyPolicyDetailsScheduleArrayOutput

func (LifecyclePolicyPolicyDetailsScheduleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleArrayOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleArrayOutput) ToLifecyclePolicyPolicyDetailsScheduleArrayOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleArrayOutput

type LifecyclePolicyPolicyDetailsScheduleCreateRule 

type LifecyclePolicyPolicyDetailsScheduleCreateRule struct {
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values.
	Interval int `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value.
	IntervalUnit *string `pulumi:"intervalUnit"`
	// A list of times in 24 hour clock format that sets when the lifecycle policy should be evaluated. Max of 1.
	Times *string `pulumi:"times"`
}

type LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs struct {
	// How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values.
	Interval pulumi.IntInput `pulumi:"interval"`
	// The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value.
	IntervalUnit pulumi.StringPtrInput `pulumi:"intervalUnit"`
	// A list of times in 24 hour clock format that sets when the lifecycle policy should be evaluated. Max of 1.
	Times pulumi.StringPtrInput `pulumi:"times"`
}

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutput 

func (i LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutput() LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput

type LifecyclePolicyPolicyDetailsScheduleCreateRuleInput 

type LifecyclePolicyPolicyDetailsScheduleCreateRuleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutput() LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput
	ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput
}

LifecyclePolicyPolicyDetailsScheduleCreateRuleInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs and LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleCreateRuleInput` via: 

LifecyclePolicyPolicyDetailsScheduleCreateRuleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput 

type LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) Interval 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) Interval() pulumi.IntOutput

How often this lifecycle policy should be evaluated. `1`, `2`,`3`,`4`,`6`,`8`,`12` or `24` are valid values.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) IntervalUnit 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) IntervalUnit() pulumi.StringPtrOutput

The unit for how often the lifecycle policy should be evaluated. `HOURS` is currently the only allowed value and also the default value.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) Times 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) Times() pulumi.StringPtrOutput

A list of times in 24 hour clock format that sets when the lifecycle policy should be evaluated. Max of 1.

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutput 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutput() LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleCreateRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput

type LifecyclePolicyPolicyDetailsScheduleInput 

type LifecyclePolicyPolicyDetailsScheduleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleOutput() LifecyclePolicyPolicyDetailsScheduleOutput
	ToLifecyclePolicyPolicyDetailsScheduleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleOutput
}

LifecyclePolicyPolicyDetailsScheduleInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleArgs and LifecyclePolicyPolicyDetailsScheduleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleInput` via: 

LifecyclePolicyPolicyDetailsScheduleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleOutput 

type LifecyclePolicyPolicyDetailsScheduleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleOutput) CopyTags 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) CopyTags() pulumi.BoolPtrOutput

Copy all user-defined tags on a source volume to snapshots of the volume created by this policy.

func (LifecyclePolicyPolicyDetailsScheduleOutput) CreateRule 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) CreateRule() LifecyclePolicyPolicyDetailsScheduleCreateRuleOutput

See the `createRule` block. Max of 1 per schedule.

func (LifecyclePolicyPolicyDetailsScheduleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleOutput) Name 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) Name() pulumi.StringOutput

A name for the schedule.

func (LifecyclePolicyPolicyDetailsScheduleOutput) RetainRule 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) RetainRule() LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput

See the `retainRule` block. Max of 1 per schedule.

func (LifecyclePolicyPolicyDetailsScheduleOutput) TagsToAdd 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) TagsToAdd() pulumi.StringMapOutput

A map of tag keys and their values. DLM lifecycle policies will already tag the snapshot with the tags on the volume. This configuration adds extra tags on top of these.

func (LifecyclePolicyPolicyDetailsScheduleOutput) ToLifecyclePolicyPolicyDetailsScheduleOutput 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) ToLifecyclePolicyPolicyDetailsScheduleOutput() LifecyclePolicyPolicyDetailsScheduleOutput

func (LifecyclePolicyPolicyDetailsScheduleOutput) ToLifecyclePolicyPolicyDetailsScheduleOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleOutput) ToLifecyclePolicyPolicyDetailsScheduleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleOutput

type LifecyclePolicyPolicyDetailsScheduleRetainRule 

type LifecyclePolicyPolicyDetailsScheduleRetainRule struct {
	// How many snapshots to keep. Must be an integer between 1 and 1000.
	Count int `pulumi:"count"`
}

type LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs 

type LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs struct {
	// How many snapshots to keep. Must be an integer between 1 and 1000.
	Count pulumi.IntInput `pulumi:"count"`
}

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutput 

func (i LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutput() LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutputWithContext 

func (i LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput

type LifecyclePolicyPolicyDetailsScheduleRetainRuleInput 

type LifecyclePolicyPolicyDetailsScheduleRetainRuleInput interface {
	pulumi.Input

	ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutput() LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput
	ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutputWithContext(context.Context) LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput
}

LifecyclePolicyPolicyDetailsScheduleRetainRuleInput is an input type that accepts LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs and LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput values. You can construct a concrete instance of `LifecyclePolicyPolicyDetailsScheduleRetainRuleInput` via: 

LifecyclePolicyPolicyDetailsScheduleRetainRuleArgs{...}

type LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput 

type LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) Count 

func (o LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) Count() pulumi.IntOutput

How many snapshots to keep. Must be an integer between 1 and 1000.

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) ElementType 

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) ElementType() reflect.Type

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutput 

func (o LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutput() LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput

func (LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutputWithContext 

func (o LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput) ToLifecyclePolicyPolicyDetailsScheduleRetainRuleOutputWithContext(ctx context.Context) LifecyclePolicyPolicyDetailsScheduleRetainRuleOutput

type LifecyclePolicyPtrInput 

type LifecyclePolicyPtrInput interface {
	pulumi.Input

	ToLifecyclePolicyPtrOutput() LifecyclePolicyPtrOutput
	ToLifecyclePolicyPtrOutputWithContext(ctx context.Context) LifecyclePolicyPtrOutput
}

type LifecyclePolicyPtrOutput 

type LifecyclePolicyPtrOutput struct{ *pulumi.OutputState }

func (LifecyclePolicyPtrOutput) Elem added in v4.15.0 

func (o LifecyclePolicyPtrOutput) Elem() LifecyclePolicyOutput

func (LifecyclePolicyPtrOutput) ElementType 

func (LifecyclePolicyPtrOutput) ElementType() reflect.Type

func (LifecyclePolicyPtrOutput) ToLifecyclePolicyPtrOutput 

func (o LifecyclePolicyPtrOutput) ToLifecyclePolicyPtrOutput() LifecyclePolicyPtrOutput

func (LifecyclePolicyPtrOutput) ToLifecyclePolicyPtrOutputWithContext 

func (o LifecyclePolicyPtrOutput) ToLifecyclePolicyPtrOutputWithContext(ctx context.Context) LifecyclePolicyPtrOutput

type LifecyclePolicyState 

type LifecyclePolicyState struct {
	// Amazon Resource Name (ARN) of the DLM Lifecycle Policy.
	Arn pulumi.StringPtrInput
	// A description for the DLM lifecycle policy.
	Description pulumi.StringPtrInput
	// The ARN of an IAM role that is able to be assumed by the DLM service.
	ExecutionRoleArn pulumi.StringPtrInput
	// See the `policyDetails` configuration block. Max of 1.
	PolicyDetails LifecyclePolicyPolicyDetailsPtrInput
	// Whether the lifecycle policy should be enabled or disabled. `ENABLED` or `DISABLED` are valid values. Defaults to `ENABLED`.
	State pulumi.StringPtrInput
	// Key-value map of resource tags. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapInput
}

func (LifecyclePolicyState) ElementType 

func (LifecyclePolicyState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.