Connexion à l’aide de l’authentification Microsoft Entra

Télécharger le pilote JDBC

Cet article donne des informations sur le développement d’applications Java pour utiliser la fonctionnalité d’authentification Microsoft Entra avec le pilote JDBC Microsoft pour SQL Server.

Vous pouvez utiliser l’authentification Microsoft Entra qui est un mécanisme de connexion à la base de données Azure SQL, à Azure SQL Managed Instance et à Azure Synapse Analytics à l’aide d’identités dans Microsoft Entra ID. Utilisez l’authentification Microsoft Entra pour gérer de manière centralisée les identités des utilisateurs de base de données et comme alternative à l’authentification SQL Server. Le pilote JDBC vous permet de spécifier vos informations d’identification Microsoft Entra dans la chaîne de connexion JDBC pour vous connecter à Azure SQL. Pour plus d’informations sur la configuration de l’authentification Microsoft Entra, consultez Connexion à Azure SQL à l’aide de l’authentification Microsoft Entra.

Les propriétés de connexion pour la prise en charge de l’authentification Microsoft Entra dans le pilote JDBC Microsoft pour SQ  Server sont les suivantes :

• authentication : utilisez cette propriété pour indiquer la méthode d’authentification SQL à utiliser pour la connexion. Les valeurs possibles sont les suivantes :

  • ActiveDirectoryManagedIdentity

    • Depuis la version v8.3.1 du pilote, vous pouvez utiliser authentication=ActiveDirectoryMSI pour vous connecter à une instance Azure SQL Database/Synapse Analytics à partir d’une ressource Azure où la prise en charge de la fonctionnalité « Identity » est activée. Si vous le souhaitez, vous pouvez spécifier msiClientId dans les propriétés de connexion/source de données avec ce mode d’authentification. msiClientId doit contenir l’ID client d’une identité managée à utiliser pour acquérir l’accessToken pour l’établissement de la connexion. Depuis la version 12.2 du pilote, vous pouvez également utiliser authentication=ActiveDirectoryManagedIdentity pour vous connecter à une instance Azure SQL Database/Synapse Analytics à partir d’une ressource Azure où la prise en charge de la fonctionnalité « Identity » est activée. Si vous le souhaitez, l’ID client d’une identité managée peut également être défini dans la propriété user. Pour plus d’informations, consultez la section Se connecter à l’aide du mode d’authentification ActiveDirectoryManagedIdentity.

  • ActiveDirectoryDefault

    • Depuis la version 12.2 du pilote, vous pouvez utiliser authentication=ActiveDirectoryDefault pour vous connecter à Azure SQL / Synapse Analytics via DefaultAzureCredential dans la bibliothèque de client Azure Identity. Pour plus d’informations, consultez Se connecter à l’aide du mode d’authentification ActiveDirectoryDefault.

  • ActiveDirectoryIntegrated

    • Depuis la version 6.0 du pilote, vous pouvez utiliser authentication=ActiveDirectoryIntegrated pour vous connecter à Azure SQL/Synapse Analytics à l’aide de l’authentification intégrée. Pour utiliser ce mode d’authentification, vous devez fédérer les services de fédération Active Directory (ADFS) sur site avec Microsoft Entra ID dans le cloud. Une fois que vous l'avez configuré, vous pouvez vous connecter en ajoutant la bibliothèque native mssql-jdbc_auth-<version>-<arch>.dll au chemin de la classe d’application sur Windows ou en configurant un ticket Kerberos pour la prise en charge de l’authentification multiplateforme. Vous pouvez accéder à Azure SQL / Azure Synapse Analytics sans être invité à entrer des informations d’identification quand vous vous connectez à une machine jointe à un domaine. Pour plus d’informations, consultez Se connecter à l’aide du mode d’authentification ActiveDirectoryIntegrated.

  • ActiveDirectoryPassword

    • Depuis la version 6.0 du pilote, vous pouvez utiliser authentication=ActiveDirectoryPassword pour vous connecter à Azure SQL/Synapse Analytics avec un nom d’utilisateur et un mot de passe Microsoft Entra. Pour plus d’informations, consultez Se connecter à l’aide du mode d’authentification ActiveDirectoryPassword.

  • ActiveDirectoryInteractive

    • Depuis la version 9.2 du pilote, vous pouvez utiliser authentication=ActiveDirectoryInteractive pour vous connecter à Azure SQL / Synapse Analytics à l’aide d’un flux d’authentification interactif (authentification multifacteur). Pour plus d’informations, consultez Se connecter à l’aide du mode d’authentification ActiveDirectoryInteractive.

  • ActiveDirectoryServicePrincipal

    • Depuis la version 9.2 du pilote, vous pouvez utiliser authentication=ActiveDirectoryServicePrincipal pour vous connecter à Azure SQL / Synapse Analytics en spécifiant l’ID d’application/client dans la propriété userName et le secret d’une identité de principal de service dans la propriété password. Pour plus d’informations, consultez Se connecter à l’aide du mode d’authentification ActiveDirectoryServicePrincipal.

  • ActiveDirectoryServicePrincipalCertificate

    • Depuis la version 12.4 du pilote, vous pouvez utiliser authentication=ActiveDirectoryServicePrincipalCertificate pour vous connecter à Azure SQL Database/Synapse Analytics en spécifiant l’ID d’application/client dans la propriété userName et l’emplacement du certificat du Principal de service dans la propriété clientCertificate. Pour plus d’informations, consultez Se connecter à l’aide du mode d’authentification ActiveDirectoryServicePrincipalCertificate.

  • SqlPassword

    • Utilisez authentication=SqlPassword pour vous connecter à un serveur SQL Server avec les propriétés userName/user et password.

  • NotSpecified

    • Utilisez l’authentification authentication=NotSpecified ou conservez-la comme authentification par défaut si aucune de ces méthodes d’authentification n’est nécessaire.

  • accessToken : utilisez cette propriété de connexion pour vous connecter à SQL Database avec un jeton d’accès. accessToken peut uniquement être défini à l’aide du paramètre Propriétés de la méthode getConnection() dans la classe DriverManager. Il ne peut pas être utilisé dans l’URL de connexion.

