Tentukan penangan fungsi Lambda di Rust

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 batas waktu.

Halaman ini menjelaskan cara bekerja dengan penangan fungsi Lambda di Rust, termasuk inisialisasi proyek, konvensi penamaan, dan praktik terbaik. Halaman ini juga menyertakan contoh fungsi Rust Lambda yang mengambil informasi tentang pesanan, menghasilkan tanda terima file teks, dan menempatkan file ini dalam bucket Amazon Simple Storage Service (S3). Untuk informasi selengkapnya tentang cara menerapkan fungsi Anda setelah menulisnya, lihatMenyebarkan fungsi Rust Lambda dengan arsip file.zip.

Menyiapkan proyek Rust handler Anda

Saat bekerja dengan fungsi Lambda di Rust, prosesnya melibatkan penulisan kode Anda, mengkompilasinya, dan menyebarkan artefak yang dikompilasi ke Lambda. Cara paling sederhana untuk mengatur proyek handler Lambda di Rust adalah dengan menggunakan AWS Lambda Runtime for Rust. Terlepas dari namanya, AWS Lambda Runtime for Rust bukanlah runtime terkelola dalam arti yang sama seperti di Lambda untuk Python, Java, atau Node.js. Sebaliknya, AWS Lambda Runtime for Rust adalah crate (lambda_runtime) yang mendukung penulisan fungsi Lambda di Rust dan berinteraksi dengan AWS Lambda lingkungan eksekusi.

Gunakan perintah berikut untuk menginstal Cargo Lambda, ekstensi sumber terbuka pihak ketiga untuk alat baris perintah Cargo yang menyederhanakan pembuatan dan penerapan fungsi Rust Lambda:

cargo install cargo-lambda

Setelah Anda berhasil menginstalcargo-lambda, gunakan perintah berikut untuk menginisialisasi proyek pengendali fungsi Rust Lambda baru:

cargo lambda new example-rust

Ketika Anda menjalankan perintah ini, antarmuka baris perintah (CLI) menanyakan beberapa pertanyaan tentang fungsi Lambda Anda:

Setelah perintah berjalan dengan sukses, masukkan direktori utama proyek Anda:

cd example-rust

Perintah ini menghasilkan generic_handler.rs file dan main.rs file di src direktori. generic_handler.rsDapat digunakan untuk menyesuaikan event handler generik. main.rsFile berisi logika aplikasi utama Anda. Cargo.tomlFile berisi metadata tentang paket Anda dan daftar dependensi eksternalnya.

Contoh kode fungsi Rust Lambda

Contoh kode fungsi Rust Lambda berikut mengambil informasi tentang pesanan, menghasilkan tanda terima file teks, dan menempatkan file ini dalam bucket Amazon S3.

use aws_sdk_s3::{Client, primitives::ByteStream};
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::env;

#[derive(Deserialize, Serialize)]
struct Order {
    order_id: String,
    amount: f64,
    item: String,
}

async fn function_handler(event: LambdaEvent<Value>) -> Result<String, Error> {
    let payload = event.payload;

    // Deserialize the incoming event into Order struct
    let order: Order = serde_json::from_value(payload)?;

    let bucket_name = env::var("RECEIPT_BUCKET")
        .map_err(|_| "RECEIPT_BUCKET environment variable is not set")?;

    let receipt_content = format!(
        "OrderID: {}\nAmount: ${:.2}\nItem: {}",
        order.order_id, order.amount, order.item
    );
    let key = format!("receipts/{}.txt", order.order_id);

    let config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
    let s3_client = Client::new(&config);

    upload_receipt_to_s3(&s3_client, &bucket_name, &key, &receipt_content).await?;

    Ok("Success".to_string())
}

async fn upload_receipt_to_s3(
    client: &Client,
    bucket_name: &str,
    key: &str,
    content: &str,
) -> Result<(), Error> {
    client
        .put_object()
        .bucket(bucket_name)
        .key(key)
        .body(ByteStream::from(content.as_bytes().to_vec()))  // Fixed conversion
        .content_type("text/plain")
        .send()
        .await?;

    Ok(())
}

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

main.rsFile ini berisi bagian-bagian kode berikut:

[package]
name = "example-rust"
version = "0.1.0"
edition = "2024"

[dependencies]
aws-config = "1.5.18"
aws-sdk-s3 = "1.78.0"
lambda_runtime = "0.13.0"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "1", features = ["full"] }

Agar fungsi ini berfungsi dengan baik, peran pelaksanaannya harus memungkinkan s3:PutObject tindakan. Juga, pastikan Anda mendefinisikan variabel RECEIPT_BUCKET lingkungan. Setelah pemanggilan berhasil, bucket Amazon S3 harus berisi file tanda terima.

Definisi kelas yang valid untuk penangan Rust

Dalam kebanyakan kasus, tanda tangan pengendali Lambda yang Anda tentukan di Rust memiliki format berikut:

async fn function_handler(event: LambdaEvent<T>) -> Result<U, Error>

Untuk handler ini:

Dalam contoh kita, tanda tangan handler terlihat seperti berikut:

async fn function_handler(event: LambdaEvent<Value>) -> Result<String, Error>

Tanda tangan handler yang valid lainnya dapat menampilkan yang berikut:

Konvensi penamaan handler

Penangan Lambda di Rust tidak memiliki batasan penamaan yang ketat. Meskipun Anda dapat menggunakan nama apa pun untuk handler Anda, nama fungsi di Rust umumnya ada disnake_case.

Untuk aplikasi yang lebih kecil, seperti dalam contoh ini, Anda dapat menggunakan satu main.rs file untuk berisi semua kode Anda. Untuk proyek yang lebih besar, main.rs harus berisi titik masuk ke fungsi Anda, tetapi Anda dapat memiliki file tambahan untuk memisahkan kode Anda menjadi modul logis. Misalnya, Anda mungkin memiliki struktur file berikut:

/example-rust
│── src/
│   ├── main.rs        # Entry point
│   ├── handler.rs     # Contains main handler
│   ├── services.rs    # [Optional] Back-end service calls
│   ├── models.rs      # [Optional] Data models
│── Cargo.toml

Mendefinisikan dan mengakses objek peristiwa input

JSON adalah format input yang paling umum dan standar untuk fungsi Lambda. Dalam contoh ini, fungsi mengharapkan input yang mirip dengan berikut ini:

{
    "order_id": "12345",
    "amount": 199.99,
    "item": "Wireless Headphones"
}

Di Rust, Anda dapat menentukan bentuk peristiwa input yang diharapkan dalam struct. Dalam contoh ini, kita mendefinisikan struct berikut untuk mewakili: Order

#[derive(Deserialize, Serialize)]
struct Order {
    order_id: String,
    amount: f64,
    item: String,
}

Struct ini cocok dengan bentuk input yang diharapkan. Dalam contoh ini, #[derive(Deserialize, Serialize)] makro secara otomatis menghasilkan kode untuk serialisasi dan deserialisasi. Ini berarti bahwa kita dapat mendeserialisasi tipe JSON input generik ke dalam struct kita menggunakan metode. serde_json::from_value() Ini diilustrasikan dalam beberapa baris pertama handler:

async fn function_handler(event: LambdaEvent<Value>) -> Result<String, Error> {
    let payload = event.payload;

    // Deserialize the incoming event into Order struct
    let order: Order = serde_json::from_value(payload)?;
    ...
}

Anda kemudian dapat mengakses bidang objek. Misalnya, order.order_id mengambil nilai order_id dari input asli.

Pre-defined masukan jenis acara

Ada banyak jenis peristiwa input yang telah ditentukan sebelumnya yang tersedia di aws_lambda_events peti. Misalnya, jika Anda ingin memanggil fungsi Anda dengan API Gateway, termasuk impor berikut:

use aws_lambda_events::event::apigw::ApiGatewayProxyRequest;

