AI API Gateway Middleware ออกแบบอย่างไร? รวม Authentication, Rate Limiting และ Logging ในระบบเดียว

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

บทนำ: ทำไมต้องมี AI API Gateway

เมื่อคุณต้องเรียกใช้ AI หลายตัวพร้อมกัน ไม่ว่าจะเป็น GPT-4, Claude หรือ Gemini การจัดการ Authentication Token, Rate Limiting และการ Log การใช้งานแยกกันจะสร้างความซับซ้อนโดยไม่จำเป็น Middleware ที่ดีจะช่วยให้คุณ:

• รวม Key หลายตัวในที่เดียว ไม่ต้องจัดการแยก
• ควบคุม Rate Limit อัตโนมัติตามแผนของลูกค้า
• ติดตามการใช้งานและค่าใช้จ่ายแบบ Real-time
• ป้องกันการล้มระบบจาก Request มากเกินไป

เปรียบเทียบต้นทุน AI API ปี 2026

ก่อนเข้าสู่การออกแบบ มาดูต้นทุนจริงของแต่ละ Provider ที่ตรวจสอบแล้วสำหรับ Output Tokens กัน:

Provider / Model	ราคา/1M Tokens	10M Tokens/เดือน	HolySheep (¥1=$1)
GPT-4.1	$8.00	$80.00	¥80
Claude Sonnet 4.5	$15.00	$150.00	¥150
Gemini 2.5 Flash	$2.50	$25.00	¥25
DeepSeek V3.2	$0.42	$4.20	¥4.20

จะเห็นได้ว่า DeepSeek V3.2 ประหยัดกว่า GPT-4.1 ถึง 19 เท่า สำหรับงานทั่วไป และ สมัครที่นี่ เพื่อรับอัตราแลกเปลี่ยนพิเศษ ¥1=$1 ประหยัดมากกว่า 85% จากราคาปกติ

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

ระบบที่เราจะสร้างประกอบด้วย 3 ส่วนหลักที่ทำงานร่วมกัน:

1. Authentication Middleware - ตรวจสอบ API Key และจัดการ Token Routing
2. Rate Limiting Middleware - ควบคุมจำนวน Request ตามแผนของผู้ใช้
3. Logging Middleware - บันทึก Request/Response, Token Usage และ Cost Tracking

Implementation: Node.js + Express

1. Authentication Middleware

// middleware/auth.js
const jwt = require('jsonwebtoken');
const { modelConfigs } = require('../config/models');

const authenticateAPIKey = async (req, res, next) => {
    const apiKey = req.headers['x-api-key'] || req.query['api_key'];
    
    if (!apiKey) {
        return res.status(401).json({ 
            error: 'API key is required',
            code: 'MISSING_API_KEY'
        });
    }

    try {
        // ตรวจสอบ API Key จาก Database
        const user = await User.findOne({ 
            apiKey: apiKey,
            isActive: true 
        });

        if (!user) {
            return res.status(401).json({ 
                error: 'Invalid API key',
                code: 'INVALID_API_KEY'
            });
        }

        // ตรวจสอบว่า User มีสิทธิ์ใช้ Model ที่ร้องขอหรือไม่
        const requestedModel = req.body?.model || 'gpt-4';
        const hasAccess = checkModelAccess(user, requestedModel);

        if (!hasAccess) {
            return res.status(403).json({ 
                error: You don't have access to ${requestedModel},
                code: 'MODEL_ACCESS_DENIED'
            });
        }

        // แนบข้อมูล User เข้ากับ Request
        req.user = {
            id: user._id,
            plan: user.plan, // 'free', 'starter', 'pro', 'enterprise'
            rateLimit: user.rateLimit,
            monthlyBudget: user.monthlyBudget,
            usedTokens: user.usedTokens || 0
        };

        next();
    } catch (error) {
        console.error('Authentication error:', error);
        return res.status(500).json({ 
            error: 'Authentication service error',
            code: 'AUTH_SERVICE_ERROR'
        });
    }
};

