Azure Data Explorer-Ausgabebindungen für Azure Functions (Vorschau)

Wenn eine Funktion ausgeführt wird, erfasst die Azure Data Explorer-Ausgabebindung Daten in Azure Data Explorer.

Informationen zu Setup- und Konfigurationsdetails finden Sie in der Übersicht.

Beispiele

Eine C#-Funktion kann mit einem der folgenden C#-Modi erstellt werden:

• Isoliertes Workermodell: Kompilierte C#-Funktion, die in einem Workerprozess ausgeführt wird, der von der Runtime isoliert ist. Ein isolierter Workerprozess ist erforderlich, um C#-Funktionen zu unterstützen, die in LTS- und Nicht-LTS-Versionen von .NET und .NET Framework ausgeführt werden.
• In-Process-Modell: Kompilierte C#-Funktion, die im gleichen Prozess wie die Functions-Runtime ausgeführt wird.
• C#-Skript: Wird hauptsächlich beim Erstellen von C#-Funktionen im Azure-Portal verwendet.

Wichtig

Die Unterstützung für das In-Process-Modell endet am 10. November 2026. Es wird dringend empfohlen, Ihre Apps zum isolierten Workermodell zu migrieren, um den vollständigen Support zu ermöglichen.

Isoliertes Workermodell

Weitere Beispiele für die Azure Data Explorer-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

• HTTP-Trigger: Schreiben eines Datensatzes
• HTTP-Trigger, Schreiben von Datensätzen mit Zuordnung

Die Beispiele beziehen sich auf eine Product-Klasse und eine entsprechende Datenbanktabelle:

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)

HTTP-Trigger: Schreiben eines Datensatzes

Das folgende Beispiel zeigt eine C#-Funktion, die einer Datenbank einen Datensatz hinzufügt. Die Funktion verwendet Daten, die in einer HTTP POST-Anforderung als JSON-Text bereitgestellt werden.

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

HTTP-Trigger, Schreiben von Datensätzen mit Zuordnung

Das folgende Beispiel zeigt eine C#-Funktion, die einer Datenbank eine Sammlung von Datensätzen hinzufügt. Die Funktion verwendet eine Zuordnung, die ein Product in ein Item transformiert.

Zum Transformieren von Daten von Product in Item verwendet die Funktion einen Zuordnungsverweis:

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

In-Process-Modell

Weitere Beispiele für die Azure Data Explorer-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

• HTTP-Trigger: Schreiben eines Datensatzes
• HTTP-Trigger: Schreiben in zwei Tabellen
• HTTP-Trigger: Schreiben von Datensätzen mit IAsyncCollector

Die Beispiele beziehen sich auf eine Product-Klasse und eine entsprechende Datenbanktabelle:

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)

HTTP-Trigger: Schreiben eines Datensatzes

Das folgende Beispiel zeigt eine C#-Funktion, die einer Datenbank einen Datensatz hinzufügt. Die Funktion verwendet Daten, die in einer HTTP POST-Anforderung als JSON-Text bereitgestellt werden.

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

HTTP-Trigger: Schreiben in zwei Tabellen

Das folgende Beispiel zeigt eine C#-Funktion, die einer Datenbank Datensätze in zwei verschiedenen Tabellen (Products und ProductsChangeLog) hinzufügt. Die Funktion verwendet Daten, die in einer HTTP POST-Anforderung als JSON-Text und mehrere Ausgabebindungen bereitgestellt werden.

.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");
        }
    }
}

HTTP-Trigger: Schreiben von Datensätzen mit IAsyncCollector

Das folgende Beispiel zeigt eine C#-Funktion, die eine Reihe von Datensätzen in einer Tabelle erfasst. Die Funktion verwendet Daten, die in einem JSON-Array des HTTP POST-Texts bereitgestellt werden.

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

Weitere Beispiele für die Java Azure Data Explorer-Eingabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

• HTTP-Trigger: Schreiben eines Datensatzes in eine Tabelle
• HTTP-Trigger: Schreiben in zwei Tabellen

Die Beispiele beziehen sich auf eine Products-Klasse (in einer getrennten Datei Product.java) und eine entsprechende Datenbanktabelle Products (zuvor definiert):

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

HTTP-Trigger: Schreiben eines Datensatzes in eine Tabelle

Das folgende Beispiel zeigt eine Azure Data Explorer-Ausgabebindung in einer Java-Funktion, die einen Produktdatensatz einer Tabelle hinzufügt. Die Funktion verwendet Daten, die in einer HTTP POST-Anforderung als JSON-Text bereitgestellt werden. Die Funktion benötigt eine weitere Abhängigkeit von der Bibliothek com.fasterxml.jackson.core zum Parsen des JSON-Textkörpers.

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

HTTP-Trigger: Schreiben in zwei Tabellen

