Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Mengkonfigurasi klien layanan di AWS SDK untuk Rust
Untuk mengakses secara terprogram Layanan AWS, AWS SDK untuk Rust menggunakan struct klien untuk masing-masing. Layanan AWS Misalnya, jika aplikasi Anda perlu mengakses Amazon EC2, aplikasi Anda akan membuat struct EC2 klien Amazon untuk berinteraksi dengan layanan tersebut. Anda kemudian menggunakan klien layanan untuk membuat permintaan untuk itu Layanan AWS.
Untuk membuat permintaan ke Layanan AWS, Anda harus terlebih dahulu membuat klien layanan. Untuk setiap penggunaan kode Layanan AWS Anda, ia memiliki peti sendiri dan tipe khusus untuk berinteraksi dengannya. Klien mengekspos satu metode untuk setiap operasi API yang diekspos oleh layanan.
Ada banyak cara alternatif untuk mengonfigurasi perilaku SDK, tetapi pada akhirnya semuanya berkaitan dengan perilaku klien layanan. Konfigurasi apa pun tidak berpengaruh sampai klien layanan yang dibuat darinya digunakan.
Anda harus menetapkan bagaimana kode Anda mengautentikasi dengan AWS ketika Anda mengembangkan dengan Layanan AWS. Anda juga harus mengatur yang ingin Wilayah AWS Anda gunakan.
[Panduan Referensi AWS SDKs and Tools](https://docs.aws.amazon.com/sdkref/latest/guide/) juga berisi pengaturan, fitur, dan konsep dasar lainnya yang umum di antara banyak. AWS SDKs
**Topics**
+ [Konfigurasi klien secara eksternal](config-external.md)
+ [Konfigurasi klien dalam kode](config-code.md)
+ [Wilayah AWS](region.md)
+ [Penyedia kredensi](credproviders.md)
+ [Versi perilaku](behavior-versions.md)
+ [Percobaan ulang](retries.md)
+ [Timeout](timeouts.md)
+ [Observabilitas](observability.md)
+ [Titik akhir klien](endpoints.md)
+ [Mengesampingkan konfigurasi operasi](peroperation.md)
+ [HTTP](http.md)
+ [Pencegat](interceptors.md)
# Mengkonfigurasi klien AWS SDK for Rust layanan secara eksternal
Banyak pengaturan konfigurasi dapat ditangani di luar kode Anda. Ketika konfigurasi ditangani secara eksternal, konfigurasi diterapkan di semua aplikasi Anda. Sebagian besar pengaturan konfigurasi dapat diatur sebagai variabel lingkungan atau dalam AWS `config` file bersama yang terpisah. `config`File bersama dapat mempertahankan set pengaturan terpisah, yang disebut profil, untuk menyediakan konfigurasi yang berbeda untuk lingkungan atau pengujian yang berbeda.
Variabel lingkungan dan pengaturan `config` file bersama distandarisasi dan dibagikan di seluruh AWS SDKs dan alat untuk mendukung fungsionalitas yang konsisten di berbagai bahasa pemrograman dan aplikasi.
Lihat *Panduan Referensi Alat AWS SDKs dan* untuk mempelajari tentang mengonfigurasi aplikasi Anda melalui metode ini, ditambah detail pada setiap setelan lintas sdk. Untuk melihat semua pengaturan yang dapat diselesaikan SDK dari variabel lingkungan atau file konfigurasi, lihat [referensi Pengaturan di Panduan Referensi](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html) *Alat AWS SDKs dan Alat*.
Untuk membuat permintaan ke Layanan AWS, pertama-tama Anda membuat instance klien untuk layanan itu. Anda dapat mengonfigurasi pengaturan umum untuk klien layanan seperti batas waktu, klien HTTP, dan konfigurasi coba lagi.
Setiap klien layanan membutuhkan Wilayah AWS dan penyedia kredensi. SDK menggunakan nilai-nilai ini untuk mengirim permintaan ke Wilayah yang benar untuk sumber daya Anda dan untuk menandatangani permintaan dengan kredenal yang benar. Anda dapat menentukan nilai-nilai ini secara terprogram dalam kode atau membuatnya dimuat secara otomatis dari lingkungan.
SDK memiliki serangkaian tempat (atau sumber) yang diperiksa untuk menemukan nilai untuk pengaturan konfigurasi.
1. Pengaturan eksplisit apa pun yang disetel dalam kode atau pada klien layanan itu sendiri lebih diutamakan daripada yang lain.
1. Variabel-variabel lingkungan
+ Untuk detail tentang pengaturan variabel lingkungan, lihat [variabel lingkungan](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html) di *Panduan Referensi Alat AWS SDKs dan Alat*.
+ Perhatikan bahwa Anda dapat mengonfigurasi variabel lingkungan untuk shell pada tingkat cakupan yang berbeda: seluruh sistem, seluruh pengguna, dan untuk sesi terminal tertentu.
1. Berbagi `config` dan `credentials` file
+ Untuk detail tentang pengaturan file-file ini, lihat [Dibagikan `config` dan `credentials` file](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) di *Panduan Referensi Alat AWS SDKs dan Alat*.
1. Setiap nilai default yang disediakan oleh kode sumber SDK itu sendiri digunakan terakhir.
+ Beberapa properti, seperti Region, tidak memiliki default. Anda harus menentukannya secara eksplisit dalam kode, dalam pengaturan lingkungan, atau dalam file bersama`config`. Jika SDK tidak dapat menyelesaikan konfigurasi yang diperlukan, permintaan API dapat gagal saat runtime.
# Mengkonfigurasi AWS SDK untuk klien layanan Rust dalam kode
Ketika konfigurasi ditangani langsung dalam kode, lingkup konfigurasi terbatas pada aplikasi yang menggunakan kode itu. Di dalam aplikasi itu, ada opsi untuk konfigurasi global semua klien layanan, konfigurasi untuk semua klien dari Layanan AWS jenis tertentu, atau konfigurasi ke instance klien layanan tertentu.
Untuk membuat permintaan ke Layanan AWS, pertama-tama Anda membuat instance klien untuk layanan itu. Anda dapat mengonfigurasi pengaturan umum untuk klien layanan seperti batas waktu, klien HTTP, dan konfigurasi coba lagi.
Setiap klien layanan membutuhkan Wilayah AWS dan penyedia kredensi. SDK menggunakan nilai-nilai ini untuk mengirim permintaan ke Wilayah yang benar untuk sumber daya Anda dan untuk menandatangani permintaan dengan kredenal yang benar. Anda dapat menentukan nilai-nilai ini secara terprogram dalam kode atau membuatnya dimuat secara otomatis dari lingkungan.
**catatan**
Pelanggan layanan bisa mahal untuk dibangun dan umumnya dimaksudkan untuk dibagikan. Untuk memfasilitasi ini, semua `Client` struct menerapkan`Clone`.
## Konfigurasikan klien dari lingkungan
Untuk membuat klien dengan konfigurasi bersumber lingkungan, gunakan metode statis dari peti: `aws-config`
```
let config = aws_config::defaults(BehaviorVersion::latest())
.load()
.await;
let s3 = aws_sdk_s3::Client::new(&config);
```
Membuat klien dengan cara ini berguna saat berjalan di Amazon Elastic Compute Cloud AWS Lambda,, atau konteks lain di mana konfigurasi klien layanan tersedia langsung dari lingkungan. Ini memisahkan kode Anda dari lingkungan tempat ia berjalan dan membuatnya lebih mudah untuk menerapkan aplikasi Anda ke beberapa Wilayah AWS tanpa mengubah kode.
Anda dapat secara eksplisit mengganti properti tertentu. Konfigurasi eksplisit lebih diutamakan daripada konfigurasi yang diselesaikan dari lingkungan eksekusi. Contoh berikut memuat konfigurasi dari lingkungan, tetapi secara eksplisit mengesampingkan: Wilayah AWS
```
let config = aws_config::defaults(BehaviorVersion::latest())
.region("us-east-1")
.load()
.await;
let s3 = aws_sdk_s3::Client::new(&config);
```
**catatan**
Tidak semua nilai konfigurasi bersumber oleh klien pada waktu pembuatan. Pengaturan terkait kredensil, seperti kunci akses sementara dan konfigurasi IAM Identity Center, diakses oleh lapisan penyedia kredensi ketika klien digunakan untuk membuat permintaan.
Kode yang `BehaviorVersion::latest()` ditampilkan dalam contoh sebelumnya menunjukkan versi SDK yang akan digunakan untuk default. `BehaviorVersion::latest()`sesuai untuk sebagian besar kasus. Lihat perinciannya di [Menggunakan versi perilaku di AWS SDK for Rust](behavior-versions.md).
## Gunakan pola pembangun untuk pengaturan khusus layanan
Ada beberapa opsi yang hanya dapat dikonfigurasi pada jenis klien layanan tertentu. Namun, paling sering, Anda masih ingin memuat sebagian besar konfigurasi dari lingkungan, dan kemudian secara khusus menambahkan opsi tambahan. Pola pembangun adalah pola umum di dalam AWS SDK for Rust peti. Pertama-tama Anda memuat konfigurasi umum menggunakan`aws_config::defaults`, kemudian menggunakan `from` metode untuk memuat konfigurasi itu ke pembuat untuk layanan yang Anda kerjakan. Anda kemudian dapat mengatur nilai konfigurasi unik apa pun untuk layanan dan panggilan tersebut`build`. Terakhir, klien dibuat dari konfigurasi termodfikasi ini.
```
// Call a static method on aws-config that sources default config values.
let config = aws_config::defaults(BehaviorVersion::latest())
.load()
.await;
// Use the Builder for S3 to create service-specific config from the default config.
let s3_config = aws_sdk_s3::config::Builder::from(&config)
.accelerate(true) // Set an S3-only configuration option
.build();
// Create the client.
let s3 = aws_sdk_s3::Client::from_conf(s3_config);
```
Salah satu cara untuk menemukan metode tambahan yang tersedia untuk jenis klien layanan tertentu adalah dengan menggunakan dokumentasi API, seperti untuk [https://docs.rs/aws-sdk-s3/latest/aws_sdk_s3/config/struct.Builder.html](https://docs.rs/aws-sdk-s3/latest/aws_sdk_s3/config/struct.Builder.html).
## Konfigurasi klien eksplisit tingkat lanjut
Untuk mengonfigurasi klien layanan dengan nilai tertentu alih-alih memuat konfigurasi dari lingkungan, Anda dapat menentukannya pada `Config` pembuat klien seperti yang ditunjukkan dalam berikut ini:
```
let conf = aws_sdk_s3::Config::builder()
.region("us-east-1")
.endpoint_resolver(my_endpoint_resolver)
.build();
let s3 = aws_sdk_s3::Client::from_conf(conf);
```
Saat Anda membuat konfigurasi layanan dengan`aws_sdk_s3::Config::builder()`, *tidak ada konfigurasi default yang dimuat*. Default hanya dimuat saat membuat konfigurasi berdasarkan. `aws_config::defaults`
Ada beberapa opsi yang hanya dapat dikonfigurasi pada jenis klien layanan tertentu. Contoh sebelumnya menunjukkan contoh ini dengan menggunakan `endpoint_resolver` fungsi pada klien Amazon S3.
# Mengatur Wilayah AWS untuk AWS SDK for Rust
Anda dapat mengakses Layanan AWS yang beroperasi di wilayah geografis tertentu dengan menggunakan Wilayah AWS. Ini dapat berguna baik untuk redundansi dan untuk menjaga data dan aplikasi Anda berjalan dekat dengan tempat Anda dan pengguna Anda mengaksesnya. Untuk informasi selengkapnya tentang cara Wilayah digunakan, lihat [Wilayah AWS](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html)di *Panduan Referensi Alat AWS SDKs dan Alat*.
**penting**
Sebagian besar sumber daya berada di tempat tertentu Wilayah AWS dan Anda harus menyediakan Wilayah yang benar untuk sumber daya saat menggunakan SDK.
Anda harus menetapkan default Wilayah AWS untuk SDK untuk Rust untuk digunakan untuk AWS permintaan. Default ini digunakan untuk setiap panggilan metode layanan SDK yang tidak ditentukan dengan Region.
Untuk contoh tentang cara mengatur wilayah default melalui AWS `config` file bersama atau variabel lingkungan, lihat [Wilayah AWS](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html)di *Panduan Referensi Alat AWS SDKs dan*.
## Wilayah AWS rantai penyedia
Proses pencarian berikut digunakan saat memuat konfigurasi klien layanan dari lingkungan eksekusi. Nilai pertama yang ditemukan SDK set digunakan dalam konfigurasi klien. Untuk informasi selengkapnya tentang membuat klien layanan, lihat[Konfigurasikan klien dari lingkungan](config-code.md#configure-a-client-from-the-environment).
1. Setiap Wilayah eksplisit diatur secara terprogram.
1. Variabel `AWS_REGION` lingkungan diperiksa.
+ Jika Anda menggunakan AWS Lambda layanan, variabel lingkungan ini diatur secara otomatis oleh AWS Lambda wadah.
1. `region`Properti dalam AWS `config` file bersama dicentang.
+ Variabel `AWS_CONFIG_FILE` lingkungan dapat digunakan untuk mengubah lokasi `config` file bersama. Untuk mempelajari lebih lanjut tentang tempat penyimpanan file ini, lihat [Lokasi `credentials` file bersama `config` dan](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html) di *Panduan Referensi Alat AWS SDKs dan*.
+ Variabel `AWS_PROFILE` lingkungan dapat digunakan untuk memilih profil bernama bukan default. Untuk mempelajari lebih lanjut tentang mengonfigurasi profil yang berbeda, lihat [Dibagikan `config` dan `credentials` file](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) di *Panduan Referensi Alat AWS SDKs dan Alat*.
1. SDK mencoba menggunakan Layanan Metadata Instans Amazon EC2 untuk menentukan Wilayah instans Amazon EC2 yang sedang berjalan.
+ AWS SDK for Rust Satu-satunya dukungan IMDSv2.
Secara otomatis `RegionProviderChain` digunakan tanpa kode tambahan saat membuat konfigurasi dasar untuk digunakan dengan klien layanan:
```
let config = aws_config::defaults(BehaviorVersion::latest())
.load()
.await;
```
## Mengatur kode Wilayah AWS dalam
### Secara eksplisit mengatur Wilayah dalam kode
Gunakan `Region::new()` langsung dalam konfigurasi Anda ketika Anda ingin secara eksplisit mengatur Wilayah.
Rantai penyedia Wilayah tidak digunakan - rantai ini tidak memeriksa lingkungan, `config` file bersama, atau Layanan Metadata Instans Amazon EC2.
```
use aws_config::{defaults, BehaviorVersion};
use aws_sdk_s3::config::Region;
#[tokio::main]
async fn main() {
let config = defaults(BehaviorVersion::latest())
.region(Region::new("us-west-2"))
.load()
.await;
println!("Using Region: {}", config.region().unwrap());
}
```
Pastikan Anda memasukkan string yang valid untuk Wilayah AWS; nilai yang diberikan tidak divalidasi.
### Menyesuaikan `RegionProviderChain`
Gunakan [Wilayah AWS rantai penyedia](#region-provider-chain) saat Anda ingin menyuntikkan Wilayah secara kondisional, menggantinya, atau menyesuaikan rantai resolusi.
```
use aws_config::{defaults, BehaviorVersion};
use aws_config::meta::region::RegionProviderChain;
use aws_sdk_s3::config::Region;
use std::env;
#[tokio::main]
async fn main() {
let region_provider = RegionProviderChain::first_try(env::var("CUSTOM_REGION").ok().map(Region::new))
.or_default_provider()
.or_else(Region::new("us-east-2"));
let config = aws_config::defaults(BehaviorVersion::latest())
.region(region_provider)
.load()
.await;
println!("Using Region: {}", config.region().unwrap());
}
```
Konfigurasi sebelumnya akan:
1. Pertama lihat apakah ada string yang ditetapkan dalam variabel `CUSTOM_REGION` lingkungan.
1. Jika itu tidak tersedia, kembali ke rantai penyedia Wilayah default.
1. Jika gagal, gunakan “us-east-2" sebagai fallback terakhir.
# Menggunakan AWS SDK untuk penyedia kredensi Rust
Semua permintaan AWS harus ditandatangani secara kriptografi dengan menggunakan kredensil yang dikeluarkan oleh. AWS Saat runtime, SDK mengambil nilai konfigurasi untuk kredensil dengan memeriksa beberapa lokasi.
Jika konfigurasi yang diambil menyertakan [setelan akses masuk AWS IAM Identity Center tunggal](credentials.md), SDK bekerja dengan Pusat Identitas IAM untuk mengambil kredenal sementara yang digunakan untuk membuat permintaan. Layanan AWS
Jika konfigurasi yang diambil menyertakan [kredensil sementara](https://docs.aws.amazon.com/sdkref/latest/guide/access-temp-idc.html), SDK menggunakannya untuk melakukan panggilan. Layanan AWS Kredensi sementara terdiri dari kunci akses dan token sesi.
Otentikasi dengan AWS dapat ditangani di luar basis kode Anda. Banyak metode otentikasi dapat dideteksi, digunakan, dan disegarkan secara otomatis oleh SDK menggunakan rantai penyedia kredensi.
Untuk opsi terpandu untuk memulai AWS autentikasi untuk proyek Anda, lihat [Otentikasi dan akses di Panduan](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) *Referensi Alat AWS SDKs dan Alat*.
## Rantai penyedia kredensi
Jika Anda tidak secara eksplisit menentukan penyedia kredensi saat membuat klien, SDK for Rust menggunakan rantai penyedia kredensi yang memeriksa serangkaian tempat di mana Anda dapat menyediakan kredensil. Setelah SDK menemukan kredensil di salah satu lokasi ini, pencarian akan berhenti. Untuk detail tentang membangun klien, lihat[Mengkonfigurasi AWS SDK untuk klien layanan Rust dalam kode](config-code.md).
Contoh berikut tidak menentukan penyedia kredensi dalam kode. SDK menggunakan rantai penyedia kredensi untuk mendeteksi otentikasi yang telah disiapkan di lingkungan hosting, dan menggunakan otentikasi tersebut untuk panggilan ke. Layanan AWS
```
let config = aws_config::defaults(BehaviorVersion::latest()).load().await;
let s3 = aws_sdk_s3::Client::new(&config);
```
### Urutan pengambilan kredensi
Rantai penyedia kredensi menelusuri kredensil menggunakan urutan yang telah ditentukan berikut ini:
1. **Akses variabel lingkungan kunci**
SDK mencoba memuat kredensil dari variabel `AWS_ACCESS_KEY_ID` dan`AWS_SECRET_ACCESS_KEY`, dan `AWS_SESSION_TOKEN` lingkungan.
1. **Yang dibagikan AWS `config` dan `credentials` file**
SDK mencoba memuat kredensil dari `[default]` profil di file bersama AWS `config` dan file. `credentials` Anda dapat menggunakan variabel `AWS_PROFILE` lingkungan untuk memilih profil bernama yang ingin dimuat SDK alih-alih menggunakan`[default]`. `credentials`File `config` dan dibagikan oleh berbagai AWS SDKs alat. Untuk informasi selengkapnya tentang file-file ini, lihat [Dibagikan `config` dan `credentials` file](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) di *Panduan Referensi Alat AWS SDKs dan Alat*. Untuk informasi selengkapnya tentang penyedia standar yang dapat Anda tentukan di profil, lihat [AWS SDKs dan Penyedia kredensi standar Alat](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html).
1. **AWS STS identitas web**
Saat membuat aplikasi seluler atau aplikasi web berbasis klien yang memerlukan akses ke AWS, AWS Security Token Service (AWS STS) mengembalikan satu set kredensi keamanan sementara untuk pengguna federasi yang diautentikasi melalui penyedia identitas publik (iDP).
+ Saat Anda menentukan ini di profil, SDK atau alat akan mencoba mengambil kredensi sementara menggunakan metode API. AWS STS `AssumeRoleWithWebIdentity` Untuk detail tentang metode ini, lihat [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)di *Referensi AWS Security Token Service API*.
+ Untuk panduan tentang mengonfigurasi penyedia ini, lihat Menggabungkan [dengan identitas web atau OpenID Connect](https://docs.aws.amazon.com/sdkref/latest/guide/access-assume-role.html#webidentity) di Panduan Referensi Alat *AWS SDKs dan* OpenID.
+ Untuk detail tentang properti konfigurasi SDK untuk penyedia ini, lihat [Mengasumsikan penyedia kredensi peran di Panduan](https://docs.aws.amazon.com/sdkref/latest/guide/feature-assume-role-credentials.html) *Referensi Alat AWS SDKs dan*.
1. **Kredensi wadah Amazon ECS dan Amazon EKS**
Tugas Amazon Elastic Container Service dan akun layanan Kubernetes Anda dapat memiliki peran IAM yang terkait dengannya. Izin yang diberikan dalam peran IAM diasumsikan oleh kontainer yang berjalan di tugas atau kontainer pod. Peran ini memungkinkan SDK Anda untuk kode aplikasi Rust (pada penampung) untuk menggunakan kode aplikasi lainnya Layanan AWS.
SDK mencoba untuk mengambil kredensi dari `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` atau variabel `AWS_CONTAINER_CREDENTIALS_FULL_URI` lingkungan, yang dapat diatur secara otomatis oleh Amazon ECS dan Amazon EKS.
+ Untuk detail tentang pengaturan peran ini untuk Amazon ECS, lihat [peran IAM tugas Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) di Panduan Pengembang *Layanan Kontainer Elastis Amazon*.
+ Untuk informasi penyiapan Amazon EKS, lihat [Menyiapkan Agen Identitas Pod Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-agent-setup.html) di **Panduan Pengguna Amazon EKS**.
+ Untuk detail tentang properti konfigurasi SDK untuk penyedia ini, lihat Penyedia [kredensi kontainer di Panduan](https://docs.aws.amazon.com/sdkref/latest/guide/feature-container-credentials.html) *Referensi Alat AWS SDKs dan Alat*.
1. **Layanan Metadata Instans Amazon EC2**
Buat peran IAM dan lampirkan ke instance Anda. Aplikasi SDK for Rust pada instance mencoba mengambil kredensil yang disediakan oleh peran dari metadata instance.
+ SDK untuk Rust hanya mendukung [IMDSv2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html).
+ *Untuk detail tentang pengaturan peran ini dan menggunakan metadata, [peran IAM untuk Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) dan [Bekerja dengan metadata instans](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) di Panduan Pengguna Amazon EC2.*
+ Untuk detail tentang properti konfigurasi SDK untuk penyedia ini, lihat Penyedia [kredenal IMDS](https://docs.aws.amazon.com/sdkref/latest/guide/feature-imds-credentials.html) di Panduan Referensi *Alat AWS SDKs dan Alat*.
1. Jika kredensil masih belum diselesaikan pada saat ini, operasi panics dengan kesalahan.
Untuk detail tentang setelan konfigurasi penyedia AWS kredensi, lihat [Penyedia kredensi terstandarisasi](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html) di *referensi Pengaturan *AWS SDKs dan* Panduan Referensi* Alat.
## Penyedia kredensi eksplisit
Alih-alih mengandalkan rantai penyedia kredensi untuk mendeteksi metode autentikasi, Anda dapat menentukan penyedia kredensi tertentu yang harus digunakan SDK. Saat memuat konfigurasi umum menggunakan`aws_config::defaults`, Anda dapat menentukan penyedia kredensi khusus seperti yang ditunjukkan pada berikut ini:
```
let config = aws_config::defaults(BehaviorVersion::latest())
.credentials_provider(MyCredentialsProvider::new())
.load()
.await;
```
Anda dapat menerapkan penyedia kredensi Anda sendiri dengan menerapkan [https://docs.rs/aws-credential-types/latest/aws_credential_types/provider/trait.ProvideCredentials.html](https://docs.rs/aws-credential-types/latest/aws_credential_types/provider/trait.ProvideCredentials.html)sifat tersebut.
## Caching identitas
SDK akan menyimpan kredensil dan jenis identitas lainnya seperti token SSO. Secara default, SDK menggunakan implementasi cache malas yang memuat kredensil pada permintaan pertama, menyimpannya dalam cache, dan kemudian mencoba untuk menyegarkannya selama permintaan lain saat hampir kedaluwarsa. Klien yang dibuat dari yang sama `SdkConfig` akan berbagi [https://docs.rs/aws-smithy-runtime/latest/aws_smithy_runtime/client/identity/struct.IdentityCache.html](https://docs.rs/aws-smithy-runtime/latest/aws_smithy_runtime/client/identity/struct.IdentityCache.html).
# Menggunakan versi perilaku di AWS SDK for Rust
AWS SDK for Rust pengembang mengharapkan dan mengandalkan perilaku yang kuat dan dapat diprediksi yang ditawarkan bahasa dan perpustakaan utamanya. Untuk membantu pengembang yang menggunakan SDK for Rust mendapatkan perilaku yang diharapkan, konfigurasi klien diperlukan untuk menyertakan file. `BehaviorVersion` `BehaviorVersion`Menentukan versi SDK yang defaultnya diharapkan. Hal ini memungkinkan SDK berkembang dari waktu ke waktu, mengubah praktik terbaik agar sesuai dengan standar baru dan mendukung fitur baru tanpa dampak buruk yang tidak terduga pada perilaku aplikasi Anda.
**Awas**
Jika Anda mencoba mengonfigurasi SDK atau membuat klien tanpa secara eksplisit menentukan a`BehaviorVersion`, konstruktor akan melakukannya. panic
Misalnya, bayangkan bahwa versi baru SDK dirilis dengan kebijakan coba ulang default yang baru. Jika aplikasi Anda menggunakan `BehaviorVersion` pencocokan versi SDK sebelumnya, maka konfigurasi sebelumnya akan digunakan sebagai ganti konfigurasi default yang baru.
Setiap kali versi perilaku baru SDK untuk Rust dirilis, versi sebelumnya `BehaviorVersion` ditandai dengan `deprecated` atribut SDK for Rust dan versi baru ditambahkan. Hal ini menyebabkan peringatan terjadi pada waktu kompilasi, tetapi sebaliknya, biarkan build berlanjut seperti biasa. `BehaviorVersion::latest()`juga diperbarui untuk menunjukkan perilaku default versi baru.
**catatan**
Jika kode Anda tidak bergantung pada karakteristik perilaku yang sangat spesifik, Anda harus menggunakan `BehaviorVersion::latest()` dalam kode atau menggunakan tanda fitur `behavior-version-latest` dalam `Cargo.toml` file. Jika Anda menulis kode yang sensitif terhadap latensi, atau yang menyetel perilaku Rust SDK, pertimbangkan `BehaviorVersion` untuk menyematkan ke versi utama tertentu.
## Setel versi perilaku di `Cargo.toml`
Anda dapat menentukan versi perilaku untuk SDK dan modul individual, seperti `aws-sdk-s3` atau`aws-sdk-iam`, dengan menyertakan tanda fitur yang sesuai dalam `Cargo.toml` file. Saat ini, hanya `latest` versi SDK yang didukung di`Cargo.toml`:
```
[dependencies]
aws-config = { version = "1", features = ["behavior-version-latest"] }
aws-sdk-s3 = { version = "1", features = ["behavior-version-latest"] }
```
## Mengatur versi perilaku dalam kode
Kode Anda dapat mengubah versi perilaku sesuai kebutuhan dengan menentukannya saat mengonfigurasi SDK atau klien:
```
let config = aws_config::load_defaults(BehaviorVersion::v2023_11_09()).await;
```
Contoh ini membuat konfigurasi yang menggunakan lingkungan untuk mengkonfigurasi SDK tetapi menetapkan `BehaviorVersion` ke`v2023_11_09()`.
# Mengonfigurasi percobaan ulang di AWS SDK untuk Rust
AWS SDK untuk Rust menyediakan perilaku coba ulang default untuk permintaan layanan dan opsi konfigurasi yang dapat disesuaikan. Panggilan untuk Layanan AWS sesekali mengembalikan pengecualian yang tidak terduga. Jenis kesalahan tertentu, seperti kesalahan pelambatan atau transien, mungkin berhasil jika panggilan dicoba ulang.
Perilaku coba lagi dapat dikonfigurasi secara global menggunakan variabel lingkungan atau pengaturan dalam AWS `config` file bersama. Untuk informasi tentang pendekatan ini, lihat [Coba lagi perilaku](https://docs.aws.amazon.com/sdkref/latest/guide/feature-retry-behavior.html) di *Panduan Referensi Alat AWS SDKs dan Alat*. Ini juga mencakup informasi rinci tentang implementasi strategi coba lagi dan bagaimana memilih satu di atas yang lain.
Atau, opsi ini juga dapat dikonfigurasi dalam kode Anda, seperti yang ditunjukkan pada bagian berikut.
## Konfigurasi coba lagi default
Setiap klien layanan default ke konfigurasi strategi `standard` coba lagi yang disediakan melalui struct. [https://docs.rs/aws-smithy-types/latest/aws_smithy_types/retry/struct.RetryConfig.html](https://docs.rs/aws-smithy-types/latest/aws_smithy_types/retry/struct.RetryConfig.html) Secara default, panggilan akan dicoba tiga kali (*upaya awal, ditambah dua percobaan ulang*). Selain itu, setiap percobaan ulang akan ditunda oleh durasi acak yang pendek untuk menghindari badai coba lagi. Konvensi ini cocok untuk sebagian besar kasus penggunaan tetapi mungkin tidak cocok dalam keadaan tertentu seperti sistem throughput tinggi.
Hanya beberapa jenis kesalahan yang dianggap dapat dicoba ulang oleh. SDKs Contoh kesalahan yang dapat dicoba ulang adalah:
+ batas waktu soket
+ pelambatan sisi layanan
+ kesalahan layanan sementara seperti respons HTTP 5XX
Contoh-contoh berikut **tidak dianggap dapat** dicoba kembali:
+ Parameter hilang atau tidak valid
+ kesalahan otentikasi/keamanan
+ pengecualian salah konfigurasi
Anda dapat menyesuaikan strategi `standard` coba lagi dengan mengatur upaya maksimum, penundaan, dan konfigurasi backoff.
## Upaya Maksimum
Anda dapat menyesuaikan upaya maksimum dalam kode Anda dengan memberikan modifikasi [https://docs.rs/aws-smithy-types/latest/aws_smithy_types/retry/struct.RetryConfig.html](https://docs.rs/aws-smithy-types/latest/aws_smithy_types/retry/struct.RetryConfig.html)ke: `aws_config::defaults`
```
const CUSTOM_MAX_ATTEMPTS: u32 = 5;
let retry_config = RetryConfig::standard()
// Set max attempts. When max_attempts is 1, there are no retries.
// This value MUST be greater than zero.
// Defaults to 3.
.with_max_attempts(CUSTOM_MAX_ATTEMPTS);
let config = aws_config::defaults(BehaviorVersion::latest())
.retry_config(retry_config)
.load()
.await;
```
## Penundaan dan backoff
Jika percobaan ulang diperlukan, strategi coba lagi default menunggu sebelum melakukan upaya berikutnya. Penundaan untuk percobaan ulang pertama kecil tetapi tumbuh secara eksponensial untuk percobaan ulang nanti. Jumlah penundaan maksimum dibatasi sehingga tidak tumbuh terlalu besar.
Jitter acak diterapkan pada penundaan di antara semua upaya. Jitter membantu mengurangi efek armada besar yang dapat menyebabkan badai coba lagi. *Untuk diskusi yang lebih dalam tentang backoff eksponensial dan jitter, lihat Exponential Backoff And Jitter di [Blog Arsitektur](https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/).AWS *
Anda dapat menyesuaikan pengaturan penundaan dalam kode Anda dengan memberikan modifikasi [https://docs.rs/aws-smithy-types/latest/aws_smithy_types/retry/struct.RetryConfig.html](https://docs.rs/aws-smithy-types/latest/aws_smithy_types/retry/struct.RetryConfig.html)ke kode Anda`aws_config::defaults`. Kode berikut menetapkan konfigurasi untuk menunda upaya percobaan ulang pertama hingga 100 milidetik dan jumlah waktu maksimum antara upaya coba lagi adalah 5 detik.
```
let retry_config = RetryConfig::standard()
// Defaults to 1 second.
.with_initial_backoff(Duration::from_millis(100))
// Defaults to 20 seconds.
.with_max_backoff(Duration::from_secs(5));
let config = aws_config::defaults(BehaviorVersion::latest())
.retry_config(retry_config)
.load()
.await;
```
## Mode Coba Ulang Adaptif
Sebagai alternatif dari strategi coba lagi `standard` mode, strategi coba lagi `adaptive` mode adalah pendekatan lanjutan yang mencari tingkat permintaan ideal untuk meminimalkan kesalahan pelambatan.
**catatan**
Coba ulang adaptif adalah mode coba lagi lanjutan. Menggunakan strategi ini biasanya tidak disarankan. Lihat [Perilaku Coba lagi](https://docs.aws.amazon.com/sdkref/latest/guide/feature-retry-behavior.html#standardvsadaptive) di *Panduan Referensi Alat AWS SDKs dan*.
Percobaan ulang adaptif mencakup semua fitur percobaan ulang standar. Ini menambahkan pembatas tingkat sisi klien yang mengukur tingkat permintaan yang dibatasi dibandingkan dengan permintaan non-throttled. Ini juga membatasi lalu lintas untuk mencoba tetap dalam bandwidth yang aman, idealnya menyebabkan kesalahan pelambatan nol.
Tarif beradaptasi secara real time untuk mengubah kondisi layanan dan pola lalu lintas dan dapat meningkatkan atau menurunkan tingkat lalu lintas yang sesuai. Secara kritis, pembatas tarif mungkin menunda upaya awal dalam skenario lalu lintas tinggi.
Anda dapat memilih strategi `adaptive` coba lagi dalam kode dengan menyediakan modifikasi: [https://docs.rs/aws-smithy-types/latest/aws_smithy_types/retry/struct.RetryConfig.html](https://docs.rs/aws-smithy-types/latest/aws_smithy_types/retry/struct.RetryConfig.html)
```
let config = aws_config::defaults(BehaviorVersion::latest())
.retry_config(RetryConfig::adaptive())
.load()
.await;
```
# Mengkonfigurasi batas waktu di AWS SDK untuk Rust
AWS SDK untuk Rust menyediakan beberapa pengaturan untuk mengelola batas waktu Layanan AWS permintaan dan aliran data yang terhenti. Ini membantu aplikasi Anda berperilaku optimal ketika penundaan dan kegagalan yang tidak terduga terjadi di jaringan.
## Batas waktu API
Ketika ada masalah sementara yang dapat menyebabkan upaya permintaan memakan waktu lama atau gagal sepenuhnya, penting untuk meninjau dan mengatur batas waktu sehingga aplikasi Anda dapat gagal dengan cepat dan berperilaku optimal. Permintaan yang gagal dapat dicoba ulang secara otomatis oleh SDK. Ini adalah praktik yang baik untuk mengatur batas waktu untuk upaya individu dan seluruh permintaan.
SDK untuk Rust menyediakan batas waktu default untuk membuat koneksi untuk permintaan. SDK tidak memiliki pengaturan waktu tunggu maksimum default untuk menerima respons untuk upaya permintaan atau untuk seluruh permintaan. Opsi batas waktu berikut tersedia:
| Parameter | Nilai default | Deskripsi |
| --- | --- | --- |
| Connect timeout | 3,1 detik | Jumlah maksimum waktu untuk menunggu untuk membuat koneksi sebelum menyerah. |
| Batas waktu operasi | Tidak ada | Jumlah maksimum waktu untuk menunggu sebelum menerima respons dari SDK untuk Rust, termasuk semua percobaan ulang. |
| Batas waktu upaya operasi | Tidak ada | Jumlah maksimum waktu untuk menunggu satu percobaan HTTP, setelah itu panggilan API dapat dicoba ulang. |
| Baca batas waktu | Tidak ada | Jumlah maksimum waktu untuk menunggu untuk membaca byte pertama respons dari saat permintaan dimulai. |
Contoh berikut menunjukkan konfigurasi klien Amazon S3 dengan nilai batas waktu kustom:
```
let config = aws_config::defaults(BehaviorVersion::latest())
.timeout_config(
TimeoutConfig::builder()
.operation_timeout(Duration::from_secs(5))
.operation_attempt_timeout(Duration::from_millis(1500))
.build()
)
.load()
.await;
let s3 = aws_sdk_s3::Client::new(&config);
```
Ketika Anda menggunakan operasi dan mencoba timeout bersama-sama, Anda menetapkan batas keras pada total waktu yang dihabiskan untuk semua upaya di seluruh percobaan ulang. Anda juga menetapkan permintaan HTTP individual untuk gagal cepat pada permintaan yang lambat.
Sebagai alternatif untuk menetapkan nilai batas waktu ini pada klien layanan untuk semua operasi, Anda dapat mengonfigurasi atau [menggantinya untuk satu permintaan](peroperation.md).
**penting**
Batas waktu operasi dan upaya tidak berlaku untuk streaming data yang dikonsumsi setelah SDK for Rust mengembalikan respons. Sebagai contoh, mengkonsumsi data dari `ByteStream` anggota respons tidak tunduk pada batas waktu operasi.
## Perlindungan aliran terhenti
SDK untuk Rust menyediakan bentuk batas waktu lain yang terkait dengan mendeteksi aliran yang macet. Stream macet adalah aliran unggahan atau unduhan yang tidak menghasilkan data lebih lama dari masa tenggang yang dikonfigurasi. Ini membantu mencegah aplikasi menggantung tanpa batas waktu dan tidak pernah membuat kemajuan.
Perlindungan aliran yang terhenti akan mengembalikan kesalahan saat aliran menganggur lebih lama dari periode yang dapat diterima.
Secara default, SDK untuk Rust memungkinkan perlindungan streaming yang terhenti untuk unggahan dan unduhan dan mencari setidaknya 1 byte/sec aktivitas dengan masa tenggang 20 detik.
Contoh berikut menunjukkan penyesuaian `StalledStreamProtectionConfig` yang menonaktifkan perlindungan unggahan dan mengubah masa tenggang tanpa aktivitas menjadi 10 detik:
```
let config = aws_config::defaults(BehaviorVersion::latest())
.stalled_stream_protection(
StalledStreamProtectionConfig::enabled()
.upload_enabled(false)
.grace_period(Duration::from_secs(10))
.build()
)
.load()
.await;
```
**Awas**
Perlindungan aliran terhenti adalah opsi konfigurasi lanjutan. Kami merekomendasikan untuk mengubah nilai-nilai ini hanya jika aplikasi Anda membutuhkan kinerja yang lebih ketat atau jika itu menyebabkan beberapa masalah lain.
### Nonaktifkan perlindungan aliran yang macet
Contoh berikut menunjukkan cara menonaktifkan perlindungan aliran macet sepenuhnya:
```
let config = aws_config::defaults(BehaviorVersion::latest())
.stalled_stream_protection(StalledStreamProtectionConfig::disabled())
.load()
.await;
```
# Mengonfigurasi fitur observabilitas di AWS SDK untuk Rust
Observabilitas adalah sejauh mana keadaan sistem saat ini dapat disimpulkan dari data yang dipancarkannya. Data yang dipancarkan biasanya disebut sebagai telemetri.
**Topics**
+ [Pencatatan log](logging.md)
# Mengkonfigurasi dan menggunakan logging di AWS SDK untuk Rust
AWS SDK for Rust Menggunakan kerangka [penelusuran](http://tracing.rs/) untuk logging. Untuk mengaktifkan logging, tambahkan `tracing-subscriber` peti dan inisialisasi di aplikasi Rust Anda. Log menyertakan stempel waktu, level log, dan jalur modul, membantu men-debug permintaan API dan perilaku SDK. Gunakan variabel `RUST_LOG` lingkungan untuk mengontrol verbositas log, memfilter berdasarkan modul jika diperlukan.
## Cara mengaktifkan login di AWS SDK untuk Rust
1. Dalam prompt perintah untuk direktori proyek Anda, tambahkan peti [tracing-subscriber](https://crates.io/crates/tracing-subscriber) sebagai dependensi:
```
$ cargo add tracing-subscriber --features tracing-subscriber/env-filter
```
Ini menambahkan peti ke `[dependencies]` bagian `Cargo.toml` file Anda.
1. Inisialisasi pelanggan. Biasanya ini dilakukan di awal `main` fungsi sebelum memanggil SDK apa pun untuk operasi Rust:
```
use aws_config::BehaviorVersion;
type BoxError = Box;
#[tokio::main]
async fn main() -> Result<(), BoxError> {
tracing_subscriber::fmt::init(); // Initialize the subscriber.
let config = aws_config::defaults(BehaviorVersion::latest())
.load()
.await;
let s3 = aws_sdk_s3::Client::new(&config);
let _resp = s3.list_buckets()
.send()
.await?;
Ok(())
}
```
1. Aktifkan logging menggunakan variabel `RUST_LOG` lingkungan. Untuk mengaktifkan tampilan informasi logging, dalam prompt perintah, atur variabel `RUST_LOG` lingkungan ke tingkat yang ingin Anda log. Contoh berikut menetapkan logging ke `debug` level:
------
#### [ Linux/macOS ]
```
$ RUST_LOG=debug
```
------
#### [ Windows ]
Jika Anda menggunakan VSCode, jendela terminal sering default ke. PowerShell Verifikasi jenis prompt yang Anda gunakan.
```
C:\> set RUST_LOG=debug
```
------
#### [ PowerShell ]
```
PS C:\> $ENV:RUST_LOG="debug"
```
------
1. Jalankan program:
```
$ cargo run
```
Anda akan melihat output tambahan di jendela konsol atau terminal.
Untuk informasi selengkapnya lihat [memfilter peristiwa dengan variabel lingkungan](https://docs.rs/tracing-subscriber/0.3.18/tracing_subscriber/fmt/index.html#filtering-events-with-environment-variables) dari `tracing-subscriber` dokumentasi.
## Menafsirkan output log
Setelah Anda mengaktifkan logging dengan mengikuti langkah-langkah di bagian sebelumnya, informasi log tambahan akan dicetak ke standar secara default.
Jika Anda menggunakan format keluaran log default (disebut “penuh” oleh modul penelusuran), informasi yang Anda lihat di output log terlihat mirip dengan ini:
```
2024-06-25T16:10:12.367482Z DEBUG invoke{service=s3 operation=ListBuckets sdk_invocation_id=3434933}:try_op:try_attempt:lazy_load_identity: aws_smithy_runtime::client::identity::cache::lazy: identity cache miss occurred; added new identity (took 480.892ms) new_expiration=2024-06-25T23:07:59Z valid_for=25066.632521s partition=IdentityCachePartition(7)
2024-06-25T16:10:12.367602Z DEBUG invoke{service=s3 operation=ListBuckets sdk_invocation_id=3434933}:try_op:try_attempt: aws_smithy_runtime::client::identity::cache::lazy: loaded identity
2024-06-25T16:10:12.367643Z TRACE invoke{service=s3 operation=ListBuckets sdk_invocation_id=3434933}:try_op:try_attempt: aws_smithy_runtime::client::orchestrator::auth: resolved identity identity=Identity { data: Credentials {... }, expiration: Some(SystemTime { tv_sec: 1719356879, tv_nsec: 0 }) }
2024-06-25T16:10:12.367695Z TRACE invoke{service=s3 operation=ListBuckets sdk_invocation_id=3434933}:try_op:try_attempt: aws_smithy_runtime::client::orchestrator::auth: signing request
```
Setiap entri mencakup yang berikut:
+ Stempel waktu entri log.
+ Tingkat log entri. Ini adalah kata seperti`INFO`,`DEBUG`, atau`TRACE`.
+ Kumpulan [bentang](https://docs.rs/tracing/latest/tracing/span/index.html) bersarang dari mana entri log dihasilkan, dipisahkan oleh titik dua (“:”). Ini membantu Anda mengidentifikasi sumber entri log.
+ Jalur modul Rust yang berisi kode yang menghasilkan entri log.
+ Teks pesan log.
Format output standar modul tracing menggunakan kode escape ANSI untuk mewarnai output. Ingatlah urutan pelarian ini saat memfilter atau mencari output.
**catatan**
`sdk_invocation_id`Yang muncul dalam kumpulan rentang bersarang adalah ID unik yang dihasilkan sisi klien oleh SDK untuk membantu mengkorelasikan pesan log. Ini tidak terkait dengan ID permintaan yang ditemukan dalam respons dari file Layanan AWS.
## Sempurnakan level logging Anda
Jika Anda menggunakan peti yang mendukung pemfilteran lingkungan, seperti`tracing_subscriber`, Anda dapat mengontrol verbositas log berdasarkan modul.
Anda dapat mengaktifkan level logging yang sama untuk setiap modul. Berikut ini menetapkan level logging `trace` untuk setiap modul:
```
$ RUST_LOG=trace cargo run
```
Anda dapat mengaktifkan pencatatan tingkat penelusuran untuk modul tertentu. Dalam contoh berikut, hanya log yang berasal dari yang `aws_smithy_runtime` akan masuk pada `trace` level.
```
$ RUST_LOG=aws_smithy_runtime=trace
```
Anda dapat menentukan tingkat log yang berbeda untuk beberapa modul dengan memisahkannya dengan koma. Contoh berikut menetapkan `aws_config` modul ke `trace` level logging, dan `aws_smithy_runtime` modul ke `debug` level logging.
```
$ RUST_LOG=aws_config=trace,aws_smithy_runtime=debug cargo run
```
Tabel berikut menjelaskan beberapa modul yang dapat Anda gunakan untuk memfilter pesan log:
| Awalan | Deskripsi |
| --- | --- |
| `aws_smithy_runtime` | Permintaan dan respons pencatatan kawat |
| `aws_config` | Pemuatan kredensil |
| `aws_sigv4` | Permintaan penandatanganan dan permintaan kanonik |
Salah satu cara untuk mengetahui modul mana yang perlu Anda sertakan dalam output log Anda adalah dengan terlebih dahulu mencatat semuanya, lalu temukan nama peti di output log untuk informasi yang Anda butuhkan. Kemudian Anda dapat mengatur variabel lingkungan yang sesuai dan menjalankan program Anda lagi.
# Mengkonfigurasi titik akhir klien di AWS SDK for Rust
Saat AWS SDK for Rust memanggil Layanan AWS, salah satu langkah pertamanya adalah menentukan ke mana harus merutekan permintaan. Proses ini dikenal sebagai resolusi titik akhir.
Anda dapat mengonfigurasi resolusi titik akhir untuk SDK saat membuat klien layanan. Konfigurasi default untuk resolusi titik akhir biasanya baik-baik saja, tetapi ada beberapa alasan mengapa Anda mungkin ingin mengubah konfigurasi default. Dua contoh alasannya adalah sebagai berikut:
+ Untuk membuat permintaan ke versi pra-rilis layanan atau untuk penyebaran lokal layanan.
+ Untuk mengakses fitur layanan tertentu yang belum dimodelkan dalam SDK.
**Awas**
Resolusi titik akhir adalah topik SDK lanjutan. Jika Anda mengubah pengaturan default, Anda berisiko melanggar kode Anda. Pengaturan default berlaku untuk sebagian besar pengguna di lingkungan produksi.
Titik akhir kustom dapat diatur secara global sehingga digunakan untuk semua permintaan layanan, atau Anda dapat menetapkan titik akhir khusus untuk yang spesifik. Layanan AWS
Endpoint kustom dapat dikonfigurasi menggunakan variabel lingkungan atau pengaturan dalam AWS `config` file bersama. Untuk informasi tentang pendekatan ini, lihat [Titik akhir khusus layanan](https://docs.aws.amazon.com/sdkref/latest/guide/feature-ss-endpoints.html) di Panduan Referensi Alat *AWS SDKs dan Alat*. Untuk daftar lengkap setelan `config` file bersama dan variabel lingkungan untuk semua Layanan AWS, lihat [Pengidentifikasi untuk titik akhir khusus layanan](https://docs.aws.amazon.com/sdkref/latest/guide/ss-endpoints-table.html).
Atau, kustomisasi ini juga dapat dikonfigurasi dalam kode Anda, seperti yang ditunjukkan pada bagian berikut.
## Konfigurasi Kustom
Anda dapat menyesuaikan resolusi titik akhir klien layanan dengan dua metode yang tersedia saat Anda membangun klien:
1. `endpoint_url(url: Into)`
1. `endpoint_resolver(resolver: impl crate::config::endpoint::ResolveEndpoint + `static)`
Anda dapat mengatur kedua properti. Namun, paling sering Anda hanya menyediakan satu. Untuk penggunaan umum, paling `endpoint_url` sering disesuaikan.
### Tetapkan URL titik akhir
Anda dapat menetapkan nilai untuk `endpoint_url` untuk menunjukkan nama host “dasar” untuk layanan. Nilai ini, bagaimanapun, tidak final karena diteruskan sebagai parameter ke `ResolveEndpoint` instance klien. `ResolveEndpoint`Implementasi kemudian dapat memeriksa dan berpotensi memodifikasi nilai tersebut untuk menentukan titik akhir.
### Tetapkan penyelesai titik akhir
`ResolveEndpoint`Implementasi klien layanan menentukan titik akhir yang diselesaikan yang digunakan SDK untuk setiap permintaan yang diberikan. Klien layanan memanggil `resolve_endpoint` metode untuk setiap permintaan dan menggunakan [https://docs.rs/aws-smithy-runtime-api/latest/aws_smithy_runtime_api/client/endpoint/struct.EndpointFuture.html](https://docs.rs/aws-smithy-runtime-api/latest/aws_smithy_runtime_api/client/endpoint/struct.EndpointFuture.html)nilai yang dikembalikan oleh resolver tanpa perubahan lebih lanjut.
Contoh berikut menunjukkan penyediaan implementasi penyelesai titik akhir kustom untuk klien Amazon S3 yang menyelesaikan titik akhir per tahap yang berbeda, seperti pementasan dan produksi:
```
use aws_sdk_s3::config::endpoint::{ResolveEndpoint, EndpointFuture, Params, Endpoint};
#[derive(Debug)]
struct StageResolver { stage: String }
impl ResolveEndpoint for StageResolver {
fn resolve_endpoint(&self, params: &Params) -> EndpointFuture<'_> {
let stage = &self.stage;
EndpointFuture::ready(Ok(Endpoint::builder().url(format!("{stage}.myservice.com")).build()))
}
}
let config = aws_config::defaults(BehaviorVersion::latest())
.load()
.await;
let resolver = StageResolver { stage: std::env::var("STAGE").unwrap() };
let s3_config = aws_sdk_s3::config::Builder::from(&config)
.endpoint_resolver(resolver)
.build();
let s3 = aws_sdk_s3::Client::from_conf(s3_config);
```
**catatan**
Resolver titik akhir, dan dengan ekstensi `ResolveEndpoint` sifat, khusus untuk setiap layanan, dan dengan demikian hanya dapat dikonfigurasi pada konfigurasi klien layanan. URL titik akhir, di sisi lain, dapat dikonfigurasi baik menggunakan konfigurasi bersama (berlaku untuk semua layanan yang berasal darinya) atau untuk layanan tertentu.
#### ResolveEndpoint parameter
`resolve_endpoint`Metode ini menerima parameter khusus layanan yang berisi properti yang digunakan dalam resolusi titik akhir.
Setiap layanan mencakup properti dasar berikut:
| Nama | Tipe | Deskripsi |
| --- | --- | --- |
| region | String | Klien Wilayah AWS |
| endpoint | String | Sebuah representasi string dari nilai set endpointUrl |
| use\$1fips | Boolean | Apakah titik akhir FIPS diaktifkan dalam konfigurasi klien |
| use\$1dual\$1stack | Boolean | Apakah titik akhir dual-stack diaktifkan dalam konfigurasi klien |
Layanan AWS dapat menentukan properti tambahan yang diperlukan untuk resolusi. Misalnya, [parameter endpoint](https://docs.rs/aws-sdk-s3/latest/aws_sdk_s3/config/endpoint/struct.Params.html) Amazon S3 menyertakan nama bucket dan juga beberapa pengaturan fitur khusus Amazon S3. Misalnya, `force_path_style` properti menentukan apakah pengalamatan host virtual dapat digunakan.
Jika Anda menerapkan penyedia Anda sendiri, Anda tidak perlu membuat instance parameter endpoint Anda sendiri. SDK menyediakan properti untuk setiap permintaan dan meneruskannya ke implementasi `resolve_endpoint` Anda.
### Bandingkan menggunakan `endpoint_url` dengan menggunakan `endpoint_resolver`
Penting untuk dipahami bahwa dua konfigurasi berikut, satu yang menggunakan `endpoint_url` dan yang lain yang menggunakan`endpoint_resolver`, TIDAK menghasilkan klien dengan perilaku resolusi titik akhir yang setara.
```
use aws_sdk_s3::config::endpoint::{ResolveEndpoint, EndpointFuture, Params, Endpoint};
#[derive(Debug, Default)]
struct CustomResolver;
impl ResolveEndpoint for CustomResolver {
fn resolve_endpoint(&self, _params: &Params) -> EndpointFuture<'_> {
EndpointFuture::ready(Ok(Endpoint::builder().url("https://endpoint.example").build()))
}
}
let config = aws_config::defaults(BehaviorVersion::latest())
.load()
.await;
// use endpoint url
aws_sdk_s3::config::Builder::from(&config)
.endpoint_url("https://endpoint.example")
.build();
// Use endpoint resolver
aws_sdk_s3::config::Builder::from(&config)
.endpoint_resolver(CustomResolver::default())
.build();
```
Klien yang menetapkan `endpoint_url` menentukan URL *dasar* yang diteruskan ke penyedia (default), yang dapat dimodifikasi sebagai bagian dari resolusi titik akhir.
Klien yang menetapkan `endpoint_resolver` menentukan URL *akhir* yang digunakan klien Amazon S3.
## Contoh
Endpoint kustom sering digunakan untuk pengujian. Alih-alih melakukan panggilan ke layanan berbasis cloud, panggilan dialihkan ke layanan simulasi yang dihosting secara lokal. Dua opsi tersebut adalah:
+ [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html) lokal — versi lokal dari layanan Amazon DynamoDB.
+ [LocalStack](https://github.com/localstack/localstack)— emulator layanan cloud yang berjalan dalam wadah di mesin lokal Anda.
Contoh berikut menggambarkan dua cara berbeda untuk menentukan titik akhir kustom untuk menggunakan dua opsi pengujian ini.
### Gunakan DynamoDB lokal langsung dalam kode
Seperti yang dijelaskan di bagian sebelumnya, Anda dapat mengatur `endpoint_url` langsung dalam kode untuk mengganti titik akhir dasar untuk menunjuk ke server DynamoDB lokal. Dalam kode Anda:
```
let config = aws_config::defaults(aws_config::BehaviorVersion::latest())
.test_credentials()
// DynamoDB run locally uses port 8000 by default.
.endpoint_url("http://localhost:8000")
.load()
.await;
let dynamodb_local_config = aws_sdk_dynamodb::config::Builder::from(&config).build();
let client = aws_sdk_dynamodb::Client::from_conf(dynamodb_local_config);
```
[Contoh lengkap](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/dynamodb/src/bin/list-tables-local.rs) tersedia di GitHub.
### Gunakan LocalStack menggunakan `config` file
Anda dapat mengatur [titik akhir khusus layanan](https://docs.aws.amazon.com/sdkref/latest/guide/feature-ss-endpoints.html) di file bersama Anda. AWS `config` Profil konfigurasi berikut ditetapkan `endpoint_url` untuk terhubung ke `localhost` pada port`4566`. Untuk informasi selengkapnya tentang LocalStack konfigurasi, lihat [Mengakses LocalStack melalui URL titik akhir](https://docs.localstack.cloud/references/network-troubleshooting/endpoint-url/) di situs web *LocalStackdokumen*.
```
[profile localstack]
region=us-east-1
endpoint_url = http://localhost:4566
```
SDK akan mengambil perubahan dalam `config` file bersama dan menerapkannya ke klien SDK Anda saat Anda menggunakan profil. `localstack` Dengan menggunakan pendekatan ini, kode Anda tidak perlu menyertakan referensi apa pun ke titik akhir, dan akan terlihat seperti:
```
// set the environment variable `AWS_PROFILE=localstack` when running
// the application to source `endpoint_url` and point the SDK at the
// localstack instance
let config = aws_config::defaults(BehaviorVersion::latest()).load().await;
let s3_config = aws_sdk_s3::config::Builder::from(&config)
.force_path_style(true)
.build();
let s3 = aws_sdk_s3::Client::from_conf(s3_config);
```
[Contoh lengkap](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/localstack) tersedia di GitHub.
# Mengganti konfigurasi operasi tunggal klien di AWS SDK untuk Rust
Setelah Anda [membuat klien layanan](config-code.md), konfigurasi menjadi tidak berubah dan akan berlaku untuk semua operasi selanjutnya. Meskipun konfigurasi tidak dapat dimodifikasi pada saat ini, konfigurasi dapat diganti berdasarkan per operasi.
Setiap pembuat operasi memiliki `customize` metode yang tersedia untuk membuat `CustomizableOperation` sehingga Anda dapat mengganti salinan individual dari konfigurasi yang ada. Konfigurasi klien asli akan tetap tidak dimodifikasi.
Contoh berikut menunjukkan pembuatan klien Amazon S3 yang memanggil dua operasi, yang kedua diganti untuk dikirim ke yang berbeda. Wilayah AWS Semua pemanggilan objek Amazon S3 menggunakan `us-east-1` wilayah kecuali saat panggilan API diganti secara eksplisit untuk menggunakan modifikasi. `us-west-2`
```
use aws_config::{BehaviorVersion, Region};
let config = aws_config::defaults(BehaviorVersion::latest())
.region("us-east-1")
.load()
.await;
let s3 = aws_sdk_s3::Client::new(&config);
// Request will be sent to "us-east-1"
s3.list_buckets()
.send()
.await?;
// Unset fields default to using the original config value
let modified = aws_sdk_s3::Config::builder()
.region(Region::from_static("us-west-2"));
// Request will be sent to "us-west-2"
s3.list_buckets()
// Creates a CustomizableOperation
.customize()
.config_override(modified)
.send()
.await?;
```
**catatan**
Contoh sebelumnya adalah untuk Amazon S3, namun konsepnya sama untuk semua operasi. Operasi tertentu mungkin memiliki metode tambahan`CustomizeableOperation`.
Untuk contoh menambahkan pencegat menggunakan `customize` untuk operasi tunggal, lihat. [Pencegat hanya untuk operasi tertentu](interceptors.md#interceptors-registration-specific)
# Mengkonfigurasi pengaturan tingkat HTTP dalam SDK untuk AWS Rust
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
`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
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
`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
`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
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
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
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);
}
```
# Mengkonfigurasi pencegat di SDK untuk AWS Rust
Anda dapat menggunakan pencegat untuk menghubungkan eksekusi permintaan dan tanggapan API. Pencegat adalah mekanisme terbuka di mana SDK memanggil kode yang Anda tulis untuk menyuntikkan perilaku ke dalam siklus hidup. request/response Dengan cara ini, Anda dapat mengubah permintaan dalam penerbangan, proses permintaan debug, kesalahan tampilan, dan lainnya.
Contoh berikut menunjukkan pencegat sederhana yang menambahkan header tambahan ke semua permintaan keluar sebelum loop coba lagi dimasukkan:
```
use std::borrow::Cow;
use aws_smithy_runtime_api::client::interceptors::{
Intercept,
context::BeforeTransmitInterceptorContextMut,
};
use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
use aws_smithy_types::config_bag::ConfigBag;
use aws_smithy_runtime_api::box_error::BoxError;
#[derive(Debug)]
struct AddHeaderInterceptor {
key: Cow<'static, str>,
value: Cow<'static, str>,
}
impl AddHeaderInterceptor {
fn new(key: &'static str, value: &'static str) -> Self {
Self {
key: Cow::Borrowed(key),
value: Cow::Borrowed(value),
}
}
}
impl Intercept for AddHeaderInterceptor {
fn name(&self) -> &'static str {
"AddHeader"
}
fn modify_before_retry_loop(
&self,
context: &mut BeforeTransmitInterceptorContextMut<'_>,
_runtime_components: &RuntimeComponents,
_cfg: &mut ConfigBag,
) -> Result<(), BoxError> {
let headers = context.request_mut().headers_mut();
headers.insert(self.key.clone(), self.value.clone());
Ok(())
}
}
```
[Untuk informasi lebih lanjut dan kait pencegat yang tersedia, lihat sifat Intercept.](https://docs.rs/aws-smithy-runtime-api/latest/aws_smithy_runtime_api/client/interceptors/trait.Intercept.html)
## Pendaftaran pencegat
Anda mendaftarkan pencegat ketika Anda membangun klien layanan atau ketika Anda mengganti konfigurasi untuk operasi tertentu. Pendaftaran berbeda tergantung pada apakah Anda ingin pencegat berlaku untuk semua operasi untuk klien Anda atau hanya yang spesifik.
### Interceptor untuk semua operasi pada klien layanan
Untuk mendaftarkan pencegat untuk seluruh klien, tambahkan pencegat menggunakan pola. `Builder`
```
let config = aws_config::defaults(BehaviorVersion::latest())
.load()
.await;
// All service operations invoked using 's3' will have the header added.
let s3_conf = aws_sdk_s3::config::Builder::from(&config)
.interceptor(AddHeaderInterceptor::new("x-foo-version", "2.7"))
.build();
let s3 = aws_sdk_s3::Client::from_conf(s3_conf);
```
### Pencegat hanya untuk operasi tertentu
Untuk mendaftarkan pencegat hanya untuk satu operasi, gunakan ekstensi. `customize` Anda dapat mengganti konfigurasi klien layanan Anda di tingkat per operasi menggunakan metode ini. Untuk informasi selengkapnya tentang operasi yang dapat disesuaikan, lihat. [Mengganti konfigurasi operasi tunggal klien di AWS SDK untuk Rust](peroperation.md)
```
// Only the list_buckets operation will have the header added.
s3.list_buckets()
.customize()
.interceptor(AddHeaderInterceptor::new("x-bar-version", "3.7"))
.send()
.await?;
```