Teilen über

Dapr Veröffentlichen der Ausgabebindung für Azure-Funktionen

Mit der Dapr-Ausgabebindung können Sie eine Nachricht während einer Funktionsausführung in einem Dapr-Thema veröffentlichen.

Informationen zu Setup- und Konfigurationsdetails der Dapr-Erweiterung finden Sie in der Dapr-Erweiterungsübersicht.

Example

Eine C#-Funktion kann mit einem der folgenden C#-Modi erstellt werden:

Execution model Description
Isoliertes Workermodell Ihr Funktionscode wird in einem separaten .NET-Workerprozess ausgeführt. Verwenden Sie dazu unterstützte Versionen von .NET und .NET Framework. Weitere Informationen finden Sie im Handbuch zum Ausführen von C#-Azure-Funktionen im isolierten Arbeitsmodell.
In-process model Ihr Funktionscode wird im gleichen Prozess wie der Functions-Hostprozess ausgeführt. Unterstützt nur LTS-Versionen (Long Term Support) von .NET. Weitere Informationen finden Sie unter Entwickeln von C#-Klassenbibliotheksfunktionen mithilfe von Azure Functions.

Das folgende Beispiel veranschaulicht die Verwendung einer Dapr-Veröffentlichungsausgabebindung zum Ausführen eines Dapr-Veröffentlichungsvorgangs in einer pub/sub-Komponente und einem Thema.

[FunctionName("PublishOutputBinding")]
public static void Run(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = "topic/{topicName}")] HttpRequest req,
    [DaprPublish(PubSubName = "%PubSubName%", Topic = "{topicName}")] out DaprPubSubEvent pubSubEvent,
    ILogger log)
{
    string requestBody = new StreamReader(req.Body).ReadToEnd();
    pubSubEvent = new DaprPubSubEvent(requestBody);
}

Im folgenden Beispiel wird eine "TransferEventBetweenTopics" Funktion mithilfe der DaprPublishOutput Bindung mit einer DaprTopicTrigger:

@FunctionName("TransferEventBetweenTopics")
public String run(
        @DaprTopicTrigger(
            pubSubName = "%PubSubName%",
            topic = "A")
            String request,
        @DaprPublishOutput(
            pubSubName = "%PubSubName%",
            topic = "B")
        OutputBinding<String> payload,
        final ExecutionContext context) throws JsonProcessingException {
    context.getLogger().info("Java function processed a TransferEventBetweenTopics request from the Dapr Runtime.");
}

Im folgenden Beispiel wird die Dapr-Ausgabebindung mit einem HTTP-Trigger gekoppelt, der app vom Objekt registriert wird:

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

app.generic('PublishOutputBinding', {
    trigger: trigger.generic({
        type: 'httpTrigger',
        authLevel: 'anonymous',
        methods: ['POST'],
        route: "topic/{topicName}",
        name: "req"
    }),
    return: daprPublishOutput,
    handler: async (request, context) => {
        context.log("Node HTTP trigger function processed a request.");
        const payload = await request.text();
        context.log(JSON.stringify(payload));

        return { payload: payload };
    }
});

The following examples show Dapr triggers in a function.json file and PowerShell code that uses those bindings.

Here's the function.json file for daprPublish:

{
  "bindings": 
    {
      "type": "daprPublish",
      "direction": "out",
      "name": "pubEvent",
      "pubsubname": "%PubSubName%",
      "topic": "B"
    }
}

For more information about function.json file properties, see the Configuration section.

In code:

using namespace System
using namespace Microsoft.Azure.WebJobs
using namespace Microsoft.Extensions.Logging
using namespace Microsoft.Azure.WebJobs.Extensions.Dapr
using namespace Newtonsoft.Json.Linq

# Example to use Dapr Service Invocation Trigger and Dapr State Output binding to persist a new state into statestore
param (
    $subEvent
)

Write-Host "PowerShell function processed a TransferEventBetweenTopics request from the Dapr Runtime."

# Convert the object to a JSON-formatted string with ConvertTo-Json
$jsonString = $subEvent["data"]

$messageFromTopicA = "Transfer from Topic A: $jsonString".Trim()

$publish_output_binding_req_body = @{
    "payload" = $messageFromTopicA
}

# Associate values to output bindings by calling 'Push-OutputBinding'.
Push-OutputBinding -Name pubEvent -Value $publish_output_binding_req_body

