Méthodes d’authentification des applications

S’applique à : ✅Microsoft Fabric✅Azure Data Explorer

Cet article fournit une vue d’ensemble des méthodes d’authentification principales disponibles pour les bibliothèques clientes Kusto. Les extraits de code montrent différentes façons d’authentifier les utilisateurs et les applications, ce qui permet une interaction transparente avec les clusters Kusto. Chaque méthode convient à différents scénarios et exigences.

Utilisez des identités managées au lieu de l’authentification par nom d’utilisateur et mot de passe ou des chaînes de connexion dans la mesure du possible. Les identités managées offrent une approche plus sécurisée et simplifiée de l’authentification.

Dans cet article, vous allez apprendre à vous authentifier à l’aide de :

Authentification d’une identité managée

• Authentification par certificat
• Authentification par clé d’application

Principal de l’utilisateur

• Authentification de connexion utilisateur interactive
• Authentification Azure Command-Line Interface (CLI)
• d’authentification du code d’appareil

Fournisseur de jetons personnalisé

• Fournisseur de jeton personnalisé pour l'authentification d'informations d'identification par identité managée fédérée
• Utilisation de l’authentification Azure TokenCredential

Prerequisites

• Configurer votre environnement de développement pour utiliser la bibliothèque de client Kusto

Méthodes d’authentification du principal d’application

Cette section décrit les différentes méthodes d’authentification à l’aide d’un principal d’application.

Authentification d’une identité managée

Il existe deux types d’identités managées : affectées par le système et affectées par l’utilisateur. Les identités managées affectées par le système ont leur cycle de vie lié à la ressource qui les crée. Cette identité est limitée à une seule ressource. Les identités managées affectées par l’utilisateur peuvent être utilisées sur plusieurs ressources. Pour plus d’informations, consultez Identités managées.

Dans les exemples suivants, remplacez <QueryEndpointUri> et <ManagedIdentityClientId> par vos valeurs.

• Identité managée affectée par le système :

  • C#
  • Python
  • TypeScript
  • Java

  var kcsb = new KustoConnectionStringBuilder(<QueryEndpointUri>)
    .WithAadSystemManagedIdentity();
  

• Identité managée affectée par l’utilisateur. Utilisez l’ID client d’identité ou l’ID d’objet, comme suit :

  • C#
  • Python
  • TypeScript
  • Java

  var kcsb = new KustoConnectionStringBuilder(<QueryEndpointUri>)
    .WithAadUserManagedIdentity(<ManagedIdentityClientId>);
  

Authentification basée sur un certificat

Les certificats servent de secrets pour authentifier l’identité d’une application lors de la demande d’un jeton. Il existe plusieurs méthodes pour charger le certificat, par exemple le chargement à partir du magasin d’informations d’identification locales de l’ordinateur ou du disque.

| Dans les exemples suivants, remplacez <QueryEndpointUri>, <ApplicationId><CertificateSubjectName><CertificateIssuerName><CertificateThumbprint><CertificateObject><AuthorityId><PemPublicCertificate><PemPrivateKey>, <privateKeyPemFilePath>et <PemCertificatePath><EnableSubjectAndIssuerAuth> par vos propres valeurs.

• Le certificat du magasin de certificats local de l’ordinateur est pris en charge uniquement en utilisant C#.

  var kcsb = new KustoConnectionStringBuilder(<QueryEndpointUri>)
    .WithAadApplicationSubjectAndIssuerAuthentication(<ApplicationId>, <CertificateSubjectName>, <CertificateIssuerName>, <AuthorityId>);
  

  Important

  Lorsque vous utilisez le nom de l’objet et l’émetteur, le certificat doit être installé dans le magasin de certificats de l’ordinateur local.

• Certificat à partir d’une source arbitraire, tel qu’un fichier sur disque, un cache ou un magasin sécurisé tel qu’Azure Key Vault. L’objet de certificat doit contenir une clé privée :

  • C#
  • Python
  • TypeScript
  • Java

  X509Certificate2 certificate = <CertificateObject>;
  var kcsb = new KustoConnectionStringBuilder(<QueryEndpointUri>)
    .WithAadApplicationCertificateAuthentication(<ApplicationId>, certificate, <AuthorityId>);
  

  Pour plus d’informations, consultez chaînes de connexion Kusto.

Authentification par clé d’application

La clé d’application, également appelée mot de passe d’application, est une chaîne secrète qu’une application utilise pour authentifier et prouver son identité lors de la demande d’un jeton. Il sert de forme d’informations d’identification pour que l’application accède aux ressources protégées. La clé d’application est généralement générée et affectée par le fournisseur d’identité ou le serveur d’autorisation. Il est important de gérer et de protéger en toute sécurité la clé d’application pour empêcher l’accès non autorisé aux informations sensibles ou aux actions.

