CFSDN nhấn mạnh vào giá trị tạo ra nguồn mở và chúng tôi cam kết xây dựng nền tảng chia sẻ tài nguyên để mọi nhân viên CNTT có thể tìm thấy thế giới tuyệt vời của bạn tại đây.

这篇CFSDN的博客文章学会这几招让 Go 程序自己监控自己由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

Khi nói đến việc cho phép các chương trình Go giám sát việc sử dụng tài nguyên của các tiến trình của riêng chúng, trước tiên chúng ta hãy nói về những chỉ số nào cần được theo dõi. Nói chung, các chỉ báo phổ biến nhất của các tiến trình là mức chiếm dụng bộ nhớ, mức chiếm dụng CPU và quá trình tạo tiến trình. Số lượng chủ đề. Vì ngôn ngữ Go duy trì các Goroutine trên đầu các luồng nên chỉ báo tài nguyên của quy trình Go cũng cần thêm số lượng Goroutine đã tạo.

Và vì nhiều dịch vụ hiện được triển khai trên các cụm Kubernetes nên một tiến trình Go thường là một Pod, nhưng tài nguyên của vùng chứa được chia sẻ với máy chủ. Chỉ có giới hạn sử dụng tài nguyên trên được chỉ định khi tạo, vì vậy khi lấy CPU và Bộ nhớ này. thông tin cần được thảo luận riêng dựa trên các trường hợp cụ thể.

Cách sử dụng Go để có được các chỉ số khác nhau của quy trình

Trước tiên, hãy thảo luận về cách lấy các chỉ báo này trong trường hợp máy chủ và máy ảo thông thường sẽ được thảo luận trong phần tiếp theo.

Việc sử dụng tài nguyên của quy trình Go có thể được hoàn thành bằng cách sử dụng thư viện gopstuil. Nó che giấu sự khác biệt giữa các hệ thống khác nhau và giúp chúng tôi dễ dàng có được thông tin phần cứng và hệ thống khác nhau. gopsutil chia các chức năng khác nhau thành các gói con khác nhau. Các mô-đun mà nó cung cấp chủ yếu bao gồm:

• cpu: mô-đun liên quan đến CPU hệ thống;
• đĩa: các mô-đun liên quan đến đĩa hệ thống;
• docker: các mô-đun liên quan đến docker;
• mem: mô-đun liên quan đến bộ nhớ;
• net: liên quan đến mạng;
• quy trình: mô-đun liên quan đến quy trình;
• winservices: Các mô-đun liên quan đến dịch vụ Windows.

Chúng tôi chỉ sử dụng gói phụ quy trình của nó ở đây để lấy thông tin liên quan đến quy trình.

Tuyên bố: Mô-đun quy trình cần được nhập vào dự án sau khi nhập "github.com/shirou/gopsutil/process". Hệ điều hành và các mô-đun khác sẽ được sử dụng trong mã trình bày sau này sẽ bỏ qua một cách thống nhất thông tin liên quan đến nhập và xử lý lỗi. , điều này sẽ được giải thích trước.

Tạo đối tượng quy trình

NewProcess của mô-đun quy trình sẽ trả về một đối tượng Quy trình chứa PID đã chỉ định. Phương thức này sẽ kiểm tra xem PID có tồn tại hay không. Nếu nó không tồn tại, chúng ta có thể nhận được nhiều thông tin khác nhau về quy trình thông qua các phương thức khác được xác định trên mô-đun quy trình. Đối tượng xử lý

1. p, _ := tiến trình. NewProcess(int32(os. Getpid()))

Xử lý việc sử dụng CPU

Việc sử dụng CPU của một tiến trình cần được tính toán bằng cách tính toán sự thay đổi thời gian sử dụng CPU của tiến trình đó trong một khoảng thời gian xác định.

1. cpuPercent, lỗi := p.Percent(thời gian.Thứ hai)

Những gì được trả về ở trên là tỷ lệ của toàn bộ thời gian CPU. Nếu muốn xem tỷ lệ một cách trực quan hơn, bạn có thể tính tỷ lệ của một lõi.

1. cp := cpuPercent / float64(runtime.NumCPU())

Mức sử dụng bộ nhớ, số lượng luồng và số lượng goroutines

Việc tiếp thu 3 chỉ số này quá đơn giản nên chúng ta hãy cùng nhau nói về chúng nhé.

1. // Lấy tỷ lệ bộ nhớ bị chiếm bởi tiến trình
2. mp, _ := p. Bộ nhớ phần trăm()
3. //Số chủ đề được tạo
4. threadCount := pprof.Lookup("tạo luồng").Đếm()
5. // số goroutine
6. gNum := thời gian chạy.NumGoroutine()

Phương pháp lấy tỷ lệ tài nguyên quy trình ở trên chỉ chính xác trong môi trường máy ảo và máy vật lý. Các bộ chứa Linux như Docker dựa vào sự cô lập quy trình và các hạn chế về tài nguyên do công nghệ Namespace và Cgroups của Linux triển khai, điều này là không khả thi.

Nhiều công ty hiện nay triển khai các cụm K8, vì vậy nếu muốn biết mức sử dụng tài nguyên của quy trình Go trong Docker, bạn cần tính toán dựa trên giới hạn trên của tài nguyên được Cgroups phân bổ cho vùng chứa cho chính xác.

