Liaison de sortie Azure SQL pour Azure Functions

Article
06/26/2024

La liaison de sortie Azure SQL vous permet d’écrire dans une base de données.

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

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. Si vous souhaitez obtenir plus d’informations sur les différences entre v3 et v4, consultez le guide de migration.

Exemples

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.
Modèle In-process : fonction C# compilée exécutée dans le même processus que le runtime Functions.
Script C# : principalement utilisé lors de la création de fonctions C# dans le portail Azure.

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

Modèle de worker isolé
Modèle in-process

D’autres exemples pour la liaison de sortie Azure SQL sont disponibles dans le dépôt GitHub.

Cette section contient les exemples suivants :

Déclencheur HTTP, écriture d’un enregistrement
Déclencheur HTTP, écriture dans deux tables

Les exemples font référence à une classe ToDoItem et à une table de base de données correspondante :

namespace AzureSQL.ToDo
{
    public class ToDoItem
    {
        public Guid Id { get; set; }
        public int? order { get; set; }
        public string title { get; set; }
        public string url { get; set; }
        public bool? completed { get; set; }
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Pour retourner plusieurs liaisons de sortie dans nos exemples, nous allons créer un type de retour personnalisé :

public static class OutputType
{
    [SqlOutput("dbo.ToDo", connectionStringSetting: "SqlConnectionString")]
    public ToDoItem ToDoItem { get; set; }
    public HttpResponseData HttpResponse { get; set; }
}

Déclencheur HTTP, écriture d’un enregistrement

L’exemple suivant montre une fonction C# qui ajoute un enregistrement à une base de données en utilisant les données fournies dans une requête HTTP POST comme corps JSON. L’objet retourné est la classe OutputType que nous avons créée pour gérer à la fois une réponse HTTP et la liaison de sortie SQL.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Azure.Functions.Worker.Extensions.Sql;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace AzureSQL.ToDo
{
    public static class PostToDo
    {
        // create a new ToDoItem from body object
        // uses output binding to insert new item into ToDo table
        [FunctionName("PostToDo")]
        public static async Task<OutputType> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "PostFunction")] HttpRequestData req,
                FunctionContext executionContext)
        {
            var logger = executionContext.GetLogger("PostToDo");
            logger.LogInformation("C# HTTP trigger function processed a request.");

            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            ToDoItem toDoItem = JsonConvert.DeserializeObject<ToDoItem>(requestBody);

            // generate a new id for the todo item
            toDoItem.Id = Guid.NewGuid();

            // set Url from env variable ToDoUri
            toDoItem.url = Environment.GetEnvironmentVariable("ToDoUri")+"?id="+toDoItem.Id.ToString();

            // if completed is not provided, default to false
            if (toDoItem.completed == null)
            {
                toDoItem.completed = false;
            }

            return new OutputType()
            {
                ToDoItem = toDoItem,
                HttpResponse = req.CreateResponse(System.Net.HttpStatusCode.Created)
            }
        }
    }

    public static class OutputType
    {
        [SqlOutput("dbo.ToDo", connectionStringSetting: "SqlConnectionString")]
        public ToDoItem ToDoItem { get; set; }

        public HttpResponseData HttpResponse { get; set; }
    }
}

Déclencheur HTTP, écriture dans deux tables

L’exemple suivant montre une fonction C# qui ajoute des enregistrements à une base de données dans deux tables différentes (dbo.ToDo et dbo.RequestLog) en utilisant les données fournies dans une requête HTTP POST comme corps JSON et plusieurs liaisons de sortie.

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)

