Ansible之PythonDevops

目录

一、Ansible简介

什么是Ansible

Ansible的组成

Ansible特性

Ansible工作流程

二、Ansible安装

软件依赖关系（管理主机）

软件依赖关系（被托管主机）

Ansible安装方法一： yum 扩展源安装（推荐）

Ansible安装方法二：pip 方式安装

Ansible安装方法三：源码安装

三、Ansible模式之ad-hoc

什么是ad-hoc模式？

Ansible配置文件查找顺序

编辑hosts、ansible.cfg 配置文件

inventory 参数说明

自定义配置文件

动态主机

Json

脚本输出主机列表

脚本输出样例

四、Ansible批量执行管理

ansible命令基础

批量部署证书文件

模块

command模块：

shell | raw 模块

script模块

copy 模块

lineinfile | replace 模块 

yum模块

service模块

setup模块

 五、playbook剧本

什么是playbook模式？

为什么要使用playbook

playbook之Yaml语法基础

playbook 构成

配置VIM缩进为两个空格以便于编写Yaml

Playbook在web服务器上配置httpd，在数据库服务器上配置mariadb

Playbook实现免密登陆

六、Ansible编程

命名元组

ad-hoc模式

调用playbook

模块开发

模块库目录

模块执行流程

管道连接

ansible-cmdb

使用ansible-cmdb

---

一、Ansible简介

• 什么是Ansible

Ansible是2013年推出的一款IT自动化和DevOps软件，目前Redhat已签署Ansible收购协议。

Ansible是一个配置管理和配置工具，类似于Chef，Puppet或Salt。其是基于Python研发，糅合了很多老运维工具的优点实现了批量操作系统配置，批量程序的部署，批量运行命令等功能。

这是一款很简单也很容易入门的部署工具，它使用SSH连接到服务器并运行配置好的任务。服务器上不用安装任何多余的软件，只需要开启ssh，所有工作都交给client端的ansible负责。

• Ansible的组成

1. Ansible Playbooks：任务集，编排定义Ansible任务集的配置文件，由Ansible顺序依次执行，通常是json格式的YAML文件
2. Inventory：Ansible管理主机的清单
3. Modules：Ansible执行命令的功能模块，多数为内置的核心模块，也支持自定义
4. Plugins：模块功能的补充，如连接类型插件、循环插件、变量插件、过滤插件等，改功能不常用
5. API：供第三方程序调用的应用程序编程接口
6. Ansible：此处指的是组合nventory、Modules、Plugins、API的Ansible命令工具，其为核心执行工具

• Ansible特性

1. 基于python语言实现：
2. – paramiko
3. – PyYAML (半结构化语言)
4. – jinja2
5. 其模块支持JSON等标准输出格式，可采用任何编程语言重写
6. Ansible有两种模式，ad-hoc和playbook模式

• Ansible工作流程

上图展示了Ansible组建之间的调用关系，管理员通过使用Ad-Hoc或Ansible-playbooks时，在服务器终端输入Ansible的Ad-Hoc命令集或palybook后，Ansible会遵循预先编排的规则将Playbooks逐条拆解为Play，再将paly组织成Ansible可识别的任务（Task），随后调用任务涉及的所有模块（modules）和插件（plugins），根据Inventory中定义的主机列表通过SSH将任务集以临时文件或命令的形式传输到远程客户端执行并返回执行结果，如果是临时文件，则执行完毕后自动删除。

二、Ansible安装

• 软件依赖关系（管理主机）

1. 要求有Python 2.6 或 Python 2.7环境
2. ansible 使用了以下模块,都需要安装：
3. paramiko
4. PyYAML
5. Jinja2
6. httplib2
7. six

• 软件依赖关系（被托管主机）

1. Ansible默认通过 SSH 协议管理机器，被管理主机要开启 ssh 服务，允许 ansible 主机登陆
2. 在托管节点上也需要安装 Python 2.5 或以上的版本
3. 如果托管节点上开启了Selinux，需要安装libselinux-python

