Výstupní vazby Azure Data Exploreru pro Azure Functions (Preview)

Když se funkce spustí, výstupní vazba Azure Data Exploreru ingestuje data do Azure Data Exploreru.

Informace o nastavení a konfiguraci najdete v přehledu.

Příklady

Funkci jazyka C# je možné vytvořit pomocí jednoho z následujících režimů jazyka C#:

• Izolovaný model pracovního procesu: Kompilovaná funkce jazyka C#, která běží v pracovním procesu, který je izolovaný od modulu runtime. Izolovaný pracovní proces je nutný pro podporu funkcí C# spuštěných na LTS a jiných verzích než LTS .NET a rozhraní .NET Framework.
• Model v procesu: Zkompilovaná funkce jazyka C#, která běží ve stejném procesu jako modul runtime služby Functions.
• Skript jazyka C#: Používá se především při vytváření funkcí jazyka C# na webu Azure Portal.

Důležité

Podpora modelu v procesu skončí 10. listopadu 2026. Důrazně doporučujeme migrovat aplikace do izolovaného modelu pracovního procesu pro plnou podporu.

Izolovaný model pracovního procesu

Další ukázky pro výstupní vazbu Azure Data Exploreru jsou k dispozici v úložišti GitHub.

Tato část obsahuje následující příklady:

• Trigger HTTP, zápis jednoho záznamu
• Trigger HTTP, zápis záznamů s mapováním

Příklady odkazují na Product třídu a odpovídající tabulku databáze:

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)

Trigger HTTP, zápis jednoho záznamu

Následující příklad ukazuje funkci jazyka C#, která přidá záznam do databáze. Funkce používá data zadaná v požadavku HTTP POST jako tělo 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 { };
        }
    }
}

Trigger HTTP, zápis záznamů s mapováním

Následující příklad ukazuje funkci jazyka C#, která přidá kolekci záznamů do databáze. Funkce používá mapování, které transformuje na ProductItem.

K transformaci dat z Product do Itemfunkce se používá odkaz na mapování:

.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 v procesu

Další ukázky pro výstupní vazbu Azure Data Exploreru jsou k dispozici v úložišti GitHub.

Tato část obsahuje následující příklady:

• Trigger HTTP, zápis jednoho záznamu
• Trigger HTTP, zápis do dvou tabulek
• Trigger HTTP, zápis záznamů pomocí IAsyncCollectoru

Příklady odkazují na Product třídu a odpovídající tabulku databáze:

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)

Trigger HTTP, zápis jednoho záznamu

Následující příklad ukazuje funkci jazyka C#, která přidá záznam do databáze. Funkce používá data zadaná v požadavku HTTP POST jako tělo 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);
        }
    }
}

Trigger HTTP, zápis do dvou tabulek

Následující příklad ukazuje funkci jazyka C#, která přidává záznamy do databáze ve dvou různých tabulkách (Products a ProductsChangeLog). Funkce používá data poskytnutá v požadavku HTTP POST jako tělo JSON a několik výstupních vazeb.

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

Trigger HTTP, zápis záznamů pomocí IAsyncCollectoru

Následující příklad ukazuje funkci jazyka C#, která ingestuje sadu záznamů do tabulky. Funkce používá data zadaná v poli JSON těla 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");
        }
    }
}

Další ukázky vstupní vazby Azure Data Exploreru v Javě jsou k dispozici v úložišti GitHub.

Tato část obsahuje následující příklady:

• Trigger HTTP, zápis záznamu do tabulky
• Trigger HTTP, zápis do dvou tabulek

Příklady odkazují na Products třídu (v samostatném souboru Product.java) a odpovídající databázovou tabulku Products (definovanou dříve):

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

Trigger HTTP, zápis záznamu do tabulky

Následující příklad ukazuje výstupní vazbu Azure Data Exploreru ve funkci Java, která přidá záznam produktu do tabulky. Funkce používá data zadaná v požadavku HTTP POST jako tělo JSON. Funkce přebírá další závislost na knihovně com.fasterxml.jackson.core k analýze textu 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();
        }
    }
}

Trigger HTTP, zápis do dvou tabulek

Následující příklad ukazuje výstupní vazbu Azure Data Exploreru ve funkci Java, která přidává záznamy do databáze ve dvou různých tabulkách (Product a ProductChangeLog). Funkce používá data poskytnutá v požadavku HTTP POST jako tělo JSON a několik výstupních vazeb. Funkce přebírá další závislost na knihovně com.fasterxml.jackson.core k analýze textu JSON.

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

Druhá tabulka, ProductsChangeLogodpovídá následující definici:

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

a třída Java v 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();
        }
    }
}

Další ukázky pro výstupní vazbu Azure Data Exploreru jsou k dispozici v úložišti GitHub.

Tato část obsahuje následující příklady:

• Trigger HTTP, zápis záznamů do tabulky
• Trigger HTTP, zápis do dvou tabulek

Příklady odkazují na tabulku databáze.

Příklady odkazují na tabulky Products a ProductsChangeLog (definované dříve).

Trigger HTTP, zápis záznamů do tabulky

Následující příklad ukazuje výstupní vazbu Azure Data Exploreru v souboru function.json a funkci JavaScriptu, která přidává záznamy do tabulky. Funkce používá data zadaná v požadavku HTTP POST jako tělo JSON.

Následující příklad je svázání dat v souboru 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
}

Oddíl konfigurace vysvětluje tyto vlastnosti.

Následující fragment kódu je ukázkový javascriptový kó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
    };
}

Trigger HTTP, zápis do dvou tabulek

Následující příklad ukazuje výstupní vazbu Azure Data Exploreru v souboru function.json a funkci JavaScriptu, která přidává záznamy do databáze ve dvou různých tabulkách (Products a ProductsChangeLog). Funkce používá data poskytnutá v požadavku HTTP POST jako tělo JSON a několik výstupních vazeb.

Druhá tabulka, ProductsChangeLogodpovídá následující definici:

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

Následující fragment kódu je svázání dat v souboru 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
}

Oddíl konfigurace vysvětluje tyto vlastnosti.

Následující fragment kódu je ukázkový javascriptový kó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"
        }
    }
}

Další ukázky pro výstupní vazbu Azure Data Exploreru jsou k dispozici v úložišti GitHub.

Tato část obsahuje následující příklady:

• Trigger HTTP, zápis záznamů do tabulky
• Trigger HTTP, zápis do dvou tabulek

Příklady odkazují na tabulky Products a ProductsChangeLog (definované dříve).

Trigger HTTP, zápis záznamů do tabulky

Následující příklad ukazuje výstupní vazbu Azure Data Exploreru v souboru function.json a funkci Pythonu, která přidává záznamy do tabulky. Funkce používá data zadaná v požadavku HTTP POST jako tělo JSON.

Následující fragment kódu je svázání dat v souboru 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"
    }
  ]
}

Oddíl konfigurace vysvětluje tyto vlastnosti.

Následující fragment kódu je ukázkový kód Pythonu:

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

Trigger HTTP, zápis do dvou tabulek

Následující příklad ukazuje výstupní vazbu Azure Data Exploreru v souboru function.json a funkci JavaScriptu, která přidává záznamy do databáze ve dvou různých tabulkách (Products a ProductsChangeLog). Funkce používá data poskytnutá v požadavku HTTP POST jako tělo JSON a několik výstupních vazeb. Druhá tabulka, ProductsChangeLogodpovídá následující definici:

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

Následující fragment kódu je svázání dat v souboru 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"
    }
  ]
}

Oddíl konfigurace vysvětluje tyto vlastnosti.

Následující fragment kódu je ukázkový kód Pythonu:

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

Atributy

Knihovna C# pomocí atributu KustoAttribute deklaruje vazby Azure Data Exploreru pro funkci, která má následující vlastnosti.

Vlastnost atributu	Popis
Databáze	Povinný: Databáze, ve které se má dotaz spustit.
Connection	Povinný: Název proměnné, která obsahuje připojovací řetězec, která se přeloží prostřednictvím proměnných prostředí nebo prostřednictvím nastavení aplikace funkcí. Ve výchozím nastavení se vyhledá proměnná KustoConnectionString. Za běhu se tato proměnná vyhledá v prostředí. Dokumentace k připojovací řetězec je na připojovací řetězec Kusto. Například: "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	Povinný: Tabulka, do které chcete ingestovat data.
MappingRef	Nepovinné. Atribut pro předání odkazu mapování, který je již definován v clusteru.
ManagedServiceIdentity	Nepovinné. Spravovanou identitu je možné použít k připojení k Azure Data Exploreru. Pokud chcete použít spravovanou identitu systému, použijte "systém". Všechny ostatní názvy identit se interpretují jako identita spravovaná uživatelem.
Dataformat	Nepovinné. Výchozí formát dat je multijson/json. Dá se nastavit na textové formáty podporované ve výčtu datasourceformátu. Ukázky se ověřují a poskytují pro formáty CSV a JSON.

