การ Implement Rate Limiting

การ Implement Rate Limiting

ในโลกของการพัฒนา API, Rate Limiting คือกลไกที่ใช้ควบคุมจำนวน Request ที่ Client แต่ละรายสามารถส่งเข้ามายัง API ของเราในช่วงเวลาที่กำหนด Rate Limiting มีความสำคัญอย่างยิ่งในการป้องกันการใช้งาน API ที่มากเกินไป (Abuse), Distributed Denial-of-Service (DDoS) Attacks, และการรักษาเสถียรภาพของระบบโดยรวม หากไม่มี Rate Limiting API ของคุณอาจถูกโจมตีหรือถูกใช้งานจนเกินขีดจำกัด ทำให้ผู้ใช้งานรายอื่นไม่สามารถเข้าถึงบริการได้

Rate Limiting คืออะไร

Rate Limiting ทำงานโดยการกำหนดขีดจำกัด (Limit) ของจำนวน Request ที่ Client แต่ละรายสามารถส่งเข้ามาในระยะเวลาที่กำหนด (Time Window) ตัวอย่างเช่น เราอาจกำหนดให้ Client แต่ละรายสามารถส่ง Request ได้ไม่เกิน 100 ครั้งต่อนาที หาก Client ส่ง Request เกินขีดจำกัดที่กำหนด API จะตอบกลับด้วย HTTP Status Code 429 Too Many Requests เพื่อแจ้งให้ Client ทราบว่ามีการส่ง Request มากเกินไป

เหตุผลที่ต้องใช้ Rate Limiting:

• ป้องกันการ Abuse: ป้องกันผู้ไม่หวังดีจากการใช้งาน API ในทางที่ผิด เช่น การส่ง Request จำนวนมากเพื่อดึงข้อมูลทั้งหมด
• ป้องกัน DDoS Attacks: ลดผลกระทบจาก Distributed Denial-of-Service Attacks ที่พยายามทำให้ API ไม่สามารถใช้งานได้
• รักษาเสถียรภาพของระบบ: ป้องกันไม่ให้ API ถูกใช้งานจนเกินขีดจำกัด ทำให้ผู้ใช้งานรายอื่นยังสามารถเข้าถึงบริการได้
• บริหารจัดการทรัพยากร: ช่วยให้เราสามารถบริหารจัดการทรัพยากรของ Server ได้อย่างมีประสิทธิภาพ
• สร้างแผนการใช้งาน (Usage Plans): สามารถใช้ Rate Limiting เป็นส่วนหนึ่งของแผนการใช้งาน API ที่แตกต่างกัน เช่น Free Tier อาจมี Rate Limit ที่ต่ำกว่า Paid Tier

การ Implement Rate Limiting

การ Implement Rate Limiting สามารถทำได้หลายวิธี ขึ้นอยู่กับความต้องการและสถาปัตยกรรมของระบบของเรา วิธีการที่พบบ่อยได้แก่:

• Memory-based Rate Limiting: ใช้ Memory (เช่น Redis หรือ Memcached) เพื่อเก็บจำนวน Request ที่ Client แต่ละรายส่งเข้ามา
• Database-based Rate Limiting: ใช้ Database (เช่น MySQL หรือ PostgreSQL) เพื่อเก็บจำนวน Request ที่ Client แต่ละรายส่งเข้ามา
• Token Bucket Algorithm: เป็น Algorithm ที่ใช้จำลองถังที่มี Token อยู่ เมื่อ Client ส่ง Request จะนำ Token ออกจากถัง หากถังไม่มี Token แล้ว Client จะไม่สามารถส่ง Request ได้
• Leaky Bucket Algorithm: เป็น Algorithm ที่ใช้จำลองถังที่มีน้ำอยู่ เมื่อ Client ส่ง Request จะเติมน้ำลงในถัง หากน้ำในถังเกินความจุ น้ำจะรั่วไหลออกไป

ในบทความนี้ เราจะเน้นการ Implement Rate Limiting โดยใช้ Memory-based approach ร่วมกับ Redis เนื่องจาก Redis มีประสิทธิภาพสูงและเหมาะกับการใช้งานในลักษณะนี้

