Liaisons de sortie Tables Azure pour Azure Functions

Utilisez une liaison de sortie de stockage Table Azure pour écrire des entités dans une table dans Azure Cosmos DB for Table ou Stockage Table Azure.

Pour plus d’informations sur les détails d’installation et de configuration, consultez la vue d’ensemble

Notes

Cette liaison de sortie prend uniquement en charge la création de nouvelles entités dans une table. Si vous devez mettre à jour une entité existante à partir de votre code de fonction, utilisez un kit de développement logiciel (SDK) Tables Azure directement.

Important

Cet article utilise des onglets pour prendre en charge plusieurs versions du modèle de programmation Node.js. Le modèle v4 est en disponibilité générale. Il est conçu pour offrir une expérience plus flexible et intuitive aux développeurs JavaScript et TypeScript. Pour plus d’informations sur le fonctionnement du modèle v4, reportez-vous au guide du développeur Azure Functions Node.js. En savoir plus sur les différences entre v3 et v4 dans le guide de migration.

Exemple

Le support Go n’est pas disponible pour ce liaison pour le moment.

Une fonction C# peut être créée à l’aide de l’un des modes C# suivants :

  • Modèle worker isolé : fonction C# compilée exécutée dans un processus worker isolé du runtime. Le processus Worker isolé est requis pour prendre en charge les fonctions C# exécutées sur les versions LTS et non-LTS de .NET et de .NET Framework. Les extensions pour les fonctions de processus de travail isolés utilisent des espaces de noms Microsoft.Azure.Functions.Worker.Extensions.*.
  • Modèle In-process : fonction C# compilée exécutée dans le même processus que le runtime Functions. Dans une variation de ce modèle, Functions peut être exécuté à l’aide de scripts C#, principalement pris en charge pour la modification du portail C#. Les extensions pour les fonctions in-process utilisent des espaces de noms Microsoft.Azure.WebJobs.Extensions.*.

Important

La prise en charge du modèle in-process prendra fin le 10 novembre 2026. Pour continuer à bénéficier d’une prise en charge complète, nous vous recommandons vivement de migrer vos applications vers le modèle worker isolé.

La classe MyTableData suivante représente une ligne de données dans la table :

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

La fonction suivante, qui est démarrée par un déclencheur Stockage File d’attente, écrit une nouvelle entité MyDataTable dans une table nommée 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}"
    };
}

L’exemple suivant illustre une fonction Java utilisant un déclencheur HTTP pour écrire une seule ligne de table.

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

L’exemple suivant illustre une fonction Java utilisant un déclencheur HTTP pour écrire plusieurs lignes de table.

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

L’exemple suivant montre une liaison de données de sortie de table qui écrit plusieurs entités de table.

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

L'exemple suivant montre comment écrire plusieurs entités dans une table à partir d'une fonction.

Configuration de liaison dans function.json :

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

Code PowerShell dans run.ps1 :

param($InputData, $TriggerMetadata)

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

L’exemple suivant montre comment utiliser la liaison de sortie de stockage de table. Configurez la liaison table est configurée dans le fichier function.json en affectant des valeurs à name, tableName, partitionKey et connection :

La fonction suivante génère un UUI unique pour la valeur rowKey et conserve le message dans le stockage de table.

import logging
import uuid
import json
import azure.functions as func

app = func.FunctionApp()

@app.route(route="table_out_binding")
@app.table_output(arg_name="message",
                  connection="AzureWebJobsStorage",
                  table_name="messages")
def table_out_binding(req: func.HttpRequest, message: func.Out[str]):
    row_key = str(uuid.uuid4())
    data = {
        "Name": "Output binding message",
        "PartitionKey": "message",
        "RowKey": row_key
    }
    table_json = json.dumps(data)
    message.set(table_json)
    return table_json

Attributs

Les bibliothèques C# in-process et de processus Worker isolé utilisent des attributs pour définir la fonction. Le script C# utilise à la place un fichier de configuration function.json comme décrit dans le guide de script C#.