const checkModelAccess = (user, model) => {
    const planModelAccess = {
        free: ['gpt-3.5-turbo', 'gemini-flash'],
        starter: ['gpt-3.5-turbo', 'gpt-4', 'gemini-flash'],
        pro: ['gpt-3.5-turbo', 'gpt-4', 'gpt-4-turbo', 'claude-sonnet', 'gemini-*'],
        enterprise: ['*'] // ทุก Model
    };

    const allowed = planModelAccess[user.plan] || [];
    return allowed.includes('*') || allowed.includes(model) || 
           (allowed.includes('gemini-*') && model.includes('gemini'));
};

module.exports = { authenticateAPIKey };

2. Rate Limiting Middleware

// middleware/rateLimit.js
const Redis = require('ioredis');
const redis = new Redis(process.env.REDIS_URL);

const RATE_LIMITS = {
    free: { requests: 60, window: 60 },      // 60 req/min
    starter: { requests: 500, window: 60 },  // 500 req/min
    pro: { requests: 2000, window: 60 },      // 2000 req/min
    enterprise: { requests: 10000, window: 60 } // 10000 req/min
};

const TOKEN_LIMITS = {
    free: 100000,        // 100K tokens/month
    starter: 1000000,    // 1M tokens/month
    pro: 10000000,        // 10M tokens/month
    enterprise: Infinity
};

const checkRateLimit = async (req, res, next) => {
    const userId = req.user.id;
    const plan = req.user.plan;
    const rateConfig = RATE_LIMITS[plan] || RATE_LIMITS.free;

    const key = ratelimit:${userId}:${Math.floor(Date.now() / 1000 / rateConfig.window)};

    try {
        const current = await redis.incr(key);
        
        if (current === 1) {
            await redis.expire(key, rateConfig.window + 1);
        }

        const remaining = Math.max(0, rateConfig.requests - current);

        res.set({
            'X-RateLimit-Limit': rateConfig.requests,
            'X-RateLimit-Remaining': remaining,
            'X-RateLimit-Reset': Math.ceil(Date.now() / 1000 / rateConfig.window) * rateConfig.window
        });

        if (current > rateConfig.requests) {
            return res.status(429).json({
                error: 'Rate limit exceeded',
                code: 'RATE_LIMIT_EXCEEDED',
                retryAfter: rateConfig.window
            });
        }

        // ตรวจสอบ Monthly Token Limit
        const tokenKey = tokens:${userId}:${new Date().toISOString().slice(0, 7)};
        const usedTokens = parseInt(await redis.get(tokenKey) || '0');
        const tokenLimit = TOKEN_LIMITS[plan];

        if (usedTokens >= tokenLimit) {
            return res.status(429).json({
                error: 'Monthly token limit exceeded',
                code: 'TOKEN_LIMIT_EXCEEDED',
                upgrade: '/pricing'
            });
        }

        req.tokenUsage = { used: usedTokens, limit: tokenLimit };
        next();
    } catch (error) {
        console.error('Rate limit check error:', error);
        // ถ้า Redis ล่ม ให้ Allow Request แต่ Log เตือน
        next();
    }
};

module.exports = { checkRateLimit };

3. Unified Logging Middleware

// middleware/logging.js
const { LogRequest, saveUsage } = require('../models');
const { calculateTokenCost } = require('../utils/costCalculator');

