Microservice message communication solution based on go-zero

With the popularity of microservice architecture, communication between microservices becomes more and more important. The REST API communication method commonly used in the past has the following shortcomings when microservices call each other:

• Frequent network requests will bring delays and performance bottlenecks;
• For High-frequency requests and a large number of requests in a short period of time may cause service crashes;
• For scenarios with large amounts of data transmission, the transmission method based on the HTTP protocol is also prone to inefficiency.

Therefore, implementing asynchronous communication between microservices based on message queue (Message Queue) has become a good choice. The message queue can send messages to the message server, and the recipient can receive and process the messages asynchronously, saving time-consuming communication between services, improving system performance and ensuring communication reliability.

However, in terms of architecture implementation, how to quickly implement a powerful and highly scalable message communication solution? Today we will talk about the microservice message communication solution based on go-zero.

Environment configuration

To implement microservice communication, we need tools to handle the message queue on the server. Currently popular ones include RabbitMQ, Kafka, RocketMQ, etc. This article will introduce the use of RabbitMQ message queue. So we first need to install and configure RabbitMQ.

Installing RabbitMQ

Relevant installation packages and installation methods can be viewed at [RabbitMQ official website](https://www.rabbitmq.com/download.html). No detailed explanation is given here.

After the installation is complete, create the required vhost and user on the RabbitMQ web management console. Here we set a vhost as myhost, a username and password as admin/admin.

Install go-zero

go-zero is a toolkit for building scalable and maintainable microservices. It integrates all the necessary tools in a monolithic application and provides the most commonly used tools such as microservices, RPC, and API gateways. We need to install the go-zero development environment locally.

go-zero infrastructure

go-zero is based on microservice architecture and provides common development tools such as microservices, RPC, and API gateways. It is very simple to use go-zero to implement a microservice architecture that supports RabbitMQ message queue.

1. Create services

We use the goctl tool (go-zero's command line tool) to quickly create services. First, enter the directory where the service was created in the go-zero command line, and then run the following command:

goctl api new message

The results of the operation are as follows:

- api
    - etc
        - message-api.yaml
    - internal
        - config
            - config.go
        - handler
            - message_handler.go
        - service
            - message_service.go
    - message.api
- Dockerfile
- go.mod
- go.sum
- main.go

Through goctl api new## The service created by the # command contains the basic directory and default implementation we need. Among them, - api represents the name of the service, and - etc/message-api.yaml represents the configuration file of the service.

2. Configuration file

Open

etc/message-api.yaml and configure our RabbitMQ information:

Name: message-api
Host: 0.0.0.0
Port: 8080
JwtSecret: # 在API网关中使用

MessageQueue:
  Host: 127.0.0.1
  Port: 5672 # RabbitMQ端口
  User: admin # RabbitMQ用户名
  Password: admin # RabbitMQ密码
  VirtualHost: myhost # RabbitMQ vhost

Among them

MessageQueue# The ## section specifies the necessary information when using RabbitMQ. 3. Handler and service implementation

We need to add handler and service implementation to process messages in the RabbitMQ message queue. Add the

message_handler.go

file in the handler directory, and add the following code: <pre class='brush:go;toolbar:false;'>package handler import ( &quot;context&quot; &quot;github.com/tal-tech/go-zero/core/logx&quot; &quot;github.com/tal-tech/go-zero/rest/httpx&quot; &quot;github.com/tal-tech/go-zero/zmq&quot; ) type MessageHandler struct { messageService *zmq.Service } func NewMessageHandler(ctx context.Context) *MessageHandler { return &amp;MessageHandler{ messageService: zmq.NewService(&quot;my-exchange&quot;, &quot;my-key&quot;, false), // 确定队列信息 } } func (h *MessageHandler) SendMessage(ctx context.Context, req *MessageRequest) (*MessageResponse, error) { logx.Infof(&quot;handler receive message %v&quot;, req.Message) err := h.messageService.SendMessage(zmq.NewMessage(req.Message)) // 发送消息到队列 if err != nil { logx.Error(err) return nil, httpx.NewDefaultError(httpx.InternalServerErrorStatus) } return &amp;MessageResponse{}, nil }</pre> Among them, we use the zmq tool provided by go-zero to implement RabbitMQ Message queue interaction (see [go-zero official documentation](https://go-zero.dev/cn/tools/zmq) for details).

Add the

message_service.go

file in the service directory, and add the following code: <pre class='brush:go;toolbar:false;'>package service import ( &quot;context&quot; &quot;message/internal/biz&quot; ) type MessageApi struct { bc *biz.BizClient } func NewMessageApi(bc *biz.BizClient) *MessageApi { return &amp;MessageApi{ bc: bc, } } func (s *MessageApi) SendMessage(ctx context.Context, req *MessageRequest) (*MessageResponse, error) { _, err := s.bc.SendMessage(ctx, req.Message) if err != nil { return nil, err } return &amp;MessageResponse{}, nil }</pre>Among them, the

biz

part To handle the code of application logic, specific code implementation can be written according to specific business needs. 4. Code generation

After creating the handler and service, we need to use the go-zero command line tool to automatically generate RPC code for us. In the command line, we enter the same directory as the

message.api

file and run the following code: <pre class='brush:php;toolbar:false;'>goctl rpc proto -src message.api -dir .</pre>This command will automatically generate the

message.api# for us. ##File related gRPC protocol files and place them in the current directory.

5. Registration service

Add the following code in

internal/config/config.go

:

// register MessageApi
group := server.Group("/")
messageSvc := service.NewMessageApi(biz.NewBizClient())
server.POST(group+"/send-message", httpx.NewHandler(messageSvc.SendMessage))

go func() {
    err = zmq.NewSubscriber("my-exchange", "my-key", false).Subscribe(func(msg zmq.Message) {
        logx.Infof("[RabbitMQ Subscriber] receive message %s", string(msg.Body))
    }) // 订阅队列

    if err != nil {
        panic(err)
    }
}()

Among them, we have # in the application The ##MessageApi service is registered and subscribed in the

zmq.NewSubscriber

call. After subscribing to the message, we directly process the message in the RabbitMQ queue through logx.Infof. Finally, add the following code in the Run method in

main.go

: <pre class='brush:go;toolbar:false;'>s := &amp;http.Server{ Handler: server, Addr: &quot;:&quot;+cfg.Port, }</pre>The above code configures the service to be runnable HTTP server and bind to the specified port. Finally we can test whether our service is normal. Summary

In this article, we introduced the microservice message communication solution based on go-zero, and implemented the microservice architecture supporting RabbitMQ through sample code. RabbitMQ has the advantages of being widely used in messaging communication technology, supporting multiple programming languages, and being open source. It is suitable for most enterprise-level application scenarios. In practical applications, we need to use it flexibly based on business scenarios and demand characteristics.

The above is the detailed content of Microservice message communication solution based on go-zero. For more information, please follow other related articles on the PHP Chinese website!