1. RPC

1.1. RPC概念

RPC(Remote Procedure Call)，远程过程调用，即两个进程跨网络进行调用，就如同调用本地的方法一样，无须关注细节。RPC是一种服务端-客户端模式，大概流程如下：

  • 客户端stub（client stub）将这些参数包装，并通过系统调用发送到服务端机器。打包的过程叫 marshalling。（常见方式：XML、JSON、二进制编码）
  • 客户端本地操作系统发送信息至服务器。（可通过自定义TCP协议或HTTP传输）
  • 服务器系统将信息传送至服务端stub（server stub）。
  • 服务端stub（server stub）解析信息。该过程叫 unmarshalling。
  • 服务端stub（server stub）调用程序，并通过类似的方式返回给客户端。

    1.2. Golang RPC编码流程

    1.2.1. 常用方法

    ```go // 注册服务，name为服务的名，rcvr为结构体对象(通常为指针) func RegisterName(name string, rcvr interface{}) error // 处理客户端连接 func ServeConn(conn io.ReadWriteCloser)

// 连接服务端 func Dial(network, address string) (Client, error) // 调用服务端的方法 func (client Client) Call(serviceMethod string, args interface{}, reply interface{})

  1. <a name="OZeWL"></a>
  2. ### 1.2.2. 编码流程
  3. <a name="DvG9W"></a>
  4. ####  1.2.2.1. 一般流程
  6. - 服务端
  7. ```go
  8. //    1. 定义结构体
  9. type Server struct{}
  11. //     2. 定义对外的RPC方法：
  12. //         只能有两个参数，第一个是传入参数，第二个是传出参数，传出参数必须是指针
  13. //        只能有一个返回值，并且是 error
  14. //        方法必须是可以导出的
  15. func (s *Server) Handler(input,*output) error {}
  17. //  3. 注册RCP结构体
  18. err := rpc.RegisterName("pkg/server", new(Server))
  20. //  4.  监听端口
  21. Listner,err := net.Listen("tcp", "0.0.0.0:8080")
  23. //  5.  接收请求
  24. conn,err := server.Listener.Accept()
  26. //  6. 处理请求
  27. go rpc.ServeConn(conn)
  • 客户端 ```go // 1. 拨号 client, err := rpc.Dail(“tcp”,”127.0.0.1:8080)

// 2. 调用远程RCP接口 err := client.Call(“pkg/server.Handler”, &resp)

  1. <a name="oxXER"></a>
  2. #### 1.2.2.2. 规范RPC编码流程

基本定义

  1. 定义服务名称常量：通常为包路径.结构体名称
  2. 定义该服务接口：通过接口规范需要对外暴露的RPC方法列表
  3. 服务端定义注册RPC的结构体，参数类型为上述接口

接口实现

  1. 客户端和服务端同时定义和实现上述接口
  2. 客户端额外增加一个Close方法关闭RPC客户端 ```

    1.3. 案例

    1.3.1. 简单案例1

    ```go // server/server.go

package server

import ( “fmt” log “github.com/sirupsen/logrus” “net” “net/rpc” )

const ( HelloServiceMethodName = “rpc/server/HelloService” )

var ( Listener net.Listener )

// 定义结构体 type HelloService struct { }

// rcp 方法必须满足三个条件： // 1. 只能有两个可序列化的参数，第二个是指针。通过第二个参数(传出参数)获取返回结果 // 2. 方法的返回值有且只能有一个 error // 3. 方法必须是可以导出的 func (p HelloService) Hello( request string, reply string) error { *reply = fmt.Sprintf(“Hello %s !”, request) return nil }

func init() { // 注册RCP对象 err := rpc.RegisterName(HelloServiceMethodName, new(HelloService)) if err != nil { log.Fatalf(“register hello service failed,err:%s”,err.Error()) } // 启用监听 Listener, err = net.Listen(“tcp”, “0.0.0.0:55999”) if err != nil { log.Fatalf(“bind address 0.0.0.0:55999 failed,err:%s”,err.Error()) } }

  1. ```go
  2. // server.go
  4. package main
  6. import (
  7.     log "github.com/sirupsen/logrus"
  8.     "learn/network/rpc/server"
  9.     "net/rpc"
  10. )
  12. func main() {
  13.     for {
  14.         // 接收新的连接
  15.         conn, err := server.Listener.Accept()
  16.         if err != nil {
  17.             log.Errorf("accept new conn failed,err:%s", err.Error())
  18.         }
  19.         log.Infof("recv new conn:%s", conn.RemoteAddr().String())
  21.         go func() {
  22.             defer conn.Close()
  23.             rpc.ServeConn(conn)
  24.         }()
  25.     }
  26. }
  1. package main
  3. import (
  4.     "fmt"
  5.     log "github.com/sirupsen/logrus"
  6.     "net/rpc"
  7. )
  9. func main()  {
  10.     // 拨号连接 rpc 服务端
  11.     dial, err := rpc.Dial("tcp", "127.0.0.1:55999")
  12.     if err != nil {
  13.         log.Errorf("dial to address 127.0.0.1:55999 failed, err:%s", err.Error())
  14.         return
  15.     }
  16.     var resp string
  17.     // 远程调用服务端
  18.     err = dial.Call("rpc/server/HelloService.Hello", "张三", &resp)
  19.     if err != nil {
  20.         log.Errorf("call service failed, err:%s",err.Error())
  21.         return
  22.     }
  23.     fmt.Println(resp)
  24. }

