Bibliothèque Azure Identity pour Java

Bibliothèque d'authentification pour les clients Azure SDK utilisant Microsoft Entra ID.

Installation

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.15.0</version>
</dependency>

Concepts clés

DefaultAzureCredential (Recommandé)

DefaultAzureCredential essaie plusieurs méthodes d'authentification dans l'ordre. Consultez Vue d'ensemble de DefaultAzureCredential pour l'ordre actuel de la chaîne de credentials et les valeurs par défaut.

import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;

// Utilisation simple
DefaultAzureCredential credential = new DefaultAzureCredentialBuilder().build();

// Utilisation avec n'importe quel client Azure
BlobServiceClient blobClient = new BlobServiceClientBuilder()
    .endpoint("https://<storage-account>.blob.core.windows.net")
    .credential(credential)
    .buildClient();

KeyClient keyClient = new KeyClientBuilder()
    .vaultUrl("https://<vault-name>.vault.azure.net")
    .credential(credential)
    .buildClient();

Configurer DefaultAzureCredential

DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
    .managedIdentityClientId("<user-assigned-identity-client-id>")  // Pour MI assignée par l'utilisateur
    .tenantId("<tenant-id>")                                        // Limiter à un tenant spécifique
    .excludeEnvironmentCredential()                                 // Ignorer les variables d'env
    .excludeAzureCliCredential()                                    // Ignorer Azure CLI
    .build();

Identité managée

Pour les applications hébergées sur Azure (App Service, Functions, AKS, VMs).

import com.azure.identity.ManagedIdentityCredential;
import com.azure.identity.ManagedIdentityCredentialBuilder;

// Identité managée assignée par le système
ManagedIdentityCredential credential = new ManagedIdentityCredentialBuilder()
    .build();

// Identité managée assignée par l'utilisateur (par client ID)
ManagedIdentityCredential credential = new ManagedIdentityCredentialBuilder()
    .clientId("<user-assigned-client-id>")
    .build();

// Identité managée assignée par l'utilisateur (par resource ID)
ManagedIdentityCredential credential = new ManagedIdentityCredentialBuilder()
    .resourceId("/subscriptions/<sub>/resourceGroups/<rg>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<name>")
    .build();

Service principal avec secret

import com.azure.identity.ClientSecretCredential;
import com.azure.identity.ClientSecretCredentialBuilder;

ClientSecretCredential credential = new ClientSecretCredentialBuilder()
    .tenantId("<tenant-id>")
    .clientId("<client-id>")
    .clientSecret("<client-secret>")
    .build();

Service principal avec certificat

import com.azure.identity.ClientCertificateCredential;
import com.azure.identity.ClientCertificateCredentialBuilder;

// Depuis un fichier PEM
ClientCertificateCredential credential = new ClientCertificateCredentialBuilder()
    .tenantId("<tenant-id>")
    .clientId("<client-id>")
    .pemCertificate("<path-to-cert.pem>")
    .build();

// Depuis un fichier PFX avec mot de passe
ClientCertificateCredential credential = new ClientCertificateCredentialBuilder()
    .tenantId("<tenant-id>")
    .clientId("<client-id>")
    .pfxCertificate("<path-to-cert.pfx>", "<pfx-password>")
    .build();

// Envoyer la chaîne de certificats pour SNI
ClientCertificateCredential credential = new ClientCertificateCredentialBuilder()
    .tenantId("<tenant-id>")
    .clientId("<client-id>")
    .pemCertificate("<path-to-cert.pem>")
    .sendCertificateChain(true)
    .build();

Environment Credential

Lit les credentials depuis les variables d'environnement.

import com.azure.identity.EnvironmentCredential;
import com.azure.identity.EnvironmentCredentialBuilder;

EnvironmentCredential credential = new EnvironmentCredentialBuilder().build();

Variables d'environnement requises

Pour service principal avec secret :

AZURE_TENANT_ID=<tenant-id>
AZURE_CLIENT_ID=<client-id>
AZURE_CLIENT_SECRET=<client-secret>

Pour service principal avec certificat :

AZURE_TENANT_ID=<tenant-id>
AZURE_CLIENT_ID=<client-id>
AZURE_CLIENT_CERTIFICATE_PATH=/path/to/cert.pem
AZURE_CLIENT_CERTIFICATE_PASSWORD=<optional-password>

Azure CLI Credential

Pour le développement local avec az login.

import com.azure.identity.AzureCliCredential;
import com.azure.identity.AzureCliCredentialBuilder;

AzureCliCredential credential = new AzureCliCredentialBuilder()
    .tenantId("<tenant-id>")  // Optionnel : tenant spécifique
    .build();

Navigateur interactif

Pour les applications de bureau nécessitant une connexion utilisateur.

import com.azure.identity.InteractiveBrowserCredential;
import com.azure.identity.InteractiveBrowserCredentialBuilder;

InteractiveBrowserCredential credential = new InteractiveBrowserCredentialBuilder()
    .clientId("<client-id>")
    .redirectUrl("http://localhost:8080")  // Doit correspondre à l'inscription d'app
    .build();

Code d'appareil

Pour les appareils sans interface (IoT, outils CLI).

import com.azure.identity.DeviceCodeCredential;
import com.azure.identity.DeviceCodeCredentialBuilder;

DeviceCodeCredential credential = new DeviceCodeCredentialBuilder()
    .clientId("<client-id>")
    .challengeConsumer(challenge -> {
        // Afficher à l'utilisateur
        System.out.println(challenge.getMessage());
    })
    .build();

Chained Credential

Créer des chaînes d'authentification personnalisées.

import com.azure.identity.ChainedTokenCredential;
import com.azure.identity.ChainedTokenCredentialBuilder;

ChainedTokenCredential credential = new ChainedTokenCredentialBuilder()
    .addFirst(new ManagedIdentityCredentialBuilder().build())
    .addLast(new AzureCliCredentialBuilder().build())
    .build();

Workload Identity (AKS)

Pour Azure Kubernetes Service avec workload identity.

import com.azure.identity.WorkloadIdentityCredential;
import com.azure.identity.WorkloadIdentityCredentialBuilder;

// Lit depuis AZURE_TENANT_ID, AZURE_CLIENT_ID, AZURE_FEDERATED_TOKEN_FILE
WorkloadIdentityCredential credential = new WorkloadIdentityCredentialBuilder().build();

// Ou configuration explicite
WorkloadIdentityCredential credential = new WorkloadIdentityCredentialBuilder()
    .tenantId("<tenant-id>")
    .clientId("<client-id>")
    .tokenFilePath("/var/run/secrets/azure/tokens/azure-identity-token")
    .build();

Mise en cache des tokens

Activer la mise en cache persistante des tokens pour de meilleures performances.

// Activer la mise en cache des tokens (en mémoire par défaut)
DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
    .enableAccountIdentifierLogging()
    .build();

// Avec cache de tokens partagé (pour scénarios multi-credentials)
SharedTokenCacheCredential credential = new SharedTokenCacheCredentialBuilder()
    .clientId("<client-id>")
    .build();

Clouds souverains

import com.azure.identity.AzureAuthorityHosts;

// Azure Government
DefaultAzureCredential govCredential = new DefaultAzureCredentialBuilder()
    .authorityHost(AzureAuthorityHosts.AZURE_GOVERNMENT)
    .build();

// Azure China
DefaultAzureCredential chinaCredential = new DefaultAzureCredentialBuilder()
    .authorityHost(AzureAuthorityHosts.AZURE_CHINA)
    .build();

Gestion des erreurs

import com.azure.identity.CredentialUnavailableException;
import com.azure.core.exception.ClientAuthenticationException;

try {
    DefaultAzureCredential credential = new DefaultAzureCredentialBuilder().build();
    AccessToken token = credential.getToken(new TokenRequestContext()
        .addScopes("https://management.azure.com/.default"));
} catch (CredentialUnavailableException e) {
    // Aucun credential n'a pu s'authentifier
    System.out.println("Authentication failed: " + e.getMessage());
} catch (ClientAuthenticationException e) {
    // Erreur d'authentification (mauvais credentials, expirés, etc.)
    System.out.println("Auth error: " + e.getMessage());
}

Journalisation

Activer la journalisation d'authentification pour le débogage.

// Via variable d'environnement
// AZURE_LOG_LEVEL=verbose

// Ou par programme
DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
    .enableAccountIdentifierLogging()  // Enregistrer les infos de compte
    .build();

Variables d'environnement

# Configuration de DefaultAzureCredential
AZURE_TENANT_ID=<tenant-id>
AZURE_CLIENT_ID=<client-id>
AZURE_CLIENT_SECRET=<client-secret>

# Identité managée
AZURE_CLIENT_ID=<user-assigned-mi-client-id>

# Workload Identity (AKS)
AZURE_FEDERATED_TOKEN_FILE=/var/run/secrets/azure/tokens/azure-identity-token

# Journalisation
AZURE_LOG_LEVEL=verbose

# Hôte d'autorité
AZURE_AUTHORITY_HOST=https://login.microsoftonline.com/

Bonnes pratiques

1. Utiliser DefaultAzureCredential - Fonctionne sans interruption du développement à la production
2. Identité managée en production - Pas de secrets à gérer, rotation automatique
3. Azure CLI pour le développement local - Exécuter az login avant de lancer votre app
4. Principe du moindre privilège - Accorder uniquement les permissions requises aux service principals
5. Mise en cache des tokens - Activée par défaut, réduit les allers-retours d'authentification
6. Variables d'environnement - Utiliser pour CI/CD, pas de secrets en dur

Matrice de sélection des credentials

Phrases déclencheurs

• "Azure authentication Java", "DefaultAzureCredential Java"
• "managed identity Java", "service principal Java"
• "Azure login Java", "Azure credentials Java"
• "AZURE_CLIENT_ID", "AZURE_TENANT_ID"