python运维脚本
1. 运维工程师为什么要学python
纯粹的运维，发展肯定不如会开发的运维好！
一些运维的小工具，自己能开发最好了
如果一个运维，能有不错的开发基础，可以更深入的参与到项目的开发中，能理解软件开发的需求和难题，能跟得上开发的思维，能更好的跟开发沟通！
最重要的是，能吹牛B，能涨工资！
最近运维自动化，非常火，然后其中以Python占多，因为Python的是一种胶水式的语言，什么都能做！
Python简单易学，代码容易读！
2. 请问python大神自动化运维为什么要使用python
运维学习Python到底能够带来多大的收益？
上午我QQ的一个运维技术群不知道什么时候开始聊起作为运维人有没有必要再学习一门编程语言，学什么最好等，一开始开始我没看，没想到竟然在群里讨论了近2个小时，一般情况这种问题的都是运维新人，可能目前运维整体情况还不太了解，所以为了让更多的让新入行朋友不在迷茫，今天呢我就这个问题表达下我的看法。
一、那作为运维人员要不要学习一门编程语言？
我给出的答案是：“如果不学习一门编程语言，再过2年你可能就得下岗”，我这绝不是危言耸听，不信你搜下现在对运维岗位的技能要求看看，但如果不够深刻，那接下里我们从现在运维的情况和未来运维的发展来分析下具体原因：
早些年的运维，基本是会部署个环境，懂点linux命令，再往后点呢，能用shell写出日常用的自动化脚本，满足业务的需求基本就可以了，企业对运维要求也是这些，一句话：别出事。但随着计算机技术的发展，凡是跟技术沾边的都经过不断迭代更新，运维属于技术机的一个分支，也经历了翻天覆地变化，现在这个时期我个人判断是要体现运维价值的时代，所以不创造价值的工作将逐渐被自动化运维平台所取代，也就是说之前上线部署很复杂的操作，通过一个运维自动化平台点点鼠标就可以完成实现，彻底拜托了对人的依赖，这个时期最明显的就是各个公司基本都有自己的运维平台，要么再建设中，要么已经建完了，如果平台就已建完，出于对公司人力成本的考虑，最基础的运维操作会由类似客服部门的人来负责，所以随着时间的推移，一些只做日常操作的运维将逐渐从公司消失，那按这个逻辑，既然要搭建运维平台，用shell肯定是不能满足了，所以你必须学习一门编程语言，这样你才可能拿到进入这个行业的门票。
以上就是我对大家所讨论问题的看法，不对的地方请斧正，如果您也认同，请让更多的人看到，让密迷茫的人不在迷茫，最后一句话送给大家共勉，做技术：
时间千万不要浪费在选择上，而要多用在行动上！
Python是个非常牛B的脚本语言，能满足绝大部分自动化运维的需求，又能做后端C/S架构，又能用WEB框架快速开发出高大上的Web界面，只有当你自已有能力做出一套运维自动化系统的时候，你的价值才体现出来，你才有资格跟老板谈重视。加企鹅Q秋：444加513和089连在一起，如果你想学习，这就是你的一个学习机会，提升你的个人价值，你跟大牛只差一次努力的学习！吹过牛逼不如努力一搏，还在迷茫，还在停滞不前的运维终究会被努力的别人所超越！
3. python都可以干什么
Python的应用方向
1. 常规软件开发
Python支持函数式编程和OOP面向对象编程，能够承担任何种类软件的开发工作，因此常规的软件开发、脚本编写、网络编程等都属于标配能力。
2. 科学计算
随着NumPy，SciPy，Matplotlib，Enthoughtlibrarys等众多程序库的开发，Python越来越适合于做科学计算、绘制高质量的2D和3D图像。和科学计算领域最流行的商业软件Matlab相比，Python是一门通用的程序设计语言，比Matlab所采用的脚本语言的应用范围更广泛，有更多的程序库的支持。虽然Matlab中的许多高级功能和toolbox目前还是无法替代的，不过在日常的科研开发之中仍然有很多的工作是可以用Python代劳的。
3. 自动化运维
这几乎是Python应用的自留地，作为运维工程师首选的编程语言，Python在自动化运维方面已经深入人心，比如Saltstack和Ansible都是大名鼎鼎的自动化平台。
4. 云计算
开源云计算解决方案OpenStack就是基于Python开发的，搞云计算的同学都懂的。
5. WEB开发
基于Python的Web开发框架不要太多，比如耳熟能详的Django，还有Tornado，Flask。其中的Python+Django架构，应用范围非常广，开发速度非常快，学习门槛也很低，能够帮助你快速的搭建起可用的WEB服务。
6. 网络爬虫
也称网络蜘蛛，是大数据行业获取数据的核心工具。没有网络爬虫自动地、不分昼夜地、高智能地在互联网上爬取免费的数据，那些大数据相关的公司恐怕要少四分之三。能够编写网络爬虫的编程语言有不少，但Python绝对是其中的主流之一，其Scripy爬虫框架应用非常广泛。
7. 数据分析
在大量数据的基础上，结合科学计算、机器学习等技术，对数据进行清洗、去重、规格化和针对性的分析是大数据行业的基石。Python是数据分析的主流语言之一。
8. 人工智能
Python在人工智能大范畴领域内的机器学习、神经网络、深度学习等方面都是主流的编程语言，得到广泛的支持和应用。
参考：网页链接
4. python 运维常用脚本
Python 批量遍历目录文件,并修改访问时间
import os
path = "D:/UASM64/include/"
dirs = os.listdir(path)
temp=[];
for file in dirs:
temp.append(os.path.join(path, file))
for x in temp:
os.utime(x, (1577808000, 1577808000))
Python 实现的自动化服务器管理
import sys
import os
import paramiko
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
def ssh_cmd(user,passwd,port,userfile,cmd):
def ssh_put(user,passwd,source,target):
while True:
try:
shell=str(input("[Shell] # "))
if (shell == ""):
continue
elif (shell == "exit"):
exit()
elif (shell == "put"):
ssh_put("root","123123","./a.py","/root/a.py")
elif (shell =="cron"):
temp=input("输入一个计划任务: ")
temp1="(crontab -l; echo "+ temp + ") |crontab"
ssh_cmd("root","123123","22","./user_ip.conf",temp1)
elif (shell == "uncron"):
temp=input("输入要删除的计划任务: ")
temp1="crontab -l | grep -v " "+ temp + "|crontab"
ssh_cmd("root","123123","22","./user_ip.conf",temp1)
else:
ssh_cmd("lyshark","123123","22","./user_ip.conf",shell)
遍历目录和文件
import os
def list_all_files(rootdir):
import os
_files = []
list = os.listdir(rootdir) #列出文件夹下所有的目录与文件
for i in range(0,len(list)):
path = os.path.join(rootdir,list[i])
if os.path.isdir(path):
_files.extend(list_all_files(path))
if os.path.isfile(path):
_files.append(path)
return _files
a=list_all_files("C:/Users/LyShark/Desktop/a")
print(a)
python检测指定端口状态
import socket
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sk.settimeout(1)
for ip in range(0,254):
try:
sk.connect(("192.168.1."+str(ip),443))
print("192.168.1.%d server open
"%ip)
except Exception:
print("192.168.1.%d server not open"%ip)
sk.close()
python实现批量执行CMD命令
import sys
import os
import paramiko
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
print("------------------------------>
")
print("使用说明,在当前目录创建ip.txt写入ip地址")
print("------------------------------>
")
user=input("输入用户名:")
passwd=input("输入密码:")
port=input("输入端口:")
cmd=input("输入执行的命令:")
file = open("./ip.txt", "r")
line = file.readlines()
for i in range(len(line)):
print("对IP: %s 执行"%line[i].strip('
'))
python3-实现钉钉报警
import requests
import sys
import json
dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='
data = {"msgtype": "markdown","markdown": {"title": "监控","text": "apche异常"}}
headers = {'Content-Type':'application/json;charset=UTF-8'}
send_data = json.mps(data).encode('utf-8')
requests.post(url=dingding_url,data=send_data,headers=headers)
import psutil
import requests
import time
import os
import json
monitor_name = set(['httpd','cobblerd']) # 用户指定监控的服务进程名称
proc_dict = {}
proc_name = set() # 系统检测的进程名称
monitor_map = {
'httpd': 'systemctl restart httpd',
'cobblerd': 'systemctl restart cobblerd' # 系统在进程down掉后，自动重启
}
dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='
while True:
for proc in psutil.process_iter(attrs=['pid','name']):
proc_dict[proc.info['pid']] = proc.info['name']
proc_name.add(proc.info['name'])
判断指定端口是否开放
import socket
port_number = [135,443,80]
for index in port_number:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((飗.0.0.1', index))
if result == 0:
print("Port %d is open" % index)
else:
print("Port %d is not open" % index)
sock.close()
判断指定端口并且实现钉钉轮询报警
import requests
import sys
import json
import socket
import time
def dingding(title,text):
dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='
data = {"msgtype": "markdown","markdown": {"title": title,"text": text}}
headers = {'Content-Type':'application/json;charset=UTF-8'}
send_data = json.mps(data).encode('utf-8')
requests.post(url=dingding_url,data=send_data,headers=headers)
def net_scan():
port_number = [80,135,443]
for index in port_number:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((飗.0.0.1', index))
if result == 0:
print("Port %d is open" % index)
else:
return index
sock.close()
while True:
dingding("Warning",net_scan())
time.sleep(60)
python-实现SSH批量CMD执行命令
import sys
import os
import paramiko
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
def ssh_cmd(user,passwd,port,userfile,cmd):
file = open(userfile, "r")
line = file.readlines()
for i in range(len(line)):
print("对IP: %s 执行"%line[i].strip('
'))
ssh.connect(hostname=line[i].strip('
'),port=port,username=user,password=passwd)
cmd=cmd
stdin, stdout, stderr = ssh.exec_command(cmd)
result = stdout.read()
ssh_cmd("lyshark","123","22","./ip.txt","free -h |grep 'Mem:' |awk '{print $3}'")
用python写一个列举当前目录以及所有子目录下的文件，并打印出绝对路径
import sys
import os
for root,dirs,files in os.walk("C://"):
for name in files:
print(os.path.join(root,name))
os.walk()
按照这样的日期格式（xxxx-xx-xx）每日生成一个文件，例如今天生成的文件为2013-09-23.log， 并且把磁盘的使用情况写到到这个文件中。
import os
import sys
import time
new_time = time.strftime("%Y-%m-%d")
disk_status = os.popen("df -h").readlines()
str1 = ''.join(disk_status)
f = open(new_time+'.log','w')
f.write("%s"%str1)
f.flush()
f.close()
统计出每个IP的访问量有多少？（从日志文件中查找）
import sys
list = []
f = open("/var/log/httpd/access_log","r")
str1 = f.readlines()
f.close()
for i in str1:
ip=i.split()[0]
list.append(ip)
list_num=set(list)
for j in list_num:
num=list.count(j)
print("%s -----> %s" %(num,j))
写个程序，接受用户输入数字，并进行校验，非数字给出错误提示，然后重新等待用户输入。
import tab
import sys
while True:
try:
num=int(input("输入数字：").strip())
for x in range(2,num+1):
for y in range(2,x):
if x % y == 0:
break
else:
print(x)
except ValueError:
print("您输入的不是数字")
except KeyboardInterrupt:
sys.exit("
")
ps 可以查看进程的内存占用大小，写一个脚本计算一下所有进程所占用内存大小的和。
import sys
import os
list=[]
sum=0
str1=os.popen("ps aux","r").readlines()
for i in str1:
str2=i.split()
new_rss=str2[5]
list.append(new_rss)
for i in list[1:-1]:
num=int(i)
sum=sum+num
print("%s ---> %s"%(list[0],sum))
关于Python 命令行参数argv
import sys
if len(sys.argv) < 2:
print ("没有输入任何参数")
sys.exit()
if sys.argv[1].startswith("-"):
option = sys.argv[1][1:]
利用random生成6位数字加字母随机验证码
import sys
import random
rand=[]
for x in range(6):
y=random.randrange(0,5)
if y == 2 or y == 4:
num=random.randrange(0,9)
rand.append(str(num))
else:
temp=random.randrange(65,91)
c=chr(temp)
rand.append(c)
result="".join(rand)
print(result)
自动化-使用pexpect非交互登陆系统
import pexpect
import sys
ssh = pexpect.spawn('ssh [email protected]')
fout = file('sshlog.txt', 'w')
ssh.logfile = fout
ssh.expect("[email protected]'s password:")
ssh.sendline("密码")
ssh.expect('#')
ssh.sendline('ls /home')
ssh.expect('#')
Python-取系统时间
import sys
import time
time_str = time.strftime("日期：%Y-%m-%d",time.localtime())
print(time_str)
time_str= time.strftime("时间：%H:%M",time.localtime())
print(time_str)
psutil-获取内存使用情况
import sys
import os
import psutil
memory_convent = 1024 * 1024
mem =psutil.virtual_memory()
print("内存容量为:"+str(mem.total/(memory_convent))+"MB
")
print("已使用内存:"+str(mem.used/(memory_convent))+"MB
")
print("可用内存:"+str(mem.total/(memory_convent)-mem.used/(1024*1024))+"MB
")
print("buffer容量:"+str(mem.buffers/( memory_convent ))+"MB
")
print("cache容量:"+str(mem.cached/(memory_convent))+"MB
")
Python-通过SNMP协议监控CPU
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*
import os
def getAllitems(host, oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid + '|grep Raw|grep Cpu|grep -v Kernel').read().split('
')[:-1]
return sn1
def getDate(host):
items = getAllitems(host, '.1.3.6.1.4.1.2021.11')
if name == ' main ':
Python-通过SNMP协议监控系统负载
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*
import os
import sys
def getAllitems(host, oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split('
')
return sn1
def getload(host,loid):
load_oids = Ƈ.3.6.1.4.1.2021.10.1.3.' + str(loid)
return getAllitems(host,load_oids)[0].split(':')[3]
if name == ' main ':
Python-通过SNMP协议监控内存
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*
import os
def getAllitems(host, oid):
def getSwapTotal(host):
def getSwapUsed(host):
def getMemTotal(host):
def getMemUsed(host):
if name == ' main ':
Python-通过SNMP协议监控磁盘
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*
import re
import os
def getAllitems(host,oid):
def getDate(source,newitem):
def getRealDate(item1,item2,listname):
def caculateDiskUsedRate(host):
if name == ' main ':
Python-通过SNMP协议监控网卡流量
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*
import re
import os
def getAllitems(host,oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split('
')[:-1]
return sn1
def getDevices(host):
device_mib = getAllitems(host,'RFC1213-MIB::ifDescr')
device_list = []
def getDate(host,oid):
date_mib = getAllitems(host,oid)[1:]
date = []
if name == ' main ':
Python-实现多级菜单
import os
import sys
ps="[None]->"
ip=["192.168.1.1","192.168.1.2","192.168.1.3"]
flage=1
while True:
ps="[None]->"
temp=input(ps)
if (temp=="test"):
print("test page !!!!")
elif(temp=="user"):
while (flage == 1):
ps="[User]->"
temp1=input(ps)
if(temp1 =="exit"):
flage=0
break
elif(temp1=="show"):
for i in range(len(ip)):
print(i)
Python实现一个没用的东西
import sys
ps="[root@localhost]# "
ip=["192.168.1.1","192.168.1.2","192.168.1.3"]
while True:
temp=input(ps)
temp1=temp.split()
检查各个进程读写的磁盘IO
import sys
import os
import time
import signal
import re
class DiskIO:
def init (self, pname=None, pid=None, reads=0, writes=0):
self.pname = pname
self.pid = pid
self.reads = 0
self.writes = 0
def main():
argc = len(sys.argv)
if argc != 1:
print ("usage: please run this script like [./lyshark.py]")
sys.exit(0)
if os.getuid() != 0:
print ("Error: This script must be run as root")
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
os.system('echo 1 > /proc/sys/vm/block_mp')
print ("TASK PID READ WRITE")
while True:
os.system('dmesg -c > /tmp/diskio.log')
l = []
f = open('/tmp/diskio.log', 'r')
line = f.readline()
while line:
m = re.match(
'^(S+)(d+)(d+): (READ|WRITE) block (d+) on (S+)', line)
if m != None:
if not l:
l.append(DiskIO(m.group(1), m.group(2)))
line = f.readline()
continue
found = False
for item in l:
if item.pid == m.group(2):
found = True
if m.group(3) == "READ":
item.reads = item.reads + 1
elif m.group(3) == "WRITE":
item.writes = item.writes + 1
if not found:
l.append(DiskIO(m.group(1), m.group(2)))
line = f.readline()
time.sleep(1)
for item in l:
print ("%-10s %10s %10d %10d" %
(item.pname, item.pid, item.reads, item.writes))
def signal_handler(signal, frame):
os.system('echo 0 > /proc/sys/vm/block_mp')
sys.exit(0)
if name ==" main ":
main()
利用Pexpect实现自动非交互登陆linux
import pexpect
import sys
ssh = pexpect.spawn('ssh [email protected]')
fout = file('sshlog.log', 'w')
ssh.logfile = fout
ssh.expect("[email protected]'s password:")
ssh.sendline("密码")
ssh.expect('#')
ssh.sendline('ls /home')
ssh.expect('#')
利用psutil模块获取系统的各种统计信息
import sys
import psutil
import time
import os
time_str = time.strftime( "%Y-%m-%d", time.localtime( ) )
file_name = "./" + time_str + ".log"
if os.path.exists ( file_name ) == False :
os.mknod( file_name )
handle = open ( file_name , "w" )
else :
handle = open ( file_name , "a" )
if len( sys.argv ) == 1 :
print_type = 1
else :
print_type = 2
def isset ( list_arr , name ) :
if name in list_arr :
return True
else :
return False
print_str = "";
if ( print_type == 1 ) or isset( sys.argv,"mem" ) :
memory_convent = 1024 * 1024
mem = psutil.virtual_memory()
print_str += " 内存状态如下:
"
print_str = print_str + " 系统的内存容量为: "+str( mem.total/( memory_convent ) ) + " MB
"
print_str = print_str + " 系统的内存以使用容量为: "+str( mem.used/( memory_convent ) ) + " MB
"
print_str = print_str + " 系统可用的内存容量为: "+str( mem.total/( memory_convent ) - mem.used/( 1024*1024 )) + "MB
"
print_str = print_str + " 内存的buffer容量为: "+str( mem.buffers/( memory_convent ) ) + " MB
"
print_str = print_str + " 内存的cache容量为:" +str( mem.cached/( memory_convent ) ) + " MB
"
if ( print_type == 1 ) or isset( sys.argv,"cpu" ) :
print_str += " CPU状态如下:
"
cpu_status = psutil.cpu_times()
print_str = print_str + " user = " + str( cpu_status.user ) + "
"
print_str = print_str + " nice = " + str( cpu_status.nice ) + "
"
print_str = print_str + " system = " + str( cpu_status.system ) + "
"
print_str = print_str + " idle = " + str ( cpu_status.idle ) + "
"
print_str = print_str + " iowait = " + str ( cpu_status.iowait ) + "
"
print_str = print_str + " irq = " + str( cpu_status.irq ) + "
"
print_str = print_str + " softirq = " + str ( cpu_status.softirq ) + "
"
print_str = print_str + " steal = " + str ( cpu_status.steal ) + "
"
print_str = print_str + " guest = " + str ( cpu_status.guest ) + "
"
if ( print_type == 1 ) or isset ( sys.argv,"disk" ) :
print_str += " 硬盘信息如下:
"
disk_status = psutil.disk_partitions()
for item in disk_status :
print_str = print_str + " "+ str( item ) + "
"
if ( print_type == 1 ) or isset ( sys.argv,"user" ) :
print_str += " 登录用户信息如下:
"
user_status = psutil.users()
for item in user_status :
print_str = print_str + " "+ str( item ) + "
"
print_str += "---------------------------------------------------------------
"
print ( print_str )
handle.write( print_str )
handle.close()
import psutil
mem = psutil.virtual_memory()
print mem.total,mem.used,mem
print psutil.swap_memory() # 输出获取SWAP分区信息
cpu = psutil.cpu_stats()
printcpu.interrupts,cpu.ctx_switches
psutil.cpu_times(percpu=True) # 输出每个核心的详细CPU信息
psutil.cpu_times().user # 获取CPU的单项数据 [用户态CPU的数据]
psutil.cpu_count() # 获取CPU逻辑核心数，默认logical=True
psutil.cpu_count(logical=False) # 获取CPU物理核心数
psutil.disk_partitions() # 列出全部的分区信息
psutil.disk_usage('/') # 显示出指定的挂载点情况【字节为单位】
psutil.disk_io_counters() # 磁盘总的IO个数
psutil.disk_io_counters(perdisk=True) # 获取单个分区IO个数
psutil.net_io_counter() 获取网络总的IO，默认参数pernic=False
psutil.net_io_counter(pernic=Ture)获取网络各个网卡的IO
psutil.pids() # 列出所有进程的pid号
p = psutil.Process(2047)
p.name() 列出进程名称
p.exe() 列出进程bin路径
p.cwd() 列出进程工作目录的绝对路径
p.status()进程当前状态[sleep等状态]
p.create_time() 进程创建的时间 [时间戳格式]
p.uids()
p.gids()
p.cputimes() 【进程的CPU时间，包括用户态、内核态】
p.cpu_affinity() # 显示CPU亲缘关系
p.memory_percent() 进程内存利用率
p.meminfo() 进程的RSS、VMS信息
p.io_counters() 进程IO信息，包括读写IO数及字节数
p.connections() 返回打开进程socket的nametples列表
p.num_threads() 进程打开的线程数
import psutil
from subprocess import PIPE
p =psutil.Popen(["/usr/bin/python" ,"-c","print 'helloworld'"],stdout=PIPE)
p.name()
p.username()
p.communicate()
p.cpu_times()
psutil.users() # 显示当前登录的用户，和Linux的who命令差不多
psutil.boot_time() 结果是个UNIX时间戳，下面我们来转换它为标准时间格式，如下：
datetime.datetime.fromtimestamp(psutil.boot_time()) # 得出的结果不是str格式，继续进行转换 datetime.datetime.fromtimestamp(psutil.boot_time()).strftime('%Y-%m-%d%H:%M:%S')
Python生成一个随机密码
import random, string
def GenPassword(length):
if name == ' main ':
print (GenPassword(6))
5. 纯干货！python 在运维中的应用 (一)：批量 ssh/sftp
日常工作中需要大量、频繁地使用ssh到服务器查看、拉取相关的信息或者对服务器进行变更。目前公司大量使用的shell，但是随着逻辑的复杂化、脚本管理的精细化，shell已经不满足日常需求，于是我尝试整合工作中的需求，制作适合的工具。 由于管理制度的缺陷，我以工作流程为核心思考适合自己的运维方式，提升工作效率，把时间留给更有价值的事情。 完整代码在最后，请大家参考。
生产：4000+物理服务器，近 3000 台虚拟机。
开发环境：python3.6、redhat7.9，除了paramiko为第三方模块需要自己安装，其他的直接import即可。
批量执行操作是一把双刃剑。批量执行操作可以提升工作效率，但是随之而来的风险不可忽略。
风险案例如下：
挂载很多数据盘，通常先格式化硬盘，再挂载数据盘，最后再写入将开机挂载信息写入/etc/fstab文件。在批量lsblk检查硬盘信息的时候发现有的系统盘在/sda有的在/sdm，如果不事先检查机器相关配置是否一致直接按照工作经验去执行批量操作，会很容易造成个人难以承受的灾难。
在执行批量操作时按照惯例：格式化硬盘->挂载->开机挂载的顺序去执行，假设有的机器因为某些故障导致格式化硬盘没法正确执行。在处理这类问题的时候通常会先提取出失败的ip，并再按照惯例执行操作。运维人员会很容易忽略开机挂载的信息已经写过了，导致复写（这都是血和泪的教训）。
所以，为了避免故障，提升工作效率，我认为应当建立团队在工作上的共识，应当遵守以下原则：
当然，代码的规范也应当重视起来，不仅是为了便于审计，同时也需要便于溯源。我认为应当注意以下几点：
1、ssh no existing session，sftp超时时间设置:
在代码无错的情况下大量ip出现No existing session，排查后定位在代码的写法上，下面是一个正确的示例。由于最开始没考虑到ssh连接的几种情况导致了重写好几遍。另外sftp的实例貌似不能直接设置连接超时时间，所以我采用了先建立ssh连接再打开sftp的方法。
2、sftp中的get()和put()方法仅能传文件，不支持直接传目录：
不能直接传目录，那换个思路，遍历路径中的目录和文件，先创建目录再传文件就能达到一样的效果了。在paramiko的sftp中sftp.listdir_attr()方法可以获取远程路径中的文件、目录信息。那么我们可以写一个递归来遍历远程路径中的所有文件和目录(传入一个列表是为了接收递归返回的值)。
python自带的os模块中的os.walk()方法可以遍历到本地路径中的目录和文件。
3、多线程多个ip使用sftp.get()方法时无法并发。
改成多进程即可。
4、多个ip需要执行相同命令或不同的命令。
由于是日常使用的场景不会很复杂，所以借鉴了ansible的playbook，读取提前准备好的配置文件即可，然后再整合到之前定义的ssh函数中。
同时，我们还衍生出一个需求，既然都要读取配置，那同样也可以提前把ip地址准备在文件里。正好也能读取我们返回的执行程序的结果。
参数说明：
密码认证：
公钥认证：
可以配合 grep，awk 等命令精准过滤。
个人认为 Python 在初中级运维工作中的性质更像是工具，以提升工作效率、减少管理成本为主。可以从当前繁琐的工作中解脱出来，去 探索 更有价值的事情。python 本质上并不会减少故障的产生，所以在不同的阶段合理利用自身掌握的知识解决当前最重要的痛点，千万不要本末倒置。
6. Python的用途是什么
Python的中文名称为蟒蛇，是一种计算机程序设计语言;是一种动态的、面向对象的脚本语言。最初是用来编写自动化脚本的，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。
Python的用途有很多，以下为大家介绍一下Python最常见的用途：
1、Web开发
Python拥有非常完善的与Web服务器进行交互的库，以及大量的免费的前端网页模板。更具优势的是，有非常优秀且成熟的Django
Web框架，功能一应俱全。
2、数据科学
数据科学，包含了机器学习、数据处理。
①数据处理：Python作为一门工程性语言，对于数据处理的类库是相当丰富的，比如有高性能的科学计算类库Numpy和Scipy;大名鼎鼎的云计算框架OpenStack就是Python开发的。
②机器学习：可以研究人工智能、机器人、语言识别、图像识别、自然语言处理和专家系统等。
3、网络爬虫
网络爬虫又称为网络蜘蛛，是指按照某种规则在网络上爬取所需内容的脚本程序。众所周知，每个网页通常包含其他网页的入口，网络爬虫则通过一个网址依次进入其他网址获取所需内容。
在爬虫领域，Python是独领风骚的。Python有非常丰富的库去访问网页文档的接口API以及后期网页文档的快速处理。
4、Linux系统运维
事实上，在早期都是通过shell脚本去实现自动化运维，但是由于shell脚本本身可编程的能力偏弱，一些需要实现的功能的库也很少，大部分都需要自己从头写起，然而Python作为胶水语言可以很方便的和其他语言集成起来，对各类工具进行二次开发，形成一套自己的运维管理系统。
5、游戏开发
Python在游戏开发方面可能不及lua或者C++，但是由于Python脚本化的特点，类似于游戏剧本、游戏玩法逻辑等这种非常灵活的设计上，我们修改起来十分方便。当然了，如果开发一款小的游戏程序，Python还是很具有优势的，比较出名的就是pygame了，对于我们而言是一个福音。
6、桌面应用开发
在桌面应用开发领域，Python可以实现对C++的无缝对接，并且同时支持QT和GTK。