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
<a name="presigned-urls"></a>

 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](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-presigned-url.html) no *Guia do usuário do Amazon Simple Storage Service*.

## Conceitos básicos de pré-assinatura
<a name="presign-basics"></a>

 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`
<a name="presign-post-put"></a>

 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 [https://docs.rs/http/latest/http/request/struct.Request.html](https://docs.rs/http/latest/http/request/struct.Request.html) 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
<a name="standalone-signer"></a>

**nota**  
Esse é um caso de uso avançado. Ele não é necessário nem recomendado para a maioria dos usuários.

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 [https://docs.rs/aws-sigv4/latest/aws_sigv4/index.html](https://docs.rs/aws-sigv4/latest/aws_sigv4/index.html) 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);
```