Ansible 学习 && 使用笔记

在这里插入图片描述

文章目录

闲扯

今晚有点空，整理一下博客。一个半月没打理，怎么就过五百篇了，得清理下。
这篇是把我 “Ansible” 系列的 19 篇整合一下，加上我这段时间的所见所闻所用，自然会有所删减。
各位也可以在这篇的基础上拿走自行增删作为自己的工具字典。

安装 ansible

Ansible可以运行在任何机器上，但是对管理机有一定要求。管理机应安装Python 2（2.7）或Python 3（3.5或更高版本），另外，管理机不支持Windows控制节点。我们可以使用Linux发行版包管理器、源码安装或者Python包管理器（PIP）来安装Ansible。

我使用的是 CentOS7。

1、配置EPEL YUM

2、yum install ansible -y #yum安装最新版

3、ansible --version #安装后查看版本以及模块路径等信息

配置证书登录

为了使Ansible与客户端通信，需要使用用户帐户配置管理机和客户机。为了方便快捷安全，一般会配置证书方式连接客户机。

在所有客户机和管理上创建新的ansible用户之后，我们在管理机（ansible用户）生成SSH密钥，然后将SSH公钥复制到所有客户机。

ssh-keygen

三个回车，要是想后面执行一条命令就要输入一次 ssh 密码的话也可以给它个密码。

现在，将SSH公钥复制到所有客户机，这使管理机ansible用户无需输入密码即可登录客户机：

ssh-copy-id -i ~/.ssh/id_rsa.pub 远程主机名@远程主机ip

Ansible 配置文件

1、/etc/ansible/hosts：主机列表清单，也叫Inventory。在大规模的配置管理工作中，特别是云服务提供商或者IDC厂家，需要管理不同业务的不同机器，这些机器的信息都存放在Ansible的inventory组件里面。在我们使用Ansible进行远程主机管理时，必须先将主机信息存放在inventory里面，这样才能使用Ansible对它进行操作。如果不想使用默认清单的话可以用-i选项指定自定义的清单文件，防止多人混合使用一个主机清单。如果没有定义在主机列表文件中，执行命令会提示“No hosts matched”

2、/etc/ansible/ansible.cfg：Ansible服务主配置文件，比如并发数控制等在此文件定义

Inventory 定义方法

方法一：将主机IP、端口、用户名、密码写在配置文件的不同组中，多种写法格式如下

vim /etc/ansible/hosts
[webserver]  #组名为webserver
192.168.1.31 ansible_ssh_port=22 ansible_ssh_user=root ansible_ssh_pass="123456"
192.168.1.32 ansible_ssh_port=22 ansible_ssh_user=root ansible_ssh_pass="123456"
192.168.1.33 ansible_ssh_port=22 ansible_ssh_user=root ansible_ssh_pass="123456"
192.168.1.36 ansible_ssh_port=22 ansible_ssh_user=root ansible_ssh_pass="123456"

[dbserver]  #组名为dbserver
192.168.1.4[1:3] ansible_ssh_port=22 ansible_ssh_user=root ansible_ssh_pass="123456"  #连续IP的简写

[redis]
192.168.1.5[1:3]
[redisserver:vars]  #将信息定义为变量
ansible_ssh_pass="123456"

[nginx] #推荐写法
nginx_1 ansible_ssh_host=192.168.1.61 ansible_ssh_port=22 ansible_ssh_user=root ansible_ssh_pass="123456"
nginx_2 ansible_ssh_host=192.168.1.62 ansible_ssh_port=22 ansible_ssh_user=root ansible_ssh_pass="123456"

方法二：自定义Inventory清单文件

#创建清单文件
vim /etc/ansible/dockers
[dockers]
192.168.1.31 ansible_ssh_pass='123456'
192.168.1.32
192.168.1.33
#使用-i指定清单文件
ansible dockers -m ping -i /etc/dockers

这里我要说一下我的学习方法，ansible 这么多模块，记我是肯定记不住的，我是直接拿组里用的 ansible 学习、运行、看日志、再一行一行去读懂代码的。所以下面的模块可能会有点混乱。无伤大雅。

Andible 常用模块和基本操作

这些常用的模块，就好比基本功，基本招式一样，我们需要掌握这些基本功，掌握这些基本招式。

ping 模块

ping是测试远程节点的SSH连接是否就绪的常用模块，但是它并不像Linux命令那样简单地ping一下远程节点，而是先检查能否通过SSH登陆远程节点，再检查其Python版本能否满足要求，如果都满足则会返回pong，表示成功。使用方式如下：

ansible web -m ping

ping无须任何参数。上述命令输出结果如下所示：

192.168.1.2 | SUCCESS => {
    
    
    "changed": false,
    "ping": "pong"
}
192.168.1.4 | SUCCESS => {
    
    
    "changed": false,
    "ping": "pong"
}

debug模块

打印输出信息，类似Linux上的echo命令。在后续的学习过程中，我们会经常用这个命令来调试我们写的playbook。

对于debug模块有两种用法。下面就对这两种用法都进行详细的总结。

通过参数msg定义打印的字符串
msg中可以嵌入变量，比如我先定义了以下的一个playbook。

  ---
  
  - hosts: web
    vars:
      name: jellythink
    tasks:
      - name: display
        debug: msg="I am {
    
    {
    
    name}}"

通过参数var定义需要打印的变量
变量可以是系统变量，也可以是动态的执行结果，通过关键字register注入变量中。对于变量，我们可以这样玩：

---

- hosts: web
  vars:
    name: jellythink
  tasks:
    - name: display
      debug:
        var: name

对于注入变量，可以这样玩：

---

- hosts: web
  tasks:
    - name: register var
      shell: hostname
      register: result
    - name: display
      debug:
        var: result

copy模块

从当前的机器上复制静态文件到远程节点上，并且设置合理的文件权限。copy模块在复制文件的时候，会先比较一下文件的 checksum，如果相同则不会复制，返回状态为 OK；如果不同才会复制，返回状态为 changed。

一般情况的使用，就是这样的：

---

- hosts: server1
  tasks:
    - name: copyDemo
      copy:
        src: /home/jelly/nameList.txt 
        dest: /home/test1/nameList.txt

在实际的工作中，一般会在进行文件分发时，需要备份原文件，这个时候就需要我们加上backup选项：

---

- hosts: server1
  tasks:
    - name: copyDemo
      copy:
        src: /home/jelly/nameList.txt 
        dest: /home/test1/nameList.txt
        backup: yes

加上backup: yes后，在目标主机上，就会对原来的文件进行备份。

template模块

如果只是复制静态文件，使用copy模块就可以了；但是如果在复制的同时需要根据实际情况修改部分内容，那么就需要用到template模块了。

比如我们在分发配置文件时，每个配置文件需要根据远程主机的一些属性不同而配置不同的值，对于需要替换的部分，我们就可以使用template模块来进行替换。template模块使用的是Python中的Jinja2模板引擎，这里我们不需要过多的去关注这个模板引擎，只需要知道变量的表示法是{ {}}就可以了。比如这里就有一个http.conf.j2的模板文件（我见过的更多的模板文件后缀都是 yaml 的），文件内容如下：

Listen {
   
   {ansible_default_ipv4.address}}
Port {
   
   {http_port}}

其中{ {ansible_default_ipv4.address}}就是需要根据不同的主机，动态变化的。接下来，我们就可以这样使用template模块来完成变量的替换。

---

- hosts: server1
  vars:
    http_port: 8080

  tasks:
  - name: Write Config File
    template:
      src: http.conf.j2
      dest: /home/test1/http.conf

在目的主机上，文件内容如下：

Listen 192.168.1.3
Port 8080

和copy模块一样，template模块也可以进行权限设置和文件备份等功能。

file模块

file模块可以用来设置远程主机上的文件、软链接和文件夹的权限，也可以用来创建和删除它们。

我们可以使用mode参数进行权限修改，可以直接赋值数字权限（必须以0开头）。

---

- hosts: server1
  tasks:
  - name: Modify Mode
    file:
      path: /home/test1/http.conf
      mode: 0777

我们还可以根据state参数的不同，实现不同的行为，比如创建软链接：

---

- hosts: server1
  tasks:
    - name: Create Soft Link
      file:
        src: /home/test1/http.conf
        dest: /home/test1/conf
        state: link

也可以设置state: touch创建一个新文件，比如这样：

---

- hosts: server1
  tasks:
    - name: Create a new file
      file:
        path: /home/test1/touchfile
        state: touch 
        mode: 0700

还可以设置state: directory新建一个文件夹，比如这样：

---

- hosts: server1
  tasks:
    - name: Create directory
      file: 
        path: /home/test1/testDir
        state: directory
        mode: 0755

user模块

user模块可以对用户进行管理，实现增、删、改Linux远程节点的用户账户。比如增加用户：

---

- hosts: server1
  tasks:
    - name: Add user
      user:
        name: test3

删除用户：

---

- hosts: server1
  tasks:
    - name: Add user
      user:
        name: test3
        state: absent
        remove: yes

但是在使用这个user模块时，需要注意权限问题。

shell模块

在远程节点上通过/bin/sh执行命令。如果一个命令可以通过模块yum、copy模块实现时，那么建议不要使用shell或者command这样通用的命令模块。因为通用的命令模块不会根据具体操作的特点进行状态判断，所以当没有必要再重新执行的时候，它还是会重新执行一遍。

支持<、>、|、;和&

--- 
- hosts: server1
  tasks:
    - name: Test shell
      shell: echo "test1" > ~/testDir/test1 && echo "test2" > ~/testDir/test2

调用脚本

---

- hosts: server1
  tasks:
    - shell: ~/test.sh >> somelog.txt

在执行命令之前，我们可以改变工作目录，并且仅在文件somelog.txt不存在时执行命令，除此之外，还可以指定用bash运行命令：

---

- hosts: server1
  tasks:
    - shell: ~/test.sh >> somelog.txt
      args:
        chdir: ~/testDir
        creates: somelog.txt
        executable: /bin/bash

service/systemd

管理服务。

- name: 服务管理
  service:
    name: etcd
    state: started
    #state: stopped
    #state: restarted
    #state: reloaded
- name: 设置开机启动
  service:
    name: httpd
    enabled: yes
- name: 服务管理  
  systemd: 
	name=etcd 
	state=restarted 
	enabled=yes 
	daemon_reload=yes

archive&unarchive

1. archive模块

功能：在远端主机打包与压缩；

主要参数如下：

参数	说明
path	要压缩的文件或目录
dest	压缩后的文件
format	指定打包压缩的类型：bz2、gz、tar、xz、zip

示例一：将 /var/log 目录压缩为 tar.gz 格式，并存储至 /opt 目录下；

[root@xuzhichao ~]# ansible 192.168.20.23 -m archive -a 'path=/var/log dest=/opt/log.tar.gz format=gz'

[root@nginx03 ~]# ll /opt
total 692
-rw-r--r-- 1 root root 705807 Aug  2 15:22 log.tar.gz

2. unarchive模块

功能：在远端主机解包与解压缩；

主要参数如下：

参数	说明
src	要解压的软件包路径
dest	解压到目标位置，需要是一个目录
remote_src	yes：要解压的包在被控端、no：要解压的包在控制端
owner	文件复制到远程并设定属主，默认为root
group	文件复制到远程并设定属组，默认为root
mode	文件复制到远程并设定权限，默认file=644，directory=755

示例一：把压缩包推送到被控端，在被控端主机解压缩：

  #把压缩包拷贝到远端主机：
  [root@xuzhichao ~]# ansible 192.168.20.23 -m copy -a 'src=/root/nginx-1.20.1.tar.gz dest=/tmp/'
  
  #在远端主机解压缩：
  [root@xuzhichao ~]# ansible 192.168.20.23 -m copy -a 'src=/tmp/nginx-1.20.1.tar.gz dest=/tmp/nginx-1.20.1 remote_src=yes'

示例二：压缩包在ansible主机上，直接解压到被控主机：

  [root@xuzhichao ~]# ansible 192.168.20.23 -m unarchive -a 'src=/root/nginx-1.20.1.tar.gz dest=/tmp/'
  
  [root@nginx03 ~]# ll /tmp/
  total 0
  drwxr-xr-x 8 xu1 xu1 158 May 25 20:35 nginx-1.20.1

（其他遗漏，文末补全）

Ansible playbook

playbook本质是包含了一个或多个play的YAML配置文件，通常以.yaml或者.yml结尾。在单一的一个playbook文件中，使用连续的三个中横线（—）作为每个play的区分。

执行playbook命令

我们都是按照yaml语法规则来编写playbook。

Ansible提供了一个单独的命令：ansible-playbook命令，我们可以通过这个命令来执行yaml脚本。常见的ansible-playbook的使用方法如下：

最简单的使用方法：

ansible-playbook copyDemo.yaml

我们还可以使用以下命令查看输出的细节：

ansible-playbook copyDemo.yaml --verbose

我们也可以使用以下命令查看该yaml脚本将影响的主机列表：

ansible-playbook copyDemo.yaml --list-hosts

还可以使用以下命令检查yaml脚本语法是否正确：

ansible-playbook copyDemo.yaml --syntax-check

上面的几种使用方法基本就涵盖了我们日常工作中80%的场景了，剩余的20%场景，比如并行、异步等，很少用到，等真正用到的时候再去查阅相关资料也来的及。而工作中，更多的时候，我们不是在编写playbook，就是在编写playbook的路上。所以，接下来我重点说说如何写这个playbook，也就是playbook的基本语法。

playbook基本语法

最基本的playbook脚本分为三个部分：

在哪些机器上以什么身份执行
执行的任务有哪些
善后任务有哪些

我们在编写playbook脚本的时候，总是离不开上面的三个部分的。下面先来一个稍微有点复杂的playbook脚本，让大家先有一个整体的认识。

---
- hosts: server1
  user: root
  vars:
    http_port: 80
    max_clients: 200

  tasks:
    - name: Write apache config file
      template: src=/home/test1/httpd.j2 dest=/home/test2/httpd.conf
      notify:
        - restart apache
    - name: Ensure apache is running
      service: name=httpd state=started

  handlers:
    - name: restart apache
      service: name=httpd state=restarted

任务列表

任务列表是整个playbook的核心，对于任务列表，我们首先需要知道以下三点内容：

任务是从上到下顺序执行的，如果中间发生错误，那么整个playbook会中止，除非 ignore error；
每一个任务都是对模块的一次调用，只是使用不同的参数和变量而已；
每一个任务最好有一个name属性，这样在执行yaml脚本时，可以看到执行进度信息（也方便失败的时候快速定位）。

对于任务的参数有两种不同的写法，我们在编写yaml脚本时，可以按照自己的喜好进行选择。

写法一：

- name: Write apache config file
  template: src=/home/test1/httpd.j2 dest=/home/test2/httpd.conf

写法二：

- name: Write apache config file
  template: 
    src: /home/test1/httpd.j2
    dest: /home/test2/httpd.conf

这两种写法都是OK的，我一般喜欢第二种写法。

最后，对于任务我们还需要特别一个点，那就是任务的执行状态。我们在执行Ansible Ad-Hoc或者ansible-playbook的时候，在输出中都会有一个changed字段，比如：

192.168.1.3                : ok=2    changed=0    unreachable=0    failed=0

或者

192.168.1.3                : ok=2    changed=1    unreachable=0    failed=0

这里的这个changed就是任务的执行状态，但是它为什么一会是0，一会有是1呢？这就要说到Ansible中一个叫做“幂等性”的概念。

幂等性

幂等性是数学和计算机科学上一个常见的概念，多次执行产生的结果不会发生改变，这样的特性就被成为幂等性。

大多数的Ansible模块在设计时保证了幂等性，幂等性保证了Ansible脚本多次执行情况下的相同结果，尽可能的避免使用那些不能满足幂等性的模块。比如我们经常使用的shell模块就是非幂等性的。

我们要明白Ansible是以“结果为导向的”，我们指定了一个“目标状态”，Ansible会自动判断“当前状态”是否与“目标状态”一致，如果一致，则不进行任何操作；如果不一致，那么就将“当前状态”变成“目标状态”，这就是“幂等性”，“幂等性”可以保证我们重复的执行同一项操作时，得到的结果是一样的。

那这个幂等性与上面的changed又有什么关系呢？且听我下面慢慢道来！

