ansible看这一篇就够了！！！

自动化运维工具-ansible

1、ansible简介

ansible是什么

ansible是目前最受运维欢迎的自动化运维工具，基于Python开发，集合了众多运维工具（SaltStack puppet、chef、func、fabric）的优点，实现了批量系统配置、批量程序部署、批量运行命令等功能。
​
    ansible是基于 paramiko 开发的,并且基于模块化工作，本身没有批量部署的能力。真正具有批量部署的是ansible所运行的模块，ansible只是提供一种框架。ansible不需要在远程主机上安装client/agents，因为它们是基于ssh来和远程主机通讯的。ansible目前已经已经被红帽官方收购，是自动化运维工具中大家认可度最高的，并且上手容易，学习简单。是每位运维工程师必须掌握的技能之一。

ansible特点

1. 部署简单，只需在主控端部署Ansible环境，被控端无需做任何操作；
2. 默认使用SSH协议对设备进行管理；
3. 有大量常规运维操作模块，可实现日常绝大部分操作；
4. 配置简单、功能强大、扩展性强；
5. 支持API及自定义模块，可通过Python轻松扩展；
6. 通过Playbooks来定制强大的配置、状态管理；
7. 轻量级，无需在客户端安装agent，更新时，只需在操作机上进行一次更新即可；
8. 提供一个功能强大、操作性强的Web管理界面和REST API接口——AWX平台。

ansible结构图

