Maison

Skill

Sécurité

azure-keyvault-py

microsoft/skills

Gérez les secrets, les clés cryptographiques et les certificats dans Azure Key Vault à l'aide du SDK Python.

...Développer tout

Heure mise à jour 12 septembre 2026

# python # azure key vault # azure sdk # azure identity # certificates # cryptographic keys # secrets

SDK Azure Key Vault pour Python

Stockage sécurisé et gestion des secrets, des clés cryptographiques et des certificats.

Installation

# Secrets
pip install azure-keyvault-secrets azure-identity

# Clés (opérations cryptographiques)
pip install azure-keyvault-keys azure-identity

# Certificats
pip install azure-keyvault-certificates azure-identity

# Tout
pip install azure-keyvault-secrets azure-keyvault-keys azure-keyvault-certificates azure-identity

Variables d'environnement

AZURE_KEYVAULT_URL=https://<nom-du-coffre>.vault.azure.net/  # Requis pour toutes les méthodes d'authentification
AZURE_TOKEN_CREDENTIALS=prod # Requis uniquement si DefaultAzureCredential est utilisé en production
</nom-du-coffre>

Authentification et cycle de vie

🔑 Deux règles s'appliquent à chaque exemple de code ci-dessous :
Privilégiez DefaultAzureCredential. Il fonctionne localement (Azure CLI / VS Code / CLI de développement) et dans Azure (identité managée, identité de charge de travail) sans modification de code. Évitez les chaînes de connexion, les comptes/clés API — ils contournent l'audit Entra et la rotation.
Développement local : DefaultAzureCredential fonctionne tel quel.
Production : définissez AZURE_TOKEN_CREDENTIALS=prod (ou AZURE_TOKEN_CREDENTIALS=<identifiant_credential_spécifique></identifiant_credential_spécifique>) pour limiter la chaîne d'identification aux identifiants sûrs pour la production.
Enveloppez chaque client dans un gestionnaire de contexte afin que les transports HTTP, les sockets et les caches de jetons soient libérés de manière déterministe :
Synchrone : with <client>(...) as client:</client>
Asynchrone : async with <client>(...) as client:</client> et async with DefaultAzureCredential() as credential: (de azure.identity.aio)
Les extraits de code peuvent abréger cette configuration, mais le code de production doit toujours respecter les deux règles.

Secrets

Configuration de SecretClient

from azure.identity import DefaultAzureCredential, ManagedIdentityCredential
from azure.keyvault.secrets import SecretClient

# Développement local : DefaultAzureCredential. Production : définissez AZURE_TOKEN_CREDENTIALS=prod ou AZURE_TOKEN_CREDENTIALS=<identifiant_credential_spécifique>
credential = DefaultAzureCredential(require_envvar=True)
# Ou utilisez un identifiant spécifique directement en production :
# Voir https://learn.microsoft.com/python/api/overview/azure/identity-readme?view=azure-python#credential-classes
# credential = ManagedIdentityCredential()
vault_url = "https://<nom-du-coffre>.vault.azure.net/"

with SecretClient(vault_url=vault_url, credential=credential) as client:
    # Toutes les opérations sur les secrets se trouvent dans ce bloc (voir exemples ci-dessous)
    ...
</nom-du-coffre></identifiant_credential_spécifique>

Opérations sur les secrets

# Définir un secret
secret = client.set_secret("mot-de-passe-base-de-donnees", "valeur-très-secrète")
print(f"Créé : {secret.name}, version : {secret.properties.version}")

# Obtenir un secret
secret = client.get_secret("mot-de-passe-base-de-donnees")
print(f"Valeur : {secret.value}")

# Obtenir une version spécifique
secret = client.get_secret("mot-de-passe-base-de-donnees", version="abc123")

# Lister les secrets (noms uniquement, pas les valeurs)
for secret_properties in client.list_properties_of_secrets():
    print(f"Secret : {secret_properties.name}")

# Lister les versions
for version in client.list_properties_of_secret_versions("mot-de-passe-base-de-donnees"):
    print(f"Version : {version.version}, Créé : {version.created_on}")