Pour plus d’informations, consultez la propriété d’authentification à la page Définition des propriétés de connexion.

Configuration d'installation client requise

Outre la Configuration requise du pilote de base, les modes d’authentification suivants sont soumis à des exigences supplémentaires.

Le tableau suivant répertorie les dépendances de bibliothèque requises pour chaque mode d’authentification et version du pilote. Les dépendances de dépendances sont également requises.

Se connecter en utilisant le mode d’authentification ActiveDirectoryManagedIdentity

Ce mode d’authentification est pris en charge à partir de la version 7.2. Pour l’utiliser, spécifiez authentication=ActiveDirectoryMSI. À partir de la version 12.2, vous pouvez également spécifier authentication=ActiveDirectoryManagedIdentity.

Outre les exigences de dépendance de bibliothèque répertoriées dans Exigences de configuration du client, cette fonctionnalité présente les exigences suivantes :

• La base de données cible doit avoir un utilisateur de base de données autonome, avec l’autorisation CONNECT. L’utilisateur autonome doit représenter l’identité managée affectée par le système ou l’identité managée affectée par l’utilisateur de votre ressource Azure ou l’un des groupes auquel appartient votre identité managée.

• L’environnement client doit être une ressource Azure et la prise en charge de la fonctionnalité « Identity » doit être activée. Le tableau suivant répertorie les services Azure pris en charge par chaque version du pilote JDBC :

  Version du pilote	Dépendances requises	Services Azure pris en charge
  7.2–11.2	Aucune	Azure App Service et Azure Functions Machines virtuelles Azure
  12,2 12.4 12.6 12.8	azure-identity 1.7.0 azure-identity 1.9.0 azure-identity 1.11.1 azure-identity 1.12.2	Azure App Service et Azure Functions Azure Arc Azure Cloud Shell Azure Kubernetes Service Azure Service Fabric Machines virtuelles Azure Azure Virtual Machine Scale Sets

L’exemple suivant montre comment utiliser le mode authentication=ActiveDirectoryManagedIdentity. Exécutez cet exemple à partir d’une ressource Azure configurée pour Managed Identity.

Pour exécuter l’exemple, remplacez le nom du serveur/de la base de données par le nom de votre serveur/base de données dans les lignes suivantes :

ds.setServerName("msentra-managed-demo.database.windows.net"); // replace 'msentra-managed-demo' with your server name
ds.setDatabaseName("demo"); // replace with your database name
//Optional
ds.setMSIClientId("<managed_identity_client>"); // Replace with Client ID of user-assigned managed identity to be used

Exemple d’utilisation du mode d’authentification ActiveDirectoryMSI :

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

import com.microsoft.sqlserver.jdbc.SQLServerDataSource;

public class MsEntraMSI {
    public static void main(String[] args) throws Exception {

        SQLServerDataSource ds = new SQLServerDataSource();
        ds.setServerName("msentra-managed-demo.database.windows.net"); // Replace with your server name
        ds.setDatabaseName("demo"); // Replace with your database name
        ds.setAuthentication("ActiveDirectoryMSI");
        // Optional
        ds.setMSIClientId("<managed_identity_client_guid>"); // Replace with Client ID of user-assigned managed identity to be used

        try (Connection connection = ds.getConnection();
                Statement stmt = connection.createStatement();
                ResultSet rs = stmt.executeQuery("SELECT SUSER_SNAME()")) {
            if (rs.next()) {
                System.out.println("You have successfully logged on as: " + rs.getString(1));
            }
        }
    }
}

L’exemple suivant montre comment utiliser le mode authentication=ActiveDirectoryManagedIdentity.

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

import com.microsoft.sqlserver.jdbc.SQLServerDataSource;

public class MSEntraManagedIdentity {
    public static void main(String[] args) throws Exception {

        SQLServerDataSource ds = new SQLServerDataSource();
        ds.setServerName("msentra-managed-demo.database.windows.net"); // Replace with your server name
        ds.setDatabaseName("demo"); // Replace with your database name
        ds.setAuthentication("ActiveDirectoryManagedIdentity"); // ActiveDirectoryManagedIdentity for JDBC driver version v12.2.0+
        // Optional
        ds.setUser("<managed_identity_client>"); // Replace with Client ID of User-Assigned Managed Identity to be used

        try (Connection connection = ds.getConnection();
                Statement stmt = connection.createStatement();
                ResultSet rs = stmt.executeQuery("SELECT SUSER_SNAME()")) {
            if (rs.next()) {
                System.out.println("You have successfully logged on as: " + rs.getString(1));
            }
        }
    }
}

