自动化运维工具---Ansible 企业实战详解！！！

一、ansible 简介

1、ansible 是什么？

        ansible是基于 python 开发的,并且基于模块化工作，本身没有批量部署的能力。真正具有批量部署的是ansible所运行的模块，ansible只是提供一种框架。ansible不需要在远程主机上安装client/agents，因为它们是基于ssh来和远程主机通讯的。ansible目前已经已经被红帽官方收购，是自动化运维工具中大家认可度最高的，并且上手容易，学习简单。是每位运维工程师必须掌握的技能之一。

2、ansible 特点

        1. 部署简单，只需在主控端部署Ansible环境，被控端无需做任何操作；
        2. 默认使用SSH协议对设备进行管理；
        3. 有大量常规运维操作模块，可实现日常绝大部分操作；
        4. 配置简单、功能强大、扩展性强；
        5. 支持API及自定义模块，可通过Python轻松扩展；
        6. 通过Playbooks来定制强大的配置、状态管理；
        7. 轻量级，无需在客户端安装agent，更新时，只需在操作机上进行一次更新即

3、ansible 架构图

主要模块如下：

        Ansible：Ansible核心程序。
        HostInventory：记录由Ansible管理的主机信息，包括端口、密码、ip等。
        Playbooks：“剧本”YAML格式文件，多个任务定义在一个文件中，定义主机需要调用哪些模块来完成的功能。

        CoreModules：核心模块，主要操作是通过调用核心模块来完成管理任务。
        CustomModules：自定义模块，完成核心模块无法完成的功能，支持多种语言。
        ConnectionPlugins：连接插件，Ansible和Host通信使用

4、自动化运维工具对比

        1.Puppet:基于 Ruby 开发,采用 C/S 架构,扩展性强,基于SSL,远程命令执行相对较弱；
        2.SaltStack:基于 Python 开发,采用 C/S 架构,相对 puppet 更轻量级,配置语法使用YAML,使得配置脚本更简单.需要配置客户端以及服务器端。每台被控制节点需要安装agent；
        3.Ansible:基于Python开发,分布式,无需客户端,轻量级,配置语法使用YAML语言,更强的远程命令执行操作；

二、ansible 任务执行

1、ansible 任务执行模式

Ansible 系统由控制主机对被管节点的操作方式可分为三类，即ad-hoc、playbook和role：

• ad-hoc模式(点对点模式) 使用单个模块，支持批量执行单条命令。ad-hoc 命令是一种可以快速输入的命令，而且不需要保存起来的命令。就相当于bash中的一句话shell。

• playbook模式(剧本模式) 是Ansible主要管理方式，也是Ansible功能强大的关键所在。playbook通过多个task集合完成一类功能，如Web服务的安装部署、数据库服务器的批量备份等。可以简单地把playbook理解为通过组合多条ad-hoc操作的配置文件。 类似于shell脚本，可以进行多个步骤。

• role模式(角色模式) 类似于多个脚本导入

2、ansible 命令执行过程

1. 加载自己的配置文件，默认/etc/ansible/ansible.cfg；

2. 查找对应的主机配置文件，找到要执行的主机或者组；

3. 加载自己对应的模块文件，如 command；

4. 通过ansible将模块或命令生成对应的临时py文件(python脚本)， 并将该文件传输至远程服务器；

5. 对应执行用户的家目录的.ansible/tmp/XXX/XXX.PY文件；

6. 给文件 +x 执行权限；

7. 执行并返回结果；

8. 删除临时py文件，sleep 0退出；

三、ansible 配置详解

1、ansible 安装方式

        ansible安装常用两种方式，yum 安装 和 pip 程序安装。

2、使用 yum 安装

        yum 安装是我们很熟悉的安装方式了。我们需要先安装一个epel-release包，然后再安装我们的 ansible 即可。

     yum install -y epel-release
     yum install -y ansible

