docker 容器资源监测：CPU、内存、网络接收、网络发送、磁盘读取、磁盘写入

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading;

namespace TaskStatusCheck
{
    class Program
    {
        static Timer _TimerStatusCheck = null;
        
        static void Main(string[] args)
        {
            Console.WriteLine("Hello TaskStatusCheck *****");
            _TimerStatusCheck = new Timer(TimerStatusCheckBack, null, 0, 5000);
            if (_TimerStatusCheck != null)
            {
                _TimerStatusCheck.Dispose();
                _TimerStatusCheck = null;
            }
            Console.ReadLine();
        }

        private static void TimerStatusCheckBack(object state)
        {
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            {
                //监控 cpu 和 内存使用情况
                GetCPUandMemory("Start.dll");

                //监控容器网卡的实时速率
                GetDockerReceiveAndTransmit("docker");

                //监控容器磁盘的读写实时速率
                GetDiskReadAndWrite("");
            }
            else
            {

            }
        }
        /// <summary>
        /// 监控容器磁盘的读写实时速率
        /// </summary>
        /// <param name="name"></param>
        private static void GetDiskReadAndWrite(string name)
        {
            try
            {
                var str = ExecuteCommand("iostat -dx");
                var str_l = str.Where(o => !string.IsNullOrWhiteSpace(o)).Select(o => o.Split(' ', StringSplitOptions.RemoveEmptyEntries));
                var res = str_l.Skip(2);
                var c = res.FirstOrDefault();
                var l = res.Skip(1);

                var data = l.Select(o =>
                {
                    Dictionary<string, string> temp = new Dictionary<string, string>();
                    for (var i = 0; i < c.Length; i++)
                        temp.Add(c[i], o[i]);
                    return temp;
                });

                var ps = data.FirstOrDefault();
                var read = ps["r/s"].ToString();//磁盘读取速度
                var write = ps["w/s"].ToString();//磁盘写入速度

                Console.WriteLine($"DiskRead：{read} DiskWrite：{write}");

            }
            catch (Exception ex)
            {
                Console.WriteLine("Get cpu and memory Exception：" + ex.Message);
            }
        }

        /// <summary>
        /// 监控容器网卡的实时速率
        /// </summary>
        /// <param name="name"></param>
        private static void GetDockerReceiveAndTransmit(string name)
        {
            try
            {
                //第一次获取接口发送或接收的数据的
                var str1 = ExecuteCommand("cat /proc/net/dev");
                Thread.Sleep(1000);
                //第二次获取接口发送或接收的数据的
                var str2 = ExecuteCommand("cat /proc/net/dev");

                //第一次接收到的数据
                var firstData = GetFormatData(str1);
                var firstPs = firstData.FirstOrDefault(o => o["face"].Contains(name));
                //第一次收包
                var firstReceive = Convert.ToInt64(firstPs["|bytes"]);
                //第一次发包
                var firstTransmit = Convert.ToInt64(firstPs["multicast|bytes"]);

                //第二次接收到的数据
                var secondData = GetFormatData(str2);
                var secondPs = secondData.FirstOrDefault(o => o["face"].Contains(name));
                //第二次收包
                var secondReceive = Convert.ToInt64(firstPs["|bytes"]);
                //第二次发包
                var secondTransmit = Convert.ToInt64(firstPs["multicast|bytes"]);

                //接收速率
                var receive = (secondReceive - firstReceive) / 1024;
                //读取速率
                var transmit = (secondTransmit - firstTransmit) / 1024;

                Console.WriteLine($"DockerReceive：{receive} DockerTransmit：{transmit}");
            }
            catch (Exception ex)
            {
                Console.WriteLine("Get receive and transmit Exception：" + ex.Message);
            }
        }

        private static IEnumerable<Dictionary<string, string>> GetFormatData(string[] str1)
        {
            var str_1 = str1.Where(o => !string.IsNullOrWhiteSpace(o)).Select(o => o.Split(' ', StringSplitOptions.RemoveEmptyEntries));
            var str_2 = str_1.Skip(1);
            var c = str_2.FirstOrDefault();
            var l = str_2.Skip(1);

            var data = l.Select(o =>
            {
                Dictionary<string, string> temp = new Dictionary<string, string>();
                for (var i = 0; i < c.Length; i++)
                   temp.Add(c[i], o[i]);
                return temp;
            });
            return data;
        }

        private static void GetCPUandMemory(string processType)
        {
            try
            {
                var str = ExecuteCommand("ps -aux");
                var str_l = str.Where(o => !string.IsNullOrWhiteSpace(o)).Select(o => o.Split(' ', StringSplitOptions.RemoveEmptyEntries));
                var c = str_l.FirstOrDefault();
                var l = str_l.Skip(1);

                var data = l.Select(o =>
                {
                    Dictionary<string, string> temp = new Dictionary<string, string>();
                    for (var i = 0; i < c.Length; i++)
                    {
                        if (i == 10)
                        {
                            temp.Add(c[i], string.Join(" ", o.Skip(10))); 
                        }
                        else { 
                            temp.Add(c[i], o[i]);
                        }
                    }
                    return temp;
                });

                var ps = data.FirstOrDefault(o => o["COMMAND"].Contains(processType));
                var cpuPercent = Convert.ToDouble(ps["%CPU"]);//CPU 占用比例

                var memoryValue = Convert.ToInt64(ps["RSS"]);//真实内存
                var memoryPercent = Convert.ToDouble(ps["%MEM"]);//内存占用比例
                var memoryOther = Convert.ToInt64(ps["VSZ"]);//虚拟内存
                
                Console.WriteLine($"CPU：{cpuPercent} Memory：{memoryPercent} RSS：{memoryPercent} VSZ：{memoryOther}");
            }
            catch (Exception ex)
            {
                Console.WriteLine("Get cpu and memory Exception：" + ex.Message);
            }
        }

        /// <summary>
        /// 执行 linux命令
        /// </summary>
        /// <param name="pmCommand"></param>
        /// <returns></returns>
        static string[] ExecuteCommand(string pmCommand)
        {
            var process = new System.Diagnostics.Process
            {
                StartInfo = new System.Diagnostics.ProcessStartInfo("/bin/bash", "")
            };
            process.StartInfo.RedirectStandardInput = true;
            process.StartInfo.RedirectStandardOutput = true;
            process.StartInfo.UseShellExecute = false;
            process.Start();
            process.StandardInput.WriteLine(pmCommand);
            //process.StandardInput.WriteLine("netstat -an |grep ESTABLISHED |wc -l");
            process.StandardInput.Close();
            var cpuInfo = process.StandardOutput.ReadToEnd();
            process.WaitForExit();
            process.Dispose();
            var lines = cpuInfo.Split('\n');
            return lines;
        }

    }
}