Ces exemples sur une machine virtuelle Azure récupèrent un jeton d’accès à partir de l’identité managée affectée par le système ou de l’identité managée affectée par l’utilisateur (si msiClientIdou user est spécifié avec un ID client d’une identité managée) et établit une connexion à l’aide du jeton d’accès récupéré. Si une connexion est établie, le message suivant doit s’afficher :

You have successfully logged on as: <your Managed Identity username>

Se connecter en utilisant le mode d’authentification ActiveDirectoryDefault

L’option d’authentification ActiveDirectoryDefault utilise l’implémentation TokenCredential chaînée de DefaultAzureCredential de la bibliothèque de client Azure Identity. Les informations d’identification combinent les méthodes d’authentification couramment utilisées, lesquelles sont enchaînées.

L’authentification ActiveDirectoryDefault nécessite une dépendance au moment de l’exécution vis-à-vis de la bibliothèque de client Azure Identity pour Managed Identity. Pour plus d’informations sur la version de la bibliothèque, consultez Exigences de configuration du client.

Le tableau suivant répertorie la chaîne d’identifiant DefaultAzureCredential pour chaque version du pilote JDBC.

Il existe de nombreuses variables qui peuvent être définies pour configurer l’identifiant Environment. Pour plus d’informations sur la configuration de la chaîne DefaulAzureCredential, y compris l’identifiant Environment, consultez la version appropriée de la documentation azure-identity liée dans le tableau précédent.

Pour utiliser IntellijCredential sur Windows, définissez la variable d’environnement INTELLIJ_KEEPASS_PATH sur l’emplacement de votre fichier keepass. Par exemple : INTELLIJ_KEEPASS_PATH=C:\user\your\path\to\the\keepass\file.

Pour fournir davantage de clients à DefaultAzureCredential, utilisez la variable d’environnement ADDITIONALLY_ALLOWED_TENANTS. Cette variable utilise une liste délimitée par des virgules. Par exemple, ADDITIONALLY_ALLOWED_TENANTS=<your-tenant-id-0>,<your-tenant-id-1>,<your-tenant-id-2>,...

L’exemple suivant montre comment utiliser le mode authentication=ActiveDirectoryDefault avec AzureCliCredential dans DefaultAzureCredential.

1. Pour commencer, connectez-vous à Azure CLI avec la commande suivante.

   az login
   

2. Une fois la connexion à Azure CLI établie, exécutez le code suivant.

   import java.sql.Connection;
   import java.sql.ResultSet;
   import java.sql.Statement;
   
   import com.microsoft.sqlserver.jdbc.SQLServerDataSource;
   
   public class MSEntraDefault {
       public static void main(String[] args) throws Exception {
   
           SQLServerDataSource ds = new SQLServerDataSource();
           ds.setServerName("msentra-managed-demo.database.windows.net"); // Replace with your server name
           ds.setDatabaseName("demo"); // Replace with your database name
           ds.setAuthentication("ActiveDirectoryDefault");
   
           try (Connection connection = ds.getConnection();
                   Statement stmt = connection.createStatement();
                   ResultSet rs = stmt.executeQuery("SELECT SUSER_SNAME()")) {
               if (rs.next()) {
                   System.out.println("You have successfully logged on as: " + rs.getString(1));
               }
           }
       }
   }
   

Se connecter à l’aide du mode d’authentification ActiveDirectoryIntegrated

Il existe deux façons d’utiliser l’authentification ActiveDirectoryIntegrated dans Microsoft JDBC Driver pour SQL Server :

• Sur Windows, le fichier mssql-jdbc_auth-<version>-<arch>.dll issu du package téléchargé peut être copié vers un emplacement du chemin du système.
• Si vous ne pouvez pas utiliser la DLL, la version 6.4 et les versions ultérieures vous permettront de configurer un ticket Kerberos. Cette méthode est prise en charge sur plusieurs plateformes (Windows, Linux et macOS). Pour plus d’informations, consultez Définir le ticket Kerberos sur Windows, Linux et macOS.

Vérifiez que vous disposez des bibliothèques dépendantes requises selon les Exigences de configuration du client.

L’exemple suivant montre comment utiliser le mode authentication=ActiveDirectoryIntegrated. Cet exemple est exécuté sur un ordinateur joint à un domaine qui est fédéré avec Microsoft Entra ID. Un utilisateur de base de données qui représente votre utilisateur Windows doit exister dans la base de données et doit disposer de l’autorisation CONNECT.

Avant d’exécuter l’exemple, remplacez le nom du serveur/de la base de données par le nom de votre serveur/base de données dans les lignes suivantes :

ds.setServerName("msentra-managed-demo.database.windows.net"); // replace 'msentra-managed-demo' with your server name
ds.setDatabaseName("demo"); // replace with your database name

Exemple d’utilisation du mode d’authentification ActiveDirectoryIntegrated :

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

