Vaults - Update

Serviço:: Key Vault

Versão da API:: 2024-11-01

Atualize um cofre de chaves na assinatura especificada.

PATCH https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}?api-version=2024-11-01

Parâmetros do URI

Name	Em	Necessário	Tipo	Description
resourceGroupName	path	True	string	O nome do Grupo de Recursos ao qual o servidor pertence.
subscriptionId	path	True	string	Credenciais de assinatura que identificam exclusivamente a assinatura do Microsoft Azure. O ID da assinatura faz parte do URI de cada chamada de serviço.
vaultName	path	True	string pattern: ^[a-zA-Z0-9-]{3,24}$	Nome do cofre
api-version	query	True	string	Versão da API do cliente.

Corpo do Pedido

Name	Tipo	Description
properties	VaultPatchProperties	Propriedades do cofre
tags	object	As tags que serão atribuídas ao cofre de chaves.

Respostas

Name	Tipo	Description
200 OK	Vault	Cofre corrigido
201 Created	Vault	Cofre corrigido
Other Status Codes	CloudError	Resposta de erro descrevendo por que a operação falhou.

Exemplos

Update an existing vault

Pedido de amostra

PATCH https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-resource-group/providers/Microsoft.KeyVault/vaults/sample-vault?api-version=2024-11-01

{
  "properties": {
    "tenantId": "00000000-0000-0000-0000-000000000000",
    "sku": {
      "family": "A",
      "name": "standard"
    },
    "accessPolicies": [
      {
        "tenantId": "00000000-0000-0000-0000-000000000000",
        "objectId": "00000000-0000-0000-0000-000000000000",
        "permissions": {
          "keys": [
            "encrypt",
            "decrypt",
            "wrapKey",
            "unwrapKey",
            "sign",
            "verify",
            "get",
            "list",
            "create",
            "update",
            "import",
            "delete",
            "backup",
            "restore",
            "recover",
            "purge"
          ],
          "secrets": [
            "get",
            "list",
            "set",
            "delete",
            "backup",
            "restore",
            "recover",
            "purge"
          ],
          "certificates": [
            "get",
            "list",
            "delete",
            "create",
            "import",
            "update",
            "managecontacts",
            "getissuers",
            "listissuers",
            "setissuers",
            "deleteissuers",
            "manageissuers",
            "recover",
            "purge"
          ]
        }
      }
    ],
    "enabledForDeployment": true,
    "enabledForDiskEncryption": true,
    "enabledForTemplateDeployment": true,
    "publicNetworkAccess": "Enabled"
  }
}


import com.azure.resourcemanager.keyvault.models.AccessPolicyEntry;
import com.azure.resourcemanager.keyvault.models.CertificatePermissions;
import com.azure.resourcemanager.keyvault.models.KeyPermissions;
import com.azure.resourcemanager.keyvault.models.Permissions;
import com.azure.resourcemanager.keyvault.models.SecretPermissions;
import com.azure.resourcemanager.keyvault.models.Sku;
import com.azure.resourcemanager.keyvault.models.SkuFamily;
import com.azure.resourcemanager.keyvault.models.SkuName;
import com.azure.resourcemanager.keyvault.models.VaultPatchParameters;
import com.azure.resourcemanager.keyvault.models.VaultPatchProperties;
import java.util.Arrays;
import java.util.UUID;