const requestLogger = async (req, res, next) => {
    const startTime = Date.now();
    const requestId = req_${Date.now()}_${Math.random().toString(36).substr(2, 9)};
    
    // เก็บ Request Original
    const originalBody = { ...req.body };
    
    // สร้าง Response Interceptor
    const originalSend = res.send;
    res.send = function(body) {
        res.body = body;
        return originalSend.apply(this, arguments);
    };

    // เมื่อ Response เสร็จ
    res.on('finish', async () => {
        const duration = Date.now() - startTime;
        
        try {
            const logData = {
                requestId,
                userId: req.user?.id,
                method: req.method,
                path: req.originalUrl,
                requestModel: originalBody?.model,
                responseModel: parseModelFromResponse(res.body),
                requestTokens: originalBody?.max_tokens || 0,
                promptTokens: extractPromptTokens(res.body),
                completionTokens: extractCompletionTokens(res.body),
                totalTokens: extractTotalTokens(res.body),
                costUSD: calculateTokenCost(originalBody?.model, res.body),
                statusCode: res.statusCode,
                duration,
                ip: req.ip,
                userAgent: req.headers['user-agent']
            };

            // บันทึก Log
            await LogRequest.create(logData);

            // อัพเดท Token Usage ใน Redis
            await updateTokenUsage(req.user.id, logData.totalTokens);

            // Log สำหรับ Monitor
            console.log(JSON.stringify({
                timestamp: new Date().toISOString(),
                level: res.statusCode < 400 ? 'info' : 'warn',
                requestId,
                userId: req.user?.id,
                model: originalBody?.model,
                tokens: logData.totalTokens,
                cost: logData.costUSD,
                latency: duration,
                status: res.statusCode
            }));

        } catch (error) {
            console.error('Logging error:', error);
        }
    });

    req.requestId = requestId;
    next();
};

// Utility Functions
const extractPromptTokens = (responseBody) => {
    try {
        const body = typeof responseBody === 'string' ? JSON.parse(responseBody) : responseBody;
        return body.usage?.prompt_tokens || 0;
    } catch { return 0; }
};

const extractCompletionTokens = (responseBody) => {
    try {
        const body = typeof responseBody === 'string' ? JSON.parse(responseBody) : responseBody;
        return body.usage?.completion_tokens || 0;
    } catch { return 0; }
};

const extractTotalTokens = (responseBody) => {
    try {
        const body = typeof responseBody === 'string' ? JSON.parse(responseBody) : responseBody;
        return body.usage?.total_tokens || 0;
    } catch { return 0; }
};

const updateTokenUsage = async (userId, tokens) => {
    const redis = require('ioredis').default;
    const client = new redis(process.env.REDIS_URL);
    const monthKey = tokens:${userId}:${new Date().toISOString().slice(0, 7)};
    await client.incrby(monthKey, tokens);
    await client.expire(monthKey, 60 * 24 * 60 * 60); // 60 วัน
};

module.exports = { requestLogger };

4. Proxy Handler สำหรับ AI Providers

// routes/proxy.js
const express = require('express');
const router = express.Router();
const { authenticateAPIKey } = require('../middleware/auth');
const { checkRateLimit } = require('../middleware/rateLimit');
const { requestLogger } = require('../middleware/logging');

const PROVIDER_ENDPOINTS = {
    'gpt-4': 'https://api.holysheep.ai/v1/chat/completions',
    'gpt-4-turbo': 'https://api.holysheep.ai/v1/chat/completions',
    'gpt-3.5-turbo': 'https://api.holysheep.ai/v1/chat/completions',
    'claude-sonnet': 'https://api.holysheep.ai/v1/chat/completions',
    'gemini-flash': 'https://api.holysheep.ai/v1/chat/completions',
    'deepseek-v3': 'https://api.holysheep.ai/v1/chat/completions'
};

// ตัวอย่างการใช้งาน HolySheep API
const holySheepClient = async (model, messages, apiKey) => {
    const response = await fetch('https://api.holysheep.ai/v1/chat/completions', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': Bearer ${apiKey}
        },
        body: JSON.stringify({
            model: model,
            messages: messages,
            temperature: 0.7,
            max_tokens: 2048
        })
    });

    if (!response.ok) {
        const error = await response.json();
        throw new Error(error.error?.message || 'API Error');
    }

    return await response.json();
};

