azure.dataprotection.BackupInstanceBlogStorage

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",
        });
        var exampleBackupVault = new Azure.DataProtection.BackupVault("exampleBackupVault", new Azure.DataProtection.BackupVaultArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            Location = exampleResourceGroup.Location,
            DatastoreType = "VaultStore",
            Redundancy = "LocallyRedundant",
            Identity = new Azure.DataProtection.Inputs.BackupVaultIdentityArgs
            {
                Type = "SystemAssigned",
            },
        });
        var exampleAssignment = new Azure.Authorization.Assignment("exampleAssignment", new Azure.Authorization.AssignmentArgs
        {
            Scope = exampleAccount.Id,
            RoleDefinitionName = "Storage Account Backup Contributor Role",
            PrincipalId = exampleBackupVault.Identity.Apply(identity => identity?.PrincipalId),
        });
        var exampleBackupPolicyBlobStorage = new Azure.DataProtection.BackupPolicyBlobStorage("exampleBackupPolicyBlobStorage", new Azure.DataProtection.BackupPolicyBlobStorageArgs
        {
            VaultId = exampleBackupVault.Id,
            RetentionDuration = "P30D",
        });
        var exampleBackupInstanceBlogStorage = new Azure.DataProtection.BackupInstanceBlogStorage("exampleBackupInstanceBlogStorage", new Azure.DataProtection.BackupInstanceBlogStorageArgs
        {
            VaultId = exampleBackupVault.Id,
            Location = exampleResourceGroup.Location,
            StorageAccountId = exampleAccount.Id,
            BackupPolicyId = exampleBackupPolicyBlobStorage.Id,
        }, new CustomResourceOptions
        {
            DependsOn = 
            {
                exampleAssignment,
            },
        });
    }

}

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/authorization"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/dataprotection"
	"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"),
		})
		if err != nil {
			return err
		}
		exampleBackupVault, err := dataprotection.NewBackupVault(ctx, "exampleBackupVault", &dataprotection.BackupVaultArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			DatastoreType:     pulumi.String("VaultStore"),
			Redundancy:        pulumi.String("LocallyRedundant"),
			Identity: &dataprotection.BackupVaultIdentityArgs{
				Type: pulumi.String("SystemAssigned"),
			},
		})
		if err != nil {
			return err
		}
		exampleAssignment, err := authorization.NewAssignment(ctx, "exampleAssignment", &authorization.AssignmentArgs{
			Scope:              exampleAccount.ID(),
			RoleDefinitionName: pulumi.String("Storage Account Backup Contributor Role"),
			PrincipalId: exampleBackupVault.Identity.ApplyT(func(identity dataprotection.BackupVaultIdentity) (string, error) {
				return identity.PrincipalId, nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		exampleBackupPolicyBlobStorage, err := dataprotection.NewBackupPolicyBlobStorage(ctx, "exampleBackupPolicyBlobStorage", &dataprotection.BackupPolicyBlobStorageArgs{
			VaultId:           exampleBackupVault.ID(),
			RetentionDuration: pulumi.String("P30D"),
		})
		if err != nil {
			return err
		}
		_, err = dataprotection.NewBackupInstanceBlogStorage(ctx, "exampleBackupInstanceBlogStorage", &dataprotection.BackupInstanceBlogStorageArgs{
			VaultId:          exampleBackupVault.ID(),
			Location:         exampleResourceGroup.Location,
			StorageAccountId: exampleAccount.ID(),
			BackupPolicyId:   exampleBackupPolicyBlobStorage.ID(),
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleAssignment,
		}))
		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",
});
const exampleBackupVault = new azure.dataprotection.BackupVault("exampleBackupVault", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    datastoreType: "VaultStore",
    redundancy: "LocallyRedundant",
    identity: {
        type: "SystemAssigned",
    },
});
const exampleAssignment = new azure.authorization.Assignment("exampleAssignment", {
    scope: exampleAccount.id,
    roleDefinitionName: "Storage Account Backup Contributor Role",
    principalId: exampleBackupVault.identity.apply(identity => identity?.principalId),
});
const exampleBackupPolicyBlobStorage = new azure.dataprotection.BackupPolicyBlobStorage("exampleBackupPolicyBlobStorage", {
    vaultId: exampleBackupVault.id,
    retentionDuration: "P30D",
});
const exampleBackupInstanceBlogStorage = new azure.dataprotection.BackupInstanceBlogStorage("exampleBackupInstanceBlogStorage", {
    vaultId: exampleBackupVault.id,
    location: exampleResourceGroup.location,
    storageAccountId: exampleAccount.id,
    backupPolicyId: exampleBackupPolicyBlobStorage.id,
}, {
    dependsOn: [exampleAssignment],
});

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")
example_backup_vault = azure.dataprotection.BackupVault("exampleBackupVault",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    datastore_type="VaultStore",
    redundancy="LocallyRedundant",
    identity=azure.dataprotection.BackupVaultIdentityArgs(
        type="SystemAssigned",
    ))
example_assignment = azure.authorization.Assignment("exampleAssignment",
    scope=example_account.id,
    role_definition_name="Storage Account Backup Contributor Role",
    principal_id=example_backup_vault.identity.principal_id)
example_backup_policy_blob_storage = azure.dataprotection.BackupPolicyBlobStorage("exampleBackupPolicyBlobStorage",
    vault_id=example_backup_vault.id,
    retention_duration="P30D")
example_backup_instance_blog_storage = azure.dataprotection.BackupInstanceBlogStorage("exampleBackupInstanceBlogStorage",
    vault_id=example_backup_vault.id,
    location=example_resource_group.location,
    storage_account_id=example_account.id,
    backup_policy_id=example_backup_policy_blob_storage.id,
    opts=pulumi.ResourceOptions(depends_on=[example_assignment]))