Ansible命令使用

Ansible常用模块详解
YAML语法简介
Ansible playbook基础
Playbook变量、tags、handlers使用
Playbook模板templates
Playbook条件判断 when
Playbook字典 with_items
Ansible Roles

安装

rpm包安装: EPEL源

yum install ansible

编译安装:

yum -y install python-jinja2 PyYAML python-paramiko python-babel python-crypto
tar xf ansible-1.5.4.tar.gz
cd ansible-1.5.4
python setup.py build
python setup.py install
mkdir /etc/ansible
cp -r examples/* /etc/ansible

Git方式:

git clone git://github.com/ansible/ansible.git --recursive
cd ./ansible
source ./hacking/env-setup

pip安装： pip是安装Python包的管理器，类似yum

yum install python-pip python-devel
yum install gcc glibc-devel zibl-devel rpm-bulid openssl-devel
pip install --upgrade pip
pip install ansible --upgrade

确认安装：ansible --version

配置文件

/etc/ansible/ansible.cfg 主配置文件，配置ansible工作特性
/etc/ansible/hosts 主机清单
/etc/ansible/roles/ 存放角色的目录

Ansible 配置文件

Ansible 配置文件/etc/ansible/ansible.cfg （一般保持默认）
 [defaults]
 #inventory = /etc/ansible/hosts # 主机列表配置文件
 #library = /usr/share/my_modules/ # 库文件存放目录
 #remote_tmp     = ~/.ansible/tmp  #临时py命令文件存放在远程主机目录
 #local_tmp      = ~/.ansible/tmp # 本机的临时命令执行目录
 #forks = 5 # 默认并发数
 #sudo_user = root # 默认sudo 用户
 #ask_sudo_pass = True #每次执行ansible命令是否询问ssh密码
 #ask_pass = True
 #remote_port = 22
 #host_key_checking = False # 检查对应服务器的host_key，建议取消注释
 #log_path = /var/log/ansible.log  是否启用日志功能

程序

/usr/bin/ansible 主程序，临时命令执行工具
/usr/bin/ansible-doc 查看配置文档，模块功能查看工具
/usr/bin/ansible-galaxy 下载/上传优秀代码或Roles模块的官网平台
/usr/bin/ansible-playbook 定制自动化任务，编排剧本工具/usr/bin/ansible-pull 远程执行命令的工具
/usr/bin/ansible-vault 文件加密工具
/usr/bin/ansible-console 基于Console界面与用户交互的执行工具

Inventory 主机清单

ansible的主要功用在于批量主机操作，为了便捷地使用其中的部分主机，可以在inventory file中将其分组命名
默认的inventory file为/etc/ansible/hosts
inventory file可以有多个，且也可以通过Dynamic Inventory来动态生成

文件格式

/etc/ansible/hosts文件格式

inventory文件遵循INI文件风格，中括号中的字符为组名。可以将同一个主机同时归并到多个不同的组中；此外，当如若目标主机使用了非默认的SSH端口，还可以在主机名称之后使用冒号加端口号来标明

ntp.5212345.cn
[webservers]
www1.5212345.cn:2222
www2.5212345.cn
[dbservers]
db1.5212345.cn
db2.5212345.cn
db3.5212345.cn

如果主机名称遵循相似的命名模式，还可以使用列表的方式标识各主机

示例：

[websrvs]
www[01:100].example.com
[dbsrvs]
db-[a:f].example.com

命令

ansible ansible-doc ansible-playbook ansible-vault  ansible-console ansible-galaxy ansible-pull

ansible-doc: 显示模块帮助

ansible-doc [options] [module...]
-a 显示所有模块的文档
-l, --list 列出可用模块
-s, --snippet 显示指定模块的playbook片段

示例：

ansible-doc –l 列出所有模块
ansible-doc ping 查看指定模块帮助用法
ansible-doc –s ping 查看指定模块帮助用法

ansible

ansible通过ssh实现配置管理、应用部署、任务执行等功能，建议配置ansible端能基于密钥认证的方式联系各被管理节点

ansible <host-pattern> [-m module_name] [-a args]
	--version 显示版本
	-m module 指定模块，默认为command
	-v 详细过程 –vv -vvv更详细
	--list-hosts 显示主机列表，可简写—list
	-k, --ask-pass 提示连接密码，默认Key验证
	-K, --ask-become-pass 提示输入sudo
	-C, --check 检查，并不执行
	-T, --timeout=TIMEOUT 执行命令的超时时间，默认10s
	-u, --user=REMOTE_USER 执行远程执行的用户
	-b, --become 代替旧版的sudo 切换

ansible的Host-pattern

匹配主机的列表

All ：表示所有Inventory中的所有主机
	ansible all –m ping
* :通配符
	ansible “*” -m ping
	ansible 192.168.1.* -m ping
	ansible “*srvs” -m ping
或关系
	ansible “websrvs:appsrvs” -m ping
	ansible “192.168.1.10:192.168.1.20” -m ping

逻辑与
	ansible “websrvs:&dbsrvs” –m ping
	在websrvs组并且在dbsrvs组中的主机
逻辑非
	ansible ‘websrvs:!dbsrvs’ –m ping
	在websrvs组，但不在dbsrvs组中的主机
综合逻辑
	ansible ‘websrvs:dbsrvs:&appsrvs:!ftpsrvs’ –m ping
正则表达式
	ansible “websrvs:&dbsrvs” –m ping
	ansible “~(web|db).*\.5212345\.cn” –m ping

ansible命令执行过程

1.加载自己的配置文件 默认/etc/ansible/ansible.cfg
2.加载自己对应的模块文件，如command
3.通过ansible将模块或命令生成对应的临时py文件，并将该 文件传输至远程服务器的对应执行用户$HOME/.ansible/tmp/ansible-tmp-数字/XXX.PY文件
4.给文件+x执行
5.执行并返回结果
6.删除临时py文件，sleep 0退出

执行状态：
绿色：执行成功并且不需要做改变的操作
黄色：执行成功并且对目标主机做变更
红色：执行失败

颜色可以在ansible.cfg配置文件里改

示例

# 以user用户执行ping存活检测
ansible all -m ping -u user -k

# 以user sudo至root执行ping存活检测
ansible all -m ping -u user –b -k

# 以user sudo至qinghai用户执行ping存活检测
ansible all -m ping -u user –b -k --become-user qinghai

# 以user sudo至root用户执行ls
ansible all -m command -u user --become-user=root -a 'ls /root' -b –k -K

Ansible-playbook

cat hello.yaml
---
- hosts: dbsrvs
  remote_user: root

  tasks:
    - name: test yaml
      command: /usr/bin/wall "hello world"

# 检查语法
ansible-playbook --check hello.yaml

# 执行
ansible-playbook hello.yml

[root@ansible ansible]# cat file.yaml
---
- hosts: dbsrvs
  remote_user: root

  tasks:
    - name: file yml
      file: name=/app/fileyaml  state=touch mode=600

# 检查语法
ansible-playbook --check file.yaml

# 执行
ansible-playbook file.yaml

Ansible-vault

功能：管理加密解密yml文件

ansible-vault [create|decrypt|edit|encrypt|rekey|view]

# 加密
ansible-vault encrypt hello.yml 

#  解密
ansible-vault decrypt hello.yml

#  查看
ansible-vault view hello.yml

# 编辑加密文件
ansible-vault edit hello.yml

# 修改口令
ansible-vault rekey hello.yml

# 创建新文件
ansible-vault create new.yml 

Ansible-console

Ansible-console：2.0+新增，可交互执行命令，支持tab

root@test (2)[f:10] $
执行用户 @ 当前操作的主机组 (当前组的主机数量) [f:并发数]$
设置并发数： forks n 例如： forks 10
切换组： cd 主机组 例如： cd web
列出当前组主机列表： list
列出所有的内置命令： ?或help

示例

root@all (2)[f:5]$ list
root@all (2)[f:5]$ cd appsrvs
root@appsrvs (2)[f:5]$ list
root@appsrvs (2)[f:5]$ yum name=httpd state=present
root@appsrvs (2)[f:5]$ service name=httpd state=started

模块

Command

Command：在远程主机执行命令，默认模块，可忽略-m选项

ansible srvs -m command -a ‘service vsftpd start’

# chdir 改变工作目录,执行后续命令
ansible dbsrvs -m command -a 'chdir=/app ls'

# creates 如果文件存在,就不执行后续命令
ansible dbsrvs -m command -a 'creates=/etc/fstab ls /app'

# removes 如果文件不存在,就不执行后续命令
ansible dbsrvs -m command -a 'removes=/etc/fstab ls /app'

# 此命令不支持 $VARNAME < > | ; & 等，用shell模块实现
ansible srvs -m command -a ‘echo 123456 |passwd --stdin user’ #不成功

Shell

Shell：和command相似，用shell执行命令

# 支持特殊符号
ansible dbsrvs -m shell  -a 'grep -q root /etc/passwd && ls -l /app '

ansible srv -m shell -a ‘echo 123456 |passwd –stdin user’


调用bash执行命令 类似 cat /tmp/stanley.md | awk -F‘|’ ‘{print $1,$2}’ &> /tmp/example.txt 这些复杂命令，即使使用shell也可能会失败，解决办法：写到脚本时，copy到远程，执行，再把需要的结果拉回执行命令的机器

Script

-a "/PATH/TO/SCRIPT_FILE“
ansible websrvs -m script -a f1.sh


# 示例
==================
cat /app/test.sh
#!/bin/bash
hostname
date
df -h

chmod +x /app/test.sh

ansible dbsrvs -m script  -a '/app/test.sh'
========================

Copy

Copy:从服务器复制文件到客户端

# ansible管理机的selinux的config文件,复制到其他机器
ansible dbsrvs -m copy -a 'src=/etc/selinux/config dest=/etc/selinux/config backup=yes'
  # backup=yes 如果文件存在,就备份原来的文件

# 如目标存在，默认覆盖，此处指定先备份
ansible srv -m copy -a “src=/root/f1.sh dest=/tmp/f2.sh owner=user mode=600 backup=yes”

# 复制fstab 到目标机器的/app下,并且重命名为fstab2 ,权限改为600,所有者改为test1
ansible dbsrvs -m copy -a 'src=/etc/fstab dest=/app/fstab2 mode=600 owner=test1'

# 复制sysconfig目录到目标主机的/app目录下
ansible dbsrvs -m copy -a 'src=/etc/sysconfig dest=/app/'

# 利用内容，直接生成目标文件
ansible dbsrvs -m copy -a 'content="df -h\nhostname\nls\n" dest=/app/f1.sh'
ansible srv -m copy -a “content=‘test content\n’ dest=/tmp/f1.txt” 

Fetch

Fetch:从客户端取文件至服务器端，copy相反，不能直接传目录, 目录可先tar

ansible srv -m fetch -a ‘src=/root/a.sh dest=/data/scripts’

# 被控端的/etc/passwd文件,复制到/app/目录下
ansible dbsrvs -m fetch -a 'src=/etc/passwd dest=/app/'

[root@ansible ansible]# tree /app/
/app/
├── 192.168.0.101
│   └── etc
│       └── passwd
├── 192.168.0.103
│   └── etc
│       └── passwd
└── test.sh

4 directories, 3 files

# /var/log/所有log结尾文件,传到控制端的/app目录下
# 因为不能传目录,需要先打包  有专门的tar模块(archive),也可以用shell模块
# unarchive是解包
ansible dbsrvs -m shell -a 'tar Jcf /app/log.tar.xz  /var/log/*.log'
ansible dbsrvs -m fetch -a 'src=/app/log.tar.xz  dest=/app/'

[root@ansible ansible]# tree /app/192.168.0.10*
/app/192.168.0.101
├── app
│   └── log.tar.xz
└── etc
    └── passwd
/app/192.168.0.103
├── app
│   └── log.tar.xz
└── etc
    └── passwd

4 directories, 4 files

Cron

Cron：计划任务

支持时间：minute，hour，day，month，weekday

# 每5分钟 执行一下时间同步
ansible srv -m cron -a “minute=*/5 job=‘/usr/sbin/ntpdate 172.16.0.1 &>/dev/null’ name=Synctime” 创建任务

# 删除任务
ansible srv -m cron -a ‘state=absent name=Synctime’ 

# 周六周日,每5分钟执行一次广播
ansible dbsrvs -m cron -a 'minute=*/5 weekday=0,6 job="/usr/bin/wall cron job" name="test cronjob"'

# 禁用计划任务,必须有作业(job="/usr/bin/wall cron job")
ansible dbsrvs -m cron -a 'disabled=true job="/usr/bin/wall cron job" name="test cronjob"'

# 删除任务
ansible dbsrvs -m cron -a 'state=absent job="/usr/bin/wall cron job" name="test cronjob"'

File

File：设置文件属性

# 创建一个空文件, 权限600 所有者test1
ansible dbsrvs -m file -a 'path=/app/testfile state=touch mode=600 owner=test1'

# 给testfile文件创建一个链接文件 这里path和dest等价
ansible dbsrvs -m file -a 'src=/app/testfile path=/tmp/testfile-link state=link'
ansible dbsrvs -m file -a 'src=/app/testfile dest=/tmp/testfile-link state=link'

# 创建一个目录
ansible dbsrvs -m file -a 'path=/app/dir2 state=directory'

# 删除一个文件或者目录
ansible dbsrvs -m file -a 'path=/app/dir2 state=absent'
ansible dbsrvs -m file -a 'path=/app/fstab2 state=absent'

Hostname

hostname：管理主机名

ansible node1 -m hostname -a “name=websrv”

Yum

Yum：管理包

# state=latest  # 安装最新版本
ansible srv -m yum -a ‘name=httpd state=latest’

# name=NAME,NAME 用逗号隔开可以安装多个
ansible dbsrvs  -m yum -a 'name=http,memcached,vsftpd  state=latest' 

# disable_gpg_check=yes 临时禁用gpgcheck
ansible dbsrvs  -m yum -a 'name=http,memcached,vsftpd  disable_gpg_check=yes'  

# update_cache=yes 更新yum缓存
ansible dbsrvs  -m yum -a 'name=http,memcached,vsftpd  state=latest update_cache=yes'

# 卸载
ansible srv -m yum -a ‘name=httpd state=absent’ # 卸载

# 卸载多个
ansible dbsrvs  -m yum -a 'name=http,memcached,vsftpd  state=absent'

Service

Service：管理服务

没有找到同时启动多个服务的办法

# state=started 启动服务
ansible srv -m service -a 'name=httpd state=started'

# state=started 启动服务 enabled=yes 开机启动
ansible dbsrvs -m service -a 'name=httpd state=started enabled=yes '

# state=stopped 停止服务
ansible dbsrvs -m service -a 'name=httpd state=stopped'

# state=restarted 重启服务
ansible dbsrvs -m service -a 'name=httpd state=restarted'

# state=reloaded 重新加载
ansible srv –m service –a 'name=httpd state=reloaded'

User

User：管理用户

ansible dbsrvs -m user -a 'name=test2 comment="test user2" uid=2000 home=/app/test2 group=qinghai groups=root,bin'
	# name: 用户名
	# comment: 描述信息
	# uid: 设置UID
	# home: 设置家目录
	# group: 设置组名
	# groups: 设置辅助组

ansible srv -m user -a 'name=user1 comment=“test user” uid=2048 home=/app/user1 group=root‘

# system=yes 创建系统用户
ansible srv -m user -a 'name=sysuser1 system=yes home=/app/sysuser1 ’

# 删除用户
ansible srv -m user -a 'name=user1 state=absent'

# 删除用户及家目录等数据  remove=yes 删除家目录
ansible srv -m user -a 'name=user1  state=absent remove=yes'

Group

Group：管理组

# 创建一个组
ansible dbsrvs -m group -a 'name=group1'

# 创建一个系统组
ansible srv -m group -a "name=testgroup system=yes“

# 删除组
ansible srv -m group -a "name=testgroup state=absent"

ansible-galaxy

连接 https://galaxy.ansible.com 下载相应的roles
列出所有已安装的galaxy
ansible-galaxy list
安装galaxy
ansible-galaxy install geerlingguy.redis
删除galaxy
ansible-galaxy remove geerlingguy.redis

ansible-pull

推送命令至远程，效率无限提升，对运维要求较高

playbook

YAML语法简介

playbook是由一个或多个“play”组成的列表
play的主要功能在于将事先归并为一组的主机装扮成事先通过ansible中的task定义好的角色。从根本上来讲，所谓task无非是调用ansible的一个module。将多个play组织在一个playbook中，即可以让它们联同起来按事先编排的机制同唱一台大戏
Playbook采用YAML语言编写

List：列表，其所有元素均使用“-”打头

