Go Micro（3）——开发微服务

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

什么是 Go Micro?

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

Go Micro 是：

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

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 接口

我们使用 protoc 和 proto-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() 来运行，这会让服务监听一个随机端口，这个调用也会让服务将自身注册到注册器，当服务停止运行时，会在注册器注销自己。

完整的服务端

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