ansible学习笔记

ansible

Ansible is a radically simple configuration-management, application deployment, task-execution, and multinode orchestration engine.
主控端Python版本需要2.6或以上
被控端Python版本小于2.4需要安装python-simplejson,如果开启SELinux需要安装libselinux-python
windows不能做主控端

安装和使用

ansible依赖于Python 2.6或更高的版本、paramiko、PyYAML及Jinja2
注意:不同版本的ansible的功能差异可能较大。
只需在服务端安装
被控端如开启SELinux需要安装libselinux-python

编译安装

解决依赖关系

1
2
3
4
5
6
7
s01 ~]# yum -y install python-jinja2 PyYAML python-paramiko python-babel python-crypto
s01 ~]# tar xf ansible-1.5.4.tar.gz
s01 ~]# cd ansible-1.5.4
s01 ~]# python setup.py build
s01 ~]# python setup.py install
s01 ~]# mkdir /etc/ansible
s01 ~]# cp -r examples/* /etc/ansible

rpm包安装

1
s01 ~]# yum install ansible  		# 依赖epel源

配置文件:/etc/ansible/ansible.cfg
主机清单:/etc/ansible/hosts
模块说明:/usr/bin/ansible-doc

Git安装

1
2
3
s01 ~]# git clone git://github.com/ansible/ansible.git --recursive
s01 ~]# cd ./ansible
s01 ~]# source ./hacking/env-setup

pip安装

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

1
2
3
4
5
s01 ~]# yum install python-pip python-devel
s01 ~]# yum install gcc glibc-devel zibl-devel rpm-bulid openssl-devel
s01 ~]# pip install --upgrade pip
s01 ~]# pip install ansible --upgrade
s01 ~]# ansible --version

配置文件

/etc/ansible/ansible.cfg 主配置文件,配置ansible工作特性
[defaults]
#inventory = /etc/ansible/hosts # 主机列表配置文件
#library = /usr/share/my_modules/ # 库文件存放目录
#remote_tmp = $HOME/.ansible/tmp #临时py命令文件存放在远程主机目录
#local_tmp = $HOME/.ansible/tmp # 本机的临时命令执行目录
#forks = 5 # 默认并发数
#sudo_user = root # 默认sudo 用户
#ask_sudo_pass = True # 每次执行ansible命令是否询问ssh密码
#ask_pass = True
#remote_port = 22
#host_key_checking = False # 首次ssh连接要求输入yes,建议取消注释,即不输入yes
#log_path=/var/log/ansible.log # 日志文件
#module_name = command # 默认模块

/etc/ansible/hosts 主机清单 # 默认的Inventory file
/etc/ansible/roles 存放角色的目录

常用设置
启用日志 log_path= /var/log/ansible.log
修改默认模块 module name = shell
首次链接不输入yes

配置免密登录

ansible通过ssh实现配置管理、应用部署、任务执行等功能,因此,需要事先配置ansible端能基于密钥认证的方式联系各被管理节点;或者在Inventory中指定账号密码

1
2
3
4
5
6
7
8
9
node2 ~]$ ssh-keygen   [ -t rsa -P '' ]  
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa): 回车
node2 ~]$ ssh-copy-id [ -i ~/.ssh/id_rsa.pub ] root@192.18.35.2
node2 ~]$ ssh-copy-id [ -i ~/.ssh/id_rsa.pub ] root@192.18.35.3
node2 ~]$ ssh-copy-id [ -i ~/.ssh/id_rsa.pub ] root@192.18.35.4
node2 ~]$ ssh root@192.18.35.2 'date'
node2 ~]$ ssh root@192.18.35.3 'date'
node2 ~]$ ssh root@192.18.35.4 'date'

ansible常见应用

1
2
3
4
5
6
7
8
vim /etc/ansible/host
[websrvs]
172.16.100.7:2222
172.16.100.8
[DB]
172.16.100.9
node2 ~]$ ansible websrvs --list #查看组里的成员
node2 ~]$ ansible all --list #查看所有主机

主机清单inventory

Inventory 主机清单
ansible的主要功用在于批量主机操作,为了便捷地使用其中的部分主机,可以在inventory file中将其分组命名

默认的inventory file为 /etc/ansible/hosts
inventory file可以有多个,且也可以通过Dynamic Inventory来动态生成

ansible 的 Host-pattern 匹配主机的列表

all : 表示所有Inventory中的主机

* :通配符   
    node2 ~]$ ansible "*" -m ping  ## 等价于all
    node2 ~]$ ansible 192.168.1.* -m ping  ## 从主机清单里匹配通配符表示的地址
    node2 ~]$ ansible "web*" -m ping

: & | : | :!  与 或 非 逻辑关系
    node2 ~]$ ansible "web:&app" -m ping   ## 与关系 既在在web组又在app组里的主机
    node2 ~]$ ansible "web:app" -m ping    ## 或关系 web组和app组里的所有主机
    node2 ~]$ ansible "web:!app" -m ping   ## 非关系 在web里但不在app里
正则表达式
    node2 ~]$ ansible "~(web|db).*\.meng\.com" -m ping   ## ~表示后面跟的正则表达式

/etc/ansible/hosts文件格式

inventory文件遵循INI文件风格,中括号中的字符为组名。可以将同一个主机同时归并到多个不同的组中;此外,当目标主机使用了非默认的SSH端口,还可以在主机名称之后使用冒号加端口号来标明
ntp.magedu.com
[webservers]
www1.magedu.com:2222
www2.magedu.com
[dbservers]
db1.magedu.com
db2.magedu.com
db3.magedu.com
如果主机名称遵循相似的命名模式,还可以使用列表的方式标识各主机,示例:
[websrvs]
www[1:100].example.com
[dbsrvs]
db-[a:f].example.com

常用命令

1
2
3
4
5
6
7
8
9
10
11
node2 ~]$ ansible-doc -l  ## 列出当前主机ansible支持的所有模块 ;-a 是所有模块
node2 ~]$ ansible-doc yum ## --snippet Show playbook snippet for specified module(s) 查看yum模块帮助
node2 ~]$ ansible-doc -s command #查看command模块的用法, 不带-s为详细用法

ansible <host-pattern> [-f forks] [-m module_name] [-a args]
-f forks: 启动的并发线程数。能调用几台主机
-m module_name: 要使用的模块,不指定-m,使用默认模块(可更改)
-a args: 模块特有的参数
-v -vvv:显示详细信息
--version
--list

ansible命令执行过程

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

ansible特性:

具有幂等性,即多次执行,只有第一次生效

常见模块

command:默认模块,可以忽略 -m选项。

此命令不支持$VARNAME < > | ; & 等符号,所以一般使用shell模块

1
2
3
node2 ~]$ ansible websrvs -m command -a 'date'
node2 ~]$ ansible 192.18.35.2 -m command -a 'date'
node2 ssh]$ ansible all -m command -a 'date'

执行状态:配置文件定义
绿色:执行成功并且不需要做改变的操作
黄色:执行成功并且对目标主机做变更
红色:执行失败

shell:类似command,但可执行管道等功能的复杂命令

更改默认模块为shell:vim /etc/ansible/ansible.cfg module_name = shell

1
node2 ~]$ ansible srv -m shell -a 'echo magedu |passwd –stdin wang'

注意:当调用bash执行类似命令 cat stanley.md | awk ‘{print $1}’ &> /tmp/example.txt 这些杂命令,即使使用shell也可能会失败。 解决办法:写到脚本里,使用script模块执行

script:在远程主机上运行ansible服务器上的脚本

原理:本地脚本复制到远程主机,并运行脚本,仅支持使用相对路径

1
2
3
4
5
6
7
8
node2 ~]$ vim test.sh
#!/bin/bash
echo "test page" > /tmp/script.ansible
useradd user2
node2 ~]$ chmod +x /tmp/test.sh
node2 ~]$ ansible all -m srcipt -a '/root/test.sh'
测试:tail /etc/passwd
ls -l /tmp

cron:计划任务

支持时间: minute, hour, day, month, weekday

实例:实现每10分钟运行一次命令 */10 * * * * /bin/echo “hello word”

1
2
3
4
5
6
node2 ssh]$ ansible websrvs -m cron -a 'minute="*/10" job="/bin/echo hello" name="test cron job"'  
#任务中不写*,默认都为*,即*/10 * * * *; state默认present,可以不写
node2 ssh]$ ansible srv -m cron -a "minute=*/5 job='/usr/sbin/ntpdate 172.16.0.1 &>/dev/null' name=Synctime"
node2 ssh]$ ansibe srv -m cron -a 'state=absent name=test cron jab' ## 删除计划任务
disabled=yes 禁用计划任务,直接注释计划任务代码
测试:node2 ssh]$ ansible srv -a 'crontab -l '

user:group

1
2
3
4
5
6
7
node2 ~] ansible app -m user -a 'uid=198 group=MAN groups=PAG,focus system=yes name=testu password=1 append=yes'
#注意:append=yes时groups里的组追加到用户组里
append=no(默认)时,groups里的组会覆盖原来的组
创建系统用户会自动创建家目录,因为create_home默认为yes
node2 ~] ansible srv -m user -a ‘name=user1 state=absent remove=yes‘
## 删除用户state 删除家目录 remove
node2 ssh]$ ansible websrvs -m group -a 'name=mysql gid=306 system=yes'

copy:复制文件

src: 定义本地源文件
dest:定义远程目标文件路径
backup=yes 如目标存在,默认覆盖,此处指先备份在拷贝
content:直接用指定信息生成为目标文件内容 与src不能同时用
1
2
3
4
node2 ssh]$ ansible all -m copy -a 'content="Hello word\nHi,meng" dest=/tmp/test.ansible'
## 指定内容,直接生成目标文件
node2 ssh]$ ansible app -m copy -a 'src=/data/config dest=/etc/selinux/ backup=yes'
## 如果目标存在,默认覆盖,此处指定先备份

Fetch:从远程主机提取文件至主控端,copy相反,目前不支持目录需要先tar

1
2
node2 ssh]$ ansible srv -m fetch -a 'src=/root/a.sh dest=/data/scripts'
## 多台机器会生成目录,不用担心混淆

file:设定文件属性

path:指定文件路径,可使用name或dest来替换
1
2
3
4
node2 ssh]$ ansible all -m file -a 'owner=mysql group=mysql mode=644 path=/tmp/fstab.ansible'
测试:切换主机 ls -l /tmp
node2 ssh]$ ansible srv -m file -a 'path=/data/test.txt state=absent' ## 删除文件
node2 ssh]$ ansible all -m file -a 'dest=/tmp/fstab.link src=/tmp/fstab.ansible state=link' ## 创建符号链接文件

ping:测试主机是否能连接

1
node2 ssh]$ ansible all -m ping

service:管理服务

enabled:是否开机启动
state:状态,取值started | stopped | restarted | reloaded
name:服务名称
1
2
3
node2 ssh]$ ansible all -a 'service httpd status'    #使用command模块也可
node2 ssh]$ ansible websrvs -a 'chkconfig --list httpd'
node2 ssh]$ ansible websrvs -m service -a 'enabled=yes name=httpd state=started'

yum:安装卸载程序包

name:需要安装的程序包,可以带版本号
state:present, installed, latest (最新版本)  表示安装,absent,removed表示卸载 
1
node2 ~]$ ansible all -m yum -a 'name=vsftpd,samba'     ## 可以一次性装多个包

setup:收集远程主机可用的facts

facts是由正在通信的远程目标主机发回的信息,这些信息被保存在ansible变量中。要获取指定的远程主机所支持的所有facts,可使用如下命令进行:ansible hostname -m setup

每个被管理节点在接受并运行管理命令之前,会将自己主机相关信息如操作系统版本,IP地址等报告给远程ansible主机此信息使用setup模块查看,其中的键值就是变量,可以使用fileter查找,playbook中 “{{  }}”调用
1
2
3
node2 ssh]$ ansible all -m setup | grep  $%^&
node2 ssh]$ ansible all -m setup -a 'filter="ansible_distribution_major_version"'
node2 ssh]$ ansible all -m setup -a 'filter="ansible_nodename"'

unarchive:解包解压缩

有两种用法:
1、将ansible主机上的压缩包在本地解压缩后传到远程主机上,设置copy=yes.
2、将远程主机上的某个压缩包解压缩到指定路径下,设置copy=no
常见参数:
copy:默认yes,将压缩包解压后从ansible主机复制到远程主机,当copy=no,会在远程主机上寻找src源文件
src:默认是ansible主机上的路径,设置copy=no后是远程主机上的路径
dest:远程主机上的目标路径
mode:设置解压缩后的文件权限

1
2
3
4
node2 ~]$ tar Jcf sysconfig.tar.xz /etc/sysconfig
node2 ~]$ ansible srv -m unarchive -a 'srv=/data/sysconfig.tar.xz dest=/data/ copy=yes' ## copy可以不写
node2 ~]$ ansible srv -m unarchive -a 'src=/tmp/foo.zip dest=/data copy=no mode=0777'
node2 ~]$ ansible srv -m unarchive -a 'src=https://example.com/example.zip dest=/data copy=no'

archive:打包压缩

1
node2 ~]$ansible all -m archive -a 'path=/etc/sysconfig dest=/data/sysconfig.tar.bz2 format=bz2 owner=wang mode=0777'

Hostname:管理主机名

更改配置文件,并且立即生效
1
2
node2 ssh]$ ansible node1 -m hostname -a “name=websrv”
node2 ssh]$ 批量改机器时因为主机名都不一样用到变量

authorized_key:添加sshd免密登录

= key The SSH public key(s) 可以是字符串或url (https://github.com/username.keys)
- state

    present 添加指定key到authorized_keys文件中
    absent 从authorized_keys文件中移除指定key [Default: present]

1
node01 ~]$ ansible all -m authorized_key -a "user=root key='{{ lookup('file', '/root/.ssh/id_rsa.pub')}}' path='/root/.ssh/authorized_keys' manage_dir=no" --ask-pass -c paramiko

示例:新增公钥内容到服务器用户家目录的.ssh目录的authorized_keys文件 没有则创建authorized_keys文件

1
2
3
4
5
6
7
8
9
10
---
- hosts: test
gather_facts: false
tasks:
- name: deliver authorized_keys
authorized_key:
user: root
key: "{{ lookup('file', '/etc/ansible/roles/authorized_keys') }}" # 从本地authorized_keys文件读取公钥内容
state: present
exclusive: no

ansible-galaxy

连接 https://galaxy.ansible.com 下载相应的roles

1
2
3
node2 ~ ]$ ansible-galaxy list     ## 列出所有已安装的galaxy,未安装任何role时有两条报警
node2 ~ ]$ ansible-galaxy install geerlingguy.redis ## 安装galaxy,从网站上找的
node2 ~ ]$ ansible-galaxy remove geerlingguy.redis ## 删除galaxy,或者删除目录

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

变量

变量名仅能由字母、数字和下划线组成,且只能以字母开头。

变量来源:

