はじめに

LambdaをRustで書く機会がありました。
LambdaはRustを標準でサポートしているわけではないので、通常であればカスタムランタイムを使うことになると思います。
一見大変そう...と感じるかもしれませんが、cargo-lambdaとcargo-lambda-cdkを用いることによって、快適に開発を進められました。

今回の記事では簡単なAPIをハンズオンで実装することでそのtipsをお伝えできればと思っています。
本記事では,POSTすることでDynamoDBにレコード追加をするLambda,
GETすることで作成したレコードの一覧を返すLambdaの2つをcargo-lambda, cargo-lambda-cdkを用いて定義・デプロイしたいと思います。

cargo-lambda, cargo-lambda-cdkとは？

cargo-lambdaとは

ひとことで言ってしまえばRust + Lambda開発のためのcargoのサブコマンドです。
cargo-lambdaの嬉しいところは/binの中にバイナリファイル複数作っておけばそれごとにlambdaを作成できるのでモジュールの再利用等がしやすい点です。
また、cargo lambda watchコマンドで、lambdaをローカルで実行できる点も非常に嬉しいです。
一般的なCDK + Lambdaの開発だとLambdaのローカル実行はsam localやlocalstackを使用することになると思いますがコマンド１個ですぐにローカル実行できるのは便利です。

今回の記事でもこれらの点を含めてご紹介できればと思っています。

cargo-lambda-cdkとは

cargo-lambda単体でも十分便利なのですが、たとえばS3を作成する、DynamoDBを作成するなどといったリソース付与だったり、IAMロールの付与だったりができません。
この辺はCDKだったりserverless frameworkだったりのいわゆるIaCツールが得意なところですので、ちゃっちゃとやってしまいたいところです。
ですが、Lambdaをカスタムランタイムを設定しなくてはいけないしなんだかめんどくさそう...
↑を解決してくれるのがcargo-lambda-cdkというnpm packageです。
こちらを用いることでCDKでRustFunctionというモジュールを定義できるようになり、
以下の様に簡単にLambdaを定義できるようになります。

    const lambda = new RustFunction(this, 'sample-lambda', {
      manifestPath: path.join(__dirname, '..', 'lambda', 'Cargo.toml'),
      binaryName: 'lambda1',
      vpc: vpc,
      vpcSubnets: {
        subnets: config.lambda.subnets.map((subnet, idx) => Subnet.fromSubnetId(this, `subnet-${idx}`, subnet))
      },
      allowPublicSubnet: false,
      environment: {
        REGION: config.region,
      },
    })

インストール

Rust, cargo

aws-cdk

初めて設定する方はaws configureで認証情報を設定してください。

cargo-lambda

DynamoDBテーブル・作成API定義

さて、今回実装するAPIで操作するDynamoDBのテーブルを定義します。
今回はここが本質ではないので非常に簡易なテーブルとしました。
PKをname, SKをcreatedAtとして、追加でmessageを持つようなテーブルとします。

また、レコード作成のリクエストはnameとmessageをrequest bodyに入れてPOSTリクエストするようにします。
つまりはput-recordのリクエストの想定は以下のような感じです。

$ http POST <endpoint> name=haw_ohnuma message=hoge

GETに関しては全てのレコードを返すだけなのでただ単にエンドポイントにリクエストを投げるだけにします。

$ http <endpoint>

Lambda

lambda	method	処理
put-record	POST	DynamoDBにリクエストされたレコードを追加する
get-records	GET	DynamoDBのレコード一覧を返す

DynamoDB

key	型	設定例
name(PK)	String	haw_ohnuma
createdAt	String	2024-09-27T13:23:55.941840+09:00
message	String	hello cargo lambda

CDKリポジトリ作成 & cargo-lambda-cdk導入

各種インストールが済んだらcdk initしましょう。
cargo-lambda-cdkがnpm packageのため、CDKの言語はjsかtsを選択してください。
自分はtypescriptを選択します。

$ mkdir sample-rust-api && cd sample-rust-api
$ cdk init sample-app --language typescript

initが終わったらついでにcargo-lambda-cdkをインストールしちゃいましょう。

$ npm i cargo-lambda-cdk

これで準備は整いました。
cargo-lambdaを使ってRustでLambdaを実装していきましょう！

cargo-lambdaでのLambdaの実装

cargo lambda new

Lambdaの作業環境を作ります。今回はCDKリポジトリ内のlambdaというディレクトリを作成します。
するとHTTP Functionを作るのか聞かれます。今回はAPI開発ですのでYesで作成します。

$ cargo lambda new lambda
> Is this function an HTTP function? Yes

すると、新しいcargo PJが/lambdaに作成されます。

$ tree lambda
lambda
├── Cargo.lock
├── Cargo.toml
└── src
    └── main.rs

これでプロジェクトの初期設定は以上となります。

(tips)初期生成コードのローカル実行

src/main.rsに初期生成コードが作成されています。
自分の環境では以下のようなコードが生成されていました。

use lambda_http::{run, service_fn, tracing, Body, Error, Request, RequestExt, Response};

/// This is the main body for the function.
/// Write your code inside it.
/// There are some code example in the following URLs:
/// - https://github.com/awslabs/aws-lambda-rust-runtime/tree/main/examples
async fn function_handler(event: Request) -> Result<Response<Body>, Error> {
    // Extract some useful information from the request
    let who = event
        .query_string_parameters_ref()
        .and_then(|params| params.first("name"))
        .unwrap_or("world");
    let message = format!("Hello {who}, this is an AWS Lambda HTTP request");

    // Return something that implements IntoResponse.
    // It will be serialized to the right response event automatically by the runtime
    let resp = Response::builder()
        .status(200)
        .header("content-type", "text/html")
        .body(message.into())
        .map_err(Box::new)?;
    Ok(resp)
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    tracing::init_default_subscriber();

    run(service_fn(function_handler)).await
}

何をやっているのでしょうか？
これをローカルで動かしてみましょう。

$ cd lambda
$ cd cargo lambda watch
 INFO invoke server waiting for requests socket_addr=[::]:9000
 INFO starting lambda function function="_" manifest="Cargo.toml" cmd=Exec { prog: "cargo", args: ["run", "--manifest-path", "Cargo.toml", "--color", "auto"] }
	Compiling pin-project-lite v0.2.14
	Compiling itoa v1.0.11
	Compiling memchr v2.7.4
	Compiling futures-core v0.3.30
	Compiling futures-sink v0.3.30
	Compiling slab v0.4.9

		.....
	 
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.26s
     Running `target/debug/lambda`

するとローカルサーバーがポート9000番に立ち上がります。

curlでもpostmanでもなんでもいいのでリクエストしてみましょう。
自分はHTTPieを使っています。

$ http :9000

Hello world, this is an AWS Lambda HTTP request

Hello worldが返ってきました。コードをよく見ると、

    let who = event
        .query_string_parameters_ref()
        .and_then(|params| params.first("name"))
        .unwrap_or("world");
    let message = format!("Hello {who}, this is an AWS Lambda HTTP request");

これが返されていることがわかります。さきほどのリクエストではnameに何も値を入れなかったのでunwrap_orの値が返されていました。
そこで、query string parameterにnameを設定してリクエストしてみましょう。

$ http :9000 name==haw_ohnuma

Hello haw_ohnuma, this is an AWS Lambda HTTP request

正しくローカルで実行できていそうです。
こんな簡単にlambdaの挙動をローカルで検証できました。

put-record API実装

それではDynamoDBへのリクエスト処理を実装していきます。

まずはAWS SDKのクレートを導入していきます。
Cargo.tomlに下記を追加してcargo buildしてください。

[dependencies]
lambda_http = "0.13.0"

tokio = { version = "1", features = ["macros"] }
aws-config = { version = "1", features = ["behavior-version-latest"] }
aws-sdk-dynamodb = "1"
serde_dynamo = { version = "4", features = ["aws-sdk-dynamodb+1"] }

ちなみにですがAWS SDK for Rustは2023年11月にめでたくGAされました。安心して使えますね。

また、Event Bodyのパースのためにserde, createdAt取得のためにchronoエラー処理のためにanyhowを用います。
それぞれCargo.tomlに追加しましょう。

[dependencies]
lambda_http = "0.13.0"

tokio = { version = "1", features = ["macros"] }
aws-config = { version = "1", features = ["behavior-version-latest"] }
aws-sdk-dynamodb = "1"
serde_dynamo = { version = "4", features = ["aws-sdk-dynamodb+1"] }
serde = {version = "1.0", features = ["derive"]}
serde_json = "1.0"
anyhow = { version = "1.0.70", features = ["backtrace", "std"] }
chrono = "0.4"
chrono-tz = "0.6"

まずは、put-recordのエントリポイント用にlambda/src/bin/put-record.rsを作成してください。
また、共用モジュールの一括管理のために、lambda/src/lib.rsを作成しておいてください。
treeでみるとこんな感じです。

$ tree -I target ../lambda
  
../lambda
├── Cargo.lock
├── Cargo.toml
└── src
    ├── bin
    │   └── put-record.rs
    └── lib.rs

それではput-record.rsに以下を追加してください。

use std::collections::HashMap;

use anyhow::{anyhow, Result};
use aws_config::SdkConfig;
use aws_sdk_dynamodb::{config::Credentials, Client};
use chrono::Utc;
use chrono_tz::Asia::Tokyo;
use lambda::{format_json_response, DynamoItem};
use lambda_http::{run, service_fn, tracing, Body, Error, Request, Response};
use serde::{Deserialize, Serialize};
use serde_dynamo::aws_sdk_dynamodb_1::to_item;
use serde_json::json;

#[derive(Deserialize, Serialize)]
struct EventBody {
    name: String,
    message: String,
}

fn get_current_datetime_in_tokyo() -> String {
    let now_utc = Utc::now();
    let now_tokyo = now_utc.with_timezone(&Tokyo);
    now_tokyo.to_rfc3339()
}

fn parse_event_body(body: &Body) -> Result<EventBody> {
    let str_body = match body {
        Body::Text(text) => text,
        _ => return Err(anyhow!("invalid event body format")),
    };
    let parsed_body: EventBody = serde_json::from_str(str_body)?;
    Ok(parsed_body)
}

async fn get_aws_clinet_config(is_offline: &str) -> SdkConfig {
    match is_offline {
        "true" => {
            let credentials = Credentials::new(
                "aws_access_key_id",
                "aws_secret_access_key",
                None,
                None,
                "offline",
            );
            aws_config::from_env()
                .endpoint_url("http://localhost:8000")
                .credentials_provider(credentials)
                .load()
                .await
        }
        "false" => aws_config::load_from_env().await,
        _ => unreachable!("failed to get is_offline flag"),
    }
}

async fn function_handler(event: Request) -> Result<Response<Body>> {
    let envs = std::env::vars().collect::<HashMap<_, _>>();
    let is_offline = envs
        .get("IS_OFFLINE")
        .unwrap_or(&String::from("false"))
        .to_owned();
    let table_name = envs
        .get("TABLE_NAME")
        .unwrap()
        .to_owned();
    let config = get_aws_clinet_config(&is_offline).await;
    let client = Client::new(&config);
    let body = event.body();
    let event_body = parse_event_body(body)?;
    let current_date_time = get_current_datetime_in_tokyo();
    let item: DynamoItem = DynamoItem {
        name: event_body.name,
        message: event_body.message,
        date: current_date_time,
    };
    client
        .put_item()
        .table_name(table_name)
        .set_item(Some(to_item(item).unwrap()))
        .send()
        .await?;

    format_json_response(200, &json!({"result": "ok"}).to_string())
}

#[tokio::main]
async fn main() -> Result<()> {
    tracing::init_default_subscriber();
    run(service_fn(|event| async move {
        function_handler(event).await.map_err(Error::from)
    }))
    .await
    .map_err(|e| anyhow!(e.to_string()))
}

そして、lib.rsに以下を実装します。

use anyhow::Result;
use lambda_http::{http::StatusCode, Body, Response};
use serde::{Deserialize, Serialize};

pub fn format_json_response(status_code: u16, body: &str) -> Result<Response<Body>> {
    let resp = Response::builder()
        .status(StatusCode::from_u16(status_code).unwrap())
        .header("content-type", "application/json")
        .body(body.into())
        .map_err(Box::new)?;
    Ok(resp)
}

#[derive(Deserialize, Serialize)]
pub struct DynamoItem {
    pub name: String,
    pub date: String,
    pub message: String,
}

