python自动化运维笔记

命令行工具

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压缩包密码：

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:UsersqingheshDesktop1.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:UsersPublicMusicSample MusicKalimba.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客户端项目：

import os
import sys
try:
    import ConfigParser
except ImportError:
    import configparser as ConfigParser
import argparse
import yagmail

from storage import Storage
from logger import get_logger

logger = get_logger()


def get_argparse():
    parser = argparse.ArgumentParser(description='A email client in terminal')
    parser.add_argument('-s', action='store', dest='subject', required=True, help='specify a subject (must be in quotes if it has spaces)')
    parser.add_argument('-a', action='store', nargs='*', dest='attaches', required=False, help='attach file(s) to the message')
    parser.add_argument('-f', action='store', dest='conf', required=False, help='specify an alternate .emcli.cnf file')
    parser.add_argument('-r', action='store', nargs='*', dest='recipients', required=True, help='recipient who you are sending the email to')
    parser.add_argument('-v', action='version', version='%(prog)s 0.2')
    return parser.parse_args()


def get_config_file(config_file):
    if config_file is None:
        config_file = os.path.expanduser('~/.emcli.cnf')
    return config_file


def get_meta_from_config(config_file):
    config = ConfigParser.SafeConfigParser()

    with open(config_file) as fp:
        config.readfp(fp)

    meta = Storage()
    for key in ['smtp_server', 'smtp_port', 'username', 'password']:
        try:
            val = config.get('DEFAULT', key)
        except (ConfigParser.NoSectionError, ConfigParser.NoOptionError) as err:
            logger.error(err)
            raise SystemExit(err)
        else:
            meta[key] = val

    return meta


def get_email_content():
    return sys.stdin.read()


def send_email(meta):
    content = get_email_content()
    body = [content]
    if meta.attaches:
        body.extend(meta.attaches)

    with yagmail.SMTP(user=meta.username, password=meta.password,
                      host=meta.smtp_server, port=int(meta.smtp_port)) as yag:
        logger.info('ready to send email "{0}" to {1}'.format(meta.subject, meta.recipients))
        ret = yag.send(meta.recipients, meta.subject, body)


def main():
    parser = get_argparse()

    config_file = get_config_file(parser.conf)

    if not os.path.exists(config_file):
        logger.error('{0} is not exists'.format(config_file))
        raise SystemExit()
    else:
        meta = get_meta_from_config(config_file)

    meta.subject = parser.subject
    meta.recipients = parser.recipients
    meta.attaches = parser.attaches

    for attach in meta.attaches:
        if not os.path.exists(attach):
            logger.error('{0} is not exists'.format(attach))
            raise SystemExit()

    send_email(meta)


if __name__ == '__main__':
    main()

import logging


def get_logger(log_level=logging.INFO):
    logger = logging.getLogger(__name__)
    logger.setLevel(log_level)

    formatter = logging.Formatter("%(asctime)s [emcli] [%(levelname)s] : %(message)s", "%Y-%m-%d %H:%M:%S")

    handler = logging.StreamHandler()
    handler.setFormatter(formatter)

    logger.handlers = [handler]

    return logger

class Storage(dict):
    """
    A Storage object is like a dictionary except `obj.foo` can be used
    in addition to `obj['foo']`.
    """
    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError as k:
            raise AttributeError(k)

    def __setattr__(self, key, value):
        self[key] = value

    def __delattr__(self, key):
        try:
            del self[key]
        except KeyError as k:
            raise AttributeError(k)

    def __repr__(self):
        return '<Storage ' + dict.__repr__(self) + '>'

from emcli import main

emcli.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

polysh

polysh运维工具，直接用pip安装即可，是一个交互式命令，可以批量对服务器进行处理。也就是说可以同时登陆多台服务器，并在各服务器上同时执行相同的操作。

polysh --ssh='exec ssh -p 22 -i ~/.ssh/id_rsa' --user=root --hosts-file=hosts.txt

fabric

fabric是对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 loaddata

5）shell_env设置Shell脚本的环境变量

with shell_env(ZMQ_DIR='/home/user/local'):
    run('pip install pyzmq')

相当于shell代码：

export ZMQ_DIR='/home/user/local' && pip install pyzmq

6）settings通用的设置，用于临时覆盖env变量

with settings(user='foo'):
    do something

7）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():
    pass

fabric执行模型

步骤：

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)

 一源码的方式在远程服务器上安装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
      - git

YMAL语法规则：

文件的第一行为'---'，表示这是一个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 version=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=lmx

palybook可以包含多个play，但是为了playbook的可读性和可维护性，我们一般会在一个playbook写一个play，如果我们在first_playbook.yml这个拆分成两个playbook，分别为web.yml和db.yml，当我们可以先执行db.yml,再执行web.yml，可以写一个all.yml   

---
-  include: db.yml
-  include: web.yml

include选项是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 == 5 

ignore_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-python

在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: epic

when选项可以与循环一起使用，以实现过滤的功能：

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选项。该选项值