Konfigurowanie pozyskiwania danych za pośrednictwem przesyłania strumieniowego w klastrze usługi Azure Data Explorer

Pozyskiwanie przesyłania strumieniowego jest przydatne do ładowania danych, gdy potrzebujesz małego opóźnienia między pozyskiwaniem i wykonywaniem zapytań. Rozważ użycie pozyskiwania przesyłania strumieniowego w następujących scenariuszach:

• Wymagane jest opóźnienie mniejsze niż sekundę.
• Aby zoptymalizować przetwarzanie operacyjne wielu tabel, w których strumień danych do każdej tabeli jest stosunkowo mały (kilka rekordów na sekundę), ale ogólny wolumin pozyskiwania danych jest wysoki (tysiące rekordów na sekundę).

Jeśli strumień danych do każdej tabeli jest wysoki (ponad 4 GB na godzinę), rozważ użycie pozyskiwania w kolejce.

Aby dowiedzieć się więcej na temat różnych metod pozyskiwania danych, zobacz Omówienie pozyskiwania danych.

Przykłady kodu oparte na poprzednich wersjach zestawu SDK można znaleźć w zarchiwizowanym artykule.

Wybierz odpowiedni typ pozyskiwania przesyłania strumieniowego

Obsługiwane są dwa typy pozyskiwania przesyłania strumieniowego:

Typ pozyskiwania	opis
Połączenie danych	Połączenia danych usługi Event Hubs, IoT Hub i Event Grid mogą używać pozyskiwania danych przesyłanych strumieniowo, pod warunkiem, że jest on włączony na poziomie klastra. Decyzja o użyciu pozyskiwania przesyłania strumieniowego jest wykonywana zgodnie z zasadami pozyskiwania przesyłania strumieniowego skonfigurowanymi w tabeli docelowej. Aby uzyskać informacje na temat zarządzania połączeniami danych, zobacz Event Hub, IoT Hub i Event Grid.
Niestandardowe pozyskiwanie	Niestandardowe pozyskiwanie wymaga napisania aplikacji korzystającej z jednej z bibliotek klienckich usługi Azure Data Explorer. Skorzystaj z informacji w tym temacie, aby skonfigurować niestandardowe pozyskiwanie. Możesz również znaleźć przykładową aplikację do pozyskiwania danych w języku C?view=azure-data-explorer&preserve-view=true#.

Poniższa tabela ułatwia wybór typu pozyskiwania, który jest odpowiedni dla danego środowiska:

Kryterium	Połączenie danych	Niestandardowe pozyskiwanie
Opóźnienie danych między inicjowaniem pozyskiwania i danymi dostępnymi dla zapytania	Dłuższe opóźnienie	Krótsze opóźnienie
Obciążenie związane z programowaniem	Szybka i łatwa konfiguracja, brak obciążeń programistycznych	Duże obciążenie programistyczne w celu utworzenia aplikacji pozyskiwania danych, obsługi błędów i zapewnienia spójności danych

Uwaga

Możesz zarządzać procesem włączania i wyłączania pozyskiwania przesyłania strumieniowego w klastrze przy użyciu witryny Azure Portal lub programowo w języku C#. Jeśli używasz języka C# dla aplikacji niestandardowej, możesz go znaleźć bardziej wygodne przy użyciu podejścia programowego.

Wymagania wstępne

• Subskrypcja platformy Azure. Utwórz bezpłatne konto platformy Azure.

Zagadnienia dotyczące wydajności i działania

Głównymi współautorami, które mogą mieć wpływ na pozyskiwanie przesyłania strumieniowego, są:

• Rozmiar maszyny wirtualnej i klastra: wydajność pozyskiwania przesyłania strumieniowego i skalowanie pojemności przy użyciu zwiększonych rozmiarów maszyn wirtualnych i klastrów. Liczba współbieżnych żądań pozyskiwania jest ograniczona do sześciu na rdzeń. Na przykład w przypadku 16-rdzeniowych jednostek SKU, takich jak D14 i L16, maksymalne obsługiwane obciążenie to 96 równoczesnych żądań pozyskiwania. W przypadku dwóch podstawowych jednostek SKU, takich jak D11, maksymalne obsługiwane obciążenie to 12 współbieżnych żądań pozyskiwania.
• Limit rozmiaru danych: limit rozmiaru danych dla żądania pozyskiwania przesyłania strumieniowego wynosi 4 MB. Obejmuje to wszystkie dane utworzone dla zasad aktualizacji podczas pozyskiwania.
• Aktualizacje schematu: aktualizacje schematu, takie jak tworzenie i modyfikowanie tabel i mapowań pozyskiwania, może potrwać do pięciu minut dla usługi pozyskiwania przesyłania strumieniowego. Aby uzyskać więcej informacji, zobacz Pozyskiwanie przesyłania strumieniowego i zmiany schematu.
• Pojemność dysków SSD: Włączenie pozyskiwania strumieniowego w klastrze, nawet jeśli dane nie są pozyskiwane za pośrednictwem przesyłania strumieniowego, używa części lokalnego dysku SSD maszyn klastra do przesyłania strumieniowego danych pozyskiwania danych i zmniejsza ilość miejsca dostępnego dla gorącej pamięci podręcznej.

Włączanie pozyskiwania danych przesyłanych strumieniowo w klastrze

Aby można było użyć pozyskiwania przesyłania strumieniowego, należy włączyć funkcję w klastrze i zdefiniować zasady pozyskiwania przesyłania strumieniowego. Funkcję można włączyć podczas tworzenia klastra lub dodać do istniejącego klastra.

Ostrzeżenie

Zapoznaj się z ograniczeniami przed włączeniem pozyskiwania przesyłania strumieniowego.

Włączanie pozyskiwania przesyłania strumieniowego podczas tworzenia nowego klastra

Pozyskiwanie przesyłania strumieniowego można włączyć podczas tworzenia nowego klastra przy użyciu witryny Azure Portal lub programowo w języku C#.

Portal

Podczas tworzenia klastra, wykonując kroki opisane w temacie Tworzenie klastra i bazy danych usługi Azure Data Explorer, na karcie Konfiguracje wybierz pozycję Pozyskiwanie przesyłania strumieniowego>włączone.

C#

Aby włączyć pozyskiwanie przesyłania strumieniowego podczas tworzenia nowego klastra usługi Azure Data Explorer, uruchom następujący kod:

using System.Threading.Tasks;
using Azure;
using Azure.Core;
using Azure.Identity; // Required package Azure.Identity
using Azure.ResourceManager;
using Azure.ResourceManager.Kusto; // Required package Azure.ResourceManager.Kusto
using Azure.ResourceManager.Kusto.Models;
namespace StreamingIngestion;
class Program
{
    static async Task Main(string[] args)
    {
        var appId = "<appId>";
        var appKey = "<appKey>";
        var appTenant = "<appTenant>";
        var subscriptionId = "<subscriptionId>";
        var credentials = new ClientSecretCredential(appTenant, appId, appKey);
        var resourceManagementClient = new ArmClient(credentials, subscriptionId);
        var resourceGroupName = "<resourceGroupName>";
        var clusterName = "<clusterName>";
        
        var subscription = await resourceManagementClient.GetDefaultSubscriptionAsync();
        var resourceGroup = (await subscription.GetResourceGroupAsync(resourceGroupName)).Value;
        var clusters = resourceGroup.GetKustoClusters();
        
        var location = new AzureLocation("<location>");
        var skuName = new KustoSkuName("<skuName>");
        var skuTier = new KustoSkuTier("<skuTier>");
        var clusterData = new KustoClusterData(location, new KustoSku(skuName, skuTier)) { IsStreamingIngestEnabled = true };
        await clusters.CreateOrUpdateAsync(WaitUntil.Completed, clusterName, clusterData);
    }
}

Włączanie pozyskiwania danych przesyłanych strumieniowo w istniejącym klastrze

Jeśli masz istniejący klaster, możesz włączyć pozyskiwanie przesyłania strumieniowego przy użyciu witryny Azure Portal lub programowo w języku C#.

Portal

1. W witrynie Azure Portal przejdź do klastra usługi Azure Data Explorer.

2. W obszarze Ustawienia wybierz pozycję Konfiguracje.

3. W okienku Konfiguracje wybierz pozycję Włączone, aby włączyć pozyskiwanie przesyłania strumieniowego.

4. Wybierz pozycję Zapisz.

   

C#

Pozyskiwanie przesyłania strumieniowego można włączyć podczas aktualizowania istniejącego klastra usługi Azure Data Explorer.

