ឯកសារ 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

ការប្រមូលការតភ្ជាប់
// Node.js HTTP Agent ជាមួយការប្រមូល
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 ផ្គូផ្គងពេលវេលារង់ចាំរបស់សឺវ័រ

ប្រតិបត្តិការជាក្រុម

ការបញ្ចូលការស្នើសុំ

ការស្នើសុំជាក្រុម
// ជំនួសឱ្យការស្នើសុំច្រើន
// 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 ជួរ

ការធ្វើឱ្យប្រសើរនៃការស្នើសុំ

ការធ្វើឱ្យប្រសើរការស្នើសុំ

  • បញ្ជាក់វាល — ស្នើសុំតែវាលដែលត្រូវការ
  • ប្រើតម្រង — បន្ថយទំហំការឆ្លើយតបជាមួយតម្រង
  • ការបែងចែកទំព័រ — ប្រើប៉ារ៉ាម៉ែត្រកំណត់ មិនមែនផ្លាស់ទី
  • រយៈពេល — ស្នើសុំតែទិន្នន័យដែលអ្នកត្រូវការ
ការស្នើសុំដែលបានធ្វើឱ្យប្រសើរ
// មិនប្រសើរ៖ ទិន្នន័យច្រើន
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 បង្ហាប់ដោយស្វ័យប្រវត្តិប្រសិនបើគាំទ្រ
// ការបង្ហាប់ធម្មតា៖ កាត់បន្ថយទំហំ ៧០-៨០%

ការសន្សំពីការបង្ហាប់

ប្រភេទទិន្នន័យ មិនបានបង្ហាប់ បានបង្ហាប់ ការសន្សំ
ការឆ្លើយតប 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
  • ធ្វើតេស្តជាមួយកម្រិតភាពស្របគ្នាដែលសម្បូរបែប
  • វាស់ការចែកចាយពេលវេលាពន្យារ មិនមែនគ្រាន់តែមធ្យមទេ
  • ធ្វើតេស្តជាមួយឃ្លាំងសម្ងាត់ក្តៅនិងត្រជាក់

អនុសាសន៍ពីការធ្វើឱ្យប្រសើរ

ការឈ្នះរហ័ស

  1. បើកការដាក់ជាក្រុម HTTP connection pooling (ការកែលម្អ 1-5 ដង)
  2. អនុវត្តការផ្ទុកជាមូលដ្ឋាន (កែលម្អ 10-50 ដងសម្រាប់សំណើរដដែលៗ)
  3. ប្រើប្រតិបត្តិការជាក្រុម (កាត់បន្ថយសំណើរ 2-5 ដង)
  4. បើកការបង្ហាប់ gzip (កាត់បន្ថយ bandwidth 3-5 ដង)

ការធ្វើឱ្យប្រសើរកម្រិតខ្ពស់

  1. អនុវត្តការផ្ទុក CDN សម្រាប់ទិន្នន័យប្រវត្តិសាស្ត្រ
  2. ប្រើការដាក់ជាក្រុមការភ្ជាប់ទិន្នន័យសម្រាប់ការផ្ទុកជាមូលដ្ឋាន
  3. អនុវត្តគំរូ circuit breaker
  4. ប្រើការឆ្លើយតបដោយហូរសម្រាប់ទិន្នន័យច្រើន

សម្រេចបាននូវដំណើរការអតិបរមា

Smart Money API ត្រូវបានបង្កើតសម្រាប់ល្បឿន។ អនុវត្តយុទ្ធសាស្ត្រការធ្វើឱ្យប្រសើរទាំងនេះសម្រាប់ពេលវេលាពន្យារតិចជាង 100ms និងដំណើរការអតិបរមា។

មើលកម្រិតដំណើរការ
គម្រោង Pro និង Enterprise រួមបញ្ចូលលក្ខណៈពិសេសនៃការផ្ទុកនិងដំណើរការកម្រិតខ្ពស់។

ធនធានពាក់ព័ន្ធ

ការផ្ទុកការឆ្លើយតប →

យុទ្ធសាស្ត្រផ្ទុកកម្រិតខ្ពស់

ប្រតិបត្តិការជាក្រុម →

ប្រតិបត្តិការទិន្នន័យច្រើនដែលមានប្រសិទ្ធភាព

ការត្រួតពិនិត្យ →

ការត្រួតពិនិត្យនិងការជូនដំណឹងដំណើរការ
ចាប់ផ្តើមដោយឥតគិតថ្លៃ — 100 ការហៅ/ថ្ងៃ, គ្មានកាត

ទទួលបានលំហូរសត្វច្រែងផ្ទាល់, ការផ្តល់មូលនិធិ, ការចាប់អារម្មណ៍បើក និងទិន្នន័យ on-chain ពី 3 កន្លែងផ្លាស់ប្តូរពី API តែមួយ។ កម្រិតឥតគិតថ្លៃ, គ្មានកាតឥណទាន, ដំឡើងកម្រិតណាមួយពេល។

ចាប់ផ្តើមដោយឥតគិតថ្លៃ →
សាកល្បងកុងសូល API ផ្ទាល់ → (មិនត្រូវការគណនី)