import com.microsoft.sqlserver.jdbc.SQLServerDataSource;

public class MSEntraIntegrated {
    public static void main(String[] args) throws Exception {

        SQLServerDataSource ds = new SQLServerDataSource();
        ds.setServerName("msentra-managed-demo.database.windows.net"); // Replace with your server name
        ds.setDatabaseName("demo"); // Replace with your database name
        ds.setAuthentication("ActiveDirectoryIntegrated");

        try (Connection connection = ds.getConnection();
                Statement stmt = connection.createStatement();
                ResultSet rs = stmt.executeQuery("SELECT SUSER_SNAME()")) {
            if (rs.next()) {
                System.out.println("You have successfully logged on as: " + rs.getString(1));
            }
        }
    }
}

L’exécution de cet exemple utilise automatiquement votre ticket Kerberos à partir de la plateforme client et aucun mot de passe n’est requis. Si une connexion est établie, le message suivant doit s’afficher :

You have successfully logged on as: <your domain user name>

Définir le ticket Kerberos sur Windows, Linux et macOS

Vous devez configurer un ticket Kerberos pour lier votre utilisateur actif à un compte de domaine Windows. Vous trouverez ci-dessous un résumé des étapes principales.

Windows

JDK est fourni avec kinit, que vous pouvez utiliser pour obtenir un TGT à partir d’un centre de distribution de clés sur un ordinateur joint à un domaine fédéré avec Microsoft Entra.

Étape 1 : Tester la récupération d’accords de ticket

• Exécuter sur : Windows

• Action :

  • Utilisez la commande kinit username@DOMAIN.COMPANY.COM pour obtenir un TGT du KDC. Vous êtes alors invité à entrer votre mot de passe de domaine.
  • Utilisez klist pour afficher les tickets disponibles. Si l’exécution de kinit a réussi, vous devez voir un ticket de krbtgt/DOMAIN.COMPANY.COM@ DOMAIN.COMPANY.COM.

  Remarque

  Vous devrez peut-être spécifier un fichier .ini avec -Djava.security.krb5.conf pour que votre application localise KDC.

Linux et macOS

Spécifications

Accédez à un ordinateur Windows joint à un domaine pour interroger votre contrôleur de domaine Kerberos.

Étape 1 : Rechercher Kerberos KDC

• Exécuter sur : Ligne de commande Windows

• Action : nltest /dsgetdc:DOMAIN.COMPANY.COM (où DOMAIN.COMPANY.COM correspond au nom de votre domaine)

• Exemple de sortie

  DC: \\co1-red-dc-33.domain.company.com
  Address: \\2111:4444:2111:33:1111:ecff:ffff:3333
  ...
  The command completed successfully
  

• Informations à extraire Nom du contrôleur de domaine, dans ce cas co1-red-dc-33.domain.company.com

Étape 2 : configurer KDC dans krb5.conf

• Exécuter sur : Linux/macOS

• Action : Modifiez /etc/krb5.conf dans l’éditeur de votre choix. Configurez les clés suivantes

  [libdefaults]
    default_realm = DOMAIN.COMPANY.COM
  
  [realms]
  DOMAIN.COMPANY.COM = {
     kdc = co1-red-dc-28.domain.company.com
  }
  

  Ensuite, enregistrez le fichier krb5.conf et quittez

  Remarque

  Le domaine doit être en MAJUSCULES.

Étape 3 : tester la récupération de ticket d’attribution de ticket

• Exécuter sur : Linux/macOS
• Action :
  • Utilisez la commande kinit username@DOMAIN.COMPANY.COM pour obtenir un TGT du KDC. Vous êtes alors invité à entrer votre mot de passe de domaine.
  • Utilisez klist pour afficher les tickets disponibles. Si l’exécution de kinit a réussi, vous devez voir un ticket de krbtgt/DOMAIN.COMPANY.COM@ DOMAIN.COMPANY.COM.

Se connecter à l’aide du mode d’authentification ActiveDirectoryPassword

L’exemple suivant montre comment utiliser le mode authentication=ActiveDirectoryPassword.

Pour générer et exécuter l’exemple :

1. Vérifiez que vous disposez des bibliothèques dépendantes requises selon les Exigences de configuration du client.

2. Localisez les lignes de code suivantes et remplacez le nom du serveur/de la base de données par le nom de votre serveur/base de données.

   ds.setServerName("msentra-managed-demo.database.windows.net"); // replace 'msentra-managed-demo' with your server name
   ds.setDatabaseName("demo"); // replace with your database name
   

3. Recherchez les lignes de code suivantes. Remplacez le nom d’utilisateur par le nom de l’utilisateur Microsoft Entra avec lequel vous souhaitez vous connecter.

   ds.setUser("bob@example.com"); // replace with your username
   ds.setPassword("password");     // replace with your password
   

Exemple d’utilisation du mode d’authentification ActiveDirectoryPassword :

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

import com.microsoft.sqlserver.jdbc.SQLServerDataSource;

public class MSEntraUserPassword {

