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

Warning

Rozszerzenie Dapr dla Azure Functions zostanie wycofane 20 kwietnia 2027 roku i planowane jest usunięcie z pakietów rozszerzenia tego dnia. Usunięcie dotyczy pakietu głównego rozszerzenia w wersji 4.42.0 i nowszych oraz pakietu rozszerzenia podglądowego w wersji 4.60.0 i nowszych.

To usunięcie dotyczy również wersji pakietów preinstalowanych lub cacheowanych w obrazach hostingowych Linuksa albo dystrybuowanych przez hosting Windows.

Migruj do Dapr client SDK lub API HTTP Dapr bezpośrednio z kodu funkcji i zastąp wyzwalacze Dapr funkcjami wyzwalanymi przez HTTP, które odbierają odwołania Dapr. Istniejące aplikacje mogą tymczasowo przypiąć główny pakiet lub [4.*, 4.42.0) pakiet podglądowy do [4.*, 4.60.0) .host.json Aplikacje .NET mogą nadal korzystać bezpośrednio z odpowiadających pakietów NuGet do Dapr. Ani przypinanie starszego pakietu, ani dalsze korzystanie z pakietów NuGet nie przedłuża wsparcia po 20 kwietnia 2027 roku ani nie zmienia daty usunięcia.

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

Model wykonania 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.
Model wewnątrzprocesowy 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.
[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 "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)

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

Poniższe przykłady pokazują wyzwalacze Dapr w pliku function.json oraz kod PowerShell korzystający z 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 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])

Attributes

W modelu w trakcie procesu używamy do DaprSecret zdefiniowania tajnego wiązania wejściowego 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

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

Property Description
key Wartość klucza tajnego.
secretStoreName Nazwa magazynu sekretów zdefiniowana w pliku komponentu local-secret-store.yaml .
metadata 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 Description
key Wartość klucza tajnego.
secretStoreName Nazwa magazynu sekretów zdefiniowana w pliku komponentu local-secret-store.yaml .
metadata 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.

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

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

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.

Aby użyć wersji daprSecret w Python v2, skonfiguruj projekt z odpowiednimi zależnościami.

  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.