Ansible：Ansible核心程序。
HostInventory：记录由Ansible管理的主机信息，包括端口、密码、ip等。
Playbooks：“剧本”YAML格式文件，多个任务定义在一个文件中，定义主机需要调用哪些模块来完成的功能。
CoreModules：核心模块，主要操作是通过调用核心模块来完成管理任务。
CustomModules`：自定义模块，完成核心模块无法完成的功能，支持多种语言。
ConnectionPlugins：连接插件，Ansible和Host通信使用

2、ansible任务执行

anslible任务执行模式

ansible系统控制主机对被管节点的操作方式可以分为两类，ad-hoc和playbook
​
ad-hoc模式（点对点模式）使用单个模块，支持批量执行单条命令，ad-hoc命令是一种可以快速输入的命令，而且不需要保存起来的命令。就相当于bash中的一句话shell
​
playbook模式（剧本模式）是ansible主要的管理方式，也是ansible功能强大的关键所在，playbook通过多个task集合完成一类功能，如web服务的安装部署，数据库服务器的批量备份等， 可以简单地把playbook理解为通过组合多条ad-hoc操作的配置文件，类似于shell脚本，可以进行多个步骤
​
role模式（角色模式）类似于多个脚本导入

ansible执行流程

　　

Ansible在运行时，首先读取ansible.cfg中的配置，根据规则获取Inventory中的管理主机列表，并行的在这些主机中执行配置的任务，最后等待执行返回的结果。

ansible命令执行过程

1、加载自己的配置文件，默认/etc/ansible/ansible.cfg
2、查找对应的主机配置文件，找到要执行的主机或者组
3、加载自己对应的模块文件，如command
4、通过ansible将模块或命令生成对应的临时py文件（python脚本），并将该文件传输至远程服务器
5、对应执行用户的家目录的.ansible/xxx/xxx./py文件
6、给文件+x执行权限
7、执行并返回结果
8、删除临时py文件，sleep 0推出

3、ansible配置详解

安装方式

ansible安装常用两种方式，yum安装和pip程序安装
​
yum安装：
yum install -y epel-release     epel-release是一个软件仓库的配置包
yum install -y ansible          安装完上面的包再安装ansible

程序结构

安装目录如下（yum安装）：
配置文件目录：     /etc/ansible/ 
主机清单文件：     /etc/hosts/
执行文件目录：     /usr/bin/ 　　
Lib库依赖目录：    /usr/lib/pythonX.X/site-packages/ansible/ 　　
Help文档目录：     /usr/share/doc/ansible-X.X.X/ 　　
Man文档目录：      /usr/share/man/man1/

配置文件查找顺序

ansible在查找配置文件的顺序和其他的服务器有很大的一点不同，ansible查找配置文件时从多个地方查找的，顺序如下：
1、检查环境变量ANSIBLE_CONFIG指向的路径文件（epxort ANSIBLE_CONFIG=/etc.ansible.cfg）
2、/root/.ansible.cfg，检查当前目录下的ansible.cfg配置文件
3、/etc/ansible.cfg检查etc目录的配置文件

配置文件

/etc/ansible/ansible.cfg        ansible的配置文件
常见的参数：
inventory = /etc/ansible/hosts  这个参数表示资源清单inventory文件的位置
library = /usr/share/ansible    指向存放ansible模块的目录，支持多个目录方式，只要用:隔开就可以
forks = 5                       并发连接数，默认为5
remote_pore = 22                指定连接被管节点的管理端口，默认22端口，建议修改，能够更安装
host_key_cheking = False        设置为False，第一次连接远程主机的时候，默认直接输入yes，不需要交互
timeout = 60                    设置ssh连接的超时时间，单位为秒
log_path = /var/log/ansible.log     指定一个存储ansible日志的文件（默认不记录日志）
​
vim /etc/ssh/sshd_config
------------------------
UseDNS no       将该配置设置为no，会使ssh连接速度加快，方便asnible连接
------------------------

主机清单

ansible需要连接管理的主机列表，定义方式：
​
vim /etc/ansible/hosts      在配置文件中添加连接的主机列表
1、直接指明主机地址或主机名：
green.example.com
blue.example.com
10.36.181.66
10.36.181.88
​
2、定义一个主机组[组名]把地址或主机名加进去
[mysql]
10.36.181.11 ansible_ssh_user=root ansible_ssh_pass="1"     给单个用户设置密码
10.36.181.22
10.36.181.33
10.36.181.[44:55]       10.36.181.44到10.36.181.55所有的机器
​
3、给组中的ip设置用户密码
[组名]
10.36.181.11
10.36.181.22
[组名:children]
ansible_ssh_root="root"
ansible_ssh_pass="1"
​
4、父组
[组名1]
10.36.181.11
10.36.181.22
[组名2]
10.36.181.33
10.36.181.44
[父组:children]
组名1
组名2
​
5、给组批量设置变量，用户密码
[父组:vars]
ansible_ssh_user=root
ansible_ssh_pass="1"
​
6、给需要被操作的ip添加密钥，将密码写入文件不安全
ssh-keygen      创建密钥
sshpass -p "1" ssh-copy-id root@需要被操控的ip        将密钥传送到被操控的ip，-p "1"并自动输入密码
​
写入到/etc/ansible/hosts的数据，使用--list-hosts查看需要连接管理的主机列表
ansible 父组/子组/all --list-hosts
​
all         指定文件中所有的ip
[]          设置子组
children    设置父组
​
如果是自己创建的文件，则使用
ansible -i ./文件名 子组/父组 --list-hosts         -i指定文件

4、ansible常用命令

ansible命令集

/usr/bin/ansible            ansible AD-Hoc临时命令执行工具，常用于临时命令的执行
/usr/bin/ansible-doc        ansible模块功能查看工具
/usr/bin/ansible-galaxy     下载/上传优秀的代码或roles模块的官网平台，基于网络的
/usr/bin/ansible-platbook   ansible定制自动化的任务集编排工具，使用脚本或剧本都使用该命令
/usr/bin/ansible-pull       ansible远程执行命令的工具，拉取配置而非推送配置
/usr/bin/ansible-vault      ansible文件加密工具
/usr/bin/ansible-console    ansible基于Linux console界面可与用户交互的命令执行工具，批量控制多台，使用方法
ansible-console -i 指定主机清单 all/组名/父组     进入交互模式，在里面输入命令，多台虚拟机将会一起执行

ansible-doc命令

ansible-doc命令常用于获取模块信息及其使用帮助，一般用法如下：
ansible-doc                 查看ansible-doc的全部参数
ansible-doc -l              获取全部模块的信息
ansible-doc -s ping         获取执行模块的使用帮助
​
以mysql相关为例：
ansible-doc | grep mysql        查看mysql中都有什么模块
ansible-doc -s mysql_user       调用mysql中的user模块，用户模块
​
vim加密,vim进去，输入内容，esc进入命令模式，输入X，将内容变成加密模式，访问该文件的时候，密码错误将会访问乱码，取消密码模式，输入正确密码后，再执行一遍X，两次回车，设置为空密码，则代表取消加密

ansible命令详解

命令具体格式如下：
ansible <host-pattern> [ -f forks ] [ -m module_name ] [ -a age ]
ansible -i主机清单中的主机组 -f 开启线程数   -m 模块    -a 模块需要的参数
​
可以通过ansible -h来查看帮助，常用的选项，解释其含义：
-a MODULE_ARGS      模块大的参数，如果执行默认COMMAND模块，既是命令参数，如date、pwd等
-k --ask-pass       ask for SSH password，登录密码，提示输入ssh密码而不是假设基于密钥的验证
--ask-su-pass       ask for su password，su切换密码
-K --ask-sudo-pass  ask for sudo password，提示密码使用sudo，sudo表示提权操作
--ask-vault-pass    ask for vault password，假设我们设定了加密的密码，则用该选项进行访问
-B SECONDS          后台下运行超时时间
-C                  模拟运行环境并进行预运行，可以进行查错测试
-c CONNECTION       连接类型使用
-f FORKS            并行任务数，默认为5
-i INVENTORY        指定主机清单的路径，默认为/etc/ansible/hosts
--list-hosts        查看有哪些主机
-m MODULE_NAME      执行模块的名字，默认使用command模块，所以如果是只执行单一命令可以不用-m参数
-o                  压缩输出，尝试将所有结果在一行输入，一般针对收集工具使用
-s                  使用sudo命令
-U SUDO_USER        指定sudo到哪个用户，默认为root用户
-T TIMEOUT          指定ssh默认超时时间，默认为10s，也可在配置文件中修改
-u REMOTE_USER      远程用户，默认为root用户
-v                  查看详细信息，同时支持-vvv，-vvvv可查看更详细信息

ansible配置公私钥

上面提到过ansible是基于ssh协议实现的，所以其配置公私钥的方式与ssh协议的方式相同，具体操作：
​
1、安装软件包
yum install -y openssh-clients
​
2、生成私钥
ssh-keygen
​
3、向主机分发私钥
ssh-copy-id root@10.36.181.111
ssh-copy-id root@10.36.181.122

5、ansible常用模块

主机连通性测试

vim /etc/ansible/hosts
======================
[a]
10.36.181.11
10.36.181.22
======================
输入：ansible a -m ping
输出：
10.36.181.11 | SUCCESS => {
    "changed": false, 
    "ping": "pong"
}
10.36.181.22 | SUCCESS => {
    "changed": false, 
    "ping": "pong"
}
这样就说明我们的主机是连通状态，接下来的操作才可以正常进行

command模块（不能执行多条命令）

这个模块可以直接在远程主机上执行命令，并将结果返回本主机
ansible a -m command -a 'ss -tnlp'
​
​
命令模块接受命令名称，后面是空格分割的列表参数，给定的命令将在所有选定的节点上执行，不会通过shell进行处理，该命令不执行|管道命令，该模块常用的几个命令：
chdir           在执行命令前，先切换到该目录
executtable     切换shell来执行命令，需要使用命令的绝对路径
free_form       要执行的Linux指令，一般使用ansible -a参数代替
creates 文件名         当文件不存在，则该命令执行，可用来做判断，这个也可用shell模块执行
removes 文件名         当文件存在，则该命令执行，这个也可用shell模块执行
​
执行效果：
ansible a -m command -a 'chdit=/data/ ls'       先切换到data目录再执行ls命令
ansible a -m command -a 'creates=/data/aa.jpg ls'   如果/data/aa.jpg存在，则不执行ls命令
ansible a -m command -a 'removes=/data/aa.jpg cat /data/a'
如果/data/aa.jpd存在，则执行“cat /data/a”命令

shell模块（可以执行多条命令）

shell模块可以在远程主机上调用shell解释器运行命令，支持shell的各种功能
ansible a -m shell -a 'cat /etc/passwd | grep "keer"'
连接远程主机，查看/etc/passwd中的文件，过滤出来带有keer的语句
只要是shell命令，都可以通过这个模块在远程主机上运行
用;隔开，可以同时使用多个命令，command不支持该操作，不能使用特殊符号，对比下来shell更加完善
如果执行已有的模块，会报很长一串信息，可以关闭
vim /etc/ansible/ansible.cfg
------------------
command warnings = False        将这一行的注释取消，将不会显示多余信息
------------------

copy模块

颜色：
红色：错误
黄色：文件传输成功，但是内容被修改了，根据哈希值来区别，checksum后面跟的就是哈希值
绿色：文件传输成功，内容和和上次传输保持一致
​
这个模块用于将文件复制到远程主机，同时支持给定内容生成文件和修改权限等，相关选项如下：
src         本地文件的路径，如果路径是一个目录，则会递归复制，指定本地路径
content     用于替换src，可以直接指定文件的值，src复制文件，content直接输入内容进去
dest        必选项，将源文件复制到远程主机的绝对路径，指定目标路径
backup      当文件内容发生改变后，在覆盖之前把源文件备份，备份文件包含时间信息
directory_mode      递归设置目录权限，默认为系统默认权限
force       当目标主机包含该文件，但内容不同时，设置yes，表示强制覆盖，设置为no，表示目标主机的目标位置不存在该文件才复制，默认为yes
others      所有的file模块中的选项可以在这里使用
​
ansible a -m copy -a 'src=root/hello dest=/data'
将本地root下hello文件或目录发送到目标主机/date下
​
ansible a -m copy -a 'content="woaixuexi" dest=/data/name directory_mode=666'
将woaixuexi覆盖到目标主机/data/name，并设置该/data/name权限为666并且递归下去
​
ansible a -m shell -a 'ls -l /data/'
使用shell命令ls -l查看目标主机下的data目录
​
ansible a -m copy -a 'content="woaixuexi" backup=yes dest=/data/name directory_mode=666'
打印woaixuexi到目标主机的/data/name目录下，权限设置为666，并且备份源文件修改名字为当前时间
​
ansible a -m shell -a 'ls -l /data/'
使用ls -l查看目标主机/data下的文件
​
ansible a -m shell -a 'cat /data/name'
使用cat查看目录主机/data/name中的内容

file模块

该模块主要用于设置文件的属性，如创建文件，创建链接文件，删除文件，以下是常见命令：
force   需要在两种情况下强制创建软连接，一种是源文件不存在，但之后会建立的情况下；另一种是目标软连接已存在，需要先取消之前的软链接，然后创建新的软链接，有两个选项：yes|no
group   定义文件/目录的属组，后面可以加上
mode    定义文件/目录的权限
owner   定义文件/目录的属主
path    定义文件/目录的路径
recurse 递归设置文件的属性，只对目录有效，后面跟上
src     被链接的源文件路径，只应用于state=link的情况
dest    被链接到的路径，只应用于stste=link的情况
state   状态，有以下选项：
        directory，如果目录不存在，就创建目录
        link；创建软链接
        hard；创建硬链接
        touch，如果文件不存在，则会创建一个新的文件，如果文件或目录已存在，则更行最后修改时间
        absent，删除目录、文件或取消链接文件
        
举例：
ansible -i a all -m file -a 'path=/data/app state=directory'
检查目标主机/data/下有没有app目录，如果没有则创建该目录
​
ansible -i a all -m file -a 'path=/data/bb.jpg src=/data/aa.jpg state=link'
给目标主机/data/aa,jpg文件创建一个软连接，如果创建失败，可以使用force强制创建
​
ansible -i a all -m shell -a 'ls -l' /data/'
查看目标主机data下的文件

fetch模块

该模块用于从远程某主机复制文件到本地
dest    指定的是本地存放文件的路径，将远程文件存放到本地哪个地方
src     指定的是要拉取远程远程文件的路径，和copy是相反的，必须是file，不能是目录
​
距离：
ansible -i a all -m fetch -a 'src=/root/a dest=/root/'
从远程主机root目录下，复制文件a到本机目录root下

cron模块

该模块适用于管理cron计划任务的，和crontab文件中的语法一致
day=        日应该运行的工作（1-31，/2）
hour=       小时（0-23，/2）
minute=     分钟（0-59，/2）
month=      月（1-12，/2）
weekday=    周（0-6 for Sunday-Saturday）
job=        指明运行的命令是什么
name=       定时任务描述
reboot=     任务在重启时运行，不建议使用，建议使用special_time
special_time    特殊的时间范围，参数：reboot（重启时），annually（每年），monthly（每月），weekly（每周），daily（每天），hourly（每小时）
state       指定状态，present表示添加定时任务，默认设置，absent表示删除定时任务
user        以哪个用户的身份执行
​
举例：
ansible -i a all -m cron -a 'name="ntp update every 5 min" minute=*/5 job="/sbin/ntpdate 172.17.0.1 &> /dev/null"'
将目标主机的时间，每五分钟和172.17.0.1的ip时间对准一次，结果丢掉，name是任务的名字
​
ansible -i a all -m shell 'crontab -l'
将目标主机的所有计划任务打印出来
​
ansible -i a all -m cron -a "minute=0 hour=3 weekday=2 month=4 day=18 name='打印' job='echo hello world'"
每年四月的18号或周二，执行一条echo hello world命令，该循环的备注为打印
​
ansible -i a all -m cron -a "name='打印' state=absent"
删除所有主机清单a文件中名为打印的循环任务

yum模块

该模块主要用于软件的安装
name=               所安装软件包的名称
state=              present安装、latest安装最新的、absent卸载软件
update_cache        强制更行yum的缓存
conf_file           指定远程yum安装时所依赖的配置文件
disable_gpg_check   是否禁止gpg checking，只用于present或larest
disablerepo         临时禁止使用yum库，只用于安装或更新时
enablerepo          临时使用yum库，只用于安装或更新时
​
举例：
ansible -i a all -m yum -a 'name=vim state=present'
进入目标主机安装vim

service模块

该模块用于服务程序的管理
arguments   命令提供额外的参数
enabled     设置开机启动
name=       服务名称
runlevel    开机启动的级别，一般不用指定
sleep       在重启服务的过程中，是否等待，如在服务器关闭以后等待2秒再启动（在剧本中定义）
state       有四种状态，started启动服务，stopped停止服务，restarted重启服务，reloaded重载配置
​
举例；
ansible -i a all -m service -a 'name=nginx state=startes enabled=ture'
进入目标主机，启动nginx，设置开机自启动
​
ansible -i a all -m shell 'ss -tnlp'
查看目标主机nginx是否已启动
​
ansible -i a all -m service -a 'name=nginx state=stopped'
进入目标主机，停止nginx
​
ansible -i a all -m shell 'ss -tnlp | grep 80'
进入目标主机，过滤80端口查看

user模块

该模块主要是用来管理用户账号
comment     用户的描述信息
createhome  是否创建家目录
force       在使用state=absent时，行为与userdel-force一致
group       指定基本组
groups      指定附加组，如果指定为groups=表示删除所有组
home        指定用户家目录
move_home   如果设置为home=时，试图将用户主目录移动到指定的目录
name        指定用户名
non_unique  该选项允许改变非唯一的用户id值
password    指定用户密码，对密码加密可以使用python的crypt和passlib
remove      在使用state-absent时，行为是与userdel=remove一致
shell       指定默认shell
state       设置账号状态，不指定为创建，指定值为absent表示删除
system      当创建一个用户，设置这个用户是系统用户，设个设置不能更改现有用户
uid         指定用户的uid
​
举例：
ansible -i a all -m user -a 'name=jiaming uid=1111'
进入目标主机，创建一个名为jiaming的用户，并指定uid为1111
​
ansible -i a all user -a 'name=jiaming state=absent'
进入目标主机，删除用户jiaming

group模块

该模块主要用于添加或删除组
gid=        设置组的gid号
name=       指定组的名称
state=      指定组的状态，默认为创建，设置值为absent为删除，system=设置值为yes，表示创建为系统组
​
举例：
ansible -i a all -m group -a 'name=xa gid=2222'
进入目标系统，创建一个名为xa的组，组的gid号为2222
​
ansible -a a all -m group -a 'name=xa state=absent'
进入目标系统，删除名为xa的组

script模块

该模块用于将本机的脚本在被管理端的机器上运行，该模块直接指定脚本的路径即可
​
举例：
vim /root/s.sh          创建脚本
=====================
#!/usr/bin/bash         解释器
date >> /root/b.log     在执行该脚本时，把当前的时间添加到b.txt文件中
df -lh >> /root/b.log   在执行该脚本时，把当前时间的内存容量添加到b.txt文件中
======================
ansible -i a all -m script -a '/root/s.sh'
进入目标主机，执行该脚本

setup模块

该模块主要用于收集信息，是通过调用facts组件来实现
facts是变量，内建变量，每个主机的各种信息，cpu个数，内存大小
​
举例：
查看信息：
ansible -i a all -m setup -a 'filter="*mem*"'   查看内存
ansible -i a all -m shell -a 'free -m'      查看内存大小是否一致
​
保存信息：
ansible -i a all -m setup -a 'filter="*mem*"' --tree /root/facts
进入目标主机，查看内存大小，并保存到/root/facts文件下

get_url模块

用于将文件或软件从http、https或ftp下载到本地节点上
dest            指定文件下载到哪里，绝对路径--必须
url             文件的下载地址（网址）--必须
url_username    用于http基本认证的用户名
url_password    用于http基本认证的密码
validate_certs  如果否，ssl证书将不会验证
owner           指定属主
group           指定属组
mode            指定权限
​
ansible -i a all -m get_url -a "url=ftp://10.36.181.250/root/a.txt dest=/tmp"
下载10.36.181.250/root/a.txt文件到本地/tmp下

stat模块

检查文件系统或文件系统的状态
对windows目标的话，改用win_stat模块
​
path:       文件/对象的完整路径（必须）
​
ansible -i a all -m stat -a "path=/etc/passwd"
常见的返回值判断：
exists： 判断是否存在，false表示不存在，ture表示存在，存在的话会显示文本中的内容
isuid：  调用用户的id与所有者id是否匹配

unarchive模块

从本地机器上复制存档后，将其解包
该模块将解压缩一个存档，默认情况下，它将在解包之前将源文件从本地系统复制到目标
对于windows目标，改用win_unzip模块
​
dest        远程绝对路径，档案应该被解压缩
exec        列出需要排除的目录和文件
src         指定源
creates     一个文件名，当文件已存在时，这个步骤将不会被运行
remote_src=yes  指定源文件是否位于目标主机上，如果源文件在控制节点上，直接使用该命令，就不需要往ansible主机导源文件导入了
​
举例：
ansible -i a all -m unarchive -a 'src=/root/a.zip dest=/tmp'
将本地的压缩包传送到目标主机，并进行解压

6、ansible playbook简介

playbook是ansible用于配置，部署和管理被控节点的剧本，通过playbook的详细描述，执行其中的一系列tasks，可以让远端主机达到预期的状态。playbook就像ansible控制器给被控节点列出的一系列to-da-list，而被控节点必须要完成，playbook字面意思即剧本，现实中有演员按照剧本进行表演，在ansible中，这次有计算器进行表演，由计算器安装，由计算器安装，部署应用，提供对外服务，以及组织计算器处理各种各样的事情

7、ansible playbook使用场景

执行一些简单的任务，使用ad-hoc命令可以方便解决问题，但是有时一个设置过于复杂，需要大量的操作时候，执行的ad-hoc命令是不合适的，这时最好使用playbook，就像执行shell命令与写shell脚本一样，也可以理解为批处理任务，playbook有自己的语法格式，使用playbook可以方便的重复这些代码，可以移植到不同的机器上面，像函数一样，最大的利用代码，在使用ansible的过程中，会发现所处理的大部分操作都是编写的playbook，可以把常见的应用都编写成playbook，之后管理服务器会变得十分简单

8、ansible playbook格式

格式简介

playbook由ymal语言编写，yaml参考了其他多种语言，包括：XML,C语言,Python,Prel以及电子邮件格式RFC2822，ymal格式类似于json文件格式
以下为playbook常用到的ymal格式：
1、文件的第一行应该以"---"三个连字符开始，表明了ymal文件的开始
2、在同一行中，#之后的内容表示注释，类似于shell、python
3、ymal中的列表元素以"-"开头然后紧跟着一个空格，后面为元素内容
4、同一列表中的元素应保持相同的缩进，否则会被当做错误处理
5、play中hosts、variables、roles、tasks等对象的表示方法都是键值中间以":"分隔表示，":"后面还要增加一个空格
​
举例：
===========================================
#安装与运行mysql服务
- hosts: node1
  remote_user: root
  tasks:
    - name: install mysql-server package
      yum: name=mysql-server state=present
    -name: starting mysqld service
      service: name=mysql state=started
===========================================
文件名称要以.yml结尾，否则会识别不出来
host部分：使用hosts指示使用哪个主机或主机组来运行下面的tasks，每个playbook都必须指定hosts，hosts也可以使用通配符格式，主机或主机组在inventory清单中指定，可以使用系统默认的/etc/ansible/hosts，也可以自己编辑，在运行的时候加上-i选项，指定清单的位置即可，在运行清单文件的时候，--list-hosts选项会显示那些主机将会参与执行task的过程中
​
remote_user部分：指定远端主机中的哪个用户来登录远端系统，在远端系统执行task的用户，可以任意指定，也可以使用sudo，但是用户必须要执行相应task的权限
​
tasks部分：指定远端主机将要执行的一系列动作。tasks的核心为ansible的模块，前面已经提到模块的用法，tasks包含name和要执行的模块，name是可选的，只是为了便于用户阅读，不过还是建议加上去，模块是必须的，同时也要基于模块相应的参数
​
使用ansible-playbook运行playbook文件，得到如下输出，输出内容为json格式，并且由不同颜色组成，便于识别，一般而言，绿色代表执行成功，系统保持原样。黄色代表系统发生改变。红色代表执行失败，显示错误输出。执行由三个步骤，1、收集facts。2、执行tasks。3、报告结果

核心元素

playbook的核心元素：
hosts:主机组
tasks:任务列表
variables:变量，设置的方式由四种
templates:包含了模糊语法的文本文件
handlers:由特定条件触发的任务

定义变量

常量：
a: b
​
列表：
a: 
 - 1
 - 2
 - 3
 - 4
 
字典：
dice:
 name: xiaoming
 age: 18
 
在ansible中定义变量，中间都需要有空格
​
在/etc/vimrc中，为vim添加参数
set ts=2            一个tab键等于两格
set nu              每次进入vim都会显示行号
set list            用于显示特殊字符，如tab键，换行键
set cursorline      增加对齐的横线
set cursorcolumn    增加对齐的竖线
set mouse=a         启用鼠标支持

基本组件

playbook配置文件基础组件：
hosts：运行指定任务的目标主机
remote_user：在远程主机上执行任务的用户
sudo_user：指定非root用户来执行特定任务或命令的机制
gather facts: false：用于playbook时是否收集目标主机的额外信息，false是关闭收集数据，使playbook运行更快
tasks：任务列表
​
​
举例：
vim ip.yml
=====================
---
- hosts: 192.168.253.111        运行任务的主机，可以写主机清单中的一个ip或一个组
  remote_user: root             哪个用户执行
  gather facts: false           关闭收集数据，当操作的机器多的时候会卡顿
  tasks:                        任务列表
    -name: 检查主机             执行任务的名字
    shell: ip a                 使用模块，:后面跟参数、
=====================
ansible-playbook -i a ip.yml        执行剧本的命令，-i使用主机清单，执行的主机在剧本中定义了
​
格式：
1、action:module arguments
2、module:arguments
shell和command模块在后面直接跟命令，而非key=value类的参数列表
​
1、某任务的状态在运行后为changed时，可以通过notify通知给相应的handlers
2、让你无可以通过tags打标签，而后可在ansible-playbook命令上使用-t指定调用
​
举例：
第一步、定义playbook：
cd /etc/ansible
vim nginx.yml
=========================================
---
- hosts: a
  remote_user: root
  tasks:
    - name: install nginx
      yum: name=nginx state=present
    - name: copy nginx.conf
      copy: src=/tmp/ngxinx.conf dest=/etc/nginx/nginx.conf backup=yes
      notify: reload            #当该任务执行成功并进行改变，则执行触发器，所有tasksk事件执行完才执行
      tags: reloadnginx     #标签
    - name: start nginx service
      service: name=nginx seate=started
      tags: starting        #标签
      
  handlers:         #触发条件
    - name: reload
      service: name=nginx state=restarted
=========================================
ansible-playbook -i a  -t reloadnginx nginx.yml     -t，只执行某一个任务，只执行剧本中copy nginx.conf部分
​
运行前三部曲
检查错误，语法的检查
ansible-playbook -i a all nginx.yml --syntax-check
​
列出所有任务
ansible-playbook -i a all nginx.yml --list-task
​
列出那些机器执行
ansible-playbook -i a all nginx.yml --list=hosts
​
运行
ansible-playbook -i a all nginx.yml
​
第二步、测试运行结果
ansible-playbook -i a all nginx.yml     运行后的结果如下图
ansible -i a all -m shell -a 'ss -tnlp | grep nginx'        检查nginx端口是否启动
​
第三步、测试标签
我们在里面已经打上了一个标签，可以直接引用标签，但是我们需要先把服务关闭，再来运行剧本并引用标签
ansible a -m shell -a 'systemctl stop nginx'
ansible-playbook nginx.yml -t starnginx
​
第四步、测试notify
触发条件是配置文件被改变，所以可以修改一下配置文件的端口看看效果
vim /tmp/nginx.conf
=====================
listen      8080;
=====================
ansible-playbook nginx.yml -t reloadnginx       重新加载剧本
ansible -i a all -m shell -a 'ss -tnlp | grep nginx'    检查nginx端口是否成功修改

varibles部分

facts：可直接调用

setup模块是通过调用facts组件来实现的，variables可以直接调用facts组件，然直接放入剧本中调用即可
ansible_all_ipv4_addresses          仅显示ipv4的信息
ansible_eth0['ipv4']['address']     仅显示ipv4的信息
ansible_devices                     仅显示磁盘设备信息
ansible_distribution                显示是什么系统，例如centos
ansible_distribution_version        仅显示系统版本
ansible_machine                     仅显示系统类型，例如32位，64位
ansible_eth0                        仅显示eth0信息
ansible_hostname                    仅显示主机名
ansible_kernel                      仅显示内核版本
ansible_lvm                         显示lvm相关信息
ansible_memtotal_mb                 显示系统总内存
ansible_memfree_mb                  显示可用系统内存
ansible_memory_mb                   详细显示内存信息
ansible_swaptotal_mb                显示总的swap内存
ansible_swapfree_mb                 显示swap内存的可用内存
ansible_mounts                      显示系统磁盘挂载情况
ansible_processor                   显示cpu个数，具体显示每个cpu型号
ansible_processor_vcpus             显示cpu个数，只显示总的个数
ansible_python_version              显示python版本
​
例如：
批量修改主机host文件
========================================================
---
- hosts: a                      指定playbook的目标主机组
  vars:                         定义变量，这里将当前主机eth0接口的ipv4地址定义为变量
    IP: "{{ ansible_eth0['ipv4']['address']}}"
  tasks:                        列出要在目标主机上执行的任务
  - name: 将原有的hosts文件备份
    shell: mv /etc/hosts /etc/hosts_bak     将/etc/hosts文件重命名为/etc/hosts_bak
  - name: 将ansible端的hosts复制到各自机器上
    copy: src=/root/hosts dest=/etc/ owner=root group=root mode=0644    将ansible控制端上的/root/hosts文件复制到目标主机/etc目录下，并设置这个文件的属主和属组为root，权限为0664
  - name: 在新的hosts文件后面追加各自机器内网ip和hostname
    lineinfile: dest=/etc/hosts line=" {{ IP }} {{ ansible_hostname}}   在目标主机/etc/hosts文件下的末尾追加一行，内容为当前主机内网ip地址（ip变量）和主机名（ansible_hostname事实）
========================================================

用户自定义变量

自定义变量有以下两种方式
​
通过命令行传入：-e
ansible-playbook a.yml -e b=vim         -e 定义变量
​
在playbook中定义变量：
vars：
  - var1: value1
  - var2: value2
 
举例：
在剧本中定义变量
vim a.yml
==================================
---
- hosts: a                  指定的目标主机
  remote_user: root         连接到目标主机使用root用户
  vars:                     定义变量
    - b: c                  b的变量值为c
  tasks:                    要在主机上执行的任务
  - name: install {{ b }}
    yum: name={{ b }} state=present     安装b，b为变量
==================================
​
在playbook中定义变量
修改上面剧本vars中- b后面的c，c为变量，自己在该地方手动修改
​
运行定义过变量的剧本
ansible-playbook a.yml

ansible剧本下载mysql

vim /root/mysql.sh
------------------
systemctl stop mysqld mariadb
yum erase -y mysql-community-server mariadb-server
rm -rf /etc/my.* /var/lib/mysql* /var/log/mysqld
userdel -r mysql
------------------
​
vim mysql.yml
-------------------
---
- hosts: a              执行该剧本的主机清单
  remote_user: root     执行的用户
  gather_facts: false   关闭收集数据，ansible -m setup可以看出来查询的是na
  vars:                 定义变量
    db_level: 57        设置变量
    db_password: Qianfeng@123       设置变量
  tasks:                执行任务清单
    - name: 清理环境        任务名字
      script:           执行脚本模块
        cmd: /root/mysql.sh     执行哪个脚本
      ignore_errors: yes    如果有错误跳过，该脚本中有一段systemctl stop mysqld mariadb，因为某些机器可能没安装mysql，所以停止的时候会导致报错，如果这一段有报错则跳过，继续执行下列
      
    - name: 安装mysql官方源
        shell: yum install -y https://dev.mysql.com/get/mysql80-community-release-el7-11.noarch.rpm         安装的mysql源
        ignore_errors: yes
        
      - name: 安装mysql{{ db_level }}
        yum:
          name: mysql-community-server      安装的软件
          state: present                安装
          disable_gpg_check: no         关闭检查
          disablerpo: "*"               禁用所有的yum源
          enablerepo: mysql{{ db_level }}-community     只使用这个源进行安装
          
        - name: 启动mysql
          service:
            name: mysql     启动的服务名称
            state: restarted        重新启动
            
        - name: 修改初始密码
          shell: passwd=$(grep -o 'root@localhost.*' /var/log/mysqld.log | awk 'END{print $NF}') ; mysqladmin -uroot -p$passwd password $password
-------------------
ansible-playbook -i a all mysql.yml
​
注：ignore_errors: yes        跳过错误，继续执行下列任务

ansible剧本部署word press

vim /root/hostfile          主机清单
------------------------
[web]
192.168.253.132 name=web    #添加别名，后续可以直接引用该别名
​
[database]
192.168.253.134 name=db
------------------------
​
vim wordpress.yml
-------------------------------
---
- hosts: all
  remote_user: root                     #执行的用户
  gather_facts: false           #关闭收集数据
  vars:                                         #添加变量
    db_password: "Qianfeng@123"
    db_name: "wordpress"
    db_user: "wq"
    db_pass: "Qianfeng@123"
    wordpress_path: /usr/share/nginx/
    nginx_root: "{{ wordpress_path }}wordpress"
    nginx_port: 80
    php_root: 127.0.0.1:9000
    wordpress: wordpress-6.5.3-zh_CN.tar.gz
​
  tasks:                                        #任务清单
    - name: 安装nginx和php的源
      yum:
        name: "{{ item }}"              #item和xargs -i的{}效果一样，将with_items的内容传入到这个地方
        state: present
      with_items:
        - http://rpms.remirepo.net/enterprise/remi-release-7.rpm
        - epel-release
      ignore_errors: yes                #遇到错误跳过，继续执行下列的任务
      when: "name == 'web'"             #哪个用户执行这个任务
​
    - name: 安装nginx和php的源
      yum:
        name: nginx,php80-php-xsl,php80-php,php80-php-cli,php80-php-devel,php80-php-gd,php80-php-pdo,php80-php-mysql,php80-php-fpm
        state: present
      when: "name == 'web'"
​
    - name: 安装mysql源
      shell: "yum -y install https://dev.mysql.com/get/mysql84-community-release-el7-1.noarch.rpm"
      when: "name == 'db'"
      ignore_errors: yes            #如果这一条任务报错的话，直接跳过执行下一个任务
      
    - name: 安装mysql
      yum:
        name: mysql-community-server
        state: present
        disable_gpg_check: yes          #下载mysql的时候禁止检查，如果是http协议的话会报错，关闭检查就不会报错
      when: "name == 'db'"
​
    - name: 启动mysql
      service:
        name: mysqld
        state: started
      when: "name == 'db'"
​
    - name: 修改初始密码并创建数据库和远程用户
      shell: passwd=$(grep -o 'root@localhost.*' /var/log/mysqld.log | awk 'END{print $NF}') ; mysqladmin -uroot -p$passwd password {{ db_password }} ; mysql -uroot -p{{ db_password }} -e "create database if not exists {{ db_name }} ; create user {{ db_user }} identified by '{{ db_pass }}'; grant all on *.* to '{{ db_user }}'@'%' ; flush privileges ;"
      when: "name == 'db'"
​
    - name: 拷贝nginx配置文件
      template:
        src: ./nginx.conf
        dest: /etc/nginx/nginx.conf
      when: "name == 'web'"
​
    - name: 上线代码
      unarchive:        #和docker中ADD模块一样，如果是压缩包，解压完再拷过去
        src: "{{ wordpress }}"
        dest: "{{ wordpress_path }}"
        owner: "apache"
        group: "apache"
      when: "name == 'web'"
​
    - name: 启动nginx和php
      service:
        name: "{{ item }}"      #和xargs -i的{}效果一样，将with_items的内容批量执行
        state: started
      with_items:
        - nginx
        - php80-php-fpm
      when: "name == 'web'"
-------------------------------
​
vim nginx.conf
-------------------------------
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;
include /usr/share/nginx/modules/*.conf;
​
events {
    worker_connections 1024;
}
​
http {
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
​
    access_log  /var/log/nginx/access.log  main;
​
    sendfile            on;
    tcp_nopush          on;
    tcp_nodelay         on;
    keepalive_timeout   65;
    types_hash_max_size 4096;
​
    include             /etc/nginx/mime.types;
    default_type        application/octet-stream;
​
    include /etc/nginx/conf.d/*.conf;
    server {
        listen      {{ nginx_port }};
        server_name _;
        location / {
                        root {{ nginx_root }};
                        index index.php;
                }
        location ~ \.php$ {
            root          {{ nginx_root }};  #指定网站目录
            fastcgi_pass   {{ php_root }};    #指定访问地址
            fastcgi_index  index.php;           #指定默认文件
            fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name; #站点根目录，取决于root配置项
            include        fastcgi_params;  #包含nginx常量定义
                        }
        }
}
-------------------------------
​
将wordpress的包下载到和wordpress.yml一个目录下,wordpress的官网cn.wordpress.org
wget https://cn.wordpress.org/wordpress-6.5.3-zh_CN.tar.gz
​
如果目标主机的源里面有mysql的源可能会报错，在安装mysql的主机上删除源再执行剧本
yum remove -y yum -y remove mysql84-community-release-el7-1.noarch
​
ansible-playbook -i ./hostfile wordpress.yml        执行剧本

通过roles传递变量

roles为角色，具体的在下文详解

host Inventory

直接在主机清单中定义，定义方法如下：
​
向不同的主机传递不同的变量：
IP/HOSTNAME varaiable=value var2=value2
​
向组中的主机传递相同的变量：
[groupname:vars]
variable=value
​
使用内置密码把用户名和密码写在inventory中，就是/etc/ansible/hosts文件中，缺点就是暴露了账号密码，不太安全，如果由多个主机需要使用同样的变量，也可以使用组变量的形式，举例：
[a]
10.36.181.111
10.36.181.222
[a:vars]
ansible_ssh_prot=22             连接的端口
ansible_ssh_user='root'         连接的用户
ansible_ssh_pass='Qiaifeng@123'     连接用户的密码

ansible inventory内置参数

参数	用途	例子
ansible_ssh_host	定义hosts ssh地址	ansible_ssh_host=10.36.181.111
ansible_ssh_port	定义hosts ssh端口	ansible_ssh_port=22
ansible_ssh_user	定义hosts ssh认证用户	ansible_ssh_user=jiaming
ansible_ssh_pass	定义hosts ssh认证密码	ansible_ssh_pass=Qianfeng@123
ansible_sudo	定义hosts sudo用户	ansible_sudo=www
ansible_sudo_pass	定义hosts sudo密码	ansible_sudo_pass=pass
ansible_sudo_exe	定义hosts sudo路径	ansible_sudo_exe=/root/a.txt
ansible_connection	定义hosts连接方式	ansible_connection=local
ansible_ssh_private_key_file	定义hosts私钥	ansible_ssh_private_key_file=/root/key
ansible_ssh_shell_type	定义hosts shell类型	ansible_ssh_shell_type=bash
ansible_python_interpreter	定义hosts任务执行python路径	ansible_python_interpreter=/usr/bin/python2.6
ansible_ * _interpreter	定义hosts其他语言解析路径	ansible_ * _interpreter=/usr/bin/shell

模板template、条件测试、字典

模板template

模板是一个文本文件，嵌套有脚本（使用模板编程语言编写）
jinja2是python的一种模板语言，以Django的模板语言为原本。
​
模板支持：
字符串：使用单引号或双引号
数字：整数浮点数
列表：[itme1,itme2,...]
元组：(itme1,item2,...)
字典：{key1:value1,key2:value2,...}
布尔型：ture/false
算术运算：
+,-,*,/,//,%,**
比较运算：
==,!=,>,>=,<,<=
逻辑运算：
and,or,not
通常来说，模板都是通过引用变量来运用的
​
举例：
定义模板：
vim b.txt
============================
我是{{ name }},我今年{{ age }}
{% if age < 18 %}
我是年轻人
{% else %}
我是成年人
{% endif %}
============================
​
创建剧本：
vim a.yml
============================
---
-  hosts: 192.168.253.131
   remote_user: root
   gather_facts: false
   vars:            #定义变量
     name: "佳明"
     age: 22
   tasks:
     - name: 拷贝
       copy:            #或template 关键点！！！！！！
         src: ./b.txt
         dest: /roo
============================
​
运行剧本：
ansible-playbook -i hostfile a.yml
​
当关键点的地方为copy的时候，执行剧本后，会将b.txt文件原封不动的复制过去
在192.168.253.131该虚拟上查看传送过去的文件
cat /root/b.txt
---------------------
我是{{ name }},我今年{{ age }}
{% if age < 18 %}
我是年轻人
{% else %}
我是成年人
{% endif %}
---------------------
​
当关键点的地方为template的时候，执行剧本后会将剧本中的变量赋值给b.txt文件，然后传送到192.168.253.131服务器
cat /root/b.txt
---------------------
我是佳明,我今年22
我是成年人
---------------------
​
不能直接在命令行中传数值类型的参数，命令行中的内容都将被认做字符串格式，数字也作为字符串类型，字符串类型

条件测试

when语句：在task中使用，jinja2语法格式，举例如下：
===================================================
tasks:
- name: install conf file to centos7
  template: src=files/nginx.conf.c7.j2
  when: {{ ansible_distribution_major_version }} == "7"
- name: install conf file to centos6
  template: src=files/nginx.cinf.c6.j2
  when: {{ ansible_distribution_major_version }} == "6"
===================================================
当{{ ansible_distribution_major_version }}的变量等于7时，则执行，当变量不等于7的时候，则不执行
需要关闭gather facts: false，这个代表不收集信息，上面的变量是内置变量，不收集信息的话，会搜索不到该变量，所以不用写这一条
​
循环：迭代，需要重复执行的任务
对迭代的引用，固定变量名为"item"，而后要在task中使用with_items给定要迭代的元素列表，举例如下：
=====================================
tasks:
- name: 创建文件
  file:
    state: touch
    path: "{{ item }}"
  with_items:
    - /root/a.txt
    - /root/b.txt
    - /root/c.txt
    - /root/d.txt
=====================================
当执行剧本后，会在目标服务器root下创建a、b、c、d.txt文件，如果不使用item，需要四个模块才能创建四个文件
​
循环举例2：
=====================================
tasks:
- name: 拷贝文件
  copy:
    src: "{{ item.key }}"
    dest: "{{ item.value }}"
  with_items:
    - { key: /root/a.txt, value: /opt/a.txt }
    - { key: /root/b.txt, value: /opt/b.txt }
=====================================
x拷贝多个文件，使用变量进行拷贝
​
跳过错误：
=====================================
tasks:
- name: unstall web packages
  yum: name=httpd state=absent
  igonre_errors: yes
=====================================

字典

ansible playbook支持字典功能，举例如下：
=====================================
- nameL install some packages
  yum: name={{ item }} state=present
  with_items:
    - nginx
    - memcached
    - php-fpm
- name: add some groups
  group: name={{ item }} state=present
  with_items:
    - group11
    - group12
    - group13
- name: add some users
  user: name={{ item.name }} group={{ item.group }} state=present
  with_itens:
    - { name: 'user11', group: 'group11' }
    - { name: 'user12', group: 'group12' }
    - { name: 'user13', group: 'group13' }
=====================================

角色订制

简介

对于以上所有的方式有个弊端，就是无法实现复用，假设在同时部署web、da、ha时或不同服务器组合，不同的应用就需要写多个yml文件，很难实现灵活的调用，roles用于层次性，结构化地组织playbook，roles能够根据层次型结构自动装载变量文件，tasks以及handlers等，要使用roles只需要在playbook中使用inculde指令即
简单来说，roles就是通过分别将变量（vars），文件（file），任务（tasks），模块（modules）及处理器（handlers）放置于单独的目录中，并可以便捷地include它们的一种机制，角色一般用于基于主机构建服务的场景中，但也可以是用于构建守护进程等场景中

角色集合

角色集合：roles/ mysql/ httpd/ nginx/ files/:存储由copy或script等模块调用的文件，tasks/:此目录至少应该由一个名为main.yml的文件，用于定义各task，其他的文件需要由main.yml进行"包含"调用，main.yml进行包含调用。vars/:此目录中至少应该由一个名为main.yml的文件，用于定义各variable。其他文件需要由main.yml进行包含调用。templates/:存储由template模块调用的模板文本。meta/:此目录中至少应该有一个名为main.yml的文件，定义当前角色的特殊设定及其依赖关系。其他的文件需要由main.yml进行包含调用。default/:此目录中至少应该由一个名为main.yml的文件，用于设定默认变量

角色定制实例

1、在roles目录下生成对应的目录结构
mkdir -pv ./{nginx,mysql,httpd}/{files,templates,vars,tasks,handlers,meta,default}      创建对应的目录结构
tree        树状显示当前目录下目录中的文件（tree命令需要安装，yum install -y tree）
​
2、定义配置文件，需要修改配置文件为/tasks/mainx.yml
vim /etc/ansible/roles/nginx/tasks/main.yml
===========================================
- name: cp rpm for nginx
  copy: src=nginx-1.10.2-1.1.e17.ngx.x86_64.rpm dest=/tmp/nginx-1.10.2-1.e17.ngx.x86_64.rpm
- name: install
  template: src=nginx.conf,j2 dest=/etc/nginx/nginx.conf
  tags: nginxconf
  notify: new conf to reload
- name: start service
  service: name=nginx state=started enabled=true
===========================================
​
3、放置我们所需要的文件到指定目录，因为我们定义的角色已经有了新的组成方式，所以我们需要把文件都放在指定的位置，这样才能让配置文件找到这些并进行加载。
cp /tmp/nginx-1.10.2-1.e17.ngx.x86_64.rpm ./files/
cp /tmp/nginx.conf/j2 ./templates/
tree
-----------------------------------------
.
├── default
├── files
│   └── nginx-1.10.2-1.el7.ngx.x86_64.rpm
├── handlers
├── meta
├── tasks
│   └── main.yml
├── templates
│   └── nginx.conf.j2
└── vars
​
7 directories, 3 files
-----------------------------------------
​
4、修改变量文件，我们在模板中定义的变量，也要去配置文件中加上
vim /etc/ansible/roles/nginx/vars/main.yml
nginxprot: 9999
​
5、定义handlers文件，我们在配置文件中定义了notify，所以也需要定义handlers
vim handlers/main.yml
======================
- name: new conf to reload
  service: name=nginx state=restarted
======================
​
6、定义剧本文件，接下来定义剧本文件，由于大部分设置我们都单独配置在了roles中，所以接下来剧本只需要写一点点内容
vim //etc/ansible/roles/nginx/handlers.yml
==========================
- hosts: a
  remote_user: root
  roles:
    - nginx
==========================
​
tree        查看完成后的目录
-----------------------------
./
├── httpd
│   ├── default
│   ├── files
│   ├── handlers
│   ├── meta
│   ├── tasks
│   ├── templates
│   └── vars
├── mysql
│   ├── default
│   ├── files
│   ├── handlers
│   ├── meta
│   ├── tasks
│   ├── templates
│   └── vars
├── nginx
│   ├── default
│   ├── files
│   │   └── nginx-1.10.2-1.el7.ngx.x86_64.rpm
│   ├── handlers
│   │   └── main.yml
│   ├── meta
│   ├── tasks
│   │   └── main.yml
│   ├── templates
│   │   └── nginx.conf.j2
│   └── vars
│       └── main.yml
└── roles.yml
-----------------------------
​
7、启动服务，剧本定义完成以后，就可以启动服务
ansible-playbook roles.yml              指定剧本
ansible -i a all shell -a "ss -tnlp | grep 9999"        如果可以看到9999端口则证明剧本执行成功

ansible制作主从

vim hostfile
-----------------------
[master]
192.168.253.132 server_id=1
​
[master:vars]
rloe=master
​
[slave]
192.168.253.134 server_id=2
​
[slave:vars]
role=slave
-----------------------
​
vim mysql-replication.yml
-----------------------
---
- hosts: all
  remote_user: root
  vars: 
    db_password: "Qianfeng@123"
    repl_user: "slave"
    repl_password: "Qianfeng@123"
    master_host: 192.168.253.132
  tasks:
    - name: 安装mysql源
      shell: "yum -y install https://dev.mysql.com/get/mysql84-community-release-el7-1.noarch.rpm"
      ignore_errors: yes            #如果这一条任务报错的话，直接跳过执行下一个任务
      
    - name: 安装mysql
      yum:
        name: mysql-community-server
        state: present
        disable_gpg_check: yes      #下载mysql的时候禁止检查，如果是http协议的话会报错，关闭检查就不会报错
    
    - name: 拷贝配置文件
      template:
        src: my.cnf
        dest: /etc/my.cnf
        backup: yes
​
    - name: 启动mysql
      service:
        name: mysqld
        state: started
​
    - name: 修改初始密码
      shell: passwd=$(grep -o 'root@localhost.*' /var/log/mysqld.log | awk 'END{print $NF}') ; mysqladmin -uroot -p$passwd password "{{ db_password }}"
      
    - name: 配置主库用户
      shell: mysql -uroot -p"{{ db_password }}" -e "create user if not exists '{{ repl_user }}'@'%' identified by '{{ repl_password }}' ; grant replication slave on *.* to '{{ repl_user }}'@'%' ; flush privileges"
      when: "role == 'master'"
      
    - name: 查看主库日志
      shell: mysql -N -uroot -p"{{ db_password }}" -e "show master status;" | awk '{print $1}'
      when: "role == 'master'"
      
    - name: 查看主库日志位置
      shell: mysql -N -uroot -p"{{ db_password }}" -e "show master status;" | awk '{print $2}'
      when: "role == 'master'"
      
    - name: 执行从库配置
      shell: mysql -uroot -p"{{ db_password }}" -e "CHANGE MASTER TO MASTER_HOST='{{ master_host }}',MASTER_USER='{{ repl_user }}',MASTER_PASSWORD='{{ repl_password }}',MASTE_LOG_FILE='mysql-bin.000002',MASTER_LOG_POS=1023; start slave; show slave status\G;"
      register: slave_status
      when: "role == 'slave'"
      
    - name: 输出结果
      debug:
        var: slave_status
-----------------------
​
vim my.cnf
-----------------------
[mysqld]
datadir=/var/lib/mysql
socket=/var/lib/mysql/mysql.sock
log-error=/var/log/mysqld.log
server-id={{ server_id }}
{% if role == "master" %}
log-bin=/var/lib/mysql/mysql-bin
{% endif %}
-----------------------
​
变量引用不成功，有时间再研究

角色制作word press

ansible-galaxy init jiaming     自动创建角色的目录，tree可以查看
tasks/：此目录中至少应该有一个名为main.yml的文件，用于定义各task；其它的文件需要由main.yml进行“包含”调用； 
handlers/：此目录中至少应该有一个名为main.yml的文件，用于定义各handler；其它的文件需要由main.yml进行“包含”调用； 
vars/：此目录中至少应该有一个名为main.yml的文件，用于定义各variable；其它的文件需要由main.yml进行“包含”调用； 
templates/：存储由template模块调用的模板文本； 
meta/：此目录中至少应该有一个名为main.yml的文件，定义当前角色的特殊设定及其依赖关系；其它的文件需要由main.yml进行“包含”调用； 
default/：此目录中至少应该有一个名为main.yml的文件，用于设定默认变量；
​
同步时间，如果是快照的机器，时间不同步，install会报错
​
创建角色：
ansible-galaxy init mysql
ansible-galaxy init php
ansible-galaxy init nginx
ansible-galaxy init wordpress
​
vim mysql/tasks/main.yml
---------------------------------------------------
---
# tasks file for mysql
  - name: install database
    yum: name=mariadb-server,mariadb state=present
​
  - name: start database
    service: name=mariadb state=started
​
  - name: status mysql
    wait_for:
      host: localhost
      port: 3306
      timeout: 10
​
  - name: create mysql databse
    shell: mysql -e "CREATE DATABASE if not exists {{ MYSQL_DB_NAME }};grant all privileges on {{ MYSQL_DB_NAME }}.* to '{{ MYSQL_USER }}'@'%' identified by '{{ MYSQL_PASSWORD }}';flush privileges;"
---------------------------------------------------
​
vim php/tasks/main.yml
---------------------------------------------------
---
# tasks file for php
  - name: install php packages
    shell: yum install -y http://rpms.remirepo.net/enterprise/remi-release-9.rpm
​
  - name: install php
    yum: name={{ package }} state=present
​
  - name: start php
    service: name=php80-php-fpm state=started
​
  - name: mode
    file: path=/var/opt/remi/php80/run/php-fpm/www.sock mode=0777
---------------------------------------------------
​
vim nginx/tasks/main.yml
---------------------------------------------------
---
# tasks file for nginx
  - name: install nginx package
    yum: name=epel-release state=present
​
  - name: install nginx
    yum: name=nginx state=present
​
  - name: configure nginx
    template: src=nginx.conf dest=/etc/nginx/nginx.conf
​
  - name: state nginx
    service: name=nginx state=started
---------------------------------------------------
​
vim nginx/vars/main.yml
---------------------------------------------------
---
# vars file for nginx
  nginx_port: 80
  nginx_root: /usr/share/nginx
---------------------------------------------------
​
vim nginx/templates/nginx.conf
---------------------------------------------------
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;
include /usr/share/nginx/modules/*.conf;
​
events {
    worker_connections 1024;
}
​
http {
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
​
    access_log  /var/log/nginx/access.log  main;
​
    sendfile            on;
    tcp_nopush          on;
    tcp_nodelay         on;
    keepalive_timeout   65;
    types_hash_max_size 4096;
​
    include             /etc/nginx/mime.types;
    default_type        application/octet-stream;
​
    include /etc/nginx/conf.d/*.conf;
    server {
        listen      {{ nginx_port }};
        root        {{ nginx_root }}/wordpress;
        server_name _;
        location / {
                        root {{ nginx_root }}/wordpress;
                        index index.php;
                }
        location ~ \.php$ {
            root          {{ nginx_root }}/wordpress;  #指定网站目录
            fastcgi_pass   unix:///var/opt/remi/php80/run/php-fpm/www.sock;    #指定访问地址
            fastcgi_index  index.php;           #指定默认文件
            fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name; #站点根目录，取决于root配置项
            include        fastcgi_params;  #包含nginx常量定义
                        }
        }
}
---------------------------------------------------
​
vim wordpress/tasks/main.yml
---------------------------------------------------
---
# tasks file for wordpress
  - name: Copy wordpress files to webserver
    unarchive: src=wordpress-6.5.3-zh_CN.tar.gz dest=/usr/share/nginx/ mode=777
---------------------------------------------------
将word press的压缩包放到word press角色中的files目录下
​
在所所有角色的同级目录中创建一个剧本
vim roles.yml
----------------------------------
---
- hosts: "{{ host }}"
  remote_user: root
  gather_facts: no
  roles:
    - "{{ role }}"
----------------------------------
​
vim aa
----------------------------------
[mysql]
192.168.253.140 name=db
​
[nginx]
192.168.253.142 name=web
----------------------------------
​
ansible-playbook -i aa -e host=mysql -e role=mysql roles.yml 
ansible-playbook -i aa -e host=nginx -e role=php roles.yml 
ansible-playbook -i aa -e host=nginx -e role=nginx roles.yml 
ansible-playbook -i aa -e host=nginx -e role=wordpress roles.yml
​
浏览器中访问nginx服务器即可，用户密码都在配置文件中

1