Das folgende Beispiel zeigt eine Azure Data Explorer-Ausgabebindung in einer Java-Funktion, die einer Datenbank in zwei verschiedenen Tabellen (Product und ProductChangeLog) Datensätze hinzufügt. Die Funktion verwendet Daten, die in einer HTTP POST-Anforderung als JSON-Text und mehrere Ausgabebindungen bereitgestellt werden. Die Funktion benötigt eine weitere Abhängigkeit von der Bibliothek com.fasterxml.jackson.core zum Parsen des JSON-Textkörpers.

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

Die zweite Tabelle, ProductsChangeLog, entspricht der folgenden Definition:

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

und Java-Klasse in 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();
        }
    }
}

Weitere Beispiele für die Azure Data Explorer-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

• HTTP-Trigger: Schreiben von Datensätzen in eine Tabelle
• HTTP-Trigger: Schreiben in zwei Tabellen

Die Beispiele beziehen sich auf eine Datenbanktabelle.

Die Beispiele beziehen sich auf die Tabellen Products und ProductsChangeLog (die zuvor definiert wurden).

HTTP-Trigger: Schreiben von Datensätzen in eine Tabelle

Das folgende Beispiel zeigt eine Azure Data Explorer-Ausgabebindung in einer Datei function.json und eine JavaScript-Funktion, die einer Tabelle Datensätze hinzufügt. Die Funktion verwendet Daten, die in einer HTTP POST-Anforderung als JSON-Text bereitgestellt werden.

Das folgende Beispiel bindet Daten in der Datei 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
}

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.

Der folgende Codeschnipsel zeigt JavaScript-Beispielcode:

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

HTTP-Trigger: Schreiben in zwei Tabellen

Das folgende Beispiel zeigt eine Azure Data Explorer-Ausgabebindung in einer Datei function.json und eine JavaScript-Funktion, die einer Datenbank in zwei verschiedenen Tabellen (Products und ProductsChangeLog) Datensätze hinzufügt. Die Funktion verwendet Daten, die in einer HTTP POST-Anforderung als JSON-Text und mehrere Ausgabebindungen bereitgestellt werden.

Die zweite Tabelle, ProductsChangeLog, entspricht der folgenden Definition:

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

Der folgende Codeschnipsel bindet Daten in der Datei 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
}

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.

Der folgende Codeschnipsel zeigt JavaScript-Beispielcode:

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"
        }
    }
}

Weitere Beispiele für die Azure Data Explorer-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

• HTTP-Trigger: Schreiben von Datensätzen in eine Tabelle
• HTTP-Trigger: Schreiben in zwei Tabellen

Die Beispiele beziehen sich auf die Tabellen Products und ProductsChangeLog (die zuvor definiert wurden).

HTTP-Trigger: Schreiben von Datensätzen in eine Tabelle

Das folgende Beispiel zeigt eine Azure Data Explorer-Ausgabebindung in einer Datei function.json und eine Python-Funktion, die einer Tabelle Datensätze hinzufügt. Die Funktion verwendet Daten, die in einer HTTP POST-Anforderung als JSON-Text bereitgestellt werden.

Der folgende Codeschnipsel bindet Daten in der Datei 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"
    }
  ]
}

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.

Der folgende Codeschnipsel zeigt Python-Beispielcode:

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

HTTP-Trigger: Schreiben in zwei Tabellen

Das folgende Beispiel zeigt eine Azure Data Explorer-Ausgabebindung in einer Datei function.json und eine JavaScript-Funktion, die einer Datenbank in zwei verschiedenen Tabellen (Products und ProductsChangeLog) Datensätze hinzufügt. Die Funktion verwendet Daten, die in einer HTTP POST-Anforderung als JSON-Text und mehrere Ausgabebindungen bereitgestellt werden. Die zweite Tabelle, ProductsChangeLog, entspricht der folgenden Definition:

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

Der folgende Codeschnipsel bindet Daten in der Datei 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"
    }
  ]
}

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.

Der folgende Codeschnipsel zeigt Python-Beispielcode:

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

Attribute

Die C#-Bibliothek verwendet das Attribut KustoAttribute, um die Azure Data Explorer-Bindungen für die Funktion zu deklarieren, die die folgenden Eigenschaften aufweist.

Attributeigenschaft	BESCHREIBUNG
Datenbank	Erforderlich. Die Datenbank, für die die Abfrage ausgeführt werden muss.
Verbindung	Erforderlich. Der Name der Variablen, die die Verbindungszeichenfolge enthält, die durch Umgebungsvariablen oder über Funktions-App-Einstellungen aufgelöst wird. Standardmäßig wird nach der Variablen KustoConnectionString gesucht. Zur Laufzeit wird diese Variable anhand der Umgebung gesucht. Dokumentation zur Verbindungszeichenfolge finden Sie unter Kusto-Verbindungszeichenfolgen. Beispiel: "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	Erforderlich. Die Tabelle, in der die Daten erfasst werden sollen.
MappingRef	Optional. Attribut zum Übergeben eines im Cluster bereits definierten Zuordnungsverweises.
ManagedServiceIdentity	Optional. Eine verwaltete Identität kann verwendet werden, um eine Verbindung mit Azure Data Explorer herzustellen. Wenn Sie eine systemseitig verwaltete Identität verwenden möchten, verwenden Sie „System“. Alle anderen Identitätsnamen werden als benutzerseitig verwaltete Identität interpretiert.
DataFormat	Optional. Als Standarddatenformat wird multijson/json verwendet. Dies kann auf Textformate festgelegt werden, die im datasource-Format Enumeration unterstützt werden. Die Beispiele werden überprüft und für CSV- und JSON-Formate bereitgestellt.

