AI API 负载测试：Locust + k6 วิธีทดสอบประสิทธิภาพสำหรับ AI API ที่ดีที่สุดในปี 2026

การทำ Load Testing สำหรับ AI API เป็นขั้นตอนสำคัญที่หลายทีมมองข้าม แต่กลับกลายเป็นจุดคอขวดเมื่อระบบต้องรับโหลดจริง ในบทความนี้ผมจะแบ่งปันประสบการณ์ตรงจากการย้ายระบบ AI API ของทีมจากผู้ให้บริการรายเดิมมายัง HolySheep AI พร้อมวิธีการทดสอบประสิทธิภาพที่ครอบคลุมด้วย Locust และ k6

ทำไมต้องทดสอบ Load สำหรับ AI API

AI API มีความแตกต่างจาก REST API ทั่วไปอย่างมาก ทั้งในด้าน Latency ที่ไม่แน่นอน การใช้ Token ที่เปลี่ยนแปลงตลอดเวลา และ Rate Limiting ที่เข้มงวด หากไม่ทดสอบล่วงหน้า ระบบอาจล่มกลางคันเมื่อ Traffic พุ่งสูงขึ้น

การตั้งค่า Environment สำหรับทดสอบ HolySheep API

ก่อนเริ่มการทดสอบ เราต้องตั้งค่า Environment และเตรียมความพร้อมสำหรับการเชื่อมต่อ HolySheep API ซึ่งมีความเร็วตอบสนองต่ำกว่า 50ms และรองรับโหลดสูงได้อย่างมีประสิทธิภาพ

# ติดตั้ง Dependencies สำหรับการทดสอบ
pip install locust k6 requests python-dotenv aiohttp

สร้างไฟล์ .env สำหรับ HolySheep API
cat > .env << 'EOF'
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
HOLYSHEEP_BASE_URL=https://api.holysheep.ai/v1
MODEL_NAME=gpt-4.1
MAX_TOKENS=2048
EOF

ตรวจสอบการเชื่อมต่อ
python -c "
import os
from dotenv import load_dotenv
import requests

load_dotenv()
api_key = os.getenv('HOLYSHEEP_API_KEY')
base_url = os.getenv('HOLYSHEEP_BASE_URL')

response = requests.get(
    f'{base_url}/models',
    headers={'Authorization': f'Bearer {api_key}'}
)
print(f'Status: {response.status_code}')
print(f'Response Time: {response.elapsed.total_seconds()*1000:.2f}ms')
print(f'Models Available: {len(response.json().get(\"data\", []))}')
"

การทดสอบด้วย Locust — Python-based Load Testing

Locust เป็นเครื่องมือ Load Testing ที่ใช้ Python เขียนสคริปต์ได้ง่าย รองรับ Distributed Testing และมี Web UI สำหรับดูผลลัพธ์แบบ Real-time เหมาะสำหรับทีมที่คุ้นเคยกับ Python

# locustfile.py - Locust Load Test สำหรับ HolySheep API
import os
import random
import time
from locust import HttpUser, task, between, events
from locust.runners import MasterRunner
import requests

ตั้งค่า Configuration
BASE_URL = os.getenv('HOLYSHEEP_BASE_URL', 'https://api.holysheep.ai/v1')
API_KEY = os.getenv('HOLYSHEEP_API_KEY', 'YOUR_HOLYSHEEP_API_KEY')
MODEL = os.getenv('MODEL_NAME', 'gpt-4.1')

ตัวอย่าง Prompts สำหรับทดสอบ
TEST_PROMPTS = [
    "Explain quantum computing in simple terms",
    "Write a Python function to sort a list",
    "What is the capital of France?",
    "Analyze this code snippet for bugs",
    "Translate 'Hello World' to 5 languages"
]

class HolySheepAPIUser(HttpUser):
    """
    Simulates real user behavior สำหรับ AI API
    - Wait time: 1-5 วินาทีระหว่าง requests
    - Random prompts เพื่อจำลองการใช้งานจริง
    """
    wait_time = between(1, 5)
    
    def on_start(self):
        """เริ่มต้น session ด้วยการตรวจสอบ API key"""
        self.headers = {
            'Authorization': f'Bearer {API_KEY}',
            'Content-Type': 'application/json'
        }
    
    @task(3)
    def chat_completion_standard(self):
        """ทดสอบ Chat Completion มาตรฐาน - น้ำหนัก 3 เท่า"""
        prompt = random.choice(TEST_PROMPTS)
        payload = {
            'model': MODEL,
            'messages': [
                {'role': 'user', 'content': prompt}
            ],
            'max_tokens': 500,
            'temperature': 0.7
        }
        
        start_time = time.time()
        with self.client.post(
            f'{BASE_URL}/chat/completions',
            json=payload,
            headers=self.headers,
            catch_response=True,
            name='/chat/completions [standard]'
        ) as response:
            latency = (time.time() - start_time) * 1000
            
            if response.status_code == 200:
                data = response.json()
                tokens_used = data.get('usage', {}).get('total_tokens', 0)
                
                # ตรวจสอบ SLA: Response time < 2000ms
                if latency < 2000:
                    response.success()
                    print(f"✅ Success: {latency:.2f}ms, Tokens: {tokens_used}")
                else:
                    response.failure(f"Latency {latency:.2f}ms exceeds SLA")
                    
            elif response.status_code == 429:
                response.failure("Rate Limited - Too Many Requests")
            elif response.status_code == 401:
                response.failure("Authentication Failed")
            else:
                response.failure(f"HTTP {response.status_code}")
    
    @task(1)
    def chat_completion_streaming(self):
        """ทดสอบ Streaming Response"""
        payload = {
            'model': MODEL,
            'messages': [
                {'role': 'user', 'content': 'Write a short story about AI'}
            ],
            'max_tokens': 1000,
            'stream': True
        }
        
        start_time = time.time()
        with self.client.post(
            f'{BASE_URL}/chat/completions',
            json=payload,
            headers=self.headers,
            stream=True,
            catch_response=True,
            name='/chat/completions [streaming]'
        ) as response:
            if response.status_code == 200:
                # วัดเวลาจนกว่าจะได้ chunk แรก
                first_chunk_time = None
                total_chunks = 0
                
                for line in response.iter_lines():
                    if line:
                        total_chunks += 1
                        if first_chunk_time is None:
                            first_chunk_time = time.time()
                    
                    # จำกัดจำนวน chunks เพื่อไม่ให้ทดสอบนานเกินไป
                    if total_chunks >= 20:
                        break
                
                ttft = (first_chunk_time - start_time) * 1000 if first_chunk_time else 0
                print(f"📡 Streaming: TTFT={ttft:.2f}ms, Chunks={total_chunks}")
                response.success()
            else:
                response.failure(f"Streaming failed: {response.status_code}")

Event Handlers สำหรับเก็บ Metrics
@events.request.add_listener
def on_request(request_type, name, response_time, response_length, exception, **kwargs):
    if exception:
        print(f"❌ Request failed: {name} - {exception}")

@events.quitting.add_listener
def on_quitting(environment, **kwargs):
    """สรุปผลการทดสอบเมื่อจบ"""
    stats = environment.stats
    print("\n" + "="*60)
    print("📊 LOAD TEST SUMMARY - HolySheep API")
    print("="*60)
    print(f"Total Requests: {stats.total.num_requests}")
    print(f"Failed Requests: {stats.total.num_failures}")
    print(f"Average Response Time: {stats.total.avg_response_time:.2f}ms")
    print(f"P50 Latency: {stats.total.get_response_time_percentile(0.5):.2f}ms")
    print(f"P95 Latency: {stats.total.get_response_time_percentile(0.95):.2f}ms")
    print(f"P99 Latency: {stats.total.get_response_time_percentile(0.99):.2f}ms")
    print(f"RPS: {stats.total.total_rps:.2f}")
    print("="*60)

if __name__ == "__main__":
    # รัน Locust ในโหมด Standalone
    # locust -f locustfile.py --host=https://api.holysheep.ai/v1
    pass

การทดสอบด้วย k6 — Modern Load Testing Framework

k6 เป็นเครื่องมือ Load Testing รุ่นใหม่ที่ใช้ Go เขียน เร็วและเบากว่า รองรับ JavaScript/TypeScript สำหรับเขียนสคริปต์ และมีความสามารถในการ Export Metrics ไปยัง InfluxDB, Prometheus, Grafana ได้โดยตรง

// k6-load-test.js - k6 Load Test สำหรับ HolySheep API
// รันด้วย: k6 run k6-load-test.js

import http from 'k6/http';
import { check, sleep, group } from 'k6';
import { Rate, Trend, Counter } from 'k6/metrics';

// Custom Metrics
const latency = new Trend('api_latency');
const ttft = new Trend('time_to_first_token');
const tokenUsage = new Trend('tokens_per_request');
const errorRate = new Rate('error_rate');

// Configuration
const BASE_URL = 'https://api.holysheep.ai/v1';
const API_KEY = 'YOUR_HOLYSHEEP_API_KEY';

// Test Scenarios Configuration
export const options = {
    scenarios: {
        // Scenario 1: Baseline Load - 10 VUs for 2 minutes
        baseline: {
            executor: 'constant-vus',
            vus: 10,
            duration: '2m',
            tags: { test_type: 'baseline' },
        },
        
        // Scenario 2: Stress Test - Ramp up to 100 VUs
        stress_test: {
            executor: 'ramping-vus',
            startVUs: 10,
            stages: [
                { duration: '30s', target: 50 },   // Ramp up
                { duration: '1m', target: 50 },    // Hold
                { duration: '30s', target: 100 },  // Stress
                { duration: '1m', target: 100 },   // Hold peak
                { duration: '30s', target: 0 },    // Ramp down
            ],
            tags: { test_type: 'stress' },
        },
        
        // Scenario 3: Spike Test - Sudden burst
        spike_test: {
            executor: 'spike',
            vus: 10,
            stages: [
                { duration: '10s', target: 10 },
                { duration: '10s', target: 200 },  // Spike!
                { duration: '30s', target: 200 },
                { duration: '10s', target: 10 },
            ],
            tags: { test_type: 'spike' },
        },
    },
    
    thresholds: {
        // SLA Thresholds
        'http_req_duration': ['p(95)<3000'],      // 95% ต้องตอบสนองภายใน 3 วินาที
        'api_latency': ['p(99)<5000'],            // 99% ต้องตอบสนองภายใน 5 วินาที
        'error_rate': ['rate<0.05'],              // Error rate ต่ำกว่า 5%
        'checks': ['rate>0.95'],                  // Success rate สูงกว่า 95%
    },
    
    // Summary ระหว่างทดสอบ
    summaryTrendStats: ['avg', 'min', 'med', 'max', 'p(95)', 'p(99)'],
};

// Test Prompts
const prompts = [
    'Explain the concept of machine learning in simple terms',
    'Write a Python function to calculate fibonacci numbers',
    'What are the benefits of microservices architecture?',
    'How does blockchain technology work?',
    'Describe the water cycle in nature',
];

export default function () {
    // เลือก Prompt แบบสุ่ม
    const prompt = prompts[Math.floor(Math.random() * prompts.length)];
    
    // Payload สำหรับ Chat Completion
    const payload = JSON.stringify({
        model: 'gpt-4.1',
        messages: [
            { role: 'user', content: prompt }
        ],
        max_tokens: 500,
        temperature: 0.7,
    });
    
    const params = {
        headers: {
            'Authorization': Bearer ${API_KEY},
            'Content-Type': 'application/json',
        },
        tags: { 
            test_type: __ENV.TEST_TYPE || 'baseline',
            model: 'gpt-4.1'
        },
    };
    
    group('Chat Completion API', () => {
        const startTime = Date.now();
        
        const response = http.post(
            ${BASE_URL}/chat/completions,
            payload,
            params
        );
        
        const responseTime = Date.now() - startTime;
        latency.add(responseTime);
        
        // Check Response
        const checkResult = check(response, {
            'status is 200': (r) => r.status === 200,
            'has content': (r) => r.json('choices') !== undefined,
            'has usage info': (r) => r.json('usage') !== undefined,
            'response time < 3s': (r) => responseTime < 3000,
        });
        
        if (!checkResult) {
            errorRate.add(1);
            console.error(❌ Request failed: ${response.status} - ${response.body});
        } else {
            errorRate.add(0);
            
            // เก็บ Token Usage
            const usage = response.json('usage');
            tokenUsage.add(usage.total_tokens || 0);
            
            console.log(✅ Success: ${responseTime}ms, Tokens: ${usage.total_tokens});
        }
    });
    
    group('Streaming API', () => {
        const streamPayload = JSON.stringify({
            model: 'gpt-4.1',
            messages: [{ role: 'user', content: 'Count from 1 to 10' }],
            max_tokens: 100,
            stream: true,
        });
        
        const streamStart = Date.now();
        let firstTokenTime = null;
        let chunkCount = 0;
        
        const response = http.post(
            ${BASE_URL}/chat/completions,
            streamPayload,
            {
                ...params,
                stream: true,
            }
        );
        
        if (response.status === 200) {
            const lines = response.body.split('\n');
            for (const line of lines) {
                if (line.startsWith('data:')) {
                    chunkCount++;
                    if (firstTokenTime === null) {
                        firstTokenTime = Date.now() - streamStart;
                    }
                }
            }
            ttft.add(firstTokenTime);
            console.log(📡 Streaming: TTFT=${firstTokenTime}ms, Chunks=${chunkCount});
        }
    });
    
    // Random delay ระหว่าง requests (1-3 วินาที)
    sleep(Math.random() * 2 + 1);
}

