Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Mengkonfigurasi pengaturan tingkat HTTP dalam SDK untuk AWS Rust
<a name="http"></a>

 AWS SDK for Rust Ini menyediakan fungsionalitas HTTP bawaan yang digunakan oleh Layanan AWS klien yang Anda buat dalam kode Anda. 

Secara default, SDK untuk Rust menggunakan klien HTTPS berdasarkan`hyper`,`rustls`, dan`aws-lc-rs`. Klien ini harus bekerja dengan baik untuk sebagian besar kasus penggunaan tanpa konfigurasi tambahan. 
+ [https://docs.rs/hyper/latest/hyper/](https://docs.rs/hyper/latest/hyper/)adalah pustaka HTTP tingkat rendah untuk Rust yang dapat digunakan dengan AWS SDK for Rust untuk melakukan panggilan layanan API.
+ [https://github.com/rustls/rustls](https://github.com/rustls/rustls)adalah perpustakaan TLS modern yang ditulis dalam Rust yang memiliki opsi bawaan untuk penyedia kriptografi.
+ [https://github.com/aws/aws-lc](https://github.com/aws/aws-lc)adalah perpustakaan kriptografi tujuan umum yang berisi algoritma yang diperlukan untuk TLS dan aplikasi umum. 
+ [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs)adalah pembungkus idiomatik di sekitar `aws-lc` perpustakaan di Rust.

`aws-smithy-http-client`Peti menyediakan beberapa opsi dan konfigurasi tambahan jika Anda ingin memilih penyedia TLS atau kriptografi yang berbeda. Untuk kasus penggunaan yang lebih lanjut, Anda dianjurkan untuk membawa implementasi klien HTTP Anda sendiri atau mengajukan permintaan fitur untuk dipertimbangkan.

## Memilih penyedia TLS alternatif
<a name="tlsProviders"></a>

`aws-smithy-http-client`Peti menyediakan beberapa penyedia TLS alternatif.

Penyedia berikut tersedia:

**`rustls` dengan `aws-lc`**  
Penyedia TLS berdasarkan [https://github.com/rustls/rustls](https://github.com/rustls/rustls)penggunaannya [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs)untuk kriptografi.  
Ini adalah perilaku HTTP default untuk SDK untuk Rust. Jika Anda ingin menggunakan opsi ini, Anda tidak perlu mengambil tindakan tambahan apa pun dalam kode Anda.

**`s2n-tls`**  
Penyedia TLS berdasarkan [https://github.com/aws/s2n-tls](https://github.com/aws/s2n-tls).

**`rustls` dengan `aws-lc-fips`**  
Penyedia TLS berdasarkan [https://github.com/rustls/rustls](https://github.com/rustls/rustls)itu menggunakan versi kriptografi yang sesuai dengan FIPS [https://github.com/aws/aws-lc-rs](https://github.com/aws/aws-lc-rs)

**`rustls` dengan `ring`**  
Penyedia TLS berdasarkan [https://github.com/rustls/rustls](https://github.com/rustls/rustls)penggunaannya [https://github.com/briansmith/ring](https://github.com/briansmith/ring)untuk kriptografi.

### Prasyarat
<a name="prereqTls"></a>

Menggunakan `aws-lc-rs` atau `s2n-tls` membutuhkan C Compiler (Clang atau GCC) untuk membangun. Untuk beberapa platform, build mungkin juga memerlukan CMake. Membangun dengan fitur “fips” pada platform apa pun membutuhkan CMake dan Go. Untuk informasi selengkapnya, rujuk repositori [AWS Libcrypto for Rust (`aws-lc-rs`)](https://github.com/aws/aws-lc-rs/blob/main/aws-lc-rs/README.md) dan instruksi build.

### Cara menggunakan penyedia TLS alternatif
<a name="s2nTls"></a>

`aws-smithy-http-client`Peti menyediakan opsi TLS tambahan. Agar Layanan AWS klien Anda menggunakan penyedia TLS yang berbeda, ganti `http_client` menggunakan loader dari peti`aws_config`. Klien HTTP digunakan untuk keduanya Layanan AWS dan penyedia kredensyal.

Contoh berikut menunjukkan cara menggunakan penyedia `s2n-tls` TLS. Namun, pendekatan serupa juga berlaku untuk penyedia lain.

Untuk mengkompilasi kode contoh, jalankan perintah berikut untuk menambahkan dependensi ke proyek Anda:

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

Kode contoh:

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

## Mengaktifkan dukungan FIPS
<a name="fipsTls"></a>

`aws-smithy-http-client`Peti menyediakan opsi untuk mengaktifkan implementasi kripto yang sesuai dengan FIPS. Agar Layanan AWS klien Anda dapat menggunakan penyedia yang sesuai dengan FIPS, ganti `http_client` penggunaan loader dari peti. `aws_config` Klien HTTP digunakan untuk keduanya Layanan AWS dan penyedia kredensyal.

**catatan**  
Dukungan FIPS memerlukan dependensi tambahan di lingkungan build Anda. Lihat instruksi [pembuatan](https://github.com/aws/aws-lc/blob/main/BUILDING.md) untuk `aws-lc` peti.

Untuk mengkompilasi kode contoh, jalankan perintah berikut untuk menambahkan dependensi ke proyek Anda:

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

Kode contoh berikut memungkinkan dukungan 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);
}
```

## Memprioritaskan pertukaran kunci pasca-kuantum
<a name="quantumTls"></a>

Penyedia TLS default didasarkan pada `rustls` penggunaan `aws-lc-rs` yang mendukung algoritma pertukaran kunci `X25519MLKEM768` pasca-kuantum. Untuk membuat `X25519MLKEM768` algoritma prioritas tertinggi, Anda perlu menambahkan `rustls` paket ke peti Anda dan mengaktifkan flag `prefer-post-quantum` fitur. Kalau tidak, itu tersedia tetapi bukan prioritas tertinggi. Lihat `rustls` [dokumentasi](https://docs.rs/rustls/0.23.23/rustls/manual/_05_defaults/index.html#about-the-post-quantum-secure-key-exchange-x25519mlkem768) untuk informasi lebih lanjut. 

**catatan**  
Ini akan menjadi default dalam rilis future.

## Mengganti DNS Resolver
<a name="overrideDns"></a>

 DNS resolver default dapat diganti dengan mengkonfigurasi klien HTTP secara manual. 

Untuk mengkompilasi kode contoh, jalankan perintah berikut untuk menambahkan dependensi ke proyek Anda:

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

Contoh kode berikut mengesampingkan 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);
}
```

**catatan**  
Secara default, Amazon Linux 2023 (AL2023) tidak menyimpan DNS di tingkat sistem operasi.

## Menyesuaikan sertifikat CA root
<a name="customizeCertificatesTls"></a>

Secara default, penyedia TLS memuat sertifikat root asli sistem untuk platform yang diberikan. Untuk menyesuaikan perilaku ini untuk memuat bundel CA kustom, Anda dapat mengonfigurasi `TlsContext` dengan paket Anda sendiri`TrustStore`. 

Untuk mengkompilasi kode contoh, jalankan perintah berikut untuk menambahkan dependensi ke proyek Anda:

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

Contoh berikut menggunakan `rustls` dengan `aws-lc` tetapi akan berfungsi untuk penyedia TLS yang didukung: 

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