世界一小さいDockerベースイメージ「scratch」でLambdaを動かす

2026.06.16
世界一小さいDockerベースイメージ「scratch」でLambdaを動かす
この記事をシェアする

AWS Lambda はコンテナイメージでデプロイできます。そのとき多くの人は AWS 提供の Lambda 用ベースイメージ(public.ecr.aws/lambda/...)を使うでしょう。でも実は、あのベースイメージは使わなくてもよいのです。なんなら、中身が空っぽの「世界一小さいベースイメージ」scratch でも Lambda は動きます。理由は、Lambda が求めているのが「Runtime API を喋るプロセス」だけだからです。本記事では scratch で Lambda を動かし、ついでに Runtime API を自力で実装してイメージをどこまで小さくできるか試します。

この記事の要約

巨大なベースイメージ(約40MB)から、中身が空の scratch(約209KB)へ
  • Lambda のコンテナは、AWS 提供のベースイメージでなくても動く。極端な話 scratch(空イメージ)でもよい
  • Lambda が要求するのは「Lambda Runtime API を喋るプロセス」だけ。AWS が配る RIC(Runtime Interface Client)はその実装の1つにすぎない
  • Runtime API は localhost への平文 HTTP なので、外部ライブラリや TLS を使わず自作できる
  • scratch にすると ECR 圧縮後 約209KB(提供ベースイメージは約40MB)。しかもコールドスタートが速い

サンプルコード一式は以下のリポジトリにあります。

https://github.com/s4k4x4r0/demo-scratch-container-lambda-rust-hello-world

1. Lambda で動かせるコンテナの条件

「Lambda のコンテナイメージは、AWS 提供のベースイメージから作る必要がある」と思われがちです。でも、実はそんな決まりはありません。

Lambda の実行環境は、起動したプロセスに対して次に処理すべきリクエストを渡し、結果を受け取る HTTP の API を提供しています。これが Lambda Runtime API です。コンテナの中身がこの API を相手に次のループを回せれば、ベースイメージが何であっても Lambda は動きます。

  1. GET /runtime/invocation/next … 次の呼び出しを待つ(来るまでブロックされる)
  2. 受け取ったイベントを処理する
  3. POST /runtime/invocation/{requestId}/response … 結果を返す

登場人物は3つです。外部からの呼び出しを受け付ける Lambda Service、実行環境内に立っているローカルの Runtime API、そして私たちのコンテナで動く Function。この3者のやり取りを図にすると次のようになります。

Lambda Service・Runtime API・Function が next と response でやり取りするシーケンス図

ポイントは、通信を始めるのは常に Function 側だということです。Function が next を取りに行き(ポーリング)、処理して response を返す。このループを回し続けるのがカスタムランタイムの仕事で、Runtime API はその窓口にすぎません。

AWS が各言語向けに配っている RIC(Runtime Interface Client) は、このループを実装したライブラリです。public.ecr.aws/lambda/... のベースイメージも、それを同梱しているにすぎません。本質的に必要なのは「RIC」でも「Lambda 用ベースイメージ」でもありません。Runtime API を喋るプロセスそのものです。

ということは、その条件さえ満たせばベースイメージは限界まで削れるはずです。その答えが scratch です。

2. 世界一小さい Docker イメージ「scratch」とは

scratch は Docker の特別な予約イメージで、**中身が空(0バイト)**です。OS・シェル・共有ライブラリといったものは何も含まれていません。FROM scratch から始めて、自分のバイナリを 1 個置けば、それがイメージの全内容になります。

普段は Go や Rust のような静的バイナリを 1 個だけ動かすときに使われます。今回はこれを Lambda のベースイメージにしてしまおう、というわけです。「世界一小さいベースイメージ」というのは誇張ではなく、文字どおり空です。

3. まずは scratch で Lambda を動かす

ここでは「普通の書き方」で scratch コンテナを Lambda にデプロイします。Runtime API のループは AWS 公式の lambda_runtime クレート(=RIC)に任せ、ベースイメージだけを scratch にします。

3-1. 構成

項目内容
言語Rust
ターゲットaarch64-unknown-linux-musl(arm64 / 静的バイナリ)
ベースイメージscratch
ランタイム実装lambda_runtime クレート(公式 RIC)

ターゲットに musl を選ぶのがポイントです。musl をターゲットにすると 共有ライブラリに依存しない完全な静的バイナリができ、libc すら無い scratch でも動きます。

3-2. ハンドラのコード

lambda_runtime を使えば、書くのはハンドラ関数だけです。

use lambda_runtime::{service_fn, Error, LambdaEvent};
use serde_json::{json, Value};

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

async fn handler(_event: LambdaEvent<Value>) -> Result<Value, Error> {
    Ok(json!({ "message": "Hello from a scratch container on Lambda!" }))
}
  • lambda_runtime::run が Runtime API のループ(next → response)を回してくれる
  • 開発者は「リクエストが来たら何を返すか」だけ書けばよい

3-3. Dockerfile は scratch + バイナリ 1 個

マルチステージビルドにして、ビルド用ステージでコンパイルし、最終イメージは空っぽの scratch にバイナリをコピーするだけです。

# ビルド用ステージ
FROM rust:1.96-slim AS builder
RUN rustup target add aarch64-unknown-linux-musl
WORKDIR /build
COPY . .
RUN cargo build --release --target aarch64-unknown-linux-musl

# 最終イメージ = 世界一小さいベースイメージ scratch
FROM scratch
COPY --from=builder /build/target/aarch64-unknown-linux-musl/release/bootstrap /bootstrap
ENTRYPOINT ["/bootstrap"]
  • 最終イメージは実質バイナリ 1 個だけ
  • バイナリ名 bootstrap は慣習にすぎず、コンテナでは ENTRYPOINT で起動するため名前は任意

3-4. なぜ scratch で動くのか

シェルや libc が無い空のイメージで動くのは、次の条件が噛み合っているからです。

  • 静的 musl バイナリなので共有ライブラリに依存しない(ldd の結果は not a dynamic executable)
  • Runtime API の接続先は環境変数 AWS_LAMBDA_RUNTIME_API(実行環境内のローカル IP:ポート)なので名前解決が不要。/etc/hosts や resolver が無くても困らない(glibc 静的リンクだとここでハマりがち)
  • 通信が平文 HTTP(localhost)なので TLS や CA 証明書が要らない

デプロイして aws lambda invoke で叩くと、ちゃんと返ってきます。

{"message":"Hello from a scratch container on Lambda!"}

空っぽの scratch に載せたコンテナが、実際の Lambda 上で動きました。

3-5. どれだけ小さくなるか

普段使う AWS 提供のベースイメージ(public.ecr.aws/lambda/provided:al2023)に載せた場合と、ベースを scratch にした場合を比べます。どちらも同じ lambda_runtime 版のバイナリです。

ベースイメージdocker ローカルECR 圧縮後
provided:al2023137MB約40MB
scratch856kB約460KB

ベースイメージを scratch にするだけで、約 40MB が約 460KB になりました。ざっと 89 倍小さい計算です。ここまでで「Lambda 用ベースイメージは必須でない」こと、そして scratch でも普通に動くことを確認できました。

4. どうせなら極限まで:Runtime API を自作する

ここからが本題のおかわりです。せっかく scratch でサイズにこだわるなら、イメージに載っている lambda_runtime クレート(とその依存)も削りたくなります。

第 1 章で見たとおり、Lambda が求めるのは「Runtime API を喋ること」だけ。そして Runtime API は localhost への平文 HTTP。だったら、外部クレートを一切使わず Rust の標準ライブラリ(std)だけで実装できるはずです。RIC というブラックボックスを開けてみましょう。

4-1. ループの本体

やることは第 1 章の 3 ステップそのままです。

fn main() {
    // 実行環境が "127.0.0.1:9001" のような形で注入してくる
    let api = std::env::var("AWS_LAMBDA_RUNTIME_API").expect("未設定");

    // 呼び出しを延々と処理し続けるのがカスタムランタイムの仕事
    loop {
        // 1. 次の呼び出しを取得(来るまでブロックされる)
        let next = http_get(&api, "/2018-06-01/runtime/invocation/next");
        let request_id = header(&next, "lambda-runtime-aws-request-id");

        // 2. 結果を組み立てて返す(今回は固定のJSON)
        let body = br#"{"message":"Hello from a scratch container on Lambda!"}"#;
        http_post(&api, &format!("/2018-06-01/runtime/invocation/{request_id}/response"), body);
    }
}
  • やっているのは「next を GET → response を POST」のループだけ。これが RIC の正体
  • リクエスト ID はレスポンスヘッダ Lambda-Runtime-Aws-Request-Id に入っており、結果を返す URL に埋め込む

4-2. HTTP クライアントも std だけで書く

外部クレートを使わないので、HTTP も自前です。とはいえ難しいことはなく、「TCP でつないで、リクエストの文字列を書き込んで、返事を全部読む」だけです。4-1 で呼んでいた http_get / http_post は、いずれも次の http_request を呼ぶ薄いラッパーだと思ってください。

