สารบัญ

ภาพรวม กลยุทธ์การแคช การรวมการเชื่อมต่อ การดำเนินการแบบแบตช์ การปรับแต่งคำสั่ง การบีบอัด รูปแบบการทำงานแบบอะซิงโครนัส เมตริกประสิทธิภาพ การทดสอบประสิทธิภาพ คำแนะนำการปรับปรุง

เอกสาร API

การปรับปรุงประสิทธิภาพ API และการลดความหน่วง

บรรลุเวลาตอบสนองต่ำกว่า 100ms ด้วย Smart Money API เรียนรู้การแคช การรวมการเชื่อมต่อ การดำเนินการแบบแบตช์ และการปรับแต่งคำสั่งเพื่อประสิทธิภาพสูงสุด

เผยแพร่ 21 มีนาคม 2026 • อ่าน 17 นาที • ประสิทธิภาพ

ภาพรวมประสิทธิภาพ

Smart Money API ถูกปรับแต่งเพื่อความหน่วงต่ำและประสิทธิภาพสูง บรรลุประสิทธิภาพสูงสุดด้วยการนำรูปแบบที่แนะนำไปใช้ในการผสานรวมของคุณ

ชั้นการปรับปรุงประสิทธิภาพ:

การแคช — การแคชแบบท้องถิ่นและ CDN ลดการร้องขอไปยังต้นทาง
การรวมการเชื่อมต่อ — ใช้การเชื่อมต่อซ้ำ ลดค่าโสหุ้ย
การดำเนินการแบบแบตช์ — รวมหลายคำขอเป็นหนึ่งเดียว
การปรับแต่งคำสั่ง — ขอเฉพาะข้อมูลที่จำเป็น
การทำงานแบบอะซิงโครนัส/ขนาน — ประมวลผลหลายคำขอพร้อมกัน

เป้าหมายประสิทธิภาพ: ความหน่วง P95 <100ms, P99 <500ms, เวลาทำงาน 99.9% ด้วยอัตราความผิดพลาด <0.1%

กลยุทธ์การแคช

การแคชการตอบสนอง

แคชท้องถิ่น
// เคารพส่วนหัว Cache-Control
const cache = new Map();
async function cachedFetch(url) {
  const cached = cache.get(url);
  if (cached && !cached.isExpired) {
    return cached.data;
  }
  const response = await fetch(url);
  const ttl = parseCacheControl(response.headers);
  cache.set(url, { data: response, expiry: ttl });
  return response;
}

การยกเลิกแคช

ข้อมูลสะสมวาฬ: TTL 5 นาที
อัตราเงินทุน: TTL 1 นาที
ข้อมูล OHLCV: TTL 1 ชั่วโมง
ข้อมูลประวัติ: TTL 24 ชั่วโมง

รับคีย์ API ของคุณใน 30 วินาที

พร้อมสร้างหรือยัง? รับคีย์ API ฟรี (100 ครั้ง/วัน ไม่ต้องใช้บัตร) และเริ่มดึงข้อมูลสดเกี่ยวกับวาฬ เงินทุน และข้อมูลบนเชน

รับคีย์ API →

การรวมการเชื่อมต่อ

การใช้การเชื่อมต่อ HTTP ซ้ำ

พูลการเชื่อมต่อ
// HTTP Agent ของ Node.js พร้อมพูล
const http = require('http');
const https = require('https');
const httpAgent = new http.Agent({
  keepAlive: true,
  maxSockets: 50,
  maxFreeSockets: 10
});
const httpsAgent = new https.Agent({
  keepAlive: true,
  maxSockets: 50,
  maxFreeSockets: 10
});
// ใช้ Agent ในการร้องขอ
fetch(url, { agent: httpsAgent });

การตั้งค่าการเชื่อมต่อ

พารามิเตอร์	แนะนำ	เหตุผล
maxSockets	50-100	สมดุลระหว่างการทำงานพร้อมกันและการใช้ทรัพยากร
maxFreeSockets	10-20	รักษาการเชื่อมต่อที่ไม่ได้ใช้งานเพื่อใช้ซ้ำ
keepAliveTimeout	60000ms	ตรงกับเวลา timeout ของเซิร์ฟเวอร์

การดำเนินการแบบแบตช์

การรวมคำขอ

คำขอแบบแบตช์
// แทนที่จะใช้หลายคำขอ
// GET /whales?asset=BTC
// GET /whales?asset=ETH
// GET /whales?asset=SOL
// ใช้คำขอแบบแบตช์เดียว
GET /v1/whales?asset=BTC,ETH,SOL
// ประหยัดเวลา ~200ms เมื่อเทียบกับ 3 คำขอตามลำดับ

ขีดจำกัดแบตช์

สัญลักษณ์สูงสุดต่อคำขอ: 100
ช่วงเวลาสูงสุด: 365 วัน
ผลลัพธ์สูงสุด: 10,000 แถว

การปรับแต่งคำสั่ง

การปรับแต่งคำขอ

ระบุฟิลด์ — ขอเฉพาะฟิลด์ที่จำเป็น
ใช้ตัวกรอง — ลดขนาดการตอบสนองด้วยตัวกรอง
การแบ่งหน้า — ใช้พารามิเตอร์ limit ไม่ใช่ offset
ช่วงเวลา — ขอเฉพาะข้อมูลที่คุณต้องการ

คำสั่งที่ปรับแต่งแล้ว
// ไม่มีประสิทธิภาพ: ข้อมูลมาก
GET /v1/whales?lookback=90d&limit=10000
// มีประสิทธิภาพมากขึ้น: ข้อมูลเฉพาะ
GET /v1/whales?
  asset=BTC&
  metric=accumulation&
  lookback=7d&
  limit=100

การบีบอัดการตอบสนอง

การบีบอัด Gzip

การบีบอัดคำขอ
// เปิดใช้งานการบีบอัดในคำขอ
fetch(url, {
  headers: {
    'Accept-Encoding': 'gzip, deflate'
  }
});
// API จะบีบอัดข้อมูลอัตโนมัติหากรองรับ
// การบีบอัดทั่วไป: ลดขนาดข้อมูลได้ 70-80%

ประหยัดจากการบีบอัด

ประเภทข้อมูล	ไม่บีบอัด	บีบอัด	ประหยัด
การตอบกลับแบบ JSON	500KB	85KB	83%
ตารางขนาดใหญ่	2MB	350KB	82%

รูปแบบ Async/Parallel

คำขอพร้อมกัน

คำขอแบบขนาน
// ไม่มีประสิทธิภาพ: แบบลำดับ
const btc = await fetch('/whales/BTC');
const eth = await fetch('/whales/ETH');
const sol = await fetch('/whales/SOL');
// เวลารวม: ~300ms
// มีประสิทธิภาพ: แบบขนาน
const [btc, eth, sol] = await Promise.all([
  fetch('/whales/BTC'),
  fetch('/whales/ETH'),
  fetch('/whales/SOL')
]);
// เวลารวม: ~100ms (เร็วขึ้น 3 เท่า!)

เมตริกประสิทธิภาพ

เมตริกหลัก

เมตริก	เป้าหมาย	การวัดผล
P50 Latency	<50ms	เวลาตอบสนองเฉลี่ย
P95 Latency	<100ms	เปอร์เซ็นไทล์ที่ 95
P99 Latency	<500ms	เปอร์เซ็นไทล์ที่ 99
Throughput	>1000 req/s	คำขอต่อวินาที

การตรวจสอบประสิทธิภาพ

การตรวจสอบประสิทธิภาพ
// ติดตามเวลาตอบสนอง
const start = performance.now();
const response = await fetch(url);
const duration = performance.now() - start;
// บันทึกเพื่อวิเคราะห์
console.log(`Request took ${duration}ms`);

การทดสอบประสิทธิภาพ

การทดสอบโหลด

ทดสอบการเชื่อมต่อของคุณเพื่อหาจุดบกพร่อง:

เครื่องมือ: Apache Bench, wrk, หรือ Locust
ทดสอบด้วยระดับการทำงานพร้อมกันที่สมจริง
วัดการกระจายเวลาตอบสนอง ไม่ใช่แค่ค่าเฉลี่ย
ทดสอบทั้งแบบแคชร้อนและเย็น

คำแนะนำการปรับปรุงประสิทธิภาพ

ปรับปรุงง่ายได้ผลเร็ว

เปิดใช้งาน HTTP connection pooling (ประสิทธิภาพดีขึ้น 1-5 เท่า)
ใช้ local caching (ประสิทธิภาพดีขึ้น 10-50 เท่าสำหรับคำขอซ้ำ)
ใช้ batch operations (ลดจำนวนคำขอลง 2-5 เท่า)
เปิดใช้งาน gzip compression (ลดปริมาณข้อมูลลง 3-5 เท่า)

การปรับปรุงประสิทธิภาพขั้นสูง

ใช้ CDN caching สำหรับข้อมูลย้อนหลัง
ใช้ database connection pools สำหรับ local caching
ใช้ circuit breaker pattern
ใช้ streaming responses สำหรับชุดข้อมูลขนาดใหญ่

ประสิทธิภาพสูงสุด

Smart Money API ออกแบบมาเพื่อความเร็ว ใช้กลยุทธ์การปรับปรุงเหล่านี้เพื่อให้ได้เวลาตอบสนองต่ำกว่า 100ms และปริมาณการทำงานสูงสุด

ดูระดับประสิทธิภาพ

แผน Pro และ Enterprise รวมถึงคุณสมบัติการแคชและประสิทธิภาพขั้นสูง