Claude API trên Serverless — Cloudflare Workers và AWS Lambda

Serverless computing cho phép bạn chạy Claude API mà không cần quản lý server — không cần provision, không cần patch, không cần lo scale. Bạn chỉ trả tiền cho thời gian thực thi thực tế. Bài viết này hướng dẫn chi tiết cách triển khai Claude API trên hai nền tảng serverless phổ biến nhất: Cloudflare Workers và AWS Lambda, kèm phân tích chi phí và các kỹ thuật tối ưu.

Tại sao Serverless cho Claude API

Trước khi triển khai, hãy hiểu khi nào serverless là lựa chọn đúng và khi nào nên dùng server truyền thống.

Ưu điểm của serverless

• Pay-per-use: Chỉ trả tiền khi có request. Nếu ứng dụng có traffic thấp hoặc bursty, chi phí thấp hơn nhiều so với server chạy 24/7.
• Auto-scale: Tự động mở rộng từ 0 đến hàng nghìn concurrent requests mà không cần cấu hình.
• Zero ops: Không cần quản lý OS, patches, hoặc infrastructure. Tập trung vào code.
• Global distribution: Đặc biệt với Cloudflare Workers — code chạy ở edge, gần người dùng nhất.

Khi nào KHÔNG nên dùng serverless

• Traffic ổn định cao: Nếu server chạy 80%+ capacity liên tục, always-on rẻ hơn
• Long-running tasks: Lambda timeout tối đa 15 phút, Workers timeout 30 giây (có thể mở rộng). Nếu Claude response mất quá lâu, cần workaround.
• Cần persistent connections: WebSocket long-lived connections phức tạp hơn trên serverless
• Complex state: Serverless là stateless. Nếu cần giữ state phức tạp giữa các request, cần thêm external storage.

Cloudflare Workers Implementation

Cloudflare Workers chạy trên V8 isolates (không phải containers), cho cold start gần bằng 0 và latency cực thấp. Đây là lựa chọn tốt nhất nếu ưu tiên tốc độ phản hồi.

Setup dự án

# Cài đặt Wrangler CLI
npm install -g wrangler

# Tạo project mới
wrangler init claude-worker
cd claude-worker

# Cấu hình wrangler.toml
cat wrangler.toml

Cấu hình wrangler.toml

name = "claude-api-worker"
main = "src/index.ts"
compatibility_date = "2024-01-01"

[vars]
ALLOWED_ORIGINS = "https://your-domain.com"

# Không đặt API key ở đây — dùng secrets
# wrangler secret put ANTHROPIC_API_KEY

Code Worker chính

// src/index.ts
interface Env {
  ANTHROPIC_API_KEY: string;
  ALLOWED_ORIGINS: string;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    // CORS headers
    const corsHeaders = {
      "Access-Control-Allow-Origin": env.ALLOWED_ORIGINS,
      "Access-Control-Allow-Methods": "POST, OPTIONS",
      "Access-Control-Allow-Headers": "Content-Type, Authorization",
    };

    // Handle preflight
    if (request.method === "OPTIONS") {
      return new Response(null, { headers: corsHeaders });
    }

    if (request.method !== "POST") {
      return new Response("Method not allowed", {
        status: 405,
        headers: corsHeaders
      });
    }

    try {
      const body = await request.json() as {
        message: string;
        system?: string;
        max_tokens?: number;
      };

      // Validate input
      if (!body.message || body.message.length > 10000) {
        return new Response(
          JSON.stringify({ error: "Invalid message" }),
          { status: 400, headers: { ...corsHeaders, "Content-Type": "application/json" } }
        );
      }

      // Gọi Claude API
      const claudeResponse = await fetch(
        "https://api.anthropic.com/v1/messages",
        {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
            "x-api-key": env.ANTHROPIC_API_KEY,
            "anthropic-version": "2023-06-01",
          },
          body: JSON.stringify({
            model: "claude-sonnet-4-20250514",
            max_tokens: body.max_tokens || 1024,
            system: body.system || "Ban la tro ly AI huu ich.",
            messages: [
              { role: "user", content: body.message }
            ],
          }),
        }
      );

      const result = await claudeResponse.json();

      return new Response(JSON.stringify(result), {
        headers: {
          ...corsHeaders,
          "Content-Type": "application/json",
        },
      });
    } catch (error) {
      return new Response(
        JSON.stringify({ error: "Internal server error" }),
        {
          status: 500,
          headers: { ...corsHeaders, "Content-Type": "application/json" },
        }
      );
    }
  },
};

Streaming Response trên Workers

Claude API hỗ trợ streaming — trả về từng phần response thay vì đợi toàn bộ. Trên Workers, bạn dùng TransformStream:

async function handleStreaming(request: Request, env: Env): Promise<Response> {
  const body = await request.json() as { message: string };

  const claudeResponse = await fetch(
    "https://api.anthropic.com/v1/messages",
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-key": env.ANTHROPIC_API_KEY,
        "anthropic-version": "2023-06-01",
      },
      body: JSON.stringify({
        model: "claude-sonnet-4-20250514",
        max_tokens: 1024,
        stream: true,
        messages: [{ role: "user", content: body.message }],
      }),
    }
  );

  // Pipe stream trực tiếp từ Claude đến client
  return new Response(claudeResponse.body, {
    headers: {
      "Content-Type": "text/event-stream",
      "Cache-Control": "no-cache",
      "Connection": "keep-alive",
    },
  });
}

Deploy

# Set API key (chỉ cần làm 1 lần)
wrangler secret put ANTHROPIC_API_KEY

# Deploy
wrangler deploy

# Test
curl -X POST https://claude-api-worker.your-account.workers.dev   -H "Content-Type: application/json"   -d '{"message": "Xin chao Claude!"}'

AWS Lambda Implementation

AWS Lambda phù hợp khi bạn đã có hệ sinh thái AWS hoặc cần timeout dài hơn (lên đến 15 phút).

Setup dự án với SAM

# Cài đặt AWS SAM CLI
# macOS
brew install aws-sam-cli

# Tạo project
sam init --runtime python3.12 --name claude-lambda
cd claude-lambda

SAM Template

# template.yaml
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Globals:
  Function:
    Timeout: 60
    MemorySize: 256
    Runtime: python3.12
    Environment:
      Variables:
        ANTHROPIC_API_KEY: !Ref AnthropicApiKey

Parameters:
  AnthropicApiKey:
    Type: String
    NoEcho: true

Resources:
  ClaudeFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: app.handler
      Events:
        Api:
          Type: Api
          Properties:
            Path: /chat
            Method: post
      Policies:
        - SSMParameterReadPolicy:
            ParameterName: anthropic-api-key

  # Rate limiting
  ApiUsagePlan:
    Type: AWS::ApiGateway::UsagePlan
    Properties:
      Throttle:
        BurstLimit: 50
        RateLimit: 20

Lambda Handler

# app.py
import json
import os
import anthropic

client = anthropic.Anthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY")
)

def handler(event, context):
    """Lambda handler cho Claude API proxy."""
    try:
        body = json.loads(event.get("body", "{}"))

        if not body.get("message"):
            return {
                "statusCode": 400,
                "body": json.dumps({"error": "Message is required"}),
                "headers": {"Content-Type": "application/json"}
            }

        # Gọi Claude API
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=body.get("max_tokens", 1024),
            system=body.get("system", "Ban la tro ly AI huu ich."),
            messages=[
                {"role": "user", "content": body["message"]}
            ]
        )

        return {
            "statusCode": 200,
            "body": json.dumps({
                "response": response.content[0].text,
                "usage": {
                    "input_tokens": response.usage.input_tokens,
                    "output_tokens": response.usage.output_tokens,
                }
            }),
            "headers": {
                "Content-Type": "application/json",
                "Access-Control-Allow-Origin": "*"
            }
        }

    except anthropic.RateLimitError:
        return {
            "statusCode": 429,
            "body": json.dumps({"error": "Rate limited. Vui long thu lai sau."}),
            "headers": {"Content-Type": "application/json"}
        }

    except Exception as e:
        return {
            "statusCode": 500,
            "body": json.dumps({"error": "Internal server error"}),
            "headers": {"Content-Type": "application/json"}
        }

Deploy Lambda

# Build
sam build

# Deploy lần đầu (interactive)
sam deploy --guided

# Deploy các lần sau
sam deploy

# Test local
sam local invoke ClaudeFunction   --event '{"body": "{"message": "Xin chao Claude!"}"}'

Cold Start Optimization