急に完成物を見せてしまいましたが、特段難しいことはしていません。
handlerの上から順にお気持ちを書いておきます。

Event Body

#[derive(Deserialize, Serialize)]
struct EventBody {
    name: String,
    message: String,
}

fn parse_event_body(body: &Body) -> Result<EventBody> {
    let str_body = match body {
        Body::Text(text) => text,
        _ => return Err(anyhow!("invalid event body format")),
    };
    let parsed_body: EventBody = serde_json::from_str(str_body)?;
    Ok(parsed_body)
}


...


    let body = event.body();
    let event_body = parse_event_body(body)?;

今回はリクエストボディにnameとmessageを与えてリクエストする想定ですので、
その構造体を定義してあげて、serdeでパースしてあげます。

config取得箇所

async fn get_aws_clinet_config(is_offline: &str) -> SdkConfig {
    match is_offline {
        "true" => {
            let credentials = Credentials::new(
                "aws_access_key_id",
                "aws_secret_access_key",
                None,
                None,
                "offline",
            );
            aws_config::from_env()
                .endpoint_url("http://localhost:8000")
                .credentials_provider(credentials)
                .load()
                .await
        }
        "false" => aws_config::load_from_env().await,
        _ => unreachable!("failed to get is_offline flag"),
    }
}

aws clientのconfigを掴む関数です。
ローカル実行とそうでないときの条件分岐を簡単にしたかったので、こんな関数を用意しています。
環境変数に設定されたIS_OFFLINEが"true"になっていた場合に設定したcredential情報を持って、endpoint_urlに設定されたエンドポイントへリクエストを投げます。
このような関数を用意しておくことで、

$ IS_OFFLINE=true cargo lambda watch

とコマンドを叩くことで簡単にローカルへリクエストを飛ばせるということです。

DynamoDBへのリクエスト

use serde_dynamo::aws_sdk_dynamodb_1::to_item;

    let item: DynamoItem = DynamoItem {
        name: event_body.name,
        message: event_body.message,
        date: current_date_time,
    };
    client
        .put_item()
        .table_name(table_name)
        .set_item(Some(to_item(item).unwrap()))
        .send()
        .await?;

Rustの型堅牢さゆえに通常putItemを実行するのはちまちまと一つ一つのキーを指定して書かなくてはならないのですが、
serde_dynamoという偉大なるクレートのおかげでだいぶ簡単に書くことができます。

ここでは詳しく説明しませんがみんな大好きクラメソさんが記事にしてくれているので気になる方は以下の記事をご覧ください。

作成物のローカル実行

それでは作ったコードをローカルで実行して正しく動作することを確認してみましょう。
DynamoDBのローカルでのエミュレータはDynamoDB localを用います。

docker-compose.ymlを作成して下記を追加してください。
これで先ほどIS_OFFLINEがtrueの時にendpoint_urlに指定したhttp://localhost:8000にDynamoDBを構えることができます。

services:
  dynamodb:
    image: amazon/dynamodb-local:1.21.0
    ports:
      - 8000:8000
    volumes:
      - ./.storage/dynamodb:/data

volumes:
  dynamodb:

ローカル実行でのAWSのクレデンシャル設定をするため、~/.aws/configに以下を追加します。

[profile local]
aws_access_key_id = aws_access_key_id
aws_secret_access_key = aws_secret_access_key
region = ap-northeast-1

次に、テーブルを作成します。
実際にデプロイする際はこの辺の定義はCDKで行なってしまうので今回は若干めんどくさいですがCLIで以下のコマンドを叩きます。

$ aws dynamodb create-table \
	--table-name sample-rust-api-table-local \
	--attribute-definitions \
			AttributeName=name,AttributeType=S \
			AttributeName=date,AttributeType=S \
	--key-schema \
			AttributeName=name,KeyType=HASH \
			AttributeName=date,KeyType=RANGE \
	--billing-mode PAY_PER_REQUEST --endpoint-url http://localhost:8000 --profile local --region ap-northeast-1

{
    "TableDescription": {
        "AttributeDefinitions": [
            {
                "AttributeName": "name",
                "AttributeType": "S"
            },
            {
                "AttributeName": "date",
                "AttributeType": "S"
            }
        ],
        "TableName": "sample-rust-api-table-local",
        "KeySchema": [
            {
                "AttributeName": "name",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "date",
                "KeyType": "RANGE"
            }
        ],
        "TableStatus": "ACTIVE",
        "CreationDateTime": "2024-09-27T13:23:26.221000+09:00",
        "ProvisionedThroughput": {
            "LastIncreaseDateTime": "1970-01-01T09:00:00+09:00",
            "LastDecreaseDateTime": "1970-01-01T09:00:00+09:00",
            "NumberOfDecreasesToday": 0,
            "ReadCapacityUnits": 0,
            "WriteCapacityUnits": 0
        },
        "TableSizeBytes": 0,
        "ItemCount": 0,
        "TableArn": "arn:aws:dynamodb:ddblocal:000000000000:table/sample-rust-api-table-local",
        "BillingModeSummary": {
            "BillingMode": "PAY_PER_REQUEST",
            "LastUpdateToPayPerRequestDateTime": "2024-09-27T13:23:26.221000+09:00"
        }
    }
}

テーブルが作成できたので以下のコマンドでローカル起動して、リクエストしてみましょう。
/binにエントリポイントを定義した場合には:9000/lambda-url/<filename>でリクエストします。

$ IS_OFFLINE=true TABLE_NAME=sample-rust-api-table-local cargo lambda watch
$ http POST :9000/lambda-url/put-record name=haw_ohnuma message=hoge

{
    "result": "ok"
}

が返ってくれば成功です。ちゃんとputできているかscanして確認してみます。

$ aws dynamodb scan --table-name sample-rust-api-table-local --endpoint-url http://localhost:8000 --region ap-northeast-1 --profile local

{
    "Items": [
        {
            "date": {
                "S": "2024-09-27T14:26:52.607810+09:00"
            },
            "message": {
                "S": "hoge"
            },
            "name": {
                "S": "haw_ohnuma"
            }
        }
    ],
    "Count": 1,
    "ScannedCount": 1,
    "ConsumedCapacity": null
}

正しくputができていそうです！

get-records API実装

それでは次もサクッと実装してしまいましょう。
bin/get-records.rsを作成して以下を追加してください。

use std::collections::HashMap;

use anyhow::{anyhow, Result};
use aws_config::SdkConfig;
use aws_sdk_dynamodb::{config::Credentials, Client};
use lambda::{format_json_response, DynamoItem};
use lambda_http::{run, service_fn, tracing, Body, Error, Request, Response};
use serde_dynamo::aws_sdk_dynamodb_1::from_item;
use serde_json::json;


async fn get_aws_clinet_config(is_offline: &str) -> SdkConfig {
    match is_offline {
        "true" => {
            let credentials = Credentials::new(
                "aws_access_key_id",
                "aws_secret_access_key",
                None,
                None,
                "offline",
            );
            aws_config::from_env()
                .endpoint_url("http://localhost:8000")
                .credentials_provider(credentials)
                .load()
                .await
        }
        "false" => aws_config::load_from_env().await,
        _ => unreachable!("failed to get is_offline flag"),
    }
}

async fn function_handler(_event: Request) -> Result<Response<Body>> {
    let envs = std::env::vars().collect::<HashMap<_, _>>();
    let is_offline = envs
        .get("IS_OFFLINE")
        .unwrap_or(&String::from("false"))
        .to_owned();
    let table_name = envs.get("TABLE_NAME").unwrap().to_owned();
    let config = get_aws_clinet_config(&is_offline).await;
    let client = Client::new(&config);
    let output = client.scan().table_name(table_name).send().await.unwrap();
    let items = output
        .items
        .unwrap()
        .into_iter()
        .map(|item| {
            let dynamo_item: DynamoItem = from_item(item).unwrap();
            dynamo_item
        })
        .collect::<Vec<DynamoItem>>();

    format_json_response(200, &json!({"items": items}).to_string())
}

#[tokio::main]
async fn main() -> Result<()> {
    tracing::init_default_subscriber();
    run(service_fn(|event| async move {
        function_handler(event).await.map_err(Error::from)
    }))
    .await
    .map_err(|e| anyhow!(e.to_string()))
}