3、ansible 程序结构

        安装目录如下(yum安装)： 　

                配置文件目录：/etc/ansible/ 　　

                执行文件目录：/usr/bin/ 　　

                Lib库依赖目录：/usr/lib/pythonX.X/site-packages/ansible/ 　　

                Help文档目录：/usr/share/doc/ansible-X.X.X/ 　　

                Man文档目录：/usr/share/man/man1/

4、ansible配置文件

        ansible 的配置文件为/etc/ansible/ansible.cfg，ansible 有许多参数，下面我们列出一些常见的参数：

    inventory = /etc/ansible/hosts      #这个参数表示资源清单inventory文件的位置
    library = /usr/share/ansible          #指向存放Ansible模块的目录，支持多个目录方式，只要用冒号（：）隔开就可以
    forks = 5                                       #并发连接数，默认为5
    sudo_user = root                         #设置默认执行命令的用户
    remote_port = 22                         #指定连接被管节点的管理端口，默认为22端口，建议修改，能够更加安全
    host_key_checking = False         #设置是否检查SSH主机的密钥，值为True/False。关闭后第一次连接不会提示配置实例
    timeout = 60                                 #设置SSH连接的超时时间，单位为秒

    log_path = /var/log/ansible.log     #指定一个存储ansible日志的文件（默认不记录日志）

5、ansible主机清单

        在配置文件中，我们提到了资源清单，这个清单就是我们的主机清单，里面保存的是一些 ansible 需要连接管理的主机列表。我们可以来看看他的定义方式：

ansible-web1                        #单独指定主机，可以使用主机名称或IP地址
2.添加主机组：
[websrvs]                        #使用[]标签指定主机组 ----标签自定义
192.168.146.131                      #如果未解析添加ip
ansible-web2                        #解析添加主机名
3.组可以包含其他组：
[websrvs1]                       #组一
ansible-web1
[websrvs2]                       #组二
ansible-web2
[weball:children]                    #children-照写 #weball包括两个子组
websrvs1                         #组一
websrvs2                        #组二
4.为一个组指定变量，组内每个主机都可以使用该变量：
[weball:vars]                         #设置变量,vars--照写
ansible_ssh_port=22     
ansible_ssh_user=root   
#ansible_ssh_private_key_file=/root/.ssh/id_rsa  
ansible_ssh_pass=test       #也可以定义密码，如果没有互传秘钥可以使用密码。

        需要注意的是，这里的组成员可以使用通配符来匹配，这样对于一些标准化的管理来说就很轻松方便了。 我们可以根据实际情况来配置我们的主机列表，具体操作如下：

[root@reece ~]# vim /etc/ansible/hosts   
         [web]    
        192.168.146.131    

四、ansible 常用命令

1、ansible 命令集

/usr/bin/ansible　　                Ansibe AD-Hoc 临时命令执行工具，常用于临时命令的执行

/usr/bin/ansible-doc 　　        Ansible 模块功能查看工具

/usr/bin/ansible-galaxy　　    下载/上传优秀代码或Roles模块 的官网平台，基于网络的

/usr/bin/ansible-playbook　　 Ansible 定制自动化的任务集编排工具

/usr/bin/ansible-pull　　        Ansible远程执行命令的工具，拉取配置而非推送配置（使用较少，海量机器时使用，对运维的架构能力要求较高）

/usr/bin/ansible-vault　　       Ansible 文件加密工具

/usr/bin/ansible-console　　   Ansible基于Linux Console界面可与用户交互的命令执行工具

        其中，我们比较常用的是/usr/bin/ansible和/usr/bin/ansible-playbook、/usr/bin/ansible-galaxy。

2、ansible-doc 命令

        ansible-doc 命令常用于获取模块信息及其使用帮助，一般用法如下：

    ansible-doc -l              #获取全部模块的信息
    ansible-doc -s MOD_NAME     #获取指定模块的使用帮助

        我们也可以查看一下ansible-doc的全部用法：

[root@reece ~]# ansible-doc
Usage: ansible-doc [options] [module...]