1.3.2. 简单案例2

  1. // server.go
  3. package main
  5. import (
  6.     "context"
  7.     "errors"
  8.     "github.com/docker/docker/api/types"
  9.     "github.com/docker/docker/client"
  10.     log "github.com/sirupsen/logrus"
  11.     "net"
  12.     "net/rpc"
  13.     "strings"
  14. )
  16. var DockerClient *client.Client
  18. func GetDockerClient() (*client.Client, error) {
  19.     if DockerClient != nil {
  20.         return DockerClient, nil
  21.     }
  22.     return client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
  23. }
  25. type Image struct{}
  27. // 根据镜像的Id获取镜像Tag列表的方法
  28. func (i *Image) GetImageTag(id string, tags *[]string) error {
  29.     cli, err := GetDockerClient()
  30.     if err != nil {
  31.         log.Errorf("get docker client failed ,err:%s", err.Error())
  32.         return err
  33.     }
  35.     images, err := cli.ImageList(context.TODO(), types.ImageListOptions{})
  36.     if err != nil {
  37.         log.Errorf("list images failed ,err:%s", err.Error())
  38.         return err
  39.     }
  40.     for _, image := range images {
  41.         if strings.Contains(image.ID, id) {
  42.             *tags = image.RepoTags
  43.             return nil
  44.         }
  45.     }
  46.     return errors.New("the container id not found")
  47. }
  49. // 根据镜像id删除镜像
  50. func (i *Image) DeleteImage(id string, resp *[]string) error {
  51.     cli, err := GetDockerClient()
  52.     if err != nil {
  53.         log.Errorf("get docker client failed ,err:%s", err.Error())
  54.         return err
  55.     }
  56.     responseList, err := cli.ImageRemove(context.TODO(), id, types.ImageRemoveOptions{})
  57.     if err != nil {
  58.         log.Errorf("remove image failed,err:%s", err.Error())
  59.         return err
  60.     }
  61.     for _, response := range responseList {
  62.         if response.Untagged != "" {
  63.             *resp = append(*resp, response.Untagged)
  64.         }
  65.     }
  66.     return nil
  67. }
  69. func main() {
  70.     // 注册结rpc服务
  71.     err := rpc.RegisterName("container/image", &Image{})
  72.     if err != nil {
  73.         log.Fatalf("registry rpc service failed,err:%s", err.Error())
  74.     }
  75.     // 监听端口
  76.     listen, err := net.Listen("tcp", "0.0.0.0:8089")
  77.     if err != nil {
  78.         log.Fatalf("binding rpc service to 0.0.0.0:8089 failed,err:%s", err.Error())
  79.     }
  80.     for {
  81.         conn, err := listen.Accept()
  82.         if err != nil {
  83.             log.Errorf("accept connect failed,err:%s", err.Error())
  84.             continue
  85.         }
  86.         go func() {
  87.             rpc.ServeConn(conn)
  88.             _ = conn.Close()
  89.         }()
  90.     }
  91. }
  1. // client.go
  3. package main
  5. import (
  6.     "fmt"
  7.     log "github.com/sirupsen/logrus"
  8.     "net/rpc"
  9. )
  11. func main() {
  12.     dial, err := rpc.Dial("tcp", "127.0.0.1:8089")
  13.     if err != nil {
  14.         log.Errorf("connet to rpc server failed,err:%s", err.Error())
  15.         return
  16.     }
  18.     var resp []string
  19.     err = dial.Call("container/image.GetImageTag", "ed0e1d894299", &resp)
  20.     if err != nil {
  21.         log.Errorf("call container/image.GetImageTag failed,err:%s", err.Error())
  22.         return
  23.     }
  24.     fmt.Println(resp)
  25.     err = dial.Call("container/image.DeleteImage", "ed0e1d894299", &resp)
  26.     if err != nil {
  27.         log.Errorf("call container/image.DeleteImage failed,err:%s", err.Error())
  28.         return
  29.     }
  30.     fmt.Println(resp)
  31. }

