Udostępnij za pośrednictwem

Powiązania wyjściowe usługi Azure Data Explorer dla usługi Azure Functions (wersja zapoznawcza)

  • Artykuł

Po uruchomieniu funkcji powiązanie wyjściowe usługi Azure Data Explorer pozyskuje dane z usługi Azure Data Explorer.

Aby uzyskać informacje na temat konfiguracji i konfiguracji, zobacz omówienie.

Przykłady

Funkcję języka C# można utworzyć przy użyciu jednego z następujących trybów języka C#:

  • Model izolowanego procesu roboczego: skompilowana funkcja języka C#, która jest uruchamiana w procesie roboczym izolowanym od środowiska uruchomieniowego. Proces izolowanego procesu roboczego jest wymagany do obsługi funkcji języka C# uruchomionych w wersjach LTS i innych niż LTS platformy .NET oraz programu .NET Framework.
  • Model przetwarzania: skompilowana funkcja języka C#, która działa w tym samym procesie co środowisko uruchomieniowe usługi Functions.
  • Skrypt języka C#: używany głównie podczas tworzenia funkcji języka C# w witrynie Azure Portal.

Ważne

Wsparcie zostanie zakończone dla modelu procesu 10 listopada 2026 r. Zdecydowanie zalecamy przeprowadzenie migracji aplikacji do izolowanego modelu procesu roboczego w celu uzyskania pełnej obsługi.

Więcej przykładów dla powiązania danych wyjściowych usługi Azure Data Explorer jest dostępnych w repozytorium GitHub.

Ta sekcja zawiera następujące przykłady:

Przykłady odnoszą się do Product klasy i odpowiedniej tabeli bazy danych:

public class Product
{
    [JsonProperty(nameof(ProductID))]
    public long ProductID { get; set; }

    [JsonProperty(nameof(Name))]
    public string Name { get; set; }

    [JsonProperty(nameof(Cost))]
    public double Cost { get; set; }
}

.create-merge table Products (ProductID:long, Name:string, Cost:double)

Wyzwalacz HTTP, zapis jednego rekordu

W poniższym przykładzie przedstawiono funkcję języka C#, która dodaje rekord do bazy danych. Funkcja używa danych podanych w żądaniu HTTP POST jako treści JSON.

using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Extensions.Kusto;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Azure.WebJobs.Extensions.Kusto.SamplesOutOfProc.OutputBindingSamples.Common;

namespace Microsoft.Azure.WebJobs.Extensions.Kusto.SamplesOutOfProc.OutputBindingSamples
{
    public static class AddProduct
    {
        [Function("AddProduct")]
        [KustoOutput(Database: "productsdb", Connection = "KustoConnectionString", TableName = "Products")]
        public static async Task<Product> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "addproductuni")]
            HttpRequestData req)
        {
            Product? prod = await req.ReadFromJsonAsync<Product>();
            return prod ?? new Product { };
        }
    }
}

Wyzwalacz HTTP, zapisywanie rekordów za pomocą mapowania

W poniższym przykładzie pokazano funkcję języka C#, która dodaje kolekcję rekordów do bazy danych. Funkcja używa mapowania, które przekształca element na Product Item.

Aby przekształcić dane z Product na Item, funkcja używa odwołania do mapowania:

.create-merge table Item (ItemID:long, ItemName:string, ItemCost:float)


-- Create a mapping that transforms an Item to a Product

.create-or-alter table Product ingestion json mapping "item_to_product_json" '[{"column":"ProductID","path":"$.ItemID"},{"column":"Name","path":"$.ItemName"},{"column":"Cost","path":"$.ItemCost"}]'

namespace Microsoft.Azure.WebJobs.Extensions.Kusto.SamplesOutOfProc.OutputBindingSamples.Common
{
    public class Item
    {
        public long ItemID { get; set; }

        public string? ItemName { get; set; }

        public double ItemCost { get; set; }
    }
}

using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Extensions.Kusto;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Azure.WebJobs.Extensions.Kusto.SamplesOutOfProc.OutputBindingSamples.Common;