router.post('/v1/chat/completions', 
    authenticateAPIKey, 
    checkRateLimit, 
    requestLogger,
    async (req, res) => {
        try {
            const { model, messages, ...options } = req.body;
            
            // Route ไปยัง Provider ที่เหมาะสม
            const targetEndpoint = PROVIDER_ENDPOINTS[model] || 
                                   PROVIDER_ENDPOINTS['gpt-4'];

            // เรียกใช้ HolySheep API
            const apiKey = process.env.HOLYSHEEP_API_KEY; // Server-side key
            
            const response = await fetch(targetEndpoint, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': Bearer ${apiKey}
                },
                body: JSON.stringify({ model, messages, ...options })
            });

            const data = await response.json();
            
            if (!response.ok) {
                return res.status(response.status).json(data);
            }

            res.json(data);
        } catch (error) {
            console.error('Proxy error:', error);
            res.status(500).json({ 
                error: 'Internal server error',
                code: 'PROXY_ERROR'
            });
        }
    }
);

module.exports = router;

5. Cost Calculator Utility

// utils/costCalculator.js

// ราคาจริงปี 2026 (USD per 1M tokens - Output)
const MODEL_PRICING = {
    'gpt-4.1': { input: 2.50, output: 8.00 },
    'gpt-4-turbo': { input: 10.00, output: 30.00 },
    'gpt-4': { input: 30.00, output: 60.00 },
    'gpt-3.5-turbo': { input: 0.50, output: 1.50 },
    'claude-sonnet-4-5': { input: 3.00, output: 15.00 },
    'claude-haiku': { input: 0.25, output: 1.25 },
    'gemini-2.5-flash': { input: 0.70, output: 2.50 },
    'gemini-1.5-pro': { input: 1.25, output: 5.00 },
    'deepseek-v3.2': { input: 0.14, output: 0.42 },
    'deepseek-chat': { input: 0.07, output: 0.21 }
};

// HolySheep Exchange Rate: ¥1 = $1 (ประหยัด 85%+)
const HOLYSHEEP_EXCHANGE_RATE = 1; 

const calculateTokenCost = (model, response) => {
    try {
        const pricing = MODEL_PRICING[model] || MODEL_PRICING['gpt-4'];
        const usage = response?.usage || {};
        
        const inputCost = (usage.prompt_tokens / 1000000) * pricing.input;
        const outputCost = (usage.completion_tokens / 1000000) * pricing.output;
        
        return (inputCost + outputCost);
    } catch (error) {
        console.error('Cost calculation error:', error);
        return 0;
    }
};

const calculateMonthlyCost = (usageData) => {
    let totalCost = 0;
    
    for (const [model, usage] of Object.entries(usageData)) {
        const pricing = MODEL_PRICING[model] || { input: 0, output: 0 };
        totalCost += (usage.promptTokens / 1000000) * pricing.input;
        totalCost += (usage.completionTokens / 1000000) * pricing.output;
    }
    
    return {
        usd: totalCost,
        cny: totalCost * HOLYSHEEP_EXCHANGE_RATE,
        savings: totalCost * 0.85 // 85% savings with HolySheep
    };
};

module.exports = { 
    calculateTokenCost, 
    calculateMonthlyCost,
    MODEL_PRICING 
};

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

เหมาะกับใคร	ไม่เหมาะกับใคร
Startup ที่ต้องการประหยัดค่า API สูงสุด 85% นักพัฒนาที่ใช้ AI หลาย Provider พร้อมกัน ทีมที่ต้องการระบบ Rate Limiting ที่ยืดหยุ่น ธุรกิจที่ต้องการจัดการ Cost อย่างละเอียด ผู้ที่ต้องการ Latency ต่ำกว่า 50ms	โครงการที่ต้องการ Support ภาษาไทยเฉพาะเจาะจง องค์กรที่ต้องการ Enterprise SLA เต็มรูปแบบ ผู้ที่ไม่มีความรู้ด้าน Backend Development

ราคาและ ROI

