ساخت APIهای بهتر با ThrottleX: Rate Limiting به درستی انجام شد

Summarize this content to 400 words in Persian Lang
هی انجمن توسعه دهندگان! 👋 من با دنیای متن باز کاملاً تازه کار هستم و از هر توصیه ای که ممکن است داشته باشید خوشحال می شوم.

اگر تا به حال یک API ساخته اید که نیاز به مدیریت دارد کنترل ترافیک، شما می دانید که محدود کردن نرخ برای منصفانه و کارآمد نگه داشتن چیزها بسیار مهم است. امروز، من مشتاق هستم که شما را با پروژه منبع باز خود آشنا کنم: ThrottleX – یک محدود کننده نرخ قدرتمند، انعطاف پذیر و آسان برای استفاده برای API های شما! 🚀

ThrottleX چیست؟

ThrottleX یک است کتابخانه محدود کننده نرخ توزیع شده برای Go که به شما کمک می کند از استفاده منصفانه از منابع API خود، حتی تحت بار سنگین اطمینان حاصل کنید. چه با افزایش درخواست‌های یک کاربر مواجه باشید یا بخواهید از سوء استفاده جلوگیری کنید، ThrottleX شما را با چندین استراتژی محدودکننده نرخ تحت پوشش قرار می‌دهد.

ویژگی های فعلی 💡

ThrottleX در حال حاضر پشتیبانی می کند سه سیاست اصلی محدود کننده نرخ:

محدود کردن نرخ پنجره ثابت

تصور کنید که یک کافی شاپ کوچک دارید و فقط تعداد معینی شات اسپرسو در دقیقه در دسترس دارید. پنجره ثابت درخواست‌ها را در یک بازه زمانی ثابت به یک عدد مشخص محدود می‌کند – ساده، موثر و عالی برای مدیریت رگبار ترافیک API.

محدود کردن نرخ پنجره کشویی

پنجره کشویی به طور مشابه کار می کند اما مانند یک میانگین متحرک برای درخواست ها عمل می کند. به جای بازنشانی کامل، بیشتر فراهم می کند کنترل دانه ای بیش از درخواست برای جلوگیری از افزایش ناگهانی. مانند این است که شات های اسپرسوی خود را به طور مساوی در هر دقیقه توزیع کنید تا خدمات ثابتی داشته باشید. ☕

محدودیت نرخ سطل توکن

این خط‌مشی به شما امکان می‌دهد در طول زمان توکن‌ها را جمع‌آوری کنید و در صورت نیاز آنها را خرج کنید. انعطاف‌پذیر است و تا زمانی که توکن‌های کافی در دسترس باشد، امکان فعالیت‌های ناگهانی را فراهم می‌کند. اگر به اندازه کافی توکن‌های وفاداری ذخیره کرده باشند، به این فکر کنید که کسی چندین قهوه می‌خرد! ☕🎟️

بعد چه می شود؟ نقشه راه آینده

ما هنوز تمام نشده ایم! در اینجا چیزی است که ما برای ThrottleX کار می کنیم تا آن را حتی بیشتر تطبیق دهیم:

محدودیت نرخ اولویت بندی شده: کاربران مختلف، اولویت های مختلف! به زودی می‌توانیم درخواست‌ها را برای کاربران یا خدمات خاص اولویت‌بندی کنیم.

درخواست سیاست توکن: به کاربران اجازه می دهد تا توکن های خاصی را برای افزایش محدودیت نرخ خود ارائه دهند.

محدود کردن نرخ عقب نشینی نمایی: به تدریج زمان انتظار را برای مشتریانی که به محدودیت های نرخ ادامه می دهند افزایش دهید.

محدود کردن نرخ جغرافیایی: بر اساس مناطق جغرافیایی محدودیت‌های نرخ متفاوتی را تنظیم کنید. 🌍

محدودیت نرخ سلسله مراتبی: محدودیت های نرخ را در بین کاربران/گروه ها در یک ساختار سلسله مراتبی اعمال کنید.

محدود کردن نرخ پویا: محدودیت های نرخ را به صورت پویا بر اساس بار سرور تنظیم کنید. 🌡️

درخواست خط‌مشی‌های سهمیه (سهمیه ثابت/تقریبی): سهمیه های مختلف را برای کاربران یا گروه ها در مدت زمان طولانی تنظیم کنید.

محدودیت همزمانی: تعداد درخواست های همزمان را محدود کنید.

الگوریتم سطل نشتی: شبیه سطل توکن است اما سرعت جریان ثابتی را اعمال می کند و از ترکیدن ناگهانی جلوگیری می کند.