当changed为false或者0时，表示Ansible没有进行任何操作，没有“改变什么”；
当changed为true或者大于0时，表示Ansible执行了操作，“当前状态”已经被Ansible改变成了“目标状态”。

拿copy这个模块来举例子说明，当我们准备将一个文件通过Ansible拷贝到远程主机时，copy模块首先检查远程是否已经存在了该文件，如果不存在，则把文件拷贝过去，返回changed为大于0；如果存在时，则开始比对两个文件的md5值，如果md5值一致，则说明两个文件是一样的，则不需要拷贝，此时copy模块则什么都不干，返回changed为0。

playbook的handlers与notify

一、Ansible handlers的作用

handlers是一种触发器，它可以对task进行监控，如果task所指定的任务状态发生变化，则进行notify通知，然后触发额外的一系列操作，看一个示例来帮助理解：

- hosts: webservers
  remote_user: root
  tasks:
  - name: install apache
    yum: name=httpd state=latest
  - name: install configure file for httpd
    copy: src=/root/conf/httpd.conf dest=/etc/httpd/conf/httpd.conf
  - name: start httpd service
    service: enabled=true name=httpd state=started

上面的YAML文件存在三个task任务，分别是安装httpd、复制配置文件到远端主机、启动httpd服务。但是当第二个task中的配置文件发生了改变后再次执行playbook的话，会发现新的配置文件虽然会正确的复制到远端主机去，但是却没有重启httpd服务。因为Ansible在执行playbook时发现第三个任务与现在状态是一致的，就不会再次执行任务。为了解决这种问题，就需要使用ansible的handlers功能。handlers是用于监控一个任务的执行状态，如果一个tasks任务最后是changed状态则会触发handlers指定的操作。

二、如何配置handlers

Ansible中通过notify这个模块来实现handlers，将示例1修改后：

- hosts: webservers
  remote_user: root
  tasks:
  - name: install apache
    yum: name=httpd state=latest
  - name: install configure file for httpd
    copy: src=/root/conf/httpd.conf dest=/etc/httpd/conf/httpd.conf
    notify:
    - restart httpd  #通知restart httpd这个触发器
    - check httpd  #可以定义多个触发器
  - name: start httpd service
    service: enabled=true name=httpd state=started
  handlers：  #定义触发器，和tasks同级
  - name: restart httpd  #触发器名字，被notify引用，两边要一致
    service: name=httpd state=restart
  - name: check httpd
    shell: netstat -ntulp | grep 80

当httpd.conf的源文件发生修改后，只需重新执行playbook就会自动重启httpd服务，因为配置文件状态是changed而非ok。

playbook的变量定义与调用

1.作用：将playbook中的某些值使用变量代替，从而简化playbook的编写
2.变量简介：要创建的用户、要安装的软件包、要重启的服务、要删除的文件、要从互联网检索的文档
3.方法：变量名应该由字母、数字、下划线组成，变量名需要以字母开头，ansible内置的关键字不能作为变量名。
4.范围

全局范围：从命令行或ansible配置设置的变量
play范围：在play和相关结构中设置的变量
主机范围：由清单、事实收集或注册的任务，在主机组和个别主机上设置的变量
如果多个级别上定义了相同名称的变量，优先采用级别最高的变量，窄范围优先于广范围

vars定义变量

1、playbook中的变量（vars和vars_files）

vars:
  - testvar1: testfile
  - testvar2: testfile2

在定义变量时，还能够以类似”属性”的方式定义变量，示例如下

---
- hosts: testB
  remote_user: root
  vars:
    httpd:
      conf80: /etc/httpd/conf.d/80.conf
      conf8080: /etc/httpd/conf.d/8080.conf
  tasks:
  - name: task1
    file:
      path: "{
    
    {httpd.conf80}}"
      state: touch
  - name: task2
    file:
      path: "{
    
    {httpd.conf8080}}"
      state: touch

引用变量

当我们需要引用这两个变量时，有两种语法可用

"{
    
    {
    
    httpd.conf80}}"

在外部文件定义playbook变量（vars_files）
在playbook中引入包含变量的文件时，需要使用vars_files关键字，被引入的文件需要以- 开头，以YAML中块序列的语法引入，示例如下

---
- hosts: testB
  remote_user: root
  vars_files:
  - httpd_vars.yml
  tasks:
  - name: task1
    file:
      path={
    
    {
    
    httpd.conf80}}
      state=touch
  - name: task2
    file:
      path={
    
    {
    
    httpd['conf8080']}}
      state=touch

在外部文件中写入

  - testvar1: testfile
  - testvar2: testfile2

httpd:
  conf80: /etc/httpd/conf.d/80.conf
  conf8080: /etc/httpd/conf.d/8080.conf

上例中使用vars_files关键字引入了对应的变量文件，然后使用了文件中定义的变量。

上例中vars_files关键字只引入了一个变量文件，也可以引入多个变量文件，每个被引入的文件都需要以- 开头，示例如下

 vars_files:
  - /testdir/ansible/httpd_vars.yml
  - /testdir/ansible/other_vars.yml

“vars”关键字和”vars_files”关键字可以同时使用，如下

 vars:
  - conf90: /etc/httpd/conf.d/90.conf
  vars_files:
  - /testdir/ansible/httpd_vars.yml

流程控制

条件：

tasks:
- name: 只在192.168.1.100运行任务
  debug: msg="{
   
   {ansible_default_ipv4.address}}"
  when: ansible_default_ipv4.address == '192.168.1.100'

循环：

