Vaults - Create Or Update

Service:

Recovery Services

API Version:

2023-04-01

Cria ou atualiza um cofre dos Serviços de Recuperação.

PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.RecoveryServices/vaults/{vaultName}?api-version=2023-04-01

Parâmetros de URI

Nome	Em	Obrigatório	Tipo	Description
resourceGroupName	path	True	string	O nome do grupo de recursos. O nome diferencia maiúsculas de minúsculas.
subscriptionId	path	True	string	A ID da assinatura de destino.
vaultName	path	True	string	O nome do cofre dos serviços de recuperação.
api-version	query	True	string	A versão da API a ser usada para esta operação.

Corpo da solicitação

Nome	Obrigatório	Tipo	Description
location	True	string	Local do recurso.
etag		string	ETag opcional.
identity		IdentityData	Identidade do recurso.
properties		VaultProperties	Propriedades do cofre.
sku		Sku	Identifica o identificador de sistema exclusivo para cada recurso do Azure.
tags		object	Marcas de recurso.

Respostas

Nome	Tipo	Description
200 OK	Vault	OK
201 Created	Vault	Criado
Other Status Codes	CloudError	Resposta de erro que descreve por que a operação falhou.

Segurança

azure_auth

Fluxo do OAuth2 do Azure Active Directory

Type: oauth2
Flow: implicit
Authorization URL: https://login.microsoftonline.com/common/oauth2/authorize

Scopes

Nome	Description
user_impersonation	represente sua conta de usuário.

Exemplos

Create or Update Recovery Services vault

Create or Update Vault with CustomerManagedKeys

Create or Update Vault With Monitoring Setting

Create or Update Vault with User Assigned Identity

Create or Update Recovery Services vault

Sample Request

HTTP

PUT https://management.azure.com/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample?api-version=2023-04-01

{
  "properties": {
    "publicNetworkAccess": "Enabled"
  },
  "sku": {
    "name": "Standard"
  },
  "location": "West US",
  "identity": {
    "type": "SystemAssigned"
  }
}

Java

import com.azure.resourcemanager.recoveryservices.models.IdentityData;
import com.azure.resourcemanager.recoveryservices.models.PublicNetworkAccess;
import com.azure.resourcemanager.recoveryservices.models.ResourceIdentityType;
import com.azure.resourcemanager.recoveryservices.models.Sku;
import com.azure.resourcemanager.recoveryservices.models.SkuName;
import com.azure.resourcemanager.recoveryservices.models.VaultProperties;
import java.util.HashMap;
import java.util.Map;

