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

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.

Model izolowanego procesu roboczego

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:

• Wyzwalacz HTTP, zapis jednego rekordu
• Wyzwalacz HTTP, zapisywanie rekordów za pomocą mapowania

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 ProductItem.

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 { };
        }
    }
}

Model w procesie

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:

• Wyzwalacz HTTP, zapis jednego rekordu
• Wyzwalacz HTTP, zapis w dwóch tabelach
• Wyzwalacz HTTP, zapisywanie rekordów przy użyciu funkcji IAsyncCollector

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 System.Globalization;
using System.IO;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Azure.WebJobs.Extensions.Kusto.Samples.Common;
using Microsoft.Azure.WebJobs.Kusto;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace Microsoft.Azure.WebJobs.Extensions.Kusto.Samples.OutputBindingSamples
{
    public static class AddProduct
    {
        [FunctionName("AddProductUni")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "addproductuni")]
            HttpRequest req, ILogger log,
            [Kusto(Database:"productsdb" ,
            TableName ="Products" ,
            Connection = "KustoConnectionString")] out Product product)
        {
            log.LogInformation($"AddProduct function started");
            string body = new StreamReader(req.Body).ReadToEnd();
            product = JsonConvert.DeserializeObject<Product>(body);
            return new CreatedResult($"/api/addproductuni", product);
        }
    }
}

Wyzwalacz HTTP, zapis w dwóch tabelach

W poniższym przykładzie pokazano funkcję języka C#, 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.

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

using System;
using Newtonsoft.Json;

namespace Microsoft.Azure.WebJobs.Extensions.Kusto.Samples.Common
{
    public class ProductsChangeLog
    {
        [JsonProperty(nameof(ProductID))]
        public long ProductID { get; set; }

        [JsonProperty(nameof(CreatedAt))]
        public DateTime CreatedAt { get; set; }

    }
}

using System;
using System.IO;
using Kusto.Cloud.Platform.Utils;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Azure.WebJobs.Extensions.Kusto.Samples.Common;
using Microsoft.Azure.WebJobs.Kusto;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace Microsoft.Azure.WebJobs.Extensions.Kusto.Samples.OutputBindingSamples
{
    public static class AddMultiTable
    {
        [FunctionName("AddMultiTable")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "addmulti")]
            HttpRequest req, ILogger log,
            [Kusto(Database:"productsdb" ,
            TableName ="Products" ,
            Connection = "KustoConnectionString")] IAsyncCollector<Product> productsCollector,
                        [Kusto(Database:"productsdb" ,
            TableName =S"ProductsChangeLog" ,
            Connection = "KustoConnectionString")] IAsyncCollector<ProductsChangeLog> changeCollector)
        {
            log.LogInformation($"AddProducts function started");
            string body = new StreamReader(req.Body).ReadToEnd();
            Product[] products = JsonConvert.DeserializeObject<Product[]>(body);
            products.ForEach(p =>
            {
                productsCollector.AddAsync(p);
                changeCollector.AddAsync(new ProductsChangeLog { CreatedAt = DateTime.UtcNow, ProductID = p.ProductID });
            });
            productsCollector.FlushAsync();
            changeCollector.FlushAsync();
            return products != null ? new ObjectResult(products) { StatusCode = StatusCodes.Status201Created } : new BadRequestObjectResult("Please pass a well formed JSON Product array in the body");
        }
    }
}

Wyzwalacz HTTP, zapisywanie rekordów przy użyciu funkcji IAsyncCollector

W poniższym przykładzie pokazano funkcję języka C#, która pozyskuje zestaw rekordów do tabeli. Funkcja używa danych podanych w tablicy JSON treści HTTP POST.

using System.IO;
using Kusto.Cloud.Platform.Utils;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Azure.WebJobs.Extensions.Kusto.Samples.Common;
using Microsoft.Azure.WebJobs.Kusto;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace Microsoft.Azure.WebJobs.Extensions.Kusto.Samples.OutputBindingSamples
{
    public static class AddProductsAsyncCollector
    {
        [FunctionName("AddProductsAsyncCollector")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "addproductsasynccollector")]
            HttpRequest req, ILogger log,
            [Kusto(Database:"productsdb" ,
            TableName ="Products" ,
            Connection = "KustoConnectionString")] IAsyncCollector<Product> collector)
        {
            log.LogInformation($"AddProductsAsyncCollector function started");
            string body = new StreamReader(req.Body).ReadToEnd();
            Product[] products = JsonConvert.DeserializeObject<Product[]>(body);
            products.ForEach(p =>
            {
                collector.AddAsync(p);
            });
            collector.FlushAsync();
            return products != null ? new ObjectResult(products) { StatusCode = StatusCodes.Status201Created } : new BadRequestObjectResult("Please pass a well formed JSON Product array in the body");
        }
    }
}

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:

• Wyzwalacz HTTP, zapisywanie rekordu w tabeli
• Wyzwalacz HTTP, zapis w dwóch tabelach

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:

• Wyzwalacz HTTP, zapisywanie rekordów w tabeli
• Wyzwalacz HTTP, zapis w dwóch tabelach

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:

• Wyzwalacz HTTP, zapisywanie rekordów w tabeli
• Wyzwalacz HTTP, zapis w dwóch tabelach

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)