Utilisez go-zero pour mettre en œuvre la distribution et la planification distribuées des tâches

Avec le développement rapide du commerce Internet et l'augmentation progressive du volume d'affaires, la quantité de données qu'un seul serveur peut gérer est loin de répondre à la demande. Afin de répondre aux exigences de haute concurrence, de haute disponibilité et de hautes performances, une architecture distribuée a émergé au fur et à mesure que les temps l'exigent.

Dans une architecture distribuée, la répartition et la planification des tâches sont un élément très critique. La qualité de la répartition et de la planification des tâches affectera directement les performances et la stabilité de l'ensemble du système. Ici, nous présenterons comment utiliser le framework go-zero pour implémenter la distribution et la planification distribuées des tâches.

1. Distribution distribuée des tâches

La distribution des tâches consiste à attribuer des tâches à exécuter à différents nœuds. Dans un environnement distribué, la répartition des tâches est généralement mise en œuvre via des files d'attente de messages. La file d'attente de messages présente les caractéristiques de haute disponibilité, d'asynchrone et de découplage, et peut bien résoudre les risques et les incertitudes dans le processus de répartition des tâches.

go-zero prend en charge les files d'attente de messages telles que RabbitMQ et Kafka. Ici, nous prenons Rabbitmq comme exemple pour présenter comment l'utiliser pour réaliser une distribution distribuée des tâches.

1.1 Installer Rabbitmq

Nous devons d'abord installer Rabbitmq. Vous pouvez l'installer en vous référant à la documentation sur le site officiel de Rabbitmq. Une fois l'installation terminée, nous devons créer un nouvel hôte virtuel et un nouvel utilisateur et définir les autorisations.

# 创建 vhost
sudo rabbitmqctl add_vhost vhost-test

# 创建用户
sudo rabbitmqctl add_user user-test passwd-test

# 设置用户权限
sudo rabbitmqctl set_permissions -p vhost-test user-test ".*" ".*" ".*"

1.2 Configurer Rabbitmq

Ensuite, nous devons ajouter la configuration associée à Rabbitmq dans le fichier de configuration :

[message]
    # 是否启用message
    enable = true
    # message类型，支持multi、nsq、kafka、rabbitmq
    type = "rabbitmq"
    # rabbitmq地址（IP:PORT）
    addr = "localhost:5672"
    # rabbitmq账号
    user = "user-test"
    # rabbitmq密码
    password = "passwd-test"
    # rabbitmq虚拟主机（默认值：/）
    virtualhost = "vhost-test"
    # 消息队列名称
    queue = "test-queue"

1.3 Envoyer des tâches

En go-zero, nous pouvons réaliser une distribution distribuée des tâches via des files d'attente de messages. Nous pouvons envoyer des messages via la file d'attente des messages, et le consommateur du message récupérera le message de la file d'attente des messages et effectuera les tâches correspondantes.

Ici, nous prenons l'envoi d'e-mails comme exemple pour présenter comment envoyer des tâches :

func sendMail(ctx context.Context, req *types.SendMailRequest) error {
    // 将任务转为消息发送到消息队列中
    return message.SendMessage(ctx, "test-queue", &types.SendMailRequest{
        Email: req.Email,
        Title: req.Title,
        Content: req.Content,
    })
}

Dans cette méthode, nous convertissons la tâche d'e-mail en message et envoyons le message à la file d'attente des messages via la fonction SendMessage.

2. Planification distribuée des tâches

La planification distribuée des tâches consiste à attribuer des tâches à différents nœuds et à les planifier. Dans un environnement distribué, la planification des tâches est généralement effectuée via un système de tâches planifiées tel que cron.

Le framework go-zero fournit le package cronexpr, qui peut faciliter la planification des tâches. Nous pouvons analyser les expressions cron via le package cronexpr, puis effectuer les tâches correspondantes.

2.1 Ajouter des tâches

Nous pouvons ajouter des tâches au système de tâches planifiées via AddFunc, AddJob et d'autres fonctions, par exemple :

func startSchedule() {
    // 解析cron表达式，每天凌晨1点执行
    expr, err := cronexpr.Parse("0 0 1 * * *")
    if err != nil {
        log.Fatalf("failed to parse cron expression: %s", err.Error())
    }

    // 添加任务
    cron.Schedule(expr, cron.FuncJob(func() {
        // do something
    }))
}

Dans cet exemple, nous analysons l'expression cron qui est exécutée à 1 heure du matin tous les jours, puis ajouter des tâches à la tâche planifiée Un FuncJob est ajouté au système.

2.2 Exécution de tâches

Le système de tâches planifiées appellera la fonction correspondant à la tâche pour exécuter la tâche. Nous pouvons gérer la tâche en écrivant la fonction de traitement correspondante, par exemple :

func handleMailTask() {
    // 监听消息队列
    message.ReceiveMessage(context.Background(),"test-queue", func(ctx context.Context, data []byte) error {
        var req types.SendMailRequest
        // 解析消息
        if err := json.Unmarshal(data, &req); err != nil {
            return err
        }

        // 发送邮件
        if err := sendMail(context.Background(), &req); err != nil {
            log.Printf("failed to send mail of %s: %s", req.Email, err.Error())
        }

        return nil
    })
}

Dans cette fonction de traitement, nous écoutons la file d'attente des messages, obtenons le message et analysons la tâche. Appelez ensuite la fonction sendMail pour envoyer l'e-mail.

3. Résumé

Cet article présente comment utiliser le framework go-zero pour réaliser une distribution et une planification distribuées des tâches. Grâce à la file d'attente des messages et au système de tâches planifiées, nous pouvons facilement réaliser la distribution et la planification des tâches, et améliorer les performances et la disponibilité du système.

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!