App-Authentifizierungsmethoden

Gilt für: ✅Microsoft Fabric✅Azure Data Explorer

Dieser Artikel enthält eine Übersicht über die primären Authentifizierungsmethoden, die für die Kusto-Clientbibliotheken verfügbar sind. Die Codeausschnitte zeigen verschiedene Möglichkeiten zum Authentifizieren von Benutzern und Apps, wodurch eine nahtlose Interaktion mit Kusto-Clustern ermöglicht wird. Jede Methode passt zu verschiedenen Szenarien und Anforderungen.

Verwenden Sie verwaltete Identitäten anstelle der Benutzernamen- und Kennwortauthentifizierung oder Verbindungszeichenfolgen, wenn möglich. Verwaltete Identitäten bieten einen sichereren und optimierten Ansatz für die Authentifizierung.

In diesem Artikel erfahren Sie, wie Sie mithilfe der folgenden Ressourcen eine Authentifizierung durchführen:

Authentifizierung der verwalteten Identität

• Zertifikatbasierte Authentifizierung
• Anwendungsschlüsselauthentifizierung

Benutzerprinzipal

• Interaktive Benutzeranmeldung-Authentifizierung
• Authentifizierung mit Azure-Befehlszeilenschnittstelle (CLI)
• Gerätecode-Authentifizierung

Benutzerdefinierter Tokenanbieter

• Benutzerdefinierter Tokenanbieter für die Authentifizierung von Verbundidentitätsinformationen für verwaltete Identitäten
• Verwenden der Azure TokenCredential-Authentifizierung

Voraussetzungen

• Einrichten Der Entwicklungsumgebung für die Verwendung der Kusto-Clientbibliothek

Methoden für die Anwendungsprinzipalauthentifizierung

In diesem Abschnitt werden die verschiedenen Methoden der Authentifizierung mithilfe eines Anwendungs-Principals behandelt.

Authentifizierung der verwalteten Identität

Es gibt zwei Arten von verwalteten Identitäten: systemzugewiesen und benutzerzugewiesen. Vom System zugewiesene verwaltete Identitäten haben ihren Lebenszyklus an die Ressource gebunden, die sie erstellt. Diese Identität ist auf eine Ressource beschränkt. Von Benutzern zugewiesene verwaltete Identitäten können für mehrere Ressourcen verwendet werden. Weitere Informationen finden Sie unter Verwaltete Identitäten.

Ersetzen Sie in den folgenden Beispielen <QueryEndpointUri> und <ManagedIdentityClientId> durch Ihre Werte.

• Systemseitig zugewiesene verwaltete Identität:

  • C#
  • Python
  • TypeScript
  • Java

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

• Vom Benutzer zugewiesene verwaltete Identität. Verwenden Sie die Identitätsclient-ID oder -objekt-ID wie folgt:

  • C#
  • Python
  • TypeScript
  • Java

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

Zertifikatbasierte Authentifizierung

Zertifikate dienen als geheime Schlüssel, um die Identität einer Anwendung beim Anfordern eines Tokens zu authentifizieren. Es gibt mehrere Methoden zum Laden des Zertifikats, z. B. das Laden des Zertifikats aus dem lokalen Anmeldeinformationsspeicher des Computers oder vom Datenträger.

| Ersetzen Sie in den folgenden Beispielen <QueryEndpointUri>, <ApplicationId>, <CertificateSubjectName>, <CertificateIssuerName>, <CertificateThumbprint>, <CertificateObject>, <AuthorityId>, <PemPublicCertificate>, <PemPrivateKey>, <privateKeyPemFilePath>, <PemCertificatePath>und <EnableSubjectAndIssuerAuth> mit Ihren eigenen Werten.

• Das Zertifikat aus dem lokalen Zertifikatspeicher des Computers wird nur mit C# unterstützt:

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

  Wichtig

  Wenn Sie Betreffname und Aussteller verwenden, muss das Zertifikat im Zertifikatsspeicher des lokalen Computers installiert sein.

• Zertifikat aus einer beliebigen Quelle, z. B. datei auf Datenträger, Cache oder sicherem Speicher wie Azure Key Vault. Das Zertifikatobjekt muss einen privaten Schlüssel enthalten:

  • C#
  • Python
  • TypeScript
  • Java

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

  Weitere Informationen finden Sie unter Kusto-Verbindungszeichenfolgen.

Anwendungsschlüssel-Authentifizierung

Der Anwendungsschlüssel, auch als Anwendungskennwort bezeichnet, ist eine geheime Zeichenfolge, die von einer Anwendung verwendet wird, um ihre Identität beim Anfordern eines Tokens zu authentifizieren und zu beweisen. Sie dient als Anmeldeinformation, damit eine Anwendung auf geschützte Ressourcen zugreifen kann. Der Anwendungsschlüssel wird in der Regel vom Identitätsanbieter oder Autorisierungsserver generiert und zugewiesen. Es ist wichtig, den Anwendungsschlüssel sicher zu verwalten und zu schützen, um nicht autorisierten Zugriff auf vertrauliche Informationen oder Aktionen zu verhindern.

