Associazioni di output delle tabelle di Azure per Funzioni di Azure

La classe seguente MyTableData rappresenta una riga di dati nella tabella:

public class MyTableData : Azure.Data.Tables.ITableEntity
{
    public string Text { get; set; }

    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public DateTimeOffset? Timestamp { get; set; }
    public ETag ETag { get; set; }
}

La funzione seguente, avviata da un trigger di archiviazione code, scrive una nuova MyDataTable entità in una tabella denominata OutputTable.

[Function("TableFunction")]
[TableOutput("OutputTable", Connection = "AzureWebJobsStorage")]
public static MyTableData Run(
    [QueueTrigger("table-items")] string input,
    [TableInput("MyTable", "<PartitionKey>", "{queueTrigger}")] MyTableData tableInput,
    FunctionContext context)
{
    var logger = context.GetLogger("TableFunction");

    logger.LogInformation($"PK={tableInput.PartitionKey}, RK={tableInput.RowKey}, Text={tableInput.Text}");

    return new MyTableData()
    {
        PartitionKey = "queue",
        RowKey = Guid.NewGuid().ToString(),
        Text = $"Output record with rowkey {input} created at {DateTime.Now}"
    };
}

L'esempio seguente illustra una funzione C# che usa un trigger HTTP per scrivere una singola riga della tabella.

public class TableStorage
{
    public class MyPoco
    {
        public string PartitionKey { get; set; }
        public string RowKey { get; set; }
        public string Text { get; set; }
    }

    [FunctionName("TableOutput")]
    [return: Table("MyTable")]
    public static MyPoco TableOutput([HttpTrigger] dynamic input, ILogger log)
    {
        log.LogInformation($"C# http trigger function processed: {input.Text}");
        return new MyPoco { PartitionKey = "Http", RowKey = Guid.NewGuid().ToString(), Text = input.Text };
    }
}

import { app, HttpRequest, HttpResponseInit, InvocationContext, output } from '@azure/functions';

const tableOutput = output.table({
    tableName: 'Person',
    connection: 'MyStorageConnectionAppSetting',
});

interface PersonEntity {
    PartitionKey: string;
    RowKey: string;
    Name: string;
}

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    const rows: PersonEntity[] = [];
    for (let i = 1; i < 10; i++) {
        rows.push({
            PartitionKey: 'Test',
            RowKey: i.toString(),
            Name: `Name ${i}`,
        });
    }
    context.extraOutputs.set(tableOutput, rows);
    return { status: 201 };
}

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [tableOutput],
    handler: httpTrigger1,
});

Gli esempi typeScript non sono documentati per il modello v3.

const { app, output } = require('@azure/functions');

const tableOutput = output.table({
    tableName: 'Person',
    connection: 'MyStorageConnectionAppSetting',
});

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [tableOutput],
    handler: async (request, context) => {
        const rows = [];
        for (let i = 1; i < 10; i++) {
            rows.push({
                PartitionKey: 'Test',
                RowKey: i.toString(),
                Name: `Name ${i}`,
            });
        }
        context.extraOutputs.set(tableOutput, rows);
        return { status: 201 };
    },
});

Ecco il file function.json:

{
  "bindings": [
    {
      "name": "input",
      "type": "manualTrigger",
      "direction": "in"
    },
    {
      "tableName": "Person",
      "connection": "MyStorageConnectionAppSetting",
      "name": "tableBinding",
      "type": "table",
      "direction": "out"
    }
  ],
  "disabled": false
}

Queste proprietà sono descritte nella sezione configuration.

Ecco il codice JavaScript:

module.exports = async function (context) {

    context.bindings.tableBinding = [];

    for (var i = 1; i < 10; i++) {
        context.bindings.tableBinding.push({
            PartitionKey: "Test",
            RowKey: i.toString(),
            Name: "Name " + i
        });
    }
};

La funzione seguente genera un'interfaccia utente univoca per il rowKey valore e salva in modo permanente il messaggio nell'archiviazione tabelle.

import logging
import uuid
import json
import azure.functions as func

app = func.FunctionApp()

@app.route(route="table_out_binding")
@app.table_output(arg_name="message",
                  connection="AzureWebJobsStorage",
                  table_name="messages")
def table_out_binding(req: func.HttpRequest, message: func.Out[str]):
    row_key = str(uuid.uuid4())
    data = {
        "Name": "Output binding message",
        "PartitionKey": "message",
        "RowKey": row_key
    }
    table_json = json.dumps(data)
    message.set(table_json)
    return table_json

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "message",
      "type": "table",
      "tableName": "messages",
      "partitionKey": "message",
      "connection": "AzureWebJobsStorage",
      "direction": "out"
    },
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    }
  ]
}

La funzione seguente genera un'interfaccia utente univoca per il rowKey valore e salva in modo permanente il messaggio nell'archiviazione tabelle.

import logging
import uuid
import json

import azure.functions as func

def main(req: func.HttpRequest, message: func.Out[str]) -> func.HttpResponse:

    rowKey = str(uuid.uuid4())

    data = {
        "Name": "Output binding message",
        "PartitionKey": "message",
        "RowKey": rowKey
    }

    message.set(json.dumps(data))

    return func.HttpResponse(f"Message created with the rowKey: {rowKey}")

