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.
# Konfiguration von Einstellungen auf HTTP-Ebene im AWS SDK für Rust
Das AWS SDK für 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-Client`hyper`, der auf`rustls`, und basiert`aws-lc-rs`. Dieser Client sollte für die meisten Anwendungsfälle ohne zusätzliche Konfiguration gut funktionieren.
+ [https://docs.rs/hyper/latest/hyper/](https://docs.rs/hyper/latest/hyper/)ist eine HTTP-Bibliothek auf niedrigerer Ebene für Rust, die zusammen mit der verwendet werden kann, AWS SDK für Rust um API-Dienstaufrufe zu tätigen.
+ [https://github.com/rustls/rustls](https://github.com/rustls/rustls)ist eine moderne, in Rust geschriebene TLS-Bibliothek mit integrierten Optionen für kryptografische Anbieter.
+ [https://github.com/aws/aws-lc](https://github.com/aws/aws-lc)ist eine kryptografische Bibliothek für allgemeine Zwecke, die Algorithmen enthält, die für TLS und gängige Anwendungen benötigt werden.
+ [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs)ist ein idiomatischer Wrapper rund um die Bibliothek in Rust. `aws-lc`
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:
**`rustls` mit `aws-lc`**
Ein TLS-Anbieter [https://github.com/rustls/rustls](https://github.com/rustls/rustls), der auf diesem basiert und [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs)für die Kryptografie verwendet wird.
Dies ist das standardmäßige HTTP-Verhalten für das SDK für Rust. Wenn Sie diese Option verwenden möchten, müssen Sie in Ihrem Code keine zusätzlichen Maßnahmen ergreifen.
**`s2n-tls`**
Ein TLS-Anbieter, der auf basiert [https://github.com/aws/s2n-tls](https://github.com/aws/s2n-tls).
**`rustls` mit `aws-lc-fips`**
Ein darauf [https://github.com/rustls/rustls](https://github.com/rustls/rustls)basierender TLS-Anbieter verwendet eine FIPS-konforme Version von für die Kryptografie [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs)
**`rustls` mit `ring`**
Ein darauf basierender TLS-Anbieter für Kryptografie [https://github.com/rustls/rustls](https://github.com/rustls/rustls). [https://github.com/briansmith/ring](https://github.com/briansmith/ring)
### 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`)](https://github.com/aws/aws-lc-rs/blob/main/aws-lc-rs/README.md) 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.
**Anmerkung**
Die FIPS-Unterstützung erfordert zusätzliche Abhängigkeiten in Ihrer Build-Umgebung. Weitere Informationen finden Sie in den [Bauanweisungen](https://github.com/aws/aws-lc/blob/main/BUILDING.md) für die `aws-lc` Kiste.
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` Verwendung`aws-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](https://docs.rs/rustls/0.23.23/rustls/manual/_05_defaults/index.html#about-the-post-quantum-secure-key-exchange-x25519mlkem768).
**Anmerkung**
Dies wird in einer future Version die Standardeinstellung sein.
## 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);
}
```
**Anmerkung**
Standardmäßig speichert Amazon Linux 2023 (AL2023) DNS nicht auf Betriebssystemebene.
## 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 konfigurieren`TrustStore`.
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` with`aws-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);
}
```