Definieren Sie Lambda-Funktionshandler in Rust

Der Lambda-Funktionshandler ist die Methode in Ihrem Funktionscode, die Ereignisse verarbeitet. Wenn Ihre Funktion aufgerufen wird, führt Lambda die Handler-Methode aus. Ihre Funktion wird so lange ausgeführt, bis der Handler eine Antwort zurückgibt, beendet wird oder ein Timeout auftritt.

Auf dieser Seite wird beschrieben, wie Sie mit Lambda-Funktionshandlern in Rust arbeiten, einschließlich Projektinitialisierung, Benennungskonventionen und Best Practices. Diese Seite enthält auch ein Beispiel für eine Rust-Lambda-Funktion, die Informationen über eine Bestellung aufnimmt, eine Textdateiquittung erstellt und diese Datei in einen Amazon Simple Storage Service (S3) -Bucket legt. Weitere Informationen darüber, wie Sie Ihre Funktion nach dem Schreiben bereitstellen, finden Sie unterBereitstellen von Lambda-Rust-Funktionen mit ZIP-Dateiarchiven.

Richten Sie Ihr Rust-Handler-Projekt ein

Wenn Sie mit Lambda-Funktionen in Rust arbeiten, umfasst der Prozess das Schreiben Ihres Codes, das Kompilieren und das Bereitstellen der kompilierten Artefakte in Lambda. Der einfachste Weg, ein Lambda-Handler-Projekt in Rust einzurichten, ist die Verwendung der AWS Lambda Runtime for Rust. Trotz ihres Namens ist AWS Lambda Runtime for Rust keine verwaltete Laufzeit im gleichen Sinne wie Lambda für Python, Java oder Node.js. Stattdessen ist die AWS Lambda Runtime for Rust eine crate (lambda_runtime), die das Schreiben von Lambda-Funktionen in Rust und die Anbindung an die Ausführungsumgebung AWS Lambda unterstützt.

Verwenden Sie den folgenden Befehl, um AWS Lambda Runtime for Rust zu installieren:

cargo install cargo-lambda

Verwenden Sie nach erfolgreicher Installation den folgenden Befehlcargo-lambda, um ein neues Rust Lambda Function Handler-Projekt zu initialisieren:

cargo lambda new example-rust

Wenn Sie diesen Befehl ausführen, stellt Ihnen die Befehlszeilenschnittstelle (CLI) einige Fragen zu Ihrer Lambda-Funktion:

Nachdem der Befehl erfolgreich ausgeführt wurde, geben Sie das Hauptverzeichnis Ihres Projekts ein:

cd example-rust

Dieser Befehl generiert eine generic_handler.rs Datei und eine main.rs Datei im src Verzeichnis. Der generic_handler.rs kann verwendet werden, um einen generischen Event-Handler anzupassen. Die main.rs Datei enthält Ihre Hauptanwendungslogik. Die Cargo.toml Datei enthält Metadaten zu Ihrem Paket und listet dessen externe Abhängigkeiten auf.

Beispiel für einen Rust Lambda-Funktionscode

Das folgende Beispiel für einen Rust-Lambda-Funktionscode nimmt Informationen über eine Bestellung auf, erstellt eine Textdateiquittung und legt diese Datei in einen Amazon S3 S3-Bucket.

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
}

Diese main.rs-Datei enthält die folgenden Abschnitte des Codes:

[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"] }

Damit diese Funktion ordnungsgemäß funktioniert, muss ihre Ausführungsrolle die s3:PutObject Aktion zulassen. Stellen Sie außerdem sicher, dass Sie die RECEIPT_BUCKET-Umgebungsvariable definieren. Nach einem erfolgreichen Aufruf sollte der Amazon-S3-Bucket eine Empfangsdatei enthalten.

Gültige Klassendefinitionen für Rust-Handler

In den meisten Fällen haben Lambda-Handler-Signaturen, die Sie in Rust definieren, das folgende Format:

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

Für diesen Handler:

In unserem Beispiel sieht die Handler-Signatur wie folgt aus:

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

Andere gültige Handler-Signaturen können Folgendes enthalten:

Namenskonventionen für Handler

Lambda-Handler in Rust haben keine strengen Namensbeschränkungen. Obwohl Sie einen beliebigen Namen für Ihren Handler verwenden können, sind Funktionsnamen in Rust im Allgemeinen in. snake_case

Für kleinere Anwendungen, wie in diesem Beispiel, können Sie eine einzige main.rs Datei verwenden, die Ihren gesamten Code enthält. Bei größeren Projekten main.rs sollte sie den Einstiegspunkt zu Ihrer Funktion enthalten, aber Sie können zusätzliche Dateien dafür verwenden, um Ihren Code in logische Module zu unterteilen. Beispielsweise könnten Sie die folgende Dateistruktur haben:

/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

Definieren Sie das Eingabeereignisobjekt und greifen Sie darauf zu

JSON ist das gebräuchlichste und standardmäßigste Eingabeformat für Lambda-Funktionen. In diesem Beispiel erwartet die Funktion eine Eingabe ähnlich der folgenden:

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

In Rust können Sie die Form des erwarteten Eingabeereignisses in einer Struktur definieren. In diesem Beispiel definieren wir die folgende Struktur zur Darstellung einesOrder:

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

Diese Struktur entspricht der erwarteten Eingabeform. In diesem Beispiel generiert das #[derive(Deserialize, Serialize)] Makro automatisch Code für die Serialisierung und Deserialisierung. Das bedeutet, dass wir den generischen Eingabe-JSON-Typ mithilfe der Methode in unsere Struktur deserialisieren können. serde_json::from_value() Dies wird in den ersten Zeilen des Handlers veranschaulicht:

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)?;
    ...
}