// Handle Test Summary
export function handleSummary(data) {
    return {
        'stdout': textSummary(data, { indent: ' ', enableColors: true }),
        'summary.json': JSON.stringify(data, null, 2),
    };
}

function textSummary(data, options) {
    const { metrics } = data;
    
    let summary = '\n';
    summary += '='.repeat(70) + '\n';
    summary += '📊 K6 LOAD TEST SUMMARY - HolySheep AI API\n';
    summary += '='.repeat(70) + '\n\n';
    
    // HTTP Request Metrics
    summary += '🌐 HTTP Metrics:\n';
    summary +=   Total Requests:    ${metrics.http_reqs.values.count}\n;
    summary +=   Request Rate:      ${metrics.http_reqs.values.rate.toFixed(2)} req/s\n;
    summary +=   Avg Duration:      ${metrics.http_req_duration.values.avg.toFixed(2)}ms\n;
    summary +=   P95 Duration:      ${metrics.http_req_duration.values['p(95)'].toFixed(2)}ms\n;
    summary +=   P99 Duration:      ${metrics.http_req_duration.values['p(99)'].toFixed(2)}ms\n\n;
    
    // API Latency
    summary += '⚡ API Latency:\n';
    summary +=   Average:           ${metrics.api_latency.values.avg.toFixed(2)}ms\n;
    summary +=   P99:               ${metrics.api_latency.values['p(99)'].toFixed(2)}ms\n\n;
    
    // Token Usage
    summary += '💰 Token Usage:\n';
    summary +=   Average:           ${metrics.tokens_per_request.values.avg.toFixed(0)} tokens/req\n;
    summary +=   Max:               ${metrics.tokens_per_request.values.max.toFixed(0)} tokens\n\n;
    
    // Error Rate
    summary += '❌ Error Rate:\n';
    summary +=   Total Errors:      ${metrics.error_rate.values.count}\n;
    summary +=   Error Percentage:  ${(metrics.error_rate.values.rate * 100).toFixed(2)}%\n\n;
    
    // SLA Compliance
    summary += '✅ SLA Compliance:\n';
    const p95Pass = metrics.http_req_duration.values['p(95)'] <= 3000;
    summary +=   P95 < 3000ms:      ${p95Pass ? '✅ PASS' : '❌ FAIL'}\n;
    const errorPass = metrics.error_rate.values.rate < 0.05;
    summary +=   Error Rate < 5%:   ${errorPass ? '✅ PASS' : '❌ FAIL'}\n;
    
    summary += '\n' + '='.repeat(70) + '\n';
    
    return summary;
}

การรัน Load Test และวิเคราะห์ผลลัพธ์

# วิธีที่ 1: รัน Locust (Web UI Mode)
locust -f locustfile.py \
    --host=https://api.holysheep.ai/v1 \
    --users=100 \
    --spawn-rate=10 \
    --run-time=5m \
    --headless \
    --html=report.html \
    --csv=results

