Azure Tables bemeneti kötések az Azure Functionshez

Az Azure Tables bemeneti kötésével beolvashat egy táblát az Azure Cosmos DB for Table vagy az Azure Table Storage szolgáltatásban.

A beállítással és a konfigurációval kapcsolatos információkért tekintse meg az áttekintést.

Fontos

Ez a cikk lapokat használ a Node.js programozási modell több verziójának támogatásához. A v4-modell általánosan elérhető, és úgy lett kialakítva, hogy rugalmasabb és intuitívabb felhasználói élményt nyújtson JavaScript- és TypeScript-fejlesztők számára. A v4-modell működésével kapcsolatos további információkért tekintse meg az Azure Functions Node.js fejlesztői útmutatóját. A v3 és a v4 közötti különbségekről a migrálási útmutatóban olvashat bővebben.

Példa

A kötés használata a bővítménycsomag verziójától és a függvényalkalmazásban használt C# modalitástól függ, amely az alábbiak egyike lehet:

Izolált feldolgozói modell

A C# függvényt lefordított izolált feldolgozói folyamatosztály-kódtár a futtatókörnyezettől elkülönített folyamatban fut.

Folyamaton belüli modell

Fontos

A folyamaton belüli modell támogatása 2026. november 10-én megszűnik. Erősen javasoljuk, hogy az alkalmazásokat az elkülönített feldolgozói modellbe migrálja a teljes támogatás érdekében.

A folyamatközi osztálykódtár egy lefordított C# függvény, amely ugyanabban a folyamatban fut, mint a Functions-futtatókörnyezet.

Válasszon ki egy verziót a módra és a verzióra vonatkozó példák megtekintéséhez.

Azure Tables-bővítmény

Az alábbi példa egy C# függvényt mutat be, amely egyetlen táblázatsort olvas be. Az üzenetsorba küldött összes üzenet esetén a függvény aktiválódik.

A sorkulcs értéke {queueTrigger} az üzenet metaadataihoz köti a sorkulcsot, amely az üzenet sztringje.

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

TableClient Egy metódusparaméter használatával olvassa be a táblázatot az Azure SDK használatával. Íme egy példa egy olyan függvényre, amely lekérdez egy Azure Functions-naplótáblát:

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

További információ a használatról TableClient: Azure.Data.Tables API-referencia.

Kombinált Azure Storage-bővítmény

Az alábbi példa egy C# függvényt mutat be, amely egyetlen táblázatsort olvas be. Az üzenetsorba küldött összes üzenet esetén a függvény aktiválódik.

A sorkulcs értéke {queueTrigger} az üzenet metaadataihoz köti a sorkulcsot, amely az üzenet sztringje.

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

CloudTable Egy metódusparaméter használatával olvassa be a táblázatot az Azure Storage SDK használatával. Íme egy példa egy olyan függvényre, amely lekérdez egy Azure Functions-naplótáblát:

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

A CloudTable használatával kapcsolatos további információkért tekintse meg az Azure Table Storage használatának első lépéseit.

Ha megpróbál kapcsolódni, CloudTable és hibaüzenetet kap, győződjön meg arról, hogy rendelkezik a megfelelő Storage SDK-verzióra mutató hivatkozással.

Functions 1.x

Az alábbi példa egy C# függvényt mutat be, amely egyetlen táblázatsort olvas be. Az üzenetsorba küldött összes üzenet esetén a függvény aktiválódik.

A sorkulcs értéke {queueTrigger} az üzenet metaadataihoz köti a sorkulcsot, amely az üzenet sztringje.

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

Az alábbi példa egy C# függvényt mutat be, amely több táblázatsort olvas be, amelyekből TableEntityaz MyPoco osztály származik.

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

Azure Tables-bővítmény

A következő MyTableData osztály egy adatsort jelöl a táblában:

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

Az alábbi függvény, amelyet egy Queue Storage-eseményindító indít el, beolvassa a sorkulcsot az üzenetsorból, amely a bemeneti tábla sorának lekérésére szolgál. A kifejezés {queueTrigger} a sorkulcsot az üzenet metaadataihoz köti, amely az üzenet sztringje.

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

A következő üzenetsor által aktivált függvény az első 5 entitást adja vissza üzenetsorként IEnumerable<T>, a partíciókulcs értéke pedig üzenetsorként van beállítva.

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

