Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation de l' AWS Secrets Manager agent
## Comment fonctionne l'agent Secrets Manager
L' AWS Secrets Manager Agent est un service HTTP côté client qui vous aide à normaliser la façon dont vous consommez les secrets de Secrets Manager dans vos environnements informatiques. Vous pouvez l'utiliser avec les services suivants :
+ AWS Lambda
+ Amazon Elastic Container Service
+ Amazon Elastic Kubernetes Service
+ Amazon Elastic Compute Cloud
L'agent Secrets Manager récupère et met en cache les secrets en mémoire, ce qui permet à vos applications d'obtenir des secrets auprès de localhost au lieu de passer des appels directs à Secrets Manager. L'agent Secrets Manager peut uniquement lire les secrets, il ne peut pas les modifier.
**Important**
L'agent Secrets Manager utilise les AWS informations d'identification de votre environnement pour appeler Secrets Manager. Il inclut une protection contre la falsification des requêtes côté serveur (SSRF) afin d'améliorer la sécurité des secrets. L'agent Secrets Manager utilise l'échange de clés ML-KEM post-quantique comme échange de clés ayant la priorité la plus élevée par défaut.
## Comprendre la mise en cache des agents Secrets Manager
L'agent Secrets Manager utilise un cache en mémoire qui se réinitialise au redémarrage de l'agent Secrets Manager. Il actualise régulièrement les valeurs secrètes mises en cache en fonction des éléments suivants :
+ La fréquence de rafraîchissement par défaut (TTL) est de 300 secondes
+ Vous pouvez modifier le TTL à l'aide d'un fichier de configuration
+ L'actualisation a lieu lorsque vous demandez un secret après l'expiration du TTL
**Note**
L'agent Secrets Manager n'inclut pas l'invalidation du cache. Si un secret change avant l'expiration de l'entrée du cache, l'agent Secrets Manager peut renvoyer une valeur secrète périmée.
L'agent Secrets Manager renvoie les valeurs secrètes dans le même format que la réponse de`GetSecretValue`. Les valeurs secrètes ne sont pas chiffrées dans le cache.
**Topics**
+ [Comment fonctionne l'agent Secrets Manager](#agent-overview)
+ [Comprendre la mise en cache des agents Secrets Manager](#agent-caching)
+ [Créez l'agent Secrets Manager](#secrets-manager-agent-build)
+ [Installation de l'agent Secrets Manager](#secrets-manager-agent-install)
+ [Récupérez des secrets avec l'agent Secrets Manager](#secrets-manager-agent-call)
+ [Comprendre le `refreshNow` paramètre](#secrets-manager-agent-refresh)
+ [Configuration de l'agent Secrets Manager](#secrets-manager-agent-config)
+ [Fonctionnalités optionnelles](#secrets-manager-agent-features)
+ [Logging](#secrets-manager-agent-log)
+ [Considérations sur la sécurité](#secrets-manager-agent-security)
## Créez l'agent Secrets Manager
Avant de commencer, assurez-vous que les outils de développement standard et les outils Rust sont installés pour votre plateforme.
**Note**
La création de l'agent avec la `fips` fonctionnalité activée sur macOS nécessite actuellement la solution de contournement suivante :
Créez une variable d'environnement appelée `SDKROOT` qui est définie sur le résultat de l'exécution `xcrun --show-sdk-path`
------
#### [ RPM-based systems ]
**Pour s'appuyer sur des systèmes basés sur le RPM**
1. Utilisez le `install` script fourni dans le référentiel.
Le script génère un jeton SSRF aléatoire au démarrage et le stocke dans le fichier`/var/run/awssmatoken`. Le jeton est lisible par le `awssmatokenreader` groupe créé par le script d'installation.
1. Pour permettre à votre application de lire le fichier de jetons, vous devez ajouter au `awssmatokenreader` groupe le compte utilisateur sous lequel votre application s'exécute. Par exemple, vous pouvez autoriser votre application à lire le fichier de jetons à l'aide de la commande usermod suivante, où ** est l'ID utilisateur sous lequel votre application s'exécute.
```
sudo usermod -aG awssmatokenreader
```
**Installation d'outils de développement**
Sur les systèmes basés sur le RPM tels que AL2023, installez le groupe d'outils de développement :
```
sudo yum -y groupinstall "Development Tools"
```
1.
**Installez Rust**
Suivez les instructions de la section [Installer Rust](https://www.rust-lang.org/tools/install) dans la *documentation Rust* :
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions
. "$HOME/.cargo/env"
```
1.
**Créez l'agent**
Créez l'agent Secrets Manager à l'aide de la commande cargo build :
```
cargo build --release
```
Vous trouverez le fichier exécutable sous`target/release/aws_secretsmanager_agent`.
------
#### [ Debian-based systems ]
**Pour s'appuyer sur des systèmes basés sur Debian**
1.
**Installation d'outils de développement**
Sur les systèmes basés sur Debian tels qu'Ubuntu, installez le package build-essential :
```
sudo apt install build-essential
```
1.
**Installez Rust**
Suivez les instructions de la section [Installer Rust](https://www.rust-lang.org/tools/install) dans la *documentation Rust* :
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions
. "$HOME/.cargo/env"
```
1.
**Créez l'agent**
Créez l'agent Secrets Manager à l'aide de la commande cargo build :
```
cargo build --release
```
Vous trouverez le fichier exécutable sous`target/release/aws_secretsmanager_agent`.
------
#### [ Windows ]
**Pour créer sous Windows**
1.
**Configuration de l'environnement de développement**
Suivez les instructions de la [section Configurer votre environnement de développement sous Windows pour Rust](https://learn.microsoft.com/en-us/windows/dev-environment/rust/setup) dans la *documentation Microsoft Windows*.
1.
**Créez l'agent**
Créez l'agent Secrets Manager à l'aide de la commande cargo build :
```
cargo build --release
```
Vous trouverez le fichier exécutable sous`target/release/aws_secretsmanager_agent.exe`.
------
#### [ Cross-compile natively ]
**Pour effectuer une compilation croisée en mode natif**
1.
**Installation d'outils de compilation croisée**
Sur les distributions où le package mingw-w64 est disponible, comme Ubuntu, installez la chaîne d'outils de compilation croisée :
```
# Install the cross compile tool chain
sudo add-apt-repository universe
sudo apt install -y mingw-w64
```
1.
**Ajouter des cibles de build Rust**
Installez la cible de compilation Windows GNU :
```
rustup target add x86_64-pc-windows-gnu
```
1.
**Construire pour Windows**
Compilez l'agent pour Windows de manière croisée :
```
cargo build --release --target x86_64-pc-windows-gnu
```
Vous trouverez le fichier exécutable à l'adresse`target/x86_64-pc-windows-gnu/release/aws_secretsmanager_agent.exe`.
------
#### [ Cross compile with Rust cross ]
**Pour effectuer une compilation croisée à l'aide de Rust cross**
Si les outils de compilation croisée ne sont pas disponibles nativement sur le système, vous pouvez utiliser le projet croisé Rust. Pour plus d'informations, voir [https://github.com/cross-rs/croix](https://github.com/cross-rs/cross).
**Important**
Nous recommandons 32 Go d'espace disque pour l'environnement de génération.
1.
**Configurer Docker**
Installez et configurez Docker :
```
# Install and start docker
sudo yum -y install docker
sudo systemctl start docker
sudo systemctl enable docker # Make docker start after reboot
```
1.
**Configurer les autorisations Docker**
Ajoutez votre utilisateur au groupe de dockers :
```
# Give ourselves permission to run the docker images without sudo
sudo usermod -aG docker $USER
newgrp docker
```
1.
**Construire pour Windows**
Installez cross et compilez l'exécutable :
```
# Install cross and cross compile the executable
cargo install cross
cross build --release --target x86_64-pc-windows-gnu
```
------
## Installation de l'agent Secrets Manager
Choisissez votre environnement informatique parmi les options d'installation suivantes.
------
#### [ Amazon EC2 ]
**Pour installer l'agent Secrets Manager sur Amazon EC2**
1.
**Accédez au répertoire de configuration**
Accédez au répertoire de configuration :
```
cd aws_secretsmanager_agent/configuration
```
1.
**Exécuter le script d'installation**
Exécutez le `install` script fourni dans le référentiel.
Le script génère un jeton SSRF aléatoire au démarrage et le stocke dans le fichier`/var/run/awssmatoken`. Le jeton est lisible par le `awssmatokenreader` groupe créé par le script d'installation.
1.
**Configurer les autorisations des applications**
Ajoutez au `awssmatokenreader` groupe le compte utilisateur sous lequel votre application s'exécute :
```
sudo usermod -aG awssmatokenreader APP_USER
```
Remplacez *APP\$1USER* par l'ID utilisateur sous lequel votre application s'exécute.
------
#### [ Container Sidecar ]
Vous pouvez exécuter l'agent Secrets Manager en tant que conteneur annexe à votre application à l'aide de Docker. Votre application peut ensuite récupérer les secrets depuis le serveur HTTP local fourni par l'agent Secrets Manager. Pour plus d'informations sur Docker, consultez la documentation [Docker](https://docs.docker.com).
**Pour créer un conteneur annexe pour l'agent Secrets Manager**
1.
**Créer un agent Dockerfile**
Créez un Dockerfile pour le conteneur annexe de l'agent Secrets Manager :
```
# 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.
**Créer un Dockerfile d'application**
Créez un Dockerfile pour votre application cliente.
1.
**Créer un fichier Docker Compose**
Créez un fichier Docker Compose pour exécuter les deux conteneurs avec une interface réseau partagée :
**Important**
Vous devez charger les AWS informations d'identification et le jeton SSRF pour que l'application puisse utiliser l'agent Secrets Manager. Pour Amazon EKS et Amazon ECS, consultez les rubriques suivantes :
[Gérez l'accès](https://docs.aws.amazon.com/eks/latest/userguide/cluster-auth.html) dans le *guide de l'utilisateur Amazon EKS*
[Rôle IAM de la tâche Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) dans le manuel du *développeur Amazon ECS*
```
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 de copie binaire**
Copiez le `secrets-manager-agent` fichier binaire dans le même répertoire que celui qui contient vos fichiers Dockerfiles et Docker Compose.
1.
**Créez et gérez des conteneurs**
Créez et exécutez les conteneurs à l'aide de Docker Compose :
```
docker-compose up --build
```
1.
**Étapes suivantes**
Vous pouvez désormais utiliser l'agent Secrets Manager pour récupérer les secrets de votre conteneur client. Pour de plus amples informations, veuillez consulter [Récupérez des secrets avec l'agent Secrets Manager](#secrets-manager-agent-call).
------
#### [ Lambda ]
Vous pouvez [empaqueter l'agent Secrets Manager sous forme d'extension Lambda](https://docs.aws.amazon.com/lambda/latest/dg/packaging-layers.html). Vous pouvez ensuite l'[ajouter à votre fonction Lambda sous forme de couche](https://docs.aws.amazon.com/lambda/latest/dg/adding-layers.html) et appeler l'agent Secrets Manager depuis votre fonction Lambda pour obtenir des secrets.
Les instructions suivantes montrent comment obtenir un nom de secret à l'aide *MyTest*de l'exemple de script [https://github.com/aws/aws-secretsmanager-agent](https://github.com/aws/aws-secretsmanager-agent)pour installer l'agent Secrets Manager `secrets-manager-agent-extension.sh` en tant qu'extension Lambda.
**Pour créer une extension Lambda pour l'agent Secrets Manager**
1.
**Package de la couche d'agent**
À partir de la racine du package de code de l'agent Secrets Manager, exécutez les commandes suivantes :
```
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.
**Configurer le jeton SSRF**
La configuration par défaut de l'agent définira automatiquement le jeton SSRF à la valeur définie dans les variables prédéfinies `AWS_SESSION_TOKEN` ou d'`AWS_CONTAINER_AUTHORIZATION_TOKEN`environnement (cette dernière variable est activée pour les fonctions Lambda). SnapStart Vous pouvez également définir la variable d'`AWS_TOKEN`environnement avec une valeur arbitraire pour votre fonction Lambda, car cette variable a priorité sur les deux autres. Si vous choisissez d'utiliser la variable d'`AWS_TOKEN`environnement, vous devez définir cette variable d'environnement par un `lambda:UpdateFunctionConfiguration` appel.
1.
**Attacher une couche à la fonction**
Attachez la version de la couche à votre fonction Lambda :
```
# Attach the layer version to the Lambda function
aws lambda update-function-configuration \
--function-name $LAMBDA_ARN \
--layers "$LAYER_VERSION_ARN"
```
1.
**Mettre à jour le code de la fonction**
Mettez à jour votre fonction Lambda pour effectuer `http://localhost:2773/secretsmanager/get?secretId=MyTest` une requête avec la valeur d'`X-Aws-codes-Secrets-Token`en-tête définie sur la valeur du jeton SSRF provenant de l'une des variables d'environnement mentionnées ci-dessus afin de récupérer le secret. Veillez à implémenter une logique de nouvelle tentative dans le code de votre application afin de prendre en compte les délais d'initialisation et d'enregistrement de l'extension Lambda.
1.
**Tester la fonction**
Appelez la fonction Lambda pour vérifier que le secret est correctement extrait.
------
## Récupérez des secrets avec l'agent Secrets Manager
Pour récupérer un secret, appelez le point de terminaison local de l'agent Secrets Manager avec le nom du secret ou l'ARN comme paramètre de requête. Par défaut, l'agent Secrets Manager récupère la `AWSCURRENT` version du secret. Pour récupérer une version différente, utilisez le paramètre VersionStage ou VersionId.
**Important**
Pour protéger l'agent Secrets Manager, vous devez inclure un en-tête de jeton SSRF dans chaque demande :`X-Aws-Parameters-Secrets-Token`. L'agent Secrets Manager refuse les demandes qui ne contiennent pas cet en-tête ou qui contiennent un jeton SSRF non valide. Vous pouvez personnaliser le nom de l'en-tête SSRF dans le[Configuration de l'agent Secrets Manager](#secrets-manager-agent-config).
### Autorisations requises
L'agent Secrets Manager utilise le AWS SDK pour Rust, qui utilise la chaîne de [fournisseurs AWS d'informations d'identification](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html). L'identité de ces informations d'identification IAM détermine les autorisations dont dispose l'agent Secrets Manager pour récupérer les secrets.
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Pour en savoir plus sur les autorisations, consultez [Référence des autorisations pour AWS Secrets Manager](auth-and-access.md#reference_iam-permissions).
**Important**
Une fois la valeur secrète saisie dans l'agent Secrets Manager, tout utilisateur ayant accès à l'environnement informatique et au jeton SSRF peut accéder au secret depuis le cache de l'agent Secrets Manager. Pour de plus amples informations, veuillez consulter [Considérations sur la sécurité](#secrets-manager-agent-security).
### Exemples de demandes
------
#### [ curl ]
**Example Exemple — Obtenir un secret en utilisant curl**
L'exemple de curl suivant montre comment obtenir un secret auprès de l'agent Secrets Manager. L'exemple repose sur la présence du SSRF dans un fichier, où il est stocké par le script d'installation.
```
curl -v -H \\
"X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\
'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID' \\
echo
```
------
#### [ Python ]
**Example Exemple — Obtenir un secret en utilisant Python**
L'exemple Python suivant montre comment obtenir un secret à partir de l'agent Secrets Manager. L'exemple repose sur la présence du SSRF dans un fichier, où il est stocké par le script d'installation.
```
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}")
```
------
## Comprendre le `refreshNow` paramètre
L'agent Secrets Manager utilise un cache en mémoire pour stocker les valeurs secrètes, qu'il actualise régulièrement. Par défaut, cette actualisation a lieu lorsque vous demandez un secret après l'expiration du délai de vie (TTL), généralement toutes les 300 secondes. Cependant, cette approche peut parfois entraîner des valeurs secrètes périmées, en particulier si un secret change avant l'expiration de l'entrée du cache.
Pour pallier cette limitation, l'agent Secrets Manager prend en charge un paramètre appelé `refreshNow` dans l'URL. Vous pouvez utiliser ce paramètre pour forcer l'actualisation immédiate de la valeur d'un secret, en contournant le cache et en vous assurant de disposer du maximum up-to-date d'informations.
**Comportement par défaut (sans`refreshNow`)**
+ Utilise les valeurs mises en cache jusqu'à l'expiration du TTL
+ Actualise les secrets uniquement après TTL (300 secondes par défaut)
+ Peut renvoyer des valeurs périmées si les secrets changent avant l'expiration du cache
**Comportement avec `refreshNow=true`**
+ Contourne complètement le cache
+ Récupère la dernière valeur secrète directement depuis Secrets Manager
+ Met à jour le cache avec la nouvelle valeur et réinitialise le TTL
+ Garantit que vous obtenez toujours la valeur secrète la plus récente
### Actualiser de force une valeur secrète
**Important**
La valeur par défaut de `refreshNow` est `false`. Lorsqu'il est défini sur`true`, il remplace le TTL spécifié dans le fichier de configuration de l'agent Secrets Manager et envoie un appel d'API à Secrets Manager.
------
#### [ curl ]
**Example Exemple — Actualisation forcée d'un secret à l'aide de curl**
L'exemple de curl suivant montre comment forcer l'agent Secrets Manager à actualiser le secret. L'exemple repose sur la présence du SSRF dans un fichier, où il est stocké par le script d'installation.
```
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 Exemple — Actualisation forcée d'un secret à l'aide de Python**
L'exemple Python suivant montre comment obtenir un secret à partir de l'agent Secrets Manager. L'exemple repose sur la présence du SSRF dans un fichier, où il est stocké par le script d'installation.
```
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}")
```
------
## Configuration de l'agent Secrets Manager
Pour modifier la configuration de l'agent Secrets Manager, créez un fichier de configuration [TOML](https://toml.io/en/), puis appelez`./aws_secretsmanager_agent --config config.toml`.Options de configuration
**`log_level`**
Niveau de détail indiqué dans les journaux pour l'agent Secrets Manager : DEBUG, INFO, WARN, ERROR ou NONE. La valeur par défaut est INFO.
**`log_to_file`**
S'il faut se connecter à un fichier ou à stdout/stderr : ou. `true` `false` La valeur par défaut est `true`.
**`http_port`**
Port du serveur HTTP local, compris entre 1024 et 65535. La valeur par défaut est 2773.
**`region`**
La AWS région à utiliser pour les demandes. Si aucune région n'est spécifiée, l'agent Secrets Manager détermine la région à partir du SDK. Pour plus d'informations, consultez [Spécifier vos informations d'identification et la région par défaut](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html) dans le *guide du développeur du AWS SDK pour Rust*.
**`ttl_seconds`**
Le TTL en secondes pour les éléments mis en cache, compris entre 0 et 3 600. La valeur par défaut est 300. 0 indique qu'il n'y a pas de mise en cache.
**`cache_size`**
Le nombre maximum de secrets pouvant être stockés dans le cache, compris entre 1 et 1 000. La valeur par défaut est 1000.
**`ssrf_headers`**
Une liste de noms d'en-têtes que l'agent Secrets Manager vérifie pour le jeton SSRF. La valeur par défaut est « X-Aws-Parameters-Secrets-Token ». X-Vault-Token
**`ssrf_env_variables`**
Une liste de noms de variables d'environnement que l'agent Secrets Manager vérifie dans l'ordre séquentiel pour le jeton SSRF. La variable d'environnement peut contenir le jeton ou une référence au fichier du jeton comme dans :`AWS_TOKEN=file:///var/run/awssmatoken`. La valeur par défaut est «AWS\$1TOKEN, AWS\$1SESSION \$1TOKEN, AWS\$1CONTAINER \$1AUTHORIZATION\$1TOKEN ».
**`path_prefix`**
Le préfixe d'URI utilisé pour déterminer si la demande est une demande basée sur le chemin. La valeur par défaut est « /v1/ ».
**`max_conn`**
Le nombre maximum de connexions depuis des clients HTTP autorisées par l'agent Secrets Manager, compris entre 1 et 1 000. La valeur par défaut est 800.
## Fonctionnalités optionnelles
L'agent Secrets Manager peut être créé avec des fonctionnalités optionnelles en passant le `--features` drapeau à`cargo build`. Les fonctionnalités disponibles sont les suivantes :Fonctions de génération
**`prefer-post-quantum`**
Génère `X25519MLKEM768` l'algorithme d'échange de clés ayant la priorité la plus élevée. Dans le cas contraire, il est disponible mais n'est pas prioritaire. `X25519MLKEM768`est un algorithme hybride d'échange de post-quantum-secure clés.
**`fips`**
Limite les suites de chiffrement utilisées par l'agent aux seuls chiffrements approuvés par FIPS.
## Logging
**Journalisation locale**
L'agent Secrets Manager enregistre les erreurs localement dans le fichier `logs/secrets_manager_agent.log` ou dans stdout/stderr en fonction de la variable de configuration. `log_to_file` Lorsque votre application appelle l'agent Secrets Manager pour obtenir un secret, ces appels apparaissent dans le journal local. Ils n'apparaissent pas dans les CloudTrail journaux.
**Rotation du journal**
L'agent Secrets Manager crée un nouveau fichier journal lorsque le fichier atteint 10 Mo, et il stocke jusqu'à cinq fichiers journaux au total.
**AWS journalisation des services**
Le journal n'est pas envoyé à Secrets Manager CloudTrail, ou CloudWatch. Les demandes d'obtention de secrets de la part de l'agent Secrets Manager n'apparaissent pas dans ces journaux. Lorsque l'agent Secrets Manager appelle Secrets Manager pour obtenir un secret, cet appel est enregistré CloudTrail avec une chaîne d'agent utilisateur contenant`aws-secrets-manager-agent`.
Vous pouvez configurer les options de journalisation dans le[Configuration de l'agent Secrets Manager](#secrets-manager-agent-config).
## Considérations sur la sécurité
**Domaine de confiance**
Pour une architecture d'agent, le domaine de confiance correspond à l'endroit où le point de terminaison de l'agent et le jeton SSRF sont accessibles, c'est-à-dire généralement l'ensemble de l'hôte. Le domaine de confiance de l'agent Secrets Manager doit correspondre au domaine dans lequel les informations d'identification du Secrets Manager sont disponibles afin de maintenir le même niveau de sécurité. Par exemple, sur Amazon EC2, le domaine de confiance de l'agent Secrets Manager serait le même que celui des informations d'identification lors de l'utilisation de rôles pour Amazon EC2.
**Important**
Les applications soucieuses de sécurité qui n'utilisent pas déjà une solution d'agent avec les informations d'identification de Secrets Manager verrouillées sur l'application devraient envisager d'utiliser des solutions spécifiques à la langue AWS SDKs ou de mise en cache. Pour plus d'informations, voir [Obtenir des secrets](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html).