PromQL

及时向量选择器：返回列表

= ：等于

up{job="kafka"}

!= ：不等于

up{job!="kafka"}

=~：等于正则表达式，也就是说正则表达式说了算

up{job=~"pod-.*"}

!~ ：不等于正则表达式，正则匹配到的都不算

up{job!~"pod-.*"}

同一个字段可以写多个条件：如下 mountpoint 字段

node_filesystem_size_bytes{job="kubernetes-node-exporter",mountpoint=~"/etc/.*",mountpoint!~"/etc/host.*"}

等效的两种查询模式：

{__name__="http_requests_total"}
http_requests_total

查询以某个字符开头的所有指标：如下示例是查询以etcd开头的所有指标。

{__name__=~"etcd.*"}

安标签值查找：如下查找所有code=200记录

{code="200"}

4xx-5xx的状态码：

status=~"[4-5].*"

不要的状态码：

status!~"200|400|404"

区间向量选择器：返回多个样本

获取一分钟内的样本：后面的m是单位，有s、m、h、d、w、y。是以当前时间为基准的。

process_cpu_seconds_total [1m]

如图一分钟内有4个数据样本，两分钟就会有8个。

时间偏移操作 offset：

查看15分钟之前的数据：

process_resident_memory_bytes{job="pod-jmx"} offset 15m
process_resident_memory_bytes{job="pod-jmx"} [1m]offset 15m

简单求和 sum：

sum(http_requests_total)

按照by后面的字段进行聚合计算：

sum(http_requests_total) by (env, instance)

去除without后面的字段进行聚合计算：

sum(http_requests_total) without (env, instance)

最大值 max：将组内最大值作为返回值

返回每个组中最大的那个值。

max by(instance)(node_filesystem_size_bytes)

如图每一行就是一组聚合。

去除某些值来进行计算：

max without(mountpoint,device)(node_filesystem_size_bytes)

最小值 min：返回组内的最小值

去除某些字段求最小值。

min without(mountpoint,device)(node_filesystem_size_bytes)

对某些字段求最小值：

min by(mountpoint,device)(node_filesystem_size_bytes)

平均值 avg：

计算每个CPU每分钟的空闲时间。

avg without(cpu,mode) (rate(node_cpu_seconds_total{mode="idle"}[1m]))
avg by(cpu,mode) (rate(node_cpu_seconds_total{mode="idle"}[1m]))

标准差 stddev：反应数据波动大小，数据波动越大值越大。

stddev(http_requests_total)

标准差参考：

www.cnblogs.com/chanshuyi/p/04_quick_start_of_promql.html

标准方差stdvar：标准差的平方

stdvar(http_requests_total)

统计 count：

如下示例为统计主机磁盘设备数量。

count without(device)(node_disk_written_bytes_total)

值统计 count_values：

对相同values进行计数，统计每个样本值的出现次数，目前没有示例。

排序：

topk：对请求数前5进行排序。

topk(5, http_requests_total)

buttomk：对请求数倒数前5的进行排序。

bottomk(5, http_requests_total)

计算当前样本数据值的分布情况：当第一个参数的值为0.5时表示取样本数据的中位数。第一个参数值在0到1之间。

quantile(0.5, http_requests_total)

sort_desc 倒序：

sort_desc()

sort_asc 正序：

sort_asc()

运算符

算术运算符：

变量与标量之间运算得到的是一组数据。

如获取内存使用率：

1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)

获取磁盘读写时间总量：将左边的标签和右边的标签完全一致的进行运算，找不到则丢弃。

node_disk_written_bytes_total+node_disk_read_bytes_total

关系运算符：

==、!=、>、<、>=、<=

如下示例：在运算符之后加上bool关键字可以让结果返回0或1。

99 >= bool 88

变量与标量之间的运算：结果为true的保留，为false的丢弃。

如下示例：获取主机状态为ESTABLISHED的大于30的。

node_netstat_Tcp_CurrEstab > 30

即时向量与即时向量的运算：返回一组结果，用于过滤，匹配不到的将被丢弃，表达式不为true将被丢弃，在运算符后加bool返回0或1。

node_disk_written_bytes_total > bool node_disk_read_bytes_total

向量匹配：

一对一匹配：

即两遍拥有的标签完全相同，找到唯一一条条目依次进行匹配。

process_open_fds / process_max_fds

如果两边拥有的标签不一致可以用 on 或 ignoring 关键字修改标签间的匹配行为。

on：指定要匹配的标签，只匹配指定的标签。

ignoring：忽略某些标签，就是指定的这些标签不匹配，其他的都匹配。

如下示例中只对 instance 和 job 两个标签进行匹配。

sum by(instance, job) (rate(node_cpu_seconds_total{mode="idle"}[5m])) 
/ on (instance, job) 
sum by(instance, job) (rate(node_cpu_seconds_total [5m] ))

两个即时向量进行比较时都会返回左边的表达式：

如下示例都会返回左边的表达式：可以根据需求来写表达式。

process_open_fds < process_max_fds
process_max_fds >  process_open_fds

一对多或多对一匹配：