/**
 * Samples for Vaults Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/updateVault.json
     */
    /**
     * Sample code: Update an existing vault.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void updateAnExistingVault(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.vaults().manager().serviceClient().getVaults().updateWithResponse("sample-resource-group", "sample-vault",
            new VaultPatchParameters().withProperties(new VaultPatchProperties()
                .withTenantId(UUID.fromString("00000000-0000-0000-0000-000000000000"))
                .withSku(new Sku().withFamily(SkuFamily.A).withName(SkuName.STANDARD))
                .withAccessPolicies(Arrays.asList(new AccessPolicyEntry()
                    .withTenantId(UUID.fromString("00000000-0000-0000-0000-000000000000"))
                    .withObjectId("00000000-0000-0000-0000-000000000000")
                    .withPermissions(new Permissions()
                        .withKeys(Arrays.asList(KeyPermissions.ENCRYPT, KeyPermissions.DECRYPT, KeyPermissions.WRAP_KEY,
                            KeyPermissions.UNWRAP_KEY, KeyPermissions.SIGN, KeyPermissions.VERIFY, KeyPermissions.GET,
                            KeyPermissions.LIST, KeyPermissions.CREATE, KeyPermissions.UPDATE, KeyPermissions.IMPORT,
                            KeyPermissions.DELETE, KeyPermissions.BACKUP, KeyPermissions.RESTORE,
                            KeyPermissions.RECOVER, KeyPermissions.PURGE))
                        .withSecrets(Arrays.asList(SecretPermissions.GET, SecretPermissions.LIST, SecretPermissions.SET,
                            SecretPermissions.DELETE, SecretPermissions.BACKUP, SecretPermissions.RESTORE,
                            SecretPermissions.RECOVER, SecretPermissions.PURGE))
                        .withCertificates(Arrays.asList(CertificatePermissions.GET, CertificatePermissions.LIST,
                            CertificatePermissions.DELETE, CertificatePermissions.CREATE, CertificatePermissions.IMPORT,
                            CertificatePermissions.UPDATE, CertificatePermissions.MANAGECONTACTS,
                            CertificatePermissions.GETISSUERS, CertificatePermissions.LISTISSUERS,
                            CertificatePermissions.SETISSUERS, CertificatePermissions.DELETEISSUERS,
                            CertificatePermissions.MANAGEISSUERS, CertificatePermissions.RECOVER,
                            CertificatePermissions.PURGE)))))
                .withEnabledForDeployment(true).withEnabledForDiskEncryption(true)
                .withEnabledForTemplateDeployment(true).withPublicNetworkAccess("Enabled")),
            com.azure.core.util.Context.NONE);
    }
}

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

from azure.identity import DefaultAzureCredential

from azure.mgmt.keyvault import KeyVaultManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-keyvault
# USAGE
    python update_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 = KeyVaultManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="00000000-0000-0000-0000-000000000000",
    )

    response = client.vaults.update(
        resource_group_name="sample-resource-group",
        vault_name="sample-vault",
        parameters={
            "properties": {
                "accessPolicies": [
                    {
                        "objectId": "00000000-0000-0000-0000-000000000000",
                        "permissions": {
                            "certificates": [
                                "get",
                                "list",
                                "delete",
                                "create",
                                "import",
                                "update",
                                "managecontacts",
                                "getissuers",
                                "listissuers",
                                "setissuers",
                                "deleteissuers",
                                "manageissuers",
                                "recover",
                                "purge",
                            ],
                            "keys": [
                                "encrypt",
                                "decrypt",
                                "wrapKey",
                                "unwrapKey",
                                "sign",
                                "verify",
                                "get",
                                "list",
                                "create",
                                "update",
                                "import",
                                "delete",
                                "backup",
                                "restore",
                                "recover",
                                "purge",
                            ],
                            "secrets": ["get", "list", "set", "delete", "backup", "restore", "recover", "purge"],
                        },
                        "tenantId": "00000000-0000-0000-0000-000000000000",
                    }
                ],
                "enabledForDeployment": True,
                "enabledForDiskEncryption": True,
                "enabledForTemplateDeployment": True,
                "publicNetworkAccess": "Enabled",
                "sku": {"family": "A", "name": "standard"},
                "tenantId": "00000000-0000-0000-0000-000000000000",
            }
        },
    )
    print(response)


# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/updateVault.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

package armkeyvault_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/keyvault/armkeyvault"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/ee1eec42dcc710ff88db2d1bf574b2f9afe3d654/specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/updateVault.json
func ExampleVaultsClient_Update() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armkeyvault.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewVaultsClient().Update(ctx, "sample-resource-group", "sample-vault", armkeyvault.VaultPatchParameters{
		Properties: &armkeyvault.VaultPatchProperties{
			AccessPolicies: []*armkeyvault.AccessPolicyEntry{
				{
					ObjectID: to.Ptr("00000000-0000-0000-0000-000000000000"),
					Permissions: &armkeyvault.Permissions{
						Certificates: []*armkeyvault.CertificatePermissions{
							to.Ptr(armkeyvault.CertificatePermissionsGet),
							to.Ptr(armkeyvault.CertificatePermissionsList),
							to.Ptr(armkeyvault.CertificatePermissionsDelete),
							to.Ptr(armkeyvault.CertificatePermissionsCreate),
							to.Ptr(armkeyvault.CertificatePermissionsImport),
							to.Ptr(armkeyvault.CertificatePermissionsUpdate),
							to.Ptr(armkeyvault.CertificatePermissionsManagecontacts),
							to.Ptr(armkeyvault.CertificatePermissionsGetissuers),
							to.Ptr(armkeyvault.CertificatePermissionsListissuers),
							to.Ptr(armkeyvault.CertificatePermissionsSetissuers),
							to.Ptr(armkeyvault.CertificatePermissionsDeleteissuers),
							to.Ptr(armkeyvault.CertificatePermissionsManageissuers),
							to.Ptr(armkeyvault.CertificatePermissionsRecover),
							to.Ptr(armkeyvault.CertificatePermissionsPurge)},
						Keys: []*armkeyvault.KeyPermissions{
							to.Ptr(armkeyvault.KeyPermissionsEncrypt),
							to.Ptr(armkeyvault.KeyPermissionsDecrypt),
							to.Ptr(armkeyvault.KeyPermissionsWrapKey),
							to.Ptr(armkeyvault.KeyPermissionsUnwrapKey),
							to.Ptr(armkeyvault.KeyPermissionsSign),
							to.Ptr(armkeyvault.KeyPermissionsVerify),
							to.Ptr(armkeyvault.KeyPermissionsGet),
							to.Ptr(armkeyvault.KeyPermissionsList),
							to.Ptr(armkeyvault.KeyPermissionsCreate),
							to.Ptr(armkeyvault.KeyPermissionsUpdate),
							to.Ptr(armkeyvault.KeyPermissionsImport),
							to.Ptr(armkeyvault.KeyPermissionsDelete),
							to.Ptr(armkeyvault.KeyPermissionsBackup),
							to.Ptr(armkeyvault.KeyPermissionsRestore),
							to.Ptr(armkeyvault.KeyPermissionsRecover),
							to.Ptr(armkeyvault.KeyPermissionsPurge)},
						Secrets: []*armkeyvault.SecretPermissions{
							to.Ptr(armkeyvault.SecretPermissionsGet),
							to.Ptr(armkeyvault.SecretPermissionsList),
							to.Ptr(armkeyvault.SecretPermissionsSet),
							to.Ptr(armkeyvault.SecretPermissionsDelete),
							to.Ptr(armkeyvault.SecretPermissionsBackup),
							to.Ptr(armkeyvault.SecretPermissionsRestore),
							to.Ptr(armkeyvault.SecretPermissionsRecover),
							to.Ptr(armkeyvault.SecretPermissionsPurge)},
					},
					TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"),
				}},
			EnabledForDeployment:         to.Ptr(true),
			EnabledForDiskEncryption:     to.Ptr(true),
			EnabledForTemplateDeployment: to.Ptr(true),
			PublicNetworkAccess:          to.Ptr("Enabled"),
			SKU: &armkeyvault.SKU{
				Name:   to.Ptr(armkeyvault.SKUNameStandard),
				Family: to.Ptr(armkeyvault.SKUFamilyA),
			},
			TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %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 = armkeyvault.Vault{
	// 	Name: to.Ptr("sample-vault"),
	// 	Type: to.Ptr("Microsoft.KeyVault/vaults"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-resource-group/providers/Microsoft.KeyVault/vaults/sample-vault"),
	// 	Location: to.Ptr("westus"),
	// 	Properties: &armkeyvault.VaultProperties{
	// 		AccessPolicies: []*armkeyvault.AccessPolicyEntry{
	// 			{
	// 				ObjectID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 				Permissions: &armkeyvault.Permissions{
	// 					Certificates: []*armkeyvault.CertificatePermissions{
	// 						to.Ptr(armkeyvault.CertificatePermissionsGet),
	// 						to.Ptr(armkeyvault.CertificatePermissionsList),
	// 						to.Ptr(armkeyvault.CertificatePermissionsDelete),
	// 						to.Ptr(armkeyvault.CertificatePermissionsCreate),
	// 						to.Ptr(armkeyvault.CertificatePermissionsImport),
	// 						to.Ptr(armkeyvault.CertificatePermissionsUpdate),
	// 						to.Ptr(armkeyvault.CertificatePermissionsManagecontacts),
	// 						to.Ptr(armkeyvault.CertificatePermissionsGetissuers),
	// 						to.Ptr(armkeyvault.CertificatePermissionsListissuers),
	// 						to.Ptr(armkeyvault.CertificatePermissionsSetissuers),
	// 						to.Ptr(armkeyvault.CertificatePermissionsDeleteissuers),
	// 						to.Ptr(armkeyvault.CertificatePermissionsManageissuers),
	// 						to.Ptr(armkeyvault.CertificatePermissionsRecover),
	// 						to.Ptr(armkeyvault.CertificatePermissionsPurge)},
	// 						Keys: []*armkeyvault.KeyPermissions{
	// 							to.Ptr(armkeyvault.KeyPermissionsEncrypt),
	// 							to.Ptr(armkeyvault.KeyPermissionsDecrypt),
	// 							to.Ptr(armkeyvault.KeyPermissionsWrapKey),
	// 							to.Ptr(armkeyvault.KeyPermissionsUnwrapKey),
	// 							to.Ptr(armkeyvault.KeyPermissionsSign),
	// 							to.Ptr(armkeyvault.KeyPermissionsVerify),
	// 							to.Ptr(armkeyvault.KeyPermissionsGet),
	// 							to.Ptr(armkeyvault.KeyPermissionsList),
	// 							to.Ptr(armkeyvault.KeyPermissionsCreate),
	// 							to.Ptr(armkeyvault.KeyPermissionsUpdate),
	// 							to.Ptr(armkeyvault.KeyPermissionsImport),
	// 							to.Ptr(armkeyvault.KeyPermissionsDelete),
	// 							to.Ptr(armkeyvault.KeyPermissionsBackup),
	// 							to.Ptr(armkeyvault.KeyPermissionsRestore),
	// 							to.Ptr(armkeyvault.KeyPermissionsRecover),
	// 							to.Ptr(armkeyvault.KeyPermissionsPurge)},
	// 							Secrets: []*armkeyvault.SecretPermissions{
	// 								to.Ptr(armkeyvault.SecretPermissionsGet),
	// 								to.Ptr(armkeyvault.SecretPermissionsList),
	// 								to.Ptr(armkeyvault.SecretPermissionsSet),
	// 								to.Ptr(armkeyvault.SecretPermissionsDelete),
	// 								to.Ptr(armkeyvault.SecretPermissionsBackup),
	// 								to.Ptr(armkeyvault.SecretPermissionsRestore),
	// 								to.Ptr(armkeyvault.SecretPermissionsRecover),
	// 								to.Ptr(armkeyvault.SecretPermissionsPurge)},
	// 							},
	// 							TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 					}},
	// 					EnabledForDeployment: to.Ptr(true),
	// 					EnabledForDiskEncryption: to.Ptr(true),
	// 					EnabledForTemplateDeployment: to.Ptr(true),
	// 					HsmPoolResourceID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 					NetworkACLs: &armkeyvault.NetworkRuleSet{
	// 						Bypass: to.Ptr(armkeyvault.NetworkRuleBypassOptionsAzureServices),
	// 						DefaultAction: to.Ptr(armkeyvault.NetworkRuleActionDeny),
	// 						IPRules: []*armkeyvault.IPRule{
	// 							{
	// 								Value: to.Ptr(""),
	// 						}},
	// 						VirtualNetworkRules: []*armkeyvault.VirtualNetworkRule{
	// 							{
	// 								ID: to.Ptr(""),
	// 								IgnoreMissingVnetServiceEndpoint: to.Ptr(false),
	// 						}},
	// 					},
	// 					PrivateEndpointConnections: []*armkeyvault.PrivateEndpointConnectionItem{
	// 						{
	// 							ID: to.Ptr(""),
	// 							Properties: &armkeyvault.PrivateEndpointConnectionProperties{
	// 								PrivateEndpoint: &armkeyvault.PrivateEndpoint{
	// 									ID: to.Ptr(""),
	// 								},
	// 								PrivateLinkServiceConnectionState: &armkeyvault.PrivateLinkServiceConnectionState{
	// 									ActionsRequired: to.Ptr(armkeyvault.ActionsRequiredNone),
	// 									Status: to.Ptr(armkeyvault.PrivateEndpointServiceConnectionStatusApproved),
	// 								},
	// 								ProvisioningState: to.Ptr(armkeyvault.PrivateEndpointConnectionProvisioningStateSucceeded),
	// 							},
	// 					}},
	// 					ProvisioningState: to.Ptr(armkeyvault.VaultProvisioningStateSucceeded),
	// 					PublicNetworkAccess: to.Ptr("Enabled"),
	// 					SKU: &armkeyvault.SKU{
	// 						Name: to.Ptr(armkeyvault.SKUNameStandard),
	// 						Family: to.Ptr(armkeyvault.SKUFamilyA),
	// 					},
	// 					TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 					VaultURI: to.Ptr("https://sample-vault.vault.azure.net"),
	// 				},
	// 				SystemData: &armkeyvault.SystemData{
	// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T12:00:00.000Z"); return t}()),
	// 					CreatedBy: to.Ptr("keyVaultUser1"),
	// 					CreatedByType: to.Ptr(armkeyvault.IdentityTypeUser),
	// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T12:00:00.000Z"); return t}()),
	// 					LastModifiedBy: to.Ptr("keyVaultUser2"),
	// 					LastModifiedByType: to.Ptr(armkeyvault.IdentityTypeUser),
	// 				},
	// 				Tags: map[string]*string{
	// 				},
	// 			}
}

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

const { KeyVaultManagementClient } = require("@azure/arm-keyvault");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Update a key vault in the specified subscription.
 *
 * @summary Update a key vault in the specified subscription.
 * x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/updateVault.json
 */
async function updateAnExistingVault() {
  const subscriptionId =
    process.env["KEYVAULT_SUBSCRIPTION_ID"] || "00000000-0000-0000-0000-000000000000";
  const resourceGroupName = process.env["KEYVAULT_RESOURCE_GROUP"] || "sample-resource-group";
  const vaultName = "sample-vault";
  const parameters = {
    properties: {
      accessPolicies: [
        {
          objectId: "00000000-0000-0000-0000-000000000000",
          permissions: {
            certificates: [
              "get",
              "list",
              "delete",
              "create",
              "import",
              "update",
              "managecontacts",
              "getissuers",
              "listissuers",
              "setissuers",
              "deleteissuers",
              "manageissuers",
              "recover",
              "purge",
            ],
            keys: [
              "encrypt",
              "decrypt",
              "wrapKey",
              "unwrapKey",
              "sign",
              "verify",
              "get",
              "list",
              "create",
              "update",
              "import",
              "delete",
              "backup",
              "restore",
              "recover",
              "purge",
            ],
            secrets: ["get", "list", "set", "delete", "backup", "restore", "recover", "purge"],
          },
          tenantId: "00000000-0000-0000-0000-000000000000",
        },
      ],
      enabledForDeployment: true,
      enabledForDiskEncryption: true,
      enabledForTemplateDeployment: true,
      publicNetworkAccess: "Enabled",
      sku: { name: "standard", family: "A" },
      tenantId: "00000000-0000-0000-0000-000000000000",
    },
  };
  const credential = new DefaultAzureCredential();
  const client = new KeyVaultManagementClient(credential, subscriptionId);
  const result = await client.vaults.update(resourceGroupName, vaultName, parameters);
  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

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.KeyVault.Models;
using Azure.ResourceManager.KeyVault;

// Generated from example definition: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/updateVault.json
// this example is just showing the usage of "Vaults_Update" 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 KeyVaultResource created on azure
// for more information of creating KeyVaultResource, please refer to the document of KeyVaultResource
string subscriptionId = "00000000-0000-0000-0000-000000000000";
string resourceGroupName = "sample-resource-group";
string vaultName = "sample-vault";
ResourceIdentifier keyVaultResourceId = KeyVaultResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, vaultName);
KeyVaultResource keyVault = client.GetKeyVaultResource(keyVaultResourceId);

