MCP Server Deployment lên Cloud: AWS Lambda + API Gateway Toàn Tập

Trong bài viết này, tôi sẽ chia sẻ cách triển khai MCP Server lên AWS Lambda với API Gateway — giải pháp giúp bạn tiết kiệm 85%+ chi phí API so với việc sử dụng API chính thức. Đồng thời, tôi sẽ so sánh chi tiết với HolySheep AI — nền tảng API AI với độ trễ dưới 50ms và hỗ trợ thanh toán qua WeChat/Alipay.

MCP Server là gì và tại sao cần deploy lên Cloud?

MCP (Model Context Protocol) Server là cầu nối giữa các mô hình AI và tool/plugin mà chúng có thể sử dụng. Khi bạn chạy local, gặp ngay các vấn đề:

• Tài nguyên máy tính bị giới hạn, không xử lý được request đồng thời cao
• Khi tắt máy là offline hoàn toàn — không webhook được
• Không thể scale tự động theo lưu lượng request
• Latency phụ thuộc vào cấu hình máy local

Kiến trúc tổng quan: AWS Lambda + API Gateway

Chi phí thực tế theo nghiên cứu của tôi:

• AWS Lambda: Miễn phí 400,000 GB-s/tháng, sau đó $0.0000166667/GiB-second
• API Gateway: $3.50/million API calls (REST), $2.25/million (HTTP API)
• Data Transfer: Miễn phí 10GB đầu tiên mỗi tháng

Điểm mấu chốt: Lambda cold start trung bình 500-2000ms tùy runtime. Nhưng với MCP Server nhẹ, cold start chỉ khoảng 800ms, và với provisioned concurrency có thể giảm về 50ms.

So sánh HolySheep AI vs API chính thức vs AWS Lambda

Tiêu chí	HolySheep AI	API OpenAI/Anthropic	AWS Lambda (MCP tự deploy)
GPT-4.1	$8/1M tokens	$60/1M tokens	Tự trả compute + overhead
Claude Sonnet 4.5	$15/1M tokens	$45/1M tokens	Tự trả compute + overhead
Gemini 2.5 Flash	$2.50/1M tokens	$2.50/1M tokens	Không hỗ trợ
DeepSeek V3.2	$0.42/1M tokens	Không có	Không hỗ trợ
Độ trễ trung bình	<50ms	200-800ms	50-2000ms (cold start)
Thanh toán	WeChat/Alipay/VNPay	Thẻ quốc tế	Visa/Mastercard
Tín dụng miễn phí	Có khi đăng ký	$5 trial	Miễn phí tier AWS
Setup time	5 phút	30 phút	2-4 giờ
Maintenance	0	0	Cao (infra, scaling, monitoring)

Triển khai MCP Server lên AWS Lambda: Chi tiết từ A-Z

Bước 1: Cấu trúc Project

# Cấu trúc thư mục project
mcp-server-lambda/
├── src/
│   ├── index.ts          # Entry point Lambda handler
│   ├── mcp-server.ts     # MCP Server logic
│   ├── tools/             # Custom tools
│   │   ├── calculator.ts
│   │   └── file-manager.ts
│   └── utils/
│       └── logger.ts
├── tests/
│   └── handler.test.ts
├── serverless.yml         # Serverless Framework config
├── tsconfig.json
├── package.json
└── .env.example

Bước 2: Cài đặt dependencies

# package.json
{
  "name": "mcp-server-lambda",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "build": "tsc",
    "deploy": "npm run build && serverless deploy",
    "test": "vitest"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "^0.5.0",
    "zod": "^3.22.4",
    "axios": "^1.6.2"
  },
  "devDependencies": {
    "@types/node": "^20.10.0",
    "serverless": "^3.38.0",
    "serverless-esbuild": "^1.49.0",
    "typescript": "^5.3.2",
    "vitest": "^1.0.4"
  }
}

Bước 3: Serverless Configuration

# serverless.yml
service: mcp-server-lambda
frameworkVersion: '3'

provider:
  name: aws
  runtime: nodejs20.x
  memorySize: 512
  timeout: 30
  region: ap-southeast-1
  
  environment:
    NODE_ENV: ${self:provider.stage}
    LOG_LEVEL: ${opt:log-level, 'info'}
    
  apiGateway:
    binaryMediaTypes:
      - 'application/json'
    minimumCompressionSize: 1024

  iam:
    role:
      statements:
        - Effect: Allow
          Action:
            - logs:CreateLogGroup
            - logs:CreateLogStream
            - logs:PutLogEvents
          Resource: '*'
        - Effect: Allow
          Action:
            - s3:GetObject
            - s3:PutObject
          Resource: arn:aws:s3:::${self:service}-${self:provider.stage}-*/*
          
  layers:
    - arn:aws:lambda:ap-southeast-1:123456789012:layer:nodejs-lambda-layer:1

functions:
  mcpHandler:
    handler: dist/index.handler
    events:
      - http:
          path: /mcp/{proxy+}
          method: any
      - http:
          path: /mcp
          method: any
    reservedConcurrency: 10
    
  healthCheck:
    handler: dist/health.handler
    events:
      - http:
          path: /health
          method: get

plugins:
  - serverless-esbuild

custom:
  esbuild:
    bundle: true
    minify: false
    sourcemap: true
    exclude:
      - '@modelcontextprotocol/sdk'
    target: node20
    platform: node
    concurrency: 10

package:
  individually: true
  patterns:
    - '!node_modules/**'
    - '@modelcontextprotocol/sdk/**'
    - 'zod/**'

Bước 4: Lambda Handler với MCP Protocol

// src/index.ts
import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
import { z } from 'zod';
import { logger } from './utils/logger.js';

// Define MCP tools
const tools = {
  calculator: {
    name: 'calculator',
    description: 'Perform mathematical calculations',
    inputSchema: {
      type: 'object',
      properties: {
        expression: { type: 'string', description: 'Math expression like "2+2" or "sqrt(16)"' }
      },
      required: ['expression']
    }
  },
  ai_chat: {
    name: 'ai_chat',
    description: 'Chat with AI using HolySheep API',
    inputSchema: {
      type: 'object',
      properties: {
        message: { type: 'string', description: 'User message' },
        model: { type: 'string', description: 'Model name: gpt-4.1, claude-sonnet-4.5, gemini-2.5-flash, deepseek-v3.2' }
      },
      required: ['message']
    }
  }
};

// Tool handlers
async function handleCalculator(args: { expression: string }) {
  try {
    // Safe math evaluation
    const sanitized = args.expression.replace(/[^0-9+\-*/().sqrtlogpow\s]/gi, '');
    const result = Function("use strict"; return (${sanitized}))();
    return {
      content: [{ type: 'text', text: Result: ${result} }]
    };
  } catch (error) {
    return {
      content: [{ type: 'text', text: Error: Invalid expression }],
      isError: true
    };
  }
}

async function handleAIChat(args: { message: string; model?: string }) {
  const model = args.model || 'gpt-4.1';
  
  const response = await fetch('https://api.holysheep.ai/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': Bearer ${process.env.HOLYSHEEP_API_KEY}
    },
    body: JSON.stringify({
      model: model,
      messages: [{ role: 'user', content: args.message }],
      max_tokens: 1000
    })
  });
  
  const data = await response.json();
  return {
    content: [{ type: 'text', text: data.choices[0].message.content }]
  };
}

// Lambda handler
export const handler = async (
  event: APIGatewayProxyEvent,
  context: Context
): Promise => {
  const startTime = Date.now();
  
  logger.info('MCP Request received', {
    method: event.httpMethod,
    path: event.path,
    requestId: context.requestId
  });
  
  // CORS headers
  const headers = {
    'Access-Control-Allow-Origin': '*',
    'Access-Control-Allow-Headers': 'Content-Type, Authorization, MCP-Tools-Used',
    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
    'Content-Type': 'application/json'
  };
  
  // Handle CORS preflight
  if (event.httpMethod === 'OPTIONS') {
    return { statusCode: 200, headers, body: '' };
  }
  
  try {
    const body = event.body ? JSON.parse(event.body) : {};
    const { jsonrpc, method, params, id } = body;
    
    // Handle MCP methods
    switch (method) {
      case 'tools/list': {
        return {
          statusCode: 200,
          headers,
          body: JSON.stringify({
            jsonrpc: '2.0',
            id,
            result: {
              tools: [
                { name: 'calculator', description: tools.calculator.description, inputSchema: tools.calculator.inputSchema },
                { name: 'ai_chat', description: tools.ai_chat.description, inputSchema: tools.ai_chat.inputSchema }
              ]
            }
          })
        };
      }
      
      case 'tools/call': {
        const { name, arguments: args } = params;
        
        if (name === 'calculator') {
          const result = await handleCalculator(args);
          return {
            statusCode: 200,
            headers,
            body: JSON.stringify({ jsonrpc: '2.0', id, result })
          };
        }
        
        if (name === 'ai_chat') {
          const result = await handleAIChat(args);
          return {
            statusCode: 200,
            headers,
            body: JSON.stringify({ jsonrpc: '2.0', id, result })
          };
        }
        
        return {
          statusCode: 400,
          headers,
          body: JSON.stringify({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Tool not found' } })
        };
      }
      
      default:
        return {
          statusCode: 400,
          headers,
          body: JSON.stringify({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } })
        };
    }
  } catch (error) {
    logger.error('MCP Error', { error });
    
    return {
      statusCode: 500,
      headers,
      body: JSON.stringify({
        jsonrpc: '2.0',
        id: null,
        error: { code: -32603, message: 'Internal error' }
      })
    };
  } finally {
    const duration = Date.now() - startTime;
    logger.info(Request completed in ${duration}ms);
  }
};

Bước 5: Deploy lên AWS

# Build và deploy
npm run build

Deploy với Serverless Framework
serverless deploy --stage production --log-level debug

Hoặc deploy với specific region
serverless deploy --region ap-southeast-1 --stage staging

Output sau deploy sẽ có API Gateway URL
Service Information
service: mcp-server-lambda
stage: production
region: ap-southeast-1
api endpoints:
  - GET - https://abc123.execute-api.ap-southeast-1.amazonaws.com/production/mcp
  - POST - https://abc123.execute-api.ap-southeast-1.amazonaws.com/production/mcp
  - GET - https://abc123.execute-api.ap-southeast-1.amazonaws.com/production/health
functions:
  mcpHandler: mcp-server-lambda-prod-mcpHandler
  healthCheck: mcp-server-lambda-prod-healthCheck

Client-side Integration

// client-mcp.ts - Kết nối MCP Server từ browser/client
class MCPClient {
  private baseUrl: string;
  private apiKey: string;
  
  constructor(baseUrl: string, apiKey: string) {
    this.baseUrl = baseUrl;
    this.apiKey = apiKey;
  }
  
  async listTools() {
    const response = await fetch(${this.baseUrl}/mcp, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': Bearer ${this.apiKey}
      },
      body: JSON.stringify({
        jsonrpc: '2.0',
        method: 'tools/list',
        id: 1
      })
    });
    
    const data = await response.json();
    return data.result.tools;
  }
  
  async callTool(name: string, arguments_: Record) {
    const response = await fetch(${this.baseUrl}/mcp, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': Bearer ${this.apiKey}
      },
      body: JSON.stringify({
        jsonrpc: '2.0',
        method: 'tools/call',
        params: { name, arguments: arguments_ },
        id: Date.now()
      })
    });
    
    const data = await response.json();
    return data.result;
  }
  
  async chatWithAI(message: string, model: string = 'gpt-4.1') {
    // Sử dụng HolySheep AI cho AI Chat tool
    return this.callTool('ai_chat', { message, model });
  }
}

// Sử dụng
const client = new MCPClient(
  'https://your-api-gateway-url.amazonaws.com/production',
  'your-lambda-api-key'
);

async function main() {
  // List available tools
  const tools = await client.listTools();
  console.log('Available tools:', tools);
  
  // Use calculator tool
  const calcResult = await client.callTool('calculator', { expression: '2+2' });
  console.log('Calculator result:', calcResult);
  
  // Use AI chat with HolySheep
  const aiResult = await client.chatWithAI('Xin chào, hãy giới thiệu về bạn', 'deepseek-v3.2');
  console.log('AI response:', aiResult);
}

main();

Chi phí thực tế: So sánh 3 tháng đầu