Options:
  -h, --help            show this help message and exit　　# 显示命令参数API文档
  -l, --list            List available modules　　#列出可用的模块
  -M MODULE_PATH, --module-path=MODULE_PATH　　#指定模块的路径
                        specify path(s) to module library (default=None)
  -s, --snippet         Show playbook snippet for specified module(s)　　#显示playbook制定模块的用法
  -v, --verbose         verbose mode (-vvv for more, -vvvv to enable　　# 显示ansible-doc的版本号查看模块列表：
                        connection debugging)
  --version             show program's version number and exit	

        我们可以来看一下，以mysql相关的为例：

[root@reece ~]# ansible-doc -l | grep mysql
mysql_db                           Add or remove MySQL databases from a remote...
mysql_replication                  Manage MySQL replication                   
mysql_user                         Adds or removes a user from a MySQL databas...
mysql_variables                    Manage MySQL global variables    

3、ansible 命令详解

        命令的具体格式如下：

ansible <host-pattern> [-f forks] [-m module_name] [-a args]
ansible 主机清单中的主机组 -f 开启线程数 -m 模块 -a 模块需要的参数

        也可以通过ansible -h来查看帮助，下面我们列出一些比较常用的选项，并解释其含义：

-a MODULE_ARGS      #模块的参数，如果执行默认COMMAND的模块，即是命令参数，如： “date”，“pwd”等等
-k，--ask-pass      #ask for SSH password。登录密码，提示输入SSH密码而不是假设基于密钥的验证
--ask-su-pass       #ask for su password。su切换密码
-K，--ask-sudo-pass #ask for sudo password。提示密码使用sudo，sudo表示提权操作
--ask-vault-pass    #ask for vault password。假设我们设定了加密的密码，则用该选项进行访问
-B SECONDS          #后台运行超时时间
-C                  #模拟运行环境并进行预运行，可以进行查错测试
-c CONNECTION       #连接类型使用
-f FORKS            #并行任务数，默认为5
-i INVENTORY        #指定主机清单的路径，默认为/etc/ansible/hosts
--list-hosts        #查看有哪些主机
-m MODULE_NAME      #执行模块的名字，默认使用command 模块，所以如果是只执行单一命令可以不用-m参数
-o                  #压缩输出，尝试将所有结果在一行输出，一般针对收集工具使用
-s                  #用 sudo 命令
-U SUDO_USER        #指定 sudo 到哪个用户，默认为 root 用户
-T TIMEOUT          #指定 ssh 默认超时时间，默认为10s，也可在配置文件中修改
-u REMOTE_USER      #远程用户，默认为 root 用户
-v                  #查看详细信息，同时支持-vvv，-vvvv可查看更详细信息

3、ansible 配置公私钥

        上面我们已经提到过 ansible 是基于 ssh 协议实现的，所以其配置公私钥的方式与 ssh 协议的方式相同，具体操作步骤如下：

#1.生成私钥
[root@reece ~]# ssh-keygen 
#2.向主机分发私钥
[root@reece ~]# ssh-copy-id root@192.168.146.131

        这样的话，就可以实现无密码登录，我们的实验过程也会顺畅很多。 　　

        注意，如果出现了以下报错：

  -bash: ssh-copy-id: command not found

        那么就代表我们需要安装一个包：

        把包安装上即可。

        注：如果提示ansible不支持用户密码，把该注释打开 host_key_checking = False

五、ansible 常用模块

1、主机连通性测试（ping 模块）

        我们使用ansible web -m ping命令来进行主机连通性测试，效果如下：

[root@reece ~]# ansible web -m ping
192.168.146.131 | SUCCESS => {
    "changed": false, 
    "ping": "pong"
}

        这样就说明我们的主机是连通状态的。接下来的操作才可以正常进行。

2、command 模块

        这个模块可以直接在远程主机上执行命令，并将结果返回本主机。 　　

        举例如下：

