Dela via

Utdatabindningar för Azure Tables för Azure Functions

  • Artikel

Använd en Azure Tables-utdatabindning för att skriva entiteter till en tabell i Azure Cosmos DB för Table eller Azure Table Storage.

Information om konfiguration och konfigurationsinformation finns i översikten

Kommentar

Den här utdatabindningen stöder endast skapandet av nya entiteter i en tabell. Om du behöver uppdatera en befintlig entitet från funktionskoden använder du i stället ett Azure Tables SDK direkt.

Viktigt!

Den här artikeln använder flikar för att stödja flera versioner av Node.js programmeringsmodellen. V4-modellen är allmänt tillgänglig och är utformad för att ha en mer flexibel och intuitiv upplevelse för JavaScript- och TypeScript-utvecklare. Mer information om hur v4-modellen fungerar finns i utvecklarguiden för Azure Functions Node.js. Mer information om skillnaderna mellan v3 och v4 finns i migreringsguiden.

Exempel

En C#-funktion kan skapas med något av följande C#-lägen:

  • Isolerad arbetsmodell: Kompilerad C#-funktion som körs i en arbetsprocess som är isolerad från körningen. Isolerad arbetsprocess krävs för att stödja C#-funktioner som körs på LTS- och icke-LTS-versioner .NET och .NET Framework. Tillägg för isolerade arbetsprocessfunktioner använder Microsoft.Azure.Functions.Worker.Extensions.* namnområden.
  • Processmodell: Kompilerad C#-funktion som körs i samma process som Functions-körningen. I en variant av den här modellen kan Functions köras med C#-skript, vilket främst stöds för redigering av C#-portalen. Tillägg för in-process-funktioner använder Microsoft.Azure.WebJobs.Extensions.* namnområden.

Viktigt!

Supporten upphör för den pågående modellen den 10 november 2026. Vi rekommenderar starkt att du migrerar dina appar till den isolerade arbetsmodellen för fullt stöd.

Följande MyTableData klass representerar en rad med data i tabellen:

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

Följande funktion, som startas av en Queue Storage-utlösare, skriver en ny MyDataTable entitet till en tabell med namnet OutputTable.

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

I följande exempel visas en Java-funktion som använder en HTTP-utlösare för att skriva en enskild tabellrad.

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

I följande exempel visas en Java-funktion som använder en HTTP-utlösare för att skriva flera tabellrader.

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

I följande exempel visas en tabellutdatabindning som skriver flera tabellentiteter.

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

I följande exempel visas hur du skriver flera entiteter till en tabell från en funktion.

Bindningskonfiguration i function.json:

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

PowerShell-kod i run.ps1:

param($InputData, $TriggerMetadata)

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

I följande exempel visas hur du använder table storage-utdatabindningen. Konfigurera bindningen i function.json genom att tilldela värden till name, tableName, partitionKeyoch connection: table

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

Följande funktion genererar ett unikt UUI för rowKey värdet och bevarar meddelandet i Table Storage.

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

Attribut

C#-bibliotek i både processprocess och isolerad arbetsprocess använder attribut för att definiera funktionen. C#-skriptet använder i stället en function.json konfigurationsfil enligt beskrivningen i C#-skriptguiden.

I C#-klassbibliotek har TableInputAttribute stöd för följande egenskaper:

Attributegenskap beskrivning
TableName Namnet på den tabell som ska skrivas till.
PartitionKey Partitionsnyckeln för tabellentiteten som ska skrivas.
RowKey Radnyckeln för tabellentiteten som ska skrivas.
Anslutning Namnet på en appinställning eller inställningssamling som anger hur du ansluter till tabelltjänsten. Se Anslutningar.

Kommentarer

I Java Functions-körningsbiblioteket använder du TableOutput-kommentaren på parametrar för att skriva värden till dina tabeller. Attributet stöder följande element:

Element Description
Namn Variabelnamnet som används i funktionskoden som representerar tabellen eller entiteten.
Datatyp Definierar hur Functions-körningen ska behandla parametervärdet. Mer information finns i dataType.
tableName Namnet på den tabell som ska skrivas till.
partitionKey Partitionsnyckeln för tabellentiteten som ska skrivas.
rowKey Radnyckeln för tabellentiteten som ska skrivas.
samband Namnet på en appinställning eller inställningssamling som anger hur du ansluter till tabelltjänsten. Se Anslutningar.

Konfiguration

I följande tabell förklaras de egenskaper som du kan ange för objektet options som skickas output.table() till metoden.

Property beskrivning
tableName Namnet på den tabell som ska skrivas till.
partitionKey Partitionsnyckeln för tabellentiteten som ska skrivas.
rowKey Radnyckeln för tabellentiteten som ska skrivas.
samband Namnet på en appinställning eller inställningssamling som anger hur du ansluter till tabelltjänsten. Se Anslutningar.

Konfiguration

I följande tabell förklaras de bindningskonfigurationsegenskaper som du anger i filen function.json .

function.json egenskap beskrivning
typ Måste anges till table. Den här egenskapen anges automatiskt när du skapar bindningen i Azure-portalen.
riktning Måste anges till out. Den här egenskapen anges automatiskt när du skapar bindningen i Azure-portalen.
Namn Variabelnamnet som används i funktionskoden som representerar tabellen eller entiteten. Ange till för att referera till $return funktionens returvärde.
tableName Namnet på den tabell som ska skrivas till.
partitionKey Partitionsnyckeln för tabellentiteten som ska skrivas.
rowKey Radnyckeln för tabellentiteten som ska skrivas.
samband Namnet på en appinställning eller inställningssamling som anger hur du ansluter till tabelltjänsten. Se Anslutningar.

När du utvecklar lokalt lägger du till dina programinställningar i den local.settings.json filen i Values samlingen.

anslutningar

Egenskapen connection är en referens till miljökonfigurationen som anger hur appen ska ansluta till din tabelltjänst. Den kan ange:

Om det konfigurerade värdet både är en exakt matchning för en enskild inställning och en prefixmatchning för andra inställningar används den exakta matchningen.

Connection string

Om du vill hämta en niska veze för tabeller i Azure Table Storage följer du stegen som visas i Hantera åtkomstnycklar för lagringskonton. Om du vill hämta en niska veze för tabeller i Azure Cosmos DB for Table följer du stegen som visas i vanliga frågor och svar om Azure Cosmos DB for Table.

Den här niska veze ska lagras i en programinställning med ett namn som matchar det värde som anges av connection egenskapen för bindningskonfigurationen.

Om namnet på appinställningen börjar med "AzureWebJobs" kan du bara ange resten av namnet här. Om du till exempel anger connection "MyStorage" letar Functions-körningen efter en appinställning med namnet "AzureWebJobsMyStorage". Om du lämnar connection tomt använder Functions-körningen standardinställningen Storage niska veze i appinställningen med namnet AzureWebJobsStorage.

Identitetsbaserade anslutningar

Om du använder api-tillägget Tabeller i stället för att använda en niska veze med en hemlighet kan du låta appen använda en Microsoft Entra-identitet. Detta gäller endast vid åtkomst till tabeller i Azure Storage. Om du vill använda en identitet definierar du inställningar under ett vanligt prefix som mappar till connection egenskapen i utlösar- och bindningskonfigurationen.

Om du anger connection "AzureWebJobsStorage" läser du Ansluta till värdlagring med en identitet. För alla andra anslutningar kräver tillägget följande egenskaper:

Property Miljövariabelmall beskrivning Exempelvärde
Tabelltjänst-URI <CONNECTION_NAME_PREFIX>__tableServiceUri1 Dataplanets URI för Den Azure Storage-tabelltjänst som du ansluter till med hjälp av HTTPS-schemat. <https:// storage_account_name.table.core.windows.net>

1 <CONNECTION_NAME_PREFIX>__serviceUri kan användas som ett alias. Om båda formulären tillhandahålls används formuläret tableServiceUri . Formuläret serviceUri kan inte användas när den övergripande anslutningskonfigurationen ska användas mellan blobar, köer och/eller tabeller.

Andra egenskaper kan anges för att anpassa anslutningen. Se Vanliga egenskaper för identitetsbaserade anslutningar.

Formuläret serviceUri kan inte användas när den övergripande anslutningskonfigurationen ska användas mellan blobar, köer och/eller tabeller i Azure Storage. URI:n kan bara ange tabelltjänsten. Alternativt kan du ange en URI specifikt för varje tjänst under samma prefix, vilket gör att en enda anslutning kan användas.

När identitetsbaserade anslutningar finns i Azure Functions-tjänsten använder de en hanterad identitet. Den systemtilldelade identiteten används som standard, även om en användartilldelad identitet kan anges med credential egenskaperna och clientID . Observera att det inte går att konfigurera en användartilldelad identitet med ett resurs-ID. När den körs i andra sammanhang, till exempel lokal utveckling, används utvecklaridentiteten i stället, även om den kan anpassas. Se Lokal utveckling med identitetsbaserade anslutningar.

Bevilja behörighet till identiteten

Den identitet som används måste ha behörighet att utföra de avsedda åtgärderna. För de flesta Azure-tjänster innebär det att du måste tilldela en roll i Azure RBAC med hjälp av antingen inbyggda eller anpassade roller som ger dessa behörigheter.

Viktigt!

Vissa behörigheter kan exponeras av måltjänsten som inte är nödvändiga för alla kontexter. Om möjligt följer du principen om minsta behörighet och beviljar identiteten endast nödvändiga privilegier. Om appen till exempel bara behöver kunna läsa från en datakälla använder du en roll som bara har behörighet att läsa. Det skulle vara olämpligt att tilldela en roll som också tillåter skrivning till tjänsten, eftersom detta skulle vara överdriven behörighet för en läsåtgärd. På samma sätt vill du se till att rolltilldelningen endast är begränsad till de resurser som behöver läsas.

Du måste skapa en rolltilldelning som ger åtkomst till din Azure Storage-tabelltjänst vid körning. Hanteringsroller som Ägare räcker inte. I följande tabell visas inbyggda roller som rekommenderas när du använder Azure Tables-tillägget mot Azure Storage i normal drift. Programmet kan kräva ytterligare behörigheter baserat på den kod du skriver.

Bindningstyp Exempel på inbyggda roller (Azure Storage1)
Indatabindning Dataläsare för lagringstabell
Utdatabindning Storage Table Data-deltagare

1 Om din app i stället ansluter till tabeller i Azure Cosmos DB för tabell stöds inte användning av en identitet och anslutningen måste använda en niska veze.

Användning

Användningen av bindningen beror på versionen av tilläggspaketet och den C#-modalitet som används i funktionsappen, vilket kan vara något av följande:

Ett isolerat arbetsprocessklassbibliotek kompilerade C#-funktioner körs i en process som är isolerad från körningen.

Välj en version för att se användningsinformation för läget och versionen.

När du vill att funktionen ska skriva till en enda entitet kan Azure Tables-utdatabindningen binda till följande typer:

Typ Beskrivning
En JSON-serialiserbar typ som implementerar [ITableEntity] Functions försöker serialisera en vanlig CLR-objekttyp (POCO) som entitet. Typen måste implementera [ITableEntity] eller ha en strängegenskap RowKey och en strängegenskap PartitionKey .

När du vill att funktionen ska skriva till flera entiteter kan Azure Tables-utdatabindningen binda till följande typer:

Typ Beskrivning
T[] där T är en av de enskilda entitetstyperna En matris som innehåller flera entiteter. Varje post representerar en entitet.

För andra utdatascenarier skapar och använder du typer från Azure.Data.Tables direkt.

Det finns två alternativ för att mata ut en tabelllagringsrad från en funktion med hjälp av kommentaren TableStorageOutput :

Alternativ Description
Returvärde Genom att använda anteckningen på själva funktionen sparas funktionens returvärde som en tabelllagringsrad.
Imperativ Om du uttryckligen vill ange tabellraden använder du anteckningen på en specifik parameter av typen OutputBinding<T>, där T innehåller PartitionKey egenskaperna och RowKey . Du kan följa med dessa egenskaper genom att implementera ITableEntity eller ärva TableEntity.

Ange utdata för utdataraden genom att returnera värdet eller använda context.extraOutputs.set().

Om du vill skriva till tabelldata använder du cmdleten Push-OutputBinding , anger parametern -Name TableBinding och -Value parametern lika med raddata. Mer information finns i PowerShell-exemplet .

Det finns två alternativ för att mata ut ett tabelllagringsradmeddelande från en funktion:

Alternativ Description
Returvärde name Ange egenskapen i function.json till $return. Med den här konfigurationen bevaras funktionens returvärde som en tabelllagringsrad.
Imperativ Skicka ett värde till den angivna metoden för parametern som deklarerats som en Ut-typ . Värdet som skickas till set sparas som tabellrad.

Specifik användningsinformation finns i Exempel.

Undantag och returkoder

Bindning Referens
Register Tabellfelkoder
Blob, Tabell, Kö Felkoder för lagring
Blob, Tabell, Kö Felsökning

Nästa steg

Läs mer om Utlösare och bindningar för Azure-funktioner