FlareBall's Blog
0%

Posted on Edited on In ,

贪心

时间复杂度$O(n)$

空间复杂度$O(1)$

1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
    public int maxProfit(int[] prices) {
        int ans = 0, pre = prices[0];
        for (int i = 1; i < prices.length; ++i) {
            int cur = prices[i];
            if (cur > pre) {
                ans += cur - pre;
            }
            pre = cur;
        }
        return ans;
    }
}

Posted on Edited on In ,

贪心

时间复杂度$O(n)$

空间复杂度$O(1)$

1
2
3
4
5
6
7
8
9
10
class Solution {
    public int maxProfit(int[] prices) {
        int ans = 0, preMin = prices[0];
        for (int i = 1; i < prices.length; ++i) {
            ans = Math.max(ans, prices[i] - preMin);
            preMin = Math.min(preMin, prices[i]);
        }
        return ans;
    }
}

Posted on Edited on In ,

双指针

时间复杂度$O(n)$

空间复杂度$O(1)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
    public void rotate(int[] nums, int k) {
        k %= nums.length;
        reverse(nums, 0, nums.length - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.length - 1);
    }
    private void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int tmp = nums[start];
            nums[start] = nums[end];
            nums[end] = tmp;
            start++;
            end--;
        }
    }
}

Posted on Edited on In ,

摩尔投票

时间复杂度$O(n)$

空间复杂度$O(1)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution {
    public int majorityElement(int[] nums) {
        int cnt = 1;
        int ans = nums[0];
        for (int i = 1; i < nums.length; ++i) {
            if (nums[i] == ans) {
                cnt++;
            } else if (--cnt == 0) {
                ans = nums[i];
                cnt = 1;
            }
        }
        return ans;
    }
}

Posted on Edited on In ,

双指针

时间复杂度$O(n)$

空间复杂度$O(1)$

1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
    public int removeDuplicates(int[] nums) {
        int left = 0, right = 1, n = nums.length;
        while (right < n) {
            if (nums[right] != nums[left]) {
                left++;
                nums[left] = nums[right];
            }
            right++;
        }
        return left + 1;
    }
}

Posted on Edited on In ,

双指针

时间复杂度 $O(m+n)$

空间复杂度 $O(1)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p1 = m - 1, p2 = n - 1;
        for (int i = m + n - 1; i >= 0; i--) {
            int x1 = p1 >= 0 ? nums1[p1] : Integer.MIN_VALUE;
            int x2 = p2 >= 0 ? nums2[p2] : Integer.MIN_VALUE;
            if (x1 > x2) {
                nums1[i] = x1;
                p1--;
            } else {
                nums1[i] = x2;
                p2--;
            }
        }
    }
}

Posted on Edited on In ,

双指针

把新数组想象成一个栈，用一个指针维护栈顶位置

时间复杂度$O(n)$

空间复杂度$O(1)$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
    public int removeDuplicates(int[] nums) {
        int n = nums.length;
        if (n <= 2) {
            return n;
        }
        int left = 2, right = 2;
        while (right < n) {
            if (nums[right] != nums[left - 2]) {  // left 始终指向新数组的第一个可用位置
                nums[left] = nums[right];
                left++;
            }
            right++;
        }
        return left;
    }
}

Posted on Edited on In ,

双指针

时间复杂度$O(n)$

空间复杂度$O(1)$

1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
    public int removeElement(int[] nums, int val) {
        int left = 0, right = 0;
        while (right < nums.length) {
            if (nums[right] != val) {
                nums[left] = nums[right];
                left++;
            }
            right++;
        }
        return left;
    }
}

Posted on

在k8s集群上利用nfs实现跨节点目录共享，部署ollama和nginx作为练习。

环境为openeuler22.03 sp3，k8s1.23.6，docker为容器引擎，flannel提供通信支持

一主（node0-192.168.195.40）二从(node1-192.168.195.41、node2-192.168.195.42)

所有数据利用nfs实现共享（所有节点均需安装nfs服务），数据存储在主节点/opt/k8s_store/目录。分别为/opt/k8s_store/ollama和/opt/k8s_store/nginx

nfs共享

安装NFS服务（所有节点）：

1
sudo dnf install nfs-utils

编辑/etc/exports文件，添加共享目录配置（存储节点）：

1
/opt/k8s_store  *(rw,sync,no_root_squash,no_subtree_check)

这会使/opt/k8s_store目录对所有节点（*表示所有）可读写。

重启NFS服务：

1
2
sudo systemctl restart nfs-server
sudo systemctl enable nfs-server

ollama部署

1
2
[root@node0 ollama]# ls
deployment.yaml  pvc.yaml  pv.yaml  service.yaml

配置文件pv.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[root@node0 ollama]# cat pv.yaml 
apiVersion: v1
kind: PersistentVolume
metadata:
  name: ollama-pv
spec:
  capacity:
    storage: 8Gi
  volumeMode: Filesystem
  accessModes:
    - ReadWriteMany  # 使用ReadWriteMany，支持多个节点挂载
  persistentVolumeReclaimPolicy: Retain
  nfs:
    path: /opt/k8s_store/ollama  # 共享目录
    server: node0  # NFS服务器地址

配置文件pvc.yaml

1
2
3
4
5
6
7
8
9
10
11
[root@node0 ollama]# cat pvc.yaml 
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: ollama-pvc
spec:
  accessModes:
    - ReadWriteMany  # 对应修改后的PV配置
  resources:
    requests:
      storage: 8Gi

配置文件deployment.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
[root@node0 ollama]# cat deployment.yaml 
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama-deployment  # Deployment 名称
spec:
  replicas: 1  # 副本数（可以根据需求调整副本数）
  selector:
    matchLabels:
      app: ollama  # 匹配标签，Pod 会以此标签进行选择
  template:
    metadata:
      labels:
        app: ollama  # Pod 标签
    spec:
      containers:
        - name: ollama  # 容器名称
          image: ollama/ollama:latest  # 使用的镜像
          ports:
            - containerPort: 11434  # 容器端口映射
          volumeMounts:
            - name: ollama-storage  # 使用 PVC 挂载卷
              mountPath: /root/.ollama  # 挂载路径，容器内的路径
      restartPolicy: Always  # 确保容器失败时重启
      volumes:
        - name: ollama-storage
          persistentVolumeClaim:
            claimName: ollama-pvc  # 绑定的 PVC 名称

配置文件service.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
[root@node0 ollama]# cat service.yaml 
apiVersion: v1
kind: Service
metadata:
  name: ollama-service  # Service 名称
spec:
  selector:
    app: ollama  # 匹配的标签，确保请求被转发到 Deployment 对应的 Pod
  ports:
    - protocol: TCP
      port: 11434  # Service 端口
      targetPort: 11434  # 容器内部端口
  type: NodePort  # 让外部能够通过 NodePort 访问该服务

(实际上在本示例中并未进一步使用此处开放的端口)，这里可以进一步与dify等工具联动，实现外部api访问服务。可以查阅

Private Deployment of Ollama + DeepSeek + Dify: Build Your Own AI Assistant | Dify

利如下命令进行部署

1
2
3
kubectl apply -f pv.yaml
kubectl apply -f pvc.yaml
kubectl apply -f deployment.yaml

最终结果为

1
2
3
4
5
6
7
[root@node0 ollama]# kubectl get pods
NAME                                 READY   STATUS        RESTARTS      AGE
k8s-nginx-6d779d947c-mvj99           1/1     Running       2 (76m ago)   46d
k8s-nginx-6d779d947c-qdkvh           1/1     Running       2 (76m ago)   46d
k8s-nginx-6d779d947c-zh8zs           1/1     Running       2 (76m ago)   46d
ollama-deployment-777b9bccb7-sj7wd   1/1     Running       0             3m18s
[root@node0 ollama]#

ollama试用

此处进入pod内部，下载deepseekr1:1.5b完整部署结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
[root@node0 ollama]# kubectl exec -it ollama-deployment-777b9bccb7-sj7wd -- /bin/bash
root@ollama-deployment-777b9bccb7-sj7wd:/# ollama run deepseek-r1:1.5b
pulling manifest
pulling aabd4debf0c8... 100% ▕█████████████████████████████████████████████████████████▏ 1.1 GB
pulling 369ca498f347... 100% ▕█████████████████████████████████████████████████████████▏  387 B
pulling 6e4c38e1172f... 100% ▕█████████████████████████████████████████████████████████▏ 1.1 KB
pulling f4d24e9138dd... 100% ▕█████████████████████████████████████████████████████████▏  148 B
pulling a85fe2a2e58e... 100% ▕█████████████████████████████████████████████████████████▏  487 B
verifying sha256 digest
writing manifest
success
>>> hi
<think>

</think>

Hello! How can I assist you today? 😊

>>> wo are you
<think>

</think>

Hello! It seems like your message is a bit unclear. Could you please provide more context or clarify what you're asking? I'm here to help! 😊

>>> /bye
root@ollama-deployment-777b9bccb7-sj7wd:/# exit
exit
[root@node0 ollama]#

可以顺利使用，部署成功。

nginx搭建html服务器

此处准备了wireshark的本地用户手册作为服务内容。

1
WiresharkUser'sGuide.zip # 内含n多html文档

解压到/opt/k8s_store/nginx/index里面。

1
unzip "WiresharkUser'sGuide.zip" -d /opt/k8s_store/nginx/index

在共享目录写一个index.html放在/opt/k8s_store/nginx

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
[root@node0 nginx]# nano index.html
[root@node0 nginx]# pwd
/opt/k8s_store/nginx

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Index of Files</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            margin: 20px;
        }
        h1 {
            color: #333;
        }
        ul {
            list-style-type: none;
            padding: 0;
        }
        li {
            margin: 8px 0;
        }
        a {
            text-decoration: none;
            color: #007bff;
        }
        a:hover {
            text-decoration: underline;
        }
    </style>
</head>
<body>
    <h1>Index of Files</h1>
    <ul>
        <li><a href="index/index.html">Click Here to 'Wireshark User’s Guide'</a></li>
        <!-- Add more links here as needed -->
    </ul>
</body>
</html>

用到的配置文件

1
2
[root@node0 nginx]# ls
nginx-deployment.yaml  nginx-service.yaml  pvc.yaml  pv.yaml

pv.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[root@node0 nginx]# cat pv.yaml 
apiVersion: v1
kind: PersistentVolume
metadata:
  name: nginx-pv
spec:
  capacity:
    storage: 1Gi
  volumeMode: Filesystem
  accessModes:
    - ReadWriteMany  # 使用ReadWriteMany，支持多个节点挂载
  persistentVolumeReclaimPolicy: Retain
  nfs:
    path: /opt/k8s_store/nginx  # 共享目录
    server: node0  # NFS服务器地址

pvc.yaml

1
2
3
4
5
6
7
8
9
10
11
[root@node0 nginx]# cat pvc.yaml 
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: nginx-pvc
spec:
  accessModes:
    - ReadWriteMany  # 对应修改后的PV配置
  resources:
    requests:
      storage: 1Gi

nginx-deployment.yaml 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
[root@node0 nginx]# cat nginx-deployment.yaml 
apiVersion: apps/v1
kind: Deployment
metadata:
  name: k8s-nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: k8s-nginx
  template:
    metadata:
      labels:
        app: k8s-nginx
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - containerPort: 80
          volumeMounts:
            - name: nginx-storage
              mountPath: /usr/share/nginx/html  # NFS 共享目录挂载到 Nginx 的默认网页目录
      volumes:
        - name: nginx-storage
          persistentVolumeClaim:
            claimName: nginx-pvc  # 绑定的 PVC 名称

nginx-service.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[root@node0 nginx]# cat nginx-service.yaml 
apiVersion: v1
kind: Service
metadata:
  name: nginx-service  # 服务名称
