自建 AI API Gateway：认证 + 限流 + 计费全栈方案

ในยุคที่ AI API กลายเป็นหัวใจสำคัญของธุรกิจดิจิทัล หลายองค์กรต้องเผชิญกับความท้าทายในการจัดการการเข้าถึง การควบคุมปริมาณการใช้งาน และการเรียกเก็บค่าบริการอย่างมีประสิทธิภาพ บทความนี้จะพาคุณสร้าง AI API Gateway แบบครบวงจรที่ตอบโจทย์ทุกความต้องการ

กรณีศึกษา: บริษัท E-commerce ระดับ Top 3 ของไทย

สมมติว่าคุณเป็นทีม Tech Lead ของแพลตฟอร์ม E-commerce รายใหญ่ที่กำลังเผชิญกับปัญหา: - **ปัญหา**: แชทบอท AI ที่ใช้ GPT-4 มีค่าใช้จ่ายพุ่งสูงถึง 50,000 ดอลลาร์ต่อเดือน - **สาเหตุ**: ไม่มีระบบจัดการ API Key ที่ดี ผู้ใช้งานภายในเรียกใช้โดยไม่มีการควบคุม - **ผลลัพธ์**: ค่าใช้จ่ายบานปลาย ยากต่อการวิเคราะห์ ROI การสร้าง API Gateway ของตัวเองจะช่วยแก้ปัญหานี้ได้อย่างมีประสิทธิภาพ และยังสามารถนำไปต่อยอดเป็นระบบ SaaS ได้อีกด้วย

สถาปัตยกรรมระบบ AI API Gateway

ระบบ AI API Gateway ที่ดีต้องประกอบด้วย 4 ส่วนหลัก:

┌─────────────────────────────────────────────────────────────┐
│                    Client Application                        │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    API Gateway Layer                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
│  │  Auth       │  │ Rate Limit  │  │ Request Routing     │  │
│  │  Middleware │  │  Middleware │  │  & Transformation   │  │
│  └─────────────┘  └─────────────┘  └─────────────────────┘  │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    Business Logic Layer                      │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
│  │ Usage Track │  │  Billing    │  │  Analytics          │  │
│  │             │  │  Engine     │  │  Dashboard          │  │
│  └─────────────┘  └─────────────┘  └─────────────────────┘  │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    AI Provider Layer                         │
│           HolySheep AI / OpenAI / Anthropic                 │
└─────────────────────────────────────────────────────────────┘

การติดตั้งและตั้งค่าโครงสร้างพื้นฐาน

1. สร้างโปรเจกต์และติดตั้ง dependencies

# สร้างโปรเจกต์ Node.js
mkdir ai-api-gateway
cd ai-api-gateway
npm init -y

ติดตั้ง dependencies หลัก
npm install express rate-limiter-flexible
npm install jsonwebtoken bcryptjs
npm install mongoose redis ioredis
npm install stripe pricer
npm install dotenv cors helmet
npm install express-rate-limit

สำหรับ development
npm install -D nodemon typescript @types/node

2. โครงสร้างโฟลเดอร์โปรเจกต์

ai-api-gateway/
├── src/
│   ├── config/
│   │   ├── database.ts
│   │   ├── redis.ts
│   │   └── holySheep.ts
│   ├── middleware/
│   │   ├── auth.ts
│   │   ├── rateLimiter.ts
│   │   └── billing.ts
│   ├── routes/
│   │   ├── auth.ts
│   │   ├── proxy.ts
│   │   └── admin.ts
│   ├── models/
│   │   ├── User.ts
│   │   ├── ApiKey.ts
│   │   └── UsageLog.ts
│   ├── services/
│   │   ├── billingService.ts
│   │   └── holySheepService.ts
│   ├── utils/
│   │   └── pricing.ts
│   └── app.ts
├── .env
├── package.json
└── tsconfig.json

ระบบ Authentication และ API Key Management

