Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Configurazione delle impostazioni a livello HTTP all'interno dell' AWS SDK per Rust
AWS SDK per Rust Fornisce funzionalità HTTP integrate che vengono utilizzate dai Servizio AWS client creati nel codice.
Per impostazione predefinita, l'SDK per Rust utilizza un client HTTPS basato su `hyper``rustls`, e`aws-lc-rs`. Questo client dovrebbe funzionare bene per la maggior parte dei casi d'uso senza configurazioni aggiuntive.
+ [https://docs.rs/hyper/latest/hyper/](https://docs.rs/hyper/latest/hyper/)è una libreria HTTP di livello inferiore per Rust che può essere utilizzata con AWS SDK per Rust per effettuare chiamate ai servizi API.
+ [https://github.com/rustls/rustls](https://github.com/rustls/rustls)è una moderna libreria TLS scritta in Rust che dispone di opzioni integrate per i provider di crittografia.
+ [https://github.com/aws/aws-lc](https://github.com/aws/aws-lc)è una libreria crittografica generica contenente algoritmi necessari per TLS e applicazioni comuni.
+ [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs)è un wrapper idiomatico per la libreria di Rust. `aws-lc`
La `aws-smithy-http-client` cassa fornisce alcune opzioni e configurazioni aggiuntive se si desidera scegliere un provider TLS o crittografico diverso. Per casi d'uso più avanzati, vi consigliamo di utilizzare l'implementazione del vostro client HTTP o di presentare una richiesta di funzionalità da prendere in considerazione.
## Scelta di un provider TLS alternativo
La `aws-smithy-http-client` cassa fornisce alcuni provider TLS alternativi.
Sono disponibili i seguenti provider:
**`rustls` con `aws-lc`**
Un provider TLS basato su [https://github.com/rustls/rustls](https://github.com/rustls/rustls)questo metodo [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs)per la crittografia.
Questo è il comportamento HTTP predefinito per l'SDK per Rust. Se desideri utilizzare questa opzione non devi eseguire alcuna azione aggiuntiva nel codice.
**`s2n-tls`**
Un provider TLS basato su. [https://github.com/aws/s2n-tls](https://github.com/aws/s2n-tls)
**`rustls` con `aws-lc-fips`**
Un provider TLS basato su [https://github.com/rustls/rustls](https://github.com/rustls/rustls)questo utilizza una versione conforme a FIPS di per la crittografia [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs)
**`rustls` con `ring`**
Un provider TLS basato su questo utilizza la crittografia. [https://github.com/rustls/rustls](https://github.com/rustls/rustls)
### Prerequisiti
Utilizza `aws-lc-rs` o `s2n-tls` richiede un compilatore C (Clang o GCC) per la compilazione. Per alcune piattaforme, la build potrebbe richiedere anche. CMake La creazione con la funzionalità «fips» su qualsiasi piattaforma richiede CMake Band Go. Per ulteriori informazioni, [consulta il repository AWS Libcrypto for Rust (`aws-lc-rs`)](https://github.com/aws/aws-lc-rs/blob/main/aws-lc-rs/README.md) e le istruzioni di compilazione.
### Come usare un provider TLS alternativo
La `aws-smithy-http-client` cassa fornisce opzioni TLS aggiuntive. Affinché Servizio AWS i tuoi clienti utilizzino un provider TLS diverso, sostituisci l'`http_client`utilizzo del caricatore presente nella cassa. `aws_config` Il client HTTP viene utilizzato sia per i fornitori di credenziali che per i provider di credenziali Servizi AWS .
L'esempio seguente mostra come utilizzare il provider `s2n-tls` TLS. Tuttavia, un approccio simile funziona anche per altri provider.
Per compilare il codice di esempio, esegui il comando seguente per aggiungere dipendenze al progetto:
```
cargo add aws-smithy-http-client -F {{s2n-tls}}
```
Codice di esempio:
```
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);
}
```
## Attivazione del supporto FIPS
La `aws-smithy-http-client` cassa offre un'opzione per abilitare un'implementazione crittografica conforme a FIPS. Affinché Servizio AWS i tuoi clienti utilizzino il provider conforme a FIPS, sostituisci l'utilizzo del caricatore presente nella cassa. `http_client` `aws_config` Il client HTTP viene utilizzato sia per i fornitori di credenziali che per i provider di credenziali. Servizi AWS
**Nota**
Il supporto FIPS richiede dipendenze aggiuntive nell'ambiente di compilazione. Consulta le istruzioni di [costruzione](https://github.com/aws/aws-lc/blob/main/BUILDING.md) della `aws-lc` cassa.
Per compilare il codice di esempio, esegui il seguente comando per aggiungere dipendenze al tuo progetto:
```
cargo add aws-smithy-http-client -F rustls-aws-lc-fips
```
Il codice di esempio seguente abilita il supporto 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);
}
```
## Dare priorità allo scambio di chiavi post-quantistico
Il provider TLS predefinito si basa sull'`rustls`utilizzo `aws-lc-rs` che supporta l'algoritmo di scambio di chiavi post-quantistiche. `X25519MLKEM768` Per creare `X25519MLKEM768` l'algoritmo con la massima priorità, devi aggiungere il `rustls` pacchetto alla cassa e abilitare il flag della funzionalità. `prefer-post-quantum` Altrimenti, è disponibile ma non ha la massima priorità. Per ulteriori informazioni, `rustls` [consulta la documentazione](https://docs.rs/rustls/0.23.23/rustls/manual/_05_defaults/index.html#about-the-post-quantum-secure-key-exchange-x25519mlkem768).
**Nota**
Questa opzione diventerà l'impostazione predefinita nelle future release.
## Sovrascrivere il DNS Resolver
Il resolver DNS predefinito può essere sovrascritto configurando manualmente il client HTTP.
Per compilare il codice di esempio, esegui i seguenti comandi per aggiungere dipendenze al progetto:
```
cargo add aws-smithy-http-client -F rustls-aws-lc
cargo add aws-smithy-runtime-api -F client
```
Il codice di esempio seguente sostituisce il resolver 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);
}
```
**Nota**
Per impostazione predefinita, Amazon Linux 2023 (AL2023) non memorizza nella cache DNS a livello di sistema operativo.
## Personalizzazione dei certificati CA root
Per impostazione predefinita, il provider TLS carica i certificati root nativi del sistema per la piattaforma specificata. Per personalizzare questo comportamento in modo da caricare un pacchetto CA personalizzato, puoi configurarne uno `TlsContext` con il tuo. `TrustStore`
Per compilare il codice di esempio, esegui i seguenti comandi per aggiungere dipendenze al progetto:
```
cargo add aws-smithy-http-client -F rustls-aws-lc
```
L'esempio seguente utilizza `rustls` with `aws-lc` ma funzionerà per qualsiasi provider TLS supportato:
```
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);
}
```