使用Go Micro编写微服务

发表于 | 分类于 | 评论数：

这是一系列介绍Micro框架的文章的第三篇，我将会把作者的博客翻译成中文，推广Micro这个微服务框架。

这是一个高等级的说明：怎样使用go-micro来编写微服务，如果你想学习更多微服务的知识以及Micro的整体架构，参考以前的文章。

什么是Go Micro?

Go Micro是一个插件化的基础框架，基于此可以构建微服务。Micro的设计哲学是『可插拔』的插件化架构。在架构之外，它默认实现了consul作为服务发现，通过http进行通信，通过protobuf和json进行编解码。我们一步步深入下去。

Go Micro是：

  1. 一个用Golang编写的包
  2. 一系列插件化的接口定义
  3. 基于RPC

Go Micro为下面的模块定义了接口：

  1. 服务发现
  2. 编解码
  3. 服务端、客户端
  4. 订阅、发布消息

更详细的说明可以在这里看到。

为什么是Go Micro?

Go Micro从一年多以前开始开发，最初只是个人需求，很快我发现这对那些编写微服务的程序员会有很大的价值。它基于我在不同的技术公司如google和hailo的开发经验编写而成。

就像前面提到的，Go Micro是一个golang编写的插件化架构，专注于提供底层的接口定义和基础工具。这些接口可以接纳各种实现。比如 Registry接口定义了服务发现的接口，默认采用了consul作为服务发现的实现，但也可以采用其他实现比如etcd和zookeeper等，只要能满足接口，就可以使用。

插件化的架构意味着如果你想替换底层的实现，你不需要修改任何底层的代码。

编写一个服务

如果你想直接看代码，看这里：examples/service

顶层的Service接口是构建服务的主要组件。它把底层的各个包需要实现的接口，做了一次封装。

1
2
3
4
5
6
7
8
type Service interface {
    Init(...Option)
    Options() Options
    Client() client.Client
    Server() server.Server
    Run() error
    String() string
}

初始化

一个服务可以这样创建micro.NewService

1
2
3
import "github.com/micro/go-micro"

service := micro.NewService()

参数可以在创建时传入

1
2
3
4
service := micro.NewService(
	micro.Name("greeter"),
	micro.Version("latest"),
)

所有可选的参数设置可以在这里看到

Go Micro也提供了读取命令行的方式

1
2
3
4
5
6
7
8
9
10
11
12
13
import (
	"github.com/micro/cli"
	"github.com/micro/go-micro"
)

service := micro.NewService(
	micro.Flags(
		cli.StringFlag{
			Name:  "environment",
			Usage: "The environment",
		},
	)
)

通过 service.Init来解析参数，附加的处理可以通过micro.Action解决

1
2
3
4
5
6
7
8
service.Init(
	micro.Action(func(c *cli.Context) {
		env := c.StringFlag("environment")
		if len(env) > 0 {
			fmt.Println("Environment set to", env)
		}
	}),
)

Go Micro提供了提供了预定义的参数，也会被service.Init解析，这里可以看到所有的flag

定义API

我们使用protobuf文件来定义服务的API，这是一种方便且严格的定义方式，协议将会提供给服务端和客户端。下面是一个协议的例子：greeter.proto

1
2
3
4
5
6
7
8
9
10
11
12
13
syntax = "proto3";

service Greeter {
	rpc Hello(HelloRequest) returns (HelloResponse) {}
}

message HelloRequest {
	string name = 1;
}

message HelloResponse {
	string greeting = 2;
}

这里定义了一个服务叫做Greeter，它提供一个接口叫Hello，它接受HelloRequest的请求，返回HelloResponse。

生成API接口

我们使用protoc和proto-gen-go这两个工具来生成代码，Go Micro也会生成客户端代码，减少工作量，这里需要使用我们fork并修改过的github.com/micro/protobuf，与原始版本的区别是，fork版本能生成客户端代码

1
2
go get github.com/micro/protobuf/{proto,protoc-gen-go}
protoc --go_out=plugins=micro:. greeter.proto

生成的代码可以在handler中引用相应的包进行使用，下面是生成的一部分代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
type HelloRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}

