Tentukan penangan fungsi Lambda di Rust - AWS Lambda
Dasar-dasar penangan karatMenggunakan status bersamaPraktik terbaik kode untuk fungsi Rust Lambda

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

Tentukan penangan fungsi Lambda di Rust

catatan

Klien runtime Rust adalah paket eksperimental. Hal ini dapat berubah dan dimaksudkan hanya untuk tujuan evaluasi.

Handler fungsi Lambda Anda adalah metode dalam kode fungsi Anda yang memproses peristiwa. Saat fungsi Anda diaktifkan, Lambda menjalankan metode handler. Fungsi Anda berjalan sampai handler mengembalikan respons, keluar, atau waktu habis.

Dasar-dasar penangan karat

Tulis kode fungsi Lambda Anda sebagai Rust yang dapat dieksekusi. Menerapkan kode fungsi handler dan fungsi utama dan termasuk yang berikut:

contoh - Rust handler yang memproses peristiwa JSON

Contoh berikut menggunakan peti serde_json untuk memproses peristiwa dasar: JSON

use lambda_runtime::{service_fn, LambdaEvent, Error};
use serde_json::{json, Value};

async fn handler(event: LambdaEvent<Value>) -> Result<Value, Error> {
 let payload = event.payload;
 let first_name = payload["firstName"].as_str().unwrap_or("world");
 Ok(json!({ "message": format!("Hello, {first_name}!") }))
}

#[tokio::main]
async fn main() -> Result<(), Error> {
 lambda_runtime::run(service_fn(handler)).await
}

Perhatikan hal berikut:

  • use: Mengimpor pustaka yang dibutuhkan fungsi Lambda Anda.

  • async fn main: Titik masuk yang menjalankan kode fungsi Lambda. Klien runtime Rust menggunakan Tokio sebagai runtime async, jadi Anda harus membubuhi keterangan fungsi utama dengan. #[tokio::main]

  • async fn handler(event: LambdaEvent<Value>) -> Result<Value,Error>: Ini adalah tanda tangan penangan Lambda. Ini termasuk kode yang berjalan ketika fungsi dipanggil.

    • LambdaEvent<Value>: Ini adalah tipe generik yang menjelaskan peristiwa yang diterima oleh runtime Lambda serta konteks fungsi Lambda.

    • Result<Value, Error>: Fungsi mengembalikan Result tipe. Jika fungsinya berhasil, hasilnya adalah JSON nilai. Jika fungsinya tidak berhasil, hasilnya adalah kesalahan.

Menggunakan status bersama

Anda dapat mendeklarasikan variabel bersama yang independen dari kode handler fungsi Lambda Anda. Variabel ini dapat membantu Anda memuat informasi status selamaFase inisialisasi, sebelum fungsi Anda menerima peristiwa apa pun.

contoh — Bagikan klien Amazon S3 di seluruh instance fungsi

Perhatikan hal berikut:

  • use aws_sdk_s3::Client: Contoh ini mengharuskan Anda untuk menambahkan aws-sdk-s3 = "0.26.0" ke daftar dependensi dalam file AndaCargo.toml.

  • aws_config::from_env: Contoh ini mengharuskan Anda untuk menambahkan aws-config = "0.55.1" ke daftar dependensi dalam file AndaCargo.toml.

use aws_sdk_s3::Client;
use lambda_runtime::{service_fn, Error, LambdaEvent};
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct Request {
    bucket: String,
}

#[derive(Serialize)]
struct Response {
    keys: Vec<String>,
}

async fn handler(client: &Client, event: LambdaEvent<Request>) -> Result<Response, Error> {
    let bucket = event.payload.bucket;
    let objects = client.list_objects_v2().bucket(bucket).send().await?;
    let keys = objects
        .contents()
        .map(|s| s.iter().flat_map(|o| o.key().map(String::from)).collect())
        .unwrap_or_default();
    Ok(Response { keys })
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    let shared_config = aws_config::from_env().load().await;
    let client = Client::new(&shared_config);
    let shared_client = &client;
    lambda_runtime::run(service_fn(move |event: LambdaEvent<Request>| async move {
        handler(&shared_client, event).await
    }))
    .await
}

