As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Obtenha um segredo do Secrets Manager usando Python com armazenamento em cache no lado do cliente
<a name="retrieving-secrets_cache-python"></a>

Ao recuperar um segredo, é possível usar o componente de cache baseado em Python do Secrets Manager para armazená-lo em cache para uso futuro. Recuperar um segredo armazenado em cache é mais rápido do que recuperá-lo do Secrets Manager. Como há um custo para ligar para o Secrets Manager APIs, usar um cache pode reduzir seus custos. Para ver todas as formas pelas quais é possível recuperar segredos, consulte [Obter segredos](retrieving-secrets.md).

A política de caches é a do menos usado recentemente (LRU). Assim, quando o cache precisar descartar um segredo, escolherá o segredo menos usado recentemente. Por padrão, o cache atualiza segredos a cada hora. É possível configurar [com qual frequência o segredo será atualizado](retrieving-secrets_cache-ref-secretcacheconfig.md) no cache e será possível [se conectar à recuperação do segredo](retrieving-secrets_cache-ref-secretcachehook.md) para adicionar mais funcionalidades.

O cache não obriga a coleta de resíduos depois que as referências de cache são liberadas. A implementação do cache não inclui a invalidação do cache. A implementação do cache é centrada em torno do próprio cache, portanto, não é reforçada ou tem ênfase em segurança. Se você necessitar de mais segurança, como criptografia de itens no cache, use as interfaces e os métodos abstratos fornecidos.

Para usar o componente, é necessário ter o seguinte: 
+ Python 3.6 ou superior.
+ botocore 1.12 ou superior. Consulte [AWS SDK para Python](https://aws.amazon.com/sdk-for-python/) e [Botocore](https://botocore.amazonaws.com/v1/documentation/api/latest/index.html). 
+ setuptools\$1scm 3.2 ou superior. Veja [https://pypi. org/project/setuptools-fraude/](https://pypi.org/project/setuptools-scm/).

Para baixar o código-fonte, consulte o componente cliente de [cache baseado em Python do Secrets Manager](https://github.com/aws/aws-secretsmanager-caching-python ) em. GitHub

Para instalar o componente, use o seguinte comando.

```
$ pip install aws-secretsmanager-caching
```

**Permissões obrigatórias: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`

Para obter mais informações, consulte [Referência de permissões](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 Recuperar segredos**  
O exemplo a seguir mostra como obter o valor secreto de um segredo chamado*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>

Um cache na memória para segredos recuperados no Secrets Manager. Você usa [get\$1secret\$1string](#retrieving-secrets_cache-ref-secretcache_get_secret_string) ou [get\$1secret\$1binary](#retrieving-secrets_cache-ref-secretcache_get_secret_binary) para recuperar um segredo do cache. É possível definir as configurações de cache executando-as em um objeto [SecretCacheConfig](retrieving-secrets_cache-ref-secretcacheconfig.md) no construtor. 

Para obter mais informações, incluindo exemplos, consulte [Obtenha um segredo do Secrets Manager usando Python com armazenamento em cache no lado do 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
<a name="retrieving-secrets_cache-ref-secretcache_get_secret_string"></a>

Recupera o valor da string do segredo.

Sintaxe da solicitação  

```
response = cache.get_secret_string(
    secret_id='string',
    version_stage='string' )
```

Parâmetros  
+ `secret_id` (*string*): [obrigatório] o nome ou o ARN do segredo.
+ `version_stage` (*string*): a versão dos segredos que você deseja recuperar. Para obter mais informações, consulte [versões de segredos](whats-in-a-secret.md). O padrão é 'AWSCURRENT'. 

Tipo de retorno  
string

## get\$1secret\$1binary
<a name="retrieving-secrets_cache-ref-secretcache_get_secret_binary"></a>

Recupera o valor do binário do segredo.

Sintaxe da solicitação  

```
response = cache.get_secret_binary(
    secret_id='string',
    version_stage='string'
)
```

Parâmetros  
+ `secret_id` (*string*): [obrigatório] o nome ou o ARN do segredo.
+ `version_stage` (*string*): a versão dos segredos que você deseja recuperar. Para obter mais informações, consulte [versões de segredos](whats-in-a-secret.md). O padrão é 'AWSCURRENT'. 

Tipo de retorno  
String [codificada em base64](https://tools.ietf.org/html/rfc4648#section-4)

# SecretCacheConfig
<a name="retrieving-secrets_cache-ref-secretcacheconfig"></a>

Opções de configuração de cache para um [SecretCache](retrieving-secrets_cache-ref-secretcache.md), como o tamanho máximo do cache e a vida útil (TTL) para segredos armazenados em cache.Parâmetros

`max_cache_size` (*int*)  
O tamanho máximo do cache. O padrão é de `1024` segredos. 

`exception_retry_delay_base` (*int*)  
O número de segundos a aguardar ao encontrar uma exceção e antes de repetir a solicitação. O padrão é `1`.

`exception_retry_growth_factor` (*int*)pur  
O fator de crescimento a ser usado para calcular o tempo de espera entre novas tentativas de solicitações com falha. O padrão é `2`. 

`exception_retry_delay_max` (*int*)  
O tempo máximo em segundos a aguardar entre solicitações com falha. O padrão é `3600`.

`default_version_stage` (*str*)  
A versão de segredos que você deseja armazenar em cache. Para obter mais informações, consulte [Secret versions](whats-in-a-secret.md#term_version) (Versões de segredos). O padrão é `'AWSCURRENT'`.

`secret_refresh_interval` (*int*)  
O número de segundos a aguardar entre a atualização de informações de segredos armazenados em cache. O padrão é `3600`.

`secret_cache_hook` (*SecretCacheHook*)  
Uma implementação da classe abstrata de `SecretCacheHook`. O valor padrão é `None`.

# SecretCacheHook
<a name="retrieving-secrets_cache-ref-secretcachehook"></a>

Uma interface para conectar a um [SecretCache](retrieving-secrets_cache-ref-secretcache.md) para executar ações nos segredos sendo armazenados no cache. 

**Topics**
+ [put](#retrieving-secrets_cache-ref-secretcachehook_put)
+ [obter](#retrieving-secrets_cache-ref-secretcachehook_get)

## put
<a name="retrieving-secrets_cache-ref-secretcachehook_put"></a>

Prepara o objeto para armazenamento no cache.

Sintaxe da solicitação  

```
response = hook.put(
    obj='secret_object'
)
```

Parâmetros  
+ `obj` (*objeto*): [obrigatório] o segredo ou objeto que contém o segredo.

Tipo de retorno  
objeto

## obter
<a name="retrieving-secrets_cache-ref-secretcachehook_get"></a>

Deriva o objeto do objeto armazenado em cache.

Sintaxe da solicitação  

```
response = hook.get(
    obj='secret_object'
)
```

Parâmetros  
+ `obj` (*objeto*): [obrigatório] o segredo ou objeto que contém o segredo.

Tipo de retorno  
objeto

# @InjectSecretString
<a name="retrieving-secrets_cache-decor-string"></a>

Este decorador espera uma string de ID de segredo e [SecretCache](retrieving-secrets_cache-ref-secretcache.md) como o primeiro e o segundo argumentos. O decorador retorna o valor da string do segredo. O segredo deve conter uma string. 

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

Este decorador espera uma string de ID de segredo e [SecretCache](retrieving-secrets_cache-ref-secretcache.md) como o primeiro e o segundo argumentos. Os argumentos restantes mapeiam parâmetros da função empacotada para chaves JSON no segredo. O segredo deve conter uma string na estrutura JSON. 

Para um segredo que contém esse JSON:

```
{
  "username": "saanvi",
  "password": "EXAMPLE-PASSWORD"
}
```

O exemplo a seguir mostra como extrair os valores JSON para `username` e `password` do segredo.

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