Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Verwenden von Secrets-Manager-Secrets in Lambda-Funktionen AWS Secrets Manager hilft Ihnen bei der Verwaltung von Anmeldeinformationen, API-Schlüsseln und anderen Geheimnissen, die Ihre Lambda-Funktionen benötigen. Sie haben zwei Hauptansätze für das Abrufen von Geheimnissen in Ihren Lambda-Funktionen, die beide eine bessere Leistung und geringere Kosten bieten als das direkte Abrufen von Geheimnissen mithilfe des SDK: AWS + **AWS Lambda-Erweiterung für Parameter und Geheimnisse** — Eine laufzeitunabhängige Lösung, die eine einfache HTTP-Schnittstelle zum Abrufen von Geheimnissen bietet + **Powertools for AWS Lambda Parameters Utility** — Eine codeintegrierte Lösung, die mehrere Anbieter (Secrets Manager, Parameter Store AppConfig) mit integrierten Transformationen unterstützt Beide Ansätze verwenden lokale Caches für Secrets, sodass Ihre Funktion nicht bei jedem Aufruf den Secrets Manager aufrufen muss. Wenn Ihre Funktion ein Secret anfordert, wird zuerst der Cache überprüft. Ist das Secret verfügbar und nicht abgelaufen, wird es sofort zurückgegeben. Andernfalls wird es aus dem Secrets Manager abgerufen, zwischengespeichert und zurückgegeben. Dieser Caching-Mechanismus führt zu schnelleren Antwortzeiten und geringeren Kosten durch die Minimierung von API-Aufrufen. ## Auswahl des Ansatzes Berücksichtigen Sie diese Faktoren, wenn Sie zwischen der Erweiterung und folgenden Optionen wählen: PowerTools Verwenden Sie die Lambda-Erweiterung AWS Parameters and Secrets, wenn: + Sie eine laufzeitunabhängige Lösung benötigen, die mit jeder Lambda-Laufzeit funktioniert. + Sie keine Codeabhängigkeiten zu Ihrer Funktion hinzufügen möchten. + Sie nur Secrets aus Secrets Manager oder Parameter Store abrufen müssen. Verwenden Sie Powertools for AWS Lambda Parameters Utility, wenn: + Sie eine integrierte Entwicklungserfahrung mit Ihrem Anwendungscode wünschen. + Sie benötigen Unterstützung für mehrere Anbieter (Secrets Manager, Parameter Store, AppConfig) + Sie integrierte Datentransformationen (JSON-Parsing, Base64-Decodierung) benötigen. + Sie verwenden Python- TypeScript, Java- oder .NET-Laufzeiten ## Wann Sie den Secrets Manager mit Lambda verwenden sollten Zu den häufigsten Anwendungsfällen für den Secrets Manager mit Lambda gehören: + Speichern von Datenbank-Anmeldeinformationen, die Ihre Funktion für die Verbindung zu Amazon RDS oder anderen Datenbanken verwendet. + Verwalten von API-Schlüsseln für externe Dienste, die Ihre Funktion aufruft. + Speichern von Verschlüsselungsschlüsseln oder anderen sensiblen Konfigurationsdaten. + Automatische Rotation der Anmeldeinformationen, ohne dass Sie Ihren Funktionscode aktualisieren müssen. ## Verwenden der Lambda-Erweiterung AWS Parameter und Geheimnisse Die Lambda-Erweiterung AWS Parameters and Secrets verwendet eine einfache HTTP-Schnittstelle, die mit jeder Lambda-Laufzeit kompatibel ist. Standardmäßig werden Secrets 300 Sekunden (5 Minuten) lang zwischengespeichert und es können bis zu 1 000 Secrets gespeichert werden. Sie können [diese Einstellungen mit Umgebungsvariablen anpassen](#lambda-secrets-manager-env-vars). ### Verwendung des Secrets Manager in einer Lambda-Funktion In diesem Abschnitt wird davon ausgegangen, dass Sie bereits ein Secret im Secrets Manager besitzen. Informationen zum Erstellen eines Secrets finden Sie unter [Create an AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) Secret. #### Erstellen des Bereitstellungspakets Wählen Sie Ihre bevorzugte Laufzeit und folgen Sie den Schritten, um eine Funktion zu erstellen, die Secrets aus dem Secrets Manager abruft. Die Beispielfunktion ruft ein Secrets aus dem Secrets Manager ab und kann verwendet werden, um auf Datenbank-Anmeldeinformationen, API-Schlüssel oder andere sensible Konfigurationsdaten in Ihren Anwendungen zuzugreifen. ------ #### [ Python ] **So erstellen Sie eine Python-Funktion** 1. Erstellen Sie ein neues Projektverzeichnis und navigieren Sie dorthin. Beispiel: ``` mkdir my_function cd my_function ``` 1. Erstellen Sie eine Datei mit dem Namen `lambda_function.py` und dem folgenden Code. Verwenden Sie für `secret_name` den Namen oder den Amazon-Ressourcennamen (ARN) Ihres Secrets. ``` import json import os import requests def lambda_handler(event, context): try: # Replace with the name or ARN of your secret secret_name = "arn:aws:secretsmanager:us-east-1:111122223333:secret:SECRET_NAME" secrets_extension_endpoint = f"http://localhost:2773/secretsmanager/get?secretId={secret_name}" headers = {"X-Aws-Parameters-Secrets-Token": os.environ.get('AWS_SESSION_TOKEN')} response = requests.get(secrets_extension_endpoint, headers=headers) print(f"Response status code: {response.status_code}") secret = json.loads(response.text)["SecretString"] print(f"Retrieved secret: {secret}") return { 'statusCode': response.status_code, 'body': json.dumps({ 'message': 'Successfully retrieved secret', 'secretRetrieved': True }) } except Exception as e: print(f"Error: {str(e)}") return { 'statusCode': 500, 'body': json.dumps({ 'message': 'Error retrieving secret', 'error': str(e) }) } ``` 1. Erstellen Sie eine Datei namens „`requirements.txt`“ mit folgendem Inhalt: ``` requests ``` 1. Installieren Sie die Abhängigkeiten: ``` pip install -r requirements.txt -t . ``` 1. Erstellen Sie eine ZIP-Datei, die alle Dateien enthält: ``` zip -r function.zip . ``` ------ #### [ Node.js ] **Erstellen einer Funktion Node.js.** 1. Erstellen Sie ein neues Projektverzeichnis und navigieren Sie dorthin. Beispiel: ``` mkdir my_function cd my_function ``` 1. Erstellen Sie eine Datei mit dem Namen `index.mjs` und dem folgenden Code. Verwenden Sie für `secret_name` den Namen oder den Amazon-Ressourcennamen (ARN) Ihres Secrets. ``` import http from 'http'; export const handler = async (event) => { try { // Replace with the name or ARN of your secret const secretName = "arn:aws:secretsmanager:us-east-1:111122223333:secret:SECRET_NAME"; const options = { hostname: 'localhost', port: 2773, path: `/secretsmanager/get?secretId=${secretName}`, headers: { 'X-Aws-Parameters-Secrets-Token': process.env.AWS_SESSION_TOKEN } }; const response = await new Promise((resolve, reject) => { http.get(options, (res) => { let data = ''; res.on('data', (chunk) => { data += chunk; }); res.on('end', () => { resolve({ statusCode: res.statusCode, body: data }); }); }).on('error', reject); }); const secret = JSON.parse(response.body).SecretString; console.log('Retrieved secret:', secret); return { statusCode: response.statusCode, body: JSON.stringify({ message: 'Successfully retrieved secret', secretRetrieved: true }) }; } catch (error) { console.error('Error:', error); return { statusCode: 500, body: JSON.stringify({ message: 'Error retrieving secret', error: error.message }) }; } }; ``` 1. Erstellen Sie eine ZIP-Datei, die die Datei „`index.mjs`“ enthält: ``` zip -r function.zip index.mjs ``` ------ #### [ Java ] **So erstellen Sie eine Java-Funktion** 1. Erstellen Sie ein Maven-Projekt: ``` mvn archetype:generate \ -DgroupId=example \ -DartifactId=lambda-secrets-demo \ -DarchetypeArtifactId=maven-archetype-quickstart \ -DarchetypeVersion=1.4 \ -DinteractiveMode=false ``` 1. Navigieren Sie zum Projektverzeichnis: ``` cd lambda-secrets-demo ``` 1. Öffnen Sie die Datei „`pom.xml`“ und ersetzen Sie deren Inhalt durch Folgendes: ``` 4.0.0 example lambda-secrets-demo 1.0-SNAPSHOT 11 11 com.amazonaws aws-lambda-java-core 1.2.1 org.apache.maven.plugins maven-shade-plugin 3.2.4 package shade false function ``` 1. Benennen Sie die Datei „`/lambda-secrets-demo/src/main/java/example/App.java`“ in „`Hello.java`“ um, um sie an den Standardnamen des Java-Handlers von Lambda (`example.Hello::handleRequest`) anzupassen: ``` mv src/main/java/example/App.java src/main/java/example/Hello.java ``` 1. Öffnen Sie die Datei `Hello.java` und ersetzen Sie den Inhalt durch Folgendes. Verwenden Sie für `secretName` den Namen oder den Amazon-Ressourcennamen (ARN) Ihres Secrets. ``` package example; import com.amazonaws.services.lambda.runtime.Context; import com.amazonaws.services.lambda.runtime.RequestHandler; import java.net.URI; import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; public class Hello implements RequestHandler { private final HttpClient client = HttpClient.newHttpClient(); @Override public String handleRequest(Object input, Context context) { try { // Replace with the name or ARN of your secret String secretName = "arn:aws:secretsmanager:us-east-1:111122223333:secret:SECRET_NAME"; String endpoint = "http://localhost:2773/secretsmanager/get?secretId=" + secretName; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(endpoint)) .header("X-Aws-Parameters-Secrets-Token", System.getenv("AWS_SESSION_TOKEN")) .GET() .build(); HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); String secret = response.body(); secret = secret.substring(secret.indexOf("SecretString") + 15); secret = secret.substring(0, secret.indexOf("\"")); System.out.println("Retrieved secret: " + secret); return String.format( "{\"statusCode\": %d, \"body\": \"%s\"}", response.statusCode(), "Successfully retrieved secret" ); } catch (Exception e) { e.printStackTrace(); return String.format( "{\"body\": \"Error retrieving secret: %s\"}", e.getMessage() ); } } } ``` 1. Entfernen Sie das Testverzeichnis. Maven erstellt dies standardmäßig, aber wir benötigen es für dieses Beispiel nicht. ``` rm -rf src/test ``` 1. Erstellen Sie das Projekt: ``` mvn package ``` 1. Laden Sie die JAR-Datei (`target/function.jar`) zur späteren Verwendung herunter. ------ #### Erstellen der Funktion 1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole. 1. Wählen Sie **Funktion erstellen**. 1. Wählen Sie **Verfassen von Grund auf** aus. 1. Geben Sie für **Function name** (Funktionsname) **secret-retrieval-demo** ein. 1. Wählen Sie Ihre bevorzugte **Laufzeit**. 1. Wählen Sie **Funktion erstellen**. **So laden Sie das Bereitstellungspaket hoch** 1. Wählen Sie auf der Registerkarte **Code** der Funktion die Option **Hochladen von** und dann **ZIP-Datei** (für Python und Node.js) oder **JAR-Datei** (für Java) aus. 1. Laden Sie das Bereitstellungspaket hoch, das Sie zuvor erstellt haben. 1. Wählen Sie **Speichern**. #### Hinzufügen der Erweiterung **Um die Lambda-Erweiterung AWS Parameters and Secrets als Ebene hinzuzufügen** 1. Scrollen Sie auf der Registerkarte **Code** der Funktion nach unten zu **Ebenen**. 1. Wählen Sie **Add a layer (Layer hinzufügen)** aus. 1. Wählen Sie **AWS -Ebenen** aus. 1. Wählen Sie **AWS-Parameters-and-Secrets-Lambda-Extension** aus. 1. Wählen Sie die neueste Version aus. 1. Wählen Sie **Hinzufügen** aus. #### Berechtigungen hinzufügen **So fügen Sie Ihrer Ausführungsrolle Berechtigungen für den Secrets Manager hinzu** 1. Wählen Sie die Registerkarte **Konfiguration** und dann **Berechtigungen** aus. 1. Wählen Sie unter **Rollenname** den Link zu Ihrer Ausführungsrolle. Dieser Link öffnet die Rolle in der IAM-Konsole. ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/execution-role-console.png) 1. Wählen Sie **Add permissions** (Berechtigungen hinzufügen) und dann **Create inline policy** (Inline-Richtlinie erstellen) aus. ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/create-inline-policy.png) 1. Wählen Sie die Registerkarte **JSON** aus und fügen Sie die folgende Richtlinie hinzu. Geben Sie für `Resource` den ARN Ihres Secrets ein. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "secretsmanager:GetSecretValue", "Resource": "arn:aws:secretsmanager:us-east-1:111122223333:secret:SECRET_NAME" } ] } ``` ------ 1. Wählen Sie **Weiter** aus. 1. Geben Sie einen Namen für die Richtlinie ein. 1. Wählen Sie **Richtlinie erstellen** aus. #### Testen der Funktion **So testen Sie die -Funktion** 1. Kehren Sie zur Lambda-Konsole zurück. 1. Wählen Sie die Registerkarte **Test**. 1. Wählen Sie **Test** aus. Sie sollten die folgende Antwort sehen: ![\[\]](http://docs.aws.amazon.com/de_de/lambda/latest/dg/images/execution-results-secret.png) ### Umgebungsvariablen Die Lambda-Erweiterung AWS Parameters and Secrets verwendet die folgenden Standardeinstellungen. Sie können diese Einstellungen überschreiben, indem Sie die entsprechenden [Umgebungsvariablen](configuration-envvars.md#create-environment-variables) erstellen. Setzen Sie `PARAMETERS_SECRETS_EXTENSION_LOG_LEVEL` auf `DEBUG`, um die aktuellen Einstellungen für eine Funktion anzuzeigen. Die Erweiterung CloudWatch protokolliert ihre Konfigurationsinformationen zu Beginn jedes Funktionsaufrufs in Logs. | Einstellung | Standardwert | Zulässige Werte | Umgebungsvariable | Details | | --- | --- | --- | --- | --- | | HTTP-Port | 2773 | 1–65 535 | PARAMETERS\$1SECRETS\$1EXTENSION\$1HTTP\$1PORT | Port für den lokalen HTTP-Server | | Cache aktiviert | TRUE | TRUE \$1 FALSE | PARAMETERS\$1SECRETS\$1EXTENSION\$1CACHE\$1ENABLED | Aktivieren oder Deaktivieren des Cache | | Cache-Größe | 1000 | 0–1 000 | PARAMETERS\$1SECRETS\$1EXTENSION\$1CACHE\$1SIZE | Auf 0 setzen, um das Caching zu deaktivieren | | Secrets Manager TTL | 300 Sekunden | 0–300 Sekunden | SECRETS\$1MANAGER\$1TTL | Time-to-live für zwischengespeicherte Geheimnisse. Auf 0 setzen, um das Caching zu deaktivieren. Diese Variable wird ignoriert, wenn der Wert für PARAMETERS\$1SECRETS\$1EXTENSION\$1CACHE\$1SIZE 0 ist. | | Parameter Store TTL | 300 Sekunden | 0–300 Sekunden | SSM\$1PARAMETER\$1STORE\$1TTL | Time-to-live für zwischengespeicherte Parameter. Auf 0 setzen, um das Caching zu deaktivieren. Diese Variable wird ignoriert, wenn der Wert für PARAMETERS\$1SECRETS\$1EXTENSION\$1CACHE\$1SIZE 0 ist. | | Protokollebene | INFO | DEBUG \$1 INFO \$1 WARN \$1 ERROR \$1 NONE | PARAMETERS\$1SECRETS\$1EXTENSION\$1LOG\$1LEVEL | Der Detaillierungsgrad, der in Protokollen für die Erweiterung gemeldet wird | | Maximale Verbindungen | 3 | 1 oder höher | PARAMETERS\$1SECRETS\$1EXTENSION\$1MAX\$1CONNECTIONS | Maximale Anzahl von HTTP-Verbindungen für Anforderungen an den Parameter Store oder Secrets Manager | | Timeout für Secrets Manager | 0 (kein Timeout) | Alle ganzen Zahlen | SECRETS\$1MANAGER\$1TIMEOUT\$1MILLIS | Timeout für Anfragen an Secrets Manager (in Millisekunden) | | Timeout für Parameter Store | 0 (kein Timeout) | Alle ganzen Zahlen | SSM\$1PARAMETER\$1STORE\$1TIMEOUT\$1MILLIS | Timeout für Anfragen an den Parameter Store (in Millisekunden) | ### Arbeiten mit Secret-Rotation Wenn Sie Secrets häufig rotieren, kann die standardmäßige Cachedauer von 300 Sekunden dazu führen, dass Ihre Funktion veraltete Secrets verwendet. Sie haben zwei Möglichkeiten, um sicherzustellen, dass Ihre Funktion den neuesten Secret-Wert verwendet: + Reduzieren Sie die Cache-TTL, indem Sie die `SECRETS_MANAGER_TTL`-Umgebungsvariable auf einen niedrigeren Wert (in Sekunden) setzen. Wenn Sie sie beispielsweise auf `60` einstellen, wird sichergestellt, dass Ihre Funktion niemals ein Secret verwendet, das älter als eine Minute ist. + Verwenden Sie die Staging-Bezeichnungen `AWSCURRENT` oder `AWSPREVIOUS` in Ihrer Secret-Anfrage, um sicherzustellen, dass Sie die gewünschte Version erhalten: ``` secretsmanager/get?secretId=YOUR_SECRET_NAME&versionStage=AWSCURRENT ``` Wählen Sie den Ansatz, der Ihren Anforderungen an Leistung und Aktualität am besten gerecht wird. Eine niedrigere TTL bedeutet häufigere Aufrufe von Secrets Manager, stellt jedoch sicher, dass Sie mit den aktuellsten Secret-Werten arbeiten. ## Verwenden Sie das Parameter-Hilfsprogramm von Powertools für AWS Lambda Das Parameter-Hilfsprogramm von Powertools for AWS Lambda bietet eine einheitliche Oberfläche zum Abrufen von Geheimnissen von mehreren Anbietern, darunter Secrets Manager, Parameterspeicher und. AppConfig Es übernimmt Caching und Transformationen und bietet im Vergleich zum Erweiterungsansatz eine integriertere Entwicklungserfahrung. ### Vorteile des Parameter-Dienstprogramms + **Mehrere Anbieter** — Rufen Sie Parameter aus Secrets Manager und Parameter Store ab und AppConfig verwenden Sie dieselbe Schnittstelle + **Integrierte Transformationen** – Automatisches JSON-Parsing, Base64-Decodierung und weitere Datentransformationen + **Integriertes Caching** – Konfigurierbares Caching mit TTL-Unterstützung zur Reduzierung von API-Aufrufen + **Typsicherheit** — Starke Tippunterstützung in TypeScript und anderen unterstützten Laufzeiten + **Fehlerbehandlung** – Integrierte Wiederholungslogik und Fehlerbehandlung ### Codebeispiele Die folgenden Beispiele zeigen, wie Secrets mit dem Parameter-Dienstprogramm in verschiedenen Laufzeiten abgerufen werden: **Python** Vollständige Beispiele und Anweisungen zur Einrichtung finden Sie in der [Dokumentation zum Parameter-Dienstprogramm](https://docs.powertools.aws.dev/lambda/python/latest/utilities/parameters/). Abrufen von Geheimnissen aus Secrets Manager mit dem Hilfsprogramm Powertools for AWS Lambda Parameters. ``` from aws_lambda_powertools import Logger from aws_lambda_powertools.utilities import parameters logger = Logger() def lambda_handler(event, context): try: # Get secret with caching (default TTL: 5 seconds) secret_value = parameters.get_secret("my-secret-name") # Get secret with custom TTL secret_with_ttl = parameters.get_secret("my-secret-name", max_age=300) # Get secret and transform JSON secret_json = parameters.get_secret("my-json-secret", transform="json") logger.info("Successfully retrieved secrets") return { 'statusCode': 200, 'body': 'Successfully retrieved secrets' } except Exception as e: logger.error(f"Error retrieving secret: {str(e)}") return { 'statusCode': 500, 'body': f'Error: {str(e)}' } ``` **TypeScript** Vollständige Beispiele und Anweisungen zur Einrichtung finden Sie in der [Dokumentation zum Parameter-Dienstprogramm](https://docs.aws.amazon.com/powertools/typescript/2.1.1/utilities/parameters/). Abrufen von Geheimnissen aus Secrets Manager mit dem Hilfsprogramm Powertools for AWS Lambda Parameters. ``` import { Logger } from '@aws-lambda-powertools/logger'; import { getSecret } from '@aws-lambda-powertools/parameters/secrets'; import type { Context } from 'aws-lambda'; const logger = new Logger(); export const handler = async (event: any, context: Context) => { try { // Get secret with caching (default TTL: 5 seconds) const secretValue = await getSecret('my-secret-name'); // Get secret with custom TTL const secretWithTtl = await getSecret('my-secret-name', { maxAge: 300 }); // Get secret and transform JSON const secretJson = await getSecret('my-json-secret', { transform: 'json' }); logger.info('Successfully retrieved secrets'); return { statusCode: 200, body: 'Successfully retrieved secrets' }; } catch (error) { logger.error('Error retrieving secret', { error }); return { statusCode: 500, body: `Error: ${error}` }; } }; ``` **Java** Vollständige Beispiele und Anweisungen zur Einrichtung finden Sie in der [Dokumentation zum Parameter-Dienstprogramm](https://docs.powertools.aws.dev/lambda/java/latest/utilities/parameters/). Abrufen von Geheimnissen aus Secrets Manager mit dem Hilfsprogramm Powertools for AWS Lambda Parameters. ``` import software.amazon.lambda.powertools.logging.Logging; import software.amazon.lambda.powertools.parameters.SecretsProvider; import software.amazon.lambda.powertools.parameters.ParamManager; import com.amazonaws.services.lambda.runtime.Context; import com.amazonaws.services.lambda.runtime.RequestHandler; public class SecretHandler implements RequestHandler { private final SecretsProvider secretsProvider = ParamManager.getSecretsProvider(); @Logging @Override public String handleRequest(Object input, Context context) { try { // Get secret with caching (default TTL: 5 seconds) String secretValue = secretsProvider.get("my-secret-name"); // Get secret with custom TTL (300 seconds) String secretWithTtl = secretsProvider.withMaxAge(300).get("my-secret-name"); // Get secret and transform JSON MySecret secretJson = secretsProvider.get("my-json-secret", MySecret.class); return "Successfully retrieved secrets"; } catch (Exception e) { return "Error retrieving secret: " + e.getMessage(); } } public static class MySecret { // Define your secret structure here } } ``` **.NET** Vollständige Beispiele und Anweisungen zur Einrichtung finden Sie in der [Dokumentation zum Parameter-Dienstprogramm](https://docs.aws.amazon.com/powertools/typescript/latest/features/parameters/). Abrufen von Geheimnissen aus Secrets Manager mit dem Hilfsprogramm Powertools for AWS Lambda Parameters. ``` using AWS.Lambda.Powertools.Logging; using AWS.Lambda.Powertools.Parameters; using Amazon.Lambda.Core; [assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))] public class Function { private readonly ISecretsProvider _secretsProvider; public Function() { _secretsProvider = ParametersManager.SecretsProvider; } [Logging] public async Task FunctionHandler(object input, ILambdaContext context) { try { // Get secret with caching (default TTL: 5 seconds) var secretValue = await _secretsProvider.GetAsync("my-secret-name"); // Get secret with custom TTL var secretWithTtl = await _secretsProvider.WithMaxAge(TimeSpan.FromMinutes(5)) .GetAsync("my-secret-name"); // Get secret and transform JSON var secretJson = await _secretsProvider.GetAsync("my-json-secret"); return "Successfully retrieved secrets"; } catch (Exception e) { return $"Error retrieving secret: {e.Message}"; } } public class MySecret { // Define your secret structure here } } ``` ### Einrichtung und Berechtigungen Um das Parameter-Dienstprogramm zu verwenden, müssen Sie Folgendes tun: 1. Installieren Sie Powertools für AWS Lambda für Ihre Runtime. Details hierzu finden Sie unter [Powertools for AWS Lambda](powertools-for-lambda.md). 1. Fügen Sie der Ausführungsrolle Ihrer Funktion die erforderlichen IAM-Berechtigungen hinzu. Weitere Einzelheiten finden Sie unter [Verwaltung von Berechtigungen in AWS Lambda](lambda-permissions.md). 1. Konfigurieren Sie optionale Einstellungen über [Umgebungsvariablen](configuration-envvars.md). Die erforderlichen IAM-Berechtigungen sind dieselben wie beim Erweiterungsansatz. Das Dienstprogramm übernimmt automatisch das Caching und die API-Aufrufe an den Secrets Manager basierend auf Ihrer Konfiguration.