Cold start là thời gian khởi tạo function lần đầu khi không có instance sẵn sàng. Đây là nhược điểm chính của serverless.

So sánh cold start

Platform	Cold Start	Warm Invocation
Cloudflare Workers	gần 0ms (V8 isolate)	gần 0ms
AWS Lambda (Python)	200-800ms	1-5ms
AWS Lambda (Node.js)	100-500ms	1-5ms

Lưu ý: Thời gian trên chưa bao gồm thời gian gọi Claude API (thường 1-10 giây tùy độ phức tạp). Cold start thường không đáng kể so với thời gian Claude xử lý.

Giảm cold start trên Lambda

# Kỹ thuật 1: Khởi tạo client NGOÀI handler
# Client được tạo 1 lần khi container start, tái sử dụng cho các invocations sau

import anthropic

# Khởi tạo ở module level — chỉ chạy 1 lần
client = anthropic.Anthropic()

def handler(event, context):
    # client đã sẵn sàng, không cần khởi tạo lại
    response = client.messages.create(...)
    return response

# Kỹ thuật 2: Provisioned Concurrency (trả thêm tiền để giữ warm instances)
# Trong template.yaml:
Resources:
  ClaudeFunction:
    Type: AWS::Serverless::Function
    Properties:
      ProvisionedConcurrencyConfig:
        ProvisionedConcurrentExecutions: 5  # Giữ 5 instances warm

# Kỹ thuật 3: Giảm package size
# requirements.txt — chỉ cài những gì cần thiết
anthropic==0.40.0
# Không cài boto3 — đã có sẵn trong Lambda runtime

Timeout Handling

Claude có thể mất nhiều giây để trả lời, đặc biệt với prompt phức tạp. Cần xử lý timeout cẩn thận.

Chiến lược timeout

import signal

class TimeoutError(Exception):
    pass

def timeout_handler(signum, frame):
    raise TimeoutError("Claude response exceeded timeout")

def handler(event, context):
    # Lambda timeout - 60s, để dành 5s cho cleanup
    remaining_time = context.get_remaining_time_in_millis() / 1000
    claude_timeout = min(remaining_time - 5, 55)

    signal.signal(signal.SIGALRM, timeout_handler)
    signal.alarm(int(claude_timeout))

    try:
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            messages=[{"role": "user", "content": body["message"]}]
        )
        signal.alarm(0)  # Cancel alarm
        return success_response(response)

    except TimeoutError:
        return {
            "statusCode": 504,
            "body": json.dumps({
                "error": "Request timeout. Vui long thu lai voi prompt ngan hon."
            })
        }

Async pattern cho long-running requests

Nếu Claude cần thời gian xử lý lâu, dùng pattern async: Lambda nhận request, đẩy vào queue, và trả về job ID ngay lập tức. Một Lambda khác xử lý queue và lưu kết quả.

# Lambda 1: Nhận request, trả về job ID
def submit_handler(event, context):
    job_id = str(uuid.uuid4())
    sqs_client.send_message(
        QueueUrl=QUEUE_URL,
        MessageBody=json.dumps({
            "job_id": job_id,
            "message": body["message"]
        })
    )
    return {"statusCode": 202, "body": json.dumps({"job_id": job_id})}

# Lambda 2: Xử lý queue, gọi Claude, lưu kết quả
def process_handler(event, context):
    for record in event["Records"]:
        body = json.loads(record["body"])
        response = client.messages.create(...)
        # Lưu kết quả vào DynamoDB
        dynamodb.put_item(
            TableName="claude-results",
            Item={
                "job_id": body["job_id"],
                "result": response.content[0].text,
                "status": "completed"
            }
        )

# Lambda 3 (hoặc API endpoint): Check kết quả
def check_handler(event, context):
    job_id = event["pathParameters"]["job_id"]
    result = dynamodb.get_item(
        TableName="claude-results",
        Key={"job_id": job_id}
    )
    return {"statusCode": 200, "body": json.dumps(result.get("Item", {}))}

Phân tích chi phí: Serverless vs Always-On

Quyết định serverless hay server truyền thống phần lớn dựa vào traffic pattern.

Cloudflare Workers pricing

Hạng mục	Free	Paid ($5/tháng)
Requests/ngày	100,000	10 triệu included
Requests thêm	N/A	$0.50/triệu
CPU time	10ms/request	50ms/request

