Azure Tables kimeneti kötések az Azure Functionshez

  • Cikk

Az Azure Tables kimeneti kötésének használatával entitásokat írhat egy táblába 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

Feljegyzés

Ez a kimeneti kötés csak új entitások létrehozását támogatja egy táblában. Ha egy meglévő entitást kell frissítenie a függvénykódból, használja közvetlenül az Azure Tables SDK-t.

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 C#-függvények a következő C#-módok egyikével hozhatók létre:

  • Izolált feldolgozómodell: Lefordított C# függvény, amely a futtatókörnyezettől elkülönített feldolgozói folyamatban fut. Izolált feldolgozói folyamat szükséges az LTS- és nem LTS-verziókon futó C#-függvények támogatásához .NET és .NET-keretrendszer. Az izolált feldolgozói folyamatfüggvények bővítményei névtereket használnak Microsoft.Azure.Functions.Worker.Extensions.* .
  • Folyamaton belüli modell: Lefordított C# függvény, amely ugyanabban a folyamatban fut, mint a Functions-futtatókörnyezet. A modell egy változatában a Functions C#-szkriptekkel futtatható, amely elsősorban a C#-portál szerkesztéséhez támogatott. A folyamaton belüli függvények bővítményei névtereket használnak Microsoft.Azure.WebJobs.Extensions.* .

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 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, egy új MyDataTable entitást ír egy OutputTable nevű táblába.

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

Az alábbi példa egy Java-függvényt mutat be, amely EGY HTTP-eseményindítót használ egyetlen táblasor írásához.

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

public class AddPerson {

    @FunctionName("addPerson")
    public HttpResponseMessage get(
            @HttpTrigger(name = "postPerson", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.FUNCTION, route="persons/{partitionKey}/{rowKey}") HttpRequestMessage<Optional<Person>> request,
            @BindingName("partitionKey") String partitionKey,
            @BindingName("rowKey") String rowKey,
            @TableOutput(name="person", partitionKey="{partitionKey}", rowKey = "{rowKey}", tableName="%MyTableName%", connection="MyConnectionString") OutputBinding<Person> person,
            final ExecutionContext context) {

        Person outPerson = new Person();
        outPerson.setPartitionKey(partitionKey);
        outPerson.setRowKey(rowKey);
        outPerson.setName(request.getBody().get().getName());

        person.setValue(outPerson);

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

Az alábbi példa egy Java-függvényt mutat be, amely HTTP-eseményindítót használ több táblasor írásához.

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

public class AddPersons {

    @FunctionName("addPersons")
    public HttpResponseMessage get(
            @HttpTrigger(name = "postPersons", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.FUNCTION, route="persons/") HttpRequestMessage<Optional<Person[]>> request,
            @TableOutput(name="person", tableName="%MyTableName%", connection="MyConnectionString") OutputBinding<Person[]> persons,
            final ExecutionContext context) {

        persons.setValue(request.getBody().get());

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

Az alábbi példa egy táblakimeneti kötést mutat be, amely több táblaentitást ír.

import { app, HttpRequest, HttpResponseInit, InvocationContext, output } from '@azure/functions';

const tableOutput = output.table({
    tableName: 'Person',
    connection: 'MyStorageConnectionAppSetting',
});

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

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    const rows: PersonEntity[] = [];
    for (let i = 1; i < 10; i++) {
        rows.push({
            PartitionKey: 'Test',
            RowKey: i.toString(),
            Name: `Name ${i}`,
        });
    }
    context.extraOutputs.set(tableOutput, rows);
    return { status: 201 };
}

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [tableOutput],
    handler: httpTrigger1,
});

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

const tableOutput = output.table({
    tableName: 'Person',
    connection: 'MyStorageConnectionAppSetting',
});

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [tableOutput],
    handler: async (request, context) => {
        const rows = [];
        for (let i = 1; i < 10; i++) {
            rows.push({
                PartitionKey: 'Test',
                RowKey: i.toString(),
                Name: `Name ${i}`,
            });
        }
        context.extraOutputs.set(tableOutput, rows);
        return { status: 201 };
    },
});

Az alábbi példa bemutatja, hogyan írhat több entitást egy táblába egy függvényből.

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

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

PowerShell-kód a run.ps1-ben:

param($InputData, $TriggerMetadata)

foreach ($i in 1..10) {
    Push-OutputBinding -Name TableBinding -Value @{
        PartitionKey = 'Test'
        RowKey = "$i"
        Name = "Name $i"
    }
}

Az alábbi példa bemutatja, hogyan használható a Table Storage kimeneti kötése. Konfigurálja a kötést table a function.json úgy, hogy az értékeket a következőhöz connectionnametableNamepartitionKeyrendeli:

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

Az alábbi függvény létrehoz egy egyedi UUI-t az rowKey értékhez, és megőrzi az üzenetet a Table Storage-ba.

