Envoy、gRPC和速率限制

ServiceMesher2018-11-24 21:37:10

作者:Venil Noronha 譯者:王全根 校對:楊傳勝、王凱 原文:https://venilnoronha.io/envoy-grpc-and-rate-limiting

Envoy是專為Cloud Native應用設計的輕量級服務代理,也是為數不多的支持gRPC的代理之一。gRPC是一個基於HTTP/2的高性能RPC(遠程過程調用)框架,支持多種語言。

在這篇文章中,我們將使用gRPC和Protocol Buffers構建C++語言版本的Greeter應用,使用Go語言構建另一個gRPC應用,實現Envoy的RateLimitService接口。最後,將Envoy部署為Greeter應用的代理,使用我們的實現反壓機制(backpressure)。

gRPC Greeter應用

我們首先安裝gRPC和Protobuf,然後構建C++語言版本的Greeter應用。您還可以通過選擇文檔中列出的其他語言來構建此應用程序; 但是,我將在本文中使用C++。

以下是Greeter應用的示意圖。

運行Greeter應用時,終端中會有以下輸出:

  1. $ ./greeter_server

  2. Server listening on 0.0.0.0:50051

  1. $ ./greeter_client

  2. Greeter received: Hello world

升級gRPC Greeter應用

現在,我們通過使用帶有請求計數前綴的返回值替代靜態的“Hello”前綴,來增強Greeter應用。只需更新 greeter_server.cc文件,如下所示。

  1. // Logic and data behind the server's behavior.

  2. class GreeterServiceImpl final : public Greeter::Service {

  3. +  int counter = 0;

  4.   Status SayHello(ServerContext* context, const HelloRequest* request,

  5.                   HelloReply* reply) override {

  6. -    std::string prefix("Hello ");

  7. +    std::string prefix(std::to_string(++counter) + " ");

  8.     reply->set_message(prefix + request->name());

  9.     return Status::OK;

  10.   }

然後重新構建和運行 greeter_server,通過 greeter_client發送請求時你就能看到如下輸出。

  1. $ for i in {1..3}; do ./greeter_client; sleep 1; done

  2. Greeter received: 1 world

  3. Greeter received: 2 world

  4. Greeter received: 3 world

簡單速率限制服務

接下來,我們通過擴展Envoy的RateLimitService原型接口,用Go語言實現一個簡單的速率限制服務。為此,我們創建一個名為 rate-limit-service的Go項目,並引入Envoy的go-control-plane和其它相關依賴。 go-control-plane項目為Envoy原型提供了Go語言綁定。為了後續實現速率限制服務,我們還需創建 cmd/server/main.gocmd/client/main.go兩個文件。

  1. $ mkdir -p $GOPATH/src/github.com/venilnoronha/rate-limit-service/

  2. $ cd $GOPATH/src/github.com/venilnoronha/rate-limit-service/

  3. $ mkdir -p cmd/server/ && touch cmd/server/main.go

  4. $ mkdir cmd/client/ && touch cmd/client/main.go

引入了所有依賴之後,你將獲得一個如下所示的項目結構。注意我只突出列出了這個實驗相關的包。

  1. ── rate-limit-service

  2.   ├── cmd

  3.     ├── client

  4.       └── main.go

  5.     └── server

  6.         └── main.go

  7.   └── vendor

  8.       ├── github.com

  9.         ├── envoyproxy

  10.           ├── data-plane-api

  11.           └── go-control-plane

  12.         ├── gogo

  13.           ├── googleapis

  14.           └── protobuf

  15.         └── lyft

  16.             └── protoc-gen-validate

  17.       └── google.golang.org

  18.           ├── genproto

  19.           └── grpc

速率限制

現在,我們創建一個簡單的gRPC速率限制服務,來限制每秒的請求數(譯者注:例子實現是交替限制請求)。

  1. package main

  2. import (

  3.    "log"

  4.    "net"

  5.    "golang.org/x/net/context"

  6.    "google.golang.org/grpc"

  7.    "google.golang.org/grpc/reflection"

  8.    rls "github.com/envoyproxy/go-control-plane/envoy/service/ratelimit/v2"

  9. )

  10. // server is used to implement rls.RateLimitService

  11. type server struct{

  12.    // limit specifies if the next request is to be rate limited

  13.    limit bool

  14. }

  15. func (s *server) ShouldRateLimit(ctx context.Context,

  16.        request *rls.RateLimitRequest) (*rls.RateLimitResponse, error) {

  17.    log.Printf("request: %v\n", request)

  18.    // logic to rate limit every second request

  19.    var overallCode rls.RateLimitResponse_Code

  20.    if s.limit {

  21.        overallCode = rls.RateLimitResponse_OVER_LIMIT

  22.        s.limit = false

  23.    } else {

  24.        overallCode = rls.RateLimitResponse_OK

  25.        s.limit = true

  26.    }

  27.    response := &rls.RateLimitResponse{OverallCode: overallCode}

  28.    log.Printf("response: %v\n", response)

  29.        return response, nil

  30. }

  31. func main() {

  32.    // create a TCP listener on port 50052

  33.        lis, err := net.Listen("tcp", ":50052")

  34.        if err != nil {

  35.                log.Fatalf("failed to listen: %v", err)

  36.        }

  37.    log.Printf("listening on %s", lis.Addr())

  38.    // create a gRPC server and register the RateLimitService server

  39.        s := grpc.NewServer()

  40.    rls.RegisterRateLimitServiceServer(s, &server{limit: false})

  41.        reflection.Register(s)

  42.        if err := s.Serve(lis); err != nil {

  43.                log.Fatalf("failed to serve: %v", err)

  44.        }

  45. }

啟動 RateLimitService服務之後,終端輸出如下。

  1. $ go run cmd/server/main.go

  2. 2018/10/27 00:35:28 listening on [::]:50052

速率限制

我們同樣創建一個 RateLimitService的客戶端來驗證服務端的行為。

  1. package main

  2. import (

  3.        "log"

  4.    "time"

  5.        "golang.org/x/net/context"

  6.        "google.golang.org/grpc"

  7.    rls "github.com/envoyproxy/go-control-plane/envoy/service/ratelimit/v2"

  8. )

  9. func main() {

  10.        // Set up a connection to the server

  11.        conn, err := grpc.Dial("localhost:50052", grpc.WithInsecure())

  12.        if err != nil {

  13.                log.Fatalf("could not connect: %v", err)

  14.        }

  15.        defer conn.Close()

  16.        c := rls.NewRateLimitServiceClient(conn)

  17.        // Send a request to the server

  18.        ctx, cancel := context.WithTimeout(context.Background(), time.Second)

  19.        defer cancel()

  20.    r, err := c.ShouldRateLimit(ctx, &rls.RateLimitRequest{Domain: "envoy"})

  21.        if err != nil {

  22.                log.Fatalf("could not call service: %v", err)

  23.        }

  24.        log.Printf("response: %v", r)

  25. }

現在讓我們通過啟動客戶端來測試服務端/客戶端的交互。

  1. $ for i in {1..4}; do go run cmd/client/main.go; sleep 1; done

  2. 2018/10/27 17:32:23 response: overall_code:OK

  3. 2018/10/27 17:32:25 response: overall_code:OVER_LIMIT

  4. 2018/10/27 17:32:26 response: overall_code:OK

  5. 2018/10/27 17:32:28 response: overall_code:OVER_LIMIT

服務端的相關日誌。

  1. 2018/10/27 17:32:23 request: domain:"envoy"

  2. 2018/10/27 17:32:23 response: overall_code:OK

  3. 2018/10/27 17:32:25 request: domain:"envoy"

  4. 2018/10/27 17:32:25 response: overall_code:OVER_LIMIT

  5. 2018/10/27 17:32:26 request: domain:"envoy"

  6. 2018/10/27 17:32:26 response: overall_code:OK

  7. 2018/10/27 17:32:28 request: domain:"envoy"

  8. 2018/10/27 17:32:28 response: overall_code:OVER_LIMIT

Envoy代理

現在我們引入Envoy代理,它將來自Greeter客戶端的請求路由到Greeter服務端,同時使用我們的速率限制服務檢查速率。下圖描述了我們最終的部署結構。

代理配置

我們使用如下Envoy配置來註冊Greeter和RateLimitService服務並啟用限速檢查。注意,由於我們是將Envoy部署在Docker for Mac上,本地部署的服務是通過 docker.for.mac.localhost地址引用的。

  1. static_resources:

  2.  listeners:

  3.  - address:

  4.      socket_address:

  5.        address: 0.0.0.0

  6.        port_value: 9211 # expose proxy on port 9211

  7.    filter_chains:

  8.    - filters:

  9.      - name: envoy.http_connection_manager

  10.        config:

  11.          codec_type: auto

  12.          stat_prefix: ingress_http

  13.          access_log: # configure logging

  14.            name: envoy.file_access_log

  15.            config:

  16.              path: /dev/stdout

  17.          route_config:

  18.            name: greeter_route # configure the greeter service routes

  19.            virtual_hosts:

  20.            - name: service

  21.              domains:

  22.              - "*"

  23.              routes:

  24.              - match:

  25.                  prefix: "/"

  26.                  grpc: {}

  27.                route:

  28.                  cluster: greeter_service

  29.              rate_limits: # enable rate limit checks for the greeter service

  30.                actions:

  31.                - destination_cluster: {}

  32.          http_filters:

  33.          - name: envoy.rate_limit # enable the Rate Limit filter

  34.            config:

  35.              domain: envoy

  36.          - name: envoy.router # enable the Router filter

  37.            config: {}

  38.  clusters:

  39.  - name: greeter_service # register the Greeter server

  40.    connect_timeout: 1s

  41.    type: strict_dns

  42.    lb_policy: round_robin

  43.    http2_protocol_options: {} # enable H2 protocol

  44.    hosts:

  45.    - socket_address:

  46.        address: docker.for.mac.localhost

  47.        port_value: 50051

  48.  - name: rate_limit_service # register the RateLimitService server

  49.    connect_timeout: 1s

  50.    type: strict_dns

  51.    lb_policy: round_robin

  52.    http2_protocol_options: {} # enable H2 protocol

  53.    hosts:

  54.    - socket_address:

  55.        address: docker.for.mac.localhost

  56.        port_value: 50052

  57. rate_limit_service: # define the global rate limit service

  58.  use_data_plane_proto: true

  59.  grpc_service:

  60.    envoy_grpc:

  61.      cluster_name: rate_limit_service

部署Envoy代理

為了部署Envoy代理,我們將上述配置拷貝到 envoy.yaml文件。然後我們使用如下的 Dockerfile構建Docker鏡像。

  1. FROM envoyproxy/envoy:latest

  2. COPY envoy.yaml /etc/envoy/envoy.yaml

使用如下命令構建鏡像:

  1. $ docker build -t envoy:grpc .

  2. Sending build context to Docker daemon  74.75kB

  3. Step 1/2 : FROM envoyproxy/envoy:latest

  4. ---> 51fc619e4dc5

  5. Step 2/2 : COPY envoy.yaml /etc/envoy/envoy.yaml

  6. ---> c766ba3d7d09

  7. Successfully built c766ba3d7d09

  8. Successfully tagged envoy:grpc

然後運行代理:

  1. $ docker run -p 9211:9211 envoy:grpc

  2. ...

  3. [2018-10-28 02:59:20.469][000008][info][main] [source/server/server.cc:456] starting main dispatch loop

  4. [2018-10-28 02:59:20.553][000008][info][upstream] [source/common/upstream/cluster_manager_impl.cc:135] cm init: all clusters initialized

  5. [2018-10-28 02:59:20.554][000008][info][main] [source/server/server.cc:425] all clusters initialized. initializing init manager

  6. [2018-10-28 02:59:20.554][000008][info][config] [source/server/listener_manager_impl.cc:908] all dependencies initialized. starting workers

更新Greeter客戶端

由於要使用Envoy路由Greeter客戶端的請求,我們將客戶端代碼中的服務端端口從 50051改為 9211,並重新build。

  1.   GreeterClient greeter(grpc::CreateChannel(

  2. -      "localhost:50051", grpc::InsecureChannelCredentials()));

  3. +      "localhost:9211", grpc::InsecureChannelCredentials()));

  4.   std::string user("world");

  5.   std::string reply = greeter.SayHello(user);

最終測試

此時,我們已經有了Greeter服務端、RateLimitService服務和一個Envoy代理,是時候驗證整個部署了。為此,我們使用更新後的Greeter客戶端發送幾個如下所示的請求(譯者注:前面Greeter服務端沒有停,counter已經到了3)。

  1. $ for i in {1..10}; do ./greeter_client; sleep 1; done

  2. Greeter received: 4 world

  3. 14:

  4. Greeter received: RPC failed

  5. Greeter received: 5 world

  6. 14:

  7. Greeter received: RPC failed

  8. Greeter received: 6 world

  9. 14:

  10. Greeter received: RPC failed

  11. Greeter received: 7 world

  12. 14:

  13. Greeter received: RPC failed

  14. Greeter received: 8 world

  15. 14:

  16. Greeter received: RPC failed

如你所見,10個請求中的5個是成功的,交替出現gRPC狀態碼為 14RPC failed失敗請求。這表明速率限制服務按照設計限制了請求,Envoy正確地終止了之後的請求。

結論

這篇文章讓你對如何使用Envoy作為應用代理有了一個高層次的認識,也能幫助你理解Envoy的限速過濾器如何跟gRPC協議協同工作。

相關閱讀推薦

Istio

IBM Istio

  • 111 Istio

  • 118 Istio上手

  • 1115 Istio

  • 11月22日 Envoy

  • 1129 使Istio

  • 126 Istio mixer -

  • 1213 Istio

  • 1220 Istio使Serverless knative

  • IBMIstio

點擊【閱讀原文】跳轉到ServiceMesher網站上瀏覽可以查看文中的鏈接。

  • SOFAMesh(https://github.com/alipay/sofa-mesh)基於Istio的大規模服務網格解決方案

  • SOFAMosn(https://github.com/alipay/sofa-mosn)使用Go語言開發的高性能Sidecar代理

合作社區

參與社區

以下是參與ServiceMesher社區的方式,最簡單的方式是聯繫我!

  • 加入微信交流群:關注本微信公眾號後訪問主頁右下角有獲取聯繫方式按鈕,添加好友時請註明姓名-公司

  • 社區網址:http://www.servicemesher.com

  • Slack:https://servicemesher.slack.com (需要邀請才能加入)

  • GitHub:https://github.com/servicemesher

  • Istio中文文檔進度追蹤:https://github.com/servicemesher/istio-official-translation

  • Twitter: https://twitter.com/servicemesher

  • 提供文章線索與投稿:https://github.com/servicemesher/trans


閱讀原文

TAGS: