HTTP

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.

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.

Das AWS SDK for Rust bietet integrierte HTTP-Funktionalität, die von den AWS-Service Clients verwendet wird, die Sie in Ihrem Code erstellen.

Standardmäßig verwendet das SDK für Rust einen HTTPS-Clienthyper, der aufrustls, und basiertaws-lc-rs. Dieser Client sollte für die meisten Anwendungsfälle ohne zusätzliche Konfiguration gut funktionieren.

Die aws-smithy-http-client Kiste bietet einige zusätzliche Optionen und Konfigurationen, falls Sie einen anderen TLS- oder Kryptografieanbieter wählen möchten. Für fortgeschrittenere Anwendungsfälle empfehlen wir Ihnen, Ihre eigene HTTP-Client-Implementierung mitzubringen oder eine Funktionsanfrage zur Prüfung einzureichen.

Wählen Sie einen alternativen TLS-Anbieter

Die aws-smithy-http-client Kiste bietet einige alternative TLS-Anbieter.

Die folgenden Anbieter sind verfügbar:

Voraussetzungen

Zum Erstellen wird ein C-Compiler (Clang oder GCC) verwendet aws-lc-rs oder s2n-tls benötigt. Für einige Plattformen erfordert der Build möglicherweise auch. CMake Für das Bauen mit der „FIPS“ -Funktion auf einer beliebigen Plattform ist Go erforderlich CMake . Weitere Informationen finden Sie im AWS-Repository Libcrypto for Rust (aws-lc-rs) und in den Build-Anweisungen.

Wie verwende ich einen alternativen TLS-Anbieter

Die aws-smithy-http-client Kiste bietet zusätzliche TLS-Optionen. Damit Ihre AWS-Service Kunden einen anderen TLS-Anbieter verwenden können, müssen Sie die http_client Verwendung des Loaders aus der aws_config Kiste außer Kraft setzen. Der HTTP-Client wird sowohl für Anbieter als auch AWS-Services für Anbieter von Anmeldeinformationen verwendet.

Das folgende Beispiel zeigt, wie der s2n-tls TLS-Anbieter verwendet wird. Ein ähnlicher Ansatz funktioniert jedoch auch für andere Anbieter.

Um den Beispielcode zu kompilieren, führen Sie den folgenden Befehl aus, um Ihrem Projekt Abhängigkeiten hinzuzufügen:

cargo add aws-smithy-http-client -F s2n-tls

Beispiel-Code:

use aws_smithy_http_client::{tls, Builder};

#[tokio::main]
async fn main() {
    let http_client = Builder::new()
        .tls_provider(tls::Provider::S2nTls)
        .build_https();

    let sdk_config = aws_config::defaults(
        aws_config::BehaviorVersion::latest()
    )
    .http_client(http_client)
    .load()
    .await;

    // create client(s) using sdk_config
    // e.g. aws_sdk_s3::Client::new(&sdk_config);
}

FIPS-Unterstützung aktivieren

Die aws-smithy-http-client Kiste bietet eine Option, um eine FIPS-konforme Kryptoimplementierung zu aktivieren. Damit Ihre AWS-Service Kunden den FIPS-konformen Anbieter verwenden können, müssen Sie die Verwendung des Loaders aus der http_client Kiste außer Kraft setzen. aws_config Der HTTP-Client wird sowohl für Anbieter von Anmeldeinformationen als auch AWS-Services für Anbieter von Anmeldeinformationen verwendet.

Um den Beispielcode zu kompilieren, führen Sie den folgenden Befehl aus, um Ihrem Projekt Abhängigkeiten hinzuzufügen:

cargo add aws-smithy-http-client -F rustls-aws-lc-fips

Der folgende Beispielcode aktiviert die FIPS-Unterstützung:

// file: main.rs
use aws_smithy_http_client::{
    tls::{self, rustls_provider::CryptoMode},
    Builder,
};

#[tokio::main]
async fn main() {
    let http_client = Builder::new()
        .tls_provider(tls::Provider::Rustls(CryptoMode::AwsLcFips))
        .build_https();

    let sdk_config = aws_config::defaults(
        aws_config::BehaviorVersion::latest()
    )
    .http_client(http_client)
    .load()
    .await;

    // create client(s) using sdk_config
    // e.g. aws_sdk_s3::Client::new(&sdk_config);
}

