S’authentifier auprès de ressources Azure à partir d’applications Java hébergées localement

Les applications hébergées en dehors de Azure, telles que locales ou dans un centre de données tiers, doivent utiliser un principal de service d’application via Microsoft Entra ID pour s’authentifier auprès de Azure services. Dans les sections suivantes, vous allez apprendre :

Comment inscrire une application auprès de Microsoft Entra pour créer un principal de service.
Comment attribuer des rôles aux permissions de périmètre.
Comment s’authentifier à l’aide d’un principal de service à partir de votre code d’application.

En utilisant des principaux de service d'application dédiés, vous pouvez suivre le principe du moindre privilège pour accéder aux ressources Azure. Limitez les autorisations aux exigences spécifiques de l’application pendant le développement pour empêcher l’accès accidentel à Azure ressources destinées à d’autres applications ou services. Cette approche vous permet également d’éviter les problèmes lors du déplacement de l’application en production en s’assurant que l’application n’est pas sur-privilégiée dans l’environnement de développement.

Créez une inscription d’application différente pour chaque environnement dans lequel vous hébergez l’application. Vous pouvez configurer des autorisations de ressources spécifiques à l'environnement pour chaque principal de service et vérifier qu'une application déployée dans un environnement n'accède pas aux ressources Azure dans un autre environnement.

Inscrire l’application dans Azure

Les objets principaux du service d’application sont créés via une inscription d’application dans Azure à l’aide du portail Azure ou de Azure CLI.

portail Azure
Azure CLI

Dans le portail Azure, utilisez la barre de recherche pour accéder à la page App registrations.
Dans la page App registrations, sélectionnez + Nouvelle inscription.
Dans la page Inscrire une application :
- Pour le champ Nom, entrez une valeur descriptive qui inclut le nom de l’application et l’environnement cible.
- Pour Types de comptes pris en charge, sélectionnez Comptes qui se trouvent uniquement dans cet annuaire organisationnel (géré par le client uniquement - locataire unique), ou l’option qui correspond le mieux à vos besoins.
Sélectionnez Inscrire pour inscrire votre application et créer le principal du service.

capture d’écran
Dans la page d'inscription de l'application , copiez l'ID d'application (client) et l'ID de répertoire (locataire) et collez-les dans un emplacement temporaire pour une utilisation ultérieure dans les configurations de code de votre application.
Sélectionnez Ajouter un certificat ou un secret pour configurer des informations d’identification pour votre application.
Sur la page Certificats & secrets, sélectionnez + Nouvelle clé secrète client.
Dans le panneau volant Ajouter un secret client qui s’ouvre :
- Pour la description, entrez la valeur Current.
- Pour la valeur Expires, conservez la valeur recommandée par défaut .180 days
- Sélectionnez Ajouter pour ajouter le secret.
Sur la page Certificats & secrets, copiez la propriété Valeur du secret client à utiliser dans une étape ultérieure.

Note

La valeur de la clé secrète client n’est affichée qu’une fois après la création de l'inscription de l'application. Vous pouvez ajouter d’autres secrets client sans invalider ce secret client, mais il n’existe aucun moyen d’afficher cette valeur à nouveau.

Azure CLI commandes peuvent être exécutées dans le Azure Cloud Shell ou sur une station de travail avec le Azure CLI installé.

Utilisez la commande az ad sp create-for-rbac pour créer une inscription et un principal de service pour l’application.

az ad sp create-for-rbac --name <service-principal-name>

La sortie de cette commande ressemble au code JSON suivant :

{
  "appId": "00000000-0000-0000-0000-000000000000",
  "displayName": "<service-principal-name>",
  "password": "abcdefghijklmnopqrstuvwxyz",
  "tenant": "11111111-1111-1111-1111-111111111111"
}

Copiez cette sortie dans un fichier temporaire dans un éditeur de texte, car vous aurez besoin de ces valeurs dans une prochaine étape.

Note

La valeur de la clé secrète client n’est affichée qu’une fois après la création de l'inscription de l'application. Vous pouvez ajouter d’autres secrets client sans invalider ce secret client, mais il n’existe aucun moyen d’afficher cette valeur à nouveau.

Attribuer des rôles au principal du service d’application

