azure.dataprotection.BackupInstanceDisk

using Pulumi;
using Azure = Pulumi.Azure;

class MyStack : Stack
{
    public MyStack()
    {
        var rg = new Azure.Core.ResourceGroup("rg", new Azure.Core.ResourceGroupArgs
        {
            Location = "West Europe",
        });
        var exampleManagedDisk = new Azure.Compute.ManagedDisk("exampleManagedDisk", new Azure.Compute.ManagedDiskArgs
        {
            Location = rg.Location,
            ResourceGroupName = rg.Name,
            StorageAccountType = "Standard_LRS",
            CreateOption = "Empty",
            DiskSizeGb = 1,
        });
        var exampleBackupVault = new Azure.DataProtection.BackupVault("exampleBackupVault", new Azure.DataProtection.BackupVaultArgs
        {
            ResourceGroupName = rg.Name,
            Location = rg.Location,
            DatastoreType = "VaultStore",
            Redundancy = "LocallyRedundant",
            Identity = new Azure.DataProtection.Inputs.BackupVaultIdentityArgs
            {
                Type = "SystemAssigned",
            },
        });
        var example1 = new Azure.Authorization.Assignment("example1", new Azure.Authorization.AssignmentArgs
        {
            Scope = rg.Id,
            RoleDefinitionName = "Disk Snapshot Contributor",
            PrincipalId = exampleBackupVault.Identity.Apply(identity => identity?.PrincipalId),
        });
        var example2 = new Azure.Authorization.Assignment("example2", new Azure.Authorization.AssignmentArgs
        {
            Scope = exampleManagedDisk.Id,
            RoleDefinitionName = "Disk Backup Reader",
            PrincipalId = exampleBackupVault.Identity.Apply(identity => identity?.PrincipalId),
        });
        var exampleBackupPolicyDisk = new Azure.DataProtection.BackupPolicyDisk("exampleBackupPolicyDisk", new Azure.DataProtection.BackupPolicyDiskArgs
        {
            VaultId = exampleBackupVault.Id,
            BackupRepeatingTimeIntervals = 
            {
                "R/2021-05-19T06:33:16+00:00/PT4H",
            },
            DefaultRetentionDuration = "P7D",
        });
        var exampleBackupInstanceDisk = new Azure.DataProtection.BackupInstanceDisk("exampleBackupInstanceDisk", new Azure.DataProtection.BackupInstanceDiskArgs
        {
            Location = exampleBackupVault.Location,
            VaultId = exampleBackupVault.Id,
            DiskId = exampleManagedDisk.Id,
            SnapshotResourceGroupName = rg.Name,
            BackupPolicyId = exampleBackupPolicyDisk.Id,
        });
    }

}

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		rg, err := core.NewResourceGroup(ctx, "rg", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleManagedDisk, err := compute.NewManagedDisk(ctx, "exampleManagedDisk", &compute.ManagedDiskArgs{
			Location:           rg.Location,
			ResourceGroupName:  rg.Name,
			StorageAccountType: pulumi.String("Standard_LRS"),
			CreateOption:       pulumi.String("Empty"),
			DiskSizeGb:         pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		exampleBackupVault, err := dataprotection.NewBackupVault(ctx, "exampleBackupVault", &dataprotection.BackupVaultArgs{
			ResourceGroupName: rg.Name,
			Location:          rg.Location,
			DatastoreType:     pulumi.String("VaultStore"),
			Redundancy:        pulumi.String("LocallyRedundant"),
			Identity: &dataprotection.BackupVaultIdentityArgs{
				Type: pulumi.String("SystemAssigned"),
			},
		})
		if err != nil {
			return err
		}
		_, err = authorization.NewAssignment(ctx, "example1", &authorization.AssignmentArgs{
			Scope:              rg.ID(),
			RoleDefinitionName: pulumi.String("Disk Snapshot Contributor"),
			PrincipalId: exampleBackupVault.Identity.ApplyT(func(identity dataprotection.BackupVaultIdentity) (string, error) {
				return identity.PrincipalId, nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		_, err = authorization.NewAssignment(ctx, "example2", &authorization.AssignmentArgs{
			Scope:              exampleManagedDisk.ID(),
			RoleDefinitionName: pulumi.String("Disk Backup Reader"),
			PrincipalId: exampleBackupVault.Identity.ApplyT(func(identity dataprotection.BackupVaultIdentity) (string, error) {
				return identity.PrincipalId, nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		exampleBackupPolicyDisk, err := dataprotection.NewBackupPolicyDisk(ctx, "exampleBackupPolicyDisk", &dataprotection.BackupPolicyDiskArgs{
			VaultId: exampleBackupVault.ID(),
			BackupRepeatingTimeIntervals: pulumi.StringArray{
				pulumi.String("R/2021-05-19T06:33:16+00:00/PT4H"),
			},
			DefaultRetentionDuration: pulumi.String("P7D"),
		})
		if err != nil {
			return err
		}
		_, err = dataprotection.NewBackupInstanceDisk(ctx, "exampleBackupInstanceDisk", &dataprotection.BackupInstanceDiskArgs{
			Location:                  exampleBackupVault.Location,
			VaultId:                   exampleBackupVault.ID(),
			DiskId:                    exampleManagedDisk.ID(),
			SnapshotResourceGroupName: rg.Name,
			BackupPolicyId:            exampleBackupPolicyDisk.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

const rg = new azure.core.ResourceGroup("rg", {location: "West Europe"});
const exampleManagedDisk = new azure.compute.ManagedDisk("exampleManagedDisk", {
    location: rg.location,
    resourceGroupName: rg.name,
    storageAccountType: "Standard_LRS",
    createOption: "Empty",
    diskSizeGb: "1",
});
const exampleBackupVault = new azure.dataprotection.BackupVault("exampleBackupVault", {
    resourceGroupName: rg.name,
    location: rg.location,
    datastoreType: "VaultStore",
    redundancy: "LocallyRedundant",
    identity: {
        type: "SystemAssigned",
    },
});
const example1 = new azure.authorization.Assignment("example1", {
    scope: rg.id,
    roleDefinitionName: "Disk Snapshot Contributor",
    principalId: exampleBackupVault.identity.apply(identity => identity?.principalId),
});
const example2 = new azure.authorization.Assignment("example2", {
    scope: exampleManagedDisk.id,
    roleDefinitionName: "Disk Backup Reader",
    principalId: exampleBackupVault.identity.apply(identity => identity?.principalId),
});
const exampleBackupPolicyDisk = new azure.dataprotection.BackupPolicyDisk("exampleBackupPolicyDisk", {
    vaultId: exampleBackupVault.id,
    backupRepeatingTimeIntervals: ["R/2021-05-19T06:33:16+00:00/PT4H"],
    defaultRetentionDuration: "P7D",
});
const exampleBackupInstanceDisk = new azure.dataprotection.BackupInstanceDisk("exampleBackupInstanceDisk", {
    location: exampleBackupVault.location,
    vaultId: exampleBackupVault.id,
    diskId: exampleManagedDisk.id,
    snapshotResourceGroupName: rg.name,
    backupPolicyId: exampleBackupPolicyDisk.id,
});

import pulumi
import pulumi_azure as azure

rg = azure.core.ResourceGroup("rg", location="West Europe")
example_managed_disk = azure.compute.ManagedDisk("exampleManagedDisk",
    location=rg.location,
    resource_group_name=rg.name,
    storage_account_type="Standard_LRS",
    create_option="Empty",
    disk_size_gb=1)
example_backup_vault = azure.dataprotection.BackupVault("exampleBackupVault",
    resource_group_name=rg.name,
    location=rg.location,
    datastore_type="VaultStore",
    redundancy="LocallyRedundant",
    identity=azure.dataprotection.BackupVaultIdentityArgs(
        type="SystemAssigned",
    ))
example1 = azure.authorization.Assignment("example1",
    scope=rg.id,
    role_definition_name="Disk Snapshot Contributor",
    principal_id=example_backup_vault.identity.principal_id)
example2 = azure.authorization.Assignment("example2",
    scope=example_managed_disk.id,
    role_definition_name="Disk Backup Reader",
    principal_id=example_backup_vault.identity.principal_id)
example_backup_policy_disk = azure.dataprotection.BackupPolicyDisk("exampleBackupPolicyDisk",
    vault_id=example_backup_vault.id,
    backup_repeating_time_intervals=["R/2021-05-19T06:33:16+00:00/PT4H"],
    default_retention_duration="P7D")
example_backup_instance_disk = azure.dataprotection.BackupInstanceDisk("exampleBackupInstanceDisk",
    location=example_backup_vault.location,
    vault_id=example_backup_vault.id,
    disk_id=example_managed_disk.id,
    snapshot_resource_group_name=rg.name,
    backup_policy_id=example_backup_policy_disk.id)