自动化运维-Ansible
自动化运维-Ansible
1、企业自动化运维之路
1.1 运维人员发展之路
1.2 企业自动化运维代码提交流程
2、实际应用场景
公司计划在年底做一次大型市场促销活动，全面冲刺下交易额，为明年的上市做准备。
公司要求各业务组对年底大促做准备，运维部要求所有业务容量进行三倍的扩容，并搭建出多套环境可以共开发和测试人员做测试，运维老大为了在年底有所表现，要求运维部门同学尽快实现，当你接到这个任务时，有没有更快的解决方案？
2.1 企业实际应用场景分析
1）Dev开发环境
使用者：程序员
功能：程序员开发软件，测试BUG的环境
管理者：程序员
2）测试环境
使用者：QA测试工程师
功能：测试经过Dev环境测试通过的软件的功能
管理者：运维
说明：测试环境往往有多套,测试环境满足测试功能即可，不宜过多
1、测试人员希望测试环境有多套,公司的产品多产品线并发，即多个版本，意味着多个版本同步测试
2、通常测试环境有多少套和产品线数量保持一样
3）发布环境：代码发布机，有些公司为堡垒机（安全屏障）
使用者：运维
功能：发布代码至生产环境
管理者：运维（有经验）
发布机：往往需要有2台（主备）
4）生产环境
使用者：运维，少数情况开放权限给核心开发人员，极少数公司将权限完全
开放给开发人员并其维护
功能：对用户提供公司产品的服务
管理者：只能是运维
生产环境服务器数量：一般比较多，且应用非常重要。往往需要自动工具协助部署配置应用
5）灰度环境（生产环境的一部分）
使用者：运维
功能：在全量发布代码前将代码的功能面向少量精准用户发布的环境,可基
于主机或用户执行灰度发布
案例：共100台生产服务器，先发布其中的10台服务器，这10台服务器就是灰度服务器
管理者：运维
灰度环境：往往该版本功能变更较大，为保险起见特意先让一部分用户优化体验该功能，
待这部分用户使用没有重大问题的时候，再全量发布至所有服务器
2.2 Ansible发展史
Ansible
Michael DeHaan（ Cobbler 与 Func 作者）
名称来自《安德的游戏》中跨越时空的即时通信工具
2012-03-09，发布0.0.1版，2015-10-17，Red Hat 1.5亿$宣布收购Ansible
官网：https://www.ansible.com
官方文档：https://docs.ansible.com
同类自动化工具GitHub关注程度（2016-07-10）
2.3 常用自动化运维工具
Ansible：python，Agentless，中小型应用环境
Saltstack：python，一般需部署agent，执行效率更高
Puppet：ruby, 功能强大，配置复杂，重型,适合大型环境
Fabric：python，agentless
Chef：ruby，国内应用少
Cfengine: sina
func
2.4 自动化运维应用场景
文件传输
应用部署
配置管理
任务流编排
2.5 ansible的特性
1> 模块化：调用特定的模块，完成特定任务
2> Paramiko（python对ssh的实现），PyYAML，Jinja2（模板语言）三个关键模块
3> 支持自定义模块
4> 基于Python语言实现
5> 部署简单，基于python和SSH(默认已安装)，agentless
6> 安全，基于OpenSSH
7> 支持playbook编排任务
8> 幂等性：一个任务执行1遍和执行n遍效果一样，不因重复执行带来意外情况
9> 无需代理不依赖PKI（无需ssl）
10> 可使用任何编程语言写模块
11> YAML格式，编排任务，支持丰富的数据结构
12> 较强大的多层解决方案-role
2.6 Ansible架构
ansible的作用以及工作结构
1、ansible简介：
ansible是新出现的自动化运维工具，基于Python开发，集合了众多运维工具（puppet、cfengine、chef、func、fabric）的优点，实现了批量系统配置、批量程序部署、批量运行命令等功能。ansible是基于模块工作的，本身没有批量部署的能力。真正具有批量部署的是ansible所运行的模块，ansible只是提供一种框架。
主要包括：
(1)、连接插件connection plugins：负责和被监控端实现通信；
(2)、host inventory：指定操作的主机，是一个配置文件里面定义监控的主机；
(3)、各种模块核心模块、command模块、自定义模块；
(4)、借助于插件完成记录日志邮件等功能；
(5)、playbook：剧本执行多个任务时，非必需可以让节点一次性运行多个任务。
2、ansible的架构：连接其他主机默认使用ssh协议
2.7 Ansible工作原理
2.8 Ansible主要组成部分
ANSIBLE PLAYBOOKS：任务剧本（任务集），编排定义Ansible任务集的配置文件， 由Ansible顺序依次执行，通常是JSON格式的YML文件
INVENTORY：Ansible管理主机的清单 /etc/anaible/hosts
MODULES： Ansible执行命令的功能模块，多数为内置核心模块，也可自定义
PLUGINS： 模块功能的补充，如连接类型插件、循环插件、变量插件、过滤插件等，该功能不常用
API： 供第三方程序调用的应用程序编程接口
ANSIBLE： 组合INVENTORY、API、MODULES、PLUGINS的绿框，可以理解为是ansible命令工具，其为核心执行工具
Ansible命令执行来源：
1> USER，普通用户，即SYSTEM ADMINISTRATOR
2> CMDB（配置管理数据库） API 调用
3> PUBLIC/PRIVATE CLOUD API调用 (公有私有云的API接口调用)
4> USER-> Ansible Playbook -> Ansibile
利用ansible实现管理的方式：
1> Ad-Hoc 即ansible单条命令，主要用于临时命令使用场景
2> Ansible-playbook 主要用于长期规划好的，大型项目的场景，需要有前期的规划过程
Ansible-playbook（剧本）执行过程
将已有编排好的任务集写入Ansible-Playbook
通过ansible-playbook命令分拆任务集至逐条ansible命令，按预定规则逐条执行
Ansible主要操作对象
HOSTS主机
NETWORKING网络设备
注意事项:
执行ansible的主机一般称为主控端，中控，master或堡垒机
主控端Python版本需要2.6或以上
被控端Python版本小于2.4需要安装python-simplejson
被控端如开启SELinux需要安装libselinux-python
windows不能做为主控端
ansible不是服务,不会一直启动,只是需要的时候启动
3、Ansible安装
3.1 ansible的安装方式
1）rpm包安装: EPEL源
yum install ansible
2）编译安装:
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
3）Git方式:
git clone git://github.com/ansible/ansible.git --recursive
cd ./ansible
source ./hacking/env-setup
4）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
3.2 Ansible相关文件
配置文件
/etc/ansible/ansible.cfg 主配置文件,配置ansible工作特性(一般无需修改)
/etc/ansible/hosts 主机清单(将被管理的主机放到此文件)
/etc/ansible/roles/ 存放角色的目录
程序
/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界面与用户交互的执行工具
3.3 主机清单inventory
Inventory 主机清单
1> ansible的主要功用在于批量主机操作，为了便捷地使用其中的部分主机，可以在inventory file中将其分组命名
2> 默认的inventory file为/etc/ansible/hosts
3> inventory file可以有多个，且也可以通过Dynamic Inventory来动态生成
3.4 主机清单的配置方式
/etc/ansible/hosts文件格式
inventory文件遵循INI文件风格，中括号中的字符为组名。
可以将同一个主机同时归并到多个不同的组中；
此外，当如若目标主机使用了非默认的SSH端口，还可以在主机名称之后使用冒号加端口号来标明
ntp.hopu.com 不分组,直接加
[webservers] webservers组
www1.hopu.com:2222 可以指定端口
www2.hopu.com
[dbservers]
db1.hopu.com
db2.hopu.com
db3.hopu.com
如果主机名称遵循相似的命名模式，还可以使用列表的方式标识各主机
示例：
[webweb]
www[1:100].hopu.com ip: 1-100
[dbweb]
db-[a:f].hopu.com dba-dbff
3.5 ansible 配置文件
Ansible 配置文件/etc/ansible/ansible.cfg （一般保持默认）
vim /etc/ansible/ansible.cfg
[defaults]
#inventory = /etc/ansible/hosts # 主机列表配置文件
#library = /usr/share/my_modules/ # 库文件存放目录
#remote_tmp = $HOME/.ansible/tmp # 临时py命令文件存放在远程主机目录
#local_tmp = $HOME/.ansible/tmp # 本机的临时命令执行目录
#forks = 5 # 默认并发数,同时可以执行5次
#sudo_user = root # 默认sudo 用户
#ask_sudo_pass = True # 每次执行ansible命令是否询问ssh密码
#ask_pass = True # 每次执行ansible命令是否询问ssh口令
#remote_port = 22 # 远程主机的端口号(默认22)
建议优化项：
host_key_checking = False # 检查对应服务器的host_key，建议取消注释
log_path=/var/log/ansible.log # 日志文件,建议取消注释
module_name = command # 默认模块
3.6 ansible系列命令
Ansible系列命令
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 查看指定模块帮助用法
3.7 ansible的基本语法
ansible通过ssh实现配置管理、应用部署、任务执行等功能，
建议配置ansible端能基于密钥认证的方式联系各被管理节点
ansible <host-pattern> [-m module_name] [-a args]
ansible +被管理的主机(ALL) +模块 +参数
--version 显示版本
-m module 指定模块，默认为command
-v 详细过程 –vv -vvv更详细
--list-hosts 显示主机列表，可简写 --list
-k, --ask-pass 提示输入ssh连接密码,默认Key验证
-C, --check 检查，并不执行
-T, --timeout=TIMEOUT 执行命令的超时时间,默认10s
-u, --user=REMOTE_USER 执行远程执行的用户
-b, --become 代替旧版的sudo切换
--become-user=USERNAME 指定sudo的runas用户,默认为root
-K, --ask-become-pass 提示输入sudo时的口令
ansible all --list 列出所有主机
ping模块: 探测网络中被管理主机是否能够正常使用 走ssh协议，如果对方主机网络正常,返回pong
ansible-doc -s ping 查看ping模块的语法
检测所有主机的网络状态
1> 默认情况下连接被管理的主机是ssh基于key验证,如果没有配置key,权限将会被拒绝
因此需要指定以谁的身份连接,输入用户密码,必须保证被管理主机用户密码一致
ansible all -m ping -k
2> 或者实现基于key验证 将公钥ssh-copy-id到被管理的主机上 , 实现免密登录
ansible all -m ping
3.8 ansible的Host-pattern
ansible的Host-pattern
匹配主机的列表
All ：表示所有Inventory中的所有主机
ansible all –m ping
* :通配符
ansible "*" -m ping (*表示所有主机)
ansible 192.168.1.* -m ping
ansible "*web" -m ping
或关系 ":"
ansible "webweb:appweb" -m ping
ansible “192.168.1.10:192.168.1.20” -m ping
逻辑与 ":&"
ansible "webweb:&dbweb" –m ping
在webweb组并且在dbweb组中的主机
逻辑非 ":!"
ansible 'webweb:!dbweb' –m ping
在webweb组，但不在dbweb组中的主机
注意：此处为单引号
综合逻辑
ansible 'webweb:dbweb:&appweb:!ftpweb' –m ping
正则表达式
ansible "webweb:&dbweb" –m ping
ansible "~(web|db).*\.hopu\.com" –m ping
3.9 ansible命令执行过程
ansible命令执行过程
1. 加载自己的配置文件 默认/etc/ansible/ansible.cfg
2. 加载自己对应的模块文件，如command
3. 通过ansible将模块或命令生成对应的临时py文件，并将该文件传输至远程服务器的对应执行用户$HOME/.ansible/tmp/ansible-tmp-数字/XXX.PY文件
4. 给文件+x执行(ansible web -vvv -m ping |grep chmod)
5. 执行并返回结果
6. 删除临时py文件，sleep 0退出(ansible web -vvv -m ping |grep rm)
执行状态：
绿色：执行成功并且不需要做改变的操作
黄色：执行成功并且对目标主机做变更
红色：执行失败
3.10 ansible使用示例
以wu用户执行ping存活检测
ansible all -m ping -u wu -k
以wu sudo至root执行ping存活检测
ansible all -m ping -u wu -k -b
以wu sudo至user1用户执行ping存活检测
ansible all -m ping -u wu -k -b --become-user=use1
以wu sudo至root用户执行ls
ansible all -m command -u wu -a 'ls /root' -b --become-user=root -k -K
ansible ping模块测试连接
ansible 192.168.38.126,192.168.38.127 -m ping -k
3.11 ansible常用模块
ansible的模块在2015年达到270多个，在2019年达到2080个模块，在2020年3月至今达到3387个模块
模块文档：https://docs.ansible.com/ansible/2.9/modules/list_of_all_modules.html
1）Command：在远程主机执行命令，默认模块，可忽略-m选项
常见参数：
chdir: 进入到被管理主机目录
creates: 如果有一个目录是存在的,步骤将不会运行Command命令
removes: 如果有一个目录是不存在的,步骤将不会运行Command命令
warn: 忽略告警
-----------------------------
示例：
[root@server ~]# ansible web -m command -a 'systemctl start httpd'
[root@server ~]# ansible web -m command -a 'echo 123456 |passwd --stdin wu'
[root@server ~]# ansible web -m command -a "hostname" #查看主机名
[root@server ~]# ansible web -m command -a "df -h" #查看磁盘空间信息
[root@server ~]# ansible web -m command -a "df -h | grep sda" 查看磁盘空间信息
[root@server ~]# ansible web -m command -a 'touch /opt/a.txt' 或者下面这一类写法
[root@server ~]# ansible web -m command -a 'chdir=/mnt touch a1.txt' 切换目录创建文件
[root@server ~]# ansible web -m command -a 'chdir=/data/ ls' 切换目录,查看内容
[root@server ~]# ansible web -m command -a 'creates=/mnt/a1.txt touch a2.txt' 如果a1存在则不创建a2，反之如果不存在则创建
[root@server ~]# ansible all -m command -a 'removes=/data cat /etc/fstab' 如果/data存在，则执行后面的命令
[root@server ~]# ansible web -m command -a 'creates=/mnt/a3.txt chdir=/mnt touch a3.txt'
如果a3文件不存在，则进入mnt创建一个a3文件
注意：此命令不支持 $VARNAME < > | ; & 等,用shell模块实现，比如下面写法：
给用户赋予密码
[root@server ~]# ansible 192.168.1.102 -a 'echo 123456|passwd --stdin u1'
[root@server ~]# ansible web -m command -a 'echo $HOSTNAME'
[root@server ~]# ansible web -m command -a 'echo 123 >/mnt/a1/txt'
[root@server ~]# ansible web -m command -a "ls /root/file*"
[root@server ~]# ansible web -m command -a 'df;date'‘
2）Shell：和command相似，用shell执行命令
常见参数：
chdir: 进入到被管理主机目录
creates: 如果有一个目录是存在的,步骤将不会运行Command命令
removes: 如果有一个目录是不存在的,步骤将不会运行Command命令
warn: 忽略告警
[root@server ~]# ansible web -m shell -a 'echo $HOSTNAME'
[root@server ~]# ansible web -m shell -a 'echo $HOSTNAME > /mnt/a1.txt'
[root@server ~]# ansible all -m shell -a 'getenforce' 查看SELINUX状态
[root@server ~]# ansible all -m shell -a "sed -i 's/SELINUX=.*/SELINUX=disabled/g' /etc/selinux/config"
[root@server ~]# ansible srv -m s hell -a 'echo hopu |passwd –stdin wuchaofeng'
调用bash执行命令 类似 cat /tmp/stanley.md | awk -F'|' '{print $1,$2}' &> /tmp/example.txt
这些复杂命令，即使使用shell也可能会失败，
解决办法：写到脚本时，copy到远程执行，再把需要的结果拉回执行命令的机器
修改配置文件,使shell作为默认模块
vim /etc/ansible/ansible.cfg
修改下面这一行：
module_name = shell
3）Script：在远程主机上运行ansible服务器上的脚本
-a "/PATH/TO/SCRIPT_FILE"
[root@server ~]# ansible webweb -m script -a /data/test.sh
4）Copy：从主控端复制文件到远程主机
常见参数：
src : 源文件 指定拷贝文件的本地路径 (如果有/ 则拷贝目录内容,比拷贝目录本身)
dest: 指定目标路径
owner: 指定文件所属用户
group: 指定文件所属组
mode: 设置权限
backup: 备份源文件
content: 代替src 指定本机文件内容
[root@server ~]#ansible web -m copy -a "src=/etc/hosts dest=/mnt/test.yml mode=1777" 复制本地文件到远程主机/mnt下 指定权限为1777
[root@server ~]# ansible web -m copy -a src=/etc/hosts dest=/mnt/test.yml mode=1777 owner=root backup=yes' #如若重复则备份
[root@server ~]# ansible web -m copy -a "content="123456" dest=/mnt/test.yml" #直接覆盖文件内容
5）Fetch：从远程主机提取文件至主控端，copy相反，目前不支持目录,可以先打包,再提取文件
[root@server ~]# ansible web -m fetch -a 'src=/root/test.sh dest=/data/scripts'
[root@server ~]# ansible web -m fetch -a 'src=/var/log/messages dest=/mnt'
会生成每个被管理主机不同编号的目录,不会发生文件名冲突
[root@server ~]# ansible all -m shell -a 'tar jxvf test.tar.gz /root/test.sh'
[root@server ~]# ansible all -m fetch -a 'src=/root/test.tar.gz dest=/data/'
6）File：设置文件属性
常见参数：
path: 要管理的文件路径 (强制添加)
recurse: 递归,文件夹要用递归
src: 创建硬链接,软链接时,指定源目标,配合'state=link' 'state=hard' 设置软链接,硬链接
state: 状态
absent：删除
directory：目录
file：文件
hard：硬链接
link：软连接
touch：创建
[root@server ~]# ansible webweb -m file -a 'dest=/mnt/filedir state=directory' 创建目录
[root@server ~]# ansible webweb -m file -a 'dest=/mnt/filedir/file.txt state=touch owner=root mode=755' 创建文件并指定权限
[root@server ~]# ansible webweb -m file -a 'path=/app/test.txt state=touch' 创建文件
[root@server ~]# ansible webweb -m file -a "path=/data/testdir state=directory" 创建目录
[root@server ~]# ansible webweb -m file -a "path=/root/test.sh owner=root mode=755" 设置权限755
[root@server ~]# ansible webweb -m file -a 'src=/data/testfile dest=/data/testfile-link state=link' 创建软链接
[root@server ~]# ansible webweb -m file -a 'dest=/mnt/filedir1 state=directory mode=777 owner=root recurse=yes' 递归式添加权限
[root@server ~]# ansible webweb -m file -a 'dest=/mnt/filedir/file.txt state=absent' 删除文件
7）unarchive：解包解压缩，有两种用法：
1、将ansible主机上的压缩包传到远程主机后解压缩至特定目录，设置copy=yes.
2、将远程主机上的某个压缩包解压缩到指定路径下，设置copy=no
常见参数：
copy：默认为yes，当copy=yes，拷贝的文件是从ansible主机复制到远程主机上，
如果设置为copy=no，会在远程主机上寻找src源文件
src： 源路径，可以是ansible主机上的路径，也可以是远程主机上的路径，
如果是远程主机上的路径，则需要设置copy=no
dest：远程主机上的目标路径
mode：设置解压缩后的文件权限
示例：
[root@server ~]# ansible web -m unarchive -a 'src=/root/nginx-1.18.0.tar.gz dest=/data'
#默认copy为yes ,将本机目录文件解压到目标主机对应目录下
[root@server ~]# ansible web -m unarchive -a 'src=/data/nginx-1.18.0.tar.gz dest=/data copy=no mode=0777'
# 解压被管理主机的nginx到data目录下, 并设置权限777
[root@server ~]# ansible web -m unarchive -a 'src=http://nginx.org/download/nginx-1.18.0.tar.gz dest=/opt owner=root mode=755 copy=no'
#下载互联网上的压缩包
8）Archive：打包压缩
将远程主机目录打包
常见参数：
path: 指定路径
dest: 指定目标文件
format: 指定打包格式
owner: 指定所属者
mode: 设置权限
示例：
[root@server ~]# ansible all -m archive -a 'path=/etc/sysconfig dest=/data/sysconfig.tar.gz format=gz owner=root mode=0777'
9）Hostname：管理主机名
ansible appweb -m hostname -a "name=node02.example.com" 更改一组的主机名
ansible 192.168.1.102 -m hostname -a "name=node02.example.com" 更改单个主机名
10)Cron：计划任务
支持时间：minute,hour,day,month,weekday
[root@server ~]# ansible web -m cron -a "minute=*/5 job='/usr/sbin/ntpdate 172.16.0.1 &>/dev/null' name=Synctime" #创建任务
[root@server ~]# ansible web -m cron -a "minute=*/5 job='/usr/sbin/ntpdate 172.16.0.1 &>/dev/null' name=Synctime disabled=yes" #注释任务,不在生效
[root@server ~]# ansible web -m cron -a "minute=*/5 job='/usr/sbin/ntpdate 172.16.0.1 &>/dev/null' name=Synctime disabled=no" #启动任务
[root@server ~]# ansible web -m cron -a 'state=absent name=Synctime' #删除任务
11)Yum：管理包
name ---指定要安装的软件包名，如果有多个用“,”进行分隔
state ---指定使用Yum的方法
installed，present --安装软件包
removed，absent ---移除软件包
latest ---安装最新的软件包
[root@server ~]# ansible web -m yum -a 'list=httpd' 查看程序列表
[root@server ~]# ansible web -m yum -a 'name=httpd state=present' 安装
[root@server ~]# ansible web -m yum -a 'name=httpd state=absent' 删除
可以同时安装多个程序包
[root@server ~]# ansible all -m yum -a 'name=httpd,vsftpd state=installed'
安装rpm包
[root@server ~]# ansible all -m yum -a 'name=/data/lrzsz-0.12.20-36.el7.x86_64.rpm state=installed'
12）管理服务
Service：CentOS6
[root@server ~]# ansible web -m service -a 'name=httpd state=stopped' 停止服务
[root@server ~]# ansible web -m service -a 'name=httpd state=started enabled=yes' 启动服务,并设为开机自启
[root@server ~]# ansible web -m service -a 'name=httpd state=reloaded' 重新加载
[root@server ~]# ansible web -m service -a 'name=httpd state=restarted' 重启服务
systemd: CentOS7
[root@server ~]# ansible web -m systemd -a 'name=nginx state=stopped' 停止服务
[root@server ~]# ansible web -m systemd -a 'name=nginx state=started enabled=yes' 启动服务,并设为开机自启
[root@server ~]# ansible web -m systemd -a 'name=nginx state=reloaded' 重新加载
[root@server ~]# ansible web -m systemd -a 'name=nginx state=restarted' 重启服务
13）User：管理用户
name: 用户名
uid： 用户ID
home : 指定家目录路径
system: 指定系统账号
group: 指定组
remove: 清除账户，家目录信息删除
shell: 指定shell类型
[root@server ~]# ansible web -m user -a 'name=user1 comment="test user" uid=2048 home=/app/user1 group=root'
[root@server ~]# ansible web -m user -a 'name=sysuser1 system=yes home=/app/sysuser1'
[root@server ~]# ansible web -m user -a 'name=user1 state=absent remove=yes' 清空用户所有数据
[root@server ~]# ansible web -m user -a 'name=app uid=88 system=yes home=/app groups=root shell=/sbin/nologin password="$1$zfVojmPy$ZILcvxnXljvTI2PhP2Iqv1"' 创建用户
[root@server ~]# ansible web -m user -a 'name=app state=absent' 不会删除家目录
安装mkpasswd
mkpasswd 生成口令
openssl passwd -1 生成加密口令
14）Group：管理组
[root@server ~]# ansible web -m group -a "name=testgroup system=yes" 创建组
[root@server ~]# ansible web -m group -a "name=testgroup state=absent" 删除组
15）lineInfile
ansible在使用sed进行替换时，经过会遇到需要转义的问题，而且ansible在遇到特殊符号进行替换时，存在问题，无法正常替换，但是ansible自身提供了2个模块：lineinfile和replace可以进行替换
一般在进行单行修改的时候，使用lineinfile
regexp参数：使用正则表达式匹配对应的行，当替换文本时，如果有多行文本都能被匹配，则只有最后面被匹配到的那行文本才会被替换，当删除文本时，如果有多行文本被匹配到了，则匹配到的行都会被删除
[root@server ~]# ansible web -m shell -a "sed -i 's/^Listen 80/Listen 8080/' /etc/httpd/conf/httpd.conf"
[root@server ~]# ansible web -m lineinfile -a "path=/etc/httpd/conf/httpd.conf regexp='^Listen' line='Listen 80'"
#修改http的端口
[root@server ~]# ansible web -m lineinfile -a "path=/etc/selinux/config regexp='^SELINUX=' line='SELINUX=disabled'"
#关闭selinux
[root@server ~]# ansible web -m lineinfile -a "path=/etc/fstab state=absent regexp='^#'"
16）replace
和lineinfile的功能类似，可以实现多行替换，建议使用
[root@server ~]# ansible web -m replace -a "path=/etc/fstab regexp='^(UUID)' replace='#\1'" 添加注释
[root@server ~]# ansible web -m replace -a "path=/etc/fstab regexp='^#(UUID)' replace='\1'" 取消注释
17)setup
用于收集主机的系统信息,但是如果机器数量过多会影响性能，所有可以使用 ：gather_facts: no将其关闭，提高速度
[root@server ~]# ansible web -m setup
[root@server ~]# ansible web -m setup -a 'filter=ansible_interfaces'
[root@server ~]# ansible web -m setup -a 'filter=ansible_selinux'
192.168.1.102 | SUCCESS => {
"ansible_facts": {
"ansible_selinux": {
"status": "disabled"
},
"discovered_interpreter_python": "/usr/bin/python"
},
"changed": false
}
3.12 ansible系列命令
ansible-galaxy
> 连接 https://galaxy.ansible.com
下载相应的roles(角色)
> 列出所有已安装的galaxy
ansible-galaxy list
> 安装galaxy
ansible-galaxy install robertdebock.nginx
> 删除galaxy
ansible-galaxy remove robertdebock.nginx
ansible-pull
推送命令至远程，效率无限提升，对运维要求较高
ansible-playbook 可以引用按照标准的yml语言写的脚本
执行playbook
示例：ansible-playbook hello.yml
cat hello.yml
---
#hello world yml file
- hosts: web
remote_user: root
gather_facts: no
tasks:
- name: hello world
command: /usr/bin/wall hello world
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：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 appweb
root@appweb (2)[f:5]$ list
root@appweb (2)[f:5]$ yum name=httpd state=present
root@appweb (2)[f:5]$ service name=httpd state=started
4、playbook
> playbook是由一个或多个"play"组成的列表
> play的主要功能在于将预定义的一组主机，装扮成事先通过ansible中的task定义好的角色。
Task实际是调用ansible的一个module，将多个play组织在一个playbook中，
即可以让它们联合起来，按事先编排的机制执行预定义的动作
> Playbook采用YAML语言编写
4.1 playbook图解介绍
用户通过ansible命令直接调用yml语言写好的playbook,playbook由多条play组成
每条play都有一个任务(task)相对应的操作,然后调用模块modules，应用在主机清单上,通过ssh远程连接从而控制远程主机或者网络设备
playbook是有一个或者多个play组成的
主要的功能在于将预定义的一组主机，通过playbook实现定义好的角色的功能，按照预先定义好的规则来实现预定义的动作
4.2 YAML介绍
YAML是一个可读性高的用来表达资料序列的格式。
YAML参考了其他多种语言，包括：XML、C语言、Python、Perl以及电子邮件格式RFC2822等。
Clark Evans在2001年在首次发表了这种语言，另外Ingy döt Net与Oren Ben-Kiki也是这语言的共同设计者，目前很多的流行的软件均采用这种语言用于保存配置信息，比如：docker,k8s,ubuntu,ansible,saltstack等
YAML Ain't Markup Language，即YAML不是XML。不过，在开发的这种语言时，YAML的意思其实是："Yet Another Markup Language"（仍是一种标记语言）
特性
YAML的可读性好
YAML和脚本语言的交互性好
YAML使用实现语言的数据类型
YAML有一个一致的信息模型
YAML易于实现
YAML可以基于流来处理
YAML表达能力强，扩展性好
更多的内容及规范参见：http://www.yaml.org
4.3 YAML语法简介
> 在单一档案中，可用连续三个连字号(——)区分多个档案。另外，还有选择性的连续三个点号( ... )用来表示档案结尾
> 次行开始正常写Playbook的内容，一般建议写明该Playbook的功能
> 使用#号注释代码
> 缩进必须是统一的，不能空格和tab混用
> 缩进的级别也必须是一致的，同样的缩进代表同样的级别，程序判别配置的级别是通过缩进结合换行来实现的
> YAML文件内容是区别大小写的，k/v的值均需大小写敏感
> 多个k/v可同行写也可换行写，同行使用:分隔
> v可是个字符串，也可是另一个列表[]
> 一个完整的代码块功能需最少元素需包括 name 和 task
> 一个name只能包括一个task
> YAML文件扩展名通常为yml或yaml
4.4 YAML语法特点
4.4.1 YAML的数据结构
1)List：列表，其所有元素均使用“-”打头
列表代表同一类型的元素
示例：
# A list of tasty fruits
kind:
- Apple
- Orange
- Strawberry
- Mango
另一种写法
kind：[Apple,Orange,Strawberry,Mango]
2)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} 有空格
4.5 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
ender: Male
- name: Jenny Smith
age: 13
gender: Female
4.6 三种常见的数据交换格式
http://www.json2yaml.com/ #json转yaml格式网站
4.7 Playbook核心元素
Hosts 执行的远程主机列表(应用在哪些主机上)
Tasks 任务集
Variables 内置变量或自定义变量在playbook中调用
Templates模板 可替换模板文件中的变量并实现一些简单逻辑的文件
Handlers和notify结合使用，由特定条件触发的操作，满足条件方才执行，否则不执行
tags标签 指定某条任务执行，用于选择运行playbook中的部分代码。ansible具有幂等性，因此会自动跳过没有变化的部分，即便如此，有些代码为测试其确实没有发生变化的时间依然会非常地长。此时，如果确信其没有变化，就可以通过tags跳过此些代码片断
示例：
ansible-playbook -t tagsname useradd.yml
4.8 playbook基础组件
1)Hosts：
> playbook中的每一个play的目的都是为了让特定主机以某个指定的用户身份执行任务。hosts用于指定要执行指定任务的主机，须事先定义在主机清单中
> 可以是如下形式：
one.example.com
one.example.com:two.example.com
192.168.1.50
192.168.1.*
> Webweb:dbweb 或者，两个组的并集
> Webweb:&dbweb 与，两个组的交集
> webservers:!phoenix 在webweb组，但不在dbweb组
示例:
- hosts: web:db
2)remote_user:
可用于Host和task中。也可以通过指定其通过sudo的方式在远程主机上执行任务，其可用于play全局或某任务；此外，甚至可以在sudo时使用sudo_user指定sudo时切换的用户
- hosts: webweb
remote_user: root (可省略,默认为root) 以root身份连接
tasks: 指定任务
- name: test connection
ping:
remote_user: hopu
sudo: yes 默认sudo为root
sudo_user: wcfeng sudo为wcfeng
task列表和action
任务列表task:由多个动作,多个任务组合起来的,每个任务都调用的模块,一个模块一个模块执行
1> play的主体部分是task list，task list中的各任务按次序逐个在hosts中指定的所有主机上执行，
即在所有主机上完成第一个任务后，再开始第二个任务
2> task的目的是使用指定的参数执行模块，而在模块参数中可以使用变量。
模块执行是幂等的，这意味着多次执行是安全的，因为其结果均一致
3> 每个task都应该有其name，用于playbook的执行结果输出，建议其内容能清晰地描述任务执行步骤。
如果未提供name，则action的结果将用于输出
tasks：任务列表
两种格式：
(1) action: module arguments
(2) module: arguments 建议使用 模块: 参数
注意：shell和command模块后面跟命令，而非key=value
示例：
---
- hosts: web
remote_user: root
tasks:
- name:install httpd
yum:name=httpd
- name: start httpd
service:name=httpd state=started enabled=yes
4.9 运行playbook
运行playbook的方式
ansible-playbook <filename.yml> ... [options]
常见选项
--check -C 只检测可能会发生的改变，但不真正执行操作
(只检查语法,如果执行过程中出现问题,-C无法检测出来)
(执行playbook生成的文件不存在,后面的程序如果依赖这些文件,也会导致检测失败)
--list-hosts 列出运行任务的主机
--list-tags 列出tag (列出标签)
--list-tasks 列出task (列出任务)
--limit 主机列表 只针对主机列表中的主机执行
-v -vv -vvv 显示过程
示例
ansible-playbook hello.yml --check 只检测
ansible-playbook hello.yml --list-hosts 显示运行任务的主机
ansible-playbook hello.yml --limit web 限制主机
4.9.1 Playbook VS ShellScripts
SHELL脚本安装httpd
#!/bin/bash
# 安装Apache
yum install --quiet -y httpd
# 复制配置文件
cp /tmp/httpd.conf /etc/httpd/conf/httpd.conf
cp /tmp/vhosts.conf /etc/httpd/conf.d/
# 启动Apache，并设置开机启动
systemctl enable --now httpd
Playbook定义安装httpd
---
- hosts: all
remote_user: root
tasks:
- name: "安装Apache"
yum: name=httpd #yum模块:安装httpd
- name: "复制配置文件"
copy: src=/tmp/httpd.conf dest=/etc/httpd/conf/ #copy模块: 拷贝文件
- name: "复制配置文件"
copy: src=/tmp/vhosts.conf dest=/etc/httpd/conf.d/
- name: "启动Apache，并设置开机启动"
service: name=httpd state=started enabled=yes #service模块: 启动服务
4.9.2 Playbook示例 创建用户
示例：sysuser.yml
---
- hosts: all
remote_user: root
tasks:
- name: create mysql user
user: name=mysql system=yes uid=3600
- name: create a group
group: name=httpd system=yes
4.9.3 Playbook示例 安装httpd服务
示例：httpd.yml
- hosts: web
remote_user: root
gather_facts: no
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
4.9.4 Playbook示例 安装nginx服务
示例 nginx.yml
- hosts: web
remote_user: root
gather_facts: no
tasks:
- name: install epel-release
yum: name=epel-release state=present
- name: add group nginx
group: name=nginx system=yes gid=3306
- name: add user nginx
user: name=nginx system=yes uid=3306 create_home=no home=/opt/mysql shell=/sbin/nologin
- name: Install Nginx
yum: name=nginx state=present
- name: Start Nginx
service: name=nginx state=started enabled=yes
卸载nginx服务
---
- hosts: web
remote_user: root
gather_facts: no
tasks:
- name: remove nginx service
yum: name=nginx state=absent
- name: remove nginx user
user: name=nginx state=absent
- name: remove nginx web file
file: name=/usr/share/nginx/html state=absent
- name: remove nginx configure file
file: name=/etc/nginx/ state=absent
4.9.5 Playbook示例 安装mysql服务
#准备my.cnf文件
[root@server files]#cat /playbook/files/my.cnf
[mysqld]
socket=/tmp/mysql.sock
user=mysql
symbolic-links=0
datadir=/data/mysql
innodb_file_per_table=1
pid-file=/data/mysql/mysqld.pid
[client]
port=3306
socket=/tmp/mysql.sock
[mysqld_safe]
log-error=/var/log/mysqld.log
----------------------------------------------------------------------------------------
#编写yml配置文件
[root@server files]# vim install_mysql.yml
---
- hosts: all
remote_user: root
gather_facts: no
tasks:
- name: install packages
yum: name=libaio,perl-Data-Dumper,perl-Getopt-Long
- name: create mysql group
group: name=mysql gid=3306
- name: create mysql user
user: name=mysql uid=3306 group=mysql shell=/sbin/nologin system=yes create_home=yes home=/data/mysql
- name: copy tar to remote host and file mode
unarchive: src=/root/playbook/files/mysql-5.7.37-linux-glibc2.12-x86_64.tar.gz dest=/usr/local/ owner=root group=root
- name: create linkfile /usr/local/mysql
file: src=/usr/local/mysql-5.7.37-linux-glibc2.12-x86_64 dest=/usr/local/mysql state=link
- name: data dir
shell: chdir=/usr/local/mysql/bin ./mysqld --initialize-insecure --datadir=/data/mysql --user=mysql --port=3306
tags: data
- name: config my.cnf
copy: src=/root/playbook/files/my.cnf dest=/etc/my.cnf
- name: service script
shell: /bin/cp /usr/local/mysql/support-files/mysql.server /etc/init.d/mysqld
- name: enable service
shell: /etc/init.d/mysqld start;chkconfig --add mysqld;chkconfig mysqld on
tags: service
- name: PATH variable
copy: content='PATH=/usr/local/mysql/bin:$PATH' dest=/etc/profile.d/mysql.sh
小练习：
1、请编写playbook文件，删除httpd服务
4.10 playbook中的 handlers和notify结合使用触发条件
Handlers 实际上就是一个触发器,是task列表，这些task与前述的task并没有本质上的不同,用于当关注的资源发生变化时，才会采取一定的操作,Notify此action可用于在每个play的最后被触发，这样可避免多次有改变发生时每次都执行指定的操作，仅在所有的变化发生完成后一次性地执行指定操作。在notify中列出的操作称为handler，也即notify中调用handler中定义的操作
4.11 Playbook中handlers使用
4.11.1 handlers+notify示例: http
---
- hosts: all
remote_user: root
gather_facts: no
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
4.11.2 handlers+notify示例：nginx
---
- hosts: web
remote_user: root
gather_facts: no
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
4.11.3 handlers+notify示例：heartbeat
cat heartbeat.yaml
---
- hosts: web
remote_user: root
tasks:
- name: ensure heartbeat latest version
yum: name=heartbeat state=present
- name: authkeys configure file
copy: src=/root/hb_conf/authkeys dest=/etc/ha.d/authkeys
- name: authkeys mode 600
file: path=/etc/ha.d/authkeys mode=600
notify:
- restart heartbeat
- name: ha.cf configure file
copy: src=/root/hb_conf/ha.cf dest=/etc/ha.d/ha.cf
notify:
- restart heartbeat
handlers:
- name: restart heartbeat
service: name=heartbeat state=restarted
4.12 Playbook中tags使用
tage: 添加标签
可以指定某一个任务添加一个标签,添加标签以后,想执行某个动作可以做出挑选来执行
多个动作可以使用同一个标签
示例：httpd.yml
---
- hosts: web
remote_user: root
tasks:
- name: Install httpd
yum: name=httpd state=present
tage: install
- 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
[root@server playbook]# ansible-playbook httpd.yml --list-tags #查看标签列表
[root@server playbook]# ansible-playbook –t install,conf httpd.yml 指定执行install,conf 两个标签
4.12.1 Playbook中tags使用示例:安装配置http
- hosts: testsrv
remote_user: root
tags: inshttpd 针对整个playbook添加tage
tasks:
- name: Install httpd
yum: name=httpd state=present
- name: Install configure file
copy: src=files/httpd.conf dest=/etc/httpd/conf/
tags: rshttpd
notify: restart httpd
handlers:
- name: restart httpd
service: name=httpd status=restarted
执行：
[root@server playbook]# ansible-playbook –t rshttpd httpd2.yml
4.13 Playbook中变量的使用
变量名：仅能由字母、数字和下划线组成，且只能以字母开头
变量定义：
variable=value
示例：
http_port=80
变量调用方式：
通过{{ variable_name }} 调用变量，且变量名前后必须有空格，有时用“{{ variable_name }}”才生效
变量来源：
1> ansible setup facts 远程主机的所有变量都可直接调用 (系统自带变量)
setup模块可以实现系统中很多系统信息的显示,可以返回每个主机的系统信息包括:版本、主机名、cpu、内存
ansible all -m setup -a 'filter="ansible_nodename"' 查询主机名
ansible all -m setup -a 'filter="ansible_memtotal_mb"' 查询主机内存大小
ansible all -m setup -a 'filter="ansible_distribution_major_version"' 查询系统版本
ansible all -m setup -a 'filter="ansible_processor_vcpus"' 查询主机cpu个数
2> 在/etc/ansible/hosts(主机清单)中定义变量
普通变量：主机组中主机单独定义，优先级高于公共变量(单个主机 )
公共(组)变量：针对主机组中所有主机定义统一变量(一组主机的同一类别)
3> 通过命令行指定变量，优先级最高
ansible-playbook –e varname=value
4> 在playbook中定义
vars:
- var1: value1
- var2: value2
5> 在独立的变量YAML文件中定义
6> 在role中定义
4.13.1 主机清单中定义变量示例
在主机清单中定义变量,在ansible中使用变量
例子1：
vim /etc/ansible/hosts:
[web]
192.168.1.102 http_port=817 name=www
192.168.1.103 http_port=827 name=web
调用变量
[root@server playbook]# ansible web -m hostname -a'name={{name}}' 更改主机名为各自被定义的变量
针对一组设置变量
[web:vars]
make="-"
[root@server playbook]# ansible web -m hostname -a 'name={{name}}{{mark}}{{http_port}}' ansible调用变量
--------
例子2：
[web]
192.168.1.102 name=node01
192.168.1.103 name=node02
[web:vars]
domain=hopu.org
2、执行
[root@server playbooks]# ansible web -m hostname -a "name={{name}}.{{domain}}"
4.13.2 示例：使用setup变量
setup的变量需要在playbook中定义，直接使用命令调用不支持
错误的语法：
[root@server playbooks]# ansible web -m file -a "path=/var/log/{{ansible_fqdn}}.log state=touch"
192.168.1.101 | FAILED! => {
"msg": "The task includes an option with an undefined variable. The error was: 'ansible_fqdn' is undefined"
}
192.168.1.102 | FAILED! => {
"msg": "The task includes an option with an undefined variable. The error was: 'ansible_fqdn' is undefined"
}
[root@server playbooks]#
正确的语法：
---
示例：var.yml
- hosts: webweb
remote_user: root
tasks:
- name: create log file
file: name=/var/log/{{ ansible_fqdn }} state=touch
##执行调用
[root@server playbook]# ansible-playbook var.yml
4.13.3 示例：在命令行中定义变量
示例：var2.yml
---
- hosts: web
remote_user: root
tasks:
- name: install package
yum: name={{ pkname }} state=present
[root@server playbook]# ansible-playbook –e pkname=httpd var2.yml
#也可以将变量写入一个配置文件
[root@server playbook]# cat var3
pkname: memcached
[root@server playbook]# ansible-playbook -e @var3 var2.yml #执行调用
4.13.4 示例：在playbook中定义变量
示例：var3.yml
---
- hosts: all
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
[root@server playbook]# ansible-playbook var3.yml
#如果配置文件中和命令中的变量名一致，命令行的优先级高于配置文件中的优先级，所有这里执行会创建user2和group2.
[root@server playbook]# ansible-playbook -e "username=user2 groupname=group2” var3.yml
4.13.5 示例：使用变量文件
cat vars.yml
var1: httpd
var2: nginx
-----------------------------------------
cat var.yml
- hosts: web
remote_user: root
vars_files:
- vars.yml
tasks:
- name: create httpd log
file: name=/app/{{ var1 }}.log state=touch
- name: create nginx log
file: name=/app/{{ var2 }}.log state=touch
4.14 清单文件中其他参数
invertory参数：用于定义ansible远程连接目标主机时使用的参数，而非传递给playbook的变量
ansible_ssh_host
ansible_ssh_port
ansible_ssh_user
ansible_ssh_pass
ansbile_sudo_pass
示例：
cat /etc/ansible/hosts
[web]
192.168.1.102 ansible_ssh_user=root ansible_ssh_pass=hopu ansible_ssh_port=220
192.168.1.103 ansible_ssh_user=root ansible_ssh_pass=hop uansible_ssh_port=220
5、模板templates
文本文件，嵌套有脚本（使用模板编程语言编写） 借助模板生成真正的文件
5.1 jinja2语言
官方网站：
https://jinja.palletsprojects.com/en/3.1.x/
http://doc.yonyoucloud.com/doc/jinja2-docs-cn/index.html
使用字面量，有下面形式
字符串：使用单引号或双引号
数字：整数，浮点数
列表：[item1, item2, ...]
元组：(item1, item2, ...)
字典：{key1:value1, key2:value2, ...}
布尔型：true/false
算术运算：+, -, *, /, //, %, **
比较操作：==, !=, >, >=, <, <=
逻辑运算：and，or，not
流表达式：For，If，When
5.2 jinja2相关
5.2.1 字面量
1.表达式最简单的形式就是字面量。字面量表示诸如字符串和数值的 Python对象。如“Hello World”双引号或单引号中间的一切都是字符串。
2.无论何时你需要在模板中使用一个字符串（比如函数调用、过滤器或只是包含或继承一个模板的参数），如4242.23
3.数值可以为整数和浮点数。如果有小数点，则为浮点数，否则为整数。在Python 里， 42 和 42.0 是不一样的
5.2.2 算术运算
jinja2 允许你用计算值。这在模板中很少用到，但为了完整性允许其存在，支持下面的运算符
1. +：把两个对象加到一起。通常对象是数字，但是如果两者是字符串或列表，你可以用这 种方式来衔接它们。无论如何这不是首选的连接字符串的方式！连接字符串见 ~ 运算符。 {{ 1 + 1 }} 等于 2
2. -：用第一个数减去第二个数。 {{ 3 - 2 }} 等于 1
3. /：对两个数做除法。返回值会是一个浮点数。 {{ 1 / 2 }} 等于 {{ 0.5 }}
4. //：对两个数做除法，返回整数商。 {{ 20 // 7 }} 等于 2
5. %：计算整数除法的余数。 {{ 11 % 7 }} 等于 4
6. *：用右边的数乘左边的操作数。 {{ 2 * 2 }} 会返回 4 ，也可以用于重 复一个字符串多次。{{ ‘=’ * 80 }} 会打印 80 个等号的横条
7. **：取左操作数的右操作数次幂。 {{ 2**3 }} 会返回 8
5.2.3 Jinja2比较操作符
== 比较两个对象是否相等
!= 比较两个对象是否不等
> 如果左边大于右边，返回 true
>= 如果左边大于等于右边，返回 true
< 如果左边小于右边，返回 true
<= 如果左边小于等于右边，返回 true
逻辑运算符
对于 if 语句，在 for 过滤或 if 表达式中，它可以用于联合多个表达式
and
如果左操作数和右操作数同为真，返回 true
or
如果左操作数和右操作数有一个为真，返回 true
not
对一个表达式取反（见下）
(expr)
表达式组
5.3 template 的使用
template功能：根据模块文件动态生成对应的配置文件
1. template文件必须存放于templates目录下，且命名为 .j2 结尾
2. yaml/yml 文件需和templates目录平级，目录结构如下：
./
├── temnginx.yml
└── templates
└── nginx.conf.j2
算法运算：
示例：
vim nginx.conf.j2
worker_processes {{ ansible_processor_vcpus**2 }};
worker_processes {{ ansible_processor_vcpus+2 }};
5.3.1 示例：利用template 同步nginx配置文件
1、准备templates/nginx.conf.j2文件
示例：
vim nginx.conf.j2
worker_processes {{ ansible_processor_vcpus**2 }}; 写法1
worker_processes {{ ansible_processor_vcpus+2 }}; 写法2
.....
2、准备temnginx.yml文件
vim temnginx.yml
---
- hosts: web
remote_user: root
tasks:
- name: install epel
yum: name=epel-release state=present
- name: install nginx
yum: name=nginx state=present
- name: template config to remote hosts
template: src=nginx.conf.j2 dest=/etc/nginx/nginx.conf
- name: start nginx
service: name=nginx state=started enabled=yes
2、执行
[root@ansible ansible]#ansible-playbook temnginx.yml
示例2：配合handlers使用templates
1、修改文件nginx.conf.j2 下面行为
worker_processes {{ ansible_processor_vcpus**2 }};
2、修改yml文件 temnginx2.yml
---
- hosts: web
remote_user: root
tasks:
- name: install epel
yum: name=epel-release state=present
- name: install nginx
yum: name=nginx state=present
- name: template config to remote hosts
template: src=nginx.conf.j2 dest=/etc/nginx/nginx.conf
notify: restart nginx
- name: start nginx
service: name=nginx state=started enabled=yes
handlers:
- name: restart nginx
service: name=nginx state=restarted
3、执行
[root@ansible ansible]#ansible-playbook temnginx2.yml
5.4 template中使用for和if流程控制语句
在template中可以使用if或者for流程控制语句来判断生成模板文件
5.4.1示例1:列表：template中使用for循环生成nginx的配置
1、编辑yml文件
vim temnginx2.yml
---
- hosts: web
remote_user: root
vars:
nginx_vhosts:
- 8080
- 8081
- 8082
tasks:
- name: template config
template: src=nginx2.conf.j2 dest=/mnt/nginx.conf
2、编写模板（注意是在template中）
vim template/nginx2.conf.j2
{% for vhost in nginx_vhosts %}
server {
listen {{ vhost }};
}
{% endfor %}
3、执行
[root@server templates]# ansible-playbook temnginx2.yml
4、被控端查看结果：
[root@aliyun mnt]# cat nginx.conf
server {
listen 8080;
}
server {
listen 8081;
}
server {
listen 8082;
}
5.4.2示例2:单字典：template中使用for循环生成nginx的配置
1、编辑yml文件
vim temnginx3.yml
---
- hosts: web
remote_user: root
vars:
nginx_vhosts:
- listen: 8080
tasks:
- name: template config
template: src=nginx3.conf.j2 dest=/mnt/nginx.conf
2、 vim nginx3.conf.j2
{% for vhost in nginx_vhosts %}
server {
listen {{ vhost.listen }};
}
{% endfor %}
3、执行
[root@server playbooks]# ansible-playbook temnginx3.yml
4、查看结果
[root@aliyun mnt]# cat nginx.conf
server {
listen 8080;
}
5.4.3 示例3：多字典：template中使用for循环生成nginx的配置
1、编辑vim temnginx4.yml
---
- hosts: web
remote_user: root
vars:
nginx_vhosts:
- listen: 8080
server_name: "node01.aliyun.com"
root: "/var/www/nginx/node01"
- listen: 8081
server_name: "node02.aliyun.com"
root: "/var/www/nginx/node02"
tasks:
- name: template config
template: src=nginx4.conf.j2 dest=/mnt/nginx.conf
2、编辑模板：
vim nginx4.conf.j2
{% for vhost in nginx_vhosts %}
server {
listen {{ vhost.listen }};
server_name {{ vhost.server_name}};
root {{ vhost.root }};
}
{% endfor %}
3、执行
[root@server playbooks]# ansible-playbook temnginx4.yml
4、查看结果
[root@aliyun mnt]# cat nginx.conf
server {
listen 8080;
server_name node01.aliyun.com;
root /var/www/nginx/node01;
}
server {
listen 8081;
server_name node02.aliyun.com;
root /var/www/nginx/node02;
}
5.4.4 示例：在template中加入if判断
1、编辑yml配置文件
vim temnginx5.yml
---
- hosts: web
remote_user: root
vars:
nginx_vhosts:
- web01: #可以省略
listen: 8080
server_name: "node01.aliyun.com"
root: "/var/www/nginx/node01"
- web02: #可以省略
listen: 8081
server_name: "node02.aliyun.com"
root: "/var/www/nginx/node02"
- web03: #可以省略
listen: 8082
root: "/var/www/nginx/node03"
tasks:
- name: template config
template: src=nginx5.conf.j2 dest=/mnt/nginx.conf
2、编辑模板文件
vim nginx5.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 %}
3、执行
[root@server templates]# ansible-playbook temnginx5.yml
4、查看结果
[root@node01 mnt]# cat nginx.conf
server {
listen 8080;
server_name node01.aliyun.com;
root /var/www/nginx/node01;
}
server {
listen 8081;
server_name node02.aliyun.com;
root /var/www/nginx/node02;
}
server {
listen 8082;
root /var/www/nginx/node03;
}
5.5 playbook中when 实现条件判断
条件测试:如果需要根据变量、facts或此前任务的执行结果来做为某task执行与否的前提时要用到条件测试,
通过when语句实现，在task中使用，jinja2的语法格式
when语句
在task后添加when子句即可使用条件测试；when语句支持Jinja2表达式语法
5.5.1 示例1:判断系统类型进行操作
---
- hosts: web
remote_user: root
tasks:
- name: "shutdown RedHat flavored systems"
command: /sbin/shutdown -h now
when: ansible_os_family == "RedHat" 当系统属于红帽系列,执行command模块
5.5.2 示例2：when条件判断，根据操作系统类型安装不同的数据库
---
- hosts: web
remote_user: root
tasks:
- name: install mysql
yum: name=mysql-server state=present
when: ansible_distribution_major_version == "6"
- name: install mariadb
yum: name=mariadb-server state=present
when: ansible_distribution_major_version == "7"
5.5.3 示例3：根据不同的软件版本复制不同的文件
---
- hosts: web
remote_user: root
tasks:
- name: install conf file to centos7
template: srcenginx.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"
5.6 playbook中的迭代：with_items（循环）
迭代：当有需要重复性执行的任务时，可以使用迭代机制
> 对迭代项的引用，固定变量名为"item"
> 要在task中使用with_items给定要迭代的元素列表
> 列表格式：
字符串
字典
5.6.1 示例1： 创建用户(字符串)
---
- hosts: web
remote_user: root
tasks:
- name: add several users
user: name={{ item }} state=present groups=wheel #{{ item }} 系统自定义变量
with_items: # 定义{{ item }} 的值和个数
- user1
- user2
上面语句的功能等同于下面的语句：
- name: add user testuser1
user: name=user1 state=present groups=wheel
- name: add user testuser2
user: name=user2 state=present groups=wheel
5.6.2 示例2：删除mysql
---
- hosts: web
remote_user: root
tasks:
- name: stop service
shell: /etc/init.d/mysqld stop
- name: delete files and dir
file: path={{item}} state=absent
with_items:
- /etc/init.d/mysqld
- /etc/my.cnf
- /data/mysql
- /etc/profile.d/mysql.sh
- name: delete user
user: name=mysql state=absent remove=yes
ansible-playbook remove_mysql.yml
5.6.3 示例3：将多个文件进行copy到被控端
---
- hosts: all
remote_user: root
tasks:
- name: Create rsyncd config
copy: src={{ item }} dest=/data/{{ item }}
with_items:
- file1
- file2
5.6.4 示例4：将多个文件进行copy到被控端,并安装多个软件
---
- hosts: all
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
5.6.5 示例5：一次安装多个软件
- hosts：web
remote_user: root
tasks
- name: install some packages
yum: name={{ item }} state=present
with_items:
- nginx
- memcached
- php-fpm
5.6.6 示例6：迭代嵌套子变量，创建用户和组
迭代中还可以嵌套子变量，多个子变量一起使用
---
- hosts: all
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文件创建5个用户，要求指定用户的UID并设置用户的家目录为/opt/user$,同时设置登录的shell为非登录shell
---
- hosts: web
remote_user: root
tasks:
- name: create group
group: name={{item}} state=present
with_items:
- user1
- user2
- user3
- user4
- user5
- name: create user
user: name={{ item.name }} group={{ item.group }} uid={{ item.uid }} home={{ item.home }} shell={{ item.shell }} state=present
with_items:
- { name: 'user1', group: 'user1', uid: 1100, home: '/opt/user1', shell: '/sbin/nologin'}
- { name: 'user2', group: 'user2', uid: 1101, home: '/opt/user2', shell: '/sbin/nologin'}
- { name: 'user3', group: 'user3', uid: 1102, home: '/opt/user3', shell: '/sbin/nologin'}
- { name: 'user4', group: 'user4', uid: 1103, home: '/opt/user4', shell: '/sbin/nologin'}
- { name: 'user5', group: 'user5', uid: 1104, home: '/opt/user5', shell: '/sbin/nologin'}
6、Roles：角色
ansible自1.2版本引入的新特性，用于层次性、结构化地组织playbook。roles能够根据层次型结构自动装载变量文件、tasks以及handlers等。要使用roles只需要在playbook中使用include指令即可。
简单来讲，roles就是通过分别将变量、文件、任务、模板及处理器放置于单独的目录中，并可以便捷地include它们的一种机制。角色一般用于基于主机构建服务的场景中，但也可以是用于构建守护进程等场景中
复杂场景：建议使用roles，代码复用度高
6.1 角色(roles)：角色集合
可以将多个角色放置在roles中的不同的独立子目录下
示例：
roles/
mysql/
httpd/
nginx/
memcached/
redis/
可以互相调用
6.2 Ansible Roles目录编排
6.3 roles目录结构
每个角色，以特定的层级目录结构进行组织
roles目录结构：
playbook.yml 调用角色
roles/
project/ (角色名称)
tasks/
files/
vars/
templates/
handlers/
default/ 不常用
meta/ 不常用
6.4 Roles各目录作用
/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文件，优先级比vars低一些
6.5 Role角色调用
调用角色方法1：
- hosts: web
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' }
6.6 创建role的步骤
(1) 创建以roles命名的目录
(2) 在roles目录中分别创建以各角色名称命名的目录，如webservers等
(3) 在每个角色命名的目录中分别创建files、handlers、meta、tasks、templates和vars目录；用不到的目录可以创建为空目录，也可以不创建
(4) 在playbook文件中，调用各角色
针对大型项目使用Roles进行编排示例：
示例：
nginx-role.yml
roles/
└── nginx
├── files
│ └── main.yml
├── tasks
│ ├── groupadd.yml
│ ├── install.yml
│ ├── main.yml
│ ├── restart.yml
│ └── useradd.yml
└── vars
└── main.yml
6.7 通过roles传递变量
通过roles传递变量
当给一个主机应用角色的时候可以传递变量，然后在角色内使用这些变量
示例：
- hosts: webservers
roles:
- common
- { role: foo_app_instance, dir: '/web/htdocs/a.com', port: 8080 }
6.8 向roles传递参数
而在playbook中，可以这样使用roles：
---
- hosts: webservers
roles:
- common
- webservers
也可以向roles传递参数
示例：
---
- hosts: webservers
roles:
- common
- { role: foo_app_instance, dir: '/opt/a', port: 5000 }
- { role: foo_app_instance, dir: '/opt/b', port: 5001 }
6.9 when条件式地使用roles
甚至也可以条件式地使用roles
示例：
---
- hosts: webservers
roles:
- { role: some_role, when: "ansible_os_family == 'RedHat'" }
6.10 Roles when条件判断
When条件
roles:
- {role: nginx, when: "ansible_distribution_major_version == '7' " ,username: nginx }
变量调用
- hosts: zabbix-proxy
sudo: yes
roles:
- { role: geerlingguy.php-mysql }
- { role: dj-wasabi.zabbix-proxy, zabbix_server_host: 192.168.1.100 }
6.11 roles playbook tags使用
1、vim nginx-role.yml
---
- hosts: testweb
remote_user: root
roles:
- { role: nginx ,tags: [ 'nginx', 'web' ] ,when: ansible_distribution_major_version == "7" }
- { role: httpd ,tags: [ 'httpd', 'web' ] }
- { role: mysql ,tags: [ 'mysql', 'db' ] }
- { role: marridb ,tags: [ 'mariadb', 'db' ] }
2、ansible-playbook --tags="nginx,httpd,mysql" nginx-role.yml 对标签进行挑选执行
6.12 实战案例：
6.12.1 示例1：创建http角色
1> 创建roles目录
cd /app/ansible/roles
mkdir roles/httpd/{handlers,files,tasks}
查看目录结构
tree roles/
└── roles
└── httpd
├── files
├── handlers
└── tasks
2> 创建目标文件
cd roles/httpd/tasks/
touch install.yml config.yml service.yml index.yml
3> 将网页的yml文件写进tasks/mian.yml文件中
vim main.yml
- include: install.yml
- include: config.yml
- include: index.yml
- include: service.yml
4> vim install.yml
- name: install httpd package
yum: name=httpd
vim config.yml
- name: config file
copy: src=httpd.conf dest=/etc/httpd/conf/ backup=yes
notify: restart service httpd
vim service.yml
- name: start service
service: name=httpd state=started enabled=yes
创建网页的yml文件
vim tasks/index.yml
- name: index.html
copy: src=index.html dest=/var/www/html
5> 准备httpd.conf文件,放到httpd单独的文件目录下
cp /app/ansible/flies/httpd.conf ../files/
6> 创建一个网页
vim flies/index.html
<h1> welcome to hopu <\h1>
7> 在handlers目录下创建handler文件mian.yml
vim handlers/main.yml
- name: restart service httpd
service: name=httpd state=restarted
8> 创建文件调用httpd角色
cd /app/ansible/roles #调用目录和角色目录要一致
vim role_httpd.yml
---
- hosts: all
remote_user: root
roles:
- role: httpd
9> 查看目录结构
tree
.
httpd
├── files
│ ├── httpd.conf
│ └── index.html
├── handlers
│ └── main.yml
└── tasks
├── config.yml
├── index.yml
├── install.yml
├── main.yml
└── service.yml
10> 执行
ansible-playbook role_httpd.yml
6.12.2 示例2：创建nginx角色
建立nginx角色在多台主机上来部署nginx需要安装 创建账号
1> 创建nginx角色目录
cd /app/ansible/role
mkdir nginx
cd nginx
mkdir -pv tasks templates handlers
2> 创建任务目录
cd tasks/
touch insatll.yml config.yml service.yml index.yml
创建main.yml文件定义任务执行顺序
vim main.yml
- include: insatll.yml
- include: config.yml
- include: index.yml
- include: service.yml
3> 准备配置文件(centos7、8)
ll /app/ansible/role/nginx/templates/
nginx7.conf.j2
nginx6.conf.j2
4> 定义任务
vim tasks/install.yml ##准备安装文件
- name: install
yum: name=nginx
vim tasks/config.yml ##准备配置文件
- name: config file
template: src=nginx7.conf.j2 dest=/etc/nginx/nginx.conf
when: ansible_distribution_major_version=="7"
notify: restart
- name: config file
template: src=nginx8.conf.j2 dest=/etc/nginx/nginx.conf
when: ansible_distribution_major_version=="8"
notify: restart
vim tasks/index.yml ## 跨角色调用网页文件,实现文件复用
- name: index.html
copy: src=roles/httpd/files/index.html dest=/usr/share/nginx/html/
vim tasks/service.yml ##准备服务管理文件
- name: start service
service: name=nginx state=started enabled=yes
vim handlers/main.yml ##准备触发器文件
- name: restart
service: name=nginx state=restarted
vim roles/role_nginix.yml ##准备调用文件
---
#test rcle
- hosts: appweb
roles:
- role: nginx
5> 测试安装
ansible-playbook role_nginx.yml
6.12.3 示例3: 创建角色memcached
memcacched 当做缓存用,会在内存中开启一块空间充当缓存
cat /etc/sysconfig/memcached
PORT="11211"
USER="memcached"
MAXCONN="1024"
CACHESIZE="64" # 缓存空间默认64M
OPTIONS=""
1> 创建对用目录
cd /app/ansible
mkdir roles/memcached/{tasks,templates} -pv
2> 拷贝memcached配置文件模板
cp /etc/sysconfig/memcached templates/memcached.j2
vim templates/memcached.j2
CACHESIZE="{{ansible_memtotal_mb//4}}" #物理内存的1/4用做缓存
3> 创建对应yml文件,并做相应配置
cd tasks/
touch install.yml config.yml service.yml
创建main.yml文件定义任务执行顺序
vim main.yml
- include: install.yml
- include: config.yml
- include: service.yml
vim install.yml
- name: install
yum: name=memcached
vim config.yml
- name: config file
template: src=memcached.j2 dets=/etc/sysconfig/memcached
vim service.yml
- name: service
service: name=memcached state=started enabled=yes
4> 创建调用角色文件
cd /app/ansible/roles/
vim role_memcached.yml
---
- hosts: all
roles:
- role: memcached
5> 安装
ansible-playbook role_memcached.yml
memcached端口号11211
6.12.4 示例4: 通过角色创建mysql5.6
[root@ansible ~] cat /data/ansible/roles/mysql/files/my.cnf ##准备my.cnf文件
[mysqld]
socket=/tmp/mysql.sock
user=mysql
symbolic-links=0
datadir=/data/mysql
innodb_file_per_table=1
pid-file=/data/mysql/mysqld.pid
[client]
port=3306
socket=/tmp/mysql.sock
[mysqld_safe]
log-error=/var/log/mysqld.log
##安全初始化如下：
[root@ansible files]# cat secure_mysql.sh
#!/bin/bash
#数据库安全初始化
/usr/local/mysql/bin/mysql_secure_installation <<EOF
y
123456
123456
y
y
y
y
EOF
[root@ansible ~]#ls /data/ansible/roles/mysql/files/
my.cnf
mysql-5.6.49-linux-glibc2.12-x86_64.tar.gz
secure_mysql.sh
[root@ansible ~]#cat /data/ansible/roles/mysql/tasks/main.yml
- include: install.yml
- include: group.yml
- include: user.yml
- include: mkdir.yml
- include: unarchive.yml
- include: link.yml
- include: data.yml
- include: config.yml
- include: service.yml
- include: path.yml
- include: secure.yml
[root@ansible ~]#cat /data/ansible/roles/mysql/tasks/install.yml
- name: install packages
yum: name=libaio,perl-Data-Dumper,perl-Getopt-Long,make state=present
[root@ansible ~]#cat /data/ansible/roles/mysql/tasks/group.yml
- name: create mysql group
group: name=mysql gid=306
[root@ansible ~]#cat /data/ansible/roles/mysql/tasks/user.yml
- name: create mysql user
user: name=mysql uid=306 group=mysql shell=/sbin/nologin system=yes create_home=no
home=/data/mysql
[root@ansible tasks]# cat /data/ansible/roles/mysql/tasks/mkdir.yml
- name: mkdir data dir
file: dest=/data/mysql state=directory mode=755 owner=mysql group=mysql recurse=yes
[root@ansible ~]#cat /data/ansible/roles/mysql/tasks/unarchive.yml
- name: copy tar to remote host and file mode
unarchive: src=mysql-5.6.49-linux-glibc2.12-x86_64.tar.gz dest=/usr/local/ owner=root group=root
[root@ansible ~]#cat /data/ansible/roles/mysql/tasks/link.yml
- name: mkdir /usr/local/mysql
file: src=/usr/local/mysql-5.6.49-linux-glibc2.12-x86_64 dest=/usr/local/mysql state=link
[root@ansible ~]#cat /data/ansible/roles/mysql/tasks/data.yml
- name: data dir
shell: chdir=/usr/local/mysql/scripts ./mysql_install_db --datadir=/data/mysql
--basedir=/usr/local/mysql --user=mysql --port=3306
[root@ansible ~]#cat /data/ansible/roles/mysql/tasks/config.yml
- name: config my.cnf
copy: src=my.cnf dest=/etc/my.cnf
[root@ansible ~]#cat /data/ansible/roles/mysql/tasks/service.yml
- name: service script
shell: /bin/cp /usr/local/mysql/support-files/mysql.server /etc/init.d/mysqld;/etc/init.d/mysqld start;chkconfig --add mysqld; chkconfig mysqld on
[root@ansible ~]#cat /data/ansible/roles/mysql/tasks/path.yml
- name: PATH variable
copy: content='PATH=/usr/local/mysql/bin:$PATH' dest=/etc/profile.d/mysql.sh
[root@ansible~]#cat/data/ansible/roles/mysql/tasks/secure.yml
- name: secure script
script: secure_mysql.sh
[root@ansible files]#
[root@ansible ansible]# tree
.
├── mysql.role.yml
└── roles
└── mysql
├── files
│ ├── my.cnf
│ ├── mysql-5.6.49-linux-glibc2.12-x86_64.tar.gz
│ └── secure_mysql.sh
└── tasks
├── config.yml
├── data.yml
├── group.yml
├── install.yml
├── link.yml
├── main.yml
├── mkdir.yml
├── path.yml
├── secure.yml
├── service.yml
├── unarchive.yml
└── user.yml
4 directories, 16 files
[root@ansible ansible]#
[root@ansible ansible]# cat mysql.role.yml
- hosts: all
remote_user: root
roles:
- {role: mysql,tags: ["mysql","db"]}
##运行
[root@ansible ansible]# ansible-playbook mysql.role.yml
评论
匿名评论
隐私政策
你无需删除空行，直接评论以获取最佳展示效果