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 for 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 hyperrustls, eaws-lc-rs. Questo client dovrebbe funzionare bene per la maggior parte dei casi d'uso senza configurazioni aggiuntive.

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:

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) 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_clientutilizzo 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 allo standard 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

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'rustlsutilizzo 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.

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

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