Azure Tables-Ausgabebindungen für Azure Functions

Die folgende MyTableData-Klasse stellt eine Datenzeile in der Tabelle dar:

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

Die folgende Funktion, die von einem Queue Storage-Trigger gestartet wird, schreibt eine neue MyDataTable-Entität in eine Tabelle mit dem Namen 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}"
    };
}

Das folgende Beispiel zeigt eine C#-Funktion mit einem HTTP-Trigger zum Schreiben einer einzelnen Tabellenzeile.

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

TypeScript-Beispiele sind für Modell v3 nicht dokumentiert.

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

Die Datei function.json sieht wie folgt aus:

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

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.

Der JavaScript-Code sieht wie folgt aus:

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

Die folgende Funktion generiert eine eindeutige UUI für den rowKey-Wert und speichert die Nachricht dauerhaft im Tabellenspeicher.

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

Die folgende Funktion generiert eine eindeutige UUI für den rowKey-Wert und speichert die Nachricht dauerhaft im Tabellenspeicher.

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

In C#-Klassenbibliotheken unterstützt TableInputAttribute die folgenden Eigenschaften:

In C#-Klassenbibliotheken unterstützt TableAttribute die folgenden Eigenschaften:

Der Konstruktor des Attributs akzeptiert den Tabellennamen. Verwenden Sie das Attribut für einen out-Parameter oder für den Rückgabewert der Funktion, wie im folgenden Beispiel gezeigt:

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

Sie können die Connection-Eigenschaft festlegen, um eine Verbindung mit dem Tabellendienst anzugeben, wie im folgenden Beispiel gezeigt:

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

Während das Attribut eine Connection-Eigenschaft annimmt, können Sie auch Connection verwenden, um eine Speicherkontoverbindung anzugeben. Sie können so vorgehen, wenn Sie ein anderes Speicherkonto als andere Funktionen in der Bibliothek verwenden müssen. Der Konstruktor akzeptiert den Namen einer App-Einstellung mit einer Speicherverbindungszeichenfolge. Das Attribut kann auf Parameter-, Methoden- oder Klassenebene angewendet werden. Das folgende Beispiel zeigt die Anwendung auf Klassen- und Methodenebene:

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

Das zu verwendende Speicherkonto wird anhand von Folgendem bestimmt (in der angegebenen Reihenfolge):

• Die Connection-Eigenschaft des Triggers oder Bindungsattributs.
• Das StorageAccount-Attribut, das auf den gleichen Parameter wie der Trigger oder das Bindungsattribut angewendet wird.
• Das Attribut StorageAccount, das auf die Funktion angewendet wird.
• Das Attribut StorageAccount, das auf die Klasse angewendet wird.
• Das Standardspeicherkonto für die Funktions-App, das in der AzureWebJobsStorage-Anwendungseinstellung definiert ist.

In der folgenden Tabelle werden die Eigenschaften erläutert, die Sie für das options-Objekt festlegen können, das an die output.table()-Methode übergeben wurde.

Die folgende Tabelle gibt Aufschluss über die Bindungskonfigurationseigenschaften, die Sie in der Datei function.json festlegen.

Eine Klassenbibliothek in einem isolierten Workerprozess ist eine kompilierte C#-Funktion, die in einem von der Runtime isolierten Prozess ausgeführt wird.

Eine In-Process-Klassenbibliothek ist eine kompilierte C#-Funktion, die im gleichen Prozess wie die Functions-Runtime ausgeführt wird.

Die folgenden Typen werden für out-Parameter und -Rückgabetypen unterstützt:

• Ein einfaches altbekanntes CLR-Objekt (POCO), das die PartitionKey- und RowKey-Eigenschaften enthält. Sie können diese Eigenschaften begleiten, indem Sie ITableEntity implementieren.
• ICollector<T> oder IAsyncCollector<T>, wobei T die PartitionKey- und RowKey-Eigenschaft enthält. Sie können diese Eigenschaften begleiten, indem Sie ITableEntity implementieren.

Sie können auch eine Bindung an das Azure SDK ausführen TableClient. Anschließend können Sie dieses Objekt verwenden, um in die Tabelle zu schreiben.

Die folgenden Typen werden für out-Parameter und -Rückgabetypen unterstützt:

• Ein einfaches altbekanntes CLR-Objekt (POCO), das die PartitionKey- und RowKey-Eigenschaften enthält. Sie können diese Eigenschaften begleiten, indem Sie ITableEntity implementieren oder von TableEntity erben.
• ICollector<T> oder IAsyncCollector<T>, wobei T die PartitionKey- und RowKey-Eigenschaft enthält. Sie können diese Eigenschaften begleiten, indem Sie ITableEntity implementieren oder von TableEntity erben.

Sie können auch als Methodenparameter an CloudTabledas Storage SDK binden. Anschließend können Sie dieses Objekt verwenden, um in die Tabelle zu schreiben.

Die folgenden Typen werden für out-Parameter und -Rückgabetypen unterstützt:

• Ein einfaches altbekanntes CLR-Objekt (POCO), das die PartitionKey- und RowKey-Eigenschaften enthält. Sie können diese Eigenschaften begleiten, indem Sie ITableEntity implementieren oder von TableEntity erben.
• ICollector<T> oder IAsyncCollector<T>, wobei T die PartitionKey- und RowKey-Eigenschaft enthält. Sie können diese Eigenschaften begleiten, indem Sie ITableEntity implementieren oder von TableEntity erben.

Sie können auch als Methodenparameter an CloudTabledas Storage SDK binden. Anschließend können Sie dieses Objekt verwenden, um in die Tabelle zu schreiben.

Wenn die Funktion in eine einzelne Entität schreiben soll, kann die Blobausgabebindung an die folgenden Typen gebunden werden:

Wenn die Funktion in mehrere Entitäten schreiben soll, kann die Blobausgabebindung an die folgenden Typen gebunden werden:

Erstellen und verwenden Sie für andere Ausgabeszenarien einen TableClient mit anderen Typen aus Azure.Data.Tables direkt. Ein Beispiel für die Verwendung der Abhängigkeitsinjektion zum Erstellen eines Clienttyps aus dem Azure SDK finden Sie unter Registrieren von Azure-Clients .

Gibt ein einfaches altbekanntes CLR-Objekt (POCO) mit Eigenschaften zurück, die der Tabellenentität zugeordnet werden können.

Die Azure Functions-Version 1.x unterstützt keinen isolierten Workerprozess.

Legen Sie die Ausgabezeilendaten fest, indem Sie den Wert zurückgeben oder context.extraOutputs.set() verwenden.

Legen Sie mithilfe von context.bindings.<name> die Daten der Ausgabezeile ab, wobei <name> der in der name-Eigenschaft von function.json angegebene Wert ist.