Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Obtener un valor secreto de Secrets Manager mediante Python con almacenamiento en caché del cliente
Cuando recupera un secreto, puede utilizar el componente de almacenamiento en caché basado en Python de Secrets Manager para utilizarlo más adelante. Recuperar un secreto almacenado en la memoria caché es más rápido que recuperarlo desde Secrets Manager. Como llamar a Secrets Manager conlleva un coste APIs, el uso de una memoria caché puede reducir los costes. Para conocer todas las formas en las que puede recuperar secretos, consulte [Obtener secretos](retrieving-secrets.md).
La política de la caché consiste en el algoritmo menos usado recientemente (LRU), por lo que, cada vez que la caché tiene que descartar un secreto, lo hace con el de uso menos reciente. De forma predeterminada, la caché actualiza secretos cada hora. Puede configurar la [frecuencia con la que se actualiza el secreto](retrieving-secrets_cache-ref-secretcacheconfig.md) en la memoria caché, y también [conectarse a la recuperación del secreto](retrieving-secrets_cache-ref-secretcachehook.md) para agregar más funcionalidad.
La memoria caché no fuerza la recopilación de elementos no utilizados una vez liberadas las referencias de la memoria caché. La implementación de la memoria caché no incluye la invalidación de la memoria caché. La implementación de la memoria caché se centra en la memoria caché en sí misma y no está reforzada ni centrada en la seguridad. Si necesita más seguridad, como cifrar elementos en la memoria caché, utilice las interfaces y los métodos abstractos que se proporcionan.
Para utilizar el componente, debe disponer de lo siguiente:
+ Python 3.6 o posterior
+ botocore 1.12 o superior. Consulte [AWS SDK para Python](https://aws.amazon.com/sdk-for-python/) y [Botocore](https://botocore.amazonaws.com/v1/documentation/api/latest/index.html).
+ setuptools\$1scm 3.2 o superior. Consulte [https://pypi. org/project/setuptools-scm/](https://pypi.org/project/setuptools-scm/).
Para descargar el código fuente, consulte el componente de cliente de almacenamiento [en caché basado en Python de Secrets Manager](https://github.com/aws/aws-secretsmanager-caching-python ) en. GitHub
Para instalar el componente, utilice el siguiente comando.
```
$ pip install aws-secretsmanager-caching
```
**Permisos necesarios: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`
Para obtener más información, consulte [Referencia de permisos](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 Recuperación de un secreto**
El siguiente ejemplo muestra cómo obtener el valor secreto de un secreto denominado. *mysecret*
```
import botocore
import botocore.session
from aws_secretsmanager_caching import SecretCache, SecretCacheConfig
client = botocore.session.get_session().create_client('secretsmanager')
cache_config = SecretCacheConfig()
cache = SecretCache( config = cache_config, client = client)
secret = cache.get_secret_string('mysecret')
```
# SecretCache
Una caché en memoria para los secretos recuperados de Secrets Manager. Utilice [get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string) o [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary) para recuperar un secreto de la caché. Puede configurar los ajustes de la memoria caché si transfiere un objeto [SecretCacheConfig](retrieving-secrets_cache-ref-secretcacheconfig.md) en el constructor.
Para obtener más información, incluidos algunos ejemplos, consulte [Obtener un valor secreto de Secrets Manager mediante Python con almacenamiento en caché del cliente](retrieving-secrets_cache-python.md).
```
cache = SecretCache(
config = SecretCacheConfig,
client = [client](https://botocore.amazonaws.com/v1/documentation/api/latest/reference/services/secretsmanager.html)
)
```
**Topics**
+ [get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string)
+ [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary)
## get\$1secret\$1string
Recupera el valor de la cadena del secreto.
Sintaxis de la solicitud
```
response = cache.get_secret_string(
secret_id='string',
version_stage='string' )
```
Parameters
+ `secret_id` (*cadena*): [obligatorio] el nombre o ARN del secreto.
+ `version_stage` (*cadena*): la versión de los secretos que desea recuperar. Para obtener más información, consulte [versiones del secreto](whats-in-a-secret.md). El valor predeterminado es 'AWSCURRENT'.
Tipo de devolución
cadena
## get\$1secret\$1binary
Recupera el valor binario del secreto.
Sintaxis de la solicitud
```
response = cache.get_secret_binary(
secret_id='string',
version_stage='string'
)
```
Parameters
+ `secret_id` (*cadena*): [obligatorio] el nombre o ARN del secreto.
+ `version_stage` (*cadena*): la versión de los secretos que desea recuperar. Para obtener más información, consulte [versiones del secreto](whats-in-a-secret.md). El valor predeterminado es 'AWSCURRENT'.
Tipo de devolución
Cadena [codificada en base64](https://tools.ietf.org/html/rfc4648#section-4)
# SecretCacheConfig
Opciones de configuración de la caché para un [SecretCache](retrieving-secrets_cache-ref-secretcache.md), como el tamaño máximo de esta y el periodo de vida (TTL) de los secretos almacenados en ella.Parameters
`max_cache_size` (*int*)
El tamaño máximo de la caché. El valor predeterminado es de `1024` secretos.
`exception_retry_delay_base` (*int*)
La cantidad de segundos que se debe esperar luego de que se haya producido una excepción antes de reintentar la solicitud. El valor predeterminado es `1`.
`exception_retry_growth_factor` (*int*)pur
El factor de crecimiento que se debe utilizar para calcular el tiempo de espera entre los reintentos de las solicitudes en las que se haya producido un error. El valor predeterminado es `2`.
`exception_retry_delay_max` (*int*)
La cantidad máxima de tiempo en segundos que se debe esperar entre las solicitudes en las que se haya producido un error. El valor predeterminado es `3600`.
`default_version_stage` (*str*)
La versión de los secretos que desea almacenar en caché. Para obtener más información, consulte [Versiones del secreto](whats-in-a-secret.md#term_version). El valor predeterminado es `'AWSCURRENT'`.
`secret_refresh_interval` (*int*)
La cantidad de segundos que se debe esperar entre la actualización de la información del secreto en la caché. El valor predeterminado es `3600`.
`secret_cache_hook` (*SecretCacheHook*)
Implementación de la clase abstracta `SecretCacheHook`. El valor predeterminado es `None`.
# SecretCacheHook
Una interfaz para conectarse a una [SecretCache](retrieving-secrets_cache-ref-secretcache.md) y realizar acciones sobre los secretos almacenados en ella.
**Topics**
+ [put](#retrieving-secrets_cache-ref-secretcachehook_put)
+ [introducción](#retrieving-secrets_cache-ref-secretcachehook_get)
## put
Prepara el objeto para almacenarlo en la caché.
Sintaxis de la solicitud
```
response = hook.put(
obj='secret_object'
)
```
Parameters
+ `obj` (*objeto*): [obligatorio] el secreto o el objeto que contiene el secreto.
Tipo de devolución
objeto
## introducción
Deriva el objeto a partir del objeto almacenado en caché.
Sintaxis de la solicitud
```
response = hook.get(
obj='secret_object'
)
```
Parameters
+ `obj` (*objeto*): [obligatorio] el secreto o el objeto que contiene el secreto.
Tipo de devolución
objeto
# @InjectSecretString
Este elemento Decorator espera una cadena de ID del secreto y una [SecretCache](retrieving-secrets_cache-ref-secretcache.md) como primer y segundo argumento. El elemento Decorator devuelve el valor de la cadena del secreto. El nombre del secreto debe contener una cadena.
```
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
Este elemento Decorator espera una cadena de ID del secreto y una [SecretCache](retrieving-secrets_cache-ref-secretcache.md) como primer y segundo argumento. Los argumentos restantes asignan parámetros de la función integrada a las claves JSON del secreto. El secreto debe contener una cadena en la estructura JSON.
Para un secreto que contenga este JSON:
```
{
"username": "saanvi",
"password": "EXAMPLE-PASSWORD"
}
```
En el siguiente ejemplo se muestra cómo extraer los valores JSON de `username` y `password` del secreto.
```
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')
```