Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Créer un pré-signé URLs

Vous pouvez présigner des demandes pour certaines opérations AWS d'API afin qu'un autre appelant puisse utiliser la demande ultérieurement sans présenter ses propres informations d'identification.

Supposons par exemple que Jane ait accès à un objet Amazon Simple Storage Service (Amazon S3) et qu'elle souhaite partager temporairement l'accès à cet objet avec Alejandro. Jane peut générer une GetObject demande présignée à partager avec Alejandro afin qu'il puisse télécharger l'objet sans avoir besoin d'accéder aux informations d'identification de Jane ou d'avoir les siennes. Les informations d'identification utilisées par l'URL présignée sont celles de Jane, car c'est elle AWS qui a généré l'URL.

Pour en savoir plus sur le présigné URLs dans Amazon S3, consultez la section Travailler avec le présigné URLs dans le guide de l'utilisateur d'Amazon Simple Storage Service.

Principes de base de la présignature

Kit AWS SDK pour Rust Il fournit une presigned() méthode d'opération fluent-builders qui peut être utilisée pour obtenir une demande présignée.

L'exemple suivant crée une GetObject demande présignée pour Amazon S3. La demande est valide pendant 5 minutes après sa création.

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

La presigned() méthode renvoie unResult<PresignedRequest, SdkError<E, R>>.

Le résultat PresignedRequest contient des méthodes permettant d'accéder aux composants d'une requête HTTP, notamment la méthode, l'URI et les en-têtes éventuels. Tous ces éléments doivent être envoyés au service, le cas échéant, pour que la demande soit valide. Cependant, de nombreuses demandes présignées peuvent être représentées uniquement par l'URI.

Présignature POST et demandes PUT

De nombreuses opérations présignables ne nécessitent qu'une URL et doivent être envoyées sous forme de requêtes HTTPGET. Cependant, certaines opérations prennent un corps et doivent être envoyées sous forme de PUT requête HTTP POST ou HTTP avec des en-têtes dans certains cas. La présignature de ces demandes est identique à la présignature des GET demandes, mais l'invocation de la demande présignée est plus compliquée.

Voici un exemple de présignature d'une demande Amazon S3 et de sa conversion en une PutObject requête http::request::Requestqui peut être envoyée à l'aide d'un client HTTP de votre choix.

Pour utiliser into_http_1x_request() cette méthode, ajoutez la http-1x fonctionnalité à votre aws-sdk-s3 caisse dans votre Cargo.toml fichier :

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

Fichier source :

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

Signataire autonome

Dans certains cas d'utilisation, il est nécessaire de créer une demande signée en dehors du contexte du SDK pour Rust. Pour cela, vous pouvez utiliser la aws-sigv4caisse indépendamment du SDK.

Voici un exemple illustrant les éléments de base. Consultez la documentation relative à la caisse pour plus de détails.

Ajoutez les http caisses aws-sigv4 et à votre Cargo.toml fichier :

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

Fichier source :

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