group_left：左边有更多的子集

group_right：右边有更多的子集

语法：

如下示例为左边的每组的每一个mode生成一个输出样本。

sum without (cpu)(rate(node_cpu_seconds_total [5m])) 
/ ignoring(mode) group_left 
sum without (mode, cpu)(rate(node_cpu_seconds_total [5m]))

逻辑运算符：

and、or、unless，与或非

用于向量之间，以多对多的方式工作。

vector1 and vector2

规则：vector1瞬时向量中的每个样本数据与vector2向量中的所有样本数据进行标签匹配，不匹配的，全部丢弃。运算结果是保留左边的度量指标名称和值。

employee_age_bucket{le=~"30|40|50"} and employee_age_bucket{le=~"40|50|60"}

vector1 or vector2

规则: 保留vector1向量中的每一个元素，对于vector2向量元素，则不匹配vector1向量的任何元素，则追加到结果元素中。

employee_age_bucket{le=~"30|40|50"} or employee_age_bucket{le=~"40|50|60"}

vector1 unless vector2

规则：包含在vector1中的元素，但是该元素不在vector2向量所有元素列表中，则写入到结果集中。

employee_age_bucket{le=~"30|40|50"} unless employee_age_bucket{le=~"40|50|60"}

运算符优先级：

函数

数学函数：

绝对值函数：

abs()：返回每个值的绝对值

abs(process_open_fds{addr="10.32.121.21:9121",instance="10.32.121.21:9121"})

返回的结果中会去掉指标名称：

{addr="10.32.121.21:9121",instance="10.32.121.21:9121",ip="10.32.121.21",job="redis"}

sqrt()：平方根

sqrt(process_open_fds{instance="10.32.121.21:9121"})

round()：四舍五入

round(sqrt(process_open_fds{instance="10.32.121.21:9121"}))

ceil：进一取整

ceil()

保留小数：后面的 0.001 表示保留三位小数

round(sum(irate(nginx_ingress_controller_requests{service="trust"}[2m])) by (ingress), 0.001)

clamp_max：设置上限，输入一个瞬时向量和最大值，样本数据值若大于max，则改为max，否则不变

clamp_max(process_open_fds, 100)

clamp_minx：设置下限，输入一个瞬时向量和最大值，样本数据值小于min，则改为min。否则不变

clamp_min(process_open_fds, 100)

时间函数：

time()：返回从1970-01-01到现在的秒数，注意：它不是直接返回当前时间，而是时间戳

查看进程运行了多长时间：

time() - process_start_time_seconds

minute()：minute(v=vector(time()) instant-vector)函数返回给定UTC时间当前小时的第多少分钟。结果范围：0~59。

hour()：hour(v=vector(time()) instant-vector)函数返回被给定UTC时间的当前第几个小时，时间范围：0~23。

month()：month(v=vector(time()) instant-vector)函数返回给定UTC时间当前属于第几个月，结果范围：0~12。

year()：year(v=vector(time()) instant-vector) 返回年份

year查看进程是那一年启动的：

year(process_start_time_seconds)

day_of_month()：day_of_month(v=vector(time()) instant-vector)函数，返回被给定UTC时间所在月的第几天。返回值范围：1~31。

运行了多少个月了：

day_of_month(process_start_time_seconds)

day_of_week()：day_of_week(v=vector(time()) instant-vector)函数，返回被给定UTC时间所在周的第几天。返回值范围：0~6. 0表示星期天。

days_in_month()：days_in_month(v=vector(time()) instant-vector)函数，返回当月一共有多少天。返回值范围：28~31.

标签操作函数：

label_replace(v instant-vector, dst_label string, replacement string, src_label string, regex string)

label_join()

指标增长率：要与计数器一起使用。

increase()：获取样本的第一个样本和最后一个样本，并返回其增长量。

increase(process_cpu_seconds_total [3m])

rate()：rate会取指定时间范围内所有数据点，算出一组速率，然后取平均值作为结果。结果比较平缓。

rate(process_cpu_seconds_total [3m])

irate()：在一组数据中取最后两个数据点来计算区间增长速率。结果波动幅度大。通常用于计算每秒请求率。

irate(process_cpu_seconds_total [3m])

指标趋势变化预测：

gauge()：

如根据之前1小时的数据来预测磁盘是否在未来4小时占满。

predict_linear(node_filesystem_free_bytes{job="es-dev"} [1h], 4*3600) < 0

参考：

cnblogs.com/wayne-liu/p/9273492.html

更多函数见官方文档：

prometheus.io/docs/prometheus/2.23/querying/functions/

常用示例：

内存使用率：

(1 - (node_memory_MemAvailable_bytes{job="kubernetes-node-exporter"}) / (node_memory_MemTotal_bytes{job="kubernetes-node-exporter"})) * 100

磁盘使用率：

((node_filesystem_size_bytes{mountpoint="/data-disk",device=~"/dev/sda3|/dev/sda4"} - node_filesystem_free_bytes{mountpoint="/data-disk",device=~"/dev/sda3|/dev/sda4"}) / node_filesystem_size_bytes{mountpoint="/data-disk",device=~"/dev/sda3|/dev/sda4"}) * 100