• Ansible安装方法一： yum 扩展源安装（推荐）

1. – http://mirror.centos.org/.../.../extras/
2. – yum -y install ansible
3. 安装完成以后验证
4. – ansible --version

• Ansible安装方法二：pip 方式安装

1. ansible 源码下载
2. – git clone git://github.com/ansible/ansible.git
3. – yum install python-setuptools python-devel
4. – python setup.py build
5. – python setup.py install
6. pip 方式安装
7. – pip install ansible

• Ansible安装方法三：源码安装

1. – pip，需要配置扩展镜像软件包源 extras
2. – git
3. yum install epel-release
4. yum install git python2-pip
5. – pip安装依赖模块
6. pip install paramiko PyYAML Jinja2 httplib2 six

三、Ansible模式之ad-hoc

• 什么是ad-hoc模式？

ad-hoc简而言之，就是"临时命令"，一般用来做一些一次性的工作，比如说在多台机器上，查看某个进程是否启动，开一个服务。ad-hoc模式使用单个模块，支持批量执行单条命令。ad-hoc命令是一种可以快速输入的命令，而且不需要保存起来的命令，相当于bash中的一句shell。

• Ansible配置文件查找顺序

1. – 首先检测 ANSIBLE_CONFIG 变量定义的配置文件
2. – 其次检查当前目录下的 ./ansible.cfg 文件
3. – 再次检查当前用户家目录下 ~/ansible.cfg 文件
4. – 最后检查默认配置文件 /etc/ansible/ansible.cfg

• 编辑hosts、ansible.cfg 配置文件

1. 首先编辑 /etc/ansible/hosts 文件，写入主机的地址。
2. 格式：
3. [组名称]
4. 主机名称或者ip地址，登录用户名，密码、端口等信息
5. 测试
6. – ansible [组名称] --list-hosts

• inventory 参数说明

1. – ansible_ssh_host     //– 将要连接的主机名。
2. – ansible_ssh_port    //ssh端口号
3. – ansible_ssh_user    //默认的 ssh 用户名
4. – ansible_ssh_pass    //ssh 密码(这种方式并不安全,我们强烈建议使用 --ask-pass 或 SSH 密钥)
5. – ansible_sudo_pass    //sudo 密码(建议使用 --ask-sudo-pass)
6. – ansible_sudo_exe (new in version 1.8)    //sudo 命令路径(适用于1.8及以上版本)
7. – ansible_connection    //不主机的连接类型，比如:local, ssh 或者paramiko。Ansible 1.2 以前默认使用 paramiko.1.2 以后默认使用 'smart','smart' 方式会根据是否支持ControlPersist, 来判断'ssh' 方式是否可行
8. – ansible_ssh_private_key_file    //ssh 使用的私钥文件。适用于有多个密钥,而你不想使用SSH 代理的情况
9. – ansible_shell_type    //目标系统的shell类型.默认情况下，命令的执行使用 'sh'语法，可设置为 'csh' 或 其他
10. – ansible_python_interpreter    //目标主机的 python 路径。适用的情况: 系统中有多个Python, 或者命令路径不是"/usr/bin/python"

• 自定义配置文件

1. – 创建文件夹 myansible
2. – 创建配置文件 ansible.cfg
3. [defaults]
4. inventory = myhost
5. – 配置主机文件myhosts
6. [nginx]
7. [web]
8. web[1:2]
9. [web:vars]
10. ansible_ssh_user="root"
11. ansible_ssh_pass="pwd"
12. ansible_ssh_port="22"
13. [cache]
14. 192.168.1.66  ansible_ssh_user="root" ansible_ssh_pass="pwd"
15. – ansible nginx --list-hosts

• 动态主机

Ansible Inventory实际上是包含静态Inventory和劢态Inventory两部分，静态Inventory指的是在文件/etc/ansible/hosts中指定的主机和组，DynamicInventory指通过外部脚本获取主机列表，并按照ansible 所要求的格式返回给ansilbe命令。