Ensuite, déterminez les rôles (autorisations) dont votre application a besoin sur les ressources et attribuez ces rôles au principal de service que vous avez créé. Les rôles peuvent être attribués au niveau de la ressource, du groupe de ressources ou de l’étendue de l’abonnement. Cet exemple montre comment attribuer des rôles à l’étendue du groupe de ressources, car la plupart des applications regroupent toutes leurs ressources Azure en un seul groupe de ressources.

portail Azure
Azure CLI

Dans le portail Azure, accédez à la page Overview du groupe de ressources qui contient votre application.
Dans le menu de navigation de gauche, sélectionnez Contrôle d’accès (IAM) .
Dans la page Contrôle d’accès (IAM), sélectionnez + Ajouter , puis choisissez Ajouter une attribution de rôle dans le menu déroulant. La page Ajouter une attribution de rôle fournit plusieurs onglets pour configurer et attribuer des rôles.
Sous l’onglet Rôle , utilisez la zone de recherche pour localiser le rôle que vous souhaitez attribuer. Sélectionnez le rôle, puis choisissez Suivant.
Sous l’onglet Membres :
- Pour la valeur Attribuer l’accès à, sélectionnez Utilisateur, groupe ou principal de service.
- Pour la valeur Membres , choisissez + Sélectionner des membres pour ouvrir le volet volant Sélectionner des membres .
- Recherchez le principal de service que vous avez créé précédemment et sélectionnez-le dans les résultats filtrés. Choisissez Sélectionner pour choisir le groupe et fermer le volet déroulant.
- Sélectionnez Vérifier + affecter en bas de l’onglet Membres .
Sous l’onglet Révision + affectation , sélectionnez Vérifier + affecter en bas de la page.

Utilisez la commande az role definition list pour obtenir les noms des rôles auxquels un principal de service peut être affecté :

az role definition list \
    --query "sort_by([].{roleName:roleName, description:description}, &roleName)" \
    --output table

Utilisez la commande az role assignment create pour affecter un rôle à un principal de service d’application :
```
az role assignment create \
    --assignee "<app-Id>" \
    --role "<role-name>" \
    --resource-group "<resource-group-name>"
```
Pour plus d’informations sur l’attribution d’autorisations au niveau de la ressource ou de l’abonnement à l’aide du Azure CLI, consultez Assigner des rôles Azure à l’aide du Azure CLI.

Définir les variables d’environnement d’application

Lors de l’exécution, certaines authentifications de la bibliothèque d’identités Azure, telles que DefaultAzureCredential, EnvironmentCredential et ClientSecretCredential, recherchent par convention les informations de principal de service dans les variables d’environnement. Lorsque vous utilisez Java, vous pouvez configurer des variables d’environnement de plusieurs façons, en fonction de vos outils et de votre environnement.

Quelle que soit l’approche choisie, configurez les variables d’environnement suivantes pour un principal de service :

AZURE_CLIENT_ID : utilisé pour identifier l’application inscrite dans Azure.
AZURE_TENANT_ID : ID du locataire Microsoft Entra.
AZURE_CLIENT_SECRET: informations d’identification secrètes générées pour l’application.

Définissez les variables d’environnement suivantes. Remplacez les valeurs d’espace réservé par les valeurs réelles de l'enregistrement de votre application :

export AZURE_CLIENT_ID="<your-client-id>"
export AZURE_TENANT_ID="<your-tenant-id>"
export AZURE_CLIENT_SECRET="<your-client-secret>"

Pour une application Java s’exécutant en tant que service système sur un serveur de production, définissez les variables d’environnement dans un fichier et référencez-la avec la directive EnvironmentFile dans le fichier d’unité de service :

[Unit]
Description=Java application service
After=network.target

[Service]
User=app-user
WorkingDirectory=/path/to/java-app
EnvironmentFile=/path/to/java-app/app-environment-variables
ExecStart=/usr/bin/java -jar app.jar

[Install]
WantedBy=multi-user.target

Le fichier d’environnement doit contenir une liste de variables d’environnement avec leurs valeurs :

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