1 ansible setup facts 远程主机的所有变量都可直接调用
2 在/etc/ansible/hosts中定义
普通(主机)变量: 主机组中主机单独定义,优先级高于公共变量
[websrvs]
192.168.32.6 http_port=86
192.168.32.7 http_port=87
公共(组) 变量: 针对主机组中所有主机定义统一变量
[websrvs]
192.168.32.6
192.168.32.7
[websrvs:vars]
varname=value
3 通过命令行指定变量,优先级最高
ansible-playbook –e varname=value
4 在playbook中定义
remote_user: root
vars:
- var1: value1
- var2: value2
5 在独立的变量YAML文件中定义
node2 ~ ]$ cat test_var.yml
- hosts: web
remote_user: root
vars_files:
- var.yml ## 如果不在同一目录可以试试绝对路径
node2 ~ ]$ cat var.yml
http_port: 8080
pname: projectA
6 在role中定义
- hosts: webservers
roles:
- common
- { role: foo_app_instance, dir: ‘/web/htdocs/a.com’, port: 8080 }

变量调用

通过{{ variable_name }} 调用变量,变量名前后可以有空格,有时用“{{ variable_name }}”才生效

示例1:使用setup变量

1
2
3
4
5
6
7
node2 ~ ]$ cat var.yml
- hosts: websrvs
remote_user: root
tasks:
- name: create log file
file: name=/var/log/{{ ansible_fqdn }} state=touch ## 主机名
node2 ~ ]$ ansible-playbook var.yml

示例2:命令行变量

1
2
3
4
5
6
7
node2 ~ ]$ cat var.yml
- hosts: websrvs
remote_user: root
tasks:
- name: install package
yum: name={{ pkname }} state=present
node2 ~ ]$ cat ansible-playbook –e pkname=httpd var.yml

示例3:yaml变量

1
2
3
4
5
6
7
8
9
10
11
12
13
node2 ~ ]$ var.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
node2 ~ ]$ ansible-playbook var.yml
node2 ~ ]$ ansible-playbook -e "username=user2 groupname=group2” var2.yml ## 命令行变量优先级最高

register

把任务的输出定义为变量,然后用于其他任务,示例如下:

1
2
3
4
tasks:
- shell: /usr/bin/foo
register: foo_result
ignore_errors: True

组嵌套

inventory中,组还可以包含其它的组,并且也可以向组中的主机指定变量。不过,这些变量只能在ansible-playbook中使用,而ansible不支持。例如:

1
2
3
4
5
6
7
8
9
10
11
[apache]
httpd1.magedu.com
httpd2.magedu.com
[nginx]
ngx1.magedu.com
ngx2.magedu.com
[webservers:children] #此组包含四台主机
apache
nginx
[webservers:vars]
ntp_server=ntp.magedu.com

inventory参数

ansible基于ssh连接inventory中指定的远程主机时,还可以通过参数指定其交互方式;这些参数如下所示:
ansible_ssh_host:
## The name of the host to connect to, if different from the alias you wish to give to it.
ansible_ssh_port:
## The ssh port number, if not 22
ansible_ssh_user:
## The default ssh user name to use.
ansible_ssh_pass:
## The ssh password to use (this is insecure, we strongly recommend using –ask-pass or SSH keys)
ansible_sudo_pass:
## The sudo password to use (this is insecure, we strongly recommend using –ask-sudo-pass)
ansible_connection:
## Connection type of the host. Candidates are local, ssh or paramiko. The default is paramiko before Ansible 1.2, and ‘smart’ afterwards which detects whether usage of ‘ssh’ would be feasible based on whether ControlPersist is supported.
ansible_ssh_private_key_file
## Private key file used by ssh. Useful if using multiple keys and you don’t want to use SSH agent.
ansible_shell_type:
## The shell type of the target system. By default commands are formatted using ‘sh’-style syntax by default. Setting this to ‘csh’ or ‘fish’ will cause commands executed on target systems to follow those shell’s syntax instead.
ansible_python_interpreter
## The target host python path. This is useful for systems with more than one Python or not located at “/usr/bin/python” such as *BSD, or where /usr/bin/python is not a 2.X series Python. We do not use the “/usr/bin/env” mechanism as that requires the remote user’s path to be set right and also assumes the “python” executable is named python, where the executable might be named something like “python26”.

ansible_*_interpreter:
## Works for anything such as ruby or perl and works just like ansible_python_interpreter.
This replaces shebang of modules which will run on that host.

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语法

YAML的语法和其他高阶语言类似,并且可以简单表达清单、散列表、标量等数据结构。其结构(Structure)通过空格来展示,序列(Sequence)里的项用”-“来代表,Map里的键值对用”:”分隔。下面是一个示例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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的内容,一般建议写明该Playbook的功能
使用#号注释代码
缩进必须是统一的,不能空格和tab混用
缩进的级别也必须是一致的,同样的缩进代表同样的级别,程序判别配置的级别是通过缩进结合换行来实现的
YAML文件内容是区别大小写的,k/v的值均需大小写敏感
多个k/v可同行写也可换行写,同行使用,分隔;v可是个字符串,也可是另一个列表
一个完整的代码块功能需最少元素需包括 name 和 task
一个name只能包括一个task
YAML文件扩展名通常为yml或yaml

list:列表的所有元素均使用“-”打头,例如:

1
2
3
4
# A list of tasty fruits
- Orange
- Strawberry
- Mango