3. ตั้งค่า Configuration หลัก

// src/config/holySheep.ts
import axios from 'axios';

// HolySheep AI Configuration - base_url ต้องเป็น https://api.holysheep.ai/v1
export const holySheepConfig = {
  baseUrl: 'https://api.holysheep.ai/v1',
  // ราคา ณ ปี 2026 (USD per Million Tokens)
  pricing: {
    'gpt-4.1': { input: 8, output: 8 },
    'claude-sonnet-4.5': { input: 15, output: 15 },
    'gemini-2.5-flash': { input: 2.50, output: 2.50 },
    'deepseek-v3.2': { input: 0.42, output: 0.42 }
  }
};

// Client สำหรับเรียก HolySheep API
export const holySheepClient = axios.create({
  baseURL: holySheepConfig.baseUrl,
  timeout: 60000,
  headers: {
    'Content-Type': 'application/json'
  }
});

// Helper function สำหรับเรียก API
export async function callHolySheepChat(
  apiKey: string,
  model: string,
  messages: any[],
  options: any = {}
) {
  const response = await holySheepClient.post('/chat/completions', {
    model,
    messages,
    ...options
  }, {
    headers: {
      'Authorization': Bearer ${apiKey}
    }
  });
  return response.data;
}

4. ระบบ Authentication Middleware

// src/middleware/auth.ts
import { Request, Response, NextFunction } from 'express';
import jwt from 'jsonwebtoken';
import ApiKey from '../models/ApiKey';
import User from '../models/User';

export interface AuthRequest extends Request {
  user?: any;
  apiKeyDoc?: any;
}

const JWT_SECRET = process.env.JWT_SECRET || 'your-super-secret-key';

// Middleware สำหรับตรวจสอบ JWT Token
export const authenticateJWT = async (
  req: AuthRequest,
  res: Response,
  next: NextFunction
) => {
  try {
    const authHeader = req.headers.authorization;
    
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      return res.status(401).json({ 
        error: 'Authorization header is required' 
      });
    }

    const token = authHeader.split(' ')[1];
    const decoded = jwt.verify(token, JWT_SECRET) as any;
    
    const user = await User.findById(decoded.userId);
    if (!user) {
      return res.status(401).json({ error: 'User not found' });
    }

    req.user = user;
    next();
  } catch (error) {
    return res.status(403).json({ error: 'Invalid or expired token' });
  }
};

// Middleware สำหรับตรวจสอบ API Key
export const authenticateApiKey = async (
  req: AuthRequest,
  res: Response,
  next: NextFunction
) => {
  try {
    const apiKeyHeader = req.headers['x-api-key'] as string;
    
    if (!apiKeyHeader) {
      return res.status(401).json({ 
        error: 'X-API-Key header is required' 
      });
    }

    const apiKeyDoc = await ApiKey.findOne({ 
      key: apiKeyHeader,
      isActive: true 
    }).populate('user');

    if (!apiKeyDoc) {
      return res.status(401).json({ 
        error: 'Invalid or inactive API key' 
      });
    }

    // ตรวจสอบว่า API key หมดอายุหรือไม่
    if (apiKeyDoc.expiresAt && new Date() > apiKeyDoc.expiresAt) {
      return res.status(401).json({ 
        error: 'API key has expired' 
      });
    }

    // ตรวจสอบ quota คงเหลือ
    if (apiKeyDoc.quotaLimit && apiKeyDoc.usedQuota >= apiKeyDoc.quotaLimit) {
      return res.status(429).json({ 
        error: 'API key quota exceeded',
        upgrade: 'https://www.holysheep.ai/dashboard'
      });
    }

    req.apiKeyDoc = apiKeyDoc;
    req.user = apiKeyDoc.user;
    next();
  } catch (error) {
    return res.status(500).json({ 
      error: 'Authentication error' 
    });
  }
};

// สร้าง JWT Token
export const generateToken = (userId: string): string => {
  return jwt.sign({ userId }, JWT_SECRET, { expiresIn: '7d' });
};