spec:
  selector:
    app: k8s-nginx  # 选择标签，确保将流量转发到对应的 Pod
  ports:
    - protocol: TCP
      port: 80  # 服务端口
      targetPort: 80  # 容器内部端口
  type: NodePort  # 使用 NodePort 类型来暴露服务

[root@node0 nginx]#

应用即可

常见问题

更改共享目录权限

所有人可以访问

1
[root@node0 nginx]# sudo chmod -R 777 /opt/k8s_store

pvc/pv更新

如果之前部署文件有误要重新部署，可以使用删除原配置重新部署

1
2
3
4
5
6
7
8
9
10
11
# 删除旧的pvc和pv创建新的
[root@node0 ollama]# vi pv.yaml
[root@node0 ollama]# vi pvc.yaml
[root@node0 ollama]# kubectl delete pvc ollama-pvc
persistentvolumeclaim "ollama-pvc" deleted
[root@node0 ollama]# kubectl delete pv ollama-pv
persistentvolume "ollama-pv" deleted
[root@node0 ollama]# kubectl apply -f pv.yaml
persistentvolume/ollama-pv created
[root@node0 ollama]# kubectl apply -f pvc.yaml
persistentvolumeclaim/ollama-pvc created

pvc删除卡住

显示

1
2
3
4
[root@node0 ~]# kubectl get pvc ollama-pvc
NAME         STATUS        VOLUME      CAPACITY   ACCESS MODES   STORAGECLASS   AGE
ollama-pvc   Terminating   ollama-pv   8Gi        RWO                           27m
[root@node0 ~]#

当PVC显示为Terminating时，通常意味着Kubernetes正在执行删除操作，但未能完全完成。这通常是由于某些资源清理不完整或在删除过程中发生阻塞。

查看该PVC详细信息

1
kubectl describe pvc ollama-pvc

此处显示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[root@node0 ~]# kubectl describe pvc ollama-pvc
Name:          ollama-pvc
Namespace:     default
StorageClass:  
Status:        Terminating (lasts 2m16s)
Volume:        ollama-pv
Labels:        <none>
Annotations:   pv.kubernetes.io/bind-completed: yes     
               pv.kubernetes.io/bound-by-controller: yes
Finalizers:    [kubernetes.io/pvc-protection]
Capacity:      8Gi
Access Modes:  RWO
VolumeMode:    Filesystem
Used By:       ollama-deployment-777b9bccb7-wq6lh
Events:        <none>
[root@node0 ~]#

可以看到，它正处于Finalizers保护机制下。Finalizers: [kubernetes.io/pvc-protection]表示Kubernetes正在确保该PVC不会在被使用时被删除。

由于ollama-deployment-777b9bccb7-wq6lh这个Pod仍在使用该PVC，删除操作没有完成。

解决方案为删除Pod

1
kubectl delete pod ollama-deployment-777b9bccb7-wq6lh

这时候pvc即可删除

除此之外，可以选择强制删除pvc，不过不做推荐（此处未使用）

1
kubectl delete pvc ollama-pvc --force --grace-period=0

pod自动重启

刚才执行了

1
kubectl delete pod ollama-deployment-777b9bccb7-wq6lh

但由于之前部署由Deployment管理，Deployment会自动创建一个新的Pod来替代被删除的Pod。

如下所示

1
2
3
4
5
6
7
[root@node0 ~]# kubectl get po
NAME                                 READY   STATUS    RESTARTS      AGE
k8s-nginx-6d779d947c-mvj99           1/1     Running   2 (59m ago)   46d
k8s-nginx-6d779d947c-qdkvh           1/1     Running   2 (59m ago)   46d
k8s-nginx-6d779d947c-zh8zs           1/1     Running   2 (59m ago)   46d
ollama-deployment-777b9bccb7-nb9ct   0/1     Pending   0             10s
[root@node0 ~]#

阻止pod自动重启可以删除deployment

1
kubectl delete deployment ollama-deployment

重新查看，发现删除成功

1
2
3
4
5
6
7
[root@node0 ollama]# kubectl get pods
NAME                                 READY   STATUS        RESTARTS      AGE
k8s-nginx-6d779d947c-mvj99           1/1     Running       2 (76m ago)   46d
k8s-nginx-6d779d947c-qdkvh           1/1     Running       2 (76m ago)   46d
k8s-nginx-6d779d947c-zh8zs           1/1     Running       2 (76m ago)   46d
ollama-deployment-777b9bccb7-sj7wd   1/1     Running       0             3m18s
[root@node0 ollama]

更改副本数

1
kubectl scale deployment k8s-nginx --replicas=1

scp传输

1
2
3
4
5
6
PS C:\Users\dd\Desktop> scp '.\WiresharkUser''sGuide.zip' root@192.168.195.40:/opt/k8s_store/nginx

Authorized users only. All activities may be monitored and reported.
root@192.168.195.40's password:
WiresharkUser'sGuide.zip                                                              100%   10MB 129.3MB/s   00:00
PS C:\Users\dd\Desktop>

Posted on

prometheus监控k8s

初见prometheus

1
nano /opt/prometheus/config/prometheus.yml

填入如下内容作为配置（监控自己）

1
2
3
4
scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]  # Prometheus 主节点地址

运行

1
docker run -d --name=prometheus -p 9090:9090 -v /opt/prometheus/config/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus

运行成功后可以浏览器访问

image-20241203192821670

nginx实例

1
docker run -d --name=mynginx -p 10080:80 nginx

此时可以在浏览器访问

image-20241203193603780

使用stats查看某容器状态

1
2
3
4
5
[root@node0 docker.service.d]# docker stats mynginx
# or
[root@node0 docker.service.d]# docker stats --no-stream mynginx
CONTAINER ID        NAME                CPU %               MEM USAGE / LIMIT     MEM %               NET I/O             BLOCK I/O           PIDS
96ee9202c1c9        mynginx             0.00%               3.598MiB / 3.297GiB   0.11%               5.77kB / 4.89kB     0B / 16.4kB         5

说明 –no-stream Disable streaming stats and only pull the first result\

终端处理格式化文本

1
docker stats --no-stream mynginx | awk 'NR!=1{print $3}'

解释
NR：表示当前处理的行号。NR != 1 代表跳过第一行（标题行）
print $3：表示输出每行的第三列（即 CPU 使用百分比）。

awk使用（插曲）

awk 是一种强大的文本处理工具，通常用于从文本中提取、处理和生成报告。它特别适用于处理结构化的文本数据，比如日志文件、CSV 文件、配置文件、表格数据等。它可以按行处理文本，并且可以通过分隔符（例如空格、逗号等）来处理数据。

awk 基本用途和功能

按列处理数据

awk 可以轻松处理按空格或其他分隔符（例如逗号）分隔的文本。默认情况下，awk 使用空格或制表符（Tab）作为分隔符来划分每行数据，并通过 $1, $2, $3 等来访问每一列。

示例：从一个文件或命令输出中提取每行的第一列数据：

1
echo -e "apple 10\nbanana 20" | awk '{print $1}'

输出：

1
2
apple
banana

操作行和列

在 awk 中使用条件语句、循环、数学运算等来处理文本中的数据。

示例：计算每行第一列和第二列的和：

1
echo -e "10 20\n30 40" | awk '{print $1 + $2}'

输出：

1
2
30
70

使用字段分隔符（FS）

可以指定自定义的字段分隔符。例如，当数据是 CSV 格式时，分隔符是逗号。

示例：指定逗号作为分隔符来处理 CSV 数据：

1
echo -e "apple,10\nbanana,20" | awk -F ',' '{print $1}'

输出：

输出：

1
2
apple
banana

模式匹配和条件执行

awk 允许根据条件执行特定的操作，例如打印满足条件的行。

示例：打印包含“banana”这一单词的行：

1
echo -e "apple 10\nbanana 20" | awk '$1 == "banana" {print $0}'

输出：

1
banana 20

内置变量

awk 提供了一些内置变量，比如：