磁盘使用率：

(1 - (node_filesystem_free_bytes{device=~"/dev.*",mountpoint!~"/var/lib/.*|/boot"} / node_filesystem_size_bytes{device=~"/dev.*",mountpoint!~"/var/lib/.*|/boot"})) * 100

CPU使用率：仪表盘

(1-(sum(increase(node_cpu_seconds_total{mode="idle"}[1m]))by(instance))/(sum(increase(node_cpu_seconds_total[1m]))by(instance)))*100

CPU使用率：表格

(1 - avg(rate(node_cpu_seconds_total{mode="idle"}[5m])) by (instance,kubernetes_node)) * 100

POD 非正常状态：

count(kube_pod_status_phase{phase!="Running",phase!="Succeeded"} > 0) by (pod,phase,namespace)

Pod每分钟重启次数：

sum(irate(kube_pod_container_status_restarts_total [1m])) by (namespace,pod) > 0

Pod入流量：

sum by(pod_name)(irate(container_network_receive_bytes_total[1m]))

每分钟Pod使用cpu：

sum by(pod_name)(irate(container_cpu_usage_seconds_total[1m]))

Pod内存使用：

sum by(pod_name)(irate(container_memory_working_set_bytes[1m]))

节点运行的Pod数量：

sum(kubelet_running_pod_count) by(instance)

节点运行的容器数量：

sum(kubelet_running_container_count) by(instance)

POD资源使用总量三连：

按应用统计POD内存使用总量：

sort_desc(sum(container_memory_usage_bytes{image!=""}) by (container_name, image))

按应用统计POD CPU使用总量：

sum by (container_name)( rate(container_cpu_usage_seconds_total{image!=""}[5m]))

按应用统计POD 流量出入总量：

入流量：

sort_desc(sum by (pod_name) (rate (container_network_receive_bytes_total{name!=""}[5m])))

出流量：

sort_desc(sum by (pod_name) (rate (container_network_transmit_bytes_total{name!=""}[5m])))

POD资源监控三连：

POD 内存使用率：

sum(container_memory_rss{image!=""}) by(pod_name, namespace) / sum(container_spec_memory_limit_bytes{image!=""}) by(pod_name, namespace) * 100 != +inf

POD CPU使用率：

sum(rate(container_cpu_usage_seconds_total{image!=""}[1m])) by (pod_name, namespace) / (sum(container_spec_cpu_quota{image!=""}/100000) by (pod_name, namespace)) * 100

POD 文件系统使用量：

sum(container_fs_usage_bytes{image!=""}) by(pod_name, namespace) / (1024*1024*1024)

资源统计：

内存使用率：多个节点加起来的内存使用率

(1 - sum(node_memory_MemAvailable_bytes) / sum(node_memory_MemTotal_bytes))

CPU使用率：多个节点CPU的使用率

(1 - avg(rate(node_cpu_seconds_total{mode="idle"}[2m])))

节点流量统计：

下载带宽：单位：bits/sec(SI)

max(rate(node_network_receive_bytes_total[2m])*8) by (instance)

上传带宽：单位：bits/sec(SI)

max(rate(node_network_transmit_bytes_total[2m])*8) by (instance)

Nginx-ingress：4xx 5xx 状态码

sum(rate(nginx_ingress_controller_requests{controller_pod=~"$controller",controller_class=~"$controller_class",namespace=~"$namespace",ingress=~"$ingress",status=~"[4-5].*"}[2m])) by (status,ingress,service)

统计24小时状态码：

sum(nginx_ingress_controller_requests{ingress="trust"}) by (status) - sum(nginx_ingress_controller_requests{ingress="trust"} offset 24h) by (status)

Pod重启：

PodRestartingTooMuch：pod重启次数过多，重启次数大于10

sum(kube_pod_container_status_restarts_total{}) by (cluster, namespace, pod, container) > 10

PodFrequentlyRestarting：pod频繁重启，1分钟之内重启了3次

increase(kube_pod_container_status_restarts_total{}[1m]) > 3

PodContainerTerminated：pod出于退出状态，比如因为OOM、错误退出和不能正常运行

kube_pod_container_status_terminated_reason{reason=~"OOMKilled|Error|ContainerCannotRun"} > 0

PodNotReady：pod未处于ready状态，15分钟之内pod没有ready

min_over_time(sum by (cluster, namespace, pod, container) (kube_pod_status_phase{phase=~"Pending|Unknown|Failed"})[15m:1m]) > 0

DeploymentReplicasMismatch：deployment未按预期replicas运行

kube_deployment_status_replicas_available{} != kube_deployment_spec_replicas{}

StatefulSetReplicasMismatch：statefulset未按预期replicas运行

kube_statefulset_status_replicas_available{} != kube_statefulset_replicas{}

监控PV使用量：

sum by (persistentvolumeclaim) (kubelet_volume_stats_used_bytes / kubelet_volume_stats_capacity_bytes * 100) > 60

其他参考：

help.aliyun.com/document_detail/176180.html?utm_content=g_1000230851