[root@reece ~]# ansible web -m command -a 'ss -ntl'
192.168.146.131 | SUCCESS | rc=0 >>
State      Recv-Q Send-Q Local Address:Port               Peer Address:Port              
LISTEN     0      128          *:111                      *:*                  
LISTEN     0      5      192.168.146.1:53                       *:*                  
LISTEN     0      128          *:22                       *:*                  
LISTEN     0      128    127.0.0.1:631                      *:*                  
LISTEN     0      128          *:23000                    *:*                  
LISTEN     0      100    127.0.0.1:25                       *:*                  
LISTEN     0      128         :::111                     :::*                  
LISTEN     0      128         :::22                      :::*                  
LISTEN     0      128        ::1:631                     :::*                  
LISTEN     0      100        ::1:25                      :::*     

        注意，该命令不支持| 管道命令 不支持> >>重定向符号、&。 　　

        下面来看一看该模块下常用的几个命令：

chdir                    # 在执行命令之前，先切换到该目录

executable          # 切换shell来执行命令，需要使用命令的绝对路径

free_form            # 要执行的Linux指令，一般使用Ansible的-a参数代替。

creates                # 一个文件名，当这个文件存在，则该命令不执行,可以用来做判断

removes              # 一个文件名，这个文件不存在，则该命令不执行

        下面我们来看看这些命令的执行效果：

[root@reece ~]# ansible web -m command -a 'chdir=/data/ ls'  #先切换到/data/ 目录，再执行“ls”命令
192.168.146.131 | SUCCESS | rc=0 >>
webapp.jpg
csdn
web

3、shell 模块

        shell模块可以在远程主机上调用shell解释器运行命令，支持shell的各种功能，例如管道等。

[root@reece ~]# ansible web -m shell -a 'cat /etc/passwd |grep "keer"'
192.168.146.131 | SUCCESS | rc=0 >>
keer:x:10001:1000:keer:/home/keer:/bin/sh

        只要是我们的shell命令，都可以通过这个模块在远程主机上运行，这里就不一一举例了。

4、file 模块

该模块主要用于设置文件的属性，比如创建文件、创建链接文件、删除文件等。 　　下面是一些常见的命令：

force　　          #需要在两种情况下强制创建软链接，一种是源文件不存在，但之后会建立的情况下；另一种是目标软链接已存在，需要先取消之前的软链，然后创建新的软链，有两个选项：yes|no

group　　          #定义文件/目录的属组。后面可以加上

mode：                #定义文件/目录的权限

owner　　           #定义文件/目录的属主。后面必须跟上

path：                #定义文件/目录的路径

recurse　　       #递归设置文件的属性，只对目录有效，后面跟上

src：                  #被链接的源文件路径，只应用于state=link的情况

dest　　            #被链接到的路径，只应用于state=link的情况

state　　            #状态，有以下选项：

directory：        #如果目录不存在，就创建目录

link：                #创建软链接

hard：                #创建硬链接

touch：               #如果文件不存在，则会创建一个新的文件，如果文件或目录已存在，则更新其最后修改时间

absent：              #删除目录、文件或者取消链接文件

用法举例如下： 创建目录：

[root@server ~]# ansible web -m file -a 'path=/data/app state=directory'
192.168.146.131 | SUCCESS => {
    "changed": true, 
    "gid": 0, 
    "group": "root", 
    "mode": "0755", 
    "owner": "root", 
    "path": "/data/app", 
    "size": 6, 
    "state": "directory", 
    "uid": 0
}

        我们可以查看一下：

[root@reece ~]# ansible web -m shell -a 'ls -l /data'
192.168.146.131 | SUCCESS | rc=0 >>
total 28
drwxr-xr-x   2 root root    6 Dec  6 10:21 app

        可以看出，我们的目录已经创建完成。

        删除文件:

[root@reece ~]# ansible web -m file -a 'path=/data/a state=absent'
192.168.146.131 | SUCCESS => {
    "changed": true, 
    "path": "/data/a", 
    "state": "absent"
}

        我们可以查看一下：

[root@reece ~]# ansible web -m shell -a 'ls /data/a'
192.168.146.131 | FAILED | rc=2 >>
ls: cannot access /data/a: No such file or directory

