Megosztás a következőn keresztül:


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:

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.

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

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.

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.

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

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.

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.

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ó

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.

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:

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ő

1 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:

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.

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

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.

1 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.

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

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

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