Azure SQL-Ausgabebindung für Azure Functions

Mit der Azure SQL-Ausgabebindung können Sie in eine Datenbank schreiben.

Informationen zu Setup- und Konfigurationsdetails finden Sie in der Übersicht.

Wichtig

In diesem Artikel werden Registerkarten verwendet, um mehrere Versionen des Node.js-Programmiermodells zu unterstützen. Das v4-Modell ist allgemein verfügbar und bietet JavaScript- und TypeScript-Entwicklern eine flexiblere und intuitivere Erfahrung. Weitere Informationen zur Funktionsweise des v4-Modells finden Sie im Azure Functions Node.js-Entwicklerhandbuch. Weitere Informationen zu den Unterschieden zwischen v3 und v4 finden Sie im Migrationshandbuch.

Ein vollständiges End-to-End-Beispiel für die Verwendung der Azure SQL Ausgabebindung finden Sie unter Respond für Azure SQL-Datenbank Änderungen mithilfe von Azure Functions.

Beispiele

Go-Support ist derzeit nicht für diese Bindung verfügbar.

Sie können eine C#-Funktion mit einem der folgenden C#-Modi erstellen:

  • Isoliertes Workermodell: Kompilierte C#-Funktion, die in einem Workerprozess ausgeführt wird, der von der Runtime isoliert ist. Ein isolierter Arbeitsprozess ist erforderlich, um C#-Funktionen zu unterstützen, die auf long-term support (LTS) und nicht-LTS-Versionen für .NET und .NET Framework ausgeführt werden.
  • In-Process-Modell: Kompilierte C#-Funktion, die im gleichen Prozess wie die Azure Functions-Laufzeit ausgeführt wird.
  • C#-Skript: Wird hauptsächlich beim Erstellen von C#-Funktionen im Azure-Portal verwendet.

Wichtig

Die Unterstützung für das In-Process-Modell endet am 10. November 2026. Es wird dringend empfohlen, Ihre Apps zum isolierten Workermodell zu migrieren, um den vollständigen Support zu ermöglichen.

Weitere Beispiele für die Azure SQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

Die Beispiele beziehen sich auf eine ToDoItem-Klasse und eine entsprechende Datenbanktabelle:

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

Um mehrere Ausgabebindungen in unseren Beispielen zurückzugeben, erstellen wir einen benutzerdefinierten Rückgabetyp:

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

HTTP-Trigger: Schreiben eines Datensatzes

Das folgende Beispiel zeigt eine C#-Funktion, die einer Datenbank einen Datensatz hinzufügt und dabei Daten aus einer HTTP POST-Anforderung als JSON-Textkörper verwendet. Das Rückgabeobjekt ist die OutputType-Klasse, die Sie erstellt haben, um eine HTTP-Antwort und die SQL-Ausgabebindung zu behandeln.

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

HTTP-Trigger: Schreiben in zwei Tabellen

Im folgenden Beispiel zeigt eine C#-Funktion, die Datensätze zu einer Datenbank in zwei verschiedenen Tabellen (dbo.ToDo und dbo.RequestLog) hinzufügt, indem Daten aus einer HTTP-POST-Anforderung als JSON-Textkörper sowie mehrere Ausgabebindungen verwendet werden.

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

Um eine zusätzliche Ausgabebindung zu verwenden, fügen wir eine Klasse für unsere Klasse hinzu RequestLog und ändern diese 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; }
    }

}

Weitere Beispiele für die Azure SQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

Die Beispiele beziehen sich auf eine ToDoItem-Klasse (in einer getrennten Datei ToDoItem.java) und eine entsprechende Datenbanktabelle:

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

HTTP-Trigger: Schreiben eines Datensatzes in eine Tabelle

Das folgende Beispiel zeigt eine SQL-Ausgabebindung in einer Java-Funktion, die einen Datensatz einer Tabelle hinzufügt und dabei Daten verwendet, die in einer HTTP POST-Anforderung als JSON-Textkörper bereitgestellt werden. Die Funktion verwendet eine weitere Abhängigkeit von der com.google.code.gson-Bibliothek , um den JSON-Text zu analysieren.

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

HTTP-Trigger: Schreiben in zwei Tabellen

Das folgende Beispiel zeigt eine SQL-Ausgabebindung in einer JavaS-Funktion, die Datensätze zu zwei unterschiedlichen Tabellen (dbo.ToDo und dbo.RequestLog) hinzufügt. Dabei werden in einer HTTP POST-Anforderung bereitgestellte Daten als JSON-Textkörper sowie mehrere Ausgabebindungen verwendet. Die Funktion verwendet eine weitere Abhängigkeit von der com.google.code.gson-Bibliothek , um den JSON-Text zu analysieren.

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

Die zweite Tabelle, dbo.RequestLog, entspricht der folgenden Definition:

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

und Java-Klasse in 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();
    }
}

Weitere Beispiele für die Azure SQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

Das Beispiel bezieht sich auf eine Datenbanktabelle:

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

HTTP-Trigger: Schreiben von Datensätzen in eine Tabelle

Das folgende Beispiel zeigt eine SQL-Ausgabebindung, die einer Tabelle Datensätze hinzufügt und dabei Daten verwendet, die in einer HTTP POST-Anforderung als JSON-Textkörper bereitgestellt werden.

HTTP-Trigger: Schreiben in zwei Tabellen

Das folgende Beispiel zeigt eine SQL-Ausgabebindung, die Datensätze zu zwei unterschiedlichen Tabellen (dbo.ToDo und dbo.RequestLog) hinzufügt. Dabei werden in einer HTTP POST-Anforderung bereitgestellte Daten als JSON-Textkörper sowie mehrere Ausgabebindungen verwendet.

Die zweite Tabelle, dbo.RequestLog, entspricht der folgenden Definition:

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

Weitere Beispiele für die Azure SQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

Das Beispiel bezieht sich auf eine Datenbanktabelle:

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

HTTP-Trigger: Schreiben von Datensätzen in eine Tabelle

Das folgende Beispiel zeigt eine SQL-Ausgabebindung in der Datei „function.json“ und eine PowerShell-Funktion, die Datensätze einer Tabelle hinzufügt. Dabei werden in einer HTTP POST-Anforderung bereitgestellte Daten als JSON-Textkörper verwendet.

Das folgende Beispiel bindet Daten in der function.json-Datei:

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

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.

Es folgt ein PowerShell-Beispielcode für die Funktion in der Datei 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
})

HTTP-Trigger: Schreiben in zwei Tabellen

Das folgende Beispiel zeigt eine SQL-Ausgabebindung in der Datei „function.json“ und eine PowerShell-Funktion, die Datensätze zwei Tabellen (dbo.ToDo und dbo.RequestLog) hinzufügt. Dabei werden in einer HTTP POST-Anforderung bereitgestellte Daten als JSON-Textkörper sowie mehrere Ausgabebindungen verwendet.

Die zweite Tabelle, dbo.RequestLog, entspricht der folgenden Definition:

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

Das folgende Beispiel bindet Daten in der function.json-Datei:

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

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.

Es folgt ein PowerShell-Beispielcode für die Funktion in der Datei 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
})

Weitere Beispiele für die Azure SQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

Das Beispiel bezieht sich auf eine Datenbanktabelle:

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

HTTP-Trigger: Schreiben von Datensätzen in eine Tabelle

Das folgende Beispiel zeigt eine SQL-Ausgabebindung in der Datei „function.json“ und eine Python-Funktion, die Datensätze einer Tabelle hinzufügt. Dabei werden in einer HTTP POST-Anforderung bereitgestellte Daten als JSON-Textkörper verwendet.

Nachfolgend sehen Sie Python-Beispielcode für die function_app.py-Datei:

import json
import logging
import azure.functions as func

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

HTTP-Trigger: Schreiben in zwei Tabellen