AWS Lambda pricing

Hạng mục	Giá
Requests	$0.20/triệu (1M free/tháng)
Duration (256MB)	$0.0000041667/giây
Duration (1GB)	$0.0000166667/giây

So sánh với VPS

Giả sử ứng dụng nhận 10,000 requests/ngày, mỗi request xử lý trung bình 3 giây (bao gồm gọi Claude API):

Giải pháp	Chi phí/tháng (ước tính)	Ghi chú
Cloudflare Workers	$5 + $0	Nằm trong quota paid plan
AWS Lambda (256MB)	~$4.35	300K requests + 900K GB-seconds
VPS 2vCPU/4GB	$20-40	Chạy 24/7, cần quản lý

Với 10,000 requests/ngày, serverless rẻ hơn 4-8 lần so với VPS. Tuy nhiên, ở mức 100,000+ requests/ngày liên tục, VPS có thể rẻ hơn vì chi phí serverless tăng tuyến tính theo traffic.

Breakeven point

Dùng prompt sau để Claude tính toán cho trường hợp cụ thể của bạn:

Giúp tôi so sánh chi phí serverless vs VPS cho ứng dụng Claude API:

Thông tin:
- Số requests/ngày: [Con số]
- Thời gian xử lý trung bình/request: [Giây]
- Memory cần thiết: [MB]
- Traffic pattern: [Ổn định / Bursty / Chỉ giờ hành chính]
- VPS hiện tại: [Cấu hình và giá]

Hãy tính chi phí hàng tháng cho:
1. Cloudflare Workers (paid plan)
2. AWS Lambda
3. VPS hiện tại

Và xác định breakeven point — ở mức traffic nào thì
VPS rẻ hơn serverless.

Edge Deployment với Cloudflare Workers

Một lợi thế quan trọng của Cloudflare Workers là chạy ở edge — code được distribute đến hơn 300 data centers trên toàn cầu. Đối với ứng dụng Claude API, điều này có nghĩa:

• Giảm latency cho request processing: Authentication, input validation, rate limiting chạy gần người dùng
• Caching: Có thể cache response cho các query lặp lại, giảm chi phí Claude API
• Geographic routing: Có thể route requests đến API endpoint gần nhất

Cache strategy cho Claude responses

async function handleWithCache(request: Request, env: Env): Promise<Response> {
  const body = await request.json() as { message: string };

  // Tạo cache key từ message (chỉ cache cho queries phổ biến)
  const cacheKey = new Request(
    "https://cache.internal/" + btoa(body.message),
    { method: "GET" }
  );

  // Kiểm tra cache
  const cache = caches.default;
  let cachedResponse = await cache.match(cacheKey);

  if (cachedResponse) {
    // Clone response và thêm header cho biết là từ cache
    const headers = new Headers(cachedResponse.headers);
    headers.set("X-Cache", "HIT");
    return new Response(cachedResponse.body, { headers });
  }

  // Cache miss — gọi Claude API
  const claudeResult = await callClaude(body.message, env);

  // Lưu vào cache (TTL 1 giờ)
  const response = new Response(JSON.stringify(claudeResult), {
    headers: {
      "Content-Type": "application/json",
      "Cache-Control": "max-age=3600",
      "X-Cache": "MISS",
    },
  });

  // Cache response
  await cache.put(cacheKey, response.clone());
  return response;
}

Error Handling và Retry Logic

Khi gọi Claude API từ serverless, bạn cần xử lý lỗi một cách chặt chẽ vì không có persistent process để retry tự động.

Các loại lỗi thường gặp

• 429 Rate Limited: Quá nhiều requests. Cần retry với exponential backoff.
• 500/503 Server Error: Claude API tạm thời không khả dụng. Retry 2-3 lần.
• Timeout: Request vượt quá thời gian cho phép. Giảm max_tokens hoặc đơn giản hóa prompt.
• 400 Bad Request: Input không hợp lệ. Không nên retry, cần sửa input.

Retry pattern cho Lambda

import time
import random

