Metody uwierzytelniania aplikacji

Dotyczy: ✅Microsoft Fabric✅Azure Data Explorer

Ta dokumentacja zawiera omówienie podstawowych metod uwierzytelniania dostępnych dla bibliotek klienckich usługi Kusto. Podane fragmenty kodu przedstawiają różne podejścia do uwierzytelniania użytkowników i aplikacji, umożliwiając bezproblemową interakcję z klastrami Kusto. Każda metoda jest odpowiednia dla różnych scenariuszy i wymagań.

Jeśli to możliwe, zalecamy używanie tożsamości zarządzanych zamiast nazwy użytkownika i uwierzytelniania haseł lub parametrów połączenia. Tożsamości zarządzane zapewniają bezpieczniejsze i usprawnione podejście do uwierzytelniania.

Z tego artykułu dowiesz się, jak uwierzytelniać się przy użyciu:

Podmiot główny aplikacji

• Uwierzytelnianie za pomocą tożsamości zarządzanej
• uwierzytelniania Certificate-Based
• uwierzytelnianie klucza aplikacji

Główny użytkownik

• interaktywne uwierzytelnianie użytkownika podczas logowania
• Uwierzytelnianie interfejsu Azure Command-Line (CLI)
• Kod urządzenia uwierzytelniania

niestandardowy dostawca tokenów

• Niestandardowy dostawca tokenów dla uwierzytelniania poświadczeń zarządzanej tożsamości federacyjnej
• Korzystanie z uwierzytelniania przy użyciu Azure TokenCredential

Warunki wstępne

• Skonfiguruj środowisko deweloperskie do korzystania z biblioteki klienta Kusto.

Metody uwierzytelniania podmiotu zabezpieczeń aplikacji

W tej sekcji opisano różne metody uwierzytelniania przy użyciu tożsamości aplikacji.

Uwierzytelnianie za pomocą tożsamości zarządzanej

Istnieją dwa typy tożsamości zarządzanych: przypisane przez system i przypisane przez użytkownika. Tożsamości zarządzane przypisane przez system mają swój cykl życia związany z zasobem, który je utworzył. Ta tożsamość jest ograniczona do tylko jednego zasobu. Tożsamości zarządzane przypisane przez użytkownika mogą być używane dla wielu zasobów. Aby uzyskać więcej informacji, zobacz Tożsamości zarządzane.

| W poniższych przykładach zastąp <QueryEndpointUri> i <ManagedIdentityClientId> własnymi wartościami.

• Tożsamość zarządzana przypisana przez system:

  C#

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

  kcsb = KustoConnectionStringBuilder
    .with_aad_managed_service_identity_authentication(<QueryEndpointUri>)
  

  TypeScript

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

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

• Tożsamość zarządzana przypisana przez użytkownika. Użyj identyfikatora klienta tożsamości lub identyfikatora obiektu w następujący sposób:

  C#

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

  kcsb = KustoConnectionStringBuilder
    .with_aad_managed_service_identity_authentication(<QueryEndpointUri>, client_id=<ManagedIdentityClientId>)
  

  Notatka

  Aby użyć identyfikatora obiektu zamiast identyfikatora klienta, użyj parametru object_id.

  TypeScript

  const kcsb = KustoConnectionStringBuilder
    .withUserManagedIdentity(<QueryEndpointUri>, <ManagedIdentityClientId>);
  

  ConnectionStringBuilder kcsb = ConnectionStringBuilder
    .createWithAadManagedIdentity(<QueryEndpointUri>, <ManagedIdentityClientId>);
  

Ważny

• Aby uzyskać dostęp do klastra Kusto, należy przypisać rolę obiektowi, czyli jednostce głównej, zasobu tożsamości zarządzanej. Możesz to zrobić w Azure Portal na stronie zasobu klastra Kusto w sekcji Zabezpieczenia + Sieć>Uprawnienia. Zarządzana tożsamość nie powinna być bezpośrednio dołączana do klastra Kusto.
• Uwierzytelnianie przy użyciu tożsamości zarządzanej nie jest obsługiwane w lokalnych środowiskach programistycznych. Aby przetestować uwierzytelnianie tożsamości zarządzanej, wdróż aplikację na platformie Azure lub użyj innej metody uwierzytelniania podczas pracy lokalnie.

