常见

#定义任务的名称 #调用模块，具体要做的事情
- name: create new file file: name=/tmp/playtest.txt state=touch
- name: create new dir file: name=/tmp/back state=directory
- name: create new user user: name=test02 system=yes shell=/sbin/nologin
user: name=test001 state=present
- name: Create New Group group: name=test001 state=present
- name: install package yum: name=httpd
- name: start httpd service: name=httpd state=started
- name: copy index.html copy: src=/var/www/html/index.html dest=/var/www/html/index.html
- name: run df -h shell: name=df -h
get ip_addr shell: echo {{ ansible_default_ipv4[ “address” ] }} >> /root/newfile.txt

task定义要执行该任务的远程用户

  1. tasks: 
  2.   - name: run df -h
  3.     remote_user: test
  4.     shell: name=df -h

task定义使用sudo授权用户执行该任务

  1. tasks: 
  2.   - name: run df -h
  3.     sudo_user: test
  4.     sudo: yes
  5.     shell: name=df -h

task任务列表

每一个task必须有一个名称name,这样在运行playbook时，从其输出的任务执行信息中可以很清楚的辨别是属于哪一个task的，如果没有定义 name，action的值将会用作输出信息中标记特定的task。

Handlers与Notify

很多时候当我们某一个配置发生改变，我们需要重启服务，（比如httpd配置文件文件发生改变了）这时候就可以用到handlers和notify了；
(当发生改动时)notify actions会在playbook的每一个task结束时被触发，而且即使有多个不同task通知改动的发生，notify actions知会被触发一次；比如多个resources指出因为一个配置文件被改动，所以apache需要重启，但是重新启动的操作只会被执行一次。

  1. [root@ansible ~]# cat httpd.yml 
  2. #用于安装httpd并配置启动
  3. ---
  4. - hosts: 192.168.1.31
  5.   remote_user: root
  7.   tasks:
  8.   - name: install httpd
  9.     yum: name=httpd state=installed
  10.   - name: config httpd
  11.     template: src=/root/httpd.conf dest=/etc/httpd/conf/httpd.conf
  12.     notify:
  13.       - restart httpd
  14.   - name: start httpd
  15.     service: name=httpd state=started
  17.   handlers:
  18.     - name: restart httpd
  19.       service: name=httpd state=restarted
  21. #这里只要对httpd.conf配置文件作出了修改，修改后需要重启生效，在tasks中定义了restart httpd这个action，然后在handlers中引用上面tasks中定义的notify。

Playbook中变量的使用

环境说明：这里配置了两个组，一个apache组和一个nginx组

  1. [root@ansible PlayBook]# cat /etc/ansible/hosts
  2. [apache]
  3. 192.168.1.36
  4. 192.168.1.33
  6. [nginx]
  7. 192.168.1.3[1:2]

命令行指定变量

执行playbook时候通过参数-e传入变量，这样传入的变量在整个playbook中都可以被调用，属于全局变量

  1. [root@ansible PlayBook]# cat variables.yml 
  2. ---
  3. - hosts: all
  4.   remote_user: root
  6.   tasks:
  7.     - name: install pkg
  8.       yum: name={{ pkg }}
  10. #执行playbook 指定pkg
  11. [root@ansible PlayBook]# ansible-playbook -e "pkg=httpd" variables.yml

hosts文件中定义变量

在/etc/ansible/hosts文件中定义变量，可以针对每个主机定义不同的变量，也可以定义一个组的变量，然后直接在playbook中直接调用。注意，组中定义的变量没有单个主机中的优先级高。

  1. # 编辑hosts文件定义变量
  2. [root@ansible PlayBook]# vim /etc/ansible/hosts
  3. [apache]
  4. 192.168.1.36 webdir=/opt/test     #定义单个主机的变量
  5. 192.168.1.33
  6. [apache:vars]      #定义整个组的统一变量
  7. webdir=/web/test
  9. [nginx]
  10. 192.168.1.3[1:2]
  11. [nginx:vars]
  12. webdir=/opt/web
  15. # 编辑playbook文件
  16. [root@ansible PlayBook]# cat variables.yml 
  17. ---
  18. - hosts: all
  19.   remote_user: root
  21.   tasks:
  22.     - name: create webdir
  23.       file: name={{ webdir }} state=directory   #引用变量
  26. # 执行playbook
  27. [root@ansible PlayBook]# ansible-playbook variables.yml

