Verbinden Azure Functions mit Azure SQL Database mithilfe von Visual Studio Code

mit Azure Functions können Sie Azure Dienste und andere Ressourcen mit Funktionen verbinden, ohne ihren eigenen Integrationscode schreiben zu müssen. Diese Bindungen, die sowohl Eingabe als auch Ausgabe darstellen, werden innerhalb der Funktionsdefinition deklariert. Daten von Bindungen werden der Funktion als Parameter bereitgestellt. Ein Trigger ist ein spezieller Typ von Eingabebindung. Eine Funktion hat zwar nur einen Trigger, kann aber mehrere Ein- und Ausgabebindungen haben. Weitere Informationen finden Sie unter Azure Functions Trigger und Bindungen Konzepte.

In diesem Artikel erfahren Sie, wie Sie Visual Studio Code verwenden, um Azure SQL Database mit der Funktion zu verbinden, die Sie im vorherigen Schnellstartartikel erstellt haben. Die Ausgabebindung, die Sie dieser Funktion hinzufügen, schreibt Daten aus der HTTP-Anforderung in eine Tabelle in Azure SQL Database.

Bevor Sie beginnen, müssen Sie den Schnellstart: Erstellen einer C#-Funktion in Azure mit Visual Studio Code abschließen. Wenn Sie ressourcen bereits am Ende dieses Artikels bereinigt haben, führen Sie die Schritte erneut durch, um die Funktions-App und die zugehörigen Ressourcen in Azure neu zu erstellen.

Bevor Sie beginnen, müssen Sie den Schnellstart: Erstellen einer JavaScript-Funktion in Azure mit Visual Studio Code abschließen. Wenn Sie ressourcen bereits am Ende dieses Artikels bereinigt haben, führen Sie die Schritte erneut durch, um die Funktions-App und die zugehörigen Ressourcen in Azure neu zu erstellen.

Bevor Sie beginnen, müssen Sie den Schnellstart: Erstellung einer Python-Funktion in Azure mithilfe von Visual Studio Code abschließen. Wenn Sie ressourcen bereits am Ende dieses Artikels bereinigt haben, führen Sie die Schritte erneut durch, um die Funktions-App und die zugehörigen Ressourcen in Azure neu zu erstellen.

Weitere Details zu den Einstellungen für Azure SQL Bindungen und Trigger für Azure Functions finden Sie in der Azure Functions Dokumentation.

Erstellen Ihrer Azure SQL Database

  1. Folgen Sie der Schnellstartanleitung für Azure SQL-Datenbank, um eine serverlose Azure SQL-Datenbank zu erstellen. Die Datenbank kann leer sein oder aus dem Beispieldataset „AdventureWorksLT“ erstellt werden.

  2. Geben Sie nach entsprechender Aufforderung Folgendes ein:

    Prompt Auswahl
    Ressourcengruppe Wählen Sie die Ressourcengruppe aus, in der Sie im vorherigen Artikel Ihre Funktions-App erstellt haben.
    Datenbankname Geben Sie mySampleDatabase ein.
    Servername Geben Sie einen eindeutigen Namen für Ihren Server ein. Wir können keinen genauen Servernamen angeben, der verwendet werden soll, da Servernamen für alle Server in Azure global eindeutig sein müssen, nicht nur innerhalb eines Abonnements.
    Authentifizierungsmethode Wählen Sie SQL Server authentication aus.
    Serveradministratoranmeldung Geben Sie azureuser ein.
    Kennwort Geben Sie ein Kennwort ein, das die Komplexitätsanforderungen erfüllt.
    Erlauben Sie Azure-Diensten und -Ressourcen den Zugriff auf diesen Server Wählen Sie Ja aus.

    Wichtig

    In diesem Artikel wird derzeit gezeigt, wie Sie mithilfe SQL Server Authentifizierung eine Verbindung mit Azure SQL Database herstellen. Für die beste Sicherheit sollten Sie stattdessen verwaltete Identitäten für die Azure SQL Database-Verbindung verwenden. Weitere Informationen finden Sie unter Erstellen eines Azure SQL-Datenbankservers mit einer benutzerdefinierten verwalteten Identität.

  3. Navigieren Sie nach Abschluss der Erstellung zum Datenbankblatt im Azure portal, und wählen Sie unter SettingsConnection strings aus. Kopieren Sie die ADO.NET connection string für die SQL-Authentifizierung. Fügen Sie die connection string zur späteren Verwendung in ein temporäres Dokument ein.

    Screenshot zum Kopieren der Verbindungszeichenfolge der Azure SQL-Datenbank im Azure-Portal.

  4. Erstellen Sie eine Tabelle zum Speichern der Daten aus der HTTP-Anforderung. Navigieren Sie im Azure portal zum Datenbankblatt, und wählen Sie Query editor aus. Geben Sie die folgende Abfrage ein, um eine neue Tabelle namens dbo.ToDo zu erstellen:

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

  5. Stellen Sie sicher, dass Ihre Azure-Funktion die Azure SQL Database access kann, indem Sie die Firewalleinstellungen des Servers überprüfen. Navigieren Sie zum Blatt server auf dem Azure portal, und wählen Sie unter SecurityNetworking aus. Die Ausnahme für Azure-Dienste und -Ressourcen den Zugriff auf diesen Server erlauben sollte überprüft werden.

    Screenshot zum Überprüfen der Azure SQL Database Firewalleinstellungen im Azure portal.

