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á.

# Obter um valor de segredo do Secrets Manager usando Rust
<a name="retrieving-secrets-rust"></a>

Nos aplicativos, você pode recuperar seus segredos ligando `GetSecretValue` ou `BatchGetSecretValue` em qualquer um dos AWS SDKs. No entanto, recomendamos armazenar em cache seus valores de segredos usando o cache do lado do cliente. Armazenar segredos em cache melhora a velocidade e reduz os seus custos.

**Topics**
+ [Obtenha um segredo do Secrets Manager usando Rust com armazenamento em cache no lado do cliente](retrieving-secrets_cache-rust.md)
+ [Obtenha um valor secreto do Secrets Manager usando o Rust SDK AWS](retrieving-secrets-rust-sdk.md)

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

Ao recuperar um segredo, é possível usar o componente de cache baseado em Rust 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 cache é a do primeiro a entrar, primeiro a sair (FIFO). Assim, quando o cache precisar descartar um segredo, usará o segredo mais antigo. Por padrão, o cache atualiza segredos a cada hora. É possível configurar as seguintes opções:
+ `max_size`: o número máximo de segredos em cache a serem mantidos antes da remoção dos segredos que não foram acessados recentemente.
+ `ttl`: a duração pela qual um item armazenado em cache é considerado válido antes de exigir uma atualização do estado do segredo.

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ê precisar de segurança adicional, como criptografar itens no cache, use as características fornecidas para modificar o cache.

Para usar o componente, é necessário ter um ambiente de desenvolvimento do Rust 2021 com `tokio`. Para obter mais informações, consulte [Conceitos básicos](https://www.rust-lang.org/learn/get-started) no site Rust Programming Language.

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

Para instalar o componente de armazenamento em cache, use o seguinte comando.

```
cargo add 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).

**Example Recuperar segredos**  
O exemplo a seguir mostra como obter o valor secreto de um segredo chamado*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 Instanciação do cache com uma configuração personalizada e um cliente personalizado**  
O exemplo a seguir mostra como configurar o cache e, em seguida, obter o valor secreto de um segredo chamado*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
```
```

# Obtenha um valor secreto do Secrets Manager usando o Rust SDK AWS
<a name="retrieving-secrets-rust-sdk"></a>

Nos aplicativos, você pode recuperar seus segredos ligando `GetSecretValue` ou `BatchGetSecretValue` em qualquer um dos AWS SDKs. No entanto, recomendamos armazenar em cache seus valores de segredos usando o cache do lado do cliente. Armazenar segredos em cache melhora a velocidade e reduz os seus custos.

Para aplicativos Rust, use o [componente de cache baseado em Rust do Secrets Manager](retrieving-secrets_cache-rust.md) ou chame o [SDK](https://docs.rs/releases/search?query=aws-sdk-secretsmanager) diretamente com ou. GetSecretValue BatchGetSecretValue

O exemplo de código a seguir mostra como obter um valor de segredo do Secrets Manager.

**Permissões obrigatórias: **`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(())
}
```