Agen pelaksana Golang

Golang ialah bahasa pengaturcaraan yang pesat membangun yang digunakan secara meluas dalam pelbagai bidang, terutamanya dalam pembangunan bahagian pelayan. Dalam beberapa tahun kebelakangan ini, apabila aplikasi menjadi lebih kompleks, pemantauan dan pengurusan aplikasi menjadi semakin penting. Oleh itu, melaksanakan Agen yang boleh memantau dan mengurus aplikasi telah menjadi tugas yang perlu. Artikel ini akan memperkenalkan secara terperinci cara menggunakan Golang untuk menulis Ejen mudah untuk melaksanakan pemantauan dan pengurusan aplikasi.

Agen ialah program yang memantau dan mengurus aplikasi secara kerap boleh mengumpul pelbagai penunjuk aplikasi, seperti penggunaan CPU, penggunaan memori, dsb., dan menghantar penunjuk ini kepada pelayan pengurusan. Pentadbir aplikasi boleh melihat metrik ini pada pelayan pengurusan dan mengurus serta menala aplikasi.

Sebelum melaksanakan Agen, kita perlu memahami beberapa konsep penting. Yang pertama ialah seni bina Ejen. Ejen biasanya terdiri daripada dua bahagian: pemantauan dan pengurusan. Bahagian pemantauan bertanggungjawab untuk mengumpul pelbagai penunjuk aplikasi, dan bahagian pengurusan bertanggungjawab untuk menghantar penunjuk ini ke pelayan pengurusan dan mengurus serta melaraskan aplikasi. Yang kedua ialah penunjuk yang dikumpul. Sebagai tambahan kepada penunjuk yang disediakan oleh sistem itu sendiri, alat pihak ketiga juga boleh digunakan untuk mengumpul penunjuk, seperti Prometheus, Grafana, dll.

Sekarang, kita boleh mula menulis Ejen. Pertama, kita perlu memilih rangka kerja pembangunan yang sesuai. Golang mempunyai banyak rangka kerja pembangunan, seperti gin, beego, dll. Dalam artikel ini, kami akan memilih gin sebagai rangka kerja pembangunan kami kerana prestasi dan kebolehskalaannya sangat baik.

Seterusnya, kita perlu melaksanakan bahagian pemantauan Ejen. Kita boleh menggunakan pakej pprof yang disertakan dengan bahasa Go untuk mengumpul pelbagai penunjuk aplikasi. pprof terutamanya merangkumi bahagian berikut:

1. Penggunaan CPU

Dalam bahasa Go, kita boleh menggunakan pakej runtime untuk mendapatkan penggunaan CPU.

import "runtime"

func main() {
    cpuNum := runtime.NumCPU()
    for i := 0; i < cpuNum; i++ {
        go func() {
            for {
                a := 1
                for j := 0; j < 100000000; j++ {
                    a++
                }
            }
        }()
    }
}

Kod di atas akan memulakan berbilang program yang menduduki CPU dan memperoleh penggunaan CPU melalui pakej masa jalan.

2. Penggunaan Memori

Kami boleh menggunakan MemStats dalam pakej runtime untuk mendapatkan penggunaan memori aplikasi.

import (
    "fmt"
    "runtime"
)

func main() {
    var stats runtime.MemStats
    runtime.ReadMemStats(&stats)
    fmt.Printf("Alloc:%d TotalAlloc:%d Sys:%d NumGC:%d
",stats.Alloc/1024, 
    stats.TotalAlloc/1024, stats.Sys/1024, stats.NumGC)
}

Kod di atas akan mengeluarkan penunjuk seperti Alloc, TotalAlloc, Sys dan NumGC.

3. Penunjuk IO rangkaian

Kita boleh menggunakan pakej bersih untuk mendapatkan penunjuk I/O rangkaian.

import (
    "fmt"
    "net"
)

func main() {
    conn, _ := net.Dial("tcp", "www.google.com:80")
    fmt.Println(conn.LocalAddr())
    fmt.Println(conn.RemoteAddr())
}

Kod di atas akan mencetak IP tempatan dan alamat IP jauh.

4. Penunjuk IO Fail

Kita boleh menggunakan kaedah File.Stat dalam pakej os untuk mendapatkan status fail.

import (
    "fmt"
    "os"
)

func main() {
    file, _ := os.Open("/root/test.txt")
    defer file.Close()

    stat, _ := file.Stat()
    fmt.Println(stat.Size())
}

Kod di atas akan mengeluarkan saiz fail.

Selain penunjuk di atas, kami juga boleh menggunakan perpustakaan pihak ketiga untuk mengumpul lebih banyak penunjuk. Sebagai contoh, kita boleh menggunakan Prometheus dan Grafana untuk mengumpul pelbagai penunjuk aplikasi.

Sekarang, mari kita laksanakan bahagian pengurusan Ejen. Kami boleh menggunakan pakej bersih Golang sendiri untuk melaksanakan protokol TCP/IP untuk berkomunikasi dengan pelayan pengurusan. Pelayan pengurusan boleh menghantar arahan kepada Ejen melalui protokol TCP/IP, seperti memulakan aplikasi, menutup aplikasi, dsb.

import (
    "bufio"
    "fmt"
    "net"
    "os"
)

func main() {
    listener, err := net.Listen("tcp", "0.0.0.0:8000")
    if err != nil {
        fmt.Println("Failed to bind port")
        os.Exit(-1)
    }

    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Failed to accept connection")
            continue
        }

        scanner := bufio.NewScanner(conn)
        for scanner.Scan() {
            fmt.Println(scanner.Text())
        }

        conn.Close()
    }
}

Kod di atas akan mendengar pada port TCP 8000 dan mencetak semua mesej yang diterima.

Selain fungsi Ejen asas di atas, kami juga boleh mempertimbangkan untuk menambah lebih banyak fungsi. Sebagai contoh, kita boleh menggunakan Grafana untuk melaksanakan visualisasi data untuk melihat pelbagai metrik aplikasi dengan lebih intuitif. Kami juga boleh menggunakan Etcd untuk melaksanakan penemuan perkhidmatan Ejen dan pengurusan konfigurasi untuk mengurus Ejen dengan lebih mudah.

Ringkasan: Artikel ini memperkenalkan cara menggunakan Golang untuk menulis Ejen mudah untuk mencapai pemantauan dan pengurusan aplikasi asas. Melalui Agen ini, pentadbir aplikasi boleh menjejaki pelbagai penunjuk aplikasi dan mengurus serta melaraskan aplikasi. Pada masa yang sama, kami juga memperkenalkan cara menggunakan perpustakaan pihak ketiga seperti Prometheus dan Grafana untuk mengumpulkan lebih banyak penunjuk, dan menggunakan Etcd untuk melaksanakan penemuan perkhidmatan dan pengurusan konfigurasi Ejen.

Atas ialah kandungan terperinci Agen pelaksana Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!