一. Kratos 简介
Kratos 是 B 站基于 Golang 实现的一个开源的面向微服务的框架. 使用 Kratos 可以很方便地构建一个规范的服务.
开源 GitHub 地址: https://github.com/go-kratos/kratos
文档地址: https://go-kratos.dev/docs/
二. Kratos 特点
- 简单易用
- 高效
- 稳定
- 高性能
- 可扩展
- 容错性好
- 丰富的工具链
以上特点, 还都是从 Readme 文档翻译出来的, 后面将逐一验证和体验.
三. Kratos 实现一个 Helloworld
安装
go get github.com/go-kratos/kratos/cmd/kratos/v2@latest
根据文档
# create project template
kratos new helloworld
cd helloworld
# download modules
go mod download
# generate Proto template
kratos proto add api/helloworld/helloworld.proto
# generate Proto source code
kratos proto client api/helloworld/helloworld.proto
# generate server template
kratos proto server api/helloworld/helloworld.proto -t internal/service
# generate all proto source code, wire, etc.
go generate ./...
编译并执行
mkdir bin
# compile
go build -o ./bin/ ./...
# run
./bin/helloworld -conf ./configs
就以上这么一顿操作, 就一起完成一个服务的构建.
四. 目录结构分析
tree -d 查看目录结构
.
├── api
│ └── helloworld
│ └── v1
├── cmd
│ └── helloworld
├── configs
└── internal
├── biz
├── conf
├── data
├── server
└── service
1. /api
这个文件夹下面, 包含 proto 文件和编译 proto 文件生成的 go 文件.
之所以把目录命名为 api, 是因为可以把 proto 当作 api 文档, 生成的 go 文件就相当于 api.
2. /cmd
这个文件夹下的代码, 主要负责程序的启动、关闭、配置初始化等.
cmd 大概率是 command 的缩写, 下面的文件夹是一个 helloworld 应用并且包含 main.go文件.
在执行 go build 的时候, 就会以文件夹的名称来命名应用.
一般不建议在 /cmd 这个文件夹下放置过多的代码和文件夹.
如果代码不是可重用的, 或者你不希望其他人重用它, 请将该代码放到 /internal 目录中.
3. /configs
放置配置文件模板, 或默认配置, 一般是 yaml 文件.
比如注册的服务的地址, 各种数据库的连接配置等.
4. /internal
这个文件夹下面, 一般都放置不希望作为第三包给他人使用的, 即是当作私有库.
-
/biz目录: 业务逻辑的组装层, 类似于 DDD (领域驱动设计) 的 domain 层. -
/conf目录: 这里会有 proto 文件和编译 proto 得到的 go 代码, 而且 proto 会与上面的/configs下的 yaml 文件对应. -
/data目录: 业务数据访问, 包含 cache、db 等封装, 实现了 biz 的 repo 接口. 类似于 DDD 的 repo. -
/server目录: gRPC 和 HTTP 服务的注册. -
/service目录: 这里是实现上层的/api的 interface. 类似于 DDD 的 application 层.
更多参考: https://github.com/golang-standards/project-layout/blob/master/README_zh.md
五. 关键代码分析
helloworld/cmd/helloworld/main.go
func main() {
flag.Parse()
logger := log.NewStdLogger(os.Stdout)
c := config.New(
config.WithSource(
file.NewSource(flagconf),
),
config.WithDecoder(func(kv *config.KeyValue, v map[string]interface{}) error {
return yaml.Unmarshal(kv.Value, v)
}),
)
if err := c.Load(); err != nil {
panic(err)
}
var bc conf.Bootstrap
if err := c.Scan(&bc); err != nil {
panic(err)
}
app, cleanup, err := initApp(bc.Server, bc.Data, logger)
if err != nil {
panic(err)
}
defer cleanup()
// start and wait for stop signal
if err := app.Run(); err != nil {
panic(err)
}
}
这里使用 "github.com/go-kratos/kratos/v2/config" 这个包, 它的作用是将解析 /configs/config.yaml 文件解析为 protobuf, 内部隐藏的操作是, 将 yaml 文件转为 json, 然后再转为 protobuf.
六. 结合 Kratos 实现 gRPC 客户端
想法: 前面学习了 gRPC, 这里学习了 Kratos, 而 Kratos 里也有 gRPC, 已经实现了 gRPC 的服务端. 所以, 不如结合 Kratos 实现一个 gRPC 客户端, 以作 Kratos 实战.
根据上面的目录结构分析, 客户端的实现逻辑代码, 应当放在 /internal/client 文件夹下.
另外 main.go 文件, 应该放在 /cmd/helloworld_client 文件夹下.
如果先前没有的文件夹则创建.
以下主要结合了 Kratos 的 log 和 config 两个工具, 以及 wire (github.com/google/wire).
1./internal/client/grpc.go
为了使用 wire , 在 NewGrpcClient 函数的返回值的第二个参数, 必须是 func() 类型, 用于 cleanup.
NewGrpcClient 函数主要有两步, 第一步是建立 gRPC 服务连接并连接 greeter RPC, 第二步是 cleanup 处理.
GrpcClient 结构体主要是实现 RPC 的通信.
package client
import (
"context"
"time"
"helloworld/internal/conf"
"google.golang.org/grpc"
"github.com/go-kratos/kratos/v2/log"
v1 "helloworld/api/helloworld/v1"
"github.com/pkg/errors"
)
type GrpcClient struct {
logger *log.Helper
cli v1.GreeterClient
}
func (gc *GrpcClient) DoSay(name string) error {
ctx, cancel := context.WithTimeout(context.Background(), time.Second*3)
defer cancel()
reply, err := gc.cli.SayHello(ctx, &v1.HelloRequest{Name: name})
if err != nil {
return errors.Wrap(err, "could not greet")
}
gc.logger.Infof("Greeting: %s", reply.GetMessage())
return nil
}
func NewGrpcClient(confServer *conf.Server, logger log.Logger) (*GrpcClient, func(), error) {
addr := confServer.Grpc.Addr
conn, err := grpc.Dial(addr, grpc.WithInsecure(), grpc.WithBlock())
if err != nil {
return nil, nil, errors.Wrap(err, "did not dail gRPC server")
}
gc := &GrpcClient{
logger: log.NewHelper("client/greeter", logger),
cli: v1.NewGreeterClient(conn),
}
cleanup := func() {
if err := conn.Close(); err != nil {
gc.logger.Errorf("hanppend a little wrongs when close gRPC server:\n %v", err)
}
}
return gc, cleanup, nil
}
2./internal/client/client.go
wire.NewSet 可以放多个函数, 不分顺序.
package client
import "github.com/google/wire"
var ProviderSet = wire.NewSet(NewGrpcClient)
3./cmd/helloworld_client/wire.go
这个文件主要是通过 wire 命令来生成 wire_gen.go, 关键函数是 wire.Build , 同时不要删掉这行代码 //+build wireinject .
//+build wireinject
package main
import (
"helloworld/internal/client"
"helloworld/internal/conf"
"github.com/go-kratos/kratos/v2/log"
"github.com/google/wire"
)
func initClient(confServer *conf.Server, logger log.Logger) (*client.GrpcClient, func(), error) {
panic(wire.Build(client.ProviderSet))
}
4./cmd/helloworld_client/main.go
这里也主要学习了 helloworld 应用中的 conf 的使用, 以及发了 100 次的 SayHello.
package main
import (
"flag"
"os"
"strconv"
"helloworld/internal/conf"
"github.com/go-kratos/kratos/v2/config"
"github.com/go-kratos/kratos/v2/config/file"
"github.com/go-kratos/kratos/v2/log"
"gopkg.in/yaml.v2"
)
var (
flagconf string
logger log.Logger
)
func init() {
flag.StringVar(&flagconf, "conf", "../../configs", "config path, eg: -conf config.yaml")
logger = log.NewStdLogger(os.Stdout)
}
func main() {
flag.Parse()
// yaml 先转 json,
// json 再转 protobuf
cfg := config.New(
config.WithSource(
file.NewSource(flagconf),
),
config.WithDecoder(func(kv *config.KeyValue, v map[string]interface{}) error {
return yaml.Unmarshal(kv.Value, v)
}),
)
if err := cfg.Load(); err != nil {
panic(err)
}
var bc conf.Bootstrap
if err := cfg.Scan(&bc); err != nil {
panic(err)
}
gcli, cleanup, err := initClient(bc.Server, logger)
if err != nil {
panic(err)
}
defer cleanup()
lg := log.NewHelper("client/main", logger)
for i := 0; i < 100; i++ {
if err := gcli.DoSay("fango" + strconv.Itoa(i+1)); err != nil {
lg.Error(err)
}
}
lg.Info("finished")
}
5.编译 helloworld_client
go build -o ./bin/ ./cmd/helloworld_client