using System.Threading.Tasks;
using Azure;
using Azure.Identity; // Required package Azure.Identity
using Azure.ResourceManager;
using Azure.ResourceManager.Kusto; // Required package Azure.ResourceManager.Kusto
using Azure.ResourceManager.Kusto.Models;
namespace StreamingIngestion;
class Program
{
    static async Task Main(string[] args)
    {
        var appId = "<appId>";
        var appKey = "<appKey>";
        var appTenant = "<appTenant>";
        var subscriptionId = "<subscriptionId>";
        var credentials = new ClientSecretCredential(appTenant, appId, appKey);
        var resourceManagementClient = new ArmClient(credentials, subscriptionId);
        var resourceGroupName = "<resourceGroupName>";
        var clusterName = "<clusterName>";
        var subscription = await resourceManagementClient.GetDefaultSubscriptionAsync();
        var resourceGroup = (await subscription.GetResourceGroupAsync(resourceGroupName)).Value;
        var cluster = (await resourceGroup.GetKustoClusterAsync(clusterName)).Value;
        var clusterPatch = new KustoClusterPatch(cluster.Data.Location) { IsStreamingIngestEnabled = true };
        await cluster.UpdateAsync(WaitUntil.Completed, clusterPatch);
    }
}

Tworzenie tabeli docelowej i definiowanie zasad

Utwórz tabelę do odbierania danych pozyskiwania przesyłania strumieniowego i zdefiniuj powiązane z nią zasady przy użyciu witryny Azure Portal lub programowo w języku C#.

Portal

1. W witrynie Azure Portal przejdź do klastra.

2. Wybierz kwerendę.

   

3. Aby utworzyć tabelę, która będzie odbierać dane za pośrednictwem pozyskiwania przesyłania strumieniowego, skopiuj następujące polecenie do okienka Zapytanie i wybierz pozycję Uruchom.

   .create table TestTable (TimeStamp: datetime, Name: string, Metric: int, Source:string)
   

   

4. Skopiuj jedno z następujących poleceń do okienka Zapytanie i wybierz pozycję Uruchom. Definiuje zasady pozyskiwania przesyłania strumieniowego w tabeli utworzonej lub w bazie danych zawierającej tabelę.

   Napiwek

   Zasady zdefiniowane na poziomie bazy danych mają zastosowanie do wszystkich istniejących i przyszłych tabel w bazie danych. Po włączeniu zasad na poziomie bazy danych nie ma potrzeby włączania jej dla każdej tabeli.

   • Aby zdefiniować zasady w utworzonej tabeli, użyj:

     .alter table TestTable policy streamingingestion enable
     

   • Aby zdefiniować zasady w bazie danych zawierającej utworzoną tabelę, użyj:

     .alter database StreamingTestDb policy streamingingestion enable
     

   

C#

using Kusto.Data; // Requires Package Microsoft.Azure.Kusto.Data
using Kusto.Data.Common;
using Kusto.Data.Net.Client;
namespace StreamingIngestion;
class Program
{
    static async Task Main(string[] args)
    {
        var clusterPath = "https://<clusterName>.<region>.kusto.windows.net";
        var appId = "<appId>";
        var appKey = "<appKey>";
        var appTenant = "<appTenant>";
        // Create Kusto connection string with App Authentication
        var connectionStringBuilder = new KustoConnectionStringBuilder(clusterPath)
            .WithAadApplicationKeyAuthentication(
                applicationClientId: appId,
                applicationKey: appKey,
                authority: appTenant
            );
        using var client = KustoClientFactory.CreateCslAdminProvider(connectionStringBuilder);
        
        var tableName = "<tableName>";
        var tableSchema = new TableSchema(
            tableName,
            new ColumnSchema[]
            {
                new("TimeStamp", "System.DateTime"),
                new("Name", "System.String"),
                new("Metric", "System.int"),
                new("Source", "System.String"),
            });
        var tableCreateCommand = CslCommandGenerator.GenerateTableCreateCommand(tableSchema);
        var tablePolicyAlterCommand = CslCommandGenerator.GenerateTableAlterStreamingIngestionPolicyCommand(tableName, isEnabled: true);
        
        await client.ExecuteControlCommandAsync(tableCreateCommand);
        await client.ExecuteControlCommandAsync(tablePolicyAlterCommand);
    }
}

Tworzenie aplikacji pozyskiwania przesyłania strumieniowego w celu pozyskiwania danych do klastra

