Udostępnij za pośrednictwem


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.

Przykład

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

Model wykonania opis
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 Develop .NET isolated worker process functions (Tworzenie izolowanych funkcji procesów roboczych platformy .NET).
Model w procesie 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 platformy .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.");
}

Poniższy przykład tworzy "RetreveSecret" 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)

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

W poniższych przykładach pokazano wyzwalacze języka Dapr w pliku function.json i kodzie programu PowerShell, który używa tych powiązań.

Oto plik function.json dla elementu daprServiceInvocationTrigger:

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

Aby uzyskać więcej informacji na temat function.json właściwości pliku, zobacz sekcję Konfiguracja.

W kodzie:

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"

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 daprServiceInvocationTrigger z daprSecret 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])

Atrybuty

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

Parametr Opis
SecretStoreName Nazwa magazynu wpisów tajnych w celu pobrania wpisu tajnego.
Klawisz Klucz identyfikujący nazwę wpisu tajnego do pobrania.
Metadane Opcjonalny. Tablica właściwości metadanych w formularzu "key1=value1&key2=value2".

Adnotacje

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

Element opis
secretStoreName Nazwa magazynu wpisów tajnych Dapr.
key Wartość klucza tajnego.
metadane Opcjonalne. Wartości metadanych.

Konfigurowanie

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

Właściwości opis
key Wartość klucza tajnego.
secretStoreName Nazwa magazynu wpisów tajnych zgodnie z definicją w pliku składnika local-secret-store.yaml .
metadane Przestrzeń nazw metadanych.

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

właściwość function.json opis
key Wartość klucza tajnego.
secretStoreName Nazwa magazynu wpisów tajnych zgodnie z definicją w pliku składnika local-secret-store.yaml .
metadane Przestrzeń nazw metadanych.

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

Właściwości opis
secret_store_name Nazwa magazynu wpisów tajnych.
key Wartość klucza tajnego.
metadane Przestrzeń nazw metadanych.

Zobacz sekcję Przykład, aby zapoznać się z kompletnymi przykładami.

Użycie

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.

Aby użyć elementu daprSecret w języku Python w wersji 2, skonfiguruj projekt przy użyciu poprawnych zależności.

  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
    

Następne kroki

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