Azure Tables-invoerbindingen voor Azure Functions

Een geïsoleerde werkprocesklassebibliotheek gecompileerde C#-functie wordt uitgevoerd in een proces dat is geïsoleerd van de runtime.

Een in-process-klassebibliotheek is een gecompileerde C#-functie die wordt uitgevoerd in hetzelfde proces als de Functions-runtime.

In het volgende voorbeeld ziet u een C#-functie die één tabelrij leest. Voor elk bericht dat naar de wachtrij wordt verzonden, wordt de functie geactiveerd.

De rijsleutelwaarde {queueTrigger} verbindt de rijsleutel met de metagegevens van het bericht. Dit is de berichttekenreeks.

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

Gebruik een TableClient methodeparameter om de tabel te lezen met behulp van de Azure SDK. Hier volgt een voorbeeld van een functie waarmee een query wordt uitgevoerd op een Azure Functions-logboektabel:

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

Zie de NaslaginformatieTableClientgebruik.

In het volgende voorbeeld ziet u een C#-functie die één tabelrij leest. Voor elk bericht dat naar de wachtrij wordt verzonden, wordt de functie geactiveerd.

De rijsleutelwaarde {queueTrigger} verbindt de rijsleutel met de metagegevens van het bericht. Dit is de berichttekenreeks.

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

Gebruik een CloudTable methodeparameter om de tabel te lezen met behulp van de Azure Storage SDK. Hier volgt een voorbeeld van een functie waarmee een query wordt uitgevoerd op een Azure Functions-logboektabel:

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

Zie Aan de slag met Azure Table Storage voor meer informatie over het gebruik van CloudTable.

Als u verbinding probeert te CloudTable maken en een foutbericht wilt ontvangen, controleert u of u een verwijzing hebt naar de juiste Storage SDK-versie.

In het volgende voorbeeld ziet u een C#-functie die één tabelrij leest. Voor elk bericht dat naar de wachtrij wordt verzonden, wordt de functie geactiveerd.

De rijsleutelwaarde {queueTrigger} verbindt de rijsleutel met de metagegevens van het bericht. Dit is de berichttekenreeks.

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

In het volgende voorbeeld ziet u een C#-functie die meerdere tabelrijen leest waaruit de MyPoco klasse is TableEntityafgeleid.

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

De volgende MyTableData klasse vertegenwoordigt een rij met gegevens in de tabel:

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

De volgende functie, die wordt gestart door een Queue Storage-trigger, leest een rijsleutel uit de wachtrij, die wordt gebruikt om de rij op te halen uit de invoertabel. De expressie {queueTrigger} verbindt de rijsleutel met de metagegevens van het bericht, de berichttekenreeks.

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

De volgende door wachtrij geactiveerde functie retourneert de eerste vijf entiteiten als een IEnumerable<T>, waarbij de waarde van de partitiesleutel is ingesteld als het wachtrijbericht.

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

De Filter en Take eigenschappen worden gebruikt om het aantal geretourneerde entiteiten te beperken.

De volgende MyTableData klasse vertegenwoordigt een rij met gegevens in de tabel:

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

De volgende functie, die wordt gestart door een Queue Storage-trigger, leest een rijsleutel uit de wachtrij, die wordt gebruikt om de rij op te halen uit de invoertabel. De expressie {queueTrigger} verbindt de rijsleutel met de metagegevens van het bericht, de berichttekenreeks.

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,

De volgende door wachtrij geactiveerde functie retourneert de eerste vijf entiteiten als een IEnumerable<T>, waarbij de waarde van de partitiesleutel is ingesteld als het wachtrijbericht.

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

De Filter en Take eigenschappen worden gebruikt om het aantal geretourneerde entiteiten te beperken.

Functions versie 1.x biedt geen ondersteuning voor geïsoleerd werkproces.

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

TypeScript-voorbeelden worden niet gedocumenteerd voor model 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
}

In de configuratiesectie worden deze eigenschappen uitgelegd.

Dit is de JavaScript-code:

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

import json
import azure.functions as func

app = func.FunctionApp()

@app.route(route="messages/{id}")
@app.table_input(arg_name="messageJSON",
                 connection="AzureWebJobsStorage",
                 table_name="messages",
                 row_key='{id}',
                 partition_key="message")
def table_in_binding(req: func.HttpRequest, messageJSON):
    message = json.loads(messageJSON)
    return func.HttpResponse(f"Table row: {messageJSON}")

Met deze eenvoudige binding kunt u niet programmatisch omgaan met een geval waarin geen rij met een rijsleutel-id wordt gevonden. Gebruik de opslag-SDK voor meer verfijnde gegevensselectie.

Bindingsconfiguratie in het function.json-bestand :

{
  "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 het bestand __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}")

Met deze eenvoudige binding kunt u niet programmatisch omgaan met een geval waarin geen rij met een rijsleutel-id wordt gevonden. Gebruik de opslag-SDK voor meer verfijnde gegevensselectie.