Dans les bibliothèques de classes C#, TableInputAttribute prend en charge les propriétés suivantes :

Propriété d’attribut Descriptif
Nom_de_table Nom de la table dans laquelle écrire.
PartitionKey Clé de partition de l’entité de table à écrire.
RowKey Clé de ligne de l’entité de table à écrire.
Connexion Nom d’un paramètre d’application ou d’une collection de paramètres d’application qui spécifie la façon de se connecter au service de table. Consultez Connexions.

Commentaires

Dans la bibliothèque runtime de fonctions Java, utilisez l’annotation TableOutput sur les paramètres pour écrire des valeurs dans vos tables. L’attribut prend en charge les éléments suivants :

Élément Descriptif
nom Nom de variable utilisé dans le code de la fonction qui représente la table ou l’entité.
Datatype Définit comment le runtime Functions doit traiter la valeur de paramètre. Pour plus d’informations, consultez dataType.
tableName Nom de la table dans laquelle écrire.
partitionKey Clé de partition de l’entité de table à écrire.
rowKey Clé de ligne de l’entité de table à écrire.
connexion Nom d’un paramètre d’application ou d’une collection de paramètres d’application qui spécifie la façon de se connecter au service de table. Consultez Connexions.

Paramétrage

Le tableau suivant explique les propriétés que vous pouvez définir pour l’objet options passé à la méthode output.table().

Propriété Descriptif
tableName Nom de la table dans laquelle écrire.
partitionKey Clé de partition de l’entité de table à écrire.
rowKey Clé de ligne de l’entité de table à écrire.
connexion Nom d’un paramètre d’application ou d’une collection de paramètres d’application qui spécifie la façon de se connecter au service de table. Consultez Connexions.

Paramétrage

Le tableau suivant décrit les propriétés de configuration de liaison que vous définissez dans le fichier function.json.

Propriété function.json Descriptif
type Cette propriété doit être définie sur table. Cette propriété est définie automatiquement lorsque vous créez la liaison dans le portail Azure.
direction Cette propriété doit être définie sur out. Cette propriété est définie automatiquement lorsque vous créez la liaison dans le portail Azure.
nom Nom de variable utilisé dans le code de la fonction qui représente la table ou l’entité. La valeur doit être $return pour faire référence à la valeur de retour de la fonction.
tableName Nom de la table dans laquelle écrire.
partitionKey Clé de partition de l’entité de table à écrire.
rowKey Clé de ligne de l’entité de table à écrire.
connexion Nom d’un paramètre d’application ou d’une collection de paramètres d’application qui spécifie la façon de se connecter au service de table. Consultez Connexions.

Lorsque vous développez en local, ajoutez vos paramètres d’application dans le fichier local.settings.json de la collection Values.

Connexions

La connection propriété est définie sur une clé dans les paramètres de l’application qui renvoie une valeur utilisée par l’exécution Functions pour se connecter au compte de stockage utilisé par l’extension. La valeur du paramètre de propriété de connexion dépend du type de connexion :

  • Connexion d’identité gérée : La connection propriété est <CONNECTION_NAME_PREFIX> partagée par un groupe de paramètres qui définissent ensemble une connexion basée sur l’identité avec le compte de stockage. Pour plus d’informations, voir Définir les connexions identités.
  • Référence Key Vault : Le connection paramètre de propriété renvoie une référence Azure Key Vault à l’emplacement où la chaîne de connexion est centralisée. Pour plus d’informations, voir Définir les connexions Key Vault.
  • Référence App Configuration : Le connection paramètre de propriété renvoie une référence Azure App Configuration qui renvoie une chaîne de connexion ou une référence Key Vault. Pour plus d’informations, consultez Azure App Configuration dans l’article sur les connexions.
  • Connection string : Le connection paramètre de propriété renvoie la chaîne de connexion réelle du compte de stockage. Parce que la chaîne de connexion contient des clés secrètes partagées, vous devriez envisager d’utiliser une connexion d’identité gérée, lorsque c’est possible. Pour plus d’informations, voir Définir les connexions.

