prometheus及gpu,k8s

##一，物理節點安裝配置（簡單配置，未涉及報警及grafana圖形展現）html

1，prometheus 官網下載安裝node

下載安裝
# pwd
/usr/local/src
https://github.com/prometheus/prometheus/releases/download/v2.12.0/prometheus-2.12.0.linux-amd64.tar.gz
# tar xvf prometheus-2.11.1.linux-amd64.tar.gz
# ln -sv /usr/local/src/prometheus-2.11.1.linux-amd64 /usr/local/prometheus
# cd /usr/local/prometheus

服務啓動腳本
# vim /etc/systemd/system/prometheus.service
[Unit]
Description=Prometheus Server
Documentation=https://prometheus.io/docs/introduction/overview/
After=network.target
[Service]
Restart=on-failure
WorkingDirectory=/usr/local/prometheus/
ExecStart=/usr/local/prometheus/prometheus --
config.file=/usr/local/prometheus/prometheus.yml
[Install]
WantedBy=multi-user.target

配置所監控的node
cd /usr/local/prometheus
# grep -v "#" prometheus.yml | grep -v "^$"
global:
alerting:
  alertmanagers:
  - static_configs:
    - targets:
rule_files:
scrape_configs:
  - job_name: 'prometheus'
    static_configs:
    - targets: ['localhost:9090']
  - job_name: 'promethues-node'
    static_configs:
    - targets: ['192.168.7.110:9100','192.168.7.111:9100']


修改配置文件後須要重啓服務
啓動
# systemctl daemon-reload
# systemctl restart prometheus
# systemctl enable prometheus
查看端口是否監聽正常

2,節點安裝mysql

# pwd
/usr/local/src

https://github.com/prometheus/node_exporter/releases/download/v0.18.1/node_exporter-0.18.1.linux-amd64.tar.gz
# tar xvf node_exporter-0.18.1.linux-amd64.tar.gz
# ln -sv /usr/local/src/node_exporter-0.18.1.linux-amd64 /usr/local/node_exporter
# cd /usr/local/node_exporter


啓動腳本
# vim /etc/systemd/system/node-exporter.service
[Unit]
Description=Prometheus Node Exporter
After=network.target
[Service]
ExecStart=/usr/local/node_exporter/node_exporter
[Install]
WantedBy=multi-user.target


啓動
# systemctl daemon-reload
# systemctl restart node-exporter
# systemctl enable node-exporter
 
查看端口是否監聽正常，關閉防火牆和selinxu

3，監控k8slinux

參考https://github.com/NVIDIA/gpu-monitoring-tools/tree/master/exporters/prometheus-dcgmios

起gpu特定容器作監控git

#######################################################github

docker 使用GPU

查看docker 使用的runtimegolang

docker   info  |  grep  Runtime
更改默認的runtime 
配置daemon的默認運行時
是否已安裝
ls  /usr/bin/nvidia-container-runtime
nvidia-docker 命令是否出現
指定默認的runtime    "default-runtime": "nvidia"  添加加速代理鏡像源

vim  /etc/docker/daemon.json 
{
    "default-runtime": "nvidia",
    "runtimes": {
        "nvidia": {
            "path": "/usr/bin/nvidia-container-runtime",
            "runtimeArgs": [],
            "registry-mirrors": ["https://gemfield.mirror.aliyuncs.com"]
        }
    }
}

重啓服務
	sudo systemctl restart docker
	
	ldconfig -p 
	 dpkg -S /usr/lib/x86_64-linux-gnu/libcuda.so.1   dpkg -S命令來檢查下它屬於哪一個package

https://gitlab.com/nvidia/cuda/blob/master/dist/ubuntu16.04/10.1/base/Dockerfileweb

apt-get install pciutils
apt-get install kmod    安裝lspci
 apt install dirmngr

https://github.com/NVIDIA/nvidia-docker
 Docker中使用GPU
https://cloud.tencent.com/developer/article/1142345
 
 export DEVICES=$(\ls /dev/nvidia* | xargs -I{} echo '--device {}:{}')
docker run -it --rm $DEVICES -v /usr/lib64/nvidia/:/usr/local/nvidia/lib64 tensorflow/tensorflow:latest-gpu bash


#nvidia-docker run -it -p 8888:8888 --name ten tensorflow/tensorflow:0.11.0rc0-gpu  /bin/sh

jupyter_jianhang_v5.1_gpu


進入容器輸入nvidia-smi，輸入顯卡信息，說明安裝是正確的。

製做docker 鏡像 Anaconda3 + tensorflow-gpu part2 Dockerfile nvidia docker
https://blog.csdn.net/weixin_41270857/article/details/83449964

指定顯存大小使用gpu正則表達式

https://yq.aliyun.com/articles/690623?utm_content=g_1000041607

在k8s上調度GPU

http://longlongloves.life/2018-05-23/%E5%9C%A8k8s%E4%B8%8A%E8%B0%83%E5%BA%A6GPU.html

Kubernetes 多container組成的Pod

https://blog.csdn.net/liumiaocn/article/details/52490444

kubernetes單個pod運行兩個容器yaml文件實踐
https://blog.csdn.net/zhangxiangui40542/article/details/63273746

Docker 及 nvidia-docker 使用
https://www.cnblogs.com/makefile/p/docker-usage.html



 sudo -u nvidia-docker sh -c 'echo $PATH'  /sbin:/bin:/usr/sbin:/usr/bin

安裝 CUDA

安裝步驟官網
https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#verify-you-have-cuda-enabled-system
博客
https://blog.csdn.net/weixin_42652125/article/details/81178943
https://www.cnblogs.com/luofeel/p/8654964.html
https://blog.csdn.net/QLULIBIN/article/details/78714596


ubuntu安裝cuda驅動實現nvidia-smi命令
https://blog.csdn.net/weixin_42652125/article/details/81178943

顯卡監控

顯卡信息
lspci | grep -i vga
使用nvidia GPU能夠：
lspci | grep -i nvidia
[GeForce GTX 960M] (rev a2)
命令行中輸入cat /proc/driver/nvidia/version查看顯卡信息

https://us.download.nvidia.cn/XFree86/Linux-x86_64/384.130/NVIDIA-Linux-x86_64-384.130.run  

前邊的序號 "00:0f.0"是顯卡的代號(這裏是用的虛擬機);
查看指定顯卡的詳細信息用如下指令：
lspci -v -s 00:0f.0
nvidia-smi

表頭釋義：
Fan：顯示風扇轉速，數值在0到100%之間，是計算機的指望轉速，若是計算機不是經過風扇冷卻或者風扇壞了，顯示出來就是N/A；
Temp：顯卡內部的溫度，單位是攝氏度；
Perf：表徵性能狀態，從P0到P12，P0表示最大性能，P12表示狀態最小性能；
Pwr：GPU能耗表示；
Bus-Id：涉及GPU總線的相關信息；
Disp.A：是Display Active的意思，表示GPU的顯示是否初始化；
Memory Usage：顯存的使用率；
Volatile GPU-Util：浮動的GPU利用率；
Compute M：計算模式；
下邊的Processes顯示每塊GPU上每一個進程所使用的顯存狀況。

若是要週期性的輸出顯卡的使用狀況，能夠用watch指令實現：

watch -n 10 nvidia-smi

#nvidia-smi
 nvidia-smi -L     #列出gpu 及id 
 GPU 0: GeForce GTX 960M (UUID: GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97)
 
nvidia-smi –i   gpuid   # 指定gpuid  0,1,2,
nvidia-smi –l xxx
動態刷新信息（默認5s刷新一次），按Ctrl+C中止，可指定刷新頻率，以秒爲單位
nvidia-smi –f xxx
將查詢的信息輸出到具體的文件中，不在終端顯示
nvidia-smi -q   查詢全部GPU的當前詳細信息
nvidia-smi –q –i xxx
指定具體的GPU或unit信息
nvidia-smi –q –f xxx
將查詢的信息輸出到具體的文件中，不在終端顯示
nvidia-smi –q –x
將查詢的信息以xml的形式輸出
nvidia-smi -q –d xxx
指定顯示GPU卡某些信息，xxx參數能夠爲MEMORY, UTILIZATION, ECC, TEMPERATURE, POWER,CLOCK, COMPUTE, PIDS, PERFORMANCE, SUPPORTED_CLOCKS, PAGE_RETIREMENT,ACCOUNTING
nvidia-smi –q –l xxx
動態刷新信息，按Ctrl+C中止，可指定刷新頻率，以秒爲單位
nvidia-smi --query-gpu=gpu_name,gpu_bus_id,vbios_version--format=csv
選擇性查詢選項，能夠指定顯示的屬性選項
可查看的屬性有：timestamp，driver_version，pci.bus，pcie.link.width.current等。（可查看nvidia-smi--help-query–gpu來查看有哪些屬性）

