Verificatiemethoden voor apps

Van toepassing op: ✅Microsoft Fabric✅Azure Data Explorer-

Dit artikel bevat een overzicht van de primaire verificatiemethoden die beschikbaar zijn voor de Kusto-clientbibliotheken. De codefragmenten tonen verschillende manieren om gebruikers en apps te verifiëren, waardoor naadloze interactie met Kusto-clusters mogelijk is. Elke methode past bij verschillende scenario's en vereisten.

Gebruik waar mogelijk beheerde identiteiten in plaats van gebruikersnaam- en wachtwoordverificatie of verbindingsreeksen. Beheerde identiteiten bieden een veiligere en gestroomlijndere benadering van verificatie.

In dit artikel leert u hoe u zich verifieert met behulp van:

Verificatie van beheerde identiteit

• Verificatie op basis van certificaat
• verificatie van toepassingssleutels

Gebruikershoofdrol

• interactieve aanmeldingsverificatie van gebruikers
• Azure Command-Line Interface (CLI) authenticatie
• verificatie van apparaatcode

Aangepaste token-provider

• Aangepaste tokenprovider voor authenticatie van federatief beheerde identiteitsreferenties
• Azure TokenCredential-verificatie gebruiken

Voorwaarden

• Uw ontwikkelomgeving instellen voor het gebruik van de Kusto-clientbibliotheek

Verificatiemethoden voor toepassingsprincipaal

In deze sectie worden de verschillende verificatiemethoden beschreven met behulp van een toepassingsprincipaal.

Verificatie van beheerde identiteit

Er zijn twee typen beheerde identiteiten: door het systeem toegewezen en door de gebruiker toegewezen. Door het systeem toegewezen beheerde identiteiten hebben hun levenscyclus gekoppeld aan de resource waarmee ze worden gemaakt. Deze identiteit is beperkt tot één bron. Door de gebruiker toegewezen beheerde identiteiten kunnen worden gebruikt voor meerdere resources. Zie Beheerde identiteitenvoor meer informatie.

Vervang <QueryEndpointUri> en <ManagedIdentityClientId> door uw eigen waarden in de volgende voorbeelden.

• Door het systeem toegewezen beheerde identiteit:

  • C#
  • Python
  • TypeScript-
  • Java

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

• Door de gebruiker toegewezen beheerde identiteit. Gebruik de identiteitsclient-ID of object-ID als volgt:

  • C#
  • Python
  • TypeScript-
  • Java

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

Verificatie op basis van certificaten

Certificaten fungeren als geheimen om de identiteit van een toepassing te verifiëren bij het aanvragen van een token. Er zijn verschillende methoden om het certificaat te laden, zoals het laden van het certificaat vanuit het lokale referentiearchief van de computer of van de schijf.

| Vervang in de volgende voorbeelden <QueryEndpointUri>, <ApplicationId>, <CertificateSubjectName>, <CertificateIssuerName>, <CertificateThumbprint>, <CertificateObject>, <AuthorityId>, <PemPublicCertificate>, <PemPrivateKey>, <privateKeyPemFilePath>, <PemCertificatePath>en <EnableSubjectAndIssuerAuth> door uw eigen waarden.

• Het certificaat van het lokale certificaatarchief van de computer wordt alleen ondersteund met C#:

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

  Belangrijk

  Wanneer u de onderwerpnaam en de uitgever gebruikt, moet het certificaat worden geïnstalleerd in de certificaatopslag van de lokale computer.

• Certificaat van een willekeurige bron, zoals een bestand op schijf, cache of beveiligd archief, zoals Azure Key Vault. Het certificaatobject moet een persoonlijke sleutel bevatten:

  • C#
  • Python
  • TypeScript-
  • Java

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

  Voor meer informatie, zie Kusto-verbindingsreeksen.

Verificatie van toepassingssleutels

Toepassingssleutel, ook wel een toepassingswachtwoord genoemd, is een geheime tekenreeks die een toepassing gebruikt om de identiteit te verifiëren en te bewijzen bij het aanvragen van een token. Het fungeert als een vorm van referentie voor de toepassing voor toegang tot beveiligde resources. De toepassingssleutel wordt doorgaans gegenereerd en toegewezen door de id-provider of autorisatieserver. Het is belangrijk dat u de toepassingssleutel veilig beheert en beveiligt om onbevoegde toegang tot gevoelige informatie of acties te voorkomen.