5、yum 模块

        顾名思义，该模块主要用于软件的安装。 　　

        其选项如下：

name=　　            #所安装的包的名称

state=　　          #present--->安装， latest--->安装最新的, absent---> 卸载软件。

update_cache　　#强制更新yum的缓存

conf_file　　     #指定远程yum安装时所依赖的配置文件（安装本地已有的包）。

disable_gpg_check　　#是否禁止GPG checking，只用于presentor latest。

disablerepo　　 #临时禁止使用yum库。 只用于安装或更新时。

enablerepo　　  #临时使用的yum库。只用于安装或更新时。

        下面我们就来安装一个包试试看：

[root@server ~]# ansible web -m yum -a 'name=htop state=present'
192.168.146.131 | SUCCESS => {
    "changed": true, 
    "msg": "", 
    "rc": 0, 
    "results": [
        "Loaded plugins: fastestmirror, langpacks\nLoading mirror speeds from cached hostfile\nResolving Dependencies\n--> Running transaction check\n---> Package htop.x86_64 0:2.0.2-1.el7 will be installed\n--> Finished Dependency Resolution\n\nDependencies Resolved\n\n================================================================================\n Package         Arch              Version                Repository       Size\n================================================================================\nInstalling:\n htop            x86_64            2.0.2-1.el7            epel             98 k\n\nTransaction Summary\n================================================================================\nInstall  1 Package\n\nTotal download size: 98 k\nInstalled size: 207 k\nDownloading packages:\nRunning transaction check\nRunning transaction test\nTransaction test succeeded\nRunning transaction\n  Installing : htop-2.0.2-1.el7.x86_64                                      1/1 \n  Verifying  : htop-2.0.2-1.el7.x86_64                                      1/1 \n\nInstalled:\n  htop.x86_64 0:2.0.2-1.el7                                                     \n\nComplete!\n"
    ]
}

6、service 模块

        该模块用于服务程序的管理。

        其主要选项如下：

arguments     #命令行提供额外的参数

enabled         #设置开机启动。yes|no     true|false
name=          #服务名称
runlevel         #开机启动的级别，一般不用指定。
sleep             #在重启服务的过程中，是否等待。如在服务关闭以后等待2秒再启动。(定义在剧本中。)
state              #有四种状态，分别为：`started`--->启动服务， `stopped`--->停止服务， `restarted`--->重启服务， `reloaded`--->重载配置

        下面是一些例子： 开启服务并设置自启动

        我们可以去查看一下端口是否打开：

[root@reece ~]# ansible web -m shell -a 'ss -ntl'
192.168.146.131 | SUCCESS | rc=0 >>
State      Recv-Q Send-Q Local Address:Port               Peer Address:Port              
LISTEN     0      128          *:80                       *:*             

        我们也可以通过该模块来关闭我们的服务：

[root@server ~]# ansible web -m service -a 'name=nginx state=stopped'
192.168.146.131 | SUCCESS => {
    "changed": true, 
    "name": "nginx", 
    "state": "stopped", 
    ……
}

        一样的，我们来查看一下端口：

[root@reece ~]# ansible web -m shell -a 'ss -ntl | grep 80'
192.168.146.131 | FAILED | rc=1 >>

7、script 模块

       该模块用于将本机的脚本在被管理端的机器上运行。

       该模块直接指定脚本的路径即可，我们通过例子来看一看到底如何使用的：

                首先，我们写一个脚本，并给其加上执行权限：

[root@reece ~]# vim /tmp/df.sh
    #!/bin/bash
    date >> /tmp/disk_total.log 
    df -lh >> /tmp/disk_total.log 
[root@reece ~]# chmod +x /tmp/df.sh 

        然后，我们直接运行命令来实现在被管理端执行该脚本：

[root@reece ~]# ansible web -m script -a '/tmp/df.sh'
192.168.146.131 | SUCCESS => {
    "changed": true, 
    "rc": 0, 
    "stderr": "Shared connection to 192.168.146.131 closed.\r\n", 
    "stdout": "", 
    "stdout_lines": []
}

        照例查看一下文件内容：