2.3  設備修改選項
能夠手動設置GPU卡設備的狀態選項
nvidia-smi –pm 0/1
設置持久模式：0/DISABLED,1/ENABLED
nvidia-smi –e 0/1
切換ECC支持：0/DISABLED, 1/ENABLED
nvidia-smi –p 0/1
重置ECC錯誤計數：0/VOLATILE, 1/AGGREGATE
nvidia-smi –c
設置計算應用模式：0/DEFAULT,1/EXCLUSIVE_PROCESS,2/PROHIBITED
nvidia-smi –r
GPU復位
nvidia-smi –vm
設置GPU虛擬化模式
nvidia-smi –ac xxx,xxx
設置GPU運行的工做頻率。e.g. nvidia-smi –ac2000,800
nvidia-smi –rac
將時鐘頻率重置爲默認值
nvidia-smi –acp 0/1
切換-ac和-rac的權限要求，0/UNRESTRICTED, 1/RESTRICTED
nvidia-smi –pl
指定最大電源管理限制（瓦特）
nvidia-smi –am 0/1
啓用或禁用計數模式，0/DISABLED,1/ENABLED
nvidia-smi –caa
清除緩衝區中的全部已記錄PID，0/DISABLED,1/ENABLED

nvidia-smi pmon
nvidia-smi pmon –i xxx
用逗號分隔GPU索引，PCI總線ID或UUID
nvidia-smi pmon –d xxx
指定刷新時間（默認爲1秒，最大爲10秒）
nvidia-smi pmon –c xxx
顯示指定數目的統計信息並退出
nvidia-smi pmon –s xxx
指定顯示哪些監控指標（默認爲u），其中：
u：GPU使用率
m：FB內存使用狀況
nvidia-smi pmon –o D/T
指定顯示的時間格式D：YYYYMMDD，THH:MM:SS
nvidia-smi pmon –f xxx
將查詢的信息輸出到具體的文件中，不在終端顯示

阿里雲GPU監控指標

MetricName	單位	名稱
gpu_memory_freespace	Byte	GPU維度顯存空閒量
gpu_memory_totalspace	Byte	GPU維度顯存總量
gpu_memory_usedspace	Byte	GPU維度顯存使用量
gpu_gpu_usedutilization	%	GPU維度GPU使用率
gpu_encoder_utilization	%	GPU維度編碼器使用率
gpu_decoder_utilization	%	GPU維度解碼器使用率
gpu_gpu_temperature	℃	GPU維度GPU溫度
gpu_power_readings_power_draw	W	GPU維度GPU功率
gpu_memory_freeutilization	%	GPU維度顯存空閒率
gpu_memory_useutilization	%	GPU維度顯存使用率

基於阿里雲容器服務監控 Kubernetes集羣GPU指標 https://www.jianshu.com/p/1c7ddf18e8b2

檢測腳本 #未測試
monitor.sh
GPU跨平臺通用監控腳本
功能： Useage: monitor.sh fast|mem|gpu|temp|all|[pathToLog sleepTimeNum]
注意： ./monitor.sh fast速度最快

#nvidia-smi pmon -h#!/bin/bash
#. /etc/profile
#. ~/.bash_profile
#. ~/.bashrc
# 判斷nvidia-smi命令是否存在
#/usr/bin/nvidia-smi > /dev/nullif 
# if [ $? -eq 0 ];then  
#       echo 'nvidia-smi check pass' `date`
#    else  
#       echo 'nvidia-smi not exists'   
#       exit 1
#  fi

        # 獲取GPU Count
  get_gpu_list()
 {
        count=`nvidia-smi -L|wc -l` 
        echo $count
  }
        #獲取GPU id對應uuid
get_uuid()
{
    uuid=`nvidia-smi -q -i $1|grep 'UUID'|awk '{print $4}'`   echo $uuid
}
    #獲取顯存使用率 
get_memory_usage()
{
    usage=`nvidia-smi -q -d MEMORY -i $1|grep -E 'Total|Used'|head -2|awk '{print $3}'|xargs echo|awk '{print $2/$1}'`   
    echo $usage
} 
   #獲取內存詳細信息
get_memory_detail()
{
    detail=`nvidia-smi -q -d MEMORY -i $1|grep -E 'Total|Used|Free'|head -3|awk '{print $3}'|xargs echo`  
    echo $detail
} 
   #獲取GPU使用率
 get_volatile_gpu(){

    vol=`nvidia-smi -q -d UTILIZATION -i $1 |grep -A 5 "GPU Utilization"|tail -1|awk '{print $3}'`  
    echo $vol
}
    #獲取GPU Current 溫度
 get_temperature()
{  
    temp=`nvidia-smi -q -d Temperature -i $1|grep 'GPU Current'|awk '{print $5}'`  
    echo $temp
}
    #獲取Pod_id
get_pod_id()
{
    echo `hostname`
} 
#數據output
    #output $1 $2 $3 $4 $5
    #$1 字段名 $2 pod_id $3 gpu編號 $4 uuid $5 監控值
output(){
    echo $1"{podid=\""$2"\",gpu=\""$3"\",uuid=\""$4"\"}" $5
}   
 #輸出mem prometheus格式數據
    #dcgm_mem_usage{pod_id="localhost"}
mem_prm()
{ 
  for((i=0;i<`get_gpu_list`;i++)) 
    do      
    name="dcgm_mem_usage"     
    pod_id=`get_pod_id`      
    uuid=`get_uuid $i`     
    value=`get_memory_usage $i`      
    output $name $pod_id $i $uuid $value  
    done
}
  #輸出mem detail prometheus格式數據#dcgm_mem_detail{pod_id="localhost"}
 mem_detail_prm()
    { 
    for((i=0;i<`get_gpu_list`;i++)) 
    do    
    pod_id=`get_pod_id`      
    uuid=`get_uuid $i`    
    value=`get_memory_detail $i`    
    output "dcgm_fb_total" $pod_id $i $uuid `echo $value|awk '{print $1}'`     
    output "dcgm_fb_used" $pod_id $i $uuid `echo $value|awk '{print $2}'`      
    output "dcgm_fb_free" $pod_id $i $uuid `echo $value|awk '{print $3}'`  
    done
    }
    #輸出gpu prometheus格式數據
    #dcgm_gpu_utilization{...}
 gpu_prm()
    {
    for((i=0;i<`get_gpu_list`;i++)) 
    do       
    name="dcgm_gpu_utilization"       
    pod_id=`get_pod_id`      
    uuid=`get_uuid $i`     
    value=`get_volatile_gpu $i`     
    output $name $pod_id $i $uuid $value  
    done
    }
    #輸出溫度 prometheus格式數據
    #dcgm_temp{...}
 temp_prm()
    {  
    for((i=0;i<`get_gpu_list`;i++)) 
    do      
    name="dcgm_temp"   
    pod_id=`get_pod_id`      
    uuid=`get_uuid $i`   
    value=`get_temperature $i`   
    output $name $pod_id $i $uuid $value  
    done
    }
