Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Dukungan karat untuk Instans Terkelola Lambda
## Konfigurasi konkurensi
Jumlah maksimum permintaan bersamaan yang dikirim Lambda ke setiap lingkungan eksekusi dikendalikan oleh pengaturan `PerExecutionEnvironmentMaxConcurrency` dalam konfigurasi fungsi. Ini adalah pengaturan opsional, dan nilai default untuk Rust adalah 8 permintaan bersamaan per vCPU, atau Anda dapat mengonfigurasi nilai Anda sendiri. Nilai ini menentukan jumlah tugas Tokio yang dihasilkan oleh runtime dan statis untuk masa pakai lingkungan eksekusi. Setiap pekerja menangani persis satu permintaan dalam penerbangan pada satu waktu, tanpa multiplexing per pekerja. Lambda secara otomatis menyesuaikan jumlah permintaan bersamaan hingga maksimum yang dikonfigurasi berdasarkan kapasitas setiap lingkungan eksekusi untuk menyerap permintaan tersebut.
## Membangun fungsi untuk multi-konkurensi
Anda harus menerapkan praktik keamanan utas yang sama saat menggunakan Instans Terkelola Lambda seperti yang Anda lakukan di lingkungan multi-utas lainnya. Karena objek handler dibagikan di semua thread pekerja, setiap status yang bisa berubah harus aman untuk utas. Ini termasuk koleksi, koneksi database, dan objek statis apa pun yang dimodifikasi selama pemrosesan permintaan.
Untuk mengaktifkan penanganan permintaan bersamaan, tambahkan tanda `concurrency-tokio` fitur ke `Cargo.toml` file Anda.
```
[dependencies]
lambda_runtime = { version = "1", features = ["concurrency-tokio"] }
```
Titik `lambda_runtime::run_concurrent(…)` masuk harus dipanggil dari dalam runtime Tokio, biasanya disediakan oleh `#[tokio::main]` atribut pada fungsi utama Anda. Penutupan handler Anda harus menerapkan [https://doc.rust-lang.org/std/clone/trait.Clone.html](https://doc.rust-lang.org/std/clone/trait.Clone.html)\$1 [https://doc.rust-lang.org/std/marker/trait.Send.html](https://doc.rust-lang.org/std/marker/trait.Send.html). Ini memungkinkan kerangka kerja untuk membagikan handler Anda di beberapa tugas asinkron dengan aman. Jika batas-batas tersebut tidak terpenuhi, kode Anda tidak akan dikompilasi.
Saat Anda membutuhkan status bersama di seluruh pemanggilan (kumpulan database, struct konfigurasi), bungkus [https://doc.rust-lang.org/std/sync/struct.Arc.html](https://doc.rust-lang.org/std/sync/struct.Arc.html)dan kloning ke dalam setiap pemanggilan. `Arc`
Semua klien AWS SDK untuk Rust aman secara konkurensi dan tidak memerlukan penanganan khusus.
### Contoh: AWS Klien SDK
Contoh berikut menggunakan klien S3 untuk meng-upload objek pada setiap pemanggilan. Klien dikloning langsung ke penutupan tanpa`Arc`:
```
let config = aws_config::load_defaults(BehaviorVersion::latest()).await;
let s3_client = aws_sdk_s3::Client::new(&config);
run_concurrent(service_fn(move |event: LambdaEvent| {
let s3_client = s3_client.clone(); // cheap clone, no Arc needed
async move {
s3_client.put_object()
.bucket(&event.payload.bucket)
.key(&event.payload.key)
.body(event.payload.body.into_bytes().into())
.send()
.await?;
Ok(Response { message: "uploaded".into() })
}
}))
.await
```
### Contoh: Kolam koneksi database
Ketika handler Anda membutuhkan akses ke status bersama seperti klien dan konfigurasi, bungkus [https://doc.rust-lang.org/std/sync/struct.Arc.html](https://doc.rust-lang.org/std/sync/struct.Arc.html)dan kloning `Arc` ke dalam setiap pemanggilan:
```
#[derive(Debug)]
struct AppState {
dynamodb_client: DynamoDbClient,
table_name: String,
cache_ttl: Duration,
}
let config = aws_config::load_defaults(BehaviorVersion::latest()).await;
let state = Arc::new(AppState {
dynamodb_client: DynamoDbClient::new(&config),
table_name: std::env::var("TABLE_NAME").expect("TABLE_NAME must be set"),
cache_ttl: Duration::from_secs(300),
});
run_concurrent(service_fn(move |event: LambdaEvent| {
let state = state.clone();
async move { handle(event, state).await }
}))
.await
```
## Direktori bersama/tmp
`/tmp`Direktori dibagikan di semua pemanggilan bersamaan di lingkungan eksekusi yang sama. Gunakan nama file unik per pemanggilan (misalnya sertakan ID permintaan) atau terapkan penguncian file eksplisit untuk menghindari kerusakan data.
## Pencatatan log
Log interleaving (entri log dari permintaan berbeda yang disisipkan dalam log) adalah normal dalam sistem multi-konkuren. [Fungsi yang menggunakan Instans Terkelola Lambda mendukung format log JSON terstruktur melalui kontrol logging lanjutan Lambda.](monitoring-logs.md#monitoring-cloudwatchlogs-advanced) Format ini mencakup`requestId`, memungkinkan entri log dikorelasikan dengan satu permintaan. Untuk informasi lebih lanjut, lihat[Menerapkan logging lanjutan dengan peti Tracing](rust-logging.md#rust-logging-tracing).
## Permintaan Konteks
`Context`Objek dilewatkan langsung ke setiap pemanggilan handler. Gunakan `event.context.request_id` untuk mengakses ID permintaan untuk permintaan saat ini.
Gunakan `event.context.xray_trace_id` untuk mengakses ID jejak X-Ray. Lambda tidak mendukung variabel `_X_AMZN_TRACE_ID` lingkungan dengan Instans Terkelola Lambda. ID jejak X-Ray disebarkan secara otomatis saat menggunakan AWS SDK untuk Rust.
Gunakan `event.context.deadline` untuk mendeteksi batas waktu - ini berisi tenggat waktu pemanggilan dalam milidetik.
## Inisialisasi dan shutdown
Inisialisasi fungsi terjadi sekali per lingkungan eksekusi. Objek yang dibuat selama inisialisasi dibagikan di seluruh permintaan.
Untuk fungsi Lambda dengan ekstensi, lingkungan eksekusi memancarkan sinyal SIGTERM saat dimatikan. Sinyal ini digunakan oleh ekstensi untuk memicu tugas pembersihan, seperti pembilasan buffer. `lambda_runtime`menawarkan pembantu untuk menyederhanakan konfigurasi penanganan sinyal shutdown yang anggun,. [https://docs.rs/lambda_runtime/latest/lambda_runtime/fn.spawn_graceful_shutdown_handler.html](https://docs.rs/lambda_runtime/latest/lambda_runtime/fn.spawn_graceful_shutdown_handler.html) Untuk mempelajari lebih lanjut tentang siklus hidup lingkungan eksekusi, lihat. [Memahami siklus hidup lingkungan pelaksanaan Lambda](lambda-runtime-environment.md)
## Versi ketergantungan
Instans Terkelola Lambda memerlukan versi paket minimum berikut:
+ `lambda_runtime`: versi 1.1.1 atau yang lebih baru, dengan `concurrency-tokio` fitur diaktifkan
+ Versi Rust minimum yang didukung (MSRV) adalah 1.84.0.