Kemudian, pastikan handler utama Anda menggunakan tanda tangan berikut:

async fn handler(event: LambdaEvent<ApiGatewayProxyRequest>) -> Result<String, Error> {
    let body = event.payload.body.unwrap_or_default();
    ...
}

Lihat peti aws_lambda_events untuk informasi selengkapnya tentang jenis peristiwa input yang telah ditentukan sebelumnya.

Mengakses dan menggunakan objek konteks Lambda

Objek konteks Lambda berisi informasi tentang pemanggilan, fungsi, dan lingkungan eksekusi. Di Rust, pem LambdaEvent bungkus menyertakan objek konteks. Misalnya, Anda dapat menggunakan objek konteks untuk mengambil ID permintaan dari pemanggilan saat ini dengan kode berikut:

async fn function_handler(event: LambdaEvent<Value>) -> Result<String, Error> {
    let request_id = event.context.request_id;
    ...
}

Untuk informasi selengkapnya tentang objek konteks, lihatMenggunakan objek konteks Lambda untuk mengambil informasi fungsi Rust.

Menggunakan AWS SDK for Rust di handler Anda

Seringkali, Anda akan menggunakan fungsi Lambda untuk berinteraksi dengan atau membuat pembaruan ke AWS sumber daya lain. Cara paling sederhana untuk berinteraksi dengan sumber daya ini adalah dengan menggunakan AWS SDK for Rust.

Untuk menambahkan dependensi SDK ke fungsi Anda, tambahkan ke Cargo.toml file Anda. Kami menyarankan hanya menambahkan pustaka yang Anda butuhkan untuk fungsi Anda. Dalam contoh kode sebelumnya, kami menggunakanaws_sdk_s3::Client. Dalam Cargo.toml file, Anda dapat menambahkan ketergantungan ini dengan menambahkan baris berikut di bawah [dependencies] bagian:

aws-sdk-s3 = "1.78.0"

The, impor dependensi langsung dalam kode Anda:

use aws_sdk_s3::{Client, primitives::ByteStream};

Kode contoh kemudian menginisialisasi klien Amazon S3 sebagai berikut:

let config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let s3_client = Client::new(&config);

Setelah menginisialisasi klien SDK, Anda kemudian dapat menggunakannya untuk berinteraksi dengan AWS layanan lain. Kode contoh memanggil PutObject API Amazon S3 dalam fungsi upload_receipt_to_s3 helper.

Mengakses variabel lingkungan

Dalam kode handler Anda, Anda dapat mereferensikan variabel lingkungan apa pun dengan menggunakan env::var metode ini. Dalam contoh ini, kita mereferensi RECEIPT_BUCKET kan variabel lingkungan yang ditentukan menggunakan baris kode berikut:

let bucket_name = env::var("RECEIPT_BUCKET")
    .map_err(|_| "RECEIPT_BUCKET environment variable is not set")?;

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. Misalnya, Anda dapat memodifikasi kode di halaman ini untuk menggunakan status bersama saat menginisialisasi klien Amazon S3 dengan memperbarui main fungsi dan tanda tangan handler:

async fn function_handler(client: &Client, event: LambdaEvent<Value>) -> Result<String, Error> {
    ...
    upload_receipt_to_s3(client, &bucket_name, &key, &receipt_content).await?;
    ...
}

...
      
#[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:

Manfaatkan penggunaan kembali lingkungan eksekusi untuk meningkatkan kinerja fungsi Anda. Inisialisasi klien SDK dan koneksi basis data di luar fungsi handler, dan lakukan caching 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 direktif 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 Kem bali Koneksi dengan Keep-Alive in 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 fungsi reservasi konkurensi ke 0 segera untuk membatasi semua pemanggilan ke fungsi, saat Anda memperbarui kode.

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

Tulis kode idempotent. Menulis kode idempotent 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 lebih lanjut, lihat Bagaimana cara membuat fungsi Lambda saya idempoten? .