Sie können dann auf die Felder des Objekts zugreifen. Zum Beispiel holt order.order_id den Wert von order_id aus der ursprünglichen Eingabe.

Vordefinierte Eingabe-Ereignistypen

In der Kiste sind viele vordefinierte Eingabe-Ereignistypen verfügbar. aws_lambda_events Zum Beispiel, wenn Sie beabsichtigen, Ihre Funktion mit API Gateway aufzurufen, einschließlich des folgenden Imports:

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

Stellen Sie dann sicher, dass Ihr Haupthandler die folgende Signatur verwendet:

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

Weitere Informationen zu anderen vordefinierten Eingabe-Ereignistypen finden Sie in der Kiste aws_lambda_events.

Zugreifen auf und Verwenden des Lambda-Kontextobjekts

Das Lambda-Kontextobjekt enthält Informationen über Aufruf, Funktion und Ausführungsumgebung. In Rust enthält der Wrapper das Kontextobjekt. LambdaEvent Sie können beispielsweise das Kontextobjekt verwenden, um die Anforderungs-ID des aktuellen Aufrufs mit dem folgenden Code abzurufen:

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

Weitere Informationen über das Kontextobjekt finden Sie unter Verwenden des Lambda-Kontextobjekts zum Abrufen von Rust-Funktionsinformationen.

Verwenden Sie die AWS SDK for Rust in Ihrem Handler

Oft verwenden Sie Lambda-Funktionen, um mit anderen AWS Ressourcen zu interagieren oder diese zu aktualisieren. Die einfachste Art, eine Schnittstelle zu diesen Ressourcen herzustellen, ist die AWS SDK for RustVerwendung von.

Um Ihrer Funktion SDK-Abhängigkeiten hinzuzufügen, fügen Sie sie zu Ihrer Cargo.toml Datei hinzu. Wir empfehlen, nur die Bibliotheken hinzuzufügen, die Sie für Ihre Funktion benötigen. Im Beispielcode zuvor haben wir die verwendetaws_sdk_s3::Client. In der Cargo.toml Datei können Sie diese Abhängigkeit hinzufügen, indem Sie die folgende Zeile unter dem [dependencies] Abschnitt hinzufügen:

aws-sdk-s3 = "1.78.0"

Importieren Sie dann die Abhängigkeiten direkt in Ihren Code:

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

Der Beispielcode initialisiert dann einen Amazon S3 S3-Client wie folgt:

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

Nachdem Sie Ihren SDK-Client initialisiert haben, können Sie ihn verwenden, um mit anderen Diensten zu interagieren. AWS Der Beispielcode ruft die Amazon S3 PutObject S3-API in der upload_receipt_to_s3 Hilfsfunktion auf.

Zugriff auf Umgebungsvariablen

In Ihrem Handler-Code können Sie mithilfe der env::var-Methode auf beliebige Umgebungsvariablen verweisen. In diesem Beispiel verweisen wir mit der folgenden Codezeile auf die definierte RECEIPT_BUCKET-Umgebungsvariable:

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

Geteilten Zustand verwenden

Sie können geteilte Variablen deklarieren, die unabhängig vom Handler-Code Ihrer Lambda-Funktion sind. Diese Variablen können Ihnen helfen, Zustandsinformationen während des Init-Phase zu laden, bevor Ihre Funktion Ereignisse empfängt. Sie können beispielsweise den Code auf dieser Seite ändern, um den Shared State bei der Initialisierung des Amazon S3 S3-Clients zu verwenden, indem Sie die main Funktion und die Handler-Signatur aktualisieren:

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

Bewährte Codemethoden für Rust-Lambda-Funktionen

Halten Sie sich an die Richtlinien in der folgenden Liste, um beim Erstellen Ihrer Lambda-Funktionen die besten Codierungspraktiken anzuwenden: