As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Definindo configurações de nível HTTP dentro do SDK para Rust AWS
O AWS SDK para Rust fornece a funcionalidade HTTP integrada que é usada pelos AWS service (Serviço da AWS) clientes que você cria em seu código.
Por padrão, o SDK para Rust usa um cliente HTTPS baseado em `hyper`, `rustls` e `aws-lc-rs`. Esse cliente deve funcionar bem na maioria dos casos de uso sem configuração adicional.
+ [https://docs.rs/hyper/latest/hyper/](https://docs.rs/hyper/latest/hyper/)é uma biblioteca HTTP de nível inferior para Rust que pode ser usada com o AWS SDK para Rust para fazer chamadas de serviço de API.
+ [https://github.com/rustls/rustls](https://github.com/rustls/rustls) é uma biblioteca TLS moderna escrita em Rust que tem opções integradas para provedores criptográficos.
+ [https://github.com/aws/aws-lc](https://github.com/aws/aws-lc) é uma biblioteca criptográfica de uso geral com algoritmos necessários para TLS e aplicações comuns.
+ [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs) é um wrapper idiomático da biblioteca `aws-lc` em Rust.
A caixa `aws-smithy-http-client` fornece algumas opções e configurações adicionais se você quiser escolher um provedor TLS ou criptográfico diferente. Para casos de uso mais avançados, recomendamos que você traga sua própria implementação de cliente HTTP ou envie uma solicitação de recurso para consideração.
## Escolher um provedor de TLS alternativo
A caixa `aws-smithy-http-client` fornece alguns provedores alternativos de TLS.
Os seguintes provedores estão disponíveis:
**`rustls` com `aws-lc`**
Um provedor de TLS baseado em [https://github.com/rustls/rustls](https://github.com/rustls/rustls) usa [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs) para criptografia.
Esse é o comportamento HTTP padrão para o SDK para Rust. Se você quiser usar essa opção, você não precisa realizar nenhuma ação adicional em seu código.
**`s2n-tls`**
Um provedor de TLS baseado em [https://github.com/aws/s2n-tls](https://github.com/aws/s2n-tls).
**`rustls` com `aws-lc-fips`**
Um provedor de TLS baseado em [https://github.com/rustls/rustls](https://github.com/rustls/rustls) usa uma versão compatível com FIPS do [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs) para criptografia
**`rustls` com `ring`**
Um provedor de TLS baseado em [https://github.com/rustls/rustls](https://github.com/rustls/rustls) usa [https://github.com/briansmith/ring](https://github.com/briansmith/ring) para criptografia.
### Pré-requisitos
Usar `aws-lc-rs` ou `s2n-tls` exige um compilador C (Clang ou GCC) para compilação. Para algumas plataformas, a compilação também pode exigir CMake. Construir com o recurso “fips” em qualquer plataforma requer CMake e pronto. Para obter mais informações, consulte o repositório [AWS Libcrypto for Rust (`aws-lc-rs`)](https://github.com/aws/aws-lc-rs/blob/main/aws-lc-rs/README.md) e as instruções de compilação.
### Como usar um provedor de TLS alternativo
A caixa `aws-smithy-http-client` fornece opções adicionais de TLS. Para que seus clientes do AWS service (Serviço da AWS) usem um provedor TLS diferente, substitua o `http_client` usando o carregador da caixa `aws_config`. O cliente HTTP é usado para provedores de Serviços da AWS e credenciais.
O exemplo a seguir mostra como usar a o provedor TLS `s2n-tls`. No entanto, uma abordagem semelhante também funciona para outros fornecedores.
Para compilar o código de exemplo, execute o seguinte comando para adicionar dependências ao seu projeto:
```
cargo add aws-smithy-http-client -F s2n-tls
```
Código de exemplo:
```
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 o suporte a FIPS
A caixa `aws-smithy-http-client` oferece uma opção para habilitar uma implementação de criptografia compatível com FIPS. Para que seus AWS service (Serviço da AWS) clientes usem o provedor compatível com FIPS, substitua o `http_client` uso do carregador da caixa. `aws_config` O cliente HTTP é usado tanto para provedores de credenciais Serviços da AWS quanto para provedores de credenciais.
**nota**
O suporte ao FIPS requer dependências adicionais em seu ambiente de compilação. Veja as instruções de [compilação](https://github.com/aws/aws-lc/blob/main/BUILDING.md) da caixa `aws-lc`.
Para compilar o código de exemplo, execute o seguinte comando para adicionar dependências ao seu projeto:
```
cargo add aws-smithy-http-client -F rustls-aws-lc-fips
```
O código de exemplo a seguir habilita o suporte ao 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 a troca de chaves pós-quântica
O provedor TLS padrão é baseado no `rustls` usando `aws-lc-rs`, o que oferece suporte ao algoritmo de troca de chaves pós-quântica `X25519MLKEM768`. Para fazer do `X25519MLKEM768` o algoritmo de maior prioridade, você precisa adicionar o pacote `rustls` à sua caixa e ativar o sinalizador de recursos `prefer-post-quantum`. Caso contrário, ele está disponível, mas não com a prioridade mais alta. Consulte a [Documentação do `rustls`](https://docs.rs/rustls/0.23.23/rustls/manual/_05_defaults/index.html#about-the-post-quantum-secure-key-exchange-x25519mlkem768) para obter mais informações.
**nota**
Esse sinalizador se tornará o padrão em uma versão futura.
## Substituir o resolvedor de DNS
O resolvedor de DNS padrão pode ser substituído configurando o cliente HTTP manualmente.
Para compilar o código de exemplo, execute os seguintes comandos para adicionar dependências ao seu projeto:
```
cargo add aws-smithy-http-client -F rustls-aws-lc
cargo add aws-smithy-runtime-api -F client
```
O código de exemplo a seguir substitui o resolvedor 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);
}
```
**nota**
Por padrão, o Amazon Linux 2023 (AL2023) não armazena em cache o DNS no nível do sistema operacional.
## Personalizar certificados CA raiz
Por padrão, o provedor TLS carrega os certificados raiz nativos do sistema para a plataforma em questão. Para personalizar esse comportamento para carregar um pacote de CA personalizado, você pode configurar um `TlsContext` com o seu próprio `TrustStore`.
Para compilar o código de exemplo, execute os seguintes comandos para adicionar dependências ao seu projeto:
```
cargo add aws-smithy-http-client -F rustls-aws-lc
```
O exemplo a seguir usa `rustls` com `aws-lc`, mas funcionará para qualquer provedor de TLS compatível:
```
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);
}
```