golang接口IP限流,IP黑名單,IP白名單的實例
增加中間件
可以選擇普通模式和LUA腳本模式，建議選擇普通模式，實際上不需要控制的那麼精確。
package Middlewares
import (
"github.com/gin-gonic/gin"
"strconv"
"time"
"voteapi/pkg/app/response"
"voteapi/pkg/gredis"
"voteapi/pkg/util"
)
const IP_LIMIT_NUM_KEY = "ipLimit:ipLimitNum"
const IP_BLACK_LIST_KEY = "ipLimit:ipBlackList"
var prefix = "{gateway}"
var delaySeconds int64 = 60 // 觀察時間跨度，秒
var maxAttempts int64 = 10000 // 限制請求數
var blackSeconds int64 = 0 // 封禁時長，秒，0-不封禁
func GateWayPlus() gin.HandlerFunc {
return func(c *gin.Context) {
path := c.FullPath()
clientIp := c.ClientIP()
// redis配置集群時必須
param := make(map[string]string)
param["path"] = path
param["clientIp"] = clientIp
if !main(param) {
c.Abort()
response.JsonResponseError(c, "當前IP請求過於頻繁，暫時被封禁~")
}
}
}
func main(param map[string]string) bool {
// 預知的IP黑名單
var blackList []string
if util.InStringArray(param["clientIp"], blackList) {
return false
}
// 預知的IP白名單
var whiteList []string
if util.InStringArray(param["clientIp"], whiteList) {
return false
}
blackKey := prefix + ":" + IP_BLACK_LIST_KEY
limitKey := prefix + ":" + IP_LIMIT_NUM_KEY
curr := time.Now().Unix()
item := util.Md5(param["path"] + "|" + param["clientIp"])
return normal(blackKey, limitKey, item, curr)
}
// 普通模式
func normal(blackKey string, limitKey string, item string, time int64) (res bool) {
if blackSeconds > 0 {
timeout, _ := gredis.RawCommand("HGET", blackKey, item)
if timeout != nil {
to, _ := strconv.Atoi(string(timeout.([]uint8)))
if int64(to) > time {
// 未解封
return false
}
// 已解封，移除黑名單
gredis.RawCommand("HDEL", blackKey, item)
}
}
l, _ := gredis.RawCommand("HGET", limitKey, item)
if l != nil {
last, _ := strconv.Atoi(string(l.([]uint8)))
if int64(last) >= maxAttempts {
return false
}
}
num, _ := gredis.RawCommand("HINCRBY", limitKey, item, 1)
if ttl, _ := gredis.TTLKey(limitKey); ttl == int64(-1) {
gredis.Expire(limitKey, int64(delaySeconds))
}
if num.(int64) >= maxAttempts && blackSeconds > 0 {
// 加入黑名單
gredis.RawCommand("HSET", blackKey, item, time+blackSeconds)
// 刪除記錄
gredis.RawCommand("HDEL", limitKey, item)
}
return true
}
// LUA腳本模式
// 支持redis集群部署
func luaScript(blackKey string, limitKey string, item string, time int64) (res bool) {
script := `
local blackSeconds = tonumber(ARGV[5])
if(blackSeconds > 0)
then
local timeout = redis.call('hget', KEYS[1], ARGV[1])
if(timeout ~= false)
then
if(tonumber(timeout) > tonumber(ARGV[2]))
then
return false
end
redis.call('hdel', KEYS[1], ARGV[1])
end
end
local last = redis.call('hget', KEYS[2], ARGV[1])
if(last ~= false and tonumber(last) >= tonumber(ARGV[3]))
then
return false
end
local num = redis.call('hincrby', KEYS[2], ARGV[1], 1)
local ttl = redis.call('ttl', KEYS[2])
if(ttl == -1)
then
redis.call('expire', KEYS[2], ARGV[4])
end
if(tonumber(num) >= tonumber(ARGV[3]) and blackSeconds > 0)
then
redis.call('hset', KEYS[1], ARGV[1], ARGV[2] + ARGV[5])
redis.call('hdel', KEYS[2], ARGV[1])
end
return true
`
result, err := gredis.RawCommand("EVAL", script, 2, blackKey, limitKey, item, time, maxAttempts, delaySeconds, blackSeconds)
if err != nil {
return false
}
if result == int64(1) {
return true
} else {
return false
}
}
補充：golang實現限制每秒多少次的限頻操作
前言
一些函數的執行可能會限制頻率，比如某個api接口要求每秒最大請求30次。下面記錄瞭自己寫的限頻和官方的限頻
代碼
// 加鎖限頻，輸出次數大概率小於最大值
func ExecLimit(lastExecTime *time.Time, l *sync.RWMutex ,maxTimes int, perDuration time.Duration, f func()) {
l.Lock()
defer l.Unlock()
// per times cost time(s)
SecondsPerTimes := float64(perDuration) / float64(time.Second) / float64(maxTimes)
now := time.Now()
interval := now.Sub(*lastExecTime).Seconds()
if interval < SecondsPerTimes {
time.Sleep(time.Duration(int64((SecondsPerTimes-interval)*1000000000)) * time.Nanosecond)
}
f()
*lastExecTime = time.Now()
}
// 官方的，需要引用 "golang.org/x/time/rate"
// 基本上可以達到滿值，比自己寫的更優
func ExecLimit2(l *rate.Limiter, f func()) {
go func() {
l.Wait(context.Background())
f()
}()
}
使用
func TestExecLimit(t *testing.T) {
runtime.GOMAXPROCS(runtime.NumCPU())
go func() {
var lastExecTime time.Time
var l sync.RWMutex
for {
ExecLimit(&lastExecTime, &l, 10, time.Second, func() {
fmt.Println("do")
})
}
}()
select {
case <-time.After(1 * time.Second):
fmt.Println("1秒到時")
}
}
func TestExecLimit2(t *testing.T) {
runtime.GOMAXPROCS(runtime.NumCPU())
l := rate.NewLimiter(1, 30)
go func() {
for {
ExecLimit2(l, func() {
fmt.Println("do")
})
}
}()
select {
case <-time.After(1 * time.Second):
fmt.Println("1秒到時")
}
}
輸出：
一秒內輸出瞭<=10次 “do”
如何在多節點服務中限制頻
上述使用，定義在某個服務節點的全局變量lastExecTime僅僅會對該服務的函數f()操作限頻，如果在負載均衡後，多個相同服務的節點，對第三方的接口累計限頻，比如三個服務共同拉取第三方接口，合計限頻為30次/s.
則，必須將lastExecTime的獲取，從redis等共享中間件中獲取，而不應該從任何一個單點服務獲取。
以上為個人經驗，希望能給大傢一個參考，也希望大傢多多支持WalkonNet。如有錯誤或未考慮完全的地方，望不吝賜教。