golang 網路框架之 grpc

grpc 是 google 開源的一款網路框架，具有極好的效能，可能是目前效能最好的網路框架，支援流式 rpc，可以很方便地構建訊息訂閱釋出系統，支援幾乎所有主流的語言，使用上面也很簡單，公司很多服務基於 grpc 框架構建，執行非常穩定

開始之前首先你要知道網路框架為你做了哪些事情：

> 1. 網路協議序列化與反序列化 > 2. 網路底層通訊 > 3. 併發管理

以及需要你做哪些事情：

> 1. 定義通訊的內容（通過協議檔案） > 2. 實現通訊的方法（實現協議介面）

以下面兩個例子來分別說明兩種 rpc 服務的簡單用法

下面使用的完整程式碼下列地址： 實現檔案：<https://github.com/hatlonely/hellogolang/tree/master/cmd/grpc> 協議檔案：<https://github.com/hatlonely/hellogolang/tree/master/api>

簡單 echo 服務

要實現的這個服務很簡單，功能和 echo 命令類似，用一個字串請求伺服器，返回相同的字串

獲取 grpc

go get google.golang.org/grpc
go get google.golang.org/genproto/

go get 上面兩個庫就可以了。可能被牆了，需要 vpn；如果沒有 vpn，可以找一臺能下載的伺服器下載下來再傳到本地；如果也沒有伺服器，可以點選這裡下載，解壓後放到 vendor/ 目錄下即可，不過可能不是最新版本

定義協議檔案

首先要定義通訊的協議，grpc 使用的是 proto3 序列化協議，這是一個高效的協議，關於這個協議的跟多內容可以參考下面連結：<https://developers.google.com/protocol-buffers/docs/proto3>

syntax = "proto3";

package echo;

message EchoReq {
    string msg = 1;
}

message EchoRes {
    string msg = 1;
}

service Echo {
    rpc echo (EchoReq) returns (EchoRes);
}

執行如下命令會自動生成 echo.pb.go 檔案，這個過程其實是把上面這個協議翻譯成 golang：

protoc --go_out=plugins=grpc:. echo.proto

實際專案中可以把這個命令放到一個 Makefile 檔案中，執行 make 命令即可生成程式碼：

上面命令依賴 protoc 工具，以及 golang 外掛 protoc-gen-go，可以通過如下命令獲取

Mac

brew install grpc
go get -u github.com/golang/protobuf/{proto,protoc-gen-go}

Linux

wget https://github.com/google/protobuf/releases/download/v3.2.0/protobuf-cpp-3.2.0.tar.gz
tar -xzvf protobuf-cpp-3.2.0.tar.gz
cd protobuf-3.2.0
./configure --prefix=${output}
make -j8
[sudo] make install
go get -u github.com/golang/protobuf/{proto,protoc-gen-go}

實現協議介面

type EchoServerImp struct {

}

func (e *EchoServerImp) Echo(ctx context.Context, req *echo.EchoReq) (*echo.EchoRes, error) {
    fmt.Printf("message from client: %v\n", req.GetMsg())

    res := &echo.EchoRes{
        Msg: req.GetMsg(),
    }

    return res, nil
}

首先要定義一個介面的實現類 EchoServerImp，介面的的定義可以在上面生成的檔案 echo.pb.go 中找到，這個類裡面也可以有一些和業務邏輯相關的成員變數，這裡我們的需求比較簡單，沒有其他的成員

然後需要在介面函式裡面實現我們具體的業務邏輯，這裡僅僅把請求裡面的內容讀出來，再寫回到響應裡面

你還可以為這個類增加其他的函式，比如初始化之類的，根據你具體的業務需求就好

實現服務端

func main() {
    server := grpc.NewServer()
    echo.RegisterEchoServer(server, &EchoServerImp{})

    address, err := net.Listen("tcp", ":3000")
    if err != nil {
        panic(err)
    }

    if err := server.Serve(address); err != nil {
        panic(err)
    }
}

把我們剛剛實現的類例項註冊到 grpc 裡，再繫結到本地的一個埠上就可以了，現在可以啟動服務了 go run echo_server.go

實現客戶端

func main() {
    conn, err := grpc.Dial("127.0.0.1:3000", grpc.WithInsecure())
    if err != nil {
        fmt.Errorf("dial failed. err: [%v]\n", err)
        return
    }

    client := echo.NewEchoClient(conn)
    res, err := client.Echo(context.Background(), &echo.EchoReq{
        Msg: strings.Join(os.Args[1:], " "),
    })

    if err != nil {
        fmt.Errorf("client echo failed. err: [%v]", err)
        return
    }

    fmt.Printf("message from server: %v", res.GetMsg())
}

建立一個 client 之後，就可以像訪問本地方法一樣訪問我們的服務了，go run echo_client.go hellogrpc

流式 rpc 服務

實現一個 counter 服務，客戶端傳過來一個數字，服務端從這個數字開始，不停地向下計數返回

定義協議檔案

syntax = "proto3";

package counter;

message CountReq {
    int64 start = 1;
}

message CountRes {
    int64 num = 1;
}

service Counter {
    rpc count (CountReq) returns (stream CountRes);
}

定義一個流式的 rpc 只需要在返回的欄位前加一個 stream 關鍵字就可以

實現服務端

type CounterServerImp struct {

}

func (c *CounterServerImp) Count(req *counter.CountReq, stream counter.Counter_CountServer) error {
    fmt.Printf("request from client. start: [%v]\n", req.GetStart())

    i := req.GetStart()
    for {
        i++
        stream.Send(&counter.CountRes{
            Num: i,
        })
        time.Sleep(time.Duration(500) * time.Millisecond)
    }

    return nil
}

func main() {
    server := grpc.NewServer()
    counter.RegisterCounterServer(server, &CounterServerImp{})

    address, err := net.Listen("tcp", ":3000")
    if err != nil {
        panic(err)
    }

    if err := server.Serve(address); err != nil {
        panic(err)
    }
}

介面實現上需要寫一個死迴圈，不停地呼叫 Send 函式返回結果即可

實現客戶端

func main() {
    start, _ := strconv.ParseInt(os.Args[1], 10, 64)

    conn, err := grpc.Dial("127.0.0.1:3000", grpc.WithInsecure())
    if err != nil {
        fmt.Errorf("dial failed. err: [%v]\n", err)
        return
    }
    client := counter.NewCounterClient(conn)

    stream, err := client.Count(context.Background(), &counter.CountReq{
        Start: start,
    })
    if err != nil {
        fmt.Errorf("count failed. err: [%v]\n", err)
        return
    }

    for {
        res, err := stream.Recv()
        if err != nil {
            fmt.Errorf("client count failed. err: [%v]", err)
            return
        }

        fmt.Printf("server count: %v\n", res.GetNum())
    }
}

客戶端的 Count 介面返回的是一個 stream，不斷地呼叫這個 stream 的 Recv 方法，可以不斷地獲取來自服務端的返回

參考連結

• grpc 官方文件中文版: <http://doc.oschina.net/grpc?t=60133>
• grpc 官方示例: <https://github.com/grpc/grpc-go/tree/master/examples/route_guide>
• proto3 語法: <https://developers.google.com/protocol-buffers/docs/proto3>

> 轉載請註明出處 > 本文連結：<http://hatlonely.github.io/2018/02/03/golang-%E7%BD%91%E7%BB%9C%E6%A1%86%E6%9E%B6%E4%B9%8B-grpc/>