Shulou(Shulou.com)06/02 Report--

This article will explain in detail how to achieve the user daily quota on Go. The editor thinks it is very practical, so I share it with you as a reference. I hope you can get something after reading this article.

If you write a bug management system, with this PeriodLimit, you can limit each tester to only one bug per day. Isn't it a lot easier to work? : P

Nowadays, the essential reason for the popularity of micro-service architecture is that it is necessary to reduce the overall complexity of the system and share the system risk among subsystems to maximize the stability of the system. after dividing the domain into different subsystems, each subsystem can be developed, tested and released independently, and the R & D rhythm and efficiency can be significantly improved.

But at the same time, it also brings problems, such as: the call link is too long, the complexity of deployment architecture is increased, and various middleware need to support distributed scenarios. In order to ensure the normal operation of micro-services, service governance is indispensable, which usually includes: current limiting, degradation, and circuit breakers.

Current limit means to limit the frequency of API calls so as not to drag down the system if the load limit is exceeded. For example:

E-commerce second kill scene

API restricts current for different merchants

The commonly used current limiting algorithms are:

Fixed time window current limit

Sliding time window current limit

Leaky bucket current limit

Token bucket current limit

This paper mainly explains the fixed-time window current-limiting algorithm, the main use scenarios such as:

Each mobile phone number can only send 5 CAPTCHA text messages per day.

Each user can only try the password three times in a row per hour.

Each member can only receive benefits three times a day.

working principle

From a certain point in time, the number of requests per request is + 1, and it is judged whether the number of requests in the current time window exceeds the limit, if it exceeds the limit, the request is rejected, and then the counter is cleared to wait for the request at the beginning of the next time window.

Advantages and disadvantages

Advantages

The implementation is simple and efficient, and is especially suitable for limiting scenarios such as a user can only send 10 articles a day, can only send 5 SMS verification codes, and can only try to log in 5 times. Such scenarios are very common in actual business.

Shortcoming

The disadvantage of fixed time window current limitation is that it can not handle the critical area request burst scenario.

Assuming a limit of 100 requests per second, the user initiates 200 requests within 1 s when the intermediate 500ms starts. At this time, all 200 requests can be passed. This is inconsistent with our expectation that the current limit is 100 times per second, and the root cause is that the fine grain of the current limit is too coarse.

Go-zero code implementation

Core/limit/periodlimit.go

Redis expiration time is used in go-zero to simulate a fixed time window.

Redis lua script:

-- KYES [1]: current limiter key-- ARGV [1]: qos, maximum number of requests per unit time-- ARGV [2]: unit limit window time-maximum number of requests, equal to p.quotalocal limit = tonumber (ARGV [1])-- window is a unit current limit period. Here, expiration is used to simulate the window effect, which is equal to p.permitlocal window = tonumber (ARGV [2])-- number of requests + 1. Get the total number of requests local current = redis.call ("INCRBY", KYES [1], 1)-if it is the first request, set the expiration time and return successful if current = = 1 then redis.call ("expire", KYES [1], window) return 1 elseif current-if the number of current requests is less than limit, return successful elseif current

Limit returns failed else return 0end

Definition of current limiter with fixed time window

Type (/ / PeriodOption defines the method to customize a PeriodLimit. / / the common option parameter mode in go / / if there are many parameters, it is recommended to use this mode to set the parameter PeriodOption func (l * PeriodLimit) / / A PeriodLimit is used to limit requests during a period of time. / / fixed time window current limiter PeriodLimit struct {/ / window size, unit s period int / / request upper limit quota int / / Storage limitStore * redis.Redis / / key prefix keyPrefix string / / Linear current limit. When this option is enabled, periodic current limit / / such as quota=5 can be achieved. The actual value of quota may be 5.4.3.2.1 showing a periodic change align bool})

Pay attention to the align parameter. The request limit will change periodically during align=true.

For example, in quota=5, the actual quota may be 5.4.3.2.1 showing periodic changes.

Current limiting logic

In fact, the current limiting logic is implemented in the above lua script, and it is important to note that the return value is returned.

0: indicates an error, such as possible redis failure or overload

1: allow

2: allowed, but the upper limit has been reached in the current window. If you are running batch business, you can hibernate sleep for a while and wait for the next window (the author considers it very carefully)

3: refuse

/ / Take requests a permit, it returns the permit state.// performs current limit / / Note the returned value: / / 0: indicates an error For example, it may be redis failure, overload / 1: allow / / 2: allow but the upper limit has been reached in the current window / / 3: deny func (h * PeriodLimit) Take (key string) (int, error) {/ / execute lua script resp, err: = h.limitStore.Eval (periodScript, [] string {h.keyPrefix + key}, [] string {strconv.Itoa (h.quota), strconv.Itoa (h.calcExpireSeconds ()) }) if err! = nil {return Unknown, err} code, ok: = resp. (int64) if! ok {return Unknown, ErrUnknownCode} switch code {case internalOverQuota: return OverQuota, nil case internalAllowed: return Allowed, nil case internalHitQuota: return HitQuota, nil default: return Unknown, ErrUnknownCode}}

This fixed window limit may be used to limit, for example, a user can only send CAPTCHA text messages five times a day, in which case we need to correspond to China time zone (GMT+8). In fact, the current limit time should start from zero, and we need additional alignment (set align to true).

/ / calculate the expiration time, that is, the window time / / if align==true// linear current limit is enabled, periodic current limit / / such as quota=5 can be achieved when this option is enabled. The actual value of quota may be 5.4.3.2.1 showing periodic changes func (h * PeriodLimit) calcExpireSeconds () int {if h.align {now: = time.Now () _, offset: = now.Zone () unix: = now.Unix () + int64 (offset) return h.period-int (unix%int64 (h.period))} return h.period} this is the end of the article on "how Go implements the user's daily quota". Hope that the above content can be helpful to you, so that you can learn more knowledge, if you think the article is good, please share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.