type HelloResponse struct {
	Greeting string `protobuf:"bytes,2,opt,name=greeting" json:"greeting,omitempty"`
}

// Client API for Greeter service

type GreeterClient interface {
	Hello(ctx context.Context, in *HelloRequest, opts ...client.CallOption) (*HelloResponse, error)
}


type greeterClient struct {
	c           client.Client
	serviceName string
}

func NewGreeterClient(serviceName string, c client.Client) GreeterClient {
	if c == nil {
		c = client.NewClient()
	}
	if len(serviceName) == 0 {
		serviceName = "greeter"
	}
	return &greeterClient{
		c:           c,
		serviceName: serviceName,
	}
}

func (c *greeterClient) Hello(ctx context.Context, in *HelloRequest, opts ...client.CallOption) (*HelloResponse, error) {
	req := c.c.NewRequest(c.serviceName, "Greeter.Hello", in)
	out := new(HelloResponse)
	err := c.c.Call(ctx, req, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Greeter service

type GreeterHandler interface {
	Hello(context.Context, *HelloRequest, *HelloResponse) error
}

func RegisterGreeterHandler(s server.Server, hdlr GreeterHandler) {
	s.Handle(s.NewHandler(&Greeter{hdlr}))
}

实现handler

服务端需要注册handler来处理请求，一个handler是一个这样的方法：

1
func(ctx context.Context, req interface{}, rsp interface{}) error

正如上面看到的，一个handler实现了API协议中定义的接口

1
2
3
type GreeterHandler interface {
        Hello(context.Context, *HelloRequest, *HelloResponse) error
}

这里是一个Greeter的handler实现

1
2
3
4
5
6
7
8
import proto "github.com/micro/micro/examples/service/proto"

type Greeter struct{}

func (g *Greeter) Hello(ctx context.Context, req *proto.HelloRequest, rsp *proto.HelloResponse) error {
	rsp.Greeting = "Hello " + req.Name
	return nil
}

handler需要注册到某个服务

1
2
3
4
5
service := micro.NewService(
	micro.Name("greeter"),
)

proto.RegisterGreeterHandler(service.Server(), new(Greeter))

运行服务

服务可以直接调用server.Run()来运行，这会让服务监听一个随机端口，这个调用也会让服务将自身注册到注册器，当服务停止运行时，会在注册器注销自己。

完整的服务端

greeter.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package main

import (
        "log"

        "github.com/micro/go-micro"
        proto "github.com/micro/go-micro/examples/service/proto"

        "golang.org/x/net/context"
)

type Greeter struct{}

func (g *Greeter) Hello(ctx context.Context, req *proto.HelloRequest, rsp *proto.HelloResponse) error {
        rsp.Greeting = "Hello " + req.Name
        return nil
}

func main() {
        service := micro.NewService(
                micro.Name("greeter"),
                micro.Version("latest"),
        )

        service.Init()

        proto.RegisterGreeterHandler(service.Server(), new(Greeter))

        if err := service.Run(); err != nil {
                log.Fatal(err)
        }
}

注意，服务发现机制需要首先运行起来，这样服务才能注册到注册器中，才能被客户端发现，这里有一个简单的介绍。

编写客户端

client 包用于向服务端发起请求，当你创建一个服务，客户端可以调用的接口已经自动生成了

调用上面的服务可以用下面的客户端代码

1
2
3
4
5
6
7
8
9
10
11
12
13
/ create the greeter client using the service name and client
greeter := proto.NewGreeterClient("greeter", service.Client())

// request the Hello method on the Greeter handler
rsp, err := greeter.Hello(context.TODO(), &proto.HelloRequest{
	Name: "John",
})
if err != nil {
	fmt.Println(err)
	return
}

fmt.Println(rsp.Greeter)

proto.NewGreeterClient就是我们刚才生成的代码，根据服务名称发送请求。

完整的示例可以在这里看到：go-micro/examples/service

总结

这篇文章是一个高等级的使用说明，介绍了怎样编写客户端和服务端代码，你可以在这里看到更多示例代码：github.com/micro

如果你想了解更多，请看这个blog，或者这个repo，Twitter可以关注@MicroHQ，Slack社区在这里

相关文章