playbook文件中定义变量#

编写playbook时，直接在里面定义变量，然后直接引用，可以定义多个变量；注意：如果在执行playbook时，又通过-e参数指定变量的值，那么会以-e参数指定的为准。

  1. # 编辑playbook
  2. [root@ansible PlayBook]# cat variables.yml 
  3. ---
  4. - hosts: all
  5.   remote_user: root
  6.   vars:                #定义变量
  7.     pkg: nginx         #变量1
  8.     dir: /tmp/test1    #变量2
  10.   tasks:
  11.     - name: install pkg
  12.       yum: name={{ pkg }} state=installed    #引用变量
  13.     - name: create new dir
  14.       file: name={{ dir }} state=directory   #引用变量
  17. # 执行playbook
  18. [root@ansible PlayBook]# ansible-playbook variables.yml
  20. # 如果执行时候又重新指定了变量的值，那么会已重新指定的为准
  21. [root@ansible PlayBook]# ansible-playbook -e "dir=/tmp/test2" variables.yml

调用setup模块获取变量#

setup模块默认是获取主机信息的，有时候在playbook中需要用到，所以可以直接调用。常用的参数参考

  1. # 编辑playbook文件
  2. [root@ansible PlayBook]# vim variables.yml
  3. - hosts: [dbservers]
  4.   remote_user: ansibleuser
  5.   become: yes
  6.   become_user: root
  7.   tasks:
  8.   - name: create new file
  9.     shell: echo {{ ansible_fqdn }} > /tmp/newfile.txt
  12. # 执行playbook
  13. [root@ansible PlayBook]# ansible-playbook variables.yml
  1. [ansibleuser@node1 ~]$ ansible dbservers -m setup >setup.txt
  2. [ansibleuser@node1 ~]$ head -50 setup.txt 
  3. 172.18.15.182 | SUCCESS => {
  4.     "ansible_facts": {
  5.         "ansible_all_ipv4_addresses": [
  6.             "172.18.15.182"
  7.         ], 
  8.         "ansible_all_ipv6_addresses": [
  9.             "fe80::a00:27ff:fe2f:c9bc"
  10.         ], 
  11. ......
  13. 当然，仔细观察setup模块的输出信息不难发现，所有的内建变量都是键值对的形式，有些多个键值对在一个花括号里面，这样的文本组织形式是基于JSON格式。
  15. 在变量ansible_default_ipv4下还有多个子变量，我们可以称之为二级变量或者子键，分别对应着不同的值，这些子键的调用需要上级主键的配合使用才能完成变量调用，其格式为{{ main_var[ "sub_var" ] }}。
  17.   task:
  18.   - name: get ip_addr
  19.     shell: echo {{ ansible_default_ipv4[ "address" ] }} >> /root/newfile.txt
  20.   - name: get mac_addr
  21.     shell: echo {{ ansible_default_ipv4[ "macaddress" ] }} >> /root/newfile.txt

独立的变量YAML文件中定义#

为了方便管理将所有的变量统一放在一个独立的变量YAML文件中，playbook文件直接引用文件调用变量即可。

  1. # 定义存放变量的文件
  2. [root@ansible PlayBook]# cat var.yml 
  3. var1: vsftpd
  4. var2: httpd
  6. # 编写playbook
  7. [root@ansible PlayBook]# cat variables.yml 
  8. ---
  9. - hosts: all
  10.   remote_user: root
  11.   vars_files:    #引用变量文件
  12.     - ./var.yml   #指定变量文件的path（这里可以是绝对路径，也可以是相对路径）
  14.   tasks:
  15.     - name: install package
  16.       yum: name={{ var1 }}   #引用变量
  17.     - name: create file
  18.       file: name=/tmp/{{ var2 }}.log state=touch   #引用变量
  21. # 执行playbook
  22. [root@ansible PlayBook]# ansible-playbook  variables.yml

Playbook中标签的使用#

一个playbook文件中，执行时如果想执行某一个任务，那么可以给每个任务集进行打标签，这样在执行的时候可以通过-t选择指定标签执行，还可以通过--skip-tags选择除了某个标签外全部执行等。

Playbook中模板的使用#

template模板为我们提供了动态配置服务，使用jinja2语言，里面支持多种条件判断、循环、逻辑运算、比较操作等。其实说白了也就是一个文件，和之前配置文件使用copy一样，只是使用copy，不能根据服务器配置不一样进行不同动态的配置。这样就不利于管理。
说明：
1、多数情况下都将template文件放在和playbook文件同级的templates目录下（手动创建），这样playbook文件中可以直接引用，会自动去找这个文件。如果放在别的地方，也可以通过绝对路径去指定。
2、模板文件后缀名为.j2。
示例：通过template安装httpd
1）playbook文件编写

  1. [root@ansible PlayBook]# cat testtmp.yml 
  2. #模板示例
  3. ---
  4. - hosts: all
  5.   remote_user: root
  6.   vars:
  7.     - listen_port: 88    #定义变量
  9.   tasks:
  10.     - name: Install Httpd
  11.       yum: name=httpd state=installed
  12.     - name: Config Httpd
  13.       template: src=httpd.conf.j2 dest=/etc/httpd/conf/httpd.conf    #使用模板
  14.       notify: Restart Httpd
  15.     - name: Start Httpd
  16.       service: name=httpd state=started
  18.   handlers:
  19.     - name: Restart Httpd
  20.       service: name=httpd state=restarted

2）模板文件准备，httpd配置文件准备，这里配置文件端口使用了变量

  1. [root@ansible PlayBook]# cat templates/httpd.conf.j2 |grep ^Listen
  2. Listen {{ listen_port }}

3）查看目录结构

  1. # 目录结构
  2. [root@ansible PlayBook]# tree .
  3. .
  4. ├── templates
  5. │   └── httpd.conf.j2
  6. └── testtmp.yml
  8. 1 directory, 2 files

template之when#

条件测试：如果需要根据变量、facts或此前任务的执行结果来做为某task执行与否的前提时要用到条件测试，通过when语句执行，在task中使用jinja2的语法格式、
when语句：
在task后添加when子句即可使用条件测试；when语句支持jinja2表达式语法。
类似这样：

  1. tasks:
  2.   - command: /bin/false
  3.     register: result
  4.     ignore_errors: True
  5.   - command: /bin/something
  6.     when: result|failed
  7.   - command: /bin/something_else
  8.     when: result|success
  9.   - command: /bin/still/something_else
  10.     when: result|skipped

示例：通过when语句完善上面的httpd配置
1）准备两个配置文件，一个centos6系统httpd配置文件，一个centos7系统httpd配置文件。

  1. [root@ansible PlayBook]# tree templates/
  2. templates/
  3. ├── httpd6.conf.j2     #6系统2.2.15版本httpd配置文件
  4. └── httpd7.conf.j2     #7系统2.4.6版本httpd配置文件
  6. 0 directories, 2 files

2）修改playbook文件，通过setup模块获取系统版本去判断。setup常用模块

  1. [root@ansible PlayBook]# cat testtmp.yml 
  2. #when示例
  3. ---
  4. - hosts: all
  5.   remote_user: root
  6.   vars:
  7.     - listen_port: 88
  9.   tasks:
  10.     - name: Install Httpd
  11.       yum: name=httpd state=installed
  12.     - name: Config System6 Httpd
  13.       template: src=httpd6.conf.j2 dest=/etc/httpd/conf/httpd.conf
  14.       when: ansible_distribution_major_version == "6"   #判断系统版本，为6便执行上面的template配置6的配置文件
  15.       notify: Restart Httpd
  16.     - name: Config System7 Httpd
  17.       template: src=httpd7.conf.j2 dest=/etc/httpd/conf/httpd.conf
  18.       when: ansible_distribution_major_version == "7"   #判断系统版本，为7便执行上面的template配置7的配置文件
  19.       notify: Restart Httpd
  20.     - name: Start Httpd
  21.       service: name=httpd state=started
  23.   handlers:
  24.     - name: Restart Httpd
  25.       service: name=httpd state=restarted

template之with_items#

with_items迭代，当有需要重复性执行的任务时，可以使用迭代机制。
对迭代项的引用，固定变量名为“item”，要在task中使用with_items给定要迭代的元素列表。
列表格式：
  字符串
  字典
示例1：通过with_items安装多个不同软件
编写playbook

  1. [root@ansible PlayBook]# cat testwith.yml 
  2. # 示例with_items
  3. ---
  4. - hosts: all
  5.   remote_user: root
  7.   tasks:
  8.     - name: Install Package
  9.       yum: name={{ item }} state=installed   #引用item获取值
  10.       with_items:     #定义with_items
  11.         - httpd
  12.         - vsftpd
  13.         - nginx

上面tasks写法等同于：

  1. ---
  2. - hosts: all
  3.   remote_user: root
  4.   tasks:
  5.     - name: Install Httpd
  6.       yum: name=httpd state=installed
  7.     - name: Install Vsftpd
  8.       yum: name=vsftpd state=installed
  9.     - name: Install Nginx
  10.       yum: name=nginx state=installed

示例2：通过嵌套子变量创建用户并加入不同的组
1）编写playbook

  1. [root@ansible PlayBook]# cat testwith01.yml 
  2. # 示例with_items嵌套子变量
  3. ---
  4. - hosts: all
  5.   remote_user: root
  7.   tasks:
  8.     - name: Create New Group
  9.       group: name={{ item }} state=present
  10.       with_items: 
  11.         - group1
  12.         - group2
  13.         - group3 
  15.     - name: Create New User
  16.       user: name={{ item.name }} group={{ item.group }} state=present
  17.       with_items:
  18.         - { name: 'user1', group: 'group1' } 
  19.         - { name: 'user2', group: 'group2' } 
  20.         - { name: 'user3', group: 'group3' }

template之for if#

通过使用for，if可以更加灵活的生成配置文件等需求，还可以在里面根据各种条件进行判断，然后生成不同的配置文件、或者服务器配置相关等。

示例1

1）编写playbook

  1. [root@ansible PlayBook]# cat testfor01.yml 
  2. # template for 示例
  3. ---
  4. - hosts: all
  5.   remote_user: root
  6.   vars:
  7.     nginx_vhost_port:
  8.       - 81
  9.       - 82
  10.       - 83
  12.   tasks:
  13.     - name: Templage Nginx Config
  14.       template: src=nginx.conf.j2 dest=/tmp/nginx_test.conf

2）模板文件编写

  1. # 循环playbook文件中定义的变量，依次赋值给port
  2. [root@ansible PlayBook]# cat templates/nginx.conf.j2 
  3. {% for port in nginx_vhost_port %}
  4. server{
  5.      listen: {{ port }};
  6.      server_name: localhost;
  7. }
  8. {% endfor %}

{% for port in nginx_vhost_port %}
server{
listen: {{ port }};
server_name: localhost;
}
{% endfor %}

3）执行playbook并查看生成结果

  1. [root@ansible PlayBook]# ansible-playbook testfor01.yml
  3. # 去到一个节点看下生成的结果发现自动生成了三个虚拟主机
  4. [root@linux ~]# cat /tmp/nginx_test.conf 
  5. server{
  6.      listen: 81;
  7.      server_name: localhost;
  8. }
  9. server{
  10.      listen: 82;
  11.      server_name: localhost;
  12. }
  13. server{
  14.      listen: 83;
  15.      server_name: localhost;
  16. }

示例2

1）编写playbook

  1. [root@ansible PlayBook]# cat testfor02.yml 
  2. # template for 示例
  3. ---
  4. - hosts: all
  5.   remote_user: root
  6.   vars:
  7.     nginx_vhosts:
  8.       - web1:
  9.         listen: 8081
  10.         server_name: "web1.example.com"
  11.         root: "/var/www/nginx/web1"
  12.       - web2:
  13.         listen: 8082
  14.         server_name: "web2.example.com"
  15.         root: "/var/www/nginx/web2"
  16.       - web3:
  17.         listen: 8083
  18.         server_name: "web3.example.com"
  19.         root: "/var/www/nginx/web3"
  21.   tasks:
  22.     - name: Templage Nginx Config
  23.       template: src=nginx.conf.j2 dest=/tmp/nginx_vhost.conf

2）模板文件编写

  1. [root@ansible PlayBook]# cat templates/nginx.conf.j2 
  2. {% for vhost in nginx_vhosts %}
  3. server{
  4.      listen:    {{ vhost.listen }};
  5.      server_name:    {{ vhost.server_name }};
  6.      root:   {{ vhost.root }}; 
  7. }
  8. {% endfor %}

3）执行playbook并查看生成结果

  1. [root@ansible PlayBook]# ansible-playbook testfor02.yml
  3. # 去到一个节点看下生成的结果发现自动生成了三个虚拟主机
  4. [root@linux ~]# cat /tmp/nginx_vhost.conf 
  5. server{
  6.      listen:    8081;
  7.      server_name:    web1.example.com;
  8.      root:   /var/www/nginx/web1; 
  9. }
  10. server{
  11.      listen:    8082;
  12.      server_name:    web2.example.com;
  13.      root:   /var/www/nginx/web2; 
  14. }
  15. server{
  16.      listen:    8083;
  17.      server_name:    web3.example.com;
  18.      root:   /var/www/nginx/web3; 
  19. }

示例3

在for循环中再嵌套if判断，让生成的配置文件更加灵活
1）编写playbook

  1. [root@ansible PlayBook]# cat testfor03.yml 
  2. # template for 示例
  3. ---
  4. - hosts: all
  5.   remote_user: root
  6.   vars:
  7.     nginx_vhosts:
  8.       - web1:
  9.         listen: 8081
  10.         root: "/var/www/nginx/web1"
  11.       - web2:
  12.         server_name: "web2.example.com"
  13.         root: "/var/www/nginx/web2"
  14.       - web3:
  15.         listen: 8083
  16.         server_name: "web3.example.com"
  17.         root: "/var/www/nginx/web3"
  19.   tasks:
  20.     - name: Templage Nginx Config
  21.       template: src=nginx.conf.j2 dest=/tmp/nginx_vhost.conf

2）模板文件编写

  1. # 说明：这里添加了判断，如果listen没有定义的话，默认端口使用8888，如果server_name有定义，那么生成的配置文件中才有这一项。
  2. [root@ansible PlayBook]# cat templates/nginx.conf.j2 
  3. {% for vhost in nginx_vhosts %}
  4. server{
  5.      {% if vhost.listen is defined %}
  6.      listen:    {{ vhost.listen }};
  7.      {% else %}
  8.      listen: 8888;
  9.      {% endif %}
  10.      {% if vhost.server_name is defined %}
  11.      server_name:    {{ vhost.server_name }};
  12.      {% endif %}
  13.      root:   {{ vhost.root }}; 
  14. }
  15. {% endfor %}

3）执行playbook并查看生成结果

  1. [root@ansible PlayBook]# ansible-playbook testfor03.yml
  3. # 去到一个节点看下生成的结果发现自动生成了三个虚拟主机
  4. [root@linux ~]# cat /tmp/nginx_vhost.conf 
  5. server{
  6.           listen:    8081;
  7.           root:   /var/www/nginx/web1; 
  8. }
  9. server{
  10.           listen: 8888;
  11.           server_name:    web2.example.com;
  12.           root:   /var/www/nginx/web2; 
  13. }
  14. server{
  15.           listen:    8083;
  16.           server_name:    web3.example.com;
  17.           root:   /var/www/nginx/web3; 
  18. }