# Supprimer un secret (suppression en douceur)
poller = client.begin_delete_secret("mot-de-passe-base-de-donnees")
deleted_secret = poller.result()

# Purger (suppression permanente, si la suppression en douceur est activée)
client.purge_deleted_secret("mot-de-passe-base-de-donnees")

# Récupérer un secret supprimé
client.begin_recover_deleted_secret("mot-de-passe-base-de-donnees").result()

Clés

Configuration de KeyClient

from azure.identity import DefaultAzureCredential
from azure.keyvault.keys import KeyClient

credential = DefaultAzureCredential()
vault_url = "https://<nom-du-coffre>.vault.azure.net/"

with KeyClient(vault_url=vault_url, credential=credential) as client:
    # Toutes les opérations sur les clés se trouvent dans ce bloc (voir exemples ci-dessous)
    ...
</nom-du-coffre>

Opérations sur les clés

from azure.keyvault.keys import KeyType

# Créer une clé RSA
rsa_key = client.create_rsa_key("cle-rsa", size=2048)

# Créer une clé EC
ec_key = client.create_ec_key("cle-ec", curve="P-256")

# Obtenir une clé
key = client.get_key("cle-rsa")
print(f"Type de clé : {key.key_type}")

# Lister les clés
for key_properties in client.list_properties_of_keys():
    print(f"Clé : {key_properties.name}")

# Supprimer une clé
poller = client.begin_delete_key("cle-rsa")
deleted_key = poller.result()

Opérations cryptographiques

from azure.keyvault.keys.crypto import CryptographyClient, EncryptionAlgorithm

# Obtenir le client cryptographique pour une clé spécifique
# crypto_client = CryptographyClient(key, credential=credential)
# Ou à partir de l'ID de la clé
with CryptographyClient(
    "https://<coffre>.vault.azure.net/keys/<nom-de-la-clé>/<version>",
    credential=credential
) as crypto_client:
    # Chiffrer
    plaintext = b"Bonjour, Key Vault !"
    result = crypto_client.encrypt(EncryptionAlgorithm.rsa_oaep, plaintext)
    ciphertext = result.ciphertext

    # Déchiffrer
    result = crypto_client.decrypt(EncryptionAlgorithm.rsa_oaep, ciphertext)
    decrypted = result.plaintext

    # Signer
    from azure.keyvault.keys.crypto import SignatureAlgorithm
    import hashlib

    digest = hashlib.sha256(b"données à signer").digest()
    result = crypto_client.sign(SignatureAlgorithm.rs256, digest)
    signature = result.signature

    # Vérifier
    result = crypto_client.verify(SignatureAlgorithm.rs256, digest, signature)
    print(f"Valide : {result.is_valid}")
</version></nom-de-la-clé></coffre>

Certificats

Configuration de CertificateClient

from azure.identity import DefaultAzureCredential
from azure.keyvault.certificates import CertificateClient, CertificatePolicy

credential = DefaultAzureCredential()
vault_url = "https://<nom-du-coffre>.vault.azure.net/"

with CertificateClient(vault_url=vault_url, credential=credential) as client:
    # Toutes les opérations sur les certificats se trouvent dans ce bloc (voir exemples ci-dessous)
    ...
</nom-du-coffre>

Opérations sur les certificats

# Créer un certificat auto-signé
policy = CertificatePolicy.get_default()
poller = client.begin_create_certificate("mon-certificat", policy=policy)
certificate = poller.result()

# Obtenir un certificat
certificate = client.get_certificate("mon-certificat")
print(f"Empreinte : {certificate.properties.x509_thumbprint.hex()}")

# Obtenir un certificat avec la clé privée (en tant que secret)
from azure.keyvault.secrets import SecretClient
with SecretClient(vault_url=vault_url, credential=credential) as secret_client:
    cert_secret = secret_client.get_secret("mon-certificat")
    # cert_secret.value contient PEM ou PKCS12

# Lister les certificats
for cert in client.list_properties_of_certificates():
    print(f"Certificat : {cert.name}")

# Supprimer un certificat
poller = client.begin_delete_certificate("mon-certificat")
deleted = poller.result()

Tableau des types de clients

Client	Package	Objectif
`SecretClient`	`azure-keyvault-secrets`	Stocker/récupérer des secrets
`KeyClient`	`azure-keyvault-keys`	Gérer les clés cryptographiques
`CryptographyClient`	`azure-keyvault-keys`	Chiffrer/déchiffrer/signer/vérifier
`CertificateClient`	`azure-keyvault-certificates`	Gérer les certificats

Clients asynchrones

from azure.identity.aio import DefaultAzureCredential
from azure.keyvault.secrets.aio import SecretClient

async def get_secret():
    async with DefaultAzureCredential() as credential:
        async with SecretClient(vault_url=vault_url, credential=credential) as client:
            secret = await client.get_secret("mon-secret")
            print(secret.value)

import asyncio
asyncio.run(get_secret())

Gestion des erreurs

from azure.core.exceptions import ResourceNotFoundError, HttpResponseError

try:
    secret = client.get_secret("inexistant")
except ResourceNotFoundError:
    print("Secret non trouvé")
except HttpResponseError as e:
    if e.status_code == 403:
        print("Accès refusé - vérifiez les autorisations RBAC")
    raise

Meilleures pratiques

Choisissez sync OU async et restez cohérent. Ne mélangez pas les clients synchrones azure.xxx avec les clients asynchrones azure.xxx.aio dans le même chemin d'appel. Choisissez un seul mode par module.
Utilisez toujours des gestionnaires de contexte pour les clients et les identifiants asynchrones. Enveloppez chaque client dans with Client(...) as client: (synchrone) ou async with Client(...) as client: (asynchrone). Pour DefaultAzureCredential asynchrone de azure.identity.aio, utilisez également async with credential: afin que les jetons et les transports soient nettoyés.
Utilisez DefaultAzureCredential pour le code s'exécutant localement. Utilisez un identifiant de jeton spécifique pour le code s'exécutant dans Azure.
Utilisez l'identité managée dans les applications hébergées sur Azure
Activez la suppression en douceur pour la récupération (activée par défaut)
Utilisez RBAC plutôt que les stratégies d'accès pour un contrôle granulaire
Faites tourner les secrets régulièrement en utilisant le versionnement
Utilisez les références de Key Vault dans la configuration d'App Service/Functions
Mettez en cache les secrets de manière appropriée pour réduire les appels API
Utilisez des clients asynchrones pour les scénarios à haut débit

Voir sur GitHub

---
name: azure-keyvault-py
description: Manage secrets, cryptographic keys, and certificates in Azure Key Vault using the Python SDK.
license: MIT
---

# Azure Key Vault SDK for Python

Secure storage and management for secrets, cryptographic keys, and certificates.

## Installation

```bash
# Secrets
pip install azure-keyvault-secrets azure-identity

# Keys (cryptographic operations)
pip install azure-keyvault-keys azure-identity

# Certificates
pip install azure-keyvault-certificates azure-identity

# All
pip install azure-keyvault-secrets azure-keyvault-keys azure-keyvault-certificates azure-identity
```

## Environment Variables

```bash
AZURE_KEYVAULT_URL=https://<vault-name>.vault.azure.net/  # Required for all auth methods
AZURE_TOKEN_CREDENTIALS=prod # Required only if DefaultAzureCredential is used in production
```

## Authentication & Lifecycle

> **🔑 Two rules apply to every code sample below:**
>
> 1. **Prefer `DefaultAzureCredential`.** It works locally (Azure CLI / VS Code / Developer CLI) and in Azure (managed identity, workload identity) with no code change. Avoid connection strings, account/API keys — they bypass Entra audit and rotation.
>    - Local dev: `DefaultAzureCredential` works as-is.
>    - Production: set `AZURE_TOKEN_CREDENTIALS=prod` (or `AZURE_TOKEN_CREDENTIALS=<specific_credential>`) to constrain the credential chain to production-safe credentials.
> 2. **Wrap every client in a context manager** so HTTP transports, sockets, and token caches are released deterministically:
>    - Sync: `with <Client>(...) as client:`
>    - Async: `async with <Client>(...) as client:` **and** `async with DefaultAzureCredential() as credential:` (from `azure.identity.aio`)
>
> Snippets may abbreviate this setup, but production code should always follow both rules.

## Secrets

### SecretClient Setup

```python
from azure.identity import DefaultAzureCredential, ManagedIdentityCredential
from azure.keyvault.secrets import SecretClient

# Local dev: DefaultAzureCredential. Production: set AZURE_TOKEN_CREDENTIALS=prod or AZURE_TOKEN_CREDENTIALS=<specific_credential>
credential = DefaultAzureCredential(require_envvar=True)
# Or use a specific credential directly in production:
# See https://learn.microsoft.com/python/api/overview/azure/identity-readme?view=azure-python#credential-classes
# credential = ManagedIdentityCredential()
vault_url = "https://<vault-name>.vault.azure.net/"

with SecretClient(vault_url=vault_url, credential=credential) as client:
    # All secret operations go inside this block (see examples below)
    ...
```

### Secret Operations

```python
# Set secret
secret = client.set_secret("database-password", "super-secret-value")
print(f"Created: {secret.name}, version: {secret.properties.version}")

# Get secret
secret = client.get_secret("database-password")
print(f"Value: {secret.value}")

# Get specific version
secret = client.get_secret("database-password", version="abc123")

# List secrets (names only, not values)
for secret_properties in client.list_properties_of_secrets():
    print(f"Secret: {secret_properties.name}")

# List versions
for version in client.list_properties_of_secret_versions("database-password"):
    print(f"Version: {version.version}, Created: {version.created_on}")

# Delete secret (soft delete)
poller = client.begin_delete_secret("database-password")
deleted_secret = poller.result()

# Purge (permanent delete, if soft-delete enabled)
client.purge_deleted_secret("database-password")

# Recover deleted secret
client.begin_recover_deleted_secret("database-password").result()
```

## Keys

### KeyClient Setup

```python
from azure.identity import DefaultAzureCredential
from azure.keyvault.keys import KeyClient

credential = DefaultAzureCredential()
vault_url = "https://<vault-name>.vault.azure.net/"

with KeyClient(vault_url=vault_url, credential=credential) as client:
    # All key operations go inside this block (see examples below)
    ...
```

### Key Operations

```python
from azure.keyvault.keys import KeyType

# Create RSA key
rsa_key = client.create_rsa_key("rsa-key", size=2048)

# Create EC key
ec_key = client.create_ec_key("ec-key", curve="P-256")

# Get key
key = client.get_key("rsa-key")
print(f"Key type: {key.key_type}")

# List keys
for key_properties in client.list_properties_of_keys():
    print(f"Key: {key_properties.name}")

# Delete key
poller = client.begin_delete_key("rsa-key")
deleted_key = poller.result()
```

### Cryptographic Operations

```python
from azure.keyvault.keys.crypto import CryptographyClient, EncryptionAlgorithm

# Get crypto client for a specific key
# crypto_client = CryptographyClient(key, credential=credential)
# Or from key ID
with CryptographyClient(
    "https://<vault>.vault.azure.net/keys/<key-name>/<version>",
    credential=credential
) as crypto_client:
    # Encrypt
    plaintext = b"Hello, Key Vault!"
    result = crypto_client.encrypt(EncryptionAlgorithm.rsa_oaep, plaintext)
    ciphertext = result.ciphertext

    # Decrypt
    result = crypto_client.decrypt(EncryptionAlgorithm.rsa_oaep, ciphertext)
    decrypted = result.plaintext

    # Sign
    from azure.keyvault.keys.crypto import SignatureAlgorithm
    import hashlib

    digest = hashlib.sha256(b"data to sign").digest()
    result = crypto_client.sign(SignatureAlgorithm.rs256, digest)
    signature = result.signature

    # Verify
    result = crypto_client.verify(SignatureAlgorithm.rs256, digest, signature)
    print(f"Valid: {result.is_valid}")
```

## Certificates

### CertificateClient Setup

```python
from azure.identity import DefaultAzureCredential
from azure.keyvault.certificates import CertificateClient, CertificatePolicy

credential = DefaultAzureCredential()
vault_url = "https://<vault-name>.vault.azure.net/"

with CertificateClient(vault_url=vault_url, credential=credential) as client:
    # All certificate operations go inside this block (see examples below)
    ...
```

### Certificate Operations

```python
# Create self-signed certificate
policy = CertificatePolicy.get_default()
poller = client.begin_create_certificate("my-cert", policy=policy)
certificate = poller.result()

# Get certificate
certificate = client.get_certificate("my-cert")
print(f"Thumbprint: {certificate.properties.x509_thumbprint.hex()}")

# Get certificate with private key (as secret)
from azure.keyvault.secrets import SecretClient
with SecretClient(vault_url=vault_url, credential=credential) as secret_client:
    cert_secret = secret_client.get_secret("my-cert")
    # cert_secret.value contains PEM or PKCS12

# List certificates
for cert in client.list_properties_of_certificates():
    print(f"Certificate: {cert.name}")

# Delete certificate
poller = client.begin_delete_certificate("my-cert")
deleted = poller.result()
```

## Client Types Table

| Client | Package | Purpose |
|--------|---------|---------|
| `SecretClient` | `azure-keyvault-secrets` | Store/retrieve secrets |
| `KeyClient` | `azure-keyvault-keys` | Manage cryptographic keys |
| `CryptographyClient` | `azure-keyvault-keys` | Encrypt/decrypt/sign/verify |
| `CertificateClient` | `azure-keyvault-certificates` | Manage certificates |

## Async Clients

```python
from azure.identity.aio import DefaultAzureCredential
from azure.keyvault.secrets.aio import SecretClient

async def get_secret():
    async with DefaultAzureCredential() as credential:
        async with SecretClient(vault_url=vault_url, credential=credential) as client:
            secret = await client.get_secret("my-secret")
            print(secret.value)

import asyncio
asyncio.run(get_secret())
```

## Error Handling

```python
from azure.core.exceptions import ResourceNotFoundError, HttpResponseError

try:
    secret = client.get_secret("nonexistent")
except ResourceNotFoundError:
    print("Secret not found")
except HttpResponseError as e:
    if e.status_code == 403:
        print("Access denied - check RBAC permissions")
    raise
```

## Best Practices

1. **Pick sync OR async and stay consistent.** Do not mix `azure.xxx` sync clients with `azure.xxx.aio` async clients in the same call path. Choose one mode per module.
2. **Always use context managers for clients and async credentials.** Wrap every client in `with Client(...) as client:` (sync) or `async with Client(...) as client:` (async). For async `DefaultAzureCredential` from `azure.identity.aio`, also use `async with credential:` so tokens and transports are cleaned up.
3. **Use `DefaultAzureCredential`** for code that runs locally. Use a specific token credential for code that runs in Azure.
4. **Use managed identity** in Azure-hosted applications
5. **Enable soft-delete** for recovery (enabled by default)
6. **Use RBAC** over access policies for fine-grained control
7. **Rotate secrets** regularly using versioning
8. **Use Key Vault references** in App Service/Functions config
9. **Cache secrets** appropriately to reduce API calls
10. **Use async clients** for high-throughput scenarios

Tous les fichiers

0 fichiers

Installer azure-keyvault-py

Téléchargez et extrayez les fichiers de compétences dans votre répertoire .claude/skills/.

Télécharger le ZIP

Clonez le dépôt et copiez les fichiers de compétence dans votre projet.

git clone https://github.com/microsoft/skills/tree/main/.github/plugins/azure-sdk-python/skills/azure-keyvault-py # Copy SKILL.md to your .claude/skills/ directory

Copier

Configuration rapide: Copiez le dossier de la compétence dans .claude/skills/ Claude détectera et utilisera automatiquement la compétence

Dépôt microsoft/skills

Compétences similaires

gmgn-portfolio

Heure mise à jour 1 juillet 2026

zeroize-audit

Heure mise à jour 1 juillet 2026

device-integrity

Heure mise à jour 29 juin 2026

flutter-use-http-package

Heure mise à jour 30 juin 2026