包含python監控esxi腳本的詞條

本文目錄一覽：

• 1、如何用python做一個設備運維軟件
• 2、如何用python檢測網站可用性
• 3、python 運維常用腳本
• 4、我的的python語言腳本監控的服務器日誌，日誌出現錯誤的時候根據錯誤關鍵字進行語音告警。可是最近出現
• 5、如何監控在服務器上運行的多個python腳本的狀態？

如何用python做一個設備運維軟件

Python開發的jumpserver跳板機

jumpserver跳板機是一款由Python編寫開源的跳板機(堡壘機)系統，實現了跳板機應有的功能。基於ssh協議來管理，客戶端無需安裝agent。

企業主要用於解決：可視化安全管理

特點：完全開源，GPL授權

Python編寫，Django開發框架，容易再次開發

實現了跳板機基本功能：認證、授權、審計。集成了Ansible、批量命令等。功能強大。

通俗點就是起到監控誰在服務器上做了什麼操作等。錄像回放、命令搜索、實時監控、批量上傳下載等。

第三：Python開發的Magedu分布式監控系統

以自動化運維視角為出發點，自動化功能、監控告警、性能調優，結合saltstack實現自動化配置管理等內容進行了全方位的深入剖析。

企業主要用於解決：自動化監控常用系統服務、應用、網絡設備等。分布式可監控更多服務器，分區域監控再匯總。Zabbix監控結合Python自定義監控腳本。

監控系統需求討論：

監控常用系統服務、應用、網絡設備等？一台主機上可監控多個不同服務、不同服務的監控間隔可不同？同一個服務在不同主機上的監控間隔、報警閾值可不同？告警級別？數據可視化，如何做出簡潔美觀的用戶界面？如何實現單機支持5000+機器監控需求？採取何種通信方式？主動、被動？

第四：Python開發的Magedu的CMDB

cmdb的開發需要包含三部分功能：採集硬件數據、API、頁面管理。

企業主要用於解決：項目功能，採集硬件數據、Api、頁面管理。統計資產，例如服務器存放位置，服務器上的賬號等等。

執行服務的過程如下：服務器的客戶端採集硬件數據，然後將硬件信息發送到API，API負責將獲取到的數據保存到數據庫中，後台管理程序負責對服務器信息的配置和展示。

第五：Python開發的任務調度系統

Python任務調度系統的multiprocessing模塊不但支持多進程，其中managers子模塊還支持把多進程分布到多台機器上。

企業主要用於解決：通俗的理解，批量管理crontab定時任務。原理用戶通過web頁面設置任務，傳輸到任務調度系統服務器上的客戶端，客戶端收集數據反饋給服務器端，服務器端根據任務具體內容調度後端的集群服務器做定時任務。

一個服務進程可以作為調度者，將任務分布到其他多個機器的多個進程中，依靠網絡通信。想到這，就在想是不是可以使用此模塊來實現一個簡單的作業調度系統。

第六：Python運維流程系統

使用python語言編寫的調度和監控工作流的平台內部用來創建、監控和調整數據管道。任何工作流都可以在這個使用Python來編寫的平台上運行。

企業主要用於解決：通俗點說就是規範運維的操作，加入審批，一步一步操作的概念。

是一種允許工作流開發人員輕鬆創建、維護和周期性地調度運行工作流（即有向無環圖或成為DAGs）的工具。這些工作流包括了如數據存儲、增長分析、Email發送、A/B測試等等這些跨越多部門的用例。

這個平台擁有和 Hive、Presto、MySQL、HDFS、Postgres和S3交互的能力，並且提供了鉤子使得系統擁有很好地擴展性。除了一個命令行界面，該工具還提供了一個基於Web的用戶界面讓您可以可視化管道的依賴關係、監控進度、觸發任務等。

來個小總結

如何用python檢測網站可用性

前言

