Verbinden von Azure Functions mit Azure Storage mithilfe von Befehlszeilentools

Bevor Sie beginnen, müssen Sie den Artikel Quickstart: Erstellen Sie ein Azure Functions-Projekt über die Kommandozeile 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 Artikel Quickstart: Erstellen Sie ein Azure Functions-Projekt über die Befehlszeile 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 Artikel Quickstart: Erstellen Sie ein Azure Functions-Projekt über die Befehlszeilenschnittstelle 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 Artikel Quickstart: Erstellen Sie ein Azure Functions-Projekt über die Befehlszeilenschnittstelle 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 Artikel Quickstart: Erstellen Sie ein Azure Functions Projekt über die Befehlszeilenschnittstelle fertigstellen. 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 Artikel Quickstart: Erstellen Sie ein Azure Functions-Projekt über die Befehlszeile 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.

Registrieren von Bindungserweiterungen

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 Storage Erweiterungspaket hinzuzufügen.

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Storage.Queues --prerelease

dotnet add package Microsoft.Azure.WebJobs.Extensions.Storage 

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

Hinzufügen einer Ausgabebindungsdefinition zur Funktion

Obwohl eine Funktion nur einen Trigger haben kann, kann sie mehrere Eingabe- und Ausgabebindungen aufweisen, mit denen Sie eine Verbindung mit anderen Azure Diensten und Ressourcen herstellen können, ohne benutzerdefinierten Integrationscode zu schreiben.

Bei Verwendung des Node.js v4-Programmiermodells werden Bindungsattribute direkt in der Datei ./src/functions/HttpExample.js definiert. Aus der vorherigen Schnellstartanleitung enthält Ihre Datei bereits eine HTTP-Bindung, die durch die Methode app.http definiert wird.

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

app.http('httpTrigger', {
  methods: ['GET', 'POST'],
  authLevel: 'anonymous',
  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) {
        return { status: 404, body: 'Not Found' };
      }

      return { body: `Hello, ${name}!` };
    } catch (error) {
      context.log(`Error: ${error}`);
      return { status: 500, body: 'Internal Server Error' };
    }
  },
});

Bei Verwendung des Node.js v4-Programmiermodells werden Bindungsattribute direkt in der Datei ./src/functions/HttpExample.js definiert. Aus der vorherigen Schnellstartanleitung enthält Ihre Datei bereits eine HTTP-Bindung, die durch die Methode app.http definiert wird.

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

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

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

  return { body: `Hello, ${name}!` };
}

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

Sie deklarieren diese Bindungen in der Datei function.json in Ihrem Funktionsordner. Im vorherigen Schnellstart enthält Ihre Datei function.json im Ordner HttpExample zwei Bindungen in der Sammlung bindings.

Bei Verwendung des Python v2-Programmiermodells werden Bindungsattribute direkt in der function_app.py-Datei als Dekorateure definiert. Aus der vorherigen Schnellstartanleitung enthält Ihre Datei function_app.py bereits eine Decorator-basierte Bindung:

import azure.functions as func
import logging

app = func.FunctionApp()

@app.function_name(name="HttpTrigger1")
@app.route(route="hello", auth_level=func.AuthLevel.ANONYMOUS)

Der route-Decorator fügt der Funktion die HttpTrigger- und HttpOutput-Bindung hinzu, sodass Ihre Funktion ausgelöst werden kann, wenn HTTP-Anforderungen die angegebene Route erreichen.

Wenn Sie aus dieser Funktion in eine Azure Storage-Warteschlange schreiben möchten, fügen Sie den Dekorator queue_output in Ihren Funktionscode ein:

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

Im Dekorateur 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 Schnellstarts verwenden Sie dasselbe Storage-Konto wie bei der Funktions-App, die sich in der Einstellung AzureWebJobsStorage befindet (aus der Datei "local.settings.json"). Wenn das queue_name-Element nicht vorhanden ist, erstellt die Bindung es bei der ersten Verwendung.

"bindings": [
  {
    "authLevel": "function",
    "type": "httpTrigger",
    "direction": "in",
    "name": "Request",
    "methods": [
      "get",
      "post"
    ]
  },
  {
    "type": "http",
    "direction": "out",
    "name": "Response"
  }
]

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: 'anonymous',
      handler: () => {}
  }
  

• Fügen Sie eine output.storageQueue-Funktion oberhalb des Aufrufs von app.http hinzu

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

Die zweite Bindung in der Sammlung hat den Namen res. Diese http-Bindung ist eine Ausgabebindung (out), die zum Schreiben der HTTP-Antwort verwendet wird.

Wenn Sie aus dieser Funktion in eine Azure Storage Warteschlange schreiben möchten, fügen Sie eine out Bindung vom Typ queue mit dem Namen msg hinzu, wie im folgenden Code gezeigt:

    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

Für einen queue-Typ müssen Sie den Namen der Warteschlange in queueName angeben und den name der Azure Storage verbindung (aus local.settings.jsondatei) in connection angeben.

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. Diese Zeichenfolgen werden als Nachrichten in eine Ausgabebindung geschrieben, wenn die Funktion abgeschlossen wird. 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. Sie übergeben die Anwendungseinstellung, die die Verbindungszeichenfolge des Speicherkontos enthält, anstatt die Verbindungszeichenfolge selbst zu übergeben.

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

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

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.

Fügen Sie Code hinzu, der das Ausgabebindungsobjekt für 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 für 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
})

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 muss nun wie im folgenden Beispiel aussehen:

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 zum Speicherort des Testcodes unter src/test/java, ö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);

Verwenden Sie im Ordner LocalFunctionsProj den Befehl func azure functionapp publish, um die project erneut bereitzustellen, indem Sie <APP_NAME> durch den Namen Ihrer App ersetzen.

func azure functionapp publish <APP_NAME>

Verwenden Sie im lokalen project Ordner den folgenden Maven-Befehl, um Ihre project erneut zu veröffentlichen:

mvn azure-functions:deploy

• 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 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