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. # Den AWS Secrets Manager Agenten verwenden ## So funktioniert der Secrets Manager Agent Der AWS Secrets Manager Agent ist ein clientseitiger HTTP-Dienst, mit dem Sie standardisieren können, wie Sie Secrets aus Secrets Manager in Ihren Computerumgebungen verwenden. Sie können ihn mit den folgenden Diensten verwenden: + AWS Lambda + Amazon Elastic Container Service + Amazon Elastic Kubernetes Service + Amazon Elastic Compute Cloud Der Secrets Manager Agent ruft Secrets ab und speichert sie im Speicher, sodass Ihre Anwendungen Secrets von localhost abrufen können, anstatt Secrets Manager direkt aufzurufen. Der Secrets Manager Agent kann nur Geheimnisse lesen — er kann sie nicht ändern. **Wichtig** Der Secrets Manager Agent verwendet die AWS Anmeldeinformationen aus Ihrer Umgebung, um Secrets Manager aufzurufen. Es bietet Schutz vor Server Side Request Forgery (SSRF), um die Sicherheit geheimer Daten zu verbessern. Der Secrets Manager Agent verwendet standardmäßig den ML-KEM-Schlüsselaustausch nach dem Quantenverfahren als Schlüsselaustausch mit der höchsten Priorität. ## Grundlegendes zum Secrets Manager Agent-Caching Der Secrets Manager Agent verwendet einen In-Memory-Cache, der zurückgesetzt wird, wenn der Secrets Manager Agent neu gestartet wird. Er aktualisiert in regelmäßigen Abständen zwischengespeicherte geheime Werte auf der Grundlage der folgenden Kriterien: + Die Standard-Aktualisierungsfrequenz (TTL) beträgt 300 Sekunden + Sie können die TTL mithilfe einer Konfigurationsdatei ändern + Die Aktualisierung erfolgt, wenn Sie nach Ablauf der TTL ein Geheimnis anfordern **Anmerkung** Der Secrets Manager Agent beinhaltet keine Cache-Invalidierung. Wenn ein Geheimnis rotiert, bevor der Cache-Eintrag abläuft, gibt der Secrets Manager Agent möglicherweise einen veralteten geheimen Wert zurück. Der Secrets Manager Agent gibt geheime Werte im gleichen Format zurück wie die Antwort von`GetSecretValue`. Geheime Werte werden im Cache nicht verschlüsselt. **Topics** + [So funktioniert der Secrets Manager Agent](#agent-overview) + [Grundlegendes zum Secrets Manager Agent-Caching](#agent-caching) + [Den Secrets Manager Agent erstellen](#secrets-manager-agent-build) + [Installieren Sie den Secrets Manager Agent](#secrets-manager-agent-install) + [Rufen Sie Geheimnisse mit dem Secrets Manager Agent ab](#secrets-manager-agent-call) + [Den Parameter verstehen `refreshNow`](#secrets-manager-agent-refresh) + [Den Secrets Manager Agent konfigurieren](#secrets-manager-agent-config) + [Optionale Funktionen](#secrets-manager-agent-features) + [Protokollierung](#secrets-manager-agent-log) + [Sicherheitsüberlegungen](#secrets-manager-agent-security) ## Den Secrets Manager Agent erstellen Bevor Sie beginnen, stellen Sie sicher, dass Sie die Standard-Entwicklungstools und Rust-Tools für Ihre Plattform installiert haben. **Anmerkung** Um den Agenten mit aktivierter `fips` Funktion auf macOS zu erstellen, ist derzeit die folgende Problemumgehung erforderlich: Erstellen Sie eine Umgebungsvariable namens`SDKROOT`, die auf das Ergebnis der Ausführung gesetzt ist `xcrun --show-sdk-path` ------ #### [ RPM-based systems ] **Um auf RPM-basierten Systemen aufzubauen** 1. Verwenden Sie das im `install` Repository bereitgestellte Skript. Das Skript generiert beim Start ein zufälliges SSRF-Token und speichert es in der Datei`/var/run/awssmatoken`. Das Token ist für die `awssmatokenreader` Gruppe lesbar, die das Installationsskript erstellt. 1. Damit Ihre Anwendung die Tokendatei lesen kann, müssen Sie der `awssmatokenreader` Gruppe das Benutzerkonto hinzufügen, unter dem Ihre Anwendung ausgeführt wird. Beispielsweise können Sie Ihrer Anwendung mit dem folgenden usermod-Befehl Berechtigungen zum Lesen der Tokendatei gewähren. Dabei ** handelt es sich um die Benutzer-ID, unter der Ihre Anwendung ausgeführt wird. ``` sudo usermod -aG awssmatokenreader ``` **Installieren Sie Entwicklungstools** Installieren Sie auf RPM-basierten Systemen wie AL2023 z. B. die Gruppe Entwicklungstools: ``` sudo yum -y groupinstall "Development Tools" ``` 1. **Installieren Sie Rust** Folgen Sie den Anweisungen unter [Rust installieren](https://www.rust-lang.org/tools/install) in der *Rust-Dokumentation*: ``` curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions . "$HOME/.cargo/env" ``` 1. **Erstellen Sie den Agenten** Erstellen Sie den Secrets Manager Agent mit dem Befehl cargo build: ``` cargo build --release ``` Sie finden die ausführbare Datei unter`target/release/aws_secretsmanager_agent`. ------ #### [ Debian-based systems ] **Um auf Debian-basierten Systemen aufzubauen** 1. **Installieren Sie Entwicklungstools** Installieren Sie auf Debian-basierten Systemen wie Ubuntu das Paket build-essential: ``` sudo apt install build-essential ``` 1. **Installieren Sie Rust** Folgen Sie den Anweisungen unter [Rust installieren](https://www.rust-lang.org/tools/install) in der *Rust-Dokumentation*: ``` curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions . "$HOME/.cargo/env" ``` 1. **Erstellen Sie den Agenten** Erstellen Sie den Secrets Manager Agent mit dem Befehl cargo build: ``` cargo build --release ``` Sie finden die ausführbare Datei unter`target/release/aws_secretsmanager_agent`. ------ #### [ Windows ] **Um unter Windows zu bauen** 1. **Richten Sie die Entwicklungsumgebung ein** Folgen Sie den Anweisungen unter [Einrichten Ihrer Entwicklungsumgebung unter Windows für Rust](https://learn.microsoft.com/en-us/windows/dev-environment/rust/setup) in der *Microsoft Windows-Dokumentation*. 1. **Erstellen Sie den Agenten** Erstellen Sie den Secrets Manager Agent mit dem Befehl cargo build: ``` cargo build --release ``` Sie finden die ausführbare Datei unter`target/release/aws_secretsmanager_agent.exe`. ------ #### [ Cross-compile natively ] **Um nativ übergreifend zu kompilieren** 1. **Installieren Sie Cross-Compile-Tools** Installieren Sie auf Distributionen, auf denen das mingw-w64-Paket verfügbar ist, wie z. B. Ubuntu, die Cross-Compile-Toolchain: ``` # Install the cross compile tool chain sudo add-apt-repository universe sudo apt install -y mingw-w64 ``` 1. **Rust-Build-Ziele hinzufügen** Installieren Sie das Windows GNU-Build-Ziel: ``` rustup target add x86_64-pc-windows-gnu ``` 1. **Für Windows erstellen** Den Agenten für Windows kreuzkompilieren: ``` cargo build --release --target x86_64-pc-windows-gnu ``` Sie finden die ausführbare Datei unter`target/x86_64-pc-windows-gnu/release/aws_secretsmanager_agent.exe`. ------ #### [ Cross compile with Rust cross ] **Zur Cross-Kompilierung mit Rust Cross** Wenn die Cross-Compile-Tools nicht nativ auf dem System verfügbar sind, können Sie das Rust-Cross-Projekt verwenden. [Weitere Informationen finden Sie unter https://github.com/cross-rs/ Cross.](https://github.com/cross-rs/cross) **Wichtig** Wir empfehlen 32 GB Festplattenspeicher für die Build-Umgebung. 1. **Richten Sie Docker ein** Installieren und konfigurieren Sie Docker: ``` # Install and start docker sudo yum -y install docker sudo systemctl start docker sudo systemctl enable docker # Make docker start after reboot ``` 1. **Docker-Berechtigungen konfigurieren** Fügen Sie Ihren Benutzer zur Docker-Gruppe hinzu: ``` # Give ourselves permission to run the docker images without sudo sudo usermod -aG docker $USER newgrp docker ``` 1. **Für Windows erstellen** Installieren Sie Cross und erstellen Sie die ausführbare Datei: ``` # Install cross and cross compile the executable cargo install cross cross build --release --target x86_64-pc-windows-gnu ``` ------ ## Installieren Sie den Secrets Manager Agent Wählen Sie Ihre Computerumgebung aus den folgenden Installationsoptionen aus. ------ #### [ Amazon EC2 ] **So installieren Sie den Secrets Manager Agent auf Amazon EC2** 1. **Navigieren Sie zum Konfigurationsverzeichnis** Wechseln Sie in das Konfigurationsverzeichnis: ``` cd aws_secretsmanager_agent/configuration ``` 1. **Installationsskript ausführen** Führen Sie das im Repository bereitgestellte `install` Skript aus. Das Skript generiert beim Start ein zufälliges SSRF-Token und speichert es in der Datei`/var/run/awssmatoken`. Das Token ist für die `awssmatokenreader` Gruppe lesbar, die das Installationsskript erstellt. 1. **Konfigurieren Sie Anwendungsberechtigungen** Fügen Sie das Benutzerkonto, unter dem Ihre Anwendung läuft, der `awssmatokenreader` Gruppe hinzu: ``` sudo usermod -aG awssmatokenreader APP_USER ``` *APP\$1USER*Ersetzen Sie es durch die Benutzer-ID, unter der Ihre Anwendung ausgeführt wird. ------ #### [ Container Sidecar ] Sie können den Secrets Manager Agent als Sidecar-Container neben Ihrer Anwendung ausführen, indem Sie Docker verwenden. Dann kann Ihre Anwendung Secrets von dem lokalen HTTP-Server abrufen, den der Secrets Manager Agent bereitstellt. Informationen zu Docker finden Sie in der [Docker-Dokumentation](https://docs.docker.com). **Um einen Sidecar-Container für den Secrets Manager Agent zu erstellen** 1. **Erstellen Sie ein Agenten-Dockerfile** Erstellen Sie ein Dockerfile für den Secrets Manager Agent Sidecar-Container: ``` # Use the latest Debian image as the base FROM debian:latest # Set the working directory inside the container WORKDIR /app # Copy the Secrets Manager Agent binary to the container COPY secrets-manager-agent . # Install any necessary dependencies RUN apt-get update && apt-get install -y ca-certificates # Set the entry point to run the Secrets Manager Agent binary ENTRYPOINT ["./secrets-manager-agent"] ``` 1. **Anwendung (Dockerfile) erstellen** Erstellen Sie ein Dockerfile für Ihre Client-Anwendung. 1. **Erstellen Sie eine Docker Compose-Datei** Erstellen Sie eine Docker Compose-Datei, um beide Container mit einer gemeinsamen Netzwerkschnittstelle auszuführen: **Wichtig** Sie müssen AWS Anmeldeinformationen und das SSRF-Token laden, damit die Anwendung den Secrets Manager Agent verwenden kann. Informationen zu Amazon EKS und Amazon ECS finden Sie im Folgenden: [Zugriff im *Amazon EKS-Benutzerhandbuch* verwalten](https://docs.aws.amazon.com/eks/latest/userguide/cluster-auth.html) Die [IAM-Rolle der Amazon ECS-Aufgabe](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) im *Amazon ECS-Entwicklerhandbuch* ``` version: '3' services: client-application: container_name: client-application build: context: . dockerfile: Dockerfile.client command: tail -f /dev/null # Keep the container running secrets-manager-agent: container_name: secrets-manager-agent build: context: . dockerfile: Dockerfile.agent network_mode: "container:client-application" # Attach to the client-application container's network depends_on: - client-application ``` 1. **Agent-Binärdatei kopieren** Kopieren Sie die `secrets-manager-agent` Binärdatei in dasselbe Verzeichnis, das Ihre Dockerfiles und die Docker Compose-Datei enthält. 1. **Container erstellen und ausführen** Erstellen und führen Sie die Container mit Docker Compose aus: ``` docker-compose up --build ``` 1. **Nächste Schritte** Sie können jetzt den Secrets Manager Agent verwenden, um Geheimnisse aus Ihrem Client-Container abzurufen. Weitere Informationen finden Sie unter [Rufen Sie Geheimnisse mit dem Secrets Manager Agent ab](#secrets-manager-agent-call). ------ #### [ Lambda ] Sie können [den Secrets Manager Agent als Lambda-Erweiterung verpacken](https://docs.aws.amazon.com/lambda/latest/dg/packaging-layers.html). Dann können Sie [es Ihrer Lambda-Funktion als Ebene hinzufügen](https://docs.aws.amazon.com/lambda/latest/dg/adding-layers.html) und den Secrets Manager Agent von Ihrer Lambda-Funktion aus aufrufen, um Geheimnisse abzurufen. Die folgenden Anweisungen zeigen, wie Sie *MyTest*mithilfe des Beispielskripts `secrets-manager-agent-extension.sh` in ein Secret einen Namen erhalten [https://github.com/aws/aws-secretsmanager-agent](https://github.com/aws/aws-secretsmanager-agent), um den Secrets Manager Agent als Lambda-Erweiterung zu installieren. **Um eine Lambda-Erweiterung für den Secrets Manager Agent zu erstellen** 1. **Verpacken Sie die Agentenschicht** Führen Sie im Stammverzeichnis des Secrets Manager Agent-Codepakets die folgenden Befehle aus: ``` AWS_ACCOUNT_ID=AWS_ACCOUNT_ID LAMBDA_ARN=LAMBDA_ARN # Build the release binary cargo build --release --target=x86_64-unknown-linux-gnu # Copy the release binary into the `bin` folder mkdir -p ./bin cp ./target/x86_64-unknown-linux-gnu/release/aws_secretsmanager_agent ./bin/secrets-manager-agent # Copy the `secrets-manager-agent-extension.sh` example script into the `extensions` folder. mkdir -p ./extensions cp aws_secretsmanager_agent/examples/example-lambda-extension/secrets-manager-agent-extension.sh ./extensions # Zip the extension shell script and the binary zip secrets-manager-agent-extension.zip bin/* extensions/* # Publish the layer version LAYER_VERSION_ARN=$(aws lambda publish-layer-version \ --layer-name secrets-manager-agent-extension \ --zip-file "fileb://secrets-manager-agent-extension.zip" | jq -r '.LayerVersionArn') ``` 1. **Konfigurieren Sie das SSRF-Token** Die Standardkonfiguration des Agenten setzt das SSRF-Token automatisch auf den Wert, der in den voreingestellten Variablen `AWS_SESSION_TOKEN` oder `AWS_CONTAINER_AUTHORIZATION_TOKEN` Umgebungsvariablen festgelegt ist (letztere Variable für Lambda-Funktionen mit SnapStart aktivierter Option). Alternativ können Sie die `AWS_TOKEN` Umgebungsvariable stattdessen mit einem beliebigen Wert für Ihre Lambda-Funktion definieren, da diese Variable Vorrang vor den anderen beiden hat. Wenn Sie die `AWS_TOKEN` Umgebungsvariable verwenden möchten, müssen Sie diese Umgebungsvariable mit einem `lambda:UpdateFunctionConfiguration` Aufruf festlegen. 1. **Ebene an Funktion anhängen** Hängen Sie die Layer-Version an Ihre Lambda-Funktion an: ``` # Attach the layer version to the Lambda function aws lambda update-function-configuration \ --function-name $LAMBDA_ARN \ --layers "$LAYER_VERSION_ARN" ``` 1. **Funktionscode aktualisieren** Aktualisieren Sie Ihre Lambda-Funktion so, dass `http://localhost:2773/secretsmanager/get?secretId=MyTest` der `X-Aws-codes-Secrets-Token` Header-Wert auf den Wert des SSRF-Tokens gesetzt ist, das aus einer der oben genannten Umgebungsvariablen stammt, um das Geheimnis abzurufen. Stellen Sie sicher, dass Sie die Wiederholungslogik in Ihrem Anwendungscode implementieren, um Verzögerungen bei der Initialisierung und Registrierung der Lambda-Erweiterung zu vermeiden. 1. **Testen der Funktion** Rufen Sie die Lambda-Funktion auf, um zu überprüfen, ob das Geheimnis korrekt abgerufen wurde. ------ ## Rufen Sie Geheimnisse mit dem Secrets Manager Agent ab Um ein Geheimnis abzurufen, rufen Sie den lokalen Secrets Manager Agent-Endpunkt mit dem geheimen Namen oder ARN als Abfrageparameter auf. Standardmäßig ruft der Secrets Manager Agent die `AWSCURRENT` Version des Secrets ab. Um eine andere Version abzurufen, verwenden Sie entweder den VersionStage- oder den VersionID-Parameter. **Wichtig** Um den Secrets Manager Agent zu schützen, müssen Sie jeder Anfrage einen SSRF-Token-Header beifügen:`X-Aws-Parameters-Secrets-Token`. Der Secrets Manager Agent lehnt Anfragen ab, die diesen Header nicht haben oder die ein ungültiges SSRF-Token haben. Sie können den Namen des SSRF-Headers in der anpassen. [Den Secrets Manager Agent konfigurieren](#secrets-manager-agent-config) ### Erforderliche Berechtigungen Der Secrets Manager Agent verwendet das AWS SDK für Rust, das die [AWS Credential Provider Chain](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html) verwendet. Die Identität dieser IAM-Anmeldeinformationen bestimmt die Berechtigungen, die der Secrets Manager Agent zum Abrufen von Geheimnissen hat. + `secretsmanager:DescribeSecret` + `secretsmanager:GetSecretValue` Weitere Informationen zu Berechtigungen finden Sie unter [Referenz zu Berechtigungen für AWS Secrets Manager](auth-and-access.md#reference_iam-permissions). **Wichtig** Nachdem der geheime Wert in den Secrets Manager Agent abgerufen wurde, kann jeder Benutzer mit Zugriff auf die Rechenumgebung und das SSRF-Token aus dem Secrets Manager Agent-Cache auf das Geheimnis zugreifen. Weitere Informationen finden Sie unter [Sicherheitsüberlegungen](#secrets-manager-agent-security). ### Beispielanfragen ------ #### [ curl ] **Example Beispiel — Holen Sie sich ein Geheimnis mit curl** Das folgende Curl-Beispiel zeigt, wie Sie ein Geheimnis vom Secrets Manager Agent abrufen können. Das Beispiel basiert darauf, dass die SSRF in einer Datei vorhanden ist, in der sie vom Installationsskript gespeichert wird. ``` curl -v -H \\ "X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\ 'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID' \\ echo ``` ------ #### [ Python ] **Example Beispiel — Holen Sie sich ein Geheimnis mit Python** Das folgende Python-Beispiel zeigt, wie ein Secret vom Secrets Manager Agent abgerufen wird. Das Beispiel basiert darauf, dass die SSRF in einer Datei vorhanden ist, in der sie vom Installationsskript gespeichert wird. ``` import requests import json # Function that fetches the secret from Secrets Manager Agent for the provided secret id. def get_secret(): # Construct the URL for the GET request url = f"http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID" # Get the SSRF token from the token file with open('/var/run/awssmatoken') as fp: token = fp.read() headers = { "X-Aws-Parameters-Secrets-Token": token.strip() } try: # Send the GET request with headers response = requests.get(url, headers=headers) # Check if the request was successful if response.status_code == 200: # Return the secret value return response.text else: # Handle error cases raise Exception(f"Status code {response.status_code} - {response.text}") except Exception as e: # Handle network errors raise Exception(f"Error: {e}") ``` ------ ## Den Parameter verstehen `refreshNow` Der Secrets Manager Agent verwendet einen In-Memory-Cache, um geheime Werte zu speichern, die er regelmäßig aktualisiert. Standardmäßig erfolgt diese Aktualisierung, wenn Sie nach Ablauf der Gültigkeitsdauer (Time to Live, TTL), in der Regel alle 300 Sekunden, ein Geheimnis anfordern. Dieser Ansatz kann jedoch manchmal zu veralteten Geheimwerten führen, insbesondere wenn ein Geheimnis rotiert, bevor der Cache-Eintrag abläuft. Um diese Einschränkung zu umgehen, unterstützt der Secrets Manager Agent einen Parameter, der `refreshNow` in der URL aufgerufen wird. Sie können diesen Parameter verwenden, um eine sofortige Aktualisierung des Werts eines Geheimnisses zu erzwingen, den Cache zu umgehen und sicherzustellen, dass Sie über die meisten up-to-date Informationen verfügen. **Standardverhalten (ohne`refreshNow`)** + Verwendet zwischengespeicherte Werte, bis TTL abläuft + Aktualisiert Geheimnisse erst nach TTL (Standard 300 Sekunden) + Kann veraltete Werte zurückgeben, wenn die Geheimnisse rotieren, bevor der Cache abläuft **Verhalten mit `refreshNow=true`** + Umgeht den Cache vollständig + Ruft den neuesten geheimen Wert direkt aus Secrets Manager ab + Aktualisiert den Cache mit dem neuen Wert und setzt die TTL zurück + Stellt sicher, dass Sie immer den aktuellsten geheimen Wert erhalten ### Force-Aktualisierung eines geheimen Werts **Wichtig** Der Standardwert von `refreshNow` ist `false`. Wenn auf gesetzt`true`, überschreibt es die in der Secrets Manager Agent-Konfigurationsdatei angegebene TTL und führt einen API-Aufruf an Secrets Manager durch. ------ #### [ curl ] **Example Beispiel — Force-Aktualisierung eines Secrets mithilfe von curl** Das folgende Curl-Beispiel zeigt, wie Sie den Secrets Manager Agent zwingen können, den Secret zu aktualisieren. Das Beispiel basiert darauf, dass die SSRF in einer Datei vorhanden ist, in der sie vom Installationsskript gespeichert wird. ``` curl -v -H \\ "X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\ 'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID&refreshNow=true' \\ echo ``` ------ #### [ Python ] **Example Beispiel — Force-Aktualisierung eines Secrets mit Python** Das folgende Python-Beispiel zeigt, wie ein Secret vom Secrets Manager Agent abgerufen wird. Das Beispiel basiert darauf, dass die SSRF in einer Datei vorhanden ist, in der sie vom Installationsskript gespeichert wird. ``` import requests import json # Function that fetches the secret from Secrets Manager Agent for the provided secret id. def get_secret(): # Construct the URL for the GET request url = f"http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID&refreshNow=true" # Get the SSRF token from the token file with open('/var/run/awssmatoken') as fp: token = fp.read() headers = { "X-Aws-Parameters-Secrets-Token": token.strip() } try: # Send the GET request with headers response = requests.get(url, headers=headers) # Check if the request was successful if response.status_code == 200: # Return the secret value return response.text else: # Handle error cases raise Exception(f"Status code {response.status_code} - {response.text}") except Exception as e: # Handle network errors raise Exception(f"Error: {e}") ``` ------ ## Den Secrets Manager Agent konfigurieren Um die Konfiguration des Secrets Manager Agent zu ändern, erstellen Sie eine [TOML-Konfigurationsdatei](https://toml.io/en/) und rufen Sie `./aws_secretsmanager_agent --config config.toml` dann auf.Konfigurationsoptionen **`log_level`** Die Detailebene, die in den Protokollen für den Secrets Manager Agent gemeldet wird: DEBUG, INFO, WARN, ERROR oder NONE. Die Standardeinstellung ist INFO. **`log_to_file`** Ob in einer Datei oder stdout/stderr protokolliert werden soll: oder. `true` `false` Der Standardwert ist `true`. **`http_port`** Der Port für den lokalen HTTP-Server im Bereich 1024 bis 65535. Die Standardeinstellung ist 2773. **`region`** Die AWS Region, die für Anfragen verwendet werden soll. Wenn keine Region angegeben ist, bestimmt der Secrets Manager Agent die Region aus dem SDK. Weitere Informationen finden [Sie unter Geben Sie Ihre Anmeldeinformationen und die Standardregion](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html) an im *AWS SDK for Rust Developer Guide*. **`ttl_seconds`** Die TTL in Sekunden für die zwischengespeicherten Elemente im Bereich 0 bis 3600. Die Standardeinstellung ist 300. 0 gibt an, dass kein Caching stattfindet. **`cache_size`** Die maximale Anzahl von Geheimnissen, die im Cache gespeichert werden können, liegt im Bereich von 1 bis 1000. Der Standardwert ist 1000. **`ssrf_headers`** Eine Liste von Header-Namen, die der Secrets Manager Agent auf das SSRF-Token überprüft. Die Standardeinstellung ist „X-Aws-Parameters-Secrets-Token,“. X-Vault-Token **`ssrf_env_variables`** Eine Liste von Umgebungsvariablennamen, die der Secrets Manager Agent in sequentieller Reihenfolge nach dem SSRF-Token sucht. Die Umgebungsvariable kann das Token oder einen Verweis auf die Tokendatei enthalten, wie in:. `AWS_TOKEN=file:///var/run/awssmatoken` Die Standardeinstellung ist "AWS\$1TOKEN, AWS\$1SESSION \$1TOKEN, AWS\$1CONTAINER \$1AUTHORIZATION\$1TOKEN“. **`path_prefix`** Das URI-Präfix, das verwendet wird, um festzustellen, ob es sich bei der Anfrage um eine pfadbasierte Anfrage handelt. Die Standardeinstellung ist „/v1/“. **`max_conn`** Die maximale Anzahl von Verbindungen von HTTP-Clients, die der Secrets Manager Agent zulässt, im Bereich von 1 bis 1000. Die Standardeinstellung ist 800. ## Optionale Funktionen Der Secrets Manager Agent kann mit optionalen Funktionen erstellt werden, indem das `--features` Flag an übergeben wird`cargo build`. Die verfügbaren Funktionen sind:Build-Funktionen **`prefer-post-quantum`** Stellt `X25519MLKEM768` den Schlüsselaustausch-Algorithmus mit der höchsten Priorität her. Andernfalls ist er verfügbar, hat aber nicht die höchste Priorität. `X25519MLKEM768`ist ein hybrider Algorithmus für den post-quantum-secure Schlüsselaustausch. **`fips`** Schränkt die vom Agenten verwendeten Verschlüsselungssammlungen auf FIPS-zugelassene Verschlüsselungen ein. ## Protokollierung **Lokale Protokollierung** Der Secrets Manager Agent protokolliert Fehler lokal in der Datei `logs/secrets_manager_agent.log` oder in stdout/stderr, abhängig von der Konfigurationsvariablen. `log_to_file` Wenn Ihre Anwendung den Secrets Manager Agent aufruft, um ein Geheimnis zu erhalten, werden diese Aufrufe im lokalen Protokoll angezeigt. Sie erscheinen nicht in den CloudTrail Protokollen. **Rotation der Protokolle** Der Secrets Manager Agent erstellt eine neue Protokolldatei, wenn die Datei 10 MB erreicht, und speichert insgesamt bis zu fünf Protokolldateien. **AWS Dienstprotokollierung** Das Protokoll geht nicht an Secrets Manager, CloudTrail, oder CloudWatch. Anfragen zum Abrufen von Geheimnissen vom Secrets Manager Agent werden in diesen Protokollen nicht angezeigt. Wenn der Secrets Manager Agent Secrets Manager aufruft, um ein Geheimnis zu erhalten, wird dieser Anruf CloudTrail mit einer Benutzer-Agent-Zeichenfolge aufgezeichnet, die enthält`aws-secrets-manager-agent`. Sie können die Protokollierungsoptionen in der konfigurieren[Den Secrets Manager Agent konfigurieren](#secrets-manager-agent-config). ## Sicherheitsüberlegungen **Domäne des Vertrauens** Bei einer Agentenarchitektur ist die Vertrauensdomäne der Ort, an dem der Agentenendpunkt und das SSRF-Token zugänglich sind, was normalerweise der gesamte Host ist. Die Vertrauensdomäne für den Secrets Manager Agent sollte mit der Domäne übereinstimmen, in der die Secrets Manager Manager-Anmeldeinformationen verfügbar sind, um den gleichen Sicherheitsstatus aufrechtzuerhalten. Auf Amazon EC2 wäre die Vertrauensdomäne für den Secrets Manager Agent beispielsweise dieselbe wie die Domäne der Anmeldeinformationen, wenn Rollen für Amazon EC2 verwendet werden. **Wichtig** Sicherheitsbewusste Anwendungen, die noch keine Agentenlösung verwenden, bei der die Secrets Manager Manager-Anmeldeinformationen für die Anwendung gesperrt sind, sollten die Verwendung sprachspezifischer Lösungen AWS SDKs oder Caching-Lösungen in Betracht ziehen. [Weitere Informationen finden Sie unter Geheime Informationen abrufen.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html)