【2026年版】サーバーレスアーキテクチャ設計ガイド：AWS Lambda・Cloudflare Workers・Vercel Functionsの使い分け

# AWS SAM テンプレート
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Globals:
  Function:
    Timeout: 30
    Runtime: nodejs20.x
    MemorySize: 256
    Architectures:
      - arm64

Resources:
  ApiFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: index.handler
      Events:
        Api:
          Type: HttpApi
          Properties:
            Path: /api/{proxy+}
            Method: ANY
      Environment:
        Variables:
          TABLE_NAME: !Ref DynamoDBTable
      Policies:
        - DynamoDBCrudPolicy:
            TableName: !Ref DynamoDBTable

  DynamoDBTable:
    Type: AWS::DynamoDB::Table
    Properties:
      BillingMode: PAY_PER_REQUEST
      AttributeDefinitions:
        - AttributeName: pk
          AttributeType: S
        - AttributeName: sk
          AttributeType: S
      KeySchema:
        - AttributeName: pk
          KeyType: HASH
        - AttributeName: sk
          KeyType: RANGE

// index.mjs
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { DynamoDBDocumentClient, GetCommand, PutCommand } from "@aws-sdk/lib-dynamodb";

const client = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(client);
const TABLE_NAME = process.env.TABLE_NAME;

export const handler = async (event) => {
  const { httpMethod, pathParameters, body } = event;

  try {
    switch (httpMethod) {
      case "GET":
        const getResult = await docClient.send(new GetCommand({
          TableName: TABLE_NAME,
          Key: { pk: pathParameters.id, sk: "ITEM" },
        }));
        return {
          statusCode: 200,
          body: JSON.stringify(getResult.Item || {}),
        };

      case "POST":
        const item = JSON.parse(body);
        await docClient.send(new PutCommand({
          TableName: TABLE_NAME,
          Item: { pk: item.id, sk: "ITEM", ...item },
        }));
        return {
          statusCode: 201,
          body: JSON.stringify({ message: "Created" }),
        };

      default:
        return { statusCode: 405, body: "Method Not Allowed" };
    }
  } catch (error) {
    console.error("Error:", error);
    return { statusCode: 500, body: JSON.stringify({ error: error.message }) };
  }
};

// src/index.ts
import { Hono } from 'hono';
import { cors } from 'hono/cors';
import { cache } from 'hono/cache';

type Bindings = {
  DB: D1Database;
  CACHE: KVNamespace;
  BUCKET: R2Bucket;
};

const app = new Hono<{ Bindings: Bindings }>();

app.use('*', cors());

// キャッシュ付きGETエンドポイント
app.get('/api/items/:id', cache({ cacheName: 'items', cacheControl: 'max-age=60' }), async (c) => {
  const id = c.req.param('id');

  // KVキャッシュを確認
  const cached = await c.env.CACHE.get(`item:${id}`);
  if (cached) {
    return c.json(JSON.parse(cached));
  }

  // D1データベースから取得
  const result = await c.env.DB
    .prepare('SELECT * FROM items WHERE id = ?')
    .bind(id)
    .first();

  if (!result) {
    return c.json({ error: 'Not found' }, 404);
  }

  // KVにキャッシュ（TTL: 300秒）
  await c.env.CACHE.put(`item:${id}`, JSON.stringify(result), { expirationTtl: 300 });

  return c.json(result);
});

// POSTエンドポイント
app.post('/api/items', async (c) => {
  const body = await c.req.json();

  const result = await c.env.DB
    .prepare('INSERT INTO items (name, description, price) VALUES (?, ?, ?)')
    .bind(body.name, body.description, body.price)
    .run();

  return c.json({ id: result.meta.last_row_id, ...body }, 201);
});

export default app;

name = "my-api"
main = "src/index.ts"
compatibility_date = "2026-01-15"

[[d1_databases]]
binding = "DB"
database_name = "my-database"
database_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

[[kv_namespaces]]
binding = "CACHE"
id = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

[[r2_buckets]]
binding = "BUCKET"
bucket_name = "my-bucket"

// app/api/items/[id]/route.ts
import { NextResponse } from 'next/server';
import { kv } from '@vercel/kv';
import { sql } from '@vercel/postgres';

export const runtime = 'edge'; // Edge Functionとして実行

export async function GET(
  request: Request,
  { params }: { params: { id: string } }
) {
  const { id } = params;

  // Vercel KVキャッシュを確認
  const cached = await kv.get(`item:${id}`);
  if (cached) {
    return NextResponse.json(cached);
  }

  // Vercel Postgresから取得
  const { rows } = await sql`SELECT * FROM items WHERE id = ${id}`;

  if (rows.length === 0) {
    return NextResponse.json({ error: 'Not found' }, { status: 404 });
  }

  // KVにキャッシュ（EX: 300秒）
  await kv.set(`item:${id}`, rows[0], { ex: 300 });

  return NextResponse.json(rows[0]);
}

export async function POST(request: Request) {
  const body = await request.json();

  const { rows } = await sql`
    INSERT INTO items (name, description, price)
    VALUES (${body.name}, ${body.description}, ${body.price})
    RETURNING *
  `;

  return NextResponse.json(rows[0], { status: 201 });
}

# メモリとCPUの最適化
# Lambda Power Tuning を使用して最適なメモリサイズを特定
# https://github.com/alexcasalboni/aws-lambda-power-tuning

# Arm64アーキテクチャの利用（x86比で20%安価）
# Graviton2プロセッサによるコスト削減

# 不要なSDKの除外でパッケージサイズを削減
# Lambda Layersの活用で共通ライブラリを共有

# Provisioned Concurrency の適切な設定
# ピーク時間帯のみ有効にすることでコスト削減

// KVキャッシュを活用してD1クエリを減らす
// Workersの無料枠を最大限活用
// 静的アセットはR2 + CDNキャッシュで配信
// Cron Triggersで非同期処理をオフピーク時間に実行

// Vercel Edge Middleware でリクエストを振り分け
// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function middleware(request: NextRequest) {
  const userAgent = request.headers.get('user-agent') || '';
  const isMobile = /Mobile|Android/i.test(userAgent);

  // モバイルとデスクトップで異なるAPIルートに振り分け
  if (request.nextUrl.pathname.startsWith('/api/feed')) {
    const rewriteUrl = isMobile
      ? new URL('/api/feed/mobile', request.url)
      : new URL('/api/feed/desktop', request.url);
    return NextResponse.rewrite(rewriteUrl);
  }

  return NextResponse.next();
}

// 接続の再利用（Lambda/Vercel）
// モジュールスコープで接続を初期化し、ハンドラ間で再利用
import { Pool } from 'pg';

// ハンドラの外で初期化（コールドスタート時のみ実行）
const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
  max: 1, // サーバーレスでは接続数を最小限に
  idleTimeoutMillis: 120000,
});

export async function handler(event: any) {
  // 接続プールを再利用
  const client = await pool.connect();
  try {
    const result = await client.query('SELECT * FROM items WHERE id = $1', [event.id]);
    return { statusCode: 200, body: JSON.stringify(result.rows[0]) };
  } finally {
    client.release();
  }
}

# AWS Lambda - 最小権限の原則
# SAMテンプレートでのポリシー例
Policies:
  - Version: '2012-10-17'
    Statement:
      - Effect: Allow
        Action:
          - dynamodb:GetItem
          - dynamodb:PutItem
        Resource: !GetAtt DynamoDBTable.Arn
      # 不要な権限は付与しない
      # dynamodb:DeleteItem は除外