Azure Tables-indatabindningar för Azure Functions

Välj ett datorspråk

C# Java JavaScript PowerShell Python TypeScript

Använd Azure Tables-indatabindningen för att läsa en tabell i Azure Cosmos DB för Table eller Azure Table Storage.

Information om konfiguration och konfigurationsinformation finns i översikten.

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

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

Isolerad arbetsmodell

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

Processmodell

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.

Ett kursbibliotek i processen är en kompilerad C#-funktion som körs i samma process som Functions-körningen.

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

Azure Tables-tillägg

I följande exempel visas en C#-funktion som läser en enskild tabellrad. För varje meddelande som skickas till kön utlöses funktionen.

Radnyckelvärdet {queueTrigger} binder radnyckeln till meddelandemetadata, som är meddelandesträngen.

C#

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

Använd en TableClient metodparameter för att läsa tabellen med hjälp av Azure SDK. Här är ett exempel på en funktion som frågar en Azure Functions-loggtabell:

C#

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

Mer information om hur du använder TableClientfinns i API-referensen för Azure.Data.Tables.

Kombinerat Azure Storage-tillägg

I följande exempel visas en C#-funktion som läser en enskild tabellrad. För varje meddelande som skickas till kön utlöses funktionen.

Radnyckelvärdet {queueTrigger} binder radnyckeln till meddelandemetadata, som är meddelandesträngen.

C#

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

Använd en CloudTable metodparameter för att läsa tabellen med hjälp av Azure Storage SDK. Här är ett exempel på en funktion som frågar en Azure Functions-loggtabell:

C#

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

Mer information om hur du använder CloudTable finns i Kom igång med Azure Table Storage.

Om du försöker binda till CloudTable och få ett felmeddelande kontrollerar du att du har en referens till rätt Storage SDK-version.

Funktioner 1.x

I följande exempel visas en C#-funktion som läser en enskild tabellrad. För varje meddelande som skickas till kön utlöses funktionen.

Radnyckelvärdet {queueTrigger} binder radnyckeln till meddelandemetadata, som är meddelandesträngen.

C#

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

I följande exempel visas en C#-funktion som läser flera tabellrader där MyPoco klassen härleds från TableEntity.

C#

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-tillägg

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

C#

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, läser en radnyckel från kön, som används för att hämta raden från indatatabellen. Uttrycket {queueTrigger} binder radnyckeln till meddelandemetadata, som är meddelandesträngen.

C#

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

Följande köutlösta funktion returnerar de första 5 entiteterna som en IEnumerable<T>, med partitionsnyckelvärdet inställt som kömeddelande.

C#

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

Egenskaperna Filter och Take används för att begränsa antalet entiteter som returneras.

Kombinerat Azure Storage-tillägg

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

C#

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

Följande funktion, som startas av en Queue Storage-utlösare, läser en radnyckel från kön, som används för att hämta raden från indatatabellen. Uttrycket {queueTrigger} binder radnyckeln till meddelandemetadata, som är meddelandesträngen.

C#

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,

Följande köutlösta funktion returnerar de första 5 entiteterna som en IEnumerable<T>, med partitionsnyckelvärdet inställt som kömeddelande.

C#

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

Egenskaperna Filter och Take används för att begränsa antalet entiteter som returneras.

Funktioner 1.x

Functions version 1.x stöder inte isolerad arbetsprocess.

I följande exempel visas en HTTP-utlöst funktion som returnerar en lista över personobjekt som finns i en angiven partition i Table Storage. I exemplet extraheras partitionsnyckeln från http-vägen och tableName och anslutningen kommer från funktionsinställningarna.

Java

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

TableInput-anteckningen kan också extrahera bindningarna från json-brödtexten i begäran, som i följande exempel.

Java

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

I följande exempel används ett filter för att fråga efter personer med ett specifikt namn i en Azure-tabell och begränsar antalet möjliga matchningar till 10 resultat.

Java

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