Nelle librerie diTableInputAttribute classi C# supporta le proprietà seguenti:

Nelle librerie diTableAttribute classi C# supporta le proprietà seguenti:

Il costruttore dell'attributo accetta il nome della tabella. Usare l'attributo su un out parametro o sul valore restituito della funzione, come illustrato nell'esempio seguente:

[FunctionName("TableOutput")]
[return: Table("MyTable")]
public static MyPoco TableOutput(
    [HttpTrigger] dynamic input, 
    ILogger log)
{
    ...
}

È possibile impostare la Connection proprietà per specificare una connessione al servizio tabelle, come illustrato nell'esempio seguente:

[FunctionName("TableOutput")]
[return: Table("MyTable", Connection = "StorageConnectionAppSetting")]
public static MyPoco TableOutput(
    [HttpTrigger] dynamic input, 
    ILogger log)
{
    ...
}

Mentre l'attributo accetta una Connection proprietà, è anche possibile usare StorageAccountAttribute per specificare una connessione all'account di archiviazione. Questa operazione può essere eseguita quando è necessario usare un account di archiviazione diverso da altre funzioni della libreria. Il costruttore accetta il nome di un'impostazione dell'app che contiene una stringa di connessione di archiviazione. L'attributo può essere applicato a livello di parametro, metodo o classe. L'esempio seguente illustra il livello classe e il livello metodo:

[StorageAccount("ClassLevelStorageAppSetting")]
public static class AzureFunctions
{
    [FunctionName("StorageTrigger")]
    [StorageAccount("FunctionLevelStorageAppSetting")]
    public static void Run( //...
{
    ...
}

L'account di archiviazione da usare è determinato nell'ordine seguente:

• Proprietà dell'attributo trigger o binding Connection .
• Attributo StorageAccount applicato allo stesso parametro dell'attributo trigger o binding.
• L'attributo StorageAccount applicato alla funzione.
• L'attributo StorageAccount applicato alla classe.
• L'account di archiviazione predefinito per l'app per le funzioni, definito nell'impostazione dell'applicazione AzureWebJobsStorage .

Nella tabella seguente vengono illustrate le proprietà che è possibile impostare sull'oggetto options passato al output.table() metodo .

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

Una funzione C# compilata di libreria di classi di processo di lavoro viene eseguita in un processo isolato dal runtime.

Una libreria di classi in-process è una funzione C# compilata eseguita nello stesso processo del runtime di Funzioni.

Per i parametri e i tipi restituiti sono supportati out i tipi seguenti:

• Oggetto CLR (POCO) normale che include le PartitionKey proprietà e RowKey . È possibile accompagnare queste proprietà implementando ITableEntity.
• ICollector<T> o IAsyncCollector<T> dove T include le PartitionKey proprietà e RowKey . È possibile accompagnare queste proprietà implementando ITableEntity.

È anche possibile eseguire il binding da TableClientAzure SDK. È quindi possibile usare tale oggetto per scrivere nella tabella.

Per i parametri e i tipi restituiti sono supportati out i tipi seguenti:

• Oggetto CLR (POCO) normale che include le PartitionKey proprietà e RowKey . È possibile accompagnare queste proprietà implementando ITableEntity o ereditando TableEntity.
• ICollector<T> o IAsyncCollector<T> dove T include le PartitionKey proprietà e RowKey . È possibile accompagnare queste proprietà implementando ITableEntity o ereditando TableEntity.

È anche possibile eseguire l'associazione da CloudTableStorage SDK come parametro del metodo. È quindi possibile usare tale oggetto per scrivere nella tabella.

Per i parametri e i tipi restituiti sono supportati out i tipi seguenti:

• Oggetto CLR (POCO) normale che include le PartitionKey proprietà e RowKey . È possibile accompagnare queste proprietà implementando ITableEntity o ereditando TableEntity.
• ICollector<T> o IAsyncCollector<T> dove T include le PartitionKey proprietà e RowKey . È possibile accompagnare queste proprietà implementando ITableEntity o ereditando TableEntity.

È anche possibile eseguire l'associazione da CloudTableStorage SDK come parametro del metodo. È quindi possibile usare tale oggetto per scrivere nella tabella.

Quando si vuole che la funzione scriva in una singola entità, l'associazione di output tabelle di Azure può essere associata ai tipi seguenti:

Quando si vuole che la funzione scriva in più entità, l'associazione di output tabelle di Azure può essere associata ai tipi seguenti:

Per altri scenari di output, creare e usare un oggetto TableClient con altri tipi direttamente da Azure.Data.Tables . Vedere Registrare i client di Azure per un esempio di uso dell'inserimento delle dipendenze per creare un tipo di client da Azure SDK.

Restituisce un oggetto CLR normale (POCO) con proprietà di cui è possibile eseguire il mapping all'entità tabella.

Le funzioni versione 1.x non supportano il processo di lavoro isolato.

Impostare i dati delle righe di output restituendo il valore o usando context.extraOutputs.set().

Impostare i dati delle righe di output usando context.bindings.<name> dove è il valore specificato nella <name> proprietà di name.