在 Cloud Run 中如何对 Golang 服务器进行请求速率控制？

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《在 Cloud Run 中如何对 Golang 服务器进行请求速率控制？》，文章讲解的知识点主要包括，如果你对Golang方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

由于云运行是“无状态”的，我假设状态在请求之间不会持续存在，因此创建 IP 地址映射将不起作用。或者像限制器这样的东西会起作用吗？

解决方案

请求由请求范围内的请求处理程序处理，而您的限制器具有全局范围。

让我用一些代码来说明这一点。我们有请求范围的变量 i 和 全局变量 j。此外，我们还有一个全局限制器。

因此，限制器和 j 仅有一个实例，但对于到达请求，会创建一个名为 i 的变量，该变量对于该请求是不同的。

package main

import (
    "flag"
    "fmt"
    "log"
    "net/http"
    "sync/atomic"
    "time"

    "github.com/ulule/limiter/v3"
    "github.com/ulule/limiter/v3/drivers/middleware/stdlib"
    "github.com/ulule/limiter/v3/drivers/store/memory"
)

var bind string

func init() {
    // make the bind address configurable
    flag.stringvar(&bind, "bind", ":9090", "address to bind to")
}

func main() {
    flag.parse()

    // the rate you want to employ
    // we use unusual values here for testing purposes
    rate := limiter.rate{
        period: 5 * time.second,
        limit:  1,
    }

    // we use an in-memory store for the sake of simplicity.
    // furthermore, as a security measure, persistence might introduce
    // an unneccessary complexity as well as a point of attack itself
    // by overloading the persistence mechanism.
    l := limiter.new(memory.newstore(), rate)

    middleware := stdlib.newmiddleware(l)

    // for further clarification, we add a globally scoped counter
    var j uint64

    // we tell the http server to take requests to /hello...
    http.handle("/hello",
        // put them through or globally scoped middleware
        // which will enfore the rate limit and...
        middleware.handler(

            // executes the actual http.handler if the limit is not reached.
            http.handlerfunc(func(w http.responsewriter, r *http.request) {

                // request scoped...
                var i int
                // so i will always be 1 after increment
                i++

                // but we also increment our globally scoped j.
                // since multiple goroutines might access j simultaneously, we need
                // to take the precaution of an atomic operation.
                atomic.adduint64(&j, 1)

                w.write([]byte(
                    fmt.sprintf("hello, world!\nrequest scoped i: %d, global scoped j:%d\n", i, atomic.loaduint64(&j))))
            })))

    // last but not least we start the server
    log.printf("starting server bound to '%s'", bind)
    log.fatal(http.listenandserve(bind, nil))
}

现在，当我们运行此代码并使用 curl 调用 url 时，我们会收到响应（限制未生效），并且 i 和 j 的值均为 1。

$ curl -iv --no-keepalive http://localhost:9090/hello
*   trying ::1:9090...
* connected to localhost (::1) port 9090 (#0)
> get /hello http/1.1
> host: localhost:9090
> user-agent: curl/7.69.1
> accept: */*
> 
* mark bundle as not supporting multiuse
< http/1.1 200 ok
http/1.1 200 ok
< x-ratelimit-limit: 1
x-ratelimit-limit: 1
< x-ratelimit-remaining: 0
x-ratelimit-remaining: 0
< x-ratelimit-reset: 1588596822
x-ratelimit-reset: 1588596822
< date: mon, 04 may 2020 12:53:37 gmt
date: mon, 04 may 2020 12:53:37 gmt
< content-length: 53
content-length: 53
< content-type: text/plain; charset=utf-8
content-type: text/plain; charset=utf-8

< 
hello, world!
request scoped i: 1, global scoped j:1
* connection #0 to host localhost left intact

如果我们在 5 秒内再次调用该 url，速率限制器就会启动，并拒绝我们访问：

$ curl -iv --no-keepalive http://localhost:9090/hello
*   trying ::1:9090...
* connected to localhost (::1) port 9090 (#0)
> get /hello http/1.1
> host: localhost:9090
> user-agent: curl/7.69.1
> accept: */*
> 
* mark bundle as not supporting multiuse
< http/1.1 429 too many requests
http/1.1 429 too many requests
< content-type: text/plain; charset=utf-8
content-type: text/plain; charset=utf-8
< x-content-type-options: nosniff
x-content-type-options: nosniff
< x-ratelimit-limit: 1
x-ratelimit-limit: 1
< x-ratelimit-remaining: 0
x-ratelimit-remaining: 0
< x-ratelimit-reset: 1588596822
x-ratelimit-reset: 1588596822
< date: mon, 04 may 2020 12:53:38 gmt
date: mon, 04 may 2020 12:53:38 gmt
< content-length: 15
content-length: 15

< 
limit exceeded
* connection #0 to host localhost left intact

并且，等待几秒钟后，我们再次调用该 url，全局作用域变量递增，而请求作用域变量再次为 1：

$ curl -iv --no-keepalive http://localhost:9090/hello
*   Trying ::1:9090...
* Connected to localhost (::1) port 9090 (#0)
> GET /hello HTTP/1.1
> Host: localhost:9090
> User-Agent: curl/7.69.1
> Accept: */*
> 
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
HTTP/1.1 200 OK
< X-Ratelimit-Limit: 1
X-Ratelimit-Limit: 1
< X-Ratelimit-Remaining: 0
X-Ratelimit-Remaining: 0
< X-Ratelimit-Reset: 1588596884
X-Ratelimit-Reset: 1588596884
< Date: Mon, 04 May 2020 12:54:39 GMT
Date: Mon, 04 May 2020 12:54:39 GMT
< Content-Length: 53
Content-Length: 53
< Content-Type: text/plain; charset=utf-8
Content-Type: text/plain; charset=utf-8

< 
Hello, world!
request scoped i: 1, global scoped j:2
* Connection #0 to host localhost left intac

理论要掌握，实操不能落！以上关于《在 Cloud Run 中如何对 Golang 服务器进行请求速率控制？》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！