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 Rust
<a name="retrieving-secrets-rust"></a>

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 Rust avec la mise en cache côté client](retrieving-secrets_cache-rust.md)
+ [Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK Rust](retrieving-secrets-rust-sdk.md)

# Obtenez une valeur secrète de Secrets Manager en utilisant Rust avec la mise en cache côté client
<a name="retrieving-secrets_cache-rust"></a>

Lorsque vous récupérez un secret, vous pouvez utiliser le composant de mise en cache basé sur Rust de Secrets Manager pour le mettre en cache pour 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 du cache est le premier entré, premier sorti (FIFO). Ainsi, lorsque le cache doit supprimer un secret, il supprime le secret le plus ancien. Par défaut, le cache actualise les secrets toutes les heures. Vous pouvez configurer les éléments suivants :
+ `max_size`— Le nombre maximum de secrets mis en cache à conserver avant d'expulser des secrets qui n'ont pas été consultés récemment.
+ `ttl`— La durée pendant laquelle un élément mis en cache est considéré comme valide avant de nécessiter une actualisation de l'état secret.

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 des éléments du cache, utilisez les caractéristiques fournies pour modifier le cache.

Pour utiliser le composant, vous devez disposer d'un environnement de développement Rust 2021 avec`tokio`. Pour plus d'informations, consultez [Getting started](https://www.rust-lang.org/learn/get-started) sur le site Web du langage de programmation Rust.

Pour télécharger le code source, voir le composant [client de mise en cache basé sur Rust de Secrets Manager](https://github.com/aws/aws-secretsmanager-agent/tree/main/aws_secretsmanager_caching) sur. GitHub

Pour installer le composant de mise en cache, utilisez la commande suivante.

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

**Example Récupérer un secret**  
L'exemple suivant montre comment obtenir la valeur secrète d'un secret nommé*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 Instanciation du cache avec une configuration personnalisée et un client personnalisé**  
L'exemple suivant montre comment configurer le cache puis obtenir la valeur secrète d'un secret nommé*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
```
```

# Obtenez une valeur secrète de Secrets Manager à l'aide du AWS SDK Rust
<a name="retrieving-secrets-rust-sdk"></a>

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 Rust, utilisez le [composant de mise en cache basé sur Rust de Secrets Manager](retrieving-secrets_cache-rust.md) ou appelez le [SDK](https://docs.rs/releases/search?query=aws-sdk-secretsmanager) directement avec ou. GetSecretValue BatchGetSecretValue

L'exemple de code suivant montre comment obtenir une valeur de Secrets Secrets Manager.

**Autorisations requises : **`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(())
}
```