[root@reece ~]# ansible web -m shell -a 'cat /tmp/disk_total.log'
192.168.146.131 | SUCCESS | rc=0 >>
Tue Dec  5 15:58:21 CST 2017
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda2        47G  4.4G   43G  10% /
devtmpfs        978M     0  978M   0% /dev
tmpfs           993M   84K  993M   1% /dev/shm
tmpfs           993M  9.1M  984M   1% /run
tmpfs           993M     0  993M   0% /sys/fs/cgroup
/dev/sda3        47G   33M   47G   1% /app
/dev/sda1       950M  153M  798M  17% /boot
tmpfs           199M   16K  199M   1% /run/user/42
tmpfs           199M     0  199M   0% /run/user/0

8、unarchive模块

用途：从本地机器上复制存档后，将其解包。
说明：
        该unarchive模块将解压缩一个存档。
        默认情况下，它将在解包之前将源文件从本地系统复制到目标。
        设置remote_src=yes为解包目标上已经存在的档案。
        对于Windows目标，请改用win_unzip模块。

常用选项：

        dest：远程绝对路径，档案应该被解压缩
        exec：列出需要排除的目录和文件
        src：指定源
        creates：一个文件名，当它已经存在时，这个步骤将不会被运行。

ansible -i /etc/ansible/hosts web -m unarchive -a 'src=/root/easy-springmvc-maven.zip dest=/tmp'

- name: Extract foo.tgz into /var/lib/foo
 unarchive:
   src: foo.tgz
   dest: /var/lib/foo

- name: Unarchive a file that is already on the remote machine
 unarchive:
   src: /tmp/foo.zip
   dest: /usr/local/bin
   remote_src: yes

- name: Unarchive a file that needs to be downloaded (added in 2.0)
 unarchive:
   src: https://example.com/example.zip
   dest: /usr/local/bin
   remote_src: yes

模块有很多，常用这几个列举出来了。

六、Ansible playbook

playbook 是 ansible 用于配置，部署，和管理被控节点的剧本。 　　

        通过 playbook 的详细描述，执行其中的一系列 tasks ，可以让远端主机达到预期的状态。playbook 就像 Ansible 控制器给被控节点列出的的一系列 to-do-list ，而被控节点必须要完成。 　　也可以这么理解，playbook 字面意思，即剧本，现实中由演员按照剧本表演，在Ansible中，这次由计算机进行表演，由计算机安装，部署应用，提供对外服务，以及组织计算机处理各种各样的事情。

Ansible playbook使用场景

执行一些简单的任务，使用ad-hoc命令可以方便的解决问题，但是有时一个设施过于复杂，需要大量的操作时候，执行的ad-hoc命令是不适合的，这时最好使用playbook。 　　

就像执行shell命令与写shell脚本一样， 也可以理解为批处理任务，不过playbook有自己的语法格式。 　　

使用playbook你可以方便的重用这些代码，可以移植到不同的机器上面，像函数一样，最大化的利用代码。在你使用Ansible的过程中，你也会发现，你所处理的大部分操作都是编写playbook。可以把常见的应用都编写成playbook，之后管理服务器会变得十分简单。

Ansible playbook格式

格式简介

        playbook由YAML语言编写。YAML( /ˈjæməl/ )参考了其他多种语言，包括：XML、C语言、Python、Perl以及电子邮件格式RFC2822，Clark Evans在2001年5月在首次发表了这种语言，另外Ingy döt Net与OrenBen-Kiki也是这语言的共同设计者。 　　

YMAL格式是类似于JSON的文件格式，便于人理解和阅读，同时便于书写。首先学习了解一下YMAL的格式，对我们后面书写playbook很有帮助。

以下为playbook常用到的YMAL格式： 　　

        1、文件的第一行应该以 "---" (三个连字符)开始，表明YMAL文件的开始。 　　

        2、在同一行中，#之后的内容表示注释，类似于shell，python和ruby。 　　

        3、YMAL中的列表元素以”-”开头然后紧跟着一个空格，后面为元素内容。 　　

        4、同一个列表中的元素应该保持相同的缩进。否则会被当做错误处理。 　　

        5、play中hosts，variables，roles，tasks等对象的表示方法都是键值中间以":"分隔表示，":"后面还要增加一个空格。　

