Rate Limit Exceeded 429 Error: การตั้งค่า Auto-Retry และ Circuit Breaker ใน Node.js SDK

การใช้งาน Large Language Model (LLM) API ในระดับ Production มักเจอปัญหา Rate Limit 429 โดยเฉพาะเมื่อต้องประมวลผลข้อมูลจำนวนมาก บทความนี้จะสอนการตั้งค่า Auto-Retry พร้อม Exponential Backoff และ Circuit Breaker เพื่อให้ระบบทำงานได้อย่างเสถียร โดยใช้ HolySheep AI เป็น API Gateway

ต้นทุน API ปี 2026: เปรียบเทียบความคุ้มค่า

ก่อนเริ่มต้น เรามาดูต้นทุนต่อ Million Tokens กัน:

• GPT-4.1 (Output): $8/MTok
• Claude Sonnet 4.5 (Output): $15/MTok
• Gemini 2.5 Flash (Output): $2.50/MTok
• DeepSeek V3.2 (Output): $0.42/MTok

คำนวณต้นทุนสำหรับ 10M Tokens/เดือน

┌─────────────────────────────────────────────────────────────────────┐
│ โมเดล              │ ราคา/MTok  │ 10M Tokens   │ เปรียบเทียบกับ DeepSeek │
├─────────────────────────────────────────────────────────────────────┤
│ GPT-4.1            │ $8.00      │ $80.00       │ 19x แพงกว่า          │
│ Claude Sonnet 4.5  │ $15.00     │ $150.00      │ 36x แพงกว่า          │
│ Gemini 2.5 Flash   │ $2.50      │ $25.00       │ 6x แพงกว่า           │
│ DeepSeek V3.2      │ $0.42      │ $4.20        │ baseline              │
└─────────────────────────────────────────────────────────────────────┘

💡 HolySheep AI: อัตราแลกเปลี่ยน ¥1=$1 (ประหยัด 85%+)
   รองรับ WeChat/Alipay พร้อม latency <50ms

จะเห็นได้ว่า DeepSeek V3.2 มีต้นทุนต่ำที่สุดถึง 19 เท่าเมื่อเทียบกับ GPT-4.1 ทำให้การจัดการ Rate Limit อย่างมีประสิทธิภาพช่วยประหยัดค่าใช้จ่ายได้มาก

การตั้งค่า HolySheep AI SDK เบื้องต้น

เริ่มต้นด้วยการติดตั้งและตั้งค่า SDK พื้นฐาน:

// ติดตั้ง dependencies
npm install @holysheep/ai-sdk axios express

// โครงสร้างโปรเจกต์
// src/
// ├── config/
// │   └── api.js
// ├── services/
// │   ├── llmClient.js
// │   └── retryHandler.js
// └── app.js

// src/config/api.js
const HOLYSHEEP_CONFIG = {
  baseURL: 'https://api.holysheep.ai/v1',
  apiKey: process.env.HOLYSHEEP_API_KEY || 'YOUR_HOLYSHEEP_API_KEY',
  timeout: 60000,
  maxRetries: 3,
  retryDelay: 1000, // 1 วินาทีเริ่มต้น
  circuitBreaker: {
    failureThreshold: 5,      // ล้มเหลว 5 ครั้ง → เปิดวงจร
    resetTimeout: 30000,      // รอ 30 วินาทีก่อนลองใหม่
    halfOpenRequests: 3       // ทดสอบ 3 ครั้งในโหมด half-open
  }
};

module.exports = HOLYSHEEP_CONFIG;

การสร้าง Auto-Retry Handler พร้อม Exponential Backoff

นี่คือหัวใจสำคัญของการจัดการ Rate Limit ที่ผมปรับแต่งจากประสบการณ์จริงในการ Deploy หลายโปรเจกต์:

// src/services/retryHandler.js

class RetryHandler {
  constructor(config) {
    this.maxRetries = config.maxRetries || 3;
    this.baseDelay = config.retryDelay || 1000;
    this.maxDelay = config.maxDelay || 30000;
    this.jitter = config.jitter || true;
    this.retryableStatuses = [408, 429, 500, 502, 503, 504];
  }

  /**
   * คำนวณ delay ด้วย Exponential Backoff
   * delay = baseDelay * 2^attempt + random_jitter
   */
  calculateDelay(attempt, retryAfter = null) {
    // ถ้า server แนะนำเวลารอ (header Retry-After)
    if (retryAfter) {
      return Math.min(retryAfter * 1000, this.maxDelay);
    }

    // Exponential backoff: 1s, 2s, 4s, 8s, 16s...
    const exponentialDelay = this.baseDelay * Math.pow(2, attempt);
    
    // เพิ่ม jitter แบบ Full Jitter กระจายคำขอ
    const jitterDelay = this.jitter 
      ? Math.random() * exponentialDelay 
      : 0;

    return Math.min(exponentialDelay + jitterDelay, this.maxDelay);
  }

  /**
   * ตรวจสอบว่าควร retry หรือไม่
   */
  shouldRetry(error, attempt) {
    // ถ้าเกินจำนวนครั้งสูงสุด
    if (attempt >= this.maxRetries) {
      return false;
    }

    // ตรวจสอบ status code
    if (error.response?.status) {
      return this.retryableStatuses.includes(error.response.status);
    }

    // Network error หรือ timeout
    if (error.code === 'ECONNABORTED' || error.code === 'ETIMEDOUT') {
      return true;
    }

    // ข้อผิดพลาดจาก rate limit
    if (error.message?.includes('429') || 
        error.message?.includes('rate limit')) {
      return true;
    }

    return false;
  }

  /**
   * ดึงค่า Retry-After จาก response header
   */
  getRetryAfter(error) {
    const retryAfter = error.response?.headers?.['retry-after'] ||
                       error.response?.headers?.['retry-after-ms'];
    
    if (retryAfter) {
      // อาจเป็นวินาที หรือ Unix timestamp
      const value = parseInt(retryAfter, 10);
      return isNaN(value) ? null : value;
    }
    return null;
  }
}

module.exports = RetryHandler;

การสร้าง Circuit Breaker Pattern

จากประสบการณ์ที่ระบบล่มหลายครั้งเมื่อ API ปิดให้บริการ ผมแนะนำให้ใช้ Circuit Breaker เสมอ:

// src/services/circuitBreaker.js

const CircuitState = {
  CLOSED: 'CLOSED',     // ปกติ ทำงานได้
  OPEN: 'OPEN',         // ปิดวงจร ไม่ยอมรับ request
  HALF_OPEN: 'HALF_OPEN' // ทดสอบว่าหายหรือยัง
};

class CircuitBreaker {
  constructor(config) {
    this.failureThreshold = config.failureThreshold || 5;
    this.resetTimeout = config.resetTimeout || 30000;
    this.halfOpenRequests = config.halfOpenRequests || 3;
    
    this.state = CircuitState.CLOSED;
    this.failureCount = 0;
    this.successCount = 0;
    this.lastFailureTime = null;
    this.nextAttempt = Date.now();
  }

  /**
   * ตรวจสอบว่ายอมรับ request หรือไม่
   */
  canExecute() {
    if (this.state === CircuitState.CLOSED) {
      return true;
    }

    if (this.state === CircuitState.OPEN) {
      // ถึงเวลาเปลี่ยนเป็น half-open หรือยัง
      if (Date.now() >= this.nextAttempt) {
        this.state = CircuitState.HALF_OPEN;
        this.successCount = 0;
        console.log('🔄 Circuit: CLOSED → HALF_OPEN');
        return true;
      }
      return false;
    }

    // HALF_OPEN state
    return this.successCount < this.halfOpenRequests;
  }

  /**
   * บันทึกผลลัพธ์ความสำเร็จ
   */
  recordSuccess() {
    if (this.state === CircuitState.HALF_OPEN) {
      this.successCount++;
      if (this.successCount >= this.halfOpenRequests) {
        // หายดีแล้ว กลับสู่สถานะปกติ
        this.state = CircuitState.CLOSED;
        this.failureCount = 0;
        console.log('✅ Circuit: HALF_OPEN → CLOSED (ระบบฟื้นตัว)');
      }
    } else {
      // รีเซ็ต counter เมื่อสำเร็จในสถานะปกติ
      this.failureCount = 0;
    }
  }

  /**
   * บันทึกผลลัพธ์ความล้มเหลว
   */
  recordFailure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();

    if (this.state === CircuitState.HALF_OPEN) {
      // ยังไม่หาย กลับไป OPEN
      this.state = CircuitState.OPEN;
      this.nextAttempt = Date.now() + this.resetTimeout;
      console.log('❌ Circuit: HALF_OPEN → OPEN (ล้มเหลวอีกครั้ง)');
    } else if (this.failureCount >= this.failureThreshold) {
      // เกิน threshold → เปิดวงจร
      this.state = CircuitState.OPEN;
      this.nextAttempt = Date.now() + this.resetTimeout;
      console.log('🚫 Circuit: CLOSED → OPEN (ถึง threshold)');
    }
  }

  /**
   * สถานะปัจจุบัน
   */
  getStatus() {
    return {
      state: this.state,
      failureCount: this.failureCount,
      successCount: this.successCount,
      nextAttempt: this.nextAttempt,
      timeUntilNextAttempt: Math.max(0, this.nextAttempt - Date.now())
    };
  }
}

module.exports = CircuitBreaker;

LVM Client ที่บูรณาการทั้งหมด

// src/services/llmClient.js

const axios = require('axios');
const HOLYSHEEP_CONFIG = require('../config/api');
const RetryHandler = require('./retryHandler');
const CircuitBreaker = require('./circuitBreaker');

class LLMClient {
  constructor(config = {}) {
    this.config = { ...HOLYSHEEP_CONFIG, ...config };
    this.retryHandler = new RetryHandler(this.config);
    this.circuitBreaker = new CircuitBreaker(this.config.circuitBreaker);
    
    this.client = axios.create({
      baseURL: this.config.baseURL,
      timeout: this.config.timeout,
      headers: {
        'Authorization': Bearer ${this.config.apiKey},
        'Content-Type': 'application/json'
      }
    });
  }

  /**
   * เรียกใช้ LLM พร้อม Retry และ Circuit Breaker
   */
  async chat(model, messages, options = {}) {
    let attempt = 0;
    let lastError;

    while (attempt <= this.config.maxRetries) {
      // ตรวจสอบ Circuit Breaker
      if (!this.circuitBreaker.canExecute()) {
        const status = this.circuitBreaker.getStatus();
        throw new Error(
          Circuit Breaker OPEN: รอ ${Math.ceil(status.timeUntilNextAttempt/1000)} วินาที
        );
      }

      try {
        const response = await this.client.post('/chat/completions', {
          model: model,
          messages: messages,
          ...options
        });

        // สำเร็จ → บันทึกความสำเร็จ
        this.circuitBreaker.recordSuccess();
        return response.data;

      } catch (error) {
        this.circuitBreaker.recordFailure();
        lastError = error;

        // ดึงข้อมูล rate limit
        const retryAfter = this.retryHandler.getRetryAfter(error);
        const isRateLimit = error.response?.status === 429;
        const rateLimitRemaining = error.response?.headers?.['x-ratelimit-remaining'];
        const rateLimitReset = error.response?.headers?.['x-ratelimit-reset'];

        if (isRateLimit && rateLimitRemaining !== undefined) {
          console.warn(
            ⚠️  Rate Limit: เหลือ ${rateLimitRemaining} requests,  +
            รีเซ็ต ${new Date(rateLimitReset * 1000).toISOString()}
          );
        }

        // ตรวจสอบว่าควร retry หรือไม่
        if (!this.retryHandler.shouldRetry(error, attempt)) {
          throw this.formatError(error);
        }

        // คำนวณ delay
        const delay = this.retryHandler.calculateDelay(attempt, retryAfter);
        console.log(
          🔁 Retry ครั้งที่ ${attempt + 1}/${this.config.maxRetries}  +
          หลัง ${delay}ms - ${error.message}
        );

        await this.sleep(delay);
        attempt++;
      }
    }

    throw this.formatError(lastError);
  }

  /**
   * ประมวลผล batch พร้อม concurrency control
   */
  async chatBatch(models, concurrency = 3) {
    const results = [];
    const chunks = this.chunkArray(models, concurrency);

    for (const chunk of chunks) {
      const promises = chunk.map(item => 
        this.chat(item.model, item.messages, item.options)
          .then(r => ({ success: true, data: r, index: item.index }))
          .catch(e => ({ success: false, error: e, index: item.index }))
      );
      
      const chunkResults = await Promise.all(promises);
      results.push(...chunkResults);
    }

    return results.sort((a, b) => a.index - b.index);
  }