Pour utiliser une liaison de sortie supplémentaire, nous ajoutons une classe à RequestLog et modifions notre classe OutputType :

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Azure.Functions.Worker.Extensions.Sql;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace AzureSQL.ToDo
{
    public static class PostToDo
    {
        // create a new ToDoItem from body object
        // uses output binding to insert new item into ToDo table
        [FunctionName("PostToDo")]
        public static async Task<OutputType> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "PostFunction")] HttpRequestData req,
                FunctionContext executionContext)
        {
            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            ToDoItem toDoItem = JsonConvert.DeserializeObject<ToDoItem>(requestBody);

            // generate a new id for the todo item
            toDoItem.Id = Guid.NewGuid();

            // set Url from env variable ToDoUri
            toDoItem.url = Environment.GetEnvironmentVariable("ToDoUri")+"?id="+toDoItem.Id.ToString();

            // if completed is not provided, default to false
            if (toDoItem.completed == null)
            {
                toDoItem.completed = false;
            }

            requestLog = new RequestLog();
            requestLog.RequestTimeStamp = DateTime.Now;
            requestLog.ItemCount = 1;

            return new OutputType()
            {
                ToDoItem = toDoItem,
                RequestLog = requestLog,
                HttpResponse = req.CreateResponse(System.Net.HttpStatusCode.Created)
            }
        }
    }

    public class RequestLog {
        public DateTime RequestTimeStamp { get; set; }
        public int ItemCount { get; set; }
    }

    public static class OutputType
    {
        [SqlOutput("dbo.ToDo", connectionStringSetting: "SqlConnectionString")]
        public ToDoItem ToDoItem { get; set; }

        [SqlOutput("dbo.RequestLog", connectionStringSetting: "SqlConnectionString")]
        public RequestLog RequestLog { get; set; }

        public HttpResponseData HttpResponse { get; set; }
    }

}

D’autres exemples pour la liaison de sortie Azure SQL sont disponibles dans le dépôt GitHub.

Cette section contient les exemples suivants :

Déclencheur HTTP, écriture d’un enregistrement
Déclencheur HTTP, écriture dans deux tables
Déclencheur HTTP, écriture d’enregistrements avec IAsyncCollector

Les exemples font référence à une classe ToDoItem et à une table de base de données correspondante :

namespace AzureSQL.ToDo
{
    public class ToDoItem
    {
        public Guid Id { get; set; }
        public int? order { get; set; }
        public string title { get; set; }
        public string url { get; set; }
        public bool? completed { get; set; }
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Déclencheur HTTP, écriture d’un enregistrement

L’exemple suivant montre une fonction C# qui ajoute un enregistrement à une base de données en utilisant les données fournies dans une requête HTTP POST comme corps JSON.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace AzureSQL.ToDo
{
    public static class PostToDo
    {
        // create a new ToDoItem from body object
        // uses output binding to insert new item into ToDo table
        [FunctionName("PostToDo")]
        public static async Task<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "PostFunction")] HttpRequest req,
            ILogger log,
            [Sql(commandText: "dbo.ToDo", connectionStringSetting: "SqlConnectionString")] IAsyncCollector<ToDoItem> toDoItems)
        {
            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            ToDoItem toDoItem = JsonConvert.DeserializeObject<ToDoItem>(requestBody);

            // generate a new id for the todo item
            toDoItem.Id = Guid.NewGuid();

            // set Url from env variable ToDoUri
            toDoItem.url = Environment.GetEnvironmentVariable("ToDoUri")+"?id="+toDoItem.Id.ToString();

            // if completed is not provided, default to false
            if (toDoItem.completed == null)
            {
                toDoItem.completed = false;
            }

            await toDoItems.AddAsync(toDoItem);
            await toDoItems.FlushAsync();
            List<ToDoItem> toDoItemList = new List<ToDoItem> { toDoItem };

            return new OkObjectResult(toDoItemList);
        }
    }
}

Déclencheur HTTP, écriture dans deux tables

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)

namespace AzureSQL.ToDo
{
    public static class PostToDo
    {
        // create a new ToDoItem from body object
        // uses output binding to insert new item into ToDo table
        [FunctionName("PostToDo")]
        public static async Task<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "PostFunction")] HttpRequest req,
            ILogger log,
            [Sql(commandText: "dbo.ToDo", connectionStringSetting: "SqlConnectionString")] IAsyncCollector<ToDoItem> toDoItems,
            [Sql(commandText: "dbo.RequestLog", connectionStringSetting: "SqlConnectionString")] IAsyncCollector<RequestLog> requestLogs)
        {
            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            ToDoItem toDoItem = JsonConvert.DeserializeObject<ToDoItem>(requestBody);

            // generate a new id for the todo item
            toDoItem.Id = Guid.NewGuid();

            // set Url from env variable ToDoUri
            toDoItem.url = Environment.GetEnvironmentVariable("ToDoUri")+"?id="+toDoItem.Id.ToString();

            // if completed is not provided, default to false
            if (toDoItem.completed == null)
            {
                toDoItem.completed = false;
            }

            await toDoItems.AddAsync(toDoItem);
            await toDoItems.FlushAsync();
            List<ToDoItem> toDoItemList = new List<ToDoItem> { toDoItem };

            requestLog = new RequestLog();
            requestLog.RequestTimeStamp = DateTime.Now;
            requestLog.ItemCount = 1;
            await requestLogs.AddAsync(requestLog);
            await requestLogs.FlushAsync();

            return new OkObjectResult(toDoItemList);
        }
    }

    public class RequestLog {
        public DateTime RequestTimeStamp { get; set; }
        public int ItemCount { get; set; }
    }
}