注意事项: 

1、主机部分必须是列表格式的
             2、hostdata行，其中的"hosts" 部分可以省略，但如果使用时，必须是"hosts"

• Json

JSON的全称是”JavaScript Object Notation”，意思是JavaScript对象表示法，它是一种基于文本，独立于语言的轻量级数据交换格式。 JSON中的分隔符限于单引号 ' 、小括号 ()、中括号[ ]、大括号 { } 、冒号 ：和逗号 ，。

• 脚本输出主机列表

#!/usr/bin/python
import json
hostlist = {}
hostlist["bb"] = ["192.168.1.15", "192.168.1.16"]
hostlist["192.168.1.13"] = {
    "ansible_ssh_user":"root","ansible_ssh_pass":"pwd"
}
hostlist["aa"] = {
    "hosts" : ["192.168.1.11", "192.168.1.12"],
    "vars" : {
        "ansible_ssh_user":"root","ansible_ssh_pass":"pwd"
        }
}
print( json.dumps(hostlist))

• 脚本输出样例

{
"aa" : {
    "hosts" : ["192.168.1.11", "192.168.1.12"],
    "vars" : {
            "ansible_ssh_user" : "root",
            "ansible_ssh_pass" : "pwd"
            }
},
"bb" : ["192.168.1.15", "192.168.1.16"],
"192.168.1.13": { 
            "ansible_ssh_user" : "root",
            "ansible_ssh_pass" : "pwd"}
}    

四、Ansible批量执行管理

• ansible命令基础

1. ansible [options]
2. – -M    //指定模块路径
3. – -m    //指定使用模块，不指定时默认 command 模块
4. – -a     //or --args 模块参数
5. – -i     //inventory 文件路径，或者可执行脚本
6. – -k    //使用交互式登陆密码
7. – -e    //定义变量
8. – -v    //详绅信息,-vvvv 开启debug 模式
9. – ansible all --list-hosts    //列出要执行的主机列表，不执行任何操作
10. – ansible all -m ping    //批量检测主机
11. – ansible all -m command -a 'id' -k    //批量执行命令

• 批量部署证书文件

每次交互输入密码比较麻烦，密码写入配置文件安全性很差，不同主机不同密码，使用key方式认证，是一个不错的选择，给所有主机部署公钥：

• – ansible all -m authorized_key -a "user=root exclusive=true manage_dir=true key='$(

 如果报错：– "msg": "Using a SSH password instead of a key isnot possible because Host Key checking is
enabled and sshpass does not support this.Please add this host's fingerprint to your known_hosts file to manage this host."

– 解决方法:

– 修改 ansible.cfg

host_key_checking = False

• 模块

1. ansible-doc    //模块的手册，相当不 shell 的 man
2. – ansible-doc -l    //列出所有模块
3. – ansible-doc modulename 查看帮助
4. ping 模块
5. – 测试网络连通性, ping模块没有参数
6. – 注：测试 ssh 的连通性
7. – ansible host-pattern -m ping

• command模块：

1. – 该模块为默认模块，通过-a跟上要执行的命令可以直接执行，不过命令里如果有带有如下字符部分则执行不成功
2. – "<", ">", "|", "&"
3. – 该模块不启动 shell 直接在 ssh 进程中执行，所有使用到 shell 特性的命令执行都会失败
4. – 下列命令执行会失败
5. ansible all -m command -a 'ps aux|grep ssh'
6. ansible all -m command -a 'set'

• shell | raw 模块

1. – shell 模块用法基本和command一样，区别是 shell模块是通过/bin/sh迚行执行命令，可以执行任意命令
2. – raw模块，用法和shell 模块一样 ,可以执行任意命令
3. – 区别是 raw 没有chdir、creates、removes参数
4. – 执行以下命令查看结果
5. ansible web -m command -a 'chdir=/tmp touch f1'
6. ansible web -m shell -a 'chdir=/tmp touch f2'
7. ansible web -m raw -a 'chdir=/tmp touch f3'

• script模块

1. ansible web -m script -a 'usrscript'  //该脚本包含但不限亍于shell 脚本，只要指定 Sha-bang 解释器的脚本都可运行

• copy 模块

1. – 复制文件到进程主机
2. – src:要复制到进程主机的文件在本地的地址,可以是绝对路径,也可以是相对路径。如果路径是一个目录，它将递归复制。在这种情况下,如果路径使用"/"来结尾，则只复制目录里的内容,如果没有使用"/"来结尾，则包含目录在内的整个内容全部复制，类似于rsync
3. – dest:必选项。进程主机的绝对路径,如果源文件是一个目录，那么该路径也必须是个目录
4. – backup:在覆盖之前将原文件备份，备份文件包含时间信息。有两个选项:yes|no
5. – force:如果目标主机包含该文件，但内容不同,如果设置为yes，则强制覆盖，如果为no，则只有当目标主机的目标位置不存在该文件时,才复制。默认为yes
6. – 复制文件
7. ansible t1 -m copy -a 'src=/root/alog dest=/root/a.log'
8. – 复制目录
9. ansible t1 -m copy -a 'src=urdir dest=/root/'

• lineinfile | replace 模块 

1. – 类似 sed 的一种行编辑替换模块
2. – path    //目的文件
3. – regexp    //正则表达式
4. – line    //替换后的结果
5. ansible web -m lineinfile -a 'path="/etc/selinux/config" regexp="^SELINUX=" line="SELINUX=disabled"'
6. – 替换指定字符
7. ansible web -m replace -a 'path="/etc/selinux/config" regexp="^(SELINUX=).*" replace="\1disabled"'

• yum模块

1. – 使用yum包管理器来管理软件包
2. – config_file:    //yum的配置文件
3. – disable_gpg_check:    //关闭gpg_check
4. – disablerepo:    //不启用某个源
5. – enablerepo:    //启用某个源
6. – name:    //要进行操作的软件包的名字，也可以传递一个url或者一个本地的rpm包的路径
7. – state:    //状态(present，absent，latest)
8. – 删除软件包
9. ansible web -m yum -a 'name="lrzsz" state=absent'
10. – 删除多个软件包
11. ansible web -m yum -a 'name="lrzsz,lftp" state=absent'
12. – 安装软件包
13. ansible web -m yum -a 'name="lrzsz"'
14. – 安装多个软件包
15. ansible web -m yum -a 'name="lrzsz,lftp"'

• service模块

1. – name:    //必选项,服务名称
2. – enabled:    //是否开机自启动 yes|no
3. – sleep:    //如果执行了restarted，在则stop和start之间沉睡几秒钟
4. – state:    //对当前服务执行吭劢,停止、重启、重新加载等操作(started,stopped,restarted,reloaded)
5. ansible t1 -m service -a 'name="sshd" enabled="yes" state="started"'

• setup模块

1. – 主要用于获取主机信息，在playbooks里经常会用到的一个参数gather_facts就不该模块相关。setup模块下经常使用的一个参数是filter参数
2. – filter 可以过滤到我们需要的信息
3. ansible t1 -m setup -a 'filter=ansible_distribution'

 五、playbook剧本

• 什么是playbook模式？

playbook模式是ansible主要管理方式，也是ansible功能强大的关键所在。Playbooks的格式是YAML语言格式，使用 YAML 是因为它像 XML 或 JSON 是一种利于人们读写的数据格式。

playbook通过多个task集合完成一类功能，如LAMP服务的安装部署、数据库服务器的批量备份等。可以简单地把playbook理解为通过组合多条ad-hoc操作的配置文件。Playbooks可以被描述为一个需要希望远程主机执行命令的方案，或者一组程序运行的命令集合，Playbook由一到多个Play组成，每个play可以指定哪些主机执行哪些任务，执行任务一般通过调用模块来实现。