tasks:
- name： 批量创建用户
  user: name={
    
    {
    
     item }} state=present groups=wheel
  with_items:
     - testuser1
     - testuser2
- name: 解压
  copy: src={
    
    {
    
     item }} dest=/tmp
  with_fileglob:
    - "*.txt"

常用循环语句：

语句	描述
with_items	标准循环
with_fileglob	遍历目录文件
with_dict	遍历字典

使用template实现灵活配置

一、Ansible template 作用

是什么前面说了，这里就直接看怎么用。

---
- hosts: all
  remote_user: root
  vars:
    - listen_port: 88    #定义变量

  tasks:
    - name: Install Httpd
      yum: name=httpd state=installed
    - name: Config Httpd
      template: src=httpd.conf.j2 dest=/etc/httpd/conf/httpd.conf    #使用模板
      notify: Restart Httpd
    - name: Start Httpd
      service: name=httpd state=started
      
  handlers:
    - name: Restart Httpd
      service: name=httpd state=restarted

遗漏部分在文末补全。

Ansible 之 roles 使用

函数。

所有的 role 单独放在一个名为 roles 的目录下，在 playbook 中调用 role 的方式为：

- include_role: 某个 role 所在目录名

或者

roles: 某个 role 所在目录名

每个 role 下面有个 tasks 目录，里面至少得有 main.yaml 文件，会被调用到。

每个role下面有个目录叫meta，在里面可以新建文件main.yml，在文件中可以设置该role和其它role之前的关联关系。

是抽象了点，没办法啦，先这样，哪天有灵感了再说。

文末补全

ansible gather_facts配置

ansible playbook 默认第一个 task 是 Gathering Facts 收集各主机的 facts 信息，以方便我们在 paybook 中直接引用 facts 里的信息。

如果不需要用到 facts 信息的话，可以设置 gather_facts: false，来省去 facts 采集这一步以提高 playbook 效率。

如果既想用 facts 信息，有希望能提高 playbook 的效率的话，可以采用 facts 缓存来实现。
facts 缓存支持多种方式：json 文件方式，redis 方式，memcache 方式等。各种方式的配置都是在 ansible.cfg 中配置。

json 文件方式

gathering=smart
fact_caching_timeout=86400
fact_caching=jsonfile
fact_caching_connection=/path/to/ansible_fact_cache
1234

这里的 86400 单位为秒，表示缓存的过期时间。保存 facts 信息的 json 文件保存在 / path/to/ansible_fact_cache 下面，文件名是按照 inventory hostname 来命名的。

ansible 之 tag

你写了一个很长的playbook，其中有很多的任务，这并没有什么问题，不过在实际使用这个剧本时，你可能只是想要执行其中的一部分任务而已，或者，你只想要执行其中一类任务而已，而并非想要执行整个剧本中的全部任务，这个时候我们该怎么办呢？我们可以借助tags实现这个需求。

见名知义，tags可以帮助我们对任务进行’打标签’的操作，当任务存在标签以后，我们就可以在执行playbook时，借助标签，指定执行哪些任务，或者指定不执行哪些任务了，这样说可能不够直观，我们来看一个小示例（为了方便示例此处只写3个任务进行举例）。

---
- hosts: test70
  tasks:
  - name: task1
    tags: t1

  - name: task2
    tags: t2

  - name: task3
    tags: t3

如上例所示，上例的play中有3个task，每个task都有对应的tags，假如在执行上述playbook时，我们只想执行task2，该怎样执行呢？我们可以使用如下命令

ansible-playbook --tags=t2 testtag.yml

如你所见，可以使用–tags选项指定某个标签，当指定标签后，只有标签对应的任务会被执行，其他任务都不会被执行，执行上述命令后，只有task2会执行，因为task2的标签值为t2，task1和task3都不会执行，这样就达到了只执行playbook中部分任务的目的。

借助标签，除了能够指定”需要执行的任务”，还能够指定”不执行的任务”，示例命令如下。

ansible-playbook --skip-tags='t2' testtag.yml

我们可以使用 –skip-tags选项指定”不执行的任务”，执行上述命令后，task1和task3会执行，task2不会执行，因为我们已经在命令中指定了’跳过’标签t2所对应的任务，相当于使用了’排除法’，t2对应的任务被排除了，其他任务都会执行。
其实，我们可以为每个任务添加多个标签

tags:
 - testtag
 - t1

在调用标签时，也可以一次性指定多个标签，调用多个标签需要用逗号隔开，命令如下

ansible-playbook --tags package,service testhttpd.yml

在调用标签之前，如果你想要概览一下playbook中都有哪些标签，可以使用 ‘ –list-tags’ 选项，示例如下

ansible-playbook --list-tags testhttpd.yml

其实，ansible还预置了5个特殊tag，这5个特殊tag分别为

always

never(2.5版本中新加入的特殊tag)

tagged

untagged

all

当我们把任务的tags的值指定为always时，那么这个任务就总是会被执行，除非你使用’–skip-tags’选项明确指定不执行对应的任务。

ansible 之 block

当我们想在满足一个条件下，执行多个任务时，就需要分组了。而不再每个任务都要用when。

  tasks: 
   - block:
     - command: echo 1
     - shell: echo 2
     - raw: echo 3
     when: ansible_distribution == 'CentOS'

错误处理

tasks:
  - block:
      - debug: msg='i execute normally'
      - command: /bin/false
      - debug: msg='i never execute, cause ERROR!'
    rescue:
      - debug: msg='I caught an error'
      - command: /bin/false
      - debug: msg='I also never execute :-('
    always:
      - debug: msg="this always executes"

