微服务已经 hot 了一段时间,自己作为 web 开发人员当然也不由自主想研究研究微服务,不过微服务的整个知识体系过于庞大,要掌握的概念和技术太多,一时有点吃不消。个人为了生计又没有大块时间去搞。不过还是难舍微服务,最近学习了 go 语言,想一块一块地吃掉微服务,先从 go 和容器入手。
我们知道微服务之间是需要相互调用和通讯的,一般会采用 RPC 来实现不同语言不用服务间的调用和通讯。那么我就先从 RPC 入手来学习微服务。
RPC 框架的特点
所谓的特点就是他能够满足那些需求,RPC 框架要实现以上目的需要满足以下需求
序列化(GOB)语言单一
上下文管理(超时控制)
拦截器(鉴权、统计和限流)
跨语言
服务注册
Call ID:由于客户端和服务端运行在不同进程,为了让客户端和服务端都了解调用了哪个函数,需要在两端维护一个函数到Call ID 的映射表,客户端根据表获取函数的 Call ID,发起请求,服务端根据 Call ID 来执行对应的函数,返回值给客户端。
序列化和反序列化:在本地调用时候函数是从栈中获取参数运行函数。而远程调用时候,如果需要在不同语言间相互调用函数,需要将参数进行序列化然后以字节流方式传递给服务端,服务端在反序列化来得到参数
网络传输:客户端和服务端间的调用往往是通过网络完成。只要能传递数据就行,与协议无关,可以使用 TCP 或 UDP。gRcp 使用的 HTTP2 。
什么是 RPC
RPC是指远程过程调用,也就是说两台服务器A,B,一个应用部署在A服务器上,想要调用B服务器上应用提供的函数/方法,由于不在一个内存空间,不能直接调用,需要通过网络来表达调用的语义和传达调用的数据。
为什么需要 RPC 呢
因为 RPC 是分布式系统中不同节点间流行的通讯方式,在互联网时代,RPC 和 IPC 一样成为不可或缺的基础构建。在 Go 语言的标准库也提供了简单的 RPC 的实现。
RPC 在服务间调用流程
我们通过上面图来看,这个流程比较清晰,也不难理解。
- 调用客户端句柄,执行传送参数
- 调用本地系统内核发送网络消息
- 消息传送至远程机器
- 服务器句柄得到消息并取得参数
- 执行远程过程
- 执行过程将结果返回给服务器句柄
- 服务器句柄返回结果,调用远程系统内核
- 消息传回本地主机
- 客户句柄由内核接收消息
- 客户接收句柄返回的数据
有了上面理论基础,我们基于理论来实现。
type RPCService struct{}
创建一个RPCService
服务,随后将其进行注册
func (s *RPCService) Hello(request string, reply *string) error{
*reply = "Hello " + request
return nil
}
- 函数必须是外部可以访问函数,函数名需要首字母大写
- 函数需要有两个参数
- 第一个参数接收的参数
- 第二个参数是返回给客户端的参数,而且需要是指针类型
- 函数还需要有一个 error 返回值
rpc.RegisterName("RPCService",new(RPCService))
注册rpc服务
listener, err := net.Listen("tcp",":1234")
创建 tcp 服务端口号为 1234 用于 rpc 服务。
conn, err := listener.Accept()
if err != nil{
log.Fatal("Accept error:", err)
}
rpc.ServeConn(conn)
服务端完整代码
package main
import(
// "fmt"
"log"
"net"
"net/rpc"
)
type RPCService struct{}
func (s *RPCService) Hello(request string, reply *string) error{
*reply = "Hello " + request
return nil
}
func main() {
rpc.RegisterName("RPCService",new(RPCService))
listener, err := net.Listen("tcp",":1234")
if err != nil{
log.Fatal("ListenTCP error:",err)
}
conn, err := listener.Accept()
if err != nil{
log.Fatal("Accept error:", err)
}
rpc.ServeConn(conn)
}
客户端代码
client, err := rpc.Dial("tcp","localhost:1234")
客户端调用 RPC 服务,然后通过client.Call调用具体的RPC方法。
err = client.Call("RPCService.Hello","World",&reply)
在调用client.Call时,第一个参数是用点号链接的RPC服务名字和方法名字,第二和第三个参数分别我们定义RPC方法的两个参数。
package main
import(
"fmt"
"log"
"net/rpc"
)
func main() {
client, err := rpc.Dial("tcp","localhost:1234")
if err != nil{
log.Fatal("dialing:", err)
}
var reply string
err = client.Call("RPCService.Hello","World",&reply)
if err != nil{
log.Fatal("call Hello method of RPCService:",err)
}
fmt.Println(reply)
}
我们先后启动服务端和客户端就可以看到下面效果
Hello World
下面更加贴近实际来写一个基于 HTTP 的 RPC 服务,服务提供两个数四则运算。
rpcService := new(RPCService)
rpc.Register(rpcService)
rpc.HandleHTTP()
这里的注册方式略有不同,但是大同小异相信大家一看就懂。
服务端完整代码
package main
import(
"errors"
"fmt"
"net/http"
"net/rpc"
)
type Args struct{
A, B int
}
type Quotient struct{
Quo, Rem int
}
type RPCService int
func (t *RPCService) Add(args *Args, reply *int) error{
*reply = args.A - args.B
return nil
}
func (t *RPCService) Multiply(args *Args, reply *int) error{
*reply = args.A * args.B
return nil
}
func (t *RPCService) Divide(args *Args, quo *Quotient) error{
if args.B == 0{
return errors.New("divide by zero")
}
quo.Quo = args.A / args.B
quo.Rem = args.A % args.B
return nil
}
func main() {
rpcService := new(RPCService)
rpc.Register(rpcService)
rpc.HandleHTTP()
err := http.ListenAndServe(":1234",nil)
if err != nil{
fmt.Println(err.Error())
}
}
package main
import(
"fmt"
"log"
"net/rpc"
"os"
)
type Args struct{
A, B int
}
type Quotient struct{
Quo, Rem int
}
func main() {
if len(os.Args) != 2{
fmt.Println("Usage: ", os.Args[0],"server")
os.Exit(1)
}
serverAddress := os.Args[1]
client, err := rpc.DialHTTP("tcp",serverAddress + ":1234")
if err != nil {
log.Fatal("dialing: ", err)
}
args := Args{17, 8}
var reply int
err = client.Call("RPCService.Add",args, &reply)
if err != nil{
log.Fatal("RPCService error: ", err)
}
fmt.Printf("RPCService: %d + %d = %d\n", args.A, args.B, &reply)
var quot Quotient
err = client.Call("RPCService.Divide",args, ")
if err != nil{
log.Fatal("RPCService error: ",err)
}
fmt.Printf("RPCService: %d/%d=%d remainder %d\n",args.A, args.B, quot.Quo,quot.Rem)
}
RPCService: 17 + 8 = 824634312296
RPCService: 17/8=2 remainder 1
其实在实际开发中我们还需要对其进行改造,例如让 rpc 请求可以获得一个 context 对象,其中包含用户信息等,然后可以对 rpc 进行超时处理。
JSONRPC
Go语言内置的 RPC 框架已经支持在 Http 协议上提供 RPC 服务。但是 Http 服务内置采用了 GOB 协议。编码不是 JSON 编码,不方便其他语言调用。不过 go 提供 JsonRPC 的 RPC 服务支持,我们来看一看怎么用代码实现。
服务端代码
package main
import(
"errors"
"fmt"
"net"
"net/rpc"
"net/rpc/jsonrpc"
// "os"
)
type Args struct{
A, B int
}
type Quotient struct{
Quo, Rem int
}
type RPCService int
func (t *RPCService) Multiply(args *Args, reply *int) error{
*reply = args.A * args.B
return nil
}
func (t *RPCService) Divide(args *Args, quo *Quotient) error{
if args.B == 0{
return errors.New("divide by zero")
}
quo.Quo = args.A / args.B
quo.Rem = args.A % args.B
return nil
}
func main() {
rpcService := new(RPCService)
rpc.Register(rpcService)
tcpAddr, err := net.ResolveTCPAddr("tcp",":1234")
checkError(err)
listener, err := net.ListenTCP("tcp",tcpAddr)
checkError(err)
for{
conn, err := listener.Accept()
if err != nil{
continue
}
jsonrpc.ServeConn(conn)
}
}
func checkError(err error){
if err != nil{
fmt.Println("Fatal error ", err.Error())
}
}
客户端代码
package main
import(
"fmt"
"log"
"net/rpc/jsonrpc"
"os"
)
type Args struct{
A, B int
}
type Quotient struct{
Quo, Rem int
}
func main() {
if len(os.Args) != 2{
fmt.Println("Usage: ", os.Args[0],"server")
log.Fatal(1)
}
serverAddress := os.Args[1]
client, err := jsonrpc.Dial("tcp",serverAddress + ":1234")
if err != nil {
log.Fatal("dialing: ", err)
}
args := Args{17, 8}
var quot Quotient
err = client.Call("RPCService.Divide",args, ")
if err != nil{
log.Fatal("RPCService error: ",err)
}
fmt.Printf("RPCService: %d/%d=%d remainder %d\n",args.A, args.B, quot.Quo,quot.Rem)
}