こちらのコードに関しては先ほどのコードで説明した以上のお気持ち解説がありませんでした...
from_item(item)でHashMap<String, AttributeValue>をDynamoItemにパースしてくれています。serde_dynamoありがたや...

作成物のローカル実行

こちらは全レコードの出力だったので特段リクエストに何かを込めるみたいなことはしてないのでそのまま実行します。
せっかくなので、先ほど作ったputのAPIで少しレコードを増やしてから実行しています。

$ http POST :9000/lambda-url/get-records

{
    "items": [
        {
            "date": "2024-09-27T14:47:17.549288+09:00",
            "message": "piyo",
            "name": "haw_ohnuma3"
        },
        {
            "date": "2024-09-27T14:47:06.981753+09:00",
            "message": "fuga",
            "name": "haw_ohnuma2"
        },
        {
            "date": "2024-09-27T14:26:52.607810+09:00",
            "message": "hoge",
            "name": "haw_ohnuma"
        }
    ]
}

いい感じに取得できています！
簡単ではありましたが、Rustを使ったLambdaの実装は以上になります。

CDKでAWSリソースの定義

さて、最後にAWSリソースの定義をCDKで宣言して先ほど実装したLambdaを実際にAWSにデプロイしましょう。
ここからはRustは使わず、Typescriptでの記述になります。

一旦lambdaディレクトリから抜けて、CDKリポジトリ直下に移動しましょう。

lib/sample-rust-api-stack.tsにリソースを定義していきましょう！

import { Duration, RemovalPolicy, Stack, StackProps } from 'aws-cdk-lib';
import { LambdaIntegration, RestApi } from 'aws-cdk-lib/aws-apigateway';
import { AttributeType, BillingMode, Table } from 'aws-cdk-lib/aws-dynamodb';
import { RustFunction } from 'cargo-lambda-cdk';
import { Construct } from 'constructs';
import * as path from 'path'

export class SampleRustApiStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);
    const prefix = 'sample-rust-api'
    const tableName = `${prefix}-table`

    // Lambdaの定義
    const putRecordLambda = new RustFunction(this, 'put-record', {
      functionName: `${prefix}-put-record`,
      manifestPath: path.join(__dirname, '..', 'lambda', 'Cargo.toml'),
      binaryName: 'put-record',
      environment: {
        TABLE_NAME: tableName
      },
    })
    const getRecordsLambda = new RustFunction(this, 'get-records', {
      functionName: `${prefix}-get-records`,
      manifestPath: path.join(__dirname, '..', 'lambda', 'Cargo.toml'),
      binaryName: 'get-records',
      environment: {
        TABLE_NAME: tableName
      },
    })

    // DynamoDBの定義
    const table = new Table(this, tableName, {
      tableName: tableName,
      partitionKey: {
        name: 'name',
        type: AttributeType.STRING,
      },
      sortKey: {
        name: 'date',
        type: AttributeType.STRING,
      },
      billingMode: BillingMode.PAY_PER_REQUEST,
      removalPolicy: RemovalPolicy.DESTROY,
    });

    // Lambdaに対してテーブルの読み書きロール付与
    table.grantReadWriteData(putRecordLambda)
    table.grantReadWriteData(getRecordsLambda)

    // API Gatewayの定義
    const apiGateway = new RestApi(this, "api-gateway", {
      restApiName: `${prefix}-apigateway`,
    });

    const apiPath = apiGateway.root;
    // rootのPOSTにputRecordLambdaを紐付け
    apiPath.addMethod(
      "POST",
      new LambdaIntegration(putRecordLambda, {
        allowTestInvoke: false,
      }),
    );

    // rootのGETにputRecordLambdaを紐付け
    apiPath.addMethod(
      "GET",
      new LambdaIntegration(getRecordsLambda, {
        allowTestInvoke: false,
      }),
    );
  }
}

Lambda

ここでやっとcargo-lambda-cdkの出番です。

import { RustFunction } from 'cargo-lambda-cdk';

...

    const putRecordLambda = new RustFunction(this, 'put-record', {
      functionName: `${prefix}-put-record`,
      manifestPath: path.join(__dirname, '..', 'lambda', 'Cargo.toml'),
      binaryName: 'put-record',
      environment: {
        TABLE_NAME: tableName
      },
    })

