azure.storage.ManagementPolicy

using Pulumi;
using Azure = Pulumi.Azure;

class MyStack : Stack
{
    public MyStack()
    {
        var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new Azure.Core.ResourceGroupArgs
        {
            Location = "West Europe",
        });
        var exampleAccount = new Azure.Storage.Account("exampleAccount", new Azure.Storage.AccountArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            Location = exampleResourceGroup.Location,
            AccountTier = "Standard",
            AccountReplicationType = "LRS",
            AccountKind = "BlobStorage",
        });
        var exampleManagementPolicy = new Azure.Storage.ManagementPolicy("exampleManagementPolicy", new Azure.Storage.ManagementPolicyArgs
        {
            StorageAccountId = exampleAccount.Id,
            Rules = 
            {
                new Azure.Storage.Inputs.ManagementPolicyRuleArgs
                {
                    Name = "rule1",
                    Enabled = true,
                    Filters = new Azure.Storage.Inputs.ManagementPolicyRuleFiltersArgs
                    {
                        PrefixMatches = 
                        {
                            "container1/prefix1",
                        },
                        BlobTypes = 
                        {
                            "blockBlob",
                        },
                        MatchBlobIndexTags = 
                        {
                            new Azure.Storage.Inputs.ManagementPolicyRuleFiltersMatchBlobIndexTagArgs
                            {
                                Name = "tag1",
                                Operation = "==",
                                Value = "val1",
                            },
                        },
                    },
                    Actions = new Azure.Storage.Inputs.ManagementPolicyRuleActionsArgs
                    {
                        BaseBlob = new Azure.Storage.Inputs.ManagementPolicyRuleActionsBaseBlobArgs
                        {
                            TierToCoolAfterDaysSinceModificationGreaterThan = 10,
                            TierToArchiveAfterDaysSinceModificationGreaterThan = 50,
                            DeleteAfterDaysSinceModificationGreaterThan = 100,
                        },
                        Snapshot = new Azure.Storage.Inputs.ManagementPolicyRuleActionsSnapshotArgs
                        {
                            DeleteAfterDaysSinceCreationGreaterThan = 30,
                        },
                    },
                },
                new Azure.Storage.Inputs.ManagementPolicyRuleArgs
                {
                    Name = "rule2",
                    Enabled = false,
                    Filters = new Azure.Storage.Inputs.ManagementPolicyRuleFiltersArgs
                    {
                        PrefixMatches = 
                        {
                            "container2/prefix1",
                            "container2/prefix2",
                        },
                        BlobTypes = 
                        {
                            "blockBlob",
                        },
                    },
                    Actions = new Azure.Storage.Inputs.ManagementPolicyRuleActionsArgs
                    {
                        BaseBlob = new Azure.Storage.Inputs.ManagementPolicyRuleActionsBaseBlobArgs
                        {
                            TierToCoolAfterDaysSinceModificationGreaterThan = 11,
                            TierToArchiveAfterDaysSinceModificationGreaterThan = 51,
                            DeleteAfterDaysSinceModificationGreaterThan = 101,
                        },
                        Snapshot = new Azure.Storage.Inputs.ManagementPolicyRuleActionsSnapshotArgs
                        {
                            ChangeTierToArchiveAfterDaysSinceCreation = 90,
                            ChangeTierToCoolAfterDaysSinceCreation = 23,
                            DeleteAfterDaysSinceCreationGreaterThan = 31,
                        },
                        Version = new Azure.Storage.Inputs.ManagementPolicyRuleActionsVersionArgs
                        {
                            ChangeTierToArchiveAfterDaysSinceCreation = 9,
                            ChangeTierToCoolAfterDaysSinceCreation = 90,
                            DeleteAfterDaysSinceCreation = 3,
                        },
                    },
                },
            },
        });
    }

}

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleAccount, err := storage.NewAccount(ctx, "exampleAccount", &storage.AccountArgs{
			ResourceGroupName:      exampleResourceGroup.Name,
			Location:               exampleResourceGroup.Location,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("LRS"),
			AccountKind:            pulumi.String("BlobStorage"),
		})
		if err != nil {
			return err
		}
		_, err = storage.NewManagementPolicy(ctx, "exampleManagementPolicy", &storage.ManagementPolicyArgs{
			StorageAccountId: exampleAccount.ID(),
			Rules: storage.ManagementPolicyRuleArray{
				&storage.ManagementPolicyRuleArgs{
					Name:    pulumi.String("rule1"),
					Enabled: pulumi.Bool(true),
					Filters: &storage.ManagementPolicyRuleFiltersArgs{
						PrefixMatches: pulumi.StringArray{
							pulumi.String("container1/prefix1"),
						},
						BlobTypes: pulumi.StringArray{
							pulumi.String("blockBlob"),
						},
						MatchBlobIndexTags: storage.ManagementPolicyRuleFiltersMatchBlobIndexTagArray{
							&storage.ManagementPolicyRuleFiltersMatchBlobIndexTagArgs{
								Name:      pulumi.String("tag1"),
								Operation: pulumi.String("=="),
								Value:     pulumi.String("val1"),
							},
						},
					},
					Actions: &storage.ManagementPolicyRuleActionsArgs{
						BaseBlob: &storage.ManagementPolicyRuleActionsBaseBlobArgs{
							TierToCoolAfterDaysSinceModificationGreaterThan:    pulumi.Int(10),
							TierToArchiveAfterDaysSinceModificationGreaterThan: pulumi.Int(50),
							DeleteAfterDaysSinceModificationGreaterThan:        pulumi.Int(100),
						},
						Snapshot: &storage.ManagementPolicyRuleActionsSnapshotArgs{
							DeleteAfterDaysSinceCreationGreaterThan: pulumi.Int(30),
						},
					},
				},
				&storage.ManagementPolicyRuleArgs{
					Name:    pulumi.String("rule2"),
					Enabled: pulumi.Bool(false),
					Filters: &storage.ManagementPolicyRuleFiltersArgs{
						PrefixMatches: pulumi.StringArray{
							pulumi.String("container2/prefix1"),
							pulumi.String("container2/prefix2"),
						},
						BlobTypes: pulumi.StringArray{
							pulumi.String("blockBlob"),
						},
					},
					Actions: &storage.ManagementPolicyRuleActionsArgs{
						BaseBlob: &storage.ManagementPolicyRuleActionsBaseBlobArgs{
							TierToCoolAfterDaysSinceModificationGreaterThan:    pulumi.Int(11),
							TierToArchiveAfterDaysSinceModificationGreaterThan: pulumi.Int(51),
							DeleteAfterDaysSinceModificationGreaterThan:        pulumi.Int(101),
						},
						Snapshot: &storage.ManagementPolicyRuleActionsSnapshotArgs{
							ChangeTierToArchiveAfterDaysSinceCreation: pulumi.Int(90),
							ChangeTierToCoolAfterDaysSinceCreation:    pulumi.Int(23),
							DeleteAfterDaysSinceCreationGreaterThan:   pulumi.Int(31),
						},
						Version: &storage.ManagementPolicyRuleActionsVersionArgs{
							ChangeTierToArchiveAfterDaysSinceCreation: pulumi.Int(9),
							ChangeTierToCoolAfterDaysSinceCreation:    pulumi.Int(90),
							DeleteAfterDaysSinceCreation:              pulumi.Int(3),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";

const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {location: "West Europe"});
const exampleAccount = new azure.storage.Account("exampleAccount", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    accountTier: "Standard",
    accountReplicationType: "LRS",
    accountKind: "BlobStorage",
});
const exampleManagementPolicy = new azure.storage.ManagementPolicy("exampleManagementPolicy", {
    storageAccountId: exampleAccount.id,
    rules: [
        {
            name: "rule1",
            enabled: true,
            filters: {
                prefixMatches: ["container1/prefix1"],
                blobTypes: ["blockBlob"],
                matchBlobIndexTags: [{
                    name: "tag1",
                    operation: "==",
                    value: "val1",
                }],
            },
            actions: {
                baseBlob: {
                    tierToCoolAfterDaysSinceModificationGreaterThan: 10,
                    tierToArchiveAfterDaysSinceModificationGreaterThan: 50,
                    deleteAfterDaysSinceModificationGreaterThan: 100,
                },
                snapshot: {
                    deleteAfterDaysSinceCreationGreaterThan: 30,
                },
            },
        },
        {
            name: "rule2",
            enabled: false,
            filters: {
                prefixMatches: [
                    "container2/prefix1",
                    "container2/prefix2",
                ],
                blobTypes: ["blockBlob"],
            },
            actions: {
                baseBlob: {
                    tierToCoolAfterDaysSinceModificationGreaterThan: 11,
                    tierToArchiveAfterDaysSinceModificationGreaterThan: 51,
                    deleteAfterDaysSinceModificationGreaterThan: 101,
                },
                snapshot: {
                    changeTierToArchiveAfterDaysSinceCreation: 90,
                    changeTierToCoolAfterDaysSinceCreation: 23,
                    deleteAfterDaysSinceCreationGreaterThan: 31,
                },
                version: {
                    changeTierToArchiveAfterDaysSinceCreation: 9,
                    changeTierToCoolAfterDaysSinceCreation: 90,
                    deleteAfterDaysSinceCreation: 3,
                },
            },
        },
    ],
});

import pulumi
import pulumi_azure as azure

example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe")
example_account = azure.storage.Account("exampleAccount",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    account_tier="Standard",
    account_replication_type="LRS",
    account_kind="BlobStorage")
example_management_policy = azure.storage.ManagementPolicy("exampleManagementPolicy",
    storage_account_id=example_account.id,
    rules=[
        azure.storage.ManagementPolicyRuleArgs(
            name="rule1",
            enabled=True,
            filters=azure.storage.ManagementPolicyRuleFiltersArgs(
                prefix_matches=["container1/prefix1"],
                blob_types=["blockBlob"],
                match_blob_index_tags=[azure.storage.ManagementPolicyRuleFiltersMatchBlobIndexTagArgs(
                    name="tag1",
                    operation="==",
                    value="val1",
                )],
            ),
            actions=azure.storage.ManagementPolicyRuleActionsArgs(
                base_blob=azure.storage.ManagementPolicyRuleActionsBaseBlobArgs(
                    tier_to_cool_after_days_since_modification_greater_than=10,
                    tier_to_archive_after_days_since_modification_greater_than=50,
                    delete_after_days_since_modification_greater_than=100,
                ),
                snapshot=azure.storage.ManagementPolicyRuleActionsSnapshotArgs(
                    delete_after_days_since_creation_greater_than=30,
                ),
            ),
        ),
        azure.storage.ManagementPolicyRuleArgs(
            name="rule2",
            enabled=False,
            filters=azure.storage.ManagementPolicyRuleFiltersArgs(
                prefix_matches=[
                    "container2/prefix1",
                    "container2/prefix2",
                ],
                blob_types=["blockBlob"],
            ),
            actions=azure.storage.ManagementPolicyRuleActionsArgs(
                base_blob=azure.storage.ManagementPolicyRuleActionsBaseBlobArgs(
                    tier_to_cool_after_days_since_modification_greater_than=11,
                    tier_to_archive_after_days_since_modification_greater_than=51,
                    delete_after_days_since_modification_greater_than=101,
                ),
                snapshot=azure.storage.ManagementPolicyRuleActionsSnapshotArgs(
                    change_tier_to_archive_after_days_since_creation=90,
                    change_tier_to_cool_after_days_since_creation=23,
                    delete_after_days_since_creation_greater_than=31,
                ),
                version=azure.storage.ManagementPolicyRuleActionsVersionArgs(
                    change_tier_to_archive_after_days_since_creation=9,
                    change_tier_to_cool_after_days_since_creation=90,
                    delete_after_days_since_creation=3,
                ),
            ),
        ),
    ])