Kitex微服务开发实践：ETCD服务注册

服务注册通常用于分布式系统或微服务架构中，是一种用于管理和发现这些分布式服务的机制。它的目标是让服务能够动态地找到其他服务，并能够与其进行通信，而无需显式地配置其位置信息

本文简单讲述使用etcd进行服务注册，基于kitex和hertz框架简单实现微服务应用

代码地址：https://github.com/T4t4KAU/Documents/tree/main/etcd-test

接口定义

使用thrift编写如下idl

add.thrift

namespace go api
 
struct AddRequest {
    1: i32 first
    2: i32 second
}
 
struct AddResponse {
    1: i32 sum
}
 
service AddService {
    AddResponse Add(AddRequest req)
}

echo.thrift

namespace go api
 
struct EchoRequest {
    1: string message
}
 
struct EchoResponse {
    2: string message
}
 
service EchoService {
    EchoResponse Echo(1:EchoRequest req)
}

使用Kitex生成代码(此处不作赘述):

.
├── add
│   ├── handler.go
│   └── main.go
├── build.sh
├── echo
│   ├── handler.go
│   └── main.go
├── go.mod
├── go.sum
├── idl
│   ├── add.thrift
│   └── echo.thrift
├── kitex_gen
│   └── api
│       ├── add.go
│       ├── addservice
│       │   ├── addservice.go
│       │   ├── client.go
│       │   ├── invoker.go
│       │   └── server.go
│       ├── echo.go
│       ├── echoservice
│       │   ├── client.go
│       │   ├── echoservice.go
│       │   ├── invoker.go
│       │   └── server.go
│       ├── k-add.go
│       ├── k-consts.go
│       └── k-echo.go
├── kitex_info.yaml
└── script
    └── bootstrap.sh

echo服务将参数message原样返回，add服务将参数中的两个整数求和后返回

代码实现

首先实现一个无服务注册的版本，在上述生成代码的基础上完善方法实现:

add/hander.go

// Add implements the AddServiceImpl interface.
func (s *AddServiceImpl) Add(ctx context.Context, req *api.AddRequest) (resp *api.AddResponse, err error) {
	resp = new(api.AddResponse)
	resp.Sum = req.First + req.Second
	return
}

add/main.go

package main
 
func main() {
    // 服务地址
	addr, _ := net.ResolveTCPAddr("tcp", "127.0.0.1:9091")
 
	svr := api.NewServer(new(AddServiceImpl),
		server.WithServerBasicInfo(&rpcinfo.EndpointBasicInfo{ServiceName: "add"}),
		server.WithServiceAddr(addr),
	)
 
	err := svr.Run()
 
	if err != nil {
		log.Println(err.Error())
	}
}

echo/handler.go

// Echo implements the EchoServiceImpl interface.
func (s *EchoServiceImpl) Echo(ctx context.Context, req *api.EchoRequest) (resp *api.EchoResponse, err error) {
	resp = new(api.EchoResponse)
	resp.Message = req.Message
	return
}

echo/main.go

package main
 
func main() {
    // 服务地址
	addr, _ := net.ResolveTCPAddr("tcp", "127.0.0.1:9092")
 
	svr := api.NewServer(new(EchoServiceImpl),
		server.WithServerBasicInfo(&rpcinfo.EndpointBasicInfo{ServiceName: "echo"}),
		server.WithServiceAddr(addr),
	)
 
	err := svr.Run()
 
	if err != nil {
		log.Println(err.Error())
	}
}

创建一个api包，作为两个服务的API网关，使用hertz来处理用户请求

目录结构：

.
├── add
│   ├── handler.go
│   └── main.go
├── api
│   ├── add.go
│   ├── echo.go
│   └── main.go
├── build.sh
├── echo
│   ├── handler.go
│   └── main.go
├── go.mod
├── go.sum
├── idl
│   ├── add.thrift
│   └── echo.thrift
├── kitex_gen
│   └── api
│       ├── add.go
│       ├── addservice
│       │   ├── addservice.go
│       │   ├── client.go
│       │   ├── invoker.go
│       │   └── server.go
│       ├── echo.go
│       ├── echoservice
│       │   ├── client.go
│       │   ├── echoservice.go
│       │   ├── invoker.go
│       │   └── server.go
│       ├── k-add.go
│       ├── k-consts.go
│       └── k-echo.go
├── kitex_info.yaml
└── script
    └── bootstrap.sh

实现web handler函数，在handler中使用RPC请求服务

add:

