Rate Limit REST API Exchange: Desain dan Implementasi Retry

Masalah: Mengapa Rate Limit dan Retry Penting?

Saat membangun bot trading atau infrastruktur yang berinteraksi dengan REST API exchange, dua tantangan utama adalah:

1. Rate Limit: Exchange memberlakukan batasan jumlah permintaan yang dapat Anda buat dalam periode waktu tertentu. Melanggar rate limit dapat mengakibatkan pemblokiran sementara atau permanen.
2. Gangguan Jaringan: Jaringan tidak selalu dapat diandalkan. Permintaan API dapat gagal karena berbagai alasan, seperti masalah konektivitas atau server yang sibuk.

Tanpa penanganan yang tepat, rate limit dan gangguan jaringan dapat menyebabkan:

• Performa bot yang tidak dapat diprediksi
• Kehilangan peluang trading
• Potensi kerugian finansial

Desain: Arsitektur Penanganan Rate Limit dan Retry

Arsitektur yang baik harus mencakup komponen-komponen berikut:

• Rate Limiter: Melacak penggunaan API dan mencegah pengiriman permintaan melebihi batas yang ditetapkan.
• Retry Policy: Secara otomatis mencoba kembali permintaan yang gagal, idealnya dengan exponential backoff.
• Error Handling: Mencatat dan menangani kesalahan yang tidak dapat dipulihkan.

Trade-off utama adalah antara latensi dan reliabilitas. Retry dapat meningkatkan reliabilitas tetapi juga dapat menambah latensi. Penting untuk menyeimbangkan kedua faktor ini berdasarkan kebutuhan aplikasi Anda.

Langkah Implementasi

Berikut adalah langkah-langkah umum untuk mengimplementasikan penanganan rate limit dan retry:

1. Implementasi Rate Limiter

Anda dapat menggunakan library rate limiting yang ada atau mengimplementasikan sendiri. Contoh pseudocode:

class RateLimiter:
    def __init__(self, max_requests, period):
        self.max_requests = max_requests
        self.period = period
        self.request_count = 0
        self.last_reset = time.time()

    def allow_request(self):
        current_time = time.time()
        if current_time - self.last_reset > self.period:
            self.request_count = 0
            self.last_reset = current_time

        if self.request_count < self.max_requests:
            self.request_count += 1
            return True
        else:
            return False

2. Implementasi Retry Policy dengan Exponential Backoff

Exponential backoff adalah strategi di mana waktu tunggu antara percobaan ulang meningkat secara eksponensial. Ini membantu menghindari pembebanan server yang berlebihan.

import time
import random

def retry_request(func, max_retries=5, base_delay=1):
    for attempt in range(max_retries):
        try:
            return func()
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            delay = base_delay * (2 ** attempt) + random.uniform(0, 1)  # Exponential backoff with jitter
            print(f"Request failed, retrying in {delay:.2f} seconds...")
            time.sleep(delay)

3. Integrasi dengan REST API Client

Integrasikan rate limiter dan retry policy ke dalam client REST API Anda. Contoh:

import requests

rate_limiter = RateLimiter(max_requests=100, period=60) # Contoh: 100 requests per 60 detik

def make_request():
    if rate_limiter.allow_request():
        response = requests.get(")
        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
        return response.json()
    else:
        raise Exception("Rate limit exceeded")

def safe_request():
    try:
        return make_request()
    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 429:
            print("Rate limit hit, retrying...")
            raise # Let retry policy handle the 429
        else:
            raise # Re-raise other HTTP errors
    except Exception as e:
        print(f"Request failed: {e}")
        raise

# Use the retry policy
data = retry_request(safe_request)
print(data)

Pitfall Produksi

Berikut adalah beberapa pitfall yang perlu dihindari dalam produksi:

• Tidak Memperhitungkan Header Retry-After: Beberapa exchange mengembalikan header Retry-After yang menunjukkan berapa lama Anda harus menunggu sebelum mencoba lagi. Selalu periksa header ini dan gunakan nilainya untuk menyesuaikan waktu tunggu Anda.
• Mengabaikan Variasi Rate Limit: Rate limit dapat bervariasi berdasarkan endpoint API, jenis permintaan, dan tingkat akun. Pastikan Anda memahami rate limit yang berlaku untuk setiap permintaan yang Anda buat.
• Penanganan Error yang Tidak Tepat: Jangan hanya mencoba kembali semua kesalahan. Beberapa kesalahan, seperti kesalahan autentikasi, memerlukan penanganan yang berbeda.
• Kurangnya Monitoring: Pantau penggunaan API Anda secara teratur untuk mendeteksi dan mengatasi masalah rate limit dengan cepat.

Checklist

Berikut adalah checklist untuk memastikan implementasi penanganan rate limit dan retry yang kuat:

• [ ] Pahami rate limit untuk setiap endpoint API yang Anda gunakan.
• [ ] Implementasikan rate limiter untuk mencegah pengiriman permintaan melebihi batas.
• [ ] Gunakan retry policy dengan exponential backoff untuk menangani kesalahan sementara.
• [ ] Periksa header Retry-After dan gunakan nilainya.
• [ ] Tangani kesalahan dengan tepat dan catat kesalahan yang tidak dapat dipulihkan.
• [ ] Pantau penggunaan API Anda secara teratur.
• [ ] Uji implementasi Anda secara menyeluruh dalam lingkungan produksi.

FAQ

Apa yang terjadi jika saya terus melanggar rate limit?

Exchange dapat memblokir IP address Anda sementara atau permanen. Beberapa exchange juga dapat mengenakan biaya tambahan.

Bagaimana cara mengetahui rate limit yang berlaku untuk API?

Informasi rate limit biasanya tersedia di dokumentasi API exchange. Anda juga dapat memeriksa header respons API, yang sering kali menyertakan informasi tentang penggunaan rate limit saat ini. Contohnya, Binance menyertakan X-MBX-USED-WEIGHT-(intervalNum)(intervalLetter) dalam response header.

Apakah exponential backoff selalu merupakan strategi terbaik?

Tidak selalu. Dalam beberapa kasus, strategi lain, seperti linear backoff atau fixed delay, mungkin lebih sesuai. Pilihan strategi tergantung pada karakteristik API dan kebutuhan aplikasi Anda.

Bagaimana cara menangani kesalahan yang tidak dapat dipulihkan?

Kesalahan yang tidak dapat dipulihkan, seperti kesalahan autentikasi, harus dicatat dan ditangani dengan tepat. Anda mungkin perlu memberi tahu pengguna atau mengambil tindakan lain untuk memperbaiki masalah.