Vaults - Update Access Policy

Service:: Key Vault

API-versie:: 2024-11-01

Werk het toegangsbeleid bij in een sleutelkluis in het opgegeven abonnement.

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

URI-parameters

Name	In	Vereist	Type	Description
operationKind	path	True	AccessPolicyUpdateKind	Naam van de bewerking
resourceGroupName	path	True	string	De naam van de resourcegroep waartoe de kluis behoort.
subscriptionId	path	True	string	Abonnementsreferenties die het Microsoft Azure-abonnement uniek identificeren. De abonnements-id maakt deel uit van de URI voor elke serviceoproep.
vaultName	path	True	string pattern: ^[a-zA-Z0-9-]{3,24}$	Naam van de kluis
api-version	query	True	string	Client-API-versie.

Aanvraagbody

Name	Vereist	Type	Description
properties	True	VaultAccessPolicyProperties	Eigenschappen van het toegangsbeleid

Antwoorden

Name	Type	Description
200 OK	VaultAccessPolicyParameters	Het bijgewerkte toegangsbeleid
201 Created	VaultAccessPolicyParameters	Het bijgewerkte toegangsbeleid
Other Status Codes	CloudError	Foutreactie waarin wordt beschreven waarom de bewerking is mislukt.

Voorbeelden

Add an access policy, or update an access policy with new permissions

Voorbeeldaanvraag

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

{
  "properties": {
    "accessPolicies": [
      {
        "tenantId": "00000000-0000-0000-0000-000000000000",
        "objectId": "00000000-0000-0000-0000-000000000000",
        "permissions": {
          "keys": [
            "encrypt"
          ],
          "secrets": [
            "get"
          ],
          "certificates": [
            "get"
          ]
        }
      }
    ]
  }
}


import com.azure.resourcemanager.keyvault.fluent.models.VaultAccessPolicyParametersInner;
import com.azure.resourcemanager.keyvault.models.AccessPolicyEntry;
import com.azure.resourcemanager.keyvault.models.AccessPolicyUpdateKind;
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.VaultAccessPolicyProperties;
import java.util.Arrays;
import java.util.UUID;

/**
 * Samples for Vaults UpdateAccessPolicy.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/updateAccessPoliciesAdd.
     * json
     */
    /**
     * Sample code: Add an access policy, or update an access policy with new permissions.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void addAnAccessPolicyOrUpdateAnAccessPolicyWithNewPermissions(
        com.azure.resourcemanager.AzureResourceManager azure) {
        azure.vaults().manager().serviceClient().getVaults().updateAccessPolicyWithResponse("sample-group",
            "sample-vault", AccessPolicyUpdateKind.ADD,
            new VaultAccessPolicyParametersInner()
                .withProperties(new VaultAccessPolicyProperties().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))
                            .withSecrets(Arrays.asList(SecretPermissions.GET))
                            .withCertificates(Arrays.asList(CertificatePermissions.GET)))))),
            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_access_policies_add.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_access_policy(
        resource_group_name="sample-group",
        vault_name="sample-vault",
        operation_kind="add",
        parameters={
            "properties": {
                "accessPolicies": [
                    {
                        "objectId": "00000000-0000-0000-0000-000000000000",
                        "permissions": {"certificates": ["get"], "keys": ["encrypt"], "secrets": ["get"]},
                        "tenantId": "00000000-0000-0000-0000-000000000000",
                    }
                ]
            }
        },
    )
    print(response)


# x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/updateAccessPoliciesAdd.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/updateAccessPoliciesAdd.json
func ExampleVaultsClient_UpdateAccessPolicy() {
	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().UpdateAccessPolicy(ctx, "sample-group", "sample-vault", armkeyvault.AccessPolicyUpdateKindAdd, armkeyvault.VaultAccessPolicyParameters{
		Properties: &armkeyvault.VaultAccessPolicyProperties{
			AccessPolicies: []*armkeyvault.AccessPolicyEntry{
				{
					ObjectID: to.Ptr("00000000-0000-0000-0000-000000000000"),
					Permissions: &armkeyvault.Permissions{
						Certificates: []*armkeyvault.CertificatePermissions{
							to.Ptr(armkeyvault.CertificatePermissionsGet)},
						Keys: []*armkeyvault.KeyPermissions{
							to.Ptr(armkeyvault.KeyPermissionsEncrypt)},
						Secrets: []*armkeyvault.SecretPermissions{
							to.Ptr(armkeyvault.SecretPermissionsGet)},
					},
					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.VaultAccessPolicyParameters = armkeyvault.VaultAccessPolicyParameters{
	// 	Type: to.Ptr("Microsoft.KeyVault/vaults/accessPolicies"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault/accessPolicies/"),
	// 	Properties: &armkeyvault.VaultAccessPolicyProperties{
	// 		AccessPolicies: []*armkeyvault.AccessPolicyEntry{
	// 			{
	// 				ObjectID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 				Permissions: &armkeyvault.Permissions{
	// 					Certificates: []*armkeyvault.CertificatePermissions{
	// 						to.Ptr(armkeyvault.CertificatePermissionsGet)},
	// 						Keys: []*armkeyvault.KeyPermissions{
	// 							to.Ptr(armkeyvault.KeyPermissionsEncrypt)},
	// 							Secrets: []*armkeyvault.SecretPermissions{
	// 								to.Ptr(armkeyvault.SecretPermissionsGet)},
	// 							},
	// 							TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 					}},
	// 				},
	// 			}
}

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 access policies in a key vault in the specified subscription.
 *
 * @summary Update access policies in a key vault in the specified subscription.
 * x-ms-original-file: specification/keyvault/resource-manager/Microsoft.KeyVault/stable/2024-11-01/examples/updateAccessPoliciesAdd.json
 */
async function addAnAccessPolicyOrUpdateAnAccessPolicyWithNewPermissions() {
  const subscriptionId =
    process.env["KEYVAULT_SUBSCRIPTION_ID"] || "00000000-0000-0000-0000-000000000000";
  const resourceGroupName = process.env["KEYVAULT_RESOURCE_GROUP"] || "sample-group";
  const vaultName = "sample-vault";
  const operationKind = "add";
  const parameters = {
    properties: {
      accessPolicies: [
        {
          objectId: "00000000-0000-0000-0000-000000000000",
          permissions: {
            certificates: ["get"],
            keys: ["encrypt"],
            secrets: ["get"],
          },
          tenantId: "00000000-0000-0000-0000-000000000000",
        },
      ],
    },
  };
  const credential = new DefaultAzureCredential();
  const client = new KeyVaultManagementClient(credential, subscriptionId);
  const result = await client.vaults.updateAccessPolicy(
    resourceGroupName,
    vaultName,
    operationKind,
    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/updateAccessPoliciesAdd.json
// this example is just showing the usage of "Vaults_UpdateAccessPolicy" 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-group";
string vaultName = "sample-vault";
ResourceIdentifier keyVaultResourceId = KeyVaultResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, vaultName);
KeyVaultResource keyVault = client.GetKeyVaultResource(keyVaultResourceId);

// invoke the operation
AccessPolicyUpdateKind operationKind = AccessPolicyUpdateKind.Add;
KeyVaultAccessPolicyParameters keyVaultAccessPolicyParameters = new KeyVaultAccessPolicyParameters(new KeyVaultAccessPolicyProperties(new KeyVaultAccessPolicy[]
{
new KeyVaultAccessPolicy(Guid.Parse("00000000-0000-0000-0000-000000000000"), "00000000-0000-0000-0000-000000000000", new IdentityAccessPermissions
{
Keys = {IdentityAccessKeyPermission.Encrypt},
Secrets = {IdentityAccessSecretPermission.Get},
Certificates = {IdentityAccessCertificatePermission.Get},
})
}));
KeyVaultAccessPolicyParameters result = await keyVault.UpdateAccessPolicyAsync(operationKind, keyVaultAccessPolicyParameters);

Console.WriteLine($"Succeeded: {result}");

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

Voorbeeldrespons

Statuscode:: 200

{
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault/accessPolicies/",
  "type": "Microsoft.KeyVault/vaults/accessPolicies",
  "properties": {
    "accessPolicies": [
      {
        "tenantId": "00000000-0000-0000-0000-000000000000",
        "objectId": "00000000-0000-0000-0000-000000000000",
        "permissions": {
          "keys": [
            "encrypt"
          ],
          "secrets": [
            "get"
          ],
          "certificates": [
            "get"
          ]
        }
      }
    ]
  }
}

Statuscode:: 201

{
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/sample-group/providers/Microsoft.KeyVault/vaults/sample-vault/accessPolicies/",
  "type": "Microsoft.KeyVault/vaults/accessPolicies",
  "properties": {
    "accessPolicies": [
      {
        "tenantId": "00000000-0000-0000-0000-000000000000",
        "objectId": "00000000-0000-0000-0000-000000000000",
        "permissions": {
          "keys": [
            "encrypt"
          ],
          "secrets": [
            "get"
          ],
          "certificates": [
            "get"
          ]
        }
      }
    ]
  }
}

Definities

Name	Description
AccessPolicyEntry	Een identiteit die toegang heeft tot de sleutelkluis. Alle identiteiten in de matrix moeten dezelfde tenant-id gebruiken als de tenant-id van de sleutelkluis.
AccessPolicyUpdateKind	Naam van de bewerking
CertificatePermissions	Machtigingen voor certificaten
CloudError	Een foutreactie van de Key Vault-resourceprovider
CloudErrorBody	Een foutreactie van de Key Vault-resourceprovider
KeyPermissions	Machtigingen voor sleutels
Permissions	Machtigingen die de identiteit heeft voor sleutels, geheimen, certificaten en opslag.
SecretPermissions	Machtigingen voor geheimen
StoragePermissions	Machtigingen voor opslagaccounts
VaultAccessPolicyParameters	Parameters voor het bijwerken van het toegangsbeleid in een kluis
VaultAccessPolicyProperties	Eigenschappen van het toegangsbeleid voor de kluis

AccessPolicyEntry

Object

Een identiteit die toegang heeft tot de sleutelkluis. Alle identiteiten in de matrix moeten dezelfde tenant-id gebruiken als de tenant-id van de sleutelkluis.

Name	Type	Description
applicationId	string (uuid)	Toepassings-id van de clientaanvraag namens een principal
objectId	string	De object-id van een gebruiker, service-principal of beveiligingsgroep in de Azure Active Directory-tenant voor de kluis. De object-id moet uniek zijn voor de lijst met toegangsbeleidsregels.
permissions	Permissions	Machtigingen die de identiteit heeft voor sleutels, geheimen en certificaten.
tenantId	string (uuid)	De tenant-id van Azure Active Directory die moet worden gebruikt voor het verifiëren van aanvragen bij de sleutelkluis.

AccessPolicyUpdateKind

Inventarisatie

Naam van de bewerking

Waarde	Description
add
replace
remove

CertificatePermissions

Inventarisatie

Machtigingen voor certificaten

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

CloudError

Object

Een foutreactie van de Key Vault-resourceprovider

Name	Type	Description
error	CloudErrorBody	Een foutreactie van de Key Vault-resourceprovider

CloudErrorBody

Object

Een foutreactie van de Key Vault-resourceprovider

Name	Type	Description
code	string	Foutcode. Dit is een geheugensteuntje dat programmatisch kan worden geconsumeerd.
message	string	Gebruiksvriendelijke foutmelding. Het bericht is meestal gelokaliseerd en kan variëren afhankelijk van de serviceversie.

KeyPermissions

Inventarisatie

Machtigingen voor sleutels

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

Permissions

Object

Machtigingen die de identiteit heeft voor sleutels, geheimen, certificaten en opslag.

Name	Type	Description
certificates	CertificatePermissions[]	Machtigingen voor certificaten
keys	KeyPermissions[]	Machtigingen voor sleutels
secrets	SecretPermissions[]	Machtigingen voor geheimen
storage	StoragePermissions[]	Machtigingen voor opslagaccounts

SecretPermissions

Inventarisatie

Machtigingen voor geheimen

Waarde	Description
all
get
list
set
delete
backup
restore
recover
purge

StoragePermissions

Inventarisatie

Machtigingen voor opslagaccounts

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

VaultAccessPolicyParameters

Object

Parameters voor het bijwerken van het toegangsbeleid in een kluis

Name	Type	Description
id	string	De resource-id van het toegangsbeleid.
location	string	Het resourcetype van het toegangsbeleid.
name	string	De resourcenaam van het toegangsbeleid.
properties	VaultAccessPolicyProperties	Eigenschappen van het toegangsbeleid
type	string	De resourcenaam van het toegangsbeleid.

VaultAccessPolicyProperties

Object

Eigenschappen van het toegangsbeleid voor de kluis

Name	Type	Description
accessPolicies	AccessPolicyEntry[]	Een matrix van 0 tot 16 identiteiten die toegang hebben tot de sleutelkluis. Alle identiteiten in de matrix moeten dezelfde tenant-id gebruiken als de tenant-id van de sleutelkluis.