namespace Microsoft.Azure.WebJobs.Extensions.Kusto.SamplesOutOfProc.OutputBindingSamples
{
    public static class AddProductsWithMapping
    {
        [Function("AddProductsWithMapping")]
        [KustoOutput(Database: "productsdb", Connection = "KustoConnectionString", TableName = "Products", MappingRef = "item_to_product_json")]
        public static async Task<Item> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "addproductswithmapping")]
            HttpRequestData req)
        {
            Item? item = await req.ReadFromJsonAsync<Item>();
            return item ?? new Item { };
        }
    }
}

Więcej przykładów dla powiązania wejściowego usługi Azure Data Explorer w języku Java jest dostępnych w repozytorium GitHub.

Ta sekcja zawiera następujące przykłady:

Przykłady odnoszą się do Products klasy (w osobnym pliku Product.java) i odpowiedniej tabeli Products bazy danych (zdefiniowanej wcześniej):

package com.microsoft.azure.kusto.common;

import com.fasterxml.jackson.annotation.JsonProperty;

public class Product {
    @JsonProperty("ProductID")
    public long ProductID;
    @JsonProperty("Name")
    public String Name;
    @JsonProperty("Cost")
    public double Cost;

    public Product() {
    }

    public Product(long ProductID, String name, double Cost) {
        this.ProductID = ProductID;
        this.Name = name;
        this.Cost = Cost;
    }
}

Wyzwalacz HTTP, zapisywanie rekordu w tabeli

W poniższym przykładzie pokazano powiązanie danych wyjściowych usługi Azure Data Explorer w funkcji Języka Java, która dodaje rekord produktu do tabeli. Funkcja używa danych podanych w żądaniu HTTP POST jako treści JSON. Funkcja przyjmuje kolejną zależność od biblioteki com.fasterxml.jackson.core , aby przeanalizować treść JSON.

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.4.1</version>
</dependency>

package com.microsoft.azure.kusto.outputbindings;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.microsoft.azure.functions.HttpMethod;
import com.microsoft.azure.functions.HttpRequestMessage;
import com.microsoft.azure.functions.HttpResponseMessage;
import com.microsoft.azure.functions.HttpStatus;
import com.microsoft.azure.functions.OutputBinding;
import com.microsoft.azure.functions.annotation.AuthorizationLevel;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.annotation.HttpTrigger;
import com.microsoft.azure.functions.kusto.annotation.KustoOutput;
import com.microsoft.azure.kusto.common.Product;

import java.io.IOException;
import java.util.Optional;

import static com.microsoft.azure.kusto.common.Constants.*;

public class AddProduct {
    @FunctionName("AddProduct")
    public HttpResponseMessage run(@HttpTrigger(name = "req", methods = {
            HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS, route = "addproductuni") HttpRequestMessage<Optional<String>> request,
            @KustoOutput(name = "product", database = "productsdb", tableName = "Products", connection = KUSTOCONNSTR) OutputBinding<Product> product)
            throws IOException {

        if (request.getBody().isPresent()) {
            String json = request.getBody().get();
            ObjectMapper mapper = new ObjectMapper();
            Product p = mapper.readValue(json, Product.class);
            product.setValue(p);
            return request.createResponseBuilder(HttpStatus.OK).header("Content-Type", "application/json").body(product)
                    .build();
        } else {
            return request.createResponseBuilder(HttpStatus.NO_CONTENT).header("Content-Type", "application/json")
                    .build();
        }
    }
}

Wyzwalacz HTTP, zapis w dwóch tabelach

W poniższym przykładzie przedstawiono powiązanie danych wyjściowych usługi Azure Data Explorer w funkcji Języka Java, która dodaje rekordy do bazy danych w dwóch różnych tabelach (Product i ProductChangeLog). Funkcja używa danych podanych w żądaniu HTTP POST jako treści JSON i wielu powiązań wyjściowych. Funkcja przyjmuje kolejną zależność od biblioteki com.fasterxml.jackson.core , aby przeanalizować treść JSON.

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.4.1</version>
</dependency>

Druga tabela ProductsChangeLogodpowiada następującej definicji:

.create-merge table ProductsChangeLog (ProductID:long, CreatedAt:datetime)

i java, klasa w :ProductsChangeLog.java

package com.microsoft.azure.kusto.common;

import com.fasterxml.jackson.annotation.JsonProperty;

public class ProductsChangeLog {
    @JsonProperty("ProductID")
    public long ProductID;
    @JsonProperty("CreatedAt")
    public String CreatedAt;

