Menggunakan rangka kerja web Golang rangka kerja Echo untuk melaksanakan penjadualan dan pemantauan tugas teragih

Dengan pembangunan Internet yang berterusan, aplikasi sistem teragih menjadi semakin meluas. Sistem teragih telah digunakan secara meluas dalam pembangunan aplikasi peringkat perusahaan kerana kelebihannya seperti kebolehpercayaan yang tinggi, konkurensi yang tinggi dan kebolehskalaan yang tinggi. Penjadualan tugasan dan pemantauan adalah isu yang sangat penting Penyelesaian kepada masalah ini adalah sangat kritikal untuk operasi yang boleh dipercayai bagi keseluruhan sistem yang diedarkan. Oleh itu, artikel ini akan memperkenalkan penyelesaian untuk melaksanakan penjadualan tugasan dan pemantauan menggunakan rangka kerja Web Golang. .

1. Apakah itu rangka kerja Echo

Echo ialah rangka kerja Web berasaskan bahasa Go yang ringan Matlamat reka bentuknya adalah untuk menyediakan prestasi tinggi, ringkas dan mudah -gunakan rangka kerja Web sambil mengekalkan pelaksanaan yang cekap dan keupayaan berkuasa bahasa Go. Ciri rangka kerja Echo termasuk yang berikut:

• Prestasi tinggi: Prestasi rangka kerja Echo sangat tinggi, menyokong Gzip, dokumentasi API automatik, perisian tengah tersuai dan ciri lain
• Mudah digunakan : Rangka kerja Echo menyediakan satu siri API yang ringkas dan mudah digunakan, yang boleh membuat laluan dengan mudah, membuat templat, permintaan proses, dsb.
• Skala yang berkuasa: Rangka kerja Echo juga menyokong mekanisme pemalam, yang boleh mengubah suai fungsi dengan mudah Pergi untuk sambungan dan penyesuaian mendalam.

2. Penjadualan tugasan dan penyelesaian pemantauan yang diedarkan

Dalam sistem teragih, penjadualan tugas dan pemantauan adalah fungsi penting. Menjadualkan tugas dengan betul dan memantau status mesin boleh memastikan kebolehpercayaan keseluruhan sistem dengan berkesan. Oleh itu, kami memerlukan penyelesaian penjadualan tugas dan pemantauan dengan kebolehpercayaan yang tinggi dan keselarasan tinggi Berikut ialah cara untuk melaksanakannya menggunakan rangka kerja Echo.

2.1 Penjadualan Tugas