ما می خواهیم ThrottleX باشد چاقوی ارتش سوئیس محدود کردن نرخ 🛠️

نحوه استفاده از ThrottleX

شروع کار با ThrottleX ساده است! آن را به پروژه Go خود اضافه کنید و آماده شروع کار هستید. در اینجا یک مثال سریع از استفاده از یکی از سیاست ها آورده شده است:

package main

import (
“github.com/neelp03/throttlex/ratelimiter”
“github.com/neelp03/throttlex/store”
“time”
“fmt”
)

func main() {
// Initialize an in-memory store and a fixed window rate limiter
memStore := store.NewMemoryStore()
limiter, err := ratelimiter.NewFixedWindowLimiter(memStore, 10, time.Second*60)
if err != nil {
fmt.Println(“Failed to create limiter:”, err)
return
}

// Simulate requests
key := “user1”
for i := 0; i < 12; i++ {
allowed, err := limiter.Allow(key)
if err != nil {
fmt.Println(“Error:”, err)
continue
}
if allowed {
fmt.Printf(“Request %d allowed\n”, i+1)
} else {
fmt.Printf(“Request %d blocked\n”, i+1)
}
}

// Simulate requests from multiple clients (e.g., 25 clients)
clients := 25
for i := 0; i < clients; i++ {
key := fmt.Sprintf(“client%d”, i+1)
for j := 0; j < 12; j++ {
allowed, err := limiter.Allow(key)
if err != nil {
fmt.Printf(“Client %d – Error: %v\n”, i+1, err)
continue
}
if allowed {
fmt.Printf(“Client %d – Request %d allowed\n”, i+1, j+1)
} else {
fmt.Printf(“Client %d – Request %d blocked\n”, i+1, j+1)
}
}
}
}

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

در مثال بالا استفاده می کنیم رفع محدودیت پنجره محدود کردن user1 به 10 درخواست در دقیقه. هنگامی که درخواست های یازدهم و دوازدهم انجام می شود، آنها مسدود می شوند و استفاده منصفانه را تضمین می کند. ما همچنین نحوه شبیه سازی را نشان می دهیم 25 مشتری درخواست‌ها، هرکدام به طور مستقل با نرخ محدود.

مثال Redis برای محیط های توزیع شده

ThrottleX همچنین از Redis به عنوان یک ذخیره سازی پشتیبانی می کند، ایده آل برای محیط های توزیع شده که در آن شما نیاز به اعمال محدودیت های نرخ در چندین سرور دارید:

package main

import (
“github.com/go-redis/redis/v8”
“github.com/neelp03/throttlex/ratelimiter”
“github.com/neelp03/throttlex/store”
“time”
“fmt”
“context”
)

func main() {
// Set up Redis client
client := redis.NewClient(&redis.Options{
Addr: “localhost:6379”,
})
err := client.Ping(context.Background()).Err()
if err != nil {
fmt.Println(“Failed to connect to Redis:”, err)
return
}

// Initialize a Redis store and a fixed window rate limiter
redisStore := store.NewRedisStore(client)
limiter, err := ratelimiter.NewFixedWindowLimiter(redisStore, 10, time.Second*60)
if err != nil {
fmt.Println(“Failed to create limiter:”, err)
return
}

// Simulate requests from multiple clients (e.g., 25 clients)
clients := 25
for i := 0; i < clients; i++ {
key := fmt.Sprintf(“client%d”, i+1)
for j := 0; j < 12; j++ {
allowed, err := limiter.Allow(key)
if err != nil {
fmt.Printf(“Client %d – Error: %v\n”, i+1, err)
continue
}
if allowed {
fmt.Printf(“Client %d – Request %d allowed\n”, i+1, j+1)
} else {
fmt.Printf(“Client %d – Request %d blocked\n”, i+1, j+1)
}
}
}
}

وارد حالت تمام صفحه شوید

از حالت تمام صفحه خارج شوید

این مثال نحوه استفاده از Redis برای اعمال را نشان می دهد رفع محدودیت پنجره در چندین مشتری Redis مدیریت محدودیت نرخ را در یک تنظیمات توزیع شده فعال می کند و ThrottleX را به یک انتخاب عالی برای مقیاس بندی برنامه ها تبدیل می کند.

چرا ThrottleX؟ 🤔

در حالی که محدودیت‌های نرخ زیادی وجود دارد، ThrottleX به گونه‌ای طراحی شده است سبک وزن، بسیار قابل تنظیم، و سازگار برای محیط های توزیع شده. با پشتیبانی از هر دو در حافظه و ردیس فضای ذخیره‌سازی، ThrottleX به شما انعطاف‌پذیری لازم را می‌دهد، خواه روی پروژه‌های کوچک کار می‌کنید یا راه‌حل‌های درجه یک سازمانی را به کار می‌گیرید. ✨

