Solution de communication de messages par microservices basée sur le go-zero

Avec la popularité de l'architecture des microservices, la communication entre les microservices devient de plus en plus importante. La méthode de communication de l'API REST couramment utilisée dans le passé présente les inconvénients suivants lorsque les microservices s'appellent entre eux :

• Des requêtes réseau fréquentes entraîneront des retards et des goulots d'étranglement en termes de performances
• Pour les requêtes à haute fréquence, dans un court laps de temps Un grand nombre ; des requêtes peuvent provoquer un crash du service ;
• Pour les scénarios avec de grandes quantités de données transmises, la méthode de transmission basée sur le protocole HTTP est également sujette à l'inefficacité.

Par conséquent, implémenter une communication asynchrone entre microservices basée sur une file d'attente de messages (Message Queue) est devenue un bon choix. La file d'attente de messages peut envoyer des messages au serveur de messages, et le destinataire peut recevoir et traiter les messages de manière asynchrone, ce qui permet d'économiser du temps entre les services, d'améliorer les performances du système et d'assurer la fiabilité des communications.

Mais en termes de mise en œuvre d'une architecture, comment mettre en œuvre rapidement une solution de communication par messagerie puissante et hautement évolutive ? Aujourd'hui, nous allons parler de la solution de communication par messages microservices basée sur le go-zero.

Configuration de l'environnement

Pour implémenter la communication par microservice, nous avons besoin d'outils pour gérer la file d'attente des messages sur le serveur. Les plus populaires actuellement incluent RabbitMQ, Kafka, RocketMQ, etc. Cet article présentera l'utilisation de la file d'attente de messages RabbitMQ. Nous devons donc d'abord installer et configurer RabbitMQ.

Installez RabbitMQ

Les packages d'installation et les méthodes d'installation pertinents peuvent être consultés sur [Site officiel de RabbitMQ](https://www.rabbitmq.com/download.html). Aucune explication détaillée n’est donnée ici.

Une fois l'installation terminée, créez le vhost et l'utilisateur requis sur la console de gestion Web de RabbitMQ. Ici, nous définissons un vhost comme myhost, un nom d'utilisateur et un mot de passe comme admin/admin.

Install go-zero

go-zero est une boîte à outils permettant de créer des microservices évolutifs et maintenables. Il intègre tous les outils nécessaires dans une application monolithique et fournit les outils les plus couramment utilisés tels que les microservices, les RPC et les passerelles API. Nous devons installer l’environnement de développement go-zero localement.

infrastructure go-zero

go-zero est basée sur une architecture de microservices et fournit des outils de développement communs tels que des microservices, RPC et des passerelles API. Il est très simple d'utiliser go-zero pour implémenter une architecture de microservices prenant en charge la file d'attente de messages RabbitMQ.

1. Créer un service

Nous utilisons l'outil goctl (l'outil de ligne de commande de go-zero) pour créer rapidement des services. Tout d'abord, entrez le répertoire dans lequel le service est créé dans la ligne de commande go-zero, puis exécutez la commande suivante :

goctl api new message

Les résultats de l'opération sont les suivants :

- 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

Le service créé via l'API goctl La nouvelle commande contient Le répertoire de base et l'implémentation par défaut dont nous avons besoin sont fournis. Parmi eux, - api représente le nom du service, et - etc/message-api.yaml représente le fichier de configuration du service. 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. Fichier de configuration

Ouvrez etc/message-api.yaml et configurez nos informations RabbitMQ :

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

La partie MessageQueue spécifie les informations nécessaires lors de l'utilisation des informations RabbitMQ. .

3. Implémentation du gestionnaire et du service🎜🎜Nous devons ajouter l'implémentation du gestionnaire et du service pour traiter les messages dans la file d'attente des messages RabbitMQ. Ajoutez le fichier message_handler.go dans le répertoire handler et ajoutez le code suivant : 🎜rrreee🎜Parmi eux, nous utilisons l'outil zmq fourni par go-zero pour implémenter le message file d'attente avec RabbitMQ Interaction (voir [documentation officielle go-zero](https://go-zero.dev/cn/tools/zmq) pour plus de détails). 🎜🎜Ajoutez le fichier message_service.go dans le répertoire service, et ajoutez le code suivant : 🎜rrreee🎜Parmi eux, la partie biz est pour le traitement du code logique d'application, une implémentation de code spécifique peut être écrite en fonction des besoins spécifiques de l'entreprise. 🎜🎜4. Génération de code🎜🎜Après avoir créé le gestionnaire et le service, vous devez utiliser l'outil de ligne de commande go-zero pour générer automatiquement le code RPC pour nous. Dans la ligne de commande, nous entrons dans le même répertoire que le fichier message.api et exécutons le code suivant : 🎜rrreee🎜Cette commande générera automatiquement le message.api pour nous Classez les fichiers du protocole gRPC associés et placez-les dans le répertoire actuel. 🎜🎜5. Enregistrez le service🎜🎜Ajoutez le code suivant dans internal/config/config.go : 🎜rrreee🎜Parmi eux, nous avons enregistré le service MessageApi dans l'application, abonné à l'appel zmq.NewSubscriber. Après vous être abonné au message, nous traitons directement le message dans la file d'attente RabbitMQ via logx.Infof. 🎜🎜Enfin, ajoutez le code suivant dans la méthode Run dans main.go : 🎜rrreee🎜Le code ci-dessus configure le service en tant que serveur HTTP exécutable et le lie à le port spécifié. Enfin, nous pouvons tester si notre service est normal. 🎜🎜Résumé🎜🎜Dans cet article, nous avons présenté la solution de communication de messages de microservice basée sur go-zero et implémenté l'architecture de microservice prenant en charge RabbitMQ via un exemple de code. RabbitMQ présente les avantages d'être largement utilisé dans la technologie de communication de messagerie, de prendre en charge plusieurs langages de programmation et d'être open source. Il convient à la plupart des scénarios d'application au niveau de l'entreprise. Dans les applications pratiques, nous devons l’utiliser de manière flexible en fonction des scénarios commerciaux et des caractéristiques de la demande. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!