package main
 
var addClient addservice.Client
 
func AddHandler(ctx context.Context, c *app.RequestContext) {
	num1, _ := strconv.Atoi(c.Query("first"))
	num2, _ := strconv.Atoi(c.Query("second"))
    
    // RPC请求
	resp, err := addClient.Add(ctx, &api.AddRequest{
		First: int32(num1), Second: int32(num2),
	})
	if err != nil {
		c.JSON(http.StatusInternalServerError, utils.H{
			"message": err.Error(),
		})
		return
	}
 
	c.JSON(http.StatusOK, utils.H{
		"message": resp.Sum,
	})
}

echo:

package main
 
var echoClient echoservice.Client
 
func EchoHandler(ctx context.Context, c *app.RequestContext) {
    // RPC请求
	resp, err := echoClient.Echo(ctx, &api.EchoRequest{
		Message: c.Query("message"),
	})
	if err != nil {
		c.JSON(http.StatusInternalServerError, utils.H{
			"message": err.Error(),
		})
	}
 
	c.JSON(http.StatusOK, utils.H{
		"message": resp.Message,
	})
}

在主调函数中进行RPC客户端初始化和路由注册:

package main
 
func Init() {
	var err error
	addClient, err = addservice.NewClient("addservice",
		client.WithHostPorts("127.0.0.1:9091"))
	if err != nil {
		panic(err)
	}
	echoClient, err = echoservice.NewClient("echoservice",
		client.WithHostPorts("127.0.0.1:9092"))
	if err != nil {
		panic(err)
	}
}
 
func main() {
	Init()
	r := server.Default()
	r.POST("/add", AddHandler)
	r.GET("/echo", EchoHandler)
 
	r.Spin()
}

启动add和echo服务，再启动api，请求URL即可访问，此处省略测试过程

引入服务注册

在上述实现中，要显式的告诉API网关服务的地址，一旦这个地址发生变化，会导致服务不可用，接下来使用服务注册

使用docker启动etc:

docker run -d -p 10079:2379 --name etcd \
  -e ETCD_LISTEN_CLIENT_URLS=http://0.0.0.0:2379 \
  -e ETCD_ADVERTISE_CLIENT_URLS=http://0.0.0.0:2379 \
  -e ETCDCTL_API=3 \
  quay.io/coreos/etcd:v3.5.5

etcd服务器启动在10079端口

接下来修改服务代码：

add/main.go

package main
 
func main() {
    // 服务注册
	r, err := etcd.NewEtcdRegistry([]string{"127.0.0.1:10079"})
	if err != nil {
		panic(err)
	}
 
	addr, _ := net.ResolveTCPAddr("tcp", "127.0.0.1:9091")
 
	svr := api.NewServer(new(AddServiceImpl),
		server.WithServerBasicInfo(&rpcinfo.EndpointBasicInfo{ServiceName: "add"}), // 指定服务名称
		server.WithServiceAddr(addr),
		server.WithRegistry(r),  // 设置服务注册
	)
 
	err = svr.Run()
 
	if err != nil {
		log.Println(err.Error())
	}
}

echo/main.go

package main
func main() {
    // 服务注册
	r, err := etcd.NewEtcdRegistry([]string{"127.0.0.1:10079"})
	if err != nil {
		panic(err)
	}
 
	addr, _ := net.ResolveTCPAddr("tcp", "127.0.0.1:9092")
 
	svr := api.NewServer(new(EchoServiceImpl),
		server.WithServerBasicInfo(&rpcinfo.EndpointBasicInfo{ServiceName: "echo"}), // 指定服务名称
		server.WithServiceAddr(addr),
		server.WithRegistry(r),  // 设置服务注册
	)
 
	err = svr.Run()
 
	if err != nil {
		log.Println(err.Error())
	}
}

修改api代码，无须给出两个服务的地址了:

package main
 
func Init() {
	var err error
 
	r, err := etcd.NewEtcdResolver([]string{"127.0.0.1:10079"})
	if err != nil {
		panic(err)
	}
 
	addClient, err = addservice.NewClient("add",
		client.WithResolver(r),
	)
	if err != nil {
		panic(err)
	}
	echoClient, err = echoservice.NewClient("echo",
		client.WithResolver(r),
	)
	if err != nil {
		panic(err)
	}
}
 
func main() {
	Init()
	r := server.Default()
	r.POST("/add", AddHandler)
	r.GET("/echo", EchoHandler)
 
	r.Spin()
}

启动之后，服务正常使用