Aktualisieren der Einstellungen Ihrer Funktions-App

Im vorhergehenden Schnellstartartikel haben Sie eine Function App in Azure erstellt. In diesem Artikel aktualisieren Sie Ihre App so, dass Daten in die Azure SQL Database geschrieben werden, die Sie soeben erstellt haben. Um eine Verbindung mit Ihrer Azure SQL-Datenbank herzustellen, müssen Sie die Verbindungszeichenfolge zu Ihren App-Einstellungen hinzufügen. Anschließend laden Sie die neue Einstellung in Ihre local.settings.json Datei herunter, damit Sie bei der lokalen Ausführung eine Verbindung mit Ihrer Azure SQL Database herstellen können.

  1. Bearbeiten Sie die connection string im zuvor erstellten temporären Dokument. Ersetzen Sie den Wert von Password durch das Kennwort, das Sie beim Erstellen der Azure SQL Database verwendet haben. Kopieren Sie die aktualisierte connection string.

  2. Drücken Sie Ctrl/Cmd+shift+P, um die Befehlspalette zu öffnen, und suchen Sie dann nach dem Befehl Azure Functions: Add New Setting....

  3. Wählen Sie die im vorherigen Artikel erstellte Funktions-App aus. Geben Sie nach entsprechender Aufforderung Folgendes ein:

    Prompt Auswahl
    Geben Sie den Namen der neuen App-Einstellung ein Geben Sie SqlConnectionStringein.
    Geben Sie einen Wert für „SqlConnectionString“ ein Fügen Sie die connection string Ihrer Azure SQL Database, die Sie soeben kopiert haben, ein.

    Dadurch wird eine Anwendungseinstellung namens "connection SqlConnectionString" in Ihrer Funktions-App in Azure erstellt. Jetzt können Sie diese Einstellung in Ihre Datei local.settings.json herunterladen.

  4. Drücken Sie Ctrl/Cmd+shift+P erneut, um die Befehlspalette zu öffnen, suchen Sie dann nach dem Befehl und führen Sie ihn aus Azure Functions: Download Remote Settings....

  5. Wählen Sie die im vorherigen Artikel erstellte Funktions-App aus. Wählen Sie Ja, alle aus, um die vorhandenen lokalen Einstellungen zu überschreiben.

Hierdurch werden alle Einstellungen von Azure auf Ihr lokales Projekt heruntergeladen, einschließlich der neuen Verbindungszeichenfolge-Einstellung. Die meisten heruntergeladenen Einstellungen werden bei der lokalen Ausführung nicht verwendet.

Registrieren von Bindungserweiterungen

Da Sie eine Azure SQL Ausgabebindung verwenden, müssen Sie die entsprechende Bindungserweiterung installiert haben, bevor Sie die project ausführen.

Mit Ausnahme von HTTP- und Timertriggern werden Bindungen als Erweiterungspakete implementiert. Führen Sie den folgenden Befehl dotnet add package im Terminalfenster aus, um dem project das Azure SQL Erweiterungspaket hinzuzufügen.

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Sql

Ihr Projekt wurde konfiguriert, um Extension Bundles zu verwenden, die einen vordefinierten Satz von Erweiterungspaketen automatisch installieren.

Die Verwendung von Erweiterungspaketen ist in der Datei host.json am Stamm des Projekts aktiviert, die folgendes Layout hat:

{
  "version": "2.0",
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  },
  "concurrency": {
    "dynamicConcurrencyEnabled": true,
    "snapshotPersistenceEnabled": true
  }
}