| Vervang in de volgende voorbeelden <QueryEndpointUri>, <ApplicationId>, <ApplicationKey>, <AuthorityId>en <AuthorityId> door uw eigen waarden.

• Toepassingssleutel:

  • C#
  • Python
  • TypeScript-
  • Java

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

• Verbindingsreeks met applicatiesleutel:

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

Verificatiemethoden voor gebruikersprincipaal

In deze sectie worden de verschillende verificatiemethoden beschreven met behulp van een gebruikersprincipaal.

Interactieve gebruikersaanmeldingsverificatie

Deze verificatiemethode gebruikt de referenties van de gebruiker om een beveiligde verbinding met Kusto tot stand te brengen. De methode opent een webbrowser waarin de gebruiker wordt gevraagd om zijn gebruikersnaam en wachtwoord in te voeren om het verificatieproces te voltooien.

| Vervang in de volgende voorbeelden <QueryEndpointUri>,<AuthorityId>en <AuthorityId> door uw eigen waarden.

• Interactieve gebruikersaanmelding:

  • C#
  • Python
  • TypeScript-
  • Java

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

Verificatie van Azure Command-Line Interface (CLI)

Deze verificatiemethode maakt gebruik van de Azure Command-Line Interface (CLI) om een token voor de gebruiker te verifiëren en te verkrijgen. Door de opdracht az login uit te voeren, kan de gebruiker veilig een verbinding tot stand brengen en het benodigde token ophalen voor verificatiedoeleinden. De gebruiker wordt mogelijk gevraagd zich aan te melden als het token niet beschikbaar is in de Azure CLI-cache en de parameter interactive is ingesteld op true. Zie Azure Command-Line Interface (CLI)voor meer informatie.

| Vervang in het volgende voorbeeld <QueryEndpointUri> door uw eigen waarde.

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

Verificatie van apparaatcode

Deze methode is ontworpen voor apparaten die geen juiste gebruikersinterface hebben voor aanmelding, zoals IoT-apparaten en serverterminals. Het biedt de gebruiker een code en een URL om te verifiëren met behulp van een ander apparaat, zoals een smartphone. Voor deze interactieve methode moet de gebruiker zich aanmelden via een browser.

| Vervang in het volgende voorbeeld <QueryEndpointUri> door uw eigen waarde.

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

Verificatiemethoden voor aangepaste tokenproviders

In deze sectie worden de verschillende verificatiemethoden beschreven met behulp van een aangepaste tokenprovider.

Aangepaste tokenprovider voor verificatie van federatieve-beheerde Managed Identity-identiteitsreferenties.

Aangepaste tokenproviders kunnen worden gebruikt om een Microsoft Entra ID-token voor verificatie te verkrijgen. In het volgende voorbeeld ziet u hoe u een aangepaste tokenprovider gebruikt om een token te verkrijgen met federatieve beheerde identiteit. U kunt de code aanpassen aan de vereisten van uw toepassing.

| Vervang in het volgende voorbeeld <AuthorityIdId>, <ApplicationId>, <ManagedIdentityClientId>en <QueryEndpointUri> door uw eigen waarden.

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

Azure TokenCredential-verificatie gebruiken

Maak een aangepaste tokenprovider door een klasse te maken die wordt overgenomen van TokenCredential en de GetToken-methode implementeert. U kunt ook een bestaande tokenprovider zoals DefaultAzureCredentialgebruiken. Deze methode biedt flexibiliteit voor verschillende verificatiescenario's wanneer een aangepaste tokenprovider vereist is.

U kunt DefaultAzureCredential gebruiken voor het ondersteunen van productiecode die gebruikmaakt van managed identity-verificatie of het testen van code met behulp van Visual Studio of Azure CLI. DefaultAzureCredential kan worden geconfigureerd voor het gebruik van verschillende verificatiemethoden.

| Vervang in het volgende voorbeeld <QueryEndpointUri> en <ManagedIdentityClientId> door uw eigen waarden.

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

Volgende stap