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 aperçu de DefaultAzureCredential pour l'ordre actuel de la chaîne de credentials et les paramètres 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 attribuée par l'utilisateur
    .tenantId("<tenant-id>")                                        // Limiter à un locataire spécifique
    .excludeEnvironmentCredential()                                 // Ignorer les variables d'environnement
    .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 attribuée par le système
ManagedIdentityCredential credential = new ManagedIdentityCredentialBuilder()
    .build();

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

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

Principal de service 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();

Principal de service avec certificat

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

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

// À partir d'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();

Credential d'environnement

Lit les credentials à partir des variables d'environnement.

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

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

Variables d'environnement requises

Pour principal de service avec secret :

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

Pour principal de service 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>

Credential Azure CLI

Pour le développement local utilisant az login.

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

AzureCliCredential credential = new AzureCliCredentialBuilder()
    .tenantId("<tenant-id>")  // Optionnel : locataire 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'application
    .build();

Code de dispositif

Pour les dispositifs 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();

Credential chaîné

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 à partir de 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 jetons

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

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

// Avec cache de jetons partagé (pour scénarios multi-credential)
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 ne peut s'authentifier
    System.out.println("Authentication failed: " + e.getMessage());
} catch (ClientAuthenticationException e) {
    // Erreur d'authentification (credentials erronées, expirées, 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()  // Journaliser les informations de compte
    .build();

Variables d'environnement

# Configuration 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/

Meilleures pratiques

1. Utiliser DefaultAzureCredential - Fonctionne sans problème du développement à la production
2. Identité managée en production - Pas de secrets à gérer, rotation automatique
3. Azure CLI pour développement local - Exécuter az login avant de lancer votre application
4. Privilèges minimaux - Accorder uniquement les permissions requises aux principaux de service
5. Mise en cache des jetons - 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"