Poznámky

Knihovna modulu runtime funkcí Java používá @KustoInput anotace (com.microsoft.azure.functions.kusto.annotation.KustoOutput).

Element (Prvek)	Popis
name	Požadováno. Název proměnné, která představuje výsledek dotazu v kódu funkce.
database	Povinný: Databáze, ve které se má dotaz spustit.
připojení	Povinný: Název proměnné, která obsahuje připojovací řetězec, která se přeloží prostřednictvím proměnných prostředí nebo prostřednictvím nastavení aplikace funkcí. Ve výchozím nastavení se vyhledá proměnná KustoConnectionString. Za běhu se tato proměnná vyhledá v prostředí. Dokumentace k připojovací řetězec je na připojovací řetězec Kusto. Například: "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	Povinný: Tabulka, do které chcete ingestovat data.
mappingRef	Nepovinné. Atribut pro předání odkazu mapování, který je již definován v clusteru.
Dataformat	Nepovinné. Výchozí formát dat je multijson/json. Dá se nastavit na textové formáty podporované ve výčtu datasourceformátu. Ukázky se ověřují a poskytují pro formáty CSV a JSON.
managedServiceIdentity	Spravovanou identitu je možné použít k připojení k Azure Data Exploreru. Pokud chcete použít spravovanou identitu systému, použijte "systém". Všechny ostatní názvy identit se interpretují jako identita spravovaná uživatelem.

Konfigurace

Následující tabulka vysvětluje vlastnosti konfigurace vazby, které jste nastavili v souboru function.json .

vlastnost function.json	Popis
type	Povinný: Musí být nastavena na kustohodnotu .
směr	Povinný: Musí být nastavena na outhodnotu .
name	Požadováno. Název proměnné, která představuje výsledek dotazu v kódu funkce.
database	Povinný: Databáze, ve které se má dotaz spustit.
připojení	Povinný: Název proměnné, která obsahuje připojovací řetězec, překládá se prostřednictvím proměnných prostředí nebo prostřednictvím nastavení aplikace funkcí. Ve výchozím nastavení se vyhledá proměnná KustoConnectionString. Za běhu se tato proměnná vyhledá v prostředí. Dokumentace k připojovací řetězec je na připojovací řetězec Kusto. Například: "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	Povinný: Tabulka, do které chcete ingestovat data.
mappingRef	Nepovinné. Atribut pro předání odkazu mapování, který je již definován v clusteru.
Dataformat	Nepovinné. Výchozí formát dat je multijson/json. Dá se nastavit na textové formáty podporované ve výčtu datasourceformátu. Ukázky se ověřují a poskytují pro formáty CSV a JSON.
managedServiceIdentity	Spravovanou identitu je možné použít k připojení k Azure Data Exploreru. Pokud chcete použít spravovanou identitu systému, použijte "systém". Všechny ostatní názvy identit se interpretují jako identita spravovaná uživatelem.

Při místním vývoji přidejte nastavení aplikace do souboru local.settings.json v kolekci Values .

Využití

Konstruktor atributu přebírá databázi a atributy TableName, MappingRefa DataFormat název nastavení připojení. Příkazem KQL může být příkaz KQL nebo funkce KQL. Název nastavení připojovací řetězec odpovídá nastavení aplikace (pro local.settings.json místní vývoj), které obsahuje připojovací řetězec Kusto. Příklad:"KustoConnectionString": "Data Source=https://your_cluster.kusto.windows.net;Database=your_Database;Fed=True;AppClientId=your_AppId;AppKey=your_AppKey;Authority Id=your_TenantId. Dotazy spouštěné vstupní vazbou jsou parametrizovány. Hodnoty zadané v parametrech KQL se používají za běhu.

Další kroky

Čtení dat z tabulky (vstupní vazba)