fn http_request(authority: &str, head: &str, body: &[u8]) -> Vec<u8> {
    // 1. TCP 接続を開く
    let mut stream = std::net::TcpStream::connect(authority).unwrap();
    // 2. リクエスト行 + ヘッダを書き込む(末尾は Connection: close)
    stream.write_all(head.as_bytes()).unwrap();
    // 3. ボディを書き込む
    stream.write_all(body).unwrap();
    // 4. サーバが接続を閉じるまで全部読む
    let mut raw = Vec::new();
    stream.read_to_end(&mut raw).unwrap();
    raw // ヘッダとボディは "\r\n\r\n" で区切られているので後で分割する
}
  • Connection: close を送ると、サーバが応答後に接続を閉じてくれる。だから「最後まで読む(read_to_end)」だけでレスポンスを受け取れる
  • これは hello-world だから成立している割り切り実装。Content-Length 前提で Transfer-Encoding: chunked には未対応であり、サーバが keep-alive を強制すると「最後まで読む」が止まる。イベントのペイロードを本格的にパースする用途には、きちんとした HTTP 処理が必要
  • 正規の RIC はエラー報告エンドポイント(/invocation/{id}/error など)も実装する。ここでは割愛している

Cargo.toml の依存は空です。tokio・hyper・serde を一切使いません。

4-3. どれだけ小さくなったか

lambda_runtime クレート版(実装A)と、std だけの自作版(実装B)を、同じサイズ最適化プロファイルでビルドして比べます。

参考までに、Rust のサイズ最適化プロファイルはこれです。

[profile.release]
opt-level = "z"     # サイズ最小化
lto = true          # リンク時最適化
codegen-units = 1
panic = "abort"     # パニック巻き戻しコードを排除
strip = true        # シンボル除去

結果はこちら。

実装バイナリECR 圧縮後
lambda_runtime クレート約836KB約460KB
std だけで自作約388KB約209KB

自作版はバイナリで約 46%、ECR でも約半分。lambda_runtime が引き込む tokio / hyper といった非同期ランタイムをまるごと削れた分が効いています。最終的に ECR 圧縮後は 約209KB まで縮みました。第3章の提供ベースイメージ(約40MB)と比べると、ざっと 190 倍以上小さい計算です。

なお、この比較は厳密に同条件ではありません。lambda_runtime 版はイベントのペイロードを実際にデシリアライズしているのに対し、自作版は固定の JSON を返すだけです。サイズ差にはこの仕事量の違いも含まれている点に留意してください。

5. おまけ: 小さくして何が嬉しいか(コールドスタート)

「小さくなったのは分かったが、それで何が嬉しいのか」に答えるおまけです。同じ自作バイナリを 2 つのベースに載せて比べます。AWS 提供の provided:al2023 と scratch です。それぞれでコールドスタートの初期化時間(Init Duration)を 20 回ずつ測りました。

ベースイメージECR 圧縮後Init Duration(median, n=20)
provided:al2023約40MB23.41ms
scratch約209KB2.58ms

scratch の方が約 9 倍速いという結果でした。ただし注意したいのは、この差の主因は「イメージのバイト数」ではない、という点です。Lambda はコンテナイメージを遅延ロード(必要な部分だけ取得)+キャッシュするので、サイズそのものは Init Duration にあまり現れません。

ではなぜ差が出たのか。provided ベースは起動時にランタイムのラッパー(初期化処理)を走らせていると考えられます。一方 scratch には自作バイナリ以外に何も無く、その初期化が要りません。つまり「小さい=初期化で動くものが少ない=速い」。バイト数を削ったから速いのではなく、余計なものが何も無いから速い、と理解するのが妥当でしょう。

さいごに

  • Lambda のコンテナは AWS 提供ベースイメージでなくても動く。必要なのは「Runtime API を喋るプロセス」だけ
  • 世界一小さい scratch + 静的 musl バイナリで、ECR 約209KB のイメージが実際に Lambda で動いた(提供ベースは約40MB)
  • Runtime API は localhost の平文 HTTP なので std だけで自作でき、RIC を自作するとイメージはさらに半分に
  • 小さい(=何も無い)と、初期化で動くものが減るぶんコールドスタートも速い

実用性はさておき、「Lambda 用ベースイメージ」をいったん外して中身を覗くと、コンテナ Lambda の仕組みがクリアになります。気になった方はぜひ手元で scratch を動かしてみてください。

この記事をシェアする
著者:酒井亮太郎
シナモロール