    public static void main(String[] args) throws Exception{

        SQLServerDataSource ds = new SQLServerDataSource();
        ds.setServerName("msentra-managed-demo.database.windows.net"); // Replace with your server name
        ds.setDatabaseName("demo"); // Replace with your database
        ds.setUser("bob@example.com"); // Replace with your username
        ds.setPassword("password"); // Replace with your password
        ds.setAuthentication("ActiveDirectoryPassword");

        try (Connection connection = ds.getConnection();
                Statement stmt = connection.createStatement();
                ResultSet rs = stmt.executeQuery("SELECT SUSER_SNAME()")) {
            if (rs.next()) {
                System.out.println("You have successfully logged on as: " + rs.getString(1));
            }
        }
    }
}

Si la connexion est établie, le message de sortie suivant doit s’afficher :

You have successfully logged on as: <your user name>

Se connecter à l’aide du mode d’authentification ActiveDirectoryInteractive

L’exemple suivant montre comment utiliser le mode authentication=ActiveDirectoryInteractive.

Pour générer et exécuter l’exemple :

1. Vérifiez que vous disposez des bibliothèques dépendantes requises selon les Exigences de configuration du client.

2. Localisez les lignes de code suivantes et remplacez le nom du serveur/de la base de données par le nom de votre serveur/base de données.

   ds.setServerName("msentra-managed-demo.database.windows.net"); // replace 'msentra-managed-demo' with your server name
   ds.setDatabaseName("demo"); // replace with your database name
   

3. Recherchez les lignes de code suivantes. Remplacez le nom d’utilisateur par le nom de l’utilisateur Microsoft Entra avec lequel vous souhaitez vous connecter.

   ds.setUser("bob@example.com"); // replace with your username
   

Exemple d’utilisation du mode d’authentification ActiveDirectoryInteractive :

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

import com.microsoft.sqlserver.jdbc.SQLServerDataSource;

public class MSEntraInteractive {
    public static void main(String[] args) throws Exception{

        SQLServerDataSource ds = new SQLServerDataSource();
        ds.setServerName("msentra-managed-demo.database.windows.net"); // Replace with your server name
        ds.setDatabaseName("demo"); // Replace with your database
        ds.setAuthentication("ActiveDirectoryInteractive");

        // Optional login hint
        ds.setUser("bob@example.com"); // Replace with your user name

        try (Connection connection = ds.getConnection();
                Statement stmt = connection.createStatement();
                ResultSet rs = stmt.executeQuery("SELECT SUSER_SNAME()")) {
            if (rs.next()) {
                System.out.println("You have successfully logged on as: " + rs.getString(1));
            }
        }
    }
}

Lorsque vous exécutez le programme, un navigateur s’affiche pour authentifier l’utilisateur. Ce que vous voyez exactement dépend de la façon dont vous configurez votre Microsoft Entra ID. Cela peut inclure ou non des invites d’authentification multifacteur demandant un nom d’utilisateur, un mot de passe, un code confidentiel ou une deuxième authentification d’appareil via un téléphone. Si plusieurs demandes d’authentification interactives sont effectuées dans le même programme, les demandes ultérieures peuvent même ne rien vous demander si la bibliothèque d’authentification peut réutiliser un jeton d’authentification précédemment mis en cache.

Pour plus d’informations sur la configuration de Microsoft Entra ID pour exiger l’authentification multifacteur, consultez la rubrique Démarrer avec l’authentification multifacteur Microsoft Entra dans le cloud.

Pour obtenir des captures d’écran de ces boîtes de dialogue, consultez la rubrique Utilisation de l’authentification multifacteur Microsoft Entra.

Si l’authentification de l’utilisateur réussit, vous devez voir le message suivant dans le navigateur :

Authentication complete. You can close the browser and return to the application.

Ce message indique seulement la réussite de l’authentification de l’utilisateur, mais pas nécessairement la réussite de la connexion au serveur. Lors du retour à l’application, si une connexion au serveur est établie, vous devez voir le message suivant :

You have successfully logged on as: <your user name>

Se connecter à l’aide du mode d’authentification ActiveDirectoryServicePrincipal

L’exemple suivant montre comment utiliser le mode authentication=ActiveDirectoryServicePrincipal.

Pour générer et exécuter l’exemple :

1. Vérifiez que vous disposez des bibliothèques dépendantes requises selon les Exigences de configuration du client.

2. Localisez les lignes de code suivantes et remplacez le nom du serveur/de la base de données par le nom de votre serveur/base de données.

   ds.setServerName("msentra-managed-demo.database.windows.net"); // replace 'msentra-managed-demo' with your server name
   ds.setDatabaseName("demo"); // replace with your database name
   

3. Recherchez les lignes de code suivantes. Remplacez la valeur de principalId par l’ID d’application / ID client du principal de service Microsoft Entra avec lequel vous souhaitez vous connecter. Remplacez la valeur de principalSecret par le secret.

   String principalId = "<service_principal_guid>"; // Replace with your Microsoft Entra service principal ID.
   String principalSecret = "..."; // Replace with your Microsoft Entra principal secret.
   

4. Définissez l’ID de principal et le secret du principal à l’aide de setUser et setPassword dans la version 10.2 et versions ultérieures, et de setAADSecurePrincipalId et setAADSecurePrincipalSecret dans la version 9.4 et versions antérieures.

Exemple d’utilisation du mode d’authentification ActiveDirectoryServicePrincipal :

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