下面是一个举例：

---
#安装与运行mysql服务
- hosts: node1
  remote_user: root
  tasks:  
    - name: install mysql-server package
      yum: name=mysql-server state=present
    - name: starting mysqld service
      service: name=mysql state=started

        我们的文件名称应该以`.yml`结尾，像我们上面的例子就是mysql.yml。其中，有三个部分组成：

host部分：使用 hosts 指示使用哪个主机或主机组来运行下面的 tasks ，每个 playbook 都必须指定 hosts 。主机或主机组在 inventory 清单中指定，可以使用系统默认的/etc/ansible/hosts，也可以自己编辑，在运行的时候加上-i选项，指定清单的位置即可。在运行清单文件的时候，–list-hosts选项会显示那些主机将会参与执行 task 的过程中。 remote_user：指定远端主机中的哪个用户来登录远端系统，在远端系统执行 task 的用户，可以任意指定，也可以使用 sudo，但是用户必须要有执行相应 task 的权限。 tasks：指定远端主机将要执行的一系列动作。tasks 的核心为 ansible 的模块，前面已经提到模块的用法。tasks 包含 name 和要执行的模块，name 是可选的，只是为了便于用户阅读，不过还是建议加上去，模块是必须的，同时也要给予模块相应的参数。

        使用ansible-playbook运行playbook文件，得到如下输出信息，输出内容为JSON格式。并且由不同颜色组成，便于识别。一般而言 | 绿色代表执行成功，系统保持原样 | 黄色代表系统代表系统状态发生改变 | 红色代表执行失败，显示错误输出。

playbook格式

        playbook由yaml语言编写。YMAL格式是类似于JSON的文件格式，便于人理解和阅读，同时便于书写。

        一个剧本里面可以有多个play，每个play只能有一个tasks，每个tasks可以有多个name。

核心元素：
Playbooks  
Variables     #变量元素,可传递给Tasks/Templates使用;  
Tasks          #任务元素,由模块定义的操作的列表，即调用模块完成任务;  
Templates   #模板元素,使用了模板语法的文本文件;  
Handlers     #处理器元素,通常指在某事件满足时触发的操作;  
Roles          #角色元素

playbook的基础组件：

name:
    定义playbook或者task的名称(描述信息)，每一个play都可以完成一个任务。
hosts:
    hosts用于指定要执行指定任务的主机.
user:
    remote_user则用于指定远程主机上的执行任务的用户
tasks:
    任务列表play的主体部分是task list. task list中的各任务按次序逐个在hosts中指定的所有主机上执行，即在所有主机上完成第一个任务后再开始第二个。
vars:
   定义变量（如果不使用内部变量需要提前定义）
vars_files:
  调用定义变量文件
notify:
    任务执行结果如果是发生更改了的则触发定义在handler的任务执行
handlers:
    用于当前关注的资源发生变化时采取一定指定的操作

        实例：

[root@reece ~]# cd /etc/ansible/
[root@reece ansible]# vim test.yml  #创建文件必须以.yml/.yaml结尾
---
 - hosts: websrvs1
   user: root
   tasks:
   - name: playbook_test
     file: state=touch path=/tmp/playbook.txt
===================================================================================
参数解释：
    hosts: 参数指定了对哪些主机进行操作；
    user: 参数指定了使用什么用户登录远程主机操作；
    tasks: 指定了一个任务.
    name:参数同样是对任务的描述，在执行过程中会打印出来。

检测语法：
[root@reece ansible]# ansible-playbook --syntax-check test.yml 
playbook: test.yml
运行Playbook：
[root@reece ansible]# ansible-playbook test.yml #加剧本名称

        实例:

