Kadar Mengehadkan API Golang menggunakan Redis

Untuk meletakkan Penghadan Kadar dalam perkataan yang lebih mudah, ini ialah teknik di mana kami mengehadkan bilangan permintaan yang boleh dibuat oleh pengguna atau pelanggan kepada API dalam tempoh masa tertentu. Anda mungkin pernah temui pada masa lalu mendapat mesej "melebihi had kadar" apabila anda cuba mengakses API cuaca atau jenaka. Terdapat banyak hujah tentang sebab untuk menilai had API, tetapi beberapa yang penting ialah menggunakan API itu secara adil, menjadikannya selamat, melindungi sumber daripada beban berlebihan, dsb.

Dalam blog ini, kami akan mencipta pelayan HTTP dengan Golang menggunakan rangka kerja Gin menggunakan fungsi had kadar pada titik akhir menggunakan Redis dan menyimpan jumlah kiraan permintaan yang dibuat oleh IP yang dibuat kepada pelayan dalam jangka masa. Dan jika melebihi had, kami tetapkan, kami akan memberikan mesej ralat.

Sekiranya anda tidak tahu apa itu Gin dan Redis. Gin ialah rangka kerja web yang ditulis dalam Golang. Ia membantu untuk mencipta pelayan yang mudah dan pantas tanpa menulis banyak kod. Redis ialah stor data dalam memori dan nilai kunci yang boleh digunakan sebagai pangkalan data atau untuk keupayaan caching.

Prasyarat

• Kebiasaan dengan Golang, Gin dan Redis
• Instance Redis (Kami boleh menggunakan Docker atau mesin jauh)

Sekarang, mari kita mulakan.

Untuk Memulakan projek jalankan go mod init contohnya, pergi mod init github.com/Pradumnasaraf/go-redis.

Kemudian mari kita buat pelayan HTTP mudah dengan Rangka Kerja Gin kemudian kita gunakan logik untuk mengehadkan kadarnya. Anda boleh menyalin kod di bawah. Ia sangat asas. Pelayan akan membalas dengan mesej apabila kami menekan titik akhir /message.

Selepas anda menyalin kod di bawah, jalankan go mod tidy untuk memasang pakej yang telah kami import secara automatik.

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    r.GET("/message", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "You can make more requests",
        })
    })
    r.Run(":8081") //listen and serve on localhost:8081
} 

Kita boleh menjalankan pelayan dengan melaksanakan go run main.go dalam terminal dan lihat mesej ini dalam terminal.

Untuk mengujinya, kita boleh pergi ke localhost:8081/message kita akan melihat mesej ini dalam penyemak imbas.

Sekarang pelayan kami sedang berjalan, mari sediakan fungsi had kadar untuk laluan /mesej. Kami akan menggunakan pakej go-redis/redis_rate. Terima kasih kepada pencipta pakej ini, kami tidak perlu menulis logik untuk mengendalikan dan menyemak had dari awal. Ia akan melakukan semua beban berat untuk kita.

Di bawah ialah kod lengkap selepas melaksanakan fungsi mengehadkan kadar. Kami akan memahami setiap bahagiannya. Hanya berikan kod lengkap awal untuk mengelakkan sebarang kekeliruan dan untuk memahami cara bahagian yang berbeza berfungsi bersama.

Sebaik sahaja anda menyalin kod jalankan go mod tidy untuk memasang semua pakej yang diimport. Sekarang mari kita melompat dan memahami kod (Di bawah coretan kod).

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    r.GET("/message", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "You can make more requests",
        })
    })
    r.Run(":8081") //listen and serve on localhost:8081
} 

Mula-mula kita terus melompat ke fungsi rateLimiter() dan memahaminya. Fungsi ini meminta hujah iaitu alamat IP permintaan yang boleh kami perolehi melalui c.ClientIP() dalam fungsi utama. Dan kami mengembalikan ralat jika ada had yang dipukul sebaliknya kekalkan tiada. Kebanyakan kod adalah kod boilerplate yang kami ambil daripada repo rasmi GitHub. Fungsi utama untuk melihat lebih dekat di sini ialah fungsi limiter.Allow(). Addr: mengambil nilai laluan URL untuk contoh Redis. Saya menggunakan Docker untuk menjalankannya secara tempatan. Anda boleh menggunakan apa sahaja, cuma pastikan anda menggantikan URL dengan sewajarnya.