示例

# A list of tasty fruits
- Apple
- Orange
- Strawberry
- Mango

YAML介绍

YAML是一个可读性高的用来表达资料序列的格式。YAML参考了其他多种语言，包括：XML、C语言、Python、Perl以及电子邮件格式RFC2822等。Clark Evans在2001年在首次发表了这种语言，另外Ingy döt Net与Oren Ben-Kiki也是这语言的共同设计者

YAML Ain't Markup Language，即YAML不是XML。不过，在开发的这种语言时，YAML的意思其实是："Yet Another Markup Language"（仍是一种标记语言）

特性

YAML的可读性好
YAML和脚本语言的交互性好
YAML使用实现语言的数据类型
YAML有一个一致的信息模型
YAML易于实现
YAML可以基于流来处理
YAML表达能力强，扩展性好

更多的内容及规范参见http://www.yaml.org

YAML语法简介

在单一档案中，可用连续三个连字号(---)区分多个档案。另外，还有选择性的连续三个点号( ... )用来表示档案结尾
次行开始正常写Playbook的内容，一般建议写明该Playbook的功能
使用#号注释代码
缩进必须是统一的，不能空格和tab混用
缩进的级别也必须是一致的，同样的缩进代表同样的级别，程序判别配置的级别是通过缩进结合换行来实现的
YAML文件内容和Linux系统大小写判断方式保持一致，是区别大小写的，k/v的值均需大小写敏感
k/v的值(a:10)可同行写也可换行写。同行使用,分隔
v可是个字符串，也可是另一个列表
一个完整的代码块功能需最少元素需包括 name: task
一个name只能包括一个task
YAML文件扩展名通常为yml或yaml

Dictionary：字典，通常由多个key与value构成

示例：

---
# An employee record
name: Example Developer
job: Developer
skill: Elite
也可以将key:value放置于{}中进行表示，用,分隔多个key:value

---
# An employee record
{name: Example Developer, job: Developer, skill: Elite}

YAML语法

YAML的语法和其他高阶语言类似，并且可以简单表达清单、散列表、标量等数据结构。其结构（Structure）通过空格来展示，序列（Sequence）里的项用"-"来代表，Map里的键值对用":"分隔

示例

name: John Smith
age: 41
gender: Male
spouse:
	name: Jane Smith
	age: 37
	gender: Female
children:
	- name: Jimmy Smith
	  age: 17
	  gender: Male
	- name: Jenny Smith
	  age 13
	  gender: Female

Playbook核心元素

Hosts 执行的远程主机列表
Tasks 任务集
Varniables 内置变量或自定义变量在playbook中调用
Templates 模板，可替换模板文件中的变量并实现一些简单逻辑的文件
Handlers 和notity结合使用，由特定条件触发的操作，满足条件方才执行，否则不执行
tags 标签 指定某条任务执行，用于选择运行playbook中的部分代码。ansible具有幂等性，因此会自动跳过没有变化的部分，即便如此，有些代码为测试其确实没有发生变化的时间依然会非常地长。此时，如果确信其没有变化，就可以通过tags跳过此些代码片断
ansible-playbook –t tagsname useradd.yml

Hosts

Hosts：
playbook中的每一个play的目的都是为了让某个或某些主机以某个指定的用户身份执行任务。hosts用于指定要执行指定任务的主机，须事先定义在主机清单中
可以是如下形式：
one.example.com
one.example.com:two.example.com
192.168.1.50
192.168.1.*

Websrvs:dbsrvs 两个组的并集
Websrvs:&dbsrvs 两个组的交集
webservers:!phoenix 在websrvs组，但不在dbsrvs组
示例: - hosts: websrvs：dbsrvs

remote_user

remote_user: 可用于Host和task中。也可以通过指定其通过sudo的方式在远程主机上执行任务，其可用于play全局或某任务；此外，甚至可以在sudo时使用sudo_user指定sudo时切换的用户

- hosts: websrvs
remote_user: root
tasks:
- name: test connection
ping:
remote_user: magedu
sudo: yes 默认sudo为root
sudo_user:wang sudo为wang

task列表和action

play的主体部分是task list。task list中的各任务按次序逐个在hosts中指定的所有主机上执行，即在所有主机上完成第一个任务后再开始第二个。在运行自下而下某playbook时，如果中途发生错误，所有已执行任务都将回滚，因此，在更正playbook后重新执行一次即可

task的目的是使用指定的参数执行模块，而在模块参数中可以使用变量。模块执行是幂等的，这意味着多次执行是安全的，因为其结果均一致

每个task都应该有其name，用于playbook的执行结果输出，建议其内容尽可能清晰地描述任务执行步骤。如果未提供name，则action的结果将用于输出

tasks：任务列表
格式：(1) action: module arguments
	 (2) module: arguments 建议使用
  注意：shell和command模块后面跟命令，而非key=value
某任务的状态在运行后为changed时，可通过“notify”通知给相应的handlers
任务可以通过"tags“打标签，而后可在ansible-playbook命令上使用-t指定进行调用
示例：
tasks:
  - name: disable selinux
    command: /sbin/setenforce 0

如果命令或脚本的退出码不为零，可以使用如下方式替代

tasks:
  - name: run this command and ignore the result
    shell: /usr/bin/somecommand || /bin/true

或者使用ignore_errors来忽略错误信息：

tasks:
  - name: run this command and ignore the result
    shell: /usr/bin/somecommand
    ignore_errors: True

运行playbook的方式

ansible-playbook <filename.yml> ... [options]

常见选项

--check 只检测可能会发生的改变，但不真正执行操作
--list-hosts 列出运行任务的主机
--limit 主机列表 只针对主机列表中的主机执行
-v 显示过程 -vv -vvv 更详细