วิธีที่ 2: รัน k6 (Command Line)
k6 run k6-load-test.js \
    --env API_KEY=YOUR_HOLYSHEEP_API_KEY \
    --summary-export=summary.json \
    --out influxdb=http://localhost:8086/k6

วิธีที่ 3: รัน k6 กับ Grafana Dashboard
Start InfluxDB + Grafana ก่อน
docker run -d --name influxdb -p 8086:8086 influxdb:2.0
docker run -d --name grafana -p 3000:3000 grafana/grafana

รัน k6 พร้อมส่ง metrics ไปยัง InfluxDB
k6 run k6-load-test.js \
    --out influxdb=http://localhost:8086/k6

วิธีที่ 4: Distributed Testing กับ Locust
Master Node
locust -f locustfile.py \
    --master \
    --bind-host 0.0.0.0 \
    --port 8089

Worker Nodes (รันหลายเครื่อง)
locust -f locustfile.py \
    --worker \
    --master-host= \
    --master-port=8089

วิเคราะห์ผลลัพธ์ด้วย Python
python << 'EOF'
import pandas as pd
import matplotlib.pyplot as plt

อ่านผลลัพธ์จาก CSV
df = pd.read_csv('results_stats.csv')
df_requests = pd.read_csv('results_stats_history.csv')

วิเคราะห์ Performance
print("📊 Performance Analysis")
print("="*50)
print(f"Total Requests: {df['Request Count'].sum()}")
print(f"Failure Rate: {df['Failure Count'].sum() / df['Request Count'].sum() * 100:.2f}%")
print(f"Average Response Time: {df['Average Response Time'].mean():.2f}ms")
print(f"P95 Response Time: {df['95%'].max():.2f}ms")
print(f"P99 Response Time: {df['99%'].max():.2f}ms")
print(f"Max Response Time: {df['Maximum'].max():.2f}ms")
print(f"RPS: {df['Requests/s'].mean():.2f}")

สร้างกราฟ
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

Response Time over Time
axes[0, 0].plot(df_requests['Timestamp'], df_requests['Average Response Time'])
axes[0, 0].fill_between(df_requests['Timestamp'], df_requests['Average Response Time'])
axes[0, 0].set_title('Average Response Time Over Time')
axes[0, 0].set_xlabel('Time')
axes[0, 0].set_ylabel('Response Time (ms)')

RPS over Time
axes[0, 1].plot(df_requests['Timestamp'], df_requests['Requests/s'])
axes[0, 1].set_title('Requests Per Second')
axes[0, 1].set_xlabel('Time')
axes[0, 1].set_ylabel('RPS')

Failure Rate
axes[1, 0].plot(df_requests['Timestamp'], df_requests['Failure Count'])
axes[1, 0].set_title('Failures Over Time')
axes[1, 0].set_xlabel('Time')
axes[1, 0].set_ylabel('Failures')

Percentiles
percentiles = ['50%', '66%', '75%', '80%', '90%', '95%', '98%', '99%']
values = [df[p].max() for p in percentiles]
axes[1, 1].bar(percentiles, values)
axes[1, 1].set_title('Response Time Percentiles')
axes[1, 1].set_xlabel('Percentile')
axes[1, 1].set_ylabel('Response Time (ms)')
axes[1, 1].tick_params(axis='x', rotation=45)

plt.tight_layout()
plt.savefig('load_test_analysis.png', dpi=150)
print("\n✅ Chart saved as load_test_analysis.png")
EOF

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

หัวข้อ	Locust	k6
เหมาะกับ	ทีมที่ใช้ Python อยู่แล้ว, ต้องการความยืดหยุ่นสูง, ต้องการ Web UI สำหรับ stakeholder	ทีม DevOps, CI/CD Pipeline, ต้องการ Performance สูง, ต้องการ Integrate กับ Prometheus/Grafana
ไม่เหมาะกับ	ทีมที่ไม่มี Python Knowledge, ต้องการ Testing ข้าม Platform	ทีมที่ต้องการ Web UI ง่ายๆ, Non-technical stakeholder
Learning Curve	ต่ำ - คนที่รู้ Python สามารถเริ่มได้ทันที	ปานกลาง - ต้องเรียนรู้ JavaScript ES6+ และ k6 API
Scaling	รองรับ Distributed Mode ได้ดี	เร็วกว่ามากในโหมด Single Node
Integration	CSV, HTML Report, InfluxDB	InfluxDB, Prometheus, Datadog, CloudWatch, JSON

