Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Utilizzo dell' Gestione dei segreti AWS agente ## Come funziona l'agente Secrets Manager L' Gestione dei segreti AWS Agent è un servizio HTTP lato client che ti aiuta a standardizzare il modo in cui utilizzi i segreti di Secrets Manager nei tuoi ambienti di elaborazione. È possibile utilizzarlo con i seguenti servizi: + AWS Lambda + Amazon Elastic Container Service + Amazon Elastic Kubernetes Service + Amazon Elastic Compute Cloud L'agente Secrets Manager recupera e memorizza nella cache i segreti in memoria, consentendo alle applicazioni di ottenere segreti da localhost invece di effettuare chiamate dirette a Secrets Manager. L'agente Secrets Manager può solo leggere i segreti, non può modificarli. **Importante** L'agente Secrets Manager utilizza AWS le credenziali dell'ambiente per chiamare Secrets Manager. Include la protezione contro Server Side Request Forgery (SSRF) per contribuire a migliorare la sicurezza segreta. Per impostazione predefinita, l'agente Secrets Manager utilizza lo scambio di chiavi ML-KEM post-quantistico come scambio di chiavi con la massima priorità. ## Informazioni sulla memorizzazione nella cache dell'agente Secrets Manager L'agente Secrets Manager utilizza una cache in memoria che si ripristina al riavvio dell'agente Secrets Manager. Aggiorna periodicamente i valori segreti memorizzati nella cache in base a quanto segue: + La frequenza di aggiornamento predefinita (TTL) è 300 secondi + È possibile modificare il TTL utilizzando un file di configurazione + L'aggiornamento avviene quando si richiede un segreto dopo la scadenza del TTL **Nota** L'agente Secrets Manager non include l'invalidazione della cache. Se un segreto ruota prima della scadenza della voce della cache, l'agente Secrets Manager potrebbe restituire un valore segreto non aggiornato. L'agente Secrets Manager restituisce valori segreti nello stesso formato della risposta di`GetSecretValue`. I valori segreti non sono crittografati nella cache. **Topics** + [Come funziona l'agente Secrets Manager](#agent-overview) + [Informazioni sulla memorizzazione nella cache dell'agente Secrets Manager](#agent-caching) + [Crea l'agente Secrets Manager](#secrets-manager-agent-build) + [Installare l'agente Secrets Manager](#secrets-manager-agent-install) + [Recupera i segreti con l'agente Secrets Manager](#secrets-manager-agent-call) + [Comprensione del parametro `refreshNow`](#secrets-manager-agent-refresh) + [Configurazione dell'agente Secrets Manager](#secrets-manager-agent-config) + [Funzionalità opzionali](#secrets-manager-agent-features) + [Registrazione dei log](#secrets-manager-agent-log) + [Considerazioni relative alla sicurezza](#secrets-manager-agent-security) ## Crea l'agente Secrets Manager Prima di iniziare, assicurati di avere gli strumenti di sviluppo standard e gli strumenti Rust installati per la tua piattaforma. **Nota** La creazione dell'agente con la `fips` funzionalità abilitata su macOS richiede attualmente la seguente soluzione alternativa: Crea una variabile di ambiente chiamata `SDKROOT` che è impostata sul risultato dell'esecuzione `xcrun --show-sdk-path` ------ #### [ RPM-based systems ] **Per creare su sistemi basati su RPM** 1. Usa lo `install` script fornito nel repository. Lo script genera un token SSRF casuale all'avvio e lo memorizza nel file. `/var/run/awssmatoken` Il token è leggibile dal `awssmatokenreader` gruppo creato dallo script di installazione. 1. Per consentire all'applicazione di leggere il file del token, è necessario aggiungere al `awssmatokenreader` gruppo l'account utente con cui viene eseguita l'applicazione. Ad esempio, potete concedere all'applicazione le autorizzazioni per leggere il file del token con il seguente comando usermod, dove si ** trova l'ID utente con cui viene eseguita l'applicazione. ``` sudo usermod -aG awssmatokenreader ``` **Installa gli strumenti di sviluppo** Su sistemi basati su RPM, ad esempio AL2023, installa il gruppo Development Tools: ``` sudo yum -y groupinstall "Development Tools" ``` 1. **Installa Rust** Segui le istruzioni su [Install Rust](https://www.rust-lang.org/tools/install) nella *documentazione di Rust*: ``` curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions . "$HOME/.cargo/env" ``` 1. **Crea l'agente** Crea l'agente Secrets Manager usando il comando cargo build: ``` cargo build --release ``` Troverai l'eseguibile sotto`target/release/aws_secretsmanager_agent`. ------ #### [ Debian-based systems ] **Per costruire su sistemi basati su Debian** 1. **Installa strumenti di sviluppo** Su sistemi basati su Debian come Ubuntu, installa il pacchetto build-essential: ``` sudo apt install build-essential ``` 1. **Installa Rust** Segui le istruzioni su [Install Rust](https://www.rust-lang.org/tools/install) nella *documentazione di Rust*: ``` curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions . "$HOME/.cargo/env" ``` 1. **Crea l'agente** Crea l'agente Secrets Manager usando il comando cargo build: ``` cargo build --release ``` Troverai l'eseguibile sotto`target/release/aws_secretsmanager_agent`. ------ #### [ Windows ] **Per creare su Windows** 1. **Configurare l'ambiente di sviluppo** Segui le istruzioni in [Configurare l'ambiente di sviluppo su Windows for Rust](https://learn.microsoft.com/en-us/windows/dev-environment/rust/setup) nella *documentazione di Microsoft Windows*. 1. **Crea l'agente** Crea l'agente Secrets Manager usando il comando cargo build: ``` cargo build --release ``` Troverai l'eseguibile sotto`target/release/aws_secretsmanager_agent.exe`. ------ #### [ Cross-compile natively ] **Per eseguire la compilazione incrociata in modo nativo** 1. **Installa strumenti di compilazione incrociata** Nelle distribuzioni in cui è disponibile il pacchetto mingw-w64 come Ubuntu, installa la toolchain cross-compile: ``` # Install the cross compile tool chain sudo add-apt-repository universe sudo apt install -y mingw-w64 ``` 1. **Aggiungi obiettivi di compilazione di Rust** Installa il target di build di Windows GNU: ``` rustup target add x86_64-pc-windows-gnu ``` 1. **Compila per Windows** Compila in modo incrociato l'agente per Windows: ``` cargo build --release --target x86_64-pc-windows-gnu ``` L'eseguibile è disponibile all'indirizzo. `target/x86_64-pc-windows-gnu/release/aws_secretsmanager_agent.exe` ------ #### [ Cross compile with Rust cross ] **Per eseguire la compilazione incrociata utilizzando Rust cross** Se gli strumenti di compilazione incrociata non sono disponibili in modo nativo sul sistema, puoi utilizzare il progetto Rust cross. [Per ulteriori informazioni, consulta cross. https://github.com/cross-rs/](https://github.com/cross-rs/cross) **Importante** Consigliamo 32 GB di spazio su disco per l'ambiente di compilazione. 1. **Configura Docker** Installa e configura Docker: ``` # Install and start docker sudo yum -y install docker sudo systemctl start docker sudo systemctl enable docker # Make docker start after reboot ``` 1. **Configura le autorizzazioni Docker** Aggiungi il tuo utente al gruppo docker: ``` # Give ourselves permission to run the docker images without sudo sudo usermod -aG docker $USER newgrp docker ``` 1. **Compila per Windows** Installa cross e crea l'eseguibile: ``` # Install cross and cross compile the executable cargo install cross cross build --release --target x86_64-pc-windows-gnu ``` ------ ## Installare l'agente Secrets Manager Scegli il tuo ambiente di elaborazione tra le seguenti opzioni di installazione. ------ #### [ Amazon EC2 ] **Per installare l'agente Secrets Manager su Amazon EC2** 1. **Passa alla directory di configurazione** Passa alla directory di configurazione: ``` cd aws_secretsmanager_agent/configuration ``` 1. **Esegui lo script di installazione** Esegui lo `install` script fornito nel repository. Lo script genera un token SSRF casuale all'avvio e lo memorizza nel file. `/var/run/awssmatoken` Il token è leggibile dal `awssmatokenreader` gruppo creato dallo script di installazione. 1. **Configura le autorizzazioni dell'applicazione** Aggiungi l'account utente con cui viene eseguita l'applicazione al `awssmatokenreader` gruppo: ``` sudo usermod -aG awssmatokenreader APP_USER ``` Sostituiscilo *APP\$1USER* con l'ID utente con cui viene eseguita l'applicazione. ------ #### [ Container Sidecar ] Puoi eseguire Secrets Manager Agent come contenitore secondario insieme all'applicazione utilizzando Docker. Quindi l'applicazione può recuperare i segreti dal server HTTP locale fornito dall'agente Secrets Manager. Per informazioni su Docker, consulta la [documentazione Docker](https://docs.docker.com). **Per creare un contenitore sidecar per l'agente Secrets Manager** 1. **Crea l'agente Dockerfile** Crea un Dockerfile per il contenitore sidecar di Secrets Manager Agent: ``` # 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. **Crea l'applicazione Dockerfile** Crea un Dockerfile per la tua applicazione client. 1. **Crea il file Docker Compose** Crea un file Docker Compose per eseguire entrambi i contenitori con un'interfaccia di rete condivisa: **Importante** È necessario caricare AWS le credenziali e il token SSRF affinché l'applicazione possa utilizzare l'agente Secrets Manager. Per Amazon EKS e Amazon ECS, consulta quanto segue: [Gestisci l'accesso](https://docs.aws.amazon.com/eks/latest/userguide/cluster-auth.html) nella *Guida per l'utente di Amazon EKS* [Task Amazon ECS (ruolo IAM](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html)) nella *Amazon ECS* Developer Guide ``` 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. **File binario dell'agente di copia** Copia il file `secrets-manager-agent` binario nella stessa directory che contiene i file Dockerfiles e Docker Compose. 1. **Crea ed esegui contenitori** Crea ed esegui i contenitori usando Docker Compose: ``` docker-compose up --build ``` 1. **Fasi successive** Ora puoi utilizzare l'agente Secrets Manager per recuperare segreti dal contenitore del tuo client. Per ulteriori informazioni, consulta [Recupera i segreti con l'agente Secrets Manager](#secrets-manager-agent-call). ------ #### [ Lambda ] È possibile [impacchettare l'agente Secrets Manager come estensione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/packaging-layers.html). Quindi puoi [aggiungerlo alla tua funzione Lambda come livello](https://docs.aws.amazon.com/lambda/latest/dg/adding-layers.html) e chiamare l'agente Secrets Manager dalla tua funzione Lambda per ottenere segreti. Le seguenti istruzioni mostrano come ottenere un nome segreto *MyTest*utilizzando lo script `secrets-manager-agent-extension.sh` di esempio [https://github.com/aws/aws-secretsmanager-agent](https://github.com/aws/aws-secretsmanager-agent)per installare l'agente Secrets Manager come estensione Lambda. **Per creare un'estensione Lambda per l'agente Secrets Manager** 1. **Package dello strato agente** Dalla radice del pacchetto di codice Secrets Manager Agent, esegui i seguenti comandi: ``` 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. **Configurare il token SSRF** La configurazione predefinita dell'agente imposterà automaticamente il token SSRF sul valore impostato nelle variabili preimpostate `AWS_SESSION_TOKEN` o di `AWS_CONTAINER_AUTHORIZATION_TOKEN` ambiente (quest'ultima variabile per le funzioni Lambda con abilitata). SnapStart In alternativa, puoi definire la variabile di `AWS_TOKEN` ambiente con un valore arbitrario per la tua funzione Lambda, poiché questa variabile ha la precedenza sulle altre due. Se si sceglie di utilizzare la variabile di `AWS_TOKEN` ambiente, è necessario impostare tale variabile di ambiente con una chiamata. `lambda:UpdateFunctionConfiguration` 1. **Collega il livello alla funzione** Collega la versione del layer alla tua funzione Lambda: ``` # Attach the layer version to the Lambda function aws lambda update-function-configuration \ --function-name $LAMBDA_ARN \ --layers "$LAYER_VERSION_ARN" ``` 1. **Aggiornamento del codice della funzione** Aggiorna la tua funzione Lambda per eseguire una query `http://localhost:2773/secretsmanager/get?secretId=MyTest` con il valore dell'`X-Aws-codes-Secrets-Token`intestazione impostato sul valore del token SSRF proveniente da una delle variabili di ambiente sopra menzionate per recuperare il segreto. Assicurati di implementare la logica dei tentativi nel codice dell'applicazione per evitare ritardi nell'inizializzazione e nella registrazione dell'estensione Lambda. 1. **Test della funzione** Invocate la funzione Lambda per verificare che il segreto venga recuperato correttamente. ------ ## Recupera i segreti con l'agente Secrets Manager Per recuperare un segreto, chiamate l'endpoint locale dell'agente Secrets Manager con il nome segreto o l'ARN come parametro di interrogazione. Per impostazione predefinita, l'agente Secrets Manager recupera la `AWSCURRENT` versione del segreto. Per recuperare una versione diversa, utilizzare il parametro VersionStage o VersionID. **Importante** Per proteggere l'agente Secrets Manager, è necessario includere un'intestazione del token SSRF come parte di ogni richiesta:. `X-Aws-Parameters-Secrets-Token` L'agente Secrets Manager nega le richieste che non hanno questa intestazione o che hanno un token SSRF non valido. È possibile personalizzare il nome dell'intestazione SSRF in. [Configurazione dell'agente Secrets Manager](#secrets-manager-agent-config) ### Autorizzazioni richieste L'agente Secrets Manager utilizza l' AWS SDK per Rust, che utilizza la catena di [fornitori di AWS credenziali](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html). L'identità di queste credenziali IAM determina le autorizzazioni di cui dispone l'agente Secrets Manager per recuperare i segreti. + `secretsmanager:DescribeSecret` + `secretsmanager:GetSecretValue` Per ulteriori informazioni sulle autorizzazioni, consultare [Riferimento alle autorizzazioni per Gestione dei segreti AWS](auth-and-access.md#reference_iam-permissions). **Importante** Dopo aver inserito il valore segreto nell'agente Secrets Manager, qualsiasi utente con accesso all'ambiente di calcolo e al token SSRF può accedere al segreto dalla cache di Secrets Manager Agent. Per ulteriori informazioni, consulta [Considerazioni relative alla sicurezza](#secrets-manager-agent-security). ### Richieste di esempio ------ #### [ curl ] **Example Esempio: ottieni un segreto usando curl** Il seguente esempio curl mostra come ottenere un segreto dall'agente Secrets Manager. L'esempio si basa sulla presenza dell'SSRF in un file, che è dove viene memorizzato dallo script di installazione. ``` curl -v -H \\ "X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\ 'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID' \\ echo ``` ------ #### [ Python ] **Example Esempio: ottieni un segreto usando Python** Il seguente esempio in Python mostra come ottenere un segreto dall'agente Secrets Manager. L'esempio si basa sulla presenza dell'SSRF in un file, che è dove viene memorizzato dallo script di installazione. ``` 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}") ``` ------ ## Comprensione del parametro `refreshNow` L'agente Secrets Manager utilizza una cache in memoria per archiviare i valori segreti, che aggiorna periodicamente. Per impostazione predefinita, questo aggiornamento si verifica quando si richiede un segreto dopo la scadenza del Time to Live (TTL), in genere ogni 300 secondi. Tuttavia, questo approccio a volte può portare a valori segreti obsoleti, specialmente se un segreto ruota prima della scadenza della voce della cache. Per ovviare a questa limitazione, l'agente Secrets Manager supporta un parametro chiamato `refreshNow` nell'URL. È possibile utilizzare questo parametro per forzare l'aggiornamento immediato del valore di un segreto, aggirando la cache e assicurandosi di disporre della maggior parte delle up-to-date informazioni. **Comportamento predefinito (senza) `refreshNow`** + Utilizza i valori memorizzati nella cache fino alla scadenza del TTL + Aggiorna i segreti solo dopo TTL (impostazione predefinita: 300 secondi) + Può restituire valori obsoleti se i segreti ruotano prima della scadenza della cache **Comportamento con `refreshNow=true`** + Ignora completamente la cache + Recupera l'ultimo valore segreto direttamente da Secrets Manager + Aggiorna la cache con il nuovo valore e reimposta il TTL + Ti assicura di ottenere sempre il valore segreto più recente ### Aggiornamento forzato di un valore segreto **Importante** Il valore predefinito di `refreshNow` è `false`. Se impostato su`true`, sovrascrive il TTL specificato nel file di configurazione di Secrets Manager Agent ed effettua una chiamata API a Secrets Manager. ------ #### [ curl ] **Example Esempio: aggiornamento forzato di un segreto utilizzando curl** Il seguente esempio curl mostra come forzare l'agente Secrets Manager ad aggiornare il segreto. L'esempio si basa sulla presenza dell'SSRF in un file, che è dove viene memorizzato dallo script di installazione. ``` 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 Esempio: aggiornamento forzato di un segreto usando Python** Il seguente esempio in Python mostra come ottenere un segreto dall'agente Secrets Manager. L'esempio si basa sulla presenza dell'SSRF in un file, che è dove viene memorizzato dallo script di installazione. ``` 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}") ``` ------ ## Configurazione dell'agente Secrets Manager Per modificare la configurazione dell'agente Secrets Manager, crea un file di configurazione [TOML](https://toml.io/en/), quindi chiama. `./aws_secretsmanager_agent --config config.toml`Opzioni di configurazione **`log_level`** Il livello di dettaglio riportato nei log per l'agente Secrets Manager: DEBUG, INFO, WARN, ERROR o NONE. L'impostazione predefinita è INFO. **`log_to_file`** Se accedere a un file o a stdout/stderr: o. `true` `false` Il valore predefinito è `true`. **`http_port`** La porta per il server HTTP locale, nell'intervallo da 1024 a 65535. L'impostazione predefinita è 2773. **`region`** La AWS regione da utilizzare per le richieste. Se non viene specificata alcuna regione, l'agente Secrets Manager determina la regione dall'SDK. Per ulteriori informazioni, consulta [Specificare le credenziali e la regione predefinita nella](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html) Guida per sviluppatori *AWS SDK for Rust*. **`ttl_seconds`** Il TTL in secondi per gli elementi memorizzati nella cache, compreso tra 0 e 3600. L'impostazione predefinita è 300. 0 indica che non è presente alcuna memorizzazione nella cache. **`cache_size`** Il numero massimo di segreti che possono essere archiviati nella cache, compreso tra 1 e 1000. Il valore predefinito è 1000. **`ssrf_headers`** Un elenco di nomi di intestazione che l'agente Secrets Manager controlla per il token SSRF. L'impostazione predefinita è «X-Aws-Parameters-Secrets-Token,». X-Vault-Token **`ssrf_env_variables`** Un elenco di nomi di variabili di ambiente che l'agente Secrets Manager controlla in ordine sequenziale per il token SSRF. La variabile di ambiente può contenere il token o un riferimento al file del token come in:. `AWS_TOKEN=file:///var/run/awssmatoken` L'impostazione predefinita è "AWS\$1TOKEN, AWS\$1SESSION \$1TOKEN, AWS\$1CONTAINER \$1AUTHORIZATION\$1TOKEN». **`path_prefix`** Il prefisso URI utilizzato per determinare se la richiesta è una richiesta basata sul percorso. L'impostazione predefinita è «/v1/». **`max_conn`** Il numero massimo di connessioni dai client HTTP consentito dall'agente Secrets Manager, compreso tra 1 e 1000. Il valore predefinito è 800. ## Funzionalità opzionali L'agente Secrets Manager può essere creato con funzionalità opzionali passando il `--features` flag a`cargo build`. Le funzionalità disponibili sono:Caratteristiche di compilazione **`prefer-post-quantum`** Crea `X25519MLKEM768` l'algoritmo di scambio di chiavi con la massima priorità. Altrimenti, è disponibile ma non ha la massima priorità. `X25519MLKEM768`è un algoritmo ibrido di scambio di post-quantum-secure chiavi. **`fips`** Limita le suite di crittografia utilizzate dall'agente ai soli codici approvati dalla FIPS. ## Registrazione dei log **Registrazione locale** L'agente Secrets Manager registra gli errori localmente nel file `logs/secrets_manager_agent.log` o su stdout/stderr a seconda della variabile di configurazione. `log_to_file` Quando l'applicazione chiama l'agente Secrets Manager per ottenere un segreto, tali chiamate vengono visualizzate nel registro locale. Non compaiono nei CloudTrail log. **Rotazione del registro** L'agente Secrets Manager crea un nuovo file di registro quando il file raggiunge i 10 MB e memorizza fino a cinque file di registro in totale. **AWS registrazione del servizio** Il registro non viene inviato a Secrets Manager CloudTrail, o CloudWatch. Le richieste di ottenere segreti dall'agente Secrets Manager non vengono visualizzate in questi registri. Quando l'agente Secrets Manager effettua una chiamata a Secrets Manager per ottenere un segreto, tale chiamata viene registrata CloudTrail con una stringa agente utente contenente`aws-secrets-manager-agent`. È possibile configurare le opzioni di registrazione in. [Configurazione dell'agente Secrets Manager](#secrets-manager-agent-config) ## Considerazioni relative alla sicurezza **Dominio di fiducia** Per un'architettura ad agenti, il dominio di fiducia è il luogo in cui sono accessibili l'endpoint dell'agente e il token SSRF, che di solito è l'intero host. Il dominio di fiducia per l'agente Secrets Manager deve corrispondere al dominio in cui sono disponibili le credenziali di Secrets Manager per mantenere lo stesso livello di sicurezza. Ad esempio, su Amazon EC2 il dominio di fiducia per l'agente Secrets Manager sarebbe lo stesso del dominio delle credenziali quando si utilizzano i ruoli per Amazon EC2. **Importante** Le applicazioni attente alla sicurezza che non utilizzano già una soluzione agente con le credenziali di Secrets Manager bloccate sull'applicazione dovrebbero prendere in considerazione l'utilizzo delle soluzioni specifiche del linguaggio o di memorizzazione AWS SDKs nella cache. [Per ulteriori informazioni, consulta Get secrets.](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html)