使用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接口是构建服务的主要组件。它把底层的各个包需要实现的接口,做了一次封装。

type Service interface {
    Init(...Option)
    Options() Options
    Client() client.Client
    Server() server.Server
    Run() error
    String() string
}

初始化

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

import "github.com/micro/go-micro"

service := micro.NewService()

参数可以在创建时传入

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

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

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

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解决

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

syntax = "proto3";

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

message HelloRequest {
	string name = 1;
}

message HelloResponse {
	string greeting = 2;
}

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

生成API接口

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

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

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

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是一个这样的方法:

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

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

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

这里是一个Greeter的handler实现

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需要注册到某个服务

service := micro.NewService(
	micro.Name("greeter"),
)

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

运行服务

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

完整的服务端

greeter.go

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 包用于向服务端发起请求,当你创建一个服务,客户端可以调用的接口已经自动生成了

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

/ 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社区在这里