Golang gRPC實踐 連載七 HTTP協議轉換

gRPC HTTP協議轉換

正當有這個需求的時候，就看到了這個實現姿式。源自coreos的一篇博客，轉載到了grpc官方博客gRPC with REST and Open APIs。

etcd3改用grpc後爲了兼容原來的api，同時要提供http/json方式的API，爲了知足這個需求，要麼開發兩套API，要麼實現一種轉換機制，他們選擇了後者，而咱們選擇跟隨他們的腳步。

他們實現了一個協議轉換的網關，對應github上的項目grpc-gateway，這個網關負責接收客戶端請求，而後決定直接轉發給grpc服務仍是轉給http服務，固然，http服務也須要請求grpc服務獲取響應，而後轉爲json響應給客戶端。結構如圖：

下面咱們就直接實戰吧。基於hello-tls項目擴展，客戶端改動不大，服務端和proto改動較大。

安裝grpc-gateway

go get -u github.com/grpc-ecosystem/grpc-gateway/protoc-gen-grpc-gateway

項目結構：

$GOPATH/src/grpc-go-practice/

example/
|—— hello-http-2/
    |—— client/
        |—— main.go   // 客戶端
    |—— server/
        |—— main.go   // 服務端
|—— keys/                 // 證書目錄
    |—— server.key
    |—— server.pem
|—— proto/
    |—— google       // googleApi http-proto定義
        |—— api
            |—— annotations.proto
            |—— annotations.pb.go
            |—— http.proto
            |—— http.pb.go
    |—— hello_http.proto   // proto描述文件
    |—— hello_http.pb.go   // proto編譯後文件
    |—— hello_http_pb.gw.go // gateway編譯後文件

這裏用到了google官方Api中的兩個proto描述文件，直接拷貝不要作修改，裏面定義了protocol buffer擴展的HTTP option，爲grpc的http轉換提供支持。

示例代碼

proto/hello_http.proto

syntax = "proto3";  // 指定proto版本

package proto;     // 指定包名

import "google/api/annotations.proto";

// 定義Hello服務
service HelloHttp {
    // 定義SayHello方法
    rpc SayHello(HelloHttpRequest) returns (HelloHttpReply) {
        // http option
        option (google.api.http) = {
            post: "/example/echo"
            body: "*"
        };
    }
}

// HelloRequest 請求結構
message HelloHttpRequest {
    string name = 1;
}

// HelloReply 響應結構
message HelloHttpReply {
    string message = 1;
}

這裏在原來的SayHello方法定義中增長了http option, POST方式，路由爲"/example/echo"。

編譯proto

cd $GOPATH/src/grpc-go-practice/example/hello-http-2/proto