Az Filter és Take a tulajdonságok a visszaadott entitások számának korlátozására szolgálnak.

Kombinált Azure Storage-bővítmény

A következő MyTableData osztály egy adatsort jelöl a táblában:

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

Az alábbi függvény, amelyet egy Queue Storage-eseményindító indít el, beolvassa a sorkulcsot az üzenetsorból, amely a bemeneti tábla sorának lekérésére szolgál. A kifejezés {queueTrigger} a sorkulcsot az üzenet metaadataihoz köti, amely az üzenet sztringje.

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,

A következő üzenetsor által aktivált függvény az első 5 entitást adja vissza üzenetsorként IEnumerable<T>, a partíciókulcs értéke pedig üzenetsorként van beállítva.

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

Az Filter és Take a tulajdonságok a visszaadott entitások számának korlátozására szolgálnak.

Functions 1.x

A Functions 1.x-es verziója nem támogatja az izolált feldolgozói folyamatot.

Az alábbi példa egy HTTP-aktivált függvényt mutat be, amely a Table Storage egy adott partíciójában lévő személyobjektumok listáját adja vissza. A példában a partíciókulcs ki lesz nyerve a HTTP-útvonalból, a tableName és a kapcsolat pedig a függvény beállításaiból származik.

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

A TableInput széljegyzet a kérés json törzséből is kinyerheti a kötéseket, ahogyan az alábbi példa is mutatja.

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

Az alábbi példa egy szűrő használatával kérdezi le az Azure-táblában egy adott névvel rendelkező személyeket, és a lehetséges találatok számát 10 találatra korlátozza.

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

Az alábbi példa egy táblabemeneti kötést mutat be, amely egy üzenetsor-eseményindítót használ egyetlen táblasor beolvasásához. A kötés egy partitionKey és egy rowKey. A rowKey (z) "{queueTrigger}" érték azt jelzi, hogy a sorkulcs az üzenetsor üzenetsztringéből származik.

Modell v4

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 v3

A TypeScript-minták nincsenek dokumentálva a v3-as modellhez.

Modell v4

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

Modell v3

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

A konfigurációs szakasz ezeket a tulajdonságokat ismerteti.

A JavaScript-kód a következő:

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

Az alábbi függvény egy üzenetsor-eseményindítóval olvas be egyetlen táblázatsort egy függvény bemeneteként.

Ebben a példában a kötéskonfiguráció explicit értéket ad meg a tábla számára, és egy kifejezéssel adja át a táblátpartitionKey.rowKey A rowKey kifejezés azt jelzi, {queueTrigger}hogy a sorkulcs az üzenetsor-üzenet sztringéből származik.

Kötéskonfiguráció a 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-kód a run.ps1-ben:

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

Az alábbi függvény EGY HTTP-eseményindítóval olvas be egy táblasort egy függvény bemeneteként.

Ebben a példában a kötéskonfiguráció explicit értéket ad meg a tábla számára, és egy kifejezéssel adja át a táblátpartitionKey.rowKey A rowKey kifejezés azt jelzi, {id} hogy a sorkulcs az {id} útvonal kérésben szereplő részéből származik.

Kötéskonfiguráció a function.json fájlban:

{
  "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-kód a __init__.py fájlban:

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

Ezzel az egyszerű kötéssel nem kezelhet olyan esetet programozott módon, amelyben nem található sorkulcs-azonosítóval rendelkező sor. A részletesebb adatkiválasztáshoz használja a Storage SDK-t.

---

Attribútumok

A folyamaton belüli és az izolált feldolgozói folyamat C# kódtárai attribútumokkal határozzák meg a függvényt. A C#-szkript ehelyett egy function.json konfigurációs fájlt használ a C#-szkriptelési útmutatóban leírtak szerint.

Izolált feldolgozói modell

A C#-osztálykódtárakban a TableInputAttribute következő tulajdonságok támogatottak:

Attribútumtulajdonság	Leírás
TableName	A tábla neve.
PartitionKey	Opcionális. Az olvasni kívánt táblaentitás partíciókulcsa.
Sorkulcs	Opcionális. Az olvasni kívánt táblaentitás sorkulcsa.
Vesz	Opcionális. Az entitásokba beolvasható IEnumerable<T>entitások maximális száma. Nem használható a RowKey.
Szűrő	Opcionális. OData-szűrőkifejezés az entitásokba beolvasandó IEnumerable<T>entitásokhoz. Nem használható a RowKey.
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a táblaszolgáltatáshoz. Lásd: Kapcsolatok.

Folyamaton belüli modell

A C#-osztálykódtárakban a TableAttribute következő tulajdonságok támogatottak:

Attribútumtulajdonság	Leírás
TableName	A tábla neve.
PartitionKey	Opcionális. Az olvasni kívánt táblaentitás partíciókulcsa. A tulajdonság használatára vonatkozó útmutatásért tekintse meg a használati szakaszt.
Sorkulcs	Opcionális. Egyetlen beolvasandó táblaentitás sorkulcsa. A (z) vagy a (z) Filternem használható.Take
Vesz	Opcionális. A visszaadandó entitások maximális száma. Nem használható a RowKey.
Szűrő	Opcionális. OData-szűrőkifejezés az entitásokhoz, amelyek a táblából térnek vissza. Nem használható a RowKey.
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a táblaszolgáltatáshoz. Lásd: Kapcsolatok.

Az attribútum konstruktora a tábla nevét, a partíciókulcsot és a sorkulcsot veszi fel az alábbi példában látható módon:

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

A tulajdonságot úgy állíthatja be Connection , hogy megadja a kapcsolatot a táblaszolgáltatással, ahogyan az alábbi példában látható:

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

Bár az attribútum egy tulajdonságot Connection használ, a StorageAccountAttribute használatával is megadhat egy tárfiók-kapcsolatot. Ezt akkor teheti meg, ha más tárfiókot kell használnia, mint a tár más funkcióit. A konstruktor egy tárolási kapcsolati sztring tartalmazó alkalmazásbeállítás nevét veszi fel. Az attribútum a paraméter, a metódus vagy az osztály szintjén alkalmazható. Az alábbi példa az osztályszintet és a metódusszintet mutatja be:

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

A használni kívánt tárfiók meghatározása a következő sorrendben történik:

• Az eseményindító vagy kötés attribútum tulajdonsága Connection .
• A StorageAccount trigger vagy kötés attribútummal azonos paraméterre alkalmazott attribútum.
• A StorageAccount függvényre alkalmazott attribútum.
• Az StorageAccount osztályra alkalmazott attribútum.
• A függvényalkalmazás alapértelmezett tárfiókja, amely az AzureWebJobsStorage alkalmazásbeállításban van definiálva.

Jegyzetek

A Java-függvények futtatókörnyezeti kódtárában használja a jegyzetet olyan @TableInput paramétereken, amelyek értéke a Table Storage-ból származna. Ez a széljegyzet natív Java-típusokkal, POJ-kkal vagy null értékű értékekkel használható a használatával Optional<T>. Ez a széljegyzet a következő elemeket támogatja:

Elem	Leírás
név	Annak a változónak a neve, amely a függvénykód tábláját vagy entitását jelöli.
tableName	A tábla neve.
partitionKey	Opcionális. Az olvasni kívánt táblaentitás partíciókulcsa.
rowKey	Opcionális. Az olvasni kívánt táblaentitás sorkulcsa.
vesz	Opcionális. Az elolvasandó entitások maximális száma.
szűrő	Opcionális. OData-szűrőkifejezés táblabemenethez.
kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a táblaszolgáltatáshoz. Lásd: Kapcsolatok.

Konfiguráció

Modell v4

Az alábbi táblázat a metódusnak input.table() átadott objektumon options beállítható tulajdonságokat ismerteti.

Tulajdonság	Leírás
tableName	A tábla neve.
partitionKey	Opcionális. Az olvasni kívánt táblaentitás partíciókulcsa.
rowKey	Opcionális. Az olvasni kívánt táblaentitás sorkulcsa. A (z) vagy a (z) filternem használható.take
vesz	Opcionális. A visszaadandó entitások maximális száma. Nem használható a rowKey.
szűrő	Opcionális. OData-szűrőkifejezés az entitásokhoz, amelyek a táblából térnek vissza. Nem használható a rowKey.
kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a táblaszolgáltatáshoz. Lásd: Kapcsolatok.

Modell v3

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

Tulajdonság	Leírás
type	A beállításnak a tablekövetkezőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
direction	A beállításnak a inkövetkezőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
név	Annak a változónak a neve, amely a függvénykód tábláját vagy entitását jelöli.
tableName	A tábla neve.
partitionKey	Opcionális. Az olvasni kívánt táblaentitás partíciókulcsa.
rowKey	Opcionális. Az olvasni kívánt táblaentitás sorkulcsa. A (z) vagy a (z) filternem használható.take
vesz	Opcionális. A visszaadandó entitások maximális száma. Nem használható a rowKey.
szűrő	Opcionális. OData-szűrőkifejezés az entitásokhoz, amelyek a táblából térnek vissza. Nem használható a rowKey.
kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a táblaszolgáltatáshoz. Lásd: Kapcsolatok.

Konfiguráció

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a tablekövetkezőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
direction	A beállításnak a inkövetkezőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
név	Annak a változónak a neve, amely a függvénykód tábláját vagy entitását jelöli.
tableName	A tábla neve.
partitionKey	Opcionális. Az olvasni kívánt táblaentitás partíciókulcsa.
rowKey	Opcionális. Az olvasni kívánt táblaentitás sorkulcsa. A (z) vagy a (z) filternem használható.take
vesz	Opcionális. A visszaadandó entitások maximális száma. Nem használható a rowKey.
szűrő	Opcionális. OData-szűrőkifejezés az entitásokhoz, amelyek a táblából térnek vissza. Nem használható a rowKey.
kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a táblaszolgáltatáshoz. Lásd: Kapcsolatok.

Helyi fejlesztéskor adja hozzá az alkalmazásbeállításokat a gyűjtemény local.settings.json fájljáhozValues.

Kapcsolatok

A connection tulajdonság a környezeti konfigurációra mutató hivatkozás, amely meghatározza, hogy az alkalmazásnak hogyan kell csatlakoznia a táblaszolgáltatáshoz. A következőt határozhatja meg:

• Egy kapcsolati sztring tartalmazó alkalmazásbeállítás neve
• Megosztott előtag neve több alkalmazásbeállításhoz, valamint identitásalapú kapcsolat definiálása

Ha a konfigurált érték egy adott beállítás pontos egyezése, a többi beállítás előtagja pedig egyezik, akkor a rendszer a pontos egyezést használja.

Kapcsolati sztring

Ha kapcsolati sztring szeretne beszerezni a táblákhoz az Azure Table Storage-ban, kövesse a tárfiók hozzáférési kulcsainak kezelése című témakörben ismertetett lépéseket. Ha kapcsolati sztring szeretne beszerezni a táblákhoz az Azure Cosmos DB for Table szolgáltatásban, kövesse az Azure Cosmos DB for Table GYIK-ben ismertetett lépéseket.

Ezt a kapcsolati sztring a kötéskonfiguráció tulajdonsága által connection megadott értéknek megfelelő névvel rendelkező alkalmazásbeállításban kell tárolni.

Ha az alkalmazásbeállítás neve az "AzureWebJobs" névvel kezdődik, itt csak a név fennmaradó részét adhatja meg. Ha például a "MyStorage" értékre van állítva connection , a Functions-futtatókörnyezet egy "AzureWebJobsMyStorage" nevű alkalmazásbeállítást keres. Ha üresen hagyjaconnection, a Functions-futtatókörnyezet az alapértelmezett Storage-kapcsolati sztring használja a névvel ellátott AzureWebJobsStoragealkalmazásbeállításban.

Identitásalapú kapcsolatok

Ha a Tables API-bővítményt használja, ahelyett, hogy titkos kapcsolati sztring használ, az alkalmazás Microsoft Entra-identitást használhat. Ez csak az Azure Storage-táblák elérésekor érvényes. Identitás használatához olyan beállításokat kell megadnia egy közös előtag alatt, amely leképezi a tulajdonságot az connection eseményindító és a kötés konfigurációjában.

Ha az "AzureWebJobsStorage" beállítást választjaconnection, olvassa el a Csatlakozás a gazdagép tárolójához identitással című témakört. Az összes többi kapcsolat esetében a bővítményhez a következő tulajdonságok szükségesek:

Tulajdonság	Környezeti változó sablonja	Leírás	Példaérték
Table Service URI	<CONNECTION_NAME_PREFIX>__tableServiceUri1	Annak az Azure Storage table service-nek az adatsík URI-ja, amelyhez csatlakozik, a HTTPS-séma használatával.	<https:// storage_account_name.table.core.windows.net>

^{Az 1} <CONNECTION_NAME_PREFIX>__serviceUri aliasként használható. Ha mindkét űrlap meg van adva, a rendszer az tableServiceUri űrlapot használja. Az serviceUri űrlap nem használható, ha az általános kapcsolatkonfigurációt blobokon, üzenetsorokon és/vagy táblákon kell használni.

Más tulajdonságok is beállíthatók a kapcsolat testreszabásához. Tekintse meg az identitásalapú kapcsolatok gyakori tulajdonságait.

Az serviceUri űrlap nem használható, ha az általános kapcsolatkonfigurációt blobokon, üzenetsorokon és/vagy táblákon kell használni az Azure Storage-ban. Az URI csak a táblaszolgáltatást tudja kijelölni. Alternatív megoldásként megadhat egy URI-t kifejezetten minden szolgáltatáshoz ugyanazon előtag alatt, lehetővé téve egyetlen kapcsolat használatát.

Az Azure Functions szolgáltatásban üzemeltetett identitásalapú kapcsolatok felügyelt identitást használnak. A rendszer alapértelmezés szerint a rendszer által hozzárendelt identitást használja, bár a felhasználó által hozzárendelt identitás megadható a credential tulajdonságokkal együtt clientID . Vegye figyelembe, hogy a felhasználó által hozzárendelt identitás erőforrás-azonosítóval való konfigurálása nem támogatott. Ha más környezetekben, például helyi fejlesztésben fut, a rendszer ehelyett a fejlesztői identitást használja, bár ez testre szabható. Lásd: Helyi fejlesztés identitásalapú kapcsolatokkal.

Engedély megadása az identitáshoz

Bármilyen identitást is használ, rendelkeznie kell a kívánt műveletek végrehajtásához szükséges engedélyekkel. A legtöbb Azure-szolgáltatás esetében ez azt jelenti, hogy egy szerepkört kell hozzárendelnie az Azure RBAC-ben beépített vagy egyéni szerepkörökkel, amelyek biztosítják ezeket az engedélyeket.

Fontos

A célszolgáltatás bizonyos engedélyeket közzétehet, amelyek nem minden környezethez szükségesek. Ahol lehetséges, tartsa be a minimális jogosultság elvét, és csak az identitáshoz szükséges jogosultságokat adja meg. Ha például az alkalmazásnak csak adatforrásból kell olvasnia, használjon olyan szerepkört, amely csak olvasási engedéllyel rendelkezik. Nem lenne helyénvaló olyan szerepkört hozzárendelni, amely lehetővé teszi az írást is a szolgáltatáshoz, mivel ez túlzott engedély lenne egy olvasási művelethez. Hasonlóképpen meg szeretné győződni arról, hogy a szerepkör-hozzárendelés csak az elolvasandó erőforrásokra terjed ki.

Létre kell hoznia egy szerepkör-hozzárendelést, amely futtatókörnyezetben hozzáférést biztosít az Azure Storage-táblaszolgáltatáshoz. A tulajdonoshoz hasonló felügyeleti szerepkörök nem elegendőek. Az alábbi táblázat a beépített szerepköröket mutatja be, amelyeket az Azure Tables bővítmény az Azure Storage-ra való normál működés során történő használatakor ajánlott. Előfordulhat, hogy az alkalmazás további engedélyeket igényel az Ön által írt kód alapján.

Kötés típusa	Példa beépített szerepkörökre (Azure Storage1)
Bemeneti kötés	Tárolótábla adatolvasója
Kimeneti kötés	Storage Table Data Közreműködő

¹ Ha az alkalmazás ehelyett táblákhoz csatlakozik az Azure Cosmos DB for Table szolgáltatásban, az identitás használata nem támogatott, és a kapcsolatnak kapcsolati sztring kell használnia.

Használat

A kötés használata a bővítménycsomag verziójától és a függvényalkalmazásban használt C# modalitástól függ, amely az alábbiak egyike lehet:

Izolált feldolgozói modell

A C# függvényt lefordított izolált feldolgozói folyamatosztály-kódtár a futtatókörnyezettől elkülönített folyamatban fut.

Folyamaton belüli modell

A folyamatközi osztálykódtár egy lefordított C# függvény, amely ugyanabban a folyamatban fut, mint a Functions-futtatókörnyezet.

Válasszon egy verziót a mód és a verzió használati adatainak megtekintéséhez.

Azure Tables-bővítmény

Ha kulcs alapján szeretne visszaadni egy adott entitást, használjon a TableEntityből származó kötési paramétert.

Több entitást visszaadó lekérdezések végrehajtásához kössön egy [TableClient] objektumot. Ezután ezzel az objektummal lekérdezéseket hozhat létre és hajthat végre a kötött táblán. Vegye figyelembe, hogy a [TableClient] és a kapcsolódó API-k az Azure.Data.Tables névtérhez tartoznak.

Kombinált Azure Storage-bővítmény

Ha kulcs alapján szeretne visszaadni egy adott entitást, használjon a TableEntityből származó kötési paramétert.

Több entitást visszaadó lekérdezések végrehajtásához kössön egy CloudTable-objektumhoz . Ezután ezzel az objektummal lekérdezéseket hozhat létre és hajthat végre a kötött táblán. Vegye figyelembe, hogy a CloudTable és a kapcsolódó API-k a Microsoft.Azure.Cosmos.Table névtérhez tartoznak.

Functions 1.x

Ha kulcs alapján szeretne visszaadni egy adott entitást, használjon a TableEntityből származó kötési paramétert. Az adott TableName, PartitionKeyés RowKey arra szolgál, hogy megpróbáljon lekérni egy adott entitást a táblából.

Több entitást visszaadó lekérdezések végrehajtásához kössön olyan IQueryable<T> típushoz, amely a TableEntitytől öröklődik.

Azure Tables-bővítmény

Egyetlen táblaentitás használata esetén az Azure Tables bemeneti kötése a következő típusokhoz köthető:

Típus	Leírás
ITableEntity-t implementáló JSON szerializálható típus	A Functions megpróbálja deszerializálni az entitást egy egyszerű régi CLR-objektum (POCO) típusba. A típusnak implementálnia kell az ITableEntity-t, vagy sztringtulajdonságokkal RowKey és sztringtulajdonságokkal PartitionKey kell rendelkeznie.
TableEntity1	Az entitás szótárszerű típus.

Ha több entitást használ egy lekérdezésből, az Azure Tables bemeneti kötése a következő típusokhoz köthető:

Típus	Leírás
IEnumerable<T> ahol T implementálja az ITableEntity-t	A lekérdezés által visszaadott entitások számbavétele. Minden bejegyzés egy entitást jelöl. A típusnak T implementálnia kell az ITableEntity-t, vagy sztringtulajdonságokkal RowKey és sztringtulajdonságokkal PartitionKey kell rendelkeznie.
TableClient1	A táblához csatlakoztatott ügyfél. Ez biztosítja a tábla feldolgozásának legnagyobb vezérlését, és írásra is használható, ha a kapcsolat megfelelő engedéllyel rendelkezik.

¹ Ezeknek a típusoknak a használatához hivatkoznia kell a Microsoft.Azure.Functions.Worker.Extensions.Tables 1.2.0 vagy újabb táblákra, valamint az SDK-típuskötések gyakori függőségeire.

Kombinált Azure Storage-bővítmény

Ha egy adott entitást kulcs alapján szeretne visszaadni, használjon egy egyszerű régi CLR-objektumot (POCO). Az adott TableName, PartitionKeyés RowKey arra szolgál, hogy megpróbáljon lekérni egy adott entitást a táblából.

Ha több entitást ad vissza, IEnumerable<T>akkor a Take tulajdonságok és Filter a tulajdonságok segítségével korlátozhatja az eredményhalmazt.

Functions 1.x

A Functions 1.x-es verziója nem támogatja az izolált feldolgozói folyamatot.

A TableInput attribútum hozzáférést biztosít a függvényt aktiváló táblasorhoz.

Modell v4

A bemeneti sor adatainak lekérése a következő használatával context.extraInputs.get(): .

Modell v3

A bemeneti sor adatainak lekérése a function.json tulajdonságában name megadott érték alapján context.bindings.<name> <name>.

Az adatok a function.json fájlban megadott kulcs által name megadott bemeneti paraméternek lesznek átadva. Adja meg a The partitionKey billentyűt, és rowKey lehetővé teszi, hogy adott rekordokra szűrjön.

A táblaadatok JSON-sztringként lesznek átadva a függvénynek. Az üzenet szerializálásának megszüntetése a bemeneti példában látható hívássaljson.loads.

A konkrét használati adatokért lásd a példát.

Következő lépések

• Táblaadatok írása függvényből