  // Utility functions
  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  chunkArray(array, size) {
    return Array.from({ length: Math.ceil(array.length / size) }, 
      (_, i) => array.slice(i * size, i * size + size)
    );
  }

  formatError(error) {
    const status = error.response?.status;
    const statusText = error.response?.statusText;
    
    const errorMessages = {
      401: 'API Key ไม่ถูกต้อง ตรวจสอบที่ https://www.holysheep.ai/register',
      403: 'ไม่มีสิทธิ์เข้าถึง API นี้',
      429: 'Rate Limit Exceeded: ลองใช้ delay หรือใช้ DeepSeek ซึ่งถูกกว่า',
      500: 'Server Error จาก API Provider',
      503: 'Service Unavailable: ลองใหม่ในอีกสักครู่'
    };

    return new Error(
      errorMessages[status] || 
      ${status || 'Network Error'}: ${statusText || error.message}
    );
  }
}

module.exports = LLMClient;

ตัวอย่างการใช้งานจริง

// src/app.js

const express = require('express');
const LLMClient = require('./services/llmClient');

const app = express();
app.use(express.json());

// สร้าง client instance
const llmClient = new LLMClient();

// ============ ตัวอย่างที่ 1: เรียกใช้งานเดี่ยว ============
app.post('/api/chat', async (req, res) => {
  try {
    const { model = 'deepseek-v3.2', message } = req.body;
    
    const response = await llmClient.chat(
      model,
      [{ role: 'user', content: message }],
      { temperature: 0.7, max_tokens: 1000 }
    );

    res.json({
      success: true,
      model: response.model,
      response: response.choices[0].message.content,
      usage: response.usage
    });
  } catch (error) {
    console.error('Chat Error:', error.message);
    res.status(429).json({ 
      success: false, 
      error: error.message,
      circuitStatus: llmClient.circuitBreaker.getStatus()
    });
  }
});