ราคาและ ROI

การย้าย API จากผู้ให้บริการรายเดิมมายัง HolySheep สามารถประหยัดค่าใช้จ่ายได้มากกว่า 85% พร้อม Performance ที่ดีกว่า

รุ่นโมเดล	ราคาเดิม ($/MTok)	ราคา HolySheep ($/MTok)	ประหยัด (%)
GPT-4.1	$60.00	$8.00	86.7%
Claude Sonnet 4.5	$100.00	$15.00	85.0%
Gemini 2.5 Flash	$17.50	$2.50	85.7%
DeepSeek V3.2	$2.80	$0.42	85.0%

ตัวอย่างการคำนวณ ROI:

การใช้งาน 10 ล้าน Tokens/เดือน ด้วย GPT-4.1
ค่าใช้จ่ายเดิม: $600/เดือน
ค่าใช้จ่ายกับ HolySheep: $80/เดือน
ประหยัด: $520/เดือน ($6,240/ปี)

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

1. Error: 401 Authentication Failed

# ❌ ปัญหา: API Key ไม่ถูกต้องหรือหมดอายุ
Error Message: {"error": {"message": "Incorrect API key", "type": "invalid_request_error"}}

✅ วิธีแก้ไข:
1. ตรวจสอบ API Key ที่ https://www.holysheep.ai/register
2. ตรวจสอบว่าไม่มีช่องว่างหรืออักขระพิเศษต่อท้าย
3. ตรวจสอบ .env file

import os
from dotenv import load_dotenv

load_dotenv()
API_KEY = os.getenv('HOLYSHEEP_API_KEY')

ตรวจสอบความถูกต้อง
if not API_KEY or API_KEY
แหล่งข้อมูลที่เกี่ยวข้อง
📚 บทช่วยสอน AI API
💰 ดูราคา
📖 เอกสารสำหรับนักพัฒนา
🚀 สมัครฟรี
บทความที่เกี่ยวข้อง
MiniMax vs Moonshot vs Step-2: วิเคราะห์ AI จีนรุ่นที่สอง ทำ
BTC ทะลุ 100,000 ดอลลาร์: วิเคราะห์โครงสร้างตลาดจุลภาคด้วย T
量化回测性能优化：Tardis 大规模数据的内存管理与并行计算

ทำไมต้องทดสอบ Load สำหรับ AI API

การตั้งค่า Environment สำหรับทดสอบ HolySheep API

สร้างไฟล์ .env สำหรับ HolySheep API

ตรวจสอบการเชื่อมต่อ

การทดสอบด้วย Locust — Python-based Load Testing

ตั้งค่า Configuration

ตัวอย่าง Prompts สำหรับทดสอบ

Event Handlers สำหรับเก็บ Metrics

การทดสอบด้วย k6 — Modern Load Testing Framework

การรัน Load Test และวิเคราะห์ผลลัพธ์

วิธีที่ 2: รัน k6 (Command Line)

วิธีที่ 3: รัน k6 กับ Grafana Dashboard

Start InfluxDB + Grafana ก่อน

รัน k6 พร้อมส่ง metrics ไปยัง InfluxDB

วิธีที่ 4: Distributed Testing กับ Locust

Master Node

Worker Nodes (รันหลายเครื่อง)

วิเคราะห์ผลลัพธ์ด้วย Python

อ่านผลลัพธ์จาก CSV

วิเคราะห์ Performance

สร้างกราฟ

Response Time over Time

RPS over Time

Failure Rate

Percentiles

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

ราคาและ ROI

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

1. Error: 401 Authentication Failed

Error Message: {"error": {"message": "Incorrect API key", "type": "invalid_request_error"}}

✅ วิธีแก้ไข:

1. ตรวจสอบ API Key ที่ https://www.holysheep.ai/register

2. ตรวจสอบว่าไม่มีช่องว่างหรืออักขระพิเศษต่อท้าย

3. ตรวจสอบ .env file

ตรวจสอบความถูกต้อง

แหล่งข้อมูลที่เกี่ยวข้อง

บทความที่เกี่ยวข้อง

🔥 ลอง HolySheep AI