1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 1,如下示例:
[ctl]
10.168.0.2
10.168.0.3
10.168.0.4

[nova:children]
ctl

[nova-compute:children]
nova

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 1,如下示例:
all:
  children:
    k8s:
      hosts:
        master:
          ansible_host: 192.168.110.11
          ansible_port: 22
          ansible_user: root
          ansible_pass: '123.com'
        node2:
          ansible_host: 192.168.110.22
          ansible_port: 22
          ansible_user: root
          ansible_pass: '123.com'
        node3:
          ansible_host: 192.168.110.33
          ansible_port: 22
          ansible_user: root
          ansible_pass: '123.com'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

---
- hosts: all
  remote_user: root
  tasks:
  - name: change nginx configuration
    lineinfile:
      path=/etc/nginx/conf.d/test.conf
      regexp="listen(.*) 8080(.*)"
      line="listen\1 8088\2"
      backrefs=yes
      backup=yes
    notify:
      restart nginx

  handlers:
  - name: restart nginx
    service:
      name=nginx
      state=restarted 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

---
- hosts: all
  remote_user: root
  tasks:
  - name: make testfile1
    file:
      path=/testdir/testfile1
      state=directory
    notify: ht2
  - name: make testfile2
    file:
      path=/testdir/testfile2
      state=directory
    notify: ht1

  handlers:
  - name: ht1
    file:
      path=/testdir/ht1
      state=touch
  
  - name: ht2
    file:
      path=/testdir/ht2
      state=touch

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

---
- hosts: all
  remote_user: root
  tasks:
  - name: task1
    file: 
      path=/testdir/testfile
      state=touch
    notify: handler1
  - name: task2
    file:
      path=/testdir/testfile2
      state=touch
    notify: handler2

  - meta: flush handlers

  - name: task3
    file:
      path=/testdir/testfile3
      state=touch
    notify: handler3

  handlers:
  - name: handler1
    file:
      path=/testdir/hd1
      state=touch
  - name: handler2
    file:
      path=/testdir/hd2
      state=touch
  - name: handler3
    file:
      path=/testdir/hd3
      state=touch

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

---
- hosts: all
  remote_user: root
  tasks:
  - name: task1
    file: 
      path=/testdir/testfile
      state=touch
    notify: handler group1

  handlers:
  - name: handler1
    listen: 'handler group1'
    shell: 'echo handler1'
  - name: handler2
    listen: 'handler group1'
    shell: 'echo handler2'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

---
- hosts: all
  remote_user: root
  tasks:
  - name: test 1
    file:
      path=/testdir/testfile
      state=touch
    tags: t1
  - name: test 2
    file:
      path=/testdir/testfile2
      state=touch
    tags:t2
  - name: test 3
    file:
      path=/testdir/testfile3
      state=touch
    tags: t3
$ ansible-playbook --tags=t2 test.yaml
$ ansible-playbook --skip-tags=t2 test.yaml

1
2
3
4

# 指定多个tag时,使用命令为
$ ansible-playbook -t tag1,tag2,tag3 test.yaml
# 执行play前,查看当前有哪些tag
$ ansible-playbook --list-tags test.yaml

1
2
3
4
5
6
7
8

# method one
tags:
  - testing
  - t1
# method two
tags: testing, t1
# method three
tags: ['testing', 't1']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

---
- hosts: test70
  remote_user: root
  tags: httpd
  tasks:
  - name: install httpd package
    tags: ['package']
    yum:
      name=httpd
      state=latest
 
  - name: start up httpd service
    tags:
      - service
    service:
      name: httpd
      state: started

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

---
- hosts: all
  remote_user: root
  vars:
    testvar1: testfile
    testvar2: testfile2
# 或者使用yaml写法
  vars:
    - testvar1: testfile
    - testvar2: testfile2
  tasks:
  - name: task1
    file:
      path: /testdir/{{testvar1}}
      state: touch

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

- hosts: all
  remote_user: root
  vars:
    nginx:
      conf80: /etc/nginx/conf.d/80.conf
      conf8080: /etc/nginx/conf.d/8080.conf
  tasks:
  - name: task1
    file:
      path: "{{nginx.conf80}}"
      # 或者path: "{{nginx['conf80']}}"
      state: touch
  - name: task2
    file:
      path: "{{nginx.conf8080}}"
      # 或者path: "{{nginx['conf8080']}}"
      state: touch
# 使用=给模块参数赋值时,可以不考虑变量是否加引号
#  - name: task2
#    file:
#      path={{nginx.conf8080}}
#      # 或者path={{nginx['conf8080']}}
#      state=touch

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# method one
testvar1: testfile
testvar2: testfile2
# method two
- testvar1: testfile
- testvar2: testfile2
# method three
nginx:
  conf80: /etc/nginx/conf.d/80.conf
  conf8080: /etc/nginx/conf.d/8080.conf

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

---
- hosts: all
  remote_user: root
  vars_files:
  - /testdir/ansible/nginx_vars.yml
  tasks:
  - name: task1
    file:
      path: "{{nginx.conf80}}"
      state: touch
  - name: task2
    file:
      path: "{{nginx['conf8080']}}"
      state: touch

1
2
3
4

# 显示内存相关信息
ansible all -m setup -a 'filter=ansible_memory_mb'
# 不确定信息相关信息,使用通配符来获取
ansible all -m setup -a 'filter=*mb*'

1
2
3
4

$ cat /etc/ansible/facts.d/test.fact
[testmsg]
msg1='test message 1'
msg2='test message 2'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

---
- hosts: all
  remote_user: root
  tasks:
  - name: test register
    shell: "echo test > /tmp/testfile"
    register: testvar
  - name: shell module return values
    debug:
      var: testvar
# 执行完成后,在控制台中看到名为”[shell module return values]”的任务中已经显示了第一个任务的返回值的信息，返回信息:
TASK [shell module return values] ************************************
ok: [master] => {    
    "testvar": {          
        "changed": true,
        "cmd": "echo test > /tmp/testfile",
        "delta": "0:00:00.010963",
        "end": "2021-03-30 09:26:47.432571",                         
        "failed": false,                                            
        "rc": 0,                                                   
        "start": "2021-03-30 09:26:47.421608",                    
        "stderr": "",
        "stderr_lines": [],                                      
        "stdout": "",
        "stdout_lines": []
    }
}
# register的变量testvar其实是一个json格式的返回值,可以通过引用testvar的不同属性获取相应的值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

---
- hosts: all
  remote_user: root
  vars_prompt:
    - name: 'your_name'
      prompt: "What is your name?"
      # private: no
    - name: 'your_age'
      prompt: "What is your age?"
      # private: no
  tasks:
  - name: output vars
    debug:
      msg: your name is {{your_name}}, your age is {{your_age}}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 需要使用到vars_prompt下encrypt,指定加密方式,而且该方式需要passlib库,么有的话需要安装
---
- hosts: test70
  remote_user: root
  vars_prompt:
    - name: "hash_string"
      prompt: "Enter something"
      private: no
      encrypt: "sha512_crypt"
  tasks:
   - name: Output the string after hash
     debug:
      msg: "{{hash_string}}"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

## 主机配置,配置/etc/ansible/hosts如下
# method one
node2 ansible_host=192.168.110.22 testhostvar=node2_host_var
# method two
all:
  hosts:
    node2:
      ansible_host: 192.168.110.22
      ansible_port: 22
      testhostvar: node2_host_var
      testhostvar2: node2_host_var2
      testhostvar3: 
        thv31: 3.1
        thv32: 3.2
$ ansible node2 -m shell -a 'echo {{testhostvar}}
$ ansible node2 -m shell -a 'echo {{testhostvar3.thv31}}' or '{{testhostvar3['thv32']}}'

## 主机组配置,配置/etc/ansible/hosts如下
# method one
[testB]
node2 ansible_host=192.168.110.22
node3 anisble_host=192.168.110.33
 
[testB:vars]
test_group_var1='group var test'
test_group_var2='group var test2'
# method two
all:
 children:
   testB:
     hosts:
       node2:
         ansible_host: 192.168.110.22
         ansible_port: 22
       node3:
         ansible_host: 192.168.110.33
         ansible_port: 22
     vars:
       test_group_var1: 'group var test1'
       test_group_var2: 'group var test2'
$ ansible testB -m shell -a 'echo {{test_group_var1}}'

1
2
3
4
5
6
7
8

---
- hosts: node2
  remote_user: root
  tasks:
  - set_fact:
      testvar: "testtest"
  - debug:
      msg: "{{testvar}}"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

---
- hosts: node2
  remote_user: root
  vars:
    testvar1: test1_string
  tasks:
  - shell: "echo test2_string"
    register: shellreturn
  - set_fact:
      testsf1: "{{testvar1}}"
      testsf2: "{{shellreturn.stdout}}"
  - debug:
      msg: "{{testsf1}} {{testsf2}}"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

---
- hosts: node2
  remote_user: root
  vars:
    testvar1: tv1
  tasks:
  - set_fact:
      testvar2: tv2
  - debug:
      msg: "{{testvar1}} ----- {{testvar2}}"
 
- hosts: node2
  remote_user: root
  tasks:
  - name: other play get testvar2
    debug:
      msg: "{{testvar2}}"
  - name: other play get testvar1
    debug:
      msg: "{{testvar1}}"
# 这两个变量在第一个play中都可以正常的输出.但是在第二个play中，testvar2可以被正常输出了，testvar1却不能被正常输出，会出现未定义testvar1的错误

1

$ ansible node2 -m debug -a 'msg={{ansible_version}}'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

---
# 第一个什么也没做,只是获取node3的facts内容,这一步是需要的,只有收集过的facts才能被后面的play使用
# 如果没有收到对应主机的facts信息,即使使用hostvars内置变量,也无法获取到对应主机的facts内容
- name: "play 1: gather facts of node3"
  hosts: node3
  remote_user: root
  # 下面的gather_facts默认是yes
  # gater_facts: yes
- name: "play 2: gathter facts of node3 when operating on node2"
  hosts: node2
  remote_user: root
  tasks:
  - debug:
    msg: "{{hostvars['node3'].ansible_enp0s3.ipv4}}"
    # 下面两种也可以
    #msg: "{{hostvars.node3.ansible_enp0s3.ipv4}}"
    #msg: "{{hostvars['node3']['ansible_enp0s3']['ipv4']}}"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

---
# 1,通过hostvars内置变量可以直接获取到其他主机中的注册变量
# 2,注册变量并不用像facts信息那样需要事先收集，即可直接通过hostvars跨主机被引用到
# 3,如果你在清单中为node3主机配置了主机变量，或者为node3主机所在的组配置了组变量，也是可以通过hostvars直接跨主机引用
- hosts: node3
  remote_user: root
  gather_facts: no
  tasks:
  - shell: "echo register_var_in_play1"
    register: shellreturn
 
- hosts: node2
  remote_user: root
  gather_facts: no
  tasks:
  - debug:
      msg: "{{hostvars.node3.shellreturn.stdout}}"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# 下列内容会报错,变量需要注册才行,直接使用vars定义的变量无法传递
---
- hosts: node3
  remote_user: root
  gather_facts: no
  vars:
    testvar: testvar_in_3
  tasks:
  - debug:
      msg: "{{testvar}}"
 
- hosts: node2
  remote_user: root
  gather_facts: no
  tasks:
  - debug:
      msg: "{{hostvars.node3.testvar}}"

# 通过set_fact将vars定义的内容注册,则可以
---
- hosts: node3
  remote_user: root
  gather_facts: no
  tasks:
  - set_fact:
      testvar: testvar_in_3
  - debug:
      msg: "{{testvar}}"
 
- hosts: node2
  remote_user: root
  gather_facts: no
  tasks:
  - debug:
      msg: "{{hostvars.node3.testvar}}"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

---
- hosts: node2,node3
  remote_user: root
  gather_facts: no
  tasks:
  - debug:
      msg: "{{play_hosts}}"
# 输出如下:
TASK [debug] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
ok: [node2] => {
    "msg": [
        "node2", 
        "node3"
    ]
}
ok: [node3] => {
    "msg": [
        "node2", 
        "node3"
    ]
}

1
2

