Azure Tables-Eingabebindungen für Azure Functions

Artikel
10/06/2023

Verwenden Sie die Azure Tables-Eingabebindung, um eine Tabelle in Azure Cosmos DB for Table oder Azure Table Storage zu lesen.

Informationen zu Setup- und Konfigurationsdetails finden Sie in der Übersicht.

Wichtig

In diesem Artikel werden Registerkarten verwendet, um mehrere Versionen des Node.js-Programmiermodells zu unterstützen. Das v4-Modell ist allgemein verfügbar und bietet JavaScript- und TypeScript-Entwicklern eine flexiblere und intuitivere Erfahrung. Weitere Informationen zur Funktionsweise des v4-Modells finden Sie im Azure Functions Node.js-Entwicklerhandbuch. Weitere Informationen zu den Unterschieden zwischen v3 und v4 finden Sie im Migrationshandbuch.

Beispiel

Die Verwendung der Bindung hängt von der Version des Erweiterungspakets und der C#-Modalität ab, die in Ihrer Funktions-App verwendet wird. Dies kann eine der folgenden Modalitäten sein:

Isoliertes Workermodell
In-Process-Modell

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

Wählen Sie eine Version aus, um Beispiele für den Modus und die Version anzuzeigen.

Das folgende Beispiel zeigt eine C#-Funktion zum Lesen einer einzelnen Tabellenzeile. Die Funktion wird für jede an die Warteschlange gesendete Nachricht ausgelöst.

Der Zeilenschlüsselwert {queueTrigger} bindet den Zeilenschlüssel an die Nachrichtenmetadaten, d. h. die Nachrichtenzeichenfolge.

public class TableStorage
{
    public class MyPoco : 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; }
    }


    [FunctionName("TableInput")]
    public static void TableInput(
        [QueueTrigger("table-items")] string input, 
        [Table("MyTable", "MyPartition", "{queueTrigger}")] MyPoco poco, 
        ILogger log)
    {
        log.LogInformation($"PK={poco.PartitionKey}, RK={poco.RowKey}, Text={poco.Text}");
    }
}

Verwenden Sie einen TableClient-Methodenparameter, um die Tabelle unter Verwendung des Azure SDKs zu lesen. Hier finden Sie ein Beispiel einer Funktion, die eine Azure Functions-Protokolltabelle abfragt:

using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;
using Azure.Data.Tables;
using System;
using System.Threading.Tasks;
using Azure;
namespace FunctionAppCloudTable2
{
    public class LogEntity : ITableEntity
    {
        public string OriginalName { get; set; }

        public string PartitionKey { get; set; }
        public string RowKey { get; set; }
        public DateTimeOffset? Timestamp { get; set; }
        public ETag ETag { get; set; }
    }
    public static class CloudTableDemo
    {
        [FunctionName("CloudTableDemo")]
        public static async Task Run(
            [TimerTrigger("0 */1 * * * *")] TimerInfo myTimer,
            [Table("AzureWebJobsHostLogscommon")] TableClient tableClient,
            ILogger log)
        {
            log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
            AsyncPageable<LogEntity> queryResults = tableClient.QueryAsync<LogEntity>(filter: $"PartitionKey eq 'FD2' and RowKey gt 't'");
            await foreach (LogEntity entity in queryResults)
            {
                log.LogInformation($"{entity.PartitionKey}\t{entity.RowKey}\t{entity.Timestamp}\t{entity.OriginalName}");
            }
        }
    }
}

Weitere Informationen zur Verwendung von TableClient finden Sie in der TableClient.

Das folgende Beispiel zeigt eine C#-Funktion zum Lesen einer einzelnen Tabellenzeile. Die Funktion wird für jede an die Warteschlange gesendete Nachricht ausgelöst.

Der Zeilenschlüsselwert {queueTrigger} bindet den Zeilenschlüssel an die Nachrichtenmetadaten, d. h. die Nachrichtenzeichenfolge.

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

    [FunctionName("TableInput")]
    public static void TableInput(
        [QueueTrigger("table-items")] string input, 
        [Table("MyTable", "MyPartition", "{queueTrigger}")] MyPoco poco, 
        ILogger log)
    {
        log.LogInformation($"PK={poco.PartitionKey}, RK={poco.RowKey}, Text={poco.Text}");
    }
}

Verwenden Sie einen CloudTable-Methodenparameter, um die Tabelle unter Verwendung des Azure Storage SDKs zu lesen. Hier finden Sie ein Beispiel einer Funktion, die eine Azure Functions-Protokolltabelle abfragt:

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;
using Microsoft.Azure.Cosmos.Table;
using System;
using System.Threading.Tasks;

namespace FunctionAppCloudTable2
{
    public class LogEntity : TableEntity
    {
        public string OriginalName { get; set; }
    }
    public static class CloudTableDemo
    {
        [FunctionName("CloudTableDemo")]
        public static async Task Run(
            [TimerTrigger("0 */1 * * * *")] TimerInfo myTimer, 
            [Table("AzureWebJobsHostLogscommon")] CloudTable cloudTable,
            ILogger log)
        {
            log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");

            TableQuery<LogEntity> rangeQuery = new TableQuery<LogEntity>().Where(
                TableQuery.CombineFilters(
                    TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, 
                        "FD2"),
                    TableOperators.And,
                    TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThan, 
                        "t")));

            // Execute the query and loop through the results
            foreach (LogEntity entity in 
                await cloudTable.ExecuteQuerySegmentedAsync(rangeQuery, null))
            {
                log.LogInformation(
                    $"{entity.PartitionKey}\t{entity.RowKey}\t{entity.Timestamp}\t{entity.OriginalName}");
            }
        }
    }
}

Weitere Informationen zur Verwendung von „CloudTable“ finden Sie unter Erste Schritte mit Azure Table Storage.

Wenn Sie versuchen, eine Bindung an CloudTable herzustellen, und eine Fehlermeldung erhalten, stellen Sie sicher, dass ein Verweis auf CloudTable vorliegt.

Das folgende Beispiel zeigt eine C#-Funktion zum Lesen einer einzelnen Tabellenzeile. Die Funktion wird für jede an die Warteschlange gesendete Nachricht ausgelöst.

Der Zeilenschlüsselwert {queueTrigger} bindet den Zeilenschlüssel an die Nachrichtenmetadaten, d. h. die Nachrichtenzeichenfolge.

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

    [FunctionName("TableInput")]
    public static void TableInput(
        [QueueTrigger("table-items")] string input, 
        [Table("MyTable", "MyPartition", "{queueTrigger}")] MyPoco poco, 
        ILogger log)
    {
        log.LogInformation($"PK={poco.PartitionKey}, RK={poco.RowKey}, Text={poco.Text}");
    }
}

Das folgende Beispiel zeigt eine C#-Funktion, die mehrere Tabellenzeilen liest, wobei die MyPoco-Klasse von TableEntity abgeleitet wird.

public class TableStorage
{
    public class MyPoco : TableEntity
    {
        public string Text { get; set; }
    }

    [FunctionName("TableInput")]
    public static void TableInput(
        [QueueTrigger("table-items")] string input, 
        [Table("MyTable", "MyPartition")] IQueryable<MyPoco> pocos, 
        ILogger log)
    {
        foreach (MyPoco poco in pocos)
        {
            log.LogInformation($"PK={poco.PartitionKey}, RK={poco.RowKey}, Text={poco.Text}");
        }
    }
}

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, liest einen Zeilenschlüssel aus der Warteschlange, der verwendet wird, um die Zeile aus der Eingabetabelle abzurufen. Der Ausdruck {queueTrigger} bindet den Zeilenschlüssel an die Nachrichtenmetadaten, d. h. die Nachrichtenzeichenfolge.

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

Die folgende durch die Warteschlange ausgelöste Funktion gibt die ersten fünf Entitäten als IEnumerable<T> zurück, wobei der Partitionsschlüsselwert als Warteschlangennachricht festgelegt ist.

[Function("TestFunction")]
public static void Run([QueueTrigger("myqueue", Connection = "AzureWebJobsStorage")] string partition,
    [TableInput("inTable", "{queueTrigger}", Take = 5, Filter = "Text eq 'test'", 
    Connection = "AzureWebJobsStorage")] IEnumerable<MyTableData> tableInputs,
    FunctionContext context)
{
    var logger = context.GetLogger("TestFunction");
    logger.LogInformation(partition);
    foreach (MyTableData tableInput in tableInputs)
    {
        logger.LogInformation($"PK={tableInput.PartitionKey}, RK={tableInput.RowKey}, Text={tableInput.Text}");
    }
}

Die Eigenschaften Filter und Take werden verwendet, um die Anzahl der zurückgegebenen Entitäten zu begrenzen.

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

