Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Obtener un valor secreto de Secrets Manager con Rust
<a name="retrieving-secrets-rust"></a>

En las aplicaciones, puede recuperar sus secretos llamando `GetSecretValue` o `BatchGetSecretValue` en cualquiera de las AWS SDKs. No obstante, se recomienda que almacene en caché sus valores secretos mediante el almacenamiento en caché del lado del cliente. El almacenado en caché de los secretos mejora la velocidad y reduce los costos.

**Topics**
+ [Obtener un valor secreto de Secrets Manager mediante Rust con almacenamiento en caché del cliente](retrieving-secrets_cache-rust.md)
+ [Obtenga un valor secreto de Secrets Manager con el AWS SDK de Rust](retrieving-secrets-rust-sdk.md)

# Obtener un valor secreto de Secrets Manager mediante Rust con almacenamiento en caché del cliente
<a name="retrieving-secrets_cache-rust"></a>

Cuando recupera un secreto, puede utilizar el componente de almacenamiento en caché basado en Rust de Secrets Manager para utilizarlo más adelante. Recuperar un secreto almacenado en la memoria caché es más rápido que recuperarlo desde Secrets Manager. Como llamar a Secrets Manager conlleva un coste APIs, el uso de una memoria caché puede reducir los costes. Para conocer todas las formas en las que puede recuperar secretos, consulte [Obtener secretos](retrieving-secrets.md).

La caché sigue la política de primero en entrar, primero en salir (FIFO), por lo que cada vez que la caché tiene que descartar un secreto, descarta el más antiguo. De forma predeterminada, la caché actualiza secretos cada hora. Puede configurar las siguientes opciones:
+ `max_size`: el número máximo de secretos en caché que se deben mantener antes de desalojar los secretos a los que no se ha accedido recientemente.
+ `ttl`: el tiempo que se considera válido un elemento almacenado en caché antes de requerir una actualización del estado del secreto.

La implementación de la memoria caché no incluye la invalidación de la memoria caché. La implementación de la memoria caché se centra en la memoria caché en sí misma y no está reforzada ni centrada en la seguridad. Si necesita más seguridad, como cifrar elementos en la memoria caché, utilice los rasgos proporcionados para modificar la caché.

Para utilizar el componente, debe disponer de un entorno de desarrollo Rust 2021 con `tokio`. Para obtener más información, consulte [Comenzar](https://www.rust-lang.org/learn/get-started) en el sitio web del lenguaje de programación Rust.

Para descargar el código fuente, consulte el [componente de cliente de almacenamiento en caché basado en Rust de Secrets Manager](https://github.com/aws/aws-secretsmanager-agent/tree/main/aws_secretsmanager_caching) en. GitHub

Para instalar el componente de almacenamiento en caché, utilice el siguiente comando.

```
cargo add aws_secretsmanager_caching
```

**Permisos necesarios: **
+ `secretsmanager:DescribeSecret`
+ `secretsmanager:GetSecretValue`

Para obtener más información, consulte [Referencia de permisos](auth-and-access.md#reference_iam-permissions).

**Example Recuperación de un secreto**  
En el siguiente ejemplo se muestra cómo obtener el valor secreto de un secreto denominado. *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 Creación de instancias de caché con una configuración y un cliente personalizados**  
En el siguiente ejemplo se muestra cómo configurar la caché y, a continuación, obtener el valor secreto de un secreto denominado*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
```
```

# Obtenga un valor secreto de Secrets Manager con el AWS SDK de Rust
<a name="retrieving-secrets-rust-sdk"></a>

En las aplicaciones, puedes recuperar tus secretos llamando `GetSecretValue` o `BatchGetSecretValue` en cualquiera de las AWS SDKs. No obstante, se recomienda que almacene en caché sus valores secretos mediante el almacenamiento en caché del lado del cliente. El almacenado en caché de los secretos mejora la velocidad y reduce los costos.

Para las aplicaciones de Rust, utilice el [componente de almacenamiento en caché basado en Rust de Secrets Manager](retrieving-secrets_cache-rust.md) o llame al [SDK directamente](https://docs.rs/releases/search?query=aws-sdk-secretsmanager) con GetSecretValue o. BatchGetSecretValue

El siguiente ejemplo de código muestra cómo obtener un valor secreto de Secrets Manager.

**Permisos necesarios: **`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(())
}
```