### 1. zabbix_proxy和zabbix_server对比


1. proxy是轻量级的
2. 没有图形界面
3. 独立工作
4. 易于维护
5. 可以自己生成数据库
6. 无本地管理功能
7. 可以准备嵌入式硬件
8. 可以单向tcp连接
9. 可以集中配置
10. 发送通知

zabbix proxy 使用场景:

1. 监控远程区域设备
2. 监控本地网络不稳定区域
3. 当zabbix监控上千设备时,使用它来减轻server的压力
4. 简化分布式监控的维护

官网说明：
zabbix proxy 仅仅需要一条tcp连接到zabbix server,所以防火墙上仅仅需要加上一条规则即可。
zabbix proxy 数据库必须和server分开,否则数据会被破坏。
proxy 收集到数据之后，首先将数据缓存在本地,然后在一定得时间之后传递给 zabbix server，这样就不会因为服务器的任何临时通信问题而丢失数据。这个时间由 proxy配置文件中参数 ProxyLocalBuffer 和 ProxyOfflineBuffer 决定。
注意从Zabbix server数据库直接更新最新配置的proxy可能会比Zabbix server新，而Zabbix server的配置由于 CacheUpdateFrequency 的原因而无法快速更新。因此，proxy收集发送Zabbix server数据可能会被忽略。
一般规格的（<=100台）集群基本上不会考虑proxy模式。

### 2. 安装zabbix

```bash 
# wget https://repo.zabbix.com/zabbix/4.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_4.0-3+bionic_all.deb
# dpkg -i zabbix-release_4.0-3+bionic_all.deb
# apt update

修改zabbix源的位置
vim /etc/apt/sources.list.d/zabbix.list

deb https://mirrors.aliyun.com/zabbix/zabbix/4.0/ubuntu bionic main
deb-src https://mirrors.aliyun.com/zabbix/zabbix/4.0/ubuntu bionic main

###创建数据库
#create database zabbix_passive character set utf8 collate utf8_bin;
#grant all privileges on zabbix_passive.* to zabbix_passive@"192.168.0.%" identified by '123456';

数据库导入sql文件建表
schema.sql
```
### 3.安装proxy

```bash
root@zabbix1:~# apt install zabbix-proxy-mysql


# 修改配置文件
vim /etc/zabbix/zabbix_proxy.conf

# 0是主动模式，1是被动模式
ProxyMode=1
# server的地址
Server=192.168.0.101
#端口
ServerPort=10051

Hostname=zabbix-proxy-passive-mykernel
ListenPort=10051
DBHost=192.168.0.220
DBName=zabbix_passive
DBUser=zabbix_passive
DBPassword=123456

#优化参数
#允许proxy保留数据多长时间，小时计算，传输完成的保留时间
ProxyLocalBuffer=168

# 主动模式的心跳检测
HeartbeatFrequency=120

# 配置监控项同步的间隔周期
ConfigFrequency=30 #生产可以长点

DataSenderFrequency=30
# 收集器数量
StartPollers=5
HistoryCacheSize=16M
# Default:
User=root


#启动
systemctl start zabbix-proxy.service 
systemctl enable zabbix-proxy.service 
```
编译安装文档：https://www.zabbix.com/documentation/4.0/zh/manual/installation/install



### 4. zabbix架构
zabbix server 添加proxy

1. 初始模式
zabbix-server - zabbix-agent  
被动模式，zabbix-server主动来监控agent
==>
2. 主动模式
被动模式，zabbix-agent主动发送监控数据给zabbix-server
==>
3. proxy模式

zabbix-proxy 主动模式
zabbix-proxy 被动模式

zabbix-proxy 去代替server去监控agent

最优方案：
主动proxy+主动agent

![image-20201114120856379](http://qiniu.mykernel.cn/image-20201114120856379.png)



zabbix代理

### 1.os.path(py3.4之前)


```python
from os import path

p = path.join('/etc','sysconfig','network')  #path.join 拼接。。只能第一个最前位置带/
p
```




    '/etc/sysconfig/network'




```python
print(type(p),p,'\n') #p 是一个字符串
print(path.exists(p)) #判断文件是否存在
print(path.dirname(p)) #路径的dirname
print(path.basename(p))  #路径的基名
print(path.split(p)) #分割dirname 和 basename
print(path.abspath('network'))  #取文件的绝对路径，/jupyter/draft/network 并不存在

```

    <class 'str'> /etc/sysconfig/network 
    
    True
    /etc/sysconfig
    network
    ('/etc/sysconfig', 'network')
    /jupyter/draft/network


### 2. pathlib.Path(py3.4之后)


```python
from pathlib import  Path
```

#### 1.生成一个路径 


```python
print('1:',Path()) #取当前路径
print('2:',Path('a','b','c/d')) #字符合成
print('3:',Path('/etc'))  #直接写入绝对路径
```

    1: .
    2: a/b/c/d
    3: /etc


#### 2. 路径的拼接和分解

/ 拼接：
p / 'str'   或者 'str' / p 


```python
p = Path('a','b','f/z')
print(p)
p2 = p / 'new_str'
print(p2)
p3 = '/new_str' / p
print(p3)
p4 = p3 / p
print(p4)
```

    a/b/f/z
    a/b/f/z/new_str
    /new_str/a/b/f/z
    /new_str/a/b/f/z/a/b/f/z


joinpath 拼接


```python
p3.joinpath('etc','ab',Path('http')) # 等效于 p3.joinpath('etc','ab','http')

```




    PosixPath('/new_str/a/b/f/z/etc/ab/http')



路径分割: parts方法


```python
print(p4.parts)

```

    ('/', 'new_str', 'a', 'b', 'f', 'z', 'a', 'b', 'f', 'z')


#### 3 获取路径

1. 获取字符串路径，str
2. 获取bytes路径，bytes


```python
p = Path('/etc')
print(str(p),'\n',bytes(p))
```

    /etc 
     b'/etc'


获取目录:
获取父目录：
parent
parents


```python
p4 = Path('/new_str/a/b/f/z/a/b/f/z')
print(p4.parent)
print(p4.parents)

for x in p4.parents:
    print(x)
```

    /new_str/a/b/f/z/a/b/f
    <PosixPath.parents>
    /new_str/a/b/f/z/a/b/f
    /new_str/a/b/f/z/a/b
    /new_str/a/b/f/z/a
    /new_str/a/b/f/z
    /new_str/a/b/f
    /new_str/a/b
    /new_str/a
    /new_str
    /


其他相关1：


```python
p = Path('/a/b/c/d/g.tar.gz.a')

print(p.name) #取basename
print(p.suffix) #取目录最后一部分的扩展名，最后一个小数点部分。包括小数点。
print(p.suffixes) #取从左到右第一个小数点右侧的部分，小数点分割。每部分都带小数点。
print(p.stem) #取basename 排除最后一个小数点部分
print(p.with_name('233.tgz')) #补仓后缀
print(p.with_suffix('.txt')) #补后缀
```

    g.tar.gz.a
    .a
    ['.tar', '.gz', '.a']
    g.tar.gz
    /a/b/c/d/233.tgz
    /a/b/c/d/g.tar.gz.txt


其他相关2：


```python
p = Path('../tmp/')
print(p.cwd())  #获取当前所在目录
print(p.home())  #获取当前用户的家目录
print(p.is_dir()) #判断是否为目录
print(p.is_file())#判断是否为文件
print(p.is_symlink()) #判断是否为软连接
print(p.is_socket()) #判断是否为socket 文件
print(p.is_block_device()) #判断是否为块设备
print(p.is_char_device()) #判断是否为字符设备
print(p.is_absolute()) #判断是否为绝对路径

print(p.resolve()) #返回绝对路径，推荐使用
print(p.absolute()) #返回绝对路径 
print(p.exists()) #判断文件或者目录是否存在


```

    /jupyter/draft
    /root
    True
    False
    False
    False
    False
    False
    False
    /jupyter/tmp
    /jupyter/draft/../tmp
    True


其他相关3：


```python
p5 = Path('/b/b/c')
p5.as_uri() #返回文件的uri

#说明：不能使用相对路径。。
```




    'file:///b/b/c'



#### 4. 创建目录或者文件


```python
from pathlib import Path

p6 = Path('../tmp/123')
p6.mkdir(exist_ok = True)

#mkdir(mode=0o777,parents=False,exist_ok = False)
#parents 是否创建父目录，递归创建
#exist_ok = True 忽略文件存在的异常，默认是不忽略。

p7 = Path('../tmp/123/hello.txt')
p7.touch()

#touch(mode=0o666,exist_ok = True)

```

#### 5. 相关操作 

路径相关操作：


```python
#设置路径变量
p1 =Path('/jupyter/tmp/a/b')
p2 =Path('/jupyter/tmp/a/b/3.txt')

# 创建文件
p1.mkdir(parents= True,exist_ok= True)
p2.touch()

# 检测文件是否创建成功
print(p2.exists())

#在a/b下创建新文件
p1 /= 'readme.txt'
p1.touch()
print(p1)
print(p1.exists())


```

    True
    /jupyter/tmp/a/b/readme.txt
    True


### 3. 文件操作

p.open(mode='r',buffering=-1,encoding=None,errors=None,newline=None)
返回一个文件对象。

p.read_bytes() 以rb读取路径对应的文件，并返回二进制流；
p.read_text(encoding=None,errors=None) rt
p.write_bytes(data) 以wb 方式写入数据到路径对应的文件
p.write_text(data,encoding=None,errors=None) wt


```python
from pathlib import Path

p = Path('../tmp/test.py')
p.write_text('i am mykernel')
print(p.read_text())

with p.open() as f:
    print(f.read(5))
```

    i am mykernel
    i am 


路径相关操作2：
遍历并判断文件的类型，如果是目录，判断其是否为空。

### 4. 总结 

<img src="http://qiniu.mykernel.cn/%E8%B7%AF%E5%BE%84%E6%93%8D%E4%BD%9C1.png">
<img src="http://qiniu.mykernel.cn/%E8%B7%AF%E5%BE%84%E6%93%8D%E4%BD%9C2.png">


python的路径操作

#### 1. 排序

sorted(interable,key,reverse)  

interable: 需要排序的对象；
key: 按照什么开始排序；
reverse： 是否逆序，默认从小到大，可设置为True。

sorted(word_count.items(),key=lambda  x:x[1],reverse=True)


```
## 返回新列表
lst = [1,2,44,3,-1,0,54]
print(sorted(lst,key=lambda x:6-x))
print(lst)

#就地修改
list.sort(lst,key=lambda x: 6-x)
print(lst)
##
```

    [54, 44, 3, 2, 1, 0, -1]
    [1, 2, 44, 3, -1, 0, 54]
    [54, 44, 3, 2, 1, 0, -1]


#### 2. 过滤


```
#过滤出数列中能被3整除的数字

print(list(filter(lambda x: x%3==0, [1,9,55,150,-3,78,28,123])))

#过滤函数过滤可迭代对象的元素，返回一个迭代器。
```

    [9, 150, -3, 78, 123]


#### 3. 映射


```
#对多个可迭代对象的元素按照指示的函数进行映射

print(list(map(lambda x:2*x+1, range(5))))

print(dict(map(lambda x: (x%5,x) , range(500))))
```

    [1, 3, 5, 7, 9]
    {0: 495, 1: 496, 2: 497, 3: 498, 4: 499}



```
#### 1. 排序

## 返回新列表
lst = [1,2,44,3,-1,0,54]
print(sorted(lst,key=lambda x:6-x))
print(lst)

#就地修改
list.sort(lst,key=lambda x: 6-x)
print(lst)
##

#### 2. 过滤

#过滤出数列中能被3整除的数字

print(list(filter(lambda x: x%3==0, [1,9,55,150,-3,78,28,123])))

#过滤函数过滤可迭代对象的元素，返回一个迭代器。

#### 3. 映射

#对多个可迭代对象的元素按照指示的函数进行映射

print(list(map(lambda x:2*x+1, range(5))))

print(dict(map(lambda x: (x%5,x) , range(500))))
```

    [54, 44, 3, 2, 1, 0, -1]
    [1, 2, 44, 3, -1, 0, 54]
    [54, 44, 3, 2, 1, 0, -1]
    [9, 150, -3, 78, 123]
    [1, 3, 5, 7, 9]
    {0: 495, 1: 496, 2: 497, 3: 498, 4: 499}


#### 4. zip  

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。


```
nums = ['flower','flow','flight']
for i in zip(*nums):
    print(i)
```

    ('f', 'f', 'f')
    ('l', 'l', 'l')
    ('o', 'o', 'i')
    ('w', 'w', 'g')



python的常用函数

### 0. 概述 

文件的操作：
关于一个文件的一生:

文件的诞生，创建文件。在linux下可以使用touch、vim等命令进行创建。使用python，可以使用open的操作进行创建。
文件的修改，此处只说明python的相关操作。
1. 打开文件，open()
2. 修改文件，write()
3. 读取文件，read()
4. 关闭文件，close()

文件的结束。linux下使用rm命令进行删除。


### 1.open 

open(file,mode='r',buffering=-1,encoding=None,errors=None,newline=None,closefd=True,opener=None)

open()是相关操作中参数最多，也是最复杂的一个方法。
file：文件名称；
mode：打开文件时候，文件具有的属性；
buffering：缓冲区；
encoding: 编码，仅文本模式使用；
errors：什么样的编码会被屏蔽；
newline：换行符的转换，进文本模式使用；
closefd：关闭文件描述符；
opener：

其中最常使用的是前5个参数，文件名不可缺省。各项缺省值如下：
open(file,mode='r',buffering=-1,encoding=None,errors=None,newline=None,closefd=True,opener=None)

#### 1. file

此处使用文件的相对路径和绝对路径均可，建议使用绝对路径。
如果不指定路径，则默认当前路径。当前路径也是相对路径开始的地方。

#### 2. mode 

文件访问的两种模式：
1. 文本模式
连续的字符，字符流。按照字符处理。
2. 二进制模式
字节流，将文件按照字节理解。

mode
r：只读打开，不存在会抛出异常，默认（正常思维的打开方式）；

w：只写打开，文件不存在时候创建，文件存时且有内容就先清空。 只写（永远打开的是一个空文件）；
x：创建文件，并且只写打开，文件存在则报错。 只写（文件不能存在，创建并打开的是一个空文件）；
a：文件存在，则追加。文件不存在时候，创建文件。 只写（永远都是写在最后）；
b：使用二进制模式打开；  
t：缺省的，使用文本模式打开；
\+ 读写打开一个文件,给原来只读。只写方式打开提供，缺省的读写能力。

只写打开的文件是不能读的。

程序是如何定位打开时候的位置呢？
文件内部都维护了一个指针，可以理解为windows下的光标位置。
当：
mode = r，指针（光标）放在文本的最前面。可以从开始一个一个的读出来。
mode = a，指针（光标）放在文本的最后边。如果此时加一个可读的权限，能读出来什么呢?

tell() 可以告诉我，这个这个打开的文件的指针位置。


```python
f = open('../tmp/test','a+')
print(f.tell())
print(f.writable())  
print(f.read())  

f.close()
##说明1：此处文本的内容为：i love python
##说明2：打开的文件使用完毕后必须第一时间调用close关闭。
```

    14
    True
    


#### 3. seek()

seek() 英文意思：往或朝…而去，此处可以移动我们的指针（光标）。
seek(offest,[whence])
offest：偏移的字节量；
whence：从什么位置开始。

seek控制字节是很好使用的，但是文本模式下就很麻烦了。
文本模式下：
whence 0：缺省值，此时offest只能是正整数；
whence 1：表示当前位置开始，offest只能是0（毫无意义）；
whence 2：表示从末尾开始，offest只能说0。


**文本模式**


```python
f = open('../tmp/test','a+')  #默认是文本模式
print(f.tell())
f.seek(1) #表示指针移到第二个字节开始的位置。
print(f.tell())
print(f.writable())  
print(f.read())  
f.close()
```

    14
    1
    True
     love python
    


**字符模式**


```python
f = open('../tmp/test1','ab+')  #b是bytes的缩写，字节模式
print(f.tell())
f.seek(-10,2)  #从末尾位置向前移到10个字符，1表示当前位置，0是默认值，不能接受负数了。
print(f.tell())
print(f.read()) 
f.close()

##文件内容是：我爱python，向前移动10个字符。python\n是7个字符，爱是三个字符。

print(b'\xe7\x88\xb1'.decode())

##说明:二进制模式下，seek不允许向前超界，向后允许。
```

    13
    3
    b'\xe7\x88\xb1python\n'
    爱


#### 4. buffering

buffering参数是写入文件时候的缓冲控制，文件写入的时候先保存到内存中，当存到一定的数量时候，就会写入硬盘。
缺省值是 -1。
二进制模式下，默认大小是4096或者8192个字节。
文本模式下，如果说终端设备，行缓存模式。非终端设备，使用二进制策略，一个汉字大多数算三个字符。
1. buffering = 0 只在二进制模式下使用，关闭buffer；
2. buffering = 1 只在文本模式下使用，表示开启行缓冲，见到换行符就保存(flush)到硬盘中；
3. buffering > 1 用于指定buffer的大小。


```python
# 查看默认的缓存区大小
import io
f = open('../tmp/test1','ab+')
print(io.DEFAULT_BUFFER_SIZE)


```

    8192


**注意：**
1. 文本模式，一般都使用默认缓冲区大小；
2. 二进制模式，都是一个个字节的操作，可以指定buffer的大小；
3. 一般来说，默认缓冲区大小说个比较好的选择，除非明确知道要干什么；
4. 一般编程中，明知道需要写入磁盘，都会手动调用flush操作。

flush()

把缓存全部写入磁盘，调用close关闭文件时，会自动先执行一次flush再关闭文件。

### 2. write()

write(s)把字符串s写入到文件中保存并返回字符个数。

### 3. read()

read(size=-1)
size表示读取多少个字符（t模式）或者字节（b模式）出来，负数或者None表示从指针处全部读出。



```python
f = open('../tmp/test1','r+')  #b是bytes的缩写，字节模式
f.seek(6)  #移动两个汉字，6个字符
print(f.read(6)) 
f.close()

#文本内容，我爱python
```

    python


readline(size=-1)
使用一次读取一行的内容；



```python
f = open('../tmp/test2','r+')  #b是bytes的缩写，字节模式

print(f.readline()) 
print(f.readline()) 
f.close()

#文本内容：
# 我爱python
# i my mykernel
```

    我爱python
    
    i my mykernel
    


readlines(size=-1)
一次性读出所有的行，并以列表的形式输出；



```python
f = open('../tmp/test2','r+')  #b是bytes的缩写，字节模式

print(f.readlines()) 
f.close()

#文本内容：
# 我爱python
# i my mykernel
```

    ['我爱python\n', 'i my mykernel\n']


### 4. close()

close()

关闭打开中的文件，如果文件并未打开，调用了也不会产生异常。

### 5. 其他  

seekable() 测试是否可seek
readable() 测试是否可读
writable() 测试是否可写
closed 测试是否已经关闭


```python
f = open('../tmp/test2','r+')  #b是bytes的缩写，字节模式

print(f.seekable())
print(f.readable())
print(f.writable())
print(f.closed)
print(f.readlines()) 

f.close()
print(f.closed)
#文本内容：
# 我爱python
# i my mykernel
```

    True
    True
    True
    False
    ['我爱python\n', 'i my mykernel\n']
    True



```python
f = open('../tmp/test2','r')  #b是bytes的缩写，字节模式

print(f.seekable())
print(f.readable())
print(f.writable())
print(f.closed)
print(f.readlines()) 

f.close()
print(f.closed)
#文本内容：
# 我爱python
# i my mykernel
```

    True
    True
    False
    False
    ['我爱python\n', 'i my mykernel\n']
    True



```python
f = open('../tmp/test2','a')  #b是bytes的缩写，字节模式

print(f.seekable())
print(f.readable())
print(f.writable())
print(f.closed)
f.close()
print(f.closed)
#文本内容：
# 我爱python
# i my mykernel
```

    True
    False
    True
    False
    True



python的文件操作

# 保障服务正常运行的监控

## 报警内容

集群报警发送给运维组（devops）

监测内容，

1. 节点的磁盘空间，cpu，内存状态。
2. pod状态（是否重启，pending，error等）

3. deployment的状态（Jenkins发版更新确认是否成功）



## 发送方式

邮件，短信（重要）。

发送给运维



# 业务是否报错的监控

## 报警的内容

报警发送给各个项目相关人员

1. 检测日志是否error，1条就发（邮件，短信）

2. 检测日志warring，根据频繁程度报警（邮件，企业微信webhook）

   

## 发送的方式

邮件，短信，企业微信webhook

发给每个对应的开发负责成员，兵总，运维

saas服务发给研发





# 阿里云给k8s提供的报警三个位置

1. arms提供的报警

https://arms-ap-southeast-1.console.aliyun.com/?promtype=ManagedKubernetes/#/promDetail/ap-southeast-1/ca3135b0b22024faf895e826d6c241c9e/alarms

![image-20211025084919049](http://qiniu.mykernel.cn/typora/image-20211025084919049.png)

2. 日志sls提供的报警

![image-20211025085054711](http://qiniu.mykernel.cn/typora/image-20211025085054711.png)

直接通过日志进行报警，原理是我们安装的ack会开启事件中心，时间中心会记录下k8s的所有事件。日志是放在sls下边，名称为k8s-event。

![image-20211025085944988](http://qiniu.mykernel.cn/typora/image-20211025085944988.png)



这里可以通过关键字进行报警。

3. ack集群提供的报警设置

![image-20211025085144189](http://qiniu.mykernel.cn/typora/image-20211025085144189.png)

这个报警也是使用的sls日志报警，通过的是阿里云的CRD配置进去的。

报警项目对应关系：https://help.aliyun.com/document_detail/207725.html?spm=5176.2020520152.help.dexternal.9c9d16ddXzw8gs

![image-20211025085321377](http://qiniu.mykernel.cn/typora/image-20211025085321377.png)



# 如何使用arms提供的报警

## 进入arms服务

![image-20211025170706169](http://qiniu.mykernel.cn/typora/image-20211025170706169.png)



点击“Prometheus监控”

![image-20211025170738023](http://qiniu.mykernel.cn/typora/image-20211025170738023.png)



点击实例进入

![image-20211025170900292](http://qiniu.mykernel.cn/typora/image-20211025170900292.png)



选择“报警配置”

![image-20211025170940236](http://qiniu.mykernel.cn/typora/image-20211025170940236.png)

这里可以看到系统内置的报警规则。

## 配置第一个报警

### 开启报警策略

主要功能是监控是否有报警产生，

在“报警配置”页面开启需要报警的服务，可以进行自定义编辑。

### 添加联系人和联系组

告警运维中心地址：https://alerts-sg.console.aliyun.com/#/alarm/dispatch

没有很明显的入口，直接使用URL进入。

![image-20211025171601606](http://qiniu.mykernel.cn/typora/image-20211025171601606.png)



### 配置通知策略

注意，这里需要配置通知策略里边的“分派规则”来关联前面的“报警策略”。

![image-20211025172219910](http://qiniu.mykernel.cn/typora/image-20211025172219910.png)



### 查看报警

在告警运维中心可以查看报警历史和正在进行的报警。

![image-20211025172853397](http://qiniu.mykernel.cn/typora/image-20211025172853397.png)

### 报警收到了

![image-20211025172518080](http://qiniu.mykernel.cn/typora/image-20211025172518080.png)

## 自定义报警策略

### 简单的PromQL语法

官方：https://help.aliyun.com/document_detail/176180.html

![image-20211027110424494](http://qiniu.mykernel.cn/typora/image-20211027110424494.png)

**查找某个image的pod的信息**

```bash
kube_pod_container_info{image="registry-vpc.ap-southeast-1.aliyuncs.com/acs/node-problem-detector:v0.6.3-29-71bd5f8"}

kube_pod_container_info是标签
支持正则表达式匹配
http_requests_total{code!="200"}// 表示查询 code 不为 "200" 的数据
http_requests_total{code=～"2.."}// 表示查询 code 为 "2xx" 的数据
http_requests_total{code!～"2.."}// 表示查询 code 不为 "2xx" 的数据
```

**查找某个pod_name前缀为ad-go-sg的pod的信息**

```bash
kube_pod_container_info{pod_name=~"ad-go-sg.*"}

.* 表示所有
```

**统计匹配到的pod个数**

```bash
count(kube_pod_container_info{pod_name=~"ad-go-sg.*"})

# 支持的聚合运算符
## sum，min，max，avg，stddev，stdvar，count，count_values，bottomk，topk，quantile，

```

```bash
kube_deployment_status_replicas{deployment=~".*ad.*"}

kube_pod_container_status_waiting_reason == 1
```

**获取pending的容器**

```bash
kube_pod_status_phase{phase=~"Pending",pod!~"ad-go-sg.*"}> 0

```

### 创建报警

点击"创建报警"

![image-20211027164755104](http://qiniu.mykernel.cn/typora/image-20211027164755104.png)



配置策略

![image-20211027165049044](http://qiniu.mykernel.cn/typora/image-20211027165049044.png)

这里是测试出来的，一些告警信息可以选的变量。

```bash
$labels的内容： {phase=Pending, _aliyun_arms_alert_level=ERROR, instance=kube-state-metrics:8080, pod=fluent-bit-46jqk, clustername=en-sg-prod, _aliyun_arms_alert_type=101, _aliyun_arms_integration_name=ARMS-DEFAULT, alertname=pending的容器（排除ad-namespace下的容器）, _aliyun_arms_userid=1919028704903788, _aliyun_arms_involvedObject_name=en-sg-prod, pod_name=fluent-bit-46jqk, _aliyun_arms_involvedObject_id=ca3135b0b22024faf895e826d6c241c9e, __name__=kube_pod_status_phase, _aliyun_arms_region_id=ap-southeast-1, _aliyun_arms_involvedObject_kind=cluster, _aliyun_arms_product_type=ARMS_PROMETHEUS, namespace=kubesphere-logging-system, _aliyun_arms_integration_id=105, _aliyun_arms_involvedObject_type=ManagedKubernetes, job=_kube-state-metrics, _aliyun_arms_alert_rule_id=18804}
 
 简单模板：
 pod状态:{{$labels.phase}}
 pod名称:{{$labels.pod}}
 集群名称:{{$labels.clustername}}
 报警名称:{{$labels.alertname}}
 命名空间:{{$labels.namespace}}
 Service:{{$labels.name}}
 
 如果是根据某个值进行的监控使用： 当前查出来的值，{{$value}}
 
```

创建完成。

![image-20211027165257374](http://qiniu.mykernel.cn/typora/image-20211027165257374.png)

通知策略同模式配置方式。



```bash
kube_deployment_status_replicas_unavailable and kube_deployment_status_replicas_available / kube_deployment_status_replicas < 1  and kube_deployment_status_replicas > 9
```

```bash

```





