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 une valeur secrète de Secrets Manager en utilisant Python avec mise en cache côté client
<a name="retrieving-secrets_cache-python"></a>

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
<a name="retrieving-secrets_cache-ref-secretcache"></a>

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
<a name="retrieving-secrets_cache-ref-secretcache_get_secret_string"></a>

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
<a name="retrieving-secrets_cache-ref-secretcache_get_secret_binary"></a>

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
<a name="retrieving-secrets_cache-ref-secretcacheconfig"></a>

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
<a name="retrieving-secrets_cache-ref-secretcachehook"></a>

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
<a name="retrieving-secrets_cache-ref-secretcachehook_put"></a>

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
<a name="retrieving-secrets_cache-ref-secretcachehook_get"></a>

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
<a name="retrieving-secrets_cache-decor-string"></a>

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
<a name="retrieving-secrets_cache-decor-keyword"></a>

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')
```