Déclencheur http, écriture d’enregistrements à l’aide d’IAsyncCollector

L’exemple suivant montre une fonction C# qui ajoute une collection d’enregistrements à une base de données en utilisant les données fournies dans une requête HTTP POST comme corps de tableau JSON.

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Newtonsoft.Json;
using System.IO;
using System.Threading.Tasks;

namespace AzureSQLSamples
{
    public static class WriteRecordsAsync
    {
        [FunctionName("WriteRecordsAsync")]
        public static async Task<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "addtodo-asynccollector")]
            HttpRequest req,
            [Sql(commandText: "dbo.ToDo", connectionStringSetting: "SqlConnectionString")] IAsyncCollector<ToDoItem> newItems)
        {
            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            var incomingItems = JsonConvert.DeserializeObject<ToDoItem[]>(requestBody);
            foreach (ToDoItem newItem in incomingItems)
            {
                await newItems.AddAsync(newItem);
            }
            // Rows are upserted here
            await newItems.FlushAsync();

            return new CreatedResult($"/api/addtodo-asynccollector", "done");
        }
    }
}

D’autres exemples pour la liaison de sortie Azure SQL sont disponibles dans le dépôt GitHub.

Cette section contient les exemples suivants :

Déclencheur HTTP, écrire un enregistrement dans une table
Déclencheur HTTP, écriture dans deux tables

Les exemples font référence à une classe ToDoItem (dans un fichier distinct ToDoItem.java) et à une table de base de données correspondante :

package com.function;
import java.util.UUID;

public class ToDoItem {
    public UUID Id;
    public int order;
    public String title;
    public String url;
    public boolean completed;

    public ToDoItem() {
    }