// invoke the operation
KeyVaultPatch patch = new KeyVaultPatch
{
    Properties = new KeyVaultPatchProperties
    {
        TenantId = Guid.Parse("00000000-0000-0000-0000-000000000000"),
        Sku = new KeyVaultSku(KeyVaultSkuFamily.A, KeyVaultSkuName.Standard),
        AccessPolicies = {new KeyVaultAccessPolicy(Guid.Parse("00000000-0000-0000-0000-000000000000"), "00000000-0000-0000-0000-000000000000", new IdentityAccessPermissions
        {
        Keys = {IdentityAccessKeyPermission.Encrypt, IdentityAccessKeyPermission.Decrypt, IdentityAccessKeyPermission.WrapKey, IdentityAccessKeyPermission.UnwrapKey, IdentityAccessKeyPermission.Sign, IdentityAccessKeyPermission.Verify, IdentityAccessKeyPermission.Get, IdentityAccessKeyPermission.List, IdentityAccessKeyPermission.Create, IdentityAccessKeyPermission.Update, IdentityAccessKeyPermission.Import, IdentityAccessKeyPermission.Delete, IdentityAccessKeyPermission.Backup, IdentityAccessKeyPermission.Restore, IdentityAccessKeyPermission.Recover, IdentityAccessKeyPermission.Purge},
        Secrets = {IdentityAccessSecretPermission.Get, IdentityAccessSecretPermission.List, IdentityAccessSecretPermission.Set, IdentityAccessSecretPermission.Delete, IdentityAccessSecretPermission.Backup, IdentityAccessSecretPermission.Restore, IdentityAccessSecretPermission.Recover, IdentityAccessSecretPermission.Purge},
        Certificates = {IdentityAccessCertificatePermission.Get, IdentityAccessCertificatePermission.List, IdentityAccessCertificatePermission.Delete, IdentityAccessCertificatePermission.Create, IdentityAccessCertificatePermission.Import, IdentityAccessCertificatePermission.Update, IdentityAccessCertificatePermission.ManageContacts, IdentityAccessCertificatePermission.GetIssuers, IdentityAccessCertificatePermission.ListIssuers, IdentityAccessCertificatePermission.SetIssuers, IdentityAccessCertificatePermission.DeleteIssuers, IdentityAccessCertificatePermission.ManageIssuers, IdentityAccessCertificatePermission.Recover, IdentityAccessCertificatePermission.Purge},
        })},
        EnabledForDeployment = true,
        EnabledForDiskEncryption = true,
        EnabledForTemplateDeployment = true,
        PublicNetworkAccess = "Enabled",
    },
};
KeyVaultResource result = await keyVault.UpdateAsync(patch);

