Utilisation du framework Web Echo de Golang pour mettre en œuvre la planification et la surveillance distribuées des tâches

Avec le développement continu d'Internet, les applications des systèmes distribués sont de plus en plus répandues. Les systèmes distribués ont été largement utilisés dans le développement d'applications au niveau de l'entreprise en raison de leurs avantages tels qu'une fiabilité élevée, une concurrence élevée et une évolutivité élevée. La planification et la surveillance des tâches distribuées sont un problème très important. La solution à ce problème est très critique pour le fonctionnement fiable de l'ensemble du système distribué. Par conséquent, cet article présentera une solution pour la mise en œuvre de la planification et de la surveillance des tâches distribuées à l'aide du framework Web Echo de Golang. .

1. Qu'est-ce que Echo Framework

Echo est un framework Web léger basé sur le langage Go. Son objectif de conception est de fournir un framework Web hautes performances et simple à utiliser tout en conservant l'exécution efficace et la puissance de Go. capacité de langage. Les fonctionnalités du framework Echo sont les suivantes :

• Hautes performances : le framework Echo a de très hautes performances et prend en charge Gzip, la documentation automatique de l'API, un middleware personnalisé et d'autres fonctionnalités
• Facile à utiliser : le framework Echo fournit une série de fonctionnalités ; fonctionnalités simples et faciles à utiliser. API, vous pouvez facilement créer des itinéraires, des modèles de rendu, traiter des demandes, etc. ;
• Évolutivité puissante : le framework Echo prend également en charge les mécanismes de plug-in, qui peuvent facilement étendre et personnaliser en profondeur les fonctions.

2. Solution de planification et de surveillance des tâches distribuées

Dans un système distribué, la planification et la surveillance des tâches sont des fonctions essentielles. Une planification correcte des tâches et une surveillance de l'état des machines peuvent garantir efficacement la fiabilité de l'ensemble du système. Par conséquent, nous avons besoin d'une solution de planification et de surveillance des tâches avec une fiabilité élevée et une concurrence élevée. Voici comment la mettre en œuvre à l'aide du framework Echo.

2.1 Planification des tâches

La planification des tâches est une partie très importante du système distribué. Différents algorithmes de planification affecteront directement la stabilité et les performances du système. Dans cet article, nous utilisons l'algorithme de planification de tâches le plus simple : l'algorithme de planification d'interrogation. Chaque travailleur (nœud de travail) interroge périodiquement la file d'attente des tâches du maître (nœud central). S'il y a une tâche dans la file d'attente des tâches, il la retirera de la file d'attente pour exécution, sinon il continuera d'attendre.

2.1.1 Définir le type de tâche

Afin de mettre en œuvre la planification des tâches, nous devons définir la structure des données de la tâche. Les tâches contiennent au moins les attributs suivants :

• ID de la tâche : un numéro utilisé pour identifier de manière unique la tâche ;
• Nom de la tâche : nom de la tâche, utilisé pour identifier le type de tâche
• Statut de la tâche : divisé en Terminé et En cours ; (En cours d'exécution), non démarré (Idle) et autres états ;
• Informations de description de la tâche : décrivez en détail les informations pertinentes de la tâche 
• Heure de création et de mise à jour de la tâche : enregistrez respectivement l'heure de création de la tâche et l'heure de la dernière mise à jour ;

Nous pouvons définir la structure suivante pour représenter les tâches :

type Task struct {

ID          int64     `json:"id"`
Name        string    `json:"name"`
Status      string    `json:"status"`
Description string    `json:"description"`
CreatedAt   time.Time `json:"created_at"`
UpdatedAt   time.Time `json:"updated_at"`

}

2.1.2 Définir la file d'attente des tâches

Après avoir défini le type de tâche, nous devons également définir la file d'attente des tâches. Les files d'attente de tâches sont généralement implémentées à l'aide de structures de données de file d'attente et suivent le principe du premier entré, premier sorti (FIFO) pour garantir l'ordre d'exécution des tâches. Nous pouvons utiliser la structure de données de file d'attente de la bibliothèque standard de Golang - une liste doublement chaînée (List) pour y parvenir. Le code est le suivant :

type TaskQueue struct {

queue *list.List
lock  sync.Mutex

}

func NewTaskQueue() *TaskQueue {

return &TaskQueue{
    queue: list.New(),
}

}

func (q TaskQueue) Push(task Task) {

q.lock.Lock()
q.queue.PushBack(task)
q.lock.Unlock()

}

func (q TaskQueue) Pop() Tâche {

q.lock.Lock()
task := q.queue.Front().Value.(*Task)
q.queue.Remove(q.queue.Front())
q.lock.Unlock()
return task

}

2.1.3 Définir des nœuds de travail

Dans un système de planification de tâches distribué, les nœuds de travail retirent les tâches de la file d'attente des tâches et les exécutent. Le nœud travailleur doit demander périodiquement des tâches au nœud maître. S'il reste des tâches inachevées, continuez à exécuter les tâches. Ici, nous définissons une structure de travail pour représenter le nœud de travail :

type Worker struct {

ID          int64
Address     string
ActiveTime  time.Time
IsAvailable bool

}

où ID représente l'ID du nœud de travail, Address représente l'adresse du service du nœud de travail et ActiveTime représente le dernier actif heure du nœud de travail, IsAvailable indique si le nœud de travail actuel est disponible.

2.1.4 Définir le nœud maître

Le nœud maître est le nœud de contrôle de l'ensemble du système de planification distribué. Il est responsable de la planification et de la surveillance des tâches. Le maître doit maintenir une file d'attente de tâches et une liste de nœuds de travail, traiter les demandes de chaque nœud de travail et attribuer des tâches à des nœuds de travail spécifiques. Le code est le suivant :

type Master struct {

TaskQueue  *TaskQueue
Workers    []*Worker
isStop     bool
taskChan   chan *Task
register   chan *Worker
report     chan *Worker
disconnect chan *Worker
lock       sync.Mutex

}

func NewMaster() *Master {

return &Master{
    TaskQueue:  NewTaskQueue(),
    Workers:    make([]*Worker, 0),
    isStop:     false,
    taskChan:   make(chan *Task),
    register:   make(chan *Worker),
    report:     make(chan *Worker),
    disconnect: make(chan *Worker),
}

}

func (m *Master) Run() {

go func() {
    for {
        select {
        case worker := <-m.register:
            m.registerWorker(worker)
        case worker := <-m.report:
            m.updateWorker(worker)
        case worker := <-m.disconnect:
            m.removeWorker(worker)
        case task := <-m.taskChan:
            m.dispatchTask(task)
        default:
            time.Sleep(time.Second * time.Duration(1))
        }

        if m.isStop {
            break
        }
    }
}()

}

2.1.5 Algorithme de planification des tâches de mise en œuvre

La planification des tâches nécessite un algorithme de planification. Ici, un algorithme de planification d'interrogation est utilisé pour répartir les tâches uniformément entre les nœuds. Cet algorithme est simple à mettre en œuvre, mais il peut y avoir des « tâches volumineuses » dans la file d'attente des tâches, ce qui rend le temps d'exécution de certaines tâches de nœud trop long, entraînant une diminution des performances de l'ensemble du système. Par conséquent, nous devons implémenter un algorithme d’équilibrage de charge dynamique pour garantir la stabilité et la fiabilité du système. Un algorithme d'équilibrage de charge basé sur l'utilisation des ressources peut être utilisé ici. Pour plus de détails, veuillez vous référer à « Revue de recherche sur les algorithmes d'équilibrage de charge ».

2.2 Surveillance des tâches

La surveillance des tâches est également une partie très importante du système distribué. Nous devons obtenir l'état des nœuds de travail, l'exécution des tâches et d'autres informations en temps réel pour garantir la fiabilité de l'ensemble du système. Afin de réaliser la surveillance des tâches, nous pouvons utiliser la fonctionnalité WebSocket du framework Echo pour pousser les données de surveillance vers le front-end pour les afficher en temps réel.

2.2.1 Définir le routage WebSocket

为了实现任务监控，我们需要定义WebSocket路由。WebSocket是一种基于TCP协议的全双工通信协议，允许服务器主动向客户端推送数据，实现实时通信。我们可以通过Echo框架提供的WebSocket API来实现WebSocket通信，代码如下所示：

func (s *Server) WebSocketHandler(c echo.Context) error {

ws, err := upgrader.Upgrade(c.Response(), c.Request(), nil)
if err != nil {
    return err
}

client := NewClient(ws)

s.clients[client] = true

go client.ReadPump()
go client.WritePump()

return nil

}

其中，upgrader是Echo框架中提供的WebSocket升级器，用于将HTTP连接升级为WebSocket连接。NewClient是一个封装了WebSocket连接的客户端结构体。这样就可以轻松地实现从服务器向客户端推送实时监控数据了。

2.2.2 实现数据推送逻辑

推送数据的逻辑比较简单，我们只需要将需要推送的数据通过WebSocket发送到客户端即可。推送的数据可以是工作节点的一些统计信息，如：CPU利用率、内存利用率等，也可以是任务的执行状态、进度等信息。代码如下：

func (c *Client) WritePump() {

ticker := time.NewTicker(pingPeriod)
defer func() {
    ticker.Stop()
    c.ws.Close()
}()

for {
    select {
    case message, ok := <-c.send:
        c.ws.SetWriteDeadline(time.Now().Add(writeWait))
        if !ok {
            c.write(websocket.CloseMessage, []byte{})
            return
        }

        w, err := c.ws.NextWriter(websocket.TextMessage)
        if err != nil {
            return
        }
        w.Write(message)

        n := len(c.send)
        for i := 0; i < n; i++ {
            w.Write(newline)
            w.Write(<-c.send)
        }

        if err := w.Close(); err != nil {
            return
        }
    }
}

}

3. 总结

本文主要介绍了使用Golang的Web框架Echo框架实现分布式任务调度与监控的方案。通过使用Echo框架，我们可以非常方便地创建路由、处理请求等，实现了分布式任务调度和监控的功能。本文只是简单地介绍了任务调度和监控的实现方式，实际应用中还需要考虑更多的问题，如：任务失败重试机制、工作节点故障处理策略等。

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!