Menambahkan Pengehadan Kadar API pada API Go Anda

Baiklah, orang ramai, kami telah membincangkan banyak perkara setakat ini: pengesahan JWT, sambungan pangkalan data, pengelogan dan pengendalian ralat. Tetapi apa yang berlaku apabila API anda mula diselar dengan permintaan? Tanpa kawalan, trafik yang tinggi boleh menyebabkan masa tindak balas yang perlahan atau bahkan masa henti. ?

Minggu ini, kami akan menyelesaikannya dengan melaksanakan penghadan kadar untuk mengawal aliran trafik. Kami akan menggunakan pakej golang.org/x/time/rate yang mudah dan berkesan. Kemudian, apabila penyelesaian ThrottleX saya sendiri sudah sedia, saya akan menunjukkan kepada anda cara untuk menyepadukannya sebagai pilihan yang lebih berskala. (Psst, lihat GitHub saya di github.com/neelp03/throttlex untuk kemas kini! Jangan ragu untuk mengulas sebarang isu yang anda lihat di sana o7)

Mengapa Mengehadkan Kadar? ?

Penghadan kadar adalah seperti bouncer untuk API anda—ia mengawal bilangan permintaan yang boleh dibuat pengguna dalam tempoh masa tertentu. Ini menghalang API anda daripada terharu, memastikan akses yang lancar dan adil untuk semua pengguna. Pengehadan kadar adalah penting untuk:

• Mencegah Penyalahgunaan: Menghentikan pelakon jahat atau pengguna yang terlalu bersemangat daripada mengatasi API anda.
• Kestabilan: Memastikan API anda responsif dan boleh dipercayai, walaupun semasa trafik meningkat.
• Kesaksamaan: Membenarkan sumber dikongsi sama rata antara pengguna.

Langkah 1: Memasang Pakej masa/kadar

Pakej golang.org/x/time/rate ialah sebahagian daripada perpustakaan Go lanjutan dan menyediakan pengehad kadar berasaskan token yang mudah. Untuk bermula, anda perlu memasangnya:

go get golang.org/x/time/rate

Langkah 2: Sediakan Pengehad Kadar

Mari kita cipta perisian tengah yang mengehadkan kadar yang mengawal bilangan permintaan yang boleh dibuat oleh pelanggan. Dalam contoh ini, kami akan mengehadkan pelanggan kepada 5 permintaan seminit.

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
}

Langkah 3: Mencipta Perisian Tengah Mengehadkan Kadar

Sekarang, mari gunakan fungsi getClientLimiter dalam perisian tengah yang akan menyekat akses berdasarkan had kadar.

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)
    })
}

Cara Ia Berfungsi:

1. Penghadan Berasaskan IP: Setiap pelanggan dikenal pasti melalui alamat IP mereka. Kami menyemak IP pelanggan dan menetapkan pengehad kadar padanya.
2. Semak Permintaan: Kaedah limiter.Allow() menyemak sama ada pelanggan berada dalam had kadar. Jika ya, permintaan diteruskan kepada pengendali seterusnya; jika tidak, kami membalas dengan 429 Permintaan Terlalu Banyak.

Langkah 4: Menggunakan Middleware Secara Global ?

Sekarang mari sambungkan pengehad kadar kami kepada API supaya setiap permintaan perlu melaluinya:

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))
}

Dengan menggunakan r.Use(rateLimitingMiddleware), kami memastikan setiap permintaan yang masuk disemak oleh pengehad kadar sebelum ia mencapai sebarang titik akhir.

Langkah 5: Menguji Pengehadan Kadar ?

Mulakan pelayan anda:

go run main.go

Sekarang, mari tekan API dengan beberapa permintaan. Anda boleh menggunakan gelung dengan curl untuk mensimulasikan berbilang permintaan berturut-turut:

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

Memandangkan kami menetapkan had kepada 5 permintaan seminit, anda seharusnya melihat 429 Permintaan Terlalu Banyak jawapan sebaik sahaja anda melebihi kadar yang dibenarkan.

Apa Seterusnya?

Dan begitulah—menghadkan kadar dengan golang.org/x/time/rate untuk memastikan API anda stabil dan responsif di bawah tekanan. Pengehadan kadar ialah alat penting untuk mana-mana API boleh skala, dan kami hanya menconteng permukaan di sini.

Setelah ThrottleX sedia untuk pengeluaran, saya akan menyiarkan tutorial susulan untuk menunjukkan kepada anda cara menyepadukannya ke dalam API Go anda untuk lebih fleksibiliti dan pengehadan kadar teragih. Pantau repo ThrottleX GitHub saya untuk mendapatkan kemas kini!

Minggu depan, kami akan memasukkan API kami dengan Docker, jadi ia sedia untuk dijalankan di mana-mana sahaja. Nantikan, dan selamat mengekod! ??

Atas ialah kandungan terperinci Menambahkan Pengehadan Kadar API pada API Go Anda. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!