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

Dukungan Rust untuk Instans Terkelola Lambda

Konfigurasi konkurensi

Jumlah maksimum permintaan bersamaan yang dikirim Lambda ke setiap lingkungan eksekusi dikendalikan oleh PerExecutionEnvironmentMaxConcurrency pengaturan 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 selama masa pakai lingkungan eksekusi. Setiap pekerja menangani tepat 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 thread yang sama saat menggunakan Instans Terkelola Lambda seperti yang Anda lakukan di lingkungan multi-utas lainnya. Karena objek handler dibagikan di semua utas pekerja, setiap status yang dapat 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"] }

T lambda_runtime::run_concurrent(…) itik masuk harus dipanggil dari dalam runtime Tokio, biasanya disediakan oleh #[tokio::main] atribut pada fungsi utama Anda. Penutupan handler Anda harus menerapkan Clone + Send. Ini memungkinkan kerangka kerja untuk berbagi 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 dalam Arc dan kloning Arc ke setiap pemanggilan.

Semua klien AWS SDK untuk Rust aman untuk bersaing dan tidak memerlukan penanganan khusus.

Contoh: AWS Klien SDK

Contoh berikut menggunakan klien S3 untuk mengunggah 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<Request>| {  
    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: Kumpulan koneksi database

Saat handler Anda membutuhkan akses ke status bersama seperti klien dan konfigurasi, bungkus dalam Arc dan kloning Arc ke 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<Request>| {  
    let state = state.clone();  
    async move { handle(event, state).await }  
}))  
.await

Direktori /tmp yang dibagikan

Direk /tmp tori 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

Interleaving log (entri log dari permintaan berbeda yang disisipkan dalam log) normal dalam sistem multi-concurrent. Fungsi yang menggunakan Lambda Managed Instances mendukung format log JSON terstruktur melalui kontrol logging lanjutan Lambda. Format ini mencakuprequestId, memungkinkan entri log untuk dikorelasikan dengan satu permintaan. Untuk informasi lebih lanjut, lihatMenerapkan logging lanjutan dengan peti Tracing.

Permintaan Konteks

Ob Context jek diteruskan 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 X-Ray jejak. Lambda tidak mendukung variabel _X_AMZN_TRACE_ID lingkungan dengan Lambda Managed Instances. ID X-Ray jejak 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 selama shutdown. Sinyal ini digunakan oleh ekstensi untuk memicu tugas pembersihan, seperti buffer pembilasan. lambda_runtimemenawarkan pembantu untuk menyederhanakan konfigurasi penanganan sinyal shutdown yang anggun, spawn_graceful_shutdown_handler (). Untuk mempelajari lebih lanjut tentang siklus hidup lingkungan eksekusi, lihatMemahami siklus hidup lingkungan pelaksanaan Lambda.

Versi ketergantungan

Instans Terkelola Lambda memerlukan versi paket minimum berikut: