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à.
# Ottieni segreti da Gestione dei segreti AWS
Secrets Manager genera una voce di CloudTrail registro quando si recupera un segreto. Per ulteriori informazioni, consulta [Registra Gestione dei segreti AWS gli eventi con AWS CloudTrail](monitoring-cloudtrail.md).
**Topics**
+ [Java](retrieving-secrets-java.md)
+ [Python](retrieving-secrets-python.md)
+ [.NET](retrieving-secrets-net.md)
+ [Go](retrieving-secrets-go.md)
+ [Rust](retrieving-secrets-rust.md)
+ [Amazon EKS](integrate_eks.md)
+ [AWS Lambda](retrieving-secrets_lambda.md)
+ [Agente Secrets Manager](secrets-manager-agent.md)
+ [C\$1\$1](retrieving-secrets-cpp.md)
+ [JavaScript](retrieving-secrets-javascript.md)
+ [Kotlin](retrieving-secrets-kotlin.md)
+ [PHP](retrieving-secrets-php.md)
+ [Ruby](retrieving-secrets-ruby.md)
+ [AWS CLI](retrieving-secrets_cli.md)
+ [AWS console](retrieving-secrets-console.md)
+ [AWS Batch](integrating_BATCH.md)
+ [CloudFormation](cfn-example_reference-secret.md)
+ [GitHub lavori](retrieving-secrets_github.md)
+ [GitLab](integrating_gitlab.md)
+ [AWS IoT Greengrass](integrating-greengrass.md)
+ [Parameter Store](integrating_parameterstore.md)
# Ottieni un valore segreto di Secrets Manager usando Java
Nelle applicazioni, puoi recuperare i tuoi segreti chiamando `GetSecretValue` o `BatchGetSecretValue` in uno qualsiasi dei AWS SDKs. Tuttavia, ti consigliamo di memorizzare nella cache i valori del segreto utilizzando la caching lato client. Memorizzare i segreti nella cache migliora la velocità e riduce i costi.
Per connettersi a un database utilizzando le credenziali di un segreto, è possibile utilizzare i driver Secrets Manager SQL Connection, che racchiudono il driver JDBC di base. Questa soluzione utilizza anche la memorizzazione nella cache lato client, in modo da ridurre i costi di chiamata a Secrets Manager. APIs
**Topics**
+ [Ottieni un valore segreto di Secrets Manager utilizzando Java con memorizzazione nella cache lato client](retrieving-secrets_cache-java.md)
+ [Connect a un database SQL utilizzando JDBC con credenziali segrete Gestione dei segreti AWS](retrieving-secrets_jdbc.md)
+ [Ottieni un valore segreto di Secrets Manager utilizzando Java AWS SDK](retrieving-secrets-java-sdk.md)
# Ottieni un valore segreto di Secrets Manager utilizzando Java con memorizzazione nella cache lato client
Quando si recupera un segreto, è possibile utilizzare il componente di caching basato su Java di Secrets Manager per memorizzarlo nella cache per un uso futuro. Il recupero di un segreto memorizzato nella cache è più veloce rispetto al recupero da Secrets Manager. Poiché la chiamata a Secrets Manager comporta un costo APIs, l'utilizzo di una cache può ridurre i costi. Per tutti i modi in cui puoi recuperare i segreti, vedi [Ottieni segreti](retrieving-secrets.md).
La policy della cache è Least Recently Used (LRU), quindi quando la cache deve eliminare un segreto, elimina il segreto usato meno di recente. Di default, la cache aggiorna i segreti ogni ora. È possibile configurare [la frequenza con cui il segreto viene aggiornato](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md#retrieving-secrets_cache-java-ref_SecretCacheConfiguration_methods-getCacheItemTTL) nella cache ed è possibile [collegarsi al recupero del segreto](retrieving-secrets_cache-java-ref_SecretCacheHook.md) per aggiungere altre funzionalità.
La cache non impone la rimozione di oggetti inutili (garbage collection) una volta liberati i riferimenti alla cache. L'implementazione della cache non include l'invalidazione della cache. L'implementazione della cache è incentrata sulla cache stessa e non è rafforzata o focalizzata sulla sicurezza. Se hai bisogno di un livello di sicurezza aggiuntivo, come la crittografia degli elementi nella cache, usa le interfacce e i metodi astratti forniti.
Per usare il componente, devi disporre dei seguenti elementi:
+ Ambiente di sviluppo Java 8 o versioni successive. Consulta [Java SE Downloads](https://www.oracle.com/technetwork/java/javase/downloads/index.html) sul sito Web di Oracle.
Per scaricare il codice sorgente, vedete [Secrets Manager, componente client di caching basato su Java](https://github.com/aws/aws-secretsmanager-caching-java) su. GitHub
Per aggiungere il componente al progetto, nel file Maven pom.xml, includi la seguente dipendenza. Per ulteriori informazioni su Maven, consulta la [Guida alle operazioni di base](https://maven.apache.org/guides/getting-started/index.html) sul sito Web Apache Maven Project.
```
com.amazonaws.secretsmanager
aws-secretsmanager-caching-java
1.0.2
```
**Autorizzazioni richieste:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Per ulteriori informazioni, consulta [Riferimento per le autorizzazioni](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md)
+ [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md)
+ [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md)
**Example Recupero di un segreto**
L'esempio di codice riportato di seguito mostra una funzione Lambda che recupera una stringa del segreto. Segue la [best practice](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) di creare un'istanza della cache al di fuori del gestore della funzione quindi non continua a chiamare l'API se si chiama nuovamente la funzione Lambda.
```
package com.amazonaws.secretsmanager.caching.examples;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.secretsmanager.caching.SecretCache;
public class SampleClass implements RequestHandler {
private final SecretCache cache = new SecretCache();
@Override public String handleRequest(String secretId, Context context) {
final String secret = cache.getSecretString(secretId);
// Use the secret, return success;
}
}
```
# SecretCache
Una cache in memoria per i segreti richiesti da Secrets Manager. Si usa [getSecretString](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretString) o [getSecretBinary](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretBinary) per recuperare un segreto dalla cache. È possibile configurare le impostazioni della cache specificando un oggetto [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md) nel costruttore.
Per ulteriori informazioni, inclusi esempi, consulta [Ottieni un valore segreto di Secrets Manager utilizzando Java con memorizzazione nella cache lato client](retrieving-secrets_cache-java.md).
## Costruttori
`public SecretCache()`
Costruttore di default per un oggetto `SecretCache`.
`public SecretCache(AWSSecretsManagerClientBuilder builder)`
Costruisce una nuova cache utilizzando un client di Secrets Manager creato utilizzando l'[https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClientBuilder.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClientBuilder.html) fornito. Utilizzate questo costruttore per personalizzare il client Secrets Manager, ad esempio per utilizzare una regione o un endpoint specifici.
`public SecretCache(AWSSecretsManager client)`
Costruisce una nuova cache del segreto utilizzando l'[https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) fornito. Utilizzate questo costruttore per personalizzare il client Secrets Manager, ad esempio per utilizzare una regione o un endpoint specifici.
`public SecretCache(SecretCacheConfiguration config)`
Costruisce una nuova cache del segreto utilizzando il `SecretCacheConfiguration` fornito.
## Metodi
### getSecretString
`public String getSecretString(final String secretId)`
Recupera un segreto stringa da Secrets Manager. Restituisce una [https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true).
### getSecretBinary
`public ByteBuffer getSecretBinary(final String secretId)`
Recupera un segreto binario da Secrets Manager. Restituisce un [https://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html](https://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html).
### refreshNow
`public boolean refreshNow(final String secretId) throws InterruptedException`
Forza l'aggiornamento della cache. Restituisce `true` se l'aggiornamento è stato completato senza errori, altrimenti `false`.
### close
`public void close()`
Chiude la cache.
# SecretCacheConfiguration
Opzioni di configurazione della cache per una [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md), ad esempio dimensione massima della cache e durata (TTL) per i segreti memorizzati nella cache.
## Costruttore
`public SecretCacheConfiguration`
Costruttore di default per un oggetto `SecretCacheConfiguration`.
## Metodi
### getClient
`public AWSSecretsManager getClient()`
Restituisce l'[https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) da cui la cache recupera segreti.
### setClient
`public void setClient(AWSSecretsManager client)`
Restituisce il client [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) da cui la cache recupera segreti.
### getCacheHook
`public SecretCacheHook getCacheHook()`
Restituisce l'interfaccia [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) utilizzata per collegarsi agli aggiornamenti della cache.
### setCacheHook
`public void setCacheHook(SecretCacheHook cacheHook)`
Imposta l'interfaccia [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) utilizzata per collegarsi agli aggiornamenti della cache.
### getMaxCacheDimensioni
`public int getMaxCacheSize()`
Restituisce la dimensione massima della cache. Il valore di default è 1024 segreti.
### setMaxCacheDimensioni
`public void setMaxCacheSize(int maxCacheSize)`
Imposta la dimensione massima della cache. Il valore di default è 1024 segreti.
### getCacheItemTTL
`public long getCacheItemTTL()`
Restituisce il TTL in millisecondi per gli elementi memorizzati nella cache. Quando un segreto memorizzato nella cache supera questo TTL, la cache recupera una nuova copia del segreto dal [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html). Il valore predefinito è 1 ora in millisecondi.
La cache aggiorna il segreto in modo sincrono quando viene richiesto il segreto dopo il TTL. Se l'aggiornamento sincrono ha esito negativo, la cache restituisce il segreto non aggiornato.
### setCacheItemTTL
`public void setCacheItemTTL(long cacheItemTTL)`
Restituisce il TTL in millisecondi per gli elementi memorizzati nella cache. Quando un segreto memorizzato nella cache supera questo TTL, la cache recupera una nuova copia del segreto dal [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html). Il valore predefinito è 1 ora in millisecondi.
### getVersionStage
`public String getVersionStage()`
Restituisce la versione dei segreti che si desidera memorizzare nella cache. Per ulteriori informazioni, consulta [Versioni del segreto](whats-in-a-secret.md#term_version). Il valore predefinito è ` "AWSCURRENT"`.
### setVersionStage
`public void setVersionStage(String versionStage)`
Imposta la versione dei segreti che si desidera memorizzare nella cache. Per ulteriori informazioni, consulta [Versioni del segreto](whats-in-a-secret.md#term_version). Il valore predefinito è `"AWSCURRENT"`.
### SecretCacheConfiguration Con Client
`public SecretCacheConfiguration withClient(AWSSecretsManager client)`
Imposta il [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html) da cui recuperare segreti. Restituisce l'oggetto `SecretCacheConfiguration` aggiornato con la nuova impostazione.
### SecretCacheConfiguration withCacheHook
`public SecretCacheConfiguration withCacheHook(SecretCacheHook cacheHook)`
Imposta l'interfaccia utilizzata per collegare la cache in memoria. Restituisce l'oggetto `SecretCacheConfiguration` aggiornato con la nuova impostazione.
### SecretCacheConfiguration withMaxCacheDimensioni
`public SecretCacheConfiguration withMaxCacheSize(int maxCacheSize)`
Imposta la dimensione massima della cache. Restituisce l'oggetto `SecretCacheConfiguration` aggiornato con la nuova impostazione.
### SecretCacheConfiguration withCacheItemTTL
`public SecretCacheConfiguration withCacheItemTTL(long cacheItemTTL)`
Restituisce il TTL in millisecondi per gli elementi memorizzati nella cache. Quando un segreto memorizzato nella cache supera questo TTL, la cache recupera una nuova copia del segreto dal [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/AWSSecretsManagerClient.html). Il valore predefinito è 1 ora in millisecondi. Restituisce l'oggetto `SecretCacheConfiguration` aggiornato con la nuova impostazione.
### SecretCacheConfiguration withVersionStage
`public SecretCacheConfiguration withVersionStage(String versionStage)`
Imposta la versione dei segreti che si desidera memorizzare nella cache. Per ulteriori informazioni, consulta [Versioni del segreto](whats-in-a-secret.md#term_version). Restituisce l'oggetto `SecretCacheConfiguration` aggiornato con la nuova impostazione.
# SecretCacheHook
Un'interfaccia per collegarsi a una [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md) per eseguire operazioni sui segreti memorizzati al suo interno.
## put
`Object put(final Object o)`
Prepara l'oggetto per la memorizzazione nella cache.
Restituisce l'oggetto da memorizzare nella cache.
## get
`Object get(final Object cachedObject)`
Deriva l'oggetto dall'oggetto memorizzato nella cache.
Restituisce l'oggetto da restituire dalla cache
# Connect a un database SQL utilizzando JDBC con credenziali segrete Gestione dei segreti AWS
Nelle applicazioni Java, è possibile utilizzare i driver Secrets Manager SQL Connection per connettersi ai database MySQL, PostgreSQL, MSSQLServer Oracle, Db2 e Redshift utilizzando le credenziali archiviate in Secrets Manager. Ogni driver esegue il wrapping del driver JDBC di base per consentire l'utilizzo delle chiamate JDBC per accedere al database. Tuttavia, invece di specificare un nome utente e una password per la connessione, si fornisce l'ID di un segreto. Il driver chiama Secrets Manager per recuperare il valore del segreto, quindi utilizza le credenziali nel segreto per connettersi al database. Il driver inoltre memorizza le credenziali nella cache utilizzando la [libreria di caching lato client Java](retrieving-secrets_cache-java.md), in modo che per le connessioni future non sia necessaria una chiamata a Secrets Manager. Per impostazione predefinita, la cache viene aggiornata ogni ora e anche quando un segreto viene ruotato. Per configurare la cache, consulta [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md).
È possibile scaricare il codice sorgente da. [GitHub](https://github.com/aws/aws-secretsmanager-jdbc )
Per utilizzare i driver di connessione SQL di Secrets Manager:
+ L'applicazione deve essere in Java 8 o versioni successive.
+ Il segreto deve essere uno fra i seguenti:
+ Un [segreto di database nella struttura JSON prevista](reference_secret_json_structure.md). Per verificare il formato, nella console di Secrets Manager, visualizza il tuo segreto e seleziona **Retrieve secret value** (Recupera valore segreto). In alternativa AWS CLI, nella chiamata [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html).
+ Un [segreto gestito](integrating_how-services-use-secrets_RDS.md) da Amazon RDS. Per questo tipo di segreto, quando si stabilisce la connessione è necessario specificare un endpoint e una porta.
+ Un segreto [gestito](integrating_how-services-use-secrets_RS.md) da Amazon Redshift. Per questo tipo di segreto, quando si stabilisce la connessione è necessario specificare un endpoint e una porta.
Se il database viene replicato in altre regioni, per connettersi a un database di replica in una regione differente, è necessario specificare l'endpoint e la porta della regione al momento della creazione della connessione. Puoi memorizzare le informazioni di connessione regionali nel segreto come key/value coppie aggiuntive, nei parametri SSM Parameter Store o nella configurazione del codice.
Per aggiungere il driver al progetto, nel file di build Maven `pom.xml`, aggiungi la seguente dipendenza per il driver. Per ulteriori informazioni, consulta [Secrets Manager SQL Connection Library](https://search.maven.org/artifact/com.amazonaws.secretsmanager/aws-secretsmanager-jdbc) sul sito Web di Maven Central Repository.
```
com.amazonaws.secretsmanager
aws-secretsmanager-jdbc
1.0.12
```
Il driver utilizza la [https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html). Se esegui il driver su Amazon EKS, potrebbe raccogliere le credenziali del nodo su cui è in esecuzione anziché il ruolo dell'account di servizio. Per risolvere questo problema, aggiungi la versione 1 di `com.amazonaws:aws-java-sdk-sts` al tuo file di progetto Gradle o Maven come dipendenza.
Per impostare un URL di endpoint AWS PrivateLink DNS e una regione nel file: `secretsmanager.properties`
```
drivers.vpcEndpointUrl = endpoint URL
drivers.vpcEndpointRegion = endpoint region
```
Per sovrascrivere la regione primaria, imposta la variabile d'ambiente `AWS_SECRET_JDBC_REGION` o apporta la seguente modifica al file `secretsmanager.properties`:
```
drivers.region = region
```
**Autorizzazioni richieste:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Per ulteriori informazioni, consulta [Riferimento per le autorizzazioni](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [Stabilire una connessione a un database](#retrieving-secrets_jdbc_example)
+ [Impostazione di una connessione specificando l'endpoint e la porta](#retrieving-secrets_jdbc_example_replica)
+ [Utilizzare il pooling di connessioni c3p0 per stabilire una connessione](#retrieving-secrets_jdbc_example_c3po)
+ [Utilizzo del pooling di connessioni c3p0 per stabilire una connessione specificando l'endpoint e la porta](#retrieving-secrets_jdbc_example_c3p0_replica)
## Stabilire una connessione a un database
Nell'esempio seguente viene illustrato come stabilire una connessione a un database utilizzando le credenziali e le informazioni di connessione in un segreto. Una volta acquisita la connessione, puoi utilizzare le chiamate JDBC per accedere al database. Per ulteriori informazioni, consulta [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sul sito Web della documentazione Java.
------
#### [ MySQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ PostgreSQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Oracle ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ MSSQLServer ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Db2 ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Redshift ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver" ).newInstance();
// Retrieve the connection info from the secret using the secret ARN
String URL = "secretId";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
## Impostazione di una connessione specificando l'endpoint e la porta
Nell'esempio seguente viene illustrato come stabilire una connessione a un database utilizzando le credenziali in un segreto con un endpoint e una porta specificati dall'utente.
[I segreti gestiti da Amazon RDS](integrating_how-services-use-secrets_RDS.md) non includono l'endpoint e la porta del database. Per connettersi a un database utilizzando le credenziali master in un segreto gestito da Amazon RDS, è necessario specificarle nel codice.
[I segreti replicati in altre Regioni](replicate-secrets.md) possono migliorare la latenza per la connessione al database regionale, ma non contengono informazioni di connessione diverse dal segreto di origine. Ogni replica è una copia del segreto di origine. Per memorizzare le informazioni di connessione regionali in modalità segreta, aggiungi altre key/value coppie per l'endpoint e le informazioni sulla porta per le regioni.
Una volta acquisita la connessione, puoi utilizzare le chiamate JDBC per accedere al database. Per ulteriori informazioni, consulta [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sul sito Web della documentazione Java.
------
#### [ MySQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:mysql://example.com:3306";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ PostgreSQL ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:postgresql://example.com:5432/database";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Oracle ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:oracle:thin:@example.com:1521/ORCL";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ MSSQLServer ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:sqlserver://example.com:1433";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Db2 ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.com.rproxy.goskope.com.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:db2://example.com:50000";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
#### [ Redshift ]
```
// Load the JDBC driver
Class.forName( "com.amazonaws.com.rproxy.goskope.com.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver" ).newInstance();
// Set the endpoint and port. You can also retrieve it from a key/value pair in the secret.
String URL = "jdbc-secretsmanager:redshift://example.com:5439";
// Populate the user property with the secret ARN to retrieve user and password from the secret
Properties info = new Properties( );
info.put( "user", "secretId" );
// Establish the connection
conn = DriverManager.getConnection(URL, info);
```
------
## Utilizzare il pooling di connessioni c3p0 per stabilire una connessione
Nell'esempio seguente viene illustrato come stabilire un pool di connessioni con un file `c3p0.properties` che utilizza il driver per recuperare le credenziali e le informazioni sulla connessione dal segreto. Per `user` e `jdbcUrl`, inserisci l'ID segreto per configurare il pool di connessioni. Puoi quindi recuperare le connessioni dal pool e utilizzarle come qualsiasi altra connessione al database. Per ulteriori informazioni, consulta [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sul sito Web della documentazione Java.
Per ulteriori informazioni su c3p0, consulta [c3p0](https://www.mchange.com/projects/c3p0/) sul sito Web Machinery For Change.
------
#### [ MySQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver
c3p0.jdbcUrl=secretId
```
------
#### [ PostgreSQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver
c3p0.jdbcUrl=secretId
```
------
#### [ Oracle ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver
c3p0.jdbcUrl=secretId
```
------
#### [ MSSQLServer ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver
c3p0.jdbcUrl=secretId
```
------
#### [ Db2 ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver
c3p0.jdbcUrl=secretId
```
------
#### [ Redshift ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver
c3p0.jdbcUrl=secretId
```
------
## Utilizzo del pooling di connessioni c3p0 per stabilire una connessione specificando l'endpoint e la porta
L'esempio seguente mostra come stabilire un pool di connessioni con un `c3p0.properties` file che utilizza il driver per recuperare le credenziali in un segreto con un endpoint e una porta specificati dall'utente. Puoi quindi recuperare le connessioni dal pool e utilizzarle come qualsiasi altra connessione al database. Per ulteriori informazioni, consulta [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sul sito Web della documentazione Java.
[I segreti gestiti da Amazon RDS](integrating_how-services-use-secrets_RDS.md) non includono l'endpoint e la porta del database. Per connettersi a un database utilizzando le credenziali master in un segreto gestito da Amazon RDS, è necessario specificarle nel codice.
[I segreti replicati in altre Regioni](replicate-secrets.md) possono migliorare la latenza per la connessione al database regionale, ma non contengono informazioni di connessione diverse dal segreto di origine. Ogni replica è una copia del segreto di origine. Per memorizzare le informazioni di connessione regionali nel segreto, aggiungi altre key/value coppie per l'endpoint e le informazioni sulla porta per le regioni.
------
#### [ MySQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMySQLDriver
c3p0.jdbcUrl=jdbc-secretsmanager:mysql://example.com:3306
```
------
#### [ PostgreSQL ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerPostgreSQLDriver
c3p0.jdbcUrl=jdbc-secretsmanager:postgresql://example.com:5432/database
```
------
#### [ Oracle ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerOracleDriver
c3p0.jdbcUrl=jdbc-secretsmanager:oracle:thin:@example.com:1521/ORCL
```
------
#### [ MSSQLServer ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerMSSQLServerDriver
c3p0.jdbcUrl=jdbc-secretsmanager:sqlserver://example.com:1433
```
------
#### [ Db2 ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerDb2Driver
c3p0.jdbcUrl=jdbc-secretsmanager:db2://example.com:50000
```
------
#### [ Redshift ]
```
c3p0.user=secretId
c3p0.driverClass=com.amazonaws.secretsmanager.sql.AWSSecretsManagerRedshiftDriver
c3p0.jdbcUrl=jdbc-secretsmanager:redshift://example.com:5439
```
------
# Ottieni un valore segreto di Secrets Manager utilizzando Java AWS SDK
Nelle applicazioni, puoi recuperare i tuoi segreti chiamando `GetSecretValue` o `BatchGetSecretValue` in uno qualsiasi dei. AWS SDKs Tuttavia, ti consigliamo di memorizzare nella cache i valori del segreto utilizzando la caching lato client. Memorizzare i segreti nella cache migliora la velocità e riduce i costi.
+ Se memorizzi le credenziali del database nel segreto, utilizza i [driver di connessione SQL di Secrets Manager](retrieving-secrets_jdbc.md) per eseguire la connessione a un database utilizzando le credenziali nel segreto.
+ Per altri tipi di segreti, usa il [componente di caching basato su Java Secrets Manager](retrieving-secrets_cache-java.md) o chiama l'SDK direttamente con o. [https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/model/GetSecretValueResult.html](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/secretsmanager/model/GetSecretValueResult.html)
Gli esempi di codice seguenti mostrano come utilizzare `GetSecretValue`.
**Autorizzazioni richieste:**`secretsmanager:GetSecretValue`
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.secretsmanager.SecretsManagerClient;
import software.amazon.awssdk.services.secretsmanager.model.GetSecretValueRequest;
import software.amazon.awssdk.services.secretsmanager.model.GetSecretValueResponse;
import software.amazon.awssdk.services.secretsmanager.model.SecretsManagerException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*
* We recommend that you cache your secret values by using client-side caching.
*
* Caching secrets improves speed and reduces your costs. For more information,
* see the following documentation topic:
*
* https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html
*/
public class GetSecretValue {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
secretName - The name of the secret (for example, tutorials/MyFirstSecret).\s
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String secretName = args[0];
Region region = Region.US_EAST_1;
SecretsManagerClient secretsClient = SecretsManagerClient.builder()
.region(region)
.build();
getValue(secretsClient, secretName);
secretsClient.close();
}
public static void getValue(SecretsManagerClient secretsClient, String secretName) {
try {
GetSecretValueRequest valueRequest = GetSecretValueRequest.builder()
.secretId(secretName)
.build();
GetSecretValueResponse valueResponse = secretsClient.getSecretValue(valueRequest);
String secret = valueResponse.secretString();
System.out.println(secret);
} catch (SecretsManagerException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
# Ottieni un valore segreto di Secrets Manager usando Python
Nelle applicazioni, puoi recuperare i tuoi segreti chiamando `GetSecretValue` o `BatchGetSecretValue` in uno qualsiasi dei. AWS SDKs Tuttavia, ti consigliamo di memorizzare nella cache i valori del segreto utilizzando la caching lato client. Memorizzare i segreti nella cache migliora la velocità e riduce i costi.
**Topics**
+ [Ottieni un valore segreto di Secrets Manager usando Python con caching lato client](retrieving-secrets_cache-python.md)
+ [Ottieni un valore segreto di Secrets Manager usando l'SDK Python AWS](retrieving-secrets-python-sdk.md)
+ [Ottieni un batch di valori segreti di Secrets Manager usando Python SDK AWS](retrieving-secrets-python-batch.md)
# Ottieni un valore segreto di Secrets Manager usando Python con caching lato client
Quando si recupera un segreto, è possibile utilizzare il componente di caching basato su Python di Secrets Manager per memorizzarlo nella cache per un uso futuro. Il recupero di un segreto memorizzato nella cache è più veloce rispetto al recupero da Secrets Manager. Poiché la chiamata a Secrets Manager comporta un costo APIs, l'utilizzo di una cache può ridurre i costi. Per tutti i modi in cui puoi recuperare i segreti, vedi [Ottieni segreti](retrieving-secrets.md).
La policy della cache è Least Recently Used (LRU), quindi quando la cache deve eliminare un segreto, elimina il segreto usato meno di recente. Di default, la cache aggiorna i segreti ogni ora. È possibile configurare [la frequenza con cui il segreto viene aggiornato](retrieving-secrets_cache-ref-secretcacheconfig.md) nella cache ed è possibile [collegarsi al recupero del segreto](retrieving-secrets_cache-ref-secretcachehook.md) per aggiungere altre funzionalità.
La cache non impone la rimozione di oggetti inutili (garbage collection) una volta liberati i riferimenti alla cache. L'implementazione della cache non include l'invalidazione della cache. L'implementazione della cache è incentrata sulla cache stessa e non è rafforzata o focalizzata sulla sicurezza. Se hai bisogno di un livello di sicurezza aggiuntivo, come la crittografia degli elementi nella cache, usa le interfacce e i metodi astratti forniti.
Per usare il componente, devi disporre dei seguenti elementi:
+ Python 3.6 o versioni successive.
+ botocore 1.12 o versioni successive. Consulta [AWS SDK for Python](https://aws.amazon.com/sdk-for-python/) e [Botocore](https://botocore.amazonaws.com/v1/documentation/api/latest/index.html).
+ setuptools\$1scm 3.2 o versioni successive. Vedi [https://pypi. org/project/setuptools-scm/](https://pypi.org/project/setuptools-scm/).
Per scaricare il codice sorgente, consulta il componente client di [caching basato su Python di Secrets Manager](https://github.com/aws/aws-secretsmanager-caching-python ) su. GitHub
Per installare il componente, utilizza il comando seguente.
```
$ pip install aws-secretsmanager-caching
```
**Autorizzazioni richieste:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Per ulteriori informazioni, consulta [Riferimento per le autorizzazioni](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [SecretCache](retrieving-secrets_cache-ref-secretcache.md)
+ [SecretCacheConfig](retrieving-secrets_cache-ref-secretcacheconfig.md)
+ [SecretCacheHook](retrieving-secrets_cache-ref-secretcachehook.md)
+ [@InjectSecretString](retrieving-secrets_cache-decor-string.md)
+ [@InjectKeywordedSecretString](retrieving-secrets_cache-decor-keyword.md)
**Example Recupero di un segreto**
L'esempio seguente mostra come ottenere il valore segreto per un segreto denominato. *mysecret*
```
import botocore
import botocore.session
from aws_secretsmanager_caching import SecretCache, SecretCacheConfig
client = botocore.session.get_session().create_client('secretsmanager')
cache_config = SecretCacheConfig()
cache = SecretCache( config = cache_config, client = client)
secret = cache.get_secret_string('mysecret')
```
# SecretCache
Una cache in memoria per i segreti recuperati da Secrets Manager. Si usa [get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string) o [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary) per recuperare un segreto dalla cache. È possibile configurare le impostazioni della cache specificando un oggetto [SecretCacheConfig](retrieving-secrets_cache-ref-secretcacheconfig.md) nel costruttore.
Per ulteriori informazioni, inclusi esempi, consulta [Ottieni un valore segreto di Secrets Manager usando Python con caching lato client](retrieving-secrets_cache-python.md).
```
cache = SecretCache(
config = SecretCacheConfig,
client = [client](https://botocore.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html)
)
```
**Topics**
+ [get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string)
+ [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary)
## get\$1secret\$1string
Recupera il valore della stringa del segreto.
Sintassi della richiesta
```
response = cache.get_secret_string(
secret_id='string',
version_stage='string' )
```
Parameters
+ `secret_id`(*string*): [Obbligatorio] Il nome o l'ARN del segreto.
+ `version_stage`(*stringa*): La versione dei segreti che desideri recuperare. Per ulteriori informazioni, [consulta Versioni segrete](whats-in-a-secret.md). Il valore di default è 'AWSCURRENT'.
Tipo restituito
stringa
## get\$1secret\$1binary
Recupera il valore binario del segreto.
Sintassi della richiesta
```
response = cache.get_secret_binary(
secret_id='string',
version_stage='string'
)
```
Parameters
+ `secret_id`(*string*): [Obbligatorio] Il nome o l'ARN del segreto.
+ `version_stage`(*stringa*): La versione dei segreti che desideri recuperare. Per ulteriori informazioni, [consulta Versioni segrete](whats-in-a-secret.md). Il valore di default è 'AWSCURRENT'.
Tipo restituito
Stringa [con codifica Base64](https://tools.ietf.org/html/rfc4648#section-4)
# SecretCacheConfig
Opzioni di configurazione della cache per una [SecretCache](retrieving-secrets_cache-ref-secretcache.md), ad esempio dimensione massima della cache e durata (TTL) per i segreti memorizzati nella cache.Parameters
`max_cache_size` (*int*)
La dimensione massima della cache. Il valore predefinito è `1024` segreti.
`exception_retry_delay_base` (*int*)
Il numero di secondi di attesa dopo aver riscontrato un'eccezione prima di riprovare la richiesta. Il valore predefinito è `1`.
`exception_retry_growth_factor` (*int*)pur
Il fattore di crescita da utilizzare per calcolare il tempo di attesa tra i tentativi di richieste non riuscite. Il valore predefinito è `2`.
`exception_retry_delay_max` (*int*)
Il numero massimo di secondi di attesa tra le richieste non riuscite. Il valore predefinito è `3600`.
`default_version_stage` (*str*)
Imposta la versione dei segreti che si desidera memorizzare nella cache. Per ulteriori informazioni, consulta [Versioni del segreto](whats-in-a-secret.md#term_version). Il valore predefinito è `'AWSCURRENT'`.
`secret_refresh_interval` (*int*)
Il numero di secondi da attendere tra gli aggiornamenti delle informazioni del segreto memorizzate nella cache. Il valore predefinito è `3600`.
`secret_cache_hook` (*SecretCacheHook*)
Un'implementazione della classe astratta di `SecretCacheHook`. Il valore predefinito è `None`.
# SecretCacheHook
Un'interfaccia per collegarsi a una [SecretCache](retrieving-secrets_cache-ref-secretcache.md) per eseguire operazioni sui segreti memorizzati al suo interno.
**Topics**
+ [put](#retrieving-secrets_cache-ref-secretcachehook_put)
+ [get](#retrieving-secrets_cache-ref-secretcachehook_get)
## put
Prepara l'oggetto per la memorizzazione nella cache.
Sintassi della richiesta
```
response = hook.put(
obj='secret_object'
)
```
Parameters
+ `obj` (*object*) -- [Obbligatorio] Il segreto o l'oggetto che contiene il segreto.
Tipo restituito
oggetto
## get
Deriva l'oggetto dall'oggetto memorizzato nella cache.
Sintassi della richiesta
```
response = hook.get(
obj='secret_object'
)
```
Parameters
+ `obj`(*oggetto*): [Obbligatorio] Il segreto o l'oggetto che contiene il segreto.
Tipo restituito
oggetto
# @InjectSecretString
Questo decoratore prevede una stringa identificativa del segreto e [SecretCache](retrieving-secrets_cache-ref-secretcache.md) come primo e secondo argomento. Il decoratore restituisce il valore della stringa del segreto. Il segreto deve contenere una stringa.
```
from aws_secretsmanager_caching import SecretCache
from aws_secretsmanager_caching import InjectKeywordedSecretString, InjectSecretString
cache = SecretCache()
@InjectSecretString ( 'mysecret' , cache )
def function_to_be_decorated( arg1, arg2, arg3):
```
# @InjectKeywordedSecretString
Questo decoratore prevede una stringa identificativa del segreto e [SecretCache](retrieving-secrets_cache-ref-secretcache.md) come primo e secondo argomento. Gli argomenti rimanenti mappano i parametri dalla funzione wrapping alle chiavi JSON nel segreto. Il segreto deve contenere una stringa nella struttura JSON.
Per un segreto che contiene questo JSON:
```
{
"username": "saanvi",
"password": "EXAMPLE-PASSWORD"
}
```
Gli esempi seguenti mostrano come estrarre i valori JSON per `username` e `password` dal segreto.
```
from aws_secretsmanager_caching import SecretCache
from aws_secretsmanager_caching import InjectKeywordedSecretString, InjectSecretString
cache = SecretCache()
@InjectKeywordedSecretString ( secret_id = 'mysecret' , cache = cache , func_username = 'username' , func_password = 'password' )
def function_to_be_decorated( func_username, func_password):
print( 'Do something with the func_username and func_password parameters')
```
# Ottieni un valore segreto di Secrets Manager usando l'SDK Python AWS
Nelle applicazioni, puoi recuperare i tuoi segreti chiamando `GetSecretValue` o `BatchGetSecretValue` in uno qualsiasi dei. AWS SDKs Tuttavia, ti consigliamo di memorizzare nella cache i valori del segreto utilizzando la caching lato client. Memorizzare i segreti nella cache migliora la velocità e riduce i costi.
Per le applicazioni Python, utilizza il [componente di caching basato su Python di Secrets Manager](retrieving-secrets_cache-python.md) o chiama direttamente l'SDK con [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/get_secret_value.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/get_secret_value.html) o [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/batch_get_secret_value.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager/client/batch_get_secret_value.html).
Gli esempi di codice seguenti mostrano come utilizzare `GetSecretValue`.
**Autorizzazioni richieste:**`secretsmanager:GetSecretValue`
```
"""
Purpose
Shows how to use the AWS SDK for Python (Boto3) with AWS
Secrets Manager to get a specific of secrets that match a
specified name
"""
import boto3
import logging
from get_secret_value import GetSecretWrapper
# Configure logging
logging.basicConfig(level=logging.INFO)
def run_scenario(secret_name):
"""
Retrieve a secret from AWS Secrets Manager.
:param secret_name: Name of the secret to retrieve.
:type secret_name: str
"""
try:
# Validate secret_name
if not secret_name:
raise ValueError("Secret name must be provided.")
# Retrieve the secret by name
client = boto3.client("secretsmanager")
wrapper = GetSecretWrapper(client)
secret = wrapper.get_secret(secret_name)
# Note: Secrets should not be logged.
return secret
except Exception as e:
logging.error(f"Error retrieving secret: {e}")
raise
class GetSecretWrapper:
def __init__(self, secretsmanager_client):
self.client = secretsmanager_client
def get_secret(self, secret_name):
"""
Retrieve individual secrets from AWS Secrets Manager using the get_secret_value API.
This function assumes the stack mentioned in the source code README has been successfully deployed.
This stack includes 7 secrets, all of which have names beginning with "mySecret".
:param secret_name: The name of the secret fetched.
:type secret_name: str
"""
try:
get_secret_value_response = self.client.get_secret_value(
SecretId=secret_name
)
logging.info("Secret retrieved successfully.")
return get_secret_value_response["SecretString"]
except self.client.exceptions.ResourceNotFoundException:
msg = f"The requested secret {secret_name} was not found."
logger.info(msg)
return msg
except Exception as e:
logger.error(f"An unknown error occurred: {str(e)}.")
raise
```
# Ottieni un batch di valori segreti di Secrets Manager usando Python SDK AWS
Il seguente esempio di codice mostra come ottenere un batch di valori segreti di Secrets Manager.
**Autorizzazioni richieste:**
+ `secretsmanager:BatchGetSecretValue`
+ `secretsmanager:GetSecretValue`autorizzazione per ogni segreto che desideri recuperare.
+ Se usi i filtri, devi avere anche `secretsmanager:ListSecrets`.
Per un esempio di policy delle autorizzazioni, consulta [Esempio: autorizzazione a recuperare un gruppo di valori segreti in un batch](auth-and-access_iam-policies.md#auth-and-access_examples_batch).
**Importante**
Se hai una policy VPCE che nega l'autorizzazione per recuperare un singolo segreto nel gruppo su cui stai agendo, `BatchGetSecretValue` non restituirà alcun valore segreto e restituirà un errore.
```
class BatchGetSecretsWrapper:
def __init__(self, secretsmanager_client):
self.client = secretsmanager_client
def batch_get_secrets(self, filter_name):
"""
Retrieve multiple secrets from AWS Secrets Manager using the batch_get_secret_value API.
This function assumes the stack mentioned in the source code README has been successfully deployed.
This stack includes 7 secrets, all of which have names beginning with "mySecret".
:param filter_name: The full or partial name of secrets to be fetched.
:type filter_name: str
"""
try:
secrets = []
response = self.client.batch_get_secret_value(
Filters=[{"Key": "name", "Values": [f"{filter_name}"]}]
)
for secret in response["SecretValues"]:
secrets.append(json.loads(secret["SecretString"]))
if secrets:
logger.info("Secrets retrieved successfully.")
else:
logger.info("Zero secrets returned without error.")
return secrets
except self.client.exceptions.ResourceNotFoundException:
msg = f"One or more requested secrets were not found with filter: {filter_name}"
logger.info(msg)
return msg
except Exception as e:
logger.error(f"An unknown error occurred:\n{str(e)}.")
raise
```
# Ottieni un valore segreto di Secrets Manager utilizzando .NET
Nelle applicazioni, puoi recuperare i tuoi segreti chiamando `GetSecretValue` o `BatchGetSecretValue` in uno qualsiasi dei AWS SDKs. Tuttavia, ti consigliamo di memorizzare nella cache i valori del segreto utilizzando la caching lato client. Memorizzare i segreti nella cache migliora la velocità e riduce i costi.
**Topics**
+ [Ottieni un valore segreto di Secrets Manager usando.NET con caching lato client](retrieving-secrets_cache-net.md)
+ [Ottieni un valore segreto di Secrets Manager utilizzando SDK per .NET](retrieving-secrets-net-sdk.md)
# Ottieni un valore segreto di Secrets Manager usando.NET con caching lato client
Quando si recupera un segreto, è possibile utilizzare il componente di caching basato su .NET di Secrets Manager per memorizzarlo nella cache per un uso futuro. Il recupero di un segreto memorizzato nella cache è più veloce rispetto al recupero da Secrets Manager. Poiché la chiamata a Secrets Manager comporta un costo APIs, l'utilizzo di una cache può ridurre i costi. Per tutti i modi in cui puoi recuperare i segreti, vedi [Ottieni segreti](retrieving-secrets.md).
La policy della cache è Least Recently Used (LRU), quindi quando la cache deve eliminare un segreto, elimina il segreto usato meno di recente. Di default, la cache aggiorna i segreti ogni ora. È possibile configurare [la frequenza con cui il segreto viene aggiornato](retrieving-secrets_cache-net-SecretCacheConfiguration.md#retrieving-secrets_cache-net-SecretCacheConfiguration-properties_CacheItemTTL) nella cache ed è possibile [collegarsi al recupero del segreto](retrieving-secrets_cache-net-ISecretCacheHook.md) per aggiungere altre funzionalità.
La cache non impone la rimozione di oggetti inutili (garbage collection) una volta liberati i riferimenti alla cache. L'implementazione della cache non include l'invalidazione della cache. L'implementazione della cache è incentrata sulla cache stessa e non è rafforzata o focalizzata sulla sicurezza. Se hai bisogno di un livello di sicurezza aggiuntivo, come la crittografia degli elementi nella cache, usa le interfacce e i metodi astratti forniti.
Per usare il componente, devi disporre dei seguenti elementi:
+ .NET Framework 4.6.2 o versioni successive o .NET Standard 2.0 o versioni successive. Consulta [Download .NET](https://dotnet.microsoft.com/en-us/download) sul sito Web di Microsoft .NET
+ L' AWS SDK per.NET. Per informazioni, consulta [AWS SDKs](asm_access.md#asm-sdks).
Per scaricare il codice sorgente, vedi [Caching client for .NET on](https://github.com/aws/aws-secretsmanager-caching-net ). GitHub
Per utilizzare la cache, creane prima un'istanza, quindi recupera il segreto usando `GetSecretString` o `GetSecretBinary`. Nei recuperi successivi, la cache restituisce la copia del segreto memorizzata nella cache.
**Recupero del pacchetto di caching**
+ Esegui una delle seguenti operazioni:
+ Nella directory del progetto, esegui il seguente comando della CLI .NET.
```
dotnet add package AWSSDK.SecretsManager.Caching --version 1.0.6
```
+ Aggiungi il seguente riferimento al pacchetto al tuo file `.csproj`.
```
```
**Autorizzazioni richieste:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Per ulteriori informazioni, consulta [Riferimento per le autorizzazioni](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md)
+ [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md)
+ [ISecretCacheHook](retrieving-secrets_cache-net-ISecretCacheHook.md)
**Example Recupero di un segreto**
Il seguente esempio di codice mostra un metodo che recupera un segreto denominato. *MySecret*
```
using Amazon.SecretsManager.Extensions.Caching;
namespace LambdaExample
{
public class CachingExample
{
private const string MySecretName ="MySecret";
private SecretsManagerCache cache = new SecretsManagerCache();
public async Task FunctionHandlerAsync(string input, ILambdaContext context)
{
string MySecret = await cache.GetSecretString(MySecretName);
// Use the secret, return success
}
}
}
```
**Example Configurazione della durata dell'aggiornamento della cache Time To Live (TTL)**
Il seguente esempio di codice mostra un metodo che recupera un segreto denominato *MySecret* e imposta la durata dell'aggiornamento della cache TTL su 24 ore.
```
using Amazon.SecretsManager.Extensions.Caching;
namespace LambdaExample
{
public class CachingExample
{
private const string MySecretName = "MySecret";
private static SecretCacheConfiguration cacheConfiguration = new SecretCacheConfiguration
{
CacheItemTTL = 86400000
};
private SecretsManagerCache cache = new SecretsManagerCache(cacheConfiguration);
public async Task FunctionHandlerAsync(string input, ILambdaContext context)
{
string mySecret = await cache.GetSecretString(MySecretName);
// Use the secret, return success
}
}
}
```
# SecretsManagerCache
Una cache in memoria per i segreti richiesti da Secrets Manager. Si usa [GetSecretString](#retrieving-secrets_cache-net-SecretsManagerCache-methods-GetSecretString) o [GetSecretBinary](#retrieving-secrets_cache-net-SecretsManagerCache-methods-GetSecretBinary) per recuperare un segreto dalla cache. È possibile configurare le impostazioni della cache specificando un oggetto [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) nel costruttore.
Per ulteriori informazioni, inclusi esempi, consulta [Ottieni un valore segreto di Secrets Manager usando.NET con caching lato client](retrieving-secrets_cache-net.md).
## Costruttori
`public SecretsManagerCache()`
Costruttore di default per un oggetto `SecretsManagerCache`.
`public SecretsManagerCache(IAmazonSecretsManager secretsManager)`
Costruisce una nuova cache utilizzando un client di Secrets Manager creato utilizzando l'[AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html) fornito. Utilizza questo costruttore per personalizzare il client di Secrets Manager, ad esempio per utilizzare una regione o un endpoint specifico.
**Parameters**
secretsManager
Il [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)da cui recuperare i segreti.
`public SecretsManagerCache(SecretCacheConfiguration config)`
Costruisce una nuova cache del segreto utilizzando il [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) fornito. Utilizza questo costruttore per configurare la cache, ad esempio il numero di segreti da inserire nella cache e la frequenza di aggiornamento.
**Parameters**
config
Un [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) che contiene informazioni di configurazione per la cache.
`public SecretsManagerCache(IAmazonSecretsManager secretsManager, SecretCacheConfiguration config)`
Costruisce una nuova cache utilizzando un client Secrets Manager creato utilizzando il file fornito [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)e un[SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md). Utilizza questo costruttore per personalizzare il client di Secrets Manager, ad esempio per utilizzare una regione o un endpoint specifici e configurare la cache, ad esempio il numero di segreti da inserire nella cache e la frequenza di aggiornamento.
**Parameters**
secretsManager
Il [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)da cui recuperare i segreti.
config
Un [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) che contiene informazioni di configurazione per la cache.
## Metodi
### GetSecretString
`public async Task GetSecretString(String secretId)`
Recupera un segreto stringa da Secrets Manager.Parameters
secretId
L'ARN o il nome del segreto da recuperare.
### GetSecretBinary
`public async Task GetSecretBinary(String secretId)`
Recupera un segreto binario da Secrets Manager.Parameters
secretId
L'ARN o il nome del segreto da recuperare.
### RefreshNowAsync
`public async Task RefreshNowAsync(String secretId)`
Richiede il valore del segreto da Secrets Manager e aggiorna la cache con eventuali modifiche. Se non esiste una voce di cache esistente, ne crea una nuova. Restituisce `true` se l'aggiornamento ha esito positivo.Parameters
secretId
L'ARN o il nome del segreto da recuperare.
### GetCachedSecret
`public SecretCacheItem GetCachedSecret(string secretId)`
Restituisce la voce di cache per il segreto specificato se presente nella cache. In caso contrario, recupera il segreto da Secrets Manager e crea una nuova voce di cache.Parameters
secretId
L'ARN o il nome del segreto da recuperare.
# SecretCacheConfiguration
Opzioni di configurazione della cache per un [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md), come dimensione massima della cache e durata (TTL) per i segreti memorizzati nella cache.
## Properties
### CacheItemTTL
`public uint CacheItemTTL { get; set; }`
Il TTL di un elemento della cache in millisecondi. Il valore predefinito è `3600000` ms o 1 ora. Il massimo è `4294967295` ms, vale a dire circa 49,7 giorni.
### MaxCacheSize
`public ushort MaxCacheSize { get; set; }`
La dimensione massima della cache. Il valore di default è 1024 segreti. Il numero massimo è pari a 65.535.
### VersionStage
`public string VersionStage { get; set; }`
Imposta la versione dei segreti che si desidera memorizzare nella cache. Per ulteriori informazioni, consulta [Versioni del segreto](whats-in-a-secret.md#term_version). Il valore predefinito è `"AWSCURRENT"`.
### Client
`public IAmazonSecretsManager Client { get; set; }`
[AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)Da cui recuperare i segreti. Se è `null`, la cache crea un'istanza di un nuovo client. Il valore predefinito è `null`.
### CacheHook
`public ISecretCacheHook CacheHook { get; set; }`
Un [ISecretCacheHook](retrieving-secrets_cache-net-ISecretCacheHook.md).
# ISecretCacheHook
Un'interfaccia per collegarsi a una [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md) per eseguire operazioni sui segreti memorizzati al suo interno.
## Metodi
### Put
`object Put(object o);`
Prepara l'oggetto per la memorizzazione nella cache.
Restituisce l'oggetto da memorizzare nella cache.
### Get
`object Get(object cachedObject);`
Deriva l'oggetto dall'oggetto memorizzato nella cache.
Restituisce l'oggetto da restituire dalla cache
# Ottieni un valore segreto di Secrets Manager utilizzando SDK per .NET
Nelle applicazioni, puoi recuperare i tuoi segreti chiamando `GetSecretValue` o `BatchGetSecretValue` in uno qualsiasi dei AWS SDKs. Tuttavia, ti consigliamo di memorizzare nella cache i valori del segreto utilizzando la caching lato client. Memorizzare i segreti nella cache migliora la velocità e riduce i costi.
Per le applicazioni .NET, utilizza il [componente di caching basato su .NET di Secrets Manager](retrieving-secrets_cache-net.md) o chiama direttamente l'SDK con [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TGetSecretValueRequest.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TGetSecretValueRequest.html) o [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TBatchGetSecretValueRequest.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TBatchGetSecretValueRequest.html).
Gli esempi di codice seguenti mostrano come utilizzare `GetSecretValue`.
**Autorizzazioni richieste:**`secretsmanager:GetSecretValue`
```
using System;
using System.IO;
using System.Threading.Tasks;
using Amazon.SecretsManager;
using Amazon.SecretsManager.Model;
///
/// This example uses the Amazon Web Service Secrets Manager to retrieve
/// the secret value for the provided secret name.
///
public class GetSecretValue
{
///
/// The main method initializes the necessary values and then calls
/// the GetSecretAsync and DecodeString methods to get the decoded
/// secret value for the secret named in secretName.
///
public static async Task Main()
{
string secretName = "<<{{MySecretName}}>>";
string secret;
IAmazonSecretsManager client = new AmazonSecretsManagerClient();
var response = await GetSecretAsync(client, secretName);
if (response is not null)
{
secret = DecodeString(response);
if (!string.IsNullOrEmpty(secret))
{
Console.WriteLine($"The decoded secret value is: {secret}.");
}
else
{
Console.WriteLine("No secret value was returned.");
}
}
}
///
/// Retrieves the secret value given the name of the secret to
/// retrieve.
///
/// The client object used to retrieve the secret
/// value for the given secret name.
/// The name of the secret value to retrieve.
/// The GetSecretValueReponse object returned by
/// GetSecretValueAsync.
public static async Task GetSecretAsync(
IAmazonSecretsManager client,
string secretName)
{
GetSecretValueRequest request = new GetSecretValueRequest()
{
SecretId = secretName,
VersionStage = "AWSCURRENT", // VersionStage defaults to AWSCURRENT if unspecified.
};
GetSecretValueResponse response = null;
// For the sake of simplicity, this example handles only the most
// general SecretsManager exception.
try
{
response = await client.GetSecretValueAsync(request);
}
catch (AmazonSecretsManagerException e)
{
Console.WriteLine($"Error: {e.Message}");
}
return response;
}
///
/// Decodes the secret returned by the call to GetSecretValueAsync and
/// returns it to the calling program.
///
/// A GetSecretValueResponse object containing
/// the requested secret value returned by GetSecretValueAsync.
/// A string representing the decoded secret value.
public static string DecodeString(GetSecretValueResponse response)
{
// Decrypts secret using the associated AWS Key Management Service
// Customer Master Key (CMK.) Depending on whether the secret is a
// string or binary value, one of these fields will be populated.
if (response.SecretString is not null)
{
var secret = response.SecretString;
return secret;
}
else if (response.SecretBinary is not null)
{
var memoryStream = response.SecretBinary;
StreamReader reader = new StreamReader(memoryStream);
string decodedBinarySecret = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(reader.ReadToEnd()));
return decodedBinarySecret;
}
else
{
return string.Empty;
}
}
}
```
# Ottieni un valore segreto di Secrets Manager usando Go
Nelle applicazioni, puoi recuperare i tuoi segreti chiamando `GetSecretValue` o `BatchGetSecretValue` in uno qualsiasi dei AWS SDKs. Tuttavia, ti consigliamo di memorizzare nella cache i valori del segreto utilizzando la caching lato client. Memorizzare i segreti nella cache migliora la velocità e riduce i costi.
**Topics**
+ [Ottieni un valore segreto di Secrets Manager usando Go con caching lato client](retrieving-secrets_cache-go.md)
+ [Ottieni un valore segreto di Secrets Manager utilizzando Go AWS SDK](retrieving-secrets-go-sdk.md)
# Ottieni un valore segreto di Secrets Manager usando Go con caching lato client
Quando si recupera un segreto, è possibile utilizzare il componente di caching basato su Go di Secrets Manager per memorizzarlo nella cache per un uso futuro. Il recupero di un segreto memorizzato nella cache è più veloce rispetto al recupero da Secrets Manager. Poiché la chiamata a Secrets Manager comporta un costo APIs, l'utilizzo di una cache può ridurre i costi. Per tutti i modi in cui puoi recuperare i segreti, vedi [Ottieni segreti](retrieving-secrets.md).
La policy della cache è Least Recently Used (LRU), quindi quando la cache deve eliminare un segreto, elimina il segreto usato meno di recente. Di default, la cache aggiorna i segreti ogni ora. È possibile configurare [la frequenza con cui il segreto viene aggiornato](retrieving-secrets_cache-go_CacheConfig.md) nella cache ed è possibile [collegarsi al recupero del segreto](retrieving-secrets_cache-go_CacheHook.md) per aggiungere altre funzionalità.
La cache non impone la rimozione di oggetti inutili (garbage collection) una volta liberati i riferimenti alla cache. L'implementazione della cache non include l'invalidazione della cache. L'implementazione della cache è incentrata sulla cache stessa e non è rafforzata o focalizzata sulla sicurezza. Se hai bisogno di un livello di sicurezza aggiuntivo, come la crittografia degli elementi nella cache, usa le interfacce e i metodi astratti forniti.
Per usare il componente, devi disporre dei seguenti elementi:
+ AWS SDK for Go. Per informazioni, consulta [AWS SDKs](asm_access.md#asm-sdks).
Per scaricare il codice sorgente, consulta [Secrets Manager Go caching client](https://github.com/aws/aws-secretsmanager-caching-go ) on GitHub.
Per configurare un ambiente di sviluppo Go, consulta [Introduzione a Golang](https://golang.org/doc/install) sul sito Web del linguaggio di programmazione Go.
**Autorizzazioni richieste:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Per ulteriori informazioni, consulta [Riferimento per le autorizzazioni](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [type Cache](retrieving-secrets_cache-go_cache.md)
+ [tipo CacheConfig](retrieving-secrets_cache-go_CacheConfig.md)
+ [tipo CacheHook](retrieving-secrets_cache-go_CacheHook.md)
**Example Recupero di un segreto**
L'esempio di codice riportato di seguito mostra una funzione Lambda che recupera un segreto.
```
package main
import (
"github.com/aws/aws-lambda-go/lambda"
"github.com/aws/aws-secretsmanager-caching-go/secretcache"
)
var (
secretCache, _ = secretcache.New()
)
func HandleRequest(secretId string) string {
result, _ := secretCache.GetSecretString(secretId)
// Use the secret, return success
}
func main() {
lambda. Start( HandleRequest)
}
```
# type Cache
Una cache in memoria per i segreti richiesti da Secrets Manager. Si usa [GetSecretString](#retrieving-secrets_cache-go_cache_operations_GetCachedSecret) o [GetSecretBinary](#retrieving-secrets_cache-go_cache_operations_GetSecretBinary) per recuperare un segreto dalla cache.
Nell'esempio seguente viene illustrato come configurare le impostazioni della cache.
```
// Create a custom secretsmanager client
client := getCustomClient()
// Create a custom CacheConfig struct
config := secretcache. CacheConfig{
MaxCacheSize: secretcache.DefaultMaxCacheSize + 10,
VersionStage: secretcache.DefaultVersionStage,
CacheItemTTL: secretcache.DefaultCacheItemTTL,
}
// Instantiate the cache
cache, _ := secretcache.New(
func( c *secretcache.Cache) { c. CacheConfig = config },
func( c *secretcache.Cache) { c. Client = client },
)
```
Per ulteriori informazioni, inclusi esempi, consulta [Ottieni un valore segreto di Secrets Manager usando Go con caching lato client](retrieving-secrets_cache-go.md).
## Metodi
### Novità
`func New(optFns ...func(*Cache)) (*Cache, error)`
New costruisce una cache del segreto utilizzando opzioni funzionali, altrimenti usa i valori predefiniti. Inizializza un SecretsManager client da una nuova sessione. Inizializza CacheConfig ai valori predefiniti. Inizializza la cache LRU con una dimensione massima predefinita.
### GetSecretString
`func (c *Cache) GetSecretString(secretId string) (string, error)`
GetSecretString ottiene il valore della stringa segreta dalla cache per un determinato ID segreto. Restituisce la stringa segreta e un errore se l'operazione non è riuscita.
### GetSecretStringWithStage
`func (c *Cache) GetSecretStringWithStage(secretId string, versionStage string) (string, error)`
GetSecretStringWithStage ottiene il valore della stringa segreta dalla cache per un determinato ID segreto e [fase della versione](whats-in-a-secret.md#term_version). Restituisce la stringa segreta e un errore se l'operazione non è riuscita.
### GetSecretBinary
`func (c *Cache) GetSecretBinary(secretId string) ([]byte, error) {`
GetSecretBinary ottiene il valore binario segreto dalla cache per un determinato ID segreto. Restituisce il numero binario del segreto e un errore in caso di errore dell'operazione.
### GetSecretBinaryWithStage
`func (c *Cache) GetSecretBinaryWithStage(secretId string, versionStage string) ([]byte, error)`
GetSecretBinaryWithStage ottiene il valore binario segreto dalla cache per un determinato ID segreto e [fase della versione](whats-in-a-secret.md#term_version). Restituisce il numero binario del segreto e un errore in caso di errore dell'operazione.
# tipo CacheConfig
Opzioni di configurazione della cache per una [Cache](retrieving-secrets_cache-go_cache.md), ad esempio dimensione massima della cache, [fase della versione](whats-in-a-secret.md#term_version) di default e durata (TTL) per i segreti memorizzati nella cache.
```
type CacheConfig struct {
// The maximum cache size. The default is 1024 secrets.
MaxCacheSize int
// The TTL of a cache item in nanoseconds. The default is
// 3.6e10^12 ns or 1 hour.
CacheItemTTL int64
// The version of secrets that you want to cache. The default
// is "AWSCURRENT".
VersionStage string
// Used to hook in-memory cache updates.
Hook CacheHook
}
```
# tipo CacheHook
Un'interfaccia per collegarsi a una [Cache](retrieving-secrets_cache-go_cache.md) per eseguire operazioni sul segreto memorizzato al suo interno.
## Metodi
### Put
`Put(data interface{}) interface{}`
Prepara l'oggetto per la memorizzazione nella cache.
### Get
`Get(data interface{}) interface{}`
Deriva l'oggetto dall'oggetto memorizzato nella cache.
# Ottieni un valore segreto di Secrets Manager utilizzando Go AWS SDK
Nelle applicazioni, puoi recuperare i tuoi segreti chiamando `GetSecretValue` o `BatchGetSecretValue` in uno qualsiasi dei. AWS SDKs Tuttavia, ti consigliamo di memorizzare nella cache i valori del segreto utilizzando la caching lato client. Memorizzare i segreti nella cache migliora la velocità e riduce i costi.
Per le applicazioni Go, utilizza il [componente di caching basato su Go di Secrets Manager](retrieving-secrets_cache-go.md) o chiama direttamente l'SDK con [https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.GetSecretValue](https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.GetSecretValue) o [https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.BatchGetSecretValue](https://docs.aws.amazon.com/sdk-for-go/api/service/secretsmanager/#SecretsManager.BatchGetSecretValue).
I seguenti esempi di codice mostrano come recuperare un valore segreto di Gestione dei segreti.
**Autorizzazioni richieste:**`secretsmanager:GetSecretValue`
```
// Use this code snippet in your app.
// If you need more information about configurations or implementing the sample code, visit the AWS docs:
// https://aws.github.io/aws-sdk-go-v2/docs/getting-started/
import (
"context"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/secretsmanager"
)
func main() {
secretName := "<<{{MySecretName}}>>"
region := "<<{{MyRegionName}}>>"
config, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(region))
if err != nil {
log.Fatal(err)
}
// Create Secrets Manager client
svc := secretsmanager.NewFromConfig(config)
input := &secretsmanager.GetSecretValueInput{
SecretId: aws.String(secretName),
VersionStage: aws.String("AWSCURRENT"), // VersionStage defaults to AWSCURRENT if unspecified
}
result, err := svc.GetSecretValue(context.TODO(), input)
if err != nil {
// For a list of exceptions thrown, see
// https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
log.Fatal(err.Error())
}
// Decrypts secret using the associated KMS key.
var secretString string = *result.SecretString
// Your code goes here.
}
```
# Ottieni un valore segreto di Secrets Manager usando Rust
Nelle applicazioni, puoi recuperare i tuoi segreti chiamando `GetSecretValue` o `BatchGetSecretValue` in uno qualsiasi dei AWS SDKs. Tuttavia, ti consigliamo di memorizzare nella cache i valori del segreto utilizzando la caching lato client. Memorizzare i segreti nella cache migliora la velocità e riduce i costi.
**Topics**
+ [Ottieni un valore segreto di Secrets Manager usando Rust con la memorizzazione nella cache lato client](retrieving-secrets_cache-rust.md)
+ [Ottieni un valore segreto di Secrets Manager utilizzando Rust AWS SDK](retrieving-secrets-rust-sdk.md)
# Ottieni un valore segreto di Secrets Manager usando Rust con la memorizzazione nella cache lato client
Quando recuperi un segreto, puoi utilizzare il componente di caching basato su Secrets Manager Rust per memorizzarlo nella cache per usi futuri. Il recupero di un segreto memorizzato nella cache è più veloce rispetto al recupero da Secrets Manager. Poiché la chiamata a Secrets Manager comporta un costo APIs, l'utilizzo di una cache può ridurre i costi. Per tutti i modi in cui puoi recuperare i segreti, vedi [Ottieni segreti](retrieving-secrets.md).
La politica della cache è First In First Out (FIFO), quindi quando la cache deve eliminare un segreto, scarta il segreto più vecchio. Di default, la cache aggiorna i segreti ogni ora. È possibile configurare quanto segue:
+ `max_size`— Il numero massimo di segreti memorizzati nella cache da mantenere prima di rimuovere i segreti a cui non è stato effettuato l'accesso di recente.
+ `ttl`— La durata di validità di un elemento memorizzato nella cache prima di richiedere un aggiornamento dello stato segreto.
L'implementazione della cache non include l'invalidazione della cache. L'implementazione della cache è incentrata sulla cache stessa e non è rafforzata o focalizzata sulla sicurezza. Se hai bisogno di una sicurezza aggiuntiva, come la crittografia degli elementi nella cache, usa le caratteristiche fornite per modificare la cache.
Per utilizzare il componente, è necessario disporre di un ambiente di sviluppo Rust 2021 con. `tokio` Per ulteriori informazioni, consulta [Guida introduttiva](https://www.rust-lang.org/learn/get-started) sul sito Web del linguaggio di programmazione Rust.
Per scaricare il codice sorgente, vedete il [componente client di caching basato su Rust Secrets Manager](https://github.com/aws/aws-secretsmanager-agent/tree/main/aws_secretsmanager_caching) su. GitHub
Per installare il componente di memorizzazione nella cache, utilizzare il comando seguente.
```
cargo add aws_secretsmanager_caching
```
**Autorizzazioni richieste:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Per ulteriori informazioni, consulta [Riferimento per le autorizzazioni](auth-and-access.md#reference_iam-permissions).
**Example Recupero di un segreto**
L'esempio seguente mostra come ottenere il valore segreto per un segreto denominato*MyTest*.
```
use aws_secretsmanager_caching::SecretsManagerCachingClient;
use std::num::NonZeroUsize;
use std::time::Duration;
let client = match SecretsManagerCachingClient::default(
NonZeroUsize::new(10).unwrap(),
Duration::from_secs(60),
)
.await
{
Ok(c) => c,
Err(_) => panic!("Handle this error"),
};
let secret_string = match client.get_secret_value("MyTest", None, None).await {
Ok(s) => s.secret_string.unwrap(),
Err(_) => panic!("Handle this error"),
};
// Your code here
```
**Example Istanziazione della cache con una configurazione personalizzata e un client personalizzato**
L'esempio seguente mostra come configurare la cache e quindi ottenere il valore segreto per un segreto denominato. *MyTest*
```
let config = aws_config::load_defaults(BehaviorVersion::latest())
.await
.into_builder()
.region(Region::from_static("us-west-2"))
.build();
let asm_builder = aws_sdk_secretsmanager::config::Builder::from(&config);
let client = match SecretsManagerCachingClient::from_builder(
asm_builder,
NonZeroUsize::new(10).unwrap(),
Duration::from_secs(60),
)
.await
{
Ok(c) => c,
Err(_) => panic!("Handle this error"),
};
let secret_string = client
.get_secret_value("MyTest", None, None)
.await
{
Ok(c) => c.secret_string.unwrap(),
Err(_) => panic!("Handle this error"),
};
// Your code here
```
```
# Ottieni un valore segreto di Secrets Manager utilizzando Rust AWS SDK
Nelle applicazioni, puoi recuperare i tuoi segreti chiamando `GetSecretValue` o `BatchGetSecretValue` in uno qualsiasi dei. AWS SDKs Tuttavia, ti consigliamo di memorizzare nella cache i valori del segreto utilizzando la caching lato client. Memorizzare i segreti nella cache migliora la velocità e riduce i costi.
Per le applicazioni Rust, usa il [componente di caching basato su Secrets Manager Rust](retrieving-secrets_cache-rust.md) o chiama l'[SDK direttamente](https://docs.rs/releases/search?query=aws-sdk-secretsmanager) con o. GetSecretValue BatchGetSecretValue
I seguenti esempi di codice mostrano come recuperare un valore segreto di Gestione dei segreti.
**Autorizzazioni richieste:**`secretsmanager:GetSecretValue`
```
async fn show_secret(client: &Client, name: &str) -> Result<(), Error> {
let resp = client.get_secret_value().secret_id(name).send().await?;
println!("Value: {}", resp.secret_string().unwrap_or("No value!"));
Ok(())
}
```
# Usa Gestione dei segreti AWS i segreti in Amazon Elastic Kubernetes Service
Per mostrare i segreti di Gestione dei segreti AWS (ASCP) come file montati in Amazon EKS Pods, puoi utilizzare AWS Secrets and Configuration Provider per il driver CSI Kubernetes Secrets Store. L'ASCP funziona con Amazon Elastic Kubernetes Service 1.17\$1 che esegue un gruppo di nodi Amazon EC2. AWS Fargate i gruppi di nodi non sono supportati. Con ASCP, è possibile archiviare e gestire i segreti in Secrets Manager e recuperarli tramite i carichi di lavoro in esecuzione su Amazon EKS. Se il tuo segreto contiene più coppie chiave-valore in formato JSON, puoi scegliere quali montare in Amazon EKS. L'ASCP utilizza la sintassi JMESPath per interrogare le coppie chiave-valore nel tuo segreto. L'ASCP funziona anche con i parametri dell'archivio parametri. L'ASCP offre due metodi di autenticazione con Amazon EKS. Il primo approccio utilizza i ruoli IAM per gli account di servizio (IRSA). Il secondo approccio utilizza Pod Identity. Ogni approccio ha i suoi vantaggi e casi d'uso.
## ASCP con ruoli IAM per gli account di servizio (IRSA)
L'ASCP con IAM Roles for Service Accounts (IRSA) ti consente di montare segreti da file Gestione dei segreti AWS as nei tuoi Amazon EKS Pods. Questo approccio è adatto quando:
+ Devi montare i segreti come file nei tuoi Pods.
+ Stai usando la versione 1.17 o quella successiva di Amazon EKS con i gruppi di nodi di Amazon EC2.
+ Vuoi recuperare coppie chiave-valore specifiche da segreti in formato JSON.
Per ulteriori informazioni, consulta [Usa AWS Secrets and Configuration Provider CSI con IAM Roles for Service Accounts (IRSA)](integrating_ascp_irsa.md).
## ASCP con Pod Identity
Il metodo ASCP con Pod Identity migliora la sicurezza e semplifica la configurazione per l'accesso ai segreti in Amazon EKS. Questo approccio è utile quando:
+ È necessaria una gestione delle autorizzazioni più granulare a livello di pod.
+ Stai utilizzando la versione 1.24 o quella successiva di Amazon EKS.
+ Desideri prestazioni e scalabilità migliorate.
Per ulteriori informazioni, consulta [Usa AWS Secrets e Configuration Provider CSI con Pod Identity per Amazon EKS](ascp-pod-identity-integration.md).
## Scelta dell'approccio giusto
Considera i seguenti fattori al momento di decidere tra ASCP con IRSA e ASCP con Pod Identity:
+ Amazon EKSversion: Pod Identity richiede Amazon EKS 1.24\$1, mentre il driver CSI funziona con Amazon EKS 1.17\$1.
+ Requisiti di sicurezza: Pod Identity offre un controllo più granulare a livello di pod.
+ Prestazioni: Pod Identity generalmente offre prestazioni migliori in ambienti su larga scala.
+ Complessità: Pod Identity semplifica la configurazione eliminando la necessità di account di servizio separati.
Scegli il metodo più adatto ai tuoi requisiti specifici e all'ambiente Amazon EKS.
# Installa ASCP per Amazon EKS
Questa sezione spiega come installare AWS Secrets and Configuration Provider per Amazon EKS. Con ASCP, puoi montare segreti da Secrets Manager e parametri da AWS Systems Manager file in Amazon EKS Pods.
## Prerequisiti
+ Cluster Amazon EKS
+ Versione 1.24 o successiva per Pod Identity
+ Versione 1.17 o successiva per IRSA
+ AWS CLI Installato e configurato
+ kubectl installato e configurato per il cluster Amazon EKS
+ Helm (versione 3.0 o successiva)
## Istalla e configura l'ASCP
L'ASCP è disponibile GitHub nel repository [secrets-store-csi-provider-aws](https://github.com/aws/secrets-store-csi-driver-provider-aws). Il repository contiene anche file YAML di esempio per la creazione e il montaggio di un segreto.
Durante l'installazione, puoi configurare l'ASCP per utilizzare un endpoint FIPS. Per un elenco di endpoint, consulta [Gestione dei segreti AWS endpoint](asm_access.md#endpoints).
**Per installare ASCP come componente aggiuntivo EKS**
1. Installazione `eksctl` (istruzioni di [installazione](https://docs.aws.amazon.com/eks/latest/eksctl/installation.html))
1. Eseguite il comando seguente per installare il componente aggiuntivo con la [configurazione predefinita](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/charts/secrets-store-csi-driver-provider-aws/values.yaml):
```
eksctl create addon --cluster --name aws-secrets-store-csi-driver-provider
```
Se desideri configurare il componente aggiuntivo, esegui invece il seguente comando di installazione:
```
aws eks create-addon --cluster-name --addon-name aws-secrets-store-csi-driver-provider --configuration-values 'file://path/to/config.yaml'
```
Il file di configurazione può essere un file YAML o JSON. Per visualizzare lo schema di configurazione del componente aggiuntivo:
1. Eseguite il comando seguente e prendete nota della versione più recente del componente aggiuntivo:
```
aws eks describe-addon-versions --addon-name aws-secrets-store-csi-driver-provider
```
1. Esegui il comando seguente per visualizzare lo schema di configurazione del componente aggiuntivo, sostituendolo `` con la versione del passaggio precedente:
```
aws eks describe-addon-configuration --addon-name aws-secrets-store-csi-driver-provider --addon-version
```
**Installazione dell'ASCP con l'utilizzo di Helm**
1. Per assicurarti che il repository punti al grafico più recente, utilizza `helm repo update.`
1. Installare il grafico. Di seguito è riportato un esempio del `helm install` comando:
```
helm install -n kube-system secrets-provider-aws aws-secrets-manager/secrets-store-csi-driver-provider-aws
```
1. Per utilizzare un endpoint FIPS, aggiungi il seguente flag: `--set useFipsEndpoint=true`
1. Per configurare la limitazione (della larghezza di banda della rete), aggiungi il seguente flag: `--set-json 'k8sThrottlingParams={"qps": "number of queries per second", "burst": "number of queries per second"}'`
1. Se il driver CSI Secrets Store è già installato sul cluster, aggiungi il seguente flag:`--set secrets-store-csi-driver.install=false`. Ciò eviterà l'installazione del driver CSI di Secrets Store come dipendenza.
**Installazione utilizzando lo YAML nel repository**
+ Utilizza i seguenti comandi:
```
helm repo add secrets-store-csi-driver https://kubernetes-sigs.github.io/secrets-store-csi-driver/charts
helm install -n kube-system csi-secrets-store secrets-store-csi-driver/secrets-store-csi-driver
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/deployment/aws-provider-installer.yaml
```
## Verifica le installazioni
Per verificare le installazioni del cluster EKS, del driver CSI di Secrets Store e del plug-in ASCP, procedi nel seguente modo:
1. Verifica il cluster EKS:
```
eksctl get cluster --name clusterName
```
Questo comando deve restituire informazioni sul cluster.
1. Verifica l'installazione del driver CSI di Secrets Store:
```
kubectl get pods -n kube-system -l app=secrets-store-csi-driver
```
Dovresti vedere dei pod in esecuzione con nomi come `csi-secrets-store-secrets-store-csi-driver-xxx`.
1. Verifica l'installazione del plugin ASCP:
------
#### [ YAML installation ]
```
$ kubectl get pods -n kube-system -l app=csi-secrets-store-provider-aws
```
Output di esempio:
```
NAME READY STATUS RESTARTS AGE
csi-secrets-store-provider-aws-12345 1/1 Running 0 2m
```
------
#### [ Helm installation ]
```
$ kubectl get pods -n kube-system -l app=secrets-store-csi-driver-provider-aws
```
Output di esempio:
```
NAME READY STATUS RESTARTS AGE
secrets-provider-aws-secrets-store-csi-driver-provider-67890 1/1 Running 0 2m
```
------
Dovresti vedere dei pod nello stato `Running`.
Dopo aver eseguito questi comandi, se tutto è impostato correttamente, dovresti vedere tutti i componenti in esecuzione senza errori. In caso di problemi, potrebbe essere necessario risolverli controllando i log dei pod specifici che presentano problemi.
## Risoluzione dei problemi
1. Per controllare i log del provider ASCP, esegui:
```
kubectl logs -n kube-system -l app=csi-secrets-store-provider-aws
```
1. Controlla lo stato di tutti i pod nel namespace: `kube-system`
```
kubectl -n kube-system get pods
```
```
kubectl -n kube-system logs pod/PODID
```
Tutti i pod relativi al driver CSI e all'ASCP devono essere nello stato "In esecuzione".
1. Controlla la versione del driver CSI:
```
kubectl get csidriver secrets-store.csi.k8s.io -o yaml
```
Questo comando deve restituire informazioni sul driver CSI installato.
## Risorse aggiuntive
Per ulteriori informazioni su come utilizzare ASCP con Amazon EKS, consulta le seguenti risorse:
+ [Utilizzo di Pod Identity con Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html)
+ [AWS Driver CSI Secrets Store attivo GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)
# Usa AWS Secrets e Configuration Provider CSI con Pod Identity per Amazon EKS
L'integrazione di AWS Secrets and Configuration Provider con Pod Identity Agent per Amazon Elastic Kubernetes Service offre maggiore sicurezza, configurazione semplificata e prestazioni migliorate per le applicazioni in esecuzione su Amazon EKS. Pod Identity semplifica l'autenticazione IAM per Amazon EKS durante il recupero di segreti da Secrets Manager o parametri da AWS Systems Manager Parameter Store.
Amazon EKS Pod Identity semplifica il processo di configurazione delle autorizzazioni IAM per le applicazioni Kubernetes consentendo quest'azione direttamente tramite le interfacce Amazon EKS, riducendo il numero di passaggi ed eliminando la necessità di passare da Amazon EKS ai servizi IAM. [Pod Identity consente l'uso di un singolo ruolo IAM su più cluster senza aggiornare le policy di attendibilità e supporta i tag delle sessioni di ruolo](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-abac.html#pod-id-abac-tags) per un controllo degli accessi più granulare. Questo approccio non solo semplifica la gestione delle policy consentendo il riutilizzo delle politiche di autorizzazione tra i ruoli, ma migliora anche la sicurezza abilitando l'accesso alle risorse in base ai AWS tag corrispondenti.
## Come funziona
1. Pod Identity assegna un ruolo IAM al pod.
1. ASCP utilizza questo ruolo per l'autenticazione con. Servizi AWS
1. Se autorizzato, ASCP recupera i segreti richiesti e li rende disponibili al Pod.
Per ulteriori informazioni, consulta [Scopri come funziona Amazon EKS Pod Identity](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-how-it-works.html) nella *Guida per l'utente di Amazon EKS*.
## Prerequisiti
**Importante**
Pod Identity è supportato solo per Amazon EKS nel cloud. Non è supportato per [Amazon EKS Anywhere](https://aws.amazon.com/eks/eks-anywhere/) o per i cluster [Servizio Red Hat OpenShift su AWS](https://aws.amazon.com/rosa/)Kubernetes autogestiti sulle istanze Amazon EC2.
+ Cluster Amazon EKS (versione 1.24 o successiva)
+ Accesso AWS CLI e cluster Amazon EKS tramite `kubectl`
+ Accesso a due Account AWS (per l'accesso su più account)
## Installazione dell'agente Amazon EKS Pod Identity
Per utilizzare Pod Identity con il tuo cluster, devi installare il componente aggiuntivo dell'agente Amazon EKS Pod Identity.
**Installare l'agente Pod Identity**
+ Installa il componente aggiuntivo Pod Identity Agent sul tuo cluster:
```
eksctl create addon \
--name eks-pod-identity-agent \
--cluster clusterName \
--region region
```
## Configura ASCP con Pod Identity
1. Crea una politica di autorizzazioni che conceda `secretsmanager:GetSecretValue` e `secretsmanager:DescribeSecret` autorizzi i segreti a cui il Pod deve accedere. Per un esempio di policy, consulta [Esempio: autorizzazione a leggere e descrivere singoli segreti](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Crea un ruolo IAM che può essere assunto dal servizio principale Amazon EKS per Pod Identity:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
------
Allega la policy IAM al ruolo:
```
aws iam attach-role-policy \
--role-name MY_ROLE \
--policy-arn POLICY_ARN
```
1. Crea un'associazione Pod Identity. Per un esempio, consulta [Crea un'associazione Pod Identity](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-association.html#pod-id-association-create) nella *Guida per l'utente Amazon EKS*
1. Crea il `SecretProviderClass` file che specifica quali segreti montare nel Pod:
```
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleSecretProviderClass-PodIdentity.yaml
```
La differenza fondamentale in `SecretProviderClass` tra IRSA e Pod Identity è il parametro `usePodIdentity` facoltativo. Si tratta di un campo facoltativo che determina l'approccio di autenticazione. Quando non è specificato, per impostazione predefinita utilizzare i ruoli IAM per gli account di servizio (IRSA).
+ Per utilizzare EKS Pod Identity, utilizza uno qualsiasi di questi valori: `"true", "True", "TRUE", "t", "T"`.
+ Per utilizzare in modo esplicito IRSA, imposta uno qualsiasi di questi valori: `"false", "False", "FALSE", "f", or "F"`.
1. Implementa il Pod che monta i segreti sotto: `/mnt/secrets-store`
```
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleDeployment-PodIdentity.yaml
```
1. Se utilizzi un cluster Amazon EKS privato, assicurati che il VPC in cui si trova il cluster abbia un AWS STS endpoint. Per informazioni sulla creazione di un endpoint, consulta [Endpoint VPC di interfaccia](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) nella * Guida per l'utente AWS Identity and Access Management *.
### Verifica il montaggio del segreto
Per verificare che il segreto sia montato correttamente, esegui il seguente comando:
```
kubectl exec -it $(kubectl get pods | awk '/pod-identity-deployment/{print $1}' | head -1) -- cat /mnt/secrets-store/MySecret
```
**Per configurare Amazon EKS Pod Identity per l'accesso ai segreti in Secrets Manager**
1. Crea una politica di autorizzazioni che conceda `secretsmanager:GetSecretValue` e `secretsmanager:DescribeSecret` autorizzi i segreti a cui il Pod deve accedere. Per un esempio di policy, consulta [Esempio: autorizzazione a leggere e descrivere singoli segreti](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Crea un segreto in Secrets Manager, se non ne hai già uno.
## Risoluzione dei problemi
È possibile visualizzare la maggior parte degli errori descrivendo l'implementazione del pod.
**Per visualizzare i messaggi di errore per il container**
1. È possibile ottenere un elenco di nomi di pod con il comando seguente. Se non si sta utilizzando il namespace predefinito, utilizzare `-n NAMESPACE`.
```
kubectl get pods
```
1. Per descrivere il Pod, nel comando seguente, *PODID* usa l'ID Pod dei Pod che hai trovato nel passaggio precedente. Se non si sta utilizzando lo spazio dei nomi predefinito, utilizzare `-n NAMESPACE`.
```
kubectl describe pod/PODID
```
**Come visualizzare gli errori per l'ASCP**
+ Per trovare maggiori informazioni nei log del provider, nel comando seguente, *PODID* usa l'ID del Pod *csi-secrets-store-provider-aws*.
```
kubectl -n kube-system get pods
kubectl -n kube-system logs pod/PODID
```
# Usa AWS Secrets and Configuration Provider CSI con IAM Roles for Service Accounts (IRSA)
**Topics**
+ [Prerequisiti](#prerequisites)
+ [Configurazione del controllo degli accessi](#integrating_ascp_irsa_access)
+ [Identificazione dei segreti montare](#integrating_ascp_irsa_mount)
+ [Risoluzione dei problemi](#integrating_ascp_irsa_trouble)
## Prerequisiti
+ Cluster Amazon EKS (versione 1.17 o successiva)
+ Accesso AWS CLI e cluster Amazon EKS tramite `kubectl`
## Configurazione del controllo degli accessi
L'ASCP recupera il Pod Identity di Amazon EKS e lo scambia con il ruolo IAM. Le autorizzazioni vengono impostate in una policy IAM per quel ruolo IAM. Quando ASCP assume il ruolo IAM, ottiene l'accesso ai segreti che hai autorizzato. Altri container non possono accedere ai segreti a meno che non vengano associati anche al ruolo IAM.
**Per consentire al tuo Amazon EKS Pod di accedere ai segreti in Secrets Manager**
1. Crea una politica di autorizzazioni che conceda `secretsmanager:GetSecretValue` e `secretsmanager:DescribeSecret` autorizzi i segreti a cui il Pod deve accedere. Per un esempio di policy, consulta [Esempio: autorizzazione a leggere e descrivere singoli segreti](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Crea un provider OpenID Connect (OIDC) IAM per il cluster se non ne è già presente uno. Per ulteriori informazioni, consulta [Crea un provider IAM OIDC per il tuo cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) nella *Guida per l'utente di Amazon EKS*.
1. Crea un [Ruolo IAM per l'account del servizio](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) e collega la policy ad esso. Per ulteriori informazioni, consulta [Crea un ruolo IAM per un account del servizio](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) nella *Guida per l'utente di Amazon EKS*.
1. Se utilizzi un cluster Amazon EKS privato, assicurati che il VPC in cui si trova il cluster abbia un AWS STS endpoint. Per informazioni sulla creazione di un endpoint, consulta [Endpoint VPC di interfaccia](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) nella * Guida per l'utente AWS Identity and Access Management *.
## Identificazione dei segreti montare
Per determinare quali segreti l'ASCP monta in Amazon EKS come file sul file system, è necessario creare un file [SecretProviderClass](ascp-examples.md#ascp-examples-secretproviderclass) YAML. `SecretProviderClass`Elenca i segreti da montare e il nome del file con cui montarli. Il `SecretProviderClass` deve trovarsi nello stesso namespace del pod Amazon EKS a cui fa riferimento.
### Monta i segreti come file
[Le seguenti istruzioni mostrano come montare i segreti come file utilizzando file YAML di esempio .yaml e [ExampleSecretProviderClass.yaml](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleSecretProviderClass-IRSA.yaml). ExampleDeployment](https://github.com/aws/secrets-store-csi-driver-provider-aws/blob/main/examples/ExampleDeployment-IRSA.yaml)
**Per montare segreti in Amazon EKS**
1. Applica il `SecretProviderClass` al pod:
```
kubectl apply -f ExampleSecretProviderClass.yaml
```
1. Distribuisci il pod:
```
kubectl apply -f ExampleDeployment.yaml
```
1. L'ASCP monta i file.
## Risoluzione dei problemi
È possibile visualizzare la maggior parte degli errori descrivendo l'implementazione del pod.
**Per visualizzare i messaggi di errore per il container**
1. È possibile ottenere un elenco di nomi di pod con il comando seguente. Se non si sta utilizzando il namespace predefinito, utilizzare `-n nameSpace`.
```
kubectl get pods
```
1. Per descrivere il Pod, nel comando seguente, *podId* usa l'ID Pod dei Pod che hai trovato nel passaggio precedente. Se non si sta utilizzando lo spazio dei nomi predefinito, utilizzare `-n nameSpace`.
```
kubectl describe pod/podId
```
**Come visualizzare gli errori per l'ASCP**
+ Per trovare maggiori informazioni nei log del provider, nel comando seguente, *podId* usa l'ID del Pod *csi-secrets-store-provider-aws*.
```
kubectl -n kube-system get pods
kubectl -n kube-system logs Pod/podId
```
+
**Verifica che il `SecretProviderClass` sia installato:**
```
kubectl get crd secretproviderclasses.secrets-store.csi.x-k8s.io
```
Questo comando deve restituire informazioni sulla definizione delle risorse personalizzate `SecretProviderClass`.
+
**Verifica che l' SecretProviderClass oggetto sia stato creato.**
```
kubectl get secretproviderclass SecretProviderClassName -o yaml
```
# AWS Segreti ed esempi di codice del Configuration Provider
## Esempi di autenticazione e controllo degli accessi ASCP
### Esempio: policy IAM che consente al servizio Amazon EKS Pod Identity (pods.eks.amazonaws.com) di assumere il ruolo e contrassegnare la sessione:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
------
## SecretProviderClass
Puoi utilizzare YAML per descrivere quali segreti montare in Amazon EKS utilizzando l'ASCP. Per alcuni esempi, consulta [SecretProviderClass utilizzo](#ascp-scenarios-secretproviderclass).
### SecretProviderClass Struttura YAML
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: name
spec:
provider: aws
parameters:
region:
failoverRegion:
pathTranslation:
usePodIdentity:
preferredAddressType:
objects:
```
Il campo parametri contiene i dettagli della richiesta di montaggio:
**region**
(Facoltativo) Il Regione AWS segreto. Se non utilizzi questo campo, l'ASCP cerca la Regione dall'annotazione sul nodo. Questa ricerca aggiunge un sovraccarico alle richieste di montaggio, quindi consigliamo di fornire la Regione per i cluster che utilizzano un numero elevato di pod.
Se specifichi anche la `failoverRegion`, l'ASCP tenta di recuperare il segreto da entrambe le Regioni. Se una delle Regioni restituisce un errore 4xx, ad esempio per un problema di autenticazione, l'ASCP non installa nessuno dei due segreti. Se il segreto viene recuperato correttamente da `region`, l'ASCP monta tale valore del segreto. Se il segreto non viene recuperato correttamente da `region`, ma viene correttamente recuperato da `failoverRegion`, l'ASCP monta tale valore del segreto.
**failoverRegion**
(Facoltativo) Se si include questo campo, l'ASCP tenta di recuperare il segreto dalle Regioni definite in`region` e in questo campo. Se una delle Regioni restituisce un errore 4xx, ad esempio per un problema di autenticazione, l'ASCP non installa nessuno dei due segreti. Se il segreto viene recuperato correttamente da `region`, l'ASCP monta tale valore del segreto. Se il segreto non viene recuperato correttamente da `region`, ma viene correttamente recuperato da `failoverRegion`, l'ASCP monta tale valore del segreto. Per un esempio su come utilizzare questo campo, consulta la sezione [Failover segreto in più regioni](#multi-region-failover).
**pathTranslation**
(Facoltativo) Un singolo carattere di sostituzione da utilizzare se il nome del file in Amazon EKS conterrà il carattere separatore di percorso, come barra (/) su Linux. L'ASCP non è in grado di creare un file montato che contiene un carattere separatore di percorso. Invece, l'ASCP sostituisce il carattere separatore di percorso con un carattere diverso. Se non utilizzi questo campo, il carattere sostitutivo è il carattere di sottolineatura (\$1), quindi ad esempio, `My/Path/Secret` monta come `My_Path_Secret`.
Per impedire la sostituzione dei caratteri, immettere la stringa `False`.
**usePodIdentity**
(Facoltativo) Determina l'approccio di autenticazione. Se non specificato, il valore predefinito è ruoli IAM per gli account di servizio (IRSA).
+ Per utilizzare EKS Pod Identity, utilizza uno qualsiasi di questi valori: `"true"`", `"True"`, `"TRUE"`, `"t"` o `"T"`.
+ Per utilizzare in modo esplicito IRSA, imposta uno qualsiasi dei seguenti valori: `"false"`, `"False"`, `"FALSE"`, `"f"`, or `"F"`"=.
**preferredAddressType**
(Facoltativo) Specifica il tipo di indirizzo IP preferito per la comunicazione con gli endpoint dell'agente Pod Identity. Il campo è applicabile solo quando si utilizza la funzionalità EKS Pod Identity e verrà ignorato, quando si utilizzano i ruoli IAM per gli account di servizio. I valori non fanno distinzione tra maiuscole e minuscole. I valori validi sono:
+ `"ipv4"`, `"IPv4"` «, oppure `"IPV4"` — Forza l'uso dell' IPv4 endpoint Pod Identity Agent
+ `"ipv6"`,`"IPv6"`, o `"IPV6"` — Forza l'uso dell'endpoint Pod Identity Agent IPv6
+ non specificato: utilizza la selezione automatica degli endpoint, provando prima l' IPv4 endpoint e ritornando all' IPv6 endpoint se fallisce IPv4
**objects**
Una stringa contenente una dichiarazione YAML dei segreti da montare. Si consiglia di utilizzare una stringa multiriga YAML o un carattere pipe (\$1).
**objectName**
Obbligatorio. Speciifica il nome del segreto o del parametro da recuperare. Per Secrets Manager questo è il parametro [https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html#API_GetSecretValue_RequestParameters](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html#API_GetSecretValue_RequestParameters) e può essere sia il nome descrittivo sia l'ARN completo del segreto. Per SSM Parameter Store, questo è il [https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#API_GetParameter_RequestParameters](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html#API_GetParameter_RequestParameters)parametro e può essere il nome o l'ARN completo del parametro.
**objectType**
Obbligatorio se non si utilizza un ARN di Secrets Manager per `objectName`. Può essere `secretsmanager` o `ssmparameter`.
**objectAlias**
(Facoltativo) Il nome file del segreto nel pod Amazon EKS. Se non indichi questo campo, `objectName` viene visualizzato come nome del file.
**Autorizzazione del file**
(Facoltativo) La stringa ottale a 4 cifre che specifica l'autorizzazione del file con cui eseguire il montaggio segreto. Se non specifichi questo campo, il valore predefinito sarà. `"0644"`
**objectVersion**
(Facoltativo) L'ID di versione del segreto. Non è consigliato perché è necessario aggiornare l'ID di versione ogni volta che si aggiorna il segreto. Per impostazione predefinita viene utilizzata la versione più recente. Se includi un `failoverRegion`, questo campo rappresenta l'`objectVersion` primario.
**objectVersionLabel**
(Facoltativo) L'alias per la versione. Il valore predefinito è la versione più recente AWSCURRENT. Per ulteriori informazioni, consulta [Versioni segrete](whats-in-a-secret.md#term_version). Se includi un `failoverRegion`, questo campo rappresenta l'`objectVersionLabel` primario.
**jmesPath**
(Facoltativo) Una mappa delle chiavi nel segreto per i file da montare in Amazon EKS. Per utilizzare questo campo, il valore del segreto deve essere in formato JSON. Se si utilizza questo campo, è necessario includere i sottocampi `path` e `objectAlias`.
**path**
Una chiave da una coppia chiave-valore nel JSON del valore segreto. Se il campo contiene un trattino, usa le virgolette singole per evitarlo, ad esempio: `path: '"hyphenated-path"'`
**objectAlias**
Il nome del file da montare nel pod Amazon EKS. Se il campo contiene un trattino, usa le virgolette singole per evitarlo, ad esempio: `objectAlias: '"hyphenated-alias"'`
**Autorizzazione del file**
(Facoltativo) La stringa ottale a 4 cifre che specifica l'autorizzazione del file con cui eseguire il montaggio segreto. Se non si specifica questo campo, verrà utilizzata per impostazione predefinita l'autorizzazione al file dell'oggetto principale.
**failoverObject**
(Facoltativo) Se specifichi questo campo, l'ASCP tenta di recuperare sia il segreto specificato nel campo primario `objectName` che il segreto specificato nel sottocampo `failoverObject` `objectName`. Se uno dei due restituisce un errore 4xx, ad esempio per un problema di autenticazione, l'ASCP non installa nessuno dei due segreti. Se il segreto viene recuperato con successo dall'`objectName` primario, l'ASCP monta tale valore del segreto. Se il segreto non viene recuperato correttamente dall'`objectName` primario, ma viene recuperato con successo dall'`objectName` di failover, l'ASCP installa tale valore del segreto. Se si include questo campo, è necessario includere il campo `objectAlias`. Per un esempio su come utilizzare questo campo, consulta la sezione [Failover su un segreto diverso](#failover-secret).
In genere, si utilizza questo campo quando il segreto di failover non è una replica. Per un esempio su come specificare una replica, consulta la sezione [Failover segreto in più regioni](#multi-region-failover).
**objectName**
Il nome o l'ARN completo del segreto di failover. Se utilizzi un ARN, la Regione nell'ARN deve corrispondere al campo `failoverRegion`.
**objectVersion**
(Facoltativo) L'ID di versione del segreto. Deve corrispondere all'`objectVersion` primaria. Non è consigliato perché è necessario aggiornare l'ID di versione ogni volta che si aggiorna il segreto. Per impostazione predefinita viene utilizzata la versione più recente.
**objectVersionLabel**
(Facoltativo) L'alias per la versione. L'impostazione predefinita è la versione più recente AWSCURRENT. Per ulteriori informazioni, consulta [Versioni segrete](whats-in-a-secret.md#term_version).
### Crea una SecretProviderClass configurazione di base per montare segreti nei tuoi Amazon EKS Pods.
------
#### [ Pod Identity ]
SecretProviderClass per utilizzare un segreto nello stesso cluster Amazon EKS:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets-manager
spec:
provider: aws
parameters:
objects: |
- objectName: "mySecret"
objectType: "secretsmanager"
usePodIdentity: "true"
```
------
#### [ IRSA ]
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: deployment-aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "MySecret"
objectType: "secretsmanager"
```
------
### SecretProviderClass utilizzo
Usa questi esempi per creare SecretProviderClass configurazioni per diversi scenari.
#### Esempio: montaggio di segreti per nome o ARN
Questo esempio mostra come montare tre diversi tipi di segreti:
+ Un segreto specificato dall'ARN completo
+ Un segreto specificato per nome
+ Una versione specifica di un segreto
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MySecret2-d4e5f6"
- objectName: "MySecret3"
objectType: "secretsmanager"
- objectName: "MySecret4"
objectType: "secretsmanager"
objectVersionLabel: "AWSCURRENT"
```
#### Esempio: monta coppie chiave-valore da un segreto
Questo esempio mostra come montare coppie chiave-valore specifiche da un segreto in formato JSON:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MySecret-a1b2c3"
jmesPath:
- path: username
objectAlias: dbusername
- path: password
objectAlias: dbpassword
```
#### Esempio: monta i segreti tramite l'autorizzazione del file
Questo esempio mostra come montare un segreto con un'autorizzazione specifica per il file
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
objects: |
- objectName: "mySecret"
objectType: "secretsmanager"
filePermission: "0600"
jmesPath:
- path: username
objectAlias: dbusername
filePermission: "0400"
```
#### Esempio: esempi di configurazione di failover
Questi esempi mostrano come configurare il failover per i segreti.
##### Failover segreto in più regioni
Questo esempio mostra come configurare il failover automatico per un segreto replicato su più regioni:
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
region: us-east-1
failoverRegion: us-east-2
objects: |
- objectName: "MySecret"
```
##### Failover su un segreto diverso
Questo esempio mostra come configurare il failover su un segreto diverso (non su una replica):
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: aws-secrets
spec:
provider: aws
parameters:
region: us-east-1
failoverRegion: us-east-2
objects: |
- objectName: "arn:aws:secretsmanager:us-east-1:777788889999:secret:MySecret-a1b2c3"
objectAlias: "MyMountedSecret"
failoverObject:
- objectName: "arn:aws:secretsmanager:us-east-2:777788889999:secret:MyFailoverSecret-d4e5f6"
```
## Risorse aggiuntive
Per ulteriori informazioni su come utilizzare ASCP con Amazon EKS, consulta le seguenti risorse:
+ [Utilizzo di Pod Identity con Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html)
+ [Utilizzo di AWS Secrets and Configuration Provider](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_ascp_csi.html)
+ [AWS Secrets Store CSI Driver attivo GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)
# Usa Gestione dei segreti AWS i segreti nelle AWS Lambda funzioni
AWS Lambda è un servizio di elaborazione senza server che consente di eseguire codice senza effettuare il provisioning o la gestione dei server. Parameter Store, una funzionalità di AWS Systems Manager, fornisce uno storage sicuro e gerarchico per la gestione dei dati di configurazione e la gestione dei segreti. Puoi utilizzare l'estensione Lambda AWS Parameters and Secrets per recuperare e memorizzare nella cache Gestione dei segreti AWS i segreti e i parametri Parameter Store nelle funzioni Lambda senza utilizzare un SDK. *Per informazioni dettagliate sull'uso di questa estensione, consulta [Use Secrets Manager secret nelle funzioni Lambda nella Lambda Developer](https://docs.aws.amazon.com/lambda/latest/dg/with-secrets-manager.html) Guide.*
## Utilizzo dei segreti di Secrets Manager con Lambda
La Lambda Developer Guide fornisce istruzioni complete per l'utilizzo dei segreti di Secrets Manager nelle funzioni Lambda. Per iniziare
1. Segui il step-by-step tutorial in [Use Secrets Manager secrets in Lambda functions](https://docs.aws.amazon.com/lambda/latest/dg/with-secrets-manager.html), che include:
+ Creazione di una funzione Lambda con il runtime preferito (Python, Node.js, Java)
+ Aggiungere l'estensione Lambda AWS Parameters and Secrets come livello
+ Configurazione delle autorizzazioni necessarie
+ Scrittura di codice per recuperare i segreti dall'estensione
+ Verifica della tua funzione
1. Scopri le variabili di ambiente per configurare il comportamento dell'estensione, incluse le impostazioni della cache e i timeout
1. Comprendi le migliori pratiche per lavorare con la rotazione segreta
### Utilizzo di Secrets Manager e Lambda in un VPC
Se la tua funzione Lambda viene eseguita in un VPC, devi creare un endpoint VPC in modo che l'estensione possa effettuare chiamate a Secrets Manager. Per ulteriori informazioni, consulta [Utilizzo di un Gestione dei segreti AWS endpoint VPC](vpc-endpoint-overview.md).
## Utilizzo dell'estensione Lambda AWS Parameters and Secrets
L'estensione può recuperare sia i segreti di Gestione dei segreti che i parametri di Archivio dei parametri Per informazioni dettagliate sull'utilizzo dei parametri Parameter Store con l'estensione, vedere [Utilizzo dei parametri Parameter Store nelle funzioni Lambda nella Guida](https://docs.aws.amazon.com/systems-manager/latest/userguide/ps-integration-lambda-extensions.html) per l'*AWS Systems Manager utente*.
La documentazione di Systems Manager include:
+ Spiegazione dettagliata del funzionamento dell'estensione con Parameter Store
+ Istruzioni per aggiungere l'estensione a una funzione Lambda
+ Variabili di ambiente per la configurazione dell'estensione
+ Comandi di esempio per il recupero dei parametri
+ Elenco completo delle estensioni ARNs per tutte le architetture e le regioni supportate
# 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)
# Ottieni un valore segreto di Secrets Manager utilizzando l'SDK C\$1\$1 AWS
Per le applicazioni C\$1\$1, chiama l'SDK direttamente con o. [GetSecretValue[BatchGetSecretValue](https://docs.aws.amazon.com/goto/SdkForCpp/secretsmanager-2017-10-17/BatchGetSecretValue)](https://docs.aws.amazon.com/goto/SdkForCpp/secretsmanager-2017-10-17/GetSecretValue)
I seguenti esempi di codice mostrano come recuperare un valore segreto di Gestione dei segreti.
**Autorizzazioni richieste:**`secretsmanager:GetSecretValue`
```
//! Retrieve an AWS Secrets Manager encrypted secret.
/*!
\param secretID: The ID for the secret.
\return bool: Function succeeded.
*/
bool AwsDoc::SecretsManager::getSecretValue(const Aws::String &secretID,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SecretsManager::SecretsManagerClient secretsManagerClient(clientConfiguration);
Aws::SecretsManager::Model::GetSecretValueRequest request;
request.SetSecretId(secretID);
Aws::SecretsManager::Model::GetSecretValueOutcome getSecretValueOutcome = secretsManagerClient.GetSecretValue(
request);
if (getSecretValueOutcome.IsSuccess()) {
std::cout << "Secret is: "
<< getSecretValueOutcome.GetResult().GetSecretString() << std::endl;
}
else {
std::cerr << "Failed with Error: " << getSecretValueOutcome.GetError()
<< std::endl;
}
return getSecretValueOutcome.IsSuccess();
}
```
# Ottieni un valore segreto di Secrets Manager utilizzando l' JavaScript AWS SDK
Per JavaScript le applicazioni, chiama l'SDK direttamente con [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#getSecretValue-property](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#getSecretValue-property)o. [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#batchGetSecretValue-property](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#batchGetSecretValue-property)
I seguenti esempi di codice mostrano come recuperare un valore segreto di Gestione dei segreti.
**Autorizzazioni richieste:**`secretsmanager:GetSecretValue`
```
import {
GetSecretValueCommand,
SecretsManagerClient,
} from "@aws-sdk/client-secrets-manager";
export const getSecretValue = async (secretName = "SECRET_NAME") => {
const client = new SecretsManagerClient();
const response = await client.send(
new GetSecretValueCommand({
SecretId: secretName,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: '584eb612-f8b0-48c9-855e-6d246461b604',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// ARN: 'arn:aws:secretsmanager:us-east-1:xxxxxxxxxxxx:secret:binary-secret-3873048-xxxxxx',
// CreatedDate: 2023-08-08T19:29:51.294Z,
// Name: 'binary-secret-3873048',
// SecretBinary: Uint8Array(11) [
// 98, 105, 110, 97, 114,
// 121, 32, 100, 97, 116,
// 97
// ],
// VersionId: '712083f4-0d26-415e-8044-16735142cd6a',
// VersionStages: [ 'AWSCURRENT' ]
// }
if (response.SecretString) {
return response.SecretString;
}
if (response.SecretBinary) {
return response.SecretBinary;
}
};
```
# Ottieni un valore segreto di Secrets Manager utilizzando l'SDK Kotlin AWS
Per le applicazioni Kotlin, chiama l'SDK direttamente con o. [GetSecretValue[BatchGetSecretValue](https://github.com/awslabs/aws-sdk-kotlin#generating-api-documentation)](https://github.com/awslabs/aws-sdk-kotlin#generating-api-documentation)
I seguenti esempi di codice mostrano come recuperare un valore segreto di Gestione dei segreti.
**Autorizzazioni richieste:**`secretsmanager:GetSecretValue`
```
suspend fun getValue(secretName: String?) {
val valueRequest =
GetSecretValueRequest {
secretId = secretName
}
SecretsManagerClient.fromEnvironment { region = "us-east-1" }.use { secretsClient ->
val response = secretsClient.getSecretValue(valueRequest)
val secret = response.secretString
println("The secret value is $secret")
}
}
```
# Ottieni un valore segreto di Secrets Manager utilizzando l'SDK PHP AWS
Per le applicazioni PHP, effettua direttamente una chiamata all'SDK con [https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#getsecretvalue](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#getsecretvalue) o [https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#batchGetsecretvalue](https://docs.aws.amazon.com//aws-sdk-php/v3/api/api-secretsmanager-2017-10-17.html#batchGetsecretvalue).
I seguenti esempi di codice mostrano come recuperare un valore segreto di Gestione dei segreti.
**Autorizzazioni richieste:**`secretsmanager:GetSecretValue`
```
>/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
// Create a Secrets Manager Client
$client = new SecretsManagerClient([
'profile' => 'default',
'version' => '2017-10-17',
'region' => '<<{{MyRegionName}}>>',
]);
$secret_name = '<<{{MySecretName}}>>';
try {
$result = $client->getSecretValue([
'SecretId' => $secret_name,
]);
} catch (AwsException $e) {
// For a list of exceptions thrown, see
// https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
throw $e;
}
// Decrypts secret using the associated KMS key.
$secret = $result['SecretString'];
// Your code goes here
```
# Ottieni un valore segreto di Secrets Manager usando Ruby SDK AWS
Per le applicazioni Ruby, effettua direttamente una chiamata all'SDK con [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#get_secret_value-instance_method](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#get_secret_value-instance_method) o [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#batch_get_secret_value-instance_method](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/SecretsManager/Client.html#batch_get_secret_value-instance_method).
I seguenti esempi di codice mostrano come recuperare un valore segreto di Gestione dei segreti.
**Autorizzazioni richieste:**`secretsmanager:GetSecretValue`
```
# Use this code snippet in your app.
# If you need more information about configurations or implementing the sample code, visit the AWS docs:
# https://aws.amazon.com/developer/language/ruby/
require 'aws-sdk-secretsmanager'
def get_secret
client = Aws::SecretsManager::Client.new(region: '<<{{MyRegionName}}>>')
begin
get_secret_value_response = client.get_secret_value(secret_id: '<<{{MySecretName}}>>')
rescue StandardError => e
# For a list of exceptions thrown, see
# https://<<{{DocsDomain}}>>/secretsmanager/latest/apireference/API_GetSecretValue.html
raise e
end
secret = get_secret_value_response.secret_string
# Your code goes here.
end
```
# Ottieni un valore segreto usando il AWS CLI
**Autorizzazioni richieste:**`secretsmanager:GetSecretValue`
**Example Recupero del valore del segreto crittografato di un segreto**
L'esempio di [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html) seguente mostra come recuperare il valore corrente del segreto.
```
aws secretsmanager get-secret-value \
--secret-id MyTestSecret
```
**Example Recupero del valore del segreto precedente**
L'esempio di [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/get-secret-value.html) seguente mostra come recuperare il valore precedente del segreto.
```
aws secretsmanager get-secret-value \
--secret-id MyTestSecret
--version-stage AWSPREVIOUS
```
## Ottieni un gruppo di segreti in un batch utilizzando il AWS CLI
**Autorizzazioni richieste:**
+ `secretsmanager:BatchGetSecretValue`
+ `secretsmanager:GetSecretValue`autorizzazione per ogni segreto che desideri recuperare.
+ Se usi i filtri, devi avere anche `secretsmanager:ListSecrets`.
Per un esempio di policy delle autorizzazioni, consulta [Esempio: autorizzazione a recuperare un gruppo di valori segreti in un batch](auth-and-access_iam-policies.md#auth-and-access_examples_batch).
**Importante**
Se hai una policy VPCE che nega l'autorizzazione per recuperare un singolo segreto nel gruppo su cui stai agendo, `BatchGetSecretValue` non restituirà alcun valore segreto e restituirà un errore.
**Example Recupera il valore segreto per un gruppo di segreti elencati per nome**
L'esempio [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html) seguente mostra come recuperare il valore corrente del segreto.
```
aws secretsmanager batch-get-secret-value \
--secret-id-list MySecret1 MySecret2 MySecret3
```
**Example Recupera il valore segreto per un gruppo di segreti selezionati dal filtro**
L'esempio [https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html](https://docs.aws.amazon.com//cli/latest/reference/secretsmanager/batch-get-secret-value.html) seguente ottiene il valore segreto per i segreti che hanno un tag denominato "Test".
```
aws secretsmanager batch-get-secret-value \
--filters Key="tag-key",Values="Test"
```
# Ottieni un valore segreto usando la console AWS
**Per recuperare un segreto (console)**
1. Apri la console Secrets Manager all'indirizzo [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. Nell'elenco di segreti, scegli il segreto che desideri recuperare.
1. Nella sezione **Secret value** (Valore segreto) scegli **Retrieve secret value** (Recupera valore segreto).
Secrets Manager visualizza la versione corrente (`AWSCURRENT`) del segreto. Per visualizzare [altre versioni](whats-in-a-secret.md#term_version) del segreto, ad esempio `AWSPREVIOUS` versioni con etichetta personalizzata, usa [Ottieni un valore segreto usando il AWS CLI](retrieving-secrets_cli.md).
# Usa Gestione dei segreti AWS i segreti in AWS Batch
AWS Batch ti aiuta a eseguire carichi di lavoro di elaborazione in batch su. Cloud AWS Con AWS Batch, puoi inserire dati sensibili nei tuoi lavori archiviandoli in modo Gestione dei segreti AWS segreto e quindi facendo riferimento ad essi nella definizione del processo. Per ulteriori informazioni, consulta [Specifica di dati sensibili con Secrets Manager](https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data-secrets.html).
# Ottieni un Gestione dei segreti AWS segreto in una CloudFormation risorsa
Con CloudFormation, puoi recuperare un segreto da utilizzare in un'altra CloudFormation risorsa. Uno scenario comune consiste nel creare prima un segreto con una password generata da Secrets Manager e quindi recuperare il nome utente e la password dal segreto da utilizzare come credenziali per un nuovo database. Per informazioni sulla creazione di segreti con CloudFormation, consulta[Crea Gestione dei segreti AWS segreti in AWS CloudFormation](cloudformation.md).
Per recuperare un segreto in un CloudFormation modello, si utilizza un *riferimento dinamico.* Quando create lo stack, il riferimento dinamico inserisce il valore segreto nella CloudFormation risorsa, quindi non è necessario codificare le informazioni segrete. Invece, riferisciti al segreto per nome o tramite l'ARN. È possibile utilizzare un riferimento dinamico per un segreto in qualsiasi proprietà della risorsa. Non è possibile utilizzare un riferimento dinamico per un segreto nei metadati delle risorse, ad esempio [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html), perché ciò renderebbe visibile il valore del segreto nella console.
Un riferimento dinamico per un segreto ha il seguente modello:
```
{{resolve:secretsmanager:secret-id:SecretString:json-key:version-stage:version-id}}
```
**secret-id**
Il nome o l'ARN del segreto. Per accedere a un segreto nel tuo AWS account, puoi usare il nome segreto. Per accedere a un segreto in un altro AWS account, usa l'ARN del segreto.
**json-key** (Facoltativo)
Il nome della chiave della coppia chiave-valore di cui intendi recuperare il valore. Se non specifichi a`json-key`, CloudFormation recupera l'intero testo segreto. Questo segmento può non includere il carattere di due punti (`:`).
**version-stage** (Facoltativo)
La [versione](whats-in-a-secret.md#term_version) del segreto da utilizzare. Secrets Manager utilizza le etichette temporanee per tenere traccia delle differenti versioni durante il processo di rotazione. Se utilizzi `version-stage`, non specificare `version-id`. Se non specifichi né `version-stage` né `version-id`, la versione di default sarà la `AWSCURRENT`. Questo segmento può non includere il carattere di due punti (`:`).
**version-id** (Facoltativo)
L'identificatore univoco della versione del segreto da utilizzare. Se specifichi `version-id`, non è necessario specificare anche `version-stage`. Se non specifichi né `version-stage` né `version-id`, la versione di default sarà la `AWSCURRENT`. Questo segmento può non includere il carattere di due punti (`:`).
Per ulteriori informazioni, consulta [Utilizzo di riferimenti dinamici per specificare i segreti di Secrets Manager](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html#dynamic-references-secretsmanager).
**Nota**
Non create un riferimento dinamico utilizzando una barra rovesciata `(\)` come valore finale. CloudFormation non è in grado di risolvere tali riferimenti, il che causa un errore di risorse.
# Usa Gestione dei segreti AWS i segreti nei GitHub lavori
Per utilizzare un segreto in un GitHub lavoro, puoi utilizzare un' GitHub azione per recuperare segreti da Gestione dei segreti AWS e aggiungerli come [variabili di ambiente](https://docs.github.com/en/actions/learn-github-actions/environment-variables) mascherate nel tuo GitHub flusso di lavoro. *Per ulteriori informazioni sulle GitHub azioni, consulta [Understanding GitHub Actions](https://docs.github.com/en/actions/learn-github-actions/understanding-github-actions) in the GitHub Docs.*
Quando aggiungi un segreto al tuo GitHub ambiente, questo è disponibile per tutte le altre fasi del tuo GitHub lavoro. Segui le indicazioni contenute in [Security Hardening for GitHub Actions per](https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions) evitare che i segreti presenti nel tuo ambiente vengano utilizzati in modo improprio.
È possibile impostare l'intera stringa nel valore segreto come valore della variabile di ambiente oppure, se la stringa è JSON, è possibile analizzare il JSON per impostare variabili di ambiente individuali per ogni coppia chiave-valore JSON. Se il valore segreto è binario, l'operazione lo converte in una stringa.
Per visualizzare le variabili di ambiente create dai tuoi segreti, attiva la registrazione del debug. *Per ulteriori informazioni, consulta [Abilitazione della registrazione di debug nei Documenti.](https://docs.github.com/en/actions/monitoring-and-troubleshooting-workflows/enabling-debug-logging) GitHub *
*Per utilizzare le variabili di ambiente create dai tuoi segreti, consulta [Variabili di ambiente nei Documenti](https://docs.github.com/en/actions/learn-github-actions/environment-variables). GitHub *
## Prerequisiti
Per utilizzare questa azione, devi prima configurare AWS le credenziali e impostarle Regione AWS nel tuo GitHub ambiente utilizzando la `configure-aws-credentials` procedura. Segui le istruzioni riportate nella sezione [Configurazione AWS delle credenziali Action for GitHub Actions](https://github.com/aws-actions/configure-aws-credentials) to **Assume il ruolo direttamente utilizzando il provider GitHub OIDC**. Ciò consente di utilizzare credenziali di breve durata ed evitare di memorizzare chiavi di accesso aggiuntive al di fuori di Gestione dei segreti.
Il ruolo IAM assunto dall'operazione deve disporre delle seguenti autorizzazioni:
+ `GetSecretValue` sui segreti che desideri recuperare.
+ `ListSecrets` su tutti i segreti.
+ (Facoltativo) `Decrypt` KMS key se i segreti sono crittografati con un. chiave gestita dal cliente
Per ulteriori informazioni, consulta [Autenticazione e controllo degli accessi per Gestione dei segreti AWS](auth-and-access.md).
## Utilizzo
Per utilizzare l'operazione, aggiungi un passaggio al flusso di lavoro che utilizza la seguente sintassi.
```
- name: Step name
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
secretId1
ENV_VAR_NAME, secretId2
name-transformation: (Optional) uppercase|lowercase|none
parse-json-secrets: (Optional) true|false
```Parameters
`secret-ids`
ARN segreti, nomi e prefissi dei nomi.
Per impostare il nome della variabile di ambiente, inseriscilo prima dell'ID del segreto, seguito da una virgola. Ad esempio, `ENV_VAR_1, secretId` crea una variabile di ambiente denominata **ENV\$1VAR\$11** dal `secretId` del segreto. Il nome della variabile di ambiente può contenere lettere maiuscole, numeri e il carattere di sottolineatura.
Per utilizzare un prefisso, inserisci almeno tre caratteri seguiti da un asterisco. Ad esempio, `dev*` abbina tutti i segreti con un nome che inizia in **dev**. Possono essere recuperati fino a 100 segreti corrispondenti. Se imposti il nome della variabile e il prefisso trova corrispondenze con più segreti, l'operazione ha esito negativo.
`name-transformation`
Per impostazione predefinita, la fase crea ogni nome di variabile di ambiente dal nome del segreto, trasformato in modo da includere solo lettere maiuscole, numeri e caratteri di sottolineatura e in modo che non inizi con un numero. Per le lettere del nome, puoi configurare il passaggio in cui utilizzare lettere minuscole con `lowercase` o non modificare le lettere maiuscole con. `none` Il valore predefinito è `uppercase`.
`parse-json-secrets`
(Facoltativo) Per impostazione predefinita, l'operazione imposta il valore della variabile di ambiente sull'intera stringa JSON nel valore del segreto. Imposta `parse-json-secrets` per `true` creare variabili di ambiente per ogni coppia chiave-valore in JSON.
Ricorda che se il JSON utilizza chiavi con distinzione tra maiuscole e minuscole (come "nome" e "Nome"), l'operazione risconterà conflitti di nomi duplicati. In questo caso, imposta `parse-json-secrets` su `false` e analizza il valore segreto JSON separatamente.
## Denominazione delle variabili di ambiente
Le variabili di ambiente create dall'azione hanno lo stesso nome dei segreti da cui provengono. Le variabili di ambiente hanno requisiti di denominazione più rigorosi rispetto ai segreti, quindi l'azione trasforma i nomi segreti per soddisfare tali requisiti. Ad esempio, l'operazione trasforma le lettere minuscole in lettere maiuscole. Se si analizza il codice JSON del segreto, il nome della variabile di ambiente include sia il nome segreto che il nome della chiave JSON, ad esempio. `MYSECRET_KEYNAME` È possibile configurare l'azione per non trasformare le lettere minuscole.
Se due variabili di ambiente finiscono con lo stesso nome, l'azione ha esito negativo. In questo caso, è necessario specificare i nomi che si desidera utilizzare per le variabili di ambiente come *alias*.
Esempi di casi in cui i nomi potrebbero essere in conflitto:
+ Un segreto chiamato "MySecret" e un segreto chiamato «mysecret» diventerebbero entrambi variabili di ambiente denominate «MYSECRET».
+ Un segreto denominato «SECRET\$1keyname» e un segreto analizzato in JSON denominato «Secret» con una chiave denominata «keyname» diventerebbero entrambi variabili di ambiente denominate «SECRET\$1KEYNAME».
È possibile impostare il nome della variabile di ambiente specificando un *alias, come illustrato nell'esempio seguente, che crea* una variabile denominata. `ENV_VAR_NAME`
```
secret-ids: |
ENV_VAR_NAME, secretId2
```
**Alias vuoti**
+ Se imposti `parse-json-secrets: true` e inserisci un alias vuoto, seguito da una virgola e quindi dall'ID segreto, l'azione assegna alla variabile di ambiente lo stesso nome delle chiavi JSON analizzate. I nomi delle variabili non includono il nome segreto.
Se il segreto non contiene un codice JSON valido, l'azione crea una variabile di ambiente e la nomina con lo stesso nome del segreto.
+ Se imposti `parse-json-secrets: false` e inserisci un alias vuoto, seguito da una virgola e dall'ID segreto, l'azione nomina le variabili di ambiente come se non avessi specificato un alias.
L'esempio seguente mostra un alias vuoto.
```
,secret2
```
## Esempi
**Example 1 Recupera segreti per nome e per ARN**
L'esempio seguente crea variabili di ambiente per i segreti identificati dal nome e dall'ARN.
```
- name: Get secrets by name and by ARN
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
exampleSecretName
arn:aws:secretsmanager:us-east-2:123456789012:secret:test1-a1b2c3
0/test/secret
/prod/example/secret
SECRET_ALIAS_1,test/secret
SECRET_ALIAS_2,arn:aws:secretsmanager:us-east-2:123456789012:secret:test2-a1b2c3
,secret2
```
Variabili di ambiente create:
```
EXAMPLESECRETNAME: secretValue1
TEST1: secretValue2
_0_TEST_SECRET: secretValue3
_PROD_EXAMPLE_SECRET: secretValue4
SECRET_ALIAS_1: secretValue5
SECRET_ALIAS_2: secretValue6
SECRET2: secretValue7
```
**Example 2 Recupera tutti i segreti che iniziano con un prefisso**
L'esempio seguente crea variabili di ambiente per tutti i segreti con nomi che iniziano con*beta*.
```
- name: Get Secret Names by Prefix
uses: 2
with:
secret-ids: |
beta* # Retrieves all secrets that start with 'beta'
```
Variabili di ambiente create:
```
BETASECRETNAME: secretValue1
BETATEST: secretValue2
BETA_NEWSECRET: secretValue3
```
**Example 3 Analizza il JSON nel segreto**
L'esempio di seguito crea variabili di ambiente analizzando il JSON nel segreto.
```
- name: Get Secrets by Name and by ARN
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: |
test/secret
,secret2
parse-json-secrets: true
```
Il segreto `test/secret` ha il seguente valore segreto.
```
{
"api_user": "user",
"api_key": "key",
"config": {
"active": "true"
}
}
```
Il segreto `secret2` ha il seguente valore segreto.
```
{
"myusername": "alejandro_rosalez",
"mypassword": "EXAMPLE_PASSWORD"
}
```
Variabili di ambiente create:
```
TEST_SECRET_API_USER: "user"
TEST_SECRET_API_KEY: "key"
TEST_SECRET_CONFIG_ACTIVE: "true"
MYUSERNAME: "alejandro_rosalez"
MYPASSWORD: "EXAMPLE_PASSWORD"
```
**Example 4 Usa lettere minuscole per i nomi delle variabili di ambiente**
L'esempio seguente crea una variabile di ambiente con un nome minuscolo.
```
- name: Get secrets
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: exampleSecretName
name-transformation: lowercase
```
Variabile di ambiente creata:
```
examplesecretname: secretValue
```
# Uso Gestione dei segreti AWS in GitLab
Gestione dei segreti AWS si integra con GitLab. Puoi sfruttare i segreti di Secrets Manager per proteggere GitLab le tue credenziali in modo che non siano più codificate. GitLab Invece, [GitLab Runner](https://docs.gitlab.com/runner/) recupera questi segreti da Secrets Manager quando l'applicazione esegue un lavoro nelle pipeline GitLab CI/CD.
Per utilizzare questa integrazione, creerai un [provider di identità OpenID Connect (OIDC) in IAM AWS Identity and Access Management e un ruolo IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html). Ciò consente a GitLab Runner di accedere al tuo segreto di Secrets Manager. [Per ulteriori informazioni su GitLab CI/CD e OIDC, consulta la documentazione. GitLab](https://docs.gitlab.com/ci/cloud_services/aws/)
## Considerazioni
Se utilizzi un' GitLab istanza non pubblica, non puoi utilizzare questa integrazione di Secrets Manager. Consulta invece la [GitLab documentazione per le istanze non pubbliche](https://docs.gitlab.com/ci/cloud_services/aws/#configure-a-non-public-gitlab-instance).
## Prerequisiti
Per integrare Secrets Manager con GitLab, completa i seguenti prerequisiti:
1.
**Crea un segreto Gestione dei segreti AWS**
Avrai bisogno di un segreto di Secrets Manager che verrà recuperato nel tuo GitLab lavoro ed elimina la necessità di codificare queste credenziali. Avrai bisogno dell'ID segreto di Secrets Manager per [configurare la tua GitLab pipeline](#configure-gitlab-pipeline). Per ulteriori informazioni, consulta [Crea un Gestione dei segreti AWS segreto](create_secret.md).
1.
**Crea GitLab il tuo provider OIDC nella console IAM.**
In questo passaggio, creerai GitLab il tuo provider OIDC nella console IAM. [Per ulteriori informazioni, consulta [Create an Identity Provider OpenID Connect (OIDC)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_providers_create_oidc.html) e documentazione. GitLab](https://docs.gitlab.com/ci/cloud_services/aws/)
Quando crei il provider OIDC nella console IAM, utilizza le seguenti configurazioni:
1. Imposta il sulla tua `provider URL` istanza. GitLab Ad esempio, **gitlab.example.com**.
1. Imposta `audience` o `aud` su**sts.amazonaws.com**.
1.
**Crea un ruolo e una policy IAM**
Dovrai creare un ruolo e una policy IAM. Questo ruolo è assunto da GitLab with [AWS Security Token Service (STS)](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html). Per ulteriori informazioni, consulta [Creare un ruolo utilizzando politiche di attendibilità personalizzate](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-custom.html).
1. Nella console IAM, utilizza le seguenti impostazioni durante la creazione del ruolo IAM:
+ Imposta `Trusted entity type` su **Web identity**.
+ Imposta `Group` su **your GitLab group**.
+ Imposta `Identity provider` lo stesso URL del provider (l'[GitLab istanza](#step2-oidc-provider)) che hai utilizzato nel passaggio 2.
+ `Audience`Impostalo sullo stesso [pubblico](#step2-oidc-audience) che hai usato nel passaggio 2.
1. Di seguito è riportato un esempio di politica di fiducia che consente di GitLab assumere ruoli. La tua politica di fiducia dovrebbe elencare Account AWS il tuo GitLab URL e il [percorso del progetto](https://docs.gitlab.com/user/project/).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRoleWithWebIdentity",
"Principal": {
"Federated": "arn:aws:iam::111122223333:oidc-provider/gitlab.example.com"
},
"Condition": {
"StringEquals": {
"gitlab.example.com:aud": [
"sts.amazon.com"
]
},
"StringLike": {
"gitlab.example.com:sub": [
"project_path:mygroup/project-*:ref_type:branch-*:ref:main*"
]
}
}
}
]
}
```
1. Dovrai anche creare una policy IAM per consentire GitLab l'accesso a Gestione dei segreti AWS. Puoi aggiungere questa politica alla tua politica di fiducia. Per ulteriori informazioni, consulta [Creare politiche IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "secretsmanager:GetSecretValue",
"Resource": "arn:aws:secretsmanager:us-east-1:111122223333:secret:your-secret"
}
]
}
```
## Integrazione con Gestione dei segreti AWS GitLab
Dopo aver completato i prerequisiti, puoi configurare GitLab l'utilizzo di Secrets Manager per proteggere le tue credenziali.
### Configurare la GitLab pipeline per utilizzare Secrets Manager
Dovrai aggiornare il [file di configurazione GitLab CI/CD](https://docs.gitlab.com/ci/yaml/yaml_optimization/) con le seguenti informazioni:
+ Il pubblico del token impostato su STS.
+ L'ID segreto di Secrets Manager.
+ Il ruolo IAM che vuoi che GitLab Runner assuma durante l'esecuzione di lavori nella GitLab pipeline.
+ Il Regione AWS luogo in cui è archiviato il segreto.
GitLab recupera il segreto da Secrets Manager e memorizza il valore in un file temporaneo. Il percorso di questo file è memorizzato in una CI/CD variabile, simile alle variabili [CI/CD di tipo file](https://docs.gitlab.com/ci/variables/#use-file-type-cicd-variables).
Quanto segue è un frammento del file YAML per un file di configurazione CI/CD: GitLab
```
variables:
AWS_REGION: us-east-1
AWS_ROLE_ARN: 'arn:aws:iam::111122223333:role/gitlab-role'
job:
id_tokens:
AWS_ID_TOKEN:
aud: 'sts.amazonaws.com'
secrets:
DATABASE_PASSWORD:
aws_secrets_manager:
secret_id: "arn:aws:secretsmanager:us-east-1:111122223333:secret:secret-name"
```
Per ulteriori informazioni, consulta la [documentazione sull'integrazione di GitLab Secrets Manager](https://docs.gitlab.com/ci/secrets/aws_secrets_manager/).
Facoltativamente, puoi testare la tua configurazione OIDC in. GitLab Per ulteriori informazioni, [GitLab consulta la documentazione per testare la configurazione OIDC](https://docs.gitlab.com/ci/cloud_services/aws/#test-the-oidc-configuration).
## Risoluzione dei problemi
Quanto segue può aiutarti a risolvere i problemi più comuni che potresti riscontrare durante l'integrazione di Secrets Manager con. GitLab
### GitLab Problemi relativi alla pipeline
Se riscontri problemi relativi alla GitLab pipeline, accertati di quanto segue:
+ Il file YAML è formattato correttamente. Per ulteriori informazioni, consulta la [documentazione di GitLab](https://docs.gitlab.com/ee/ci/yaml/).
+ La tua GitLab pipeline sta assumendo il ruolo corretto, dispone delle autorizzazioni appropriate e dell'accesso al segreto corretto. Gestione dei segreti AWS
### Risorse aggiuntive
Le seguenti risorse possono aiutarti a risolvere i problemi relativi a e: GitLab Gestione dei segreti AWS
+ [GitLab Risoluzione dei problemi OIDC](https://docs.gitlab.com/ci/cloud_services/aws/#troubleshooting)
+ [Esecuzione del debug della pipeline CI/CD GitLab ](https://docs.gitlab.com/ee/ci/troubleshooting.html)
+ [Risoluzione dei problemi](ascp-eks-installation.md#troubleshooting)
# Usa Gestione dei segreti AWS i segreti in AWS IoT Greengrass
AWS IoT Greengrass è un software che estende le funzionalità cloud ai dispositivi locali. Consente ai dispositivi di raccogliere e analizzare i dati più vicini all'origine delle informazioni, reagire autonomamente a eventi locali e comunicare in modo sicuro tra di loro sulle reti locali.
AWS IoT Greengrass consente l'autenticazione con servizi e applicazioni da AWS IoT Greengrass dispositivi senza password, token o altri segreti codificati. Puoi utilizzarlo per archiviare e Gestione dei segreti AWS gestire in modo sicuro i tuoi segreti nel cloud. AWS IoT Greengrass estende Secrets Manager ai dispositivi AWS IoT Greengrass principali, in modo che i connettori e le funzioni Lambda possano utilizzare i segreti locali per interagire con servizi e applicazioni.
Per integrare un segreto in un AWS IoT Greengrass gruppo, si crea una risorsa di gruppo che fa riferimento al segreto di Secrets Manager. Questa risorsa segreta fa riferimento al segreto cloud utilizzando l'ARN associato. Per informazioni su come creare, gestire e utilizzare risorse segrete, consulta [Lavorare con le risorse segrete](https://docs.aws.amazon.com/greengrass/latest/developerguide/secrets-using.html) nella Guida per gli AWS IoT sviluppatori.
Per distribuire segreti nel AWS IoT Greengrass core, consulta [Distribuire segreti nel AWS IoT Greengrass](https://docs.aws.amazon.com/greengrass/latest/developerguide/secrets.html) core.
# Usa Gestione dei segreti AWS i segreti in Parameter Store
AWS Systems Manager Parameter Store fornisce uno storage sicuro e gerarchico per la gestione dei dati di configurazione e la gestione dei segreti. È possibile archiviare dati, ad esempio le password, le stringhe di database e i codici di licenza, come valori dei parametri. Tuttavia, Archivio parametri non fornisce servizi di rotazione automatica per i segreti archiviati. Al contrario, Archivio parametri consente di archiviare il segreto in Secrets Manager e quindi fare riferimento al segreto come a un parametro di Parameter Store.
Quando si configura l'archivio parametri con Secrets Manager, l'archivio parametri `secret-id` richiede una barra (/) prima della stringa del nome.
*Per ulteriori informazioni, vedere [Referencing Gestione dei segreti AWS Secrets from Parameters di Parameter Store nella Guida](https://docs.aws.amazon.com/systems-manager/latest/userguide/integration-ps-secretsmanager.html) per l'AWS Systems Manager utente.*