5. ระบบ Rate Limiting

// src/middleware/rateLimiter.ts
import rateLimit from 'express-rate-limit';
import { RedisStore } from 'rate-limiter-flexible';
import { redisClient } from '../config/redis';
import { AuthRequest } from './auth';

// Rate Limiter Store สำหรับ Redis
const redisStore = new RedisStore({
  // @ts-ignore
  sendCommand: (...args: string[]) => redisClient.sendCommand(args),
});

// สำหรับ User ทั่วไป - 100 requests ต่อนาที
export const userRateLimiter = rateLimit({
  store: redisStore,
  keyGenerator: (req: AuthRequest) => {
    return req.user?._id?.toString() || req.ip || 'unknown';
  },
  points: 100,
  duration: 60, // 60 วินาที
  standardHeaders: true,
  legacyHeaders: false,
  message: {
    error: 'Too many requests, please try again later',
    retryAfter: 60
  }
});

// สำหรับ API Key - แยกตามระดับ
export const apiKeyRateLimiter = (limits: { rpm: number; tpm: number }) => {
  return rateLimit({
    store: redisStore,
    keyGenerator: (req: AuthRequest) => {
      return apikey:${req.apiKeyDoc?.key || 'unknown'};
    },
    points: limits.rpm,
    duration: 60,
    standardHeaders: true,
    legacyHeaders: false,
    message: {
      error: 'Rate limit exceeded for this API key',
      upgrade: 'https://www.holysheep.ai/pricing'
    }
  });
};

// Rate Limit ตาม Token usage (Tokens Per Minute)
export const tokenRateLimiter = (tpm: number) => {
  return rateLimit({
    store: redisStore,
    keyGenerator: (req: AuthRequest) => {
      return tpm:${req.apiKeyDoc?.key || 'unknown'};
    },
    points: tpm,
    duration: 60,
    keyValue: 'tokens', // ใช้ token count แทน request count
    skipFailedRequests: false,
    handler: (req, res) => {
      res.status(429).json({
        error: 'Token usage limit exceeded',
        tpm,
        upgrade: 'https://www.holysheep.ai/pricing'
      });
    }
  });
};

// สำหรับ Admin endpoints
export const adminRateLimiter = rateLimit({
  store: redisStore,
  keyGenerator: (req: AuthRequest) => {
    return admin:${req.ip};
  },
  points: 30,
  duration: 60,
  message: {
    error: 'Admin rate limit exceeded'
  }
});

ระบบ Billing และ Usage Tracking

6. Billing Service

// src/services/billingService.ts
import UsageLog from '../models/UsageLog';
import ApiKey from '../models/ApiKey';
import { holySheepConfig } from '../config/holySheep';

export interface UsageData {
  apiKeyId: string;
  userId: string;
  model: string;
  inputTokens: number;
  outputTokens: number;
  latency: number;
  endpoint: string;
}

// คำนวณค่าใช้จ่ายจาก token usage
export function calculateCost(
  model: string,
  inputTokens: number,
  outputTokens: number
): number {
  const pricing = holySheepConfig.pricing[model];
  
  if (!pricing) {
    // ใช้ราคา default ถ้าไม่พบ model
    return (inputTokens * 0.00001 + outputTokens * 0.00003) / 1000000;
  }
  
  const inputCost = (inputTokens / 1000000) * pricing.input;
  const outputCost = (outputTokens / 1000000) * pricing.output;
  
  return inputCost + outputCost;
}

