Vaults - Update Access Policy

Service:

Key Vault

Version d'API:

2024-11-01

Mettez à jour les stratégies d’accès dans un coffre de clés dans l’abonnement spécifié.

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

Paramètres URI

Nom	Dans	Obligatoire	Type	Description
operationKind	path	True	AccessPolicyUpdateKind	Nom de l’opération
resourceGroupName	path	True	string	Nom du groupe de ressources auquel appartient le coffre.
subscriptionId	path	True	string	Informations d’identification d’abonnement qui identifient de manière unique l’abonnement Microsoft Azure. L’ID d’abonnement fait partie de l’URI de chaque appel de service.
vaultName	path	True	string pattern: ^[a-zA-Z0-9-]{3,24}$	Nom du coffre
api-version	query	True	string	Version de l’API cliente.

Corps de la demande

Nom	Obligatoire	Type	Description
properties	True	VaultAccessPolicyProperties	Propriétés de la stratégie d’accès

Réponses

Nom	Type	Description
200 OK	VaultAccessPolicyParameters	Les politiques d’accès mises à jour
201 Created	VaultAccessPolicyParameters	Les politiques d’accès mises à jour
Other Status Codes	CloudError	Réponse d’erreur décrivant pourquoi l’opération a échoué.

Exemples

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

Exemple de requête

HTTP

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"
          ]
        }
      }
    ]
  }
}

Java

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

Python

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

Go

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

JavaScript

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

dotnet

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

Exemple de réponse

Code d’état:

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"
          ]
        }
      }
    ]
  }
}

Code d’état:

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"
          ]
        }
      }
    ]
  }
}

Définitions

Nom	Description
AccessPolicyEntry	Une identité qui a accès au coffre de clés. Toutes les identités du tableau doivent utiliser le même ID de locataire que l’ID de locataire du coffre de clés.
AccessPolicyUpdateKind	Nom de l’opération
CertificatePermissions	Autorisations sur les certificats
CloudError	Réponse d’erreur du fournisseur de ressources Key Vault
CloudErrorBody	Réponse d’erreur du fournisseur de ressources Key Vault
KeyPermissions	Autorisations sur les clés
Permissions	Autorisations dont dispose l’identité pour les clés, les secrets, les certificats et le stockage.
SecretPermissions	Autorisations sur les secrets
StoragePermissions	Autorisations pour les comptes de stockage
VaultAccessPolicyParameters	Paramètres de mise à jour de la stratégie d’accès dans un coffre-fort
VaultAccessPolicyProperties	Propriétés de la stratégie d’accès au coffre-fort

AccessPolicyEntry

Object

Une identité qui a accès au coffre de clés. Toutes les identités du tableau doivent utiliser le même ID de locataire que l’ID de locataire du coffre de clés.

Nom	Type	Description
applicationId	string (uuid)	ID d’application du client effectuant une demande pour le compte d’un principal
objectId	string	ID d’objet d’un utilisateur, d’un principal de service ou d’un groupe de sécurité dans le locataire Azure Active Directory pour le coffre. Cet ID d’objet doit être unique dans la liste des stratégies d’accès.
permissions	Permissions	Autorisations dont dispose l’identité pour les clés, les secrets et les certificats.
tenantId	string (uuid)	ID de locataire Azure Active Directory qui doit être utilisé pour authentifier les demandes auprès du coffre de clés.

AccessPolicyUpdateKind

Énumération

Nom de l’opération

Valeur	Description
add
replace
remove

CertificatePermissions

Énumération

Autorisations sur les certificats

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

CloudError

Object

Réponse d’erreur du fournisseur de ressources Key Vault

Nom	Type	Description
error	CloudErrorBody	Réponse d’erreur du fournisseur de ressources Key Vault

CloudErrorBody

Object

Réponse d’erreur du fournisseur de ressources Key Vault

Nom	Type	Description
code	string	Code d’erreur. Il s’agit d’un moyen mnémotechnique qui peut être utilisé de manière programmatique.
message	string	Message d’erreur convivial. Le message est généralement localisé et peut varier selon la version du service.

KeyPermissions

Énumération

Autorisations sur les clés

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

Permissions

Object

Autorisations dont dispose l’identité pour les clés, les secrets, les certificats et le stockage.

Nom	Type	Description
certificates	CertificatePermissions[]	Autorisations sur les certificats
keys	KeyPermissions[]	Autorisations sur les clés
secrets	SecretPermissions[]	Autorisations sur les secrets
storage	StoragePermissions[]	Autorisations pour les comptes de stockage

SecretPermissions

Énumération

Autorisations sur les secrets

Valeur	Description
all
get
list
set
delete
backup
restore
recover
purge

StoragePermissions

Énumération

Autorisations pour les comptes de stockage

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

VaultAccessPolicyParameters

Object

Paramètres de mise à jour de la stratégie d’accès dans un coffre-fort

Nom	Type	Description
id	string	ID de ressource de la politique d’accès.
location	string	Type de ressource de la stratégie d’accès.
name	string	Nom de la ressource de la stratégie d’accès.
properties	VaultAccessPolicyProperties	Propriétés de la stratégie d’accès
type	string	Nom de la ressource de la stratégie d’accès.

VaultAccessPolicyProperties

Object

Propriétés de la stratégie d’accès au coffre-fort

Nom	Type	Description
accessPolicies	AccessPolicyEntry[]	Tableau de 0 à 16 identités qui ont accès au coffre de clés. Toutes les identités du tableau doivent utiliser le même ID de locataire que l’ID de locataire du coffre de clés.