block中的任务在执行中，如果有任何错误，将执行rescue中的任务。无论在block和rescue中发生或没有发生错误，always部分都运行。

ansible 之 stat

检查文件或文件系统的状态，对于Windows目标，请改用win_stat模块

参数

path：文件/对象的完整路径，required

示例

- tasks
  name: install_apcu | Check if apcu local file is already configured.
  stat: path={
    
    {
    
     php_apcu_file_path }}
  connection: local
  register: php_apcu_file_result

ansible 之 register

用于注册一个变量，保存命令的结果(shell或command模块)，这个变量可以在后面的task、when语句或模板文件中使用。

- hosts: node3
  tasks:
    - shell: pwd
      register: pwd_status

    - name: print pwd_ststus value
      debug: msg={
    
    {
    
     pwd_status }}

debug模块可以输出register模块中对应的变量属性。

ansible register 这个功能非常有用。当我们需要判断对执行了某个操作或者某个命令后，如何做相应的响应处理（执行其他 ansible 语句），则一般会用到register 。

举个例子：

我们需要判断sda6是否存在，如果存在了就执行一些相应的脚本，则可以为该判断注册一个register变量，并用它来判断是否存在，存在返回 succeeded, 失败就是 failed.

- name: Create a register to represent the status if the /dev/sda6 exsited
  shell: df -h | grep sda6
  register: dev_sda6_result
  ignore_errors: True
  tags: docker

- name: Copy docker-thinpool.sh to all hosts
  copy: src=docker-thinpool.sh dest=/usr/bin/docker-thinpool mode=0755
  when: dev_sda6_result | succeeded
  tags: docker

注意：
1、register变量的命名不能用 -中横线，比如dev-sda6_result，则会被解析成sda6_result，dev会被丢掉，所以不要用-
2、ignore_errors这个关键字很重要，一定要配合设置成True，否则如果命令执行不成功，即 echo $?不为0，则在其语句后面的ansible语句不会被执行，导致程序中止。

那我如何去做多种条件的判断呢，比如我还需要判断是否有 docker-thinpool 存在，则还需要为它注册一个变量。

- name: Create a register to represent the status if the docker-thinpool exsited
  shell: lsblk | grep docker-thinpool
  register: docker_thinpool_result
  ignore_errors: True
  tags: docker

然后在when中用and或者or来组合判断。比如当两种条件之一成功，都对docker配置文件进行修改：

- name: Special config for docker-thinpool devicemapper
  lineinfile: dest=/etc/sysconfig/docker regexp=^OPTIONS= line=OPTIONS='--selinux-enabled=false --insecure-registry=10.213.42.254:10500 --log-level=warn --storage-opt dm.basesize={
    
    {
    
     dm_base_size }} --storage-opt dm.loopdatasize={
    
    {
    
     dm_loop_data_size }} --storage-opt dm.loopmetadatasize={
    
    {
    
     dm_loop_meta_size }} --storage-driver=devicemapper --storage-opt=dm.thinpooldev=/dev/mapper/docker-thinpool --storage-opt=dm.use_deferred_removal=true --storage-opt=dm.use_deferred_deletion=true'
  when: (dev_sda6_result | succeeded) or (docker_thinpool_result | succeeded)
  tags: docker

ansible 之 ignore_errors

在playbook执行的过程中，难免会遇到一些错误。由于playbook遇到错误后，不会执行之后的任务，不便于调试，此时，可以使用ignore_errors来暂时忽略错误，使得playbook继续执行。

ansible 之 set_fact

set_fact是一个模块，我们可以通过set_fact模块在tasks中定义变量，先来看一个小示例，如下

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

ansible 之 wait_for

有些情况下，一些任务的运行需要等待一些状态的恢复，比如某一台主机或者应用刚刚重启，我们需要需要等待它上面的某个端口开启，此时就需要将正在运行的任务暂停，直到其状态满足要求。

Ansible提供了wait_for模块以实现任务暂停的需求

wait_for模块常用参数：

- connect_timeout：在下一个任务执行之前等待连接的超时时间
- delay：等待一个端口或者文件或者连接到指定的状态时，默认超时时间为300秒，在这等待的300s的时间里，wait_for模块会一直轮询指定的对象是否到达指定的状态，delay即为多长时间轮询一次状态。
- host：wait_for模块等待的主机的地址，默认为127.0.0.1
- port：wait_for模块待待的主机的端口
- path：文件路径，只有当这个文件存在时，下一任务才开始执行，即等待该文件创建完成
- state：等待的状态，即等待的文件或端口或者连接状态达到指定的状态时，下一个任务开始执行。当等的对象为端口时，状态有started，stoped，即端口已经监听或者端口已经关闭；当等待的对象为文件时，状态有present或者started，absent，即文件已创建或者删除；当等待的对象为一个连接时，状态有drained，即连接已建立。默认为started
- timeout：wait_for的等待的超时时间,默认为300秒

示例：

#等待8080端口已正常监听，才开始下一个任务，直到超时
- wait_for: 
    port: 8080 
    state: started  
    
#等待8000端口正常监听，每隔10s检查一次，直至等待超时
- wait_for: 
    port: 8000 
    delay: 10 
    
#等待8000端口直至有连接建立
- wait_for: 
    host: 0.0.0.0 
    port: 8000 
    delay: 10 
    state: drained
    
#等待8000端口有连接建立，如果连接来自10.2.1.2或者10.2.1.3，则忽略。
- wait_for: 
    host: 0.0.0.0 
    port: 8000 
    state: drained 
    exclude_hosts: 10.2.1.2,10.2.1.3 
    