// บันทึก usage log
export async function logUsage(data: UsageData) {
  const cost = calculateCost(data.model, data.inputTokens, data.outputTokens);
  
  const usageLog = new UsageLog({
    apiKeyId: data.apiKeyId,
    userId: data.userId,
    model: data.model,
    inputTokens: data.inputTokens,
    outputTokens: data.outputTokens,
    totalTokens: data.inputTokens + data.outputTokens,
    cost,
    latency: data.latency,
    endpoint: data.endpoint,
    timestamp: new Date()
  });

  await usageLog.save();

  // อัพเดท quota ของ API Key
  await ApiKey.findByIdAndUpdate(data.apiKeyId, {
    $inc: { 
      usedQuota: cost,
      totalRequests: 1,
      totalTokens: data.inputTokens + data.outputTokens
    }
  });

  return usageLog;
}

// ดึงสถิติการใช้งานของ user
export async function getUserUsageStats(userId: string, period: 'day' | 'week' | 'month') {
  const now = new Date();
  let startDate: Date;

  switch (period) {
    case 'day':
      startDate = new Date(now.setHours(0, 0, 0, 0));
      break;
    case 'week':
      startDate = new Date(now.setDate(now.getDate() - 7));
      break;
    case 'month':
      startDate = new Date(now.setMonth(now.getMonth() - 1));
      break;
  }

  const stats = await UsageLog.aggregate([
    {
      $match: {
        userId: userId,
        timestamp: { $gte: startDate }
      }
    },
    {
      $group: {
        _id: '$model',
        totalRequests: { $sum: 1 },
        totalInputTokens: { $sum: '$inputTokens' },
        totalOutputTokens: { $sum: '$outputTokens' },
        totalCost: { $sum: '$cost' },
        avgLatency: { $avg: '$latency' }
      }
    }
  ]);

  return stats;
}

7. API Route หลักสำหรับ Proxy

// src/routes/proxy.ts
import { Router, Response } from 'express';
import { AuthRequest, authenticateApiKey } from '../middleware/auth';
import { apiKeyRateLimiter } from '../middleware/rateLimiter';
import { callHolySheepChat } from '../config/holySheep';
import { logUsage } from '../services/billingService';

const router = Router();

// Chat Completions Proxy - ใช้ HolySheep API
router.post('/chat/completions', 
  authenticateApiKey,
  apiKeyRateLimiter({ rpm: 60, tpm: 100000 }),
  async (req: AuthRequest, res: Response) => {
    const startTime = Date.now();
    
    try {
      const { model, messages, temperature, max_tokens, ...options } = req.body;

      // Validate model
      const validModels = ['gpt-4.1', 'claude-sonnet-4.5', 'gemini-2.5-flash', 'deepseek-v3.2'];
      if (!validModels.includes(model)) {
        return res.status(400).json({
          error: Invalid model. Supported: ${validModels.join(', ')}
        });
      }

      // เรียก HolySheep API
      const response = await callHolySheepChat(
        process.env.HOLYSHEEP_API_KEY!, // Your HolySheep API Key
        model,
        messages,
        { temperature, max_tokens, ...options }
      );

      // คำนวณ tokens จาก response
      const usage = response.usage || {};
      const inputTokens = usage.prompt_tokens || 0;
      const outputTokens = usage.completion_tokens || 0;
      const latency = Date.now() - startTime;

      // บันทึก usage
      await logUsage({
        apiKeyId: req.apiKeyDoc._id,
        userId: req.user._id,
        model,
        inputTokens,
        outputTokens,
        latency,
        endpoint: '/v1/chat/completions'
      });

      // เพิ่ม headers สำหรับ usage tracking
      res.set({
        'X-RateLimit-Remaining': '0', // ควรดึงจาก Redis
        'X-Usage-Cost': ((inputTokens + outputTokens) / 1000000).toFixed(6),
        'X-Latency-Ms': latency.toString()
      });

      return res.json(response);
    } catch (error: any) {
      console.error('Proxy error:', error.response?.data || error.message);
      
      return res.status(error.response?.status || 500).json({
        error: error.response?.data?.error || 'Internal server error',
        message: error.message
      });
    }
  }
);

// Health check endpoint
router.get('/health', (req, res) => {
  res.json({
    status: 'healthy',
    timestamp: new Date().toISOString(),
    providers: {
      holySheep: 'operational'
    }
  });
});

