Liaison d’entrée de secret Dapr pour Azure Functions

  • Article

Important

L’extension Dapr pour Azure Functions est en préversion et est prise en charge uniquement dans les environnements Azure Container Apps.

La liaison d’entrée de secret Dapr vous permet de lire les données de secrets sous forme d’entrée durant l’exécution d’une fonction.

Pour plus d’informations sur l’installation et la configuration de l’extension Dapr, consultez la Vue d’ensemble de l’extension Dapr.

Exemple

Une fonction C# peut être créée à l’aide de l’un des modes C# suivants :

Modèle d’exécution Description
Modèle de worker isolé Le code de votre fonction s’exécute dans un processus Worker .NET distinct. Utilisez avec les versions prises en charge de .NET et .NET Framework. Pour plus d’informations, consultez Développer les fonctions de processus Worker isolé .NET.
Modèle in-process Le code de votre fonction s’exécute dans le même processus que le processus hôte Functions. Prend uniquement en charge les versions LTS (Long Term Support) de .NET. Pour plus d’informations, consultez Développer des fonctions de bibliothèque de classes .NET. 
[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.");
}

L’exemple suivant crée une fonction "RetreveSecret" à l’aide de la liaison DaprSecretInput avec DaprServiceInvocationTrigger :

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

Dans l’exemple suivant, la liaison d’entrée secrète Dapr est associée à un déclencheur d’appel Dapr, qui est inscrit par l’objet app :

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]}`);
        }
    }
});

Les exemples suivants montrent les déclencheurs Dapr dans un fichier function.json et le code PowerShell qui utilise ces liaisons.

Voici le fichier function.json pour daprServiceInvocationTrigger :

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

Pour plus d’informations sur les propriétés du fichier function.json, consultez la section Configuration.

Dans le 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"

L’exemple suivant montre une liaison d’entrée de secret Dapr, qui utilise le modèle de programmation Python v2. Pour utiliser la liaison daprSecret avec daprServiceInvocationTrigger dans le code de votre application de fonction Python :

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

Attributs

Dans le modèle in-process, utilisez DaprSecret pour définir une liaison d’entrée de secret Dapr, qui prend en charge les paramètres suivants :

Paramètre Description
SecretStoreName Nom du magasin des secrets permettant d’obtenir le secret.
Clé Clé identifiant le nom du secret à obtenir.
Métadonnées facultatif. Tableau de propriétés de métadonnées au format "key1=value1&key2=value2".

Annotations

L’annotation DaprSecretInput permet à votre fonction d’accéder à un secret.

Élément Description
secretStoreName Nom du magasin des secrets Dapr.
key Valeur de clé secrète.
métadonnées Facultatif. Valeurs de métadonnées.

Configuration

Le tableau suivant décrit les propriétés de configuration de liaison que vous avez définies dans le code.

Propriété Description
key Valeur de clé secrète.
secretStoreName Nom du magasin des secrets tel que défini dans le fichier de composant local-secret-store.yaml.
métadonnées Espace de noms de métadonnées.

Le tableau suivant décrit les propriétés de configuration de liaison que vous définissez dans le fichier function.json.

Propriété function.json Description
key Valeur de clé secrète.
secretStoreName Nom du magasin des secrets tel que défini dans le fichier de composant local-secret-store.yaml.
métadonnées Espace de noms de métadonnées.

Le tableau suivant explique les propriétés de configuration de liaison pour @dapp.dapr_secret_input que vous définissez dans votre code Python.

Propriété Description
secret_store_name Nom du magasin des secrets.
key Valeur de clé secrète.
métadonnées Espace de noms de métadonnées.

Pour obtenir des exemples complets, consultez la section Exemple.

Usage

Pour utiliser la liaison d’entrée de secret Dapr, commencez par configurer un composant de magasin des secrets Dapr. Pour en savoir plus sur le composant à utiliser et sa configuration, consultez la documentation officielle de Dapr.

Pour utiliser daprSecret dans Python v2, configurez votre projet avec les dépendances appropriées.

  1. Créer et activer un environnement virtuel.

  2. Dans votre fichier requirements.text, ajoutez la ligne suivante :

    azure-functions==1.18.0b3

  3. Dans le terminal, installez la bibliothèque Python.

    pip install -r .\requirements.txt

  4. Modifiez votre fichier local.setting.json avec la configuration suivante :

    "PYTHON_ISOLATE_WORKER_DEPENDENCIES":1

Étapes suivantes

En savoir plus sur les secrets Dapr.