    public ProductsChangeLog() {
    }

    public ProductsChangeLog(long ProductID, String CreatedAt) {
        this.ProductID = ProductID;
        this.CreatedAt = CreatedAt;
    }
}

package com.microsoft.azure.kusto.outputbindings;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.microsoft.azure.functions.HttpMethod;
import com.microsoft.azure.functions.HttpRequestMessage;
import com.microsoft.azure.functions.HttpResponseMessage;
import com.microsoft.azure.functions.HttpStatus;
import com.microsoft.azure.functions.OutputBinding;
import com.microsoft.azure.functions.annotation.AuthorizationLevel;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.annotation.HttpTrigger;
import com.microsoft.azure.functions.kusto.annotation.KustoOutput;
import com.microsoft.azure.kusto.common.Product;
import com.microsoft.azure.kusto.common.ProductsChangeLog;

import static com.microsoft.azure.kusto.common.Constants.*;

import java.io.IOException;
import java.time.Clock;
import java.time.Instant;
import java.util.Optional;

public class AddMultiTable {
    @FunctionName("AddMultiTable")
    public HttpResponseMessage run(@HttpTrigger(name = "req", methods = {
            HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS, route = "addmultitable") HttpRequestMessage<Optional<String>> request,
            @KustoOutput(name = "product", database = "productsdb", tableName = "Products", connection = KUSTOCONNSTR) OutputBinding<Product> product,
            @KustoOutput(name = "productChangeLog", database = "productsdb", tableName = "ProductsChangeLog",
                    connection = KUSTOCONNSTR) OutputBinding<ProductsChangeLog> productChangeLog)
            throws IOException {

        if (request.getBody().isPresent()) {
            String json = request.getBody().get();
            ObjectMapper mapper = new ObjectMapper();
            Product p = mapper.readValue(json, Product.class);
            product.setValue(p);
            productChangeLog.setValue(new ProductsChangeLog(p.ProductID, Instant.now(Clock.systemUTC()).toString()));
            return request.createResponseBuilder(HttpStatus.OK).header("Content-Type", "application/json").body(product)
                    .build();
        } else {
            return request.createResponseBuilder(HttpStatus.NO_CONTENT).header("Content-Type", "application/json")
                    .build();
        }
    }
}

Więcej przykładów dla powiązania danych wyjściowych usługi Azure Data Explorer jest dostępnych w repozytorium GitHub.

Ta sekcja zawiera następujące przykłady:

Przykłady odnoszą się do tabeli bazy danych.

Przykłady odnoszą się do tabel Products i ProductsChangeLog (zdefiniowane wcześniej).

Wyzwalacz HTTP, zapisywanie rekordów w tabeli

W poniższym przykładzie pokazano powiązanie wyjściowe usługi Azure Data Explorer w pliku function.json i funkcję Języka JavaScript, która dodaje rekordy do tabeli. Funkcja używa danych podanych w żądaniu HTTP POST jako treści JSON.

Poniższy przykład to powiązanie danych w pliku function.json :

{
  "bindings": [
    {
      "authLevel": "function",
      "name": "req",
      "direction": "in",
      "type": "httpTrigger",
      "methods": [
        "post"
      ],
      "route": "addproduct"
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "product",
      "type": "kusto",
      "database": "productsdb",
      "direction": "out",
      "tableName": "Products",
      "connection": "KustoConnectionString"
    }
  ],
  "disabled": false
}

W sekcji konfiguracji opisano te właściwości.

Poniższy fragment kodu to przykładowy kod JavaScript:

// Insert the product, which will insert it into the Products table.
module.exports = async function (context, req) {
    // Note that this expects the body to be a JSON object or array of objects which have a property
    // matching each of the columns in the table to insert to.
    context.bindings.product = req.body;
    return {
        status: 201,
        body: req.body
    };
}

Wyzwalacz HTTP, zapis w dwóch tabelach

Poniższy przykład przedstawia powiązanie wyjściowe usługi Azure Data Explorer w pliku function.json i funkcję JavaScript, która dodaje rekordy do bazy danych w dwóch różnych tabelach (Products i ProductsChangeLog). Funkcja używa danych podanych w żądaniu HTTP POST jako treści JSON i wielu powiązań wyjściowych.

Druga tabela ProductsChangeLogodpowiada następującej definicji:

.create-merge table ProductsChangeLog (ProductID:long, CreatedAt:datetime)

Poniższy fragment kodu to powiązanie danych w pliku function.json :

{
  "bindings": [
    {
      "authLevel": "function",
      "name": "req",
      "direction": "in",
      "type": "httpTrigger",
      "methods": [
        "post"
      ],
      "route": "addmultitable"
    },
    {
      "name": "res",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "product",
      "type": "kusto",
      "database": "productsdb",
      "direction": "out",
      "tableName": "Products",
      "connection": "KustoConnectionString"
    },
    {
      "name": "productchangelog",
      "type": "kusto",
      "database": "productsdb",
      "direction": "out",
      "tableName": "ProductsChangeLog",
      "connection": "KustoConnectionString"
    }
  ],
  "disabled": false
}

W sekcji konfiguracji opisano te właściwości.

Poniższy fragment kodu to przykładowy kod JavaScript:

module.exports = async function (context, req) {
    context.log('JavaScript HTTP trigger and Kusto output binding function processed a request.');
    context.log(req.body);

    if (req.body) {
        var changeLog = {ProductID:req.body.ProductID, CreatedAt: new Date().toISOString()};
        context.bindings.product = req.body;
        context.bindings.productchangelog = changeLog;
        context.res = {
            body: req.body,
            mimetype: "application/json",
            status: 201
        }
    } else {
        context.res = {
            status: 400,
            body: "Error reading request body"
        }
    }
}

Więcej przykładów dla powiązania danych wyjściowych usługi Azure Data Explorer jest dostępnych w repozytorium GitHub.

Ta sekcja zawiera następujące przykłady:

Przykłady odnoszą się do tabel Products i ProductsChangeLog (zdefiniowane wcześniej).

Wyzwalacz HTTP, zapisywanie rekordów w tabeli

Poniższy przykład przedstawia powiązanie wyjściowe usługi Azure Data Explorer w pliku function.json i funkcję języka Python, która dodaje rekordy do tabeli. Funkcja używa danych podanych w żądaniu HTTP POST jako treści JSON.

Poniższy fragment kodu to powiązanie danych w pliku function.json :

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "Anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "post"
      ],
      "route": "addproductuni"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "name": "product",
      "type": "kusto",
      "database": "sdktestsdb",
      "direction": "out",
      "tableName": "Products",
      "connection": "KustoConnectionString"
    }
  ]
}