ตัวอย่างการ Implement Rate Limiting ด้วย Redis ใน PHP

ก่อนอื่น เราต้องติดตั้ง Redis extension สำหรับ PHP ก่อน สามารถทำได้โดยใช้คำสั่ง:

sudo apt-get update
sudo apt-get install php-redis

หรือถ้าใช้ XAMPP/MAMP อาจจะต้อง enable extension ใน php.ini

จากนั้น เราสามารถสร้าง Class สำหรับจัดการ Rate Limiting ได้ดังนี้:

<?php

class RateLimiter
{
    private $redis;
    private $prefix = 'rate_limit:';
    private $limit;
    private $timeWindow;

    public function __construct($redis, $limit, $timeWindow)
    {
        $this->redis = $redis;
        $this->limit = $limit;
        $this->timeWindow = $timeWindow;
    }

    public function hit($key)
    {
        $redisKey = $this->prefix . $key;
        $count = $this->redis->incr($redisKey);

        if ($count == 1) {
            $this->redis->expire($redisKey, $this->timeWindow);
        }

        return $count;
    }

    public function tooManyRequests($key)
    {
        return $this->hit($key) > $this->limit;
    }

    public function getRemainingAttempts($key)
    {
        $redisKey = $this->prefix . $key;
        $count = $this->redis->get($redisKey) ?: 0;
        return max(0, $this->limit - $count); // Ensure it's not negative
    }

    public function getTimeWindow() {
        return $this->timeWindow;
    }
}

คำอธิบาย Code:

• __construct(): Constructor ของ Class รับ Redis connection, Limit และ Time Window เป็น Parameter
• hit(): เพิ่ม Counter สำหรับ Key ที่กำหนดใน Redis และตั้งค่า Expiry Time
• tooManyRequests(): ตรวจสอบว่าจำนวน Request เกิน Limit หรือไม่
• getRemainingAttempts(): คืนค่าจำนวน Request ที่เหลืออยู่
• getTimeWindow(): คืนค่า Time Window ที่กำหนด

การใช้ Middleware สำหรับ Rate Limiting

เพื่อให้การ Implement Rate Limiting เป็นไปอย่างง่ายดายและสามารถนำไปใช้กับ Endpoint ต่างๆ ได้อย่างสะดวก เราจะสร้าง Middleware สำหรับ Rate Limiting ใน Laravel

สร้าง Middleware โดยใช้ Artisan command:

php artisan make:middleware RateLimitMiddleware

แก้ไขไฟล์ app/Http/Middleware/RateLimitMiddleware.php ดังนี้:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Support\Facades\Redis;
use App\RateLimiter;
use Symfony\Component\HttpFoundation\Response;

class RateLimitMiddleware
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @param  int  $limit
     * @param  int  $timeWindow
     * @return mixed
     */
    public function handle($request, Closure $next, $limit = 60, $timeWindow = 60)
    {
        $key = $request->ip(); // Use IP address as the key

        $redis = Redis::connection();
        $rateLimiter = new RateLimiter($redis, $limit, $timeWindow);

        if ($rateLimiter->tooManyRequests($key)) {
            $remainingAttempts = $rateLimiter->getRemainingAttempts($key); // Should be 0
            $retryAfter = $rateLimiter->getTimeWindow();

            return response()->json([
                'message' => 'Too Many Requests.',
                'remaining_attempts' => $remainingAttempts,
                'retry_after' => $retryAfter
            ], Response::HTTP_TOO_MANY_REQUESTS)
            ->header('Retry-After', $retryAfter) // Standard header for 429
            ->header('X-RateLimit-Limit', $limit)
            ->header('X-RateLimit-Remaining', $remainingAttempts);

        }

        $remainingAttempts = $rateLimiter->getRemainingAttempts($key);
        return $next($request)
            ->header('X-RateLimit-Limit', $limit)
            ->header('X-RateLimit-Remaining', $remainingAttempts);
    }
}

คำอธิบาย Code:

• handle(): Method ที่ใช้จัดการ Request ที่เข้ามา
• $key: ใช้ IP address ของ Client เป็น Key สำหรับ Rate Limiting
• $limit และ $timeWindow: รับค่า Limit และ Time Window จาก Parameter ของ Middleware (Default คือ 60 Requests ต่อ 60 วินาที)
• ตรวจสอบว่าจำนวน Request เกิน Limit หรือไม่ หากเกิน จะ Return HTTP Status Code 429 Too Many Requests พร้อม Header Retry-After เพื่อแจ้งให้ Client ทราบว่าต้องรออีกนานเท่าไหร่
• เพิ่ม Headers X-RateLimit-Limit และ X-RateLimit-Remaining เพื่อแจ้ง Limit และจำนวน Request ที่เหลืออยู่ให้กับ Client

จากนั้น Register Middleware ใน app/Http/Kernel.php:

protected $routeMiddleware = [
    // ...
    'rate_limit' => \App\Http\Middleware\RateLimitMiddleware::class,
];

สุดท้าย ใช้ Middleware กับ Route ที่ต้องการ:

Route::get('/api/data', function () {
    return response()->json(['data' => 'This is some data']);
})->middleware('rate_limit:10,60'); // 10 requests per 60 seconds

ในตัวอย่างนี้ เราได้กำหนดให้ Endpoint /api/data สามารถรับ Request ได้ไม่เกิน 10 ครั้งต่อ 60 วินาที

Trade-offs:

• Memory-based vs. Database-based: Memory-based (เช่น Redis) มีประสิทธิภาพสูงกว่า Database-based แต่ข้อมูลอาจสูญหายได้หาก Server restart Database-based มีความทนทานกว่า แต่มี Latency ที่สูงกว่า
• IP address vs. User ID: การใช้ IP address เป็น Key อาจทำให้เกิดปัญหาหาก Client หลายรายใช้ IP address เดียวกัน (เช่น ผ่าน NAT) การใช้ User ID เป็น Key จะแม่นยำกว่า แต่ต้องมีการ Authentication ก่อน
• Time Window: การเลือก Time Window ที่เหมาะสมเป็นสิ่งสำคัญ หาก Time Window สั้นเกินไป อาจทำให้ผู้ใช้งานทั่วไปถูก Rate Limit ได้ง่าย หาก Time Window ยาวเกินไป อาจทำให้ผู้ไม่หวังดีสามารถส่ง Request จำนวนมากได้ก่อนที่จะถูก Rate Limit

แนวปฏิบัติที่ดี:

• ใช้ Header Retry-After: แจ้งให้ Client ทราบว่าต้องรออีกนานเท่าไหร่ก่อนที่จะสามารถส่ง Request ได้อีกครั้ง
• ใช้ Headers X-RateLimit-Limit และ X-RateLimit-Remaining: แจ้ง Limit และจำนวน Request ที่เหลืออยู่ให้กับ Client
• Log Rate Limit Events: ช่วยให้เราสามารถตรวจสอบและวิเคราะห์การใช้งาน API ได้
• ปรับแต่ง Rate Limit ตาม Endpoint: Endpoint ที่มีความสำคัญหรือใช้ทรัพยากรมาก อาจมี Rate Limit ที่ต่ำกว่า Endpoint อื่นๆ
• มี White List: อนุญาตให้ Client ที่เชื่อถือได้ (เช่น Partner API) สามารถ Bypass Rate Limit ได้

การ Implement Rate Limiting เป็นสิ่งสำคัญในการรักษาเสถียรภาพและความปลอดภัยของ API ของคุณ การเลือกวิธีการ Implement และการตั้งค่า Parameter ที่เหมาะสมจะช่วยให้คุณสามารถป้องกันการใช้งาน API ที่มากเกินไปและให้บริการแก่ผู้ใช้งานทั่วไปได้อย่างราบรื่น ในบทความถัดไป เราจะพูดถึงการใช้ Queues สำหรับ Background Processing ซึ่งเป็นอีกหนึ่งเทคนิคที่ช่วยเพิ่มประสิทธิภาพของ API ของเรา