Uygulama kimlik doğrulama yöntemleri

Şunlar için geçerlidir: ✅Microsoft Fabric✅Azure Veri Gezgini

Bu belge, Kusto istemci kitaplıkları için kullanılabilen birincil kimlik doğrulama yöntemlerine genel bir bakış sağlar. Sağlanan kod parçacıkları, kusto kümeleriyle sorunsuz etkileşime olanak tanıyarak kullanıcıların ve uygulamaların kimliğini doğrulamak için farklı yaklaşımlar gösterir. Her yöntem farklı senaryolar ve gereksinimler için uygundur.

Mümkün olduğunda, kullanıcı adı ve parola kimlik doğrulaması veya bağlantı dizeleri yerine yönetilen kimlikler kullanmanızı öneririz. Yönetilen kimlikler, kimlik doğrulamasına daha güvenli ve kolay bir yaklaşım sağlar.

Bu makalede, aşağıdakileri kullanarak kimlik doğrulaması yapmayı öğreneceksiniz:

Önkoşullar

• Kusto istemci kitaplığını kullanmak için geliştirme ortamınızı ayarlayın.

Uygulama Sorumlusu kimlik doğrulama yöntemleri

Bu bölüm, bir uygulama sorumlusu kullanarak kimlik doğrulamanın farklı yöntemlerini kapsar.

Yönetilen Kimlik Doğrulaması

İki tür yönetilen kimlik vardır: sistem tarafından atanan ve kullanıcı tarafından atanan. Sistem tarafından atanan yönetilen kimliklerin yaşam döngüleri onları oluşturan kaynağa bağlıdır. Bu kimlik yalnızca bir kaynakla sınırlıdır. Kullanıcı tarafından atanan yönetilen kimlikler birden çok kaynakta kullanılabilir. Daha fazla bilgi için Yönetilen Kimlikler'e bakınız.

| Aşağıdaki örneklerde <QueryEndpointUri> ve <ManagedIdentityClientId> değerlerini kendi değerlerinizle değiştirin.

• Sistem tarafından atanan yönetilen kimlik:

  • C#
  • Python
  • TypeScript
  • Java

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

• Kullanıcı tarafından atanan yönetilen kimlik. Kimlik istemci kimliğini veya nesne kimliğini aşağıdaki gibi kullanın:

  • C#
  • Python
  • TypeScript
  • Java

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

Sertifika tabanlı kimlik doğrulaması

Sertifikalar, belirteç isteğinde bulunurken bir uygulamanın kimliğini doğrulamak için gizli bilgi görevi görebilir. Sertifikayı yüklemek için makinenin yerel kimlik bilgileri deposundan veya diskten yükleme gibi çeşitli yöntemler vardır.

| Aşağıdaki örneklerde, <QueryEndpointUri>, <ApplicationId>, <CertificateSubjectName>, <CertificateIssuerName>, <CertificateThumbprint>, <CertificateObject>, <AuthorityId>, <PemPublicCertificate>, <PemPrivateKey>, <privateKeyPemFilePath>, <PemCertificatePath>ve <EnableSubjectAndIssuerAuth> kendi değerlerinizle değiştirin.

• Makinenin yerel sertifika deposundaki sertifika yalnızca C# kullanılarak desteklenir:

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

  Önemli

  Konu adı ve veren kullanılırken sertifikanın yerel makinenin sertifika deposuna yüklenmesi gerekir.

• Diskteki bir dosya, önbellek veya Azure Key Vault gibi güvenli depo gibi rastgele bir kaynaktan alınan sertifika. Sertifika nesnesi bir özel anahtar içermelidir:

  • C#
  • Python
  • TypeScript
  • Java

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

  Daha fazla bilgi için bkz. Kusto bağlantı dizelerini.

Uygulama anahtarı kimlik doğrulaması

Uygulama parolası olarak da bilinen uygulama anahtarı, bir uygulamanın belirteç isteğinde bulunurken kimlik doğrulaması yapmak ve kimliğini kanıtlamak için kullandığı gizli dizidir. Uygulamanın korumalı kaynaklara erişmesi için bir kimlik bilgisi biçimi görevi görür. Uygulama anahtarı genellikle kimlik sağlayıcısı veya yetkilendirme sunucusu tarafından oluşturulur ve atanır. Hassas bilgilere veya eylemlere yetkisiz erişimi önlemek için uygulama anahtarını güvenli bir şekilde yönetmek ve korumak önemlidir.

