Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Vorsignierte erstellen URLs mit dem AWS SDK für Rust
<a name="presigned-urls"></a>

 Sie können Anfragen für einige AWS API-Operationen vorab signieren, sodass ein anderer Aufrufer die Anfrage später verwenden kann, ohne seine eigenen Anmeldeinformationen angeben zu müssen. 

 Nehmen wir zum Beispiel an, dass Jane Zugriff auf ein Amazon Simple Storage Service (Amazon S3) -Objekt hat und den Objektzugriff vorübergehend mit Alejandro teilen möchte. Jane kann eine vorab signierte `GetObject` Anfrage zur Weitergabe an Alejandro generieren, sodass er das Objekt herunterladen kann, ohne Zugriff auf Janes Anmeldeinformationen zu benötigen oder eigene zu haben. Die von der vorsignierten URL verwendeten Anmeldeinformationen gehören Jane, da sie die AWS Benutzerin ist, die die URL generiert hat.

Weitere Informationen zu presigned URLs in Amazon S3 finden Sie unter [Working with presigned URLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-presigned-url.html) im *Amazon Simple Storage Service-Benutzerhandbuch*.

## Grundlagen der Vorsignierung
<a name="presign-basics"></a>

 Das AWS SDK für Rust stellt eine `presigned()` Methode zur Operation Fluent-Builder bereit, die verwendet werden kann, um eine vorab signierte Anfrage abzurufen. 

 Das folgende Beispiel erstellt eine vorsignierte `GetObject` Anfrage für Amazon S3. Die Anfrage ist nach ihrer Erstellung 5 Minuten lang gültig. 

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

 Die `presigned()` Methode gibt a zurück`Result<PresignedRequest, SdkError<E, R>>`. 

Die zurückgegebene `PresignedRequest` Datei enthält Methoden zum Abrufen der Komponenten einer HTTP-Anfrage, einschließlich der Methode, des URI und aller Header. All diese müssen an den Dienst gesendet werden, falls vorhanden, damit die Anfrage gültig ist. Viele vorab signierte Anfragen können jedoch allein durch die URI dargestellt werden. 

## Vorsignierung `POST` und Anfragen `PUT`
<a name="presign-post-put"></a>

 Viele Operationen, die vorsignierbar sind, benötigen nur eine URL und müssen als HTTP-Anfragen gesendet werden. `GET` Einige Operationen benötigen jedoch einen Hauptteil und müssen in einigen Fällen als HTTP `POST` - oder `PUT` HTTP-Anfrage zusammen mit Headern gesendet werden. Das Vorsignieren dieser Anfragen ist identisch mit dem Vorsignieren von `GET` Anfragen, das Aufrufen der vorab signierten Anfrage ist jedoch komplizierter. 

 Im Folgenden finden Sie ein Beispiel für die Vorsignierung einer Amazon S3 `PutObject` S3-Anfrage und [https://docs.rs/http/latest/http/request/struct.Request.html](https://docs.rs/http/latest/http/request/struct.Request.html)deren Konvertierung in eine, die mit einem HTTP-Client Ihrer Wahl gesendet werden kann. 

Um diese `into_http_1x_request()` Methode zu verwenden, fügen Sie die `http-1x` Funktion zu Ihrer `aws-sdk-s3` Kiste in Ihrer `Cargo.toml` Datei hinzu:

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

Quelldatei:

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

## Eigenständiger Unterzeichner
<a name="standalone-signer"></a>

**Anmerkung**  
Dies ist ein Anwendungsfall für Fortgeschrittene. Es wird für die meisten Benutzer nicht benötigt oder empfohlen.

Es gibt einige Anwendungsfälle, in denen es erforderlich ist, eine signierte Anfrage außerhalb des SDK für Rust-Kontextes zu erstellen. Dafür können Sie die [https://docs.rs/aws-sigv4/latest/aws_sigv4/index.html](https://docs.rs/aws-sigv4/latest/aws_sigv4/index.html)Kiste unabhängig vom SDK verwenden. 

 Das Folgende ist ein Beispiel zur Veranschaulichung der grundlegenden Elemente. Weitere Informationen finden Sie in der Crate-Dokumentation. 

Fügen Sie die `http` Kisten `aws-sigv4` und zu Ihrer `Cargo.toml` Datei hinzu:

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

Quelldatei:

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