Uwierzytelnianie oparte na certyfikatach

Certyfikaty mogą służyć jako tajne informacje do uwierzytelniania tożsamości aplikacji podczas żądania tokenu. Istnieje kilka metod ładowania certyfikatu, takich jak ładowanie go z lokalnego magazynu poświadczeń maszyny lub z dysku.

| W poniższych przykładach zastąp <QueryEndpointUri>, <ApplicationId>, <CertificateSubjectName>, <CertificateIssuerName>, <CertificateThumbprint>, <CertificateObject>, <AuthorityId>, <PemPublicCertificate>, <PemPrivateKey>, <privateKeyPemFilePath>, <PemCertificatePath>i <EnableSubjectAndIssuerAuth> własnymi wartościami.

• Certyfikat z lokalnego magazynu certyfikatów maszyny jest obsługiwany tylko przy użyciu języka C#:

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

  Ważny

  W przypadku używania nazwy podmiotu i wystawcy certyfikat musi być zainstalowany w magazynie certyfikatów komputera lokalnego.

• Certyfikat z dowolnego źródła, takiego jak plik na dysku, pamięć podręczną lub bezpieczny magazyn, taki jak usługa Azure Key Vault. Obiekt certyfikatu musi zawierać klucz prywatny:

  C#

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

  • Certyfikat załadowany w pamięci:

    kcsb = KustoConnectionStringBuilder
      .with_aad_application_certificate_authentication(<QueryEndpointUri>, <ApplicationId>, <PemPrivateKey>, <CertificateThumbprint>, <AuthorityId>)
    

  • Uwierzytelnianie podmiotu i wystawcy (SNI):

    kcsb = KustoConnectionStringBuilder
     .with_aad_application_certificate_sni_authentication(<QueryEndpointUri>, <ApplicationId>, <PemPrivateKey>, <PemPublicCertificate>, <CertificateThumbprint>, <AuthorityId>)
    

  TypeScript

  • Certyfikat załadowany w pamięci, na przykład z pliku:

    const certificate: string = await fs.promises.readFile(<privateKeyPemFilePath>, "utf8");
    const kcsb = KustoConnectionStringBuilder
      .withAadApplicationCertificateAuthentication(<QueryEndpointUri>, <ApplicationId>, certificate, <AuthorityId>);
    

  • Certyfikat załadowany z pliku:

    const kcsb = KustoConnectionStringBuilder
      .withAadApplicationCertificateAuthentication(<QueryEndpointUri>, <ApplicationId>, undefined, <AuthorityId>, <EnableSubjectAndIssuerAuth>, <PemCertificatePath>);
    

  • Certyfikat załadowany w pamięci:

    ConnectionStringBuilder kcsb = ConnectionStringBuilder
      .createWithAadApplicationCertificate(<QueryEndpointUri>, <ApplicationId>, <X509Certificate>, <PrivateKey>, <AuthorityId>);
    

  • Uwierzytelnianie podmiotu i wystawcy (SNI):

    ConnectionStringBuilder kcsb = ConnectionStringBuilder
      .createWithAadApplicationCertificateSubjectNameIssuer(<QueryEndpointUri>, <ApplicationId>, <PublicCertificateChain>, <PrivateKey>, <AuthorityId>
    

  Aby uzyskać więcej informacji, zobacz parametry połączenia usługi Kusto.

Ważny

Aby załadować certyfikaty z usługi Azure Key Vault, możesz użyć klienta Azure.Security.KeyVault.Certificates.

Uwierzytelnianie klucza aplikacji

Klucz aplikacji, znany również jako hasło aplikacji, jest ciągiem tajnym używanym przez aplikację do uwierzytelniania i potwierdzenia tożsamości podczas żądania tokenu. Służy jako forma poświadczeń dla aplikacji w celu uzyskania dostępu do chronionych zasobów. Klucz aplikacji jest zwykle generowany i przypisywany przez dostawcę tożsamości lub serwer autoryzacji. Ważne jest, aby bezpiecznie zarządzać kluczem aplikacji i chronić go, aby zapobiec nieautoryzowanemu dostępowi do poufnych informacji lub akcji.

| W poniższych przykładach zastąp <QueryEndpointUri>, <ApplicationId>, <ApplicationKey>, <AuthorityId>i <AuthorityId> własnymi wartościami.

• Klucz aplikacji:

  C#

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

  Python

  kcsb = KustoConnectionStringBuilder
    .with_aad_application_key_authentication(<QueryEndpointUri>, <ApplicationId>, <ApplicationKey>, <AuthorityId>)
  

  TypeScript

  const kcsb = KustoConnectionStringBuilder
    .withAadApplicationKeyAuthentication(<QueryEndpointUri>, <ApplicationId>, <ApplicationKey>, <AuthorityId>);
  

  ConnectionStringBuilder kcsb = ConnectionStringBuilder
    .createWithAadApplicationCredentials(<QueryEndpointUri>, <ApplicationId>, <ApplicationKey>, <AuthorityId>);
  

• Ciąg połączenia z kluczem aplikacji:

  C#

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

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

  TypeScript

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

  String connectionString = "Data Source=<QueryEndpointUri>;AppClientId=<ApplicationId>;AppKey=<ApplicationKey>;Authority Id=<AuthorityId>";
  ConnectionStringBuilder kcsb = new ConnectionStringBuilder(connectionString);
  

Ważny

Twarde kodowanie sekretów w kodzie jest uznawane za złą praktykę. Przechowywanie poufnych informacji, takich jak poświadczenia uwierzytelniania, w postaci zwykłego tekstu może prowadzić do luk w zabezpieczeniach. Zalecamy przechowywanie poufnych informacji zaszyfrowanych lub przechowywanie ich w bezpiecznym magazynie kluczy. Korzystając z szyfrowania lub magazynu kluczy, możesz mieć pewność, że wpisy tajne są chronione i dostępne tylko dla autoryzowanych użytkowników lub aplikacji.

Metody uwierzytelniania głównego użytkownika

W tej sekcji opisano różne metody uwierzytelniania używając tożsamości użytkownika.

Uwierzytelnianie logowania interakcyjnego użytkownika

Ta metoda uwierzytelniania używa poświadczeń użytkownika do nawiązania bezpiecznego połączenia z usługą Kusto. Metoda otwiera przeglądarkę internetową, w której użytkownik jest monitowany o wprowadzenie nazwy użytkownika i hasła w celu ukończenia procesu uwierzytelniania.

| W poniższych przykładach zastąp <QueryEndpointUri> ,<AuthorityId>i <AuthorityId> własnymi wartościami.

• Logowanie użytkownika interakcyjnego:

  C#

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

  Python

  kcsb = KustoConnectionStringBuilder
    .with_interactive_login(<QueryEndpointUri>)
  

  TypeScript

  const kcsb = KustoConnectionStringBuilder
    .createWithUserPrompt(<QueryEndpointUri>, {tenantId: <AuthorityId>});
  

  ConnectionStringBuilder kcsb = ConnectionStringBuilder
    .createWithAadApplicationCredentials(<QueryEndpointUri>, <AuthorityId>);
  

Uwierzytelnianie interfejsu azure Command-Line (CLI)

Ta metoda uwierzytelniania używa interfejsu azure Command-Line (CLI) do uwierzytelniania i uzyskiwania tokenu dla użytkownika. Uruchomienie polecenia az login oznacza, że użytkownik może bezpiecznie nawiązać połączenie i pobrać niezbędny token do celów uwierzytelniania. Użytkownik może zostać poproszony o zalogowanie się, jeśli token nie jest dostępny w pamięci podręcznej Azure CLI, a parametr interactive jest ustawiony na true. Aby uzyskać więcej informacji, zobacz Azure CLI Command-Line.

| W poniższym przykładzie zastąp <QueryEndpointUri> własną wartością.

C#

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

kcsb = KustoConnectionStringBuilder
  .with_az_cli_authentication(<QueryEndpointUri>)

TypeScript

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

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

Ważny

Ta metoda jest obsługiwana tylko w przypadku aplikacji .NET Framework.

Uwierzytelnianie kodu urządzenia

Ta metoda jest przeznaczona dla urządzeń, które nie mają odpowiedniego interfejsu użytkownika do logowania, takich jak urządzenia IoT i terminale serwera. Udostępnia on użytkownikowi kod i adres URL do uwierzytelniania przy użyciu innego urządzenia, takiego jak smartfon. Ta metoda interaktywna wymaga od użytkownika zalogowania się za pośrednictwem przeglądarki.

| W poniższym przykładzie zastąp <QueryEndpointUri> własną wartością.

C#

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

TypeScript

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

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

Ważny

Uwierzytelnianie kodu urządzenia może być blokowane przez zasady dostępu warunkowego najemcy. W takim przypadku wybierz alternatywną metodę uwierzytelniania.

Niestandardowe metody uwierzytelniania dostawcy tokenów

W tej sekcji opisano różne metody uwierzytelniania przy użyciu niestandardowego dostawcy tokenów.

Dostosowany dostawca tokenów dla federacyjnego uwierzytelniania poświadczeń zarządzanej tożsamości.

Niestandardowy dostawca tokenów może być użyty do uzyskania tokenu Microsoft Entra ID na potrzeby uwierzytelnienia. W poniższym przykładzie pokazano, jak uzyskać token za pomocą niestandardowego dostawcy tokenów i tożsamości zarządzanej z użyciem federacji. Kod można zmodyfikować tak, aby odpowiadał wymaganiom aplikacji.

| W poniższym przykładzie zastąp <AuthorityIdId>, <ApplicationId>, <ManagedIdentityClientId>i <QueryEndpointUri> własnymi wartościami.

C#

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
  )