I följande exempel visas en tabellindatabindning som använder en köutlösare för att läsa en enskild tabellrad. Bindningen anger en partitionKey och en rowKey. Värdet rowKey {queueTrigger} anger att radnyckeln kommer från kömeddelandesträngen.

TypeScript

import { app, input, InvocationContext } from '@azure/functions';

const tableInput = input.table({
    tableName: 'Person',
    partitionKey: 'Test',
    rowKey: '{queueTrigger}',
    connection: 'MyStorageConnectionAppSetting',
});

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

export async function storageQueueTrigger1(queueItem: unknown, context: InvocationContext): Promise<void> {
    context.log('Node.js queue trigger function processed work item', queueItem);
    const person = <PersonEntity>context.extraInputs.get(tableInput);
    context.log('Person entity name: ' + person.Name);
}

app.storageQueue('storageQueueTrigger1', {
    queueName: 'myqueue-items',
    connection: 'MyStorageConnectionAppSetting',
    extraInputs: [tableInput],
    handler: storageQueueTrigger1,
});

TypeScript-exempel dokumenteras inte för modell v3.

JavaScript

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

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
}

I konfigurationsavsnittet förklaras dessa egenskaper.

Här är JavaScript-koden:

JavaScript

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

Följande funktion använder en köutlösare för att läsa en enskild tabellrad som indata till en funktion.

I det här exemplet anger bindningskonfigurationen ett explicit värde för tabellens partitionKey och använder ett uttryck för att skicka till rowKey. Uttrycket rowKey , {queueTrigger}, anger att radnyckeln kommer från kömeddelandesträngen.

Bindningskonfiguration i function.json:

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-kod i run.ps1:

PowerShell

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

Följande funktion använder en HTTP-utlösare för att läsa en enskild tabellrad som indata till en funktion.

I det här exemplet anger bindningskonfigurationen ett explicit värde för tabellens partitionKey och använder ett uttryck för att skicka till rowKey. Uttrycket rowKey {id} anger att radnyckeln kommer från den {id} del av vägen i begäran.

Bindningskonfiguration i function.json-filen:

JSON

{
  "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-kod i filen __init__.py :

Python

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

Med den här enkla bindningen kan du inte programmatiskt hantera ett ärende där ingen rad som har ett radnyckel-ID hittas. Använd lagrings-SDK för mer detaljerad dataval.

---

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.

Isolerad arbetsmodell

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

Attributegenskap	beskrivning
TableName	Tabellens namn.
PartitionKey	Valfritt. Partitionsnyckeln för tabellentiteten som ska läsas.
RowKey	Valfritt. Radnyckeln för tabellentiteten som ska läsas.
Ta	Valfritt. Det maximala antalet entiteter som ska läsas in i en IEnumerable<T>. Det går inte att använda med RowKey.
Filter	Valfritt. Ett OData-filteruttryck för entiteter som ska läsas in i en IEnumerable<T>. Det går inte att använda med RowKey.
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till tabelltjänsten. Se Anslutningar.

Processmodell

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

Attributegenskap	beskrivning
TableName	Tabellens namn.
PartitionKey	Valfritt. Partitionsnyckeln för tabellentiteten som ska läsas. Se användningsavsnittet för vägledning om hur du använder den här egenskapen.
RowKey	Valfritt. Radnyckeln för en enskild tabellentitet som ska läsas. Det går inte att använda med Take eller Filter.
Ta	Valfritt. Det maximala antalet entiteter som ska returneras. Det går inte att använda med RowKey.
Filter	Valfritt. Ett OData-filteruttryck som entiteterna ska returnera från tabellen. Det går inte att använda med RowKey.
Anslutning	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till tabelltjänsten. Se Anslutningar.

Attributets konstruktor tar tabellnamnet, partitionsnyckeln och radnyckeln enligt följande exempel:

C#

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

Du kan ange Connection egenskapen för att ange anslutningen till tabelltjänsten, som du ser i följande exempel:

C#

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

Även om attributet tar en Connection egenskap kan du också använda StorageAccountAttribute för att ange en anslutning till lagringskontot. Du kan göra detta när du behöver använda ett annat lagringskonto än andra funktioner i biblioteket. Konstruktorn tar namnet på en appinställning som innehåller en lagrings-anslutningssträng. Attributet kan användas på parameter-, metod- eller klassnivå. I följande exempel visas klassnivå och metodnivå:

C#

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

Lagringskontot som ska användas bestäms i följande ordning:

• Egenskapen för utlösaren eller bindningsattributet Connection .
• Attributet StorageAccount som tillämpas på samma parameter som utlösaren eller bindningsattributet.
• Attributet StorageAccount som tillämpas på funktionen.
• Attributet StorageAccount som tillämpas på klassen.
• Standardlagringskontot för funktionsappen, som definieras i programinställningen AzureWebJobsStorage .

Kommentarer

I Java Functions-körningsbiblioteket använder du anteckningen @TableInput för parametrar vars värde skulle komma från Table Storage. Den här anteckningen kan användas med interna Java-typer, POJO:er eller null-värden med hjälp av Optional<T>. Den här kommentaren stöder följande element:

Element	Description
Namn	Namnet på variabeln som representerar tabellen eller entiteten i funktionskoden.
tableName	Tabellens namn.
partitionKey	Valfritt. Partitionsnyckeln för tabellentiteten som ska läsas.
rowKey	Valfritt. Radnyckeln för tabellentiteten som ska läsas.
ta	Valfritt. Det maximala antalet entiteter som ska läsas.
filter	Valfritt. Ett OData-filteruttryck för tabellindata.
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 input.table() till metoden.

Property	beskrivning
tableName	Tabellens namn.
partitionKey	Valfritt. Partitionsnyckeln för tabellentiteten som ska läsas.
rowKey	Valfritt. Radnyckeln för tabellentiteten som ska läsas. Det går inte att använda med take eller filter.
ta	Valfritt. Det maximala antalet entiteter som ska returneras. Det går inte att använda med rowKey.
filter	Valfritt. Ett OData-filteruttryck som entiteterna ska returnera från tabellen. Det går inte att använda med rowKey.
samband	Namnet på en appinställning eller inställningssamling som anger hur du ansluter till tabelltjänsten. Se Anslutningar.

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

Property	Beskrivning
typ	Måste anges till table. Den här egenskapen anges automatiskt när du skapar bindningen i Azure Portal.
riktning	Måste anges till in. Den här egenskapen anges automatiskt när du skapar bindningen i Azure Portal.
Namn	Namnet på variabeln som representerar tabellen eller entiteten i funktionskoden.
tableName	Tabellens namn.
partitionKey	Valfritt. Partitionsnyckeln för tabellentiteten som ska läsas.
rowKey	Valfritt. Radnyckeln för tabellentiteten som ska läsas. Det går inte att använda med take eller filter.
ta	Valfritt. Det maximala antalet entiteter som ska returneras. Det går inte att använda med rowKey.
filter	Valfritt. Ett OData-filteruttryck som entiteterna ska returnera från tabellen. Det går inte att använda med rowKey.
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 Portal.
riktning	Måste anges till in. Den här egenskapen anges automatiskt när du skapar bindningen i Azure Portal.
Namn	Namnet på variabeln som representerar tabellen eller entiteten i funktionskoden.
tableName	Tabellens namn.
partitionKey	Valfritt. Partitionsnyckeln för tabellentiteten som ska läsas.
rowKey	Valfritt. Radnyckeln för tabellentiteten som ska läsas. Det går inte att använda med take eller filter.
ta	Valfritt. Det maximala antalet entiteter som ska returneras. Det går inte att använda med rowKey.
filter	Valfritt. Ett OData-filteruttryck som entiteterna ska returnera från tabellen. Det går inte att använda med rowKey.
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:

• Namnet på en programinställning som innehåller en anslutningssträng
• Namnet på ett delat prefix för flera programinställningar, som tillsammans definierar en identitetsbaserad anslutning

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 anslutningssträng 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 anslutningssträng 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 anslutningssträng 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 anslutningssträng 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 anslutningssträng 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>

¹ <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

¹ 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 anslutningssträng.

Förbrukning

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:

Isolerad arbetsmodell

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

Processmodell

Ett kursbibliotek i processen är en kompilerad C#-funktion som körs i samma process som Functions-körningen.

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

Azure Tables-tillägg

Om du vill returnera en specifik entitet efter nyckel använder du en bindningsparameter som härleds från TableEntity.

Om du vill köra frågor som returnerar flera entiteter binder du till ett [TableClient]-objekt. Du kan sedan använda det här objektet för att skapa och köra frågor mot den bundna tabellen. Observera att [TableClient] och relaterade API:er tillhör namnområdet Azure.Data.Tables .

Kombinerat Azure Storage-tillägg

Om du vill returnera en specifik entitet efter nyckel använder du en bindningsparameter som härleds från TableEntity.

Om du vill köra frågor som returnerar flera entiteter binder du till ett CloudTable-objekt . Du kan sedan använda det här objektet för att skapa och köra frågor mot den bundna tabellen. Observera att CloudTable och relaterade API:er tillhör namnområdet Microsoft.Azure.Cosmos.Table .

Funktioner 1.x

Om du vill returnera en specifik entitet efter nyckel använder du en bindningsparameter som härleds från TableEntity. Den specifika TableName, PartitionKeyoch RowKey används för att försöka hämta en specifik entitet från tabellen.

Om du vill köra frågor som returnerar flera entiteter binder du till en IQueryable<T> av en typ som ärver från TableEntity.

Azure Tables-tillägg

När du arbetar med en enskild tabellentitet kan Azure Tables-indatabindningen binda till följande typer:

Typ	Beskrivning
En JSON-serialiserbar typ som implementerar ITableEntity	Functions försöker deserialisera entiteten till en oformaterad TYP av CLR-objekt (POCO). Typen måste implementera ITableEntity eller ha en strängegenskap RowKey och en strängegenskap PartitionKey .
TableEntity1	Entiteten som en ordlisteliknande typ.

När du arbetar med flera entiteter från en fråga kan Azure Tables-indatabindningen binda till följande typer:

Typ	Beskrivning
IEnumerable<T> där T implementerar ITableEntity	En uppräkning av entiteter som returneras av frågan. Varje post representerar en entitet. Typen måste implementera ITableEntity eller ha en strängegenskap RowKey och en strängegenskapPartitionKey.T
TableClient1	En klient som är ansluten till tabellen. Detta ger mest kontroll för bearbetning av tabellen och kan användas för att skriva till den om anslutningen har tillräcklig behörighet.

¹ Om du vill använda dessa typer måste du referera till Microsoft.Azure.Functions.Worker.Extensions.Tables 1.2.0 eller senare och de vanliga beroendena för SDK-typbindningar.

Kombinerat Azure Storage-tillägg

Om du vill returnera en specifik entitet efter nyckel använder du ett vanligt gammalt CLR-objekt (POCO). Den specifika TableName, PartitionKeyoch RowKey används för att försöka hämta en specifik entitet från tabellen.

När du returnerar flera entiteter som en IEnumerable<T>kan du i stället använda Take och Filter egenskaper för att begränsa resultatuppsättningen.

Funktioner 1.x

Functions version 1.x stöder inte isolerad arbetsprocess.

Attributet TableInput ger dig åtkomst till tabellraden som utlöste funktionen.

Hämta indataraddata med hjälp context.extraInputs.get()av .

Hämta indataraddata med hjälp context.bindings.<name> av var <name> är värdet som anges i name egenskapen för function.json.

Data skickas till indataparametern som anges av name nyckeln i function.json-filen. Om du anger och partitionKey rowKey kan du filtrera efter specifika poster.

Tabelldata skickas till funktionen som en JSON-sträng. Av-serialisera meddelandet genom att anropa json.loads enligt indataexemplet.

Specifik användningsinformation finns i Exempel.

Nästa steg

• Skriva tabelldata från en funktion