• Hello World
    • 需求
    • 一、初始化目录
    • 二、制作证书
      • 私钥
      • 自签名公钥
      • 填写信息
    • 三、proto
      • 编写
      • 编译
    • 四、命令行模块 cmd
      • 介绍
      • 编写server
      • 编写cmd
      • 讲解
      • 测试
    • 五、服务端模块 server
      • 编写hello.go
      • *编写server.go
        • server流程剖析
          • 一、启动监听
          • 二、获取TLS
          • 三、创建内部服务
          • 四、创建tls.NewListener
          • 五、服务开始接受请求
    • 六、验证功能
      • 编写测试客户端
      • 启动服务端
      • 执行测试客户端
      • 执行测试Restful Api
    • 最终目录结构
    • 参考
      • 示例代码

    Hello World

    在上一节中我们已经完成了对环境的基本配置

    这节将开始编写一个复杂的Hello World，涉及到许多的知识，建议大家认真思考其中的概念

    需求

    由于本实践偏向Grpc+Grpc Gateway的方面，我们的需求是同一个服务端支持Rpc和Restful Api，那么就意味着http2、TLS等等的应用，功能方面就是一个服务端能够接受来自grpc和Restful Api的请求并响应

    一、初始化目录

    我们先在$GOPATH中新建grpc-hello-world文件夹，我们项目的初始目录目录如下：

    1. grpc-hello-world/
    2. ├── certs
    3. ├── client
    4. ├── cmd
    5. ├── pkg
    6. ├── proto
    7. │   ├── google
    8. │   │   └── api
    9. └── server
    • certs：证书凭证
    • client：客户端
    • cmd：命令行
    • pkg：第三方公共模块
    • proto：protobuf的一些相关文件（含.proto、pb.go、.pb.gw.go)，google/api中用于存放annotations.proto、http.proto
    • server：服务端

    二、制作证书

    在服务端支持Rpc和Restful Api，需要用到TLS，因此我们要先制作证书

    进入certs目录，生成TLS所需的公钥密钥文件

    私钥

    1. openssl genrsa -out server.key 2048
    3. openssl ecparam -genkey -name secp384r1 -out server.key
    • openssl genrsa：生成RSA私钥，命令的最后一个参数，将指定生成密钥的位数，如果没有指定，默认512
    • openssl ecparam：生成ECC私钥，命令为椭圆曲线密钥参数生成及操作，本文中ECC曲线选择的是secp384r1

    自签名公钥

    1. openssl req -new -x509 -sha256 -key server.key -out server.pem -days 3650
    • openssl req：生成自签名证书，-new指生成证书请求、-sha256指使用sha256加密、-key指定私钥文件、-x509指输出证书、-days 3650为有效期，此后则输入证书拥有者信息

    填写信息

    1. Country Name (2 letter code) [XX]:
    2. State or Province Name (full name) []:
    3. Locality Name (eg, city) [Default City]:
    4. Organization Name (eg, company) [Default Company Ltd]:
    5. Organizational Unit Name (eg, section) []:
    6. Common Name (eg, your name or your server's hostname) []:grpc server name
    7. Email Address []:

    三、proto

    编写

    1、 google.api

    我们看到proto目录中有google/api目录，它用到了google官方提供的两个api描述文件，主要是针对grpc-gateway的http转换提供支持，定义了Protocol Buffer所扩展的HTTP Option

    annotations.proto文件：

    1. // Copyright (c) 2015, Google Inc.
    2. //
    3. // Licensed under the Apache License, Version 2.0 (the "License");
    4. // you may not use this file except in compliance with the License.
    5. // You may obtain a copy of the License at
    6. //
    7. //     http://www.apache.org/licenses/LICENSE-2.0
    8. //
    9. // Unless required by applicable law or agreed to in writing, software
    10. // distributed under the License is distributed on an "AS IS" BASIS,
    11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12. // See the License for the specific language governing permissions and
    13. // limitations under the License.
    15. syntax = "proto3";
    17. package google.api;
    19. import "google/api/http.proto";
    20. import "google/protobuf/descriptor.proto";
    22. option java_multiple_files = true;
    23. option java_outer_classname = "AnnotationsProto";
    24. option java_package = "com.google.api";
    26. extend google.protobuf.MethodOptions {
    27.   // See `HttpRule`.
    28.   HttpRule http = 72295728;
    29. }

    http.proto文件：

    1. // Copyright 2016 Google Inc.
    2. //
    3. // Licensed under the Apache License, Version 2.0 (the "License");
    4. // you may not use this file except in compliance with the License.
    5. // You may obtain a copy of the License at
    6. //
    7. //     http://www.apache.org/licenses/LICENSE-2.0
    8. //
    9. // Unless required by applicable law or agreed to in writing, software
    10. // distributed under the License is distributed on an "AS IS" BASIS,
    11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12. // See the License for the specific language governing permissions and
    13. // limitations under the License.
    15. syntax = "proto3";
    17. package google.api;
    19. option cc_enable_arenas = true;
    20. option java_multiple_files = true;
    21. option java_outer_classname = "HttpProto";
    22. option java_package = "com.google.api";
    25. // Defines the HTTP configuration for a service. It contains a list of
    26. // [HttpRule][google.api.HttpRule], each specifying the mapping of an RPC method
    27. // to one or more HTTP REST API methods.
    28. message Http {
    29.   // A list of HTTP rules for configuring the HTTP REST API methods.
    30.   repeated HttpRule rules = 1;
    31. }
    33. // Use CustomHttpPattern to specify any HTTP method that is not included in the
    34. // `pattern` field, such as HEAD, or "*" to leave the HTTP method unspecified for
    35. // a given URL path rule. The wild-card rule is useful for services that provide
    36. // content to Web (HTML) clients.
    37. message HttpRule {
    38.   // Selects methods to which this rule applies.
    39.   //
    40.   // Refer to [selector][google.api.DocumentationRule.selector] for syntax details.
    41.   string selector = 1;
    43.   // Determines the URL pattern is matched by this rules. This pattern can be
    44.   // used with any of the {get|put|post|delete|patch} methods. A custom method
    45.   // can be defined using the 'custom' field.
    46.   oneof pattern {
    47.     // Used for listing and getting information about resources.
    48.     string get = 2;
    50.     // Used for updating a resource.
    51.     string put = 3;
    53.     // Used for creating a resource.
    54.     string post = 4;
    56.     // Used for deleting a resource.
    57.     string delete = 5;
    59.     // Used for updating a resource.
    60.     string patch = 6;
    62.     // Custom pattern is used for defining custom verbs.
    63.     CustomHttpPattern custom = 8;
    64.   }
    66.   // The name of the request field whose value is mapped to the HTTP body, or
    67.   // `*` for mapping all fields not captured by the path pattern to the HTTP
    68.   // body. NOTE: the referred field must not be a repeated field.
    69.   string body = 7;
    71.   // Additional HTTP bindings for the selector. Nested bindings must
    72.   // not contain an `additional_bindings` field themselves (that is,
    73.   // the nesting may only be one level deep).
    74.   repeated HttpRule additional_bindings = 11;
    75. }
    77. // A custom pattern is used for defining custom HTTP verb.
    78. message CustomHttpPattern {
    79.   // The name of this custom HTTP verb.
    80.   string kind = 1;
    82.   // The path matched by this custom verb.
    83.   string path = 2;
    84. }
    1. hello.proto

    这一小节将编写Demo的.proto文件，我们在proto目录下新建hello.proto文件，写入文件内容：

    1. syntax = "proto3";
    3. package proto;
    5. import "google/api/annotations.proto";
    7. service HelloWorld {
    8.     rpc SayHelloWorld(HelloWorldRequest) returns (HelloWorldResponse) {
    9.         option (google.api.http) = {
    10.             post: "/hello_world"
    11.             body: "*"
    12.         };
    13.     }
    14. }
    16. message HelloWorldRequest {
    17.     string referer = 1;
    18. }
    20. message HelloWorldResponse {
    21.     string message = 1;
    22. }

    在hello.proto文件中，引用了google/api/annotations.proto，达到支持HTTP Option的效果

    • 定义了一个serviceRPC服务HelloWorld，在其内部定义了一个HTTP Option的POST方法，HTTP响应路径为/hello_world
    • 定义message类型HelloWorldRequest、HelloWorldResponse，用于响应请求和返回结果

    编译

    在编写完.proto文件后，我们需要对其进行编译，就能够在server中使用

    进入proto目录，执行以下命令

    1. # 编译google.api
    2. protoc -I . --go_out=plugins=grpc,Mgoogle/protobuf/descriptor.proto=github.com/golang/protobuf/protoc-gen-go/descriptor:. google/api/*.proto
    4. #编译hello_http.proto为hello_http.pb.proto
    5. protoc -I . --go_out=plugins=grpc,Mgoogle/api/annotations.proto=grpc-hello-world/proto/google/api:. ./hello.proto
    7. #编译hello_http.proto为hello_http.pb.gw.proto
    8. protoc --grpc-gateway_out=logtostderr=true:. ./hello.proto

    执行完毕后将生成hello.pb.go和hello.gw.pb.go，分别针对grpc和grpc-gateway的功能支持

    四、命令行模块 cmd

    介绍

    这一小节我们编写命令行模块，为什么要独立出来呢，是为了将cmd和server两者解耦，避免混淆在一起。

    我们采用 Cobra 来完成这项功能，Cobra既是创建强大的现代CLI应用程序的库，也是生成应用程序和命令文件的程序。提供了以下功能：

    • 简易的子命令行模式
    • 完全兼容posix的命令行模式(包括短和长版本)
    • 嵌套的子命令
    • 全局、本地和级联flags
    • 使用Cobra很容易的生成应用程序和命令，使用cobra create appname和cobra add cmdname
    • 智能提示
    • 自动生成commands和flags的帮助信息
    • 自动生成详细的help信息-h，--help等等
    • 自动生成的bash自动完成功能
    • 为应用程序自动生成手册
    • 命令别名
    • 定义您自己的帮助、用法等的灵活性。
    • 可选与viper紧密集成的apps

    编写server

    在编写cmd时需要先用server进行测试关联，因此这一步我们先写server.go用于测试

    在server模块下 新建server.go文件，写入测试内容：

    1. package server
    3. import (
    4.     "log"
    5. )
    7. var (
    8.     ServerPort string
    9.     CertName string
    10.     CertPemPath string
    11.     CertKeyPath string
    12. )
    14. func Serve() (err error){
    15.     log.Println(ServerPort)
    17.     log.Println(CertName)
    19.     log.Println(CertPemPath)
    21.     log.Println(CertKeyPath)
    23.     return nil
    24. }

    编写cmd

    在cmd模块下 新建root.go文件，写入内容：

    1. package cmd
    3. import (
    4.     "fmt"
    5.     "os"
    7.     "github.com/spf13/cobra"
    8. )
    10. var rootCmd = &cobra.Command{
    11.     Use:   "grpc",
    12.     Short: "Run the gRPC hello-world server",
    13. }
    15. func Execute() {
    16.     if err := rootCmd.Execute(); err != nil {
    17.         fmt.Println(err)
    18.         os.Exit(-1)
    19.     }
    20. }

    新建server.go文件，写入内容：

    1. package cmd
    3. import (
    4.     "log"
    6.     "github.com/spf13/cobra"
    8.     "grpc-hello-world/server"
    9. )
    11. var serverCmd = &cobra.Command{
    12.     Use:   "server",
    13.     Short: "Run the gRPC hello-world server",
    14.     Run: func(cmd *cobra.Command, args []string) {
    15.         defer func() {
    16.             if err := recover(); err != nil {
    17.                 log.Println("Recover error : %v", err)
    18.             }
    19.         }()
    21.         server.Serve()
    22.     },
    23. }
    25. func init() {
    26.     serverCmd.Flags().StringVarP(&server.ServerPort, "port", "p", "50052", "server port")
    27.     serverCmd.Flags().StringVarP(&server.CertPemPath, "cert-pem", "", "./certs/server.pem", "cert pem path")
    28.     serverCmd.Flags().StringVarP(&server.CertKeyPath, "cert-key", "", "./certs/server.key", "cert key path")
    29.     serverCmd.Flags().StringVarP(&server.CertName, "cert-name", "", "grpc server name", "server's hostname")
    30.     rootCmd.AddCommand(serverCmd)
    31. }

    我们在grpc-hello-world/目录下，新建文件main.go，写入内容：

    1. package main
    3. import (
    4.     "grpc-hello-world/cmd"
    5. )
    7. func main() {
    8.     cmd.Execute()
    9. }

    讲解

    要使用Cobra，按照Cobra标准要创建main.go和一个rootCmd文件，另外我们有子命令server

    1、rootCmd：
    rootCmd表示在没有任何子命令的情况下的基本命令

    2、&cobra.Command：

    • Use：Command的用法，Use是一个行用法消息
    • Short：Short是help命令输出中显示的简短描述
    • Run：运行:典型的实际工作功能。大多数命令只会实现这一点；另外还有PreRun、PreRunE、PostRun、PostRunE等等不同时期的运行命令，但比较少用，具体使用时再查看亦可

    3、rootCmd.AddCommand：AddCommand向这父命令（rootCmd）添加一个或多个命令

    4、serverCmd.Flags().StringVarP()：

    一般来说，我们需要在init()函数中定义flags和处理配置，以serverCmd.Flags().StringVarP(&server.ServerPort, "port", "p", "50052", "server port")为例，我们定义了一个flag，值存储在&server.ServerPort中，长命令为--port，短命令为-p，，默认值为50052，命令的描述为server port。这一种调用方式成为Local Flags

    我们延伸一下，如果觉得每一个子命令都要设一遍觉得很麻烦，我们可以采用Persistent Flags：

    rootCmd.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", false, "verbose output")

    作用：

    flag是可以持久的，这意味着该flag将被分配给它所分配的命令以及该命令下的每个命令。对于全局标记，将标记作为根上的持久标志。

    另外还有Local Flag on Parent Commands、Bind Flags with Config、Required flags等等，使用到再 传送 了解即可

    测试

    回到grpc-hello-world/目录下执行go run main.go server，查看输出是否为（此时应为默认值）：

    1. 2018/02/25 23:23:21 50052
    2. 2018/02/25 23:23:21 dev
    3. 2018/02/25 23:23:21 ./certs/server.pem
    4. 2018/02/25 23:23:21 ./certs/server.key

    执行go run main.go server --port=8000 --cert-pem=test-pem --cert-key=test-key --cert-name=test-name，检验命令行参数是否正确：

    1. 2018/02/25 23:24:56 8000
    2. 2018/02/25 23:24:56 test-name
    3. 2018/02/25 23:24:56 test-pem
    4. 2018/02/25 23:24:56 test-key

    若都无误，那么恭喜你cmd模块的编写正确了，下一部分开始我们的重点章节！

    五、服务端模块 server

    编写hello.go

    在server目录下新建文件hello.go，写入文件内容：

    1. package server
    3. import (
    4.     "golang.org/x/net/context"
    6.     pb "grpc-hello-world/proto"
    7. )
    9. type helloService struct{}
    11. func NewHelloService() *helloService {
    12.     return &helloService{}
    13. }
    15. func (h helloService) SayHelloWorld(ctx context.Context, r *pb.HelloWorldRequest) (*pb.HelloWorldResponse, error) {
    16.     return &pb.HelloWorldResponse{
    17.         Message : "test",
    18.     }, nil
    19. }

    我们创建了helloService及其方法SayHelloWorld，对应.proto的rpc SayHelloWorld，这个方法需要有2个参数：ctx context.Context用于接受上下文参数、r *pb.HelloWorldRequest用于接受protobuf的Request参数（对应.proto的message HelloWorldRequest）

    *编写server.go

    这一小章节，我们编写最为重要的服务端程序部分，涉及到大量的grpc、grpc-gateway及一些网络知识的应用

    1、在pkg下新建util目录，新建grpc.go文件，写入内容：

    1. package util
    3. import (
    4.     "net/http"
    5.     "strings"
    7.     "google.golang.org/grpc"
    8. )
    10. func GrpcHandlerFunc(grpcServer *grpc.Server, otherHandler http.Handler) http.Handler {
    11.     if otherHandler == nil {
    12.         return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    13.             grpcServer.ServeHTTP(w, r)
    14.         })
    15.     }
    16.     return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    17.         if r.ProtoMajor == 2 && strings.Contains(r.Header.Get("Content-Type"), "application/grpc") {
    18.             grpcServer.ServeHTTP(w, r)
    19.         } else {
    20.             otherHandler.ServeHTTP(w, r)
    21.         }
    22.     })
    23. }

    GrpcHandlerFunc函数是用于判断请求是来源于Rpc客户端还是Restful Api的请求，根据不同的请求注册不同的ServeHTTP服务；r.ProtoMajor == 2也代表着请求必须基于HTTP/2

    2、在pkg下的util目录下，新建tls.go文件，写入内容：

    1. package util
    3. import (
    4.     "crypto/tls"
    5.     "io/ioutil"
    6.     "log"
    8.     "golang.org/x/net/http2"
    9. )
    11. func GetTLSConfig(certPemPath, certKeyPath string) *tls.Config {
    12.     var certKeyPair *tls.Certificate
    13.     cert, _ := ioutil.ReadFile(certPemPath)
    14.     key, _ := ioutil.ReadFile(certKeyPath)
    16.     pair, err := tls.X509KeyPair(cert, key)
    17.     if err != nil {
    18.         log.Println("TLS KeyPair err: %v\n", err)
    19.     }
    21.     certKeyPair = &pair
    23.     return &tls.Config{
    24.         Certificates: []tls.Certificate{*certKeyPair},
    25.         NextProtos:   []string{http2.NextProtoTLS},
    26.     }
    27. }

    GetTLSConfig函数是用于获取TLS配置，在内部，我们读取了server.key和server.pem这类证书凭证文件

    • tls.X509KeyPair：从一对PEM编码的数据中解析公钥/私钥对。成功则返回公钥/私钥对
    • http2.NextProtoTLS：NextProtoTLS是谈判期间的NPN/ALPN协议，用于HTTP/2的TLS设置
    • tls.Certificate：返回一个或多个证书，实质我们解析PEM调用的X509KeyPair的函数声明就是func X509KeyPair(certPEMBlock, keyPEMBlock []byte) (Certificate, error)，返回值就是Certificate

    总的来说该函数是用于处理从证书凭证文件（PEM），最终获取tls.Config作为HTTP2的使用参数

    3、修改server目录下的server.go文件，该文件是我们服务里的核心文件，写入内容：

    1. package server
    3. import (
    4.     "crypto/tls"
    5.     "net"
    6.     "net/http"
    7.     "log"
    9.     "golang.org/x/net/context"
    10.     "google.golang.org/grpc"
    11.     "google.golang.org/grpc/credentials"
    12.     "github.com/grpc-ecosystem/grpc-gateway/runtime"
    14.     pb "grpc-hello-world/proto"
    15.     "grpc-hello-world/pkg/util"
    16. )
    18. var (
    19.     ServerPort string
    20.     CertName string
    21.     CertPemPath string
    22.     CertKeyPath string
    23.     EndPoint string
    24. )
    26. func Serve() (err error){
    27.     EndPoint = ":" + ServerPort
    28.     conn, err := net.Listen("tcp", EndPoint)
    29.     if err != nil {
    30.         log.Printf("TCP Listen err:%v\n", err)
    31.     }
    33.     tlsConfig := util.GetTLSConfig(CertPemPath, CertKeyPath)
    34.     srv := createInternalServer(conn, tlsConfig)
    36.     log.Printf("gRPC and https listen on: %s\n", ServerPort)
    38.     if err = srv.Serve(tls.NewListener(conn, tlsConfig)); err != nil {
    39.         log.Printf("ListenAndServe: %v\n", err)
    40.     }
    42.     return err
    43. }
    45. func createInternalServer(conn net.Listener, tlsConfig *tls.Config) (*http.Server) {
    46.     var opts []grpc.ServerOption
    48.     // grpc server
    49.     creds, err := credentials.NewServerTLSFromFile(CertPemPath, CertKeyPath)
    50.     if err != nil {
    51.         log.Printf("Failed to create server TLS credentials %v", err)
    52.     }
    54.     opts = append(opts, grpc.Creds(creds))
    55.     grpcServer := grpc.NewServer(opts...)
    57.     // register grpc pb
    58.     pb.RegisterHelloWorldServer(grpcServer, NewHelloService())
    60.     // gw server
    61.     ctx := context.Background()
    62.     dcreds, err := credentials.NewClientTLSFromFile(CertPemPath, CertName)
    63.     if err != nil {
    64.         log.Printf("Failed to create client TLS credentials %v", err)
    65.     }
    66.     dopts := []grpc.DialOption{grpc.WithTransportCredentials(dcreds)}
    67.     gwmux := runtime.NewServeMux()
    69.     // register grpc-gateway pb
    70.     if err := pb.RegisterHelloWorldHandlerFromEndpoint(ctx, gwmux, EndPoint, dopts); err != nil {
    71.         log.Printf("Failed to register gw server: %v\n", err)
    72.     }
    74.     // http服务
    75.     mux := http.NewServeMux()
    76.     mux.Handle("/", gwmux)
    78.     return &http.Server{
    79.         Addr:      EndPoint,
    80.         Handler:   util.GrpcHandlerFunc(grpcServer, mux),
    81.         TLSConfig: tlsConfig,
    82.     }
    83. }

    server流程剖析

    我们将这一大块代码，分成以下几个部分来理解

    一、启动监听

    net.Listen("tcp", EndPoint)用于监听本地的网络地址通知，它的函数原型func Listen(network, address string) (Listener, error)

    参数：network必须传入tcp、tcp4、tcp6、unix、unixpacket，若address为空或为0则会自动选择一个端口号
    返回值：通过查看源码我们可以得知其返回值为Listener，结构体原型：

    1. type Listener interface {
    2.     Accept() (Conn, error)
    3.     Close() error
    4.     Addr() Addr
    5. }

    通过分析得知，最后net.Listen会返回一个监听器的结构体，返回给接下来的动作，让其执行下一步的操作，它可以执行三类操作

    • Accept：接受等待并将下一个连接返回给Listener
    • Close：关闭Listener
    • Addr：返回Listener的网络地址
    二、获取TLS

    通过util.GetTLSConfig解析得到tls.Config，传达给http.Server服务的TLSConfig配置项使用

    三、创建内部服务

    createInternalServer函数，是整个服务端的核心流转部分

    程序采用的是HTT2、HTTPS也就是需要支持TLS，因此在启动grpc.NewServer前，我们要将认证的中间件注册进去

    而前面所获取的tlsConfig仅能给HTTP使用，因此第一步我们要创建grpc的TLS认证凭证

    1、创建grpc的TLS认证凭证

    新增引用google.golang.org/grpc/credentials的第三方包，它实现了grpc库支持的各种凭证，该凭证封装了客户机需要的所有状态，以便与服务器进行身份验证并进行各种断言，例如关于客户机的身份，角色或是否授权进行特定的呼叫

    我们调用NewServerTLSFromFile来达到我们的目的，它能够从输入证书文件和服务器的密钥文件构造TLS证书凭证

    1. func NewServerTLSFromFile(certFile, keyFile string) (TransportCredentials, error) {
    2.     //LoadX509KeyPair读取并解析来自一对文件的公钥/私钥对
    3.     cert, err := tls.LoadX509KeyPair(certFile, keyFile)
    4.     if err != nil {
    5.         return nil, err
    6.     }
    7.     //NewTLS使用tls.Config来构建基于TLS的TransportCredentials
    8.     return NewTLS(&tls.Config{Certificates: []tls.Certificate{cert}}), nil
    9. }

    2、设置grpc ServerOption

    以grpc.Creds(creds)为例，其原型为func Creds(c credentials.TransportCredentials) ServerOption，该函数返回ServerOption，它为服务器连接设置凭据

    3、创建grpc服务端

    函数原型：

    1. func NewServer(opt ...ServerOption) *Server

    我们在此处创建了一个没有注册服务的grpc服务端，还没有开始接受请求

    1. grpcServer := grpc.NewServer(opts...)

    4、注册grpc服务

    1. pb.RegisterHelloWorldServer(grpcServer, NewHelloService())

    5、创建grpc-gateway关联组件

    1. ctx := context.Background()
    2. dcreds, err := credentials.NewClientTLSFromFile(CertPemPath, CertName)
    3. if err != nil {
    4.     log.Println("Failed to create client TLS credentials %v", err)
    5. }
    6. dopts := []grpc.DialOption{grpc.WithTransportCredentials(dcreds)}
    • context.Background：返回一个非空的空上下文。它没有被注销，没有值，没有过期时间。它通常由主函数、初始化和测试使用，并作为传入请求的顶级上下文
    • credentials.NewClientTLSFromFile：从客户机的输入证书文件构造TLS凭证
    • grpc.WithTransportCredentials：配置一个连接级别的安全凭据(例：TLS、SSL)，返回值为type DialOption
    • grpc.DialOption：DialOption选项配置我们如何设置连接（其内部具体由多个的DialOption组成，决定其设置连接的内容）

    6、创建HTTP NewServeMux及注册grpc-gateway逻辑

    1. gwmux := runtime.NewServeMux()
    3. // register grpc-gateway pb
    4. if err := pb.RegisterHelloWorldHandlerFromEndpoint(ctx, gwmux, EndPoint, dopts); err != nil {
    5.     log.Println("Failed to register gw server: %v\n", err)
    6. }
    8. // http服务
    9. mux := http.NewServeMux()
    10. mux.Handle("/", gwmux)
    • runtime.NewServeMux：返回一个新的ServeMux，它的内部映射是空的；ServeMux是grpc-gateway的一个请求多路复用器。它将http请求与模式匹配，并调用相应的处理程序
    • RegisterHelloWorldHandlerFromEndpoint：如函数名，注册HelloWorld服务的HTTP Handle到grpc端点
    • http.NewServeMux：分配并返回一个新的ServeMux
    • mux.Handle：为给定模式注册处理程序

    （带着疑问去看程序）为什么gwmux可以放入mux.Handle中？

    首先我们看看它们的原型是怎么样的

    （1）http.NewServeMux()

    1. func NewServeMux() *ServeMux {
    2.         return new(ServeMux) 
    3. }
    1. type Handler interface {
    2.     ServeHTTP(ResponseWriter, *Request)
    3. }

    （2）runtime.NewServeMux？

    1. func NewServeMux(opts ...ServeMuxOption) *ServeMux {
    2.     serveMux := &ServeMux{
    3.         handlers:               make(map[string][]handler),
    4.         forwardResponseOptions: make([]func(context.Context, http.ResponseWriter, proto.Message) error, 0),
    5.         marshalers:             makeMarshalerMIMERegistry(),
    6.     }
    7.     ...
    8.     return serveMux
    9. }

    （3）http.NewServeMux()的Handle方法

    1. func (mux *ServeMux) Handle(pattern string, handler Handler)

    通过分析可得知，两者NewServeMux都是最终返回serveMux，Handler中导出的方法仅有ServeHTTP，功能是用于响应HTTP请求

    我们回到Handle interface中，可以得出结论就是任何结构体，只要实现了ServeHTTP方法，这个结构就可以称为Handle，ServeMux会使用该Handler调用ServeHTTP方法处理请求，这也就是自定义Handler

    而我们这里正是将grpc-gateway中注册好的HTTP Handler无缝的植入到net/http的Handle方法中

    补充：在go中任何结构体只要实现了与接口相同的方法，就等同于实现了接口

    7、注册具体服务

    1. if err := pb.RegisterHelloWorldHandlerFromEndpoint(ctx, gwmux, EndPoint, dopts); err != nil {
    2.     log.Println("Failed to register gw server: %v\n", err)
    3. }

    在这段代码中，我们利用了前几小节的

    • 上下文
    • gateway-grpc的请求多路复用器
    • 服务网络地址
    • 配置好的安全凭据

    注册了HelloWorld这一个服务

    四、创建tls.NewListener
    1. func NewListener(inner net.Listener, config *Config) net.Listener {
    2.     l := new(listener)
    3.     l.Listener = inner
    4.     l.config = config
    5.     return l
    6. }

    NewListener将会创建一个Listener，它接受两个参数，第一个是来自内部Listener的监听器，第二个参数是tls.Config（必须包含至少一个证书）

    五、服务开始接受请求

    在最后我们调用srv.Serve(tls.NewListener(conn, tlsConfig))，可以得知它是http.Server的方法，并且需要一个Listener作为参数，那么Serve内部做了些什么事呢？

    1. func (srv *Server) Serve(l net.Listener) error {
    2.     defer l.Close()
    3.     ...
    5.     baseCtx := context.Background() // base is always background, per Issue 16220
    6.     ctx := context.WithValue(baseCtx, ServerContextKey, srv)
    7.     for {
    8.         rw, e := l.Accept()
    9.         ...
    10.         c := srv.newConn(rw)
    11.         c.setState(c.rwc, StateNew) // before Serve can return
    12.         go c.serve(ctx)
    13.     }
    14. }

    粗略的看，它创建了一个context.Background()上下文对象，并调用Listener的Accept方法开始接受外部请求，在获取到连接数据后使用newConn创建连接对象，在最后使用goroutine的方式处理连接请求，达到其目的

    补充：对于HTTP/2支持，在调用Serve之前，应将srv.TLSConfig初始化为提供的Listener的TLS配置。如果srv.TLSConfig非零，并且在Config.NextProtos中不包含字符串h2，则不启用HTTP/2支持

    六、验证功能

    编写测试客户端

    在grpc-hello-world/下新建目录client，新建client.go文件，新增内容：

    1. package main
    3. import (
    4.     "log"
    6.     "golang.org/x/net/context"
    7.     "google.golang.org/grpc"
    8.     "google.golang.org/grpc/credentials"
    10.     pb "grpc-hello-world/proto"
    11. )
    13. func main() {
    14.     creds, err := credentials.NewClientTLSFromFile("../certs/server.pem", "dev")
    15.     if err != nil {
    16.         log.Println("Failed to create TLS credentials %v", err)
    17.     }
    18.     conn, err := grpc.Dial(":50052", grpc.WithTransportCredentials(creds))
    19.     defer conn.Close()
    21.     if err != nil {
    22.         log.Println(err)
    23.     }
    25.     c := pb.NewHelloWorldClient(conn)
    26.     context := context.Background()
    27.     body := &pb.HelloWorldRequest{
    28.         Referer : "Grpc",
    29.     }
    31.     r, err := c.SayHelloWorld(context, body)
    32.     if err != nil {
    33.         log.Println(err)
    34.     }
    36.     log.Println(r.Message)
    37. }

    由于客户端只是展示测试用，就简单的来了，原本它理应归类到cobra的管控下，配置管理等等都应可控化

    在看这篇文章的你，可以试试将测试客户端归类好

    启动服务端

    回到grpc-hello-world/目录下，启动服务端go run main.go server，成功则仅返回

    1. 2018/02/26 17:19:36 gRPC and https listen on: 50052

    执行测试客户端

    回到client目录下，启动客户端go run client.go，成功则返回

    1. 2018/02/26 17:22:57 Grpc

    执行测试Restful Api

    1. curl -X POST -k https://localhost:50052/hello_world -d '{"referer": "restful_api"}'

    成功则返回{"message":"restful_api"}

    最终目录结构

    1. grpc-hello-world
    2. ├── certs
    3. │   ├── server.key
    4. │   └── server.pem
    5. ├── client
    6. │   └── client.go
    7. ├── cmd
    8. │   ├── root.go
    9. │   └── server.go
    10. ├── main.go
    11. ├── pkg
    12. │   └── util
    13. │       ├── grpc.go
    14. │       └── tls.go
    15. ├── proto
    16. │   ├── google
    17. │   │   └── api
    18. │   │       ├── annotations.pb.go
    19. │   │       ├── annotations.proto
    20. │   │       ├── http.pb.go
    21. │   │       └── http.proto
    22. │   ├── hello.pb.go
    23. │   ├── hello.pb.gw.go
    24. │   └── hello.proto
    25. └── server
    26.     ├── hello.go
    27.     └── server.go

    至此本节就结束了，推荐一下jergoo的文章，大家有时间可以看看

    另外本节涉及了许多组件间的知识，值得大家细细的回味，非常有意义！

    参考

    示例代码

    • grpc-hello-world