W sekcji konfiguracji opisano te właściwości.

Poniższy fragment kodu to przykładowy kod języka Python:

import azure.functions as func
from Common.product import Product


def main(req: func.HttpRequest, product: func.Out[str]) -> func.HttpResponse:
    body = str(req.get_body(),'UTF-8')
    product.set(body)
    return func.HttpResponse(
        body=body,
        status_code=201,
        mimetype="application/json"
    )

Wyzwalacz HTTP, zapis w dwóch tabelach

Poniższy przykład przedstawia powiązanie wyjściowe usługi Azure Data Explorer w pliku function.json i funkcję JavaScript, która dodaje rekordy do bazy danych w dwóch różnych tabelach (Products i ProductsChangeLog). Funkcja używa danych podanych w żądaniu HTTP POST jako treści JSON i wielu powiązań wyjściowych. Druga tabela ProductsChangeLogodpowiada następującej definicji:

.create-merge table ProductsChangeLog (ProductID:long, CreatedAt:datetime)

Poniższy fragment kodu to powiązanie danych w pliku function.json :

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "Anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "post"
      ],
      "route": "addmultitable"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "name": "product",
      "type": "kusto",
      "database": "sdktestsdb",
      "direction": "out",
      "tableName": "Products",
      "connection": "KustoConnectionString"
    },
    {
      "name": "productchangelog",
      "type": "kusto",
      "database": "sdktestsdb",
      "direction": "out",
      "tableName": "ProductsChangeLog",
      "connection": "KustoConnectionString"
    }
  ]
}