TypeScript

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

Korzystanie z uwierzytelniania azure TokenCredential

Utwórz niestandardowego dostawcę tokenów, tworząc klasę, która dziedziczy po TokenCredential i implementuje metodę GetToken. Alternatywnie możesz użyć istniejącego dostawcy tokenów, takiego jak DefaultAzureCredential. Ta metoda zapewnia elastyczność dla różnych scenariuszy uwierzytelniania, gdy jest wymagany niestandardowy dostawca tokenów.

Można użyć DefaultAzureCredential do obsługi kodu produkcyjnego korzystającego z uwierzytelniania tożsamości zarządzanej lub testowania kodu przy użyciu programu Visual Studio lub interfejsu wiersza polecenia platformy Azure. DefaultAzureCredential można skonfigurować do używania różnych metod uwierzytelniania.

| W poniższym przykładzie zastąp <QueryEndpointUri> i <ManagedIdentityClientId> własnymi wartościami.

C#

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)

TypeScript

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

Nie obsługiwane.

Notatka

DefaultAzureCredential służy do uwierzytelniania za pomocą usług platformy Azure. Podejmuje próbę uzyskania tokenu za pomocą wielu metod uwierzytelniania i można ją skonfigurować do pracy z tożsamością zarządzaną, programem Visual Studio, interfejsem wiersza polecenia platformy Azure i nie tylko. To poświadczenie jest odpowiednie zarówno dla środowisk testowych, jak i produkcyjnych, ponieważ można je skonfigurować do używania różnych metod uwierzytelniania. Aby uzyskać więcej informacji, zobacz DefaultAzureCredential Class.

Następny krok

Tworzenie aplikacji w celu uruchamiania podstawowych zapytań