:::

Jetzt können Sie Ihrer Projekt die Azure SQL Output-Bindung hinzufügen.

Hinzufügen einer Ausgabebindung

In Functions muss für jeden Typ von Bindung eine direction, ein type und ein eindeutiger name in der Datei „function.json“ definiert werden. Wie Sie diese Attribute definieren, hängt von der Sprache der Funktions-App ab.

Öffnen Sie die Datei HttpExample.cs project, und fügen Sie die folgende ToDoItem-Klasse hinzu, die das objekt definiert, das in die Datenbank geschrieben wird:

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

In einem C#-Klassenbibliothek-Projekt werden die Bindungen als Bindungsattribute für die Funktionsmethode definiert. Die von Functions benötigte Datei function.json wird basierend auf diesen Attributen automatisch generiert.

Öffnen Sie die Datei HttpExample.cs project, und fügen Sie die folgende Ausgabetypklasse hinzu, die die kombinierten Objekte definiert, die von unserer Funktion sowohl für die HTTP-Antwort als auch für die SQL-Ausgabe ausgegeben werden:

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

Fügen Sie der Bibliothek Microsoft.Azure.Functions.Worker.Extensions.Sql am Anfang der Datei eine using-Anweisung hinzu:

using Microsoft.Azure.Functions.Worker.Extensions.Sql;

Bindungsattribute werden direkt in Ihrem Code definiert. Die ausgabekonfiguration Azure SQL beschreibt die felder, die für eine Azure SQL Ausgabebindung erforderlich sind.

Für dieses MultiResponse-Szenario müssen Sie der Funktion eine Ausgabebindung vom Typ extraOutputs hinzufügen.

app.http('HttpExample', {
  methods: ['GET', 'POST'],
  extraOutputs: [sendToSql],
  handler: async (request, context) => {

Fügen Sie der Bindungskonfiguration die folgenden Eigenschaften hinzu:

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

Bindungsattribute werden direkt in der Datei function_app.py definiert. Sie verwenden den generic_output_binding-Dekoror, um eine Azure SQL Ausgabebindung hinzuzufügen:

@app.generic_output_binding(arg_name="toDoItems", type="sql", CommandText="dbo.ToDo", ConnectionStringSetting="SqlConnectionString"
    data_type=DataType.STRING)

In diesem Code identifiziert arg_name den Bindungsparameter, auf den in Ihrem Code verwiesen wird, type die Ausgabebindung als SQL-Ausgabebindung angibt, CommandText die Tabelle ist, in die die Bindung schreibt, und ConnectionStringSetting ist der Name einer Anwendungseinstellung, die die Azure SQL connection string enthält. Die connection string befindet sich in der Einstellung "SqlConnectionString" in der Datei local.settings.json.

Hinzufügen von Code, der die Ausgabebindung verwendet

Ersetzen Sie die vorhandene Ausführungsmethode durch den folgenden Code:

[Function("HttpExample")]
public static OutputType Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req,
    FunctionContext executionContext)
{
    var logger = executionContext.GetLogger("HttpExample");
    logger.LogInformation("C# HTTP trigger function processed a request.");

    var message = "Welcome to Azure Functions!";

    var response = req.CreateResponse(HttpStatusCode.OK);
    response.Headers.Add("Content-Type", "text/plain; charset=utf-8");
    response.WriteString(message);

    // Return a response to both HTTP trigger and Azure SQL output binding.
    return new OutputType()
    {
         ToDoItem = new ToDoItem
        {
            id = System.Guid.NewGuid().ToString(),
            title = message,
            completed = false,
            url = ""
        },
        HttpResponse = response
    };
}

Fügen Sie Code hinzu, der das extraInputs-Ausgabebindungsobjekt für context verwendet, um ein JSON-Dokument an die benannte Ausgabebindungsfunktion sendToSql zu senden. Fügen Sie diesen Code vor der return-Anweisung hinzu.

const data = JSON.stringify([
  {
    // create a random ID
    Id: crypto.randomUUID(),
    title: name,
    completed: false,
    url: '',
  },
]);

// Output to Database
context.extraOutputs.set(sendToSql, data);

Um das crypto-Modul zu verwenden, fügen Sie am Anfang der Datei die folgende Zeile hinzu:

const crypto = require("crypto");

Die Funktion sollte nun wie folgt aussehen:

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

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

app.http('HttpExample', {
  methods: ['GET', 'POST'],
  extraOutputs: [sendToSql],
  handler: async (request, context) => {
    try {
      context.log(`Http function processed request for url "${request.url}"`);

      const name = request.query.get('name') || (await request.text());

      if (!name) {
        return { status: 404, body: 'Missing required data' };
      }

      // Stringified array of objects to be inserted into the database
      const data = JSON.stringify([
        {
          // create a random ID
          Id: crypto.randomUUID(),
          title: name,
          completed: false,
          url: '',
        },
      ]);

      // Output to Database
      context.extraOutputs.set(sendToSql, data);

      const responseMessage = name
        ? 'Hello, ' +
          name +
          '. This HTTP triggered function executed successfully.'
        : 'This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.';

      // Return to HTTP client
      return { body: responseMessage };
    } catch (error) {
      context.log(`Error: ${error}`);
      return { status: 500, body: 'Internal Server Error' };
    }
  },
});

Aktualisieren Sie function_app.py , um dem folgenden Code zu entsprechen. Fügen Sie dem Parameter toDoItems die Funktionsdefinition und toDoItems.set() unter der if name:-Anweisung hinzu:

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

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="hello", auth_level=func.AuthLevel.FUNCTION)
@app.generic_output_binding(arg_name="toDoItems", type="sql", CommandText="dbo.ToDo", ConnectionStringSetting="SqlConnectionString",data_type=DataType.STRING)
def test_function(req: func.HttpRequest, toDoItems: func.Out[func.SqlRow]) -> func.HttpResponse:
     logging.info('Python HTTP trigger function processed a request.')
     name = req.get_json().get('name')
     if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

     if name:
        toDoItems.set(func.SqlRow({"Id": str(uuid.uuid4()), "title": name, "completed": False, "url": ""}))
        return func.HttpResponse(f"Hello {name}!")
     else:
        return func.HttpResponse(
                    "Please pass a name on the query string or in the request body",
                    status_code=400
                )

Lokales Ausführen der Funktion

Visual Studio Code lässt sich in Azure Functions Core-Tools integrieren, damit Sie dieses Projekt auf Ihrem lokalen Entwicklungscomputer ausführen können, bevor Sie es nach Azure veröffentlichen. Wenn Sie core Tools noch nicht lokal installiert haben, werden Sie aufgefordert, sie beim ersten Ausführen des project zu installieren.

  1. Um die Funktion aufzurufen, drücken Sie F5, um das Funktionsanwendungsprojekt zu starten. Im Terminalbereich wird die Ausgabe aus den Core Tools angezeigt. Ihre App wird im Terminal-Bereich gestartet. Der lokal ausgeführte URL-Endpunkt Ihrer über HTTP ausgelösten Funktion wird angezeigt.

    Screenshot der Funktion 'Local'-Ausgabe in Visual Studio Code.

    Wenn Sie noch keine Core Tools installiert haben, wählen Sie Install aus, um Core Tools zu installieren, wenn Sie dazu aufgefordert werden.
    Wenn Probleme bei der Ausführung unter Windows auftreten, stellen Sie sicher, dass das Standardterminal für Visual Studio Code nicht auf WSL Bash festgelegt ist.

  2. Wechseln Sie, wenn die Core-Tools ausgeführt werden, zum Bereich Azure: Functions. Unter Functions erweitern Sie Local Project>Functions. Klicken Sie unter Windows mit der rechten Maustaste (unter macOS STRG+Mausklick) auf die Funktion HttpExample, und wählen Sie Funktion jetzt ausführen... aus.

    Screenshot der Ausführungsfunktion jetzt aus Visual Studio Code.

  3. Drücken Sie in Anforderungstext eingeben die EINGABETASTE, um eine Anforderungsnachricht an Ihre Funktion zu übermitteln.

  4. Wenn die Funktion lokal ausgeführt wird und eine Antwort zurückgibt, wird eine Benachrichtigung in Visual Studio Code ausgelöst. Informationen zur Funktionsausführung werden im Terminalbereich angezeigt.

  5. Drücken Sie STRG+C, um die Core Tools zu beenden und die Verbindung mit dem Debugger zu trennen.

Lokales Ausführen der Funktion

  1. Wie im vorherigen Artikel drücken Sie F5, um das Funktions-App-Projekt und die Core-Tools zu starten.

  2. Wechseln Sie bei ausgeführten Kerntools zum Bereich Azure: Functions. Unter Functions erweitern Sie Local Project>Functions. Klicken Sie mit der rechten Maustaste (unter macOS STRG+Mausklick) auf die Funktion HttpExample, und wählen Sie Funktion jetzt ausführen... aus.

    Screenshot des Menüpunktes „Jetzt ausführen“ aus Visual Studio Code.

  3. Unter Enter request body (Anforderungstext eingeben) wird { "name": "Azure" } als Wert für den Text der Anforderungsnachricht angezeigt. Drücken Sie die EINGABETASTE, um diese Anforderungsnachricht an Ihre Funktion zu senden.

  4. Drücken Sie nach der Rückgabe einer Antwort STRG+C, um Core Tools zu beenden.

Überprüfen, ob Informationen in die Datenbank geschrieben wurden

  1. Wechseln Sie auf dem Azure-Portal zurück zu Ihrer Azure SQL-Datenbank und wählen Sie den Abfrage-Editor aus.

    Screenshot der Anmeldung beim Abfrage-Editor im Azure-Portal.

  2. Stellen Sie eine Verbindung mit Ihrer Datenbank her, und erweitern Sie den Knoten Tables in object explorer auf der linken Seite. Klicken Sie mit der rechten Maustaste auf die Tabelle dbo.ToDo, und wählen Sie Oberste 1.000 Zeilen auswählen aus.

  3. Überprüfen Sie, ob die neuen Informationen von der Ausgabebindung in die Datenbank geschrieben wurden.

Erneutes Bereitstellen und Überprüfen der aktualisierten App

  1. Drücken Sie in Visual Studio Code F1, um die Befehlspalette zu öffnen. Suchen Sie in der Befehlspalette den Befehl Azure Functions: Deploy to function app..., und wählen Sie ihn aus.

  2. Wählen Sie die im ersten Artikel erstellte Funktions-App aus. Da Sie Ihr Projekt in derselben App erneut deployen, wählen Sie Deploy aus, um die Warnung zum Überschreiben von Dateien zu schließen.

  3. Nach Abschluss der Bereitstellung können Sie die Funktion Execute Function Now verwenden, um die Funktion in Azure auszulösen. Dieser Befehl ruft automatisch den Funktionszugriffsschlüssel ab und verwendet ihn beim Aufrufen des Endpoints des HTTP-Triggers.

  4. Überprüfen Sie die in Ihre Azure SQL Database geschriebenen Daten, um zu bestätigen, dass die Ausgabebindung erneut ein neues JSON-Dokument generiert.

Bereinigen von Ressourcen

In Azure beziehen sich Ressourcen auf Funktions-Apps, Funktionen, Speicherkonten und so weiter. Sie werden in Ressourcengruppen zusammengefasst, und sämtliche Inhalte einer Gruppe können durch das Löschen der Gruppe gelöscht werden.

Im Rahmen dieser Schnellstartanleitungen haben Sie Ressourcen erstellt. Je nach Ihrem Kontostatus und Servicepreisen können Ihnen diese Ressourcen in Rechnung gestellt werden. Nicht mehr benötigte Ressourcen können wie folgt gelöscht werden:

  1. Drücken Sie in Visual Studio Code F1, um die Befehlspalette zu öffnen. Suchen Sie in der Befehlspalette den Befehl Azure: Open in portal, und wählen Sie ihn aus.

  2. Wählen Sie Ihre Funktions-App aus, und drücken Sie die EINGABETASTE. Die Seite der Funktions-App wird im Azure portal geöffnet.

  3. Wählen Sie auf der Registerkarte Übersicht den benannten Link neben Ressourcengruppe aus.

    Screenshot der Auswahl der Ressourcengruppe, die von der Funktions-App-Seite gelöscht werden soll

  4. Überprüfen Sie auf der Seite Ressourcengruppe die Liste mit den enthaltenen Ressourcen, und vergewissern Sie sich, dass es sich dabei um die Ressourcen handelt, die Sie löschen möchten.

  5. Klicken Sie auf Ressourcengruppe löschen, und folgen Sie den Anweisungen.

    Der Löschvorgang kann einige Minuten dauern. Nach Abschluss des Vorgangs wird kurz eine Benachrichtigung angezeigt. Sie können auch am oberen Seitenrand auf das Glockensymbol klicken, um die Benachrichtigung anzuzeigen.

Nächste Schritte

Sie haben Ihre HTTP-ausgelöste Funktion aktualisiert, um Daten in Azure SQL Database zu schreiben. Jetzt erfahren Sie mehr über die Entwicklung von Funktionen mithilfe von Visual Studio Code:

  • Last updated on