Utdatabindningar för Azure Data Explorer för Azure Functions (förhandsversion)

  • Artikel

När en funktion körs matar Azure Data Explorer-utdatabindningen in data till Azure Data Explorer.

Information om konfiguration och konfigurationsinformation finns i översikten.

Exempel

En C#-funktion kan skapas med något av följande C#-lägen:

  • Isolerad arbetsmodell: Kompilerad C#-funktion som körs i en arbetsprocess som är isolerad från körningen. Isolerad arbetsprocess krävs för att stödja C#-funktioner som körs på LTS- och icke-LTS-versioner .NET och .NET Framework.
  • Processmodell: Kompilerad C#-funktion som körs i samma process som Functions-körningen.
  • C#-skript: Används främst när du skapar C#-funktioner i Azure-portalen.

Viktigt!

Supporten upphör för den pågående modellen den 10 november 2026. Vi rekommenderar starkt att du migrerar dina appar till den isolerade arbetsmodellen för fullt stöd.

Fler exempel för Azure Data Explorer-utdatabindningen finns på GitHub-lagringsplatsen.

Det här avsnittet innehåller följande exempel:

Exemplen refererar till Product klassen och en motsvarande databastabell:

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-utlösare, skriv en post

I följande exempel visas en C#-funktion som lägger till en post i en databas. Funktionen använder data som tillhandahålls i en HTTP POST-begäran som en JSON-brödtext.

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-utlösare, skriva poster med mappning

I följande exempel visas en C#-funktion som lägger till en samling poster i en databas. Funktionen använder mappning som transformerar en Product till Item.

För att transformera data från Product till Itemanvänder funktionen en mappningsreferens:

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

Fler exempel för Java Azure Data Explorer-indatabindningen finns på GitHub-lagringsplatsen.

Det här avsnittet innehåller följande exempel:

Exemplen refererar till en Products klass (i en separat fil Product.java) och en motsvarande databastabell Products (definierad tidigare):

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-utlösare, skriva en post till en tabell

I följande exempel visas en Azure Data Explorer-utdatabindning i en Java-funktion som lägger till en produktpost i en tabell. Funktionen använder data som tillhandahålls i en HTTP POST-begäran som en JSON-brödtext. Funktionen tar ett annat beroende av com.fasterxml.jackson.core-biblioteket för att parsa JSON-brödtexten.

<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-utlösare, skriv till två tabeller

I följande exempel visas en Azure Data Explorer-utdatabindning i en Java-funktion som lägger till poster i en databas i två olika tabeller (Product och ProductChangeLog). Funktionen använder data som tillhandahålls i en HTTP POST-begäran som en JSON-brödtext och flera utdatabindningar. Funktionen tar ett annat beroende av com.fasterxml.jackson.core-biblioteket för att parsa JSON-brödtexten.

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

Den andra tabellen, ProductsChangeLog, motsvarar följande definition:

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

och Java-klass i 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();
        }
    }
}

Fler exempel för Azure Data Explorer-utdatabindningen finns på GitHub-lagringsplatsen.

Det här avsnittet innehåller följande exempel:

Exemplen refererar till en databastabell.

Exemplen refererar till tabellerna Products och ProductsChangeLog (definierades tidigare).

HTTP-utlösare, skriva poster till en tabell

I följande exempel visas en Azure Data Explorer-utdatabindning i en function.json-fil och en JavaScript-funktion som lägger till poster i en tabell. Funktionen använder data som tillhandahålls i en HTTP POST-begäran som en JSON-brödtext.

Följande exempel är bindning av data i filen 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
}

I konfigurationsavsnittet förklaras dessa egenskaper.

Följande kodfragment är JavaScript-exempelkod:

// 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-utlösare, skriv till två tabeller

I följande exempel visas en Azure Data Explorer-utdatabindning i en function.json-fil och en JavaScript-funktion som lägger till poster i en databas i två olika tabeller (Products och ProductsChangeLog). Funktionen använder data som tillhandahålls i en HTTP POST-begäran som en JSON-brödtext och flera utdatabindningar.

Den andra tabellen, ProductsChangeLog, motsvarar följande definition:

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

Följande kodfragment är bindningsdata i function.json-filen:

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

I konfigurationsavsnittet förklaras dessa egenskaper.

Följande kodfragment är JavaScript-exempelkod:

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

Fler exempel för Azure Data Explorer-utdatabindningen finns på GitHub-lagringsplatsen.

Det här avsnittet innehåller följande exempel:

Exemplen refererar till tabellerna Products och ProductsChangeLog (definierades tidigare).

HTTP-utlösare, skriva poster till en tabell

I följande exempel visas en Azure Data Explorer-utdatabindning i en function.json-fil och en Python-funktion som lägger till poster i en tabell. Funktionen använder data som tillhandahålls i en HTTP POST-begäran som en JSON-brödtext.

Följande kodfragment är bindningsdata i function.json-filen:

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

I konfigurationsavsnittet förklaras dessa egenskaper.

Följande kodfragment är python-exempelkod:

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-utlösare, skriv till två tabeller