示例

ansible-playbook file.yml --check 只检测
ansible-playbook file.yml
ansible-playbook file.yml --limit websrvs

[root@ansible ansible]# cat test1.yaml
- hosts: dbsrvs
  remote_user: root

  tasks:
    - name: install package
      yum: name=httpd state=present

    - name: start service
      service: name=httpd state=started enabled=yes

# 检查语法
ansible-playbook -C test1.yaml

# 执行
ansible-playbook  test1.yaml

一个playbook可以放多个play

[root@ansible ansible]# cat test2.yaml
- hosts: dbsrvs
  remote_user: root

  tasks:
    - name: install package
      yum: name=httpd state=present

    - name: start service
      service: name=httpd state=started enabled=yes

- hosts: websrvs
  remote_user: root
  
  tasks:
    - name: copy file
      copy: src=/etc/fstab dest=/app/ mode=600 owner=qinghai
    - name: create user
      user: name=test3 shell=/sbin/nologin system=yes 
  
# 检查语法
ansible-playbook -C test2.yaml

# 执行
ansible-playbook  test2.yaml

示例：

system.yml

---
- hosts: all
  remote_user: root
  tasks:
  - name: create mysql user
    user: name=mysql system=yes uid=36
  - name: create a group
    group: name=httpd system=yes

httpd.yml

- hosts: websrvs 
  remote_user: root
  tasks:
  - name: Install httpd 
    yum: name=httpd state=present 
  - name: Install configure file 
    copy: src=files/httpd.conf dest=/etc/httpd/conf/
  - name: start service
    service: name=httpd state=started enabled=yes

handlers和notify结合使用触发条件

Handlers
是task列表，这些task与前述的task并没有本质上的不同,用于当关注的资源发生变化时，才会采取一定的操作
notify这个action可用于在每个play的最后被触发，这样可以避免多次有改变发生时每次都执行指定的操作，仅在所有的变化发生完成后一次性地执行指定操作。在notify中列出的操作称为handler，也即notify中调用handler中定义的操作

Playbook中handlers使用

- hosts: websrvs 
  remote_user: root
  tasks:
  - name: Install httpd
    yum: name=httpd state=present
  
  - name: Install configure file 
    copy: src=files/httpd.conf dest=/etc/httpd/conf/ 
    notify: restart httpd
  
  - name: ensure apache is running
    service: name=httpd state=started enabled=yes
  handlers:
  - name: restart httpd
    service: name=httpd state=restarted

- hosts: websrvs
  remote_user: root
  
  tasks:
    - name: add group nginx
      tags: user
      user: name=nginx state=present
    - name: add user nginx
      user: name=nginx state=present group=nginx
    - name: Install Nginx
      yum: name=nginx state=present
    - name: config
      copy: src=/root/config.txt dest=/etc/nginx/nginx.conf
      notify:
        - Restart Nginx
        - Check Nginx Process
  handlers:
    - name: Restart Nginx
      service: name=nginx state=restarted enabled=yes
    - name: Check Nginx process
      shell: killall -0 nginx > /tmp/nginx.log

单台主机执行

--limit参数

ansible-playbook --limit 192.168.0.101 httpd.yaml

Playbook中tags使用

示例：httpd.yml

- hosts: websrvs
  remote_user: root
  tasks: 
    - name: Install httpd 
      yum: name=httpd state=present 

    - name: Install configure file 
      copy: src=files/httpd.conf dest=/etc/httpd/conf/ 
      tags: conf 

    - name: start httpd service 
      tags: service 
      service: name=httpd state=started enabled=yes

# 
ansible-playbook –t conf httpd.yml

Playbook VS ShellScripts

SHELL脚本
#!/bin/bash
# 安装Apache
yum install --quiet -y httpd
# 复制配置文件
cp /path/to/config/httpd.conf /etc/httpd/conf/httpd.conf
cp/path/to/httpd-vhosts.conf /etc/httpd/conf/httpd-vhosts.conf
# 启动Apache，并设置开机启动
service httpd start
chkconfig httpd on

Playbook定义
---
- hosts: all
  tasks:
  - name: "安装Apache"
    command: yum install -q -y httpd
  - name: "复制配置文件"
    command: cp /tmp/httpd.conf /etc/httpd/conf/httpd.conf
    command: cp /tmp/httpd-vhosts.conf /etc/httpd/conf/httpd-vhosts.conf
  - name: "启动Apache，并设置开机启动"
    service: name=httpd state=started enabled=yes

Playbook中变量使用

变量名：仅能由字母、数字和下划线组成，且只能以字母开头
变量来源：
1 ansible setup facts 远程主机的所有变量都可直接调用
2 在/etc/ansible/hosts中定义
普通变量：主机组中主机单独定义，优先级高于公共变量
公共（组）变量：针对主机组中所有主机定义统一变量
3 通过命令行指定变量，优先级最高
ansible-playbook –e varname=value
4 在playbook中定义

vars:
- var1: value1
- var2: value2

5 在role中定义

变量命名
变量名仅能由字母、数字和下划线组成，且只能以字母开头
变量定义：key=value
示例：http_port=80
变量调用方式：
通过{{ variable_name }} 调用变量，且变量名前后必须有空格，有时用“{{ variable_name }}”才生效
ansible-playbook –e 选项指定
ansible-playbook test.yml -e "hosts=www user=qinghai"

示例:var.yml

- hosts: websrvs
  remote_user: root
  tasks:
    - name: install package
      yum: name={{ pkname }} state=present


ansible-playbook –e pkname=httpd var.yml

示例：var2.yml

