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.
# Configuration des paramètres de niveau HTTP dans le AWS SDK pour Rust
AWS SDK pour Rust fournit une fonctionnalité HTTP intégrée qui est utilisée par les Service AWS clients que vous créez dans votre code.
Par défaut, le SDK pour Rust utilise un client HTTPS basé sur `hyper``rustls`, et`aws-lc-rs`. Ce client devrait fonctionner correctement dans la plupart des cas d'utilisation sans configuration supplémentaire.
+ [https://docs.rs/hyper/latest/hyper/](https://docs.rs/hyper/latest/hyper/)est une bibliothèque HTTP de niveau inférieur pour Rust qui peut être utilisée avec le AWS SDK pour Rust pour effectuer des appels de service d'API.
+ [https://github.com/rustls/rustls](https://github.com/rustls/rustls)est une bibliothèque TLS moderne écrite en Rust qui possède des options intégrées pour les fournisseurs de cryptographie.
+ [https://github.com/aws/aws-lc](https://github.com/aws/aws-lc)est une bibliothèque cryptographique à usage général contenant les algorithmes nécessaires au TLS et aux applications courantes.
+ [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs)est un wrapper idiomatique autour de la `aws-lc` bibliothèque dans Rust.
La `aws-smithy-http-client` caisse fournit des options et une configuration supplémentaires si vous souhaitez choisir un autre fournisseur TLS ou cryptographique. Pour les cas d'utilisation plus avancés, nous vous encourageons à implémenter votre propre client HTTP ou à déposer une demande de fonctionnalité pour examen.
## Choisir un autre fournisseur TLS
La `aws-smithy-http-client` caisse fournit quelques fournisseurs TLS alternatifs.
Les fournisseurs suivants sont disponibles :
**`rustls` avec `aws-lc`**
Un fournisseur TLS basé sur [https://github.com/rustls/rustls](https://github.com/rustls/rustls)ce type d'utilisation [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs)pour la cryptographie.
Il s'agit du comportement HTTP par défaut du SDK pour Rust. Si vous souhaitez utiliser cette option, vous n'avez aucune action supplémentaire à effectuer dans votre code.
**`s2n-tls`**
Un fournisseur TLS basé sur. [https://github.com/aws/s2n-tls](https://github.com/aws/s2n-tls)
**`rustls` avec `aws-lc-fips`**
Un fournisseur TLS basé sur [https://github.com/rustls/rustls](https://github.com/rustls/rustls)lequel utilise une version conforme à la norme FIPS de pour la cryptographie [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs)
**`rustls` avec `ring`**
Un fournisseur TLS basé sur [https://github.com/rustls/rustls](https://github.com/rustls/rustls)ce type d'utilisation [https://github.com/briansmith/ring](https://github.com/briansmith/ring)pour la cryptographie.
### Conditions préalables
Utiliser `aws-lc-rs` ou `s2n-tls` nécessite un compilateur C (Clang ou GCC) pour construire. Pour certaines plateformes, la compilation peut également nécessiter CMake. Construire avec la fonctionnalité « fips » sur n'importe quelle plateforme nécessite CMake et Go. Pour plus d'informations, consultez le référentiel [AWS Libcrypto pour Rust (`aws-lc-rs`)](https://github.com/aws/aws-lc-rs/blob/main/aws-lc-rs/README.md) et les instructions de compilation.
### Comment utiliser un autre fournisseur TLS
La `aws-smithy-http-client` caisse fournit des options TLS supplémentaires. Pour que vos Service AWS clients utilisent un autre fournisseur TLS, remplacez l'`http_client`utilisation du chargeur depuis la `aws_config` caisse. Le client HTTP est utilisé à la fois pour les fournisseurs Services AWS d'informations d'identification.
L'exemple suivant montre comment utiliser le fournisseur `s2n-tls` TLS. Cependant, une approche similaire fonctionne également pour d'autres fournisseurs.
Pour compiler l'exemple de code, exécutez la commande suivante pour ajouter des dépendances à votre projet :
```
cargo add aws-smithy-http-client -F s2n-tls
```
Exemple de 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);
}
```
## Activation du support FIPS
La `aws-smithy-http-client` caisse fournit une option pour activer une implémentation cryptographique conforme à la norme FIPS. Pour que vos Service AWS clients puissent utiliser le fournisseur conforme à la norme FIPS, remplacez l'`http_client`utilisation du chargeur depuis la caisse. `aws_config` Le client HTTP est utilisé à la fois pour les fournisseurs Services AWS d'informations d'identification.
**Note**
Le support FIPS nécessite des dépendances supplémentaires dans votre environnement de construction. Consultez les instructions de [fabrication](https://github.com/aws/aws-lc/blob/main/BUILDING.md) de la `aws-lc` caisse.
Pour compiler l'exemple de code, exécutez la commande suivante pour ajouter des dépendances à votre projet :
```
cargo add aws-smithy-http-client -F rustls-aws-lc-fips
```
L'exemple de code suivant active le support FIPS :
```
// 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);
}
```
## Prioriser l'échange de clés post-quantique
Le fournisseur TLS par défaut est basé sur `rustls` l'utilisation de celui `aws-lc-rs` qui prend en charge l'algorithme d'échange de clés `X25519MLKEM768` post-quantique. Pour créer `X25519MLKEM768` l'algorithme ayant la priorité la plus élevée, vous devez ajouter le `rustls` package à votre caisse et activer l'indicateur de `prefer-post-quantum` fonctionnalité. Dans le cas contraire, il est disponible, mais ce n'est pas la priorité la plus élevée. Consultez la `rustls` [documentation](https://docs.rs/rustls/0.23.23/rustls/manual/_05_defaults/index.html#about-the-post-quantum-secure-key-exchange-x25519mlkem768) pour plus d'informations.
**Note**
Cela deviendra la valeur par défaut dans une future version.
## Remplacer le résolveur DNS
Le résolveur DNS par défaut peut être remplacé en configurant le client HTTP manuellement.
Pour compiler l'exemple de code, exécutez les commandes suivantes pour ajouter des dépendances à votre projet :
```
cargo add aws-smithy-http-client -F rustls-aws-lc
cargo add aws-smithy-runtime-api -F client
```
L'exemple de code suivant remplace le résolveur DNS :
```
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);
}
```
**Note**
Par défaut, Amazon Linux 2023 (AL2023) ne met pas en cache le DNS au niveau du système d'exploitation.
## Personnalisation des certificats de l'autorité de certification racine
Par défaut, le fournisseur TLS charge les certificats racines natifs du système pour la plate-forme donnée. Pour personnaliser ce comportement afin de charger un bundle CA personnalisé, vous pouvez en configurer un `TlsContext` avec le vôtre`TrustStore`.
Pour compiler l'exemple de code, exécutez les commandes suivantes pour ajouter des dépendances à votre projet :
```
cargo add aws-smithy-http-client -F rustls-aws-lc
```
L'exemple suivant utilise `rustls` avec `aws-lc` mais fonctionnera pour tous les fournisseurs TLS pris en charge :
```
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);
}
```