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

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 di 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 penangan Rust Anda

Saat bekerja dengan fungsi Lambda di Rust, prosesnya melibatkan penulisan kode Anda, mengompilasinya, dan menyebarkan artefak yang dikompilasi ke Lambda. Cara termudah untuk menyiapkan proyek penangan Lambda di Rust adalah dengan menggunakan AWS Lambda Runtime for Rust. Terlepas dari namanya, AWS Lambda Runtime for Rust bukanlah runtime yang dikelola 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 lingkungan eksekusi. AWS Lambda

Gunakan perintah berikut untuk menginstal AWS Lambda Runtime for Rust:

cargo install cargo-lambda

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

cargo lambda new example-rust

Saat 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 mencantumkan dependensi eksternalnya.

Contoh kode fungsi Lambda Rust

Contoh berikut kode fungsi Rust Lambda mengambil informasi tentang pesanan, menghasilkan tanda terima file teks, dan menempatkan file ini di 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 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"] }

[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 bahwa 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 penangan Lambda yang Anda tentukan di Rust akan memiliki format berikut:

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

Untuk pawang ini:

Dalam contoh kita, tanda tangan handler terlihat seperti berikut:

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

Tanda tangan handler lain yang valid 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 masuksnake_case.

Untuk aplikasi yang lebih kecil, seperti dalam contoh ini, Anda dapat menggunakan satu main.rs file untuk memuat semua kode Anda. Untuk proyek yang lebih besar, main.rs harus berisi titik masuk ke fungsi Anda, tetapi Anda dapat memiliki file tambahan untuk itu 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 masukan

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

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

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

#[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 deserialisasi 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 dari order_id dari input asli.

Jenis acara masukan yang telah ditentukan sebelumnya

Ada banyak jenis acara input yang telah ditentukan sebelumnya yang tersedia di aws_lambda_events peti. Misalnya, jika Anda ingin menjalankan 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 masukan yang telah ditentukan sebelumnya.

Mengakses dan menggunakan objek konteks Lambda

Objek konteks Lambda berisi informasi tentang lingkungan pemanggilan, fungsi, dan eksekusi. Di Rust, LambdaEvent pembungkus 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 sumber daya lain AWS . Cara termudah untuk berinteraksi dengan sumber daya ini adalah dengan menggunakan AWS SDK for Rust.

Untuk menambahkan dependensi SDK ke fungsi Anda, tambahkan dependensi di file Anda. Cargo.toml Kami sarankan hanya menambahkan pustaka yang Anda butuhkan untuk fungsi Anda. Dalam contoh kode sebelumnya, kita 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"

Itu, impor dependensi langsung di 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 dapat menggunakannya untuk berinteraksi dengan layanan lain AWS . Kode contoh memanggil Amazon S3 PutObject API 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, kami mereferensikan variabel RECEIPT_BUCKET 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 mengubah kode di halaman ini untuk menggunakan status bersama saat menginisialisasi klien Amazon S3 dengan memperbarui fungsi dan tanda tangan main 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 panduan dalam daftar berikut untuk menggunakan praktik pengkodean terbaik saat membangun fungsi Lambda Anda: