Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Holen Sie sich mit Rust einen geheimen Wert für Secrets Manager
<a name="retrieving-secrets-rust"></a>

In Anwendungen können Sie Ihre Geheimnisse abrufen, indem Sie `GetSecretValue` oder `BatchGetSecretValue` in einem der AWS SDKs. Wir empfehlen jedoch, Ihre Secret-Werte mithilfe des clientseitigen Cachings zu speichern. Das Caching von Secrets verbessert die Geschwindigkeit und senkt Ihre Kosten.

**Topics**
+ [Holen Sie sich einen geheimen Wert für Secrets Manager mithilfe von Rust mit clientseitigem Caching](retrieving-secrets_cache-rust.md)
+ [Holen Sie sich mit dem Rust AWS SDK einen geheimen Wert für Secrets Manager](retrieving-secrets-rust-sdk.md)

# Holen Sie sich einen geheimen Wert für Secrets Manager mithilfe von Rust mit clientseitigem Caching
<a name="retrieving-secrets_cache-rust"></a>

Wenn Sie ein Geheimnis abrufen, können Sie es mit der Rust-basierten Caching-Komponente von Secrets Manager zwischenspeichern, um es für die future Verwendung zwischenzuspeichern. Das Abrufen eines gecacheten Secrets ist schneller als das Abrufen aus Secrets Manager. Da der Aufruf von Secrets Manager mit Kosten verbunden ist APIs, kann die Verwendung eines Caches Ihre Kosten senken. Alle Möglichkeiten, wie Sie Secrets abrufen können, finden Sie unter [Holen Sie sich Geheimnisse](retrieving-secrets.md).

Die Cache-Richtlinie lautet First In First Out (FIFO). Wenn der Cache also ein Geheimnis verwerfen muss, verwirft er das älteste Geheimnis. Standardmäßig aktualisiert der Cache Secrets jede Stunde. Sie können Folgendes konfigurieren:
+ `max_size`— Die maximale Anzahl zwischengespeicherter Geheimnisse, die aufbewahrt werden müssen, bevor Geheimnisse gelöscht werden, auf die in letzter Zeit nicht zugegriffen wurde.
+ `ttl`— Die Dauer, für die ein zwischengespeichertes Objekt als gültig angesehen wird, bevor eine Aktualisierung des geheimen Zustands erforderlich ist.

Die Cache-Implementierung beinhaltet keine Cache-Invalidierung. Die Cache-Implementierung konzentriert sich auf den Cache selbst und ist weder sicherheitsgehärtet noch fokussiert. Wenn Sie zusätzliche Sicherheit benötigen, z. B. die Verschlüsselung von Elementen im Cache, verwenden Sie die bereitgestellten Eigenschaften, um den Cache zu ändern.

Um die Komponente verwenden zu können, benötigen Sie eine Rust 2021-Entwicklungsumgebung mit`tokio`. Weitere Informationen finden Sie unter [Erste Schritte](https://www.rust-lang.org/learn/get-started) auf der Website der Programmiersprache Rust.

Informationen zum Herunterladen des Quellcodes finden Sie unter [Secrets Manager Rust-basierte Caching-Client-Komponente](https://github.com/aws/aws-secretsmanager-agent/tree/main/aws_secretsmanager_caching) auf. GitHub

Verwenden Sie den folgenden Befehl, um die Caching-Komponente zu installieren.

```
cargo add aws_secretsmanager_caching
```

**Erforderliche Berechtigungen: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`

Weitere Informationen finden Sie unter [Berechtigungsreferenz](auth-and-access.md#reference_iam-permissions).

**Example Ein Secret abrufen**  
Das folgende Beispiel zeigt, wie der geheime Wert für ein Secret mit dem Namen *MyTest* abgerufen wird.  

```
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 Cache mit einer benutzerdefinierten Konfiguration und einem benutzerdefinierten Client instanziieren**  
Das folgende Beispiel zeigt, wie Sie den Cache konfigurieren und dann den geheimen Wert für ein Geheimnis mit dem Namen abrufen. *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
```
```

# Holen Sie sich mit dem Rust AWS SDK einen geheimen Wert für Secrets Manager
<a name="retrieving-secrets-rust-sdk"></a>

In Anwendungen können Sie Ihre Geheimnisse abrufen, indem Sie `GetSecretValue` oder `BatchGetSecretValue` in einem der AWS SDKs. Wir empfehlen jedoch, Ihre Secret-Werte mithilfe des clientseitigen Cachings zu speichern. Das Caching von Secrets verbessert die Geschwindigkeit und senkt Ihre Kosten.

Verwenden Sie für [Rust-Anwendungen die auf Rust basierende Caching-Komponente von Secrets Manager](retrieving-secrets_cache-rust.md) oder rufen Sie das [SDK direkt](https://docs.rs/releases/search?query=aws-sdk-secretsmanager) mit oder auf. GetSecretValue BatchGetSecretValue

Das folgende Codebeispiel veranschaulicht, wie Sie einen Secrets-Manager-Geheimniswert abrufen.

**Erforderliche Berechtigungen: **`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(())
}
```