handlers：由特定条件触发的Tasks
handlers:处理器
notify:触发器
语法：
tasks：
- name: TASK_NAME
  module: arguments               #1.上面任务执行成功，然后
  notify: HANDLER_NAME            #2.通知他
handlers:
- name: HANDLER_NAME              #3.一一对应，这里的描述与notify定义的必须一样
  module: arguments               #4.执行这个命令
=======================================================
[root@reece ansible]# vim handlers.yml
---
- hosts: websrvs1
  user: root
  tasks:
  - name: test copy
    copy: src=/root/a.txt dest=/mnt
    notify: test handlers
  handlers:
  - name: test handlers
    shell: echo "abcd" >> /mnt/a.txt
========================================================
说明：只有 copy 模块真正执行后，才会去调用下面的 handlers 相关的操作，追加内容。所以这种比较适合配置文件发生更改后，需要重启服务的操作。

检测语法：

[root@reece ansible]# ansible-playbook --syntax-check handlers.yml
playbook: handlers.yml
[root@reece ansible]# ansible-playbook handlers.yml

七、Role角色

目录结构：

目录顺序:
role_name/     ---角色名称=目录
    files/：   存储一些可以用copy调用的静态文件。
    tasks/： 存储任务的目录,此目录中至少应该有一个名为main.yml的文件，用于定义各task；其它的文件需要由main.yml进行“包含”调用；
    handlers/:  此目录中至少应该有一个名为main.yml的文件，用于定义各handler；其它的文件需要由（与notify:名字相同，方便notify通知执行下一条命令）通过main.yml进行“包含”调用；
    vars/：此目录中至少应该有一个名为main.yml的文件，用于定义各variable；其它的文件需要由main.yml进行“包含”调用；
    templates/：存储由template模块调用的模板文本； （也可以调用变量）
    site.yml：定义哪个主机应用哪个角色

自动创建目录结构：
        ansible-galaxy init tomcat

1.创建nginx的测试文件
[root@reece roles]# echo 1234 > nginx/files/index.html
2.安装nginx并配置模板
[root@reece roles]# yum install -y nginx && cp /etc/nginx/nginx.conf nginx/templates/nginx.conf.j2

3.编写任务
[root@reece roles]# vim nginx/tasks/main.yml
---
- name: install epel
  yum: name=epel-release state=latest
- name: install nginx
  yum: name=nginx state=latest
- name: copy nginx.conf templte
  template: src=nginx.conf.j2 dest=/etc/nginx/nginx.conf
- name: copy index.html
  copy: src=/etc/ansible/roles/nginx/files/index.html dest=/usr/share/nginx/html/index.html
  notify: start nginx

4.准备配置文件
[root@ansible-server roles]# vim nginx/templates/nginx.conf.j2
修改成如下内容。自定义变量-

5.编写变量
[root@reece roles]# vim nginx/vars/main.yml  #添加如下内容
worker_connections: 2

6.编写handlers
[root@reece roles]# vim nginx/handlers/main.yml #编写如下内容
---
- name: start nginx  #和notify的名字必须一样
  service: name=nginx state=started

7.编写剧本
[root@reece roles]# vim site.yml
---
- hosts: websrvs4
  user: root
  roles:
   - nginx

检测语法
[root@reece roles]# ansible-playbook site.yml --syntax-check
playbook: site.yml
执行剧本：
[root@reece roles]# ansible-playbook site.yml

查看：
[root@reece ~]# netstat -lntp 
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 0.0.0.0:80              0.0.0.0:*               LISTEN      3102/nginx: master  
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      926/sshd            
tcp        0      0 127.0.0.1:25            0.0.0.0:*               LISTEN      1007/master         
tcp6       0      0 :::80                   :::*                    LISTEN      3102/nginx: master  
tcp6       0      0 :::22                   :::*                    LISTEN      926/sshd            
tcp6       0      0 ::1:25                  :::*                    LISTEN      1007/master         
[root@reece ~]# cat /etc/nginx/nginx.conf | grep pro
#worker_processes auto;
worker_processes 2;

然后在浏览器输入主机ip地址访问nginx。