export default router;

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

กรณีที่ 1: Rate Limit เกิดทันทีหลังจากเริ่มใช้งาน

**อาการ**: ผู้ใช้งานถูก block ด้วย rate limit แม้จะเพิ่งเริ่มใช้งาน **สาเหตุ**: Redis connection มีปัญหาหรือค่า key ไม่ตรงกับที่ตั้งไว้

// วิธีแก้ไข: ตรวจสอบ Redis connection และ key prefix
import Redis from 'ioredis';

const redis = new Redis({
  host: process.env.REDIS_HOST || 'localhost',
  port: parseInt(process.env.REDIS_PORT || '6379'),
  password: process.env.REDIS_PASSWORD,
  keyPrefix: 'ratelimit:', // ตรวจสอบว่า prefix ตรงกัน
  retryStrategy: (times) => {
    if (times > 3) {
      console.error('Redis connection failed after 3 retries');
      return null; // หยุด retry
    }
    return Math.min(times * 200, 2000);
  }
});

redis.on('error', (err) => {
  console.error('Redis Error:', err);
  // Fallback ไปใช้ Memory store ถ้า Redis ล่ม
});

redis.on('connect', () => {
  console.log('Redis connected successfully');
});

// สำหรับ Fallback Memory Store
import RateLimitMemory from 'rate-limiter-flexible';
const fallbackMemoryLimiter = new RateLimitMemory({
  points: 100,
  duration: 60
});

กรณีที่ 2: ค่าใช้จ่ายไม่ตรงกับการใช้งานจริง

**อาการ**: Billing dashboard แสดงค่าใช้จ่ายสูงกว่าที่ควรจะเป็น **สาเหตุ**: Token counting ไม่ถูกต้อง หรือ retry logic ทำให้เกิดการเรียกซ้ำ

// วิธีแก้ไข: ตรวจสอบ token usage จาก response
async function logUsageWithRetry(data: UsageData, retries = 3) {
  try {
    const cost = calculateCost(data.model, data.inputTokens, data.outputTokens);
    
    // ตรวจสอบว่า usage object มีค่าถูกต้อง
    if (!data.inputTokens || !data.outputTokens) {
      console.warn('Invalid token count detected:', data);
      // ไม่บันทึกถ้า token count ไม่ถูกต้อง
      return null;
    }
    
    const usageLog = await UsageLog.create({
      ...data,
      cost,
      isBilled: true,
      billingPeriod: getBillingPeriod()
    });
    
    return usageLog;
  } catch (error) {
    if (retries > 0) {
      await new Promise(resolve => setTimeout(resolve, 1000));
      return logUsageWithRetry(data, retries - 1);
    }
    throw error;
  }
}

// ปิดการ retry อัตโนมัติของ HTTP client
import axios from 'axios';

const axiosInstance = axios.create({
  baseURL: 'https://api.holysheep.ai/v1',
  timeout: 60000,
  retries: 0 // ปิด retry เพื่อควบคุม cost ได้ดีขึ้น
});

กรณีที่ 3: API Key ถูกใช้งานโดยไม่ได้รับอนุญาต

**อาการ**: พบ usage ที่ไม่ใช่ของลูกค้าจริงในบัญชี **สาเหตุ**: API Key รั่วไหลหรือถูก clone

// วิธีแก้ไข: เพิ่มระบบ IP Whitelist และ Domain Restriction
import jwt from 'jsonwebtoken';

const WHITELISTED_IPS = new Set([
  '203.0.0.1',
  '203.0.0.2'
]);