    public ToDoItem(UUID Id, int order, String title, String url, boolean completed) {
        this.Id = Id;
        this.order = order;
        this.title = title;
        this.url = url;
        this.completed = completed;
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Déclencheur HTTP, écrire un enregistrement dans une table

L’exemple suivant montre une liaison de sortie SQL dans une fonction Java qui ajoute un enregistrement dans une table, en utilisant les données fournies dans une requête HTTP POST comme corps JSON. La fonction prend une dépendance supplémentaire sur la bibliothèque com.google.code.gson pour analyser le corps JSON.

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

package com.function;

import java.util.*;
import com.microsoft.azure.functions.annotation.*;
import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.sql.annotation.SQLOutput;
import com.google.gson.Gson;

import java.util.Optional;

public class PostToDo {
    @FunctionName("PostToDo")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
            @SQLOutput(
                name = "toDoItem",
                commandText = "dbo.ToDo",
                connectionStringSetting = "SqlConnectionString")
                OutputBinding<ToDoItem> output) {
        String json = request.getBody().get();
        Gson gson = new Gson();
        ToDoItem newToDo = gson.fromJson(json, ToDoItem.class);

        newToDo.Id = UUID.randomUUID();
        output.setValue(newToDo);

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

Déclencheur HTTP, écriture dans deux tables

L’exemple suivant montre une liaison de sortie SQL dans une fonction JavaS qui ajoute des enregistrements dans deux tables différentes (dbo.ToDo et dbo.RequestLog) d’une base de données, en utilisant les données fournies dans une requête HTTP POST comme corps JSON et plusieurs liaisons de sortie. La fonction prend une dépendance supplémentaire sur la bibliothèque com.google.code.gson pour analyser le corps JSON.

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

La seconde table, dbo.RequestLog, correspond à la définition suivante :

CREATE TABLE dbo.RequestLog (
    Id INT IDENTITY(1,1) PRIMARY KEY,
    RequestTimeStamp DATETIME2 NOT NULL DEFAULT(GETDATE()),
    ItemCount INT NOT NULL
)

et la classe Java dans RequestLog.java :

package com.function;

import java.util.Date;

public class RequestLog {
    public int Id;
    public Date RequestTimeStamp;
    public int ItemCount;

    public RequestLog() {
    }

    public RequestLog(int Id, Date RequestTimeStamp, int ItemCount) {
        this.Id = Id;
        this.RequestTimeStamp = RequestTimeStamp;
        this.ItemCount = ItemCount;
    }
}

package com.function;

import java.util.*;
import com.microsoft.azure.functions.annotation.*;
import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.sql.annotation.SQLOutput;
import com.google.gson.Gson;

import java.util.Optional;

public class PostToDoWithLog {
    @FunctionName("PostToDoWithLog")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
            @SQLOutput(
                name = "toDoItem",
                commandText = "dbo.ToDo",
                connectionStringSetting = "SqlConnectionString")
                OutputBinding<ToDoItem> output,
            @SQLOutput(
                name = "requestLog",
                commandText = "dbo.RequestLog",
                connectionStringSetting = "SqlConnectionString")
                OutputBinding<RequestLog> outputLog,
            final ExecutionContext context) {
        context.getLogger().info("Java HTTP trigger processed a request.");

        String json = request.getBody().get();
        Gson gson = new Gson();
        ToDoItem newToDo = gson.fromJson(json, ToDoItem.class);
        newToDo.Id = UUID.randomUUID();
        output.setValue(newToDo);

        RequestLog newLog = new RequestLog();
        newLog.ItemCount = 1;
        outputLog.setValue(newLog);

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

D’autres exemples pour la liaison de sortie Azure SQL sont disponibles dans le dépôt GitHub.

Cette section contient les exemples suivants :

Déclencheur HTTP, écriture d’enregistrements dans une table
Déclencheur HTTP, écriture dans deux tables

Les exemples font référence à une table de base de données :

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Déclencheur HTTP, écriture d’enregistrements dans une table

L’exemple suivant montre une liaison de sortie SQL qui ajoute des enregistrements dans une table, en utilisant les données fournies dans une requête HTTP POST comme corps JSON.

Modèle v4
Modèle v3

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

const sqlOutput = output.sql({
    commandText: 'dbo.ToDo',
    connectionStringSetting: 'SqlConnectionString',
});

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log('HTTP trigger and SQL output binding function processed a request.');

    const body = await request.json();
    context.extraOutputs.set(sqlOutput, body);
    return { status: 201 };
}

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

Modèle v4
Modèle v3

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

const sqlOutput = output.sql({
    commandText: 'dbo.ToDo',
    connectionStringSetting: 'SqlConnectionString',
});

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [sqlOutput],
    handler: async (request, context) => {
        context.log('HTTP trigger and SQL output binding function processed a request.');

        const body = await request.json();
        context.extraOutputs.set(sqlOutput, body);
        return { status: 201 };
    },
});

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "post"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code JavaScript :

module.exports = async function (context, req) {
    context.log('HTTP trigger and SQL output binding function processed a request.');

    context.bindings.todoItems = req.body;
    context.res = {
        status: 201
    }
}

Déclencheur HTTP, écriture dans deux tables

L’exemple suivant montre une liaison de sortie SQL qui ajoute des enregistrements dans deux tables différentes (dbo.ToDo et dbo.RequestLog) d’une base de données, en utilisant les données fournies dans une requête HTTP POST comme corps JSON et plusieurs liaisons de sortie.

La seconde table, dbo.RequestLog, correspond à la définition suivante :

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)

Modèle v4
Modèle v3

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

const sqlTodoOutput = output.sql({
    commandText: 'dbo.ToDo',
    connectionStringSetting: 'SqlConnectionString',
});

const sqlRequestLogOutput = output.sql({
    commandText: 'dbo.RequestLog',
    connectionStringSetting: 'SqlConnectionString',
});

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log('HTTP trigger and SQL output binding function processed a request.');

    const newLog = {
        RequestTimeStamp: Date.now(),
        ItemCount: 1,
    };
    context.extraOutputs.set(sqlRequestLogOutput, newLog);

    const body = await request.json();
    context.extraOutputs.set(sqlTodoOutput, body);

    return { status: 201 };
}

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

