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

Nelle applicazioni, puoi recuperare i tuoi segreti chiamando `GetSecretValue` o `BatchGetSecretValue` in uno qualsiasi dei AWS SDKs. Tuttavia, ti consigliamo di memorizzare nella cache i valori del segreto utilizzando la caching lato client. Memorizzare i segreti nella cache migliora la velocità e riduce i costi.

**Topics**
+ [Ottieni un valore segreto di Secrets Manager usando Rust con la memorizzazione nella cache lato client](retrieving-secrets_cache-rust.md)
+ [Ottieni un valore segreto di Secrets Manager utilizzando Rust AWS SDK](retrieving-secrets-rust-sdk.md)

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

# Ottieni un valore segreto di Secrets Manager utilizzando Rust AWS SDK
<a name="retrieving-secrets-rust-sdk"></a>

Nelle applicazioni, puoi recuperare i tuoi segreti chiamando `GetSecretValue` o `BatchGetSecretValue` in uno qualsiasi dei. AWS SDKs Tuttavia, ti consigliamo di memorizzare nella cache i valori del segreto utilizzando la caching lato client. Memorizzare i segreti nella cache migliora la velocità e riduce i costi.

Per le applicazioni Rust, usa il [componente di caching basato su Secrets Manager Rust](retrieving-secrets_cache-rust.md) o chiama l'[SDK direttamente](https://docs.rs/releases/search?query=aws-sdk-secretsmanager) con o. GetSecretValue BatchGetSecretValue

I seguenti esempi di codice mostrano come recuperare un valore segreto di Gestione dei segreti.

**Autorizzazioni richieste:**`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(())
}
```