代码收藏家 使用Python搭建自动化运维平台并编写运维脚本
本篇文章给大家谈谈python 运维开发都需要掌握哪些，以及python搭建自动化运维平台，希望对各位有所帮助，不要忘了收藏本站喔。
这两天在学校实训：用Python Django做学校的在线课堂系统，可谓是让我这个从未摸过Django和SQL的屌丝涨了市面快码知识。
工作之余，我无意之间翻了翻都写哪些经典的Python WEB框架：Flask、Django这些都太大了，自己手动写纯Socket工程量又太大……有没有什么好一点的这种方案呢？既可以实现轻量化，又可以不用去研究复杂的H5、JS和SQL```*``
最后还真的被我给找到了，这就是我们今天的主角：基于Python的MINI型APP框架：Streamlit高中信息技术python怎么学。
Streamlit原本的设计初衷是为了方便实现在WEB上搭建基于Python数据可视化或深度学习的APP以便于中小型团队能够快速的构建APP模型并针对APP中的BUG能够直观的查找并修正。
但是我就比较特立独行，你们既然都干这个，那我就干点花花的：用Streamlit搭建一个小型的运维监控平台。
其实我原来也曾试想着在Django的项目中嵌入一个Models去存储这些指标数据的，可是这么做的显然很不划算（只是我单纯的不想写模型罢了），于是乎借助Streamlit强大的API功能，我就开始了这个项目的构建。
环境准备
首先我们需要准备运行这个小APP的环境：
-Anaconda3（别问我为什么不用原生Python，问就是懒得下包）
-Streamlit：我们APP的主框架和逻辑支撑都靠它了
-Pandas：用于存放短时数据流和部分数据表，之后会讲到
-Psutil和Platform库：可以说没有这俩库这个APP写不成
-Plotly：用于实现可视化效果（其实我只用了一个）
-Pycuda：用于实现检测实例下的CUDA GPU数量极其部分属性
附上懒狗安包指令：
pip install streamlit psutil pandas pycuda plotly准备好环境了，我们是时候开始写点东西了
主APP编写
在编写APP之前，我们需要认真的考虑下APP中UI的排版与布局，因为虽然Streamlit的API非常强大，但它提供的可选UI界面真的少的可怜，最后在我激烈的思想斗争之下，我选择了下拉菜单这种经典UI布局。
废话不多说，我上来就先构建了一个下拉菜单的实例：
#在这里使用set_page_config()方法定义APP在WEB浏览器上现实的标题和布局
st.set_page_config(page_title="Django实例--{}".format(platform.node()),
layout="wide")
#创建一个selectbox下拉菜单的实例，参数分别为盒子的名称以及其他监视对象的子菜单名称
sidebar = st.selectbox(
"实例资源监视",
("基本信息","网络配置","基础监控","存储监控","弹性用户组配置","弹性安全组","GPU管理","命令终端")
)好的，既然实例创建完成了，如何这个下拉菜单的实例动起来，或者随着我们点击不同业务单元，它就可以自动变换显示的内容，这是我们想要的结果。那么，这就需要对实例点击内容的判断了。
子APP编写
前面有提到过selectbox()方法下存放的两个参数：一个是盒子的名称，另外一个是由其他对象构成的数组，那么我们的逻辑一定是要从子对象的内容进行入手。
Streamlit的API在这一块就做的非常的贴心，你住需要一行简单到不能再简单的逻辑判断，即可实现对APP显示内容的变换。
if sidebar == "基本信息":就这么简单！
知道怎么变化内容了，那现在就开始写些内容好咯：我的逻辑很简单，在基本信息中罗列了如下的信息：
#首先使用platform库下的system()方法获取到当前实例的运行系统内核
system_kernel = platform.system()
#写上标题，注意！：这个表题在前端显示的效果为H1，因此在落笔写标题的时候要慎重
st.title("实例基本信息")
#使用platform.node()方法获取当当前运行实例的名称
st.write("设备名称：{}".format(platform.node()))
# 需要申明：Linux端的返回数据和Windows端的并非相同，因此
# 针对不同系统内核，你需要单独修改platform和psutil返回值
# 的格式。本次APP将会以UBuntu系统下的情况为例。
#检测到当前运行内核为Linux
if system_kernel == "Linux":
#使用platform.machine()方法，并截取字符串以获得到当前实例系统的运行位宽
st.write("系统类型：{}{}位".format(system_kernel,platform.machine()[4:6]))
#使用platform.platform()方法获取到当前实例下的系统版本
st.write("系统版本：{}".format(platform.platform()))
#psutil.cpu_count()方法返回当前实例的物理内核数量
st.write("CPU：{}核".format(psutil.cpu_count()))
#因为当前的实例是运行在虚拟机上的，因此
#platform.processor()方法返回的是x86_64
#而该方法在实体机下的返回值则是：Intel64 Family 6 Model 158 Stepping 10, GenuineIntel
#可以看到在实体机下可以看到该实例下处理器的位宽，制造厂商，最大内核数以及步进（Stepping）
st.write("CPU类型：{}".format(platform.processor()))
#使用psutil.net_if_stats追踪到当前实例中连接到主网络的设备名称
st.write("基础网路连接：{}".format(list(psutil.net_if_stats())[1]))
#使用psutil.net_if_addrs()获取对应设备的IP
st.write("IP：{}".format(list(psutil.net_if_addrs().values())[1][0][1]))
#以上两个方法的返回值都是列表，因此与要进行切分构建好基础信息之后我们需要开始构建网络配置下的内容了
#首先构建存放所有psutil模块下返回值的列表以供存储数据
network_adpater_name = []
network_adpater_isup = []
network_adpater_workmode = []
network_adpater_runspeed = []
network_adpater_maximumtrans = []
network_adpater_ip = []
network_adpater_netmask = []
#使用循环遍历出当前实例下所有的网络设备
for i in range(len(list(psutil.net_if_addrs()))):
network_adpater_name.append(list(psutil.net_if_addrs())[i])
network_adpater_isup.append(list(psutil.net_if_stats().values())[i][0])
#需要声明：psutil模块对应网卡工作模式的定义有些特殊，其返回值为整数数据
#当返回值为2时，代表当前网络设备处于全双工的工作模式
#当返回值为1时，代表当前网络设备处于半双工的工作模式
network_adpater_workmode.append(list(psutil.net_if_stats().values())[i][1])
network_adpater_runspeed.append(str(list(psutil.net_if_stats().values())[i][2])+"Mbps")
network_adpater_maximumtrans.append(list(psutil.net_if_stats().values())[i][3])
network_adpater_ip.append(list(psutil.net_if_addrs().values())[i][0][1])
network_adpater_netmask.append(list(psutil.net_if_addrs().values())[i][0][2])
#这里必须要用Pandas构建一个数据框，否则会很难看
network_adpater_info = pd.DataFrame()
network_adpater_info["网卡名称"] = network_adpater_name
network_adpater_info["上行"] = network_adpater_isup
network_adpater_info["工作模式"] = network_adpater_workmode
network_adpater_info["运行速率"] = network_adpater_runspeed
network_adpater_info["最大并行转发量"] = network_adpater_maximumtrans
network_adpater_info["网卡IP"] = network_adpater_ip
network_adpater_info["子网掩码"] = network_adpater_netmask
st.title("当前Django实例网络配置信息")
#使用StreamlitAPI下的table()方法将DataFrame数据框渲染出来
st.table(network_adpater_info)基础性能指标
通过对于基础性能指标参数的获取，这时我们需要引入流的概念。
通过上面对于参数获取并生成表，我们发现这种类型的数据是固定的，或者是对于动态的要求要求几乎微乎其微。
但是对于诸如：占用、速度这样矢量化数据而言。动态就显得尤为重要。
上代码：
#定义监视器函数并返回占用比
def CPUMonitorWatchDog():
usage = []
while True:
#在这里因为使用from pustil import *的引入方法
#因此这里的cpu_percent不需要声明属于那个类下的
#参数：interval=int用于设置psutil模块获取CPU占比的间隔
#percpu：用于控制psutil模块在获取占用时是否将内核进行拆分
usage.append(cpu_percent(interval=1, percpu=False))
return usage
def MemMonitorWatchDog():
mem_usage = []
while True:
mem_usage.append(virtual_memory().percent)
return mem_usage
def readDiskWatchDog():
read_speed = []
while True:
read_speed.append(psutil.disk_io_counters().read_bytes/1024/100)
return read_speed
def writeDiskWatchDog():
write_speed = []
while True:
write_speed.append(disk_io_counters().write_bytes/1024/100)
return write_speed
def DownLoadNetMonitorWatchDog():
download_speed = []
while True:
#这里net_ip_counters()中所有的返回值都是bit，因此无需转换为Byte
#以保证
first_recv = net_io_counters().bytes_recv
sleep(1)
second_recv = net_io_counters().bytes_recv
download_speed.append((second_recv - first_recv))
return download_speed
def UPLoadNetMonitorWatchDog():
upload_speed = []
while True:
first_sent = net_io_counters().bytes_sent
sleep(1)
second_sent = net_io_counters().bytes_sent
upload_speed.append((second_sent - first_sent))
return upload_speed
def PackageSentMonitor():
sent_pack = []
while True:
sent_pack.append(net_io_counters().packets_sent)
return sent_pack
def PackageReceiveMonitor():
sent_pack = []
while True:
sent_pack.append(net_io_counters().packets_sent)
return sent_pack
#构建数据框以实时存储监视器们返回的数据
df = pd.DataFrame(CPUMonitorWatchDog())
#设置列长更新，以保证长度Y轴长度能够实时更新
monitor_columns = [f"CPU占用率" for i in range(len(df.columns))]
df.columns = monitor_columns
df["内存占用"] = MemMonitorWatchDog()
df['读取速度'] = readDiskWatchDog()
df["写入速度"] = writeDiskWatchDog()
df["下载速度"] = DownLoadNetMonitorWatchDog()
df["上传速度"] = UPLoadNetMonitorWatchDog()
df["发包数量"] = PackageSentMonitor()
df["接受包数量"] = PackageReceiveMonitor()
#st.subheader()方法用于生成子标题，对应HTML中的h3标签
first_header = st.subheader("CPU占用率")
#使用st.area_chart()生成一个折线面积图的实例
monitor_chart = st.area_chart(df[monitor_columns])
second_header = st.subheader("内存占用率")
mem_usage_charts= st.area_chart(df["内存占用"])
third_header = st.subheader("磁盘读取速度(KB/s)")
read_bytes_charts = st.area_chart(df["读取速度"])
fourth_headers = st.subheader("磁盘写入速度(KB/s)")
write_bytes_chart = st.area_chart(df['写入速度'])
fivth_headers = st.subheader("下载速度(kb/s)")
download_charts = st.area_chart(df["下载速度"])
sixth_headers = st.subheader("上传速度(kb/s)")
upload_charts = st.area_chart(df["上传速度"])
seventh_headers = st.subheader("收包数量（个）")
packrecv_charts = st.area_chart(df["接受包数量"])
eighth_headers = st.subheader("发包数量")
packsent_charts = st.area_chart(df["发包数量"])
#开始进行数据迭代与填充
while True:
#因为每一个chart的类型属于DeletaGenerator对象，在Steamlit的API下
#可以使用.add_rows()的方法拓宽数据，在参数中声明一个DataFrame和对应列以构建数据流
monitor_chart.add_rows(pd.DataFrame(CPUMonitorWatchDog(), columns=monitor_columns))
mem_usage_charts.add_rows(pd.DataFrame(MemMonitorWatchDog(),columns=["内存占用"]))
read_bytes_charts.add_rows(pd.DataFrame(readDiskWatchDog(),columns=["读取速度"]))
write_bytes_chart.add_rows(pd.DataFrame(writeDiskWatchDog(), columns=['写入速度']))
download_charts.add_rows(pd.DataFrame(DownLoadNetMonitorWatchDog(),columns=["下载速度"]))
upload_charts.add_rows(pd.DataFrame(UPLoadNetMonitorWatchDog(),columns=["上传速度"]))
packrecv_charts.add_rows(pd.DataFrame(PackageReceiveMonitor(),columns=["接受包数量"]))
packsent_charts.add_rows(pd.DataFrame(PackageSentMonitor(),columns=["发包数量"]))构建完最复杂的动态可视化之后，我们尝试来构建存储方面监控与可视化
elif sidebar == "存储监控":
#使用disk_usage()方法获取到指定盘符下的磁盘容量
st.header("当前Django实例存储总量：{}".format(round(disk_usage("/").total/1024/1024/1000,2))+"GB")
#使用disk_partitions()方法获取到当前实例下的所有分区
st.header("共有{}个分区".format(len(psutil.disk_partitions())))
total_partitions = []
each_partion_usage = []
#通过循环显示出实例下所有的分区，极其名称和占比
#由于这个APP运行在了虚拟机上，而且虚拟磁盘是被拆分开来的，因此显示时只会获得所有虚拟分区
for i in range(len(psutil.disk_partitions())):
st.write("当前{}盘盘符占用：{}%，剩余{}GB".format(psutil.disk_partitions()[i].device,disk_usage(psutil.disk_partitions()[i].device).percent,round(disk_usage(psutil.disk_partitions()[i].device).free/1024/1024/1024),2)+"\n")
total_partitions.append(psutil.disk_partitions()[i].device)
each_partion_usage.append(disk_usage(psutil.disk_partitions()[i].device).percent)
#创建一个plotly离线对象用于绘制分区占比
pyplt = py.offline.plot
labels = total_partitions
values = each_partion_usage
trace = [go.Pie(
labels = labels,
values = values,
hole = 0.7,
hoverinfo = "label + percent")]
layout = go.Layout(
title = "当前实例硬盘分区占比"
)
fig = go.Figure(data=trace,layout=layout)
#调用streamlitAPI下的plotly_chart将之前plotly生成的figure写入到streamlit中
st.plotly_chart(figure_or_data=fig,use_container_width=True)
#捕获读写IOPs
def readIOPsWatchDog():
read_iops = []
while True:
read_iops.append(psutil.disk_io_counters().read_count)
return read_iops
def writeIPOsWatchDog():
write_iops = []
while True:
write_iops.append(psutil.disk_io_counters().write_count)
return write_iops
df = pd.DataFrame(readIOPsWatchDog())
readiops_columns = [f"顺序随机读取性能（IOPs）" for i in range(len(df.columns))]
df.columns = readiops_columns
df["顺序随机写入性能（IOPs）"] = writeIPOsWatchDog()
first_header = st.subheader("顺序随机读取性能（IOPs）")
readiops_charts= st.area_chart(df["顺序随机读取性能（IOPs）"])
second_header = st.subheader("顺序随机写入性能（IOPs）")
writeiops_charts = st.area_chart(df["顺序随机写入性能（IOPs）"])
while True:
readiops_charts.add_rows(pd.DataFrame(readIOPsWatchDog(),columns=["顺序随机读取性能（IOPs）"]))
writeiops_charts.add_rows(pd.DataFrame(writeIPOsWatchDog(),columns=["顺序随机写入性能（IOPs）"]))接下来来到弹性用户组管理与配置
需要申明一点，这里为了方便查看用户组下的所有有效信息，建议在构建APP之前，记得给root配置免密登陆，否则每一次查看用户组时都需要切回Streamlit的控制台去输入root的密码，十分麻烦
#先检测一下系统内核
system_kernel = platform.system()
st.title("当前实例用户组配置信息")
#这里设置一个用beta_columns()方法生成4个DeltaGenerator类的列对象
col1,col2,col3,col4 = st.beta_columns(4)
#针对每一个独立的列绑定一个按钮
add_group_button = col1.button("添加用户组")
delete_group_button = col2.button("删除用户组")
add_user_button = col3.button("添加用户")
delete_user_button = col4.button("删除用户")
#当系统内核检测为Linux时则执行如下逻辑
if system_kernel == "Linux":
#读取/etc/group下的分组信息
process = os.popen("sudo cat /etc/group").readlines()
#创建四个列表用于存储分列数据
group_name = []
group_key = []
gid = []
user_list = []
#开始分列
for line in process:
group_name.append(line.replace("\n","").split(":")[0])
group_key.append(line.replace("\n","").split(":")[1])
gid.append(line.replace("\n","").split(":")[2])
user_list.append(line.replace("\n","").split(":")[3])
#创建数据框
df = pd.DataFrame()
df["组名称"] = group_name
df["组密钥"] = group_key
df["GID"] = gid
df["用户群"] = user_list
st.table(df)
#当按钮被按下时
if add_group_button:
#使用text_input()方法创建一个输入框用于记录添加的用户组名
add_confirm = st.text_input("请输入你想添加的用户组")
#当前长度不等于0时
if len(add_confirm) != 0:
#如果添加的
if add_confirm.isin(df["组名称"]):
st.error("该用户组已存在，无法再次添加")
else:
os.popen("sudo groupadd {}".format(add_confirm))
st.success("添加成功")
if delete_group_button:
delete_confirm = st.text_input("请确认你删除的用户组对象名称")
if len(delete_confirm) != 0:
#生成一个警告信息
st.warning("该操作会影响实例系统下的用户组信息，请输入：我已知晓后果，并承担风险方可执行该操作！")
#进行最终确认以防止误删
final_confirm = st.text_input(label="最终确认")
if final_confirm == "我已知晓后果，并承担风险方可执行该操作":
if delete_confirm in df["组名称"]:
os.popen("sudo groupdel {}".format(delete_confirm))
st.success("删除成功")
else:
st.error("请确认该用户组是否存在")
if add_user_button:
add_user_confirm = st.text_input("请输入你想添加的用户")
if len(add_user_confirm) != 0:
all_user = []
for i in range(len(df["用户群"])):
single_group = df["用户群"][i].split(",")
for i in range(len(single_group)):
all_user.append(single_group[i])
if add_user_confirm in all_user:
st.error("无法添加！目标用户已存在！")
else:
os.popen("sduo adduser {}")
if delete_user_button:
delete_user_confirm = st.text_input("请输入你想删除的用户")
if len(delete_user_confirm) != 0:
st.warning("该操作会影响实例系统下的用户组信息，请输入：我已知晓后果，并承担风险方可执行该操作！")
final_confirm = st.text_input(label="最终确认")
if final_confirm == "我已知晓后果，并承担风险方可执行该操作":
if delete_user_confirm in all_user:
os.popen("sudo userdel --remove {}".format(delete_user_confirm))
st.success("删除成功")
else:
st.error("请确认该用户组是否存在")配置弹性安全组选项
elif sidebar == "弹性安全组":
#需额外声明，因终端输出值为一个极其不规则的值，因此无法实现十分规整的展示
#因此如果想查看完整的安全组信息需要仍然在shell内执行
with st.beta_expander("额外声明！"):
st.write("如欲获得完整组策略信息，请使用命令终端或服务器Shell端进行查询")
#设置两个分列
col1,col2 = st.beta_columns(2)
#绑定按钮
add_rule_button = col1.button("添加规则")
del_rule_button = col2.button("删除规则")
if add_rule_button:
col1.subheader("添加规则配置")
rule_type = st.text_input("规则类型")
port_rule = st.text_input("端口规则")
add_button = st.button("确认添加")
if add_button:
os.popen("sudo ufw {} {}".format(rule_type,port_rule))
if del_rule_button:
col2.subheader("删除规则配置")
port_rule = col2.text_input("端口规则")
del_button = col2.button("确认删除")
if del_button:
os.popen("sudo ufw delete {}".format(port_rule))前面有提到过我们导入了PyCuda包用于检测实例下存在的CUDA GPU数量和工作状态，那么我们开始最后一步：检测CUDA GPU
elif sidebar == "GPU管理":
st.title("GPU技术由NVIDIA提供",st.image("https://developer.nvidia.com/sites/all/themes/devzone_new/favicon.ico"))
#用pycuda.driver()方法初始化pycuda实例
drv.init()
#当driver检测设备时
if drv.Device.count() != 0:
#显示当前实例装载了多少个CUDA GPU
st.header("当前实例装载了{}个CUDA GPU.".format(drv.Device.count()))
#构建CUDA设备信息存放数据的列表
cuda_device_name = []
cuda_device_capability = []
cuda_device_memory = []
cuda_device_rundriver = []
#循环输出CUDA信息并填充至之前构建的列表中
for i in range(drv.Device.count()):
device = drv.Device(i)
cuda_device_name.append(device.name())
cuda_device_capability.append(float("%d.%d" % device.compute_capability()))
gpu_memory = device.total_memory()//(1024**2)//1024
cuda_device_memory.append(gpu_memory)
cuda_device_rundriver.append(drv.get_version()[0])
#构建数据框
df = pd.DataFrame()
df["CUDA设备名称"] = cuda_device_name
df["CUDA设备计算能力"] = cuda_device_capability
df["CUDA设备内存"] = cuda_device_memory
df["CUDA驱动版本"] = cuda_device_rundriver
#使用table()方法显示出来
st.table(df)
else:
st.error("当前Django服务器未装载GPU！")好了，综上我们所有的功能都构建好了，之后就是启动我们的Streamlit APP了，启动方法也非常简单：使用cd命令切换到你的APP目录下，并输入
streamlit run xxx.py即可顺利的运行啦，当然之前说streamlit的一大优势在于共享性，这也就意味着在你启动streamlit app时不仅有一个本地的localhost地址，同时也会有一个局域网地址。当你的服务器上顺利部署了streamlit的APP时，凡是与服务器处于同一局域网内的设备都可以访问到这个APP了。
最后如果喜欢本期分享的话，记得动动你可爱的小手，点赞、打赏、转发一键三联哦，我是Deaohst，我们下期分享见。
附上码云链接：https://gitee.com/P4r4I10w_W0nd3r/elins-code-storage/tree/myDjango/Streamlit