1.3.3. 使用接口

在涉及RPC的应用中，作为开发人员一般至少有三种角色：首先是服务端实现RPC方法的开发人员，其次是客户端调用RPC方法的人员，最后也是最重要的是制定服务端和客户端RPC接口规范的设计人员。之前的两个案例中，并不规范，以下是一个比较规范的RPC开放方法：

  1. // server.go
  2. package main
  4. import (
  5.     "context"
  6.     "errors"
  7.     "github.com/docker/docker/api/types"
  8.     "github.com/docker/docker/client"
  9.     log "github.com/sirupsen/logrus"
  10.     "net"
  11.     "net/rpc"
  12.     "strings"
  13. )
  15. var DockerClient *client.Client
  17. func GetDockerClient() (*client.Client, error) {
  18.     if DockerClient != nil {
  19.         return DockerClient, nil
  20.     }
  21.     return client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
  22. }
  24. // 定义服务名称常量；通常为路径格式，避免重名
  25. const ImageServiceName = "rpc/server/pkg.ImageService"
  27. // 定义对外暴露的RPC方法
  28. type ImageServiceInterface interface {
  29.     GetImageTag(id string, reply *[]string) error
  30.     DeleteImage(id string, reply *[]string) error
  31. }
  33. // 注册RPC方法
  34. func ImageServiceRegistry(svc ImageServiceInterface) error {
  35.     return rpc.RegisterName(ImageServiceName, svc)
  36. }
  38. // 定义RPC的服务结构体
  39. type Image struct{}
  41. // 定义RPC服务的方法
  42. // 根据镜像的Id获取镜像Tag列表的方法
  43. func (i *Image) GetImageTag(id string, tags *[]string) error {
  44.     cli, err := GetDockerClient()
  45.     if err != nil {
  46.         log.Errorf("get docker client failed ,err:%s", err.Error())
  47.         return err
  48.     }
  50.     images, err := cli.ImageList(context.TODO(), types.ImageListOptions{})
  51.     if err != nil {
  52.         log.Errorf("list images failed ,err:%s", err.Error())
  53.         return err
  54.     }
  55.     for _, image := range images {
  56.         if strings.Contains(image.ID, id) {
  57.             *tags = image.RepoTags
  58.             return nil
  59.         }
  60.     }
  61.     return errors.New("the container id not found")
  62. }
  64. // 定义RPC服务的方法
  65. // 根据镜像id删除镜像
  66. func (i *Image) DeleteImage(id string, tags *[]string) error {
  67.     cli, err := GetDockerClient()
  68.     if err != nil {
  69.         log.Errorf("get docker client failed ,err:%s", err.Error())
  70.         return err
  71.     }
  72.     responseList, err := cli.ImageRemove(context.TODO(), id, types.ImageRemoveOptions{})
  73.     if err != nil {
  74.         log.Errorf("remove image failed,err:%s", err.Error())
  75.         return err
  76.     }
  77.     for _, response := range responseList {
  78.         if response.Untagged != "" {
  79.             *tags = append(*tags, response.Untagged)
  80.         }
  81.     }
  82.     return nil
  83. }
  86. func main() {
  87.     // 注册结rpc服务
  88.     err := ImageServiceRegistry(new(Image))
  89.     if err != nil {
  90.         log.Errorf("registry ImageService failed,err:%s", err.Error())
  91.         return
  92.     }
  93.     // 监听端口
  94.     listen, err := net.Listen("tcp", "0.0.0.0:8089")
  95.     if err != nil {
  96.         log.Fatalf("binding rpc service to 0.0.0.0:8089 failed,err:%s", err.Error())
  97.     }
  98.     for {
  99.         conn, err := listen.Accept()
  100.         if err != nil {
  101.             log.Errorf("accept connect failed,err:%s", err.Error())
  102.             continue
  103.         }
  104.         go func() {
  105.             rpc.ServeConn(conn)
  106.             _ = conn.Close()
  107.         }()
  108.     }
  109. }
  1. // client.go
  3. package main
  5. import (
  6.     "fmt"
  7.     log "github.com/sirupsen/logrus"
  8.     "net/rpc"
  9. )
  11. // 定义服务名称常量；通常为路径格式，避免重名
  12. const imageServiceName = "rpc/server/pkg.ImageService"
  14. // 定义对外暴露的RPC方法
  15. type ImageServiceInterface interface {
  16.     GetImageTag(id string, reply *[]string) error
  17.     DeleteImage(id string, reply *[]string) error
  18.     Close()
  19. }
  21. // 定义服务结构体
  22. type ImageClient struct {
  23.     Name   string
  24.     Address string
  25.     client *rpc.Client
  26. }
  28. func ImageDail(address string) (ImageServiceInterface, error) {
  29.     c, err := rpc.Dial("tcp", address)
  30.     if err != nil {
  31.         return nil, err
  32.     }
  33.     return &ImageClient{Name: imageServiceName, Address: address, client: c}, nil
  34. }
  36. func (i *ImageClient) GetImageTag(id string, tags *[]string) error {
  37.     return i.client.Call(i.Name+".GetImageTag",id, tags)
  38. }
  40. func (i *ImageClient) DeleteImage(id string, tags *[]string) error  {
  41.     return i.client.Call(i.Name+".DeleteImage", id , tags)
  42. }
  44. func (i *ImageClient) Close () {
  45.     _ = i.client.Close()
  46. }
  48. func main() {
  49.     client, err := ImageDail("127.0.0.1:8089")
  50.     if err != nil {
  51.         log.Errorf("connet to rpc server failed,err:%s", err.Error())
  52.         return
  53.     }
  54.     var resp []string
  55.     err = client.GetImageTag("a9d583973f65", &resp)
  56.     if err != nil {
  57.         log.Errorf("ImageClient call GetImageTag failed,err:%s", err.Error())
  58.         return
  59.     }
  60.     fmt.Println(resp)
  61.     err = client.DeleteImage("a9d583973f65", &resp)
  62.     if err != nil {
  63.         log.Errorf("ImageClient call DeleteImage failed,err:%s", err.Error())
  64.         return
  65.     }
  66.     fmt.Println(resp)
  67.     client.Close()
  68. }