- hosts: websrvs
  remote_user: root
  vars:
  - username: user1
  - groupname: group1
  tasks:
    - name: create group
      group: name={{ groupname }} state=present
    - name: create user
      user: name={{ username }} state=present


ansible-playbook var2.yml
ansible-playbook -e "username=user2 groupname=group2” var2.yml

主机变量

可以在inventory中定义主机时为其添加主机变量以便于在playbook中使用

示例

[websrvs]
www1.5212345.cn http_port=80 maxRequestsPerChild=808
www2.5212345.cn http_port=8080 maxRequestsPerChild=909

组变量

组变量是指赋予给指定组内所有主机上的在playbook中可用的变量

示例：

[websrvs]
www1.5212345.cn
www2.5212345.cn
[websrvs:vars]
ntp_server=ntp.5212345.cn
nfs_server=nfs.5212345.cn

普通变量

[websrvs]
192.168.99.101 http_port=8080 hname=www1
192.168.99.102 http_port=80 hname=www2

公共（组）变量

[websvrs:vars]
http_port=808
mark=_
[websrvs]
192.168.99.101 http_port=8080 hname=www1
192.168.99.102 http_port=80 hname=www2

ansible websvrs –m hostname –a 'name={{ hname }}{{ mark }}{{ http_port }}'

命令行指定变量：

ansible websvrs –e http_port=8000 –m hostname –a 'name={{ hname }}{{ mark }}{{ http_port }}'

所有变量放到一个文件中

[root@ansible ansible]# cat vars.yaml 
var1: httpd
var2: nginx

[root@ansible ansible]# cat var5.yaml 
---
- hosts: websrvs
  remote_user: root
  vars_files:
    - vars.yaml

  tasks:
  - name: create file
    file: name=/app/{{ var1 }}-{{ var2 }}.log state=touch mode=600 owner=qinghai

模板templates

文本文件，嵌套有脚本（使用模板编程语言编写）
Jinja2语言，使用字面量，有下面形式
字符串：使用单引号或双引号
数字：整数，浮点数
列表：[item1, item2, ...]
元组：(item1, item2, ...)
字典：{key1:value1, key2:value2, ...}
布尔型：true/false
算术运算：+, -, *, /, //, %, **
比较操作：==, !=, >, >=, <, <=
逻辑运算：and, or, not
流表达式：For If When

templates功能：根据模块文件动态生成对应的配置文件
templates文件必须存放于templates目录下，且命名为 .j2 结尾
yaml/yml 文件需和templates目录平级，目录结构如下：

./
├── temnginx.yml
└── templates
  └── nginx.conf.j2

Templates示例

示例：利用templates 同步nginx配置文件
准备templates/nginx.conf.j2文件

vim temnginx.yml
---
- hosts: websrvs
  remote_user: root
  tasks:
    - name: template config to remote hosts
      template: src=nginx.conf.j2  dest=/etc/nginx/nginx.conf

ansible-playbook temnginx.yml

修改文件nginx.conf.j2 下面行为

worker_processes {{ ansible_processor_vcpus }};

cat temnginx2.yml
---
- hosts: websrvs 
  remote_user: root
  
  tasks: 
    - name: template config to remote hosts 
      template: src=nginx.conf.j2 dest=/etc/nginx/nginx.conf

ansible-playbook temnginx2.yml

算法运算

示例

vim nginx.conf.j2
worker_processes {{ ansible_processor_vcpus*2 }};
worker_processes {{ ansible_processor_vcpus+2 }};

when

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

tasks:
  - name: "shutdown RedHat flavored systems"
    command: /sbin/shutdown -h now
    when: ansible_os_family == "RedHat"

示例：when条件判断

---
- hosts: websrvs
  remote_user: root
  tasks:
    - name: add group nginx
      tags: user
      user: name=nginx state=present
    - name: add user nginx
      user: name=nginx state=present group=nginx
    - name: Install Nginx
      yum: name=nginx state=present
    - name: restart Nginx
      service: name=nginx state=restarted
      when: ansible_distribution_major_version == "6"

示例：

tasks:
  - name: install conf file to centos7
    template: src=nginx.conf.c7.j2
    when: ansible_distribution_major_version == "7"
  - name: install conf file to centos6
    template: src=nginx.conf.c6.j2
    when: ansible_distribution_major_version == "6"

迭代:with_items

迭代：当有需要重复性执行的任务时，可以使用迭代机制

对迭代项的引用，固定变量名为”item“
要在task中使用with_items给定要迭代的元素列表
列表格式：
字符串
字典

示例：

- name: add several users
  user: name={{ item }} state=present groups=wheel
  with_items:
    - testuser1
    - testuser2

上面语句的功能等同于下面的语句

- name: add user testuser1
  user: name=testuser1 state=present groups=wheel
- name: add user testuser2
  user: name=testuser2 state=present groups=wheel

示例：迭代

示例：将多个文件进行copy到被控端

---
- hosts: testsrv
  remote_user: root
  tasks
    - name: Create rsyncd config 
      copy: src={{ item }} dest=/etc/{{ item }} 
      with_items: 
        - rsyncd.secrets
        - rsyncd.conf

- hosts: websrvs
  remote_user: root
  
  tasks:
    - name: copy file
      copy: src={{ item }} dest=/tmp/{{ item }}
      with_items:
        - file1
        - file2
        - file3
    - name: yum install httpd
      yum: name={{ item }} state=present
      with_items:
        - apr
        - apr-util
        - httpd

- hosts：websrvs
  remote_user: root

  tasks
    - name: install some packages
      yum: name={{ item }} state=present
      with_items:
        - nginx
        - memcached
        - php-fpm

示例：迭代嵌套子变量

- hosts：websrvs
  remote_user: root
  
  tasks:
    - name: add some groups
      group: name={{ item }} state=present
      with_items:
        - group1
        - group2
        - group3
        - name: add some users
        user: name={{ item.name }} group={{ item.group }} state=present
        with_items:
          - { name: 'user1', group: 'group1' }
          - { name: 'user2', group: 'group2' }
          - { name: 'user3', group: 'group3' }

Playbook中template for if

{% for vhost in nginx_vhosts %}
server {
listen {{ vhost.listen | default('80 default_server') }};
{{% endfor %}}


{% if vhost.server_name is defined %}
server_name {{ vhost.server_name }};
{% endif %} 

{% if vhost.root is defined %}
root {{ vhost.root }}; 
{% endif %}

示例:

// temnginx.yml
---
- hosts: testweb
  remote_user: root
  vars:
    nginx_vhosts:
      - listen: 8080
  

//templates/nginx.conf.j2
{% for vhost in nginx_vhosts %}
server {
  listen {{ vhost.listen }}
}
{% endfor %}

生成的结果
server {
  listen 8080
}

// temnginx.yml
---
- hosts: websrvs
  remote_user: root
  vars:
    nginx_vhosts:
      - web1
      - web2
      - web3
  tasks:
    - name: template config
      template: src=nginx.conf.j2 dest=/etc/nginx/nginx.conf
  

// templates/nginx.conf.j2
{% for vhost in nginx_vhosts %}
server {
  listen {{ vhost }}
}
{% endfor %}

生成的结果：
server {
  listen web1
}
server {
  listen web2
}
server {
  listen web3
}

// temnginx.yml
- hosts: websrvs
  remote_user: root
  vars:
    nginx_vhosts:
      - web1:
        listen: 8080
        server_name: "web1.5212345.cn"
        root: "/var/www/nginx/web1/"
      - web2:
        listen: 8080
        server_name: "web2.5212345.cn"
        root: "/var/www/nginx/web2/"
      - web3:
        listen: 8080
        server_name: "web3.5212345.cn"
        root: "/var/www/nginx/web3/“
  tasks:
    - name: template config
      template: src=nginx.conf.j2 dest=/etc/nginx/nginx.conf
  
// templates/nginx.conf.j2
{% for vhost in nginx_vhosts %}
server {
  listen {{ vhost.listen }}
  server_name {{ vhost.server_name }}
  root {{ vhost.root }}
}
{% endfor %}

生成结果：
server {
  listen 8080
  server_name web1.5212345.cn
  root /var/www/nginx/web1/
}
server {
  listen 8080
  server_name web2.5212345.cn
  root /var/www/nginx/web2/
}
server {
  listen 8080
  server_name web3.5212345.cn
  root /var/www/nginx/web3/
}  

// temnginx.yml
- hosts: websrvs
  remote_user: root
  vars:
    nginx_vhosts:
      - web1:
        listen: 8080
        root: "/var/www/nginx/web1/"
      - web2:
        listen: 8080
        server_name: "web2.5212345.cn"
        root: "/var/www/nginx/web2/"
      - web3:
        listen: 8080
        server_name: "web3.5212345.cn"
        root: "/var/www/nginx/web3/"
  tasks:
    - name: template config to
      template: src=nginx.conf.j2 dest=/etc/nginx/nginx.conf

// templates/nginx.conf.j2
{% for vhost in nginx_vhosts %}
server {
  listen {{ vhost.listen }}
{% if vhost.server_name is defined %}
  server_name {{ vhost.server_name }}
{% endif %}
  root {{ vhost.root }}
}
{% endfor %}


生成的结果
server {
  listen 8080
  root /var/www/nginx/web1/
}
server {
  listen 8080
  server_name web2.5212345.cn
  root /var/www/nginx/web2/
}
server {
  listen 8080
  server_name web3.5212345.cn
  root /var/www/nginx/web3/
}

roles

介绍

ansilbe自1.2版本引入的新特性，用于层次性、结构化地组织playbook。roles能够根据层次型结构自动装载变量文件、tasks以及handlers等。要使用roles只需要在playbook中使用include指令即可。简单来讲，roles就是通过分别将变量、文件、任务、模板及处理器放置于单独的目录中，并可以便捷地include它们的一种机制。角色一般用于基于主机构建服务的场景中，但也可以是用于构建守护进程等场景中

复杂场景：建议使用roles，代码复用度高

变更指定主机或主机组

如命名不规范维护和传承成本大

某些功能需多个Playbook，通过Includes即可实现

角色(roles)：角色集合

roles/
	mysql/
	httpd/
	nginx/
	memcached/

Ansible Roles目录编排

每个角色，以特定的层级目录结构进行组织

roles目录结构：

playbook.yml
roles/
  project/
    tasks/
    files/
    vars/ 不常用
    default/ 不常用
    templates/
    handlers/
    meta/ 不常用

/roles/project/ :项目名称,有以下子目录

files/ ：存放由copy或script模块等调用的文件
templates/：template模块查找所需要模板文件的目录
tasks/：定义task,role的基本元素，至少应该包含一个名为main.yml的文件；其它的文件需要在此文件中通过include进行包含
handlers/：至少应该包含一个名为main.yml的文件；其它的文件需要在此文件中通过include进行包含
vars/：定义变量，至少应该包含一个名为main.yml的文件；其它的文件需要在此文件中通过include进行包含
meta/：定义当前角色的特殊设定及其依赖关系,至少应该包含一个名为main.yml的文件，其它文件需在此文件中通过include进行包含
default/：设定默认变量时使用此目录中的main.yml文件

创建role的步骤

(1) 创建以roles命名的目录
(2) 在roles目录中分别创建以各角色名称命名的目录，如webservers等
(3) 在每个角色命名的目录中分别创建files、handlers、meta、tasks、templates和vars目录；用不到的目录可以创建为空目录，也可以不创建
(4) 在playbook文件中，调用各角色

roles目录结构：
playbook.yml
roles/
  project/
    tasks/
    files/
    vars/ # 不经常用
    default/ # 不经常用
    templates/
    handlers/
    meta/ # 不经常用

示例：
nginx-role.yml
roles/
└── nginx
├── files
│ └── main.yml
├── tasks
│ ├── groupadd.yml
│ ├── install.yml
│ ├── main.yml
│ ├── restart.yml
│ └── useradd.yml
└── vars
└── main.yml

roles的示例如下所示：
site.yml
webservers.yml
dbservers.yml
  roles/
  common/
    files/
    templates/
    tasks/
    handlers/
    vars/
    meta/
  webservers/
    files/
    templates/
    tasks/
    handlers/
    vars/
    meta/

调用角色方法1：

- hosts: websrvs
  remote_user: root
  roles:
    - mysql
    - memcached
    - nginx

调用角色方法2：

传递变量给角色

- hosts:
  remote_user:
  roles:
    - mysql
    - { role: nginx, username: nginx }
		键role用于指定角色名称
		后续的k/v用于传递变量给角色

调用角色方法3：还可基于条件测试实现角色调用

roles:
  - { role: nginx, username: nginx, when: ansible_distribution_major_version == '7' }

完整的roles架构

// nginx-role.yml 顶层任务调用yml文件
---
- hosts: testweb
  remote_user: root
  
  roles:
    - role: nginx
    - role: httpd  # 可执行多个role


cat roles/nginx/tasks/main.yml
---
- include: groupadd.yml
- include: useradd.yml
- include: install.yml
- include: restart.yml
- include: filecp.yml


# include 在新版本中弃用,以后可能会删除,用import_tasks代替
cat roles/nginx/tasks/groupadd.yml
---
- name: add group nginx
  user: name=nginx state=present

cat roles/nginx/tasks/filecp.yml
---
- name: file copy
  copy: src=tom.conf dest=/tmp/tom.conf

以下文件格式类似：
useradd.yml,install.yml,restart.yml
ls roles/nginx/files/
tom.conf

调用其他roles的yml

[root@ansible ansible]# cat roles/filecopy/tasks/main.yaml
- name: filecopy
  copy: src=fstab dest=/app/

- name: file create
  file: name=/app/testfile mode=600 state=touch

- import_tasks: roles/nginx/tasks/stop.yaml


# 不建议(import_tasks)调用其他角色的yml,容易乱

roles playbook tags使用

ansible-playbook --tags="nginx,httpd,mysql" nginx-role.yml


// nginx-role.yml
---
- hosts: testweb
  remote_user: root
  
  roles:
    - { role: nginx ,tags: [ 'nginx', 'web' ] ,when: ansible_distribution_major_version == "6“ }
    - { role: httpd ,tags: [ 'httpd', 'web' ] }
    - { role: mysql ,tags: [ 'mysql', 'db' ] }
    - { role: marridb ,tags: [ 'mysql', 'db' ] }
    - { role: php }


# 只执行web标签
ansible-playbook -C -t web nginx-role.yml

综合实验

# 目录准备
mkdir /root/ansible/roles/nginx
mkdir /root/ansible/roles/nginx/{tasks,templates,handlers,vars}

# 复制模版文件
cp /etc/nginx/nginx.conf templates/nginx.conf.j2

# 修改模版文件
vim templates/nginx.conf.j2
...
worker_processes {{ ansible_processor_vcpus-1 }};
...



# 编写main文件
[root@ansible nginx]# cat tasks/main.yaml
- name: install package
  yum: name=nginx

- name: template
  template: src=nginx.conf.j2 dest=/etc/nginx/nginx.conf
  notify: restart service

- name: start service
  service: name=nginx state=started


[root@ansible nginx]# cat handlers/main.yaml
- name: restart service
  service: name=nginx state=restarted


[root@ansible ansible]# cat test-role.yaml
- hosts: websrvs
  remote_user: root
  roles:
    - role: nginx

# 运行测试
ansible-playbook -C test-role.yaml

# 运行
ansible-playbook  test-role.yaml


# handlers
# 以下再次修改template文件,触发handlers
[root@ansible ansible]# vim roles/nginx/templates/
user daemon;
worker_processes {{ ansible_processor_vcpus }};
...

# 再次测试
[root@ansible ansible]# ansible-playbook  test-role.yaml


# 变量定义
cat roles/nginx/vars/main.yaml
listen_port: 8080

# 编辑template文件,使用变量
vim roles/nginx/templates/nginx.conf.j2
...
listen       {{listen_port}};
...

# 执行
[root@ansible ansible]# ansible-playbook  test-role.yaml

# 标签  在template上添加标签(tags)
vim  roles/nginx/tasks/main.yaml
- name: install package
  yum: name=nginx

- name: template
  template: src=nginx.conf.j2 dest=/etc/nginx/nginx.conf
  notify: restart service
  tags: tmplfile

- name: start service
  service: name=nginx state=started

# 只执行tags标签的部分
ansible-playbook -t tmplfile test-role.yaml


# 只在centos7系统执行
vim test-role.yaml

- hosts: all
  remote_user: root
  roles:
    - { role: nginx, when: ansible_distribution_major_version=='7' }
 
 上面的格式,和下面格式,效果一样
 vim test-role.yaml
 - hosts: all
  remote_user: root
  roles:
    - role: nginx 
      when: ansible_distribution_major_version=='7'