Utwórz aplikację na potrzeby pozyskiwania danych do klastra przy użyciu preferowanego języka.

C#

using System.IO;
using System.Threading.Tasks;
using Kusto.Data; // Requires Package Microsoft.Azure.Kusto.Data
using Kusto.Data.Common;
using Kusto.Ingest; // Requires Package Microsoft.Azure.Kusto.Ingest
namespace StreamingIngestion;
class Program
{
    static async Task Main(string[] args)
    {
        var clusterPath = "https://<clusterName>.<region>.kusto.windows.net";
        var appId = "<appId>";
        var appKey = "<appKey>";
        var appTenant = "<appTenant>";
        // Create Kusto connection string with App Authentication
        var connectionStringBuilder = new KustoConnectionStringBuilder(clusterPath)
            .WithAadApplicationKeyAuthentication(
                applicationClientId: appId,
                applicationKey: appKey,
                authority: appTenant
            );
        // Create a disposable client that will execute the ingestion
        using var client = KustoIngestFactory.CreateStreamingIngestClient(connectionStringBuilder);
        // Ingest from a compressed file
        var fileStream = File.Open("MyFile.gz", FileMode.Open);
        // Initialize client properties
        var ingestionProperties = new KustoIngestionProperties(databaseName: "<databaseName>", tableName: "<tableName>");
        // Create source options
        var sourceOptions = new StreamSourceOptions { CompressionType = DataSourceCompressionType.gzip, };
        // Ingest from stream
        await client.IngestFromStreamAsync(fileStream, ingestionProperties, sourceOptions);
    }
}

Python

from azure.kusto.data import KustoConnectionStringBuilder, DataFormat
from azure.kusto.ingest import IngestionProperties, KustoStreamingIngestClient

clusterPath = "https://<clusterName>.<region>.kusto.windows.net"
appId = "<appId>"
appKey = "<appKey>"
appTenant = "<appTenant>"
dbName = "<dbName>"
tableName = "<tableName>"

csb = KustoConnectionStringBuilder.with_aad_application_key_authentication(
    clusterPath,
    appId,
    appKey,
    appTenant
)
client = KustoStreamingIngestClient(csb)

ingestionProperties = IngestionProperties(
    database=dbName,
    table=tableName,
    data_format=DataFormat.CSV
)

# Ingest from file
# Automatically detects gz format
client.ingest_from_file("MyFile.gz", ingestion_properties=ingestionProperties) 

Node.js

// Load modules using ES6 import statements:
import { DataFormat, IngestionProperties, StreamingIngestClient } from "azure-kusto-ingest";
import { KustoConnectionStringBuilder } from "azure-kusto-data";

// For earlier version, load modules using require statements:
// const IngestionProperties = require("azure-kusto-ingest").IngestionProperties;
// const KustoConnectionStringBuilder = require("azure-kusto-data").KustoConnectionStringBuilder;
// const {DataFormat} = require("azure-kusto-ingest").IngestionPropertiesEnums;
// const StreamingIngestClient = require("azure-kusto-ingest").StreamingIngestClient;

const clusterPath = "https://<clusterName>.<region>.kusto.windows.net";
const appId = "<appId>";
const appKey = "<appKey>";
const appTenant = "<appTenant>";
const dbName = "<dbName>";
const tableName = "<tableName>";
const mappingName = "<mappingName>"; // Required for JSON formatted files

const ingestionProperties = new IngestionProperties({
    database: dbName, // Your database
    table: tableName, // Your table
    format: DataFormat.JSON,
    ingestionMappingReference: mappingName
});

// Initialize client with engine endpoint
const client = new StreamingIngestClient(
    KustoConnectionStringBuilder.withAadApplicationKeyAuthentication(
        clusterPath,
        appId,
        appKey,
        appTenant
    ),
    ingestionProperties
);

// Automatically detects gz format
await client.ingestFromFile("MyFile.gz", ingestionProperties);

Przejdź

import (
    "context"
    "github.com/Azure/azure-kusto-go/kusto"
    "github.com/Azure/azure-kusto-go/kusto/ingest"
    "github.com/Azure/go-autorest/autorest/azure/auth"
)