| Aşağıdaki örneklerde, <QueryEndpointUri>, <ApplicationId>, <ApplicationKey>, <AuthorityId>ve <AuthorityId> değerlerini kendi değerlerinizle değiştirin.

• Uygulama anahtarı:

  • C#
  • Python
  • TypeScript
  • Java

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

• Uygulama anahtarıyla bağlantı dizesi:

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

Kullanıcı Sorumlusu kimlik doğrulama yöntemleri

Bu bölüm, kullanıcı sorumlusu kullanarak kimlik doğrulamanın farklı yöntemlerini kapsar.

Etkileşimli kullanıcı oturum açma kimlik doğrulaması

Bu kimlik doğrulama yöntemi, Kusto ile güvenli bir bağlantı kurmak için kullanıcının kimlik bilgilerini kullanır. yöntemi, kullanıcıdan kimlik doğrulama işlemini tamamlamak için kullanıcı adını ve parolasını girmesi istendiği bir web tarayıcısı açar.

| Aşağıdaki örneklerde, <QueryEndpointUri> ,<AuthorityId>ve <AuthorityId> değerlerini kendi değerlerinizle değiştirin.

• Etkileşimli kullanıcı oturum açma:

  • C#
  • Python
  • TypeScript
  • Java

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

Azure Command-Line Arabirimi (CLI) kimlik doğrulaması

Bu kimlik doğrulama yöntemi, kullanıcının kimliğini doğrulamak ve belirteç almak için Azure Command-Line Arabirimi'ni (CLI) kullanır. az login komutunu çalıştırmak, kullanıcının güvenli bir şekilde bağlantı kurabileceği ve kimlik doğrulaması amacıyla gerekli belirteci alabildiği anlamına gelir. Belirteç Azure CLI önbelleğinde kullanılamıyorsa ve interactive parametresi trueolarak ayarlandıysa kullanıcıdan oturum açması istenebilir. Daha fazla bilgi için bkz. Azure Command-Line Arayüz (CLI).

| Aşağıdaki örnekte, <QueryEndpointUri> değerini kendi değerinizle değiştirin.

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

Cihaz kodu kimlik doğrulaması

Bu yöntem, IoT cihazları ve sunucu terminalleri gibi oturum açma için uygun bir kullanıcı arabirimi olmayan cihazlar için tasarlanmıştır. Kullanıcıya akıllı telefon gibi farklı bir cihaz kullanarak kimlik doğrulaması için bir kod ve URL sağlar. Bu etkileşimli yöntem, kullanıcının tarayıcı üzerinden oturum açmasını gerektirir.

| Aşağıdaki örnekte, <QueryEndpointUri> değerini kendi değerinizle değiştirin.

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

Özel jeton sağlayıcısı kimlik doğrulama yöntemleri

Bu bölüm, özel belirteç sağlayıcısı kullanarak kimlik doğrulamanın farklı yöntemlerini kapsar.

Federasyonla Yönetilen Kimlik kimlik doğrulaması için özel belirteç sağlayıcısı

Özel belirteç sağlayıcıları, kimlik doğrulaması amacıyla bir Microsoft Entra ID belirteci almak için kullanılabilir. Aşağıdaki örnek, federatif yönetilen kimlik kullanarak belirteç almak için özel belirteç sağlayıcısının nasıl kullanılacağını göstermektedir. Kodu uygulamanızın gereksinimlerine uyacak şekilde değiştirebilirsiniz.

| Aşağıdaki örnekte, <AuthorityIdId>, <ApplicationId>, <ManagedIdentityClientId>ve <QueryEndpointUri> değerlerini kendi değerlerinizle değiştirin.

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 kimlik doğrulamayı kullanma

TokenCredential'den devralan ve GetToken yöntemini uygulayan bir sınıf oluşturarak özel belirteç sağlayıcısı oluşturun. Alternatif olarak, DefaultAzureCredentialgibi mevcut bir belirteç sağlayıcısını kullanabilirsiniz. Bu yöntem, özel belirteç sağlayıcısı gerektiğinde farklı kimlik doğrulama senaryoları için esneklik sağlar.

Yönetilen Kimlik kimlik doğrulaması kullanan üretim kodunu desteklemek veya Visual Studio veya Azure CLI kullanarak kodu test etme için DefaultAzureCredential kullanabilirsiniz. DefaultAzureCredential farklı kimlik doğrulama yöntemleri kullanacak şekilde yapılandırılabilir.

| Aşağıdaki örnekte, <QueryEndpointUri> ve <ManagedIdentityClientId> değerlerini kendi değerlerinizle değiştirin.

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

Sonraki adım