As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Como criar URLs pré-assinados usando o AWS SDK para Rust

Você pode pré-assinar solicitações para algumas operações da AWS API para outro chamador usar a solicitação posteriormente sem apresentar suas próprias credenciais.

Por exemplo, vamos supor que Jane tenha acesso a um objeto do Amazon Simple Storage Service (Amazon S3) e queira compartilhar temporariamente o acesso a esse objeto com Alejandro. Jane pode gerar uma solicitação GetObject pré-assinada para compartilhar com Alejandro para que ele possa fazer o download do objeto sem exigir acesso às credenciais de Jane ou ter suas próprias. As credenciais usadas pelo URL pré-assinado são de Jane, porque ela é o AWS da AWS que gerou o URL.

Para saber mais sobre URLs pré-assinados no Amazon S3, consulte Trabalhar com URLs pré-assinados no Guia do usuário do Amazon Simple Storage Service.

Conceitos básicos de pré-assinatura

O AWS SDK para Rust fornece um método de presigned() de operação de criadores de fluentes que pode ser usado para obter uma solicitação pré-assinada.

O exemplo a seguir cria uma solicitação GetObject pré-assinada para o Amazon S3. A solicitação é válida por 5 minutos após a criação.

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?;

O método presigned() retorna um Result<PresignedRequest, SdkError<E, R>>.

O PresignedRequest retornado contém métodos para acessar os componentes de uma solicitação HTTP, incluindo o método, o URI e quaisquer cabeçalhos. Tudo isso precisa ser enviado ao serviço, se presente, para que a solicitação seja válida. No entanto, muitas solicitações pré-assinadas podem ser representadas somente pelo URI.

Pré-assinar solicitações POST e PUT

Muitas operações que podem ser pré-assinadas exigem somente um URL e devem ser enviadas como solicitações GET HTTP. Algumas operações, no entanto, usam um corpo e devem ser enviadas como uma solicitação HTTP POST ou PUT junto a cabeçalhos em alguns casos. A pré-assinatura dessas solicitações é idêntica às solicitações pré-assinadas GET, mas invocar a solicitação pré-assinada é mais complicado.

Veja a seguir um exemplo de pré-assinatura de uma solicitação PutObject do Amazon S3 e sua conversão em um http::request::Request que pode ser enviado usando um cliente HTTP de sua escolha.

Para usar o método into_http_1x_request(), adicione o recurso http-1x à sua caixa aws-sdk-s3 no arquivo Cargo.toml:

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

Arquivo de origem:

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);

Signatário autônomo

Há alguns casos de uso em que é necessário criar uma solicitação assinada fora do contexto do SDK para Rust. Para isso, você pode usar a caixa aws-sigv4 independentemente do SDK.

Veja a seguir um exemplo que demonstra os elementos básicos. Consulte a documentação da caixa para obter mais detalhes.

Adicione as caixas aws-sigv4 e http ao arquivo Cargo.toml:

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

Arquivo de origem:

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);