func ingest() {
    clusterPath := "https://<clusterName>.<region>.kusto.windows.net"
    appId := "<appId>"
    appKey := "<appKey>"
    appTenant := "<appTenant>"
    dbName := "<dbName>"
    tableName := "<tableName>"
    mappingName := "<mappingName>" // Optional, can be nil

    // Creates a Kusto Authorizer using your client identity, secret, and tenant identity.
    // You may also uses other forms of authorization, see GoDoc > Authorization type.
    // auth package is: "github.com/Azure/go-autorest/autorest/azure/auth"
    authorizer := kusto.Authorization{
        Config: auth.NewClientCredentialsConfig(appId, appKey, appTenant),
    }

    // Create a client
    client, err := kusto.New(clusterPath, authorizer)
    if err != nil {
        panic("add error handling")
    }

    // Create an ingestion instance
    // Pass the client, the name of the database, and the name of table you wish to ingest into.
    in, err := ingest.New(client, dbName, tableName)
    if err != nil {
        panic("add error handling")
    }

    // Go currently only supports streaming from a byte array with a maximum size of 4 MB.
    jsonEncodedData := []byte("{\"a\":  1, \"b\":  10}\n{\"a\":  2, \"b\":  20}")

    // Ingestion from a stream commits blocks of fully formed data encodes (JSON, AVRO, ...) into Kusto:
    if err := in.Stream(context.Background(), jsonEncodedData, ingest.JSON, mappingName); err != nil {
        panic("add error handling")
    }
}

Java

import com.microsoft.azure.kusto.data.auth.ConnectionStringBuilder;
import com.microsoft.azure.kusto.ingest.IngestClient;
import com.microsoft.azure.kusto.ingest.IngestClientFactory;
import com.microsoft.azure.kusto.ingest.IngestionProperties;
import com.microsoft.azure.kusto.ingest.result.OperationStatus;
import com.microsoft.azure.kusto.ingest.source.CompressionType;
import com.microsoft.azure.kusto.ingest.source.StreamSourceInfo;
import java.io.FileInputStream;
import java.io.InputStream;

public class FileIngestion {
    public static void main(String[] args) throws Exception {
        String clusterPath = "https://<clusterName>.<region>.kusto.windows.net";
        String appId = "<appId>";
        String appKey = "<appKey>";
        String appTenant = "<appTenant>";
        String dbName = "<dbName>";
        String tableName = "<tableName>";

        // Build connection string and initialize
        ConnectionStringBuilder csb =
            ConnectionStringBuilder.createWithAadApplicationCredentials(
                clusterPath,
                appId,
                appKey,
                appTenant
            );

        // Initialize client and its properties
        IngestClient client = IngestClientFactory.createClient(csb);
        IngestionProperties ingestionProperties =
            new IngestionProperties(
                dbName,
                tableName
            );

        // Ingest from a compressed file
        // Create Source info
        InputStream zipInputStream = new FileInputStream("MyFile.gz");
        StreamSourceInfo zipStreamSourceInfo = new StreamSourceInfo(zipInputStream);
        // If the data is compressed
        zipStreamSourceInfo.setCompressionType(CompressionType.gz);
        // Ingest from stream
        OperationStatus status = client.ingestFromStream(zipStreamSourceInfo, ingestionProperties).getIngestionStatusCollection().get(0).status;
    }
}

Wyłączanie pozyskiwania przesyłania strumieniowego w klastrze

Ostrzeżenie

Wyłączenie pozyskiwania przesyłania strumieniowego może potrwać kilka godzin.

Przed wyłączeniem pozyskiwania przesyłania strumieniowego w klastrze usługi Azure Data Explorer usuń zasady pozyskiwania przesyłania strumieniowego ze wszystkich odpowiednich tabel i baz danych. Usunięcie zasad pozyskiwania przesyłania strumieniowego powoduje ponowne rozmieszczenie danych w klastrze usługi Azure Data Explorer. Dane pozyskiwania przesyłania strumieniowego są przenoszone z początkowego magazynu do magazynu trwałego w magazynie kolumn (zakresy lub fragmenty). Ten proces może potrwać od kilku sekund do kilku godzin, w zależności od ilości danych w początkowym magazynie.

Usuwanie zasad pozyskiwania przesyłania strumieniowego

Zasady pozyskiwania przesyłania strumieniowego można usunąć przy użyciu witryny Azure Portal lub programowo w języku C#.

Portal

1. W witrynie Azure Portal przejdź do klastra usługi Azure Data Explorer i wybierz pozycję Zapytanie.