Modèle v4
Modèle v3

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

const sqlTodoOutput = output.sql({
    commandText: 'dbo.ToDo',
    connectionStringSetting: 'SqlConnectionString',
});

const sqlRequestLogOutput = output.sql({
    commandText: 'dbo.RequestLog',
    connectionStringSetting: 'SqlConnectionString',
});

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [sqlTodoOutput, sqlRequestLogOutput],
    handler: async (request, context) => {
        context.log('HTTP trigger and SQL output binding function processed a request.');

        const newLog = {
            RequestTimeStamp: Date.now(),
            ItemCount: 1,
        };
        context.extraOutputs.set(sqlRequestLogOutput, newLog);

        const body = await request.json();
        context.extraOutputs.set(sqlTodoOutput, body);

        return { status: 201 };
    },
});

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "post"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
},
{
    "name": "requestLog",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.RequestLog",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code JavaScript :

module.exports = async function (context, req) {
    context.log('HTTP trigger and SQL output binding function processed a request.');

    const newLog = {
        RequestTimeStamp: Date.now(),
        ItemCount: 1
    };
    context.bindings.requestLog = newLog;

    context.bindings.todoItems = req.body;
    context.res = {
        status: 201
    }
}

D’autres exemples pour la liaison de sortie Azure SQL sont disponibles dans le dépôt GitHub.

Cette section contient les exemples suivants :

Déclencheur HTTP, écriture d’enregistrements dans une table
Déclencheur HTTP, écriture dans deux tables

Les exemples font référence à une table de base de données :

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Déclencheur HTTP, écriture d’enregistrements dans une table

L’exemple suivant montre une liaison de sortie SQL dans un fichier function.json, ainsi qu’une fonction PowerShell qui ajoute des enregistrements dans une table, en utilisant les données fournies dans une requête HTTP POST comme corps JSON.

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "post"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code PowerShell pour la fonction dans le fichier run.ps1 :


```powershell
using namespace System.Net

param($Request)

Write-Host "PowerShell function with SQL Output Binding processed a request."

# Update req_body with the body of the request
$req_body = $Request.Body

# Assign the value we want to pass to the SQL Output binding. 
# The -Name value corresponds to the name property in the function.json for the binding
Push-OutputBinding -Name todoItems -Value $req_body

Push-OutputBinding -Name res -Value ([HttpResponseContext]@{
    StatusCode = [HttpStatusCode]::OK
    Body = $req_body
})

Déclencheur HTTP, écriture dans deux tables

L’exemple suivant montre une liaison de sortie SQL dans un fichier function.json, ainsi qu’une fonction PowerShell qui ajoute des enregistrements dans deux tables différentes (dbo.ToDo et dbo.RequestLog) d’une base de données, en utilisant les données fournies dans une requête HTTP POST comme corps JSON et plusieurs liaisons de sortie.

La seconde table, dbo.RequestLog, correspond à la définition suivante :

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "post"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
},
{
    "name": "requestLog",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.RequestLog",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code PowerShell pour la fonction dans le fichier run.ps1 :

using namespace System.Net

param($Request)

Write-Host "PowerShell function with SQL Output Binding processed a request."

# Update req_body with the body of the request
$req_body = $Request.Body
$new_log = @{
    RequestTimeStamp = [DateTime]::Now
    ItemCount = 1
}

Push-OutputBinding -Name todoItems -Value $req_body
Push-OutputBinding -Name requestLog -Value $new_log

Push-OutputBinding -Name res -Value ([HttpResponseContext]@{
    StatusCode = [HttpStatusCode]::OK
    Body = $req_body
})

D’autres exemples pour la liaison de sortie Azure SQL sont disponibles dans le dépôt GitHub.

Cette section contient les exemples suivants :

Déclencheur HTTP, écriture d’enregistrements dans une table
Déclencheur HTTP, écriture dans deux tables

Les exemples font référence à une table de base de données :

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Déclencheur HTTP, écriture d’enregistrements dans une table

L’exemple suivant montre une liaison de sortie SQL dans un fichier function.json, ainsi qu’une fonction Python qui ajoute des enregistrements dans une table, en utilisant les données fournies dans une requête HTTP POST comme corps JSON.

Voici un exemple de code Python pour le fichier function_app.py :

import json
import logging
import azure.functions as func
from azure.functions.decorators.core import DataType

app = func.FunctionApp()

@app.function_name(name="AddToDo")
@app.route(route="addtodo")
@app.sql_output(arg_name="todo",
                        command_text="[dbo].[ToDo]",
                        connection_string_setting="SqlConnectionString")
def add_todo(req: func.HttpRequest, todo: func.Out[func.SqlRow]) -> func.HttpResponse:
    body = json.loads(req.get_body())
    row = func.SqlRow.from_dict(body)
    todo.set(row)

    return func.HttpResponse(
        body=req.get_body(),
        status_code=201,
        mimetype="application/json"
    )

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "post"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "$return"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code Python :

import logging
import azure.functions as func


def main(req: func.HttpRequest, todoItems: func.Out[func.SqlRow]) -> func.HttpResponse:
    logging.info('Python HTTP trigger and SQL output binding function processed a request.')

    try:
        req_body = req.get_json()
        rows = func.SqlRowList(map(lambda r: func.SqlRow.from_dict(r), req_body))
    except ValueError:
        pass

    if req_body:
        todoItems.set(rows)
        return func.HttpResponse(
            todoItems.to_json(),
            status_code=201,
            mimetype="application/json"
        )
    else:
        return func.HttpResponse(
            "Error accessing request body",
            status_code=400
        )

Déclencheur HTTP, écriture dans deux tables

L’exemple suivant montre une liaison de sortie SQL dans un fichier function.json, ainsi qu’une fonction Python qui ajoute des enregistrements dans deux tables différentes (dbo.ToDo et dbo.RequestLog) d’une base de données, en utilisant les données fournies dans une requête HTTP POST comme corps JSON et plusieurs liaisons de sortie.

La seconde table, dbo.RequestLog, correspond à la définition suivante :

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)

Voici un exemple de code Python pour le fichier function_app.py :

from datetime import datetime
import json
import logging
import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="PostToDo")
@app.route(route="posttodo")
@app.sql_output(arg_name="todoItems",
                        command_text="[dbo].[ToDo]",
                        connection_string_setting="SqlConnectionString")
@app.sql_output(arg_name="requestLog",
                        command_text="[dbo].[RequestLog]",
                        connection_string_setting="SqlConnectionString")
def add_todo(req: func.HttpRequest, todoItems: func.Out[func.SqlRow], requestLog: func.Out[func.SqlRow]) -> func.HttpResponse:
    logging.info('Python HTTP trigger and SQL output binding function processed a request.')
    try:
        req_body = req.get_json()
        rows = func.SqlRowList(map(lambda r: func.SqlRow.from_dict(r), req_body))
    except ValueError:
        pass

    requestLog.set(func.SqlRow({
        "RequestTimeStamp": datetime.now().isoformat(),
        "ItemCount": 1
    }))

    if req_body:
        todoItems.set(rows)
        return func.HttpResponse(
            "OK",
            status_code=201,
            mimetype="application/json"
        )
    else:
        return func.HttpResponse(
            "Error accessing request body",
            status_code=400
        )

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "post"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "$return"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
},
{
    "name": "requestLog",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.RequestLog",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code Python :

import logging
from datetime import datetime
import azure.functions as func


def main(req: func.HttpRequest, todoItems: func.Out[func.SqlRow], requestLog: func.Out[func.SqlRow]) -> func.HttpResponse:
    logging.info('Python HTTP trigger and SQL output binding function processed a request.')

    try:
        req_body = req.get_json()
        rows = func.SqlRowList(map(lambda r: func.SqlRow.from_dict(r), req_body))
    except ValueError:
        pass

    requestLog.set(func.SqlRow({
        "RequestTimeStamp": datetime.now(),
        "ItemCount": 1
    }))

    if req_body:
        todoItems.set(rows)
        return func.HttpResponse(
            todoItems.to_json(),
            status_code=201,
            mimetype="application/json"
        )
    else:
        return func.HttpResponse(
            "Error accessing request body",
            status_code=400
        )

Attributs

La bibliothèque C# utilise l’attribut SqlAttribute pour déclarer les liaisons SQL sur la fonction, qui a les propriétés suivantes :

Propriété d’attribut	Description
CommandText	Obligatoire. Nom de la table où la liaison va écrire.
ConnectionStringSetting	Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données dans laquelle les données vont être écrites. Il ne s’agit pas de la chaîne de connexion réelle ; au lieu de cela, elle doit être résolue en une variable d’environnement.

Annotations

Dans la bibliothèque du runtime des fonctions Java, utilisez l’annotation @SQLOutput (com.microsoft.azure.functions.sql.annotation.SQLOutput) sur les paramètres dont la valeur proviendrait d’Azure SQL. Cette annotation prend en charge les éléments suivants :

Élément	Description
commandText	Obligatoire. Nom de la table où la liaison va écrire.
connectionStringSetting	Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données dans laquelle les données vont être écrites. Il ne s’agit pas de la chaîne de connexion réelle ; au lieu de cela, elle doit être résolue en une variable d’environnement.
name	Obligatoire. Nom unique de la liaison de fonction.

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

Propriété

Description

commandText

Obligatoire. Nom de la table où la liaison va écrire.

connectionStringSetting

Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données dans laquelle les données vont être écrites. Il ne s’agit pas de la chaîne de connexion réelle ; au lieu de cela, elle doit être résolue en une variable d’environnement. Les mots clés facultatifs dans la valeur de chaîne de connexion sont disponibles pour affiner la connectivité des liaisons SQL.

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

Propriété	Description
type	Obligatoire. Cette propriété doit être définie sur `sql`.
direction	Obligatoire. Cette propriété doit être définie sur `out`.
name	Obligatoire. Nom de la variable qui représente l’entité dans le code de la fonction.
commandText	Obligatoire. Nom de la table où la liaison va écrire.
connectionStringSetting	Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données dans laquelle les données vont être écrites. Il ne s’agit pas de la chaîne de connexion réelle ; au lieu de cela, elle doit être résolue en une variable d’environnement. Les mots clés facultatifs dans la valeur de chaîne de connexion sont disponibles pour affiner la connectivité des liaisons SQL.

Configuration

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	Description
type	Obligatoire. Cette propriété doit être définie sur `sql`.
direction	Obligatoire. Cette propriété doit être définie sur `out`.
name	Obligatoire. Nom de la variable qui représente l’entité dans le code de la fonction.
commandText	Obligatoire. Nom de la table où la liaison va écrire.
connectionStringSetting	Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données dans laquelle les données vont être écrites. Il ne s’agit pas de la chaîne de connexion réelle ; au lieu de cela, elle doit être résolue en une variable d’environnement. Les mots clés facultatifs dans la valeur de chaîne de connexion sont disponibles pour affiner la connectivité des liaisons SQL.

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

Utilisation

La propriété CommandText est le nom de la table où les données doivent être stockées. Le nom du paramètre de la chaîne de connexion correspond au paramètre d’application qui contient la chaîne de connexion à l’instance Azure SQL ou SQL Server.

Les liaisons de sortie utilisent l’instruction T-SQL MERGE qui nécessite des autorisations SELECT sur la base de données cible.

Si une exception survient lorsqu’une liaison de sortie SQL est exécutée, le code de fonction cesse de s’exécuter. Cela peut entraîner le retour d’un code d’erreur, comme un déclencheur HTTP retournant un code d’erreur 500. Si le IAsyncCollector est utilisé dans une fonction .NET, le code de la fonction peut gérer les exceptions levées par l’appel à FlushAsync().

Partager via

Liaison de sortie Azure SQL pour Azure Functions

Exemples

Déclencheur HTTP, écriture d’un enregistrement

Déclencheur HTTP, écriture dans deux tables

Déclencheur HTTP, écriture d’un enregistrement

Déclencheur HTTP, écriture dans deux tables

Déclencheur http, écriture d’enregistrements à l’aide d’IAsyncCollector

Déclencheur HTTP, écrire un enregistrement dans une table

Déclencheur HTTP, écriture dans deux tables

Déclencheur HTTP, écriture d’enregistrements dans une table

Déclencheur HTTP, écriture dans deux tables

Déclencheur HTTP, écriture d’enregistrements dans une table

Déclencheur HTTP, écriture dans deux tables

Déclencheur HTTP, écriture d’enregistrements dans une table

Déclencheur HTTP, écriture dans deux tables

Attributs

Annotations

Configuration

Configuration

Utilisation

Étapes suivantes

Commentaires

Ressources supplémentaires