export const apiKeySecurityMiddleware = async (
  req: AuthRequest,
  res: Response,
  next: NextFunction
) => {
  const apiKey = req.apiKeyDoc;
  const clientIp = req.ip || req.connection.remoteAddress;
  
  // ตรวจสอบ IP whitelist (ถ้ามีการตั้งค่า)
  if (apiKey.allowedIps && apiKey.allowedIps.length > 0) {
    if (!apiKey.allowedIps.includes(clientIp)) {
      // Log ความพยายามเข้าถึงที่ไม่ได้รับอนุญาต
      await SecurityLog.create({
        type: 'UNAUTHORIZED_IP',
        apiKeyId: apiKey._id,
        ip: clientIp,
        userAgent: req.headers['user-agent'],
        timestamp: new Date()
      });
      
      return res.status(403).json({
        error: 'IP address not allowed for this API key',
        whitelist: 'Contact support to add your IP'
      });
    }
  }
  
  // ตรวจสอบ Referer/Domain (สำหรับ frontend)
  const allowedDomains = apiKey.allowedDomains || [];
  const referer = req.headers.referer || req.headers.origin;
  
  if (allowedDomains.length > 0 && referer) {
    const isValidDomain = allowedDomains.some(domain => 
      referer.includes(domain)
    );
    
    if (!isValidDomain) {
      await SecurityLog.create({
        type: 'INVALID_DOMAIN',
        apiKeyId: apiKey._id,
        referer,
        timestamp: new Date()
      });
      
      return res.status(403).json({
        error: 'Domain not allowed for this API key'
      });
    }
  }
  
  next();
};

เหมาะกับใคร / ไม่เหมาะกับใคร

เหมาะกับใคร

| กลุ่มเป้าหมาย | ประโยชน์ที่ได้รับ | |--------------|-----------------| | **องค์กรขนาดใหญ่** | ควบคุมค่าใช้จ่าย AI ได้อย่างเข้มงวด มีรายงาน usage ละเอียด | | **ทีมพัฒนา SaaS** | สร้างระบบ API marketplace ของตัวเองได้ | | **บริษัท E-commerce** | จัดการ AI costs สำหรับ chatbot และ product recommendations | | **องค์กรที่มีข้อมูลละเอียดอ่อน** | ไม่ต้องส่งข้อมูลไปยัง provider ต่างประเทศโดยตรง | | **Startup ที่ต้องการ Multi-provider** | รวม OpenAI, Anthropic, Google ไว้ในที่เดียว |

ไม่เหมาะกับใคร

| กลุ่ม | เหตุผล | |------|--------| | **ผู้เริ่มต้น** | ต้องมีความรู้ด้าน DevOps และ backend development | | **โปรเจกต์เล็ก** | ค่าใช้จ่ายในการ maintain สูงกว่าผลประโยชน์ที่ได้ | | **ทีมที่มีงบจำกัด** | ต้องลงทุน infrastructure และ DevOps resources | | **ต้องการ SLA สูง** | ต้องลงทุนเพิ่มใน redundancy และ monitoring |

ราคาและ ROI

ตารางเปรียบเทียบ: Self-Hosted vs HolySheep AI

| รายการ | Self-Hosted Gateway | HolySheep AI | |--------|---------------------|--------------| | **ค่าใช้จ่าย Infrastructure** | $200-5000/เดือน | รวมในราคา API | | **ค่าแรกขั้นต่ำ** | $50,000+ | ฟรี (เครดิตเริ่มต้น) | | **DevOps Engineer** | 1-2 คน | ไม่จำเป็น | | **Uptime Guarantee** | DIY | 99.9% | | **Setup Time** | 2-4 สัปดาห์ | 5 นาที | | **Latency** | +10-30ms | <50ms |

การคำนวณ ROI

สำหรับทีมที่มีการใช้งาน **1 ล้าน tokens/เดือน**: ``` Self-Hosted: - Infrastructure: $500/เดือน - DevOps (1/2 FTE): $3,000/เดือน - ค่า API (DeepSeek V3.2): $0.42/M tokens × 1,000 = $420 - รวม: $3,920/เดือน HolySheep AI: - API Cost: $0.42/M tokens × 1,000 = $420/เดือน - ประหยัด: $3