/** Samples for Vaults CreateOrUpdate. */
public final class Main {
    /*
     * x-ms-original-file: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault.json
     */
    /**
     * Sample code: Create or Update Recovery Services vault.
     *
     * @param manager Entry point to RecoveryServicesManager.
     */
    public static void createOrUpdateRecoveryServicesVault(
        com.azure.resourcemanager.recoveryservices.RecoveryServicesManager manager) {
        manager
            .vaults()
            .define("swaggerExample")
            .withRegion("West US")
            .withExistingResourceGroup("Default-RecoveryServices-ResourceGroup")
            .withIdentity(new IdentityData().withType(ResourceIdentityType.SYSTEM_ASSIGNED))
            .withProperties(new VaultProperties().withPublicNetworkAccess(PublicNetworkAccess.ENABLED))
            .withSku(new Sku().withName(SkuName.STANDARD))
            .create();
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Python

from azure.identity import DefaultAzureCredential
from azure.mgmt.recoveryservices import RecoveryServicesClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-recoveryservices
# USAGE
    python put_vault.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = RecoveryServicesClient(
        credential=DefaultAzureCredential(),
        subscription_id="77777777-b0c6-47a2-b37c-d8e65a629c18",
    )

    response = client.vaults.begin_create_or_update(
        resource_group_name="Default-RecoveryServices-ResourceGroup",
        vault_name="swaggerExample",
        vault={
            "identity": {"type": "SystemAssigned"},
            "location": "West US",
            "properties": {"publicNetworkAccess": "Enabled"},
            "sku": {"name": "Standard"},
        },
    ).result()
    print(response)


# x-ms-original-file: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Go

package armrecoveryservices_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/recoveryservices/armrecoveryservices"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/80c21c17b4a7aa57f637ee594f7cfd653255a7e0/specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault.json
func ExampleVaultsClient_BeginCreateOrUpdate_createOrUpdateRecoveryServicesVault() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrecoveryservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewVaultsClient().BeginCreateOrUpdate(ctx, "Default-RecoveryServices-ResourceGroup", "swaggerExample", armrecoveryservices.Vault{
		Location: to.Ptr("West US"),
		Identity: &armrecoveryservices.IdentityData{
			Type: to.Ptr(armrecoveryservices.ResourceIdentityTypeSystemAssigned),
		},
		Properties: &armrecoveryservices.VaultProperties{
			PublicNetworkAccess: to.Ptr(armrecoveryservices.PublicNetworkAccessEnabled),
		},
		SKU: &armrecoveryservices.SKU{
			Name: to.Ptr(armrecoveryservices.SKUNameStandard),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Vault = armrecoveryservices.Vault{
	// 	Name: to.Ptr("swaggerExample"),
	// 	Type: to.Ptr("Microsoft.RecoveryServices/vaults"),
	// 	Etag: to.Ptr("W/\"datetime'2017-12-15T12%3A36%3A51.68Z'\""),
	// 	ID: to.Ptr("/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample"),
	// 	Location: to.Ptr("westus"),
	// 	Tags: map[string]*string{
	// 		"TestUpdatedKey": to.Ptr("TestUpdatedValue"),
	// 	},
	// 	Identity: &armrecoveryservices.IdentityData{
	// 		Type: to.Ptr(armrecoveryservices.ResourceIdentityTypeSystemAssigned),
	// 		PrincipalID: to.Ptr("3137d6c7-5d6c-411c-b934-7a2a729ee247"),
	// 		TenantID: to.Ptr("d676e86e-2206-4a7c-999c-ece52c144b5b"),
	// 	},
	// 	Properties: &armrecoveryservices.VaultProperties{
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		PublicNetworkAccess: to.Ptr(armrecoveryservices.PublicNetworkAccessEnabled),
	// 	},
	// 	SKU: &armrecoveryservices.SKU{
	// 		Name: to.Ptr(armrecoveryservices.SKUNameRS0),
	// 		Tier: to.Ptr("Standard"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

JavaScript

const { RecoveryServicesClient } = require("@azure/arm-recoveryservices");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Creates or updates a Recovery Services vault.
 *
 * @summary Creates or updates a Recovery Services vault.
 * x-ms-original-file: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault.json
 */
async function createOrUpdateRecoveryServicesVault() {
  const subscriptionId =
    process.env["RECOVERYSERVICES_SUBSCRIPTION_ID"] || "77777777-b0c6-47a2-b37c-d8e65a629c18";
  const resourceGroupName =
    process.env["RECOVERYSERVICES_RESOURCE_GROUP"] || "Default-RecoveryServices-ResourceGroup";
  const vaultName = "swaggerExample";
  const vault = {
    identity: { type: "SystemAssigned" },
    location: "West US",
    properties: { publicNetworkAccess: "Enabled" },
    sku: { name: "Standard" },
  };
  const credential = new DefaultAzureCredential();
  const client = new RecoveryServicesClient(credential, subscriptionId);
  const result = await client.vaults.beginCreateOrUpdateAndWait(
    resourceGroupName,
    vaultName,
    vault
  );
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

dotnet

using System;
using System.Threading.Tasks;
using Azure;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.RecoveryServices;
using Azure.ResourceManager.RecoveryServices.Models;
using Azure.ResourceManager.Resources;

// Generated from example definition: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault.json
// this example is just showing the usage of "Vaults_CreateOrUpdate" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "77777777-b0c6-47a2-b37c-d8e65a629c18";
string resourceGroupName = "Default-RecoveryServices-ResourceGroup";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this RecoveryServicesVaultResource
RecoveryServicesVaultCollection collection = resourceGroupResource.GetRecoveryServicesVaults();

// invoke the operation
string vaultName = "swaggerExample";
RecoveryServicesVaultData data = new RecoveryServicesVaultData(new AzureLocation("West US"))
{
    Identity = new ManagedServiceIdentity("SystemAssigned"),
    Properties = new RecoveryServicesVaultProperties()
    {
        PublicNetworkAccess = VaultPublicNetworkAccess.Enabled,
    },
    Sku = new RecoveryServicesSku(RecoveryServicesSkuName.Standard),
};
ArmOperation<RecoveryServicesVaultResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, vaultName, data);
RecoveryServicesVaultResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
RecoveryServicesVaultData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Sample Response

Status code:

200

{
  "location": "westus",
  "name": "swaggerExample",
  "etag": "W/\"datetime'2017-12-15T12%3A36%3A51.68Z'\"",
  "tags": {
    "TestUpdatedKey": "TestUpdatedValue"
  },
  "identity": {
    "tenantId": "d676e86e-2206-4a7c-999c-ece52c144b5b",
    "principalId": "3137d6c7-5d6c-411c-b934-7a2a729ee247",
    "type": "SystemAssigned"
  },
  "properties": {
    "publicNetworkAccess": "Enabled",
    "provisioningState": "Succeeded"
  },
  "id": "/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample",
  "type": "Microsoft.RecoveryServices/vaults",
  "sku": {
    "name": "RS0",
    "tier": "Standard"
  }
}

Status code:

201

{
  "location": "westus",
  "name": "swaggerExample",
  "etag": "W/\"datetime'2017-12-15T12%3A36%3A51.68Z'\"",
  "tags": {
    "TestUpdatedKey": "TestUpdatedValue"
  },
  "identity": {
    "tenantId": "d676e86e-2206-4a7c-999c-ece52c144b5b",
    "principalId": "3137d6c7-5d6c-411c-b934-7a2a729ee247",
    "type": "SystemAssigned"
  },
  "properties": {
    "publicNetworkAccess": "Enabled",
    "provisioningState": "Succeeded"
  },
  "id": "/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample",
  "type": "Microsoft.RecoveryServices/vaults",
  "sku": {
    "name": "RS0",
    "tier": "Standard"
  }
}

Create or Update Vault with CustomerManagedKeys

Sample Request

HTTP

PUT https://management.azure.com/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample?api-version=2023-04-01

{
  "properties": {
    "publicNetworkAccess": "Enabled",
    "encryption": {
      "keyVaultProperties": {
        "keyUri": "https://cmk2xkv.vault.azure.net/keys/Key1/0767b348bb1a4c07baa6c4ec0055d2b3"
      },
      "kekIdentity": {
        "userAssignedIdentity": "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi"
      },
      "infrastructureEncryption": "Enabled"
    }
  },
  "sku": {
    "name": "Standard"
  },
  "location": "West US",
  "identity": {
    "type": "UserAssigned",
    "userAssignedIdentities": {
      "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi": {}
    }
  }
}

Java

import com.azure.resourcemanager.recoveryservices.models.CmkKekIdentity;
import com.azure.resourcemanager.recoveryservices.models.CmkKeyVaultProperties;
import com.azure.resourcemanager.recoveryservices.models.IdentityData;
import com.azure.resourcemanager.recoveryservices.models.InfrastructureEncryptionState;
import com.azure.resourcemanager.recoveryservices.models.PublicNetworkAccess;
import com.azure.resourcemanager.recoveryservices.models.ResourceIdentityType;
import com.azure.resourcemanager.recoveryservices.models.Sku;
import com.azure.resourcemanager.recoveryservices.models.SkuName;
import com.azure.resourcemanager.recoveryservices.models.UserIdentity;
import com.azure.resourcemanager.recoveryservices.models.VaultProperties;
import com.azure.resourcemanager.recoveryservices.models.VaultPropertiesEncryption;
import java.util.HashMap;
import java.util.Map;

/** Samples for Vaults CreateOrUpdate. */
public final class Main {
    /*
     * x-ms-original-file: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithCMK.json
     */
    /**
     * Sample code: Create or Update Vault with CustomerManagedKeys.
     *
     * @param manager Entry point to RecoveryServicesManager.
     */
    public static void createOrUpdateVaultWithCustomerManagedKeys(
        com.azure.resourcemanager.recoveryservices.RecoveryServicesManager manager) {
        manager
            .vaults()
            .define("swaggerExample")
            .withRegion("West US")
            .withExistingResourceGroup("Default-RecoveryServices-ResourceGroup")
            .withIdentity(
                new IdentityData()
                    .withType(ResourceIdentityType.USER_ASSIGNED)
                    .withUserAssignedIdentities(
                        mapOf(
                            "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi",
                            new UserIdentity())))
            .withProperties(
                new VaultProperties()
                    .withEncryption(
                        new VaultPropertiesEncryption()
                            .withKeyVaultProperties(new CmkKeyVaultProperties().withKeyUri("fakeTokenPlaceholder"))
                            .withKekIdentity(
                                new CmkKekIdentity()
                                    .withUserAssignedIdentity(
                                        "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi"))
                            .withInfrastructureEncryption(InfrastructureEncryptionState.ENABLED))
                    .withPublicNetworkAccess(PublicNetworkAccess.ENABLED))
            .withSku(new Sku().withName(SkuName.STANDARD))
            .create();
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Python

from azure.identity import DefaultAzureCredential
from azure.mgmt.recoveryservices import RecoveryServicesClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-recoveryservices
# USAGE
    python put_vault_with_cmk.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = RecoveryServicesClient(
        credential=DefaultAzureCredential(),
        subscription_id="77777777-b0c6-47a2-b37c-d8e65a629c18",
    )

    response = client.vaults.begin_create_or_update(
        resource_group_name="Default-RecoveryServices-ResourceGroup",
        vault_name="swaggerExample",
        vault={
            "identity": {
                "type": "UserAssigned",
                "userAssignedIdentities": {
                    "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi": {}
                },
            },
            "location": "West US",
            "properties": {
                "encryption": {
                    "infrastructureEncryption": "Enabled",
                    "kekIdentity": {
                        "userAssignedIdentity": "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi"
                    },
                    "keyVaultProperties": {
                        "keyUri": "https://cmk2xkv.vault.azure.net/keys/Key1/0767b348bb1a4c07baa6c4ec0055d2b3"
                    },
                },
                "publicNetworkAccess": "Enabled",
            },
            "sku": {"name": "Standard"},
        },
    ).result()
    print(response)


# x-ms-original-file: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithCMK.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Go

package armrecoveryservices_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/recoveryservices/armrecoveryservices"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/80c21c17b4a7aa57f637ee594f7cfd653255a7e0/specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithCMK.json
func ExampleVaultsClient_BeginCreateOrUpdate_createOrUpdateVaultWithCustomerManagedKeys() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrecoveryservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewVaultsClient().BeginCreateOrUpdate(ctx, "Default-RecoveryServices-ResourceGroup", "swaggerExample", armrecoveryservices.Vault{
		Location: to.Ptr("West US"),
		Identity: &armrecoveryservices.IdentityData{
			Type: to.Ptr(armrecoveryservices.ResourceIdentityTypeUserAssigned),
			UserAssignedIdentities: map[string]*armrecoveryservices.UserIdentity{
				"/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi": {},
			},
		},
		Properties: &armrecoveryservices.VaultProperties{
			Encryption: &armrecoveryservices.VaultPropertiesEncryption{
				InfrastructureEncryption: to.Ptr(armrecoveryservices.InfrastructureEncryptionStateEnabled),
				KekIdentity: &armrecoveryservices.CmkKekIdentity{
					UserAssignedIdentity: to.Ptr("/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi"),
				},
				KeyVaultProperties: &armrecoveryservices.CmkKeyVaultProperties{
					KeyURI: to.Ptr("https://cmk2xkv.vault.azure.net/keys/Key1/0767b348bb1a4c07baa6c4ec0055d2b3"),
				},
			},
			PublicNetworkAccess: to.Ptr(armrecoveryservices.PublicNetworkAccessEnabled),
		},
		SKU: &armrecoveryservices.SKU{
			Name: to.Ptr(armrecoveryservices.SKUNameStandard),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Vault = armrecoveryservices.Vault{
	// 	Name: to.Ptr("swaggerExample"),
	// 	Type: to.Ptr("Microsoft.RecoveryServices/vaults"),
	// 	Etag: to.Ptr("W/\"datetime'2017-12-15T12%3A36%3A51.68Z'\""),
	// 	ID: to.Ptr("/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample"),
	// 	Location: to.Ptr("westus"),
	// 	Tags: map[string]*string{
	// 		"TestUpdatedKey": to.Ptr("TestUpdatedValue"),
	// 	},
	// 	Identity: &armrecoveryservices.IdentityData{
	// 		Type: to.Ptr(armrecoveryservices.ResourceIdentityTypeUserAssigned),
	// 		UserAssignedIdentities: map[string]*armrecoveryservices.UserIdentity{
	// 			"/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi": &armrecoveryservices.UserIdentity{
	// 				ClientID: to.Ptr("fbe75b66-01c5-4f87-a220-233af3270436"),
	// 				PrincipalID: to.Ptr("075a0ca6-43f6-4434-9abf-c9b1b79f9219"),
	// 			},
	// 		},
	// 	},
	// 	Properties: &armrecoveryservices.VaultProperties{
	// 		Encryption: &armrecoveryservices.VaultPropertiesEncryption{
	// 			InfrastructureEncryption: to.Ptr(armrecoveryservices.InfrastructureEncryptionStateEnabled),
	// 			KekIdentity: &armrecoveryservices.CmkKekIdentity{
	// 				UseSystemAssignedIdentity: to.Ptr(false),
	// 				UserAssignedIdentity: to.Ptr("/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi"),
	// 			},
	// 			KeyVaultProperties: &armrecoveryservices.CmkKeyVaultProperties{
	// 				KeyURI: to.Ptr("https://cmk2xkv.vault.azure.net/keys/Key1/0767b348bb1a4c07baa6c4ec0055d2b3"),
	// 			},
	// 		},
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		PublicNetworkAccess: to.Ptr(armrecoveryservices.PublicNetworkAccessEnabled),
	// 	},
	// 	SKU: &armrecoveryservices.SKU{
	// 		Name: to.Ptr(armrecoveryservices.SKUNameStandard),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

JavaScript

const { RecoveryServicesClient } = require("@azure/arm-recoveryservices");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Creates or updates a Recovery Services vault.
 *
 * @summary Creates or updates a Recovery Services vault.
 * x-ms-original-file: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithCMK.json
 */
async function createOrUpdateVaultWithCustomerManagedKeys() {
  const subscriptionId =
    process.env["RECOVERYSERVICES_SUBSCRIPTION_ID"] || "77777777-b0c6-47a2-b37c-d8e65a629c18";
  const resourceGroupName =
    process.env["RECOVERYSERVICES_RESOURCE_GROUP"] || "Default-RecoveryServices-ResourceGroup";
  const vaultName = "swaggerExample";
  const vault = {
    identity: {
      type: "UserAssigned",
      userAssignedIdentities: {
        "/subscriptions/85bf5e8c30844f42Add2746ebb7e97b2/resourcegroups/defaultrg/providers/MicrosoftManagedIdentity/userAssignedIdentities/examplemsi":
          {},
      },
    },
    location: "West US",
    properties: {
      encryption: {
        infrastructureEncryption: "Enabled",
        kekIdentity: {
          userAssignedIdentity:
            "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi",
        },
        keyVaultProperties: {
          keyUri: "https://cmk2xkv.vault.azure.net/keys/Key1/0767b348bb1a4c07baa6c4ec0055d2b3",
        },
      },
      publicNetworkAccess: "Enabled",
    },
    sku: { name: "Standard" },
  };
  const credential = new DefaultAzureCredential();
  const client = new RecoveryServicesClient(credential, subscriptionId);
  const result = await client.vaults.beginCreateOrUpdateAndWait(
    resourceGroupName,
    vaultName,
    vault
  );
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

dotnet

using System;
using System.Threading.Tasks;
using Azure;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.RecoveryServices;
using Azure.ResourceManager.RecoveryServices.Models;
using Azure.ResourceManager.Resources;

// Generated from example definition: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithCMK.json
// this example is just showing the usage of "Vaults_CreateOrUpdate" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "77777777-b0c6-47a2-b37c-d8e65a629c18";
string resourceGroupName = "Default-RecoveryServices-ResourceGroup";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this RecoveryServicesVaultResource
RecoveryServicesVaultCollection collection = resourceGroupResource.GetRecoveryServicesVaults();

// invoke the operation
string vaultName = "swaggerExample";
RecoveryServicesVaultData data = new RecoveryServicesVaultData(new AzureLocation("West US"))
{
    Identity = new ManagedServiceIdentity("UserAssigned")
    {
        UserAssignedIdentities =
        {
        [new ResourceIdentifier("/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi")] = new UserAssignedIdentity(),
        },
    },
    Properties = new RecoveryServicesVaultProperties()
    {
        Encryption = new VaultPropertiesEncryption()
        {
            KeyUri = new Uri("https://cmk2xkv.vault.azure.net/keys/Key1/0767b348bb1a4c07baa6c4ec0055d2b3"),
            KekIdentity = new CmkKekIdentity()
            {
                UserAssignedIdentity = new ResourceIdentifier("/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi"),
            },
            InfrastructureEncryption = InfrastructureEncryptionState.Enabled,
        },
        PublicNetworkAccess = VaultPublicNetworkAccess.Enabled,
    },
    Sku = new RecoveryServicesSku(RecoveryServicesSkuName.Standard),
};
ArmOperation<RecoveryServicesVaultResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, vaultName, data);
RecoveryServicesVaultResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
RecoveryServicesVaultData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Sample Response

Status code:

200

{
  "location": "westus",
  "name": "swaggerExample",
  "etag": "W/\"datetime'2017-12-15T12%3A36%3A51.68Z'\"",
  "tags": {
    "TestUpdatedKey": "TestUpdatedValue"
  },
  "identity": {
    "type": "UserAssigned",
    "userAssignedIdentities": {
      "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi": {
        "clientId": "fbe75b66-01c5-4f87-a220-233af3270436",
        "principalId": "075a0ca6-43f6-4434-9abf-c9b1b79f9219"
      }
    }
  },
  "properties": {
    "publicNetworkAccess": "Enabled",
    "provisioningState": "Succeeded",
    "encryption": {
      "keyVaultProperties": {
        "keyUri": "https://cmk2xkv.vault.azure.net/keys/Key1/0767b348bb1a4c07baa6c4ec0055d2b3"
      },
      "kekIdentity": {
        "userAssignedIdentity": "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi",
        "useSystemAssignedIdentity": false
      },
      "infrastructureEncryption": "Enabled"
    }
  },
  "id": "/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample",
  "type": "Microsoft.RecoveryServices/vaults",
  "sku": {
    "name": "Standard"
  }
}

Status code:

201

Retry-After: 10
Azure-AsyncOperation: /subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample/operationStatus/YWUzNDFkMzQtZmM5OS00MmUyLWEzNDMtZGJkMDIxZjlmZjgzOzdmYzBiMzhmLTc2NmItNDM5NS05OWQ1LTVmOGEzNzg4MWQzNA==?api-version=2015-03-15

Response Body

{
  "location": "westus",
  "name": "swaggerExample",
  "etag": "W/\"datetime'2017-12-15T12%3A36%3A51.68Z'\"",
  "tags": {
    "TestUpdatedKey": "TestUpdatedValue"
  },
  "identity": {
    "type": "UserAssigned",
    "userAssignedIdentities": {
      "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi": {}
    }
  },
  "properties": {
    "publicNetworkAccess": "Enabled",
    "provisioningState": "Provisioning",
    "encryption": {
      "keyVaultProperties": {
        "keyUri": "https://cmk2xkv.vault.azure.net/keys/Key1/0767b348bb1a4c07baa6c4ec0055d2b3"
      },
      "kekIdentity": {
        "userAssignedIdentity": "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi",
        "useSystemAssignedIdentity": false
      },
      "infrastructureEncryption": "Enabled"
    }
  },
  "id": "/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample",
  "type": "Microsoft.RecoveryServices/vaults",
  "sku": {
    "name": "Standard"
  }
}

Create or Update Vault With Monitoring Setting

Sample Request

HTTP

PUT https://management.azure.com/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample?api-version=2023-04-01

{
  "properties": {
    "publicNetworkAccess": "Enabled",
    "monitoringSettings": {
      "azureMonitorAlertSettings": {
        "alertsForAllJobFailures": "Enabled"
      },
      "classicAlertSettings": {
        "alertsForCriticalOperations": "Disabled"
      }
    }
  },
  "sku": {
    "name": "Standard"
  },
  "location": "West US",
  "identity": {
    "type": "SystemAssigned"
  }
}

Java

import com.azure.resourcemanager.recoveryservices.models.AlertsState;
import com.azure.resourcemanager.recoveryservices.models.AzureMonitorAlertSettings;
import com.azure.resourcemanager.recoveryservices.models.ClassicAlertSettings;
import com.azure.resourcemanager.recoveryservices.models.IdentityData;
import com.azure.resourcemanager.recoveryservices.models.MonitoringSettings;
import com.azure.resourcemanager.recoveryservices.models.PublicNetworkAccess;
import com.azure.resourcemanager.recoveryservices.models.ResourceIdentityType;
import com.azure.resourcemanager.recoveryservices.models.Sku;
import com.azure.resourcemanager.recoveryservices.models.SkuName;
import com.azure.resourcemanager.recoveryservices.models.VaultProperties;
import java.util.HashMap;
import java.util.Map;

/** Samples for Vaults CreateOrUpdate. */
public final class Main {
    /*
     * x-ms-original-file: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithMonitoringSettings.json
     */
    /**
     * Sample code: Create or Update Vault With Monitoring Setting.
     *
     * @param manager Entry point to RecoveryServicesManager.
     */
    public static void createOrUpdateVaultWithMonitoringSetting(
        com.azure.resourcemanager.recoveryservices.RecoveryServicesManager manager) {
        manager
            .vaults()
            .define("swaggerExample")
            .withRegion("West US")
            .withExistingResourceGroup("Default-RecoveryServices-ResourceGroup")
            .withIdentity(new IdentityData().withType(ResourceIdentityType.SYSTEM_ASSIGNED))
            .withProperties(
                new VaultProperties()
                    .withPublicNetworkAccess(PublicNetworkAccess.ENABLED)
                    .withMonitoringSettings(
                        new MonitoringSettings()
                            .withAzureMonitorAlertSettings(
                                new AzureMonitorAlertSettings().withAlertsForAllJobFailures(AlertsState.ENABLED))
                            .withClassicAlertSettings(
                                new ClassicAlertSettings().withAlertsForCriticalOperations(AlertsState.DISABLED))))
            .withSku(new Sku().withName(SkuName.STANDARD))
            .create();
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Python

from azure.identity import DefaultAzureCredential
from azure.mgmt.recoveryservices import RecoveryServicesClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-recoveryservices
# USAGE
    python put_vault_with_monitoring_settings.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = RecoveryServicesClient(
        credential=DefaultAzureCredential(),
        subscription_id="77777777-b0c6-47a2-b37c-d8e65a629c18",
    )

    response = client.vaults.begin_create_or_update(
        resource_group_name="Default-RecoveryServices-ResourceGroup",
        vault_name="swaggerExample",
        vault={
            "identity": {"type": "SystemAssigned"},
            "location": "West US",
            "properties": {
                "monitoringSettings": {
                    "azureMonitorAlertSettings": {"alertsForAllJobFailures": "Enabled"},
                    "classicAlertSettings": {"alertsForCriticalOperations": "Disabled"},
                },
                "publicNetworkAccess": "Enabled",
            },
            "sku": {"name": "Standard"},
        },
    ).result()
    print(response)


# x-ms-original-file: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithMonitoringSettings.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Go

package armrecoveryservices_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/recoveryservices/armrecoveryservices"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/80c21c17b4a7aa57f637ee594f7cfd653255a7e0/specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithMonitoringSettings.json
func ExampleVaultsClient_BeginCreateOrUpdate_createOrUpdateVaultWithMonitoringSetting() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrecoveryservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewVaultsClient().BeginCreateOrUpdate(ctx, "Default-RecoveryServices-ResourceGroup", "swaggerExample", armrecoveryservices.Vault{
		Location: to.Ptr("West US"),
		Identity: &armrecoveryservices.IdentityData{
			Type: to.Ptr(armrecoveryservices.ResourceIdentityTypeSystemAssigned),
		},
		Properties: &armrecoveryservices.VaultProperties{
			MonitoringSettings: &armrecoveryservices.MonitoringSettings{
				AzureMonitorAlertSettings: &armrecoveryservices.AzureMonitorAlertSettings{
					AlertsForAllJobFailures: to.Ptr(armrecoveryservices.AlertsStateEnabled),
				},
				ClassicAlertSettings: &armrecoveryservices.ClassicAlertSettings{
					AlertsForCriticalOperations: to.Ptr(armrecoveryservices.AlertsStateDisabled),
				},
			},
			PublicNetworkAccess: to.Ptr(armrecoveryservices.PublicNetworkAccessEnabled),
		},
		SKU: &armrecoveryservices.SKU{
			Name: to.Ptr(armrecoveryservices.SKUNameStandard),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Vault = armrecoveryservices.Vault{
	// 	Name: to.Ptr("swaggerExample"),
	// 	Type: to.Ptr("Microsoft.RecoveryServices/vaults"),
	// 	Etag: to.Ptr("W/\"datetime'2017-12-15T12%3A36%3A51.68Z'\""),
	// 	ID: to.Ptr("/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample"),
	// 	Location: to.Ptr("westus"),
	// 	Tags: map[string]*string{
	// 		"TestUpdatedKey": to.Ptr("TestUpdatedValue"),
	// 	},
	// 	Identity: &armrecoveryservices.IdentityData{
	// 		Type: to.Ptr(armrecoveryservices.ResourceIdentityTypeSystemAssigned),
	// 		PrincipalID: to.Ptr("3137d6c7-5d6c-411c-b934-7a2a729ee247"),
	// 		TenantID: to.Ptr("d676e86e-2206-4a7c-999c-ece52c144b5b"),
	// 	},
	// 	Properties: &armrecoveryservices.VaultProperties{
	// 		MonitoringSettings: &armrecoveryservices.MonitoringSettings{
	// 			AzureMonitorAlertSettings: &armrecoveryservices.AzureMonitorAlertSettings{
	// 				AlertsForAllJobFailures: to.Ptr(armrecoveryservices.AlertsStateEnabled),
	// 			},
	// 			ClassicAlertSettings: &armrecoveryservices.ClassicAlertSettings{
	// 				AlertsForCriticalOperations: to.Ptr(armrecoveryservices.AlertsStateDisabled),
	// 			},
	// 		},
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		PublicNetworkAccess: to.Ptr(armrecoveryservices.PublicNetworkAccessEnabled),
	// 	},
	// 	SKU: &armrecoveryservices.SKU{
	// 		Name: to.Ptr(armrecoveryservices.SKUNameRS0),
	// 		Tier: to.Ptr("Standard"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

JavaScript

const { RecoveryServicesClient } = require("@azure/arm-recoveryservices");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Creates or updates a Recovery Services vault.
 *
 * @summary Creates or updates a Recovery Services vault.
 * x-ms-original-file: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithMonitoringSettings.json
 */
async function createOrUpdateVaultWithMonitoringSetting() {
  const subscriptionId =
    process.env["RECOVERYSERVICES_SUBSCRIPTION_ID"] || "77777777-b0c6-47a2-b37c-d8e65a629c18";
  const resourceGroupName =
    process.env["RECOVERYSERVICES_RESOURCE_GROUP"] || "Default-RecoveryServices-ResourceGroup";
  const vaultName = "swaggerExample";
  const vault = {
    identity: { type: "SystemAssigned" },
    location: "West US",
    properties: {
      monitoringSettings: {
        azureMonitorAlertSettings: { alertsForAllJobFailures: "Enabled" },
        classicAlertSettings: { alertsForCriticalOperations: "Disabled" },
      },
      publicNetworkAccess: "Enabled",
    },
    sku: { name: "Standard" },
  };
  const credential = new DefaultAzureCredential();
  const client = new RecoveryServicesClient(credential, subscriptionId);
  const result = await client.vaults.beginCreateOrUpdateAndWait(
    resourceGroupName,
    vaultName,
    vault
  );
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

dotnet

using System;
using System.Threading.Tasks;
using Azure;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.RecoveryServices;
using Azure.ResourceManager.RecoveryServices.Models;
using Azure.ResourceManager.Resources;

// Generated from example definition: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithMonitoringSettings.json
// this example is just showing the usage of "Vaults_CreateOrUpdate" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "77777777-b0c6-47a2-b37c-d8e65a629c18";
string resourceGroupName = "Default-RecoveryServices-ResourceGroup";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this RecoveryServicesVaultResource
RecoveryServicesVaultCollection collection = resourceGroupResource.GetRecoveryServicesVaults();

// invoke the operation
string vaultName = "swaggerExample";
RecoveryServicesVaultData data = new RecoveryServicesVaultData(new AzureLocation("West US"))
{
    Identity = new ManagedServiceIdentity("SystemAssigned"),
    Properties = new RecoveryServicesVaultProperties()
    {
        PublicNetworkAccess = VaultPublicNetworkAccess.Enabled,
        MonitoringSettings = new VaultMonitoringSettings()
        {
            AzureMonitorAlertAlertsForAllJobFailures = RecoveryServicesAlertsState.Enabled,
            ClassicAlertAlertsForCriticalOperations = RecoveryServicesAlertsState.Disabled,
        },
    },
    Sku = new RecoveryServicesSku(RecoveryServicesSkuName.Standard),
};
ArmOperation<RecoveryServicesVaultResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, vaultName, data);
RecoveryServicesVaultResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
RecoveryServicesVaultData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Sample Response

Status code:

200

{
  "location": "westus",
  "name": "swaggerExample",
  "etag": "W/\"datetime'2017-12-15T12%3A36%3A51.68Z'\"",
  "tags": {
    "TestUpdatedKey": "TestUpdatedValue"
  },
  "identity": {
    "tenantId": "d676e86e-2206-4a7c-999c-ece52c144b5b",
    "principalId": "3137d6c7-5d6c-411c-b934-7a2a729ee247",
    "type": "SystemAssigned"
  },
  "properties": {
    "publicNetworkAccess": "Enabled",
    "provisioningState": "Succeeded",
    "monitoringSettings": {
      "azureMonitorAlertSettings": {
        "alertsForAllJobFailures": "Enabled"
      },
      "classicAlertSettings": {
        "alertsForCriticalOperations": "Disabled"
      }
    }
  },
  "id": "/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample",
  "type": "Microsoft.RecoveryServices/vaults",
  "sku": {
    "name": "RS0",
    "tier": "Standard"
  }
}

Status code:

201

{
  "location": "westus",
  "name": "swaggerExample",
  "etag": "W/\"datetime'2017-12-15T12%3A36%3A51.68Z'\"",
  "tags": {
    "TestUpdatedKey": "TestUpdatedValue"
  },
  "identity": {
    "tenantId": "d676e86e-2206-4a7c-999c-ece52c144b5b",
    "principalId": "3137d6c7-5d6c-411c-b934-7a2a729ee247",
    "type": "SystemAssigned"
  },
  "properties": {
    "publicNetworkAccess": "Enabled",
    "provisioningState": "Succeeded",
    "monitoringSettings": {
      "azureMonitorAlertSettings": {
        "alertsForAllJobFailures": "Enabled"
      },
      "classicAlertSettings": {
        "alertsForCriticalOperations": "Disabled"
      }
    }
  },
  "id": "/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample",
  "type": "Microsoft.RecoveryServices/vaults",
  "sku": {
    "name": "RS0",
    "tier": "Standard"
  }
}

Create or Update Vault with User Assigned Identity

Sample Request

HTTP

PUT https://management.azure.com/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample?api-version=2023-04-01

{
  "properties": {
    "publicNetworkAccess": "Enabled"
  },
  "sku": {
    "name": "Standard"
  },
  "location": "West US",
  "identity": {
    "type": "UserAssigned",
    "userAssignedIdentities": {
      "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi": {}
    }
  }
}

Java

import com.azure.resourcemanager.recoveryservices.models.IdentityData;
import com.azure.resourcemanager.recoveryservices.models.PublicNetworkAccess;
import com.azure.resourcemanager.recoveryservices.models.ResourceIdentityType;
import com.azure.resourcemanager.recoveryservices.models.Sku;
import com.azure.resourcemanager.recoveryservices.models.SkuName;
import com.azure.resourcemanager.recoveryservices.models.UserIdentity;
import com.azure.resourcemanager.recoveryservices.models.VaultProperties;
import java.util.HashMap;
import java.util.Map;

/** Samples for Vaults CreateOrUpdate. */
public final class Main {
    /*
     * x-ms-original-file: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithUserAssignedIdentity.json
     */
    /**
     * Sample code: Create or Update Vault with User Assigned Identity.
     *
     * @param manager Entry point to RecoveryServicesManager.
     */
    public static void createOrUpdateVaultWithUserAssignedIdentity(
        com.azure.resourcemanager.recoveryservices.RecoveryServicesManager manager) {
        manager
            .vaults()
            .define("swaggerExample")
            .withRegion("West US")
            .withExistingResourceGroup("Default-RecoveryServices-ResourceGroup")
            .withIdentity(
                new IdentityData()
                    .withType(ResourceIdentityType.USER_ASSIGNED)
                    .withUserAssignedIdentities(
                        mapOf(
                            "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi",
                            new UserIdentity())))
            .withProperties(new VaultProperties().withPublicNetworkAccess(PublicNetworkAccess.ENABLED))
            .withSku(new Sku().withName(SkuName.STANDARD))
            .create();
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Python

from azure.identity import DefaultAzureCredential
from azure.mgmt.recoveryservices import RecoveryServicesClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-recoveryservices
# USAGE
    python put_vault_with_user_assigned_identity.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = RecoveryServicesClient(
        credential=DefaultAzureCredential(),
        subscription_id="77777777-b0c6-47a2-b37c-d8e65a629c18",
    )

    response = client.vaults.begin_create_or_update(
        resource_group_name="Default-RecoveryServices-ResourceGroup",
        vault_name="swaggerExample",
        vault={
            "identity": {
                "type": "UserAssigned",
                "userAssignedIdentities": {
                    "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi": {}
                },
            },
            "location": "West US",
            "properties": {"publicNetworkAccess": "Enabled"},
            "sku": {"name": "Standard"},
        },
    ).result()
    print(response)


# x-ms-original-file: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithUserAssignedIdentity.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Go

package armrecoveryservices_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/recoveryservices/armrecoveryservices"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/80c21c17b4a7aa57f637ee594f7cfd653255a7e0/specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithUserAssignedIdentity.json
func ExampleVaultsClient_BeginCreateOrUpdate_createOrUpdateVaultWithUserAssignedIdentity() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armrecoveryservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewVaultsClient().BeginCreateOrUpdate(ctx, "Default-RecoveryServices-ResourceGroup", "swaggerExample", armrecoveryservices.Vault{
		Location: to.Ptr("West US"),
		Identity: &armrecoveryservices.IdentityData{
			Type: to.Ptr(armrecoveryservices.ResourceIdentityTypeUserAssigned),
			UserAssignedIdentities: map[string]*armrecoveryservices.UserIdentity{
				"/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi": {},
			},
		},
		Properties: &armrecoveryservices.VaultProperties{
			PublicNetworkAccess: to.Ptr(armrecoveryservices.PublicNetworkAccessEnabled),
		},
		SKU: &armrecoveryservices.SKU{
			Name: to.Ptr(armrecoveryservices.SKUNameStandard),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Vault = armrecoveryservices.Vault{
	// 	Name: to.Ptr("swaggerExample"),
	// 	Type: to.Ptr("Microsoft.RecoveryServices/vaults"),
	// 	Etag: to.Ptr("W/\"datetime'2017-12-15T12%3A36%3A51.68Z'\""),
	// 	ID: to.Ptr("/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample"),
	// 	Location: to.Ptr("westus"),
	// 	Tags: map[string]*string{
	// 		"TestUpdatedKey": to.Ptr("TestUpdatedValue"),
	// 	},
	// 	Identity: &armrecoveryservices.IdentityData{
	// 		Type: to.Ptr(armrecoveryservices.ResourceIdentityTypeUserAssigned),
	// 		UserAssignedIdentities: map[string]*armrecoveryservices.UserIdentity{
	// 			"/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi": &armrecoveryservices.UserIdentity{
	// 				ClientID: to.Ptr("fbe75b66-01c5-4f87-a220-233af3270436"),
	// 				PrincipalID: to.Ptr("075a0ca6-43f6-4434-9abf-c9b1b79f9219"),
	// 			},
	// 		},
	// 	},
	// 	Properties: &armrecoveryservices.VaultProperties{
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		PublicNetworkAccess: to.Ptr(armrecoveryservices.PublicNetworkAccessEnabled),
	// 	},
	// 	SKU: &armrecoveryservices.SKU{
	// 		Name: to.Ptr(armrecoveryservices.SKUNameStandard),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

JavaScript

const { RecoveryServicesClient } = require("@azure/arm-recoveryservices");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Creates or updates a Recovery Services vault.
 *
 * @summary Creates or updates a Recovery Services vault.
 * x-ms-original-file: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithUserAssignedIdentity.json
 */
async function createOrUpdateVaultWithUserAssignedIdentity() {
  const subscriptionId =
    process.env["RECOVERYSERVICES_SUBSCRIPTION_ID"] || "77777777-b0c6-47a2-b37c-d8e65a629c18";
  const resourceGroupName =
    process.env["RECOVERYSERVICES_RESOURCE_GROUP"] || "Default-RecoveryServices-ResourceGroup";
  const vaultName = "swaggerExample";
  const vault = {
    identity: {
      type: "UserAssigned",
      userAssignedIdentities: {
        "/subscriptions/85bf5e8c30844f42Add2746ebb7e97b2/resourcegroups/defaultrg/providers/MicrosoftManagedIdentity/userAssignedIdentities/examplemsi":
          {},
      },
    },
    location: "West US",
    properties: { publicNetworkAccess: "Enabled" },
    sku: { name: "Standard" },
  };
  const credential = new DefaultAzureCredential();
  const client = new RecoveryServicesClient(credential, subscriptionId);
  const result = await client.vaults.beginCreateOrUpdateAndWait(
    resourceGroupName,
    vaultName,
    vault
  );
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

dotnet

using System;
using System.Threading.Tasks;
using Azure;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.RecoveryServices;
using Azure.ResourceManager.RecoveryServices.Models;
using Azure.ResourceManager.Resources;

// Generated from example definition: specification/recoveryservices/resource-manager/Microsoft.RecoveryServices/stable/2023-04-01/examples/PUTVault_WithUserAssignedIdentity.json
// this example is just showing the usage of "Vaults_CreateOrUpdate" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "77777777-b0c6-47a2-b37c-d8e65a629c18";
string resourceGroupName = "Default-RecoveryServices-ResourceGroup";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this RecoveryServicesVaultResource
RecoveryServicesVaultCollection collection = resourceGroupResource.GetRecoveryServicesVaults();

// invoke the operation
string vaultName = "swaggerExample";
RecoveryServicesVaultData data = new RecoveryServicesVaultData(new AzureLocation("West US"))
{
    Identity = new ManagedServiceIdentity("UserAssigned")
    {
        UserAssignedIdentities =
        {
        [new ResourceIdentifier("/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi")] = new UserAssignedIdentity(),
        },
    },
    Properties = new RecoveryServicesVaultProperties()
    {
        PublicNetworkAccess = VaultPublicNetworkAccess.Enabled,
    },
    Sku = new RecoveryServicesSku(RecoveryServicesSkuName.Standard),
};
ArmOperation<RecoveryServicesVaultResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, vaultName, data);
RecoveryServicesVaultResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
RecoveryServicesVaultData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Sample Response

Status code:

200

{
  "location": "westus",
  "name": "swaggerExample",
  "etag": "W/\"datetime'2017-12-15T12%3A36%3A51.68Z'\"",
  "tags": {
    "TestUpdatedKey": "TestUpdatedValue"
  },
  "identity": {
    "type": "UserAssigned",
    "userAssignedIdentities": {
      "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi": {
        "clientId": "fbe75b66-01c5-4f87-a220-233af3270436",
        "principalId": "075a0ca6-43f6-4434-9abf-c9b1b79f9219"
      }
    }
  },
  "properties": {
    "publicNetworkAccess": "Enabled",
    "provisioningState": "Succeeded"
  },
  "id": "/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample",
  "type": "Microsoft.RecoveryServices/vaults",
  "sku": {
    "name": "Standard"
  }
}

Status code:

201

Retry-After: 10
Azure-AsyncOperation: /subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample/operationStatus/YWUzNDFkMzQtZmM5OS00MmUyLWEzNDMtZGJkMDIxZjlmZjgzOzdmYzBiMzhmLTc2NmItNDM5NS05OWQ1LTVmOGEzNzg4MWQzNA==?api-version=2015-03-15

Response Body

{
  "location": "westus",
  "name": "swaggerExample",
  "etag": "W/\"datetime'2017-12-15T12%3A36%3A51.68Z'\"",
  "tags": {
    "TestUpdatedKey": "TestUpdatedValue"
  },
  "identity": {
    "type": "UserAssigned",
    "userAssignedIdentities": {
      "/subscriptions/85bf5e8c-3084-4f42-add2-746ebb7e97b2/resourcegroups/defaultrg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplemsi": {}
    }
  },
  "properties": {
    "publicNetworkAccess": "Enabled",
    "provisioningState": "Provisioning"
  },
  "id": "/subscriptions/77777777-b0c6-47a2-b37c-d8e65a629c18/resourceGroups/Default-RecoveryServices-ResourceGroup/providers/Microsoft.RecoveryServices/vaults/swaggerExample",
  "type": "Microsoft.RecoveryServices/vaults",
  "sku": {
    "name": "Standard"
  }
}

Definições

Nome	Description
AlertsState
AzureMonitorAlertSettings	Configurações para alertas baseados no Azure Monitor
BackupStorageVersion	Versão de armazenamento de backup
ClassicAlertSettings	Configurações para alertas clássicos
CloudError	CloudError
CmkKekIdentity	Os detalhes da identidade usada para CMK
CmkKeyVaultProperties	As propriedades do Key Vault que hospeda a CMK
createdByType	O tipo de identidade que criou o recurso.
crossRegionRestore	Sinalizador para mostrar se a Restauração entre Regiões está habilitada no Cofre ou não
CrossSubscriptionRestoreSettings	Configurações para configurações de restauração entre assinaturas
crossSubscriptionRestoreState
Encryption	Detalhes da Chave Gerenciada pelo Cliente do recurso.
Error	A resposta de erro de gerenciamento de recursos.
ErrorAdditionalInfo	As informações adicionais do erro de gerenciamento de recursos.
IdentityData	Identidade do recurso.
ImmutabilitySettings	Configurações de Imutabilidade do cofre
ImmutabilityState
InfrastructureEncryptionState	Habilitando/desabilitando o estado de Criptografia Dupla
MonitoringSettings	Configurações de monitoramento do cofre
MoveDetails	Os detalhes da operação de movimentação mais recente executada no Recurso do Azure
MultiUserAuthorization	Configurações de MUA do cofre
PrivateEndpoint	O recurso de rede de ponto de extremidade privado que está vinculado à conexão de ponto de extremidade privado.
PrivateEndpointConnection	Propriedades de resposta de conexão de ponto de extremidade privado.
PrivateEndpointConnectionStatus	Obtém ou define o status.
PrivateEndpointConnectionVaultProperties	Informações a serem armazenadas nas propriedades do Cofre como um elemento de privateEndpointConnections List.
PrivateLinkServiceConnectionState	Obtém ou define o estado de conexão do serviço de link privado.
ProvisioningState	Obtém ou define o estado de provisionamento da conexão de ponto de extremidade privado.
PublicNetworkAccess	para habilitar ou desabilitar o tráfego de rede de entrada do provedor de recursos de clientes públicos
RedundancySettings	As configurações de redundância de um cofre
ResourceIdentityType	O tipo de identidade gerenciada usada. O tipo 'SystemAssigned, UserAssigned' inclui uma identidade criada implicitamente e um conjunto de identidades atribuídas pelo usuário. O tipo 'None' removerá todas as identidades.
ResourceMoveState	O estado do recurso após a operação de movimentação
RestoreSettings	Restaurar configurações do cofre
SecureScoreLevel	Classificação segura do Cofre dos Serviços de Recuperação
SecuritySettings	Configurações de segurança do cofre
Sku	Identifica o identificador de sistema exclusivo para cada recurso do Azure.
SkuName	O nome do SKU é RS0 (0ª versão dos Serviços de Recuperação) e a camada é a camada padrão. Eles não têm efeito na redundância de armazenamento de back-end ou em nenhuma outra configuração do cofre. Para gerenciar a redundância de armazenamento, use o backupstorageconfig
SoftDeleteSettings	Configurações de exclusão reversível do cofre
SoftDeleteState
standardTierStorageRedundancy	A configuração de redundância de armazenamento de um cofre
systemData	Metadados relativos à criação e à última modificação do recurso.
TriggerType	A maneira como a atualização do cofre foi disparada.
UpgradeDetails	Detalhes para atualizar o cofre.
UserIdentity	Uma identidade de recurso gerenciada pelo usuário do serviço.
Vault	Informações de recurso, conforme retornado pelo provedor de recursos.
VaultPrivateEndpointState	Estado do ponto de extremidade privado para backup.
VaultProperties	Propriedades do cofre.
VaultSubResourceType	Tipo de sub-recurso para cofre AzureBackup, AzureBackup_secondary ou AzureSiteRecovery
VaultUpgradeState	Status da operação de atualização do cofre.

AlertsState

Nome	Tipo	Description
Disabled	string
Enabled	string

AzureMonitorAlertSettings

Configurações para alertas baseados no Azure Monitor

Nome	Tipo	Description
alertsForAllJobFailures	AlertsState

BackupStorageVersion

Versão de armazenamento de backup

Nome	Tipo	Description
Unassigned	string
V1	string
V2	string

ClassicAlertSettings

Configurações para alertas clássicos

Nome	Tipo	Description
alertsForCriticalOperations	AlertsState

CloudError

CloudError

Nome	Tipo	Description
error	Error	A resposta de erro de gerenciamento de recursos.

CmkKekIdentity

Os detalhes da identidade usada para CMK

Nome	Tipo	Description
useSystemAssignedIdentity	boolean	Indique que a identidade atribuída pelo sistema deve ser usada. Mutuamente exclusivo com o campo 'userAssignedIdentity'
userAssignedIdentity	string	A identidade atribuída pelo usuário a ser usada para conceder permissões caso o tipo de identidade usada seja UserAssigned

CmkKeyVaultProperties

As propriedades do Key Vault que hospeda a CMK

Nome	Tipo	Description
keyUri	string	O URI de chave da chave gerenciada pelo cliente

createdByType

O tipo de identidade que criou o recurso.

Nome	Tipo	Description
Application	string
Key	string
ManagedIdentity	string
User	string

crossRegionRestore

Sinalizador para mostrar se a Restauração entre Regiões está habilitada no Cofre ou não

Nome	Tipo	Description
Disabled	string
Enabled	string

CrossSubscriptionRestoreSettings

Configurações para configurações de restauração entre assinaturas

Nome	Tipo	Description
crossSubscriptionRestoreState	crossSubscriptionRestoreState

crossSubscriptionRestoreState

Nome	Tipo	Description
Disabled	string
Enabled	string
PermanentlyDisabled	string

Encryption

Detalhes da Chave Gerenciada pelo Cliente do recurso.

Nome	Tipo	Description
infrastructureEncryption	InfrastructureEncryptionState	Habilitar/desabilitar o estado de Criptografia Dupla
kekIdentity	CmkKekIdentity	Os detalhes da identidade usada para CMK
keyVaultProperties	CmkKeyVaultProperties	As propriedades do Key Vault que hospeda a CMK

Error

A resposta de erro de gerenciamento de recursos.

Nome	Tipo	Description
additionalInfo	ErrorAdditionalInfo[]	As informações adicionais do erro.
code	string	O código de erro.
details	Error[]	Os detalhes do erro.
message	string	A mensagem de erro.
target	string	O destino do erro.

ErrorAdditionalInfo

As informações adicionais do erro de gerenciamento de recursos.

Nome	Tipo	Description
info	object	As informações adicionais.
type	string	O tipo de informação adicional.

IdentityData

Identidade do recurso.

Nome	Tipo	Description
principalId	string	A ID da entidade de segurança da identidade do recurso.
tenantId	string	A ID do locatário do recurso.
type	ResourceIdentityType	O tipo de identidade gerenciada usada. O tipo 'SystemAssigned, UserAssigned' inclui uma identidade criada implicitamente e um conjunto de identidades atribuídas pelo usuário. O tipo 'None' removerá todas as identidades.
userAssignedIdentities	<string,  UserIdentity>	A lista de identidades atribuídas pelo usuário associadas ao recurso. As chaves do dicionário de identidade atribuídas pelo usuário serão IDs de recurso do ARM no formato: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.

ImmutabilitySettings

Configurações de Imutabilidade do cofre

Nome	Tipo	Description
state	ImmutabilityState

ImmutabilityState

Nome	Tipo	Description
Disabled	string
Locked	string
Unlocked	string

InfrastructureEncryptionState

Habilitando/desabilitando o estado de Criptografia Dupla

Nome	Tipo	Description
Disabled	string
Enabled	string

MonitoringSettings

Configurações de monitoramento do cofre

Nome	Tipo	Description
azureMonitorAlertSettings	AzureMonitorAlertSettings	Configurações para alertas baseados no Azure Monitor
classicAlertSettings	ClassicAlertSettings	Configurações para alertas clássicos

MoveDetails

Os detalhes da operação de movimentação mais recente executada no Recurso do Azure

Nome	Tipo	Description
completionTimeUtc	string	Hora de término da operação de movimentação de recursos
operationId	string	OperationId da operação de movimentação de recursos
sourceResourceId	string	Recurso de origem da operação de movimentação de recursos
startTimeUtc	string	Hora de início da operação de movimentação de recursos
targetResourceId	string	Recurso de destino da operação de movimentação de recursos

MultiUserAuthorization

Configurações de MUA do cofre

Nome	Tipo	Description
Disabled	string
Enabled	string
Invalid	string

PrivateEndpoint

O recurso de rede de ponto de extremidade privado que está vinculado à conexão de ponto de extremidade privado.

Nome	Tipo	Description
id	string	Obtém ou define a ID.

PrivateEndpointConnection

Propriedades de resposta de conexão de ponto de extremidade privado.

Nome	Tipo	Description
groupIds	VaultSubResourceType[]	IDs de grupo para o ponto de extremidade privado
privateEndpoint	PrivateEndpoint	O recurso de rede de ponto de extremidade privado que está vinculado à conexão de ponto de extremidade privado.
privateLinkServiceConnectionState	PrivateLinkServiceConnectionState	Obtém ou define o estado de conexão do serviço de link privado.
provisioningState	ProvisioningState	Obtém ou define o estado de provisionamento da conexão de ponto de extremidade privado.

PrivateEndpointConnectionStatus

Obtém ou define o status.

Nome	Tipo	Description
Approved	string
Disconnected	string
Pending	string
Rejected	string

PrivateEndpointConnectionVaultProperties

Informações a serem armazenadas nas propriedades do Cofre como um elemento de privateEndpointConnections List.

Nome	Tipo	Description
id	string	Formato de assinaturas de ID/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft. [Service]/{resource}/{resourceName}/privateEndpointConnections/{connectionName}.
location	string	O local da conexão de ponto de extremidade privado
name	string	O nome da conexão de ponto de extremidade privado
properties	PrivateEndpointConnection	Propriedades de resposta de conexão de ponto de extremidade privado.
type	string	O tipo, que será do formato Microsoft.RecoveryServices/vaults/privateEndpointConnections

PrivateLinkServiceConnectionState

Obtém ou define o estado de conexão do serviço de link privado.

Nome	Tipo	Description
actionsRequired	string	Obtém ou define as ações necessárias.
description	string	Obtém ou define a descrição.
status	PrivateEndpointConnectionStatus	Obtém ou define o status.

ProvisioningState

Obtém ou define o estado de provisionamento da conexão de ponto de extremidade privado.

Nome	Tipo	Description
Deleting	string
Failed	string
Pending	string
Succeeded	string

PublicNetworkAccess

para habilitar ou desabilitar o tráfego de rede de entrada do provedor de recursos de clientes públicos

Nome	Tipo	Description
Disabled	string
Enabled	string

RedundancySettings

As configurações de redundância de um cofre

Nome	Tipo	Description
crossRegionRestore	crossRegionRestore	Sinalizador para mostrar se a Restauração Entre Regiões está habilitada no Cofre ou não
standardTierStorageRedundancy	standardTierStorageRedundancy	A configuração de redundância de armazenamento de um cofre

ResourceIdentityType

O tipo de identidade gerenciada usada. O tipo 'SystemAssigned, UserAssigned' inclui uma identidade criada implicitamente e um conjunto de identidades atribuídas pelo usuário. O tipo 'None' removerá todas as identidades.

Nome	Tipo	Description
None	string
SystemAssigned	string
SystemAssigned, UserAssigned	string
UserAssigned	string

ResourceMoveState

O estado do recurso após a operação de movimentação

Nome	Tipo	Description
CommitFailed	string
CommitTimedout	string
CriticalFailure	string
Failure	string
InProgress	string
MoveSucceeded	string
PartialSuccess	string
PrepareFailed	string
PrepareTimedout	string
Unknown	string

RestoreSettings

Restaurar configurações do cofre

Nome	Tipo	Description
crossSubscriptionRestoreSettings	CrossSubscriptionRestoreSettings	Configurações para CrossSubscriptionRestore

SecureScoreLevel

Classificação segura do Cofre dos Serviços de Recuperação

Nome	Tipo	Description
Adequate	string
Maximum	string
Minimum	string
None	string

SecuritySettings

Configurações de segurança do cofre

Nome	Tipo	Description
immutabilitySettings	ImmutabilitySettings	Configurações de Imutabilidade de um cofre
multiUserAuthorization	MultiUserAuthorization	Configurações de MUA de um cofre
softDeleteSettings	SoftDeleteSettings	Configurações de exclusão reversível de um cofre

Sku

Identifica o identificador de sistema exclusivo para cada recurso do Azure.

Nome	Tipo	Description
capacity	string	A capacidade do SKU
family	string	A família SKU
name	SkuName	O nome do SKU é RS0 (0ª versão dos Serviços de Recuperação) e a camada é standard. Elas não têm efeito na redundância de armazenamento de back-end nem em nenhuma outra configuração de cofre. Para gerenciar a redundância de armazenamento, use o backupstorageconfig
size	string	O tamanho da SKU
tier	string	A camada de SKU.

SkuName

O nome do SKU é RS0 (0ª versão dos Serviços de Recuperação) e a camada é a camada padrão. Eles não têm efeito na redundância de armazenamento de back-end ou em nenhuma outra configuração do cofre. Para gerenciar a redundância de armazenamento, use o backupstorageconfig

Nome	Tipo	Description
RS0	string
Standard	string

SoftDeleteSettings

Configurações de exclusão reversível do cofre

Nome	Tipo	Description
softDeleteRetentionPeriodInDays	integer	Período de retenção de exclusão temporária em dias
softDeleteState	SoftDeleteState

SoftDeleteState

Nome	Tipo	Description
AlwaysON	string
Disabled	string
Enabled	string
Invalid	string

standardTierStorageRedundancy

A configuração de redundância de armazenamento de um cofre

Nome	Tipo	Description
GeoRedundant	string
LocallyRedundant	string
ZoneRedundant	string

systemData

Metadados relativos à criação e à última modificação do recurso.

Nome	Tipo	Description
createdAt	string	O carimbo de data/hora da criação de recursos (UTC).
createdBy	string	A identidade que criou o recurso.
createdByType	createdByType	O tipo de identidade que criou o recurso.
lastModifiedAt	string	O tipo de identidade que modificou o recurso pela última vez.
lastModifiedBy	string	A identidade que modificou o recurso pela última vez.
lastModifiedByType	createdByType	O tipo de identidade que modificou o recurso pela última vez.

TriggerType

A maneira como a atualização do cofre foi disparada.

Nome	Tipo	Description
ForcedUpgrade	string
UserTriggered	string

UpgradeDetails

Detalhes para atualizar o cofre.

Nome	Tipo	Description
endTimeUtc	string	Hora UTC em que a operação de atualização terminou.
lastUpdatedTimeUtc	string	Hora UTC em que a operação de atualização status foi atualizada pela última vez.
message	string	Mensagem para o usuário que contém informações sobre a operação de atualização.
operationId	string	ID da operação de atualização do cofre.
previousResourceId	string	ID do recurso do cofre antes da atualização.
startTimeUtc	string	Hora UTC em que a operação de atualização foi iniciada.
status	VaultUpgradeState	Status da operação de atualização do cofre.
triggerType	TriggerType	A maneira como a atualização do cofre foi disparada.
upgradedResourceId	string	ID do recurso do cofre atualizado.

UserIdentity

Uma identidade de recurso gerenciada pelo usuário do serviço.

Nome	Tipo	Description
clientId	string	A ID do cliente da identidade atribuída pelo usuário.
principalId	string	A ID da entidade de segurança da identidade atribuída pelo usuário.

Vault

Informações de recurso, conforme retornado pelo provedor de recursos.

Nome	Tipo	Description
etag	string	ETag opcional.
id	string	A ID do recurso representa o caminho completo para o recurso.
identity	IdentityData	Identidade do recurso.
location	string	Local do recurso.
name	string	Nome do recurso associado ao recurso.
properties	VaultProperties	Propriedades do cofre.
sku	Sku	Identifica o identificador de sistema exclusivo para cada recurso do Azure.
systemData	systemData	Metadados relativos à criação e à última modificação do recurso.
tags	object	Marcas de recurso.
type	string	O tipo de recurso representa o caminho completo do formulário Namespace/ResourceType/ResourceType/...

VaultPrivateEndpointState

Estado do ponto de extremidade privado para backup.

Nome	Tipo	Description
Enabled	string
None	string

VaultProperties

Propriedades do cofre.

Nome	Tipo	Description
backupStorageVersion	BackupStorageVersion	Versão de armazenamento de backup
encryption	Encryption	Detalhes da Chave Gerenciada pelo Cliente do recurso.
monitoringSettings	MonitoringSettings	Configurações de monitoramento do cofre
moveDetails	MoveDetails	Os detalhes da operação de movimentação mais recente executada no Recurso do Azure
moveState	ResourceMoveState	O estado do recurso após a operação de movimentação
privateEndpointConnections	PrivateEndpointConnectionVaultProperties[]	Lista de conexão de ponto de extremidade privado.
privateEndpointStateForBackup	VaultPrivateEndpointState	Estado do ponto de extremidade privado para backup.
privateEndpointStateForSiteRecovery	VaultPrivateEndpointState	Estado do ponto de extremidade privado para recuperação de site.
provisioningState	string	Estado de provisionamento.
publicNetworkAccess	PublicNetworkAccess	para habilitar ou desabilitar o tráfego de rede de entrada do provedor de recursos de clientes públicos
redundancySettings	RedundancySettings	As configurações de redundância de um cofre
restoreSettings	RestoreSettings	Restaurar configurações do cofre
secureScore	SecureScoreLevel	Classificação de segurança do cofre dos Serviços de Recuperação
securitySettings	SecuritySettings	Configurações de segurança do cofre
upgradeDetails	UpgradeDetails	Detalhes para atualizar o cofre.

VaultSubResourceType

Tipo de sub-recurso para cofre AzureBackup, AzureBackup_secondary ou AzureSiteRecovery

Nome	Tipo	Description
AzureBackup	string
AzureBackup_secondary	string
AzureSiteRecovery	string

VaultUpgradeState

Status da operação de atualização do cofre.

Nome	Tipo	Description
Failed	string
InProgress	string
Unknown	string
Upgraded	string