Azure Data Explorer kimeneti kötések az Azure Functionshez (előzetes verzió)

Amikor egy függvény fut, az Azure Data Explorer kimeneti kötése betölti az adatokat az Azure Data Explorerbe.

A beállítással és a konfigurációval kapcsolatos információkért tekintse meg az áttekintést.

Példák

A C#-függvények a következő C#-módok egyikével hozhatók létre:

• Izolált feldolgozómodell: Lefordított C# függvény, amely a futtatókörnyezettől elkülönített feldolgozói folyamatban fut. Izolált feldolgozói folyamat szükséges az LTS- és nem LTS-verziókon futó C#-függvények támogatásához .NET és .NET-keretrendszer.
• Folyamaton belüli modell: Lefordított C# függvény, amely ugyanabban a folyamatban fut, mint a Functions-futtatókörnyezet.
• C#-szkript: Elsősorban C#-függvények Azure Portalon való létrehozásakor használatos.

Fontos

A folyamaton belüli modell támogatása 2026. november 10-én megszűnik. Erősen javasoljuk, hogy az alkalmazásokat az elkülönített feldolgozói modellbe migrálja a teljes támogatás érdekében.

Izolált feldolgozói modell

Az Azure Data Explorer kimeneti kötéséhez további minták érhetők el a GitHub-adattárban.

Ez a szakasz a következő példákat tartalmazza:

• HTTP-eseményindító, egy rekord írása
• HTTP-eseményindító, rekordok írása leképezéssel

A példák az osztályra Product és a megfelelő adatbázistáblára vonatkoznak:

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-eseményindító, egy rekord írása

Az alábbi példa egy olyan C# függvényt mutat be, amely egy rekordot ad hozzá egy adatbázishoz. A függvény egy HTTP POST-kérelemben megadott adatokat használ JSON-törzsként.

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-eseményindító, rekordok írása leképezéssel

Az alábbi példa egy C# függvényt mutat be, amely rekordgyűjteményt ad hozzá egy adatbázishoz. A függvény olyan leképezést használ, amely átalakítja az a Product függvényt Item.

Az adatok Product közötti átalakításhoz Itema függvény egy leképezési hivatkozást használ:

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

Folyamaton belüli modell

Az Azure Data Explorer kimeneti kötéséhez további minták érhetők el a GitHub-adattárban.

Ez a szakasz a következő példákat tartalmazza:

• HTTP-eseményindító, egy rekord írása
• HTTP-eseményindító, írás két táblába
• HTTP-eseményindító, rekordok írása az IAsyncCollector használatával

A példák az osztályra Product és a megfelelő adatbázistáblára vonatkoznak:

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-eseményindító, egy rekord írása

Az alábbi példa egy olyan C# függvényt mutat be, amely egy rekordot ad hozzá egy adatbázishoz. A függvény egy HTTP POST-kérelemben megadott adatokat használ JSON-törzsként.

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-eseményindító, írás két táblába

Az alábbi példa egy C# függvényt mutat be, amely rekordokat ad hozzá egy adatbázishoz két különböző táblában (Products és ProductsChangeLog). A függvény egy HTTP POST-kérelemben megadott adatokat használ JSON-törzsként és több kimeneti kötésként.

.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-eseményindító, rekordok írása az IAsyncCollector használatával

Az alábbi példa egy C#-függvényt mutat be, amely rekordhalmazt egy táblába betölt. A függvény EGY HTTP POST törzs JSON-tömbben megadott adatokat használ.

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

A GitHub-adattárban további minták érhetők el a Java Azure Data Explorer bemeneti kötéséhez.

Ez a szakasz a következő példákat tartalmazza:

• HTTP-eseményindító, rekord írása egy táblába
• HTTP-eseményindító, írás két táblába

A példák egy Products osztályra (külön fájlban Product.java) és egy (korábban definiált) megfelelő adatbázistáblára Products vonatkoznak:

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-eseményindító, rekord írása egy táblába

Az alábbi példa egy Azure Data Explorer kimeneti kötést mutat be egy Java-függvényben, amely egy termékrekordot ad hozzá egy táblához. A függvény egy HTTP POST-kérelemben megadott adatokat használ JSON-törzsként. A függvény egy másik függőséget vesz fel a com.fasterxml.jackson.core könyvtártól a JSON-törzs elemzéséhez.

<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-eseményindító, írás két táblába