// ============ ตัวอย่างที่ 2: ประมวลผลเอกสารจำนวนมาก ============
app.post('/api/batch-process', async (req, res) => {
  try {
    const { documents } = req.body; // Array of { id, text }
    
    const tasks = documents.map((doc, index) => ({
      index,
      model: 'deepseek-v3.2',
      messages: [
        { 
          role: 'system', 
          content: 'สรุปเนื้อหาต่อไปนี้ให้กระชับ' 
        },
        { 
          role: 'user', 
          content: doc.text 
        }
      ],
      options: { temperature: 0.3 }
    }));

    // ประมวลผลพร้อมกัน 3 tasks
    const results = await llmClient.chatBatch(tasks, 3);
    
    const successful = results.filter(r => r.success).length;
    const failed = results.filter(r => !r.success).length;

    res.json({
      success: true,
      total: documents.length,
      processed: successful,
      failed: failed,
      results: results.map(r => ({
        index: r.index,
        summary: r.success ? r.data.choices[0].message.content : null,
        error: r.success ? null : r.error.message
      }))
    });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// ============ ตัวอย่างที่ 3: ตรวจสอบสถานะ ============
app.get('/api/status', (req, res) => {
  res.json({
    circuitBreaker: llmClient.circuitBreaker.getStatus(),
    uptime: process.uptime(),
    memory: process.memoryUsage()
  });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(🚀 Server พร้อมที่ http://localhost:${PORT});
  console.log(📊 ตรวจสอบสถานะที่ http://localhost:${PORT}/api/status);
});

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

กรณีที่ 1: "429 Rate Limit Exceeded" ติดต่อกัน

// ❌ วิธีผิด: เรียกใช้ทันทีหลังได้รับ error
try {
  await llmClient.chat(model, messages);
} catch (e) {
  // เรียกทันที → ยิ่งถูก block
  await llmClient.chat(model, messages);
}

// ✅ วิธีถูก: รอตาม Retry-After header
try {
  const response = await llmClient.chat(model, messages);
} catch (error) {
  if (error.response?.status === 429) {
    const retryAfter = parseInt(
      error.response.headers['retry-after'] || '60'
    );
    console.log(รอ ${retryAfter} วินาที...);
    await sleep(retryAfter * 1000);
    // หรือใช้ llmClient ที่มี built-in retry
    return await llmClient.chat(model, messages);
  }
  throw error;
}

กรณีที่ 2: Circuit Breaker ค้างในสถานะ OPEN

// ❌ วิธีผิด: ตั้งค่า resetTimeout สั้นเกินไป
const circuitBreaker = new CircuitBreaker({
  failureThreshold: 5,
  resetTimeout: 1000  // แค่ 1 วินาที → ยังไม่ทันฟื้น
});

// ✅ วิธีถูก: ตั้งค่า timeout ที่เหมาะสม
const circuitBreaker = new CircuitBreaker({
  failureThreshold: 5,        // ล้มเหลว 5 ครั้ง → เปิดวงจร
  resetTimeout: 30000,         // รอ 30 วินาที
  halfOpenRequests: 3          // ทดสอบ 3 ครั้งก่อนปิดวงจร
});

// แสดงสถานะปัจจุบัน
console.log(circuitBreaker.getStatus());
// { state: 'OPEN', failureCount: 5, nextAttempt: 1735689600000, ... }

// ถ้าต้องการ reset ด้วยมือ
circuitBreaker.state = 'CLOSED';
circuitBreaker.failureCount = 0;

กรณีที่ 3: Memory Leak จาก Promise ค้าง

// ❌ วิธีผิด: ไม่จัดการ timeout
async function callAPI() {
  try {
    const response = await axios.post(url, data);
    return response.data;
  } catch (e) {
    // Promise ค้างถ้า server ไม่ตอบ
    // ไม่มี timeout → memory เพิ่มขึ้นเรื่อยๆ
  }
}

// ✅ วิธีถูก: ตั้ง timeout และ AbortController
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), 30000);

try {
  const response = await axios.post(url, data, {
    signal: controller.signal,
    timeout: 30000
  });
  clearTimeout(timeoutId);
  return response.data;
} catch (error) {
  clearTimeout(timeoutId);
  if (axios.isCancel(error)) {
    throw new Error('Request cancelled due to timeout');
  }
  throw error;
}

// หรือใช้ Promise.race สำหรับ timeout
const withTimeout = (promise, ms) => {
  const timeout = new Promise((_, reject) => 
    setTimeout(() => reject(new Error('Timeout')), ms)
  );
  return Promise.race([promise, timeout]);
};

กรณีที่ 4: API Key หมดอายุหรือถูก Revoke

// ❌ วิธีผิด: Hardcode API Key
const llmClient = new LLMClient({
  apiKey: 'sk-1234567890abcdef' // ไม่ปลอดภัย + อาจถูก revoke
});

// ✅ วิธีถูก: ใช้ Environment Variable + Validation
require('dotenv').config();

if (!process.env.HOLYSHEEP_API_KEY) {
  throw new Error('HOLYSHEEP_API_KEY ไม่ได้กำหนดค่า');
}

const llmClient = new LLMClient({
  apiKey: process.env.HOLYSHEEP_API_KEY
});

// ตรวจสอบความถูกต้อง
try {
  const testResponse = await llmClient.chat('deepseek-v3.2', [
    { role: 'user', content: 'ping' }
  ]);
  console.log('✅ API Key ถูกต้อง');
} catch (error) {
  if (error.response?.status === 401) {
    console.error('❌ API Key ไม่ถูกต้องหรือถูก revoke');
    console.log('🔗 สมัครใหม่ที่: https://www.holysheep.ai/register');
  }
}

สรุป

การจัดการ Rate Limit 429 ไม่ใช่แค่การรอแล้วลองใหม่ แต่ต้องออกแบบให้:

• Retry อย่างชาญฉลาด — ใช้ Exponential Backoff กระจายโหลด
• ป้องกันระบบล่ม — ใช้ Circuit Breaker หยุดเรียกเมื่อ API มีปัญหา
• เลือกโมเดลที่เหมาะสม — DeepSeek V3.2 ราคาเพียง $0.42/MTok ประหยัดกว่า GPT-4.1 ถึง 19 เท่า
• ควบคุม Concurrency — ประมวลผลเป็น batch ไม่กระทบ rate limit

HolySheep AI มอบประสบการณ์ที่ดีกว่าด้วย Latency <50ms, รองรับ WeChat/Alipay และอัตราแลกเปลี่ยน ¥1=$1 ประหยัดได้ถึง 85%+ เมื่อเทียบกับการใช้งานโดยตรง

👉 สมัคร HolySheep AI — รับเครดิตฟรีเมื่อลงทะเบียน