隨着站點的增多，管理複雜性也上來了，俗話說：人多了不好帶，我發現站點多了也不好管，因為這些站點裡有重要的也有不重要的，重要核心的站點當然就管理的多一些，像一些萬年都不出一次問題的，慢慢就被自己都淡忘了，冷不丁那天出個問題，還的手忙腳亂的去緊急處理，所以規範的去管理這些站點是很有必要的，今天我們就做第一步，不管大站小站，先統一把監控做起來，先不說業務情況，最起碼那個站點不能訪問了，要第一時間報出來，別等着業務方給你反饋，就顯得我們不夠專業了，那接下來我們看看如果用python實現多網站的可用性監控，腳本如下：

?

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

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

#!/usr/bin/env python

import pickle, os, sys, logging

from httplib import HTTPConnection, socket

from smtplib import SMTP

def email_alert(message, status):

fromaddr = ‘xxx@163.com’

toaddrs = ‘xxxx@qq.com’

server = SMTP(‘smtp.163.com:25’)

server.starttls()

server.login(‘xxxxx’, ‘xxxx’)

server.sendmail(fromaddr, toaddrs, ‘Subject: %s\r\n%s’ % (status, message))

server.quit()

def get_site_status(url):

response = get_response(url)

try:

if getattr(response, ‘status’) == 200:

return ‘up’

except AttributeError:

pass

return ‘down’

def get_response(url):

try:

conn = HTTPConnection(url)

conn.request(‘HEAD’, ‘/’)

return conn.getresponse()

except socket.error:

return None

except:

logging.error(‘Bad URL:’, url)

exit(1)

def get_headers(url):

response = get_response(url)

try:

return getattr(response, ‘getheaders’)()

except AttributeError:

return ‘Headers unavailable’

def compare_site_status(prev_results):

def is_status_changed(url):

status = get_site_status(url)

friendly_status = ‘%s is %s’ % (url, status)

print friendly_status

if url in prev_results and prev_results[url] != status:

logging.warning(status)

email_alert(str(get_headers(url)), friendly_status)

prev_results[url] = status

return is_status_changed

def is_internet_reachable():

if get_site_status(”) == ‘down’ and get_site_status(”) == ‘down’:

return False

return True

def load_old_results(file_path):

pickledata = {}

if os.path.isfile(file_path):

picklefile = open(file_path, ‘rb’)

pickledata = pickle.load(picklefile)

picklefile.close()

return pickledata

def store_results(file_path, data):

output = open(file_path, ‘wb’)

pickle.dump(data, output)

output.close()

def main(urls):

logging.basicConfig(level=logging.WARNING, filename=’checksites.log’,

format=’%(asctime)s %(levelname)s: %(message)s’,

datefmt=’%Y-%m-%d %H:%M:%S’)

pickle_file = ‘data.pkl’

pickledata = load_old_results(pickle_file)

print pickledata

if is_internet_reachable():

status_checker = compare_site_status(pickledata)

map(status_checker, urls)

else:

logging.error(‘Either the world ended or we are not connected to the net.’)

store_results(pickle_file, pickledata)

if __name__ == ‘__main__’:

main(sys.argv[1:])

腳本核心點解釋：

1、getattr（）是python的內置函數，接收一個對象，可以根據對象屬性返回對象的值。

2、compare_site_status（）函數是返回的是一個內部定義的函數。

3、map() ，需要2個參數，一個是函數，一個是序列，功能就是將序列中的每個元素應用函數方法。

總結

以上就是這篇文章的全部內容，有需要的朋友們可以參考借鑒。

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 \n”%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(“——————————\n”)

print(“使用說明,在當前目錄創建ip.txt寫入ip地址”)

print(“——————————\n”)

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(‘\n’))

python3-實現釘釘報警

import requests

import sys

import json

dingding_url = ‘ ‘

data = {“msgtype”: “markdown”,”markdown”: {“title”: “監控”,”text”: “apche異常”}}

headers = {‘Content-Type’:’application/json;charset=UTF-8′}