Priorisierung des Schlüsselaustauschs nach dem Quantum-Verfahren

Der Standard-TLS-Anbieter basiert auf der rustls Verwendungaws-lc-rs, der den Algorithmus für den Schlüsselaustausch X25519MLKEM768 nach dem Quantenaustausch unterstützt. Um X25519MLKEM768 den Algorithmus mit der höchsten Priorität zu erstellen, müssen Sie das rustls Paket zu Ihrer Kiste hinzufügen und das prefer-post-quantum Feature-Flag aktivieren. Andernfalls ist es verfügbar, hat aber nicht die höchste Priorität. Weitere Informationen finden Sie in der rustls Dokumentation.

Den DNS-Resolver überschreiben

Der Standard-DNS-Resolver kann außer Kraft gesetzt werden, indem der HTTP-Client manuell konfiguriert wird.

Um den Beispielcode zu kompilieren, führen Sie die folgenden Befehle aus, um Ihrem Projekt Abhängigkeiten hinzuzufügen:

cargo add aws-smithy-http-client -F rustls-aws-lc
cargo add aws-smithy-runtime-api -F client

Der folgende Beispielcode überschreibt den DNS-Resolver:

use aws_smithy_http_client::{
    tls::{self, rustls_provider::CryptoMode},
    Builder
};
use aws_smithy_runtime_api::client::dns::{DnsFuture, ResolveDns};
use std::net::{IpAddr, Ipv4Addr};

/// A DNS resolver that returns a static IP address (127.0.0.1)
#[derive(Debug, Clone)]
struct StaticResolver;

impl ResolveDns for StaticResolver {
    fn resolve_dns<'a>(&'a self, _name: &'a str) -> DnsFuture<'a> {
        DnsFuture::ready(Ok(vec![IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))]))
    }
}

#[tokio::main]
async fn main() {
    let http_client = Builder::new()
        .tls_provider(tls::Provider::Rustls(CryptoMode::AwsLc))
        .build_with_resolver(StaticResolver);
    
    let sdk_config = aws_config::defaults(
        aws_config::BehaviorVersion::latest()
    )
    .http_client(http_client)
    .load()
    .await;
    
    // create client(s) using sdk_config
    // e.g. aws_sdk_s3::Client::new(&sdk_config);
}

Anpassen von Root-CA-Zertifikaten

Standardmäßig lädt der TLS-Anbieter die systemeigenen Stammzertifikate für die angegebene Plattform. Um dieses Verhalten beim Laden eines benutzerdefinierten CA-Bundles anzupassen, können Sie ein TlsContext mit Ihrem eigenen konfigurierenTrustStore.

Um den Beispielcode zu kompilieren, führen Sie die folgenden Befehle aus, um Ihrem Projekt Abhängigkeiten hinzuzufügen:

cargo add aws-smithy-http-client -F rustls-aws-lc

Das folgende Beispiel verwendet rustls withaws-lc, funktioniert aber auch für jeden unterstützten TLS-Anbieter:

use aws_smithy_http_client::{
    tls::{self, rustls_provider::CryptoMode},
    Builder
};
use std::fs;

/// read the PEM encoded root CA (bundle) and return a custom TLS context
fn tls_context_from_pem(filename: &str) -> tls::TlsContext {
    let pem_contents = fs::read(filename).unwrap();
    
    // Create a new empty trust store (this will not load platform native certificates)
    let trust_store = tls::TrustStore::empty()
        .with_pem_certificate(pem_contents.as_slice());
        
    tls::TlsContext::builder()
        .with_trust_store(trust_store)
        .build()
        .expect("valid TLS config")
}

#[tokio::main]
async fn main() {
    let http_client = Builder::new()
        .tls_provider(tls::Provider::Rustls(CryptoMode::AwsLc))
        .tls_context(tls_context_from_pem("my-custom-ca.pem"))
        .build_https();
    
    let sdk_config = aws_config::defaults(
        aws_config::BehaviorVersion::latest()
    )
    .http_client(http_client)
    .load()
    .await;
    
    // create client(s) using sdk_config
    // e.g. aws_sdk_s3::Client::new(&sdk_config);
}