# 編譯google.api
protoc -I . --go_out=plugins=grpc,Mgoogle/protobuf/descriptor.proto=github.com/golang/protobuf/protoc-gen-go/descriptor:. google/api/*.proto

# 編譯hello_http.proto
protoc -I . --go_out=plugins=grpc,Mgoogle/api/annotations.proto=git.vodjk.com/go-grpc/example/proto/google/api:. ./*.proto

# 編譯hello_http.proto gateway
protoc --grpc-gateway_out=logtostderr=true:. ./hello_http.proto

注意這裏須要編譯google/api中的兩個proto文件，同時在編譯hello_http.proto時指定引入包名，最後使用grpc-gateway編譯生成hello_http_pb.gw.go文件，這個文件就是用來作協議轉換的，查看文件能夠看到裏面生成的http handler，處理上面定義的路由"example/echo"接收POST參數，調用HelloHTTP服務的客戶端請求grpc服務並響應結果。

server/main.go

package main

import (
    "crypto/tls"
    "fmt"
    "io/ioutil"
    "log"
    "net"
    "net/http"
    "strings"

    "github.com/grpc-ecosystem/grpc-gateway/runtime"
    "golang.org/x/net/context"
    "google.golang.org/grpc"

    pb "git.vodjk.com/go-grpc/example/proto"
    "google.golang.org/grpc/credentials"
    "google.golang.org/grpc/grpclog"
)

// 定義helloHttpService並實現約定的接口
type helloHttpService struct{}

// HelloHttpService ...
var HelloHttpService = helloHttpService{}

func (h helloHttpService) SayHello(ctx context.Context, in *pb.HelloHttpRequest) (*pb.HelloHttpReply, error) {
    resp := new(pb.HelloHttpReply)
    resp.Message = "Hello " + in.Name + "."

    return resp, nil
}

// grpcHandlerFunc 檢查請求協議並返回http handler
func grpcHandlerFunc(grpcServer *grpc.Server, otherHandler http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // TODO(tamird): point to merged gRPC code rather than a PR.
        // This is a partial recreation of gRPC's internal checks https://github.com/grpc/grpc-go/pull/514/files#diff-95e9a25b738459a2d3030e1e6fa2a718R61
        if r.ProtoMajor == 2 && strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
            grpcServer.ServeHTTP(w, r)
        } else {
            otherHandler.ServeHTTP(w, r)
        }
    })
}

func main() {
    endpoint := "127.0.0.1:50052"

    // 實例化標準grpc server
    creds, err := credentials.NewServerTLSFromFile("../../keys/server.pem", "../../keys/server.key")
    if err != nil {
        grpclog.Fatalf("Failed to generate credentials %v", err)
    }
    conn, _ := net.Listen("tcp", endpoint)
    grpcServer := grpc.NewServer(grpc.Creds(creds))
    pb.RegisterHelloHttpServer(grpcServer, HelloHttpService)

    // http-grpc gateway
    ctx := context.Background()
    ctx, cancel := context.WithCancel(ctx)
    defer cancel()

    dcreds, err := credentials.NewClientTLSFromFile("../../keys/server.pem", "server name")
    if err != nil {
        grpclog.Fatalf("Failed to create TLS credentials %v", err)
    }
    dopts := []grpc.DialOption{grpc.WithTransportCredentials(dcreds)}
    gwmux := runtime.NewServeMux()
    err = pb.RegisterHelloHttpHandlerFromEndpoint(ctx, gwmux, endpoint, dopts)
    if err != nil {
        fmt.Printf("serve: %v\n", err)
        return
    }

    mux := http.NewServeMux()
    mux.Handle("/", gwmux)

    if err != nil {
        panic(err)
    }

    // 開啓HTTP服務
    cert, _ := ioutil.ReadFile("../../keys/server.pem")
    key, _ := ioutil.ReadFile("../../keys/server.key")
    var demoKeyPair *tls.Certificate
    pair, err := tls.X509KeyPair(cert, key)
    if err != nil {
        panic(err)
    }
    demoKeyPair = &pair

    srv := &http.Server{
        Addr:    endpoint,
        Handler: grpcHandlerFunc(grpcServer, mux),
        TLSConfig: &tls.Config{
            Certificates: []tls.Certificate{*demoKeyPair},
        },
    }

    fmt.Printf("grpc and https on port: %d\n", 50052)

    err = srv.Serve(tls.NewListener(conn, srv.TLSConfig))

    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }

    return
}

好吧，這麼大一坨。核心就是開啓了一個http server，收到請求後檢查請求是grpc仍是http，而後決定是由grpc服務直接處理仍是交給gateway作轉發處理。其中grpcHandlerFunc函數負責處理決定用哪一個handler處理請求，這個方法是直接Copy過來用的，原文的註釋說他們也是從別處Copy的。感謝貢獻者。

基本流程：

• 實例化標準grpc server

• 將grpc server註冊給gateway

• 開啓http服務，handler指定給grpcHandlerFunc方法

注意：必須開啓HTTPS

運行結果

開啓服務：

# hello-http-2/server
go run main.go

> grpc and https on port: 50052

調用grpc客戶端：

# hello-http-2/client
go run main.go

> Hello gRPC.

請求https：

curl -X POST -k https://localhost:50052/example/echo -d '{"name": "gRPC-HTTP is working!"}'

> {"message":"Hello gRPC-HTTP is working!."}

爲何是hello-http-2，由於1是個不完整的實現姿式，能夠不用https，可是須要分別開啓grpc服務和http服務，這裏不作說明了。

參考

本系列示例代碼

• go-grpc-example