import logging
import uuid
import json

import azure.functions as func

def main(req: func.HttpRequest, message: func.Out[str]) -> func.HttpResponse:

    rowKey = str(uuid.uuid4())

    data = {
        "Name": "Output binding message",
        "PartitionKey": "message",
        "RowKey": rowKey
    }

    message.set(json.dumps(data))

    return func.HttpResponse(f"Message created with the rowKey: {rowKey}")

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 Annak a táblának a neve, amelyhez írni szeretne.
PartitionKey Az írni kívánt táblaentitás partíciókulcsa.
Sorkulcs Az írni kívánt táblaentitás sorkulcsa.
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: Csatlakozás ions.

Jegyzetek

A Java-függvények futtatókörnyezeti kódtárában a TableOutput annotation on parameters használatával írjon értékeket a táblákba. Az attribútum a következő elemeket támogatja:

Elem Leírás
név A táblát vagy entitást képviselő függvénykódban használt változónév.
Adattípus Meghatározza, hogy a Functions futtatókörnyezet hogyan kezelje a paraméter értékét. További információ: dataType.
tableName Annak a táblának a neve, amelyhez írni szeretne.
partitionKey Az írni kívánt táblaentitás partíciókulcsa.
rowKey Az írni kívánt táblaentitás sorkulcsa.
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: Csatlakozás ions.

Konfiguráció

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

Tulajdonság Leírás
tableName Annak a táblának a neve, amelyhez írni szeretne.
partitionKey Az írni kívánt táblaentitás partíciókulcsa.
rowKey Az írni kívánt táblaentitás sorkulcsa.
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: Csatlakozás ions.

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 outkö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 A táblát vagy entitást képviselő függvénykódban használt változónév. $return A függvény visszatérési értékére való hivatkozásra van állítva.
tableName Annak a táblának a neve, amelyhez írni szeretne.
partitionKey Az írni kívánt táblaentitás partíciókulcsa.
rowKey Az írni kívánt táblaentitás sorkulcsa.
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: Csatlakozás ions.

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" értékre van állítvaconnection, tekintse meg Csatlakozás a tároló identitással való üzemeltetését. 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.

Ha azt szeretné, hogy a függvény egyetlen entitásba írjon, az Azure Tables kimeneti kötése a következő típusokhoz kapcsolódhat:

Típus Leírás
Az [ITableEntity] implementálását megvalósító JSON szerializálható típus A Functions egy egyszerű régi CLR-objektumtípust (POCO) kísérel meg entitásként szerializálni. A típusnak implementálnia kell az [ITableEntity] elemet, vagy sztringtulajdonságokkal RowKey és sztringtulajdonságokkal PartitionKey kell rendelkeznie.

Ha azt szeretné, hogy a függvény több entitásba írjon, az Azure Tables kimeneti kötése a következő típusokhoz kapcsolódhat:

Típus Leírás
T[] ahol T az egyetlen entitástípusok egyike Több entitást tartalmazó tömb. Minden bejegyzés egy entitást jelöl.

Egyéb kimeneti forgatókönyvek esetén közvetlenül hozzon létre és használjon típusokat az Azure.Data.Tables szolgáltatásból.

A TableStorageOutput széljegyzet használatával két lehetőség közül választhat, ha táblatároló sort ad ki egy függvényből:

Beállítások Leírás
Visszaadott érték A széljegyzet magára a függvényre való alkalmazásával a függvény visszatérési értéke táblatároló sorként marad meg.
Imperatív A táblázatsor explicit beállításához alkalmazza a széljegyzetet a típus OutputBinding<T>egy adott paraméterére, ahol T a tulajdonságok és RowKey a PartitionKey tulajdonságok is szerepelnek. Ezeket a tulajdonságokat implementálhatja ITableEntity vagy örökölheti TableEntity.

Állítsa be a kimeneti sor adatait az érték visszaadásával vagy a használatával context.extraOutputs.set().

Táblázatadatokba való íráshoz használja a Push-OutputBinding parancsmagot, állítsa be a paramétert és -Value a -Name TableBinding paramétert, amely megegyezik a soradatokkal. További részletekért tekintse meg a PowerShell-példát .

A Table Storage sorüzenetének függvényből való kimenetére két lehetőség van:

Beállítások Leírás
Visszaadott érték Állítsa a tulajdonságot a name function.json értékére$return. Ezzel a konfigurációval a függvény visszatérési értéke táblatároló sorként marad meg.
Imperatív Adjon meg egy értéket a Ki típusúként deklarált paraméter beállított metódusának. Az átadott set érték táblasorként marad meg.

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

Kivételek és visszatérési kódok

Kötés Referencia
Tábla Táblahibakódok
Blob, tábla, üzenetsor Tárolási hibakódok
Blob, tábla, üzenetsor Hibaelhárítás

Következő lépések

További információ az Azure Functions eseményindítóiról és kötéseiről