NR：当前处理的行号。
NF：当前行的字段数。
$0：整行文本。
$1, $2, $3：每行的第 1、2、3 列。
FS：字段分隔符（默认是空格或制表符）。
打印格式化输出
awk 可以自定义输出格式，比如指定列宽、对齐等。

示例：输出每个字段的固定宽度：

1
echo -e "apple 10\nbanana 20" | awk '{printf "%-10s %10s\n", $1, $2}'

输出：

1
2
apple           10
banana          20

cadvsior

安装

1
2
3
4
5
6
7
8
9
docker run -d --volume=/:/rootfs:ro \
  --volume=/var/run:/var/run:ro \
  --volume=/sys:/sys:ro \
  --volume=/var/lib/docker/:/var/lib/docker:ro \
  --volume=/dev/disk/:/dev/disk:ro \
  --publish=8080:8080 \
  --detach=true \
  --name=cadvisor \
  google/cadvisor:latest

此时可以在8080访问

image-20241203193536021

在prometheus绑定的配置文件添加监控源

1
nano /opt/prometheus/config/prometheus.yml

image-20241203202747980

重启prometheus

1
docker restart prometheus

静待片刻即可收到返回的新数据

image-20241203202901001

grafana

1
docker run -d --name=grafana -p 3000:3000 grafana/grafana

之后可以在端口3000访问

默认账号密码

1
2
admin
admin

第一次会提示修改密码

image-20241203202038317

先添加数据源

image-20241203202125565

image-20241203202150910

image-20241203202212419

再导入监控模板

image-20241203202246323

image-20241203202321103

image-20241203202349339

之后即可看到监控数据

image-20241203202420197

node exporter

先创建容器，使用 –net=”host”` 网络模式共享主机网络堆栈，不需要-p进行端口映射

1
docker run -d   --name=node-exporter   --net="host"   --pid="host"   -v "/:/host:ro,rslave"   quay.io/prometheus/node-exporter:latest   --path.rootfs=/host

image-20241203202633848

再次配置到前端展示

1
nano /opt/prometheus/config/prometheus.yml

image-20241203231340915

1
docker restart prometheus

静待一会即可

image-20241203231321355

对于Grafana，依旧是带入库模板，编号9276

image-20241203231507625

image-20241203231623784

之后即可看到面板

image-20241203231703052

有些显示没有图表，一般是三个原因

  1. 没数据（取采）
  2. 时间不对（采集的时间戳与实际时间不符，调节横轴时间范围）
  3. 代码写错了（如下面的网卡，可以把语句的中间拿去prometheus查询看有没有数据）

调整图表

cpu使用率

image-20241203232815565

有结果的

1
node_cpu_seconds_total{instance=~"$node",mode="idle"}

image-20241203232842329

加一个irate就没了

1
irate(node_cpu_seconds_total{instance=~"$node",mode="idle"}[1m])

image-20241203232953786

推测node_cpu_seconds_total 只被更新不频繁，增加时间范围，到2分钟，可以

1
irate(node_cpu_seconds_total{instance=~"$node",mode="idle"}[2m])

image-20241203233413063

于是问题解决

1
100 - (avg(irate(node_cpu_seconds_total{instance=~"$node",mode="idle"}[2m])) * 100)

image-20241203233919379

磁盘读写速率

点进去发现具有同样的问题，时间片从1m改为2m解决，最后一个为实时io，无data，查询普罗米修斯，返回状态码0

image-20241203234214204

image-20241204000357533

磁盘读写容量

与上面类似处理

image-20241203234646417

磁盘IO读写时间

类似处理，可以显示数据（实际上四条查询，前两个指标nodata，原因尚不清楚，后两个有）

image-20241203235634961

磁盘每秒IO耗时

类似处理，解决

image-20241203235842715

网络进出流量

比如下面这个是默认的网卡名称不对

image-20241203231809571

1
irate(node_network_receive_bytes_total{instance=~'$node',device=~'$nic'}[5m])*8

改为实际的网卡即可

1
irate(node_network_receive_bytes_total{instance=~'$node',device=~'ens33'}[5m])*8

image-20241203231933298

分区显示

刷新解决

image-20241204001130367