allinone()
    { 
    mem_prm  
    mem_detail_prm 
    gpu_prm  
    temp_prm
    }
    #快速獲取
 fast()
    {  
    nvidia-smi -q > /tmp/1 
    num=0  
    count=0 
    uuid=''  
    first=0   
    for i in `cat /tmp/1|grep -E 'Minor Number|UUID|GPU Current Temp|Gpu|Total|Used|Free'|cut -d ':' -f2|awk '{print $1}'`  
    do   
    if [ $num -eq 0 ];then      
    uuid=$i   
    elif [ $num -eq 1 ];then   
    count=$i    
    elif [ $num -eq 2 ];then  
    if [ $first -lt 13 ];then   
    echo '# HELP dcgm_fb_total Framebuffer memory total (in MiB).'          
    echo '# TYPE dcgm_fb_total gauge'        
    fi        
    output 'dcgm_fb_total' ${HOSTNAME} $count $uuid $i   
    elif [ $num -eq 3 ];then        
    if [ $first -lt 13 ];then          
    echo '# HELP dcgm_fb_used Framebuffer memory used (in MiB).'          
    echo '# TYPE dcgm_fb_used gauge'      
    fi       
    output 'dcgm_fb_used' ${HOSTNAME} $count $uuid $i  
    elif [ $num -eq 4 ];then     
    if [ $first -lt 13 ];then       
    echo '# HELP dcgm_fb_free Framebuffer memory free (in MiB).'          
    echo '# TYPE dcgm_fb_free gauge'       
    fi       
    output 'dcgm_fb_free' ${HOSTNAME} $count $uuid $i  
    elif [ $num -eq 8 ];then     
    if [ $first -lt 13 ];then      
    echo '# HELP dcgm_gpu_utilization GPU utilization (in %).'      
    echo '# TYPE dcgm_gpu_utilization gauge'   
    fi        
    output 'dcgm_gpu_utilization' ${HOSTNAME} $count $uuid $i   
    elif [ $num -eq 13 ];then     
    if [ $first -le 13 ];then       
    echo '# HELP dcgm_gpu_temp GPU temperature (in C).'          
    echo '# TYPE dcgm_gpu_temp gauge'        
    fi     
    output 'dcgm_gpu_temp' ${HOSTNAME} $count $uuid $i 
    fi    
    if [ $num -eq 13 ];then     
    num=0    
    else        
    ((num++))    
    fi     
    ((first++)) 
    done
    }
    case $1 in  "help")     
    echo 'Useage: monitor.sh fast|mem|gpu|temp|all|[pathToLog sleepTimeNum]' 
    ;; 
    "mem")     
    mem_prm        
    mem_detail_prm 
    ;;  
    "gpu")     
    gpu_prm  
    ;; 
    "temp")   
    temp_prm  
    ;; 
    "fast")   
    fast 
    ;;  
    "all") 
    allinone 
    ;; 
    "onebyone")  
    if [ ! -n "$1" ];then    
    if [ ! -d "/run/prometheus" ];then 
    mkdir -p /run/prometheus       
    fi       
    while true;do allinone > /run/prometheus/`hostname`_dcgm.prom;sleep 15;done   
    else       
    if [ ! -n "$2" ];then  
    while true;do allinone > $1;sleep 15;done       
    else         
    while true;do allinone > $1;sleep $2;done    
    fi    
    
    fi  
    ;;  
    *)  
    if [ ! -n "$1" ];then      
    if [ ! -d "/run/prometheus" ];then     
    mkdir -p /run/prometheus      
    fi     
    while true;do fast > /run/prometheus/`hostname`_dcgm.prom;sleep 15;done  
    else      
    if [ ! -n "$2" ];then    
    while true;do fast > $1;sleep 15;done 
    else          
    while true;do fast > $1;sleep $2;done      
    fi   
    fi  
    ;;
    esac

一，PGME監控

監控物理節點，監控指標較少

Prometheus GPU Metrics Exporter (PGME)
** https://github.com/chhibber/pgme  
#安裝
Local Linux Build (Genrates a binary that works on Linuxsystems)

1,go環境配置
go包下載
https://studygolang.com/dl
解壓安裝
sudo tar -zxvf go1.10.linux-386.tar.gz -C /opt
檢測
./opt/go/bin/go version
環境變量
vi /etc/profile
export GOPATH="/root/go"
export GOROOT="/opt/golang/go"
export GOARCH="amd64"
export GOOS=linux
#export GOTOOLS=$GOROOT/pkg/tool
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
source /etc/profile

2，安裝編譯pgme 
git  clone https://github.com/chhibber/pgme.git
cd pgme
make build
3,運行
#The default port is 9101，前臺進程運行
PORT=9101 ./pgme
4，訪問
http://localhost:9101/metrics
temperature_gpu{gpu="GeForce GTX 960M[0]"} 38
utilization_gpu{gpu="GeForce GTX 960M[0]"} 0
utilization_memory{gpu="GeForce GTX 960M[0]"} 0
memory_total{gpu="GeForce GTX 960M[0]"} 4044
memory_free{gpu="GeForce GTX 960M[0]"} 4043
memory_used{gpu="GeForce GTX 960M[0]"} 1


5，Prometheus example config
- job_name: "gpu_exporter"
  static_configs:
  - targets: ['localhost:9101']

二，Prometheus 自定義exporter 監控key

當Prometheus的node_exporter中沒有咱們須要的一些監控項時，就能夠如zabbix同樣定製一些key，讓其支持咱們所須要的監控項。node_exporter 可在啓動時指定路徑，並將該路徑下的 *.prom 識別爲監控數據文件。
1,獲取腳本值
cat /usr/local/node_exporter/key/key_runner 
#! /bin/bash
echo Logical_CPU_core_total  `cat /proc/cpuinfo| grep "processor"| wc -l`
echo logined_users_total     `who | wc -l`;
echo procs_total `ps aux|wc -l`
echo procs_zombie       `ps axo pid=,stat=|grep Z|wc -l`
執行測試
bash  /usr/local/node_exporter/key/key_runner 

設定定時任務
* * * * * bash /usr/local/node_exporter/key/key_runner > /usr/local/node_exporter/key/key.prom

添加啓動參數（在node_exporter 可執行目錄下）
啓動node_exporter，指定新加key值的prom路徑
./node_exporter --collector.textfile.directory=/usr/local/node_exporter/key

驗證 
curl 127.0.0.1:9100/metrics|grep -E "Logical_CPU_core_total|logined_users_total|procs_total|procs_zombie"

################################################
可以使用nvidia-smi 自定義監控項進行監控

三，NVIDIA DCGM exporter for Prometheus (容器)

nvidia-container-runtime
https://github.com/NVIDIA/nvidia-docker

https://github.com/NVIDIA/gpu-monitoring-tools/blob/master/exporters/prometheus-dcgm/README.md

#注意
Prerequisites
NVIDIA Tesla drivers = R384+ (download from NVIDIA Driver Downloads page)
nvidia-docker version > 2.0 (see how to install and it's prerequisites)
Optionally configure docker to set your default runtime to nvidia


1,肯定是否爲DGCM支持的GPUS
$ docker run --runtime=nvidia --rm --name=nvidia-dcgm-exporter nvidia/dcgm-exporter
$ docker exec nvidia-dcgm-exporter dcgmi discovery -i a -v | grep -c 'GPU ID:'

$ nvidia-smi -L | wc -l
二者輸出一至，不然執行腳本失敗


2，Bare-metal install
$ cd bare-metal
$ sudo make install
$ sudo systemctl start prometheus-dcgm

或 docker  install 
$ cd docker
$ docker-compose up


3，docker 運行測試 #（已測試）docker 運行環境須要nvidia
$ docker run -d --runtime=nvidia --rm --name=nvidia-dcgm-exporter -v /run/prometheus:/run/prometheus nvidia/dcgm-exporter

# To check the metrics
$ cat /run/prometheus/dcgm.prom

# If you want to add GPU metrics directly to node-exporter container
$ docker run -d --rm --net="host" --pid="host" --volumes-from nvidia-dcgm-exporter:ro quay.io/prometheus/node-exporter --collector.textfile.directory="/run/prometheus"

$ curl localhost:9100/metrics

3,docker 測試結果
# HELP dcgm_dec_utilization Decoder utilization (in %).
# TYPE dcgm_dec_utilization gauge  解碼使用率
dcgm_dec_utilization{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 0


# HELP dcgm_ecc_dbe_volatile_total Total number of double-bit volatile ECC errors.  雙位易失性ECC錯誤的總數
# TYPE dcgm_ecc_dbe_volatile_total counter
dcgm_ecc_dbe_volatile_total{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 0


# HELP dcgm_ecc_sbe_volatile_total Total number of single-bit volatile ECC errors.   單位易失性ECC錯誤的總數
# TYPE dcgm_ecc_sbe_volatile_total counter
dcgm_ecc_sbe_volatile_total{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 0

# HELP dcgm_enc_utilization Encoder utilization (in %).
# TYPE dcgm_enc_utilization gauge   GPU維度編碼器使用率
dcgm_enc_utilization{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 0 

# HELP dcgm_fb_free Framebuffer memory free (in MiB).
# TYPE dcgm_fb_free gauge    幀緩衝區空閒內存
dcgm_fb_free{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 4043

# HELP dcgm_fb_used Framebuffer memory used (in MiB).
# TYPE dcgm_fb_used gauge   幀緩衝區使用內存
dcgm_fb_used{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 1


# HELP dcgm_gpu_temp GPU temperature (in C).
# TYPE dcgm_gpu_temp gauge    GPU溫度
dcgm_gpu_temp{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 37  


# HELP dcgm_gpu_utilization GPU utilization (in %).
# TYPE dcgm_gpu_utilization gauge  GPU利用率
dcgm_gpu_utilization{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 0  


# HELP dcgm_mem_copy_utilization Memory utilization (in %).
# TYPE dcgm_mem_copy_utilization gauge  顯存利用率
dcgm_mem_copy_utilization{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 0


# HELP dcgm_memory_clock Memory clock frequency (in MHz).
# TYPE dcgm_memory_clock gauge    顯存時鐘頻率
dcgm_memory_clock{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 405  


# HELP dcgm_pcie_replay_counter Total number of PCIe retries.
# TYPE dcgm_pcie_replay_counter counter     PCIe重試總數
dcgm_pcie_replay_counter{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 0  


# HELP dcgm_pcie_rx_throughput Total number of bytes received through PCIe RX (in KB)
# TYPE dcgm_pcie_rx_throughput counter    經過PCIe RX接收的總字節數
dcgm_pcie_rx_throughput{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 3 


# HELP dcgm_pcie_tx_throughput Total number of bytes transmitted through PCIe TX (in KB) 
# TYPE dcgm_pcie_tx_throughput counter    經過PCIe RX發送的總字節數
dcgm_pcie_tx_throughput{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 16  


# HELP dcgm_power_violation Throttling duration due to power constraints (in us).
# TYPE dcgm_power_violation counter   因爲功率限制致使的節流持續時間
dcgm_power_violation{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 0  


# HELP dcgm_sm_clock SM clock frequency (in MHz).
# TYPE dcgm_sm_clock gauge     SM時鐘頻率
dcgm_sm_clock{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 135  


# HELP dcgm_sync_boost_violation Throttling duration due to sync-boost constraints (in us).    因爲同步 - 加強約束致使的節流持續時間
# TYPE dcgm_sync_boost_violation counter
dcgm_sync_boost_violation{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 0   


# HELP dcgm_thermal_violation Throttling duration due to thermal constraints (in us).    因爲熱約束的節流持續時間
# TYPE dcgm_thermal_violation counter
dcgm_thermal_violation{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 0   


# HELP dcgm_xid_errors Value of the last XID error encountered.
# TYPE dcgm_xid_errors gauge    遇到的最後一個XID錯誤的值
dcgm_xid_errors{gpu="0",uuid="GPU-4d52e430-b8c7-a0b9-7fda-4aa825af5c97"} 0

四，監控POD gpu metrics

go 編寫的服務

If you want to get per pod GPU metrics directly in Prometheus, deploy pod-gpu-metrics-exporter.
https://github.com/NVIDIA/gpu-monitoring-tools/tree/master/exporters/prometheus-dcgm/k8s/pod-gpu-metrics-exporter#pod-gpu-metrics-exporter

#Prerequisites
NVIDIA Tesla drivers = R384+ (download from NVIDIA Driver Downloads page)
nvidia-docker version > 2.0 (see how to install and it's prerequisites)
Set the default runtime to nvidia
Kubernetes version = 1.13
Set KubeletPodResources in /etc/default/kubelet: KUBELET_EXTRA_ARGS=--feature-gates=KubeletPodResources=true

####Deploy on Kubernetes cluster
# Deploy nvidia-k8s-device-plugin

# Deploy GPU Pods

# Create the monitoring namespace
$ kubectl create namespace monitoring

# Add gpu metrics endpoint to prometheus
$ kubectl create -f prometheus/prometheus-configmap.yaml

# Deploy prometheus
$ kubectl create -f prometheus/prometheus-deployment.yaml

$ kubectl create -f pod-gpu-metrics-exporter-daemonset.yaml

# Open in browser: localhost:9090
----------------------------------------------------------------
####Docker Build and Run
$ docker build -t pod-gpu-metrics-exporter .

# Make sure to run dcgm-exporter
$ docker run -d --runtime=nvidia --rm --name=nvidia-dcgm-exporter nvidia/dcgm-exporter

$ docker run -d --privileged --rm -p 9400:9400 -v /var/lib/kubelet/pod-resources:/var/lib/kubelet/pod-resources --volumes-from nvidia-dcgm-exporter:ro nvidia/pod-gpu-metrics-exporter:v1.0.0-alpha

# Check GPU metrics
$ curl -s localhost:9400/gpu/metrics

# Sample output

# HELP dcgm_gpu_temp GPU temperature (in C).
# TYPE dcgm_gpu_temp gauge
dcgm_gpu_temp{container_name="pod1-ctr",gpu="0",pod_name="pod1",pod_namespace="default",uuid="GPU-2b399198-c670-a848-173b-d3400051a200"} 33
dcgm_gpu_temp{container_name="pod1-ctr",gpu="1",pod_name="pod1",pod_namespace="default",uuid="GPU-9567a9e7-341e-bb7e-fcf5-788d8caa50f9"} 34
# HELP dcgm_gpu_utilization GPU utilization (in %).
# TYPE dcgm_gpu_utilization gauge
dcgm_gpu_utilization{container_name="pod1-ctr",gpu="0",pod_name="pod1",pod_namespace="default",uuid="GPU-2b399198-c670-a848-173b-d3400051a200"} 0
dcgm_gpu_utilization{container_name="pod1-ctr",gpu="1",pod_name="pod1",pod_namespace="default",uuid="GPU-9567a9e7-341e-bb7e-fcf5-788d8caa50f9"} 0
# HELP dcgm_low_util_violation Throttling duration due to low utilization (in us).
# TYPE dcgm_low_util_violation counter
dcgm_low_util_violation{container_name="pod1-ctr",gpu="0",pod_name="pod1",pod_namespace="default",uuid="GPU-2b399198-c670-a848-173b-d3400051a200"} 0
dcgm_low_util_violation{container_name="pod1-ctr",gpu="1",pod_name="pod1",pod_namespace="default",uuid="GPU-9567a9e7-341e-bb7e-fcf5-788d8caa50f9"} 0
# HELP dcgm_mem_copy_utilization Memory utilization (in %).
# TYPE dcgm_mem_copy_utilization gauge
dcgm_mem_copy_utilization{container_name="pod1-ctr",gpu="0",pod_name="pod1",pod_namespace="default",uuid="GPU-2b399198-c670-a848-173b-d3400051a200"} 0
dcgm_mem_copy_utilization{container_name="pod1-ctr",gpu="1",pod_name="pod1",pod_namespace="default",uuid="GPU-9567a9e7-341e-bb7e-fcf5-788d8caa50f9"} 0
# HELP dcgm_memory_clock Memory clock frequency (in MHz).
# TYPE dcgm_memory_clock gauge
dcgm_memory_clock{container_name="pod1-ctr",gpu="0",pod_name="pod1",pod_namespace="default",uuid="GPU-2b399198-c670-a848-173b-d3400051a200"} 810
dcgm_memory_clock{container_name="pod1-ctr",gpu="1",pod_name="pod1",pod_namespace="default",uuid="GPU-9567a9e7-341e-bb7e-fcf5-788d8caa50f9"} 810

五,基於阿里雲容器服務監控 Kubernetes集羣GPU指標

六，k8s+promethues

k8s 配置插件使用gpu
https://github.com/NVIDIA/k8s-device-plugin
調度 GPU
https://kubernetes.io/zh/docs/tasks/manage-gpus/scheduling-gpus/

在k8s 上監控gpu

1，建立prometheus server 端

用DaemonSet生成，在每個節點生成prometheus-server  （訪問每個k8s node 均可以訪問到prometheus）
配置文件使用ConfigMap生成

##prometheus理論

一，監控項

https://www.gitbook.com/book/songjiayang/prometheus/details （Prometheus 實戰） 
https://github.com/1046102779/prometheus （Prometheus 非官方中文手冊）
http://www.bubuko.com/infodetail-2004088.html （基於prometheus監控k8s集羣）
http://www.cnblogs.com/sfnz/p/6566951.html （安裝prometheus+grafana監控mysql redis kubernetes等，非docker安裝）
https://github.com/kayrus/prometheus-kubernetes （prometheus-kubernetes）
https://github.com/prometheus/node_exporter （prometheus/node_exporter）
http://dockone.io/article/2579 （ Prometheus在Kubernetes下的監控實踐）
https://github.com/prometheus/prometheus/releases （prometheus 下載列表）
https://github.com/prometheus/node_exporter/releases/ （node_exporter下載列表）

前提概念：
1.時間序列是指將同一統計指標的數值按其發生的時間前後順序排列而成的數列
2.     
=：選擇正好相等的字符串標籤
!=：選擇不相等的字符串標籤
=~：選擇匹配正則表達式的標籤（或子標籤）
!~：選擇不匹配正則表達式的標籤（或子標籤）
3.
s：seconds
m：minutes
h：hours
d：days
w：weeks
y：years
       注： [5m]指過去的5分鐘內
4.操做符
bool
and
or
unless
on
without ： without（label）在結果中移除括號內的標籤和值
by ： by（label）在結果中只保留括號內的標籤和值

1.CPU空閒率
sum(irate(node_cpu{mode="idle", instance="134node"}[1m])) * 100 / count_scalar(node_cpu{mode="user", instance="134node"})

註釋：
## instance：指的是label，具體根據實際配置，也可用正則匹配
## mode :      指cpu模式，node-exporter已經抓取出來，能夠在node-exporter部署ip：9100這個網址上查看例如：http://172.17.123.134:9100/metrics
## sum()函數： 指將括號內的指標值求和
## irate()函數： 指計算範圍向量中時間序列的每秒鐘的瞬時（per-second）速度（calculates theper-second instant rate of increase of the time series in the range vector）
## count_scalar()函數 : 指將時間序列向量中的元素個數做爲標量返回（returns the number ofelements in a time series vector as a scalar）
2.CPU負載率
node_load1{instance="134node"} / count by(job, instance)(count by(job, instance, cpu)(node_cpu{instance="134node"}))
註釋：
## node_load1 : 指1分鐘內cpu平均負載，一樣cpu_load5指5分鐘內cpu平均負載，cpu_load15指15 分鐘內cpu平均負載
## count : 指聚合向量中的每一個元素（即計數）
## 待添加後續註解
3.可用內存
node_memory_MemAvailable{instance="88node"}
註釋：
## node_memory_MemAvailable ：Memory information field MemAvailable， node-exporter已經抓取出來，只需查詢展現便可;
    注意：該指標針對不一樣的系統是採集不一樣的，CentOS6.X 上就採集不到這個指標；CentOS7上能夠；
4.空閒文件系統空間
sum(node_filesystem_free{fstype="xfs",instance="88node"})   
sum(node_filesystem_free{fstype="ext4",instance="134node"})
## node_filesystem_free： Filesystem free space in bytes
## fstype 有以下種類：
## aufs ：  指聯合文件系統,用來把本來分離的兩個文件系統聯合在一塊兒
## cgroup : Cgroups(控制組)是Linux內核的一個功能，用來限制、統計和分離一個進程組的資源(CPU、內存、磁盤輸入輸出等)。
## tmpfs ： tmpfs是一種虛擬內存文件系統，而不是塊設備。
## overlay ： 一個 overlay 文件系統包含兩個文件系統，一個 upper 文件系統和一個 lower 文件系統，是一種新型的聯合文件系統 

### proc、xfs、mqueue等等。
5.swap硬盤交換區：從硬盤到內存或從內存到硬盤，虛擬內存交換
Swap free :
node_memory_SwapFree{instance="134node"}
## node_memory_SwapTotal： Memory information field SwapTotal.
## swap ：相似於能夠把硬盤當內存用，那麼這一部份內存通常就叫作swap
Swap Usage :
node_memory_SwapTotal{instance="134node"} - node_memory_SwapFree{instance="134node"}
## node_memory_SwapFree： Memory information field SwapFree
Swap I/O（in）：
rate(node_vmstat_pswpin{instance="88node"}[1m]) * 4096 or irate(node_vmstat_pswpin{instance="88node"}[5m]) * 4096
Swap I/O（out）：
rate(node_vmstat_pswpout{instance="88node"}[1m]) * 4096 or irate(node_vmstat_pswpout{instance="88node"}[5m]) * 4096
## vmstat ：vmstat命令是最多見的Linux/Unix監控工具，能夠展示給定時間間隔的服務器的狀態值,包括服務器的CPU使用率，內存使用，虛擬內存交換狀況,IO讀寫狀況。
## pswpin/s：每秒從硬盤交換區傳送進入內存的次數。
## pswpout/s：每秒從內存傳送到硬盤交換區的次數。
## pswpin/s、 pswpout/s描述的是與硬盤交換區相關的交換活動。交換關係到系統的效率。交換區在硬盤上對硬盤的讀，寫操做比內存讀，寫慢得多，所以，爲了提升系統效率就應該設法減小交換。  
一般的做法就是加大內存，使交換區中進行的交換活動爲零，或接近爲零。若是swpot/s的值大於 1，預示可能須要增長內存或減小緩衝區（減小緩衝區可以釋放一部分自由內存空間）。
Swap free 率（百分百）
(node_memory_SwapFree{instance=~"$server"}  /node_memory_SwapTotal{instance=~"$server"}) * 100
6.CPU使用率
avg without (cpu) (irate(node_cpu{instance="88node", mode!="idle"}[5m]))
## avg : 平均值
7.網路使用狀況
上傳速率：   irate(node_network_transmit_bytes{device!="lo",instance="88node"}[1m])
下載速率：   irate(node_network_receive_bytes{device!="lo",instance="88node"}[1m])
## eth0: ethernet的簡寫，通常用於以太網接口。
## wifi0:wifi是無線局域網，所以wifi0通常指無線網絡接口。
## ath0: Atheros的簡寫，通常指Atheros芯片所包含的無線網絡接口。
## tunl0：tunl0是隧道接口,封裝數據的時候使用
## lo: local的簡寫，通常指本地環回接口。
8.內存使用率
已用內存：（總內存-空閒內存-緩存=已使用內存）
      node_memory_MemTotal{instance="88node"} -  
      node_memory_MemFree{instance="88node"} - 
      node_memory_Cached{instance="88node"} - 
      node_memory_Buffers{instance="88node"} - 
      node_memory_Slab{instance="88node"}
Buffer緩存：
     node_memory_Buffers{instance="88node"}
Cached緩存：
     node_memory_Cached{instance="88node"}  
     + node_memory_Slab{instance="88node"}
Free空閒內存：
     node_memory_MemFree{instance="88node"}
可用內存佔比：
     (node_memory_MemAvailable{instance="88node"} / 
     node_memory_MemTotal{instance="88node"}) * 100
## total:總計物理內存的大小。
## Free:空閒內存有多少。
## Shared:多個進程共享的內存總額。
## Buffers:表示buffers cache的內存數量，通常對塊設備的讀寫才須要緩衝
## Cached:表示page cached的內存數量，通常做文件系統的cached，頻繁訪問的文件都會被cached。若是cached值較大，就說明cached文件數較多。若是此時IO中的bi比較小，就說明文件系統效率比較好
## Slab:slab分配器不只能夠提供動態內存的管理功能，並且能夠做爲常常分配並釋放的內存的緩存
## MemAvailable: Free + Buffers ＋ Cached - 不可回收的部分。不可回收部分包括：共享內存段 tmpfs，ramfs等
9.磁盤讀寫（IOPs)
磁盤每秒讀取（5分鐘內）
sum by (instance) (irate(node_disk_reads_completed{instance="88node"}[5m]))
##node_disk_reads_completed： The total number of reads completed successfully
磁盤每秒寫入（5分鐘內）
sum by (instance)(irate(node_disk_writes_completed{instance="88node"}[5m]))
##node_disk_writes_completed ：The total number of writes completed successfully.
使用I/O的毫秒數（5分鐘內）
sum by (instance) (irate(node_disk_io_time_ms{instance="88node"}[5m]))
##node_disk_io_time_ms： Total Milliseconds spent doing I/Os
磁盤每秒讀寫總數（5分鐘內）
sum by (instance) (irate(node_disk_reads_completed{instance="88node"}[5m])) + sum by (instance) (irate(node_disk_writes_completed{instance="88node"}[5m]))
10.I/O Usage
磁盤讀取總數（1分鐘內）
sum(irate(node_disk_bytes_read{instance="88node"}[1m]))
##node_disk_bytes_read ： The total number of bytes read successfully（成功讀取的字節數）
磁盤寫入總數（1分鐘內）
sum(irate(node_disk_bytes_written{instance="88node"}[1m]))
##node_disk_bytes_written ：The total number of bytes written successfully（成功寫入的字節數）
使用I/O的毫秒數（1分鐘內）
sum(irate(node_disk_io_time_ms{instance="88node"}[1m]))
##node_disk_io_time_ms ：Total Milliseconds spent doing I/Os.（使用IO的總毫秒數）
11.文件系統空閒空間
最低值：
min(node_filesystem_free{fstype=~"xfs|ext4",instance="88node"} / node_filesystem_size{fstype=~"xfs|ext4",instance="88node"})
最高值：
max(node_filesystem_free{fstype=~"xfs|ext4",instance="88node"} / node_filesystem_size{fstype=~"xfs|ext4",instance="88node"})
## ext4是第四代擴展文件系統（英語：Fourth EXtended filesystem，縮寫爲ext4）是linlli
linux下的日誌文件系統，ext4的文件系統容量達到1EB，而文件容量則達到16TB
## XFS是一個64位文件系統，最大支持8EB減1字節的單個文件系統，實際部署時取決於宿主操做系統的最大塊限制。對於一個32位linux系統，文件和文件系統的大小會被限制在16TB。

二，基本概念

#數據模型
Prometheus 存儲的是時序數據, 即按照相同時序(相同的名字和標籤)，以時間維度存儲連續的數據的集合。

時序索引

時序(time series) 是由名字(Metric)，以及一組 key/value 標籤訂義的，具備相同的名字以及標籤屬於相同時序。
時序的名字由 ASCII 字符，數字，下劃線，以及冒號組成，它必須知足正則表達式 [a-zA-Z_:][a-zA-Z0-9_:]*, 其名字應該具備語義化，通常表示一個能夠度量的指標，例如: http_requests_total, 能夠表示 http 請求的總數。
時序的標籤可使 Prometheus 的數據更加豐富，可以區分具體不一樣的實例，例如 http_requests_total{method="POST"} 能夠表示全部 http 中的 POST 請求。
標籤名稱由 ASCII 字符，數字，以及下劃線組成， 其中 __ 開頭屬於 Prometheus 保留，標籤的值能夠是任何 Unicode 字符，支持中文

時序樣本

按照某個時序以時間維度採集的數據，稱之爲樣本，其值包含：
一個 float64 值
一個毫秒級的 unix 時間戳

格式
Prometheus 時序格式與 OpenTSDB 類似：
<metric name>{<label name>=<label value>, ...}
其中包含時序名字以及時序的標籤。


#時序 4 種類型
Prometheus 時序數據分爲 Counter, Gauge, Histogram, Summary 四種類型
Counter
Counter 表示收集的數據是按照某個趨勢（增長／減小）一直變化的，咱們每每用它記錄服務請求總量、錯誤總數等。

例如 Prometheus server 中 http_requests_total, 表示 Prometheus 處理的 http 請求總數，咱們可使用 delta, 很容易獲得任意區間數據的增量，這個會在 PromQL 一節中細講。

Gauge
Gauge 表示蒐集的數據是一個瞬時的值，與時間沒有關係，能夠任意變高變低，每每能夠用來記錄內存使用率、磁盤使用率等。

例如 Prometheus server 中 go_goroutines, 表示 Prometheus 當前 goroutines 的數量。

Histogram
Histogram 由 <basename>_bucket{le="<upper inclusive bound>"}，<basename>_bucket{le="+Inf"}, <basename>_sum，<basename>_count 組成，主要用於表示一段時間範圍內對數據進行採樣（一般是請求持續時間或響應大小），並可以對其指定區間以及總數進行統計，一般它採集的數據展現爲直方圖。

例如 Prometheus server 中 prometheus_local_storage_series_chunks_persisted, 表示 Prometheus 中每一個時序須要存儲的 chunks 數量，咱們能夠用它計算待持久化的數據的分位數。

Summary
Summ
ary 和 Histogram 相似，由 <basename>{quantile="<φ>"}，<basename>_sum，<basename>_count 組成，主要用於表示一段時間內數據採樣結果（一般是請求持續時間或響應大小），它直接存儲了 quantile 數據，而不是根據統計區間計算出來的。

例如 Prometheus server 中 prometheus_target_interval_length_seconds。

Histogram vs Summary
都包含 <basename>_sum，<basename>_count
Histogram 須要經過 <basename>_bucket 計算 quantile, 而 Summary 直接存儲了 quantile 的值。

#做業與實例
Prometheus 中，將任意一個獨立的數據源（target）稱之爲實例（instance）。包含相同類型的實例的集合稱之爲做業（job）。 以下是一個含有四個重複實例的做業：
- job: api-server
    - instance 1: 1.2.3.4:5670
    - instance 2: 1.2.3.4:5671
    - instance 3: 5.6.7.8:5670
    - instance 4: 5.6.7.8:5671
    
  自生成標籤和時序  
  Prometheus 在採集數據的同時，會自動在時序的基礎上添加標籤，做爲數據源（target）的標識，以便區分
  job: The configured job name that the target belongs to.
instance: The <host>:<port> part of the target's URL that was scraped.

若是其中任一標籤已經在此前採集的數據中存在，那麼將會根據 honor_labels 設置選項來決定新標籤。詳見官網解釋： scrape configuration documentation

對每個實例而言，Prometheus 按照如下時序來存儲所採集的數據樣本：

up{job="<job-name>", instance="<instance-id>"}: 1 表示該實例正常工做
up{job="<job-name>", instance="<instance-id>"}: 0 表示該實例故障

scrape_duration_seconds{job="<job-name>", instance="<instance-id>"} 表示拉取數據的時間間隔

scrape_samples_post_metric_relabeling{job="<job-name>", instance="<instance-id>"} 表示採用重定義標籤（relabeling）操做後仍然剩餘的樣本數

scrape_samples_scraped{job="<job-name>", instance="<instance-id>"}  表示從該數據源獲取的樣本數

其中 up 時序能夠有效應用於監控該實例是否正常工做。

PromQL 基本使用
https://songjiayang.gitbooks.io/prometheus/content/promql/summary.html

PromQL 查詢結果主要有 3 種類型：
瞬時數據 (Instant vector): 包含一組時序，每一個時序只有一個點，例如：http_requests_total
區間數據 (Range vector): 包含一組時序，每一個時序有多個點，例如：http_requests_total[5m]
純量數據 (Scalar): 純量只有一個數字，沒有時序，例如：count(http_requests_total)

數據可視化

Prometheus 自帶的 Web 界面比較簡單，由於它的目的是爲了及時查詢數據，方便 PromeQL 調試
它並非像常見的 Admin Dashboard，在一個頁面儘量展現多的數據，若是你有這方面的需求，不妨試試 Grafana。

Grafana 是一套開源的分析監視平臺，支持 Graphite, InfluxDB, OpenTSDB, Prometheus, Elasticsearch, CloudWatch 等數據源，其 UI 很是漂亮且高度定製化

配置文件

Prometheus 啓動的時候，能夠加載運行參數 -config.file 指定配置文件，默認爲 prometheus.yml。
在配置文件中咱們能夠指定 global, alerting, rule_files, scrape_configs, remote_write, remote_read 等屬性
#全局配置
global 屬於全局的默認配置，它主要包含 4 個屬性，
scrape_interval: 拉取 targets 的默認時間間隔。
scrape_timeout: 拉取一個 target 的超時時間。
evaluation_interval: 執行 rules 的時間間隔。
external_labels: 額外的屬性，會添加到拉取的數據並存到數據庫中

global:
  scrape_interval:     15s # By default, scrape targets every 15 seconds.
  evaluation_interval: 15s # By default, scrape targets every 15 seconds.
  scrape_timeout: 10s # is set to the global default (10s).

  # Attach these labels to any time series or alerts when communicating with
  # external systems (federation, remote storage, Alertmanager).
  external_labels:
    monitor: 'codelab-monitor'
    
#告警配置    
一般咱們可使用運行參數 -alertmanager.xxx 來配置 Alertmanager， 可是這樣不夠靈活，沒有辦法作到動態更新加載，以及動態定義告警屬性。
因此 alerting 配置主要用來解決這個問題，它可以更好的管理 Alertmanager, 主要包含 2 個參數：
alert_relabel_configs: 動態修改 alert 屬性的規則配置。
alertmanagers: 用於動態發現 Alertmanager 的配置
#規則配置
rule_files 主要用於配置 rules 文件，它支持多個文件以及文件目錄
rule_files:
  - "rules/node.rules"
  - "rules2/*.rules"
#數據拉取配置
scrape_configs 主要用於配置拉取數據節點，每個拉取配置主要包含如下參數：
job_name：任務名稱
honor_labels： 用於解決拉取數據標籤有衝突，當設置爲 true, 以拉取數據爲準，不然以服務配置爲準
params：數據拉取訪問時帶的請求參數
scrape_interval： 拉取時間間隔
scrape_timeout: 拉取超時時間
metrics_path： 拉取節點的 metric 路徑
scheme： 拉取數據訪問協議
sample_limit： 存儲的數據標籤個數限制，若是超過限制，該數據將被忽略，不入存儲；默認值爲0，表示沒有限制
relabel_configs： 拉取數據重置標籤配置
metric_relabel_configs：metric 重置標籤配置

ServiceDiscoveryConfig 主要用於 target 發現，大致分爲兩類，靜態配置和動態發現。
#遠程可寫存儲
remote_write 主要用於可寫遠程存儲配置，主要包含如下參數：
url: 訪問地址
remote_timeout: 請求超時時間
write_relabel_configs: 標籤重置配置, 拉取到的數據，通過重置處理後，發送給遠程存儲
#遠程可讀存儲
remote_read 主要用於可讀遠程存儲配置，主要包含如下參數：
url: 訪問地址
remote_timeout: 請求超時時間
#服務發現
在 Prometheus 的配置中，一個最重要的概念就是數據源 target，而數據源的配置主要分爲靜態配置和動態發現, 大體爲如下幾類：
static_configs: 靜態服務發現
dns_sd_configs: DNS 服務發現
file_sd_configs: 文件服務發現
consul_sd_configs: Consul 服務發現
serverset_sd_configs: Serverset 服務發現
nerve_sd_configs: Nerve 服務發現
marathon_sd_configs: Marathon 服務發現
kubernetes_sd_configs: Kubernetes 服務發現
gce_sd_configs: GCE 服務發現
ec2_sd_configs: EC2 服務發現
openstack_sd_configs: OpenStack 服務發現
azure_sd_configs: Azure 服務發現
triton_sd_configs: Triton 服務發現
它們具體使用以及配置模板，請參考服務發現配置模板。
它們中最重要的，也是使用最普遍的應該是 static_configs, 其實那些動態類型均可以當作是某些通用業務使用靜態服務封裝的結果。

##配置樣例
global:
  scrape_interval:     15s # By default, scrape targets every 15 seconds.
  evaluation_interval: 15s # By default, scrape targets every 15 seconds.

rule_files:
  - "rules/node.rules"

scrape_configs:
  - job_name: 'prometheus'
    scrape_interval: 5s
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node'
    scrape_interval: 8s
    static_configs:
      - targets: ['127.0.0.1:9100', '127.0.0.12:9100']

  - job_name: 'mysqld'
    static_configs:
      - targets: ['127.0.0.1:9104']
  - job_name: 'memcached'
    static_configs:
      - targets: ['127.0.0.1:9150']

export

Exporter
在 Prometheus 中負責數據彙報的程序統一叫作 Exporter, 而不一樣的 Exporter 負責不一樣的業務。 它們具備統一命名格式，即 xx_exporter, 例如負責主機信息收集的 node_exporter。
#文本格式
Exporter 本質上就是將收集的數據，轉化爲對應的文本格式，並提供 http 請求。
Exporter 收集的數據轉化的文本內容以行 (\n) 爲單位，空行將被忽略, 文本內容最後一行爲空行。
#註釋
文本內容，若是以 # 開頭一般表示註釋。
以 # HELP 開頭表示 metric 幫助說明。
以 # TYPE 開頭表示定義 metric 類型，包含 counter, gauge, histogram, summary, 和 untyped 類型。
其餘表示通常註釋，供閱讀使用，將被 Prometheus 忽略
#採樣數據
內容若是不以 # 開頭，表示採樣數據。它一般緊挨着類型定義行，知足如下格式：

metric_name [
  "{" label_name "=" `"` label_value `"` { "," label_name "=" `"` label_value `"` } [ "," ] "}"
] value [ timestamp ]

須要特別注意的是，假設採樣數據 metric 叫作 x, 若是 x 是 histogram 或 summary 類型必需知足如下條件：
採樣數據的總和應表示爲 x_sum。
採樣數據的總量應表示爲 x_count。
summary 類型的採樣數據的 quantile 應表示爲 x{quantile="y"}。
histogram 類型的採樣分區統計數據將表示爲 x_bucket{le="y"}。
histogram 類型的採樣必須包含 x_bucket{le="+Inf"}, 它的值等於 x_count 的值。
summary 和 historam 中 quantile 和 le 必需按從小到大順序排列。

Node Exporter

默認開啓的功能

名稱	說明	系統
arp	從 `/proc/net/arp` 中收集 ARP 統計信息	Linux
conntrack	從 `/proc/sys/net/netfilter/` 中收集 conntrack 統計信息	Linux
cpu	收集 cpu 統計信息	Darwin, Dragonfly, FreeBSD, Linux
diskstats	從 `/proc/diskstats` 中收集磁盤 I/O 統計信息	Linux
edac	錯誤檢測與糾正統計信息	Linux
entropy	可用內核熵信息	Linux
exec	execution 統計信息	Dragonfly, FreeBSD
filefd	從 `/proc/sys/fs/file-nr` 中收集文件描述符統計信息	Linux
filesystem	文件系通通計信息，例如磁盤已使用空間	Darwin, Dragonfly, FreeBSD, Linux, OpenBSD
hwmon	從 `/sys/class/hwmon/` 中收集監控器或傳感器數據信息	Linux
infiniband	從 InfiniBand 配置中收集網絡統計信息	Linux
loadavg	收集系統負載信息	Darwin, Dragonfly, FreeBSD, Linux, NetBSD, OpenBSD, Solaris
mdadm	從 `/proc/mdstat` 中獲取設備統計信息	Linux
meminfo	內存統計信息	Darwin, Dragonfly, FreeBSD, Linux
netdev	網口流量統計信息，單位 bytes	Darwin, Dragonfly, FreeBSD, Linux, OpenBSD
netstat	從 `/proc/net/netstat` 收集網絡統計數據，等同於 `netstat -s`	Linux
sockstat	從 `/proc/net/sockstat` 中收集 socket 統計信息	Linux
stat	從 `/proc/stat` 中收集各類統計信息，包含系統啓動時間，forks, 中斷等	Linux
textfile	經過 `--collector.textfile.directory` 參數指定本地文本收集路徑，收集文本信息	any
time	系統當前時間	any
uname	經過 `uname` 系統調用, 獲取系統信息	any
vmstat	從 `/proc/vmstat` 中收集統計信息	Linux
wifi	收集 wifi 設備相關統計數據	Linux
xfs	收集 xfs 運行時統計信息	Linux (kernel 4.4+)
zfs	收集 zfs 性能統計信息	Linux

默認關閉的功能

名稱	說明	系統
bonding	收集系統配置以及激活的綁定網卡數量	Linux
buddyinfo	從 `/proc/buddyinfo` 中收集內存碎片統計信息	Linux
devstat	收集設備統計信息	Dragonfly, FreeBSD
drbd	收集遠程鏡像塊設備（DRBD）統計信息	Linux
interrupts	收集更具體的中斷統計信息	Linux，OpenBSD
ipvs	從 `/proc/net/ip_vs` 中收集 IPVS 狀態信息，從 `/proc/net/ip_vs_stats` 獲取統計信息	Linux
ksmd	從 `/sys/kernel/mm/ksm` 中獲取內核和系通通計信息	Linux
logind	從 `logind` 中收集會話統計信息	Linux
meminfo_numa	從 `/proc/meminfo_numa` 中收集內存統計信息	Linux
mountstats	從 `/proc/self/mountstat` 中收集文件系通通計信息，包括 NFS 客戶端統計信息	Linux
nfs	從 `/proc/net/rpc/nfs` 中收集 NFS 統計信息，等同於 `nfsstat -c`	Linux
qdisc	收集隊列推定統計信息	Linux
runit	收集 runit 狀態信息	any
supervisord	收集 supervisord 狀態信息	any
systemd	從 `systemd` 中收集設備系統狀態信息	Linux
tcpstat	從 `/proc/net/tcp` 和 `/proc/net/tcp6` 收集 TCP 鏈接狀態信息	Linux

docker 安裝

docker run -d -p 9100:9100 \
  -v "/proc:/host/proc:ro" \
  -v "/sys:/host/sys:ro" \
  -v "/:/rootfs:ro" \
  --net="host" \
  quay.io/prometheus/node-exporter \
    -collector.procfs /host/proc \
    -collector.sysfs /host/sys \
    -collector.filesystem.ignored-mount-points "^/(sys|proc|dev|host|etc)($|/)"
    
     docker run -d -p 9100:9100 --net="host" prom/node-exporter
 容器如何監控外部的資源 ？？？？

##k8s部署根據

https://github.com/NVIDIA/gpu-monitoring-tools/blob/master/exporters/prometheus-dcgm/k8s/node-exporter/gpu-only-node-exporter-daemonset.yaml

一，部署promethues server

能夠經過ConfigMap配置prometheus的配置文件，生成的配置文件由prometheus使用，後期有新節點能夠修改配置文件從新應用生效

apiVersion: v1
kind: ConfigMap
metadata:
  creationTimestamp: null
  name: prometheus-config
  namespace: monitoring
data:
  prometheus.yaml: |
    global:
      scrape_interval: 15s
    scrape_configs:
    - job_name: prometheus
      scrape_interval: 5s
      static_configs:
      - targets:
        - localhost:9090
    - job_name: gpu_metrics
      scrape_interval: 1s
      metrics_path: /gpu/metrics
      scheme: http
      static_configs:
      - targets:
        - localhost:9400
-------------------------------------------
能夠添加新的job_name  或   在某一個job下添加targets

二，

節點daemonset

# Node exporter collecting only GPU metrics from dcgm-exporter.
# Except textfile collector, all other collectors that are enabled by default are disabled.
# Refer: https://github.com/prometheus/node_exporter/tree/release-0.16
apiVersion: extensions/v1beta1
kind: DaemonSet
metadata:
  name: dcgm-exporter
spec:
  template:
    metadata:
      labels:
        app: dcgm-exporter
      name: dcgm-exporter
    spec:
      nodeSelector:
        hardware-type: NVIDIAGPU
      containers:
      - image: quay.io/prometheus/node-exporter:v0.16.0
        name: node-exporter
        args:
        - "--web.listen-address=0.0.0.0:9101"
        - "--path.procfs=/host/proc"
        - "--path.sysfs=/host/sys"
        - "--collector.textfile.directory=/run/prometheus"
        - "--no-collector.arp"
        - "--no-collector.bcache"
        - "--no-collector.bonding"
        - "--no-collector.conntrack"
        - "--no-collector.cpu"
        - "--no-collector.diskstats"
        - "--no-collector.edac"
        - "--no-collector.entropy"
        - "--no-collector.filefd"
        - "--no-collector.filesystem"
        - "--no-collector.hwmon"
        - "--no-collector.infiniband"
        - "--no-collector.ipvs"
        - "--no-collector.loadavg"
        - "--no-collector.mdadm"
        - "--no-collector.meminfo"
        - "--no-collector.netdev"
        - "--no-collector.netstat"
        - "--no-collector.nfs"
        - "--no-collector.nfsd"
        - "--no-collector.sockstat"
        - "--no-collector.stat"
        - "--no-collector.time"
        - "--no-collector.timex"
        - "--no-collector.uname"
        - "--no-collector.vmstat"
        - "--no-collector.wifi"
        - "--no-collector.xfs"
        - "--no-collector.zfs"
        ports:
        - name: metrics
          containerPort: 9101
          hostPort: 9101
        resources:
          requests:
            memory: 30Mi
            cpu: 100m
          limits:
            memory: 50Mi
            cpu: 200m
        volumeMounts:
        - name: proc
          readOnly:  true
          mountPath: /host/proc
        - name: sys
          readOnly: true
          mountPath: /host/sys
        - name: collector-textfiles
          readOnly: true
          mountPath: /run/prometheus
      - image: nvidia/dcgm-exporter:1.4.6
        name: nvidia-dcgm-exporter
        securityContext:
          runAsNonRoot: false
          runAsUser: 0
        volumeMounts:
        - name: collector-textfiles
          mountPath: /run/prometheus

      hostNetwork: true
      hostPID: true

      volumes:
      - name: proc
        hostPath:
          path: /proc
      - name: sys
        hostPath:
          path: /sys
      - name: collector-textfiles
        emptyDir:
          medium: Memory
          
暴露的指標可訪問

Pod 滾動更新一：修改 CI 流程
這種辦法異常簡單，只須要咱們寫一個簡單的 CI 腳本：給 ConfigMap 算一個 Hash 值，而後做爲一個環境變量或 Annotation 加入到 Deployment 的 Pod 模板當中。

舉個例子，咱們寫這樣的一個 Deployment yaml 而後在 CI 腳本中，計算 Hash 值替換進去：

...
spec:
  template:
    metadata:
      annotations:
        com.aylei.configmap/hash: ${CONFIGMAP_HASH}
...
這時，假如 ConfigMap 變化了，那 Deployment 中的 Pod 模板天然也會發生變化，k8s 本身就會幫助咱們作滾動更新了。另外，如何 ConfigMap 不大，直接把 ConfigMap 轉化爲 JSON 放到 Pod 模板中均可以，這樣作還有一個額外的好處，那就是在排查故障時，咱們一眼就能看到這個 Pod 如今關聯的 ConfigMap 內容是什麼。

或者
----------------------------------------------------------------------------
當前最佳方案是使用 Deployment 編排 Pods，並將 ConfigMap 視爲只讀資源。當咱們須要更新 ConfigMap 時，咱們從新建立一個新的 ConfigMap，並將咱們的 Deployment 配置指向新的 ConfigMap，而後滾動更新。若是咱們新的配置是有問題，則須要執行 Deployment 回滾操做。雖然不能直接編輯 ConfigMap 那麼快，但更安全。

新增 ConfigMap 編輯 Deployment 使用最新配置，並執行更新操做

kubectl apply -f prometheus.deploy.yml

# HELP dcgm_dec_utilization Decoder utilization (in %).
# TYPE dcgm_dec_utilization gauge
dcgm_dec_utilization{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 0
# HELP dcgm_ecc_dbe_volatile_total Total number of double-bit volatile ECC errors.
# TYPE dcgm_ecc_dbe_volatile_total counter
dcgm_ecc_dbe_volatile_total{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 0
# HELP dcgm_ecc_sbe_volatile_total Total number of single-bit volatile ECC errors.
# TYPE dcgm_ecc_sbe_volatile_total counter
dcgm_ecc_sbe_volatile_total{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 0
# HELP dcgm_enc_utilization Encoder utilization (in %).
# TYPE dcgm_enc_utilization gauge
dcgm_enc_utilization{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 0
# HELP dcgm_fb_free Framebuffer memory free (in MiB).
# TYPE dcgm_fb_free gauge
dcgm_fb_free{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 3825
# HELP dcgm_fb_used Framebuffer memory used (in MiB).
# TYPE dcgm_fb_used gauge
dcgm_fb_used{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 219
# HELP dcgm_gpu_temp GPU temperature (in C).
# TYPE dcgm_gpu_temp gauge
dcgm_gpu_temp{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 39
# HELP dcgm_gpu_utilization GPU utilization (in %).
# TYPE dcgm_gpu_utilization gauge
dcgm_gpu_utilization{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 4
# HELP dcgm_mem_copy_utilization Memory utilization (in %).
# TYPE dcgm_mem_copy_utilization gauge
dcgm_mem_copy_utilization{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 2
# HELP dcgm_memory_clock Memory clock frequency (in MHz).
# TYPE dcgm_memory_clock gauge
dcgm_memory_clock{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 405
# HELP dcgm_pcie_replay_counter Total number of PCIe retries.
# TYPE dcgm_pcie_replay_counter counter
dcgm_pcie_replay_counter{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 0
# HELP dcgm_pcie_rx_throughput Total number of bytes received through PCIe RX (in KB)
# TYPE dcgm_pcie_rx_throughput counter
dcgm_pcie_rx_throughput{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 1
# HELP dcgm_pcie_tx_throughput Total number of bytes transmitted through PCIe TX (in KB)
# TYPE dcgm_pcie_tx_throughput counter
dcgm_pcie_tx_throughput{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 13
# HELP dcgm_power_violation Throttling duration due to power constraints (in us).
# TYPE dcgm_power_violation counter
dcgm_power_violation{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 0
# HELP dcgm_sm_clock SM clock frequency (in MHz).
# TYPE dcgm_sm_clock gauge
dcgm_sm_clock{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 135
# HELP dcgm_sync_boost_violation Throttling duration due to sync-boost constraints (in us).
# TYPE dcgm_sync_boost_violation counter
dcgm_sync_boost_violation{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 0
# HELP dcgm_thermal_violation Throttling duration due to thermal constraints (in us).
# TYPE dcgm_thermal_violation counter
dcgm_thermal_violation{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 0
# HELP dcgm_xid_errors Value of the last XID error encountered.
# TYPE dcgm_xid_errors gauge
dcgm_xid_errors{gpu="0",uuid="GPU-a53b4ec8-50eb-abc9-ce5a-4fdf12db1187"} 0