2. GRPC

2.1. 介绍

在Golang RPC中，存在一个文件，就是只能在golang语言项目之间调用，无法跨语言。在企业中，不同的组件可能会使用不同的语言进行项目开发，不同语言项目之间使用RPC调用，一般推荐使用GRPC。
GRPC 是一种现代化开源的高性能RPC框架，能够运行于任意环境之中。最初由谷歌进行开发。它使用HTTP/2作为传输协议。

2.2. protocol buffers

Protocol buffers是一种轻便高效的结构化数据存储方式，可以用于数据序列化，非常适合RPC通信中数据序列化，GRPC 是的数据序列化是通过protocol buffers实现的。

  • 优势：
    • 序列化后体积比Json小，适合网络传输
    • 与语言无关，即跨语言、跨平台
    • 消息序列化和反序列化速度快

  • 劣势：

    • 应用范围不广，最常见的是用于gRPC通信

      2.2.1. 基本语法

      2.2.1.1. 规则

  • 文件以 .proto 结尾，除了 { } 结构和rpc方法定义末尾除外的语句都是以分号结尾

  • 结构定义可以包含: message, service, enum
  • Message类型名称用驼峰式命名，字段采用下划线命名
  • Enum类型名称采用驼峰式命名，字段采用大写下划线命名
  • Service方法名采用驼峰式命名

    2.2.2. 命令行操作

    ```

go get google.golang.org/grpc/cmd/protoc-gen-go-grpc

  1. ```
  2. // 不带 -I 会在services下创建 pbfiles目录
  3. // --go_out会在指定目录下创建结构体
  4. // --go-grpc_out 会创建服务相关的rpc方法
  5. protoc -I=pbfiles --go_out=services --go-grpc_out=services pbfiles/prod.proto

2.3. GRPC操作