Associazioni di output Esplora dati di Azure per Funzioni di Azure (anteprima)

Quando viene eseguita una funzione, l'associazione di output di Azure Esplora dati inserisce i dati in Azure Esplora dati.

Per informazioni sui dettagli di impostazione e configurazione, vedere la panoramica.

Esempi

È possibile creare una funzione C# usando una delle modalità C# seguenti:

• Modello di lavoro isolato: funzione C# compilata eseguita in un processo di lavoro isolato dal runtime. Il processo di lavoro isolato è necessario per supportare le funzioni C# in esecuzione in LTS e versioni non LTS .NET e .NET Framework.
• Modello in-process: funzione C# compilata eseguita nello stesso processo del runtime di Funzioni.
• Script C#: usato principalmente quando si creano funzioni C# nel portale di Azure.

Importante

Il supporto terminerà per il modello in-process il 10 novembre 2026. È consigliabile eseguire la migrazione delle app al modello di lavoro isolato per il supporto completo.

Modello di lavoro isolato

Altri esempi per l'associazione di output di Azure Esplora dati sono disponibili nel repository GitHub.

Questa sezione contiene gli esempi seguenti:

• Trigger HTTP, scrittura di un record
• Trigger HTTP, scrittura di record con mapping

Gli esempi fanno riferimento alla classe e a Product una tabella di database corrispondente:

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, scrittura di un record

L'esempio seguente illustra una funzione C# che aggiunge un record a un database. La funzione usa i dati forniti in una richiesta HTTP POST come corpo 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, scrittura di record con mapping

L'esempio seguente illustra una funzione C# che aggiunge una raccolta di record a un database. La funzione usa il mapping che trasforma un oggetto Product in Item.

Per trasformare i dati da Product a Item, la funzione usa un riferimento di mapping:

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

Modello di processo

Altri esempi per l'associazione di output di Azure Esplora dati sono disponibili nel repository GitHub.

Questa sezione contiene gli esempi seguenti:

• Trigger HTTP, scrittura di un record
• Trigger HTTP, scrivere in due tabelle
• Trigger HTTP, scrittura di record con IAsyncCollector

Gli esempi fanno riferimento alla classe e a Product una tabella di database corrispondente:

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, scrittura di un record

L'esempio seguente illustra una funzione C# che aggiunge un record a un database. La funzione usa i dati forniti in una richiesta HTTP POST come corpo 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, scrittura in due tabelle

L'esempio seguente illustra una funzione C# che aggiunge record a un database in due tabelle diverse (Products e ProductsChangeLog). La funzione usa i dati forniti in una richiesta HTTP POST come corpo JSON e più associazioni di output.

.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, scrittura di record con IAsyncCollector

L'esempio seguente illustra una funzione C# che inserisce un set di record in una tabella. La funzione usa i dati forniti in una matrice JSON del corpo 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");
        }
    }
}

Altri esempi per Java Azure Esplora dati binding di input sono disponibili nel repository GitHub.

Questa sezione contiene gli esempi seguenti:

• Trigger HTTP, scrivere un record in una tabella
• Trigger HTTP, scrivere in due tabelle

Gli esempi fanno riferimento a una Products classe (in un file Product.javaseparato ) e a una tabella Products di database corrispondente (definita in precedenza):

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, scrivere un record in una tabella

L'esempio seguente illustra un'associazione di output di Azure Esplora dati in una funzione Java che aggiunge un record di prodotto a una tabella. La funzione usa i dati forniti in una richiesta HTTP POST come corpo JSON. La funzione accetta un'altra dipendenza dalla libreria com.fasterxml.jackson.core per analizzare il corpo 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, scrittura in due tabelle

L'esempio seguente illustra un'associazione di output di Azure Esplora dati in una funzione Java che aggiunge record a un database in due tabelle diverse (Product e ProductChangeLog). La funzione usa i dati forniti in una richiesta HTTP POST come corpo JSON e più associazioni di output. La funzione accetta un'altra dipendenza dalla libreria com.fasterxml.jackson.core per analizzare il corpo JSON.

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

La seconda tabella, ProductsChangeLog, corrisponde alla definizione seguente:

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