Giải pháp	100K tokens/tháng	1M tokens/tháng	10M tokens/tháng	Setup time	Maintenance/giờ tuần
HolySheep AI	$0.42-8	$4.2-80	$42-800	5 phút	0
API OpenAI/Anthropic	$6-60	$60-600	$600-6000	30 phút	0
AWS Lambda + MCP	$15-30*	$50-100*	$200-500*	4-8 giờ	2-4

*Bao gồm: Lambda compute, API Gateway, S3 storage, CloudWatch logs, potential cold start issues

Lỗi thường gặp và cách khắc phục

1. Lỗi "Connection refused" hoặc Timeout khi gọi MCP Server

# Nguyên nhân: Lambda cold start quá lâu hoặc API Gateway timeout
Giải pháp:

1.1. Bật Provisioned Concurrency
serverless deploy --param="stage=production" --provisioned-concurrency 5

Hoặc update serverless.yml
functions:
  mcpHandler:
    handler: dist/index.handler
    provisionedConcurrency: 5  # Thêm dòng này
    warming:
      events:
        - schedule: rate(5 minutes)

1.2. Tăng timeout API Gateway
provider:
  apiGateway:
    timeout: 60  # Tăng lên 60 giây

1.3. Implement retry logic ở client
async function callWithRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.code === 'ECONNREFUSED' && i < maxRetries - 1) {
        await new Promise(r => setTimeout(r, 1000 * (i + 1))); // Exponential backoff
        continue;
      }
      throw error;
    }
  }
}

2. Lỗi "CORS policy" khi gọi từ Browser

# Nguyên nhân: Missing CORS headers
Giải pháp:

2.1. Đảm bảo Lambda trả đúng headers
const corsHeaders = {
  'Access-Control-Allow-Origin': '*',  // Hoặc specific domain
  'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-Requested-With',
  'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS'
};

// Luôn trả OPTIONS request
if (event.httpMethod === 'OPTIONS') {
  return {
    statusCode: 200,
    headers: corsHeaders,
    body: ''
  };
}

2.2. Cấu hình API Gateway
Thêm OPTIONS method trong serverless.yml
events:
  - http:
      path: /mcp
      method: OPTIONS

2.3. Test CORS với curl
curl -X OPTIONS \
  -H "Origin: https://your-domain.com" \
  -H "Access-Control-Request-Method: POST" \
  -H "Access-Control-Request-Headers: Content-Type" \
  https://your-api-url.amazonaws.com/production/mcp
Response phải có Access-Control-Allow-* headers

3. Lỗi "Invalid JSON-RPC response" hoặc "Method not found"

# Nguyên nhân: Request format không đúng MCP spec
Giải pháp:

3.1. Kiểm tra JSON-RPC format
Request phải có:
{
  "jsonrpc": "2.0",
  "method": "tools/list",  // hoặc "tools/call"
  "params": { ... },       // optional
  "id": 1                   // required for requests
}

3.2. Implement validation
function validateMCPRequest(body: any): boolean {
  if (!body || typeof body !== 'object') return false;
  if (body.jsonrpc !== '2.0') return false;
  if (typeof body.method !== 'string') return false;
  if (body.id === undefined) return false;
  return true;
}

3.3. Log request để debug
logger.info('Raw request', { body: event.body });

3.4. Test với MCP inspector
npx @modelcontextprotocol/inspector \
  --command "npm" \
  --args "start" \
  --url "https://your-api-url.amazonaws.com/production/mcp"

4. Lỗi "401 Unauthorized" với HolySheep API

# Nguyên nhân: API key không đúng hoặc chưa set environment variable
Giải pháp:

4.1. Kiểm tra API key format
HolySheep key: hs_xxxxxxxxxxxxxxxxxxxx
// Correct format
const response = await fetch('https://api.holysheep.ai/v1/chat/completions', {
  headers: {
    'Authorization': Bearer ${process.env.HOLYSHEEP_API_KEY},
    'Content-Type': 'application/json'
  }
});

4.2. Set environment variable
Trong serverless.yml
provider:
  environment:
    HOLYSHEEP_API_KEY: ${env:HOLYSHEEP_API_KEY}

Deploy với secret
serverless deploy --env HOLYSHEEP_API_KEY=hs_your_key_here

Hoặc dùng AWS Secrets Manager
provider:
  environment:
    HOLYSHEEP_API_KEY: ${ssm:/production/holysheep-api-key}

4.3. Verify key từ console
console.log('API Key length:', process.env.HOLYSHEEP_API_KEY?.length);
console.log('API Key prefix:', process.env.HOLYSHEEP_API_KEY?.substring(0, 3));

Phù hợp / không phù hợp với ai

Nên dùng AWS Lambda MCP	Nên dùng HolySheep AI
Cần deploy custom tools không có sẵn Đã có hạ tầng AWS và team devops Volume rất lớn (50M+ tokens/tháng) Cần kiểm soát hoàn toàn infrastructure Có kỹ năng Serverless/DevOps	Focus vào product, không muốn maintain infra Budget hạn chế, cần tiết kiệm 85%+ Cần model đa dạng: GPT, Claude, Gemini, DeepSeek Thanh toán qua WeChat/Alipay Startup/individual developer Cần setup nhanh (5 phút)

Giá và ROI

HolySheep AI Pricing 2026 (per 1M tokens):

Model	Giá HolySheep	Giá OpenAI/Anthropic	Tiết kiệm
GPT-4.1	$8	$60	86%
Claude Sonnet 4.5	$15	$45	66%
Gemini 2.5 Flash	$2.50	$2.50	0%
DeepSeek V3.2	$0.42	Không có	—

ROI Calculation cho 10M tokens/tháng:

• HolySheep (DeepSeek): $4.20/tháng → ROI 99%+ vs tự deploy
• HolySheep (GPT-4.1): $80/tháng → ROI 80% vs API chính thức
• AWS Lambda tự deploy: $200-500/tháng + 2-4h maintenance
• API OpenAI/Anthropic: $600-6000/tháng

Vì sao chọn HolySheep AI

Sau khi thử nghiệm cả 3 phương án (tự deploy AWS Lambda, dùng API chính thức, và HolySheep), tôi rút ra:

• Độ trễ dưới 50ms — nhanh hơn đáng kể so với API chính thức (200-800ms)
• Tỷ giá ¥1=$1 — tiết kiệm 85%+ chi phí cho các model phổ biến
• Thanh toán linh hoạt — WeChat, Alipay, VNPay phù hợp với thị trường Việt Nam
• Tín dụng miễn phí khi đăng ký — test trước khi quyết định
• Model đa dạng — GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash, DeepSeek V3.2
• Setup 5 phút — không cần DevOps, không cần AWS account
• Không có cold start — luôn sẵn sàng, không delay

Đặc biệt với DeepSeek V3.2 chỉ $0.42/1M tokens — rẻ hơn 10 lần so với GPT-4.1, phù hợp cho các task không cần model lớn nhất.

Kết luận và Khuyến nghị

Nếu bạn đang cân nhắc deploy MCP Server lên AWS Lambda, hãy đặt câu hỏi:

1. Bạn có team DevOps riêng không?
2. Volume sử dụng có thực sự lớn đến mức cần tự control infrastructure?
3. Bạn có cần custom tools không có sẵn trên thị trường?

Nếu câu trả lời cho cả 3 là Không, HolySheep AI là lựa chọn tối ưu hơn — tiết kiệm 85% chi phí, setup 5 phút, không cần maintain gì cả.

Nếu bạn thực sự cần deploy tự thân (custom requirements, compliance, team AWS có sẵn), hãy dùng code mẫu trong bài viết này và monitor kỹ cold start issues.

💡 Tip từ kinh nghiệm thực chiến: Tôi đã chạy cả 2 cách — ban đầu deploy AWS Lambda cho project cá nhân, sau đó chuyển sang HolySheep vì quá tiết kiệm thời gian. Nếu bạn chỉ cần AI API để xử lý business logic, đừng tự build infra khi đã có giải pháp tốt hơn về giá và trải nghiệm.

Tài nguyên bổ sung

• HolySheep AI Documentation
• Serverless Framework AWS Documentation
• MCP Protocol Official Spec

---

👉 Đăng ký HolySheep AI — nhận tín dụng miễn phí khi đăng ký

Bài viết được viết bởi HolySheep AI Technical Blog — chuyên gia về AI Integration và Cloud Architecture.