W sekcji konfiguracji opisano te właściwości.

Poniższy fragment kodu to przykładowy kod języka Python:

import json
from datetime import datetime

import azure.functions as func
from Common.product import Product


def main(req: func.HttpRequest, product: func.Out[str],productchangelog: func.Out[str]) -> func.HttpResponse:
    body = str(req.get_body(),'UTF-8')
    # parse x:
    product.set(body)
    id = json.loads(body)["ProductID"]

    changelog = {
        "ProductID": id,
        "CreatedAt": datetime.now().isoformat(),
    }
    productchangelog.set(json.dumps(changelog))
    return func.HttpResponse(
        body=body,
        status_code=201,
        mimetype="application/json"
    )

Atrybuty

Biblioteka języka C# używa atrybutu KustoAttribute do deklarowania powiązań usługi Azure Data Explorer w funkcji, która ma następujące właściwości.

Właściwość atrybutu opis
baza danych Wymagany. Baza danych, dla której należy wykonać zapytanie.
Connection Wymagany. Nazwa zmiennej zawierającej parametry połączenia, która jest rozpoznawana za pomocą zmiennych środowiskowych lub ustawień aplikacji funkcji. Wartości domyślne do wyszukania w zmiennej KustoConnectionString. W czasie wykonywania ta zmienna jest sprawdzana względem środowiska. Dokumentacja dotycząca parametry połączenia znajduje się w witrynie Kusto parametry połączenia s. Na przykład: "KustoConnectionString": "Data Source=https://your_cluster.kusto.windows.net;Database=your_Database;Fed=True;AppClientId=your_AppId;AppKey=your_AppKey;Authority Id=your_TenantId.
TableName Wymagany. Tabela do pozyskiwania danych.
MapowanieRef Opcjonalny. Atrybut umożliwiający przekazanie odwołania mapowania , który jest już zdefiniowany w klastrze.
ManagedServiceIdentity Opcjonalny. Tożsamość zarządzana może służyć do nawiązywania połączenia z usługą Azure Data Explorer. Aby użyć tożsamości zarządzanej systemu, użyj polecenia "system". Wszystkie inne nazwy tożsamości są interpretowane jako tożsamość zarządzana przez użytkownika.
DataFormat Opcjonalny. Domyślny format danych to multijson/json. Można go ustawić na formaty tekstowe obsługiwane w datasource wyliczenie formatu. Przykłady są weryfikowane i udostępniane dla formatów CSV i JSON.

Adnotacje

Biblioteka środowiska uruchomieniowego funkcji Języka Java używa @KustoInput adnotacji (com.microsoft.azure.functions.kusto.annotation.KustoOutput).