e la classe Java 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();
        }
    }
}

Altri esempi per l'associazione di output di Azure Esplora dati sono disponibili nel repository GitHub.

Questa sezione contiene gli esempi seguenti:

• Trigger HTTP, scrivere record in una tabella
• Trigger HTTP, scrivere in due tabelle

Gli esempi fanno riferimento a una tabella di database.

Gli esempi fanno riferimento alle tabelle Products e ProductsChangeLog (definite in precedenza).

Trigger HTTP, scrittura di record in una tabella

L'esempio seguente illustra un'associazione di output Esplora dati di Azure in un file function.json e una funzione JavaScript che aggiunge record a una tabella. La funzione usa i dati forniti in una richiesta HTTP POST come corpo JSON.

L'esempio seguente è l'associazione dei dati nel file 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
}

Queste proprietà sono descritte nella sezione configuration.

Il frammento di codice JavaScript seguente è di esempio:

// 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, scrittura in due tabelle

L'esempio seguente illustra un'associazione di output Esplora dati di Azure in un file function.json e una funzione JavaScript che aggiunge record a un database in due tabelle diverse (Products e ProductsChangeLog). La funzione usa i dati forniti in una richiesta HTTP POST come corpo JSON e più associazioni di output.

La seconda tabella, ProductsChangeLog, corrisponde alla definizione seguente:

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

Il frammento di codice seguente è l'associazione dei dati nel file 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
}

Queste proprietà sono descritte nella sezione configuration.

Il frammento di codice JavaScript seguente è di esempio:

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

Altri esempi per l'associazione di output di Azure Esplora dati sono disponibili nel repository GitHub.

Questa sezione contiene gli esempi seguenti:

• Trigger HTTP, scrivere record in una tabella
• Trigger HTTP, scrivere in due tabelle

Gli esempi fanno riferimento alle tabelle Products e ProductsChangeLog (definite in precedenza).

Trigger HTTP, scrittura di record in una tabella

L'esempio seguente illustra un'associazione di output Esplora dati di Azure in un file function.json e una funzione Python che aggiunge record a una tabella. La funzione usa i dati forniti in una richiesta HTTP POST come corpo JSON.

Il frammento di codice seguente è l'associazione dei dati nel file 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"
    }
  ]
}

Queste proprietà sono descritte nella sezione configuration.

Il frammento di codice Python seguente è di esempio:

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, scrittura in due tabelle

L'esempio seguente illustra un'associazione di output Esplora dati di Azure in un file function.json e una funzione JavaScript che aggiunge record a un database in due tabelle diverse (Products e ProductsChangeLog). La funzione usa i dati forniti in una richiesta HTTP POST come corpo JSON e più associazioni di output. La seconda tabella, ProductsChangeLog, corrisponde alla definizione seguente:

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

Il frammento di codice seguente è l'associazione dei dati nel file 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"
    }
  ]
}

Queste proprietà sono descritte nella sezione configuration.

Il frammento di codice Python seguente è di esempio:

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

Attributi

La libreria C# usa l'attributo KustoAttribute per dichiarare le associazioni di Esplora dati di Azure nella funzione, con le proprietà seguenti.

Proprietà dell'attributo	Descrizione
Database	Obbligatorio. Database su cui deve essere eseguita la query.
Connessione	Obbligatorio. Nome della variabile che contiene il stringa di connessione, che viene risolto tramite variabili di ambiente o tramite le impostazioni dell'app per le funzioni. Per impostazione predefinita, cercare la variabile KustoConnectionString. In fase di esecuzione, questa variabile viene cercata nell'ambiente. La documentazione sul stringa di connessione è disponibile in Stringa di connessione Kusto. Ad esempio: "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	Obbligatorio. Tabella in cui inserire i dati.
MappingRef	Facoltativo. Attributo per passare un riferimento di mapping già definito nel cluster.
ManagedServiceIdentity	Facoltativo. È possibile usare un'identità gestita per connettersi ad Azure Esplora dati. Per usare un'identità gestita dal sistema, usare "system". Qualsiasi altro nome di identità viene interpretato come identità gestita dall'utente.
DataFormat	Facoltativo. Il formato dati predefinito è multijson/json. Può essere impostato su formati di testo supportati nell'enumerazionedatasource del formato. Gli esempi vengono convalidati e forniti per i formati CSV e JSON.

Annotazioni

La libreria di runtime delle funzioni Java usa l'annotazione @KustoInput (com.microsoft.azure.functions.kusto.annotation.KustoOutput).

Elemento	Descrizione
name	Obbligatorio. Nome della variabile che rappresenta i risultati della query nel codice della funzione.
database	Obbligatorio. Database su cui deve essere eseguita la query.
connection	Obbligatorio. Nome della variabile che contiene il stringa di connessione, che viene risolto tramite variabili di ambiente o tramite le impostazioni dell'app per le funzioni. Per impostazione predefinita, cercare la variabile KustoConnectionString. In fase di esecuzione, questa variabile viene cercata nell'ambiente. La documentazione sul stringa di connessione è disponibile in Stringa di connessione Kusto. Ad esempio: "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	Obbligatorio. Tabella in cui inserire i dati.
mappingRef	Facoltativo. Attributo per passare un riferimento di mapping già definito nel cluster.
dataFormat	Facoltativo. Il formato dati predefinito è multijson/json. Può essere impostato su formati di testo supportati nell'enumerazionedatasource del formato. Gli esempi vengono convalidati e forniti per i formati CSV e JSON.
managedServiceIdentity	È possibile usare un'identità gestita per connettersi ad Azure Esplora dati. Per usare un'identità gestita dal sistema, usare "system". Qualsiasi altro nome di identità viene interpretato come identità gestita dall'utente.

Impostazione

Nella tabella seguente sono illustrate le proprietà di configurazione dell'associazione impostate nel file function.json.

Proprietà di function.json	Descrizione
type	Obbligatorio. Deve essere impostato su kusto.
direction	Obbligatorio. Deve essere impostato su out.
name	Obbligatorio. Nome della variabile che rappresenta i risultati della query nel codice della funzione.
database	Obbligatorio. Database su cui deve essere eseguita la query.
connection	Obbligatorio. Nome della variabile che contiene il stringa di connessione, risolto tramite variabili di ambiente o tramite le impostazioni dell'app per le funzioni. Per impostazione predefinita, cercare la variabile KustoConnectionString. In fase di esecuzione, questa variabile viene cercata nell'ambiente. La documentazione sul stringa di connessione è disponibile in Stringa di connessione Kusto. Ad esempio: "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	Obbligatorio. Tabella in cui inserire i dati.
mappingRef	Facoltativo. Attributo per passare un riferimento di mapping già definito nel cluster.
dataFormat	Facoltativo. Il formato dati predefinito è multijson/json. Può essere impostato su formati di testo supportati nell'enumerazionedatasource del formato. Gli esempi vengono convalidati e forniti per i formati CSV e JSON.
managedServiceIdentity	È possibile usare un'identità gestita per connettersi ad Azure Esplora dati. Per usare un'identità gestita dal sistema, usare "system". Qualsiasi altro nome di identità viene interpretato come identità gestita dall'utente.

Quando si sviluppa in locale, aggiungere le impostazioni dell'applicazione nel file local.settings.json nella Values raccolta.

Utilizzo

Il costruttore dell'attributo accetta il database e gli attributi TableName, MappingRefe DataFormat il nome dell'impostazione di connessione. Il comando KQL può essere un'istruzione KQL o una funzione KQL. Il nome dell'impostazione stringa di connessione corrisponde all'impostazione dell'applicazione (in local.settings.json per lo sviluppo locale) che contiene i stringa di connessione Kusto. Ad esempio:"KustoConnectionString": "Data Source=https://your_cluster.kusto.windows.net;Database=your_Database;Fed=True;AppClientId=your_AppId;AppKey=your_AppKey;Authority Id=your_TenantId Le query eseguite dall'associazione di input vengono parametrizzate. I valori specificati nei parametri KQL vengono usati in fase di esecuzione.

Passaggi successivi

Leggere i dati da una tabella (associazione di input)