Pour en savoir plus sur les connexions de liaisons, consultez Gérer la connexion dans Azure Functions. Pour obtenir une chaîne de connexion, suivez les étapes indiquées à Gestion des clés d'accès au compte de stockage.

Lorsque vous définissez connection une clé ou un préfixe de clé nommé AzureWebJobsStorage ou une chaîne vide, l’extension de liaison utilise le compte de stockage hôte par défaut. Pour plus d’informations, voir Optimiser la performance de stockage.

Utilisation

L’utilisation de la liaison dépend de la version du package d’extension et de la modalité C# utilisée dans votre application de fonction, qui peut être l’une des suivantes :

Une bibliothèque de classes de processus Worker isolé est une fonction C# compilée exécutée dans un processus Worker isolé du runtime.

Choisissez une version pour afficher les détails d’utilisation du mode et de la version.

Lorsque vous souhaitez que la fonction écrive dans une seule entité, la liaison de sortie de Tables Azure peut se lier aux types suivants :

Catégorie Descriptif
Un type sérialisable JSON qui implémente [ITableEntity] Functions tente de sérialiser un type d’objet CLR traditionnel (POCO) en tant qu’entité. Le type doit implémenter [ITableEntity] ou avoir une propriété de chaîne RowKey et une propriété de chaîne PartitionKey.

Lorsque vous souhaitez que la fonction écrive dans plusieurs entités, la liaison de sortie de Tables Azure peut se lier aux types suivants :

Catégorie Descriptif
T[] où T est l’un des types d’entités uniques Un tableau contenant plusieurs entités. Chaque entrée représente une entité.

Pour d’autres scénarios de sortie, créez et utilisez un TableClient avec d’autres types à partir d’Azure.Data.Tables directement. Consultez Inscrire des clients Azure pour obtenir un exemple d’utilisation de l’injection de dépendances pour créer un type de client à partir du Kit de développement logiciel (SDK) Azure.

Il existe deux options pour produire en sortie une ligne de stockage de table à partir d’une fonction en utilisant l’annotation TableStorageOutput :

Paramètres Descriptif
Valeur de retour En appliquant l’annotation à la fonction elle-même, la valeur de retour de la fonction est conservée sous la forme d’une ligne de stockage de table.
impératives ; Pour définir explicitement la ligne de la table, appliquez l’annotation à un paramètre spécifique du type OutputBinding<T>, où T inclut les propriétés PartitionKey et RowKey. Vous pouvez accompagner ces propriétés en implémentant ITableEntity ou en héritant TableEntity.

Définissez les données de ligne de sortie en retournant la valeur ou en utilisant context.extraOutputs.set().

Pour écrire dans des données de table, utilisez la cmdlet Push-OutputBinding, et définissez les paramètres -Name TableBinding et -Value à égalité avec les données de ligne. Pour plus d'informations, consultez l'exemple PowerShell.

Il existe deux options pour générer en sortie un message de ligne de stockage de table à partir d’une fonction :

Paramètres Descriptif
Valeur de retour Définissez la propriété name dans function.json sur $return. Avec cette configuration, la valeur de retour de la fonction est conservée en tant que ligne de stockage de table.
impératives ; Passez une valeur à la méthode set du paramètre déclaré en tant que type Out. La valeur transmise à set est conservée en tant que ligne de table.

Pour des informations spécifiques sur l’utilisation, consultez Exemple.

Exceptions et codes de retour

Liaison Informations de référence
Table de charge de travail Codes d’erreur de table
Objet blob, Table, File d’attente Codes d’erreur de stockage
Objet blob, Table, File d’attente Dépannage

Étapes suivantes

En savoir plus sur les déclencheurs et les liaisons Azure Functions

  • Last updated on