// 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
KeyVaultData 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

Resposta da amostra

Código de estado:: 200

{
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-resource-group/providers/Microsoft.KeyVault/vaults/sample-vault",
  "name": "sample-vault",
  "type": "Microsoft.KeyVault/vaults",
  "location": "westus",
  "tags": {},
  "systemData": {
    "createdBy": "keyVaultUser1",
    "createdByType": "User",
    "createdAt": "2020-01-01T12:00:00.0000000Z",
    "lastModifiedBy": "keyVaultUser2",
    "lastModifiedByType": "User",
    "lastModifiedAt": "2020-01-01T12:00:00.0000000Z"
  },
  "properties": {
    "sku": {
      "family": "A",
      "name": "standard"
    },
    "tenantId": "00000000-0000-0000-0000-000000000000",
    "networkAcls": {
      "bypass": "AzureServices",
      "defaultAction": "Deny",
      "ipRules": [
        {
          "value": ""
        }
      ],
      "virtualNetworkRules": [
        {
          "id": "",
          "ignoreMissingVnetServiceEndpoint": false
        }
      ]
    },
    "accessPolicies": [
      {
        "tenantId": "00000000-0000-0000-0000-000000000000",
        "objectId": "00000000-0000-0000-0000-000000000000",
        "permissions": {
          "keys": [
            "encrypt",
            "decrypt",
            "wrapKey",
            "unwrapKey",
            "sign",
            "verify",
            "get",
            "list",
            "create",
            "update",
            "import",
            "delete",
            "backup",
            "restore",
            "recover",
            "purge"
          ],
          "secrets": [
            "get",
            "list",
            "set",
            "delete",
            "backup",
            "restore",
            "recover",
            "purge"
          ],
          "certificates": [
            "get",
            "list",
            "delete",
            "create",
            "import",
            "update",
            "managecontacts",
            "getissuers",
            "listissuers",
            "setissuers",
            "deleteissuers",
            "manageissuers",
            "recover",
            "purge"
          ]
        }
      }
    ],
    "privateEndpointConnections": [
      {
        "id": "",
        "properties": {
          "provisioningState": "Succeeded",
          "privateEndpoint": {
            "id": ""
          },
          "privateLinkServiceConnectionState": {
            "status": "Approved",
            "actionsRequired": "None"
          }
        }
      }
    ],
    "enabledForDeployment": true,
    "enabledForDiskEncryption": true,
    "enabledForTemplateDeployment": true,
    "hsmPoolResourceId": "00000000-0000-0000-0000-000000000000",
    "vaultUri": "https://sample-vault.vault.azure.net",
    "provisioningState": "Succeeded",
    "publicNetworkAccess": "Enabled"
  }
}

Código de estado:: 201

{
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-resource-group/providers/Microsoft.KeyVault/vaults/sample-vault",
  "name": "sample-vault",
  "type": "Microsoft.KeyVault/vaults",
  "location": "westus",
  "tags": {},
  "systemData": {
    "createdBy": "keyVaultUser1",
    "createdByType": "User",
    "createdAt": "2020-01-01T12:00:00.0000000Z",
    "lastModifiedBy": "keyVaultUser2",
    "lastModifiedByType": "User",
    "lastModifiedAt": "2020-01-01T12:00:00.0000000Z"
  },
  "properties": {
    "sku": {
      "family": "A",
      "name": "standard"
    },
    "tenantId": "00000000-0000-0000-0000-000000000000",
    "accessPolicies": [
      {
        "tenantId": "00000000-0000-0000-0000-000000000000",
        "objectId": "00000000-0000-0000-0000-000000000000",
        "permissions": {
          "keys": [
            "encrypt",
            "decrypt",
            "wrapKey",
            "unwrapKey",
            "sign",
            "verify",
            "get",
            "list",
            "create",
            "update",
            "import",
            "delete",
            "backup",
            "restore",
            "recover",
            "purge"
          ],
          "secrets": [
            "get",
            "list",
            "set",
            "delete",
            "backup",
            "restore",
            "recover",
            "purge"
          ],
          "certificates": [
            "get",
            "list",
            "delete",
            "create",
            "import",
            "update",
            "managecontacts",
            "getissuers",
            "listissuers",
            "setissuers",
            "deleteissuers",
            "manageissuers",
            "recover",
            "purge"
          ]
        }
      }
    ],
    "enabledForDeployment": true,
    "enabledForDiskEncryption": true,
    "enabledForTemplateDeployment": true,
    "hsmPoolResourceId": "00000000-0000-0000-0000-000000000000",
    "vaultUri": "https://sample-vault.vault.azure.net",
    "provisioningState": "Succeeded",
    "publicNetworkAccess": "Enabled"
  }
}

Definições

Name	Description
AccessPolicyEntry	Uma identidade que tem acesso ao cofre de chaves. Todas as identidades na matriz devem usar o mesmo ID de locatário que o ID de locatário do cofre de chaves.
ActionsRequired	Uma mensagem indicando se as alterações no prestador de serviços exigem atualizações sobre o consumidor.
CertificatePermissions	Permissões para certificados
CloudError	Uma resposta de erro do provedor de recursos Key Vault
CloudErrorBody	Uma resposta de erro do provedor de recursos Key Vault
CreateMode	O modo de criação do cofre para indicar se o cofre precisa ser recuperado ou não.
identityType	O tipo de identidade que criou o recurso do cofre de chaves.
IPRule	Uma regra que rege a acessibilidade de um cofre a partir de um endereço IP ou intervalo de ip específico.
KeyPermissions	Permissões para chaves
NetworkRuleAction	A ação padrão quando nenhuma regra de ipRules e de virtualNetworkRules corresponder. Isso só é usado depois que a propriedade bypass foi avaliada.
NetworkRuleBypassOptions	Informa qual tráfego pode ignorar as regras de rede. Isso pode ser 'AzureServices' ou 'None'. Se não for especificado, o padrão será 'AzureServices'.
NetworkRuleSet	Um conjunto de regras que regem a acessibilidade de rede de um cofre.
Permissions	Permissões que a identidade tem para chaves, segredos, certificados e armazenamento.
PrivateEndpoint	Propriedades do objeto de ponto de extremidade privado.
PrivateEndpointConnectionItem	Item de conexão de ponto de extremidade privado.
PrivateEndpointConnectionProvisioningState	O estado de provisionamento atual.
PrivateEndpointServiceConnectionStatus	O status da conexão de ponto de extremidade privado.
PrivateLinkServiceConnectionState	Um objeto que representa o estado de aprovação da conexão de link privado.
SecretPermissions	Permissões para segredos
Sku	Detalhes do SKU
SkuFamily	Nome de família SKU
SkuName	Nome da SKU para especificar se o cofre de chaves é um cofre padrão ou um cofre premium.
StoragePermissions	Permissões para contas de armazenamento
SystemData	Metadados referentes à criação e última modificação do recurso do cofre de chaves.
Vault	Informações de recursos com detalhes estendidos.
VaultPatchParameters	Parâmetros para criar ou atualizar um cofre
VaultPatchProperties	Propriedades do cofre
VaultProperties	Propriedades do cofre
VaultProvisioningState	Estado de provisionamento do cofre.
VirtualNetworkRule	Uma regra que rege a acessibilidade de um cofre a partir de uma rede virtual específica.

AccessPolicyEntry

Object

Uma identidade que tem acesso ao cofre de chaves. Todas as identidades na matriz devem usar o mesmo ID de locatário que o ID de locatário do cofre de chaves.

Name	Tipo	Description
applicationId	string (uuid)	ID do aplicativo do cliente que faz a solicitação em nome de um comitente
objectId	string	A ID de objeto de um usuário, entidade de serviço ou grupo de segurança no locatário do Azure Ative Directory para o cofre. O ID do objeto deve ser exclusivo para a lista de políticas de acesso.
permissions	Permissions	Permissões que a identidade tem para chaves, segredos e certificados.
tenantId	string (uuid)	A ID de locatário do Azure Ative Directory que deve ser usada para autenticar solicitações no cofre de chaves.

ActionsRequired

Enumeração

Uma mensagem indicando se as alterações no prestador de serviços exigem atualizações sobre o consumidor.

Valor	Description
None

CertificatePermissions

Enumeração

Permissões para certificados

Valor	Description
all
get
list
delete
create
import
update
managecontacts
getissuers
listissuers
setissuers
deleteissuers
manageissuers
recover
purge
backup
restore

CloudError

Object

Uma resposta de erro do provedor de recursos Key Vault

Name	Tipo	Description
error	CloudErrorBody	Uma resposta de erro do provedor de recursos Key Vault

CloudErrorBody

Object

Uma resposta de erro do provedor de recursos Key Vault

Name	Tipo	Description
code	string	Código de erro. Este é um mnemônico que pode ser consumido programaticamente.
message	string	Mensagem de erro amigável. A mensagem é normalmente localizada e pode variar com a versão do serviço.

CreateMode

Enumeração

O modo de criação do cofre para indicar se o cofre precisa ser recuperado ou não.

Valor	Description
recover
default

identityType

Enumeração

O tipo de identidade que criou o recurso do cofre de chaves.

Valor	Description
User
Application
ManagedIdentity
Key

IPRule

Object

Uma regra que rege a acessibilidade de um cofre a partir de um endereço IP ou intervalo de ip específico.

Name	Tipo	Description
value	string	Um intervalo de endereços IPv4 na notação CIDR, como '124.56.78.91' (endereço IP simples) ou '124.56.78.0/24' (todos os endereços que começam com 124.56.78).

KeyPermissions

Enumeração

Permissões para chaves

Valor	Description
all
encrypt
decrypt
wrapKey
unwrapKey
sign
verify
get
list
create
update
import
delete
backup
restore
recover
purge
release
rotate
getrotationpolicy
setrotationpolicy

NetworkRuleAction

Enumeração

A ação padrão quando nenhuma regra de ipRules e de virtualNetworkRules corresponder. Isso só é usado depois que a propriedade bypass foi avaliada.

Valor	Description
Allow
Deny

NetworkRuleBypassOptions

Enumeração

Informa qual tráfego pode ignorar as regras de rede. Isso pode ser 'AzureServices' ou 'None'. Se não for especificado, o padrão será 'AzureServices'.

Valor	Description
AzureServices
None

NetworkRuleSet

Object

Um conjunto de regras que regem a acessibilidade de rede de um cofre.

Name	Tipo	Description
bypass	NetworkRuleBypassOptions	Informa qual tráfego pode ignorar as regras de rede. Isso pode ser 'AzureServices' ou 'None'. Se não for especificado, o padrão será 'AzureServices'.
defaultAction	NetworkRuleAction	A ação padrão quando nenhuma regra de ipRules e de virtualNetworkRules corresponder. Isso só é usado depois que a propriedade bypass foi avaliada.
ipRules	IPRule[]	A lista de regras de endereço IP.
virtualNetworkRules	VirtualNetworkRule[]	A lista de regras de rede virtual.

Permissions

Object

Permissões que a identidade tem para chaves, segredos, certificados e armazenamento.

Name	Tipo	Description
certificates	CertificatePermissions[]	Permissões para certificados
keys	KeyPermissions[]	Permissões para chaves
secrets	SecretPermissions[]	Permissões para segredos
storage	StoragePermissions[]	Permissões para contas de armazenamento

PrivateEndpoint

Object

Propriedades do objeto de ponto de extremidade privado.

Name	Tipo	Description
id	string	Identificador completo do recurso de ponto de extremidade privado.

PrivateEndpointConnectionItem

Object

Item de conexão de ponto de extremidade privado.

Name	Tipo	Description
etag	string	Modificado sempre que há uma alteração no estado da conexão de ponto de extremidade privado.
id	string	Id da conexão de ponto final privado.
properties.privateEndpoint	PrivateEndpoint	Propriedades do objeto de ponto de extremidade privado.
properties.privateLinkServiceConnectionState	PrivateLinkServiceConnectionState	Estado de aprovação da conexão de link privado.
properties.provisioningState	PrivateEndpointConnectionProvisioningState	Estado de provisionamento da conexão de ponto de extremidade privado.

PrivateEndpointConnectionProvisioningState

Enumeração

O estado de provisionamento atual.

Valor	Description
Succeeded
Creating
Updating
Deleting
Failed
Disconnected

PrivateEndpointServiceConnectionStatus

Enumeração

O status da conexão de ponto de extremidade privado.

Valor	Description
Pending
Approved
Rejected
Disconnected

PrivateLinkServiceConnectionState

Object

Um objeto que representa o estado de aprovação da conexão de link privado.

Name	Tipo	Description
actionsRequired	ActionsRequired	Uma mensagem indicando se as alterações no prestador de serviços exigem atualizações sobre o consumidor.
description	string	O motivo da aprovação ou rejeição.
status	PrivateEndpointServiceConnectionStatus	Indica se a conexão foi aprovada, rejeitada ou removida pelo proprietário do cofre de chaves.

SecretPermissions

Enumeração

Permissões para segredos

Valor	Description
all
get
list
set
delete
backup
restore
recover
purge

Sku

Object

Detalhes do SKU

Name	Tipo	Description
family	SkuFamily	Nome de família SKU
name	SkuName	Nome da SKU para especificar se o cofre de chaves é um cofre padrão ou um cofre premium.

SkuFamily

Enumeração

Nome de família SKU

Valor	Description
A

SkuName

Enumeração

Nome da SKU para especificar se o cofre de chaves é um cofre padrão ou um cofre premium.

Valor	Description
standard
premium

StoragePermissions

Enumeração

Permissões para contas de armazenamento

Valor	Description
all
get
list
delete
set
update
regeneratekey
recover
purge
backup
restore
setsas
listsas
getsas
deletesas

SystemData

Object

Metadados referentes à criação e última modificação do recurso do cofre de chaves.

Name	Tipo	Description
createdAt	string (date-time)	O carimbo de data/hora da criação de recursos do cofre de chaves (UTC).
createdBy	string	A identidade que criou o recurso do cofre de chaves.
createdByType	identityType	O tipo de identidade que criou o recurso do cofre de chaves.
lastModifiedAt	string (date-time)	O carimbo de data/hora da última modificação (UTC) do recurso do cofre de chaves.
lastModifiedBy	string	A identidade que modificou pela última vez o recurso do cofre de chaves.
lastModifiedByType	identityType	O tipo de identidade que modificou pela última vez o recurso do cofre de chaves.

Vault

Object

Informações de recursos com detalhes estendidos.

Name	Tipo	Description
id	string	Identificador totalmente qualificado do recurso do cofre de chaves.
location	string	Localização do Azure do recurso do cofre de chaves.
name	string	Nome do recurso do cofre de chaves.
properties	VaultProperties	Propriedades do cofre
systemData	SystemData	Metadados do sistema para o cofre de chaves.
tags	object	Tags atribuídas ao recurso do cofre de chaves.
type	string	Tipo de recurso do recurso do cofre de chaves.

VaultPatchParameters

Object

Parâmetros para criar ou atualizar um cofre

Name	Tipo	Description
properties	VaultPatchProperties	Propriedades do cofre
tags	object	As tags que serão atribuídas ao cofre de chaves.

VaultPatchProperties

Object

Propriedades do cofre