#等待/tmp/foo文件已创建    
- wait_for: 
    path: /tmp/foo 

#等待/tmp/foo文件已创建，而且该文件中需要包含completed字符串    
- wait_for: 
    path: /tmp/foo 
    search_regex: completed 

#等待/var/lock/file.lock被删除    
- wait_for: 
    path: /var/lock/file.lock 
    state: absent 
    
#等待指定的进程被销毁
- wait_for: 
    path: /proc/3466/status 
    state: absent 
    
#等待openssh启动，10s检查一次
- wait_for: 
    port: 22 
    host: "{
    
    {
    
     ansible_ssh_host | default(inventory_hostname) }}" search_regex: OpenSSH 
    delay: 10

任务委托

在有些时候，我们希望运行与选定的主机或主机组相关联的task，但是这个task又不需要在选定的主机或主机组上执行，而需要在另一台服务器上执行。

这种特性适用于以下场景：

在告警系统中启用基于主机的告警
向负载均衡器中添加或移除一台主机
在dns上添加或修改针对某个主机的解析
在存储节点上创建一个存储以用于主机挂载
使用一个外部程序来检测主机上的服务是否正常

可以使用delegate_to语句来在另一台主机上运行task：

- name: enable alerts for web servers
  hosts: webservers
  tasks:
    - name: enable alerts
      nagios: action=enable_alerts service=web host="{
    
    {
    
     inventory_hostname }}"
      delegate_to: nagios.example.com

如果delegate_to: 127.0.0.1的时候，等价于local_action

ansible 之 lineinfile

正则模块。

下面我们详细说一说其具体可以做的事情。

修改匹配行

下面是一个简单的task示例：

# 将/etc/selinux/config中匹配到以'SELINUX='开头的行，将其替换为'SELINUX=disabled'
- name: modify selinux to disabled
  lineinfile:
    path: /etc/selinux/config
    regex: '^SELINUX='
    line: 'SELINUX=disabled'

在匹配行前或后添加内容

示例文件如下：

# cat /etc/http.conf

Listen 127.0.0.1:80
Listen 80
Port

在匹配行前添加

在http.conf文件的Listen 80前面添加一行Listen 8080，task示例如下：

- name: add line before Listen 80
  lineinfile:
    dest: /etc/http.conf
    insertbefore: '^Listen 80'
    line: 'Listen 8080'

在匹配行后添加

在http.conf文件的Port后面添加一行just a test，task示例如下：

- name: add line before Listen 80
  lineinfile:
    dest: /etc/http.conf
    insertafter: '^Port'
    line: 'just a test'

修改文件内容及权限

示例文件：

#cat /etc/hosts

127.0.0.1       localhost.localdomain localhost ::1       localhost6.localdomain6 localhost6
192.168.0.130     hub.breezey.top

修改/etc/hosts，将以127.0.0.1开头的行替换为127.0.0.1 localhost，并将/etc/hosts的属主和属组都修改为root，权限改为644，如下：

- name: modify hosts
  lineinfile:
    dest: /etc/hosts
    regex: '^127\.0\.0\.1'
    line: '127.0.0.1 localhost'
    owner: root
    group: root
    mode: 0644

删除一行内容

示例原文件：

#cat /etc/hosts

127.0.0.1       localhost.localdomain localhost ::1       localhost6.localdomain6 localhost6
192.168.0.130     hub.breezey.top

删除以192.168.0.130开头的行：

- name: delete a line
  lineinfile:
    dest: /etc/hosts
    regex: '^192\.168\.0'
    state: absent

文件存在则添加一行内容

往/etc/hosts里添加一行192.168.0.131 test.breezey.top（多次执行，不会重复添加），示例如下：

- name: add a line
  lineinfile:
    dest: /etc/hosts
    line: '192.168.0.131 test.breezey.top'

如果有匹配的行则修改该行，如果不匹配则添加

示例原文件/tmp/test.txt内容如下：

# %wheel   ALL=(ALL)   ALL

下面的示例task中，匹配以%wheel开头的行，匹配到，则执行替换，未匹配，则添加。因为原文件中，没有以%wheel开头的行，所以会添加一行：

- name: add or modify a line
  lineinfile: 
    dest: /tmp/test.txt
    regex: '^%wheel'
    line: '%wheel  ALL=(ALL)       NOPASSWD: ALL'

修改后的文件如下：

#cat /tmp/text.txt

# %wheel   ALL=(ALL)   ALL
%wheel  ALL=(ALL)       NOPASSWD: ALL

参数backrefs，backup说明

backup：是否备份原文件，默认为no
backrefs：
- 当backrefs为no时，如果regex没有匹配到行，则添加一行，如果Regx匹配到行，则修改该行
- 当backrefs为yes时，如果regex没有匹配到行，则保持原文件不变，如果regex匹配到行，则修改该行
- backrefs默认为no，所以上面那个示例中，我们没有配置backrefs，而默认没有匹配，则修改。

下面我们看一看backrefs为yes时匹配到行的示例：

示例原文件：

# cat /tmp/testfile

# %wheel   ALL=(ALL)   ALL
%wheel  ALL=(ALL)       NOPASSWD: ALL
#?bar

task示例：

 - name: test backrefs
  lineinfile:
      backup: yes
      state: present
      dest: /tmp/testfile
      regexp: '^#\?bar'
      backrefs: yes
      line: 'bar'

修改后的文件：

# cat /tmp/testfile

