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 Clone+ Send. 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 Arcdan 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 tanpaArc:

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: Kolam koneksi database

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

Direktori bersama/tmp

/tmpDirektori 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. Format ini mencakuprequestId, memungkinkan entri log dikorelasikan dengan satu permintaan. Untuk informasi lebih lanjut, lihatMenerapkan logging lanjutan dengan peti Tracing.

Permintaan Konteks

ContextObjek 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_runtimemenawarkan pembantu untuk menyederhanakan konfigurasi penanganan sinyal shutdown yang anggun,. spawn_graceful_shutdown_handler() Untuk mempelajari lebih lanjut tentang siklus hidup lingkungan eksekusi, lihat. Memahami siklus hidup lingkungan pelaksanaan Lambda

Versi ketergantungan

Instans Terkelola Lambda memerlukan versi paket minimum berikut: