Хорошо, ребята, мы уже многое рассмотрели: аутентификацию JWT, подключения к базе данных, ведение журналов и обработку ошибок. Но что произойдет, когда ваш API начнет забиваться запросами? Без контроля высокий трафик может привести к замедлению времени отклика или даже к простою. ?

На этой неделе мы собираемся решить эту проблему, внедрив ограничение скорости для контроля потока трафика. Мы будем использовать простой и эффективный пакет golang.org/x/time/rate. Позже, когда мое собственное решение ThrottleX будет готово, я покажу вам, как его интегрировать как более масштабируемый вариант. (Тсс, зайдите на мой GitHub по адресу github.com/neelp03/throttlex, чтобы быть в курсе обновлений! Не стесняйтесь комментировать любые проблемы, которые вы там видите o7)

Зачем ограничивать ставки? ?

Ограничение скорости похоже на отбойник для вашего API: оно контролирует количество запросов, которые пользователи могут сделать в течение определенного периода времени. Это предотвращает перегрузку вашего API, обеспечивая плавный и справедливый доступ для всех пользователей. Ограничение скорости необходимо для:

• Предотвращение злоупотреблений: не позволяет злоумышленникам или чрезмерно восторженным пользователям перегружать ваш API.
• Стабильность: ваш API обеспечивает оперативность и надежность даже во время пиков трафика.
• Справедливость: позволяет поровну распределять ресурсы между пользователями.

Шаг 1. Установка пакета времени/тарифа

Пакет golang.org/x/time/rate является частью расширенных библиотек Go и предоставляет простой ограничитель скорости на основе токенов. Для начала вам необходимо установить его:

go get golang.org/x/time/rate

Шаг 2. Настройка ограничителя скорости

Давайте создадим промежуточное программное обеспечение, ограничивающее скорость, которое контролирует количество запросов, которые может сделать клиент. В этом примере мы ограничим клиентов 5 запросами в минуту.

package main

import (
    "net/http"
    "golang.org/x/time/rate"
    "sync"
    "time"
)

// Create a struct to hold each client's rate limiter
type Client struct {
    limiter *rate.Limiter
}

// In-memory storage for clients
var clients = make(map[string]*Client)
var mu sync.Mutex

// Get a client's rate limiter or create one if it doesn't exist
func getClientLimiter(ip string) *rate.Limiter {
    mu.Lock()
    defer mu.Unlock()

    // If the client already exists, return the existing limiter
    if client, exists := clients[ip]; exists {
        return client.limiter
    }

    // Create a new limiter with 5 requests per minute
    limiter := rate.NewLimiter(5, 1)
    clients[ip] = &Client{limiter: limiter}
    return limiter
}

Шаг 3. Создание промежуточного программного обеспечения, ограничивающего скорость

Теперь давайте воспользуемся функцией getClientLimiter в промежуточном программном обеспечении, которое будет ограничивать доступ на основе ограничения скорости.

func rateLimitingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ip := r.RemoteAddr
        limiter := getClientLimiter(ip)

        // Check if the request is allowed
        if !limiter.Allow() {
            http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
            return
        }

        next.ServeHTTP(w, r)
    })
}

Как это работает:

1. Ограничение на основе IP: каждый клиент идентифицируется по IP-адресу. Проверяем IP клиента и назначаем ему ограничитель скорости.
2. Проверка запроса: метод limiter.Allow() проверяет, находится ли клиент в пределах ограничения скорости. Если да, запрос переходит к следующему обработчику; если нет, мы отвечаем 429 Too Many Requests.

Шаг 4. Глобальное применение промежуточного программного обеспечения?

Теперь давайте подключим наш ограничитель скорости к API, чтобы каждый запрос проходил через него:

func main() {
    db = connectDB()
    defer db.Close()

    r := mux.NewRouter()

    // Apply rate-limiting middleware globally
    r.Use(rateLimitingMiddleware)

    // Other middlewares
    r.Use(loggingMiddleware)
    r.Use(errorHandlingMiddleware)

    r.HandleFunc("/login", login).Methods("POST")
    r.Handle("/books", authenticate(http.HandlerFunc(getBooks))).Methods("GET")
    r.Handle("/books", authenticate(http.HandlerFunc(createBook))).Methods("POST")

    fmt.Println("Server started on port :8000")
    log.Fatal(http.ListenAndServe(":8000", r))
}

Применяя r.Use(rateLimitingMiddleware), мы гарантируем, что каждый входящий запрос проверяется ограничителем скорости, прежде чем он достигнет какой-либо конечной точки.

Шаг 5: Тестирование ограничения скорости?

Запустите сервер:

go run main.go

Теперь давайте обратимся к API с несколькими запросами. Вы можете использовать цикл с Curl для имитации нескольких запросов подряд:

for i in {1..10}; do curl http://localhost:8000/books; done

Поскольку мы установили ограничение на 5 запросов в минуту, вы должны увидеть ответы 429 слишком много запросов, как только вы превысите разрешенную частоту.

Что дальше?

И вот оно — ограничение скорости с помощью golang.org/x/time/rate, чтобы ваш API оставался стабильным и отзывчивым под давлением. Ограничение скорости — важнейший инструмент для любого масштабируемого API, и мы здесь только поверхностно.

Как только ThrottleX будет готов к использованию, я опубликую следующее руководство, чтобы показать вам, как интегрировать его в ваш Go API для еще большей гибкости и распределенного ограничения скорости. Следите за обновлениями в моем репозитории ThrottleX на GitHub!

На следующей неделе мы собираемся контейнеризировать наш API с помощью Docker, чтобы его можно было запускать где угодно. Оставайтесь с нами и удачного кодирования! ??