HTTP

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

AWS SDK para Rust Proporciona una funcionalidad HTTP integrada que utilizan los Servicio de AWS clientes que cree en su código.

De forma predeterminada, el SDK de Rust usa un cliente HTTPS basado en hyperrustls, yaws-lc-rs. Este cliente debería funcionar bien en la mayoría de los casos de uso sin necesidad de configuración adicional.

La aws-smithy-http-client caja proporciona algunas opciones y configuraciones adicionales si desea elegir un proveedor de TLS o criptográfico diferente. Para casos de uso más avanzados, le recomendamos que traiga su propia implementación de cliente HTTP o que presente una solicitud de funcionalidad para su consideración.

Elegir un proveedor de TLS alternativo

La aws-smithy-http-client caja proporciona algunos proveedores de TLS alternativos.

Están disponibles los siguientes proveedores:

Requisitos previos

Utiliza aws-lc-rs o s2n-tls requiere un compilador de C (Clang o GCC) para compilarlo. Para algunas plataformas, la compilación también puede requerir. CMake Para crear con la función «fips» en cualquier plataforma se necesita tener CMake listo. Para obtener más información, consulte el repositorio y las instrucciones de compilación de AWS Libcrypto for Rust (aws-lc-rs).

Cómo utilizar un proveedor de TLS alternativo

La aws-smithy-http-client caja proporciona opciones de TLS adicionales. Para que sus Servicio de AWS clientes usen un proveedor de TLS diferente, anule el http_client uso del cargador desde la caja. aws_config El cliente HTTP se utiliza tanto para los proveedores de credenciales como para Servicios de AWS los proveedores.

El siguiente ejemplo muestra cómo utilizar el proveedor de s2n-tls TLS. Sin embargo, un enfoque similar también funciona para otros proveedores.

Para compilar el código de ejemplo, ejecuta el siguiente comando para añadir dependencias a tu proyecto:

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

Código de ejemplo:

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

Habilitar la compatibilidad con FIPS

La aws-smithy-http-client caja ofrece una opción para permitir una implementación criptográfica compatible con FIPS. Para que sus Servicio de AWS clientes utilicen un proveedor compatible con FIPS, anule el uso del cargador desde la caja. http_client aws_config El cliente HTTP se utiliza tanto para los proveedores de credenciales como para los proveedores. Servicios de AWS

Para compilar el código de ejemplo, ejecuta el siguiente comando para añadir dependencias a tu proyecto:

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

El siguiente código de ejemplo habilita la compatibilidad con 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);
}

Priorizar el intercambio de claves poscuántico

El proveedor de TLS predeterminado se basa en el rustls uso, aws-lc-rs que es compatible con el algoritmo de intercambio de claves X25519MLKEM768 poscuánticas. Para crear X25519MLKEM768 el algoritmo de mayor prioridad, debes añadir el rustls paquete a tu caja y activar la prefer-post-quantum marca de función. De lo contrario, está disponible pero no es de máxima prioridad. Consulte la rustls documentación para obtener más información.

Anular el solucionador de DNS

El solucionador de DNS predeterminado se puede anular configurando el cliente HTTP manualmente.

Para compilar el código de ejemplo, ejecuta los siguientes comandos para añadir dependencias a tu proyecto:

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

El siguiente código de ejemplo anula la resolución de 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);
}

Personalización de los certificados de CA raíz

De forma predeterminada, el proveedor de TLS carga los certificados raíz nativos del sistema para la plataforma en cuestión. Para personalizar este comportamiento y cargar un paquete de CA personalizado, puede configurar uno TlsContext con el suyo propio. TrustStore

Para compilar el código de ejemplo, ejecute los siguientes comandos para añadir dependencias a su proyecto:

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

En el siguiente ejemplo, se utiliza rustls con cualquier proveedor de TLS compatible, aws-lc pero funcionará con él:

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