Das folgende Beispiel zeigt eine SQL-Ausgabebindung in der Datei „function.json“ und eine Python-Funktion, die Datensätze zu zwei Tabellen (dbo.ToDo und dbo.RequestLog) hinzufügt. Dabei werden in einer HTTP POST-Anforderung bereitgestellte Daten als JSON-Textkörper sowie mehrere Ausgabebindungen verwendet.

Die zweite Tabelle, dbo.RequestLog, entspricht der folgenden Definition:

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

Nachfolgend sehen Sie Python-Beispielcode für die function_app.py-Datei:

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
        )

Attribute

Die C#-Bibliothek verwendet das Attribut SqlAttribute, um die SQL-Bindungen für die Funktion zu deklarieren, die die folgenden Eigenschaften hat:

Attributeigenschaft BESCHREIBUNG
CommandText Erforderlich. Der Name der Tabelle, in die die Bindung geschrieben wird.
ConnectionStringSetting Erforderlich. Der Name einer App-Einstellung, die die Verbindungszeichenfolge für die Datenbank enthält, in die Daten geschrieben werden. Dieser Wert ist nicht die tatsächliche Verbindungszeichenfolge und muss stattdessen in eine Umgebungsvariable aufgelöst werden.

Anmerkungen

Verwenden Sie in der Laufzeitbibliothek für Java-Funktionen die Anmerkung @SQLOutput (com.microsoft.azure.functions.sql.annotation.SQLOutput) für Parameter, deren Wert aus Azure SQL stammt. Diese Anmerkung unterstützt die folgenden Elemente:

Element BESCHREIBUNG
commandText Erforderlich. Der Name der Tabelle, in die die Bindung geschrieben wird.
connectionStringSetting Erforderlich. Der Name einer App-Einstellung, die die Verbindungszeichenfolge für die Datenbank enthält, in die Daten geschrieben werden. Dieser Wert ist nicht die tatsächliche Verbindungszeichenfolge und muss stattdessen in eine Umgebungsvariable aufgelöst werden.
Name Erforderlich. Der eindeutige Name der Funktionsbindung.

Konfiguration

In der folgenden Tabelle werden die Eigenschaften erläutert, die Sie für das options-Objekt festlegen können, das an die output.sql()-Methode übergeben wurde.

Eigenschaft BESCHREIBUNG
commandText Erforderlich. Der Name der Tabelle, in die die Bindung geschrieben wird.
connectionStringSetting Erforderlich. Der Name einer App-Einstellung, die die Verbindungszeichenfolge für die Datenbank enthält, in die Daten geschrieben werden. Dieser Wert ist nicht die tatsächliche Verbindungszeichenfolge und muss stattdessen in eine Umgebungsvariable aufgelöst werden. Optionale Schlüsselwörter im Verbindungszeichenfolgewert sind verfügbar, um die SQL-Bindungskonnektivität zu verfeinern.

Konfiguration

Die folgende Tabelle gibt Aufschluss über die Bindungskonfigurationseigenschaften, die Sie in der Datei function.json festlegen.

function.json-Eigenschaft BESCHREIBUNG
Typ Erforderlich. Muss auf sql festgelegt sein.
Richtung Erforderlich. Muss auf out festgelegt sein.
Name Erforderlich. Der Name der Variablen, die die Entität im Funktionscode darstellt.
commandText Erforderlich. Der Name der Tabelle, in die die Bindung geschrieben wird.
connectionStringSetting Erforderlich. Der Name einer App-Einstellung, die die Verbindungszeichenfolge für die Datenbank enthält, in die Daten geschrieben werden. Dieser Wert ist nicht die tatsächliche Verbindungszeichenfolge und muss stattdessen in eine Umgebungsvariable aufgelöst werden. Optionale Schlüsselwörter im Verbindungszeichenfolgewert sind verfügbar, um die SQL-Bindungskonnektivität zu verfeinern.

Wenn Sie die Entwicklung lokal ausführen, fügen Sie Ihre Anwendungseinstellungen in der Datei local.settings.json in der Values-Sammlung hinzu.

Verwendung