dictionary:字典通过key与value进行标识,例如:

1
2
3
4
# An employee record
name: Example Developer
job: Developer
skill: Elite

也可以将key:value放置于{}中进行表示,例如:

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

ansible playbooks

playbook是由一个或多个“play”组成的列表。play的主要功能在于将事先归并为一组的主机装扮成事先通过ansible中的task定义好的角色。从根本上来讲,所谓task无非是调用ansible的一个module。将多个play组织在一个playbook中,即可以让它们联同起来按事先编排的机制同唱一台大戏。下面是一个简单示例。
1
2
3
4
5
6
7
8
9
10
- hosts: webnodes      #Inventory中定义的目标主机(组)
remote_user: root #连接到远程主机以什么身份运行
vars: #定义变量
http_port: 80
max_clients: 256
tasks: #执行的任务
- name: ensure apache is at the latest version #第一个任务
yum: name=httpd state=latest
- name: ensure apache is running #第二个任务
service: name=httpd state=started

运行playbook

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

常见选项
–check -C 只检测可能会发生的改变,但不真正执行操作
–list-hosts 列出运行任务的主机
–list-tags 列出tag
–list-tasks 列出task
–limit 主机列表 ## 只针对主机列表中的主机执行
-v -vv -vvv 显示过程

1
2
3
node01 ~]$ ansible-playbook file.yml --check | -C   ## 只检测
node01 ~]$ ansible-playbook file.yml
node01 ~]$ ansible-playbook file.yml --limit websrvs

说明:上图tasks下面要缩进两个字符

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 创建新文件

playbook基础组件

Hosts和Users

playbook中的每一个play的目的都是为了让某个或某些主机以某个指定的用户身份执行任务。
hosts用于指定要执行指定任务的主机,其可以是一个或多个由冒号分隔主机组。用法同命令行的ansible
remote_user则用于指定远程主机上的执行任务的用户。如上面示例中的
    -hosts: webnodes
     remote_user: root
不过,remote_user也可用于各task中。也可以通过指定其通过sudo的方式在远程主机上执行任务,其可用于play全局或某任务;此外,甚至可以在sudo时使用sudo_user指定sudo时切换的用户。

一般情况下一个yml文件中只写一个- host

1
2
3
4
5
6
7
8
node2 ~]$ vim test.yml
- hosts: websrvs
remote_user: root
tasks:
- name: create nginx user
user: name=nginx uid=208 group=nginx system=yes
- name: create nginx group
group: name=nginx system=yes gid=208

task list 和action

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

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

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

定义task可以使用“action: module options”或“module: options”的格式,推荐使用后者以实现向后兼容。如果action一行的内容过多,也中使用在行首使用几个空白字符进行换行。
    tasks:
      - name: make sure apache is running
       service: name=httpd state=running

在众多模块中,只有command和shell模块仅需要给定一个列表而无需使用“key=value”格式,例如:
        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 - handlers和notify结合使用触发条件

用于当关注的资源发生变化时采取一定的操作。
“notify”这个action可用于在每个play的最后被触发,这样可以避免多次有改变发生时每次都执行指定的操作,notify仅在所有的变化发生完成后一次性地执行指定操作。在notify中列出的操作称为handler,也即notify中调用handler中定义的操作。
注意事项:handlers的位置与tasks平齐,否则报语法错误

1
2
3
4
5
6
7
8
9
10
11
12
13
14
node2 ~]$ vim yum.yml
- hosts: all
remote_user: root
tasks:
- name: install httpd package
yum: name=httpd state=latest
- name: install configuration file for httpd
copy: src=/root/conf/httpd.conf dest=/etc/httpd/conf/httpd.conf
notify: restart httpd ## 写在name 列表下,当关注的copy文件发生改变触发notify执行handlers
- name: start httpd service
service: enabled=true name=httpd state=started
handlers:
- name: restart httpd
service: name=httpd state=restarted

示例2:多个notify对应多个handlers

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
- 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 ## 错误检查,返回0正常

playbook-Tags

tags用于让用户选择运行playbook中的部分代码。ansible具有幂等性,因此会自动跳过没有变化的部分,即便如此,有些代码为测试其确实没有发生变化的时间依然会非常地长。此时,如果确信其没有变化,就可以通过tags跳过此些代码片断。
为tasks添加“标签”,在执行此playbook时通过为ansible-palybook命令使用–tags | -t 选项能实现仅运行指定的tasks,同样多个name下可以调用同样的tags,意为带tags都运行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
node2 ~ ]$ cat 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
service: name=httpd state=started enabled=yes
tags:
- service
node2 ~ ]$ ansible-playbook -t conf,service httpd.yml ## 可以调用多个tags,也可以写多个同名的tags

特殊tags:always 无论如何都会运行

实例:二进制部署MySQL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 tasks:
- name: create group
group: name=mysql system=yes
- name: create user
user: name=mysql system=yes home=/data/mysql shell=/sbin/nologin group=mysql
- name: unarchive original file
unarchive: src=/data/mariadb-10.2.22-linux-x86_64.tar.gz dest=/usr/local
- name: mysqldir dir owner group
file: path=/usr/local/mariadb-10.2.22-linux-x86_64 state=directory owner=root group=mysql recurse=yes
- name: mysqldir link
file: src=/usr/local/mariadb-10.2.22-linux-x86_64 path=/usr/local/mysql state=link
- name: data file
shell: chdir=/usr/local/mysql/ ./scripts/mysql_install_db --user=mysql --datadir=/data/mysql
-name: copy config file
copy: src=/data/my.cnf dest=/etc/ backup=yes
-name: copy script file
copy: src=/data/mysqld dest=/etc/init.d/ mode=755
-name: start service
shell: /etc/init.d/mysqld start

playbook-template

文本文件,嵌套有脚本(使用模板编程语言编写)
Jinja2语言,使用字面量,有下面形式
字符串:使用单引号或双引号
数字:整数,浮点数
列表:[item1, item2, …]
元组:(item1, item2, …)
字典:{key1:value1, key2:value2, …}
布尔型:true/false
算术运算:+, -, , /, //, %, *
比较操作:==, !=, >, >=, <, <=
逻辑运算:and,or,not
流表达式:For,If,Whentemplate
功能:根据模块文件动态生成对应的配置文件

template文件必须存放于templates目录下,且命名为 .j2 结尾

yaml/yml 文件需和templates目录平级,目录结构如下:
./
├── temnginx.yml #调用模板的文件
└── templates #配置文件里不需要写路径,会自动在yml平级的目录里寻找
└── nginx.conf.j2 #模板

帮助:ansible-doc -s template 有点类似copy

Jinja2相关

字面量
字面量表示诸如字符串和数值的 Python 对象。下面 的字面量是可用的: “Hello World”:
双引号或单引号中间的一切都是字符串。无论何时你需要在模板中使用一个字符串(比如函数调用、过滤器或只是包含或继承一个模板的参数),它们都是有用的。
42 / 42.23:
直接写下数值就可以创建整数和浮点数。如果有小数点,则为浮点数,否则为 整数。记住在 Python 里, 42 和 42.0 是不一样的。
[‘list’, ‘of’, ‘objects’]:
一对中括号括起来的东西是一个列表。列表用于存储和迭代序列化的数据。例如 你可以容易地在 for 循环中用列表和元组创建一个链接的列表:

