Eingabebindung des Dapr-Geheimnisses für Azure Functions

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.

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.

In-process

[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.");
}

Isolated process

More samples for the Dapr input secret binding are available in the GitHub repository.

[Function("RetrieveSecret")]
public static void Run(
    [DaprServiceInvocationTrigger] object args,
    [DaprSecretInput("kubernetes", "my-secret", Metadata = "metadata.namespace=default")] IDictionary<string, string> secret, 
    FunctionContext functionContext)
{
    var log = functionContext.GetLogger("RetrieveSecret");
    log.LogInformation("C# function processed a RetrieveSecret request from the Dapr Runtime.");

    // print the fetched secret value
    // this is only for demo purpose
    // please do not log any real secret in your production code        
    foreach (var kvp in secret)
    {
        log.LogInformation("Stored secret: Key = {0}, Value = {1}", kvp.Key, kvp.Value);
    }

}

Im folgenden Beispiel wird eine "RetrieveSecret"-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)

Node.js v4

Im folgenden Beispiel wird die geheime Dapr-Ausgabebindung mit einem Dapr-Aufruftrigger gekoppelt, der vom app-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]}`);
        }
    }
});

Node.js v3

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

Here's the function.json file for daprServiceInvocationTrigger:

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

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

Der JavaScript-Code sieht wie folgt aus:

module.exports = async function (context) {
    context.log("Node function processed a RetrieveSecret request from the Dapr Runtime.");

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

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 daprServiceInvocationTrigger:

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

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

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"

Python v2

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

Python v1

Das folgende Beispiel zeigt eine Eingabebindung des Dapr-Geheimnisses, die das v1 Python-Programmiermodell verwendet.

Here's the function.json file for daprSecret:

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

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

Dies ist der Python-Code:

import logging
import json
import azure.functions as func

def main (payload, secret) -> None:
    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])

Attributes

In-process

In the in-process model, use the DaprSecret to define a Dapr secret input binding, which supports these parameters:

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

Isolated process

Verwenden Sie im Modell mit isoliertem Worker den DaprSecretInput, um eine Eingabebindung des Dapr-Geheimnisses zu definieren, die diese Parameter unterstützt:

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

Annotations

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

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

Configuration

Node.js v4

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

Property	Description
key	Der Wert des geheimen Schlüssels.
secretStoreName	Name of the secret store as defined in the local-secret-store.yaml component file.
metadata	Der Metadaten-Namespace.

Node.js v3

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

function.json property	Description
key	Der Wert des geheimen Schlüssels.
secretStoreName	Name of the secret store as defined in the local-secret-store.yaml component file.
metadata	Der Metadaten-Namespace.

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

function.json property	Description
key	Der Wert des geheimen Schlüssels.
secretStoreName	Name of the secret store as defined in the local-secret-store.yaml component file.
metadata	Der Metadaten-Namespace.

Python v2

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

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

Python v1

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

function.json property	Description
key	Der Wert des geheimen Schlüssels.
secretStoreName	Name of the secret store as defined in the local-secret-store.yaml component file.
metadata	Der Metadaten-Namespace.

See the Example section for complete examples.

Usage

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.

• Spezifikationen von Dapr-Geheimnisspeicher-Komponenten
• Abrufen eines Geheimnisses

Python v2

To use the daprSecret in Python v2, set up your project with the correct dependencies.

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
   

Python v1

Das Python v1-Modell erfordert keine zusätzlichen Änderungen, abgesehen von der Einrichtung des Geheimnisspeichers.

Next steps

Erfahren Sie mehr über Dapr-Geheimnisse.