import com.microsoft.sqlserver.jdbc.SQLServerDataSource;

public class MSEntraServicePrincipal {
    public static void main(String[] args) throws Exception{
        String principalId = "<service_principal_guid>"; // Replace with your Microsoft Entra service principal ID.
        String principalSecret = "..."; // Replace with your Microsoft Entra principal secret.

        SQLServerDataSource ds = new SQLServerDataSource();
        ds.setServerName("msentra-managed-demo.database.windows.net"); // Replace with your server name
        ds.setDatabaseName("demo"); // Replace with your database
        ds.setAuthentication("ActiveDirectoryServicePrincipal");
        ds.setUser(principalId); // setAADSecurePrincipalId for JDBC Driver 9.4 and below
        ds.setPassword(principalSecret); // setAADSecurePrincipalSecret for JDBC Driver 9.4 and below 

        try (Connection connection = ds.getConnection();
                Statement stmt = connection.createStatement();
                ResultSet rs = stmt.executeQuery("SELECT SUSER_SNAME()")) {
            if (rs.next()) {
                System.out.println("You have successfully logged on as: " + rs.getString(1));
            }
        }
    }
}

Si une connexion est établie, le message de sortie suivant doit s’afficher :

You have successfully logged on as: <your app/client ID>

Se connecter à l’aide du mode d’authentification ActiveDirectoryServicePrincipalCertificate

L’exemple suivant montre comment utiliser le mode authentication=ActiveDirectoryServicePrincipalCertificate.

Pour générer et exécuter l’exemple :

1. Vérifiez que vous disposez des bibliothèques dépendantes requises selon les Exigences de configuration du client.

2. Localisez les lignes de code suivantes et remplacez le nom du serveur/de la base de données par le nom de votre serveur/base de données.

   ds.setServerName("msentra-managed-demo.database.windows.net"); // replace 'msentra-managed-demo' with your server name
   ds.setDatabaseName("demo"); // replace with your database name
   

3. Recherchez les lignes de code suivantes. Remplacez la valeur de principalId par l’ID d’application / ID client du principal de service Microsoft Entra avec lequel vous souhaitez vous connecter. Remplacez la valeur de clientCertificate par l’emplacement du certificat de principal de service.

   String principalId = "<service_principal_guid>"; // Replace with your Microsoft Entra service principal ID.
   
   String clientCertificate = "..."; // Replace with the location for your Microsoft Entra service principal certificate.
   

4. Si le certificat mentionné précédemment a besoin d’un mot de passe, définissez le secret principal à l’aide de setPassword dans la version 10.2 et ultérieure ou de setAADSecurePrincipalSecret dans les versions 9.4 et antérieures.

5. Si le certificat a une clé privée associée, définissez la clé privée à l’aide de setClientKey. Si cette clé nécessite un mot de passe, définissez le mot de passe de la clé privée à l’aide de setClientKeyPassword.

Exemple d’utilisation du mode d’authentification ActiveDirectoryServicePrincipalCertificate :

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

import com.microsoft.sqlserver.jdbc.SQLServerDataSource;

public class MSEntraServicePrincipalCertificate {
    public static void main(String[] args) throws Exception{
        String principalId = "<service_principal_guid>"; // Replace with your Microsoft Entra service principal ID.
        String clientCertificate = "..."; // Replace with the location of your service principal certificate.

        SQLServerDataSource ds = new SQLServerDataSource();
        ds.setServerName("msentra-managed-demo.database.windows.net"); // Replace with your server name
        ds.setDatabaseName("demo"); // Replace with your database
        ds.setAuthentication("ActiveDirectoryServicePrincipalCertificate");
        ds.setUser(principalId); // setAADSecurePrincipalId for JDBC Driver 9.4 and below
        ds.setClientCertificate(clientCertificate);

        try (Connection connection = ds.getConnection();
             Statement stmt = connection.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT SUSER_SNAME()")) {
            if (rs.next()) {
                System.out.println("You have successfully logged on as: " + rs.getString(1));
            }
        }
    }
}

Si une connexion est établie, le message de sortie suivant doit s’afficher :

You have successfully logged on as: <your app/client ID>

Se connecter à l’aide d’un jeton d’accès

Les applications/services peuvent récupérer un jeton d’accès auprès de Microsoft Entra ID et l’utiliser pour se connecter à la base de données Azure SQL, à Azure SQL Managed Instance et à Azure Synapse Analytics.

L’exemple suivant contient une application Java simple qui se connecte à Azure en utilisant l’authentification basée sur les jetons d’accès.

Pour générer et exécuter l’exemple :

