Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Ottieni un valore segreto di Secrets Manager usando Rust con la memorizzazione nella cache lato client
<a name="retrieving-secrets_cache-rust"></a>

Quando recuperi un segreto, puoi utilizzare il componente di caching basato su Secrets Manager Rust per memorizzarlo nella cache per usi futuri. Il recupero di un segreto memorizzato nella cache è più veloce rispetto al recupero da Secrets Manager. Poiché la chiamata a Secrets Manager comporta un costo APIs, l'utilizzo di una cache può ridurre i costi. Per tutti i modi in cui puoi recuperare i segreti, vedi [Ottieni segreti](retrieving-secrets.md).

La politica della cache è First In First Out (FIFO), quindi quando la cache deve eliminare un segreto, scarta il segreto più vecchio. Di default, la cache aggiorna i segreti ogni ora. È possibile configurare quanto segue:
+ `max_size`— Il numero massimo di segreti memorizzati nella cache da mantenere prima di rimuovere i segreti a cui non è stato effettuato l'accesso di recente.
+ `ttl`— La durata di validità di un elemento memorizzato nella cache prima di richiedere un aggiornamento dello stato segreto.

L'implementazione della cache non include l'invalidazione della cache. L'implementazione della cache è incentrata sulla cache stessa e non è rafforzata o focalizzata sulla sicurezza. Se hai bisogno di una sicurezza aggiuntiva, come la crittografia degli elementi nella cache, usa le caratteristiche fornite per modificare la cache.

Per utilizzare il componente, è necessario disporre di un ambiente di sviluppo Rust 2021 con. `tokio` Per ulteriori informazioni, consulta [Guida introduttiva](https://www.rust-lang.org/learn/get-started) sul sito Web del linguaggio di programmazione Rust.

Per scaricare il codice sorgente, vedete il [componente client di caching basato su Rust Secrets Manager](https://github.com/aws/aws-secretsmanager-agent/tree/main/aws_secretsmanager_caching) su. GitHub

Per installare il componente di memorizzazione nella cache, utilizzare il comando seguente.

```
cargo add aws_secretsmanager_caching
```

**Autorizzazioni richieste:**
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`

Per ulteriori informazioni, consulta [Riferimento per le autorizzazioni](auth-and-access.md#reference_iam-permissions).

**Example Recupero di un segreto**  
L'esempio seguente mostra come ottenere il valore segreto per un segreto denominato*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 Istanziazione della cache con una configurazione personalizzata e un client personalizzato**  
L'esempio seguente mostra come configurare la cache e quindi ottenere il valore segreto per un segreto denominato. *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
```
```