Element opis
name Wymagany. Nazwa zmiennej reprezentującej zapytanie powoduje wyświetlenie kodu funkcji.
database Wymagany. Baza danych, dla której należy wykonać zapytanie.
połączenie Wymagany. Nazwa zmiennej zawierającej parametry połączenia, która jest rozpoznawana za pomocą zmiennych środowiskowych lub ustawień aplikacji funkcji. Wartości domyślne do wyszukania w zmiennej KustoConnectionString. W czasie wykonywania ta zmienna jest sprawdzana względem środowiska. Dokumentacja dotycząca parametry połączenia znajduje się w witrynie Kusto parametry połączenia s. Na przykład: "KustoConnectionString": "Data Source=https://your_cluster.kusto.windows.net;Database=your_Database;Fed=True;AppClientId=your_AppId;AppKey=your_AppKey;Authority Id=your_TenantId.
tableName Wymagany. Tabela do pozyskiwania danych.
mappingRef Opcjonalny. Atrybut umożliwiający przekazanie odwołania mapowania , który jest już zdefiniowany w klastrze.
dataFormat Opcjonalny. Domyślny format danych to multijson/json. Można go ustawić na formaty tekstowe obsługiwane w datasource wyliczenie formatu. Przykłady są weryfikowane i udostępniane dla formatów CSV i JSON.
managedServiceIdentity Tożsamość zarządzana może służyć do nawiązywania połączenia z usługą Azure Data Explorer. Aby użyć tożsamości zarządzanej systemu, użyj polecenia "system". Wszystkie inne nazwy tożsamości są interpretowane jako tożsamość zarządzana przez użytkownika.

Konfigurowanie

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json .

właściwość function.json opis
type Wymagany. Musi być ustawiona wartość kusto.
kierunek Wymagany. Musi być ustawiona wartość out.
name Wymagany. Nazwa zmiennej reprezentującej zapytanie powoduje wyświetlenie kodu funkcji.
database Wymagany. Baza danych, dla której należy wykonać zapytanie.
połączenie Wymagany. Nazwa zmiennej, która zawiera parametry połączenia, rozpoznawana za pomocą zmiennych środowiskowych lub ustawień aplikacji funkcji. Wartości domyślne do wyszukania w zmiennej KustoConnectionString. W czasie wykonywania ta zmienna jest sprawdzana względem środowiska. Dokumentacja dotycząca parametry połączenia znajduje się w witrynie Kusto parametry połączenia s. Na przykład: "KustoConnectionString": "Data Source=https://your_cluster.kusto.windows.net;Database=your_Database;Fed=True;AppClientId=your_AppId;AppKey=your_AppKey;Authority Id=your_TenantId.
tableName Wymagany. Tabela do pozyskiwania danych.
mappingRef Opcjonalny. Atrybut umożliwiający przekazanie odwołania mapowania , który jest już zdefiniowany w klastrze.
dataFormat Opcjonalny. Domyślny format danych to multijson/json. Można go ustawić na formaty tekstowe obsługiwane w datasource wyliczenie formatu. Przykłady są weryfikowane i udostępniane dla formatów CSV i JSON.
managedServiceIdentity Tożsamość zarządzana może służyć do nawiązywania połączenia z usługą Azure Data Explorer. Aby użyć tożsamości zarządzanej systemu, użyj polecenia "system". Wszystkie inne nazwy tożsamości są interpretowane jako tożsamość zarządzana przez użytkownika.

Podczas tworzenia aplikacji lokalnie dodaj ustawienia aplikacji w pliku local.settings.json w kolekcji Values .

Użycie

Konstruktor atrybutu przyjmuje bazę danych i atrybuty TableName, MappingRefi DataFormat nazwę ustawienia połączenia. Polecenie KQL może być instrukcją KQL lub funkcją KQL. Nazwa ustawienia parametry połączenia odpowiada ustawieniu aplikacji (w local.settings.json programie na potrzeby programowania lokalnego), które zawiera parametry połączenia Kusto. Na przykład:"KustoConnectionString": "Data Source=https://your_cluster.kusto.windows.net;Database=your_Database;Fed=True;AppClientId=your_AppId;AppKey=your_AppKey;Authority Id=your_TenantId. Zapytania wykonywane przez powiązanie wejściowe są sparametryzowane. Wartości podane w parametrach KQL są używane w czasie wykonywania.

Następne kroki

Odczytywanie danych z tabeli (powiązanie wejściowe)