I följande exempel visas en Azure Data Explorer-utdatabindning i en function.json-fil och en JavaScript-funktion som lägger till poster i en databas i två olika tabeller (Products och ProductsChangeLog). Funktionen använder data som tillhandahålls i en HTTP POST-begäran som en JSON-brödtext och flera utdatabindningar. Den andra tabellen, ProductsChangeLog, motsvarar följande definition:

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

Följande kodfragment är bindningsdata i function.json-filen:

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

I konfigurationsavsnittet förklaras dessa egenskaper.

Följande kodfragment är python-exempelkod:

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

Attribut

C#-biblioteket använder attributet KustoAttribute för att deklarera Azure Data Explorer-bindningar för funktionen, som har följande egenskaper.

Attributegenskap beskrivning
Databas Obligatoriskt. Databasen som frågan måste köras mot.
Connection Obligatoriskt. Namnet på variabeln som innehåller anslutningssträng, som matchas via miljövariabler eller via funktionsappinställningar. Standardvärden för att söka efter variabeln KustoConnectionString. Vid körningen granskas den här variabeln mot miljön. Dokumentation om anslutningssträng finns på Kusto anslutningssträng s. Exempel: "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 Obligatoriskt. Tabellen som data ska matas in i.
MappingRef Valfritt. Attribut för att skicka en mappnings ref som redan har definierats i klustret.
ManagedServiceIdentity Valfritt. En hanterad identitet kan användas för att ansluta till Azure Data Explorer. Om du vill använda en systemhanterad identitet använder du "system". Andra identitetsnamn tolkas som en användarhanterad identitet.
DataFormat Valfritt. Standarddataformatet är multijson/json. Den kan ställas in på textformat som stöds i datasource formatuppräkningen. Exempel verifieras och tillhandahålls för CSV- och JSON-format.

Kommentarer

Java Functions-körningsbiblioteket använder anteckningen @KustoInput (com.microsoft.azure.functions.kusto.annotation.KustoOutput).

Element Description
name Obligatoriska. Namnet på variabeln som representerar frågan resulterar i funktionskod.
database Obligatoriskt. Databasen som frågan måste köras mot.
anslutning Obligatoriskt. Namnet på variabeln som innehåller anslutningssträng, som matchas via miljövariabler eller via funktionsappinställningar. Standardvärden för att söka efter variabeln KustoConnectionString. Vid körningen granskas den här variabeln mot miljön. Dokumentation om anslutningssträng finns på Kusto anslutningssträng s. Exempel: "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 Obligatoriskt. Tabellen som data ska matas in i.
mappingRef Valfritt. Attribut för att skicka en mappnings ref som redan har definierats i klustret.
dataFormat Valfritt. Standarddataformatet är multijson/json. Den kan ställas in på textformat som stöds i datasource formatuppräkningen. Exempel verifieras och tillhandahålls för CSV- och JSON-format.
managedServiceIdentity En hanterad identitet kan användas för att ansluta till Azure Data Explorer. Om du vill använda en systemhanterad identitet använder du "system". Andra identitetsnamn tolkas som en användarhanterad identitet.

Konfiguration

I följande tabell förklaras de bindningskonfigurationsegenskaper som du anger i filen function.json .

function.json egenskap beskrivning
type Obligatoriska. Måste anges till kusto.
riktning Obligatoriskt. Måste anges till out.
name Obligatoriska. Namnet på variabeln som representerar frågan resulterar i funktionskod.
database Obligatoriskt. Databasen som frågan måste köras mot.
anslutning Obligatoriskt. Namnet på variabeln som innehåller anslutningssträng, matchas via miljövariabler eller via funktionsappinställningar. Standardvärden för att söka efter variabeln KustoConnectionString. Vid körningen granskas den här variabeln mot miljön. Dokumentation om anslutningssträng finns på Kusto anslutningssträng s. Exempel: "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 Obligatoriskt. Tabellen som data ska matas in i.
mappingRef Valfritt. Attribut för att skicka en mappnings ref som redan har definierats i klustret.
dataFormat Valfritt. Standarddataformatet är multijson/json. Den kan ställas in på textformat som stöds i datasource formatuppräkningen. Exempel verifieras och tillhandahålls för CSV- och JSON-format.
managedServiceIdentity En hanterad identitet kan användas för att ansluta till Azure Data Explorer. Om du vill använda en systemhanterad identitet använder du "system". Andra identitetsnamn tolkas som en användarhanterad identitet.

När du utvecklar lokalt lägger du till dina programinställningar i den local.settings.json filen i Values samlingen.

Användning

Attributets konstruktor tar databasen och attributen TableName, MappingRefoch DataFormat och namnet på anslutningsinställningen. KQL-kommandot kan vara en KQL-instruktion eller en KQL-funktion. Det anslutningssträng inställningsnamnet motsvarar programinställningen (i local.settings.json för lokal utveckling) som innehåller Kusto-anslutningssträng. Till exempel:"KustoConnectionString": "Data Source=https://your_cluster.kusto.windows.net;Database=your_Database;Fed=True;AppClientId=your_AppId;AppKey=your_AppKey;Authority Id=your_TenantId. Frågor som körs av indatabindningen parametriseras. Värdena som anges i KQL-parametrarna används vid körning.

Nästa steg

Läsa data från en tabell (indatabindning)