Az alábbi példa egy Azure Data Explorer kimeneti kötést mutat be egy Java-függvényben, amely rekordokat ad hozzá egy adatbázishoz két különböző táblában (Product és ProductChangeLog). A függvény egy HTTP POST-kérelemben megadott adatokat használ JSON-törzsként és több kimeneti kötésként. A függvény egy másik függőséget vesz fel a com.fasterxml.jackson.core könyvtártól a JSON-törzs elemzéséhez.

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

A második tábla ProductsChangeLoga következő definíciónak felel meg:

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

és Java-osztály a következőben 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();
        }
    }
}

Az Azure Data Explorer kimeneti kötéséhez további minták érhetők el a GitHub-adattárban.

Ez a szakasz a következő példákat tartalmazza:

• HTTP-eseményindító, rekordok írása egy táblába
• HTTP-eseményindító, írás két táblába

A példák egy adatbázistáblára vonatkoznak.

A példák a táblákra és ProductsChangeLog a (korábban definiált) táblákra Products vonatkoznak.

HTTP-eseményindító, rekordok írása egy táblába

Az alábbi példa egy Azure Data Explorer kimeneti kötést mutat be egy function.json fájlban, valamint egy JavaScript-függvényt, amely rekordokat ad hozzá egy táblához. A függvény egy HTTP POST-kérelemben megadott adatokat használ JSON-törzsként.

Az alábbi példa a function.json fájlban lévő kötési adatokra mutat:

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

A konfigurációs szakasz ezeket a tulajdonságokat ismerteti.

A következő kódrészlet javaScript-mintakód:

// 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-eseményindító, írás két táblába

Az alábbi példa egy Azure Data Explorer kimeneti kötést mutat be egy function.json fájlban, valamint egy JavaScript-függvényt, amely rekordokat ad hozzá egy adatbázishoz két különböző táblában (Products és ProductsChangeLog). A függvény egy HTTP POST-kérelemben megadott adatokat használ JSON-törzsként és több kimeneti kötésként.

A második tábla ProductsChangeLoga következő definíciónak felel meg:

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

A következő kódrészlet a function.json fájlban lévő adatok kötése:

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

A konfigurációs szakasz ezeket a tulajdonságokat ismerteti.

A következő kódrészlet javaScript-mintakód:

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

Az Azure Data Explorer kimeneti kötéséhez további minták érhetők el a GitHub-adattárban.

Ez a szakasz a következő példákat tartalmazza:

• HTTP-eseményindító, rekordok írása egy táblába
• HTTP-eseményindító, írás két táblába

A példák a táblákra és ProductsChangeLog a (korábban definiált) táblákra Products vonatkoznak.

HTTP-eseményindító, rekordok írása egy táblába

Az alábbi példa egy Azure Data Explorer kimeneti kötést mutat be egy function.json fájlban, valamint egy Python-függvényt, amely rekordokat ad hozzá egy táblához. A függvény egy HTTP POST-kérelemben megadott adatokat használ JSON-törzsként.

A következő kódrészlet a function.json fájlban lévő adatok kötése:

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

A konfigurációs szakasz ezeket a tulajdonságokat ismerteti.

A következő kódrészlet a Python-mintakód:

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-eseményindító, írás két táblába

Az alábbi példa egy Azure Data Explorer kimeneti kötést mutat be egy function.json fájlban, valamint egy JavaScript-függvényt, amely rekordokat ad hozzá egy adatbázishoz két különböző táblában (Products és ProductsChangeLog). A függvény egy HTTP POST-kérelemben megadott adatokat használ JSON-törzsként és több kimeneti kötésként. A második tábla ProductsChangeLoga következő definíciónak felel meg:

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

A következő kódrészlet a function.json fájlban lévő adatok kötése:

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

A konfigurációs szakasz ezeket a tulajdonságokat ismerteti.

A következő kódrészlet a Python-mintakód:

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

Attribútumok

A C#-kódtár a KustoAttribute attribútummal deklarálja az Azure Data Explorer-kötéseket a függvényen, amely a következő tulajdonságokkal rendelkezik.

Attribútumtulajdonság	Leírás
Adatbázis	Szükséges. Az adatbázis, amelyen a lekérdezést végre kell hajtani.
Connection	Szükséges. A kapcsolati sztring tartalmazó változó neve, amelyet környezeti változók vagy függvényalkalmazás-beállítások oldanak fel. Alapértelmezés szerint a változót KustoConnectionStringkell megkeresni. Futásidőben a rendszer megkeresi ezt a változót a környezettel szemben. A kapcsolati sztring dokumentációja a Kusto kapcsolati sztring található. Például: "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	Szükséges. A táblázat, amelybe betölti az adatokat.
MappingRef	Opcionális. Attribútum a fürtben már definiált leképezési hiv átadásához.
ManagedServiceIdentity	Opcionális. Felügyelt identitással csatlakozhat az Azure Data Explorerhez. A rendszer által felügyelt identitás használatához használja a "system" kifejezést. A rendszer minden más identitásnevet felhasználó által felügyelt identitásként értelmez.
DataFormat	Opcionális. Az alapértelmezett adatformátum a következő multijson/json: . A formátumbeszámításban datasourcetámogatott szövegformátumok állíthatók be. A minták érvényesítése és megadása CSV- és JSON-formátumokhoz szükséges.