Die CommandText-Eigenschaft ist der Name der Tabelle, in der die Daten gespeichert werden sollen.

Die Ausgabebindungen verwenden die T-SQL-Anweisung MERGE, die SELECT-Berechtigungen für die Zieldatenbank erfordert.

Wenn eine Ausnahme auftritt, wenn eine SQL-Ausgabebindung ausgeführt wird, wird die Ausführung des Funktionscodes beendet. Dieses Verhalten kann dazu führen, dass ein Fehlercode zurückgegeben wird, z. B. ein HTTP-Trigger, der einen Fehlercode von 500 zurückgibt. Wenn die IAsyncCollector Funktion in einer .NET-Funktion verwendet wird, kann der Funktionscode Ausnahmen behandeln, die vom Aufruf FlushAsync()von .

Verbindungen

Die Eigenschaft connectionStringSetting wird in den Anwendungseinstellungen auf einen Schlüssel gesetzt, der einen Wert zurückgibt, der von der Functions-Laufzeit verwendet wird, um sich mit der Azure SQL- oder SQL Server-Datenbank der Erweiterung zu verbinden. Der Wert der Verbindungseigenschaftseinstellung hängt vom Verbindungstyp ab:

  • Managed Identity-Verbindung: Die connectionStringSetting Eigenschaft gibt eine Verbindungszeichenfolge zurück, die zur Authentifizierung ohne Geheimnisse verwendet wirdAuthentication=Active Directory Managed Identity. Sie können entweder eine system- oder benutzerseitig zugewiesene verwaltete Identität verwenden. Weitere Informationen finden Sie unter Connect a function app to Azure SQL with managed identity und define identity connections.
  • Key Vault-Referenz: Die connectionStringSetting Property-Einstellung gibt eine Azure Key Vault-Referenz an den Ort zurück, an dem die Verbindungszeichenfolge zentral verwaltet wird. Weitere Informationen finden Sie unter Define Key Vault connections.
  • App Configuration Reference: Die connectionStringSetting Property-Einstellung liefert eine Azure App Configuration-Referenz, die eine Verbindungszeichenfolge oder eine Key Vault-Referenz zurückgibt. Weitere Informationen finden Sie unter Azure App Configuration im Artikel über Verbindungen.
  • Connection string: Die connectionStringSetting Eigenschaftseinstellung gibt den tatsächlichen SQL-Verbindungszeichenfolge zurück. Da der Verbindungszeichenfolge Zugangsdaten enthalten kann, sollten Sie eine verwaltete Identitätsverbindung verwenden oder zumindest die Verbindungszeichenfolge in Key Vault speichern. Weitere Informationen finden Sie unter Zusammenhänge definieren.

Um mehr über Bindungsverbindungen zu erfahren, siehe Verbindungen verwalten in Azure Functions.

Die Verbindungszeichenfolge wird an Microsoft weitergegeben. Data.SqlClient und unterstützt alle Schlüsselwörter, die in der SqlClient ConnectionString-Dokumentation definiert sind. Wichtige Schlüsselwörter sind:

  • Authentication: Verbinden Sie sich mit Azure SQL mit Microsoft Entra ID. Für verwaltete Identitäten eingestellt Active Directory Managed Identity . Weitere Informationen finden Sie unter Connect a function app to Azure SQL with managed identity.
  • Command Timeout: Warte eine festgelegte Zeitspanne in Sekunden, bevor eine Abfrage beendet wird (standardmäßig 30 Sekunden).
  • ConnectRetryCount: Zusätzliche Wiederverbindungsversuche werden automatisch durchgeführt, insbesondere anwendbar für die serverlose Stufe der Azure SQL-Datenbank (Standard 1).
  • Pooling: Verwenden Sie Verbindungen zur Datenbank wieder, um die Leistung zu verbessern (Standard true). Weitere Einstellungen für das Verbindungspooling sind Connection Lifetime, Max Pool Size und Min Pool Size. Erfahren Sie mehr in der ADO.NET-Dokumentation.

Nächste Schritte

  • Last updated on