• 为什么要使用playbook

执行一些简单的任务，使用ad-hoc命令可以方便的解决问题，但是有时一个设施过于复杂，需要大量的操作时候，执行的 ad-hoc 命令是不适合的，这时最好使用playbook,就像执行 shell 命令与写 shell 脚本一样，也可以理解为批处理任务。使用 playbook 你可以方便的重用编写的代码，可以移植到不同的机器上面，像函数一样，最大化的利用代码在使用 Ansible 的过程中，你也会发现，你所处理的大部分操作都是编写 playbook。 

• playbook之Yaml语法基础

1. – playbook由 YAML 语言编写,遵循 YAML 标准
2. – 在同一行中，#之后的内容表示注释
3. – 同一个列表中的元素应该保持相同的缩进，并且使用一个 "- " 作为开头(后面必须有一个空格)
4. – 列表中的每一项都是一个键值对, 通常它们被称为一个"哈希"或"字典"
5. – playbook 由一个或多个 play 组成
6. – play 中 hosts，variables，roles，tasks 等对象的表示方法都是键值中间以 ": " 分隔表示（后面必须有一个空格）
7. – 所有的 YAML 文件开始行都应该是 --- 这是 YAML 格式的一部分， 表明一个文件的开始 

• playbook 构成

1. – hosts:     定义将要执行 playbook 的远程主机组
2. – Vars:     定义 playbook 运行时需要使用的变量
3. – tasks： 定义将要在远程主机上执行的任务列表，每一个 play 包含了一个 task 列表(任务列表)
   – 一个 task 在其所对应的所有主机上(通过 hostpattern 匹配的所有主机)执行完毕之后，下一个 task才会执行
   – 有一点需要明白的是(很重要),在一个 play 之中，所有 hosts 会获取相同的任务指令,这是 play 的一个目的所在，也就是将一组选出的 hosts 映射到 task，执行相同的操作
4. – Handler:     定义 task 执行完成以后需要调用的任务

• 配置VIM缩进为两个空格以便于编写Yaml

1. vim  ~/.vimrc   

set ai
set ts=4
set et
autocmd FileType yaml setlocal sw=2 ts=2 et ai

• Playbook在web服务器上配置httpd，在数据库服务器上配置mariadb

---
- name: configure web service
  hosts: webservers
  tasks:
    - name: install web app
      yum:
        name: "{{item}}"
        state: present
      with_items:
        - httpd
        - php
        - php-mysql
    - name: config web service
      service:
        name: httpd
        state: started
        enabled: true

- name: configure db service
  hosts: dbservers
  tasks:
    - name: install db app
      yum:
        name: mariadb-server
        state: latest
    - name: config db service
      service:
        name: mariadb
        state: started
        enabled: yes

• Playbook实现免密登陆

1. ansible-doc authorized_key
2. vim auth_key.yml
3. ansible-playbook --syntax-check auth_key.yml
4. ansible-playbook auth_key.yml -k
5. ansible all -m ping

---
- name: configure authorized key
  hosts: all
  tasks:
  - name: root key
    authorized_key:
      user: root
      state: present
      key: "{{ lookup('file', '/root/.ssh/id_rsa.pub') }}"

六、Ansible编程

• 命名元组

https://docs.ansible.com/ansible/latest/index.html，按ctrl+f，搜索api，找到python api

命名元组与普通元组一样，有相同的表现特征，其添加的功能就是可以根据名称引用元组中的项。collections 模块提供了namedtuple()函数，用于创建自定义的元组数据类型

1. >>> from    collec]ons    import    namedtuple    
2. >>> user = namedtuple('user',    ['name',    'age'])    
3. >>> bob = user('Bob  Green',    23)    
4. >>> bob[0]    
5. 'Bob  Green'    
6. >>> bob[1]    
7. 23    
8. >>> bob.name    
9. 'Bob  Green'   

• ad-hoc模式

使用、创建TaskQueueManager实例，用于管理子进程、通过主机列表和任务建立对象。TaskQueueManager需要主机清单参数、主机变量参数、连接选项等。

#!/usr/bin/env python
# coding: utf8

import shutil
from collections import namedtuple
# DataLoader用于解析yaml/json/ini文件
from ansible.parsing.dataloader import DataLoader
# VariableManager用于分析ansible用到的变量
from ansible.vars.manager import VariableManager
# InventoryManager用于分析主机文件
from ansible.inventory.manager import InventoryManager
from ansible.playbook.play import Play
# task_queue_manager管理任务队列
from ansible.executor.task_queue_manager import TaskQueueManager
import ansible.constants as C  # ansible的常量（不会变化的数据）

# since API is constructed for CLI it expects certain options to always be set, named tuple 'fakes' the args parsing options object
Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'become', 'become_method', 'become_user', 'check', 'diff'])
# connection有三个选择local/ssh/smart
# local表示在本机执行，ssh表示通过ssh协议执行，smart表示自动选择
options = Options(connection='smart', module_path=['/to/mymodules'], forks=10, become=None, become_method=None, become_user=None, check=False, diff=False)

# initialize needed objects
loader = DataLoader()  # Takes care of finding and reading yaml, json and ini files
passwords = dict()  # 用于存储加密密码、远程连接密码等

# create inventory, use path to host config file as source or hosts in a comma separated string
# 声明被ansible管理的主机有哪些，可以把各主机用逗号分开形成字符串
# 也可以使用主机清单文件路径，将路径放到列表中
# inventory = InventoryManager(loader=loader, sources='localhost,')
inventory = InventoryManager(loader=loader, sources=['myansi/hosts'])

# variable manager takes care of merging all the different sources to give you a unifed view of variables available in each context
variable_manager = VariableManager(loader=loader, inventory=inventory)

# create datastructure that represents our play, including tasks, this is basically what our YAML loader does internally.
play_source = dict(
        name="Ansible Play",  # Play名称
        # hosts='localhost',  # 在哪些主机上执行命令
        hosts='webservers',  # 在哪些主机上执行命令
        gather_facts='no',  # 不收集主机信息
        tasks=[
            # 以下是执行的命令
            # dict(action=dict(module='shell', args='ls'), register='shell_out'),
            # dict(action=dict(module='debug', args=dict(msg='{{shell_out.stdout}}'))),
            # dict(action=dict(module='yum', args='name=httpd state=absent'), register='shell_out'),
            dict(action=dict(module='yum', args='name=httpd state=latest'), register='shell_out'),
            dict(action=dict(module='debug', args=dict(msg='{{shell_out}}')))
         ]
    )

# Create play object, playbook objects use .load instead of init or new methods,
# this will also automatically create the task objects from the info provided in play_source
play = Play().load(play_source, variable_manager=variable_manager, loader=loader)

# Run it - instantiate task queue manager, which takes care of forking and setting up all objects to iterate over host list and tasks
tqm = None
try:
    tqm = TaskQueueManager(
              inventory=inventory,
              variable_manager=variable_manager,
              loader=loader,
              options=options,
              passwords=passwords,
          )
    result = tqm.run(play) # most interesting data for a play is actually sent to the callback's methods
finally:
    # we always need to cleanup child procs and the structres we use to communicate with them
    if tqm is not None:
        tqm.cleanup()

    # Remove ansible tmpdir
    shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)

• 调用playbook

Playbook 是 Ansible的配置、部署、编排语言，它们可以被描述为一个需要希望远程主机执行命令的方案或者一组IT程序运行的命令集合，可以通过python编程的方式执行playbook。

from collections import namedtuple
from ansible.parsing.dataloader import DataLoader
from ansible.vars.manager import VariableManager
from ansible.inventory.manager import InventoryManager
from ansible.executor.playbook_executor import PlaybookExecutor