Praktik terbaik kode untuk fungsi Rust Lambda

Patuhi pedoman dalam daftar berikut untuk menggunakan praktik pengkodean terbaik saat membangun fungsi Lambda Anda:

  • Pisahkan handler Lambda dari logika inti Anda. Ini memungkinkan Anda untuk membuat fungsi yang lebih dapat teruji.

  • Minimalkan kompleksitas dependensi Anda. Utamakan memilih kerangka kerja lebih sederhana yang cepat dimuat dalam memulai lingkungan eksekusi.

  • Minimalkan ukuran paket penerapan Anda sesuai kebutuhan runtime-nya. Ini akan mengurangi jumlah waktu yang dibutuhkan untuk mengunduh dan membongkar paket deployment Anda sebelum invokasi.

  • Manfaatkan penggunaan kembali lingkungan eksekusi untuk meningkatkan kinerja fungsi Anda. Inisialisasi SDK klien dan koneksi database di luar fungsi handler, dan cache aset statis secara lokal di direktori. /tmp Invokasi selanjutnya yang diproses oleh instans yang sama dari fungsi Anda dapat menggunakan kembali sumber daya ini. Ini menghemat biaya dengan mengurangi waktu pengoperasian fungsi.

    Untuk menghindari potensi kebocoran data di seluruh invokasi, jangan menggunakan lingkungan eksekusi untuk menyimpan data pengguna, peristiwa, atau informasi lainnya implikasi keamanan. Jika fungsi Anda bergantung pada status yang dapat disenyapkan yang tidak dapat disimpan dalam memori di dalam handler, pertimbangkan untuk membuat fungsi terpisah atau versi terpisah dari fungsi untuk setiap pengguna.

  • Gunakan arahan keep-alive untuk mempertahankan koneksi yang persisten. Lambda membersihkan koneksi idle dari waktu ke waktu. Mencoba menggunakan ulang koneksi idle saat mengidentifikasi suatu fungsi akan menyebabkan kesalahan koneksi. Untuk mempertahankan koneksi yang persisten, gunakan arahan tetap aktif yang berkaitan dengan runtime Anda. Sebagai contoh, lihat Menggunakan Kembali Koneksi dengan Keep-Alive di Node.js.

  • Gunakan variabel lingkungan untuk meneruskan parameter operasional ke fungsi Anda. Misalnya, jika Anda ingin menulis ke bucket Amazon S3 alih-alih melakukan hard-coding nama bucket yang Anda tulis, konfigurasikan nama bucket sebagai variabel lingkungan.

  • Hindari menggunakan pemanggilan rekursif dalam fungsi Lambda Anda, di mana fungsi memanggil dirinya sendiri atau memulai proses yang dapat memanggil fungsi lagi. Hal ini dapat menyebabkan volume invokasi fungsi yang tidak diinginkan dan peningkatan biaya. Jika Anda melihat volume pemanggilan yang tidak diinginkan, setel konkurensi fungsi cadangan untuk 0 segera membatasi semua pemanggilan ke fungsi, saat Anda memperbarui kode.

  • Jangan gunakan non-dokumen, non-publik APIs dalam kode fungsi Lambda Anda. Untuk runtime AWS Lambda terkelola, Lambda secara berkala menerapkan pembaruan keamanan dan fungsional ke internal Lambda. APIs APIPembaruan internal ini mungkin tidak kompatibel ke belakang, yang menyebabkan konsekuensi yang tidak diinginkan seperti kegagalan pemanggilan jika fungsi Anda memiliki ketergantungan pada non-publik ini. APIs Lihat APIreferensi untuk daftar yang tersedia APIs untuk umum.

  • Tulis kode idempoten. Menulis kode idempoten untuk fungsi Anda memastikan bahwa peristiwa duplikat ditangani dengan cara yang sama. Kode Anda harus memvalidasi peristiwa dengan benar dan menangani peristiwa duplikat dengan anggun. Untuk informasi selengkapnya, lihat Bagaimana cara membuat fungsi Lambda saya idempoten? .