| Dans les exemples suivants, remplacez <QueryEndpointUri>, , <ApplicationId><ApplicationKey>, <AuthorityId>et <AuthorityId> par vos propres valeurs.

• Clé d’application :

  • C#
  • Python
  • TypeScript
  • Java

  var kcsb = new KustoConnectionStringBuilder(<QueryEndpointUri>)
    .WithAadApplicationKeyAuthentication(<ApplicationId>, <ApplicationKey>, <AuthorityId>);
  

• Chaîne de connexion avec clé d’application :

  • C#
  • Python
  • TypeScript
  • Java

  var connectionString = "Data Source=<QueryEndpointUri>;Initial Catalog=NetDefaultDB;AAD Federated Security=True;AppClientId=<ApplicationId>;AppKey=<ApplicationKey>;Authority Id=<AuthorityId>;"
  var kcsb = new KustoConnectionStringBuilder(connectionString);
  

Méthodes d’authentification du principal utilisateur

Cette section décrit les différentes méthodes d’authentification à l’aide d’un principal d’utilisateur.

Authentification de connexion utilisateur interactive

Cette méthode d’authentification utilise les informations d’identification de l’utilisateur pour établir une connexion sécurisée avec Kusto. La méthode ouvre un navigateur web dans lequel l’utilisateur est invité à entrer son nom d’utilisateur et son mot de passe pour terminer le processus d’authentification.

| Dans les exemples suivants, remplacez <QueryEndpointUri> ,<AuthorityId>et <AuthorityId> par vos propres valeurs.

• Connexion utilisateur interactive :

  • C#
  • Python
  • TypeScript
  • Java

  var kcsb = new KustoConnectionStringBuilder(<QueryEndpointUri>)
    .WithAadUserPromptAuthentication();
  

Authentification Azure Interface de ligne de commande (CLI)

Cette méthode d’authentification utilise l’interface azure Command-Line (CLI) pour authentifier et obtenir un jeton pour l’utilisateur. L’exécution de la az login commande signifie que l’utilisateur peut établir en toute sécurité une connexion et récupérer le jeton nécessaire à des fins d’authentification. L’utilisateur peut être invité à se connecter si le jeton n’est pas disponible dans le cache Azure CLI et que le interactive paramètre est défini sur true. Pour plus d’informations, consultez Azure Command-Line Interface (CLI) .

| Dans l’exemple suivant, remplacez <QueryEndpointUri> par votre propre valeur.

var kcsb = new KustoConnectionStringBuilder(<QueryEndpointUri>)
  .WithAadAzCliAuthentication(interactive: true);

kcsb = KustoConnectionStringBuilder
  .with_az_cli_authentication(<QueryEndpointUri>)

const kcsb = KustoConnectionStringBuilder
  .withAzLoginIdentity(<QueryEndpointUri>);

ConnectionStringBuilder kcsb = ConnectionStringBuilder
  .createWithAzureCli(<QueryEndpointUri>);

Authentification de code d’appareil

Cette méthode est conçue pour les appareils qui ne disposent pas d’une interface utilisateur appropriée pour la connexion, comme les appareils IoT et les terminaux de serveur. Il fournit à l’utilisateur un code et une URL pour s’authentifier à l’aide d’un autre appareil, tel qu’un smartphone. Cette méthode interactive exige que l’utilisateur se connecte via un navigateur.

| Dans l’exemple suivant, remplacez <QueryEndpointUri> par votre propre valeur.

var kcsb = new KustoConnectionStringBuilder(<QueryEndpointUri>)
  .WithAadDeviceCodeAuthentication((msg, uri, code) =>
  {
    // The callback is used to display instructions to the user on how to authenticate using the device code
    Console.WriteLine("Device Code Message: {0}", msg);
    Console.WriteLine("Device Code Uri: {0}", uri);
    Console.WriteLine("Device Code: {0}", code);

    return Task.CompletedTask;
  });

kcsb = KustoConnectionStringBuilder
  .with_aad_device_authentication(<QueryEndpointUri>)

const kcsb = KustoConnectionStringBuilder
  .withAadDeviceAuthentication(<QueryEndpointUri>);

ConnectionStringBuilder kcsb = ConnectionStringBuilder
  .createWithDeviceCode(<QueryEndpointUri>);

Méthodes d’authentification du fournisseur de jetons personnalisés

Cette section décrit les différentes méthodes d’authentification à l’aide d’un fournisseur de jetons personnalisé.

Fournisseur de jetons personnalisé pour l’authentification des identifiants de l’identité managée fédérée

Les fournisseurs de jetons personnalisés peuvent être utilisés pour acquérir un jeton d’ID Microsoft Entra pour l’authentification. L’exemple suivant montre comment utiliser un fournisseur de jetons personnalisé pour obtenir un jeton à l’aide d’une identité managée fédérée. Vous pouvez modifier le code pour répondre aux exigences de votre application.

| Dans l’exemple suivant, remplacez <AuthorityIdId>, <ApplicationId>, <ManagedIdentityClientId>et <QueryEndpointUri> par vos propres valeurs.

public class TokenProvider
{
  private ClientAssertionCredential m_clientAssertion;
  private TokenRequestContext m_tokenRequestContext;

  public TokenProvider(string queryEndpointUri)
  {
    string resourceId = null;

    try
    {
      // Get the appropiate resource id by querying the metadata
      var httpClient = new HttpClient();
      var response = httpClient.GetByteArrayAsync($"{queryEndpointUri}/v1/rest/auth/metadata").Result;
      var json = JObject.Parse(Encoding.UTF8.GetString(response));
      resourceId = json["AzureAD"]?["KustoServiceResourceId"]?.ToString();
      // Append scope to resource id
      resourceId = !string.IsNullOrWhiteSpace(resourceId) ? $"{resourceId}/.default" : null;
    }
    catch { /* Handle exception */}

    m_tokenRequestContext = new TokenRequestContext(new string[] { resourceId ?? "https://kusto.kusto.windows.net/.default" });

    // Create client assertion credential to authenticate with Kusto
    m_clientAssertion = new ClientAssertionCredential
    (
      <AuthorityIdId>,
      <ApplicationId>,
      async (token) =>
      {
        // Get Managed Identity token
        var miCredential = new ManagedIdentityCredential(<ManagedIdentityClientId>);
        var miToken = await miCredential.GetTokenAsync(new TokenRequestContext(new[] {
          "api://AzureADTokenExchange/.default"
        })).ConfigureAwait(false);
        return miToken.Token;
      }
    );
  }

  public async Task<string> GetTokenAsync()
  {
    var accessToken = await m_clientAssertion.GetTokenAsync(m_tokenRequestContext).ConfigureAwait(false);
    return accessToken.Token;
  }
}

var tokenProvider = new TokenProvider(<QueryEndpointUri>);

var kcsb = new KustoConnectionStringBuilder(<QueryEndpointUri>)
  .WithAadTokenProviderAuthentication(
    async () =>
    {
      return await tokenProvider.GetTokenAsync();
    });

import requests
from azure.identity import ClientAssertionCredential, ManagedIdentityCredential
from azure.kusto.data import KustoConnectionStringBuilder

class TokenProvider:
  def __init__(self, query_endpoint_uri):
    self.query_endpoint_uri = query_endpoint_uri
    self.resource_id = None
    self.token_request_context = None
    self.client_assertion = None
    self._initialize()

  def _initialize(self):
    try:
      # Get the appropriate resource id by querying the metadata
      response = requests.get(f"{self.query_endpoint_uri}/v1/rest/auth/metadata")
      json = response.json()
      self.resource_id = json.get("AzureAD", {}).get("KustoServiceResourceId", "https://kusto.kusto.windows.net")
      # Append scope to resource id
      self.resource_id = f"{self.resource_id}/.default"
    except Exception as error:
      print(f"Error fetching metadata: {error}")

    self.token_request_context = {"scopes": [self.resource_id or "https://kusto.kusto.windows.net/.default"]}

    # Create client assertion credential to authenticate with Kusto
    self.client_assertion = ClientAssertionCredential(
      tenant_id="<AuthorityId>"
      client_id="<ApplicationId>",
      func=self._get_managed_identity_token
    )

  async def _get_managed_identity_token(self):
    mi_credential = ManagedIdentityCredential()
    mi_token = await mi_credential.get_token("api://AzureADTokenExchange/.default")
    return mi_token.token

  async def get_token_async(self):
    access_token = await self.client_assertion.get_token(self.token_request_context)
    return access_token.token

def main():
  query_endpoint_uri = "<QueryEndpointUri>"
  token_provider = TokenProvider(query_endpoint_uri)
  kcsb = KustoConnectionStringBuilder.with_token_provider(
    query_endpoint_uri,
    token_provider.get_token_async
  )

import { ManagedIdentityCredential, ClientAssertionCredential } from '@azure/identity';
import get from 'axios';
import { KustoConnectionStringBuilder } from 'azure-kusto-data';

class TokenProvider {
  constructor(queryEndpointUri) {
    this.queryEndpointUri = queryEndpointUri;
    this.resourceId = null;
    this.tokenRequestContext = null;
    this.clientAssertion = null;
  }

  async initialize() {
    try {
      // Get the appropriate resource id by querying the metadata
      const response = await get(`${this.queryEndpointUri}/v1/rest/auth/metadata`);
      const json = response.data;
      this.resourceId = json.AzureAD?.KustoServiceResourceId || 'https://kusto.kusto.windows.net';
      // Append scope to resource id
      this.resourceId = `${this.resourceId}/.default`;
    } catch (error) {
      console.error('Error fetching metadata:', error);
    }

    this.tokenRequestContext = { scopes: [this.resourceId || 'https://kusto.kusto.windows.net/.default'] };

    // Create client assertion credential to authenticate with Kusto
    this.clientAssertion = new ClientAssertionCredential(
      '<AuthorityId>', // tenantId
      '<ApplicationId>', // clientId
      async () => {
        const miCredential = new ManagedIdentityCredential();
        const miToken = await miCredential.getToken({ scopes: ['api://AzureADTokenExchange/.default'] });
        return miToken.token;
      }
    );
  }

  async getTokenAsync() {
    const accessToken = await this.clientAssertion.getToken(this.tokenRequestContext);
    return accessToken.token;
  }
}

const tokenProvider = new TokenProvider("<QueryEndpointUri>");
await tokenProvider.initialize();

const kcsb = KustoConnectionStringBuilder.withAadTokenProviderAuthentication(
  "<QueryEndpointUri>",
  async () => {
    return await tokenProvider.getTokenAsync();
  }
);

public class TokenProvider {
  private TokenRequestContext tokenRequestContext;
  private ClientAssertionCredential clientAssertion;

  public TokenProvider(String queryEndpointUri) {
    String resourceId = "";
    try {
      // Get the appropriate resource id by querying the metadata
      URL url = new URL(queryEndpointUri + "/v1/rest/auth/metadata");
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      conn.setRequestMethod("GET");
      conn.connect();

      Scanner scanner = new Scanner(url.openStream(), StandardCharsets.UTF_8);
      String jsonResponse = scanner.useDelimiter("\\A").next();
      scanner.close();

      ObjectMapper mapper = new ObjectMapper();
      JsonNode jsonNode = mapper.readTree(jsonResponse);
      resourceId = jsonNode.path("AzureAD").path("KustoServiceResourceId").asText("https://kusto.kusto.windows.net");
      // Append scope to resource id
      resourceId = resourceId + "/.default";
    } catch (IOException e) {
      System.err.println("Error fetching metadata: " + e.getMessage());
      resourceId = "https://kusto.kusto.windows.net/.default";
    }

    tokenRequestContext = new TokenRequestContext().addScopes(resourceId);

    // Create client assertion credential to authenticate with Kusto
    clientAssertion = new ClientAssertionCredential(
      "<AuthorityId>",
      "<ApplicationId>", // clientId
      () -> {
        ManagedIdentityCredential miCredential = new ManagedIdentityCredential();
        return miCredential.getToken(new TokenRequestContext().addScopes("api://AzureADTokenExchange/.default")).block().getToken();
      }
    );
  }

  public CompletableFuture<String> getTokenAsync() {
    return clientAssertion.getToken(tokenRequestContext).thenApply(token -> token.getToken());
  }   
}

TokenProvider tokenProvider = new TokenProvider("<QueryEndpointUri>");
ConnectionStringBuilder kcsb = ConnectionStringBuilder.createWithAadTokenProviderAuthentication(queryEndpointUri,tokenProvider::getTokenAsync);

Utilisation de l’authentification Azure TokenCredential

Créez un fournisseur de jetons personnalisé en créant une classe qui hérite de TokenCredential et implémente la méthode GetToken. Vous pouvez également utiliser un fournisseur de jetons existant comme DefaultAzureCredential. Cette méthode offre une flexibilité pour différents scénarios d’authentification lorsqu’un fournisseur de jetons personnalisé est requis.

Vous pouvez utiliser DefaultAzureCredential pour prendre en charge le code de production qui utilise l’authentification d’identité managée ou le code de test à l’aide de Visual Studio ou d’Azure CLI. DefaultAzureCredential peut être configuré pour utiliser différentes méthodes d’authentification.

Dans l’exemple suivant, remplacez <QueryEndpointUri> et <ManagedIdentityClientId> par vos propres valeurs.

var credentialProvider = new DefaultAzureCredential(new DefaultAzureCredentialOptions {
  ManagedIdentityClientId = <ManagedIdentityClientId>
 });
var kcsb = new KustoConnectionStringBuilder(<QueryEndpointUri>)
  .WithAadAzureTokenCredentialsAuthentication(credentialProvider);

from azure.identity import DefaultAzureCredential
token_credential = DefaultAzureCredential()
kcsb = KustoConnectionStringBuilder
  .with_azure_token_credential(<QueryEndpointUri>, token_credential)

import { DefaultAzureCredential } from "@azure/identity";
const credential = new DefaultAzureCredential();
const kcsb = KustoConnectionStringBuilder
  .withTokenCredential(<QueryEndpointUri>, credential);

Étape suivante