Dans Visual Studio Code, définissez des variables d’environnement dans le fichier .vscode/launch.json de votre projet. L’application utilise automatiquement ces valeurs au démarrage. Toutefois, ces configurations ne se déplacent pas avec votre application pendant le déploiement. Vous devez donc configurer des variables d’environnement sur votre environnement d’hébergement cible.

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "java",
            "name": "Launch App",
            "request": "launch",
            "mainClass": "com.example.App",
            "env": {
                "AZURE_CLIENT_ID": "<your-client-id>",
                "AZURE_TENANT_ID": "<your-tenant-id>",
                "AZURE_CLIENT_SECRET": "<your-client-secret>"
            }
        }
    ]
}

Configurez les variables d’environnement dans la configuration d’exécution :

Sélectionnez Exécuter > Modifier les configurations....
Sélectionnez la configuration de votre application.

Dans le champ Variables d’environnement , ajoutez vos variables :

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

Sélectionnez Appliquer, puis OK.

Vous pouvez définir des variables d’environnement pour Windows à partir de la ligne de commande. Toutefois, toutes les applications exécutées sur ce système d’exploitation peuvent accéder aux valeurs, ce qui peut entraîner des conflits. Soyez prudent avec cette approche. Vous pouvez définir des variables d’environnement au niveau de l’utilisateur ou du système.

# Set user environment variables
setx AZURE_CLIENT_ID "<your-client-id>"
setx AZURE_TENANT_ID "<your-tenant-id>"
setx AZURE_CLIENT_SECRET "<your-client-secret>"

# Set system environment variables - requires running as admin
setx AZURE_CLIENT_ID "<your-client-id>" /m
setx AZURE_TENANT_ID "<your-tenant-id>" /m
setx AZURE_CLIENT_SECRET "<your-client-secret>" /m

Vous pouvez également utiliser PowerShell pour définir des variables d’environnement au niveau de l’utilisateur ou du système :

# Set user environment variables
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_ID", "<your-client-id>", "User")
[Environment]::SetEnvironmentVariable("AZURE_TENANT_ID", "<your-tenant-id>", "User")
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_SECRET", "<your-client-secret>", "User")

# Set system environment variables - requires running as admin
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_ID", "<your-client-id>", "Machine")
[Environment]::SetEnvironmentVariable("AZURE_TENANT_ID", "<your-tenant-id>", "Machine")
[Environment]::SetEnvironmentVariable("AZURE_CLIENT_SECRET", "<your-client-secret>", "Machine")

S’authentifier auprès de Azure services à partir de votre application

La bibliothèque d’identités Azure fournit différentes informations d'identification - implémentations de TokenCredential qui prennent en charge différents scénarios et flux d’authentification de Microsoft Entra. Les étapes suivantes vous montrent comment utiliser ClientSecretCredential lorsque vous travaillez avec des principaux de service localement et en production.

Implémenter le code

Ajoutez la azure-identity dépendance à votre pom.xml fichier :

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

Vous accédez aux services Azure à l’aide de classes clientes spécialisées à partir des différentes bibliothèques clientes Azure SDK. Pour tout code Java qui crée un objet client Azure SDK dans votre application, procédez comme suit :

Importez la ClientSecretCredentialBuilder classe à partir du com.azure.identity package.
Créez un ClientSecretCredential objet en utilisant ClientSecretCredentialBuilder avec le tenantId, clientId, et clientSecret.
Transmettez l'instance ClientSecretCredential à la méthode credential du générateur d'objets client Azure SDK.

Un exemple de cette approche est illustré dans le segment de code suivant :

import com.azure.identity.ClientSecretCredential;
import com.azure.identity.ClientSecretCredentialBuilder;
import com.azure.storage.blob.BlobServiceClient;
import com.azure.storage.blob.BlobServiceClientBuilder;

String tenantId = System.getenv("AZURE_TENANT_ID");
String clientId = System.getenv("AZURE_CLIENT_ID");
String clientSecret = System.getenv("AZURE_CLIENT_SECRET");

ClientSecretCredential credential = new ClientSecretCredentialBuilder()
    .tenantId(tenantId)
    .clientId(clientId)
    .clientSecret(clientSecret)
    .build();

BlobServiceClient blobServiceClient = new BlobServiceClientBuilder()
    .endpoint("https://<account-name>.blob.core.windows.net")
    .credential(credential)
    .buildClient();

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-03-11