Anmerkungen

Die Java-Funktionslaufzeitbibliothek verwendet die @KustoInput-Anmerkung (com.microsoft.azure.functions.kusto.annotation.KustoOutput).

Element	BESCHREIBUNG
name	Erforderlich. Der Name der Variablen, die die Abfrageergebnisse im Funktionscode darstellt.
database	Erforderlich. Die Datenbank, für die die Abfrage ausgeführt werden muss.
connection	Erforderlich. Der Name der Variablen, die die Verbindungszeichenfolge enthält, die durch Umgebungsvariablen oder über Funktions-App-Einstellungen aufgelöst wird. Standardmäßig wird nach der Variablen KustoConnectionString gesucht. Zur Laufzeit wird diese Variable anhand der Umgebung gesucht. Dokumentation zur Verbindungszeichenfolge finden Sie unter Kusto-Verbindungszeichenfolgen. Beispiel: "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	Erforderlich. Die Tabelle, in der die Daten erfasst werden sollen.
mappingRef	Optional. Attribut zum Übergeben eines im Cluster bereits definierten Zuordnungsverweises.
dataFormat	Optional. Als Standarddatenformat wird multijson/json verwendet. Dies kann auf Textformate festgelegt werden, die im datasource-Format Enumeration unterstützt werden. Die Beispiele werden überprüft und für CSV- und JSON-Formate bereitgestellt.
managedServiceIdentity	Eine verwaltete Identität kann verwendet werden, um eine Verbindung mit Azure Data Explorer herzustellen. Wenn Sie eine systemseitig verwaltete Identität verwenden möchten, verwenden Sie „System“. Alle anderen Identitätsnamen werden als benutzerseitig verwaltete Identität interpretiert.

Konfiguration

Die folgende Tabelle gibt Aufschluss über die Bindungskonfigurationseigenschaften, die Sie in der Datei function.json festlegen.

function.json-Eigenschaft	BESCHREIBUNG
type	Erforderlich. Muss auf kusto festgelegt sein.
direction	Erforderlich. Muss auf out festgelegt sein.
name	Erforderlich. Der Name der Variablen, die die Abfrageergebnisse im Funktionscode darstellt.
database	Erforderlich. Die Datenbank, für die die Abfrage ausgeführt werden muss.
connection	Erforderlich. Der Name der Variablen, die die Verbindungszeichenfolge enthält, aufgelöst durch Umgebungsvariablen oder über Funktions-App-Einstellungen. Standardmäßig wird nach der Variablen KustoConnectionString gesucht. Zur Laufzeit wird diese Variable anhand der Umgebung gesucht. Dokumentation zur Verbindungszeichenfolge finden Sie unter Kusto-Verbindungszeichenfolgen. Beispiel: "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	Erforderlich. Die Tabelle, in der die Daten erfasst werden sollen.
mappingRef	Optional. Attribut zum Übergeben eines im Cluster bereits definierten Zuordnungsverweises.
dataFormat	Optional. Als Standarddatenformat wird multijson/json verwendet. Dies kann auf Textformate festgelegt werden, die im datasource-Format Enumeration unterstützt werden. Die Beispiele werden überprüft und für CSV- und JSON-Formate bereitgestellt.
managedServiceIdentity	Eine verwaltete Identität kann verwendet werden, um eine Verbindung mit Azure Data Explorer herzustellen. Wenn Sie eine systemseitig verwaltete Identität verwenden möchten, verwenden Sie „System“. Alle anderen Identitätsnamen werden als benutzerseitig verwaltete Identität interpretiert.

Wenn Sie die Entwicklung lokal ausführen, fügen Sie Ihre Anwendungseinstellungen in der Datei local.settings.json in der Values-Sammlung hinzu.

Verbrauch

Der Konstruktor des Attributs nimmt die Datenbank und die Attribute TableName, MappingRef und DataFormat sowie den Namen der Verbindungseinstellung an. Der KQL-Befehl kann eine KQL-Anweisung oder eine KQL-Funktion sein. Der Name der Verbindungszeichenfolgeneinstellung entspricht der Anwendungseinstellung (in local.settings.json für lokale Entwicklung), die die Kusto-Verbindungszeichenfolgen enthält. Beispiel: "KustoConnectionString": "Data Source=https://your_cluster.kusto.windows.net;Database=your_Database;Fed=True;AppClientId=your_AppId;AppKey=your_AppKey;Authority Id=your_TenantId. Abfragen, die von der Eingabebindung ausgeführt werden, werden parametrisiert. Die in den KQL-Parametern angegebenen Werte werden zur Laufzeit verwendet.

Nächste Schritte

Lesen von Daten aus einer Tabelle (Eingabebindung)