Options = namedtuple(
    'Options',
    [
        'connection',
        'remote_user',
        'ask_sudo_pass',
        'verbosity',
        'ask_pass',
        'module_path',
        'forks',
        'become',
        'become_method',
        'become_user',
        'check',
        'listhosts',
        'listtasks',
        'listtags',
        'syntax',
        'sudo_user',
        'sudo',
        'diff'
    ]
)

ops = Options(
    connection='smart',
    remote_user=None,
    ask_pass=None,
    sudo_user=None,
    forks=5,
    sudo=None,
    ask_sudo_pass=False,
    verbosity=5,
    module_path=None,
    become=None,
    become_method=None,
    become_user=None,
    check=False,
    diff=False,
    listhosts=None,
    listtags=None,
    listtasks=None,
    syntax=None
)
loader = DataLoader()
passwords = dict()
inventory = InventoryManager(
    loader=loader,
    sources=['myansi/hosts']
)
variable_manager = VariableManager(
    loader=loader,
    inventory=inventory
)

def run_pb(pb_path):
    playbook = PlaybookExecutor(
        playbooks=pb_path,
        inventory=inventory,
        variable_manager=variable_manager,
        loader=loader,
        options=ops,
        passwords=passwords
    )
    result = playbook.run()
    return result

if __name__ == '__main__':
    run_pb(pb_path=['myansi/lamp.yml'])

• 模块开发

Ansible官方已经提供了大量模块,在编写模块之前,可以查看是否已有现成模块

•  官方已发布模块

–  http://docs.ansible.com/ansible/modules.html

•  官方正在开发的模块

–  https://github.com/ansible/ansible/labels/module

• 模块库目录

可以使用 ANSIBLE_LIBRARY环境变量来指定模块的存放位置，也可以在playbook当前目录下创建library目录

1. mkdir mylib
2. export ANSIBLE_LIBRARY=$(pwd)/mylib

创建模块，模块用于拷贝目标主机文件到目标主机的指定目录

#!/usr/bin/env python
import shutil
from ansible.module_utils.basic import AnsibleModule


def main():
    module = AnsibleModule(
        argument_spec=dict(
            src=dict(required=True, type='str'),
            dest=dict(required=True, type='str')
        )
    )
    shutil.copy(module.params['src'], module.params['dest'])
    module.exit_json(change=True)


if __name__ == '__main__':
    main()

 验证：ansible web -m rcopy -a "src=/etc/hosts dest=/opt"

• 模块执行流程

1. 将模块文件读入内存，然后添加传递给模块的参数，最后将模块中所需要的类添加到内存，由zipfile压缩后，再由base64进行编码，写入到模板文件内
2. 通过默认的连接方式(一般是ssh),ansible连接到远程主机,创建临时目录,并关闭连接
3. 打开另外一个ssh连接,将模板文件以sftp方式传送到刚刚创建的临时目录中,写完后关闭连接
4. 打开一个ssh连接将任务对象赋予可执行权限，执行成功后关闭连接
5. 最后，ansible将再打开一个新连接来执行模块，并删除临时目录及其所有内容
6. 模块的结果是从标准输出stdout中获取json格式的字符串，ansible将解析和处理此字符串

• 管道连接

使用了管道连接后,与远程主机只有一个连接,命令通过数据流的方式发送执行，此模式与有些系统程序兼容不太好，配置方式:

1. vim /etc/ansible/ansible.cfg        
2. pipelining = True   

• ansible-cmdb

1. 安装# pip2 install ansible-cmdb
2. 如果pip没有python2版本，那么http://pypi.python.org搜索ansible-cmdb，然后下载tar包
3. # tar xzf ansible-cmdb.xxxxx.tar.gz
4. # cd ansible-cmdb
5. # python setup.py install

• 使用ansible-cmdb

1. 将所有主机的信息用setup模块收集，并放到out目录中
2. ansible all -m setup --tree out/
3. 根据out目录中收集到的信息，生成网页
4. ansible-cmdb out/ > overview.html
5. firefox overview.html