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.
# 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
```