Das folgende Beispiel zeigt eine Dapr Publish-Ausgabebindung, die das v2 Python-Programmiermodell verwendet. So verwenden Sie daprPublish in Ihrem Python-Funktions-App-Code:

import logging
import json
import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="TransferEventBetweenTopics")
@app.dapr_topic_trigger(arg_name="subEvent", pub_sub_name="%PubSubName%", topic="A", route="A")
@app.dapr_publish_output(arg_name="pubEvent", pub_sub_name="%PubSubName%", topic="B")
def main(subEvent, pubEvent: func.Out[bytes]) -> None:
    logging.info('Python function processed a TransferEventBetweenTopics request from the Dapr Runtime.')
    subEvent_json = json.loads(subEvent)
    payload = "Transfer from Topic A: " + str(subEvent_json["data"])
    pubEvent.set(json.dumps({"payload": payload}).encode('utf-8'))

Attributes

In the in-process model, use the DaprPublish to define a Dapr publish output binding, which supports these parameters:

function.json property Description Kann per Attribut gesendet werden Kann über RequestBody gesendet werden
PubSubName Der Name des Dapr pub/sub zum Senden der Nachricht. ✔️ ✔️
Topic Der Name des Themas "Dapr", um die Nachricht zu senden. ✔️ ✔️
Payload Required. Die Nachricht, die veröffentlicht wird. ❌ ✔️

Annotations

Mit der DaprPublishOutput Anmerkung können Sie über eine Funktion auf eine veröffentlichte Nachricht zugreifen.

Element Description Kann per Attribut gesendet werden Kann über RequestBody gesendet werden
pubSubName Der Name des Dapr pub/sub zum Senden der Nachricht. ✔️ ✔️
topic Der Name des Themas "Dapr", um die Nachricht zu senden. ✔️ ✔️
payload Required. Die Nachricht, die veröffentlicht wird. ❌ ✔️

Configuration

Die folgende Tabelle gibt Aufschluss über die Bindungskonfigurationseigenschaften, die Sie im Code festlegen.

Property Description Kann per Attribut gesendet werden Kann über RequestBody gesendet werden
pubsubname Der Name des Herausgeberkomponentendiensts. ✔️ ✔️
topic Der Name/Bezeichner des Herausgeberthemas. ✔️ ✔️
payload Required. Die Nachricht, die veröffentlicht wird. ❌ ✔️

The following table explains the binding configuration properties that you set in the function.json file.

function.json property Description Kann per Attribut gesendet werden Kann über RequestBody gesendet werden
pubsubname Der Name des Herausgeberkomponentendiensts. ✔️ ✔️
topic Der Name/Bezeichner des Herausgeberthemas. ✔️ ✔️
payload Required. Die Nachricht, die veröffentlicht wird. ❌ ✔️

Die folgende Tabelle gibt Aufschluss über die Bindungskonfigurationseigenschaften für @dapp.dapr_publish_output, die Sie im Python-Code festlegen.

Property Description Kann per Attribut gesendet werden Kann über RequestBody gesendet werden
pub_sub_name Der Name des Herausgeberereignisses. ✔️ ✔️
topic Der Herausgeberthemaname/-bezeichner. ✔️ ✔️
payload Required. Die Nachricht, die veröffentlicht wird. ❌ ✔️

Wenn Eigenschaften sowohl in Attributen als auch in RequestBody definiert sind, haben die in RequestBody bereitgestellten Daten höhere Priorität.

See the Example section for complete examples.

Usage

Um die Dapr-Ausgabebindung zu verwenden, richten Sie zunächst eine Dapr pub/sub-Komponente ein. In der offiziellen Dapr-Dokumentation erfahren Sie mehr darüber, welche Komponente Sie verwenden sollten und wie Sie diese einrichten können.

Um daprPublish in Python v2 zu verwenden, richten Sie Ihr Projekt mit den richtigen Abhängigkeiten ein.

  1. Erstellen und Aktivieren einer virtuellen Umgebung

  2. Fügen Sie in Ihrer requirements.text-Datei die folgende Zeile hinzu:

    azure-functions==1.18.0b3

  3. Installieren Sie im Terminal die Python-Bibliothek.

    pip install -r .\requirements.txt

  4. Ändern Sie ihre local.setting.json-Datei mit der folgenden Konfiguration:

    "PYTHON_ISOLATE_WORKER_DEPENDENCIES":1

Next steps

Weitere Informationen zum Veröffentlichen und Abonnieren von Dapr.

  • Last updated on