$ ansible all -m debug -a 'msg={{groups}}'
$ ansible all -m debug -a 'msg={{groups.k8s}}'

1
2
3
4
5
6
7

# ansible node2 -m debug -a "msg={{group_names}}"
node2 | SUCCESS => {
    "changed": false, 
    "msg": [
        "k8s"
    ]
}

1
2
3
4
5

# ansible node2 -m debug -a "msg={{inventory_dir}}"
node2 | SUCCESS => {
    "changed": false, 
    "msg": "/etc/ansible"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# "with_items"关键字会把返回的列表信息自动处理，将每一条信息单独放在一个名为"item"的变量中，只要获取到名为"item"变量的变量值，即可循环的获取到列表中的每一条信息
# 下列debug被循环3次,每次单独输出相应循环的debug输出内容
---
- hosts: node2
  remote_user: root
  gather_facts: no
  tasks:
  - name: test with_items
    debug:
      msg: "{{item}}"
    with_items: "{{groups.k8s}}"

1
2
3
4
5
6
7

# method one
with_items:
- 1
- 2
- 3
# method two
with_items: [1, 2, 3]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

---
- hosts: node2
  remote_user: root
  gather_facts: no
  tasks:
  - debug:
      msg: "{{item.test1}}"
    with_items:
    - { test1: a, test2: b}
    - { test1: c, test2: d}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 两次debug循环,输出的内容都保存在results序列中,属于results
---
- hosts: node2
  gather_facts: no
  tasks:
  - shell: "{{item}}"
    with_items:
    - "ls /opt"
    - "ls /home"
    register: returnvalue
  - debug:
      var: returnvalue
# 可以使用如下方式,避免所有结果在最后的results中去获取
---
- hosts: node2
  gather_facts: no
  tasks:
  - shell: "{{item}}"
    with_items:
    - "ls /opt"
    - "ls /home"
    register: returnvalue
  - debug:
      msg: "{{item.stdout}}'
    with_items: "{{returnvalue.results}}"
# 先使用循环重复的调用了shell模块，然后将shell模块每次执行后的返回值注册到了变量”returnvalue”中，之后，在使用debug模块时，通过返回值”results”获取到了之前每次执行shell模块的返回值（shell每次执行后的返回值已经被放入到item变量中），最后又通过返回值”stdout”获取到了每次shell模块执行后的标准输出

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

---
- hosts: node2
  remote_user: root
  gather_facts: no
  tasks:
  - debug:
      msg: "{{ item }}"
    with_together:
    - [ 1, 2, 3 ]
    - [ a, b, c ]
# 输出如下:
TASK [debug] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
ok: [node2] => (item=[1, u'a']) => {
    "changed": false,
    "item": [
        1,
        "a"
    ],
    "msg": [
        1,
        "a"
    ]
}
ok: [node2] => (item=[2, u'b']) => {
    "changed": false,
    "item": [
        2,
        "b"
    ],
    "msg": [
        2,
        "b"
    ]
}
ok: [node2] => (item=[3, u'c']) => {
    "changed": false,
    "item": [
        3,
        "c"
    ],
    "msg": [
        3,
        "c"
    ]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 下面的例子会在node2下创建6个目录
---
- hosts: node2
  remote_user: root
  gather_facts: no
  tasks:
  - file:
      state: directory
      path: "/testdir/testdir/{{ item.0 }}/{{ item.1 }}"
    with_cartesian:
    - [ a, b, c ]
    - [ test1, test2 ]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

---
- hosts: node2
  remote_user: root
  gather_facts: no
  tasks:
  - debug:
      msg: "{{ item }}"
    with_indexed_items:
    - test1
    - test2
    - test3
# 输出如下:
TASK [debug] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
ok: [node2] => (item=(0, u'test1')) => {
    "changed": false,
    "item": [
        0,
        "test1"
    ],
    "msg": [
        0,
        "test1"
    ]
}
ok: [node2] => (item=(1, u'test2')) => {
    "changed": false,
    "item": [
        1,
        "test2"
    ],
    "msg": [
        1,
        "test2"
    ]
}
ok: [node2] => (item=(2, u'test3')) => {
    "changed": false,
    "item": [
        2,
        "test3"
    ],
    "msg": [
        2,
        "test3"
    ]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# debug模块被循环调用了5次，msg的值从1一直输出到了5，值的大小每次增加1
---
- hosts: node2
  remote_user: root
  gather_facts: no
  tasks:
  - debug:
      msg: "{{ item }}"
    with_sequence: start=1 end=5 stride=1
    # 下列写法结果一致
    # with_sequence: count=5

1
2
3
4
5
6
7
8

---
- hosts: node2
  remote_user: root
  gather_facts: no
  tasks:
  - debug:
      msg: "{{item}}"
    with_sequence: start=2 end=6 stride=2 format="number is %0.2f"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

---
- hosts: node2
  remote_user: root
  gather_facts: no
  tasks:
  - debug:
      msg: "{{item}}"
    with_random_choice:
    - 1
    - 2
    - 3
    - 4
    - 5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

---
- hosts: node2
  remote_user: root
  gather_facts: no
  vars:
    users:
      alice:
        name: Alice Appleworth
        gender: female
        telephone: 123-456-7890
      bob:
        name: Bob Bananarama
        gender: male
        telephone: 987-654-3210
  tasks:
  - debug:
      msg: "{{item}}"
    with_dict: "{{users}}"
# 输出如下:
TASK [debug] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
ok: [node2] => (item={'value': {u'gender': u'male', u'name': u'Bob Bananarama', u'telephone': u'987-654-3210'}, 'key': u'bob'}) => {
    "changed": false,
    "item": {
        "key": "bob",
        "value": {
            "gender": "male",
            "name": "Bob Bananarama",
            "telephone": "987-654-3210"
        }
    },
    "msg": {
        "key": "bob",
        "value": {
            "gender": "male",
            "name": "Bob Bananarama",
            "telephone": "987-654-3210"
        }
    }
}
ok: [node2] => (item={'value': {u'gender': u'female', u'name': u'Alice Appleworth', u'telephone': u'123-456-7890'}, 'key': u'alice'}) => {
    "changed": false,
    "item": {
        "key": "alice",
        "value": {
            "gender": "female",
            "name": "Alice Appleworth",
            "telephone": "123-456-7890"
        }
    },
    "msg": {
        "key": "alice",
        "value": {
            "gender": "female",
            "name": "Alice Appleworth",
            "telephone": "123-456-7890"
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

# 如下示例:
---
- hosts: node2
  remote_user: root
  gather_facts: no
  vars:
    users:
    - name: bob
      gender: male
      hobby:
        - Skateboard
        - VideoGame
    - name: alice
      gender: female
      hobby:
        - Music
  tasks:
  - debug:
      msg: "{{ item }}"
    with_subelements:
    - "{{users}}"
    - hobby
# 输出如下:
TASK [debug] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
ok: [node2] => (item=({u'gender': u'male', u'name': u'bob'}, u'Skateboard')) => {
    "changed": false,
    "item": [
        {
            "gender": "male",
            "name": "bob"
        },
        "Skateboard"
    ],
    "msg": [
        {
            "gender": "male",
            "name": "bob"
        },
        "Skateboard"
    ]
}
ok: [node2] => (item=({u'gender': u'male', u'name': u'bob'}, u'VideoGame')) => {
    "changed": false,
    "item": [
        {
            "gender": "male",
            "name": "bob"
        },
        "VideoGame"
    ],
    "msg": [
        {
            "gender": "male",
            "name": "bob"
        },
        "VideoGame"
    ]
}
ok: [node2] => (item=({u'gender': u'female', u'name': u'alice'}, u'Music')) => {
    "changed": false,
    "item": [
        {
            "gender": "female",
            "name": "alice"
        },
        "Music"
    ],
    "msg": [
        {
            "gender": "female",
            "name": "alice"
        },
        "Music"
    ]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

---
- hosts: node2
  remote_user: root
  gather_facts: no
  vars:
    users:
    - name: bob
      gender: male
      hobby:
        - Skateboard
        - VideoGame
    - name: alice
      gender: female
      hobby:
        - Music
  tasks:
  - debug:
      msg: "{{ item.0.name }} 's hobby is {{ item.1 }}"
    with_subelements:
    - "{{users}}"
    - hobby
# msg内容如下:
"msg": "bob 's hobby is Skateboard"
"msg": "bob 's hobby is VideoGame"
"msg": "alice 's hobby is Music"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 无论目标主机是谁，都可以通过with_file关键字获取到ansible主机中的文件内容
---
- hosts: node2
  remote_user: root
  gather_facts: no
  tasks:
  - debug:
      msg: "{{ item }}"
    with_file:
    - /testdir/testdir/a.log
    - /opt/testfile

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

---
- hosts: node2
  remote_user: root
  gather_facts: no
  tasks:
  - debug:
      msg: "{{ item }}"
    with_fileglob:
    - /testdir/(此处为星号,删除防止下面格式错乱)
# 输出如下:
TASK [debug] xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
ok: [node2] => (item=/testdir/testfile) => {
    "changed": false,
    "item": "/testdir/testfile",
    "msg": "/testdir/testfile"
}
ok: [node2] => (item=/testdir/test.sh) => {
    "changed": false,
    "item": "/testdir/test.sh",
    "msg": "/testdir/test.sh"
}
# 需要注意的是，with_fileglob只会匹配指定目录中的文件，而不会匹配指定目录中的目录

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

---
- hosts: node2
  remote_user: root
  tasks:
  - name: test when
    debug:
      msg: "System is centos"
    # 如果需要获取到facts中的key的值，都是通过引用变量的方式获取的，即"{{ key }}"
    # 在when关键字中引用变量时，变量名不需要加"{{  }}"
    when: ansible_distribution == "CentOS"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

---
- hosts: node2
  remote_user: root
  gather_facts: no
  tasks:
  - debug:
      msg: "{{item}}"
    with_items:
    - 1
    - 2
    - 3
    when: item > 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# 示例1:
---
- hosts: node2
  remote_user: root
  tasks:
  - debug:
      msg: "System release is centos7"
    when:
    # 使用列表,列表中的每一项都是一个条件，列表中的所有条件同时成立时，对应的任务才会执行
    - ansible_distribution == "CentOS"
    - ansible_distribution_major_version == "7"
# 示例2:
---
- hosts: node2
  remote_user: root
  tasks:
  - debug:
      msg: "System release is centos6 or centos7"
    # 比较运算符和逻辑运算符结合使用作为条件判断
    when: ansible_distribution == "CentOS" and
          (ansible_distribution_major_version == "6" or ansible_distribution_major_version == "7")
# 示例3:
---
- hosts: node2
  remote_user: root
  tasks:
  - debug:
      msg: "System release is not centos"
    # 逻辑取反
    when: not ansible_distribution == "CentOS"
# 示例4:
---
- hosts: node2
  remote_user: root
  tasks:
  - name: task1
    shell: "ls /testabc"
    register: returnmsg
  - name: task2
    debug:
      msg: "Command execution successful"
    # 通过shell指令的返回值判断是否执行
    when: returnmsg.rc == 0
  - name: task3
    debug:
      msg: "Command execution failed"
    when: returnmsg.rc != 0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

---
- hosts: node2
  remote_user: root
  tasks:
  - name: task1
    shell: "ls /testabc"
    register: returnmsg
    # 此处增加了ignore_errors,在不存在/testabc目录的节点就不会报错,playbook不会退出,task2,task3通过rc值来确定是否要执行
    ignore_errors: true
  - name: task2
    debug:
      msg: "Command execution successful"
    when: returnmsg.rc == 0
  - name: task3
    debug:
      msg: "Command execution failed"
    when: returnmsg.rc != 0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

---
- hosts: me
  gather_facts: no
  remote_user: root
  vars:
    testpath: /testdir
  tasks:
  - name: test tests
    debug:
      msg: "test dir exist"
    # "is exists"中的"exists"就是tests的一种，它与"test -e"命令的作用是相同的，通过"exists"可以判断ansible主机中的对应路径是否存在
    # "is not exists"表示对应路径不存在时返回真
    # 上述内容都是在ansible主机中判断的,和远端目标主机无关
    when: testpath is exists