def call_claude_with_retry(client, params, max_retries=3):
    """Gọi Claude API với exponential backoff retry."""
    for attempt in range(max_retries):
        try:
            response = client.messages.create(**params)
            return response

        except anthropic.RateLimitError:
            if attempt == max_retries - 1:
                raise
            # Exponential backoff với jitter
            wait_time = (2 ** attempt) + random.uniform(0, 1)
            time.sleep(wait_time)

        except anthropic.InternalServerError:
            if attempt == max_retries - 1:
                raise
            time.sleep(1)

        except anthropic.BadRequestError:
            # Không retry - lỗi input
            raise

Dead Letter Queue cho failed requests

Khi một request thất bại sau tất cả retries, đẩy vào Dead Letter Queue (DLQ) để xử lý sau thay vì mất hoàn toàn:

# Cấu hình DLQ trong SAM template
Resources:
  ClaudeFunction:
    Type: AWS::Serverless::Function
    Properties:
      DeadLetterQueue:
        Type: SQS
        TargetArn: !GetAtt DeadLetterQueue.Arn

  DeadLetterQueue:
    Type: AWS::SQS::Queue
    Properties:
      QueueName: claude-api-dlq
      MessageRetentionPeriod: 1209600  # 14 ngày

Monitoring và Observability

Serverless functions khó debug hơn server truyền thống vì bạn không thể SSH vào instance. Cần hệ thống monitoring tốt.

Metrics quan trọng cần theo dõi

• Invocation count: Số lần function được gọi — phát hiện traffic spike bất thường
• Error rate: Tỷ lệ lỗi — cần dưới 1% trong điều kiện bình thường
• Duration: Thời gian thực thi — bao gồm cả thời gian đợi Claude response
• Cold start rate: Tỷ lệ cold start — nếu quá cao, cần provisioned concurrency
• Claude API cost: Chi phí API Claude — theo dõi để phát hiện abuse sớm

Structured logging

import json
import time

def handler(event, context):
    start_time = time.time()
    request_id = context.aws_request_id

    try:
        body = json.loads(event.get("body", "{}"))
        response = call_claude_with_retry(client, {
            "model": "claude-sonnet-4-20250514",
            "max_tokens": 1024,
            "messages": [{"role": "user", "content": body["message"]}]
        })

        duration = (time.time() - start_time) * 1000
        # Structured log cho dễ query
        print(json.dumps({
            "level": "INFO",
            "request_id": request_id,
            "action": "claude_api_call",
            "duration_ms": round(duration),
            "input_tokens": response.usage.input_tokens,
            "output_tokens": response.usage.output_tokens,
            "model": "claude-sonnet-4-20250514",
        }))

        return success_response(response)

    except Exception as e:
        duration = (time.time() - start_time) * 1000
        print(json.dumps({
            "level": "ERROR",
            "request_id": request_id,
            "error": str(e),
            "duration_ms": round(duration),
        }))
        return error_response(e)

Security Best Practices

• API key management: Dùng secrets/environment variables, không hardcode trong code. Trên Lambda, dùng AWS Secrets Manager hoặc SSM Parameter Store. Trên Workers, dùng wrangler secret.
• Rate limiting: Giới hạn requests per user/IP để tránh abuse và kiểm soát chi phí Claude API. Trên Workers, dùng Cloudflare Rate Limiting. Trên Lambda, dùng API Gateway Usage Plans.
• Input validation: Validate và sanitize mọi input trước khi gửi đến Claude. Giới hạn độ dài message, loại bỏ ký tự không hợp lệ.
• CORS: Chỉ cho phép origin của ứng dụng bạn, không dùng wildcard trong production
• Logging: Log requests nhưng không log nội dung nhạy cảm (API keys, personal data). Mask hoặc hash user messages trong log.
• Cost alerts: Thiết lập billing alerts để phát hiện sớm traffic bất thường. Trên AWS, dùng CloudWatch Billing Alarms. Trên Cloudflare, kiểm tra Workers Analytics.
• Authentication: Thêm lớp authentication cho API endpoint. Không để endpoint public mà không có rate limiting và auth.

Bước tiếp theo

Serverless là cách nhanh nhất và rẻ nhất để đưa Claude API vào production cho các ứng dụng có traffic thấp đến trung bình. Bắt đầu với Cloudflare Workers nếu ưu tiên đơn giản và tốc độ, hoặc AWS Lambda nếu cần tích hợp sâu với hệ sinh thái AWS. Khám phá thêm các pattern triển khai tại Thư viện Ứng dụng.