แผน	ราคา/th>ธ	Token Limit	Rate Limit	ROI (vs Official API)
Free	¥0	100K tokens	60 req/min	-
Starter	¥99/เดือน	1M tokens	500 req/min	ประหยัด 85%+
Pro	¥399/เดือน	10M tokens	2000 req/min	ประหยัด 85%+
Enterprise	ติดต่อฝ่ายขาย	Unlimited	Custom	Custom Pricing

ตัวอย่าง ROI จริง

สมมติคุณใช้ DeepSeek V3.2 สำหรับ Application ที่มี 10 ล้าน tokens/เดือน:

• Official API: $4.20/เดือน (ประมาณ 147 บาท)
• HolySheep: ¥4.20/เดือน (ประมาณ 150 บาท แต่จ่ายเป็น ¥)
• GPT-4.1 (10M tokens): $80/เดือน → ประหยัด 85% = ¥80/เดือน
• Claude Sonnet 4.5 (10M tokens): $150/เดือน → ประหยัด 85% = ¥150/เดือน

ทำไมต้องเลือก HolySheep

1. ประหยัด 85%+ - อัตราแลกเปลี่ยน ¥1=$1 ทำให้ค่าใช้จ่ายต่ำกว่าที่อื่นมาก
2. Latency ต่ำกว่า 50ms - เหมาะสำหรับ Real-time Application
3. รองรับทุก Model �ยอดนิยม - GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash, DeepSeek V3.2
4. ชำระเงินง่าย - รองรับ WeChat และ Alipay
5. เครดิตฟรีเมื่อลงทะเบียน - ทดลองใช้งานก่อนตัดสินใจ

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

กรณีที่ 1: 401 Unauthorized - Invalid API Key

อาการ: ได้รับข้อผิดพลาด {"error": "Invalid API key"}

// ❌ วิธีผิด - Key ถูกส่งผ่าน Query Parameter (ไม่ปลอดภัย)
GET /v1/chat/completions?api_key=sk-xxx

// ✅ วิธีถูก - Key ถูกส่งผ่าน Header
POST /v1/chat/completions
Headers:
  Authorization: Bearer YOUR_HOLYSHEEP_API_KEY
  Content-Type: application/json

// หรือใช้ Custom Header
Headers:
  x-api-key: YOUR_HOLYSHEEP_API_KEY

กรณีที่ 2: 429 Rate Limit Exceeded

อาการ: ได้รับข้อผิดพลาด Rate Limit แม้ว่าจะเรียกไม่บ่อย

// ปัญหา: ไม่ได้ Reset Redis Key หรือ Window ไม่ถูกต้อง

// ✅ แก้ไข - ตรวจสอบ Redis Key ที่ถูกสร้าง
const key = ratelimit:${userId}:${Math.floor(Date.now() / 1000 / 60)};

// ตรวจสอบ Key ที่มีอยู่
await redis.keys('ratelimit:*').then(keys => {
    console.log('Active rate limit keys:', keys);
});

// ✅ แก้ไข - เพิ่ม TTL ให้ถูกต้อง
if (current === 1) {
    await redis.expire(key, rateConfig.window + 10); // +10 เผื่อ latency
}

// ✅ แก้ไข - ใช้ Sliding Window แทน Fixed Window
const redisLuaScript = `
    local key = KEYS[1]
    local now = tonumber(ARGV[1])
    local window = tonumber(ARGV[2])
    local limit = tonumber(ARGV[3])
    
    redis.call('ZREMRANGEBYSCORE', key, 0, now - window)
    local count = redis.call('ZCARD', key)
    
    if count < limit then
        redis.call('ZADD', key, now, now
แหล่งข้อมูลที่เกี่ยวข้อง
📚 บทช่วยสอน AI API
💰 ดูราคา
📖 เอกสารสำหรับนักพัฒนา
🚀 สมัครฟรี
บทความที่เกี่ยวข้อง
GitHub Copilot กับทางเลือกอื่น: Cursor vs Cline vs Continue 
How to Integrate HolySheep with LINE Bot สำหรับนักพัฒนาไทย
API Gateway Load Balancing สำหรับ LLM Services: คู่มือเปรียบ