1. Créez un compte d’application dans Microsoft Entra ID pour votre service.

   1. Connectez-vous au portail Azure.
   2. Allez dans Microsoft Entra ID dans la barre de navigation gauche.
   3. Sélectionnez Inscriptions d’applications.
   4. Sélectionnez Nouvelle inscription.
   5. Entrez mytokentest comme nom convivial pour l’application.
   6. Conservez la sélection par défaut pour les types de comptes pris en charge qui peuvent utiliser l’application.
   7. Sélectionnez S’inscrire en bas.
   8. Pas besoin de SIGN ON URL. Fournissez tout ce qui suit : https://mytokentest.
   9. Sélectionnez Create en bas.
   10. Lors de la sélection du Registre, l’application est immédiatement créée et vous êtes redirigé vers sa page de ressources.
   11. Dans la zone Essentials, trouvez l’ID d’application (client) et copiez-le. Vous aurez besoin de cette valeur ultérieurement pour configurer votre candidature
   12. Dans le volet de navigation, sélectionnez Certificats et secrets. Dans l’onglet Clé secrète client (0), sélectionnez Nouvelle clé secrète client. Entrez une description pour la clé secrète et sélectionnez l’expiration (la valeur par défaut convient). Sélectionnez Ajouter en bas. Important : avant de quitter cette page, copiez la Valeur générée pour votre clé secrète client. Cette valeur ne peut plus être consultée après avoir quitté la page. Cette valeur est la clé secrète client.
   13. Revenez au volet Inscriptions d’applications pour Microsoft Entra ID et recherchez l’onglet Points de terminaison. Copiez l’URL sous OAuth 2.0 token endpoint. Cette URL est votre URL STS.

   

2. Connectez-vous à votre base de données en tant qu’administrateur Microsoft Entra et utilisez une commande T-SQL pour approvisionner un utilisateur de base de données autonome pour votre principal d’application. Pour plus d’informations sur la création d’un administrateur Microsoft Entra et d’un utilisateur de base de données autonome, consultez Connexion à l’aide de l’authentification Microsoft Entra.

   CREATE USER [mytokentest] FROM EXTERNAL PROVIDER
   

3. Sur la machine cliente (sur laquelle vous voulez exécuter l’exemple), téléchargez la Bibliothèque d’authentification Microsoft (MSAL) pour Java et ses dépendances. La MSAL est uniquement nécessaire pour exécuter cet exemple spécifique. L’exemple utilise les API de cette bibliothèque pour récupérer le jeton d’accès à partir de Microsoft Entra ID. Si vous disposez déjà d’un jeton d’accès, vous pouvez ignorer cette étape et supprimer la section de l’exemple qui récupère un jeton d’accès.

Dans l’exemple suivant, remplacez l’URL STS, l’ID client, la clé secrète client, le nom du serveur et de la base de données par vos propres valeurs.

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import com.microsoft.sqlserver.jdbc.SQLServerDataSource;

// The microsoft-authentication-library-for-java is needed to retrieve the access token in this example.
import com.microsoft.aad.msal4j.ClientCredentialFactory;
import com.microsoft.aad.msal4j.ClientCredentialParameters;
import com.microsoft.aad.msal4j.ConfidentialClientApplication;
import com.microsoft.aad.msal4j.IAuthenticationResult;
import com.microsoft.aad.msal4j.IClientCredential;

public class MSEntraTokenBased {

    public static void main(String[] args) throws Exception {

        // Retrieve the access token from Microsoft Entra ID.
        String spn = "https://database.windows.net/";
        String stsurl = "https://login.microsoftonline.com/..."; // Replace with your STS URL.
        String clientId = "<service_principal_guid>"; // Replace with your client ID.
        String clientSecret = "..."; // Replace with your client secret.

        String scope = spn +  "/.default";
        Set<String> scopes = new HashSet<>();
        scopes.add(scope);

        ExecutorService executorService = Executors.newSingleThreadExecutor();
        IClientCredential credential = ClientCredentialFactory.createFromSecret(clientSecret);
        ConfidentialClientApplication clientApplication = ConfidentialClientApplication
            .builder(clientId, credential).executorService(executorService).authority(stsurl).build();
        CompletableFuture<IAuthenticationResult> future = clientApplication
            .acquireToken(ClientCredentialParameters.builder(scopes).build());

        IAuthenticationResult authenticationResult = future.get();
        String accessToken = authenticationResult.accessToken();

        System.out.println("Access Token: " + accessToken);

        // Connect with the access token.
        SQLServerDataSource ds = new SQLServerDataSource();

        ds.setServerName("msentra-managed-demo.database.windows.net"); // Replace with your server name.
        ds.setDatabaseName("demo"); // Replace with your database name.
        ds.setAccessToken(accessToken);

        try (Connection connection = ds.getConnection();
                Statement stmt = connection.createStatement();
                ResultSet rs = stmt.executeQuery("SELECT SUSER_SNAME()")) {
            if (rs.next()) {
                System.out.println("You have successfully logged on as: " + rs.getString(1));
            }
        }
    }
}

Si la connexion peut être établie, le message de sortie suivant doit s’afficher :

Access Token: <your access token>
You have successfully logged on as: <your client ID>

Se connecter en utilisant un jeton d’accès

Comme la propriété de jeton d’accès, le rappel de jeton d’accès vous permet d’inscrire une méthode qui fournit un jeton d’accès au pilote. L’avantage de ce rappel par rapport à la propriété est que le rappel permet au pilote de demander un nouveau jeton d’accès une fois le jeton expiré. Par exemple, un pool de connexions qui crée une nouvelle connexion peut demander un nouveau jeton avec une nouvelle date d’expiration. Pour plus d’informations, consultez Utilisation d’un regroupement de connexions.

L’exemple suivant illustre l’implémentation et la définition du rappel accessToken.