manifestPathに作成したCargo.tomlのパスを指定してあげます。
また、binaryNameにこのLambdaにデプロイするファイルを指定してあげます。
これで、このLambdaは先ほど実装したコードのbin/put-record.rsをエントリポイントとして定義できるというわけです。
これだけ？と思うかもしれませんが、たったこれだけでカスタムランタイムのRustを定義できてしまうのがcargo-lambda-cdkの魅力です！

DynamoDB

    const table = new Table(this, tableName, {
      tableName: tableName,
      partitionKey: {
        name: 'name',
        type: AttributeType.STRING,
      },
      sortKey: {
        name: 'date',
        type: AttributeType.STRING,
      },
      billingMode: BillingMode.PAY_PER_REQUEST,
      removalPolicy: RemovalPolicy.DESTROY,
    });

    // Lambdaに対してテーブルの読み書きロール付与
    table.grantReadWriteData(putRecordLambda)
    table.grantReadWriteData(getRecordsLambda)

DynamoDBの宣言です。
PKにname, SKにdateをそれぞれ文字列型で宣言しています。

またremovalPolicyにDESTROYを設定しないとCloudFormation Stackを削除したときに合わせてテーブルを削除してくれません。
今回はハンズオンのサンプルStackですので後片付けしやすいようにこちらを設定しています。

grantReadWriteDataでこのDBへの読み書き許可ロールをLambdaに付与してあげています。
たったこれだけの記述でロールが付与できるところがCDKが好きな理由の一つです。

API Gateway

    const apiGateway = new RestApi(this, "api-gateway", {
      restApiName: `${prefix}-apigateway`,
    });

    const apiPath = apiGateway.root;
    // rootのPOSTにputRecordLambdaを紐付け
    apiPath.addMethod(
      "POST",
      new LambdaIntegration(putRecordLambda, {
        allowTestInvoke: false,
      }),
    );

    // rootのGETにputRecordLambdaを紐付け
    apiPath.addMethod(
      "GET",
      new LambdaIntegration(getRecordsLambda, {
        allowTestInvoke: false,
      }),
    );

API Gatewayのルートにメソッドを定義しています。
また、そのメソッドにLambdaIntegrationを使ってLambda統合をひっかけています。
このようにしてrootのPOSTメソッドが呼ばれることでputRecordLambdaを発火できるようにしています。

ここまでできればリソースの準備も完了です！デプロイしましょう。

$ CDK_REGION=ap-northeast-1 npm run cdk deploy

正しくデプロイが終了すれば完了です！

動作確認

マネコンに移動してLambdaが正しくデプロイできているか確認してみましょう。

カスタムランタイムのLambdaが生まれていることがわかります！
また、DynamoDBテーブルも確認しましょう。

パーティションキー、ソートキーも正しく設定され、デプロイできていそうですね。

ここまで確認できればAPI GatewayのエンドポイントURLを取得して、APIにリクエストをしてみましょう。

$ http POST <endpoint> name=haw_ohnuma message="hello world from cargo lambda"
$ http <endpoint>

{
    "items": [
        {
            "date": "2024-09-27T15:17:16.933958463+09:00",
            "message": "cargo-lambdaとcargo-lambda-cdkを使ってDynamoDBにレコードを格納できました！",
            "name": "haw_ohnuma2"
        },
        {
            "date": "2024-09-27T15:15:47.074315362+09:00",
            "message": "hello world from cargo lambda",
            "name": "haw_ohnuma"
        },
        {
            "date": "2024-09-27T15:17:48.993830117+09:00",
            "message": "hogehogehogehogeho",
            "name": "haw_ohnuma"
        }
    ]
}

実際にマネコンからもDynamoDBレコードが作成されていることを確認できます！
正しく動作していそうです！

ここまでできれば今回のcargo-lambda, cargo-lambda-cdkを使ったRustを使ったLambdaのAPI開発はおしまいです。ありがとうございました！

後片付け

マネコンのCloudFormationからStackの削除を実行することでまとめて消せます。

おわりに

cargo-lambda, cargo-lambda-cdkを用いたRustでのLambda開発の流れをハンズオン形式で紹介してみました。
誰かのお役に立てる記事となれば幸いです。
もっとこうしたほうがイイ！こここう書ける！みたいなことあったらコメントにて教えてください。