# %wheel   ALL=(ALL)   ALL
%wheel  ALL=(ALL)       NOPASSWD: ALL
bar

使用validate验证文件是否正确修改

在一些场景下，我们修改完文件后，需要对文件做一下测试，用以检查文件修改之后，是否能正常运行。如http.conf、nginx.conf等，一旦改错，而不加以测试，可能会直接导致http服务挂掉。

可以使用validate关键字，在修改完成以后，对文件执行检测：

- name: test validate
  lineinfile:
      dest: /etc/sudoers
      state: present
      regexp: '^%ADMIN ALL='
      line: '%ADMIN ALL=(ALL)'
      validate: 'visudo -cf %s'
  tags:
    - testsudo

ansible 之 package

包管理器，通过包管理器安装软件

参数

name ：指定要安装的软件包名
state： present 安装 absent 卸载

示例

示例1

[admin@node1 ~]$ ansible webserver -m package -a "name=openssl-devel state=present" -b --ask-sudo-pass

示例2

- name: install_from_source | Ensure dependencies for building from source are installed.
  package: "name={
    
    { item }} state=installed"
  with_items: "{
    
    { php_packages }}"

ansible 之滚动执行

默认情况下，ansible会并行的在所有选定的主机或主机组上执行每一个task，但有的时候，我们会希望能够逐台运行。最典型的例子就是对负载均衡器后面的应用服务器进行更新时。通常来讲，我们会将应用服务器逐台从负载均衡器上摘除，更新，然后再添加回去。我们可以在play中使用serial语句来告诉ansible限制并行执行play的主机数量。

下面是一个在amazon EC2的负载均衡器中移除主机，更新软件包，再添加回负载均衡的配置示例：

- name: upgrade pkgs on servers behind load balancer
  hosts: myhosts
  serial: 1
  tasks:
    - name: get the ec2 instance id and elastic load balancer id
      ec2_facts:

    - name: take the host out of the elastic load balancer id
      local_action: ec2_elb
      args:
        instance_id: "{
    
    { ansible_ec2_instance_id }}"
        state: absent

    - name: upgrade pkgs
      apt: 
          update_cache: yes 
          upgrade: yes

    - name: put the host back n the elastic load balancer
      local_action: ec2_elb
      args:
        instance_id: "{
    
    { ansible_ec2_instance_id }}"
        state: present
        ec2_elbs: "{
    
    { items }}"
      with_items: ec2_elbs

在上述示例中，serial的值为1，即表示在某一个时间段内，play只在一台主机上执行。如果为2，则同时有2台主机运行play。

一般来讲，当task失败时，ansible会停止执行失败的那台主机上的任务，但是继续对其他主机执行。在负载均衡的场景中，我们会更希望ansible在所有主机执行失败之前就让play停止，否则很可能会面临所有主机都从负载均衡器上摘除并且都执行失败导致服务不可用的场景。这个时候，我们可以使用serial语句配合max_fail_percentage语句使用。max_fail_percentage表示当最大失败主机的比例达到多少时，ansible就让整个play失败。示例如下：

- name: upgrade pkgs on fservers behind load balancer
  hosts: myhosts
  serial: 1
  max_fail_percentage: 25
  tasks:
    ......

假如负载均衡后面有4台主机，并且有一台主机执行失败，这时ansible还会继续运行，要让Play停止运行，则必须超过25%，所以如果想一台失败就停止执行，我们可以将max_fail_percentage的值设为24。如果我们希望只要有执行失败，就放弃执行，我们可以将max_fail_percentage的值设为0。

ansible 之只执行一次

某些时候，我们希望某个task只执行一次，即使它被绑定到了多个主机上。例如在一个负载均衡器后面有多台应用服务器，我们希望执行一个数据库迁移，只需要在一个应用服务器上执行操作即可。

可以使用run_once语句来处理：

- name: run the database migrateions
  command: /opt/run_migrateions
  run_once: true

还可以与local_action配合使用，如下：

- name: run the task locally, only once
  command: /opt/my-custom-command
  connection: local
  run_once: true

还可以与delegate_to配合使用，让这个只执行一次的任务在指定的机器上运行：

- name: run the task locally, only once
  command: /opt/my-custom-command
  run_once: true
  delegate_to: app.a1-61-105.dev.unp

ansible 之设置环境变量

我们在命令行下执行某些命令的时候，这些命令可能会需要依赖环境变量。比如在安装某些包的时候，可能需要通过代理才能完成完装。或者某个脚本可能需要调用某个环境变量才能完成运行。

ansible 支持通过environment关键字来定义一些环境变量。

在如下场景中可能需要用到环境变量：

运行shell的时候，需要设置path变量
需要加载一些库，这些库不在系统的标准库路径当中

下面是一个简单示例：

---
- name: upload a remote file to aws s3
  hosts: test
  tasks:
    - name: install pip
      yum:
        name: python-pip
        state: installed
    
    - name: install the aws tools
      pip:
        name: awscli
        state: present
    
    - name upload file to s3
      shell aws s3 put-object --bucket=my-test-bucket --key={
    
    {
    
     ansible_hostname }}/fstab --body=/etc/fstab --region=eu-west-1
      environment:
        AWS_ACCESS_KEY_ID: xxxxxx
        AWS_SECRET_ACCESS_KEY: xxxxxx

事实上，environment也可以存储在变量当中：

- hosts: all
  remote_user: root
  vars:
    proxy_env:
      http_proxy: http://proxy.example.com:8080
      https_proxy: http://proxy.bos.example.com:8080
  tasks:
    - apt: name=cobbler state=installed
      environment: proxy_env