In C#-klassebibliotheken ondersteunt de TableInputAttribute volgende eigenschappen:

In C#-klassebibliotheken ondersteunt de TableAttribute volgende eigenschappen:

De constructor van het kenmerk gebruikt de tabelnaam, partitiesleutel en rijsleutel, zoals wordt weergegeven in het volgende voorbeeld:

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

U kunt de Connection eigenschap instellen om de verbinding met de tabelservice op te geven, zoals wordt weergegeven in het volgende voorbeeld:

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

Hoewel het kenmerk een Connection eigenschap neemt, kunt u ook storageAccountAttribute gebruiken om een opslagaccountverbinding op te geven. U kunt dit doen wanneer u een ander opslagaccount moet gebruiken dan andere functies in de bibliotheek. De constructor gebruikt de naam van een app-instelling die een opslag-verbindingsreeks bevat. Het kenmerk kan worden toegepast op het niveau van de parameter, methode of klasse. In het volgende voorbeeld ziet u klasseniveau en methodeniveau:

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

Het te gebruiken opslagaccount wordt in de volgende volgorde bepaald:

• De eigenschap van Connection het trigger- of bindingskenmerk.
• Het StorageAccount kenmerk dat is toegepast op dezelfde parameter als het trigger- of bindingskenmerk.
• Het StorageAccount kenmerk dat is toegepast op de functie.
• Het StorageAccount kenmerk dat is toegepast op de klasse.
• Het standaardopslagaccount voor de functie-app, dat is gedefinieerd in de AzureWebJobsStorage toepassingsinstelling.

In de volgende tabel worden de eigenschappen uitgelegd die u kunt instellen voor het options object dat aan de input.table() methode is doorgegeven.

In de volgende tabel worden de bindingsconfiguratie-eigenschappen uitgelegd die u in het function.json-bestand hebt ingesteld.

Een geïsoleerde werkprocesklassebibliotheek gecompileerde C#-functie wordt uitgevoerd in een proces dat is geïsoleerd van de runtime.

Een in-process-klassebibliotheek is een gecompileerde C#-functie die wordt uitgevoerd in hetzelfde proces als de Functions-runtime.

Als u een specifieke entiteit per sleutel wilt retourneren, gebruikt u een bindingsparameter die is afgeleid van TableEntity.

Als u query's wilt uitvoeren die meerdere entiteiten retourneren, bindt u aan een [TableClient]-object. U kunt dit object vervolgens gebruiken om query's te maken en uit te voeren op basis van de afhankelijke tabel. [TableClient] en gerelateerde API's behoren tot de naamruimte Azure.Data.Tables .

Als u een specifieke entiteit per sleutel wilt retourneren, gebruikt u een bindingsparameter die is afgeleid van TableEntity.

Als u query's wilt uitvoeren die meerdere entiteiten retourneren, bindt u met een CloudTable-object . U kunt dit object vervolgens gebruiken om query's te maken en uit te voeren op basis van de afhankelijke tabel. Houd er rekening mee dat CloudTable en gerelateerde API's deel uitmaken van de naamruimte Microsoft.Azure.Cosmos.Table .

Als u een specifieke entiteit per sleutel wilt retourneren, gebruikt u een bindingsparameter die is afgeleid van TableEntity. De specifieke TableName, PartitionKeyen RowKey worden gebruikt om een specifieke entiteit uit de tabel op te halen.

Als u query's wilt uitvoeren die meerdere entiteiten retourneren, bindt u aan een IQueryable<T> type dat wordt overgenomen van TableEntity.

Wanneer u met één tabelentiteit werkt, kan de Azure Tables-invoerbinding worden gekoppeld aan de volgende typen:

Wanneer u met meerdere entiteiten vanuit een query werkt, kan de Azure Tables-invoerbinding worden gekoppeld aan de volgende typen:

¹ Als u deze typen wilt gebruiken, moet u verwijzen naar Microsoft.Azure.Functions.Worker.Extensions.Tables 1.2.0 of hoger en de algemene afhankelijkheden voor SDK-typebindingen.

Als u een specifieke entiteit per sleutel wilt retourneren, gebruikt u een normaal oud CLR-object (POCO). De specifieke TableName, PartitionKeyen RowKey worden gebruikt om een specifieke entiteit uit de tabel op te halen.

Wanneer u meerdere entiteiten als een entiteit IEnumerable<T>retourneert, kunt u in plaats daarvan eigenschappen gebruiken Take en Filter de resultatenset beperken.

Functions versie 1.x biedt geen ondersteuning voor geïsoleerd werkproces.

Haal de invoerrijgegevens op met behulp van context.extraInputs.get().

Haal de invoerrijgegevens op met behulp van context.bindings.<name> waar <name> de waarde is opgegeven in de name eigenschap van function.json.