命令行工具
1.click模块
click模块和argparse功能相同，但更为易用，使用click分为两个步骤，1）使用@click.command()装饰一个函数，使之成为命令行接口；2）使用@click.option()等装饰函数，为其添加命令行选项等
import click
@click.command()
@click.option('--count',default=1,help='Number of greetings.')
@click.option('--name',prompt='Your name',help='The person to greet')
def hellp(count,name):
'''simple program thar greets NAME for total of COUNT times...'''
for x in range(count):
click.echo('Hello %s!!!' % name)
if __name__ == '__main__':
hellp()实例中，函数hellp接受两个参数count和name，他们的取值从命令行中获取，使用了click中的command、option、echo，使用了prompt选项，因此在没有指定name参数时，click会提示我们在交互模式下输入
通过nargs配置参数的个数，通过type设置参数类型
import click
@click.command()
@click.option('--pos',nargs=2,type=float)
def findme(pos):
click.echo('%s / %s' % pos)type=click.Choice(['md5','sha1'])只能选择两者之一
如果需要从命令行输入密码，使用argparse只能像输入普通参数一样，在click中只需将prompt设为True,设置hide_input为True，就可以隐藏输入，设置confirmation_prompt为True,就可以两次验证
2.prompt_toolkit模块
prompt_toolkit是一个处理交互式场景的开源库，用来取代开源的redline和curses。特点包括：
1）语法高亮
2）支持多行编辑
3）支持代码补全
4）支持自动提示
5）支持鼠标移动光标
6）支持Emacs与Vi风格快捷键
7）支持查询历史
8）对Unicode支持友好
简单示例
#!/usr/bin/python
from __future__ import unicode_literals
from prompt_toolkit import prompt
while True:
user_input = prompt('>')
print(user_input)这样交互式输入的时候就能使用ctrl+a或者ctrl+e等快捷键了，注意：在python2中需要加入from __future__ import unicode_literals
实现历史输入
from prompt_toolkit import prompt
from __future__ import unicode_literals
from prompt_toolkit.history import FileHistory
while True:
user_input = prompt('>',
history=FileHistory('history.txt'),
)
print(user_input)还可以实现输入提示from __future__ import unicode_literals
from prompt_toolkit import prompt
from prompt_toolkit.history import FileHistory
from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
while True:
user_input = prompt('>',
history=FileHistory('history.txt'),
auto_suggest=AutoSuggestFromHistory(),
)
print(user_input)最后实现自动输入自动补全
from prompt_toolkit import prompt
from __future__ import unicode_literals
from prompt_toolkit.history import FileHistory
from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
from prompt_toolkit.contrib.completers import WordCompleter
SQLCompleter = WordCompleter(['select','update','drop','insert','delete'],ignore_case=True)
while True:
user_input = prompt('>',
history=FileHistory('history.txt'),
auto_suggest=AutoSuggestFromHistory(),
completer=SQLCompleter,
)
print(user_input)3.系统管理相关脚本
按条件查找目录下的文件
#!/usr/bin/python
import os
import fnmatch
def is_file_match(filenames,patterns):
if fnmatch.fnmatch(filenames,patterns):
return True
return False
def find_specific_files(dir,patterns=['*'],exclude_dirs=[]):
for root,dirnames,filenames in os.walk(dir):
for filename in filenames:
for pattern in patterns:
if is_file_match(filename,pattern):
yield os.path.join(root,filename)
for d in exclude_dirs:
if d in dirnames:
dirnames.remove(d)
if __name__ == '__main__':
patterns=['*.jpg','*.png','*.jbg']
exclude_dirs = ['2']
for item in find_specific_files(r"D:\python_test",patterns,exclude_dirs):
print(item)例如查找目录下除dir2以外其他目录下的所有图片
patterns=['*.jpg','*.png','*.jbg']
exclude_dirs = [’ dir2']
for item in find_specific_files(".",patterns,exclude_dirs):
print(item)filecmp模块
比较目录和文件
最简单的比较两个文件使用：filecmp.cmp('a.txt','b.txt'), 如果相同返回为True，不同返回为False
filecmp的cmpfiles函数，用来同时比较两个不同目录下的多个文件，并且返回一个三元组，分别包含相同的文件、不同的文件和无法比较的文件
找出目录下所有的重复文件：
import hashlib
import sys
import os
import fnmatch
CHUCK_SIZE = 8192
def is_file_match(filenames,patterns):
if fnmatch.fnmatch(filenames,patterns):
return True
return False
def find_specific_files(dir,patterns=['*'],exclude_dirs=[]):
for root,dirnames,filenames in os.walk(dir):
for filename in filenames:
for pattern in patterns:
if is_file_match(filename,pattern):
yield os.path.join(root,filename)
for d in exclude_dirs:
if d in dirnames:
dirnames.remove(d)
def get_chunk(filename):
with open(filename,encoding="utf-8") as f:
while True:
chunk = f.read(CHUCK_SIZE)
if not chunk:
break
else:
yield chunk
def get_file_checksum(filename):
h = hashlib.md5()
for chunk in get_chunk(filename):
h.update(chunk.encode("utf-8"))
return h.hexdigest()
def main():
sys.argv.append("")
directory = sys.argv[1]
if not os.path.isdir(directory):
raise SystemExit("{0} is not a directory".format(directory))
record = {}
for item in find_specific_files(directory):
checksum = get_file_checksum(item)
if checksum in record:
print("找到相同文件: {0} VS {1}".format(record[checksum],item))
print(checksum)
else:
record[checksum] = item
if __name__ == '__main__':
main()4.tarfile模块
这是一个压缩模块，首先介绍基本用法
读取tar包：
import tarfile
with tarfile.open('tarfile_add.tar') as f:
for member_ino in f.getmembers():
print(member_info.name)tarfile中常用函数：getnames获取tar包中的文件列表 extract提取单个文件 extractall提取所有文件
创建tar包：
import tarfile
with tarfile.open('tarfile_add.tar',mode='w') as out:
out.add('README.txt)读取一个用gzip算法压缩的tar包：with tarfile.open('tarfile_add.tar',mode='r:gz') as out:
创建一个用bzip2算法的压缩tar包： with .tarfile.open('tarfile_add.tar',mode='w:bz2') as out:
实例，备份指定文件到压缩包中：
#-*- conding:utf-8 -*-
import os
import fnmatch
import tarfile
import datetime
def find_specific_files(dir,patterns=['*'],exclude_dirs=[]):
for root,dirnames,filenames in os.walk(dir):
for filename in filenames:
if is_file_match(filename,patterns):
yield os.path.join(root,filename)
for d in exclude_dirs:
if d in dirnames:
dirnames.remove(d)
def main():
patterns = ['*.txt','*.py']
now = datetime.datetime.now().strftime('%Y-%m-%d_%H_%M_%S')
filename = "all_file_{0}".format(now)
with tarfile.open(filename,mode='w:gz') as f:
for item in find_specific_files(".",patterns):
f.add(item)
if __name__ == '__main__':
main()暴力破解zip压缩包密码：解压压缩文件时，一旦密码不正确，程序会终止，在try语句只有成功解压的密码才会执行到extract函数调用后面的语句
with open('password.txt') as f:
for line in f:
try:
f.extractall(pwd=line.strip())
print("password is {0}".format(line.strip())
except:
pass使用python监控linux系统
开源工具：
dstat：集成了linux下vmstat、iostat、netstat和ifstat等命令
使用：dstat -cdngy(-a)统计cpu、磁盘io、网络流量、换页活动、系统统计(终端和上下文切换)
--fs：统计文件打开数和inodes数
-t：显示当前系统时间
-l：统计负载情况
-p：统计进程信息
--tcp：显示常用的TCP统计
--top-mem、--top-io、--top-cpu查看当前占用内存、io、cpu高的进程信息
--output：输出到csv文件中
glances
glances是一款优秀的可视化很好的监控工具
配合Bottle这个web框架，可以通过浏览器访问 pip install Bottle glances -w
使用python监控磁盘io信息：
from collections import namedtuple
Disk = namedtuple('Disk','major_number minor_number device_name'
' read_count read_merged_count read_sections'
' time_spent_reading write_count write_merged_count'
' write_sections time_spent_write io_requests'
' time_spent_doing_io weighted_time_spent_doing_io'
)
def get_disk_info(device):
"""
from /proc/diskstats read IO message
:param device:
:return:
"""
with open("/proc/diskstats") as f:
for line in f:
if line.split()[2] == device:
return Disk(*(line.split()))
raise RuntimeError("device ({0}) not found !".format(device))
def main():
disk_info = get_disk_info('sda1')
print(disk_info)
print("磁盘写次数：{0}".format(disk_info.write_count))
print("磁盘写字节数：{0}".format(disk_info.write_sections))
print("磁盘写延时：{0}".format(disk_info.time_spent_write))
if __name__ == '__main__':
main()psutil
使用psutil实现系统监控，psutil常见去用法Google一下，一下是实例：
from __future__ import unicode_literals
import os
import jinja2
import socket
from datetime import datetime
import yagmail
import psutil
EMAILL_USER = 'xxx'
EMALL_PASSWORD = 'xxx'
RECIPIENTS = ['me@xxx.com']
def render(tpl_path,**kwargs):
path,filename = os.path.split(tpl_path)
return jinja2.Environment(
loader=jinja2.FileSystemLoader(path or './')
).get_template(filename).render(**kwargs)
def bytes2human(n):
symbols = ('B','K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
prefix = {'B': 1,'K': 1024, 'M': 1048576, 'G': 1073741824, 'T': 1099511627776, 'P': 1125899906842624, 'E': 1152921504606846976,
'Z': 1180591620717411303424, 'Y': 1208925819614629174706176}
while True:
for p in reversed(symbols):
if data > prefix[p]:
value = float(data) / prefix[p]
return '%.1f%s' % (value, p)
elif data >= 1 and data <1024:
return "%sB" % data
else:
continue
def get_cpu_info():
cpu_count = psutil.cpu_count()
cpu_percent = psutil.cpu_percent(interval=1)
return dict(cpu_count=cpu_count,cpu_percent=cpu_percent)
def get_memory_info():
virtual_mem = psutil.virtual_memory()
mem_total = bytes2human(virtual_mem.total)
mem_percent = virtual_mem.percent
mem_free = bytes2human(virtual_mem.free + virtual_mem.buffers + virtual_mem.cached)
mem_used = bytes2human(virtual_mem.total * virtual_mem.percent)
return dict(mem_total=mem_total,mem_percent=mem_percent,mem_free=mem_free,mem_used=mem_used)
def get_disk_info():
disk_usage = psutil.disk_usage('/')
disk_total = bytes2human(disk_usage.total)
disk_percent = disk_usage.percent
disk_free = bytes2human(disk_usage.free)
disk_used = bytes2human(disk_usage.used)
return dict(disk_total=disk_total,disk_percent=disk_percent,disk_free=disk_free,disk_used=disk_used)
def get_boot_info():
boot_time = datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S")
return dict(boot_time=boot_time)
def collect_monitor_data():
data = {}
data.update(get_boot_info())
data.update(get_cpu_info())
data.update(get_memory_info())
data.update(get_disk_info())
return data
def main():
hostname = socket.gethostname()
data = collect_monitor_data()
data.update(dict(hostname=hostname))
content = render('monitor.html',**data)
# with yagmail.SMTP(user=EMAILL_USER,password=EMALL_PASSWORD,host='smtp.163.com',port=25) as yag:
# for recipient in RECIPIENTS:
# yag.send(recipient,"监控信息".encode('utf-8').content.encode('utf-8'))
print(data)
if __name__ == '__main__':
main()monitor.html模板内容：
<html>
<header><title>监控信息</title>
<body>
<table border="1">
<tr><td>服务器名称</td><td>{{hostname}}</td></tr>
<tr><td>开机时间</td><td>{{boot_time}}</td></tr>
<tr><td>cpu个数</td><td>{{cpu_count}}</td></tr>
<tr><td>cpu利用率</td><td>{{cpu_percent}}</td></tr>
<tr><td>内存总量</td><td>{{mem_total}}</td></tr>
<tr><td>内存利用率</td><td>{{mem_percent}}</td></tr>
<tr><td>内存已用空间</td><td>{{mem_used}}</td></tr>
<tr><td>内存可用空间</td><td>{{mem_free}}</td></tr>
<tr><td>磁盘空间总量</td><td>{{disk_total}}</td></tr>
<tr><td>磁盘空间利用率</td><td>{{disk_percent}}</td></tr>
<tr><td>磁盘已用空间</td><td>{{disk_used}}</td></tr>
<tr><td>磁盘可用空间</td><td>{{disk_free}}</td></tr>
</table>
</body>
</html>python文档与报告
openpyxl模块：
openpyxl把Excel抽象为了三个不同的类：Workbook、Worksheet、Cell。Workbook是对Excel工作簿的抽象，Worksheet是对表格的抽象，Cell是对单元格的抽象
加载一个Excel表格：wb = openpyxl.load_workbook('1.xlsx') 然后就可以调用属性和方法：active 获取活跃的Worksheet read_only 是否以read only打开Excel表格 encoding 文档的字符集编码 properties:文档的元数据如标题，创建者，创建日期 worksheets 以列表的形式返回所有的Worksheet
Workbook对象的方法大都与Worksheet相关 常用方法：get_sheet_names 获取所有表格的名称 get_sheet_by_name 通过表格名称获取Worksheet对象 get_active_sheet 获取活跃的表格 remove_sheet 删除一个表格
create_sheet 创建一个空的表格 copy_worksheet 在Worksheet内拷贝表格
常用的Worksheet属性如下：title 表格的标题 dimensions 表格的大小，这里的大小是指含有数据的表格大小 max_row 表格的最大行 min_row 表格的最小行 max_column 表格的最大列 min_column 表格的最小列
rows 按行获取单元格(Cell对象) columns 按列获取单元格(Cell对象) freeze_panes 冻结窗格 values 按行获取表格的内容(数据) iter_rows 按行获取所有单元格(Cell对象) iter_columns 按列获取所有单元格 append 在表格末尾添加数据 merged_cells 合并多个单元格 unmerge_cells 移除合并的单元格
获取表格数据：
import openpyxl
wb = openpyxl.load_workbook('1.xlsx')
ws = wb.get_sheet_by_name('Sheet1')
for row in ws.row:
print(*[cell.value for cell in row])
# 或者也可以写成
for i in ws.values:
print(*i)
# 再或者
for row in ws.iter_rows:
print(*[cell.value for cell in row])python处理图片
PIL模块
使用方法： from PIL import Image 打开一个图片：im = Image.open('1.jpg') print(im.format,im.size,im.mode) 旋转图片：rot = im.rotate(45) rot.save('2.jpg')
把一个目录下的图片都创建为缩略图：
from PIL import Image
import glob
import os
size = 128,128
for infile in glob.glob("*.jpg"):
file,ext = os.path.splitext(infile)
im = Image.open(infile)
im.thumbnail(size)
im.save(file + ".thumbnail","JPEG")获取照片的exif信息：
import sys
import os
from PIL.ExifTags import TAGS
from PIL.ExifTags import GPSTAGS
def get_iamge_meta_info(filename):
exif_data = {}
with Image.open(filename) as img:
data = img._getexif()
for tag,value in data.iteritems():
decode = TAGS.get(tag)
exif_data[decode] = value
if exif_data['GPSInfo']:
gps_data = {}
for tag,value in exif_data['GPSInfo'].iteritems():
decode = GPSTAGS.get(tag)
gps_data['GPSInfo'] = gps_data
return exif_data
def main():
sys.argv.append("")
filename = sys.argv[1]
if not os.path.isfile(filename):
raise SystemExit("{0} is not exists".format(filename))
exif_data = get_iamge_meta_info(filename)
for key,value in exif_data.items():
print(key,value,sep=':')
if __name__ == "__main__":
main()发送邮件
步骤：1、连接到SMTP服务器；2、发送SMTP的'Hello'消息；3、登录到SMTP服务器；4、发送电子邮件；5、关闭SMTP服务器的连接
1:smtp = smtplib.SMTP('smtp.163.com',25) 创建SMTP对象
2:smtp.ehlo() 调用ehlo方法与SMTP服务"打招呼"
3:smtp.starttls() 调用starttls方法将当前会话转换成一个加密的会话
4:smtp.login('xxx@163.com','password') 将smtp会话加密了就可以传输敏感信息了，如果没有调用starttls方法就登录，则会抛出SMTPAuthenticationError异常
5:smtp.sendmail(发件人邮件，收件人邮件，邮件内容) 登录上SMTP服务器之后就可以调用sendmail方法发送邮件了
6:smtp.quit() 邮件发送完成之后，调用quit方法断开与SMTP服务器的连接
为了构造一个完整的邮件，需要借助email模块，email模块用来构造邮件和解析邮件内容，构造一个邮件就是创建一个Message对象，如果构造一个MIMEText对象就表示构造一个纯文本的邮件，如果构造一个MIMEImage对象，就表示构造了一个作为附件的图片。如果把多个对象组合起来，就需要用到MIMEMultipart对象email模块下有多个类包括Message、MIMEBase、MIMEText、MIMEAudio、MIMEImage和MIMEMultipart。
发送纯文本信息的邮件：
import smtplib
from email.mime.text import MIMEText
SMTP_SERVER = "smtp.163.com"
SMTP_PORT = 25
def send_mail(user,pwd,to,subject,text):
msg = MIMEText(text)
msg['From'] = user
msg['To'] = to
msg['subject'] = subject
smtp_server = smtplib.SMTP(SMTP_SERVER,SMTP_PORT)
print('Connecting To Mail Server.')
try:
smtp_server.ehlo()
print('Starting Encrypted Section.')
smtp_server.starttls()
smtp_server.ehlo()
print('Logging Info Mail Server')
smtp_server.login(user,pwd)
print('Sending Mail')
smtp_server.sendmail(user,to,msg.as_string())
except Exception as err:
print('Sending Mail faild:{0}'.format(err))
finally:
smtp_server.quit()
def main():
send_mail(发件人邮箱,密码,收件人邮箱,邮件主题,邮件内容)
if __name__ == '__main__':
main()发送带各种附件的邮件：
import urllib
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.application import MIMEApplication
username = 'xxx@163.com'
password = 'xxx'
sender = username
receivers = ','.join(['xxx@qq.com'])
# 如名字所示： Multipart就是多个部分
msg = MIMEMultipart()
msg['Subject'] = 'Python mail Test'
msg['From'] = sender
msg['To'] = receivers
# 下面是文字部分，也就是纯文本
puretext = MIMEText('我是纯文本部分，')
msg.attach(puretext)
# 下面是附件部分 ，这里分为了好几个类型
# 首先是xlsx类型的附件
xlsxpart = MIMEApplication(open(r'C:\Users\qinghesh\Desktop\1.xlsx', 'rb').read())
xlsxpart.add_header('Content-Disposition', 'attachment', filename='绩1.xlsx')
msg.attach(xlsxpart)
# jpg类型的附件
jpgpart = MIMEApplication(open(r'D:\1.jpg', 'rb').read())
jpgpart.add_header('Content-Disposition', 'attachment', filename='1.jpg')
msg.attach(jpgpart)
# mp3类型的附件
mp3part = MIMEApplication(open(r'C:\Users\Public\Music\Sample Music\Kalimba.mp3', 'rb').read())
mp3part.add_header('Content-Disposition', 'attachment', filename='Kalimba.mp3')
msg.attach(mp3part)
## 下面开始真正的发送邮件了
try:
client = smtplib.SMTP()
client.connect('smtp.163.com')
client.login(username, password)
client.sendmail(sender, receivers, msg.as_string())
client.quit()
print('带有各种附件的邮件发送成功！')
except smtplib.SMTPRecipientsRefused:
print('Recipient refused')
except smtplib.SMTPAuthenticationError:
print('Auth error')
except smtplib.SMTPSenderRefused:
print('Sender refused')
except smtplib.SMTPException as e:
print(e)yagmail模块:
import yagmail
with yagmail.SMTP(user=user_mail,password=password,host=smtp_host,port=port) as yag:
yag.send(recipients,subject,content)注意这里的recipients和content都可以等于一个列表，表示多个收件人和多个附件
cmcli客户端项目：
1 import os
2 import sys
3 try:
4 import ConfigParser
5 except ImportError:
6 import configparser as ConfigParser
7 import argparse
8 import yagmail
9
10 from storage import Storage
11 from logger import get_logger
12
13 logger = get_logger()
14
15
16 def get_argparse():
17 parser = argparse.ArgumentParser(description='A email client in terminal')
18 parser.add_argument('-s', action='store', dest='subject', required=True, help='specify a subject (must be in quotes if it has spaces)')
19 parser.add_argument('-a', action='store', nargs='*', dest='attaches', required=False, help='attach file(s) to the message')
20 parser.add_argument('-f', action='store', dest='conf', required=False, help='specify an alternate .emcli.cnf file')
21 parser.add_argument('-r', action='store', nargs='*', dest='recipients', required=True, help='recipient who you are sending the email to')
22 parser.add_argument('-v', action='version', version='%(prog)s 0.2')
23 return parser.parse_args()
24
25
26 def get_config_file(config_file):
27 if config_file is None:
28 config_file = os.path.expanduser('~/.emcli.cnf')
29 return config_file
30
31
32 def get_meta_from_config(config_file):
33 config = ConfigParser.SafeConfigParser()
34
35 with open(config_file) as fp:
36 config.readfp(fp)
37
38 meta = Storage()
39 for key in ['smtp_server', 'smtp_port', 'username', 'password']:
40 try:
41 val = config.get('DEFAULT', key)
42 except (ConfigParser.NoSectionError, ConfigParser.NoOptionError) as err:
43 logger.error(err)
44 raise SystemExit(err)
45 else:
46 meta[key] = val
47
48 return meta
49
50
51 def get_email_content():
52 return sys.stdin.read()
53
54
55 def send_email(meta):
56 content = get_email_content()
57 body = [content]
58 if meta.attaches:
59 body.extend(meta.attaches)
60
61 with yagmail.SMTP(user=meta.username, password=meta.password,
62 host=meta.smtp_server, port=int(meta.smtp_port)) as yag:
63 logger.info('ready to send email "{0}" to {1}'.format(meta.subject, meta.recipients))
64 ret = yag.send(meta.recipients, meta.subject, body)
65
66
67 def main():
68 parser = get_argparse()
69
70 config_file = get_config_file(parser.conf)
71
72 if not os.path.exists(config_file):
73 logger.error('{0} is not exists'.format(config_file))
74 raise SystemExit()
75 else:
76 meta = get_meta_from_config(config_file)
77
78 meta.subject = parser.subject
79 meta.recipients = parser.recipients
80 meta.attaches = parser.attaches
81
82 for attach in meta.attaches:
83 if not os.path.exists(attach):
84 logger.error('{0} is not exists'.format(attach))
85 raise SystemExit()
86
87 send_email(meta)
88
89
90 if __name__ == '__main__':
91 main()
1 import logging
2
3
4 def get_logger(log_level=logging.INFO):
5 logger = logging.getLogger(__name__)
6 logger.setLevel(log_level)
7
8 formatter = logging.Formatter("%(asctime)s [emcli] [%(levelname)s] : %(message)s", "%Y-%m-%d %H:%M:%S")
9
10 handler = logging.StreamHandler()
11 handler.setFormatter(formatter)
12
13 logger.handlers = [handler]
14
15 return logger
1 class Storage(dict):
2 """
3 A Storage object is like a dictionary except `obj.foo` can be used
4 in addition to `obj['foo']`.
5 """
6 def __getattr__(self, key):
7 try:
8 return self[key]
9 except KeyError as k:
10 raise AttributeError(k)
11
12 def __setattr__(self, key, value):
13 self[key] = value
14
15 def __delattr__(self, key):
16 try:
17 del self[key]
18 except KeyError as k:
19 raise AttributeError(k)
20
21 def __repr__(self):
22 return '<Storage ' + dict.__repr__(self) + '>'
1 from emcli import mainemcli.cnf
[DEFAULT]
smtp_server = smtp.163.com
smtp_port = 25
username = xxx@163.com
password = 123456检查主机是否存活，用ping：
第一种方法：
import subprocess
import threading
def is_reacheable(ip):
if subprocess.call(["ping","-c","2",ip]):
print("{0} is alived".format(ip))
else:
print("{0} is unreacheable".format(ip))
def main():
with open('ip.txt') as f:
lines = f.readlines()
threads = []
for line in lines:
thr = threading.Thread(target=is_reacheable,args=(line,))
thr.start()
threads.append(thr)
for thr in threads:
thr.join()
if __name__ == '__main__':
main()这种方法我们是将所有ip先都读入内存当中，当如果需要扫描机器非常非常多的时候，我们可以用生产者消费者模型来写，如下：
import subprocess
import threading
import queue
def call_ping(ip):
if subprocess.call(["ping","-c","1",ip])
print("{0} is alive".format(ip))
else:
print("{0} is unreacheable".format(ip))
def is_reacheable(q):
try:
while True:
ip = q.get()
call_ping(ip)
except:
pass
def main():
q = queue.Queue()
with open('ip.txt') as f:
for line in f:
q.put(line)
threads = []
for i in range(10):
thr = threading.Thread(target=is_reacheable,args=(q,))
thr.start()
threads.append(thr)
for ths in threads:
ths.join()
if __name__ == '__main__':
main()nmap
打印IP列表，不进行任何操作:nmap -sL 192.168.0.0/30
指定多个主机：nmap -sL 192.168.1.1 192.168.1.18 也可以排除某个IP：nmap -sL 192.168.0.* --exclude 192.168.0.100 也可以将IP保存在文件中，同过-iL选项读取文件中的IP：nmap -iL ip.list
使用nmap检查网络上所有在线主机：nmap -sP 10.166.224.* 或者:nmap -sn 10.166.224.*
IPy
处理IP地址的模块，它能够自动识别IP地址的版本、IP地址类型。使用IPy模块，可以方便的进行IP地址计算，用法去百度。几个重要的用法
IP('192.168.1.1').int()：将ip地址转换为整数，mysql也有相应的函数，select inet_aton('192.168.1.1')可以将ip转化为整数，select inet_ntoa('2887432721')解析为IP地址
dnspython
域名解析模块
dns.resolver.query('域名名称',rdtype=1,rdclass=1,tcp=False,source=None,raise_on_no_answer=True,source_port=9)
rdtype:指定RR资源 A：地址记录，返回域名指向IP地址 NS：域名服务器记录，返回保存下一级域名信息的服务器地址。该记录只能设置为域名，不能设置为IP地址 MX：邮件记录，返回接受邮件的服务器地址
CNAME：规范名称目录，别名记录，实现域名间的映射 PTR：逆向查询记录，反向解析，与A记录相反，将IP地址转换为主机名
rdclass：网络类型
tcp：指定查询是否使用TCP协议
source：查询源的地址
source_port：查询源的端口
raise_on_no_answer：指定查询无应答时是否触发异常，默认为True
polyshpolysh运维工具，直接用pip安装即可，是一个交互式命令，可以批量对服务器进行处理。也就是说可以同时登陆多台服务器，并在各服务器上同时执行相同的操作。
polysh --ssh='exec ssh -p 22 -i ~/.ssh/id_rsa' --user=root --hosts-file=hosts.txt
fabricfabric是对paramiko更好的封装，它既是一个python库，也是一个命令行工具：fab fabric典型的使用方式是，创建一个python文件(默认使用fab命令不指定文件的是寻找fabfile.py)，改文件包含一到多个函数，然后使用fab命令直接调用这些函数即可
from fabric.api import run,sudo
from fabric.api import env
env.hosts = ["ip1","ip2"]
env.port = 22
env.user = 'root'
env.password = 'password'
def hostname():
run('hostname')
def ipaddr():
run('ifconfig')然后使用：fab hostname(函数名称)或者ipaddr(函数名称)调用即可 可以使用fab --list查看有哪些方法
run：执行远程命令的封装 sudo：以sudo权限执行 env：保存配置信息的字典
run和sudo函数有一个比较重要的参数，即pty，用于设置伪终端，如果我们执行命令以后需要有一个常驻的服务进程，则需要设置pty=False，避免因为fabric退出导致进程退出 创建一个文件：run("mkdir /tmp/1.txt")
result=run("whoami")如果失败：result.failed sudo("mkdir /var/www/1.log") sudo("service httpd restart",pty=False)
local：local用以执行本地命令，local是对python的subprocess进行封装，便于在本地执行shell命令，如需执行更复杂的功能，可以直接使用subprocess local("pwd ")
get从远程服务器获取文件，通过remote_path参数声明从何处下载，通过local_path参数声明下载到何处 get(remote_path =” / tmp/log _ extracts.t ar.gz ”, local _pa th =” / l ogs / new_ log.tar.gz ”)
put将本地的文件上传到远程服务器，参数与get相似，此外还可以通过mode设置远程文件的权限 put (” / local/path/to/app.tar.gz ”,” /t mp /trunk / app.tar.gz”，mode=0755)
reboot重启远程服务器，可以通过wait参数设置等待几秒开始重启 reboot(wait=30)
prompt用以在fabric执行任务的过程中与管理员进行交互，作用类似于raw_input prompt ( ’ Please specify process nicelevel :’, key =’ nice ’, validate =int)
Fabric设置：
fabric将所有配置保存在全局的env字典中，我们可以直接修改env字典来改变fabric的配置，但是，有的时候我们并不希望修改全局的参数配置，只希望临时修改部分配置。例如修改当前工作目录，修改日志的输出级别等
1）在shell中语法：cd /tmp && pwd 在fabric中可以：with cd('/var/log'): run('ls')
2）lcd与cd类似，只不过是切换本地目录
3）path配置远程服务器PATH环境变量：只会对当前会话有效，path修改支持多种模式：append：默认行为，将给定的路径添加到path后面，prepend：将给定的路径添加到path前面 replace：替换当前的path环境变量
4）prefix就是前缀的意思，实际效果是对于prefix，每个命令都执行一遍：
with cd('/path/to/app/'):
with prefix('workon myvenv'):
run('./manage.py syncdb')
run('./manage.py loaddata')替换成shell相当于：
cd /path/to/app && workon myvenv && ./manage.py syncdb
cd /path/to/app && workon myvenv && ./manage.py loaddata5）shell_env设置Shell脚本的环境变量
with shell_env(ZMQ_DIR='/home/user/local'):
run('pip install pyzmq')相当于shell代码：
export ZMQ_DIR='/home/user/local' && pip install pyzmq6）settings通用的设置，用于临时覆盖env变量
with settings(user='foo'):
do something7）remote_tunnel通过ssh的端口转发建立转发通道
with remote_tunnel(3306):
run('mysql -u root -p password')输出相关
hide隐藏指定类型的输出
def my_task():
with hide('running','stout','stderr'):
run('ls /var/www')hide可选类型有7种：
status 状态信息，如服务器断开了连接，用户使用Ctrl+C等，如果fabric正常运行不会有状态信息
aborts 终止信息，一般将fabric当做库使用的时候需要关闭
warnings 警告信息
running 运行过程中的输出
stdout 执行shell命令的标准输出
stderr 执行shell命令的错误输出
user 用户输出，类似于python代码中的print函数
show与hide相反，显示指定类型的输出 output：stdout、stderr everything：stdout、stderr、warnings、running、user commands：stdout、running
quiet隐藏全部输出，仅在执行错误时发出警告
warn_only：默认情况下当命令执行失败时，fabric会停止执行后面的命令，当设置为True的时候，允许执行失败的时候继续执行
fabric提供的装饰器
fabric提供的装饰器既不是执行具体操作的，也不是修改参数的，二是控制如何执行这些操作的，在哪些服务器上执行这些操作的
task：就是fabric需要在远程服务器执行的任务，task是一个抽象的事。如下使用方法：
from fabric.api import env
from fabric.api import task,run
import json
@task
def hostname():
run('hostname')
def ipaddr():
run('ifconfig')fibric中所有可调用对象都是一个task，但是如果用task装饰器定义的task，其他没有被装饰器装饰的函数将不会被认为是一个task，上面的代码中，只有hostname是可调用的task，可以使用fab --list
通过装饰器指定对哪些hosts执行当前task：@hosts('host1','host2') def hostname():run('hostname')
通过env.reject_unknow_hosts控制未知host的行为，该选项默认为True，类似于SSH中的StricHostKeyChecking为no
fabric中的role
role是对服务器进行分类的手段，使用role可以定义服务器的角色，以便对不同的服务器执行不容的操作，role是逻辑上将服务器进行了分类，分类之后我们需要将指定某一类服务器时指定role名称即可，一个role可以包含一台或多台服务器。role的定义保存在env.roledef中：
from fabric.api import env
env.roledefs['webserver'] = ['www1','www2','www3']
env.roledefs = {
'web':['www1','www2','www3'],
'db':['db01','db02','db03']
}定义好role后，就可以通过role装饰器指定在哪些role上运行当前这个task：
from fabric.api import env
env.roledefs = {
'web':['www1','www2','www3'],
'db':['db01','db02','db03']
}
@roles('db')
def mirget():
pass
@roles('web')
def webt():
passfabric执行模型
步骤：
1.创建一个任务列表，这些任务就是通过fab命令参数指定的任务，fabric会保持这些任务的顺序
2.对于每个任务，构造需要执行任务的服务器列表，服务器列表可以通过传参数指定，可以通过env,hosts指定，也可以通过hosts或者roles装饰器指定
3.历遍任务列表，对于每一台服务器分别执行任务
默认是串行执行：
for task in tasks:
for host in hosts:
execute(task in host)并行执行方式
1.通过命令行参数-P(--parallel)通知Fabric并行执行task
2.通过env.parallel设置是否需要并行执行
3.通过parallel装饰器通知fabric并行执行task
runs_once装饰器:只执行一次，防止task被多次调用：
from fabric.api import execute,env,runs_once,task
@runs_once
def hello():
print("hello")
@task
def test():
execute(hello)
execute(hello)serial:强制当前task串行执行。使用该装饰器后，即使用户通过参数--parallel指定需要并行执行，当执行呗serial装饰器修改过的task时，依然会串行执行。这样就达到了部分task可以串行执行
execute函数，用来对task进行封装。其好处是将一个大的任务拆分成多个小任务。每个小任务相互独立，互不干扰：
from fabric.api import execute,env,runs_once,task
env.roledefs = {
'db':['db01','db02'],
'wb':['wb01','wb02']
}
@roles('db')
def migrate():
pass
@roles('web')
def update():
pass
def deploy():
execute(migrate)
execute(update)x 一源码的方式在远程服务器上安装redis
1）在本地执行make test及redis单元测试，如果单元测试出现错误，提示用户是否需要继续部署。执行成功之后，删除redis的二进制文件，并将redis源码打成一个tar包，显然在执行单元测试的时候只需要执行一次，使用runs_once装饰器装饰函数
2）接着就是将redis源码上传到远程服务器，并执行“make install”，安装完成后清理远程服务器的文件，先使用cd切换到相应目录，在执行删除操作
3）清理本地文件
Ansible
ansible all -m file -a "dest=/tmp/data.txt mode=500 owner=root group=root" -become 这里的-become相当于sudo
plooybook示例：
---
- host: test
become: yes
become_method: sudo
task:
- name: copy file
copy: src=/tmp/data.txt dest=/tmp/data.txt
- name: change mode
file: dest=/tmp/data.txt mode=500 owner=root group=root
- name: ensure packages installed
apt: pkg={{ item }} state=present
with_items:
- tmux
- gitYMAL语法规则：
文件的第一行为'---'，表示这是一个YAML文件
YAML中的字段大小写敏感
YAML与python一样，使用缩进表示层级关系
YAML的缩进不允许使用Tab键，只允许使用空格，且空格数目不重要，只要相同层级的元素左侧对齐即可
‘#’表示注释
YAML支持三种格式的数据，分别是：
对象：键值对的集合，又称为映射，类似于python中的字典
数组：一组按次序排列的值，又称为序列，类似于python中的列表
纯量：单个的、不可再分的值，如字符串、布尔值或数字
从数据库动态取出inventor：
import argparse
import json
from collections import defaultdict
from contextlib import contextmanager
import pymysql
def to_json(in_dict):
return json.dumps(in_dict,sort_keys=True,indent=2)
@contextmanager
def get_conn(**kwargs):
conn = pymysql.connect(**kwargs)
try:
yield conn
finally:
conn.close()
def parse_args():
parser = argparse.ArgumentParser(description='Openstack Inventory Module')
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument('--list',action='store_true',help='List active servers')
group.add_argument('--host',help='List details about the specific host')
return parser.parse_args()
def list_all_hosts(conn):
hosts = defaultdict(list)
with conn as cur:
cur.execute('select * from hosts')
rows = cur.fetchall()
# print(rows)
for row in rows:
no,host,group,user,port = row
hosts[group].append(host)
return hosts
def get_host_detail(conn,host):
details = {}
with conn as cur:
cur.execute("select * from hosts where host='{0}'".format((host)))
rows = cur.fetchall()
if rows:
no,host,group,user,port = rows[0]
details.update(ansible_user=user,ansible_port=port)
return details
def main():
parser = parse_args()
with get_conn(host='x.x.x.x',user='root',passwd='123456',db='db_ansible') as conn:
if parser.list:
hosts = list_all_hosts(conn)
print(to_json(hosts))
else:
details = get_host_detail(conn,parser.host)
print(to_json(details))
if __name__ == '__main__':
main()表结构为：
CREATE TABLE `hosts` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`host` varchar(15) DEFAULT NULL,
`groupname` varchar(15) DEFAULT NULL,
`username` varchar(15) DEFAULT NULL,
`port` int(11) DEFAULT '22',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 |
#创建一个目录
ansible test -m file -a 'path=/tmp/dd state=directory mode=0755'
#修改文件的权限
ansible test -m file -a 'path=/tmp/dd state=touch mode="u=rw,g=r,o=r"'
#创建一个软连接
ansible test -m file -a 'path=/tmp/dd dest=/tmp/ddl owner=lmx group=lmx state=link'
#修改一个文件的所有者
ansible test -m file -a 'path=/tmp/dd owner=root group=root mode=0644' -become
#创建一个用户
ansible test -m user -a 'name=johd comment="jobe done" uid=1321 group=root' -become
#删除一个用户
ansible test -m user -a 'name=john state=absent' -become
#创建一个用户，并产生一对秘钥
ansible test -m user -a 'name=joind comment="joned jjj" generate_ssh_key=yes ssh_key_bits=2048' -become
#创建群组
ansible test -m group -a 'name=ansible state=present git=1234' -become
#删除群组
ansible test -m group -a 'name=ansible state=absent' -become
#下载文件到远程服务器
ansible test -m get_url -a 'url=http://www.baidu.com dest=/tmp/baidu.txt'
#下载文件到远程服务器并修改文件的权限
ansible test -m get_url -a 'url=http://www.baidu.com dest=/tmp/baidu.txt mode=0777'
#在本地创建一个名为data的目录，并在该目录穿件一些文件，然后再该目录上创建两个压缩文件，分别为data.tar.gz和data.tar.bz2
#创建一个目录
ansible test -m file -a 'path=/data state=directory'
#解压本地文件
ansible test -m unarchive -a 'src=data.tar.gz dest=/data list_files=yes'
#将本地文件拷贝到远程
ansible test -m unarchive -a 'src=data.tar.bz2 dest=/data'
#解压远程文件
ansible test -m unarchive -a 'src=/data/data.tar.bz2 dest=/tmp remote_src=yes'
git
#将requests克隆到/tmp/request目录下
ansible test -m git -a 'repo=https://github.com/kennethreitz/requests.git dest=/tmp/request versinotallow=HEAD'
#从源码安装requests
ansible test -a 'python setup.py install chdir=/tmp/request' -become
#验证requests是否安装成功
ansible test -a 'python -c "import requests"'
#获取文件的相关信息
ansible test -m stat -a 'path=/etc/passwd'
cron
#增加一个cron任务ansible test -m cron -a ’ backup=yes name =” test cron ” minute=*/2 hour=* job =” ls /tmp >/dev/null "
service
#安装httpd
ansible test -m yum -a 'name=httpd state=prestent' -become
#停止httpd
ansible test -m service -a 'name=httpd state=stopped'
#重启httpd
ansible test -m service -a 'name=httpd state=restarted'
sysctl
#设置overcommit_memory参数值为1
ansible test -m sysctl -a 'name=vm.overcommit_memory value=1' -become
mount
#挂载/dev/vda盘到/mnt/data目录
ansible test -m mount -a 'name=/mnt/data src=/dev/vda fstype=ext4 state=mounted'---
- hosts: dbserver
become: yes
become_method: sudo
tasks:
- name: install mongodb
apt: name=mongodb-server state=present
- hosts: webservers
tasks:
- name: copy file
copy: src=/tmp/data.txt dest=/tmp/data.txt
- name: change mode
file: dest=/tmp/data.txt mode=655 owner=root group=root
---
- hosts: dbserver
become: yes
become_method: sudo
tasks:
- name: install mongodb
apt: name=mongodb-server state=present state=present
- hosts: webserver
tasks:
- name: copy file
copy: src=/tmp/data.txt dest=/data.txt
- name: change mode
file: dest=/data.txt mode=755 ower=lmx group=lmxpalybook可以包含多个play，但是为了playbook的可读性和可维护性，我们一般会在一个playbook写一个play，如果我们在first_playbook.yml这个拆分成两个playbook，分别为web.yml和db.yml，当我们可以先执行db.yml,再执行web.yml，可以写一个all.yml
---
- include: db.yml
- include: web.ymlinclude选项是ansible提供的，用于在一个playbook中导入其他playbook，被导入的playbook会按顺序依次执行
ansible-playbook
-T --timeout:建立SSH连接的超时时间
--key-file --private-key:建立SSH连接的私钥文件
-i --inventory-file：指定inventory文件，默认是/etc/ansible/hosts
-f --foks:并发执行进程数，默认是5
--list-hosts:匹配到服务器列表
--list-tasks：列出任务列表
--step：每执行一个任务后停止，等待用户确认
--syntax-check：检查playbook语法
-C --check：检查当前这个playbook是否会修改远程服务器，相当于预测playbook的执行结果
playbook详细语法
在定义play时，只有hosts和tasks是必选项，其他都是根据需要加的
在ansible中，默认使用当前用户连接远程服务器执行操作，我们也可以在ansible.cfg文件中配置连接远程服务器的默认用户，此外，如果是不同的用户使用不同类型的远程服务器，那么也可以在playbook的play定义中指定连接远程服务器的用户。例如我们可以指定执行play的用户：
---
- hosts: webserver
remote_user: root用户也可以细分每一个task
---
- hosts: test
remote_user: root
tasks:
- name: test connection
ping:
remote_user: root与remote_user类似，我们也可以为单个任务使用管理员权限，
---
- hosts: test
remote_user: root
tasks:
- service: name=nginx state=restarted
become: yes
become_method: sudo通知
在ansible中，模块是幂等的。例如，我们要在远程服务器上创建一个用户，如果用户已存在，那么ansible不会将该用户删除后重新创建，而是直接返回成功，并通过change字段表示是否对远程服务器进行了修改
当我们通过ansible修改apache的配置文件，并重启apache的时候，如果我们修改的内容没变，我们就不需要重启。在ansible中，通过notify与handler机制来实现
---
- hosts: webserver
remote_user: test
become: yes
become_method: sudo
tasks:
- name: ensure apache is at letest version
yum: name=httpd state=latest
- name: write the apache config file
template: src=/srv/httpd.j2dest=/ect/httpd.conf
notify:
- restart apache
- name: ensure apache is running
service: name=httpd state=started
handlers:
- name: restart apache
service: name=httpd state=restarted需要注意的是，handle只会在所有task执行完之后执行，并且即便一个handler被触发多次，它只会执行一次。handler不是在被触发时立即执行，而是按照play中定义的顺序执行。一般情况下handler都位于play最后，即在所有任务执行完以后再执行
变量
在inventory中，我们可以定义变量，对于简单的playbook，最直接的方式是将变量定义在playbook的vars选项中
---
- hosts: webserver
vars:
mysql_port: 3307在playbook中定义的变量，可以在模板渲染时使用，
[mysqld]
datadir=/var/lib/mysql
socket=/var/lib/mysql/mysql.sock
user=mysql
port={{ mysql_port }}当变量比较多的时候，可以将其保存在一个独立的文件中，并通过vars_files选项引用该文件
---
- hosts: webserver
vars:
favcolor: blue
vars_files:
- /vars/external_vars.yml
tasks:
- name: this is just a placeholder
command: /bin/echo foo保存变量的文件是一个简单的YAML格式的字典
---
somervar: somevalue
password: magic在shell中，通过上一条命令的返回码判断命令是否执行成功，在ansible中，我们将任务的执行结果保存在一个变量中，并在之后引用这个变量。这样的变量在ansible中用register获取，也成为注册变量
如下，执行/usr/bin/foo命令，通过register选项获取命令执行结果，将结果保存在foo_result中，之后的task中引用这个变量的执行结果
---
- hosts: webserver
tasks:
- shell: /usr/bin/foo
register: foo_result
ignore_errors: True
- shell: /usr/bin/bar
when: foo_result.rc == 5ignore_errors表示忽略中的错误，后者是一个条件语句，只有条件为真时才执行当前task
Facts变量
在ansible中还有一些特殊的变量，这些变量时直接使用的。facts变量是ansible执行远程部署之前从远程服务器获得的系统信息
在playbook中可以直接引用变量，如下
---
- hosts: test
tasks:
- shell: echo {{ansible_os_family}}
register: myecho
- debug: var=myecho.stdout_lines
- name: install git on Centos linux
yum: name=git state=installed
when: ansible_os_family == "Centos"访问复杂变量的playbook
---
- hosts: test
gather_facts: yes
tasks:
- shell: echo {{ansible_eth0["ipv4"]["address"]}}
register: myecho
- debug: var=myecho.stdout_lines
- shell: echo {{ansible_eth0.ipv4.address}}
register: myecho1
- debug: var=myecho1.stdout_lines在ansible中，可以通过gather_facts选项控制是否手机远程服务器的信息，该选项默认为yes，如果确定不需要到远程服务器的信息，可以将该选项设置为no，以此提高ansible部署效率
---
- hosts: test
gather_facts: no
tasks:
- name: Install Mysql package
yum: name={{ item }} state=installed
with_items:
- mysql-server
- MySQL-python
- libselinux-python
- libsemanage-pythonx在playbook中，可以通过when选项执行条件语句，when就类似于编程语言的if，示例
tasks:
- name:"shut down Debian flavored systems"
command: /sbin/shutdown -t now
when: ansible_os_family == "Debian"when也支持多个条件语句，
tasks:
- name:"shut down Centos 6 systems"
command:/sbin/shutdown -t now
when:
- ansible_distribution == "CentOS"
- ansible_distribution_major_version == "6"对于更加复杂的条件可以使用and、or与括号进行定义
---
- hosts: test
gather_facts: yes
tasks:
- name: "shut down CentOS 6 and Debian 7 systems"
command: /sbin/shutdown -t now
when: (ansible_distribution == "CentOS" and ansible_distribution_major_version == "6") or (ansible_distribution == "Debian" and ansible_distribution_major_version == "7")when选项中可以读取变量的取值，如
vars:
epic: true
tasks:
- shell: echo "This is epic"
when: epicwhen选项可以与循环一起使用，以实现过滤的功能：
tasks:
- command: echo {{ item }}
with_items: [0,2,4,6,8,10]
when: item > 5任务执行策略
在ansible中，playbook的执行方式是以task为单位进行的，ansible默认是5个进程对远程执行任务，在默认情况的执行策略中，ansible首先执行task1，等到所有服务器执行完task1以后在执行task2，从2.0开始，ansible支持名为free的任务执行策略，允许执行较快的远程服务器提前完成Play的部署，不用等待其他远程服务器一起执行task
---
- hosts: test
strategy: free
tasks:
...使用playbook部署nginx
---
- hosts: test
become: yes
become_method: sudo
vars:
worker_connections: 768
worker_processes: auto
max_open_files: 65535
tasks:
- name: install nginx server
yum: name=nginx state=latest
- name: copy nginx config file
template: src=/etc/ansible/playbook/nginx.conf.j2 dest=/etc/nginx/nginx.conf
notify: restart nginx server
- name: copy index
template:
src=/etc/ansible/playbook/index.html.j2
dest=/usr/share/nginx/html/index.html
mode=0644
handlers:
- name: restart nginx server
service: name=nginx state=restarted# For more information on configuration, see:
# * Official English Documentation: http://nginx.org/en/docs/
# * Official Russian Documentation: http://nginx.org/ru/docs/
user root;
worker_processes {{ worker_processes }};
work_rlimit_nofile {{ max_open_files }};
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;
# Load dynamic modules. See /usr/share/nginx/README.dynamic.
include /usr/share/nginx/modules/*.conf;
events {
worker_connections {{ worker_connections }};
}
http {
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" '
'"$http_user_agent" "$http_x_forwarded_for"';
access_log /var/log/nginx/access.log main;
sendfile on;
tcp_nopush on;
tcp_nodelay on;
keepalive_timeout 65;
types_hash_max_size 2048;
include /etc/nginx/mime.types;
default_type application/octet-stream;
# Load modular configuration files from the /etc/nginx/conf.d directory.
# See http://nginx.org/en/docs/ngx_core_module.html#include
# for more information.
include /etc/nginx/conf.d/*.conf;
server {
listen 80 default_server;
listen [::]:80 default_server;
server_name 172.26.186.194;
root /usr/share/nginx/html;
# Load configuration files for the default server block.
include /etc/nginx/default.d/*.conf;
location / {
root /opt/piwik;
index index.php index.html;
}
location ~ \.php$ {
include /etc/nginx/fastcgi_params;
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME /usr/share/nginx/html/html$fastcgi_script_name;
}
error_page 404 /404.html;
location = /40x.html {
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
}
}
# Settings for a TLS enabled server.
#
# server {
# listen 443 ssl http2 default_server;
# listen [::]:443 ssl http2 default_server;
# server_name _;
# root /usr/share/nginx/html;
#
# ssl_certificate "/etc/pki/nginx/server.crt";
# ssl_certificate_key "/etc/pki/nginx/private/server.key";
# ssl_session_cache shared:SSL:1m;
# ssl_session_timeout 10m;
# ssl_ciphers HIGH:!aNULL:!MD5;
# ssl_prefer_server_ciphers on;
#
# # Load configuration files for the default server block.
# include /etc/nginx/default.d/*.conf;
#
# location / {
# }
#
# error_page 404 /404.html;
# location = /40x.html {
# }
#
# error_page 500 502 503 504 /50x.html;
# location = /50x.html {
# }
# }
}<html>
<head>
<title>Wecome to ansible</title>
</head>
<body>
<h1>nginx,configured by ansible</h1>
<p>If you can see this,ansible successful installed nginx.</p>
<p>{{ ansible_hostname }}</p>
</body>
</html>在nginx.conf.j2中引用了nginx.yaml里面定义的三个参数，在index.html.j2里面引用了系统变量
使用playbook部署mongodb
playbook中的高级语法
高级语法包括：serial、delegate_to、local_action、run_once、with_*、tags、changed_when和faild_when
线性更新服务器
ansible为了提高部署的效率，默认使用并发的方式对远程服务器进行更新。我们可以使用--forks参数控制并发的进程数，默认并发数为5.我们更新线上服务的时候应该循序渐进更新，以此达到降低对线上服务影响的目的。如果服务器数量较少，可以逐台更新，如果服务器较多，则渐进式更新。如先更新一台服务器，没有问题再更新2台服务器。如果更新过程中存在不规范或者有问题，循序渐进的更新方式可以及时停止更新，尽可能降低对线上的影响
为了实现线性更新，我们可以使用ansible playbook的serial选项。该选项值