package main

import (
    "context"
    "errors"
    "net/http"

    "github.com/gin-gonic/gin"
    "github.com/go-redis/redis_rate/v10"
    "github.com/redis/go-redis/v9"
)

func main() {
    r := gin.Default()
    r.GET("/message", func(c *gin.Context) {
        err := rateLimiter(c.ClientIP())
        if err != nil {
            c.JSON(http.StatusTooManyRequests, gin.H{
                "message": "you have hit the limit",
            })
            return
        }
        c.JSON(http.StatusOK, gin.H{
            "message": "You can make more requests",
        })
    })
    r.Run(":8081")
}

func rateLimiter(clientIP string) error {
    ctx := context.Background()
    rdb := redis.NewClient(&redis.Options{
        Addr: "localhost:6379",
    })

    limiter := redis_rate.NewLimiter(rdb)
    res, err := limiter.Allow(ctx, clientIP, redis_rate.PerMinute(10))
    if err != nil {
        panic(err)
    }
    if res.Remaining == 0 {
        return errors.New("Rate")
    }

    return nil
}

Memerlukan tiga argumen, yang pertama ialah ctx, yang kedua ialah Kunci, Kunci (kunci untuk nilai) untuk Pangkalan Data Redis dan yang ketiga ialah had. Jadi, fungsi menyimpan alamat clientIP sebagai kunci dan had lalai sebagai nilai dan mengurangkannya apabila permintaan dibuat. Sebab untuk struktur ini ialah pangkalan data Redis memerlukan pengenalan unik dan kunci unik untuk menyimpan jenis data pasangan nilai kunci, dan setiap alamat IP adalah unik dengan caranya sendiri, itulah sebabnya kami menggunakan alamat IP dan bukannya nama pengguna, dsb. Argumen ke-3 redis_rate.PerMinute(10) boleh diubah suai mengikut keperluan kita, kita boleh menetapkan had PerSecond, PerHour, dsb, dan tetapkan nilai dalam kurungan untuk berapa banyak permintaan boleh dibuat seminit/saat/jam. Dalam kes kami, ia 10 seminit. Ya, semudah itu untuk ditetapkan.

Akhir sekali, kami sedang menyemak sama ada terdapat baki kuota bukan dengan res.Baki. Jika sifar kami akan mengembalikan ralat dengan mesej jika tidak kami akan mengembalikan sifar. Contohnya, anda juga boleh melakukan res.Limit.Rate untuk menyemak kadar had, dsb. Anda boleh bermain-main dan mendalaminya.

Sekarang akan datang fungsi utama():

res, err := limiter.Allow(ctx, clientIP, redis_rate.PerMinute(10))

Semuanya hampir sama. Dalam laluan /mesej, kini setiap kali laluan terkena, kami memanggil fungsi rateLimit() dan memberikannya alamat ClientIP dan menyimpan nilai pulangan (ralat) dalam pembolehubah ralat. Jika terdapat ralat kami akan mengembalikan 429, iaitu, http.StatusTooManyRequests, dan mesej "message": "Anda telah mencapai had". Jika orang itu mempunyai baki had dan rateLimit() tidak mengembalikan ralat, ia akan berfungsi seperti biasa, seperti yang dilakukan sebelum ini dan menyampaikan permintaan.

Itu sahaja penjelasannya. Sekarang mari kita uji kerja. Jalankan semula pelayan dengan melaksanakan arahan yang sama. Buat pertama kali, kita akan melihat mesej yang sama yang kita dapat sebelum ini. Sekarang muat semula penyemak imbas anda 10 kali (Seperti yang kami tetapkan had 10 seminit), dan anda akan melihat mesej ralat dalam penyemak imbas.

Kami juga boleh mengesahkan ini dengan melihat log dalam terminal. Gin menawarkan log keluar yang hebat dari kotak. Selepas seminit ia akan memulihkan kuota had kami.

Sudah sampai ke penghujung blog ini, saya harap anda seronok membaca sebagaimana saya seronok menulis ini. Saya gembira anda berjaya sehingga akhir—terima kasih banyak atas sokongan anda. Saya juga kerap bercakap tentang Golang dan perkara lain seperti Open Source dan Docker on X (Twitter). Anda boleh sambung saya di sana.

Atas ialah kandungan terperinci Kadar Mengehadkan API Golang menggunakan Redis. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!