2. Aby usunąć zasady pozyskiwania przesyłania strumieniowego z tabeli, skopiuj następujące polecenie do okienka Zapytanie i wybierz pozycję Uruchom.

   .delete table TestTable policy streamingingestion
   

   

3. W obszarze Ustawienia wybierz pozycję Konfiguracje.

4. W okienku Konfiguracje wybierz pozycję Wyłączone , aby wyłączyć pozyskiwanie przesyłania strumieniowego.

5. Wybierz pozycję Zapisz.

   

C#

Aby usunąć zasady pozyskiwania przesyłania strumieniowego z tabeli, uruchom następujący kod:

using System.Threading.Tasks;
using Kusto.Data; // Requires Package Microsoft.Azure.Kusto.Data
using Kusto.Data.Common;
using Kusto.Data.Net.Client;
namespace StreamingIngestion;
class Program
{
    static async Task Main(string[] args)
    {
        var clusterPath = "https://<clusterName>.<region>.kusto.windows.net";
        var appId = "<appId>";
        var appKey = "<appKey>";
        var appTenant = "<appTenant>";
        // Create Kusto connection string with App Authentication
        var connectionStringBuilder = new KustoConnectionStringBuilder(clusterPath)
            .WithAadApplicationKeyAuthentication(
                applicationClientId: appId,
                applicationKey: appKey,
                authority: appTenant
            );
        using var client = KustoClientFactory.CreateCslAdminProvider(connectionStringBuilder);
        var tablePolicyDropCommand = CslCommandGenerator.GenerateTableStreamingIngestionPolicyDropCommand("<dbName>", "<tableName>");
        await client.ExecuteControlCommandAsync(tablePolicyDropCommand);
    }
}

Aby wyłączyć pozyskiwanie przesyłania strumieniowego w klastrze, uruchom następujący kod:

using System.Threading.Tasks;
using Azure;
using Azure.Identity; // Required package Azure.Identity
using Azure.ResourceManager;
using Azure.ResourceManager.Kusto; // Required package Azure.ResourceManager.Kusto
using Azure.ResourceManager.Kusto.Models;
namespace StreamingIngestion;
class Program
{
    static async Task Main(string[] args)
    {
        var appId = "<appId>";
        var appKey = "<appKey>";
        var appTenant = "<appTenant>";
        var subscriptionId = "<subscriptionId>";
        var credentials = new ClientSecretCredential(appTenant, appId, appKey);
        var resourceManagementClient = new ArmClient(credentials, subscriptionId);
        var resourceGroupName = "<resourceGroupName>";
        var clusterName = "<clusterName>";
        var subscription = await resourceManagementClient.GetDefaultSubscriptionAsync();
        var resourceGroup = (await subscription.GetResourceGroupAsync(resourceGroupName)).Value;
        var cluster = (await resourceGroup.GetKustoClusterAsync(clusterName)).Value;
        var clusterPatch = new KustoClusterPatch(cluster.Data.Location) { IsStreamingIngestEnabled = false };
        await cluster.UpdateAsync(WaitUntil.Completed, clusterPatch);
    }
}

Ograniczenia

• Mapowania danych muszą zostać wstępnie utworzone do użycia w pozyskiwaniu danych przesyłanych strumieniowo. Pojedyncze żądania pozyskiwania przesyłania strumieniowego nie są uwzględniane w wbudowanych mapowaniach danych.
• Nie można ustawić tagów zakresu na danych pozyskiwania przesyłania strumieniowego.
• Zaktualizuj zasady. Zasady aktualizowania mogą odwoływać się tylko do nowo pozyskanych danych w tabeli źródłowej, a nie do jakichkolwiek innych danych lub tabel w bazie danych.
• Gdy zasady aktualizacji z zasadami transakcyjnymi nie powiedzą się, ponawianie prób powróci do pozyskiwania wsadowego.
• Jeśli pozyskiwanie przesyłania strumieniowego jest włączone w klastrze używanym jako lider w przypadku baz danych obserwowanych, pozyskiwanie strumieniowe musi być włączone w następujących klastrach, aby śledzić dane pozyskiwania strumieniowego. To samo dotyczy tego, czy dane klastra są udostępniane za pośrednictwem udziału danych.

Powiązana zawartość

• Wykonywanie zapytań o dane w usłudze Azure Data Explorer