[TOC]

golang如何应用原生RPC及微服务简述

微服务

1. 微服务是什么

  • 应用一套小服务来开发单个利用的形式，每个服务运行在独立的过程里，个别采纳轻量级的通信机制互联，并且它们能够通过自动化的形式部署

微服务是设计思维，不是量的体现

  • 专一的性能
  • 代码量并不少
  • 架构变简单

2. 特点是啥

  • 专一的职责，例如专一于权限治理
  • 轻量级的通信，通信与平台和语言无关，例如http是轻量的
  • 隔离性，数据隔离
  • 有本人的数据
  • 技术多样

3. 微服务架构的劣势

  • 独立性
  • 使用者容易了解
  • 技术栈灵便
  • 高效团队

4. 微服务架构的有余

  • 额定的工作，服务的拆分
  • 保证数据一致性
  • 减少了沟通老本

微服务生态

1. 硬件层

  • 用docker+k8s去解决

2. 通信层

  • 网络传输，用RPC（近程过程调用）

    • HTTP传输，GET POST PUT DELETE
    • 基于TCP，更靠底层，RPC基于TCP，Dubbo（18年底改成反对各种语言），Grpc，Thrift

  • 须要晓得调用谁，用服务注册和发现

    • 须要分布式数据同步：etcd，consul，zk
  • 数据传递这外面可能是各种语言，各种技术，各种传递

数据传输协定选型倡议

1、对于公司间的零碎调用，如果性能要求在100ms以上的服务，基于XML的SOAP协定是一个值得思考的计划。

2、对于调试环境比拟顽劣的场景，采纳JSON或XML可能极大的进步调试效率，升高零碎开发成本。

3、当对性能和简洁性有极高要求的场景，Protobuf，Thrift，Avro之间具备肯定的竞争关系。

4、对于T级别的数据的长久化利用场景，Protobuf和Avro是首要抉择。如果长久化后的数据存储在Hadoop子项目里，Avro会是更好的抉择。

5、如果须要提供一个残缺的RPC解决方案，Thrift是一个好的抉择。

6、如果序列化之后须要反对不同的传输层协定，或者须要跨防火墙拜访的高性能场景，Protobuf能够优先思考。

RPC 机制和实现过程

1. RPC机制

服务间通过轻量级的近程过程调用，个别应用HTTP，RPC

  • HTTP调用应用层协定，构造绝对固定
  • RPC的网络协议就绝对灵便，并且能够定制

RPC近程过程调用，个别采纳C/S 模式，客户端服务器模式，客户端过程，调用服务端过程的程序，服务端过程执行后果返回给客户端，客户端从阻塞状态被唤醒，接收数据，提取数据。

上述过程中，客户端调用服务器的函数，来执行工作，它不晓得操作是在本地操作系统进行，还是通过近程过程调用进行的，全程无感。

RPC的根本通信如下：

RPC近程过程调用，须要思考的问题有如下四点：

  • 参数传递
  • 通信协议机制
  • 出错解决
  • 超时解决

2. 参数传递

  • 值传递

个别默认是值传递，只须要将参数中的值复制到网络音讯中的数据中即可

  • 援用传递

比拟艰难，单纯传递参数的援用是齐全没有用意义的，因为援用的地址给到远端的服务器，服务器上的该内存地址齐全不是客户端想要的数据，若非要这样解决，客户端还必须把数据的正本传递给到远端服务器，并将它们放到远端服务器内存中，服务器复制援用的地址后，即可进行数据的读取。

可是上述做法很麻烦，且很容易出错，个别RPC不反对间接传递援用

  • 数据格式对立问题

须要有一个规范来对所有数据类型进行编解码 ，数据格式能够有隐式类型和显式类型

  • 隐式类型

只传递值，不传递变量的名称或 类型

  • 显式类型

传递字段的类型和值

常见的传输数据格式有：

  • ISO规范的ASN.1
  • JSON
  • PROTOBUF
  • XML

3. 通信协议机制

狭义上的协定栈分为共有协定和公有协定

  • 共有协定

例如HTTP，SMPP，WEBSERVICE都是共有协定，领有通用型上，公网传输的能力上 有劣势

  • 公有协定

外部约定而成的协定，弊病多，然而能够高度的定制化，晋升性能，降低成本，进步灵活性和效率。企业外部往往采纳公有协定开发

对于协定的制订须要思考如下5个方面：

  • 协定设计

须要思考哪些问题

  • 公有协定的编解码

须要有业务针对性的编解码形式办法，如下有案例

  • 命令的定义和命令处理器的抉择

协定的过程个别会有2种

  1. 负载命令

传输业务具体的数据，如申请参数，响应后果的命令

  1. 管制命令

个别为性能治理命令，如心跳命令等

  • 命令的协定

个别是应用序列化协定，不同的协定在编码效率和传输效率上都不雷同，如

  • 通信模式
  1. oneway -- 不关怀响应，申请线程不会被阻塞
  2. sync -- 调用会被阻塞，晓得返回后果为止
  3. future -- 调用时不会阻塞县线程，获取后果的时候会阻塞线程
  4. callback -- 异步调用，不会阻塞线程

出错解决和超时解决

近程过程调用绝对本地过程调用出错的概率更大，因而须要思考到调用失败的各种场景：

  • 服务端出错，须要如何解决
  • 客户端申请服务时候呈现谬误或者超时，须要设置适合的重试机制

4. 繁难GO语言原生RPC

大略分为如下4个步骤：

  • 设计数据结构和办法
  • 实现办法
  • 注册服务

  • 客户端连贯服务端，调用服务端的办法

    往下看有golang如何应用原生rpc的案例

rpc调用和服务监控

  • RPC相干内容

    • 数据传输：JSON Protobuf thrift
    • 负载：随机算法 轮询 一致性hash 加权
    • 异样容错：衰弱检测 熔断 限流

  • 服务监控

    • 日志收集
    • 打点采样

1. RPC简介

  • 近程过程调用（Remote Procedure Call，RPC）是一个计算机通信协议
  • 该协定容许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额定地为这个交互作用编程
  • 如果波及的软件采纳面向对象编程，那么近程过程调用亦可称作近程调用或近程办法调用

2. RPC调用流程

个别状况下，咱们会将性能代码在本地间接调用，微服务架构下，咱们须要将这个函数作为独自的服务运行，客户端通过网络调用

  • 微服务架构下数据交互个别是对内 RPC，对外 REST

  • 将业务按功能模块拆分到各个微服务，具备如下长处

    • 进步我的项目合作效率
    • 升高模块耦合度
    • 进步零碎可用性

  • 有如下毛病：

    • 开发门槛比拟高，比方 RPC 框架的应用、前期的服务监控等工作

3.rpc golang 原生解决形式

最简略的golang原生rpc的应用

golang官网的net/rpc库应用encoding/gob进行编解码，反对tcp和http数据传输方式

server1.go

package mainimport (   "log"   "net/http"   "net/rpc")type Happy struct{}// 计算happyfunc (r *Happy) CalHappy(num int, ret *int) error {   *ret = num * 10   return nil}// 主函数func main() {   // new一个服务   ha := new(Happy)   // 注册一个Happy的服务   rpc.Register(ha)   // 服务解决绑定到http协定上   rpc.HandleHTTP()   // 监听服务   err := http.ListenAndServe(":9999", nil)   if err != nil {      log.Panicln(err)   }}

client1.go

package mainimport (   "fmt"   "log"   "net/rpc")// 主函数func main() {   //连贯近程rpc服务   conn, err := rpc.DialHTTP("tcp", ":9999")   if err != nil {      log.Fatal(err)   }   // 调用服务器办法   ret := 0   err2 := conn.Call("Happy.CalHappy", 10, &ret)   if err2 != nil {      log.Fatal(err2)   }   fmt.Println("开心指数：", ret)}

后果

golang应用jsonrpc

jsonrpc采纳JSON进行数据编解码，反对跨语言调用，jsonrpc库是基于tcp协定实现的，暂不反对http传输方式

server2.go

package mainimport (   "fmt"   "log"   "net"   "net/rpc"   "net/rpc/jsonrpc")type Happy struct{}// 计算happyfunc (r *Happy) CalHappy(num int, ret *int) error {   *ret = num * 10   return nil}// 主函数func main() {   // new一个服务   ha := new(Happy)   // 注册一个Happy的服务   rpc.Register(ha)   // 监听服务   listen, err := net.Listen("tcp", ":9999")   if err != nil {      log.Panicln(err)   }   // 解决申请   for {      con, err := listen.Accept()      if err != nil {         continue      }      // 专门开一个协程解决相应申请      go func(con net.Conn) {         fmt.Println("process new client")         jsonrpc.ServeConn(con)      }(con)   }}

client2.go

package mainimport (   "fmt"   "log"   "net/rpc/jsonrpc")// 主函数func main() {   //连贯近程rpc服务   conn, err := jsonrpc.Dial("tcp", ":9999")   if err != nil {      log.Fatal(err)   }   // 调用服务器办法   ret := 0   err2 := conn.Call("Happy.CalHappy", 10, &ret)   if err2 != nil {      log.Fatal(err2)   }   fmt.Println("开心指数：", ret)}

golang原生rpc自定义协定

例如咱们自定义协定，一段数据，前2个字节是数据头，前面的得为实在的数据，如：

  • 既然自定义了协定，那么咱们发送数据和读取数据的时候就须要恪守咱们的协定规定，否则会出问题
  • 那么咱们做数据传输的时候就会波及到编码和解码，咱们也须要本人封装好编码和解码的函数