به سفر ThrottleX بپیوندید 🚀

من جامعه متن باز را دوست دارم و دوست دارم شما بخشی از این سفر باشید. ThrottleX هنوز در حال تکامل است و اگر ایده‌ها، درخواست‌هایی برای ویژگی دارید یا می‌خواهید مشارکت کنید، لطفاً انجام دهید! بیایید محدودیت نرخ را برای همه آسان تر و لذت بخش تر کنیم.

مخزن GitHub اینجاست: ThrottleX GitHub Repo

سر بزنید، به آن ستاره بدهید ⭐ اگر دوست دارید، و به گفتگو بپیوندید!

افکار نهایی

ساختن APIها چالش برانگیز است و حصول اطمینان از اجرای روان آنها در حالی که دسترسی منصفانه را فراهم می کند، چالش برانگیزتر است. ThrottleX تلاش من برای تسهیل این کار برای توسعه دهندگان در همه جا است.

من نمی توانم منتظر بمانم تا افکار شما را بشنوم و ببینم چه چیزی می توانیم با هم بسازیم. بیایید به بهبود وب ادامه دهیم، هر بار یک درخواست!

کد نویسی مبارک، همه!

نمودارهایی برای درک بهتر

در اینجا چند نمودار برای کمک به تجسم نحوه کار ThrottleX وجود دارد:

این فلوچارت نحوه عبور یک درخواست از ThrottleX را نشان می دهد، که درخواست را بر اساس سیاست محدود کردن نرخ پیکربندی شده اجازه می دهد یا مسدود می کند.

این نمودار سیاست‌های محدودکننده نرخ متفاوتی را نشان می‌دهد که در حال حاضر توسط ThrottleX پشتیبانی می‌شوند و همگی به عملکرد اصلی آن کمک می‌کنند.

package main

import (
    "github.com/neelp03/throttlex/ratelimiter"
    "github.com/neelp03/throttlex/store"
    "time"
    "fmt"
)

func main() {
    // Initialize an in-memory store and a fixed window rate limiter
    memStore := store.NewMemoryStore()
    limiter, err := ratelimiter.NewFixedWindowLimiter(memStore, 10, time.Second*60)
    if err != nil {
        fmt.Println("Failed to create limiter:", err)
        return
    }

    // Simulate requests
    key := "user1"
    for i := 0; i < 12; i++ {
        allowed, err := limiter.Allow(key)
        if err != nil {
            fmt.Println("Error:", err)
            continue
        }
        if allowed {
            fmt.Printf("Request %d allowed\n", i+1)
        } else {
            fmt.Printf("Request %d blocked\n", i+1)
        }
    }

    // Simulate requests from multiple clients (e.g., 25 clients)
    clients := 25
    for i := 0; i < clients; i++ {
        key := fmt.Sprintf("client%d", i+1)
        for j := 0; j < 12; j++ {
            allowed, err := limiter.Allow(key)
            if err != nil {
                fmt.Printf("Client %d - Error: %v\n", i+1, err)
                continue
            }
            if allowed {
                fmt.Printf("Client %d - Request %d allowed\n", i+1, j+1)
            } else {
                fmt.Printf("Client %d - Request %d blocked\n", i+1, j+1)
            }
        }
    }
}

package main

import (
    "github.com/go-redis/redis/v8"
    "github.com/neelp03/throttlex/ratelimiter"
    "github.com/neelp03/throttlex/store"
    "time"
    "fmt"
    "context"
)

func main() {
    // Set up Redis client
    client := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })
    err := client.Ping(context.Background()).Err()
    if err != nil {
        fmt.Println("Failed to connect to Redis:", err)
        return
    }

    // Initialize a Redis store and a fixed window rate limiter
    redisStore := store.NewRedisStore(client)
    limiter, err := ratelimiter.NewFixedWindowLimiter(redisStore, 10, time.Second*60)
    if err != nil {
        fmt.Println("Failed to create limiter:", err)
        return
    }

    // Simulate requests from multiple clients (e.g., 25 clients)
    clients := 25
    for i := 0; i < clients; i++ {
        key := fmt.Sprintf("client%d", i+1)
        for j := 0; j < 12; j++ {
            allowed, err := limiter.Allow(key)
            if err != nil {
                fmt.Printf("Client %d - Error: %v\n", i+1, err)
                continue
            }
            if allowed {
                fmt.Printf("Client %d - Request %d allowed\n", i+1, j+1)
            } else {
                fmt.Printf("Client %d - Request %d blocked\n", i+1, j+1)
            }
        }
    }
}