Lấy các chỉ số quy trình trong môi trường container

Trong Linux, giao diện điều hành được Cgroups hiển thị cho người dùng là hệ thống tệp, được tổ chức dưới dạng tệp và thư mục theo đường dẫn /sys/fs/cgroup của hệ điều hành. Có nhiều cpuset, thư mục con như cpu và. bộ nhớ, mỗi thư mục con đại diện cho loại tài nguyên mà hệ thống hiện có thể hạn chế bởi Cgroups.

Đối với nhu cầu giám sát các chỉ số CPU và bộ nhớ tiến trình Go, chúng ta chỉ cần biết cpu.cfs_ Period_us, cpu.cfs_quota_us và Memory.limit_in_bytes. Hai tham số đầu tiên cần được sử dụng kết hợp. Chúng có thể được sử dụng để giới hạn quá trình chỉ được phân bổ tổng lượng thời gian CPU bằng cfs_quota trong một khoảng thời gian có độ dài cfs_ Period. vùng chứa có thể sử dụng = cfs_quota/cfs_ Period.

Do đó, phương pháp lấy phần CPU của tiến trình Go trong vùng chứa yêu cầu một số điều chỉnh. Hãy sử dụng công thức chúng tôi đưa ra ở trên để tính số lõi tối đa mà vùng chứa có thể sử dụng.

1. cpuPeriod, lỗi := readUint("/sys/fs/cgroup/cpu/cpu.cfs_ Period_us")
2.  
3. cpuQuota, lỗi := readUint("/sys/fs/cgroup/cpu/cpu.cfs_quota_us")
4.  
5. cpuNum := float64(cpuQuota) / float64(cpuPeriod)

Sau đó chia tỷ lệ tổng thời gian CPU của máy chiếm bởi tiến trình thu được thông qua p.Percent cho số lõi được tính toán để tính tỷ lệ của tiến trình Go trong thùng chứa.

1. cpuPercent, lỗi := p.Percent(thời gian.Thứ hai)
2.  
3. // cp := cpuPercent / float64(runtime.NumCPU())
4.  
5. //Điều chỉnh thành
6.  
7. cp := cpuPercent / cpuNum

Dung lượng bộ nhớ tối đa mà vùng chứa có thể sử dụng được chỉ định tự nhiên trong Memory.limit_in_bytes, do đó, cần phải lấy tỷ lệ bộ nhớ mà tiến trình Go chiếm giữ trong vùng chứa thông qua phương pháp sau.

1. memLimit, err := readUint("/sys/fs/cgroup/memory/memory.limit_in_bytes")
2.  
3. memInfo, lỗi := p.MemoryInfo
4.  
5. mp := memInfo.RSS * 100 / memLimit

RSS trong thông tin bộ nhớ quy trình ở trên được gọi là bộ nhớ thường trú, là dung lượng bộ nhớ được phân bổ cho quy trình trong RAM và được quy trình đó cho phép truy cập. ReadUint được sử dụng để đọc tài nguyên vùng chứa là một phương thức được cung cấp bởi tổ chức vùng chứa trong quá trình triển khai cgroups.

1. func readUint(chuỗi đường dẫn) (uint64, lỗi) {
2.  
3. v, lỗi := ioutil.ReadFile(đường dẫn)
4.  
5. nếu err != nil {
6.  
7. trở lại 0, lỗi
8.  
9. }
10.  
11. trở lại parseUint(strings.TrimSpace(string(v)), 10, 64)
12.  
13. }
14.  
15. func parseUint(s chuỗi, cơ sở, bitSize số nguyên) (uint64, lỗi) {
16.  
17. v, lỗi := strconv.ParseUint(s, cơ sở, bitSize)
18.  
19. nếu err != nil {
20.  
21. intValue, intErr := strconv.ParseInt(s, cơ sở, bitSize)
22.  
23. // 1. Xử lý tiêu cực giá trị lớn hơn MinInt64 (Và)
24.  
25. // 2. Xử lý tiêu cực giá trị nhỏ hơn MinInt64
26.  
27. if intErr == nil && intValue < 0 {
28.  
29. trở lại 0, không
30.  
31. } khác nếu intrr != nil &&
32.  
33. intErr.(*strconv.NumError).Err == strconv.ErrRange &&
34.  
35. Giá trị int < 0 {
36.  
37. trở lại 0, không
38.  
39. }
40.  
41. trở lại 0, lỗi
42.  
43. }
44.  
45. trở lại v, không
46.  
47. }

Tôi sẽ cung cấp liên kết đến mã nguồn của họ trong các liên kết tham khảo bên dưới.

Liên kết gốc: https://mp.weixin.qq.com/s/kASxY9NDYsUpDltO2U3qEw.

Cuối cùng, bài viết về việc tìm hiểu các thủ thuật này để chương trình Go tự giám sát sẽ kết thúc tại đây. Nếu bạn muốn biết thêm về việc tìm hiểu các thủ thuật này để chương trình Go tự giám sát, vui lòng tìm kiếm các bài viết của CFSDN hoặc tiếp tục duyệt qua các nội dung liên quan. Tôi hy vọng bạn sẽ ủng hộ blog của tôi trong tương lai! .