Jegyzetek

A Java-függvények futtatókörnyezeti kódtára a @KustoInput széljegyzetet (com.microsoft.azure.functions.kusto.annotation.KustoOutput) használja.

Elem	Leírás
név	Szükséges. A lekérdezést jelképező változó neve függvénykódot eredményez.
adatbázis	Szükséges. Az adatbázis, amelyen a lekérdezést végre kell hajtani.
kapcsolat	Szükséges. A kapcsolati sztring tartalmazó változó neve, amelyet környezeti változók vagy függvényalkalmazás-beállítások oldanak fel. Alapértelmezés szerint a változót KustoConnectionStringkell megkeresni. Futásidőben a rendszer megkeresi ezt a változót a környezettel szemben. A kapcsolati sztring dokumentációja a Kusto kapcsolati sztring található. Például: "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	Szükséges. A táblázat, amelybe betölti az adatokat.
mappingRef	Opcionális. Attribútum a fürtben már definiált leképezési hiv átadásához.
dataFormat	Opcionális. Az alapértelmezett adatformátum a következő multijson/json: . A formátumbeszámításban datasourcetámogatott szövegformátumok állíthatók be. A minták érvényesítése és megadása CSV- és JSON-formátumokhoz szükséges.
managedServiceIdentity	Felügyelt identitással csatlakozhat az Azure Data Explorerhez. A rendszer által felügyelt identitás használatához használja a "system" kifejezést. A rendszer minden más identitásnevet felhasználó által felügyelt identitásként értelmez.

Konfiguráció

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

function.json tulajdonság	Leírás
típus	Szükséges. A beállításnak a kustokövetkezőnek kell lennie: .
irány	Szükséges. A beállításnak a outkövetkezőnek kell lennie: .
név	Szükséges. A lekérdezést jelképező változó neve függvénykódot eredményez.
adatbázis	Szükséges. Az adatbázis, amelyen a lekérdezést végre kell hajtani.
kapcsolat	Szükséges. A kapcsolati sztring tartalmazó változó neve környezeti változókkal vagy függvényalkalmazás-beállításokkal oldható fel. Alapértelmezés szerint a változót KustoConnectionStringkell megkeresni. Futásidőben a rendszer megkeresi ezt a változót a környezettel szemben. A kapcsolati sztring dokumentációja a Kusto kapcsolati sztring található. Például: "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	Szükséges. A táblázat, amelybe betölti az adatokat.
mappingRef	Opcionális. Attribútum a fürtben már definiált leképezési hiv átadásához.
dataFormat	Opcionális. Az alapértelmezett adatformátum a következő multijson/json: . A formátumbeszámításban datasourcetámogatott szövegformátumok állíthatók be. A minták érvényesítése és megadása CSV- és JSON-formátumokhoz szükséges.
managedServiceIdentity	Felügyelt identitással csatlakozhat az Azure Data Explorerhez. A rendszer által felügyelt identitás használatához használja a "system" kifejezést. A rendszer minden más identitásnevet felhasználó által felügyelt identitásként értelmez.

Helyi fejlesztéskor adja hozzá az alkalmazásbeállításokat a gyűjtemény local.settings.json fájljáhozValues.

Használat

Az attribútum konstruktora az adatbázist és az attribútumokat TableName, MappingRefvalamint DataFormat a kapcsolatbeállítás nevét veszi át. A KQL-parancs lehet KQL-utasítás vagy KQL-függvény. A kapcsolati sztring beállítás neve megfelel a Kusto kapcsolati sztring tartalmazó alkalmazásbeállításnak (local.settings.jsonhelyi fejlesztés esetén). Például:"KustoConnectionString": "Data Source=https://your_cluster.kusto.windows.net;Database=your_Database;Fed=True;AppClientId=your_AppId;AppKey=your_AppKey;Authority Id=your_TenantId. A bemeneti kötés által végrehajtott lekérdezések paraméterezve vannak. A KQL-paraméterekben megadott értékek futásidőben lesznek használva.

Következő lépések

Adatok beolvasása táblázatból (bemeneti kötés)