写入数据和读取数据的函数封装
// 写入数据func MyWriteData(con net.Conn, data []byte) (int, error) {    if con == nil {        log.Fatal("con is nil")    }    buf := make([]byte, 2+len(data))    // 先写入头部,把实在数据的长度写到头外面    binary.BigEndian.PutUint16(buf[:2], uint16(len(data)))    // 再写入数据    copy(buf[2:], data)    n, err := con.Write(buf)    if err != nil {        log.Fatal("Write error", err)    }    return n, nil}//读取数据func MyReadData(con net.Conn) ([]byte, error) {    if con == nil {        log.Fatal("con is nil")    }    // 协定头2个字节    myheader := make([]byte, 2)    // 读取2个字节的协定头    _, err := io.ReadFull(con, myheader)    if err != nil {        log.Fatal("ReadFull error", err)    }    //读取实在数据    // 从头外面读取实在数据的长度    len := binary.BigEndian.Uint16(myheader)    data := make([]byte, len)    _, err = io.ReadFull(con, data)    if err != nil {        log.Fatal("ReadFull error", err)    }    return data, nil}
编写编码和解码的函数封装

咱们设计成字符串命令 与 具体调用的函数做绑定的形式，这样为接下来的server3.go rpc的实现，打好根底

// 具体的数据结构体type MyData struct {    Name   string    MyArgs []interface{} // 参数列表}// 加密func MyEncode(data *MyData) ([]byte, error) {    if data == nil {        log.Fatal("con is nil")    }    var bb bytes.Buffer    buf := gob.NewEncoder(&bb)    if err := buf.Encode(data); err != nil {        log.Fatal("Encode error ", err)    }    return bb.Bytes(), nil}// 解密func MyDecode(data []byte) (MyData, error) {    if data == nil {        log.Fatal("con is nil")    }    buf := bytes.NewBuffer(data)    myDe := gob.NewDecoder(buf)    var res MyData    if err := myDe.Decode(&res); err != nil {        log.Fatal("Decode error ", err)    }    return res, nil}
综合上述性能server端的实现 my_server.go：
package mainimport (    "bytes"    "encoding/binary"    "encoding/gob"    "fmt"    "io"    "log"    "net"    "reflect")// 写入数据func MyWriteData(con net.Conn, data []byte) (int, error) {    if con == nil {        log.Fatal("con is nil")    }    buf := make([]byte, 2+len(data))    // 先写入头部,把实在数据的长度写到头外面    binary.BigEndian.PutUint16(buf[:2], uint16(len(data)))    // 再写入数据    copy(buf[2:], data)    n, err := con.Write(buf)    if err != nil {        log.Fatal("Write error", err)    }    return n, nil}//读取数据func MyReadData(con net.Conn) ([]byte, error) {    if con == nil {        log.Fatal("con is nil")    }    // 协定头2个字节    myheader := make([]byte, 2)    // 读取2个字节的协定头    _, err := io.ReadFull(con, myheader)    if err != nil {        log.Fatal("ReadFull error", err)    }    //读取实在数据    // 从头外面读取实在数据的长度    len := binary.BigEndian.Uint16(myheader)    data := make([]byte, len)    _, err = io.ReadFull(con, data)    if err != nil {        log.Fatal("ReadFull error", err)    }    return data, nil}// 具体的数据结构体type MyData struct {    Name   string    MyArgs []interface{} // 参数列表}// 加密func MyEncode(data *MyData) ([]byte, error) {    if data == nil {        log.Fatal("con is nil")    }    var bb bytes.Buffer    buf := gob.NewEncoder(&bb)    if err := buf.Encode(data); err != nil {        log.Fatal("Encode error ", err)    }    return bb.Bytes(), nil}// 解密func MyDecode(data []byte) (MyData, error) {    if data == nil {        log.Fatal("con is nil")    }    buf := bytes.NewBuffer(data)    myDe := gob.NewDecoder(buf)    var res MyData    if err := myDe.Decode(&res); err != nil {        log.Fatal("Decode error ", err)    }    return res, nil}// 全局的一个map， 命令与函数做对应关系var myFun = make(map[string]reflect.Value)// 注册命令绑定函数func MyRegister(name string, fn interface{}) {    if _, ok := myFun[name]; ok { // 阐明该命令曾经绑定过函数        return    }    myFun[name] = reflect.ValueOf(fn)    log.Println("reflect.ValueOf(fn) == ", myFun[name])}// 服务端执行的办法func MyRun(addr string) {    listen, err := net.Listen("tcp", addr)    if err != nil {        log.Fatal("Listen is nil")    }    log.Println("启动服务端....")    // 开始阻塞期待客户端的连贯    for {        con, err := listen.Accept()        if err != nil {            log.Println("Accept is nil")            return        }        // 读取数据        b, err := MyReadData(con)        if err != nil {            log.Println("MyReadData error ", err)            return        }        log.Println("MyReadData =============== ")        // 解析数据        my, err := MyDecode(b)        if err != nil {            log.Println("MyDecode =============== ")            log.Println("MyDecode error ", err)            return        }        f, ok := myFun[my.Name]        if !ok {            fmt.Printf("命令 %s 没有绑定函数\n", my.Name)            return        }        // 获取参数        args := make([]reflect.Value, 0, len(my.MyArgs))        for _, arg := range my.MyArgs {            args = append(args, reflect.ValueOf(arg))            log.Println("reflect.ValueOf(arg) - ", reflect.ValueOf(arg))        }        //反射        res := f.Call(args)        log.Println("f.Call(args) == ", res)        // 包装后果数据给到客户端        out := make([]interface{}, 0, len(res))        for _, arg := range res {            log.Println("arg  == ", arg)            out = append(out, arg.Interface())        }        log.Println("out  == ", out)        // 编码数据        bb, err := MyEncode(&MyData{Name: my.Name, MyArgs: out})        if err != nil {            log.Println("MyEncode error ", err)            return        }        // 将数据写给客户端        _, err = MyWriteData(con, bb)        if err != nil {            log.Println("MyWriteData ======== ")            log.Println("MyWriteData error ", err)            return        }    }}// 客户端通过命令调用函数func CallRPCFun(con net.Conn, rpcName string, args interface{}) {    // 通过反射，获取args未初始化的函数原型    fn := reflect.ValueOf(args).Elem()    log.Println("fn == ", fn)    // 须要另一个函数，作用是对第一个函数参数操作    f := func(args []reflect.Value) []reflect.Value {        // 解决参数        inArgs := make([]interface{}, 0, len(args))        for _, arg := range args {            inArgs = append(inArgs, arg.Interface())        }        // 连贯        // 编码数据        reqRPC := &MyData{Name: rpcName, MyArgs: inArgs}        b, err := MyEncode(reqRPC)        if err != nil {            log.Println("MyEncode =============== ")            log.Println("MyEncode error ", err)        }        // 写数据        _, err = MyWriteData(con, b)        if err != nil {            log.Println("MyWriteData =============== ")            log.Fatal("MyWriteData error ", err)        }        // 服务端发过来返回值，此时应该读取和解析        respBytes, err := MyReadData(con)        if err != nil {            log.Fatal("MyReadData error ", err)        }        // 解码        res, err := MyDecode(respBytes)        if err != nil {            log.Println("MyDecode =============== ")            log.Fatal("MyDecode error ", err)        }        // 解决服务端返回的数据        outArgs := make([]reflect.Value, 0, len(res.MyArgs))        for i, arg := range res.MyArgs {            // 必须进行nil转换            if arg == nil {                // reflect.Zero()会返回类型的零值的value                // .out()会返回函数输入的参数类型                outArgs = append(outArgs, reflect.Zero(fn.Type().Out(i)))                continue            }            outArgs = append(outArgs, reflect.ValueOf(arg))        }        return outArgs    }    v := reflect.MakeFunc(fn.Type(), f)    // 为函数f赋值    fn.Set(v)}// 定义用户对象type Data struct {    CmdName string    Param   string}// 用于测试用户查问的办法func GetData(id int) (Data, error) {    data := make(map[int]Data)    // 假数据    data[0] = Data{"PullInfo", "xiaoxiong"}    data[1] = Data{"PutInfo", "daxiong"}    // 查问    if u, ok := data[id]; ok {        return u, nil    }    return Data{}, fmt.Errorf("%d err", id)}// 主函数func main() {    // 简略设置log参数    log.SetFlags(log.Lshortfile | log.LstdFlags)        // rpc 服务端    // 编码中有一个字段是interface{}时，进行注册    gob.Register(Data{})    addr := "127.0.0.1:9999"    // 创立服务端    // 将服务端办法，注册一下    MyRegister("GetData", GetData)    // 服务端期待调用    go MyRun(addr)        //-------------我是分割线-----------        // rpc客户端获取连贯    conn, err := net.Dial("tcp", addr)    if err != nil {        fmt.Println("Dial err")        return    }    log.Println("客户端拨号胜利了，开始调用函数了...")    // 创立客户端对象    // 须要申明函数原型    var getdata func(int) (Data, error)    CallRPCFun(conn, "GetData", &getdata)    // 失去查问后果    u, err := getdata(1)    if err != nil {        fmt.Println("getdata err")        return    }    log.Println(u)    select {}}

后果：

以上均为学习所得，若有偏误还请斧正

技术是凋谢的，咱们的心态也应如此。将来的路线上拥抱变动，怯懦前行。大家一起加油！

我是小魔童哪吒，欢送吐槽，欢送沟通