| Ersetzen Sie in den folgenden Beispielen <QueryEndpointUri>, <ApplicationId>, <ApplicationKey>, <AuthorityId>und <AuthorityId> durch Ihre eigenen Werte.

• Anwendungsschlüssel:

  • C#
  • Python
  • TypeScript
  • Java

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

• Verbindungszeichenfolge mit Anwendungsschlüssel:

  • 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);
  

Authentifizierungmethoden mit Benutzerprinzipal

In diesem Abschnitt werden die verschiedenen Methoden der Authentifizierung mithilfe eines Benutzerprinzipals behandelt.

Interaktive Benutzeranmeldungsauthentifizierung

Diese Authentifizierungsmethode verwendet die Anmeldeinformationen des Benutzers, um eine sichere Verbindung mit Kusto herzustellen. Die Methode öffnet einen Webbrowser, in dem der Benutzer aufgefordert wird, seinen Benutzernamen und sein Kennwort einzugeben, um den Authentifizierungsprozess abzuschließen.

| Ersetzen Sie in den folgenden Beispielen <QueryEndpointUri> ,<AuthorityId>und <AuthorityId> durch Ihre eigenen Werte.

• Interaktive Benutzeranmeldung:

  • C#
  • Python
  • TypeScript
  • Java

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

Azure Command-Line Interface (CLI)-Authentifizierung

Diese Authentifizierungsmethode verwendet die Azure Command-Line-Schnittstelle (CLI), um den Benutzer zu authentifizieren und ein Token zu erhalten. Das Ausführen des befehls az login bedeutet, dass der Benutzer sicher eine Verbindung herstellen und das erforderliche Token für Authentifizierungszwecke abrufen kann. Der Benutzer wird möglicherweise aufgefordert, sich anzumelden, wenn das Token im Azure CLI-Cache nicht verfügbar ist und der parameter interactive auf truefestgelegt ist. Weitere Informationen finden Sie unter Azure-Befehlszeilenschnittstelle (CLI).

| Ersetzen Sie im folgenden Beispiel <QueryEndpointUri> durch Ihren eigenen Wert.

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>);

Gerätecodeauthentifizierung

Diese Methode wurde für Geräte entwickelt, auf der keine ordnungsgemäße Benutzeroberfläche für die Anmeldung vorhanden ist, z. B. IoT-Geräte und Serverterminals. Er stellt dem Benutzer einen Code und eine URL zur Authentifizierung mit einem anderen Gerät, z. B. einem Smartphone, zur Verfügung. Für diese interaktive Methode muss sich der Benutzer über einen Browser anmelden.

| Ersetzen Sie im folgenden Beispiel <QueryEndpointUri> durch Ihren eigenen Wert.

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>);

Authentifizierungsmethoden mit Anbieter benutzerdefinierter Token

In diesem Abschnitt werden die verschiedenen Methoden der Authentifizierung mithilfe eines benutzerdefinierten Tokenanbieters behandelt.

Anbieter benutzerdefinierter Token für die Authentifizierung mit Anmeldeinformationen verwalteter Partneridentitäten

Anbieter benutzerdefinierter Token können verwendet werden, um ein Microsoft Entra ID-Token für die Authentifizierung zu erhalten. Im folgenden Beispiel wird veranschaulicht, wie Sie einen benutzerdefinierten Tokenanbieter verwenden, um ein Token mithilfe der verwalteten Verbundidentität abzurufen. Sie können den Code so ändern, dass er den Anforderungen Ihrer Anwendung entspricht.

| Ersetzen Sie im folgenden Beispiel <AuthorityIdId>, <ApplicationId>, <ManagedIdentityClientId>und <QueryEndpointUri> durch Ihre eigenen Werte.

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);

Verwenden der Azure TokenCredential-Authentifizierung

Erstellen Sie einen benutzerdefinierten Tokenanbieter, indem Sie eine Klasse erstellen, die von TokenCredential erbt und die GetToken-Methode implementiert. Alternativ können Sie einen vorhandenen Tokenanbieter wie DefaultAzureCredentialverwenden. Diese Methode bietet Flexibilität für verschiedene Authentifizierungsszenarien, wenn ein benutzerdefinierter Tokenanbieter erforderlich ist.

Sie können DefaultAzureCredential verwenden, um Produktionscode zu unterstützen, der die Verwaltete Identitätsauthentifizierung verwendet, oder Testcode mit Visual Studio oder Azure CLI. DefaultAzureCredential können für die Verwendung verschiedener Authentifizierungsmethoden konfiguriert werden.

| Ersetzen Sie im folgenden Beispiel <QueryEndpointUri> und <ManagedIdentityClientId> durch Ihre eigenen Werte.

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);

Nächster Schritt