Share via

Eingabebindung des Dapr-Geheimnisses für Azure Functions

  • Artikel

Wichtig

Die Dapr-Erweiterung für Azure Functions befindet sich derzeit in der Vorschau und wird nur in Azure Container Apps-Umgebungen unterstützt.

Mit dem Eingabebindung des Dapr-Geheimnis können Sie geheime Daten während der Funktionsausführung als Eingabe lesen.

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

Beispiel

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

Ausführungsmodell Beschreibung
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 unter Entwickeln von isolierten .NET-Workerprozessfunktionen.
In-Process-Modell 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 .NET-Klassenbibliotheksfunktionen. 
[FunctionName("RetrieveSecret")]
public static void Run(
    [DaprServiceInvocationTrigger] object args,
    [DaprSecret("kubernetes", "my-secret", Metadata = "metadata.namespace=default")] IDictionary<string, string> secret,
    ILogger log)
{
    log.LogInformation("C# function processed a RetrieveSecret request from the Dapr Runtime.");
}

Im folgenden Beispiel wird eine "RetreveSecret"-Funktion mithilfe der DaprSecretInput-Bindung mit DaprServiceInvocationTrigger erstellt:

@FunctionName("RetrieveSecret")
public void run(
    @DaprServiceInvocationTrigger(
        methodName = "RetrieveSecret") Object args,
    @DaprSecretInput(
        secretStoreName = "kubernetes", 
        key = "my-secret", 
        metadata = "metadata.namespace=default") 
        Map<String, String> secret,
    final ExecutionContext context)

Im folgenden Beispiel wird die geheime Dapr-Eingabebindung mit einem Dapr-Aufruftrigger gekoppelt, der app vom Objekt registriert wird:

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

app.generic('RetrieveSecret', {
    trigger: trigger.generic({
        type: 'daprServiceInvocationTrigger',
        name: "payload"
    }),
    extraInputs: [daprSecretInput],
    handler: async (request, context) => {
        context.log("Node function processed a RetrieveSecret request from the Dapr Runtime.");
        const daprSecretInputValue = context.extraInputs.get(daprSecretInput);

        // print the fetched secret value
        for (var key in daprSecretInputValue) {
            context.log(`Stored secret: Key=${key}, Value=${daprSecretInputValue[key]}`);
        }
    }
});

Die folgenden Beispiele zeigen Dapr-Trigger in der Datei function.json und PowerShell-Code, der diese Bindungen verwendet.

Hier sehen Sie die Datei function.json für daprServiceInvocationTrigger:

{
  "bindings": 
    {
      "type": "daprSecret",
      "direction": "in",
      "name": "secret",
      "key": "my-secret",
      "secretStoreName": "localsecretstore",
      "metadata": "metadata.namespace=default"
    }
}

Weitere Informationen zu den Dateieigenschaften von function.json finden Sie im Abschnitt Konfiguration.

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

param (
    $payload, $secret
)

# PowerShell function processed a CreateNewOrder request from the Dapr Runtime.
Write-Host "PowerShell function processed a RetrieveSecretLocal request from the Dapr Runtime."

# Convert the object to a JSON-formatted string with ConvertTo-Json
$jsonString = $secret | ConvertTo-Json

Write-Host "$jsonString"

Das folgende Beispiel zeigt eine Eingabebindung des Dapr-Geheimnisses, die das v2 Python-Programmiermodell verwendet. So verwenden Sie die daprSecret-Bindung zusammen mit daprServiceInvocationTrigger in Ihrem Python-Funktions-App-Code:

import logging
import json
import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="RetrieveSecret")
@app.dapr_service_invocation_trigger(arg_name="payload", method_name="RetrieveSecret")
@app.dapr_secret_input(arg_name="secret", secret_store_name="localsecretstore", key="my-secret", metadata="metadata.namespace=default")
def main(payload, secret: str) :
    # Function should be invoked with this command: dapr invoke --app-id functionapp --method RetrieveSecret  --data '{}'
    logging.info('Python function processed a RetrieveSecret request from the Dapr Runtime.')
    secret_dict = json.loads(secret)

    for key in secret_dict:
        logging.info("Stored secret: Key = " + key +
                     ', Value = ' + secret_dict[key])

Attribute

Verwenden Sie im In-Process-Modell die DaprSecret, um eine Eingabebindung des Dapr-Geheimnisses zu definieren, die diese Parameter unterstützt:

Parameter Beschreibung
SecretStoreName Der Name des Geheimnisspeichers, um den geheimen Schlüssel abzurufen.
Schlüssel Der Schlüssel, der den Namen des geheimen Schlüssels identifiziert, der abgerufen werden soll.
Metadaten Optional. Ein Array von Metadateneigenschaften im Schema "key1=value1&key2=value2".

Anmerkungen

Mit der Anmerkung DaprSecretInput können Sie einer Funktion Zugriff auf ein Geheimnis gewähren.

Element Beschreibung
secretStoreName Der Name des Dapr-Geheimspeichers.
key Der Wert des geheimen Schlüssels.
metadata Optional. Die Metadatenwerte.

Konfiguration

In der folgenden Tabelle werden die Bindungskonfigurationseigenschaften erläutert, die Sie im Code festlegen.

Eigenschaft Beschreibung
key Der Wert des geheimen Schlüssels.
secretStoreName Name des Geheimnisspeichers gemäß Definition in der Komponentendatei local-secret-store.yaml.
metadata Der Metadaten-Namespace.

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

function.json-Eigenschaft Beschreibung
key Der Wert des geheimen Schlüssels.
secretStoreName Name des Geheimnisspeichers gemäß Definition in der Komponentendatei local-secret-store.yaml.
metadata Der Metadaten-Namespace.

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

Eigenschaft Beschreibung
secret_store_name Der Name des Geheimnisspeichers.
key Der Wert des geheimen Schlüssels.
metadata Der Metadaten-Namespace.

Vollständige Beispiele finden Sie im Abschnitt Beispiele.

Verwendung

Um die Eingabebindung des Dapr-Geheimnisses zu verwenden, richten Sie zunächst eine Komponente für den Dapr-Geheimnisspeicher ein. In der offiziellen Dapr-Dokumentation erfahren Sie mehr darüber, welche Komponente Sie verwenden sollten und wie Sie diese einrichten können.

Um daprSecret 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

Nächste Schritte

Erfahren Sie mehr über Dapr-Geheimnisse.