Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Creazione di predefiniti URLs utilizzando AWS SDK per Rust
<a name="presigned-urls"></a>

 È possibile preassegnare le richieste per alcune operazioni AWS API in modo che un altro chiamante possa utilizzare la richiesta in un secondo momento senza presentare le proprie credenziali. 

 Ad esempio, supponiamo che Jane abbia accesso a un oggetto Amazon Simple Storage Service (Amazon S3) e desideri condividere temporaneamente l'accesso agli oggetti con Alejandro. Jane può generare una `GetObject` richiesta predefinita da condividere con Alejandro in modo che quest'ultimo possa scaricare l'oggetto senza dover accedere alle credenziali di Jane o averne di proprie. Le credenziali utilizzate dall'URL predefinito sono di Jane perché è l'utente che ha generato l'URL. AWS 

Per ulteriori informazioni sulle impostazioni predefinite URLs in Amazon S3, [consulta Working with URLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-presigned-url.html) presigned nella *Amazon Simple Storage* Service User Guide.

## Nozioni di base sulla preassegnazione
<a name="presign-basics"></a>

 AWS SDK per Rust Fornisce un `presigned()` metodo sul funzionamento fluent-builders che può essere utilizzato per ottenere una richiesta prefirmata. 

 L'esempio seguente crea una `GetObject` richiesta predefinita per Amazon S3. La richiesta è valida per 5 minuti dopo la creazione. 

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

 Il `presigned()` metodo restituisce un`Result<PresignedRequest, SdkError<E, R>>`. 

Il valore restituito `PresignedRequest` contiene metodi per accedere ai componenti di una richiesta HTTP, inclusi il metodo, l'URI ed eventuali intestazioni. Tutti questi devono essere inviati al servizio, se presente, affinché la richiesta sia valida. Tuttavia, molte richieste predefinite possono essere rappresentate solo dall'URI. 

## Preassegnazione `POST` e richieste `PUT`
<a name="presign-post-put"></a>

 Molte operazioni prefirmabili richiedono solo un URL e devono essere inviate come richieste HTTP. `GET` Alcune operazioni, tuttavia, richiedono un corpo e in alcuni casi devono essere inviate come `PUT` richiesta HTTP `POST` o HTTP insieme alle intestazioni. La preassegnazione di queste richieste è identica alla prefirma `GET` delle richieste, ma richiamare la richiesta prefirmata è più complicata. 

 Di seguito è riportato un esempio di preassegnazione di una richiesta Amazon `PutObject` S3 e la conversione in [https://docs.rs/http/latest/http/request/struct.Request.html](https://docs.rs/http/latest/http/request/struct.Request.html)una richiesta che può essere inviata utilizzando un client HTTP di tua scelta. 

Per utilizzare il `into_http_1x_request()` metodo, aggiungi la `http-1x` funzionalità alla casella del `aws-sdk-s3` file: `Cargo.toml`

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

File sorgente:

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

## Firmatario autonomo
<a name="standalone-signer"></a>

**Nota**  
Si tratta di un caso d'uso avanzato. Non è necessario o consigliato per la maggior parte degli utenti.

Esistono alcuni casi d'uso in cui è necessario creare una richiesta firmata al di fuori del contesto SDK for Rust. Per questo puoi usare la [https://docs.rs/aws-sigv4/latest/aws_sigv4/index.html](https://docs.rs/aws-sigv4/latest/aws_sigv4/index.html)cassa indipendentemente dall'SDK. 

 Quello che segue è un esempio per dimostrare gli elementi di base, consulta la documentazione del crate per maggiori dettagli. 

Aggiungi le `http` casse `aws-sigv4` e al tuo `Cargo.toml` file:

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

File sorgente:

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