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.

Creación de URL prefirmadas mediante el AWS SDK para Rust

Puede prefirmar las solicitudes de algunas operaciones de la API de AWS para que otro intermediario pueda utilizar la solicitud más adelante sin tener que presentar sus credenciales.

Por ejemplo, supongamos que Alicia tiene acceso a un objeto Amazon Simple Storage Service (Amazon S3) y desea compartir temporalmente el acceso a ese objeto con Alejandro. Alicia puede generar una solicitud de GetObject prefirmada para compartir el acceso con Alejandro de forma que él pueda descargar el objeto sin necesidad de acceder a las credenciales de Alicia ni tener las suyas propias. Las credenciales que utiliza la URL prefirmada son las de Alicia, ya que ella es el usuario de AWS que generó la URL.

Para obtener más información sobre las URL prefirmadas en Amazon S3, consulte Uso de URL prefirmadas en la Guía del usuario de Amazon Simple Storage Service.

Conceptos básicos sobre la firma previa

El AWS SDK para Rust proporciona un método presigned() en los generadores de operaciones fluidos que se puede utilizar para obtener una solicitud prefirmada.

En el siguiente ejemplo, se crea una solicitud GetObject prefirmada para Amazon S3. La solicitud es válida durante 5 minutos después de la creación.

use std::time::Duration;
use aws_config::BehaviorVersion;
use aws_sdk_s3::presigning::PresigningConfig;

let config = aws_config::defaults(BehaviorVersion::latest())
    .load()
    .await;

let s3 = aws_sdk_s3::Client::new(&config);

let presigned = s3.get_object()
    .presigned(
        PresigningConfig::builder()
            .expires_in(Duration::from_secs(60 * 5))
            .build()
            .expect("less than one week")
    )
    .await?;

El método presigned() devuelve un Result<PresignedRequest, SdkError<E, R>>.

La PresignedRequest que se devuelve contiene métodos para acceder a los componentes de una solicitud HTTP, incluidos el método, el URI y cualquier encabezado. Todos estos deben enviarse al servicio, si están presentes, para que la solicitud sea válida. Sin embargo, muchas solicitudes prefirmadas se pueden representar únicamente mediante el URI.

Firma previa de solicitudes POST y PUT

Muchas operaciones que se pueden prefirmar solo requieren una URL y deben enviarse como solicitudes GET HTTP. Sin embargo, algunas operaciones requieren un cuerpo y, en algunos casos, deben enviarse como una solicitud POST HTTP o PUT HTTP junto con encabezados. La firma previa de estas solicitudes es idéntica a la de solicitudes GET, si bien invocar la solicitud prefirmada es más complicado.

El siguiente es un ejemplo de firma previa de una solicitud PutObject de Amazon S3 y convertirla en una http::request::Request que pueda enviarse mediante el cliente HTTP que elija.

Para usar el método into_http_1x_request(), agregue la característica http-1x a la caja aws-sdk-s3 del archivo Cargo.toml:

aws-sdk-s3 = { version = "1", features = ["http-1x"] }

Archivo fuente:

let presigned = s3.put_object()
    .presigned(
        PresigningConfig::builder()
            .expires_in(Duration::from_secs(60 * 5))
            .build()
            .expect("less than one week")
    )
    .await?;


let body = "Hello AWS SDK for Rust";
let http_req = presigned.into_http_1x_request(body);

Firmante independiente

Hay algunos casos de uso en los que es necesario crear una solicitud firmada fuera del contexto del SDK para Rust. Para ello, puede utilizar la caja aws-sigv4 de manera independiente del SDK.

A continuación se muestra un ejemplo para demostrar los elementos básicos; consulte la documentación de la caja para obtener información más detallada.

Agregue las cajas http y aws-sigv4 y a su archivo Cargo.toml:

[dependencies]
aws-sigv4 = "1"
http = "1"

Archivo fuente:

use aws_smithy_runtime_api::client::identity::Identity;
use aws_sigv4::http_request::{sign, SigningSettings, SigningParams, SignableRequest};
use aws_sigv4::sign::v4;
use std::time::SystemTime;

// Set up information and settings for the signing.
// You can obtain credentials from `SdkConfig`.
let identity = Credentials::new(
    "AKIDEXAMPLE",
    "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY",
    None,
    None,
    "hardcoded-credentials").into();

let settings = SigningSettings::default();

let params = v4::SigningParams::builder()
    .identity(&identity)
    .region("us-east-1")
    .name("service")
    .time(SystemTime::now())
    .settings(settings)
    .build()?
    .into();

// Convert the HTTP request into a signable request.
let signable = SignableRequest::new(
    "GET",
    "https://some-endpoint.some-region.amazonaws.com",
    std::iter::empty(),
    SignableBody::UnsignedPayload
)?;

// Sign and then apply the signature to the request.
let (signing_instructions, _signature) = sign(signable, &params)?.into_parts();

let mut my_req = http::Request::new("...");
signing_instructions.apply_to_request_http1x(&mut my_req);