rtlambda

rtlambda 是一个 AWS Lambda 的 Rust 运行时以及创建自定义运行时的库。

rtlambda 默认的运行时实现允许您为 AWS Lambda 编写本机 Rust 事件处理器。

您的处理器代码将与运行时一起编译成单个可执行文件，然后部署到 Lambda 服务。

rtlambda 将依赖和复杂性保持在最低，并且不依赖于 tokio。编写 rtlambda 函数既简单又容易。

使用方法

要开始，您可以修改 echo-server 示例

将 rtlambda 和 serde 作为依赖项添加到您的 Cargo.toml 文件中

[dependencies]
rtlambda = "0.0.1"
serde = { version = "1", features = ["derive"] }

并在您的 main.rs 文件中

use rtlambda::prelude::*;
use serde::Serialize;

// Import the [`default_runtime`] macro from rtlambda.
#[macro_use] extern crate rtlambda;

// Create a struct representing the lambda's response, and derive the [`serde::Serialize`] trait.
#[derive(Serialize, Clone)]
struct EchoMessage {
    msg: String,
    req_id: String,
}

// Define output and error types for berevity.
// The Output type must implement [`serde::Serialize`]
type OUT = EchoMessage;
// The error type must implement the `Display` trait
type ERR = String;

// Implement an initialization function.
// The initialization function returns a Result with the Ok type resolving to a dynamically allocated
// closure that accepts the Event from Lambda (as an optional string) and the context object.
// The closure itself returns a Result with the Ok and Err types being the previously defined `OUT` and `ERR` types respectively.
// The initialization function may fail (e.g if a db connection was not succesfully opened, etc..) and in that case
// the function should return an Err variant of the same `ERR` type defined for the event handler.
fn initialize() -> Result<
    Box<dyn Fn(Option<&str>, RefLambdaContext<LambdaRuntimeEnv, UreqResponse>) -> Result<OUT, ERR>>,
    ERR,
> {
    // Your one-time initialization logic goes here:

    //

    // Return the event handler closure
    return Ok(Box::new(move |event, context| {
        // Get the aws request id
        let req_id = context.aws_request_id().unwrap();

        // Unwrap the event string 
        let event = match event {
            Some(v) => v,
            None => {
                return Err(format!(
                    "AWS should not permit empty events. Something strange must've happened."
                ))
            }
        };
        
        if event == "\"\"" {
            return Err(format!("Empty input, nothing to echo."));
        }

        // rtlambda leaves use-case specific concerns such as event JSON deserialization to the handler.
        // In this example we do not deserialize the event. Use serde_json or any other library to perform deserialization if needed.

        // Echo the event back as a string.
        Ok(EchoMessage {
            msg: format!("ECHO: {}", event),
            req_id: req_id.to_string(),
        })

    }));
}

fn main() {
    // Create a runtime instance and run its loop.
    // This is the equivalent of:
    // let mut runtime =  DefaultRuntime::<UreqResponse, UreqTransport, LambdaRuntimeEnv, OUT, ERR>::new(LAMBDA_VER, initialize);
    let mut runtime = default_runtime!(OUT, ERR, LAMBDA_VER, initialize);

    runtime.run();
}

它是如何工作的

您的 main 函数代码创建并运行运行时，该运行时在接收到事件时调用您的处理器，并在出错时处理错误。

典型的设置包括

• 创建一个新的二进制包，并在您的 Cargo.toml 文件中将 rtlambda 作为依赖项包括在内。
• 在 main.rs 文件中导入预导入 - rtlambda::prelude::*
• 编写一个初始化函数，该函数包含一次性初始化代码并返回一个闭包 - 包含事件处理逻辑（Lambda 的业务逻辑）。
• 在您的 main 函数中，创建一个新的 DefaultRuntime，传递 Lambda API 版本和指向您的初始化函数的指针。
• 在运行时实例上调用 run() 方法以启动运行时。