send_data = json.dumps(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 = ‘ ‘

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((‘127.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 = ‘ ‘

data = {“msgtype”: “markdown”,”markdown”: {“title”: title,”text”: text}}

headers = {‘Content-Type’:’application/json;charset=UTF-8′}

send_data = json.dumps(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((‘127.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(‘\n’))

ssh.connect(hostname=line[i].strip(‘\n’),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(“\n”)

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 lyshark@59.110.167.239’)

fout = file(‘sshlog.txt’, ‘w’)

ssh.logfile = fout

ssh.expect(“lyshark@59.110.167.239’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\n”)

print(“已使用內存:”+str(mem.used/(memory_convent))+”MB\n”)

print(“可用內存:”+str(mem.total/(memory_convent)-mem.used/(1024*1024))+”MB\n”)

print(“buffer容量:”+str(mem.buffers/( memory_convent ))+”MB\n”)

print(“cache容量:”+str(mem.cached/(memory_convent))+”MB\n”)

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(‘\n’)[:-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(‘\n’)

return sn1

def getload(host,loid):

load_oids = ‘1.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(‘\n’)[:-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_dump’)

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_dump’)

sys.exit(0)

if name ==” main “:

main()

利用Pexpect實現自動非交互登陸linux

import pexpect

import sys

ssh = pexpect.spawn(‘ssh root@59.110.167.239’)

fout = file(‘sshlog.log’, ‘w’)

ssh.logfile = fout

ssh.expect(“root@59.110.167.239’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 += ” 內存狀態如下:\n”

print_str = print_str + ” 系統的內存容量為: “+str( mem.total/( memory_convent ) ) + ” MB\n”

print_str = print_str + ” 系統的內存以使用容量為: “+str( mem.used/( memory_convent ) ) + ” MB\n”

print_str = print_str + ” 系統可用的內存容量為: “+str( mem.total/( memory_convent ) – mem.used/( 1024*1024 )) + “MB\n”

print_str = print_str + ” 內存的buffer容量為: “+str( mem.buffers/( memory_convent ) ) + ” MB\n”

print_str = print_str + ” 內存的cache容量為:” +str( mem.cached/( memory_convent ) ) + ” MB\n”

if ( print_type == 1 ) or isset( sys.argv,”cpu” ) :

print_str += ” CPU狀態如下:\n”

cpu_status = psutil.cpu_times()

print_str = print_str + ” user = ” + str( cpu_status.user ) + “\n”

print_str = print_str + ” nice = ” + str( cpu_status.nice ) + “\n”

print_str = print_str + ” system = ” + str( cpu_status.system ) + “\n”

print_str = print_str + ” idle = ” + str ( cpu_status.idle ) + “\n”

print_str = print_str + ” iowait = ” + str ( cpu_status.iowait ) + “\n”

print_str = print_str + ” irq = ” + str( cpu_status.irq ) + “\n”

print_str = print_str + ” softirq = ” + str ( cpu_status.softirq ) + “\n”

print_str = print_str + ” steal = ” + str ( cpu_status.steal ) + “\n”

print_str = print_str + ” guest = ” + str ( cpu_status.guest ) + “\n”

if ( print_type == 1 ) or isset ( sys.argv,”disk” ) :

print_str += ” 硬盤信息如下:\n”

disk_status = psutil.disk_partitions()

for item in disk_status :

print_str = print_str + ” “+ str( item ) + “\n”

if ( print_type == 1 ) or isset ( sys.argv,”user” ) :

print_str += ” 登錄用戶信息如下:\n “

user_status = psutil.users()

for item in user_status :

print_str = print_str + ” “+ str( item ) + “\n”

print_str += “—————————————————————\n”

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的namedutples列表

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))

我的的python語言腳本監控的服務器日誌，日誌出現錯誤的時候根據錯誤關鍵字進行語音告警。可是最近出現

應該是split後生成的列表的原始超過2個了。看下面的簡單的例子就知道了。

其實應該看一下生成後的長度，做個保護，否則像你這種賦值，只要列表長度不為2，都會異常。

x=[1,2,3]

a,b=x

Traceback (most recent call last):

File “interactive input”, line 1, in module

ValueError: too many values to unpack

如何監控在服務器上運行的多個python腳本的狀態？

linux系統的話，監控工具比較好的有ganglia，zabbix

windows系統的話，用自帶的“性能監視器”（老版本的windows叫性能計數器）