Golang melaksanakan pengehadan arus IP

Dengan perkembangan pesat Internet dan Internet mudah alih, pelayan menghadapi tekanan yang semakin meningkat Bagaimana untuk mengehadkan permintaan pelanggan kepada pelayan dan mengelakkan ranap pelayan telah menjadi masalah besar. Dalam projek sebenar, kami selalunya perlu mengehadkan bilangan permintaan IP untuk memastikan ketersediaan tapak web.

Di sini, kami akan memperkenalkan cara menggunakan Golang untuk melaksanakan pengehadan arus IP. Secara umum, kami akan menggunakan algoritma baldi token untuk melaksanakan pengehadan semasa berdasarkan alamat IP. Algoritma baldi token ialah algoritma kawalan aliran yang membenarkan bilangan permintaan tertentu untuk lulus dalam tempoh masa tertentu dan mengehadkan aliran permintaan dalam tempoh masa.

Butiran pelaksanaan

Algoritma baldi token meletakkan token ke dalam baldi pada kadar tetap Baldi token mempunyai had kapasiti, yang bermaksud bahawa bilangan token dalam baldi tidak akan melebihi kapasiti. Untuk setiap permintaan, token dikeluarkan daripada baldi Jika tiada token dalam baldi, permintaan itu tidak boleh diteruskan.

Untuk melaksanakan pengehadan semasa berdasarkan alamat IP, kami perlu mencipta baldi token untuk setiap alamat IP Setiap baldi token mempunyai kapasiti maksimum dan kelajuan tetap. Apabila permintaan datang, kami mengalih keluar token daripada baldi token dan menolak permintaan itu jika tiada token dalam baldi.

Berdasarkan ini, kita boleh mentakrifkan pengehad semasa IP:

type IPRateLimiter struct {
    limiterBuckets map[string]*rate.Limiter
    mu             *sync.Mutex
    r              rate.Limit
    b              int
}

di mana limiterBuckets ialah pemetaan yang memetakan alamat IP rentetan kepada baldi token. mu ialah mutex, r ialah kadar di mana pengehad kadar meletakkan token sesaat, dan b ialah kapasiti baldi token.

Untuk mencipta baldi token untuk setiap alamat IP, kami mentakrifkan fungsi NewIPRateLimiter:

func NewIPRateLimiter(r rate.Limit, b int) *IPRateLimiter {
    return &IPRateLimiter{
        limiterBuckets: make(map[string]*rate.Limiter),
        mu:             &sync.Mutex{},
        r:              r,
        b:              b,
    }
}

func (i *IPRateLimiter) AddIP(ip string) *rate.Limiter {
    i.mu.Lock()
    defer i.mu.Unlock()

    limiter := rate.NewLimiter(i.r, i.b)
    i.limiterBuckets[ip] = limiter

    return limiter
}

Fungsi AddIP digunakan untuk mencipta baldi token untuk alamat IP. Jika baldi token dicipta untuk alamat IP ini, baldi token sedia ada dikembalikan, jika tidak baldi token baharu dibuat dan dikembalikan.

Akhir sekali, kami boleh melaksanakan perisian tengah HTTP untuk mengehadkan bilangan permintaan kepada alamat IP:

func (i *IPRateLimiter) Limit(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ip := r.RemoteAddr
        limiter, ok := i.limiterBuckets[ip]
        if !ok {
            limiter = i.AddIP(ip)
        }

        if !limiter.Allow() {
            http.Error(w, http.StatusText(http.StatusTooManyRequests), http.StatusTooManyRequests)
            return
        }

        next.ServeHTTP(w, r)
    })
}

Perisian tengah ini membenarkan permintaan untuk lulus pada kadar dan kapasiti yang ditentukan. Jika bilangan permintaan melebihi kapasiti, kod ralat HTTP 429 (Terlalu Banyak Permintaan) dikembalikan.

Kod lengkap adalah seperti berikut:

package main

import (
    "net/http"
    "strconv"
    "sync"

    "golang.org/x/time/rate"
)

type IPRateLimiter struct {
    limiterBuckets map[string]*rate.Limiter
    mu             *sync.Mutex
    r              rate.Limit
    b              int
}

func NewIPRateLimiter(r rate.Limit, b int) *IPRateLimiter {
    return &IPRateLimiter{
        limiterBuckets: make(map[string]*rate.Limiter),
        mu:             &sync.Mutex{},
        r:              r,
        b:              b,
    }
}

func (i *IPRateLimiter) AddIP(ip string) *rate.Limiter {
    i.mu.Lock()
    defer i.mu.Unlock()

    limiter := rate.NewLimiter(i.r, i.b)
    i.limiterBuckets[ip] = limiter

    return limiter
}

func (i *IPRateLimiter) Limit(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ip := r.RemoteAddr
        limiter, ok := i.limiterBuckets[ip]
        if !ok {
            limiter = i.AddIP(ip)
        }

        if !limiter.Allow() {
            http.Error(w, http.StatusText(http.StatusTooManyRequests), http.StatusTooManyRequests)
            return
        }

        next.ServeHTTP(w, r)
    })
}

func IndexHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("welcome."))
}

func main() {
    limit := rate.Limit(10) // 速率，每秒放入令牌的数量
    capacity := 100        // 容量，桶的大小

    ipRateLimiter := NewIPRateLimiter(limit, capacity)

    http.Handle("/", ipRateLimiter.Limit(http.HandlerFunc(IndexHandler)))

    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        panic(err)
    }
}

Dalam contoh ini, kami membenarkan 10 token sesaat dan mengehadkan kapasiti baldi kepada 100. Ini bermakna bahawa pengehad boleh mengendalikan sehingga 10 permintaan sesaat, tetapi akan gagal jika permintaan ke alamat IP yang sama mencapai 100. Pada masa yang sama, kami menentukan pengendali mudah yang akan bertindak balas kepada "Selamat Datang".

Kesimpulan

Dalam artikel ini, kami menggunakan Golang untuk melaksanakan pengehadan semasa IP dan menggunakan algoritma baldi token untuk mengehadkan kadar permintaan setiap alamat IP. Kaedah ini boleh melaksanakan mekanisme pengehad semasa yang mudah dan berkesan, dan boleh dilaksanakan dengan mudah di Golang. Ini boleh menjadi teknik yang sangat berguna apabila anda menulis aplikasi rangkaian yang sangat serentak.

Atas ialah kandungan terperinci Golang melaksanakan pengehadan arus IP. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!