import com.microsoft.aad.msal4j.IClientCredential;
import com.microsoft.aad.msal4j.ClientCredentialFactory;
import com.microsoft.aad.msal4j.ConfidentialClientApplication;
import com.microsoft.aad.msal4j.IAuthenticationResult;
import com.microsoft.aad.msal4j.ClientCredentialParameters;
import java.sql.Connection;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MSEntraAccessTokenCallback {

    public static void main(String[] args) {

        SQLServerAccessTokenCallback callback = new SQLServerAccessTokenCallback() {
            @Override
            public SqlAuthenticationToken getAccessToken(String spn, String stsurl) {

                String clientSecret = "..."; // Replace with your client secret.
                String clientId = "<service_principal_guid>"; // Replace with your client ID.

                String scope = spn + "/.default";
                Set<String> scopes = new HashSet<>();
                scopes.add(scope);

                try {
                    ExecutorService executorService = Executors.newSingleThreadExecutor();
                    IClientCredential credential = ClientCredentialFactory.createFromSecret(clientSecret);
                    ConfidentialClientApplication clientApplication = ConfidentialClientApplication
                            .builder(clientId, credential).executorService(executorService).authority(stsurl).build();
                    CompletableFuture<IAuthenticationResult> future = clientApplication
                            .acquireToken(ClientCredentialParameters.builder(scopes).build());

                    IAuthenticationResult authenticationResult = future.get();
                    String accessToken = authenticationResult.accessToken();

                    return new SqlAuthenticationToken(accessToken, authenticationResult.expiresOnDate().getTime());
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return null;
            }
        };

        SQLServerDataSource ds = new SQLServerDataSource();
        ds.setServerName("msentra-managed-demo.database.windows.net"); // Replaces with your server name.
        ds.setDatabaseName("demo"); // Replace with your database name.
        ds.setAccessTokenCallback(callback);

        try (Connection connection = ds.getConnection();
                Statement stmt = connection.createStatement();
                ResultSet rs = stmt.executeQuery("SELECT SUSER_SNAME()")) {
            if (rs.next()) {
                System.out.println("You have successfully logged on as: " + rs.getString(1));
            }
        }
    }
}

Si la connexion peut être établie, le message de sortie suivant doit s’afficher :

You have successfully logged on as: <your client ID>

À partir de la version 12.4, vous pouvez définir le rappel accessToken via la propriété de chaîne de connexion accessTokenCallbackClass. L’exemple suivant montre comment définir le rappel accessToken à l’aide de cette propriété :

import com.microsoft.aad.msal4j.IClientCredential;
import com.microsoft.aad.msal4j.ClientCredentialFactory;
import com.microsoft.aad.msal4j.ConfidentialClientApplication;
import com.microsoft.aad.msal4j.IAuthenticationResult;
import com.microsoft.aad.msal4j.ClientCredentialParameters;
import java.sql.Connection;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

 

public class MSEntraAccessTokenCallbackClass {
    public static class AccessTokenCallbackClass implements SQLServerAccessTokenCallback {
        @Override
        public SqlAuthenticationToken getAccessToken(String spn, String stsurl) {
            String clientSecret = "..."; // Replace with your client secret.
            String clientId = "<service_principal_guid>"; // Replace with your client ID.
            
            String scope = spn + "/.default";
            Set<String> scopes = new HashSet<>();
            scopes.add(scope);
            
            try {
                ExecutorService executorService = Executors.newSingleThreadExecutor();
                IClientCredential credential = ClientCredentialFactory.createFromSecret(clientSecret);
                ConfidentialClientApplication clientApplication = ConfidentialClientApplication

                        .builder(clientId, credential).executorService(executorService).authority(stsurl).build();
                
                CompletableFuture<IAuthenticationResult> future = clientApplication
                        .acquireToken(ClientCredentialParameters.builder(scopes).build());
                
                IAuthenticationResult authenticationResult = future.get();
                String accessToken = authenticationResult.accessToken();
                
                return new SqlAuthenticationToken(accessToken, authenticationResult.expiresOnDate().getTime());
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    }
    
    public static void main(String[] args) throws Exception {
        
        SQLServerDataSource ds = new SQLServerDataSource();
        ds.setServerName("msentra-managed-demo.database.windows.net"); // Replaces with your server name.
        ds.setDatabaseName("demo"); // Replace with your database name.
        ds.setAccessTokenCallbackClass(AccessTokenCallbackClass.class.getName());
        
        try (Connection connection = ds.getConnection();
             Statement stmt = connection.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT SUSER_SNAME()")) {
            if (rs.next()) {
                System.out.println("You have successfully logged on as: " + rs.getString(1));
            }
        }
    }
}

Si la connexion peut être établie, le message de sortie suivant doit s’afficher :

You have successfully logged on as: <your client ID>

Étapes suivantes

En savoir plus sur les concepts associés dans les articles suivants :

• Connexion à SQL Azure à l’aide de l’authentification Microsoft Entra
• Bibliothèque d’authentification Microsoft (MSAL) pour Java
• Bibliothèque d’authentification Microsoft Azure Active Directory (ADAL) pour Java
• Résoudre des problèmes de connexion à Azure SQL Database