Name	Tipo	Description
accessPolicies	AccessPolicyEntry[]	Uma matriz de 0 a 16 identidades que têm acesso ao cofre de chaves. Todas as identidades na matriz devem usar o mesmo ID de locatário que o ID de locatário do cofre de chaves.
createMode	CreateMode	O modo de criação do cofre para indicar se o cofre precisa ser recuperado ou não.
enablePurgeProtection	boolean	Propriedade que especifica se a proteção contra limpeza está habilitada para este cofre. Definir essa propriedade como true ativa a proteção contra limpeza para este cofre e seu conteúdo - somente o serviço Cofre de Chaves pode iniciar uma exclusão difícil e irrecuperável. A configuração só será efetiva se a exclusão suave também estiver habilitada. Habilitar essa funcionalidade é irreversível - ou seja, a propriedade não aceita false como seu valor.
enableRbacAuthorization	boolean	Propriedade que controla como as ações de dados são autorizadas. Quando verdadeiro, o cofre de chaves usará o RBAC (Controle de Acesso Baseado em Função) para autorização de ações de dados e as políticas de acesso especificadas nas propriedades do cofre serão ignoradas. Quando false, o cofre de chaves usará as políticas de acesso especificadas nas propriedades do cofre e qualquer política armazenada no Azure Resource Manager será ignorada. Se nulo ou não especificado, o valor dessa propriedade não será alterado.
enableSoftDelete	boolean	Propriedade para especificar se a funcionalidade 'exclusão suave' está habilitada para este cofre de chaves. Uma vez definido como true, ele não pode ser revertido para false.
enabledForDeployment	boolean	Propriedade para especificar se as Máquinas Virtuais do Azure têm permissão para recuperar certificados armazenados como segredos do cofre de chaves.
enabledForDiskEncryption	boolean	Propriedade para especificar se o Azure Disk Encryption tem permissão para recuperar segredos do cofre e desembrulhar chaves.
enabledForTemplateDeployment	boolean	Propriedade para especificar se o Azure Resource Manager tem permissão para recuperar segredos do cofre de chaves.
networkAcls	NetworkRuleSet	Uma coleção de regras que regem a acessibilidade do cofre a partir de locais de rede específicos.
publicNetworkAccess	string	Propriedade para especificar se o cofre aceitará tráfego da Internet pública. Se definido como 'desativado', todo o tráfego, exceto o tráfego de ponto final privado e o originado de serviços confiáveis, será bloqueado. Isso substituirá as regras de firewall definidas, o que significa que, mesmo que as regras de firewall estejam presentes, não honraremos as regras.
sku	Sku	Detalhes do SKU
softDeleteRetentionInDays	integer (int32)	softDelete dias de retenção de dados. Aceita >= 7 e <= 90.
tenantId	string (uuid)	A ID de locatário do Azure Ative Directory que deve ser usada para autenticar solicitações no cofre de chaves.

VaultProperties

Object

Propriedades do cofre

Name	Tipo	Default value	Description
accessPolicies	AccessPolicyEntry[]		Uma matriz de 0 a 1024 identidades que têm acesso ao cofre de chaves. Todas as identidades na matriz devem usar o mesmo ID de locatário que o ID de locatário do cofre de chaves. Quando `createMode` está definido como `recover`, as políticas de acesso não são necessárias. Caso contrário, as políticas de acesso são necessárias.
createMode	CreateMode		O modo de criação do cofre para indicar se o cofre precisa ser recuperado ou não.
enablePurgeProtection	boolean		Propriedade que especifica se a proteção contra limpeza está habilitada para este cofre. Definir essa propriedade como true ativa a proteção contra limpeza para este cofre e seu conteúdo - somente o serviço Cofre de Chaves pode iniciar uma exclusão difícil e irrecuperável. A configuração só será efetiva se a exclusão suave também estiver habilitada. Habilitar essa funcionalidade é irreversível - ou seja, a propriedade não aceita false como seu valor.
enableRbacAuthorization	boolean	False	Propriedade que controla como as ações de dados são autorizadas. Quando verdadeiro, o cofre de chaves usará o RBAC (Controle de Acesso Baseado em Função) para autorização de ações de dados e as políticas de acesso especificadas nas propriedades do cofre serão ignoradas. Quando false, o cofre de chaves usará as políticas de acesso especificadas nas propriedades do cofre e qualquer política armazenada no Azure Resource Manager será ignorada. Se nulo ou não especificado, o cofre é criado com o valor padrão de false. Note que as ações de gestão são sempre autorizadas com o RBAC.
enableSoftDelete	boolean	True	Propriedade para especificar se a funcionalidade 'exclusão suave' está habilitada para este cofre de chaves. Se não estiver definido como qualquer valor (true ou false) ao criar um novo cofre de chaves, ele será definido como true por padrão. Uma vez definido como true, ele não pode ser revertido para false.
enabledForDeployment	boolean	False	Propriedade para especificar se as Máquinas Virtuais do Azure têm permissão para recuperar certificados armazenados como segredos do cofre de chaves.
enabledForDiskEncryption	boolean	False	Propriedade para especificar se o Azure Disk Encryption tem permissão para recuperar segredos do cofre e desembrulhar chaves.
enabledForTemplateDeployment	boolean	False	Propriedade para especificar se o Azure Resource Manager tem permissão para recuperar segredos do cofre de chaves.
hsmPoolResourceId	string		A id do recurso do Pool HSM.
networkAcls	NetworkRuleSet		Regras que regem a acessibilidade do cofre de chaves a partir de locais de rede específicos.
privateEndpointConnections	PrivateEndpointConnectionItem[]		Lista de conexões de ponto de extremidade privadas associadas ao cofre de chaves.
provisioningState	VaultProvisioningState		Estado de provisionamento do cofre.
publicNetworkAccess	string	enabled	Propriedade para especificar se o cofre aceitará tráfego da Internet pública. Se definido como 'desativado', todo o tráfego, exceto o tráfego de ponto final privado e o originado de serviços confiáveis, será bloqueado. Isso substituirá as regras de firewall definidas, o que significa que, mesmo que as regras de firewall estejam presentes, não honraremos as regras.
sku	Sku		Detalhes do SKU
softDeleteRetentionInDays	integer (int32)	90	softDelete dias de retenção de dados. Aceita >= 7 e <= 90.
tenantId	string (uuid)		A ID de locatário do Azure Ative Directory que deve ser usada para autenticar solicitações no cofre de chaves.
vaultUri	string		O URI do cofre para executar operações em chaves e segredos.

VaultProvisioningState

Enumeração

Estado de provisionamento do cofre.

Valor	Description
Succeeded
RegisteringDns

VirtualNetworkRule

Object

Uma regra que rege a acessibilidade de um cofre a partir de uma rede virtual específica.

Name	Tipo	Description
id	string	ID de recurso completo de uma sub-rede vnet, como '/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/subnet1'.
ignoreMissingVnetServiceEndpoint	boolean	Propriedade para especificar se o NRP ignorará a verificação se a sub-rede pai tiver serviceEndpoints configurado.