Verbinden von Azure Functions mit Azure Storage mithilfe von Visual Studio Code

• Installieren Sie .NET Core CLI-Tools.

Ihr Projekt wurde für die Verwendung von Erweiterungsbündeln konfiguriert, die automatisch einen vordefinierten Satz von Erweiterungspaketen installieren.

Erweiterungspakete sind bereits in der Datei host.json im Stammverzeichnis der project aktiviert, die wie im folgenden Beispiel aussehen sollte:

{
  "version": "2.0",
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[3.*, 4.0.0)"
  }
}

Jetzt können Sie dem Projekt die Speicher-Ausgabebindung hinzufügen.

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

Erweiterungspakete sind bereits in der Datei host.json im Stammverzeichnis der project aktiviert, die wie im folgenden Beispiel aussehen sollte:

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

Jetzt können Sie Ihrem Projekt die Speicher-Ausgabebindung hinzufügen.

Um in eine Azure Storage-Warteschlange zu schreiben:

• Hinzufügen einer extraOutputs-Eigenschaft zur Bindungskonfiguration

  {
      methods: ['GET', 'POST'],
      extraOutputs: [sendToQueue], // add output binding to HTTP trigger
      authLevel: 'function',
      handler: () => {}
  }
  

• Hinzufügen einer output.storageQueue-Funktion oberhalb des Aufrufs von app.http

  const sendToQueue = output.storageQueue({
    queueName: 'outqueue',
    connection: 'AzureWebJobsStorage',
  });
  

Um in eine Azure Storage-Warteschlange zu schreiben:

• Hinzufügen einer extraOutputs-Eigenschaft zur Bindungskonfiguration

  {
      methods: ['GET', 'POST'],
      extraOutputs: [sendToQueue], // add output binding to HTTP trigger
      authLevel: 'function',
      handler: () => {}
  }
  

• Hinzufügen einer output.storageQueue-Funktion oberhalb des Aufrufs von app.http

  const sendToQueue: StorageQueueOutput = output.storageQueue({
    queueName: 'outqueue',
    connection: 'AzureWebJobsStorage',
  });
  

In Functions benötigt jeder Bindungstyp einen direction, type und einen eindeutigen name. Wie Sie diese Attribute definieren, hängt von der Sprache der Funktions-App ab.

Bindungsattribute werden in der Datei function.json für eine bestimmte Funktion definiert. Abhängig vom Bindungstyp sind möglicherweise zusätzliche Eigenschaften erforderlich. Die Queue-Ausgabekonfiguration beschreibt die felder, die für eine Azure Storage Warteschlangenbindung erforderlich sind. Mit der Erweiterung können Bindungen einfach in der Datei function.json hinzugefügt werden.

Klicken Sie zum Erstellen einer Bindung im Ordner „HttpTrigger“ mit der rechten Maustaste (STRG+Klicken unter macOS) auf die Datei function.json, und wählen Sie Bindung hinzufügen... aus. Befolgen Sie die Anweisungen, um die folgenden Bindungseigenschaften für die neue Bindung zu definieren:

Eine Bindung wird dem Array bindings in der Datei function.json hinzugefügt, die wie folgt aussehen sollte:

      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

Bindungsattribute werden definiert, indem spezifischer Funktionscode in der Datei function_app.py ergänzt wird. Sie verwenden den queue_output-Dekorateur, um eine Azure-Warteschlangenspeicher-Ausgabebindung hinzuzufügen.

Mithilfe des queue_output-Dekorators ist die Bindungsrichtung implizit "out" – und der Typ ist Azure Storage Warteschlange. Fügen Sie Ihrem Funktionscode in der Datei function_app.py den folgenden Dekorator hinzu:

@app.queue_output(arg_name="msg", queue_name="outqueue", connection="AzureWebJobsStorage")

In diesem Code identifiziert arg_name den Bindungsparameter, auf den in Ihrem Code verwiesen wird, queue_name ist der Name der Warteschlange, in die die Bindung schreibt, und connection ist der Name einer Anwendungseinstellung, die den connection string für das Storage Konto enthält. In Quickstarts verwenden Sie dasselbe Speicherkonto wie die Funktions-App, die sich in der Einstellung AzureWebJobsStorage befindet. Wenn das queue_name-Element nicht vorhanden ist, erstellt die Bindung es bei der ersten Verwendung.

In einem C#-project werden die Bindungen als Bindungsattribute für die Funktionsmethode definiert. Bestimmte Definitionen hängen davon ab, ob Ihre App In-Process (C#-Klassenbibliothek) oder in einem isolierten Workerprozess ausgeführt wird.

public class MultiResponse
{
    [QueueOutput("outqueue", Connection = "AzureWebJobsStorage")]
    public string[] Messages { get; set; }
    public IActionResult HttpResponse { get; set; }
}

[Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg,

[FunctionName("HttpExample")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, 
    [Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg, 
    ILogger log)

In einem Java-project werden die Bindungen als Bindungsanmerkungen für die Funktionsmethode definiert. Die Datei function.json wird dann automatisch auf der Grundlage dieser Anmerkungen generiert.

Navigieren Sie zum Speicherort des Funktionscodes unter src/main/java, öffnen Sie die Datei Function.java project, und fügen Sie der run-Methodendefinition den folgenden Parameter hinzu:

@QueueOutput(name = "msg", queueName = "outqueue", 
connection = "AzureWebJobsStorage") OutputBinding<String> msg,

Der Parameter msg ist ein OutputBinding<T> Typ, der eine Auflistung von Zeichenfolgen darstellt, die als Nachrichten in eine Ausgabebindung geschrieben werden, wenn die Funktion abgeschlossen ist. In diesem Fall ist die Ausgabe eine Speicherwarteschlange mit dem Namen outqueue. Die Connection String für das Speicherkonto wird von der Methode connection festgelegt. Statt der Verbindungszeichenfolge selber übergeben Sie die Anwendungseinstellung, die die Storage-Konto-Verbindungszeichenfolge enthält.

Die Definition der Methode run sollte nun wie im folgenden Beispiel aussehen:

@FunctionName("HttpExample")
public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) 
        HttpRequestMessage<Optional<String>> request, 
        @QueueOutput(name = "msg", queueName = "outqueue", 
        connection = "AzureWebJobsStorage") OutputBinding<String> msg, 
        final ExecutionContext context) {

Fügen Sie Code hinzu, der das Ausgabebindungsobjekt mit context.extraOutputs verwendet, um eine Warteschlangennachricht zu erstellen. Fügen Sie diesen Code vor der return-Anweisung hinzu.

context.extraOutputs.set(sendToQueue, [msg]);

Ihre Funktion könnte nun wie folgt aussehen:

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

const sendToQueue = output.storageQueue({
  queueName: 'outqueue',
  connection: 'AzureWebJobsStorage',
});

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

      const name = request.query.get('name') || (await request.text());
      context.log(`Name: ${name}`);

      if (name) {
        const msg = `Name passed to the function ${name}`;
        context.extraOutputs.set(sendToQueue, [msg]);
        return { body: msg };
      } else {
        context.log('Missing required data');
        return { status: 404, body: 'Missing required data' };
      }
    } catch (error) {
      context.log(`Error: ${error}`);
      return { status: 500, body: 'Internal Server Error' };
    }
  },
});

Fügen Sie Code hinzu, der das Ausgabebindungsobjekt mit context.extraOutputs verwendet, um eine Warteschlangennachricht zu erstellen. Fügen Sie diesen Code vor der return-Anweisung hinzu.

context.extraOutputs.set(sendToQueue, [msg]);

Ihre Funktion könnte nun wie folgt aussehen:

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

const sendToQueue: StorageQueueOutput = output.storageQueue({
  queueName: 'outqueue',
  connection: 'AzureWebJobsStorage',
});

export async function HttpExample(
  request: HttpRequest,
  context: InvocationContext,
): Promise<HttpResponseInit> {
  try {
    context.log(`Http function processed request for url "${request.url}"`);

    const name = request.query.get('name') || (await request.text());
    context.log(`Name: ${name}`);

    if (name) {
      const msg = `Name passed to the function ${name}`;
      context.extraOutputs.set(sendToQueue, [msg]);
      return { body: msg };
    } else {
      context.log('Missing required data');
      return { status: 404, body: 'Missing required data' };
    }
  } catch (error) {
    context.log(`Error: ${error}`);
    return { status: 500, body: 'Internal Server Error' };
  }
}

app.http('HttpExample', {
  methods: ['GET', 'POST'],
  authLevel: 'anonymous',
  handler: HttpExample,
});

Fügen Sie Code hinzu, der das Cmdlet Push-OutputBinding verwendet, um Text unter Verwendung der Ausgabebindung msg in die Warteschlange zu schreiben. Fügen Sie diesen Code hinzu, bevor Sie den OK-Status in der if-Anweisung festlegen.

$outputMsg = $name
Push-OutputBinding -name msg -Value $outputMsg

Die Funktion muss nun wie folgt aussehen:

using namespace System.Net

# Input bindings are passed in via param block.
param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.
Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with query parameters or the body of the request.
$name = $Request.Query.Name
if (-not $name) {
    $name = $Request.Body.Name
}

if ($name) {
    # Write the $name value to the queue, 
    # which is the name passed to the function.
    $outputMsg = $name
    Push-OutputBinding -name msg -Value $outputMsg

    $status = [HttpStatusCode]::OK
    $body = "Hello $name"
}
else {
    $status = [HttpStatusCode]::BadRequest
    $body = "Please pass a name on the query string or in the request body."
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
    StatusCode = $status
    Body = $body
})

Aktualisieren Sie HttpExample\function_app.py so, dass es dem folgenden Code entspricht, indem Sie den Parameter msg zur Funktionsdefinition und msg.set(name) unter der if name:-Anweisung hinzufügen:

import azure.functions as func
import logging

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.route(route="HttpExample")
@app.queue_output(arg_name="msg", queue_name="outqueue", connection="AzureWebJobsStorage")
def HttpExample(req: func.HttpRequest, msg: func.Out [func.QueueMessage]) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')

    name = req.params.get('name')
    if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

    if name:
        msg.set(name)
        return func.HttpResponse(f"Hello, {name}. This HTTP triggered function executed successfully.")
    else:
        return func.HttpResponse(
             "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response.",
             status_code=200
        )

Der Parameter msg ist eine Instanz des azure.functions.Out class. Die set-Methode schreibt eine Zeichenfolgennachricht in die Warteschlange. In diesem Fall ist dies der name, der in der URL-Abfragezeichenfolge an die Funktion übergeben wird.

Nun können Sie den neuen Parameter msg verwenden, um von Ihrem Funktionscode aus in die Ausgabebindung zu schreiben. Fügen Sie vor der Erfolgsantwort die folgende Codezeile hinzu, um der Ausgabebindung name den Wert msg hinzuzufügen:

msg.setValue(name);

Wenn Sie eine Ausgabebindung verwenden, müssen Sie nicht den Azure Storage SDK-Code für die Authentifizierung, das Abrufen eines Warteschlangenverweises oder das Schreiben von Daten verwenden. Die Functions-Runtime und die Warteschlangenausgabebindung übernehmen diese Aufgaben für Sie.

Die Methode run sollte bei Ihnen nun wie im folgenden Beispiel aussehen:

@FunctionName("HttpExample")
public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) 
        HttpRequestMessage<Optional<String>> request, 
        @QueueOutput(name = "msg", queueName = "outqueue", 
        connection = "AzureWebJobsStorage") OutputBinding<String> msg, 
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a request.");

    // Parse query parameter
    String query = request.getQueryParameters().get("name");
    String name = request.getBody().orElse(query);

    if (name == null) {
        return request.createResponseBuilder(HttpStatus.BAD_REQUEST)
        .body("Please pass a name on the query string or in the request body").build();
    } else {
        // Write the name to the message queue. 
        msg.setValue(name);

        return request.createResponseBuilder(HttpStatus.OK).body("Hello, " + name).build();
    }
}

Aktualisieren der Tests

Da der Archetyp auch eine Reihe von Tests erstellt, müssen Sie diese Tests aktualisieren, um den neuen Parameter msg in der Signatur der Methode run zu behandeln.

Navigieren Sie unter src/test/java zum Speicherort des Testcodes, öffnen Sie die Datei Function.java project, und ersetzen Sie die Codezeile unter //Invoke durch den folgenden Code.

@SuppressWarnings("unchecked")
final OutputBinding<String> msg = (OutputBinding<String>)mock(OutputBinding.class);
final HttpResponseMessage ret = new Function().run(req, msg, context);

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.

   

   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. Navigieren Sie während die Kerntools laufen zum Bereich Azure: Functions. Erweitern Sie unter FunktionenLokales Projekt>Funktionen. 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.

   

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, wenn die Core-Tools ausgeführt werden, 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.

   

3. Im Anforderungstext Anforderungstext eingeben sehen Sie den Wert des Nachrichtentextes { "name": "Azure" }. Drücken Sie die EINGABETASTE, um diese Anforderungsmeldung an Ihre Funktion zu senden.

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

Da Sie die storage connection string verwenden, stellt Ihre Funktion beim lokalen Ausführen eine Verbindung mit dem Azure storage Konto bereit. Eine neue Warteschlange mit dem Namen outqueue wird in Ihrem Speicherkonto erstellt, wenn die Ausgabebindung zum ersten Mal verwendet wird. Sie verwenden Storage Explorer, um zu überprüfen, ob die Warteschlange zusammen mit der neuen Nachricht erstellt wurde.

• Beispiele für vollständige Funktionsprojekte in C#.

• Azure Functions C#-Entwicklerreferenz

• Beispiele vollständiger Funktionsprojekte in JavaScript.

• Azure Functions JavaScript-Entwicklerhandbuch

• Beispiele für vollständige Funktionsprojekte in Java.

• Azure Functions Java-Entwicklerhandbuch

• Beispiele für vollständige Funktionsprojekte in TypeScript.

• Azure Functions TypeScript-Entwicklerhandbuch

• Examples von vollständigen Funktionsprojekten in Python.

• Azure Functions Python-Entwicklerhandbuch

• Beispiele für vollständige Funktionsprojekte in PowerShell.

• Azure Functions PowerShell-Entwicklerhandbuch