<ul>
{% for href, caption in [('index.html', 'Index'),('about.html', 'About'),('downloads.html', 'Downloads')] %}
	    
  • {{ caption }}
  • {% endfor %} </ul> (‘tuple’, ‘of’, ‘values’):

    元组与列表类似,只是你不能修改元组。如果元组中只有一个项,你需要以逗号 结尾它。元组通常用于表示两个或更多元素的项。更多细节见上面的例子。
    {‘dict’: ‘of’, ‘key’: ‘and’, ‘value’: ‘pairs’}:

    Python 中的字典是一种关联键和值的结构。键必须是唯一的,并且键必须只有一个值。字典在模板中很少使用,罕用于诸如 xmlattr() 过滤器之类。
    true / false:
    true 永远是 true ,而 false 始终是 false 。

    算术运算
    Jinja 允许你用计算值。这在模板中很少用到,但是为了完整性允许其存在。支持下面的运算符:
        +        把两个对象加到一起。通常对象是素质,但是如果两者是字符串或列表,你可以用这种方式来衔接它们。无论如何这不是首选的连接字符串的方式!连接字符串见 ~ 运算符。  ##  {{ 1 + 1 }} 等于 2 。
        -        用第一个数减去第二个数。   ## {{ 3 - 2 }} 等于 1 。
        /        对两个数做除法。返回值会是一个浮点数。     ## {{ 1 / 2 }} 等于 {{ 0.5 }} 。
        //        对两个数做除法,返回整数商。   ## {{ 20 // 7 }} 等于 2 。
        %        计算整数除法的余数。     ## {{ 11 % 7 }} 等于 4 。
        *        用右边的数乘左边的操作数。 {{ 2 * 2 }} 会返回 4 。
                也可以用于重复一个字符串多次。 {{ ‘=’ * 80 }} 会打印 80 个等号的横条。
        **        取左操作数的右操作数次幂。 {{ 2**3 }} 会返回 8 。

    比较操作符

    ==        比较两个对象是否相等。
    !=        比较两个对象是否不等。
    >        如果左边大于右边,返回 true 。
    >=        如果左边大于等于右边,返回 true 。
    <        如果左边小于右边,返回 true 。
    <=        如果左边小于等于右边,返回 true 。

    逻辑运算符

    对于 if 语句,在 for 过滤或 if 表达式中,它可以用于联合多个表达式:
    and 如果左操作数和右操作数同为真,返回 true 。
    or 如果左操作数和右操作数有一个为真,返回 true 。
    not 对一个表达式取反(见下)。
    (expr) 表达式组。

    template实验

    利用template 同步nginx配置文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    node2 data]$ mkdir templates   ##注意template目录和yml文件平级
    node2 data]$ cp /etc/nginx/nginx.conf template/nginx.conf.j2
    node2 data]$ cat template/nginx.conf.j2 ## 修改模板文件
    worker_processes {{ ansible_processor_vcpus }};
    node2 data]$ cat test_tmplate.yml
    - hosts: app
    remote_user: root
    tasks:
    - name: install app
    yum: name=nginx
    - name: config file
    template: src=nginx.conf.j2 dest=/etc/nginx/nginx.conf
    - name:data file
    copy: src=/data/index.html dest=/usr/share/nginx/html/
    - name: service
    service: name=nginx state=started enabled=yes
    node2 ~]$ ansible-palybook -C nginx.yml
    node2 ~]$ ansible-palybook nginx.yml
    node2 ~]$ ansible app -a 'ps aux| grep nginx'

    条件测试

    如果需要根据变量、facts或此前任务的执行结果来做为某task执行与否的前提时要用到条件测试。

    when语句

    在tasks后添加when子句即可使用条件测试;when语句支持Jinja2表达式语法。例如:

    1
    2
    3
    4
    5
    6
    7
    tasks:                                                 
    - name: install conf file to centos7
    template: src=nginx.conf.c7.j2 dest=/etc/nginx/nginx.conf
    when: ansible_distribution_major_version == "7"
    - name: install conf file to centos6
    template: src=nginx.conf.c6.j2 dest=/etc/nginx/nginx.conf
    when: ansible_distribution_major_version == "6"

    when语句中还可以使用Jinja2的大多“filter”,例如要忽略此前某语句的错误并基于其结果(failed或者sucess)运行后面指定的语句,可使用类似如下形式:

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

    此外,when语句中还可以使用facts或playbook中定义的变量。

    迭代(循环)

    当有需要重复性执行的任务时,可以使用迭代机制。格式为将需要迭代的内容定义为item变量引用,并通过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到被控端

    1
    2
    3
    4
    5
    6
    tasks:
    - name: Create rsyncd config
    copy: src={{ item }} dest=/etc/{{ item }}
    with_items:
    - rsyncd.secrets
    - rsyncd.conf

    示例:迭代嵌套子变量

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    tasks:
    - name: add some groups ## 先创建好组,保证下面创建的user有组
    group: name={{ item }} state=present
    with_items:
    - group1
    - group2
    - name: add some users ## 当name为user1时,group为group1 •••
    user: name={{ item.name }} group={{ item.group }} state=present
    with_items:
    - { name: 'user1', group: 'group1' }
    - { name: 'user2', group: 'group2' }

    Playbook中template for if

    示例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
    node2 ~]$ cat test.for1.yml
    - hosts: appsrvs
    remote_user: root
    vars:
    ports:
    - 81
    - 82
    - 83
    tasks:
    - name:test for
    template:src=for.conf.j2 dest=/data/for1.conf

    node2 ~]$ cat for1.conf.j2
    {% for p in ports %}
    server {
    listen {{p}}
    }
    {%endfor%}

    node2 ~]$ cat for1.conf
    server {
    listen 81
    }
    server {
    listen 82
    }
    server {
    listen 83
    }

    示例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
    29
    node2 ~]$ cat test.for2.yml
    - hosts: appsrvs
    remote_user: root
    vars:
    ports:
    - listen: 81
    - listen: 82
    - listen: 83
    tasks:
    - name:test for
    template:src=for2.conf.j2 dest=/data/for2.conf

    node2 ~]$ cat for2.conf.j2
    {% for p in ports %}
    server {
    listen {{p.listen}}
    }
    {%endfor%}

    node2 ~]$ cat for1.conf
    server {
    listen 81
    }
    server {
    listen 82
    }
    server {
    listen 83
    }

    示例3:

    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
    node2 ~]$ cat test.for3.yml
    - hosts: appsrvs
    remote_user: root
    vars:
    parameter:
    - web1
    listen: 81
    name: www.meng1.com
    root: /data/web1
    - web2
    listen: 82
    name: www.meng2.com
    root: /data/web2
    - web3
    listen: 83
    name: www.meng3.com
    root: /data/web3
    tasks:
    - name:test for
    template:src=for3.conf.j2 dest=/data/for3.conf

    node2 ~]$ cat for3.conf.j3
    {% for p in parameter %}
    server {
    listen {{p.listen}}
    servername {{p.name}}
    rootdir {{p.root}}
    }
    {%endfor%}

    node2 ~]$ ansible-playbook test_for3.yml

    roles

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

    一个roles的案例如下所示:
        site.yml
        webservers.yml
        fooservers.yml
        roles/
           fooservers/
             files/
             templates/
             tasks/
             handlers/
             vars/
             meta/
           webservers/
             files/
             templates/
             tasks/
             handlers/
             vars/
             meta/
    
    而在playbook中,可以这样使用roles:
    ---
    - hosts: all
      roles:
        - fooservers
        - webservers
    
    也可以向roles传递变量,例如:
    - hosts: webservers
      roles:
        - fooservers
        - { role: foo_app_instance, dir: '/opt/a', port: 5000 }
        - { role: foo_app_instance, dir: '/opt/b', port: 5001 }
    
    甚至也可以条件式地使用roles,例如:
    - hosts: webservers
      roles:
        - { role: some_role, when: "ansible_os_family == 'RedHat'" }

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

    roles目录结构

    playbook.yml
    roles/
      project/ 此目录命令必须同playbook中调用的roles一致,包含以下子目录
        tasks/:定义task,至少包含一个main.yml;其它task文件需要在此文件中通过include进行包含
        files/:存放由copy或script模块等调用的静态文件
        vars/:定义变量,至少应该包含一个main.yml;其它的文件需要在此文件中通过include进行包含  
        templates/: template模块会自动在此目录中寻找Jinja2模板文件;使用相对路径调用
        handlers/:应当包含一个main.yml,用于定义此角色用到的各handler;在handler中使用include包含的其它的handler文件也应该位于此目录中
        default/:为当前角色设定默认变量时使用此目录;应当包含一个main.yml文件;  不常用
        meta/:定义当前角色的特殊设定及其依赖关系,至少应该包含一个名为main.yml的文件,其它文件需在此文件中通过include进行包含ansible 1.3及其以后的版本才支持  不常用

    创建role的步骤

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

    roles案例实验

    场景:三台被管理主机功能分别是 host1:httpd host2: php host3: mysql-server写成roles时:
    hosts: host1 hosts: host2 hosts: hosts3
    role: role: role:
    - websrvs - phpappsrvs - dbsrvs

    真实情况是每一台主机可能有多个role,即host4:httpd+php+mysql-server,当需要配置host4时,可以写:
    host: host4
    role
    - websrvs
    - phpappsrvs
    - dbsrvs

    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
    node1 ~]$ mkdir -pv ansible_palybooks/roles/{websrvs,dbsrvs}/{tasks,files,templates,meta,handlers,vars}
    node1 ~]$ tree ansible_playbooks/
    node1 ~]$ cd ansible_playbooks/roles/websrvs/
    node1 ~]$ ls
    files handlers meta tasks templates vars
    node1 websrvs]$ cp /etc/httpd/conf/httpd.conf files/
    node1 websrvs]$ vim tasks/main.yml
    - name: install httpd package
    yum: name=httpd
    - name: install configuration file
    copy: src=httpd.conf dest=/etc/httpd/conf/httpd.conf

    tags:
    - conf
    notify:
    - restart httpd

    - name: start httpd
    service: name=httpd state=started
    node1 websrvs]$ vim handlers/main.yml
    - name: restart httpd
    service: name=httpd state=restarted

    node1 websrvs]$ cd ../dbsrvs
    node1 dbsrvs]$ cp /etc/my.cnf files/
    node1 dbsrvs]$ vim tasks/main.yml
    - name: install mysql-server package
    yum: name=mysql-server state=latest
    -name: install configuration file
    copy: srv=my.cnf dest=/etc/my.cnf

    tags:
    - myconf
    notify:
    - restart mysqld

    -name: start mysqld service
    service: name=mysqld enabled=ture state=started

    node1 dbsrvs]$ vim handlers/main.yml
    - name: restart mysqld
    service: name=mysqld state=restarted
    node1 dbsrvs]$ cd ../..
    node1 ansible_palybooks]$ ll
    drwxr-xr-x 4 root root 31 May 25 21:57 roles
    node1 ansible_palybooks]$ vim site.yml ## 文件名可自定义
    - hosts: 192.18.35.3
    remote_user: root
    roles:
    - websrvs

    -hosts: 192.18.35.2
    remote_user: root
    roles:
    - dbsrvs

    -hosts: 192.18.35.4
    remote_user: root
    roles:
    - websrvs
    - dbsrvs
    node1 ansible_palybooks]$ ansible-playbook -C site.yml

    实验,不同处在于tasks目录里main.yml使用 include,以及site.yml调用roles的写法

    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
    node01 data]$ mkdir roles/nginx/{tasks,templates,handlers,files} -pv
    node01 data]$ cd roles/nginx/tasks
    node01 tasks]$ cat group.yml
    - name: create group
    group: name=nginx system=yes gid=80
    node01 tasks]$ cat user.yml
    -name: create user
    user: name=nginx group=nginx uid=80 system=yes shell=/sbin/nologin home=/data/www
    node01 tasks]$ cat package.yml
    - name: install package
    yum: name=nginx
    node01 tasks]$ cat copyconf.yml
    - name: copy config
    copy: src=nginx.conf dest=/etc/nginx
    node01 tasks]$ cat service.yml
    - name: service
    service: name=nginx state=started enabled=yes
    node01 tasks]$ cat temconf.yml
    - name: template
    template: src=nginx.conf.j2 dest=/etc/nginx/nginx.conf
    node01 tasks]$ cat main.yml
    - include: group.yml
    - include: user.yml
    - include: package.yml
    - include: copyconf.yml
    - include: service.yml
    node01 nginx]$ cat files/nginx.conf
    worker_processess 6;
    node01 files]$ cd ../../
    node01 data]$ cat nginx_role.yml
    - hosts: websrvs
    remote_user: root

    roles:
    - role: nginx
    node01 data]$ ansible-playbook nginx_role.yml

    跨角色调用文件,路径需要注意:

    1
    copy: src=roles/nginx/files/index.html dest=/var/www/thml

    roles中的tags

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    node01 data]$ cat 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 }
    node01 data]$ ansible-playbook --tags="nginx,httpd,mysql" nginx-role.yml
    0%