Penjadualan tugas ialah bahagian yang sangat penting dalam sistem yang diedarkan Algoritma penjadualan yang berbeza secara langsung akan menjejaskan kestabilan dan prestasi sistem. Dalam artikel ini, kami menggunakan algoritma penjadualan tugas yang paling mudah-Algoritma Penjadualan Polling. Setiap pekerja (nod pekerja) secara berkala meninjau baris gilir tugas daripada induk (nod pusat Jika terdapat tugas dalam baris gilir tugas, ia akan mengeluarkan tugas daripada baris gilir untuk pelaksanaan, jika tidak, ia akan terus menunggu.

2.1.1 Tentukan jenis tugas

Untuk melaksanakan penjadualan tugas, kita perlu mentakrifkan struktur data tugasan. Tugasan mengandungi sekurang-kurangnya atribut berikut:

• ID Tugas: nombor yang digunakan untuk mengenal pasti tugasan secara unik;
• Status tugasan: dibahagikan kepada selesai (Selesai), sedang berjalan (Berjalan), tidak dimulakan (Terbiar) dan keadaan lain
• Maklumat perihalan tugas: huraikan maklumat tugasan yang berkaitan secara terperinci ;
• Masa Penciptaan Tugas dan masa kemas kini: Catatkan masa penciptaan tugas dan masa kemas kini terkini.
• Kita boleh mentakrifkan struktur berikut untuk mewakili tugasan:

taip struct Tugas {

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 Tentukan baris gilir tugas

Selepas menentukan jenis tugasan, kita juga perlu menentukan baris gilir tugas. Barisan tugasan biasanya dilaksanakan menggunakan struktur data baris gilir dan mengikut prinsip masuk dahulu keluar (FIFO) untuk memastikan susunan pelaksanaan tugas. Kita boleh menggunakan struktur data baris gilir dalam perpustakaan standard Golang - senarai berganda (Senarai) untuk mencapai ini. Kodnya adalah seperti berikut:

taip TaskQueue struct {

queue *list.List
lock  sync.Mutex

}

func NewTaskQueue() *TaskQueue {

rreee

}

func ( q

TaskQueue) Tolak(tugas

Task) {

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

}

func (q

TaskQueue) Pop()

Task {

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

}

2.1.3 Tentukan nod pekerja

Dalam sistem penjadualan tugas teragih, nod pekerja mengeluarkan tugas daripada baris gilir tugas dan melaksanakannya. Nod pekerja perlu meminta tugas secara berkala daripada nod induk Jika masih ada tugasan yang belum selesai, teruskan melaksanakan tugas. Di sini kami mentakrifkan struktur pekerja untuk mewakili nod kerja:

taip struct Pekerja {

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

}

di mana ID mewakili ID nod kerja dan Alamat mewakili kerja nod Alamat perkhidmatan, ActiveTime menunjukkan masa aktif terakhir nod kerja, dan IsAvailable menunjukkan sama ada nod kerja semasa tersedia.

2.1.4 Definisi Nod Induk

Nod Induk ialah nod kawalan keseluruhan sistem penjadualan teragih Ia bertanggungjawab untuk penjadualan dan pemantauan. Master perlu mengekalkan baris gilir tugas dan senarai nod yang berfungsi, memproses permintaan daripada setiap nod yang berfungsi, dan memperuntukkan tugas kepada nod kerja tertentu. Kodnya adalah seperti berikut:

taip Master struct {

ID          int64
Address     string
ActiveTime  time.Time
IsAvailable bool

}

func NewMaster() *Master {

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

}

func (m *Master) Run() {

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),
}

}

2.1.5 Melaksanakan algoritma penjadualan tugas

Penjadualan tugas memerlukan algoritma penjadualan dan algoritma penjadualan undian digunakan di sini , agihkan tugas secara sama rata kepada nod. Algoritma ini mudah untuk dilaksanakan, tetapi mungkin terdapat "tugas besar" dalam baris gilir tugas, menyebabkan masa pelaksanaan beberapa tugas nod menjadi terlalu lama, mengakibatkan penurunan prestasi keseluruhan sistem. Oleh itu, kita perlu melaksanakan algoritma pengimbangan beban dinamik untuk memastikan kestabilan dan kebolehpercayaan sistem. Algoritma pengimbangan beban berdasarkan penggunaan sumber boleh digunakan di sini Untuk butiran, sila rujuk "Semakan Penyelidikan Algoritma Pengimbangan Beban".

2.2 Pemantauan Tugas

Pemantauan tugas juga merupakan bahagian yang sangat penting dalam sistem yang diedarkan. Kami perlu mendapatkan status nod yang berfungsi, pelaksanaan tugas dan maklumat lain dalam masa nyata untuk memastikan kebolehpercayaan keseluruhan sistem. Untuk mencapai pemantauan tugas, kami boleh menggunakan ciri WebSocket bagi rangka kerja Echo untuk menolak data pemantauan ke bahagian hadapan untuk paparan dalam masa nyata.

2.2.1 Tentukan penghalaan 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框架，我们可以非常方便地创建路由、处理请求等，实现了分布式任务调度和监控的功能。本文只是简单地介绍了任务调度和监控的实现方式，实际应用中还需要考虑更多的问题，如：任务失败重试机制、工作节点故障处理策略等。

Atas ialah kandungan terperinci Menggunakan rangka kerja web Golang rangka kerja Echo untuk melaksanakan penjadualan dan pemantauan tugas teragih. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!