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:

• Häufige Netzwerkanforderungen führen zu Verzögerungen und Leistungsengpässen.
• Bei hochfrequenten Anforderungen innerhalb kurzer Zeit Anzahl der Anfragen kann zum Absturz des Dienstes führen.
• Bei Szenarien mit großen Datenübertragungsmengen ist die auf dem HTTP-Protokoll basierende Übertragungsmethode ebenfalls anfällig für Ineffizienz.

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.

Umgebungskonfiguration

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.

RabbitMQ installieren

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.

Install go-zero

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-Infrastruktur

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.

1. Dienst erstellen

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表示服务的配置文件。

2. 配置文件

打开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时必需的信息。

3. handler和service实现

我们需要添加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部分为处理应用逻辑的代码，具体代码实现可以根据具体业务需求进行编写。

4. 代码生成

创建好handler和service之后，需要使用go-zero的命令行工具来为我们自动生成RPC代码。我们在命令行中，进入到与message.api文件相同的目录下，运行如下代码：

goctl rpc proto -src message.api -dir .

此命令将为我们自动生成与message.api文件相关的gRPC协议文件，并将其放到当前目录下。

5. 注册服务

在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

2. Konfigurationsdatei

Öffnen Sie etc/message-api.yaml und konfigurieren Sie unsere RabbitMQ-Informationen:

s := &http.Server{
    Handler: server,
    Addr:    ":"+cfg.Port,
}

Der Teil 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!