Powiązanie danych wejściowych wpisu tajnego języka Dapr dla usługi Azure Functions

Powiązanie wejściowe wpisu tajnego języka Dapr umożliwia odczytywanie danych wpisów tajnych jako danych wejściowych podczas wykonywania funkcji.

Aby uzyskać informacje na temat konfiguracji i szczegółów konfiguracji rozszerzenia Języka Dapr, zobacz Omówienie rozszerzenia Języka Dapr.

Example

Funkcję języka C# można utworzyć przy użyciu jednego z następujących trybów języka C#:

Execution model	Description
Model izolowanego procesu roboczego	Kod funkcji jest uruchamiany w osobnym procesie roboczym platformy .NET. Używaj z obsługiwanymi wersjami platform .NET i .NET Framework. Aby dowiedzieć się więcej, zobacz przewodnik dotyczący uruchamiania usługi Azure Functions w języku C# w izolowanym modelu procesu roboczego.
In-process model	Kod funkcji jest uruchamiany w tym samym procesie co proces hosta usługi Functions. Obsługuje tylko wersje long term support (LTS) platformy .NET. Aby dowiedzieć się więcej, zobacz Tworzenie funkcji biblioteki klas języka C# przy użyciu usługi 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);
    }

}

Poniższy przykład tworzy "RetrieveSecret" funkcję przy użyciu DaprSecretInput powiązania z elementem 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)

Node.js v4

W poniższym przykładzie powiązanie wejściowe wpisu tajnego języka Dapr jest sparowane z wyzwalaczem wywołania języka Dapr, który jest zarejestrowany przez app obiekt:

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.

Oto kod JavaScript:

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

W poniższym przykładzie pokazano powiązanie danych wejściowych Dapr Secret, które używa modelu programowania w języku Python w wersji 2. Aby użyć powiązania wraz daprSecret z daprServiceInvocationTrigger kodem aplikacji funkcji języka 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])

Python v1

W poniższym przykładzie przedstawiono powiązanie danych wejściowych dapr Secret, które używa modelu programowania w języku Python w wersji 1.

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.

Oto kod języka Python:

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	Nazwa magazynu wpisów tajnych w celu pobrania wpisu tajnego.
Key	Klucz identyfikujący nazwę wpisu tajnego do pobrania.
Metadata	Optional. Tablica właściwości metadanych w formularzu "key1=value1&key2=value2".

Isolated process

W modelu izolowanego procesu roboczego użyj polecenia , DaprSecretInput aby zdefiniować powiązanie wejściowe wpisu tajnego języka Dapr, które obsługuje następujące parametry:

Parameter	Description
SecretStoreName	Nazwa magazynu wpisów tajnych w celu pobrania wpisu tajnego.
Key	Klucz identyfikujący nazwę wpisu tajnego do pobrania.
Metadata	Optional. Tablica właściwości metadanych w formularzu "key1=value1&key2=value2".

Annotations

Adnotacja DaprSecretInput umożliwia dostęp do wpisu tajnego funkcji.

Element	Description
secretStoreName	Nazwa magazynu wpisów tajnych Dapr.
key	Wartość klucza tajnego.
metadata	Optional. Wartości metadanych.

Configuration

Node.js v4

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w kodzie.

Property	Description
key	Wartość klucza tajnego.
secretStoreName	Name of the secret store as defined in the local-secret-store.yaml component file.
metadata	Przestrzeń nazw metadanych.

Node.js v3

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json.

function.json property	Description
key	Wartość klucza tajnego.
secretStoreName	Name of the secret store as defined in the local-secret-store.yaml component file.
metadata	Przestrzeń nazw metadanych.

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json.

function.json property	Description
key	Wartość klucza tajnego.
secretStoreName	Name of the secret store as defined in the local-secret-store.yaml component file.
metadata	Przestrzeń nazw metadanych.

Python v2

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione @dapp.dapr_secret_input w kodzie języka Python.

Property	Description
secret_store_name	Nazwa magazynu wpisów tajnych.
key	Wartość klucza tajnego.
metadata	Przestrzeń nazw metadanych.

Python v1

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json.

function.json property	Description
key	Wartość klucza tajnego.
secretStoreName	Name of the secret store as defined in the local-secret-store.yaml component file.
metadata	Przestrzeń nazw metadanych.

See the Example section for complete examples.

Usage

Aby użyć powiązania wejściowego wpisu tajnego dapr, rozpocznij od skonfigurowania składnika magazynu wpisów tajnych dapr. Więcej informacji na temat tego, który składnik ma być używany i jak go skonfigurować, znajdziesz w oficjalnej dokumentacji języka Dapr.

• Specyfikacje składników magazynu wpisów tajnych języka Dapr
• Instrukcje: pobieranie wpisu tajnego

Python v2

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

1. Tworzenie i aktywowanie środowiska wirtualnego.

2. requirements.text W pliku dodaj następujący wiersz:

   azure-functions==1.18.0b3
   

3. W terminalu zainstaluj bibliotekę języka Python.

   pip install -r .\requirements.txt
   

4. local.setting.json Zmodyfikuj plik przy użyciu następującej konfiguracji:

   "PYTHON_ISOLATE_WORKER_DEPENDENCIES":1
   

Python v1

Model języka Python w wersji 1 nie wymaga żadnych dodatkowych zmian, oprócz konfigurowania magazynu wpisów tajnych.

Next steps

Dowiedz się więcej o wpisach tajnych języka Dapr.