Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Obtenez des secrets auprès de AWS Secrets Manager
Secrets Manager génère une entrée de CloudTrail journal lorsque vous récupérez un secret. Pour de plus amples informations, veuillez consulter [Enregistrez AWS Secrets Manager les événements avec 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)
+ [Agent du Gestionnaire des Secrets](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 emplois](retrieving-secrets_github.md)
+ [GitLab](integrating_gitlab.md)
+ [AWS IoT Greengrass](integrating-greengrass.md)
+ [Parameter Store](integrating_parameterstore.md)
# Obtenir une valeur secrète de Secrets Manager à l'aide de Java
Dans les applications, vous pouvez récupérer vos secrets en appelant `GetSecretValue` ou `BatchGetSecretValue` dans l'un des AWS SDKs. Cependant, nous vous recommandons de mettre en cache vos valeurs de secret à l'aide de la mise en cache côté client. La mise en cache des secrets améliore la vitesse et réduit vos coûts.
Pour vous connecter à une base de données à l'aide des informations d'identification contenues dans un code secret, vous pouvez utiliser les pilotes de connexion SQL Secrets Manager, qui encapsulent le pilote JDBC de base. Cela utilise également la mise en cache côté client, ce qui permet de réduire le coût d'appel de Secrets Manager. APIs
**Topics**
+ [Obtenez une valeur secrète de Secrets Manager à l'aide de Java avec mise en cache côté client](retrieving-secrets_cache-java.md)
+ [Connectez-vous à une base de données SQL à l'aide de JDBC avec des informations d'identification enregistrées dans un secret AWS Secrets Manager](retrieving-secrets_jdbc.md)
+ [Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK Java](retrieving-secrets-java-sdk.md)
# Obtenez une valeur secrète de Secrets Manager à l'aide de Java avec mise en cache côté client
Lorsque vous récupérez un secret, vous pouvez utiliser le composant de mise en cache basé sur Java de Secrets Manager pour le mettre en cache en vue d'une utilisation future. Il est plus rapide de récupérer un secret mis en cache que de le récupérer à partir de Secrets Manager. L'appel de Secrets Manager étant payant APIs, l'utilisation d'un cache peut vous permettre de réduire vos coûts. Pour connaître toutes les manières dont vous pouvez récupérer des secrets, consultez[Obtenez des secrets](retrieving-secrets.md).
La politique de cache est la moins récemment utilisée (LRU). Ainsi, lorsque le cache doit supprimer un secret, il supprime le secret le moins récemment utilisé. Par défaut, le cache actualise les secrets toutes les heures. Vous pouvez configurer [la fréquence d'actualisation du secret](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md#retrieving-secrets_cache-java-ref_SecretCacheConfiguration_methods-getCacheItemTTL) dans le cache et [utiliser un hook pour la récupération du secret](retrieving-secrets_cache-java-ref_SecretCacheHook.md) afin d’ajouter plus de fonctionnalités.
Le cache ne force pas le récupérateur de mémoire une fois que les références du cache sont libérées. L'implémentation du cache n'inclut pas l'invalidation du cache. L'implémentation du cache se concentre sur le cache lui-même et n'est pas renforcée ou ciblée sur le plan de la sécurité. Si vous avez besoin d'une sécurité supplémentaire, telle que le chiffrement d'éléments dans le cache, utilisez les interfaces et les méthodes abstraites fournies.
Pour pouvoir utiliser le composant, vous devez disposer des éléments suivants :
+ Environnement de développement Java 8 ou une version ultérieure. Consultez [Java SE Downloads](https://www.oracle.com/technetwork/java/javase/downloads/index.html) sur le site web d'Oracle.
Pour télécharger le code source, consultez le [composant client de mise en cache basé sur Java de Secrets Manager](https://github.com/aws/aws-secretsmanager-caching-java) sur. GitHub
Pour ajouter le composant à votre projet, dans votre fichier Maven pom.xml, intégrez la dépendance suivante. Pour plus d'informations sur Maven, consultez le [Getting Started Guide](https://maven.apache.org/guides/getting-started/index.html) sur le site web Apache Maven Project.
```
com.amazonaws.secretsmanager
aws-secretsmanager-caching-java
1.0.2
```
**Autorisations requises : **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Pour de plus amples informations, veuillez consulter [Référence des autorisations ](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 Récupérer un secret**
L'exemple de code suivant montre une fonction Lambda qui récupère une chaîne de secret. Il respecte les [bonnes pratiques](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html) consistant à instancier le cache en dehors du gestionnaire de fonctions, de sorte qu'il ne continue pas d'appeler l'API si vous appelez à nouveau la fonction 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
Un cache en mémoire pour les secrets demandés à Secrets Manager. Vous utilisez [getSecretString](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretString) ou [getSecretBinary](#retrieving-secrets_cache-java-ref_SecretCache-methods-getSecretBinary) pour récupérer un secret du cache. Vous pouvez configurer les paramètres de cache en transmettant un objet [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md) dans le constructeur.
Pour plus d'informations, ainsi que pour voir des exemples, consultez [Obtenez une valeur secrète de Secrets Manager à l'aide de Java avec mise en cache côté client](retrieving-secrets_cache-java.md).
## Constructeurs
`public SecretCache()`
Constructeur par défaut d'un objet `SecretCache`.
`public SecretCache(AWSSecretsManagerClientBuilder builder)`
Crée un cache à l'aide d'un client Secrets Manager créé à l'aide du [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) fourni. Utilisez ce constructeur pour personnaliser le client Secrets Manager, par exemple pour utiliser une région ou un point de terminaison spécifique.
`public SecretCache(AWSSecretsManager client)`
Crée un cache de secret à l'aide du [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) fourni. Utilisez ce constructeur pour personnaliser le client Secrets Manager, par exemple pour utiliser une région ou un point de terminaison spécifique.
`public SecretCache(SecretCacheConfiguration config)`
Crée un cache de secret à l'aide du `SecretCacheConfiguration` fourni.
## Méthodes
### getSecretString
`public String getSecretString(final String secretId)`
Récupère un secret de chaîne dans Secrets Manager. Retourne un [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)`
Récupère un secret binaire dans Secrets Manager. Retourne 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`
Force l'actualisation du cache. Renvoie `true` si l'actualisation s'est terminée sans erreur, sinon `false`.
### close
`public void close()`
Ferme le cache.
# SecretCacheConfiguration
Options de configuration du cache pour un [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md), telles que la taille maximale du cache et la durée de vie (TTL) pour les secrets mis en cache.
## Constructeur
`public SecretCacheConfiguration`
Constructeur par défaut d'un objet `SecretCacheConfiguration`.
## Méthodes
### getClient
`public AWSSecretsManager getClient()`
Renvoie le [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) dont le cache récupère les secrets.
### setClient
`public void setClient(AWSSecretsManager client)`
Définit le 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) à partir desquels le cache récupère des secrets.
### getCacheHook
`public SecretCacheHook getCacheHook()`
Renvoie l'interface [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) utilisée pour raccorder les mises à jour du cache.
### setCacheHook
`public void setCacheHook(SecretCacheHook cacheHook)`
Définit l'interface [SecretCacheHook](retrieving-secrets_cache-java-ref_SecretCacheHook.md) utilisée pour raccorder les mises à jour du cache.
### getMaxCacheTaille
`public int getMaxCacheSize()`
Renvoie la taille maximale du cache. La valeur par défaut est de 1 024 secrets.
### setMaxCacheTaille
`public void setMaxCacheSize(int maxCacheSize)`
Définit la taille maximale du cache. La valeur par défaut est de 1 024 secrets.
### getCacheItemTTL
`public long getCacheItemTTL()`
Renvoie la durée de vie (TTL) en millisecondes pour les éléments mis en cache. Lorsqu'un secret mis en cache dépasse cette durée de vie, le cache récupère une nouvelle copie du secret à partir du [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). La valeur par défaut est de 1 heure en millisecondes.
Le cache actualise le secret de manière synchrone lorsque le secret est demandé après la durée de vie. Si l'actualisation synchrone échoue, le cache renvoie le secret obsolète.
### setCacheItemTTL
`public void setCacheItemTTL(long cacheItemTTL)`
Définit la durée de vie (TTL) en millisecondes pour les éléments mis en cache. Lorsqu'un secret mis en cache dépasse cette durée de vie, le cache récupère une nouvelle copie du secret à partir du [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). La valeur par défaut est de 1 heure en millisecondes.
### getVersionStage
`public String getVersionStage()`
Renvoie la version des secrets que vous souhaitez mettre en cache. Pour plus d'informations, consultez [Versions de secret](whats-in-a-secret.md#term_version). La valeur par défaut est ` "AWSCURRENT"`.
### setVersionStage
`public void setVersionStage(String versionStage)`
Définit la version des secrets que vous souhaitez mettre en cache. Pour plus d'informations, consultez [Versions de secret](whats-in-a-secret.md#term_version). La valeur par défaut est `"AWSCURRENT"`.
### SecretCacheConfiguration Avec le client
`public SecretCacheConfiguration withClient(AWSSecretsManager client)`
Définit le [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) pour en récupérer des secrets. Renvoie l'objet `SecretCacheConfiguration` mis à jour avec le nouveau paramètre.
### SecretCacheConfiguration withCacheHook
`public SecretCacheConfiguration withCacheHook(SecretCacheHook cacheHook)`
Définit l'interface utilisée pour raccorder le cache en mémoire. Renvoie l'objet `SecretCacheConfiguration` mis à jour avec le nouveau paramètre.
### SecretCacheConfiguration withMaxCacheTaille
`public SecretCacheConfiguration withMaxCacheSize(int maxCacheSize)`
Définit la taille maximale du cache. Renvoie l'objet `SecretCacheConfiguration` mis à jour avec le nouveau paramètre.
### SecretCacheConfiguration withCacheItemTTL
`public SecretCacheConfiguration withCacheItemTTL(long cacheItemTTL)`
Définit la durée de vie (TTL) en millisecondes pour les éléments mis en cache. Lorsqu'un secret mis en cache dépasse cette durée de vie, le cache récupère une nouvelle copie du secret à partir du [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). La valeur par défaut est de 1 heure en millisecondes. Renvoie l'objet `SecretCacheConfiguration` mis à jour avec le nouveau paramètre.
### SecretCacheConfiguration withVersionStage
`public SecretCacheConfiguration withVersionStage(String versionStage)`
Définit la version des secrets que vous souhaitez mettre en cache. Pour plus d'informations, consultez [Versions de secret](whats-in-a-secret.md#term_version). Renvoie l'objet `SecretCacheConfiguration` mis à jour avec le nouveau paramètre.
# SecretCacheHook
Une interface pour se connecter à un [SecretCache](retrieving-secrets_cache-java-ref_SecretCache.md) pour effectuer des actions sur les secrets stockés dans le cache.
## put
`Object put(final Object o)`
Préparez l'objet en vue de son stockage dans le cache.
Renvoie l'objet à stocker dans le cache.
## get
`Object get(final Object cachedObject)`
Dérivez l'objet de l'objet mis en cache.
Renvoie l'objet à renvoyer à partir du cache
# Connectez-vous à une base de données SQL à l'aide de JDBC avec des informations d'identification enregistrées dans un secret AWS Secrets Manager
Dans les applications Java, vous pouvez utiliser les pilotes de connexion SQL Secrets Manager pour vous connecter aux bases de données MySQL, PostgreSQL, Oracle MSSQLServer, Db2 et Redshift à l'aide des informations d'identification stockées dans Secrets Manager. Chaque pilote encapsule le pilote JDBC de base, vous pouvez donc utiliser des appels JDBC pour accéder à votre base de données. Cependant, au lieu de transmettre un nom d'utilisateur et un mot de passe pour la connexion, vous fournissez l'ID d'un secret. Le pilote appelle Secrets Manager pour récupérer la valeur du secret, puis utilise les informations d'identification dans le secret pour se connecter à la base de données. Le pilote met également en cache les informations d'identification à l'aide de la [bibliothèque de mise en cache côté client Java](retrieving-secrets_cache-java.md), de sorte que les futures connexions ne nécessitent pas d'effectuer d'appel à Secrets Manager. Par défaut, le cache est actualisé toutes les heures et également lors de la rotation du secret. Pour configurer le cache, consultez [SecretCacheConfiguration](retrieving-secrets_cache-java-ref_SecretCacheConfiguration.md).
Vous pouvez télécharger le code source à partir de [GitHub](https://github.com/aws/aws-secretsmanager-jdbc ).
Pour utiliser les pilotes de connexion SQL Secrets Manager :
+ Votre application doit être en Java 8 ou une version ultérieure.
+ Votre secret doit être parmi les suivants :
+ Un [secret de base de données dans la structure JSON attendue](reference_secret_json_structure.md). Pour vérifier le format, dans la console Secrets Manager, affichez votre secret et sélectionnez **Retrieve secret value** (Récupérer la valeur du secret). Sinon, dans le AWS CLI, appelez [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html).
+ Un [secret géré](integrating_how-services-use-secrets_RDS.md) par Amazon RDS. Pour ce type de secret, vous devez spécifier un point de terminaison et un port lorsque vous établissez la connexion.
+ Un secret [géré](integrating_how-services-use-secrets_RS.md) par Amazon Redshift. Pour ce type de secret, vous devez spécifier un point de terminaison et un port lorsque vous établissez la connexion.
Si votre base de données est répliquée vers d'autres régions, pour vous connecter à une base de données de réplica dans une autre région, vous spécifiez le point de terminaison et le port régionaux lorsque vous créez la connexion. Vous pouvez stocker les informations de connexion régionales dans le secret sous forme de key/value paires supplémentaires, dans les paramètres du magasin de paramètres SSM ou dans la configuration de votre code.
Pour ajouter le pilote à votre projet, dans votre fichier de création Maven `pom.xml`, ajoutez la dépendance suivante pour le pilote. Pour plus d'informations, consultez [Secrets Manager SQL Connection Library](https://search.maven.org/artifact/com.amazonaws.secretsmanager/aws-secretsmanager-jdbc) (français non garanti) sur le site web de Maven Central Repository.
```
com.amazonaws.secretsmanager
aws-secretsmanager-jdbc
1.0.12
```
Le pilote utilise 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). Si vous exécutez le pilote sur Amazon EKS, il est possible qu'il récupère les informations d'identification du nœud sur lequel il s'exécute au lieu du rôle de compte de service. Pour résoudre ce problème, ajoutez la version 1 de `com.amazonaws:aws-java-sdk-sts` à votre fichier de projet Gradle ou Maven en tant que dépendance.
Pour définir une URL de point de terminaison AWS PrivateLink DNS et une région dans le `secretsmanager.properties` fichier :
```
drivers.vpcEndpointUrl = endpoint URL
drivers.vpcEndpointRegion = endpoint region
```
Pour remplacer la région principale, définissez la variable d'environnement `AWS_SECRET_JDBC_REGION` ou apportez les modifications suivantes au fichier `secretsmanager.properties` :
```
drivers.region = region
```
**Autorisations requises : **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Pour de plus amples informations, veuillez consulter [Référence des autorisations ](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [Établir une connexion à une base de données](#retrieving-secrets_jdbc_example)
+ [Établir une connexion en spécifiant le point de terminaison et le port](#retrieving-secrets_jdbc_example_replica)
+ [Utiliser le regroupement de connexions c3p0 pour établir une connexion](#retrieving-secrets_jdbc_example_c3po)
+ [Utiliser le regroupement de connexions c3p0 pour établir une connexion en spécifiant le point de terminaison et le port](#retrieving-secrets_jdbc_example_c3p0_replica)
## Établir une connexion à une base de données
L'exemple suivant montre comment établir une connexion à une base de données à l'aide des informations d'identification et de connexion dans un secret. Une fois la connexion établie, vous pouvez utiliser les appels JDBC pour accéder à la base de données. Pour plus d'informations, consultez [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sur le site web dédié à la documentation 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);
```
------
## Établir une connexion en spécifiant le point de terminaison et le port
L'exemple suivant montre comment établir une connexion avec une base de données en utilisant les informations d'identification dans un secret avec un point de terminaison et un port que vous devez spécifier.
[Les secrets gérés par Amazon RDS](integrating_how-services-use-secrets_RDS.md) n'incluent pas le point de terminaison et le port de la base de données. Pour vous connecter à une base de données à l'aide d'informations d'identification principales dans un secret géré par Amazon RDS, vous devez les spécifier dans votre code.
[Les secrets répliqués vers d'autres régions](replicate-secrets.md) peuvent améliorer la latence de la connexion à la base de données régionale, mais ils ne contiennent pas d'informations de connexion différentes de celles du secret source. Chaque réplica est une copie du secret source. Pour stocker les informations de connexion régionales dans le secret, ajoutez des key/value paires supplémentaires pour les informations de point de terminaison et de port pour les régions.
Une fois la connexion établie, vous pouvez utiliser les appels JDBC pour accéder à la base de données. Pour plus d'informations, consultez [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sur le site web dédié à la documentation 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.govskope.ca.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.govskope.ca.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);
```
------
## Utiliser le regroupement de connexions c3p0 pour établir une connexion
L'exemple suivant montre comment établir un groupement de connexions à l'aide d'un `c3p0.properties` fichier qui se sert du pilote pour récupérer les informations d'identification et de connexion à partir du secret. Pour `user` et `jdbcUrl`, saisissez l'ID secret pour configurer le groupe de connexions. Vous pouvez ensuite récupérer les connexions du groupe et les utiliser comme n'importe quelle autre connexion de base de données. Pour plus d'informations, consultez [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sur le site web dédié à la documentation Java.
Pour plus d'informations sur c3p0, consultez [c3p0](https://www.mchange.com/projects/c3p0/) sur le site 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
```
------
## Utiliser le regroupement de connexions c3p0 pour établir une connexion en spécifiant le point de terminaison et le port
L'exemple suivant montre comment établir un pool de connexions avec un `c3p0.properties` fichier qui utilise le pilote pour récupérer des informations d'identification dans un secret avec un point de terminaison et un port que vous spécifiez. Vous pouvez ensuite récupérer les connexions du groupe et les utiliser comme n'importe quelle autre connexion de base de données. Pour plus d'informations, consultez [JDBC Basics](https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html) sur le site web dédié à la documentation Java.
[Les secrets gérés par Amazon RDS](integrating_how-services-use-secrets_RDS.md) n'incluent pas le point de terminaison et le port de la base de données. Pour vous connecter à une base de données à l'aide d'informations d'identification principales dans un secret géré par Amazon RDS, vous devez les spécifier dans votre code.
[Les secrets répliqués vers d'autres régions](replicate-secrets.md) peuvent améliorer la latence de la connexion à la base de données régionale, mais ils ne contiennent pas d'informations de connexion différentes de celles du secret source. Chaque réplica est une copie du secret source. Pour stocker les informations de connexion régionales dans le secret, ajoutez des key/value paires supplémentaires pour les informations de point de terminaison et de port pour les régions.
------
#### [ 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
```
------
# Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK Java
Dans les applications, vous pouvez récupérer vos secrets en appelant `GetSecretValue` ou `BatchGetSecretValue` dans l'un des AWS SDKs. Cependant, nous vous recommandons de mettre en cache vos valeurs de secret à l'aide de la mise en cache côté client. La mise en cache des secrets améliore la vitesse et réduit vos coûts.
+ Si vous stockez les informations d'identification de la base de données dans le secret, utilisez les pilotes [de connexion Secrets Manager SQL](retrieving-secrets_jdbc.md) pour vous connecter à une base de données à l'aide des informations d'identification que contient le secret.
+ Pour les autres types de secrets, utilisez le [composant de mise en cache Java de Secrets Manager](retrieving-secrets_cache-java.md) ou appelez le SDK directement avec ou. [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)
Les exemples de code suivants illustrent comment utiliser `GetSecretValue`.
**Autorisations requises : **`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);
}
}
}
```
# Obtenir une valeur secrète de Secrets Manager en utilisant Python
Dans les applications, vous pouvez récupérer vos secrets en appelant `GetSecretValue` ou `BatchGetSecretValue` dans l'un des AWS SDKs. Cependant, nous vous recommandons de mettre en cache vos valeurs de secret à l'aide de la mise en cache côté client. La mise en cache des secrets améliore la vitesse et réduit vos coûts.
**Topics**
+ [Obtenez une valeur secrète de Secrets Manager en utilisant Python avec mise en cache côté client](retrieving-secrets_cache-python.md)
+ [Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK Python](retrieving-secrets-python-sdk.md)
+ [Obtenez un lot de valeurs secrètes de Secrets Manager à l'aide du AWS SDK Python](retrieving-secrets-python-batch.md)
# Obtenez une valeur secrète de Secrets Manager en utilisant Python avec mise en cache côté client
Lorsque vous récupérez un secret, vous pouvez utiliser le composant de mise en cache basé sur Python de Secrets Manager pour le mettre en cache en vue d'une utilisation future. Il est plus rapide de récupérer un secret mis en cache que de le récupérer à partir de Secrets Manager. L'appel de Secrets Manager étant payant APIs, l'utilisation d'un cache peut réduire vos coûts. Pour connaître toutes les manières dont vous pouvez récupérer des secrets, consultez[Obtenez des secrets](retrieving-secrets.md).
La politique de cache est la moins récemment utilisée (LRU). Ainsi, lorsque le cache doit supprimer un secret, il supprime le secret le moins récemment utilisé. Par défaut, le cache actualise les secrets toutes les heures. Vous pouvez configurer [la fréquence d'actualisation du secret](retrieving-secrets_cache-ref-secretcacheconfig.md) dans le cache et [utiliser un hook pour la récupération du secret](retrieving-secrets_cache-ref-secretcachehook.md) afin d’ajouter plus de fonctionnalités.
Le cache ne force pas le récupérateur de mémoire une fois que les références du cache sont libérées. L'implémentation du cache n'inclut pas l'invalidation du cache. L'implémentation du cache se concentre sur le cache lui-même et n'est pas renforcée ou ciblée sur le plan de la sécurité. Si vous avez besoin d'une sécurité supplémentaire, telle que le chiffrement d'éléments dans le cache, utilisez les interfaces et les méthodes abstraites fournies.
Pour pouvoir utiliser le composant, vous devez disposer des éléments suivants :
+ Python 3.6 ou version ultérieure.
+ botocore 1.12 ou version ultérieure. Consultez les sections [Kit SDK AWS pour Python](https://aws.amazon.com/sdk-for-python/) et [Botocore](https://botocore.amazonaws.com/v1/documentation/api/latest/index.html).
+ setuptools\$1scm 3.2 ou version ultérieure. Voir [https://pypi. org/project/setuptools-scm/](https://pypi.org/project/setuptools-scm/).
Pour télécharger le code source, voir le composant [client de mise en cache basé sur Python de Secrets Manager](https://github.com/aws/aws-secretsmanager-caching-python ) sur. GitHub
Pour installer le composant, utilisez la commande suivante.
```
$ pip install aws-secretsmanager-caching
```
**Autorisations requises : **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Pour de plus amples informations, veuillez consulter [Référence des autorisations ](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 Récupérer un secret**
L'exemple suivant montre comment obtenir la valeur secrète d'un secret nommé*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
Un cache en mémoire pour les secrets récupérés dans Secrets Manager. Vous utilisez [get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string) ou [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary) pour récupérer un secret du cache. Vous pouvez configurer les paramètres de cache en transmettant un objet [SecretCacheConfig](retrieving-secrets_cache-ref-secretcacheconfig.md) dans le constructeur.
Pour plus d'informations, ainsi que pour voir des exemples, consultez [Obtenez une valeur secrète de Secrets Manager en utilisant Python avec mise en cache côté 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
Récupère la valeur de chaîne secrète.
Syntaxe de demande
```
response = cache.get_secret_string(
secret_id='string',
version_stage='string' )
```
Parameters
+ `secret_id`(*chaîne*) : [Obligatoire] Le nom ou l'ARN du secret.
+ `version_stage`(*chaîne*) : version des secrets que vous souhaitez récupérer. Pour plus d'informations, consultez la section [Versions secrètes](whats-in-a-secret.md). La valeur par défaut est « AWSCURRENT ».
Type de retour
chaîne
## get\$1secret\$1binary
Récupère la valeur binaire secrète.
Syntaxe de demande
```
response = cache.get_secret_binary(
secret_id='string',
version_stage='string'
)
```
Parameters
+ `secret_id`(*chaîne*) : [Obligatoire] Le nom ou l'ARN du secret.
+ `version_stage`(*chaîne*) : version des secrets que vous souhaitez récupérer. Pour plus d'informations, consultez la section [Versions secrètes](whats-in-a-secret.md). La valeur par défaut est « AWSCURRENT ».
Type de retour
Chaîne [base64-encoded](https://tools.ietf.org/html/rfc4648#section-4)
# SecretCacheConfig
Options de configuration du cache pour un [SecretCache](retrieving-secrets_cache-ref-secretcache.md), telles que la taille maximale du cache et la durée de vie (TTL) pour les secrets mis en cache.Parameters
`max_cache_size` (*int*)
Taille de cache maximale. La valeur par défaut est `1024` secrets.
`exception_retry_delay_base` (*int*)
Le nombre de secondes à attendre après la rencontre d'une exception avant d'effectuer une nouvelle demande. La valeur par défaut est `1`.
`exception_retry_growth_factor` (*int*)pur
Facteur de croissance à utiliser pour calculer le temps d'attente entre les tentatives de demandes qui ont échoué. La valeur par défaut est `2`.
`exception_retry_delay_max` (*int*)
Durée maximale d'attente en secondes entre les demandes qui ont échoué. La valeur par défaut est `3600`.
`default_version_stage` (*str*)
La version des secrets que vous souhaitez mettre en cache. Pour plus d'informations, consultez [Versions de secret](whats-in-a-secret.md#term_version). La valeur par défaut est `'AWSCURRENT'`.
`secret_refresh_interval` (*int*)
Nombre de secondes à attendre entre l'actualisation des informations secrètes mises en cache. La valeur par défaut est `3600`.
`secret_cache_hook` (*SecretCacheHook*)
Implémentation de la classe abstraite `SecretCacheHook`. La valeur par défaut est `None`.
# SecretCacheHook
Une interface permettant d’utiliser un hook pour un [SecretCache](retrieving-secrets_cache-ref-secretcache.md) et effectuer des actions sur les secrets stockés dans le cache.
**Topics**
+ [put](#retrieving-secrets_cache-ref-secretcachehook_put)
+ [get](#retrieving-secrets_cache-ref-secretcachehook_get)
## put
Prépare l'objet en vue de son stockage dans le cache.
Syntaxe de demande
```
response = hook.put(
obj='secret_object'
)
```
Parameters
+ `obj` (*objet*) -- [Obligatoire] Secret ou objet qui contient le secret.
Type de retour
objet
## get
Dérive l'objet de l'objet mis en cache.
Syntaxe de demande
```
response = hook.get(
obj='secret_object'
)
```
Parameters
+ `obj`(*objet*) : [Obligatoire] Le secret ou l'objet contenant le secret.
Type de retour
objet
# @InjectSecretString
Ce décorateur attend une chaîne d'identité secrète et [SecretCache](retrieving-secrets_cache-ref-secretcache.md) comme premier et deuxième arguments. Le décorateur renvoie la valeur de chaîne secrète. Le secret doit contenir une chaîne.
```
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
Ce décorateur attend une chaîne d'identité secrète et [SecretCache](retrieving-secrets_cache-ref-secretcache.md) comme premier et deuxième arguments. Les arguments restants mappent les paramètres de la fonction encapsulée aux clés JSON du secret. Le secret doit contenir une chaîne dans la structure JSON.
Pour un secret contenant ce JSON :
```
{
"username": "saanvi",
"password": "EXAMPLE-PASSWORD"
}
```
L'exemple suivant montre comment extraire du secret les valeurs JSON pour `username` et `password`.
```
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')
```
# Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK Python
Dans les applications, vous pouvez récupérer vos secrets en appelant `GetSecretValue` ou `BatchGetSecretValue` dans l'un des AWS SDKs. Cependant, nous vous recommandons de mettre en cache vos valeurs de secret à l'aide de la mise en cache côté client. La mise en cache des secrets améliore la vitesse et réduit vos coûts.
Pour les applications Python, utilisez le [composant de mise en cache basé sur Python de Secrets Manager](retrieving-secrets_cache-python.md) ou appelez le SDK directement avec [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) ou [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).
Les exemples de code suivants illustrent comment utiliser `GetSecretValue`.
**Autorisations requises : **`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
```
# Obtenez un lot de valeurs secrètes de Secrets Manager à l'aide du AWS SDK Python
L'exemple de code suivant montre comment obtenir un lot de valeurs secrètes de Secrets Manager.
**Autorisations requises : **
+ `secretsmanager:BatchGetSecretValue`
+ `secretsmanager:GetSecretValue`autorisation pour chaque secret que vous souhaitez récupérer.
+ Si vous utilisez des filtres, vous devez également avoir `secretsmanager:ListSecrets`.
Pour obtenir un exemple de politique d'autorisations, consultez [Exemple : autorisation de récupérer un groupe de valeurs secrètes dans un lot](auth-and-access_iam-policies.md#auth-and-access_examples_batch).
**Important**
Si vous avez une politique VPCE qui refuse l'autorisation de récupérer un secret individuel dans le groupe que vous recherchez, `BatchGetSecretValue` ne renverra aucune valeur de secret et renverra une erreur.
```
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
```
# Obtenez une valeur secrète de Secrets Manager en utilisant .NET
Dans les applications, vous pouvez récupérer vos secrets en appelant `GetSecretValue` ou `BatchGetSecretValue` dans l'un des AWS SDKs. Cependant, nous vous recommandons de mettre en cache vos valeurs de secret à l'aide de la mise en cache côté client. La mise en cache des secrets améliore la vitesse et réduit vos coûts.
**Topics**
+ [Obtenez une valeur secrète de Secrets Manager en utilisant .NET avec mise en cache côté client](retrieving-secrets_cache-net.md)
+ [Obtenez une valeur secrète de Secrets Manager à l'aide du SDK pour .NET](retrieving-secrets-net-sdk.md)
# Obtenez une valeur secrète de Secrets Manager en utilisant .NET avec mise en cache côté client
Lorsque vous récupérez un secret, vous pouvez utiliser le composant de mise en cache basé sur .NET de Secrets Manager pour le mettre en cache en vue d'une utilisation future. Il est plus rapide de récupérer un secret mis en cache que de le récupérer à partir de Secrets Manager. L'appel de Secrets Manager étant payant APIs, l'utilisation d'un cache peut réduire vos coûts. Pour connaître toutes les manières dont vous pouvez récupérer des secrets, consultez[Obtenez des secrets](retrieving-secrets.md).
La politique de cache est la moins récemment utilisée (LRU). Ainsi, lorsque le cache doit supprimer un secret, il supprime le secret le moins récemment utilisé. Par défaut, le cache actualise les secrets toutes les heures. Vous pouvez configurer [la fréquence d'actualisation du secret](retrieving-secrets_cache-net-SecretCacheConfiguration.md#retrieving-secrets_cache-net-SecretCacheConfiguration-properties_CacheItemTTL) dans le cache et [utiliser un hook pour la récupération du secret](retrieving-secrets_cache-net-ISecretCacheHook.md) afin d’ajouter plus de fonctionnalités.
Le cache ne force pas le récupérateur de mémoire une fois que les références du cache sont libérées. L'implémentation du cache n'inclut pas l'invalidation du cache. L'implémentation du cache se concentre sur le cache lui-même et n'est pas renforcée ou ciblée sur le plan de la sécurité. Si vous avez besoin d'une sécurité supplémentaire, telle que le chiffrement d'éléments dans le cache, utilisez les interfaces et les méthodes abstraites fournies.
Pour pouvoir utiliser le composant, vous devez disposer des éléments suivants :
+ Framework .NET 4.6.2 ou version ultérieure, ou .NET Standard 2.0 ou version ultérieure. Consultez [Télécharger .NET](https://dotnet.microsoft.com/en-us/download) sur le site web Microsoft .NET.
+ Le AWS SDK pour .NET. Consultez [AWS SDKs](asm_access.md#asm-sdks).
Pour télécharger le code source, consultez la section [Client de mise en cache pour .NET](https://github.com/aws/aws-secretsmanager-caching-net ) sur GitHub.
Pour utiliser le cache, instanciez-le d'abord, puis récupérez votre secret en utilisant `GetSecretString` ou `GetSecretBinary`. Lors de récupérations successives, le cache renvoie la copie en cache du secret.
**Pour obtenir le package de mise en cache**
+ Effectuez l’une des actions suivantes :
+ Exécutez la commande .NET CLI suivante dans le répertoire de votre projet.
```
dotnet add package AWSSDK.SecretsManager.Caching --version 1.0.6
```
+ Ajoutez la référence de package suivante à votre fichier `.csproj`.
```
```
**Autorisations requises : **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Pour de plus amples informations, veuillez consulter [Référence des autorisations ](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 Récupérer un secret**
L'exemple de code suivant montre une méthode qui récupère un secret nommé*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 Configuration de la durée d'actualisation du cache de durée de vie (TTL)**
L'exemple de code suivant montre une méthode qui récupère un secret nommé *MySecret* et définit la durée d'actualisation du cache TTL à 24 heures.
```
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
Un cache en mémoire pour les secrets demandés à Secrets Manager. Vous utilisez [GetSecretString](#retrieving-secrets_cache-net-SecretsManagerCache-methods-GetSecretString) ou [GetSecretBinary](#retrieving-secrets_cache-net-SecretsManagerCache-methods-GetSecretBinary) pour récupérer un secret du cache. Vous pouvez configurer les paramètres de cache en transmettant un objet [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) dans le constructeur.
Pour plus d'informations, ainsi que pour voir des exemples, consultez [Obtenez une valeur secrète de Secrets Manager en utilisant .NET avec mise en cache côté client](retrieving-secrets_cache-net.md).
## Constructeurs
`public SecretsManagerCache()`
Constructeur par défaut d'un objet `SecretsManagerCache`.
`public SecretsManagerCache(IAmazonSecretsManager secretsManager)`
Crée un cache à l'aide d'un client Secrets Manager créé à l'aide du [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html) fourni. Utilisez ce constructeur pour personnaliser le client Secrets Manager, par exemple, pour utiliser une région ou un point de terminaison spécifique.
**Parameters**
secretsManager
Le [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)pour récupérer des secrets.
`public SecretsManagerCache(SecretCacheConfiguration config)`
Crée un cache de secret à l'aide du [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) fourni. Utilisez ce constructeur pour configurer le cache, par exemple, le nombre de secrets à mettre en cache et la fréquence d'actualisation.
**Parameters**
config
Une [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) qui contient des informations de configuration pour le cache.
`public SecretsManagerCache(IAmazonSecretsManager secretsManager, SecretCacheConfiguration config)`
Construit un nouveau cache à l'aide d'un client Secrets Manager créé à l'aide des options fournies [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)et a. [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) Utilisez ce constructeur pour personnaliser le client Secrets Manager, par exemple, pour utiliser une région ou un point de terminaison spécifique, ainsi que pour configurer le cache, par exemple le nombre de secrets à mettre en cache et la fréquence d'actualisation.
**Parameters**
secretsManager
Le [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)pour récupérer des secrets.
config
Une [SecretCacheConfiguration](retrieving-secrets_cache-net-SecretCacheConfiguration.md) qui contient des informations de configuration pour le cache.
## Méthodes
### GetSecretString
`public async Task GetSecretString(String secretId)`
Récupère un secret de chaîne dans Secrets Manager.Parameters
secretId
ARN ou nom du secret à récupérer.
### GetSecretBinary
`public async Task GetSecretBinary(String secretId)`
Récupère un secret binaire dans Secrets Manager.Parameters
secretId
ARN ou nom du secret à récupérer.
### RefreshNowAsync
`public async Task RefreshNowAsync(String secretId)`
Demande la valeur secrète à Secrets Manager et met à jour le cache avec toutes les modifications. Crée une entrée de cache s'il n'en existe pas déjà une. Renvoie `true` si l'actualisation est réussie.Parameters
secretId
ARN ou nom du secret à récupérer.
### GetCachedSecret
`public SecretCacheItem GetCachedSecret(string secretId)`
Renvoie l'entrée de cache pour le secret spécifié s'il existe dans le cache. Sinon, récupère le secret à partir de Secrets Manager et crée une entrée de cache.Parameters
secretId
ARN ou nom du secret à récupérer.
# SecretCacheConfiguration
Options de configuration du cache pour un [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md), telles que la taille maximale du cache et la durée de vie (TTL) pour les secrets mis en cache.
## Propriétés
### CacheItemTTL
`public uint CacheItemTTL { get; set; }`
Durée de vie (TTL) d'un élément de cache en millisecondes. La valeur par défaut est de `3600000` ms ou 1 heure. La valeur maximale est de `4294967295` ms, soit environ 49,7 jours.
### MaxCacheSize
`public ushort MaxCacheSize { get; set; }`
Taille de cache maximale. La valeur par défaut est de 1 024 secrets. Le valeur maximale est de 65 535.
### VersionStage
`public string VersionStage { get; set; }`
La version des secrets que vous souhaitez mettre en cache. Pour plus d'informations, consultez [Versions de secret](whats-in-a-secret.md#term_version). La valeur par défaut est `"AWSCURRENT"`.
### Client
`public IAmazonSecretsManager Client { get; set; }`
Le [AmazonSecretsManagerClient](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TSecretsManagerClient.html)pour récupérer des secrets. Si la valeur est `null`, le cache instancie un nouveau client. La valeur par défaut est `null`.
### CacheHook
`public ISecretCacheHook CacheHook { get; set; }`
Une [ISecretCacheHook](retrieving-secrets_cache-net-ISecretCacheHook.md).
# ISecretCacheHook
Une interface permettant d’utiliser un hook pour un [SecretsManagerCache](retrieving-secrets_cache-net-SecretsManagerCache.md) et effectuer des actions sur les secrets stockés dans le cache.
## Méthodes
### Put
`object Put(object o);`
Préparez l'objet en vue de son stockage dans le cache.
Renvoie l'objet à stocker dans le cache.
### Get
`object Get(object cachedObject);`
Dérivez l'objet de l'objet mis en cache.
Renvoie l'objet à renvoyer à partir du cache
# Obtenez une valeur secrète de Secrets Manager à l'aide du SDK pour .NET
Dans les applications, vous pouvez récupérer vos secrets en appelant `GetSecretValue` ou `BatchGetSecretValue` dans l'un des AWS SDKs. Cependant, nous vous recommandons de mettre en cache vos valeurs de secret à l'aide de la mise en cache côté client. La mise en cache des secrets améliore la vitesse et réduit vos coûts.
Pour les applications .NET, utilisez le [composant de mise en cache basé sur .NET de Secrets Manager](retrieving-secrets_cache-net.md) ou appelez le SDK directement avec [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TGetSecretValueRequest.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TGetSecretValueRequest.html) ou [https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TBatchGetSecretValueRequest.html](https://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/SecretsManager/TBatchGetSecretValueRequest.html).
Les exemples de code suivants illustrent comment utiliser `GetSecretValue`.
**Autorisations requises : **`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;
}
}
}
```
# Obtenez une valeur secrète de Secrets Manager à l'aide de Go
Dans les applications, vous pouvez récupérer vos secrets en appelant `GetSecretValue` ou `BatchGetSecretValue` dans l'un des AWS SDKs. Cependant, nous vous recommandons de mettre en cache vos valeurs de secret à l'aide de la mise en cache côté client. La mise en cache des secrets améliore la vitesse et réduit vos coûts.
**Topics**
+ [Obtenez une valeur secrète de Secrets Manager à l'aide de Go avec la mise en cache côté client](retrieving-secrets_cache-go.md)
+ [Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK Go](retrieving-secrets-go-sdk.md)
# Obtenez une valeur secrète de Secrets Manager à l'aide de Go avec la mise en cache côté client
Lorsque vous récupérez un secret, vous pouvez utiliser le composant de mise en cache basé sur Go de Secrets Manager pour le mettre en cache en vue d'une utilisation future. Il est plus rapide de récupérer un secret mis en cache que de le récupérer à partir de Secrets Manager. L'appel de Secrets Manager étant payant APIs, l'utilisation d'un cache peut réduire vos coûts. Pour connaître toutes les manières dont vous pouvez récupérer des secrets, consultez[Obtenez des secrets](retrieving-secrets.md).
La politique de cache est la moins récemment utilisée (LRU). Ainsi, lorsque le cache doit supprimer un secret, il supprime le secret le moins récemment utilisé. Par défaut, le cache actualise les secrets toutes les heures. Vous pouvez configurer [la fréquence d'actualisation du secret](retrieving-secrets_cache-go_CacheConfig.md) dans le cache et [utiliser un hook pour la récupération du secret](retrieving-secrets_cache-go_CacheHook.md) afin d’ajouter plus de fonctionnalités.
Le cache ne force pas le récupérateur de mémoire une fois que les références du cache sont libérées. L'implémentation du cache n'inclut pas l'invalidation du cache. L'implémentation du cache se concentre sur le cache lui-même et n'est pas renforcée ou ciblée sur le plan de la sécurité. Si vous avez besoin d'une sécurité supplémentaire, telle que le chiffrement d'éléments dans le cache, utilisez les interfaces et les méthodes abstraites fournies.
Pour pouvoir utiliser le composant, vous devez disposer des éléments suivants :
+ AWS SDK pour Go. Consultez [AWS SDKs](asm_access.md#asm-sdks).
Pour télécharger le code source, consultez la section [Client de mise en cache de Secrets Manager Go](https://github.com/aws/aws-secretsmanager-caching-go ) activé GitHub.
Pour configurer un environnement de développement Go, consultez [Mise en route sur Golang](https://golang.org/doc/install) sur le site web Go Programming Language.
**Autorisations requises : **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Pour de plus amples informations, veuillez consulter [Référence des autorisations ](auth-and-access.md#reference_iam-permissions).
**Topics**
+ [type Cache](retrieving-secrets_cache-go_cache.md)
+ [type CacheConfig](retrieving-secrets_cache-go_CacheConfig.md)
+ [type CacheHook](retrieving-secrets_cache-go_CacheHook.md)
**Example Récupérer un secret**
L'exemple de code suivant montre une fonction Lambda qui récupère un secret.
```
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
Un cache en mémoire pour les secrets demandés à Secrets Manager. Vous utilisez [GetSecretString](#retrieving-secrets_cache-go_cache_operations_GetCachedSecret) ou [GetSecretBinary](#retrieving-secrets_cache-go_cache_operations_GetSecretBinary) pour récupérer un secret du cache.
L'exemple suivant montre comment configurer les paramètres du 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 },
)
```
Pour plus d'informations, ainsi que pour voir des exemples, consultez [Obtenez une valeur secrète de Secrets Manager à l'aide de Go avec la mise en cache côté client](retrieving-secrets_cache-go.md).
## Méthodes
### New
`func New(optFns ...func(*Cache)) (*Cache, error)`
New construit un cache secret à l'aide d'options fonctionnelles, sinon il utilise les valeurs par défaut. Initialise un SecretsManager client à partir d'une nouvelle session. S'initialise CacheConfig aux valeurs par défaut. Initialise le cache LRU avec une taille maximale par défaut.
### GetSecretString
`func (c *Cache) GetSecretString(secretId string) (string, error)`
GetSecretString obtient la valeur de la chaîne secrète du cache pour un ID secret donné. Renvoie la chaîne secrète et une erreur en cas d'échec de l'opération.
### GetSecretStringWithStage
`func (c *Cache) GetSecretStringWithStage(secretId string, versionStage string) (string, error)`
GetSecretStringWithStage obtient la valeur de la chaîne secrète du cache pour un ID secret et une [étape de version](whats-in-a-secret.md#term_version) donnés. Renvoie la chaîne secrète et une erreur en cas d'échec de l'opération.
### GetSecretBinary
`func (c *Cache) GetSecretBinary(secretId string) ([]byte, error) {`
GetSecretBinary obtient la valeur binaire secrète du cache pour un identifiant secret donné. Renvoie le binaire secret et une erreur si l'opération a échoué.
### GetSecretBinaryWithStage
`func (c *Cache) GetSecretBinaryWithStage(secretId string, versionStage string) ([]byte, error)`
GetSecretBinaryWithStage obtient la valeur binaire secrète du cache pour un ID secret et une [étape de version](whats-in-a-secret.md#term_version) donnés. Renvoie le binaire secret et une erreur si l'opération a échoué.
# type CacheConfig
Options de configuration du cache pour un [Cache](retrieving-secrets_cache-go_cache.md), telles que la taille maximale du cache, l'[étape de version](whats-in-a-secret.md#term_version) par défaut et la durée de vie (TTL) pour les secrets mis en 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
}
```
# type CacheHook
Une interface pour se connecter à un [Cache](retrieving-secrets_cache-go_cache.md) pour effectuer des actions sur le secret stocké dans le cache.
## Méthodes
### Put
`Put(data interface{}) interface{}`
Prépare l'objet en vue de son stockage dans le cache.
### Get
`Get(data interface{}) interface{}`
Dérive l'objet de l'objet mis en cache.
# Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK Go
Dans les applications, vous pouvez récupérer vos secrets en appelant `GetSecretValue` ou `BatchGetSecretValue` dans l'un des AWS SDKs. Cependant, nous vous recommandons de mettre en cache vos valeurs de secret à l'aide de la mise en cache côté client. La mise en cache des secrets améliore la vitesse et réduit vos coûts.
Pour les applications Go, utilisez le [composant de mise en cache basé sur Go de Secrets Manager](retrieving-secrets_cache-go.md) appelez le SDK directement avec [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) ou [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).
L'exemple de code suivant montre comment obtenir une valeur de Secrets Secrets Manager.
**Autorisations requises : **`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.
}
```
# Obtenez une valeur secrète de Secrets Manager en utilisant Rust
Dans les applications, vous pouvez récupérer vos secrets en appelant `GetSecretValue` ou `BatchGetSecretValue` dans l'un des AWS SDKs. Cependant, nous vous recommandons de mettre en cache vos valeurs de secret à l'aide de la mise en cache côté client. La mise en cache des secrets améliore la vitesse et réduit vos coûts.
**Topics**
+ [Obtenez une valeur secrète de Secrets Manager en utilisant Rust avec la mise en cache côté client](retrieving-secrets_cache-rust.md)
+ [Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK Rust](retrieving-secrets-rust-sdk.md)
# Obtenez une valeur secrète de Secrets Manager en utilisant Rust avec la mise en cache côté client
Lorsque vous récupérez un secret, vous pouvez utiliser le composant de mise en cache basé sur Rust de Secrets Manager pour le mettre en cache pour une utilisation future. Il est plus rapide de récupérer un secret mis en cache que de le récupérer à partir de Secrets Manager. L'appel de Secrets Manager étant payant APIs, l'utilisation d'un cache peut réduire vos coûts. Pour connaître toutes les manières dont vous pouvez récupérer des secrets, consultez[Obtenez des secrets](retrieving-secrets.md).
La politique du cache est le premier entré, premier sorti (FIFO). Ainsi, lorsque le cache doit supprimer un secret, il supprime le secret le plus ancien. Par défaut, le cache actualise les secrets toutes les heures. Vous pouvez configurer les éléments suivants :
+ `max_size`— Le nombre maximum de secrets mis en cache à conserver avant d'expulser des secrets qui n'ont pas été consultés récemment.
+ `ttl`— La durée pendant laquelle un élément mis en cache est considéré comme valide avant de nécessiter une actualisation de l'état secret.
L'implémentation du cache n'inclut pas l'invalidation du cache. L'implémentation du cache se concentre sur le cache lui-même et n'est pas renforcée ou ciblée sur le plan de la sécurité. Si vous avez besoin d'une sécurité supplémentaire, telle que le chiffrement des éléments du cache, utilisez les caractéristiques fournies pour modifier le cache.
Pour utiliser le composant, vous devez disposer d'un environnement de développement Rust 2021 avec`tokio`. Pour plus d'informations, consultez [Getting started](https://www.rust-lang.org/learn/get-started) sur le site Web du langage de programmation Rust.
Pour télécharger le code source, voir le composant [client de mise en cache basé sur Rust de Secrets Manager](https://github.com/aws/aws-secretsmanager-agent/tree/main/aws_secretsmanager_caching) sur. GitHub
Pour installer le composant de mise en cache, utilisez la commande suivante.
```
cargo add aws_secretsmanager_caching
```
**Autorisations requises : **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Pour de plus amples informations, veuillez consulter [Référence des autorisations ](auth-and-access.md#reference_iam-permissions).
**Example Récupérer un secret**
L'exemple suivant montre comment obtenir la valeur secrète d'un secret nommé*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 Instanciation du cache avec une configuration personnalisée et un client personnalisé**
L'exemple suivant montre comment configurer le cache puis obtenir la valeur secrète d'un secret nommé*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
```
```
# Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK Rust
Dans les applications, vous pouvez récupérer vos secrets en appelant `GetSecretValue` ou `BatchGetSecretValue` dans l'un des AWS SDKs. Cependant, nous vous recommandons de mettre en cache vos valeurs de secret à l'aide de la mise en cache côté client. La mise en cache des secrets améliore la vitesse et réduit vos coûts.
Pour les applications Rust, utilisez le [composant de mise en cache basé sur Rust de Secrets Manager](retrieving-secrets_cache-rust.md) ou appelez le [SDK](https://docs.rs/releases/search?query=aws-sdk-secretsmanager) directement avec ou. GetSecretValue BatchGetSecretValue
L'exemple de code suivant montre comment obtenir une valeur de Secrets Secrets Manager.
**Autorisations requises : **`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(())
}
```
# Utiliser des AWS Secrets Manager secrets dans Amazon Elastic Kubernetes Service
Pour afficher les secrets AWS Secrets Manager (ASCP) sous forme de fichiers montés dans des pods Amazon EKS, vous pouvez utiliser le fournisseur de AWS secrets et de configuration pour le pilote CSI Kubernetes Secrets Store. L'ASCP fonctionne avec Amazon Elastic Kubernetes Service 1.17\$1 exécutant un groupe de nœuds Amazon EC2. AWS Fargate les groupes de nœuds ne sont pas pris en charge. Avec l'ASCP, vous pouvez stocker et gérer vos secrets dans Secrets Manager, puis les récupérer via vos applications exécutées sur Amazon EKS. Si votre secret contient plusieurs paires clé-valeur au format JSON, vous pouvez choisir celles à monter dans Amazon EKS. L’ASCP utilise la syntaxe JMESPath pour interroger les paires clé-valeur dans votre secret. L'ASCP fonctionne également avec les paramètres du Parameter Store. L’ASCP propose deux méthodes d’authentification avec Amazon EKS. La première approche utilise les rôles IAM pour les comptes de service (IRSA). La deuxième approche utilise les identités du pod. Chaque approche a ses avantages et cas d’utilisation.
## ASCP avec rôles IAM pour les comptes de service (IRSA)
L'ASCP avec rôles IAM pour les comptes de service (IRSA) vous permet de monter des secrets AWS Secrets Manager sous forme de fichiers dans vos pods Amazon EKS. Cette approche convient lorsque :
+ Vous devez monter les secrets sous forme de fichiers dans vos pods.
+ Vous utilisez Amazon EKS version 1.17 ou ultérieure avec des groupes de nœuds Amazon EC2.
+ Vous souhaitez récupérer des paires clé-valeur spécifiques à partir de secrets au format JSON.
Pour de plus amples informations, veuillez consulter [Utiliser AWS les secrets et le fournisseur de configuration CSI avec des rôles IAM pour les comptes de service (IRSA)](integrating_ascp_irsa.md).
## ASCP avec l’identité du pod
La méthode ASCP avec Pod Identity améliore la sécurité et simplifie la configuration pour accéder aux secrets dans Amazon EKS. Cette approche est bénéfique lorsque :
+ Vous avez besoin d’une gestion des autorisations plus précise au niveau du pod.
+ Vous utilisez Amazon EKS version 1.24 ou ultérieure.
+ Vous souhaitez améliorer les performances et la capacité de mise à l’échelle.
Pour de plus amples informations, veuillez consulter [Utiliser AWS les secrets et le fournisseur de configuration CSI avec Pod Identity pour Amazon EKS](ascp-pod-identity-integration.md).
## Choix de la bonne approche
Tenez compte des facteurs suivants lorsque vous choisissez entre ASCP avec IRSA et ASCP avec l’identité du pod :
+ Amazon EKSversion : Pod Identity nécessite Amazon EKS 1.24\$1, tandis que le pilote CSI fonctionne avec Amazon EKS 1.17\$1.
+ Exigences de sécurité : l’identité du pod offre un contrôle plus granulaire au niveau du pod.
+ Performances : l’identité du pod fonctionne généralement mieux dans les environnements à grande échelle.
+ Complexité : l’identité du pod simplifie la configuration en éliminant le besoin de comptes de service distincts.
Choisissez la méthode qui correspond le mieux à vos exigences spécifiques et à l’environnement Amazon EKS.
# Installer l’ASCP pour Amazon EKS
Cette section explique comment installer le fournisseur de AWS secrets et de configuration pour Amazon EKS. Avec ASCP, vous pouvez monter des secrets à partir de Secrets Manager et des paramètres AWS Systems Manager sous forme de fichiers dans Amazon EKS Pods.
## Conditions préalables
+ Un cluster Amazon EKS
+ Version 1.24 ou ultérieure pour l’identité du pod
+ Version 1.17 ou ultérieure pour IRSA
+ Le AWS CLI installé et configuré
+ kubectl installé et configuré pour votre cluster Amazon EKS
+ Helm (version 3.0 ou ultérieure)
## Installation et configuration de l’ASCP
L'ASCP est disponible GitHub dans le référentiel [secrets-store-csi-provider-aws](https://github.com/aws/secrets-store-csi-driver-provider-aws). Le référentiel contient également des exemples de fichiers YAML pour créer et monter un secret.
Pendant l’installation, vous pouvez configurer l’ASCP pour utiliser un point de terminaison FIPS. Pour obtenir la liste des points de terminaison , consultez [AWS Secrets Manager points de terminaison](asm_access.md#endpoints).
**Pour installer l'ASCP en tant que module complémentaire EKS**
1. Installation `eksctl` ([instructions d'installation](https://docs.aws.amazon.com/eks/latest/eksctl/installation.html))
1. Exécutez la commande suivante pour installer le module complémentaire avec la [configuration par défaut](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
```
Si vous souhaitez configurer le module complémentaire, exécutez plutôt la commande d'installation suivante :
```
aws eks create-addon --cluster-name --addon-name aws-secrets-store-csi-driver-provider --configuration-values 'file://path/to/config.yaml'
```
Le fichier de configuration peut être un fichier YAML ou JSON. Pour consulter le schéma de configuration du module complémentaire, procédez comme suit :
1. Exécutez la commande suivante et notez la dernière version du module complémentaire :
```
aws eks describe-addon-versions --addon-name aws-secrets-store-csi-driver-provider
```
1. Exécutez la commande suivante pour voir le schéma de configuration du module complémentaire, en le `` remplaçant par la version de l'étape précédente :
```
aws eks describe-addon-configuration --addon-name aws-secrets-store-csi-driver-provider --addon-version
```
**Installer l’ASCP à l’aide de Helm**
1. Pour vous assurer que le référentiel pointe vers les derniers graphiques, utilisez `helm repo update.`.
1. Installez le chart. Voici un exemple de `helm install` commande :
```
helm install -n kube-system secrets-provider-aws aws-secrets-manager/secrets-store-csi-driver-provider-aws
```
1. Pour utiliser un point de terminaison FIPS, ajoutez l’indicateur suivant : `--set useFipsEndpoint=true`
1. Pour configurer la limitation, ajoutez l’indicateur suivant : `--set-json 'k8sThrottlingParams={"qps": "number of queries per second", "burst": "number of queries per second"}'`
1. Si le pilote CSI Secrets Store est déjà installé sur votre cluster, ajoutez l'indicateur suivant :`--set secrets-store-csi-driver.install=false`. Cela ignorera l'installation du pilote CSI Secrets Store en tant que dépendance.
**Installer en utilisant le code YAML dans le référentiel**
+ Utilisez les commandes suivantes.
```
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
```
## Vérifier les installations
Pour vérifier les installations de votre cluster EKS, du pilote Secrets Store CSI et du plug-in ASCP, procédez comme suit :
1. Vérifiez le cluster EKS :
```
eksctl get cluster --name clusterName
```
Cette commande doit renvoyer des informations sur votre cluster.
1. Vérifiez l’installation du pilote Secrets Store CSI :
```
kubectl get pods -n kube-system -l app=secrets-store-csi-driver
```
Vous devriez voir des pods s’exécuter avec des noms comme `csi-secrets-store-secrets-store-csi-driver-xxx`.
1. Vérifier l’installation du plug-in ASCP :
------
#### [ YAML installation ]
```
$ kubectl get pods -n kube-system -l app=csi-secrets-store-provider-aws
```
Exemple de sortie :
```
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
```
Exemple de sortie :
```
NAME READY STATUS RESTARTS AGE
secrets-provider-aws-secrets-store-csi-driver-provider-67890 1/1 Running 0 2m
```
------
Vous devriez voir des pods dans l’état `Running`.
Après exécution de ces commandes, si tout est correctement configuré, vous devriez voir tous les composants fonctionner sans aucune erreur. Si vous rencontrez des problèmes, vous devrez peut-être les résoudre en vérifiant les journaux des pods spécifiques qui rencontrent des problèmes.
## Résolution des problèmes
1. Pour vérifier les journaux du fournisseur ASCP, exécutez :
```
kubectl logs -n kube-system -l app=csi-secrets-store-provider-aws
```
1. Vérifiez l'état de tous les pods de l'espace de `kube-system` noms :
```
kubectl -n kube-system get pods
```
```
kubectl -n kube-system logs pod/PODID
```
Tous les pods liés au pilote CSI et à l’ASCP doivent être dans l’état « En cours d’exécution ».
1. Vérifiez la version du pilote CSI :
```
kubectl get csidriver secrets-store.csi.k8s.io -o yaml
```
Cette commande doit renvoyer des informations sur le pilote CSI installé.
## Ressources supplémentaires
Pour plus d’informations sur l’utilisation d’ASCP avec Amazon EKS, consultez les ressources suivantes :
+ [Utilisation de l’identité du pod avec Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html)
+ [AWS Pilote CSI Secrets Store activé GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)
# Utiliser AWS les secrets et le fournisseur de configuration CSI avec Pod Identity pour Amazon EKS
L'intégration du fournisseur de AWS secrets et de configuration à l'agent Pod Identity pour Amazon Elastic Kubernetes Service améliore la sécurité, simplifie la configuration et améliore les performances des applications exécutées sur Amazon EKS. Pod Identity simplifie l'authentification IAM pour Amazon EKS lors de la récupération de secrets depuis Secrets Manager ou de paramètres depuis AWS Systems Manager Parameter Store.
L’identité du pod Amazon EKS rationalise le processus de configuration des autorisations IAM pour les applications Kubernetes en permettant de configurer les autorisations directement via les interfaces Amazon EKS, en réduisant le nombre d’étapes et en éliminant le besoin de basculer entre les services Amazon EKS et IAM. L’identité du pod permet d’utiliser un seul rôle IAM sur plusieurs clusters sans mettre à jour les politiques de confiance et prend en charge les [balises de session de rôle](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-abac.html#pod-id-abac-tags) pour un contrôle d’accès plus granulaire. Cette approche simplifie non seulement la gestion des politiques en permettant la réutilisation des politiques d'autorisation entre les rôles, mais elle améliore également la sécurité en autorisant l'accès aux AWS ressources en fonction des balises correspondantes.
## Comment ça marche
1. L’identité du pod attribue un rôle IAM au pod.
1. ASCP utilise ce rôle pour s'authentifier auprès de. Services AWS
1. S'il est autorisé, l'ASCP récupère les secrets demandés et les met à la disposition du Pod.
Pour plus d’informations, consultez [Comprendre le l’identité du pod Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-how-it-works.html) dans le *Guide de l’utilisateur Amazon EKS*.
## Conditions préalables
**Important**
L’identité du pod n’est prise en charge que pour Amazon EKS dans le cloud. Elle n’est pas prise en charge pour [Amazon EKS Anywhere](https://aws.amazon.com/eks/eks-anywhere/), [Red Hat OpenShift Service on AWS](https://aws.amazon.com/rosa/) ni pour les clusters Kubernetes autogérés sur les instances Amazon EC2.
+ Cluster Amazon EKS (version 1.24 ou ultérieure).
+ Accès à un AWS CLI cluster Amazon EKS via `kubectl`
+ Accès à deux Comptes AWS (pour un accès entre comptes)
## Installer l’agent d’identité du pod Amazon EKS
Pour utiliser l’identité du pod avec votre cluster, vous devez installer le module complémentaire Agent d’identité du pod Amazon EKS.
**Installer l’agent d’identité du pod**
+ Installez le module complémentaire Pod Identity Agent sur votre cluster :
```
eksctl create addon \
--name eks-pod-identity-agent \
--cluster clusterName \
--region region
```
## Configurer l’ASCP avec l’identité du pod
1. Créez une politique d'autorisation qui accorde `secretsmanager:GetSecretValue` une `secretsmanager:DescribeSecret` autorisation aux secrets auxquels le Pod a besoin pour accéder. Pour un exemple de politique, consultez [Exemple : autorisation de lire et de décrire des secrets individuels](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Créez un rôle IAM qui peut être assumé par le principal de service Amazon EKS pour l’identité du pod :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
------
Associez la politique IAM au rôle :
```
aws iam attach-role-policy \
--role-name MY_ROLE \
--policy-arn POLICY_ARN
```
1. Créez une association d’identité du pod. Par exemple, consultez [Créer une association d’identité du pod](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-association.html#pod-id-association-create) dans le *Guide de l’utilisateur Amazon EKS*.
1. Créez le `SecretProviderClass` qui spécifie les secrets à monter dans le Pod :
```
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleSecretProviderClass-PodIdentity.yaml
```
La principale différence dans `SecretProviderClass` entre IRSA et l’identité du pod réside dans le paramètre facultatif `usePodIdentity`. Il s’agit d’un champ facultatif qui détermine l’approche d’authentification. Lorsqu’il n’est pas spécifié, les rôles IAM pour les comptes de service (IRSA) sont utilisés par défaut.
+ Pour utiliser l’identité du pod EKS, utilisez l’une des valeurs suivantes : `"true", "True", "TRUE", "t", "T"`.
+ Pour utiliser IRSA de manière explicite, définissez l’une des valeurs suivantes : `"false", "False", "FALSE", "f", or "F"`.
1. Déployez le pod qui contient les secrets sous `/mnt/secrets-store` :
```
kubectl apply -f https://raw.githubusercontent.com/aws/secrets-store-csi-driver-provider-aws/main/examples/ExampleDeployment-PodIdentity.yaml
```
1. Si vous utilisez un cluster Amazon EKS privé, assurez-vous que le VPC dans lequel se trouve le cluster possède un AWS STS point de terminaison. Pour en savoir plus sur la création d’un point de terminaison, consultez [Points de terminaison de VPC d’interface](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) dans le *Guide de l’utilisateur Gestion des identités et des accès AWS *.
### Vérifier le montage du secret
Pour vérifier que le secret est correctement monté, exécutez la commande suivante :
```
kubectl exec -it $(kubectl get pods | awk '/pod-identity-deployment/{print $1}' | head -1) -- cat /mnt/secrets-store/MySecret
```
**Pour configurer Amazon EKS Pod Identity afin d'accéder aux secrets dans Secrets Manager**
1. Créez une politique d'autorisation qui accorde `secretsmanager:GetSecretValue` une `secretsmanager:DescribeSecret` autorisation aux secrets auxquels le Pod a besoin pour accéder. Pour un exemple de politique, consultez [Exemple : autorisation de lire et de décrire des secrets individuels](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Créez un secret dans Secrets Manager, si vous n'en avez pas déjà un.
## Dépannage
Vous pouvez afficher la plupart des erreurs en décrivant le déploiement du pod.
**Pour afficher les messages d'erreur pour votre conteneur**
1. Obtenez une liste de noms de pod à l’aide de la commande suivante. Si vous n'utilisez pas l'espace de noms par défaut, utilisez `-n NAMESPACE`.
```
kubectl get pods
```
1. Pour décrire le Pod, dans la commande suivante, *PODID* utilisez l'ID du Pod indiqué dans les Pods que vous avez trouvés à l'étape précédente. Si vous n'utilisez pas l'espace de noms par défaut, utilisez `-n NAMESPACE`.
```
kubectl describe pod/PODID
```
**Pour voir les erreurs pour l'ASCP**
+ Pour obtenir plus d'informations dans les journaux du fournisseur, utilisez la commande suivante pour *PODID* utiliser l'ID du module *csi-secrets-store-provider-aws*.
```
kubectl -n kube-system get pods
kubectl -n kube-system logs pod/PODID
```
# Utiliser AWS les secrets et le fournisseur de configuration CSI avec des rôles IAM pour les comptes de service (IRSA)
**Topics**
+ [Conditions préalables](#prerequisites)
+ [Configurer le contrôle d'accès](#integrating_ascp_irsa_access)
+ [Identifier les secrets à monter](#integrating_ascp_irsa_mount)
+ [Dépannage](#integrating_ascp_irsa_trouble)
## Conditions préalables
+ Cluster Amazon EKS (version 1.17 ou ultérieure).
+ Accès à un AWS CLI cluster Amazon EKS via `kubectl`
## Configurer le contrôle d'accès
L’ASCP récupère l’identité du pod Amazon EKS et l’échange pour un rôle IAM. Vous définissez des autorisations dans une politique IAM pour ce rôle IAM. Lorsque l'ASCP assume le rôle IAM, il a accès aux secrets que vous avez autorisés. Les autres conteneurs ne peuvent pas accéder aux secrets sauf si vous les associez également au rôle IAM.
**Pour autoriser votre Amazon EKS Pod à accéder aux secrets dans Secrets Manager**
1. Créez une politique d'autorisation qui accorde `secretsmanager:GetSecretValue` une `secretsmanager:DescribeSecret` autorisation aux secrets auxquels le Pod a besoin pour accéder. Pour un exemple de politique, consultez [Exemple : autorisation de lire et de décrire des secrets individuels](auth-and-access_iam-policies.md#auth-and-access_examples-read-and-describe).
1. Créez un fournisseur OpenID Connect (OIDC) IAM pour le cluster si vous n'en avez pas déjà un. Pour plus d’informations, consultez [Créer un fournisseur IAM OIDC pour votre cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) dans le *Guide de l’utilisateur Amazon EKS*.
1. Créez un [Rôle IAM pour le compte de service](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) et attachez la politique. Pour plus d’informations, veuillez consulter [Créer un rôle IAM pour un compte de service](https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html) dans le *Guide de l’utilisateur Amazon EKS*.
1. Si vous utilisez un cluster Amazon EKS privé, assurez-vous que le VPC dans lequel se trouve le cluster possède un AWS STS point de terminaison. Pour en savoir plus sur la création d’un point de terminaison, consultez [Points de terminaison de VPC d’interface](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_interface_vpc_endpoints.html) dans le *Guide de l’utilisateur Gestion des identités et des accès AWS *.
## Identifier les secrets à monter
Pour déterminer quels secrets l'ASCP monte dans Amazon EKS en tant que fichiers du système de fichiers, vous devez créer un fichier YAML [SecretProviderClass](ascp-examples.md#ascp-examples-secretproviderclass). La `SecretProviderClass` liste répertorie les secrets à monter et le nom du fichier sous lequel les monter. La `SecretProviderClass` doit se trouver dans le même espace de noms que le pod Amazon EKS auquel il fait référence.
### Montez les secrets sous forme de fichiers
[Les instructions suivantes montrent comment monter des secrets sous forme de fichiers à l'aide d'exemples de fichiers YAML .yaml et [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)
**Pour monter des secrets dans Amazon EKS**
1. Appliquez la `SecretProviderClass` au pod :
```
kubectl apply -f ExampleSecretProviderClass.yaml
```
1. Déployez votre pod :
```
kubectl apply -f ExampleDeployment.yaml
```
1. L’ASCP monte les fichiers.
## Dépannage
Vous pouvez afficher la plupart des erreurs en décrivant le déploiement du pod.
**Pour afficher les messages d'erreur pour votre conteneur**
1. Obtenez une liste de noms de pod à l’aide de la commande suivante. Si vous n'utilisez pas l'espace de noms par défaut, utilisez `-n nameSpace`.
```
kubectl get pods
```
1. Pour décrire le Pod, dans la commande suivante, *podId* utilisez l'ID du Pod indiqué dans les Pods que vous avez trouvés à l'étape précédente. Si vous n'utilisez pas l'espace de noms par défaut, utilisez `-n nameSpace`.
```
kubectl describe pod/podId
```
**Pour voir les erreurs pour l'ASCP**
+ Pour obtenir plus d'informations dans les journaux du fournisseur, utilisez la commande suivante pour *podId* utiliser l'ID du module *csi-secrets-store-provider-aws*.
```
kubectl -n kube-system get pods
kubectl -n kube-system logs Pod/podId
```
+
**Vérifiez que le CRD `SecretProviderClass` est installé :**
```
kubectl get crd secretproviderclasses.secrets-store.csi.x-k8s.io
```
Cette commande doit renvoyer des informations sur la définition de ressource personnalisée `SecretProviderClass`.
+
**Vérifiez que l' SecretProviderClass objet a été créé.**
```
kubectl get secretproviderclass SecretProviderClassName -o yaml
```
# AWS Exemples de code de secret et de fournisseur de configuration
## Exemples d’authentification et de contrôle d’accès pour l’ASCP
### Exemple : politique IAM autorisant le service d’identité du pod Amazon EKS (pods.eks.amazonaws.com) à assumer le rôle et à baliser la session :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
------
## SecretProviderClass
Vous utilisez YAML pour décrire les secrets à monter dans Amazon EKS à l'aide de l'ASCP. Pour obtenir des exemples, consultez [SecretProviderClass utilisation](#ascp-scenarios-secretproviderclass).
### SecretProviderClass Structure YAML
```
apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
name: name
spec:
provider: aws
parameters:
region:
failoverRegion:
pathTranslation:
usePodIdentity:
preferredAddressType:
objects:
```
Le champ Paramètres contient les détails de la demande de montage :
**region**
(Facultatif) Le nom Région AWS du secret. Si vous n'utilisez pas ce champ, ASCP va rechercher la région à partir de l'annotation sur le nœud. Comme cette recherche ajoute une surcharge aux demandes de montage, nous vous recommandons de fournir la région pour les clusters qui utilisent un grand nombre de pods.
Si vous spécifiez également `failoverRegion`, l'ASCP essaie de récupérer le secret des deux régions. Si l'une des régions renvoie une erreur 4xx, notamment en raison d'un problème d'authentification, l'ASCP ne monte aucun secret. Si le secret est récupéré avec succès de `region`, l'ASCP monte cette valeur secrète. Si le secret n'est pas récupéré correctement de `region`, mais qu'il l'est avec succès de `failoverRegion`, l'ASCP monte cette valeur secrète.
**failoverRegion**
(Facultatif) Si vous incluez ce champ, l'ASCP va essayer de récupérer le secret à partir des régions définies dans `region` et dans ce champ. Si l'une des régions renvoie une erreur 4xx, notamment en raison d'un problème d'authentification, l'ASCP ne monte aucun secret. Si le secret est récupéré avec succès de `region`, l'ASCP monte cette valeur secrète. Si le secret n'est pas récupéré correctement de `region`, mais qu'il l'est avec succès de `failoverRegion`, l'ASCP monte cette valeur secrète. Pour accéder à un exemple sur la façon de procéder, consultez [Basculement secret multirégional](#multi-region-failover).
**pathTranslation**
(Facultatif) Un caractère de substitution unique à utiliser si le nom de fichier dans Amazon EKS contient un caractère séparateur de chemin, tel que la barre oblique (/) sur Linux. L'ASCP ne peut pas créer un fichier monté possédant un caractère de séparation de chemin. Par contre, l'ASCP va remplacer le caractère séparateur de chemin par un autre caractère. Si vous n'utilisez pas ce champ, la valeur par défaut est le trait de soulignement (\$1). Par exemple, `My/Path/Secret` se monte en tant que `My_Path_Secret`.
Pour empêcher la substitution de caractères, entrez la chaîne `False`.
**usePodIdentity**
(Facultatif) Détermine l’approche d’authentification. Lorsqu’il n’est pas spécifié, sa valeur par défaut est Rôles IAM pour les comptes de service (IRSA) (IRSA).
+ Pour utiliser l’identité du pod EKS, utilisez l’une des valeurs suivantes : `"true"`", `"True"`, `"TRUE"`, `"t"` ou `"T"`.
+ Pour utiliser IRSA de manière explicite, définissez l’une des valeurs suivantes : `"false"`, `"False"`, `"FALSE"`, `"f"` ou `"F"`"=.
**preferredAddressType**
(Facultatif) Spécifie le type d’adresse IP préféré pour les communications entre les points de terminaison de l’agent d’identité du pod. Le champ n’est applicable que lors de l’utilisation de la fonctionnalité d’identité du pod EKS et sera ignoré lors de l’utilisation des rôles IAM pour les comptes de service. Les valeurs ne sont pas sensibles à la casse. Les valeurs valides sont :
+ `"ipv4"`, `"IPv4"` «, ou `"IPV4"` — Forcer l'utilisation du point de IPv4 terminaison Pod Identity Agent
+ `"ipv6"``"IPv6"`, ou `"IPV6"` — Forcer l'utilisation du point de IPv6 terminaison Pod Identity Agent
+ non spécifié — Utilisez la sélection automatique du point de terminaison, en essayant d'abord le point de IPv4 terminaison et en revenant au IPv6 point de terminaison en cas d' IPv4 échec
**objects**
Chaîne contenant une déclaration YAML des secrets à monter. Nous vous recommandons d'utiliser une chaîne YAML multi-ligne ou un caractère pipe (\$1).
**objectName**
Obligatoire. Spécifie le nom du secret ou du paramètre à récupérer. Pour Secrets Manager, il s’agit du paramètre [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), et il peut s’agir du nom convivial ou de l’ARN complet du secret. Pour le magasin de paramètres SSM, il s'agit [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)du paramètre et il peut s'agir du nom ou de l'ARN complet du paramètre.
**objectType**
Obligatoire si vous n'utilisez pas d'ARN Secrets Manager pour `objectName`. Peut avoir la valeur `secretsmanager` ou `ssmparameter`.
**objectAlias**
(Facultatif) Nom de fichier du secret dans le pod Amazon EKS. Si vous ne spécifiez pas ce champ,`objectName` apparaît en tant que nom de fichier.
**Autorisation du fichier**
(Facultatif) Chaîne octale à 4 chiffres qui indique l'autorisation du fichier à utiliser pour le montage du secret. Si vous ne spécifiez pas ce champ, il sera défini par défaut sur`"0644"`.
**objectVersion**
(Facultatif) ID de version du secret. Déconseillé, car vous devez mettre à jour l'identifiant de la version à chaque fois que vous mettez le secret à jour. La version la plus récente est utilisée par défaut. Si vous incluez un `failoverRegion`, ce champ représente le champ principal `objectVersion`.
**objectVersionLabel**
(Facultatif) Alias de la version. La version par défaut est la plus récente AWSCURRENT. Pour de plus amples informations, veuillez consulter [Versions secrètes](whats-in-a-secret.md#term_version). Si vous incluez un `failoverRegion`, ce champ représente le champ principal `objectVersionLabel`.
**jmesPath**
(Facultatif) Carte des clés dans le secret des fichiers à monter dans Amazon EKS. Pour utiliser ce champ, votre valeur secrète doit être au format JSON. Si vous utilisez ce champ, vous devez inclure les sous-champs `path` et `objectAlias`.
**path**
Une clé issue d'une paire clé-valeur dans le JSON de la valeur secrète. Si le champ contient un trait d'union, utilisez des guillemets simples pour l'ignorer, par exemple : `path: '"hyphenated-path"'`
**objectAlias**
Le nom du fichier à monter dans le pod Amazon EKS. Si le champ contient un trait d'union, utilisez des guillemets simples pour l'ignorer, par exemple : `objectAlias: '"hyphenated-alias"'`
**Autorisation du fichier**
(Facultatif) Chaîne octale à 4 chiffres qui indique l'autorisation du fichier à utiliser pour le montage du secret. Si vous ne spécifiez pas ce champ, l'autorisation de fichier de l'objet parent sera utilisée par défaut.
**failoverObject**
(Facultatif) Si vous spécifiez ce champ, l'ASCP essaie de récupérer à la fois le secret spécifié dans le champ principal `objectName` et le secret spécifié dans le sous-champ `failoverObject` `objectName`. Si l'un ou l'autre renvoie une erreur 4xx, notamment pour un problème d'authentification, l'ASCP ne monte aucun secret. Si le secret est récupéré avec succès à partir du `objectName` principal, l'ASCP monte cette valeur secrète. Si le secret n'est pas récupéré correctement depuis le `objectName` principal, mais qu'il est récupéré correctement depuis le basculement `objectName`, l'ASCP monte cette valeur secrète. Si vous incluez ce champ, vous devez inclure le champ `objectAlias`. Pour accéder à un exemple sur la façon de procéder, consultez [Basculement vers un autre secret](#failover-secret).
Vous allez généralement utiliser ce champ lorsque le secret de basculement n'est pas une réplique. Pour obtenir un exemple de spécification des capacités, consultez [Basculement secret multirégional](#multi-region-failover).
**objectName**
Nom ou ARN complet du secret de basculement. Si vous utilisez un ARN, la région de l'ARN doit correspondre au champ `failoverRegion`.
**objectVersion**
(Facultatif) ID de version du secret. Doit correspondre au principal `objectVersion`. Déconseillé, car vous devez mettre à jour l'identifiant de la version à chaque fois que vous mettez le secret à jour. La version la plus récente est utilisée par défaut.
**objectVersionLabel**
(Facultatif) Alias de la version. La version par défaut est la version la plus récente AWSCURRENT. Pour de plus amples informations, veuillez consulter [Versions secrètes](whats-in-a-secret.md#term_version).
### Créez une SecretProviderClass configuration de base pour monter des secrets dans vos pods Amazon EKS.
------
#### [ Pod Identity ]
SecretProviderClass pour utiliser un secret dans le même 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 utilisation
Utilisez ces exemples pour créer des SecretProviderClass configurations pour différents scénarios.
#### Exemple : Monter des secrets par nom ou ARN
Cet exemple montre comment monter trois types de secrets différents :
+ Un secret spécifié par un ARN complet
+ Un secret spécifié par son nom
+ Une version spécifique d'un secret
```
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"
```
#### Exemple : monter des paires clé-valeur à partir d'un secret
Cet exemple montre comment monter des paires clé-valeur spécifiques à partir d'un secret au format 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
```
#### Exemple : monter des secrets par autorisation de fichier
Cet exemple montre comment monter un secret avec une autorisation de fichier spécifique
```
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"
```
#### Exemple : exemples de configuration de basculement
Ces exemples montrent comment configurer le basculement pour les secrets.
##### Basculement secret multirégional
Cet exemple montre comment configurer le basculement automatique pour un secret répliqué dans plusieurs régions :
```
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"
```
##### Basculement vers un autre secret
Cet exemple montre comment configurer le basculement vers un autre secret (pas une réplique) :
```
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"
```
## Ressources supplémentaires
Pour plus d’informations sur l’utilisation d’ASCP avec Amazon EKS, consultez les ressources suivantes :
+ [Utilisation de l’identité du pod avec Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html)
+ [Utilisation des AWS secrets et du fournisseur de configuration](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_ascp_csi.html)
+ [AWS Pilote CSI Secrets Store activé GitHub](https://github.com/aws/secrets-store-csi-driver-provider-aws)
# Utiliser des AWS Secrets Manager secrets dans les AWS Lambda fonctions
AWS Lambda est un service de calcul sans serveur qui vous permet d'exécuter du code sans provisionner ni gérer de serveurs. Parameter Store, une fonctionnalité de AWS Systems Manager, fournit un stockage hiérarchique sécurisé pour la gestion des données de configuration et la gestion des secrets. Vous pouvez utiliser l'extension Lambda AWS Parameters and Secrets pour récupérer et mettre en cache les AWS Secrets Manager secrets et les paramètres du Parameter Store dans les fonctions Lambda sans utiliser de SDK. Pour des informations détaillées sur l'utilisation de cette extension, consultez la section [Utiliser les secrets du Gestionnaire de secrets dans les fonctions Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-secrets-manager.html) dans le Guide du développeur *Lambda*.
## Utilisation des secrets de Secrets Manager avec Lambda
Le guide du développeur Lambda fournit des instructions complètes sur l'utilisation des secrets de Secrets Manager dans les fonctions Lambda. Mise en route :
1. Suivez le step-by-step didacticiel de la section [Utiliser les secrets du Gestionnaire de secrets dans les fonctions Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-secrets-manager.html), qui inclut :
+ Création d'une fonction Lambda avec votre environnement d'exécution préféré (Python, Node.js, Java)
+ Ajout de l'extension Lambda AWS Parameters and Secrets en tant que couche
+ Configuration des autorisations nécessaires
+ Écrire du code pour récupérer les secrets de l'extension
+ Tester votre fonction
1. Découvrez les variables d'environnement permettant de configurer le comportement de l'extension, notamment les paramètres du cache et les délais d'expiration
1. Découvrez les meilleures pratiques relatives à l'utilisation de la rotation secrète
### Utilisation de Secrets Manager et Lambda dans un VPC
Si votre fonction Lambda s'exécute dans un VPC, vous devez créer un point de terminaison VPC afin que l'extension puisse appeler Secrets Manager. Pour de plus amples informations, veuillez consulter [Utilisation d'un point de AWS Secrets Manager terminaison VPC](vpc-endpoint-overview.md).
## Utilisation de l'extension Lambda AWS Parameters and Secrets
L'extension peut récupérer les secrets de Secrets Manager et les paramètres du Parameter Store. Pour obtenir des informations détaillées sur l'utilisation des paramètres du magasin de paramètres avec l'extension, consultez la section [Utilisation des paramètres du magasin de paramètres dans les fonctions Lambda](https://docs.aws.amazon.com/systems-manager/latest/userguide/ps-integration-lambda-extensions.html) du guide de l'*AWS Systems Manager utilisateur*.
La documentation de Systems Manager inclut :
+ Explication détaillée du fonctionnement de l'extension avec Parameter Store
+ Instructions pour ajouter l'extension à une fonction Lambda
+ Variables d'environnement pour configurer l'extension
+ Exemples de commandes pour récupérer des paramètres
+ Liste complète des extensions ARNs pour toutes les architectures et régions prises en charge
# Utilisation de l' AWS Secrets Manager agent
## Comment fonctionne l'agent Secrets Manager
L' AWS Secrets Manager Agent est un service HTTP côté client qui vous aide à normaliser la façon dont vous consommez les secrets de Secrets Manager dans vos environnements informatiques. Vous pouvez l'utiliser avec les services suivants :
+ AWS Lambda
+ Amazon Elastic Container Service
+ Amazon Elastic Kubernetes Service
+ Amazon Elastic Compute Cloud
L'agent Secrets Manager récupère et met en cache les secrets en mémoire, ce qui permet à vos applications d'obtenir des secrets auprès de localhost au lieu de passer des appels directs à Secrets Manager. L'agent Secrets Manager peut uniquement lire les secrets, il ne peut pas les modifier.
**Important**
L'agent Secrets Manager utilise les AWS informations d'identification de votre environnement pour appeler Secrets Manager. Il inclut une protection contre la falsification des requêtes côté serveur (SSRF) afin d'améliorer la sécurité des secrets. L'agent Secrets Manager utilise l'échange de clés ML-KEM post-quantique comme échange de clés ayant la priorité la plus élevée par défaut.
## Comprendre la mise en cache des agents Secrets Manager
L'agent Secrets Manager utilise un cache en mémoire qui se réinitialise au redémarrage de l'agent Secrets Manager. Il actualise régulièrement les valeurs secrètes mises en cache en fonction des éléments suivants :
+ La fréquence de rafraîchissement par défaut (TTL) est de 300 secondes
+ Vous pouvez modifier le TTL à l'aide d'un fichier de configuration
+ L'actualisation a lieu lorsque vous demandez un secret après l'expiration du TTL
**Note**
L'agent Secrets Manager n'inclut pas l'invalidation du cache. Si un secret change avant l'expiration de l'entrée du cache, l'agent Secrets Manager peut renvoyer une valeur secrète périmée.
L'agent Secrets Manager renvoie les valeurs secrètes dans le même format que la réponse de`GetSecretValue`. Les valeurs secrètes ne sont pas chiffrées dans le cache.
**Topics**
+ [Comment fonctionne l'agent Secrets Manager](#agent-overview)
+ [Comprendre la mise en cache des agents Secrets Manager](#agent-caching)
+ [Créez l'agent Secrets Manager](#secrets-manager-agent-build)
+ [Installation de l'agent Secrets Manager](#secrets-manager-agent-install)
+ [Récupérez des secrets avec l'agent Secrets Manager](#secrets-manager-agent-call)
+ [Comprendre le `refreshNow` paramètre](#secrets-manager-agent-refresh)
+ [Configuration de l'agent Secrets Manager](#secrets-manager-agent-config)
+ [Fonctionnalités optionnelles](#secrets-manager-agent-features)
+ [Logging](#secrets-manager-agent-log)
+ [Considérations sur la sécurité](#secrets-manager-agent-security)
## Créez l'agent Secrets Manager
Avant de commencer, assurez-vous que les outils de développement standard et les outils Rust sont installés pour votre plateforme.
**Note**
La création de l'agent avec la `fips` fonctionnalité activée sur macOS nécessite actuellement la solution de contournement suivante :
Créez une variable d'environnement appelée `SDKROOT` qui est définie sur le résultat de l'exécution `xcrun --show-sdk-path`
------
#### [ RPM-based systems ]
**Pour s'appuyer sur des systèmes basés sur le RPM**
1. Utilisez le `install` script fourni dans le référentiel.
Le script génère un jeton SSRF aléatoire au démarrage et le stocke dans le fichier`/var/run/awssmatoken`. Le jeton est lisible par le `awssmatokenreader` groupe créé par le script d'installation.
1. Pour permettre à votre application de lire le fichier de jetons, vous devez ajouter au `awssmatokenreader` groupe le compte utilisateur sous lequel votre application s'exécute. Par exemple, vous pouvez autoriser votre application à lire le fichier de jetons à l'aide de la commande usermod suivante, où ** est l'ID utilisateur sous lequel votre application s'exécute.
```
sudo usermod -aG awssmatokenreader
```
**Installation d'outils de développement**
Sur les systèmes basés sur le RPM tels que AL2023, installez le groupe d'outils de développement :
```
sudo yum -y groupinstall "Development Tools"
```
1.
**Installez Rust**
Suivez les instructions de la section [Installer Rust](https://www.rust-lang.org/tools/install) dans la *documentation Rust* :
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions
. "$HOME/.cargo/env"
```
1.
**Créez l'agent**
Créez l'agent Secrets Manager à l'aide de la commande cargo build :
```
cargo build --release
```
Vous trouverez le fichier exécutable sous`target/release/aws_secretsmanager_agent`.
------
#### [ Debian-based systems ]
**Pour s'appuyer sur des systèmes basés sur Debian**
1.
**Installation d'outils de développement**
Sur les systèmes basés sur Debian tels qu'Ubuntu, installez le package build-essential :
```
sudo apt install build-essential
```
1.
**Installez Rust**
Suivez les instructions de la section [Installer Rust](https://www.rust-lang.org/tools/install) dans la *documentation Rust* :
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh # Follow the on-screen instructions
. "$HOME/.cargo/env"
```
1.
**Créez l'agent**
Créez l'agent Secrets Manager à l'aide de la commande cargo build :
```
cargo build --release
```
Vous trouverez le fichier exécutable sous`target/release/aws_secretsmanager_agent`.
------
#### [ Windows ]
**Pour créer sous Windows**
1.
**Configuration de l'environnement de développement**
Suivez les instructions de la [section Configurer votre environnement de développement sous Windows pour Rust](https://learn.microsoft.com/en-us/windows/dev-environment/rust/setup) dans la *documentation Microsoft Windows*.
1.
**Créez l'agent**
Créez l'agent Secrets Manager à l'aide de la commande cargo build :
```
cargo build --release
```
Vous trouverez le fichier exécutable sous`target/release/aws_secretsmanager_agent.exe`.
------
#### [ Cross-compile natively ]
**Pour effectuer une compilation croisée en mode natif**
1.
**Installation d'outils de compilation croisée**
Sur les distributions où le package mingw-w64 est disponible, comme Ubuntu, installez la chaîne d'outils de compilation croisée :
```
# Install the cross compile tool chain
sudo add-apt-repository universe
sudo apt install -y mingw-w64
```
1.
**Ajouter des cibles de build Rust**
Installez la cible de compilation Windows GNU :
```
rustup target add x86_64-pc-windows-gnu
```
1.
**Construire pour Windows**
Compilez l'agent pour Windows de manière croisée :
```
cargo build --release --target x86_64-pc-windows-gnu
```
Vous trouverez le fichier exécutable à l'adresse`target/x86_64-pc-windows-gnu/release/aws_secretsmanager_agent.exe`.
------
#### [ Cross compile with Rust cross ]
**Pour effectuer une compilation croisée à l'aide de Rust cross**
Si les outils de compilation croisée ne sont pas disponibles nativement sur le système, vous pouvez utiliser le projet croisé Rust. Pour plus d'informations, voir [https://github.com/cross-rs/croix](https://github.com/cross-rs/cross).
**Important**
Nous recommandons 32 Go d'espace disque pour l'environnement de génération.
1.
**Configurer Docker**
Installez et configurez Docker :
```
# Install and start docker
sudo yum -y install docker
sudo systemctl start docker
sudo systemctl enable docker # Make docker start after reboot
```
1.
**Configurer les autorisations Docker**
Ajoutez votre utilisateur au groupe de dockers :
```
# Give ourselves permission to run the docker images without sudo
sudo usermod -aG docker $USER
newgrp docker
```
1.
**Construire pour Windows**
Installez cross et compilez l'exécutable :
```
# Install cross and cross compile the executable
cargo install cross
cross build --release --target x86_64-pc-windows-gnu
```
------
## Installation de l'agent Secrets Manager
Choisissez votre environnement informatique parmi les options d'installation suivantes.
------
#### [ Amazon EC2 ]
**Pour installer l'agent Secrets Manager sur Amazon EC2**
1.
**Accédez au répertoire de configuration**
Accédez au répertoire de configuration :
```
cd aws_secretsmanager_agent/configuration
```
1.
**Exécuter le script d'installation**
Exécutez le `install` script fourni dans le référentiel.
Le script génère un jeton SSRF aléatoire au démarrage et le stocke dans le fichier`/var/run/awssmatoken`. Le jeton est lisible par le `awssmatokenreader` groupe créé par le script d'installation.
1.
**Configurer les autorisations des applications**
Ajoutez au `awssmatokenreader` groupe le compte utilisateur sous lequel votre application s'exécute :
```
sudo usermod -aG awssmatokenreader APP_USER
```
Remplacez *APP\$1USER* par l'ID utilisateur sous lequel votre application s'exécute.
------
#### [ Container Sidecar ]
Vous pouvez exécuter l'agent Secrets Manager en tant que conteneur annexe à votre application à l'aide de Docker. Votre application peut ensuite récupérer les secrets depuis le serveur HTTP local fourni par l'agent Secrets Manager. Pour plus d'informations sur Docker, consultez la documentation [Docker](https://docs.docker.com).
**Pour créer un conteneur annexe pour l'agent Secrets Manager**
1.
**Créer un agent Dockerfile**
Créez un Dockerfile pour le conteneur annexe de l'agent Secrets Manager :
```
# Use the latest Debian image as the base
FROM debian:latest
# Set the working directory inside the container
WORKDIR /app
# Copy the Secrets Manager Agent binary to the container
COPY secrets-manager-agent .
# Install any necessary dependencies
RUN apt-get update && apt-get install -y ca-certificates
# Set the entry point to run the Secrets Manager Agent binary
ENTRYPOINT ["./secrets-manager-agent"]
```
1.
**Créer un Dockerfile d'application**
Créez un Dockerfile pour votre application cliente.
1.
**Créer un fichier Docker Compose**
Créez un fichier Docker Compose pour exécuter les deux conteneurs avec une interface réseau partagée :
**Important**
Vous devez charger les AWS informations d'identification et le jeton SSRF pour que l'application puisse utiliser l'agent Secrets Manager. Pour Amazon EKS et Amazon ECS, consultez les rubriques suivantes :
[Gérez l'accès](https://docs.aws.amazon.com/eks/latest/userguide/cluster-auth.html) dans le *guide de l'utilisateur Amazon EKS*
[Rôle IAM de la tâche Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) dans le manuel du *développeur Amazon ECS*
```
version: '3'
services:
client-application:
container_name: client-application
build:
context: .
dockerfile: Dockerfile.client
command: tail -f /dev/null # Keep the container running
secrets-manager-agent:
container_name: secrets-manager-agent
build:
context: .
dockerfile: Dockerfile.agent
network_mode: "container:client-application" # Attach to the client-application container's network
depends_on:
- client-application
```
1.
**Agent de copie binaire**
Copiez le `secrets-manager-agent` fichier binaire dans le même répertoire que celui qui contient vos fichiers Dockerfiles et Docker Compose.
1.
**Créez et gérez des conteneurs**
Créez et exécutez les conteneurs à l'aide de Docker Compose :
```
docker-compose up --build
```
1.
**Étapes suivantes**
Vous pouvez désormais utiliser l'agent Secrets Manager pour récupérer les secrets de votre conteneur client. Pour de plus amples informations, veuillez consulter [Récupérez des secrets avec l'agent Secrets Manager](#secrets-manager-agent-call).
------
#### [ Lambda ]
Vous pouvez [empaqueter l'agent Secrets Manager sous forme d'extension Lambda](https://docs.aws.amazon.com/lambda/latest/dg/packaging-layers.html). Vous pouvez ensuite l'[ajouter à votre fonction Lambda sous forme de couche](https://docs.aws.amazon.com/lambda/latest/dg/adding-layers.html) et appeler l'agent Secrets Manager depuis votre fonction Lambda pour obtenir des secrets.
Les instructions suivantes montrent comment obtenir un nom de secret à l'aide *MyTest*de l'exemple de script [https://github.com/aws/aws-secretsmanager-agent](https://github.com/aws/aws-secretsmanager-agent)pour installer l'agent Secrets Manager `secrets-manager-agent-extension.sh` en tant qu'extension Lambda.
**Pour créer une extension Lambda pour l'agent Secrets Manager**
1.
**Package de la couche d'agent**
À partir de la racine du package de code de l'agent Secrets Manager, exécutez les commandes suivantes :
```
AWS_ACCOUNT_ID=AWS_ACCOUNT_ID
LAMBDA_ARN=LAMBDA_ARN
# Build the release binary
cargo build --release --target=x86_64-unknown-linux-gnu
# Copy the release binary into the `bin` folder
mkdir -p ./bin
cp ./target/x86_64-unknown-linux-gnu/release/aws_secretsmanager_agent ./bin/secrets-manager-agent
# Copy the `secrets-manager-agent-extension.sh` example script into the `extensions` folder.
mkdir -p ./extensions
cp aws_secretsmanager_agent/examples/example-lambda-extension/secrets-manager-agent-extension.sh ./extensions
# Zip the extension shell script and the binary
zip secrets-manager-agent-extension.zip bin/* extensions/*
# Publish the layer version
LAYER_VERSION_ARN=$(aws lambda publish-layer-version \
--layer-name secrets-manager-agent-extension \
--zip-file "fileb://secrets-manager-agent-extension.zip" | jq -r '.LayerVersionArn')
```
1.
**Configurer le jeton SSRF**
La configuration par défaut de l'agent définira automatiquement le jeton SSRF à la valeur définie dans les variables prédéfinies `AWS_SESSION_TOKEN` ou d'`AWS_CONTAINER_AUTHORIZATION_TOKEN`environnement (cette dernière variable est activée pour les fonctions Lambda). SnapStart Vous pouvez également définir la variable d'`AWS_TOKEN`environnement avec une valeur arbitraire pour votre fonction Lambda, car cette variable a priorité sur les deux autres. Si vous choisissez d'utiliser la variable d'`AWS_TOKEN`environnement, vous devez définir cette variable d'environnement par un `lambda:UpdateFunctionConfiguration` appel.
1.
**Attacher une couche à la fonction**
Attachez la version de la couche à votre fonction Lambda :
```
# Attach the layer version to the Lambda function
aws lambda update-function-configuration \
--function-name $LAMBDA_ARN \
--layers "$LAYER_VERSION_ARN"
```
1.
**Mettre à jour le code de la fonction**
Mettez à jour votre fonction Lambda pour effectuer `http://localhost:2773/secretsmanager/get?secretId=MyTest` une requête avec la valeur d'`X-Aws-codes-Secrets-Token`en-tête définie sur la valeur du jeton SSRF provenant de l'une des variables d'environnement mentionnées ci-dessus afin de récupérer le secret. Veillez à implémenter une logique de nouvelle tentative dans le code de votre application afin de prendre en compte les délais d'initialisation et d'enregistrement de l'extension Lambda.
1.
**Tester la fonction**
Appelez la fonction Lambda pour vérifier que le secret est correctement extrait.
------
## Récupérez des secrets avec l'agent Secrets Manager
Pour récupérer un secret, appelez le point de terminaison local de l'agent Secrets Manager avec le nom du secret ou l'ARN comme paramètre de requête. Par défaut, l'agent Secrets Manager récupère la `AWSCURRENT` version du secret. Pour récupérer une version différente, utilisez le paramètre VersionStage ou VersionId.
**Important**
Pour protéger l'agent Secrets Manager, vous devez inclure un en-tête de jeton SSRF dans chaque demande :`X-Aws-Parameters-Secrets-Token`. L'agent Secrets Manager refuse les demandes qui ne contiennent pas cet en-tête ou qui contiennent un jeton SSRF non valide. Vous pouvez personnaliser le nom de l'en-tête SSRF dans le[Configuration de l'agent Secrets Manager](#secrets-manager-agent-config).
### Autorisations requises
L'agent Secrets Manager utilise le AWS SDK pour Rust, qui utilise la chaîne de [fournisseurs AWS d'informations d'identification](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html). L'identité de ces informations d'identification IAM détermine les autorisations dont dispose l'agent Secrets Manager pour récupérer les secrets.
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Pour en savoir plus sur les autorisations, consultez [Référence des autorisations pour AWS Secrets Manager](auth-and-access.md#reference_iam-permissions).
**Important**
Une fois la valeur secrète saisie dans l'agent Secrets Manager, tout utilisateur ayant accès à l'environnement informatique et au jeton SSRF peut accéder au secret depuis le cache de l'agent Secrets Manager. Pour de plus amples informations, veuillez consulter [Considérations sur la sécurité](#secrets-manager-agent-security).
### Exemples de demandes
------
#### [ curl ]
**Example Exemple — Obtenir un secret en utilisant curl**
L'exemple de curl suivant montre comment obtenir un secret auprès de l'agent Secrets Manager. L'exemple repose sur la présence du SSRF dans un fichier, où il est stocké par le script d'installation.
```
curl -v -H \\
"X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\
'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID' \\
echo
```
------
#### [ Python ]
**Example Exemple — Obtenir un secret en utilisant Python**
L'exemple Python suivant montre comment obtenir un secret à partir de l'agent Secrets Manager. L'exemple repose sur la présence du SSRF dans un fichier, où il est stocké par le script d'installation.
```
import requests
import json
# Function that fetches the secret from Secrets Manager Agent for the provided secret id.
def get_secret():
# Construct the URL for the GET request
url = f"http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID"
# Get the SSRF token from the token file
with open('/var/run/awssmatoken') as fp:
token = fp.read()
headers = {
"X-Aws-Parameters-Secrets-Token": token.strip()
}
try:
# Send the GET request with headers
response = requests.get(url, headers=headers)
# Check if the request was successful
if response.status_code == 200:
# Return the secret value
return response.text
else:
# Handle error cases
raise Exception(f"Status code {response.status_code} - {response.text}")
except Exception as e:
# Handle network errors
raise Exception(f"Error: {e}")
```
------
## Comprendre le `refreshNow` paramètre
L'agent Secrets Manager utilise un cache en mémoire pour stocker les valeurs secrètes, qu'il actualise régulièrement. Par défaut, cette actualisation a lieu lorsque vous demandez un secret après l'expiration du délai de vie (TTL), généralement toutes les 300 secondes. Cependant, cette approche peut parfois entraîner des valeurs secrètes périmées, en particulier si un secret change avant l'expiration de l'entrée du cache.
Pour pallier cette limitation, l'agent Secrets Manager prend en charge un paramètre appelé `refreshNow` dans l'URL. Vous pouvez utiliser ce paramètre pour forcer l'actualisation immédiate de la valeur d'un secret, en contournant le cache et en vous assurant de disposer du maximum up-to-date d'informations.
**Comportement par défaut (sans`refreshNow`)**
+ Utilise les valeurs mises en cache jusqu'à l'expiration du TTL
+ Actualise les secrets uniquement après TTL (300 secondes par défaut)
+ Peut renvoyer des valeurs périmées si les secrets changent avant l'expiration du cache
**Comportement avec `refreshNow=true`**
+ Contourne complètement le cache
+ Récupère la dernière valeur secrète directement depuis Secrets Manager
+ Met à jour le cache avec la nouvelle valeur et réinitialise le TTL
+ Garantit que vous obtenez toujours la valeur secrète la plus récente
### Actualiser de force une valeur secrète
**Important**
La valeur par défaut de `refreshNow` est `false`. Lorsqu'il est défini sur`true`, il remplace le TTL spécifié dans le fichier de configuration de l'agent Secrets Manager et envoie un appel d'API à Secrets Manager.
------
#### [ curl ]
**Example Exemple — Actualisation forcée d'un secret à l'aide de curl**
L'exemple de curl suivant montre comment forcer l'agent Secrets Manager à actualiser le secret. L'exemple repose sur la présence du SSRF dans un fichier, où il est stocké par le script d'installation.
```
curl -v -H \\
"X-Aws-Parameters-Secrets-Token: $(/var/run/awssmatoken)" \\
'http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID&refreshNow=true' \\
echo
```
------
#### [ Python ]
**Example Exemple — Actualisation forcée d'un secret à l'aide de Python**
L'exemple Python suivant montre comment obtenir un secret à partir de l'agent Secrets Manager. L'exemple repose sur la présence du SSRF dans un fichier, où il est stocké par le script d'installation.
```
import requests
import json
# Function that fetches the secret from Secrets Manager Agent for the provided secret id.
def get_secret():
# Construct the URL for the GET request
url = f"http://localhost:2773/secretsmanager/get?secretId=YOUR_SECRET_ID&refreshNow=true"
# Get the SSRF token from the token file
with open('/var/run/awssmatoken') as fp:
token = fp.read()
headers = {
"X-Aws-Parameters-Secrets-Token": token.strip()
}
try:
# Send the GET request with headers
response = requests.get(url, headers=headers)
# Check if the request was successful
if response.status_code == 200:
# Return the secret value
return response.text
else:
# Handle error cases
raise Exception(f"Status code {response.status_code} - {response.text}")
except Exception as e:
# Handle network errors
raise Exception(f"Error: {e}")
```
------
## Configuration de l'agent Secrets Manager
Pour modifier la configuration de l'agent Secrets Manager, créez un fichier de configuration [TOML](https://toml.io/en/), puis appelez`./aws_secretsmanager_agent --config config.toml`.Options de configuration
**`log_level`**
Niveau de détail indiqué dans les journaux pour l'agent Secrets Manager : DEBUG, INFO, WARN, ERROR ou NONE. La valeur par défaut est INFO.
**`log_to_file`**
S'il faut se connecter à un fichier ou à stdout/stderr : ou. `true` `false` La valeur par défaut est `true`.
**`http_port`**
Port du serveur HTTP local, compris entre 1024 et 65535. La valeur par défaut est 2773.
**`region`**
La AWS région à utiliser pour les demandes. Si aucune région n'est spécifiée, l'agent Secrets Manager détermine la région à partir du SDK. Pour plus d'informations, consultez [Spécifier vos informations d'identification et la région par défaut](https://docs.aws.amazon.com/sdk-for-rust/latest/dg/credentials.html) dans le *guide du développeur du AWS SDK pour Rust*.
**`ttl_seconds`**
Le TTL en secondes pour les éléments mis en cache, compris entre 0 et 3 600. La valeur par défaut est 300. 0 indique qu'il n'y a pas de mise en cache.
**`cache_size`**
Le nombre maximum de secrets pouvant être stockés dans le cache, compris entre 1 et 1 000. La valeur par défaut est 1000.
**`ssrf_headers`**
Une liste de noms d'en-têtes que l'agent Secrets Manager vérifie pour le jeton SSRF. La valeur par défaut est « X-Aws-Parameters-Secrets-Token ». X-Vault-Token
**`ssrf_env_variables`**
Une liste de noms de variables d'environnement que l'agent Secrets Manager vérifie dans l'ordre séquentiel pour le jeton SSRF. La variable d'environnement peut contenir le jeton ou une référence au fichier du jeton comme dans :`AWS_TOKEN=file:///var/run/awssmatoken`. La valeur par défaut est «AWS\$1TOKEN, AWS\$1SESSION \$1TOKEN, AWS\$1CONTAINER \$1AUTHORIZATION\$1TOKEN ».
**`path_prefix`**
Le préfixe d'URI utilisé pour déterminer si la demande est une demande basée sur le chemin. La valeur par défaut est « /v1/ ».
**`max_conn`**
Le nombre maximum de connexions depuis des clients HTTP autorisées par l'agent Secrets Manager, compris entre 1 et 1 000. La valeur par défaut est 800.
## Fonctionnalités optionnelles
L'agent Secrets Manager peut être créé avec des fonctionnalités optionnelles en passant le `--features` drapeau à`cargo build`. Les fonctionnalités disponibles sont les suivantes :Fonctions de génération
**`prefer-post-quantum`**
Génère `X25519MLKEM768` l'algorithme d'échange de clés ayant la priorité la plus élevée. Dans le cas contraire, il est disponible mais n'est pas prioritaire. `X25519MLKEM768`est un algorithme hybride d'échange de post-quantum-secure clés.
**`fips`**
Limite les suites de chiffrement utilisées par l'agent aux seuls chiffrements approuvés par FIPS.
## Logging
**Journalisation locale**
L'agent Secrets Manager enregistre les erreurs localement dans le fichier `logs/secrets_manager_agent.log` ou dans stdout/stderr en fonction de la variable de configuration. `log_to_file` Lorsque votre application appelle l'agent Secrets Manager pour obtenir un secret, ces appels apparaissent dans le journal local. Ils n'apparaissent pas dans les CloudTrail journaux.
**Rotation du journal**
L'agent Secrets Manager crée un nouveau fichier journal lorsque le fichier atteint 10 Mo, et il stocke jusqu'à cinq fichiers journaux au total.
**AWS journalisation des services**
Le journal n'est pas envoyé à Secrets Manager CloudTrail, ou CloudWatch. Les demandes d'obtention de secrets de la part de l'agent Secrets Manager n'apparaissent pas dans ces journaux. Lorsque l'agent Secrets Manager appelle Secrets Manager pour obtenir un secret, cet appel est enregistré CloudTrail avec une chaîne d'agent utilisateur contenant`aws-secrets-manager-agent`.
Vous pouvez configurer les options de journalisation dans le[Configuration de l'agent Secrets Manager](#secrets-manager-agent-config).
## Considérations sur la sécurité
**Domaine de confiance**
Pour une architecture d'agent, le domaine de confiance correspond à l'endroit où le point de terminaison de l'agent et le jeton SSRF sont accessibles, c'est-à-dire généralement l'ensemble de l'hôte. Le domaine de confiance de l'agent Secrets Manager doit correspondre au domaine dans lequel les informations d'identification du Secrets Manager sont disponibles afin de maintenir le même niveau de sécurité. Par exemple, sur Amazon EC2, le domaine de confiance de l'agent Secrets Manager serait le même que celui des informations d'identification lors de l'utilisation de rôles pour Amazon EC2.
**Important**
Les applications soucieuses de sécurité qui n'utilisent pas déjà une solution d'agent avec les informations d'identification de Secrets Manager verrouillées sur l'application devraient envisager d'utiliser des solutions spécifiques à la langue AWS SDKs ou de mise en cache. Pour plus d'informations, voir [Obtenir des secrets](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html).
# Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK C\$1\$1
Pour les applications C\$1\$1, appelez le SDK directement avec [GetSecretValue](https://docs.aws.amazon.com/goto/SdkForCpp/secretsmanager-2017-10-17/GetSecretValue)ou [BatchGetSecretValue](https://docs.aws.amazon.com/goto/SdkForCpp/secretsmanager-2017-10-17/BatchGetSecretValue).
L'exemple de code suivant montre comment obtenir une valeur de Secrets Secrets Manager.
**Autorisations requises : **`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();
}
```
# Obtenez une valeur secrète de Secrets Manager à l'aide du JavaScript AWS SDK
Pour JavaScript les applications, appelez le SDK directement avec [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#getSecretValue-property](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#getSecretValue-property)ou [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#batchGetSecretValue-property](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SecretsManager.html#batchGetSecretValue-property).
L'exemple de code suivant montre comment obtenir une valeur de Secrets Secrets Manager.
**Autorisations requises : **`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;
}
};
```
# Obtenez une valeur secrète de Secrets Manager à l'aide du SDK Kotlin AWS
Pour les applications Kotlin, appelez le SDK directement avec [GetSecretValue](https://github.com/awslabs/aws-sdk-kotlin#generating-api-documentation)ou. [BatchGetSecretValue](https://github.com/awslabs/aws-sdk-kotlin#generating-api-documentation)
L'exemple de code suivant montre comment obtenir une valeur de Secrets Secrets Manager.
**Autorisations requises : **`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")
}
}
```
# Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK PHP
Pour les applications PHP, appelez directement le SDK avec [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) ou [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).
L'exemple de code suivant montre comment obtenir une valeur de Secrets Secrets Manager.
**Autorisations requises : **`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
```
# Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK Ruby
Pour les applications Ruby, appelez directement le SDK avec [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) ou [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).
L'exemple de code suivant montre comment obtenir une valeur de Secrets Secrets Manager.
**Autorisations requises : **`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
```
# Obtenez une valeur secrète à l'aide du AWS CLI
**Autorisations requises : **`secretsmanager:GetSecretValue`
**Example Récupération de la valeur secrète cryptée d'un secret**
L'exemple suivant [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) récupère la valeur actuelle du secret.
```
aws secretsmanager get-secret-value \
--secret-id MyTestSecret
```
**Example Récupération de la valeur secrète précédente**
L'exemple suivant [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) récupère la valeur précédente du secret.
```
aws secretsmanager get-secret-value \
--secret-id MyTestSecret
--version-stage AWSPREVIOUS
```
## Obtenez un groupe de secrets par lots à l'aide du AWS CLI
**Autorisations requises : **
+ `secretsmanager:BatchGetSecretValue`
+ `secretsmanager:GetSecretValue`autorisation pour chaque secret que vous souhaitez récupérer.
+ Si vous utilisez des filtres, vous devez également avoir `secretsmanager:ListSecrets`.
Pour obtenir un exemple de politique d'autorisations, consultez [Exemple : autorisation de récupérer un groupe de valeurs secrètes dans un lot](auth-and-access_iam-policies.md#auth-and-access_examples_batch).
**Important**
Si vous avez une politique VPCE qui refuse l'autorisation de récupérer un secret individuel dans le groupe que vous recherchez, `BatchGetSecretValue` ne renverra aucune valeur de secret et renverra une erreur.
**Example Récupération de la valeur de secret d'un groupe de secrets listés par nom**
L'exemple [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) suivant récupère la valeur du secret pour trois secrets.
```
aws secretsmanager batch-get-secret-value \
--secret-id-list MySecret1 MySecret2 MySecret3
```
**Example Récupération de la valeur de secret d'un groupe de secrets sélectionnés par filtre**
L'exemple [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) suivant récupère la valeur de secret pour les secrets dotés d'une balise nommée « Test ».
```
aws secretsmanager batch-get-secret-value \
--filters Key="tag-key",Values="Test"
```
# Obtenir une valeur secrète à l'aide de la AWS console
**Pour récupérer un secret (console)**
1. Ouvrez la console Secrets Manager à l'adresse [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. Dans la liste des secrets, sélectionnez celui que vous souhaitez récupérer.
1. Dans la section **Secret value (Valeur du secret)**, choisissez **Retrieve secret value (Récupérer la valeur du secret)**.
Secrets Manager affiche la version actuelle (`AWSCURRENT`) du secret. Pour afficher les [autres versions](whats-in-a-secret.md#term_version) du secret, telles que les versions étiquetées personnalisées ou `AWSPREVIOUS`, utilisez [Obtenez une valeur secrète à l'aide du AWS CLI](retrieving-secrets_cli.md).
# Utilisez AWS Secrets Manager des secrets dans AWS Batch
AWS Batch vous permet d'exécuter des charges de travail de calcul par lots sur le AWS Cloud. Avec AWS Batch, vous pouvez injecter des données sensibles dans vos tâches en stockant vos données sensibles en AWS Secrets Manager secret, puis en les référençant dans votre définition de tâche. Pour plus d'informations, consultez [Spécification de données sensibles à l'aide de Secrets Manager](https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data-secrets.html).
# Trouver un AWS Secrets Manager secret dans une CloudFormation ressource
Avec CloudFormation, vous pouvez récupérer un secret à utiliser dans une autre CloudFormation ressource. Un scénario habituel consiste à créer d'abord un secret avec un mot de passe généré par Secrets Manager, à récupérer le nom d'utilisateur et le mot de passe du secret pour les utiliser comme des informations d'identification dans une nouvelle base de données. Pour plus d'informations sur la création de secrets avec CloudFormation, consultez[Créez des AWS Secrets Manager secrets dans AWS CloudFormation](cloudformation.md).
Pour récupérer un secret dans un CloudFormation modèle, vous devez utiliser une *référence dynamique*. Lorsque vous créez la pile, la référence dynamique introduit la valeur secrète dans la CloudFormation ressource, de sorte que vous n'avez pas à coder en dur les informations secrètes. Au lieu de cela, vous vous référez au secret par son nom ou son ARN. Vous pouvez utiliser une référence dynamique pour un secret dans n'importe quelle propriété de ressource. Vous ne pouvez pas utiliser de référence dynamique pour un secret dans les métadonnées des ressources, à l'instar de [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-init.html), car cela rendrait la valeur secrète visible dans la console.
Une référence dynamique pour un secret présente le modèle suivant :
```
{{resolve:secretsmanager:secret-id:SecretString:json-key:version-stage:version-id}}
```
**secret-id**
Nom ou ARN du secret. Pour accéder à un secret de votre AWS compte, vous pouvez utiliser le nom du secret. Pour accéder à un secret d'un autre AWS compte, utilisez l'ARN du secret.
**json-key** (Facultatif)
Le nom de clé de la paire clé-valeur dont vous voulez récupérer la valeur. Si vous ne spécifiez pas de`json-key`, CloudFormation récupère l'intégralité du texte secret. Ce segment peut ne pas inclure le caractère deux-points (`:` ).
**version-stage** (Facultatif)
La [version](whats-in-a-secret.md#term_version) du secret à utiliser. Secrets Manager utilise des étiquettes intermédiaires pour assurer le suivi des différentes versions pendant le processus de rotation. Si vous utilisez `version-stage`, ne spécifiez pas `version-id`. Si vous ne spécifiez ni `version-stage` ni `version-id`, alors la version par défaut est la version `AWSCURRENT`. Ce segment peut ne pas inclure le caractère deux-points (`:` ).
**version-id** (Facultatif)
L'identifiant unique de la version du secret à utiliser. Si vous spécifiez `version-id`, ne spécifiez pas `version-stage`. Si vous ne spécifiez ni `version-stage` ni `version-id`, alors la version par défaut est la version `AWSCURRENT`. Ce segment peut ne pas inclure le caractère deux-points (`:` ).
Pour de plus amples informations, veuillez consulter [Utilisation de références dynamiques pour spécifier les secrets Secrets Manager](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html#dynamic-references-secretsmanager).
**Note**
Ne créez pas de référence dynamique en utilisant une barre oblique inversée `(\)` comme valeur finale. CloudFormation ne peut pas résoudre ces références, ce qui entraîne une défaillance des ressources.
# Utilisez AWS Secrets Manager les secrets dans les GitHub emplois
Pour utiliser un secret dans une GitHub tâche, vous pouvez utiliser une GitHub action pour récupérer des secrets AWS Secrets Manager et les ajouter en tant que [variables d'environnement](https://docs.github.com/en/actions/learn-github-actions/environment-variables) masquées dans votre GitHub flux de travail. Pour plus d'informations sur GitHub les actions, voir [Comprendre GitHub les actions](https://docs.github.com/en/actions/learn-github-actions/understanding-github-actions) dans la *GitHub documentation*.
Lorsque vous ajoutez un secret à votre GitHub environnement, il est accessible à toutes les autres étapes de votre GitHub travail. Suivez les instructions de la section Renforcement [de la sécurité pour les GitHub actions](https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions) afin d'éviter que les secrets de votre environnement ne soient utilisés à mauvais escient.
Vous pouvez définir la chaîne complète de la valeur du secret comme valeur de variable d'environnement. Sinon, si la chaîne est au format JSON, vous pouvez analyser le fichier JSON pour définir des variables d'environnement individuelles pour chaque paire clé-valeur JSON. Si la valeur du secret est binaire, l'action la convertit en chaîne.
Pour afficher les variables d'environnement créées à partir de vos secrets, activez la journalisation du débogage. Pour plus d'informations, voir [Activation de la journalisation du débogage](https://docs.github.com/en/actions/monitoring-and-troubleshooting-workflows/enabling-debug-logging) dans la *GitHub documentation*.
Pour utiliser les variables d'environnement créées à partir de vos secrets, consultez la section [Variables d'environnement](https://docs.github.com/en/actions/learn-github-actions/environment-variables) dans la *GitHub documentation*.
## Conditions préalables
Pour utiliser cette action, vous devez d'abord configurer les AWS informations d'identification et les définir Région AWS dans votre GitHub environnement à l'aide de l'`configure-aws-credentials`étape. Suivez les instructions de la section [Configurer l'action des AWS informations d'identification pour que GitHub les actions](https://github.com/aws-actions/configure-aws-credentials) **assument le rôle directement à l'aide du fournisseur GitHub OIDC**. Cela vous permet d'utiliser des informations d'identification de courte durée et d'éviter de stocker des clés d'accès supplémentaires en dehors de Secrets Manager.
Le rôle IAM assumé par l'action doit avoir les autorisations suivantes :
+ `GetSecretValue` sur les secrets que vous souhaitez récupérer ;
+ `ListSecrets` sur tous les secrets ;
+ (Facultatif) `Decrypt` KMS key si les secrets sont chiffrés avec un clé gérée par le client.
Pour de plus amples informations, veuillez consulter [Authentification et contrôle d'accès pour AWS Secrets Manager](auth-and-access.md).
## Usage
Pour utiliser l'action, ajoutez une étape à votre flux qui utilise la syntaxe suivante.
```
- 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, noms et préfixes de nom du secret.
Pour définir le nom de la variable d'environnement, saisissez-le avant l'ID du secret, suivi d'une virgule. Par exemple, `ENV_VAR_1, secretId` crée une variable d'environnement nommée **ENV\$1VAR\$11** à partir du `secretId` du secret. Le nom de la variable d'environnement peut contenir des lettres majuscules, des chiffres et des traits de soulignement.
Pour utiliser un préfixe, saisissez au moins trois caractères suivis d'un astérisque. Par exemple, `dev*` correspond à tous les secrets dont le nom commence par **dev**. Le nombre maximum de secrets correspondants pouvant être récupérés est de 100. Si vous définissez le nom de la variable et que le préfixe correspond à plusieurs secrets, l'action échoue.
`name-transformation`
Par défaut, l'étape crée chaque nom de variable d'environnement à partir du nom du secret, transformé de façon à inclure uniquement des lettres majuscules, des chiffres et des traits de soulignement, et à ne pas commencer par un chiffre. Pour les lettres du nom, vous pouvez configurer l'étape pour utiliser des lettres minuscules avec `lowercase` ou pour ne pas changer les majuscules des lettres avec. `none` La valeur par défaut est `uppercase`.
`parse-json-secrets`
(Facultatif) Par défaut, l'action définit la valeur de la variable d'environnement sur la chaîne JSON entière de la valeur du secret. Définissez sur `parse-json-secrets` pour `true` créer des variables d'environnement pour chaque paire clé-valeur dans le JSON.
Notez que si le fichier JSON utilise des clés sensibles à la casse, par exemple « nom » et « Nom », l'action rencontrera des conflits de noms dupliqués. Dans ce cas, définissez `parse-json-secrets` sur `false` et analysez la valeur du secret JSON séparément.
## Désignation des variables d'environnement
Les variables d'environnement créées par l'action portent le même nom que les secrets dont elles proviennent. Les variables d'environnement ont des exigences de dénomination plus strictes que les secrets. L'action transforme donc les noms des secrets pour répondre à ces exigences. Par exemple, l'action transforme les lettres minuscules en lettres majuscules. Si vous analysez le JSON du secret, le nom de la variable d'environnement inclut à la fois le nom du secret et le nom de la clé JSON, par exemple`MYSECRET_KEYNAME`. Vous pouvez configurer l'action pour ne pas transformer les lettres minuscules.
Si deux variables d'environnement finissent par porter le même nom, l'action échoue. Dans ce cas, vous devez spécifier les noms que vous souhaitez utiliser pour les variables d'environnement sous forme d'*alias*.
Exemples de situations dans lesquelles les noms peuvent entrer en conflit :
+ Un secret nommé « MySecret » et un secret nommé « mysecret » deviendraient tous deux des variables d'environnement nommées « MYSECRET ».
+ Un secret nommé « Secret\$1keyname » et un secret analysé en JSON nommé « Secret » avec une clé nommée « keyname » deviendraient tous deux des variables d'environnement nommées « SECRET\$1KEYNAME ».
Vous pouvez définir le nom de la variable d'environnement en spécifiant un *alias*, comme illustré dans l'exemple suivant, qui crée une variable nommée`ENV_VAR_NAME`.
```
secret-ids: |
ENV_VAR_NAME, secretId2
```
**Alias vides**
+ Si vous définissez `parse-json-secrets: true` et entrez un alias vide, suivi d'une virgule puis de l'ID secret, l'action nomme la variable d'environnement de la même manière que les clés JSON analysées. Les noms des variables n'incluent pas le nom du secret.
Si le secret ne contient pas de code JSON valide, l'action crée une variable d'environnement et lui donne le même nom que le secret.
+ Si vous définissez `parse-json-secrets: false` et entrez un alias vide, suivi d'une virgule et de l'ID secret, l'action nomme les variables d'environnement comme si vous n'aviez pas spécifié d'alias.
L'exemple suivant montre un alias vide.
```
,secret2
```
## Exemples
**Example 1 Obtenir des secrets par leur nom et par leur ARN**
L'exemple suivant crée des variables d'environnement pour les secrets identifiés par leur nom et par leur 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
```
Variables d'environnement créées :
```
EXAMPLESECRETNAME: secretValue1
TEST1: secretValue2
_0_TEST_SECRET: secretValue3
_PROD_EXAMPLE_SECRET: secretValue4
SECRET_ALIAS_1: secretValue5
SECRET_ALIAS_2: secretValue6
SECRET2: secretValue7
```
**Example 2 Obtenir tous les secrets qui commencent par un préfixe**
L'exemple suivant crée des variables d'environnement pour tous les secrets dont le nom commence par*beta*.
```
- name: Get Secret Names by Prefix
uses: 2
with:
secret-ids: |
beta* # Retrieves all secrets that start with 'beta'
```
Variables d'environnement créées :
```
BETASECRETNAME: secretValue1
BETATEST: secretValue2
BETA_NEWSECRET: secretValue3
```
**Example 3 Analyser le fichier JSON dans le secret**
L'exemple suivant crée des variables d'environnement en analysant le fichier JSON dans le secret.
```
- 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
```
Le secret `test/secret` a la valeur de secret suivante.
```
{
"api_user": "user",
"api_key": "key",
"config": {
"active": "true"
}
}
```
Le secret `secret2` a la valeur de secret suivante.
```
{
"myusername": "alejandro_rosalez",
"mypassword": "EXAMPLE_PASSWORD"
}
```
Variables d'environnement créées :
```
TEST_SECRET_API_USER: "user"
TEST_SECRET_API_KEY: "key"
TEST_SECRET_CONFIG_ACTIVE: "true"
MYUSERNAME: "alejandro_rosalez"
MYPASSWORD: "EXAMPLE_PASSWORD"
```
**Example 4 Utilisez des lettres minuscules pour les noms des variables d'environnement**
L'exemple suivant crée une variable d'environnement dont le nom est en minuscules.
```
- name: Get secrets
uses: aws-actions/aws-secretsmanager-get-secrets@v2
with:
secret-ids: exampleSecretName
name-transformation: lowercase
```
Variable d'environnement créée :
```
examplesecretname: secretValue
```
# Utiliser AWS Secrets Manager dans GitLab
AWS Secrets Manager s'intègre à GitLab. Vous pouvez utiliser les secrets de Secrets Manager pour protéger vos GitLab informations d'identification afin qu'elles ne soient plus codées en GitLab dur. [GitLab Runner](https://docs.gitlab.com/runner/) récupère plutôt ces secrets auprès de Secrets Manager lorsque votre application exécute une tâche dans les pipelines GitLab CI/CD.
Pour utiliser cette intégration, vous allez créer un [fournisseur d'identité OpenID Connect (OIDC) dans IAM Gestion des identités et des accès AWS et un rôle IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html). Cela permet à GitLab Runner d'accéder au secret de votre Gestionnaire de Secrets Manager. [Pour plus d'informations sur le GitLab CI/CD et l'OIDC, consultez la documentation. GitLab](https://docs.gitlab.com/ci/cloud_services/aws/)
## Considérations
Si vous utilisez une GitLab instance non publique, vous ne pouvez pas utiliser cette intégration de Secrets Manager. Consultez plutôt la [GitLab documentation pour les instances non publiques](https://docs.gitlab.com/ci/cloud_services/aws/#configure-a-non-public-gitlab-instance).
## Conditions préalables
Pour intégrer Secrets Manager à GitLab, vous devez remplir les conditions préalables suivantes :
1.
**Créez un AWS Secrets Manager secret**
Vous aurez besoin d'un secret de Secrets Manager qui sera récupéré lors de votre GitLab travail et qui vous évitera d'avoir à coder en dur ces informations d'identification. Vous aurez besoin de l'ID secret de Secrets Manager [pour configurer votre GitLab pipeline](#configure-gitlab-pipeline). Pour plus d’informations, consultez [Créez un AWS Secrets Manager secret](create_secret.md).
1.
**Définissez GitLab votre fournisseur OIDC dans la console IAM.**
Au cours de cette étape, vous allez créer GitLab votre fournisseur OIDC dans la console IAM. [Pour plus d'informations, consultez la section [Création d'un fournisseur d'identité OpenID Connect (OIDC)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_providers_create_oidc.html) et documentation. GitLab](https://docs.gitlab.com/ci/cloud_services/aws/)
Lorsque vous créez le fournisseur OIDC dans la console IAM, utilisez les configurations suivantes :
1. Définissez le `provider URL` sur votre GitLab instance. Par exemple, **gitlab.example.com**.
1. Réglez le `audience` ou `aud` sur**sts.amazonaws.com**.
1.
**Création d'un rôle et d'une politique IAM**
Vous devez créer un rôle et une politique IAM. Ce rôle est assumé par GitLab with [AWS Security Token Service (STS)](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html). Voir [Créer un rôle à l'aide de politiques de confiance personnalisées](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-custom.html) pour plus d'informations.
1. Dans la console IAM, utilisez les paramètres suivants lors de la création du rôle IAM :
+ Définissez `Trusted entity type` sur **Web identity**.
+ Définissez `Group` sur **your GitLab group**.
+ Définissez `Identity provider` la même URL de fournisseur (l'[GitLab instance](#step2-oidc-provider)) que celle que vous avez utilisée à l'étape 2.
+ Définissez `Audience` le même [public](#step2-oidc-audience) que celui que vous avez utilisé à l'étape 2.
1. Voici un exemple de politique de confiance qui permet d' GitLab assumer des rôles. Votre politique de confiance doit répertorier votre Compte AWS GitLab URL et le [chemin du projet](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. Vous devrez également créer une politique IAM pour autoriser l' GitLab accès à AWS Secrets Manager. Vous pouvez ajouter cette politique à votre politique de confiance. Pour plus d'informations, consultez la section [Création de politiques 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"
}
]
}
```
## Intégration AWS Secrets Manager avec GitLab
Une fois les prérequis remplis, vous pouvez configurer l'utilisation GitLab de Secrets Manager afin de protéger vos informations d'identification.
### Configurer le GitLab pipeline pour utiliser Secrets Manager
Vous devez mettre à jour votre [fichier de configuration GitLab CI/CD](https://docs.gitlab.com/ci/yaml/yaml_optimization/) avec les informations suivantes :
+ L'audience du jeton définie sur STS.
+ L'identifiant secret du Secrets Manager.
+ Le rôle IAM que vous souhaitez que GitLab Runner assume lors de l'exécution de tâches dans le GitLab pipeline.
+ L' Région AWS endroit où le secret est conservé.
GitLab récupère le secret depuis Secrets Manager et stocke la valeur dans un fichier temporaire. Le chemin d'accès à ce fichier est stocké dans une CI/CD variable, similaire aux variables [CI/CD de type de fichier](https://docs.gitlab.com/ci/variables/#use-file-type-cicd-variables).
Voici un extrait du fichier YAML pour un fichier de configuration GitLab CI/CD :
```
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"
```
Pour plus d'informations, consultez la [documentation sur l'intégration de GitLab Secrets Manager](https://docs.gitlab.com/ci/secrets/aws_secrets_manager/).
Vous pouvez éventuellement tester votre configuration OIDC dans GitLab. Consultez [GitLab la documentation relative au test de la configuration OIDC](https://docs.gitlab.com/ci/cloud_services/aws/#test-the-oidc-configuration) pour plus d'informations.
## Résolution des problèmes
Les informations suivantes peuvent vous aider à résoudre les problèmes courants que vous pouvez rencontrer lors de l'intégration de Secrets Manager à GitLab.
### GitLab Problèmes liés au pipeline
Si vous rencontrez des problèmes de GitLab pipeline, assurez-vous de ce qui suit :
+ Votre fichier YAML est correctement formaté. Pour plus d’informations, consultez la [documentation GitLab](https://docs.gitlab.com/ee/ci/yaml/).
+ Votre GitLab pipeline assume le bon rôle, dispose des autorisations appropriées et a accès au AWS Secrets Manager secret approprié.
### Ressources supplémentaires
Les ressources suivantes peuvent vous aider à résoudre les problèmes liés à GitLab et AWS Secrets Manager :
+ [GitLab Résolution des problèmes OIDC](https://docs.gitlab.com/ci/cloud_services/aws/#troubleshooting)
+ [Débogage du pipeline GitLab CI/CD](https://docs.gitlab.com/ee/ci/troubleshooting.html)
+ [Résolution des problèmes](ascp-eks-installation.md#troubleshooting)
# Utilisez AWS Secrets Manager des secrets dans AWS IoT Greengrass
AWS IoT Greengrass est un logiciel qui étend les fonctionnalités du cloud aux appareils locaux. Il permet aux appareils de collecter et d'analyser les données plus près de la source des informations, de réagir de manière autonome aux événements locaux et de communiquer en toute sécurité sur les réseaux locaux.
AWS IoT Greengrass vous permet de vous authentifier auprès de services et d'applications à partir d' AWS IoT Greengrass appareils sans avoir à coder en dur des mots de passe, des jetons ou d'autres secrets. Vous pouvez l'utiliser AWS Secrets Manager pour stocker et gérer vos secrets en toute sécurité dans le cloud. AWS IoT Greengrass étend Secrets Manager aux appareils AWS IoT Greengrass principaux, afin que vos connecteurs et fonctions Lambda puissent utiliser des secrets locaux pour interagir avec les services et les applications.
Pour intégrer un secret dans un AWS IoT Greengrass groupe, vous devez créer une ressource de groupe qui fait référence au secret du Secrets Manager. Cette ressource secrète fait référence au secret de Cloud en utilisant l'ARN associé. Pour savoir comment créer, gérer et utiliser des ressources secrètes, consultez la section [Travailler avec des ressources secrètes](https://docs.aws.amazon.com/greengrass/latest/developerguide/secrets-using.html) dans le guide du AWS IoT développeur.
Pour déployer des secrets sur le AWS IoT Greengrass cœur, voir [Déployer des secrets sur le AWS IoT Greengrass cœur.](https://docs.aws.amazon.com/greengrass/latest/developerguide/secrets.html)
# Utiliser des AWS Secrets Manager secrets dans Parameter Store
AWS Systems Manager Parameter Store fournit un stockage hiérarchique sécurisé pour la gestion des données de configuration et la gestion des secrets. Vous pouvez stocker des données telles que des mots de passe, des chaînes de base de données et des codes de licence en tant que valeurs de paramètres. Toutefois, le Parameter Store ne fournit pas de service de rotation automatique pour les secrets stockés. Au lieu de cela, le Parameter Store vous permet de stocker votre secret dans Secrets Manager et de référencer le secret sous forme de paramètre.
Lorsque vous configurez le Parameter Store avec Secrets Manager, le Parameter Store `secret-id` requiert une barre oblique (/) avant la chaîne de nom.
Pour plus d'informations, consultez la section [Référencement de AWS Secrets Manager secrets à partir des paramètres du magasin de paramètres](https://docs.aws.amazon.com/systems-manager/latest/userguide/integration-ps-secretsmanager.html) dans le *guide de AWS Systems Manager l'utilisateur*.