{
    var tableEntities = table.QueryAsync<TableEntity>(filter: $"RowKey eq '{rowKey}'");

    await foreach (TableEntity entity in tableEntities)
    {
        _logger.LogInformation("PK={pk}, RK={rk}, Text={t}", entity.PartitionKey, entity.RowKey, entity["Text"]);
    }

namespace SampleApp
{
    public class TableFunction
    {
        private readonly ILogger<TableFunction> _logger;

        public TableFunction(ILogger<TableFunction> logger)
        {
            _logger = logger;
        }

        /// <summary>
        /// This function demonstrates binding to a single <see cref="TableClient"/>
        /// and using the client for output.
        /// </summary>
        [Function(nameof(TableFunction))]
        public async Task Run(
            [QueueTrigger("table-items")] string rowKey,

Die folgende durch die Warteschlange ausgelöste Funktion gibt die ersten fünf Entitäten als IEnumerable<T> zurück, wobei der Partitionsschlüsselwert als Warteschlangennachricht festgelegt ist.

[Function("TestFunction")]
public static void Run([QueueTrigger("myqueue", Connection = "AzureWebJobsStorage")] string partition,
    [TableInput("inTable", "{queueTrigger}", Take = 5, Filter = "Text eq 'test'", 
    Connection = "AzureWebJobsStorage")] IEnumerable<MyTableData> tableInputs,
    FunctionContext context)
{
    var logger = context.GetLogger("TestFunction");
    logger.LogInformation(partition);
    foreach (MyTableData tableInput in tableInputs)
    {
        logger.LogInformation($"PK={tableInput.PartitionKey}, RK={tableInput.RowKey}, Text={tableInput.Text}");
    }
}

Die Eigenschaften Filter und Take werden verwendet, um die Anzahl der zurückgegebenen Entitäten zu begrenzen.

Das folgende Beispiel zeigt eine durch HTTP ausgelöste Funktion, die eine Liste mit Personenobjekte in einer angegebenen Partition in Table Storage zurückgibt. Bei diesem Beispiel wird der Partitionsschlüssel aus der HTTP-Route extrahiert, und „tableName“ und „connection“ stammen aus den Funktionseinstellungen.

public class Person {
    private String PartitionKey;
    private String RowKey;
    private String Name;

    public String getPartitionKey() { return this.PartitionKey; }
    public void setPartitionKey(String key) { this.PartitionKey = key; }
    public String getRowKey() { return this.RowKey; }
    public void setRowKey(String key) { this.RowKey = key; }
    public String getName() { return this.Name; }
    public void setName(String name) { this.Name = name; }
}

@FunctionName("getPersonsByPartitionKey")
public Person[] get(
        @HttpTrigger(name = "getPersons", methods = {HttpMethod.GET}, authLevel = AuthorizationLevel.FUNCTION, route="persons/{partitionKey}") HttpRequestMessage<Optional<String>> request,
        @BindingName("partitionKey") String partitionKey,
        @TableInput(name="persons", partitionKey="{partitionKey}", tableName="%MyTableName%", connection="MyConnectionString") Person[] persons,
        final ExecutionContext context) {

    context.getLogger().info("Got query for person related to persons with partition key: " + partitionKey);

    return persons;
}

Die Anmerkung TableInput kann auch, wie im folgenden Beispiel gezeigt, die Bindungen aus dem JSON-Text der Anforderung extrahieren.

@FunctionName("GetPersonsByKeysFromRequest")
public HttpResponseMessage get(
        @HttpTrigger(name = "getPerson", methods = {HttpMethod.GET}, authLevel = AuthorizationLevel.FUNCTION, route="query") HttpRequestMessage<Optional<String>> request,
        @TableInput(name="persons", partitionKey="{partitionKey}", rowKey = "{rowKey}", tableName="%MyTableName%", connection="MyConnectionString") Person person,
        final ExecutionContext context) {

    if (person == null) {
        return request.createResponseBuilder(HttpStatus.NOT_FOUND)
                    .body("Person not found.")
                    .build();
    }

    return request.createResponseBuilder(HttpStatus.OK)
                    .header("Content-Type", "application/json")
                    .body(person)
                    .build();
}

Das folgende Beispiel verwendet einen Filter zum Abfragen von Personen mit einem bestimmten Namen in einer Azure-Tabelle und begrenzt die Anzahl der möglichen Treffer auf 10 Ergebnisse.

@FunctionName("getPersonsByName")
public Person[] get(
        @HttpTrigger(name = "getPersons", methods = {HttpMethod.GET}, authLevel = AuthorizationLevel.FUNCTION, route="filter/{name}") HttpRequestMessage<Optional<String>> request,
        @BindingName("name") String name,
        @TableInput(name="persons", filter="Name eq '{name}'", take = "10", tableName="%MyTableName%", connection="MyConnectionString") Person[] persons,
        final ExecutionContext context) {

    context.getLogger().info("Got query for person related to persons with name: " + name);

    return persons;
}

Das folgende Beispiel zeigt eine Tabelleneingabebindung, die einen Warteschlangentrigger verwendet, um eine einzelne Tabellenzeile zu lesen. Die Bindung gibt einen partitionKey und einen rowKey an. Der rowKey-Wert „{queueTrigger}“ gibt an, dass der Zeilenschlüssel aus der Zeichenfolge der Warteschlangennachricht stammt.

Modell v4
Modell v3

import { app, input, InvocationContext } from '@azure/functions';

const tableInput = input.table({
    tableName: 'Person',
    partitionKey: 'Test',
    rowKey: '{queueTrigger}',
    connection: 'MyStorageConnectionAppSetting',
});

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

export async function storageQueueTrigger1(queueItem: unknown, context: InvocationContext): Promise<void> {
    context.log('Node.js queue trigger function processed work item', queueItem);
    const person = <PersonEntity>context.extraInputs.get(tableInput);
    context.log('Person entity name: ' + person.Name);
}

app.storageQueue('storageQueueTrigger1', {
    queueName: 'myqueue-items',
    connection: 'MyStorageConnectionAppSetting',
    extraInputs: [tableInput],
    handler: storageQueueTrigger1,
});

Modell v4
Modell v3

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

const tableInput = input.table({
    tableName: 'Person',
    partitionKey: 'Test',
    rowKey: '{queueTrigger}',
    connection: 'MyStorageConnectionAppSetting',
});

app.storageQueue('storageQueueTrigger1', {
    queueName: 'myqueue-items',
    connection: 'MyStorageConnectionAppSetting',
    extraInputs: [tableInput],
    handler: (queueItem, context) => {
        context.log('Node.js queue trigger function processed work item', queueItem);
        const person = context.extraInputs.get(tableInput);
        context.log('Person entity name: ' + person.Name);
    },
});

{
  "bindings": [
    {
      "queueName": "myqueue-items",
      "connection": "MyStorageConnectionAppSetting",
      "name": "myQueueItem",
      "type": "queueTrigger",
      "direction": "in"
    },
    {
      "name": "personEntity",
      "type": "table",
      "tableName": "Person",
      "partitionKey": "Test",
      "rowKey": "{queueTrigger}",
      "connection": "MyStorageConnectionAppSetting",
      "direction": "in"
    }
  ],
  "disabled": false
}

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.

Der JavaScript-Code sieht wie folgt aus:

module.exports = async function (context, myQueueItem) {
    context.log('Node.js queue trigger function processed work item', myQueueItem);
    context.log('Person entity name: ' + context.bindings.personEntity.Name);
};

Die folgende Funktion verwendet einen Warteschlangentrigger, um eine einzelne Tabellenzeile als Eingabe für eine Funktion zu lesen.

In diesem Beispiel gibt die Bindungskonfiguration einen expliziten Wert für den partitionKey der Tabelle an und verwendet einen Ausdruck, um diesen an den rowKey zu übergeben. Der rowKey-Ausdruck {queueTrigger} gibt an, dass der Zeilenschlüssel aus der Warteschlangennachricht-Zeichenfolge stammt.

Bindungskonfiguration in function.json:

{
  "bindings": [
    {
      "queueName": "myqueue-items",
      "connection": "MyStorageConnectionAppSetting",
      "name": "MyQueueItem",
      "type": "queueTrigger",
      "direction": "in"
    },
    {
      "name": "PersonEntity",
      "type": "table",
      "tableName": "Person",
      "partitionKey": "Test",
      "rowKey": "{queueTrigger}",
      "connection": "MyStorageConnectionAppSetting",
      "direction": "in"
    }
  ],
  "disabled": false
}

PowerShell-Code in run.ps1:

param($MyQueueItem, $PersonEntity, $TriggerMetadata)
Write-Host "PowerShell queue trigger function processed work item: $MyQueueItem"
Write-Host "Person entity name: $($PersonEntity.Name)"

Die folgende Funktion verwendet einen HTTP-Trigger, um eine einzelne Tabellenzeile als Eingabe für eine Funktion zu lesen.

In diesem Beispiel gibt die Bindungskonfiguration einen expliziten Wert für den partitionKey der Tabelle an und verwendet einen Ausdruck, um diesen an den rowKey zu übergeben. Der rowKey-Ausdruck {id} gibt an, dass der Zeilenschlüssel aus dem {id}-Teil der Route in der Anforderung stammt.

Bindungskonfiguration in der function.json-Datei:

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

Python-Code in der Datei __init__.py:

import json

import azure.functions as func

def main(req: func.HttpRequest, messageJSON) -> func.HttpResponse:

    message = json.loads(messageJSON)
    return func.HttpResponse(f"Table row: {messageJSON}")

Mit dieser einfachen Bindung können Sie einen Fall, in dem keine Zeile mit einer Zeilenschlüssel-ID gefunden wird, nicht programmgesteuert behandeln. Verwenden Sie für eine differenziertere Datenauswahl das Speicher-SDK.

Attribute

Sowohl C#-Bibliotheken des Typs In-Process als auch des Typs Isolierter Workerprozess verwenden Attribute zum Definieren der Funktion. Das C#-Skript verwendet stattdessen eine Konfigurationsdatei function.json, wie im C#-Skript-Handbuch beschrieben.

Isoliertes Workermodell
In-Process-Modell

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

Attributeigenschaft	BESCHREIBUNG
TableName	Der Name der Tabelle.
PartitionKey	Optional. Der Partitionsschlüssel der zu lesenden Tabellenentität.
Zeilenschlüssel	Optional. Der Zeilenschlüssel der zu lesenden Tabellenentität.
Take	Optional. Die maximale Anzahl von Entitäten, die in ein `IEnumerable<T>`-Objekt gelesen werden sollen. Kann nicht mit "`RowKey`" verwendet werden.
Filter	Optional. Ein OData-Filterausdruck für Entitäten, die in ein `IEnumerable<T>`-Objekt gelesen werden sollen. Kann nicht mit "`RowKey`" verwendet werden.
Connection	Der Name einer App-Einstellung oder Einstellungssammlung, die angibt, wie eine Verbindung mit dem Tabellendienst hergestellt wird. Siehe Verbindungen.

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

Attributeigenschaft	BESCHREIBUNG
TableName	Der Name der Tabelle.
PartitionKey	Optional. Der Partitionsschlüssel der zu lesenden Tabellenentität. Informationen zur Verwendung dieser Eigenschaft finden Sie im Abschnitt Verwendung.
Zeilenschlüssel	Optional. Der Zeilenschlüssel einer zu lesenden einzelnen Tabellenentität. Kann nicht mit `Take` oder `Filter` verwendet werden.
Take	Optional. Die maximale Anzahl der zurückzugebenden Nachrichten. Kann nicht mit "`RowKey`" verwendet werden.
Filter	Optional. Ein OData-Filterausdruck für die Entitäten, die aus der Tabelle zurückgegeben werden sollen. Kann nicht mit "`RowKey`" verwendet werden.
Connection	Der Name einer App-Einstellung oder Einstellungssammlung, die angibt, wie eine Verbindung mit dem Tabellendienst hergestellt wird. Siehe Verbindungen.

Der Konstruktor des Attributs nimmt den Tabellennamen, den Partitionsschlüssel und den Zeilenschlüssel an, wie im folgenden Beispiel gezeigt:

[FunctionName("TableInput")]
public static void Run(
    [QueueTrigger("table-items")] string input, 
    [Table("MyTable", "Http", "{queueTrigger}")] MyPoco poco, 
    ILogger log)
{
    ...
}

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

[FunctionName("TableInput")]
public static void Run(
    [QueueTrigger("table-items")] string input, 
    [Table("MyTable", "Http", "{queueTrigger}", Connection = "StorageConnectionAppSetting")] MyPoco poco, 
    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.

Anmerkungen

Verwenden Sie die @TableInput-Anmerkung in der Laufzeitbibliothek für Java-Funktionen für Parameter, deren Wert von Table Storage empfangen wird. Diese Anmerkung kann mit nativen Java-Typen, POJOs oder Werten mit Optional<T>, die NULL-Werte annehmen können, verwendet werden. Diese Anmerkung unterstützt die folgenden Elemente:

Element	BESCHREIBUNG
name	Der Name der Variablen, die die Tabelle oder Entität im Funktionscode darstellt.
tableName	Der Name der Tabelle.
partitionKey	Optional. Der Partitionsschlüssel der zu lesenden Tabellenentität.
rowKey	Optional. Der Zeilenschlüssel der zu lesenden Tabellenentität.
take	Optional. Die maximale Anzahl der zu lesenden Nachrichten.
Filter	Optional. Ein OData-Filterausdruck für die Tabelleneingabe.
Verbindung	Der Name einer App-Einstellung oder Einstellungssammlung, die angibt, wie eine Verbindung mit dem Tabellendienst hergestellt wird. Siehe Verbindungen.

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

Eigenschaft	Beschreibung
tableName	Der Name der Tabelle.
partitionKey	Optional. Der Partitionsschlüssel der zu lesenden Tabellenentität.
rowKey	Optional. Der Zeilenschlüssel der zu lesenden Tabellenentität. Kann nicht mit `take` oder `filter` verwendet werden.
take	Optional. Die maximale Anzahl der zurückzugebenden Nachrichten. Kann nicht mit "`rowKey`" verwendet werden.
filter	Optional. Ein OData-Filterausdruck für die Entitäten, die aus der Tabelle zurückgegeben werden sollen. Kann nicht mit "`rowKey`" verwendet werden.
connection	Der Name einer App-Einstellung oder Einstellungssammlung, die angibt, wie eine Verbindung mit dem Tabellendienst hergestellt wird. Siehe Verbindungen.

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

Eigenschaft	Beschreibung des Dataflows
type	Muss auf `table` festgelegt sein. Diese Eigenschaft wird automatisch festgelegt, wenn Sie die Bindung im Azure Portal erstellen.
direction	Muss auf `in` festgelegt sein. Diese Eigenschaft wird automatisch festgelegt, wenn Sie die Bindung im Azure Portal erstellen.
name	Der Name der Variablen, die die Tabelle oder Entität im Funktionscode darstellt.
tableName	Der Name der Tabelle.
partitionKey	Optional. Der Partitionsschlüssel der zu lesenden Tabellenentität.
rowKey	Optional. Der Zeilenschlüssel der zu lesenden Tabellenentität. Kann nicht mit `take` oder `filter` verwendet werden.
take	Optional. Die maximale Anzahl der zurückzugebenden Nachrichten. Kann nicht mit "`rowKey`" verwendet werden.
filter	Optional. Ein OData-Filterausdruck für die Entitäten, die aus der Tabelle zurückgegeben werden sollen. Kann nicht mit "`rowKey`" verwendet werden.
connection	Der Name einer App-Einstellung oder Einstellungssammlung, die angibt, wie eine Verbindung mit dem Tabellendienst hergestellt wird. Siehe Verbindungen.

Konfiguration

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

function.json-Eigenschaft	BESCHREIBUNG
type	Muss auf `table` festgelegt sein. Diese Eigenschaft wird automatisch festgelegt, wenn Sie die Bindung im Azure Portal erstellen.
direction	Muss auf `in` festgelegt sein. Diese Eigenschaft wird automatisch festgelegt, wenn Sie die Bindung im Azure Portal erstellen.
name	Der Name der Variablen, die die Tabelle oder Entität im Funktionscode darstellt.
tableName	Der Name der Tabelle.
partitionKey	Optional. Der Partitionsschlüssel der zu lesenden Tabellenentität.
rowKey	Optional. Der Zeilenschlüssel der zu lesenden Tabellenentität. Kann nicht mit `take` oder `filter` verwendet werden.
take	Optional. Die maximale Anzahl der zurückzugebenden Nachrichten. Kann nicht mit "`rowKey`" verwendet werden.
filter	Optional. Ein OData-Filterausdruck für die Entitäten, die aus der Tabelle zurückgegeben werden sollen. Kann nicht mit "`rowKey`" verwendet werden.
connection	Der Name einer App-Einstellung oder Einstellungssammlung, die angibt, wie eine Verbindung mit dem Tabellendienst hergestellt wird. Siehe Verbindungen.

Wenn Sie die Entwicklung lokal ausführen, fügen Sie Ihre Anwendungseinstellungen in der Datei local.settings.json in der Values-Sammlung hinzu.

Verbindungen

Die connection-Eigenschaft ist ein Verweis auf eine Umgebungskonfiguration, die angibt, wie sich die App mit Ihrem Tabellendienst verbinden soll. Folgendes kann angegeben werden:

Der Name einer Anwendungseinstellung, die eine Verbindungszeichenfolge enthält.
Der Name eines gemeinsamen Präfixes für mehrere Anwendungseinstellungen, die zusammen eine identitätsbasierte Verbindung definieren.

Wenn der konfigurierte Wert sowohl eine genaue Übereinstimmung für eine einzelne Einstellung als auch eine Präfix-Übereinstimmung für andere Einstellungen ist, wird die genaue Übereinstimmung verwendet.

Verbindungszeichenfolge

Um eine Verbindungszeichenfolge für Tabellen im Azure Table-Speicher abzurufen, folgen Sie den Schritten unter Verwaltung der Zugriffsschlüssel für Speicherkonten. Um eine Verbindungszeichenfolge für Tabellen in Azure Cosmos DB for Table abzurufen, führen Sie die Schritte aus, die im FAQ zu Azure Cosmos DB for Table gezeigt werden.

Diese Verbindungszeichenfolge sollte in einer Anwendungseinstellung mit einem Namen gespeichert werden, der dem in der Eigenschaft connection der Bindungskonfiguration angegebenen Wert entspricht.

Falls der Name der App-Einstellung mit „AzureWebJobs“ beginnt, können Sie hier nur den Rest des Namens angeben. Wenn Sie connection also beispielsweise auf „MyStorage“ festlegen, sucht die Functions-Laufzeit nach einer App-Einstellung namens „AzureWebJobsMyStorage“. Ohne Angabe für connection verwendet die Functions-Laufzeit die standardmäßige Storage-Verbindungszeichenfolge aus der App-Einstellung AzureWebJobsStorage.

Identitätsbasierte Verbindungen

Wenn Sie die Tabellen-API-Erweiterung verwenden, können Sie die App statt einer Verbindungszeichenfolge mit einem Geheimnis eine Microsoft Entra-Identität verwenden lassen. Dies gilt nur für den Zugriff auf Tabellen in Azure Storage. Um eine Identität zu verwenden, definieren Sie Einstellungen unter einem gemeinsamen Präfix, das der Eigenschaft connection in der Trigger- und Bindungskonfiguration zugeordnet ist.

Wenn Sie connection auf „AzureWebJobsStorage“ festlegen, finden Sie weitere Informationen unter Herstellen einer Verbindung zum Hostspeicher mit einer Identität. Für alle anderen Verbindungen erfordert die Erweiterung die folgenden Eigenschaften:

Eigenschaft	Vorlage für Umgebungsvariable	BESCHREIBUNG	Beispielwert
Tabellendienst-URI	`<CONNECTION_NAME_PREFIX>__tableServiceUri`¹	Dies ist der Datenebenen-URI des Azure Storage-Tabellendiensts, mit dem Sie mithilfe des HTTPS-Schemas eine Verbindung herstellen.	https://<speicherkonto_name>.table.core.windows.net

¹ <CONNECTION_NAME_PREFIX>__serviceUri kann als Alias verwendet werden. Wenn beide Formate bereitgestellt werden, wird das Format tableServiceUri verwendet. Das Format serviceUri kann nicht verwendet werden, wenn die gesamte Verbindungskonfiguration über Blobs, Warteschlangen und/oder Tabellen hinweg verwendet werden soll.

Andere Eigenschaften können festgelegt werden, um die Verbindung anzupassen. Weitere Informationen finden Sie unter Allgemeine Eigenschaften für identitätsbasierte Verbindungen.

Das Format serviceUri kann nicht verwendet werden, wenn die gesamte Verbindungskonfiguration über Blobs, Warteschlangen und/oder Tabellen in Azure Storage hinweg verwendet werden soll. Der URI kann nur den Tabellendienst bezeichnen. Alternativ können Sie einen URI speziell für jeden Dienst unter dem gleichen Präfix bereitstellen, sodass eine einzelne Verbindung verwendet werden kann.

Identitätsbasierte Verbindungen verwenden eine verwaltete Identität, wenn sie im Azure Functions-Dienst gehostet werden. Standardmäßig wird eine vom System zugewiesene Identität verwendet, auch wenn mit den Eigenschaften credential und clientID eine vom Benutzer zugewiesene Identität angegeben werden kann. Beachten Sie, dass das Konfigurieren einer benutzerseitig zugewiesenen Identität mit einer Ressourcen-ID nicht unterstützt wird. Bei Ausführung in anderen Kontexten (z. B. bei der lokalen Entwicklung) wird stattdessen Ihre Entwickleridentität verwendet, Dieses Verhalten kann angepasst werden. Weitere Informationen finden Sie unter Lokale Entwicklung mit identitätsbasierten Verbindungen.

Erteilen der Berechtigung für die Identität

Unabhängig davon, welche Identität verwendet wird, muss diese über Berechtigungen zum Ausführen der vorgesehenen Aktionen verfügen. Daher müssen Sie für die meisten Azure-Dienste eine Rolle in Azure RBAC zuweisen, indem Sie entweder integrierte oder benutzerdefinierte Rollen verwenden, die diese Berechtigungen bieten.

Wichtig

Vom Zieldienst werden möglicherweise einige nicht für alle Kontexte erforderliche Berechtigungen verfügbar gemacht. Befolgen Sie nach Möglichkeit das Prinzip der geringsten Berechtigung, und gewähren Sie der Identität nur die erforderlichen Berechtigungen. Wenn die App beispielsweise nur Daten aus einer Datenquelle lesen muss, verwenden Sie eine Rolle, die nur über Leseberechtigungen verfügt. Es wäre nicht angemessen, eine Rolle zu zuweisen, die auch das Schreiben in diesen Dienst zulässt, da dies eine übermäßige Berechtigung für einen Lesevorgang wäre. Ebenso sollten Sie sicherstellen, dass die Rollenzuweisung auf die Ressourcen begrenzt ist, die gelesen werden müssen.

Sie müssen eine Rollenzuweisung erstellen, die zur Laufzeit Zugriff auf Ihren Azure Storage-Tabellendienst bereitstellt. Verwaltungsrollen wie Besitzer sind nicht ausreichend. Die folgende Tabelle zeigt integrierte Rollen, die für den normalen Betrieb mit der Azure Tables-Erweiterung für Azure Storage empfohlen werden. Ihre Anwendung erfordert möglicherweise zusätzliche Berechtigungen basierend auf dem von Ihnen geschriebenen Code.

Bindungstyp	Beispiel für integrierte Rollen (Azure Storage¹)
Eingabebindung	Storage-Tabellendatenleser
Ausgabebindung	Mitwirkender an Storage-Tabellendaten

¹ Wenn Ihre App stattdessen eine Verbindung mit Tabellen in Azure Cosmos DB for Table herstellt, wird die Verwendung einer Identität nicht unterstützt, und die Verbindung muss eine Verbindungszeichenfolge verwenden.

Verbrauch

Die Verwendung der Bindung hängt von der Version des Erweiterungspakets und der C#-Modalität ab, die in Ihrer Funktions-App verwendet wird. Dies kann eine der folgenden Modalitäten sein:

Isoliertes Workermodell
In-Process-Modell

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

Wählen Sie eine Version aus, um Syntaxdetails für den Modus und die Version anzuzeigen.

Um eine bestimmte Entität nach Schlüssel zurückzugeben, verwenden Sie einen Bindungsparameter, der von TableEntity abgeleitet wird. Die spezifischen TableName-, PartitionKey- und RowKey-Objekte werden verwendet, um zu versuchen, eine bestimmte Entität aus der Tabelle abzurufen.

Um Abfragen auszuführen, die mehrere Entitäten zurückgeben, verwenden Sie eine Bindung an ein IQueryable<T>-Objekt mit einem Typ, der von IQueryable<T> erbt.

Wenn Sie mit einer einzelnen Tabellenentität arbeiten, kann die Azure Tables-Eingabebindung an die folgenden Typen gebunden werden:

type	BESCHREIBUNG
Einen serialisierbaren JSON-Typ, der ITableEntity implementiert.	Functions versucht, die Entität in einen POCO-Typ (Plain-Old CLR Object) zu deserialisieren. Der Typ muss ITableEntity implementieren oder über eine Zeichenfolgeneigenschaft `RowKey` und eine Zeichenfolgeneigenschaft `PartitionKey` verfügen.
TableEntity¹	Die Entität als wörterbuchähnlicher Typ.

Beim Arbeiten mit mehreren Entitäten aus einer Abfrage kann die Azure Tables-Eingabebindung an die folgenden Typen gebunden werden:

type	BESCHREIBUNG
`IEnumerable<T>`, wobei `T`ITableEntity implementiert.	Eine Enumeration von Entitäten, die von der Abfrage zurückgegeben werden. Jeder Eintrag stellt eine Entität dar. Der Typ `T` muss ITableEntity implementieren oder über eine Zeichenfolgeneigenschaft `RowKey` und eine Zeichenfolgeneigenschaft `PartitionKey` verfügen.
TableClient¹	Ein Client, der mit der Tabelle verbunden ist. Dies bietet die größte Kontrolle für die Verarbeitung der Tabelle und kann zum Schreiben in die Tabelle verwendet werden, wenn die Verbindung über ausreichende Berechtigungen verfügt.

¹ Um diese Typen zu verwenden, müssen Sie auf Microsoft.Azure.Functions.Worker.Extensions.Tables 1.2.0 oder höher und die gemeinsamen Abhängigkeiten für SDK-Typbindungen verweisen.

Um eine bestimmte Entität nach Schlüssel zurückzugeben, verwenden Sie ein einfaches altbekanntes CLR-Objekt (POCO). Die spezifischen TableName-, PartitionKey- und RowKey-Objekte werden verwendet, um zu versuchen, eine bestimmte Entität aus der Tabelle abzurufen.

Wenn Sie mehrere Entitäten als IEnumerable<T>zurückgeben, können Sie stattdessen die Take- und Filter-Eigenschaften verwenden, um das Resultset einzuschränken.

Das TableInput-Attribut gewährt Ihnen Zugriff auf die Tabellenzeile, die die Funktion ausgelöst hat.

Modell v4
Modell v3

Rufen Sie die Eingabezeilendaten mithilfe von context.extraInputs.get() ab.

Daten werden an den Eingabeparameter übergeben, so wie durch den name-Schlüssel in der name-Datei angegeben. Durch Angabe von partitionKey und rowKey können Sie nach bestimmten Datensätzen filtern.

Tabellendaten werden als JSON-Zeichenfolge an die Funktion übergeben. Deserialisieren Sie die Nachricht durch Aufrufen von json.loads, wie im Eingabejson.loads gezeigt.

Spezifische Syntaxdetails finden Sie unter Beispiel.

Nächste Schritte

Schreiben von Tabellendaten aus einer Funktion

Freigeben über

Azure Tables-Eingabebindungen für Azure Functions

Beispiel

Attribute

Anmerkungen

Konfiguration

Konfiguration

Verbindungen

Verbindungszeichenfolge

Identitätsbasierte Verbindungen

Erteilen der Berechtigung für die Identität

Verbrauch

Nächste Schritte

Feedback

Zusätzliche Ressourcen