Heim > Artikel > Backend-Entwicklung > Microservice-Nachrichtenkommunikationslösung basierend auf Go-Zero
Mit der Popularität der Microservice-Architektur wird die Kommunikation zwischen Microservices immer wichtiger. Die in der Vergangenheit häufig verwendete REST-API-Kommunikationsmethode weist die folgenden Mängel auf, wenn sich Microservices gegenseitig aufrufen:
Daher ist die Implementierung der asynchronen Kommunikation zwischen Mikrodiensten basierend auf der Nachrichtenwarteschlange (Message Queue) eine gute Wahl. Die Nachrichtenwarteschlange kann Nachrichten an den Nachrichtenserver senden, und der Empfänger kann die Nachrichten asynchron empfangen und verarbeiten, wodurch zeitaufwändige Kommunikation zwischen Diensten eingespart, die Systemleistung verbessert und die Kommunikationszuverlässigkeit sichergestellt wird.
Wie lässt sich jedoch im Hinblick auf die Architekturimplementierung schnell eine leistungsstarke und hoch skalierbare Messaging-Kommunikationslösung implementieren? Heute werden wir über die auf Go-Zero basierende Microservice-Nachrichtenkommunikationslösung sprechen.
Um die Microservice-Kommunikation zu implementieren, benötigen wir Tools zur Handhabung der Nachrichtenwarteschlange auf dem Server. Zu den derzeit beliebtesten gehören RabbitMQ, Kafka, RocketMQ usw. In diesem Artikel wird die Verwendung der RabbitMQ-Nachrichtenwarteschlange vorgestellt. Daher müssen wir zunächst RabbitMQ installieren und konfigurieren.
Relevante Installationspakete und Installationsmethoden können auf der [offiziellen Website von RabbitMQ](https://www.rabbitmq.com/download.html) eingesehen werden. Auf eine detaillierte Erläuterung wird hier verzichtet.
Nach Abschluss der Installation erstellen Sie den erforderlichen Vhost und Benutzer auf der Webverwaltungskonsole von RabbitMQ. Hier legen wir einen vhost als myhost, einen Benutzernamen und ein Passwort als admin/admin fest.
go-zero ist ein Toolkit zum Aufbau skalierbarer und wartbarer Microservices. Es integriert alle notwendigen Tools in einer monolithischen Anwendung und stellt die am häufigsten verwendeten Tools wie Microservices, RPC und API-Gateways bereit. Wir müssen die Go-Zero-Entwicklungsumgebung lokal installieren.
Go-Zero basiert auf einer Microservice-Architektur und bietet gängige Entwicklungstools wie Microservices, RPC und API-Gateways. Es ist sehr einfach, mit Go-Zero eine Microservice-Architektur zu implementieren, die die RabbitMQ-Nachrichtenwarteschlange unterstützt.
Wir verwenden das Goctl-Tool (das Befehlszeilentool von Go-Zero), um Dienste schnell zu erstellen. Geben Sie zunächst in der Go-Zero-Befehlszeile das Verzeichnis ein, in dem der Dienst erstellt wird, und führen Sie dann den folgenden Befehl aus:
goctl api new message
Die Ergebnisse des Vorgangs sind wie folgt:
- 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
Der über die goctl-API erstellte Dienst Der Befehl new
enthält das Basisverzeichnis und die Standardimplementierung, die wir benötigen. Darunter stellt - api
den Namen des Dienstes dar und - etc/message-api.yaml
stellt die Konfigurationsdatei des Dienstes dar. goctl api new
命令创建的服务中包含了我们所需的基础目录和默认实现。其中- api
表示服务的名称,- etc/message-api.yaml
表示服务的配置文件。
打开etc/message-api.yaml
,配置我们的RabbitMQ信息:
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
其中MessageQueue
部分指定了使用RabbitMQ时必需的信息。
我们需要添加handler和service实现来处理RabbitMQ消息队列中的消息。在handler
目录下添加message_handler.go
文件,并添加如下代码:
package handler import ( "context" "github.com/tal-tech/go-zero/core/logx" "github.com/tal-tech/go-zero/rest/httpx" "github.com/tal-tech/go-zero/zmq" ) type MessageHandler struct { messageService *zmq.Service } func NewMessageHandler(ctx context.Context) *MessageHandler { return &MessageHandler{ messageService: zmq.NewService("my-exchange", "my-key", false), // 确定队列信息 } } func (h *MessageHandler) SendMessage(ctx context.Context, req *MessageRequest) (*MessageResponse, error) { logx.Infof("handler receive message %v", req.Message) err := h.messageService.SendMessage(zmq.NewMessage(req.Message)) // 发送消息到队列 if err != nil { logx.Error(err) return nil, httpx.NewDefaultError(httpx.InternalServerErrorStatus) } return &MessageResponse{}, nil }
其中,我们使用了go-zero提供的zmq工具来实现与RabbitMQ消息队列的交互(详见[go-zero官方文档](https://go-zero.dev/cn/tools/zmq))。
在service
目录中添加message_service.go
文件,并添加如下代码:
package service import ( "context" "message/internal/biz" ) type MessageApi struct { bc *biz.BizClient } func NewMessageApi(bc *biz.BizClient) *MessageApi { return &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 &MessageResponse{}, nil }
其中,biz
部分为处理应用逻辑的代码,具体代码实现可以根据具体业务需求进行编写。
创建好handler和service之后,需要使用go-zero的命令行工具来为我们自动生成RPC代码。我们在命令行中,进入到与message.api
文件相同的目录下,运行如下代码:
goctl rpc proto -src message.api -dir .
此命令将为我们自动生成与message.api
文件相关的gRPC协议文件,并将其放到当前目录下。
在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) } }()
其中,我们对应用中的MessageApi
服务进行了注册,在zmq.NewSubscriber
调用中进行了订阅。在订阅到消息后,我们通过logx.Infof
来直接处理RabbitMQ队列中的消息。
最后,在main.go
中的Run
etc/message-api.yaml
und konfigurieren Sie unsere RabbitMQ-Informationen: s := &http.Server{ Handler: server, Addr: ":"+cfg.Port, }
MessageQueue
gibt die erforderlichen Informationen an, wenn RabbitMQ-Informationen verwendet werden . 3. Handler- und Service-Implementierung🎜🎜Wir müssen Handler und Service-Implementierung hinzufügen, um Nachrichten in der RabbitMQ-Nachrichtenwarteschlange zu verarbeiten. Fügen Sie die Datei message_handler.go
im Verzeichnis handler
hinzu und fügen Sie den folgenden Code hinzu: 🎜rrreee🎜Unter anderem verwenden wir das von go-zero bereitgestellte zmq-Tool, um die Nachricht zu implementieren Warteschlange mit RabbitMQ-Interaktion (siehe [offizielle Go-Zero-Dokumentation](https://go-zero.dev/cn/tools/zmq) für Details). 🎜🎜Fügen Sie die Datei message_service.go
im Verzeichnis service
hinzu und fügen Sie den folgenden Code hinzu: 🎜rrreee🎜Darunter ist der Teil biz
Für die Verarbeitung von Anwendungslogikcode kann eine spezifische Codeimplementierung entsprechend den spezifischen Geschäftsanforderungen geschrieben werden. 🎜🎜4. Codegenerierung🎜🎜Nachdem wir den Handler und den Dienst erstellt haben, müssen wir das Go-Zero-Befehlszeilentool verwenden, um automatisch RPC-Code für uns zu generieren. In der Befehlszeile geben wir dasselbe Verzeichnis wie die Datei message.api
ein und führen den folgenden Code aus: 🎜rrreee🎜Dieser Befehl generiert automatisch die message.api
für uns Datei zugehörige gRPC-Protokolldateien ablegen und im aktuellen Verzeichnis ablegen. 🎜🎜5. Dienst registrieren🎜🎜Fügen Sie den folgenden Code in internal/config/config.go
hinzu: 🎜rrreee🎜Unter anderem haben wir den Dienst MessageApi
in der Anwendung registriert. abonniert im zmq.NewSubscriber
-Aufruf. Nachdem wir die Nachricht abonniert haben, verarbeiten wir die Nachricht direkt in der RabbitMQ-Warteschlange über logx.Infof
. 🎜🎜Fügen Sie abschließend den folgenden Code in der Methode Run
in main.go
hinzu: 🎜rrreee🎜Der obige Code konfiguriert den Dienst als ausführbaren HTTP-Server und bindet ihn an den angegebenen Port. Endlich können wir testen, ob unser Service normal ist. 🎜🎜Zusammenfassung🎜🎜In diesem Artikel haben wir die auf Go-Zero basierende Microservice-Nachrichtenkommunikationslösung vorgestellt und die Microservice-Architektur, die RabbitMQ unterstützt, durch Beispielcode implementiert. RabbitMQ hat den Vorteil, dass es in der Messaging-Kommunikationstechnologie weit verbreitet ist, mehrere Programmiersprachen unterstützt und Open Source ist. Es ist für die meisten Anwendungsszenarien auf Unternehmensebene geeignet. In praktischen Anwendungen müssen wir es basierend auf Geschäftsszenarien und Nachfragemerkmalen flexibel einsetzen. 🎜Das obige ist der detaillierte Inhalt vonMicroservice-Nachrichtenkommunikationslösung basierend auf Go-Zero. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!