Ansible 的脚本 --- playbook 剧本

目录

[playbooks 本身由以下各部分组成](#playbooks 本身由以下各部分组成)

---

playbooks 本身由以下各部分组成

playbooks：集合多个模块形成一个脚本去操作
（1）Tasks ：任务，即通过 task 调用 ansible 的模板将多个操作组织在一个 playbook 中运行
（2）Variables： 变量
（3）Templates ：模板
（4）Handlers ：处理器，当changed状态条件满足时，（notify）触发执行的操作
（5）Roles ：角色

playbook 编写 apache 的 yum 安装部署剧本

--- #yaml文件以---开头 ，以表明这是一个yaml文件，可省略

• name: first play #定义一个play的名称，可省略

gather_facts: false #设置不进行facts信息收集，这可以加快执行速度，可省略

hosts: webservers #指定要执行任务的被管理主机组，如多个主机组用冒号分隔

remote_user: root #指定被管理主机上执行任务的用户
tasks : #定义任务列表，任务列表中的各任务按次序逐个在hosts中指定的主机上执行

• name: test connection #自定义任务名称

ping: #使用 module: [options] 格式来定义一个任务

• name: disable selinux

command: '/sbin/setenforce 0' #command模块和shell模块无需使用key=value格式

ignore_errors: True #如执行命令的返回值不为0，就会报错，tasks停止，可使用ignore_errors忽略失败的任务，报错之后就会停止下面的任务

• name: disable firewalld

service: name=firewalld state=stopped #使用 module: options 格式来定义任务，option使用key=value格式

• name: install httpd

yum: name=httpd state=latest

• name: install configuration file for httpd

copy: src=/opt/httpd.conf dest=/etc/httpd/conf/httpd.conf #这里需要一个事先准备好的/opt/httpd.conf文件

notify: "restart httpd" #如以上操作后为changed的状态时，会通过notify指定的名称触发对应名称的handlers操作

• name: start httpd service

service: enabled=true name=httpd state=started

handlers: #handlers中定义的就是任务，此处handlers中的任务使用的是service模块，当所有的task的模块执行完之后，再去执行handlers模块

• name: restart httpd #notify和handlers中任务的名称必须一致

service: name=httpd state=restarted

##Ansible在执行完某个任务之后并不会立即去执行对应的handler，而是在当前play中所有普通任务都执行完后再去执行handler，这样的好处是可以多次触发notify，但最后只执行一次对应的handler，从而避免多次重启。

运行playbook

ansible-playbook test1.yaml

//补充参数：

-k（--ask-pass）：用来交互输入ssh密码

-K（-ask-become-pass）：用来交互输入sudo密码

-u：指定用户

ansible-playbook test1.yaml --syntax-check #检查yaml文件的语法是否正确

ansible-playbook test1.yaml --list-task #检查tasks任务

ansible-playbook test1.yaml --list-hosts #检查生效的主机

ansible-playbook test1.yaml --start-at-task='install httpd' #指定从某个task开始运行

---     #yaml文件以---开头，以表明这是一个yaml文件，可省略
- name: first play     #定义一个play的名称，可省略
  gather_facts: false    #设置不进行facts信息收集，这可以加快执行速度，可省略
  hosts: webservers    #指定要执行任务的被管理主机组，如多个主机组用冒号分隔
  remote_user: root    #指定被管理主机上执行任务的用户
  tasks:     #定义任务列表，任务列表中的各任务按次序逐个在hosts中指定的主机上执行
   - name: test connection    #自定义任务名称
     ping:     #使用 module: [options] 格式来定义一个任务
   - name: disable selinux
     command: '/sbin/setenforce 0'    #command模块和shell模块无需使用key=value格式
     ignore_errors: True     #如执行命令的返回值不为0，就会报错，tasks停止，可使用ignore_errors忽略失败的任务
   - name: disable firewalld
     service: name=firewalld state=stopped    #使用 module: options 格式来定义任务，option使用key=value格式
   - name: install httpd
     yum: name=httpd state=latest
   - name: install configuration file for httpd
     copy: src=/opt/httpd.conf dest=/etc/httpd/conf/httpd.conf    #这里需要一个事先准备好的/opt/httpd.conf文件
     notify: "restart httpd"    #如以上操作后为changed的状态时，会通过notify指定的名称触发对应名称的handlers操作
   - name: start httpd service
     service: enabled=true name=httpd state=started
  handlers:     #handlers中定义的就是任务，此处handlers中的任务使用的是service模块
   - name: restart httpd    #notify和handlers中任务的名称必须一致
     service: name=httpd state=restarted
##Ansible在执行完某个任务之后并不会立即去执行对应的handler，而是在当前play中所有普通任务都执行完后再去执行handler，这样的好处是可以多次触发notify，但最后只执行一次对应的handler，从而避免多次重启。

---
- name: install httpd
  gather_facts: false
  hosts: webservers
  remote_user: root
  tasks:
    - name: connection ceshi
      ping:
    - name: disable firewalld
      service: name=firewalld state=stopped
    - name: install apache
      yum: name=httpd state=latest
    - name: install config file
      copy: src=/opt/httpd.conf dest=/etc/httpd/conf/httpd.conf
      notify: "restart httpd"
    - name: start httpd service
      service: enabled=true name=httpd state=started
  handlers:
    - name: restart httpd
      service: name=httpd state=restarted

将httpd.conf的配置文件放在opt下（这个操作在ansible上执行）

随后去浏览器上面访问webservers组中的httpd 这边端口号为8080，所以访问的是webservers中组中的8080端口

定义、引用变量 vars

- name: second play
  hosts: dbservers
  remote_user: root
  vars:                 #定义变量
   - groupname: mysql   #格式为 key: value
   - username: nginx
  tasks:
   - name: create group
     group: name={{groupname}} system=yes gid=306    #使用 {{key}} 引用变量的值
   - name: create user
     user: name={{username}} uid=306 group={{groupname}} 
   - name: copy file
     copy: content="{{ansible_default_ipv4}}" dest=/opt/vars.txt    #在setup模块中可以获取facts变量信息


ansible-playbook test1.yaml -e "username=nginx"     #在命令行里定义变量

随后，在ansible上面验证

在外面使用的-e变量的值，会覆盖yaml文件里面变量的值，外面的优先级大于配置文件里面的

可以在其他的webservers组中的成员中查看 nginx

创建文件

在yaml文件中，我们可以在初始配置的模块中用var去定义变量的存在，变量的格式为 key:value ,以此来确定该变量在剧本中的存在

vim test1.yaml
---
- name: this is a play for testing variables
  hosts: dbservers
  remote_user: root
  vars:
   filename: abc.txt
  tasks:
   - name: touch a test file
     file: path=/opt/{{filename}} state=touch
 
 
ansible-playbook test1.yaml

启动

切换到db组中的192.168.88.7中的opt目录下查看，有abc,txt

引用 fact 信息中的变量

首先我们知道 使用 ansible 组 -m setup 可以收集该组中所有的节点信息 ，

所以 setup 中 fact 信息，有时候会剧本编写中需要，而 fact 的信息也是可以通过变量的方式进行调用

目的：读取该字段的weekday的信息

剧本编写：

---
- name: this is a playbook for quote variate
  hosts: dbservers
  remote_user: root
  tasks:
    - name: reading setup fact variate
      debug: msg={{ansible_date_time.weekday}}

横向纵向变量区别：

指定远程主机sudo切换用户

先在那台机器上创建 zhangsan 这边做的是dbservers组 里面只有192.168.88.7ip主机，所以在88.7主机上面操作

随后，在88.7上面设置zhangsan的权限

随后，编写剧本

随后，在db组上面，查看a.txt是否被删除

when 条件判断

在 Ansible 中，提供的唯一一个通用的条件判断是 when 指令，当 when 指令的值为 true 时，则该任务执行，否则不执行该任务。

---
- hosts: webservers
  remote_user: root
  tasks:
    - name: shutdown host
      command: /sbin/shutdown -r now
      when: ansible_default_ipv4.address == "192.168.88.5"
~                                                           

xshell关闭

when用来进行条件判断的关键字 ，其作用只在你指定条件下会执行下面的任务**，当条件为真时，任务就会被执行，否则任务将被跳过**

补充：！取反

调用service模块关闭httpd服务

---
- hosts: webservers
  remote_user: root
  tasks:
    - name: test when
      service: name=httpd state=stopped
      when: ansible_default_ipv4.address =="192.168.88.5"

随后，去192.168.88.5的主机上查看httpd的状态，已经关闭

迭代

Ansible提供了很多种循环结构，一般都命名为with_items，作用等同于 loop 循环

批量创建目录

---
- name: play1
  hosts: web-z1
  gather_facts: false
  tasks:
    - name: create directories
      file:
        path: "{{item}}"
        state: directory
      with_items:
        - /mnt/nangjing
        - /mnt/hefei

批量创建文件

---
- name: play1
  hosts: web-z1
  gather_facts: false
  tasks:
    - name: create file
      file:
        path: "{{item}}"
        state: touch
      with_items:
        - /mnt/a.txt
        - /mnt/b.txt

远程主机查看

批量创建目录、批量创建多个用户，并加入指定的组

---
- name: play1
  hosts: web-z1
  gather_facts: false
  tasks:
    - name: create directories
      file:
        path: "{{item}}"
        state: directory
      with_items:          #等同于 loop:
        - /tmp/test1
        - /tmp/test2
    - name: add users
      user: name={{item.name}} state=present groups={{item.groups}}
      with_items:
        - name: test1
          groups: wheel
        - name: test2
          groups: root

远端主机查看

关闭服务器 在db组上面查看

在vars调用变量与with_items中结合

随后，去db组上面查看，已经关闭

总结：

inventory主机清单管理
主机清单配置文件   /etc/ansible/hosts
 
格式：
[组名]
主机IP[:ssh端口]     #默认是 22 端口
主机名[:ssh端口]
主机IP[0:255]        #设置连续的主机列表范围
主机名[a:z]    ansible_port=     ansible_user=    ansible_password=           #设置主机变量
 
[组名:vars]             #设置组变量
ansible_port=
ansible_user=
ansible_password=
 
[大组名:children]       #设置嵌套组
组名1
组名2
组名3
 
 
playbook剧本
vim XXX.yaml  XXX.yml
---
- name:                 #设置play的名称
  hosts:                #指定执行此play的远程主机组
  remote_user:          #指定执行此play的用户
  #become:              #设置是否sudo切换
  #become_user:         #指定sudo切换的用户
  gather_facts:         #设置是否收集facts信息 yes|no|true|false
  vars:                 #设置自定义变量
  tasks:                #指定此play的任务列表
  - name:                  #定义任务的名称
    模块名: 模块参数       #定义任务要使用的模块和参数(键值对格式)
  - name:  
    模块名: 模块参数
    ignore_errors: true    #忽略此任务的失败
  - name:  
    模块名: 模块参数
    notify: '任务名'       #定义此任务执行结果为changed状态时要触发的handlers任务
  - name:  
    模块名: 模块参数
    when:                  #定义条件表达式(== != > >= < <=)，条件成立时执行此task任务，否则不执行此任务
  - name:  
    模块名: 模块参数={{item}}
    with_items:            #定义循环列表
  - name:  
    模块名: 模块参数
    tags:                  #定义任务的标签，ansible-playbook --tags="标签" 可实现仅执行拥有指定标签的任务(拥有always标签的任务总是执行)
	- 标签1
	- 标签2
	....
	
  handlers:
  - name: 任务名
    模块名: 模块参数
 
 
ansible-playbook XXX.yaml -u -k -K  
                          --syntax-check
						  --list-task
						  --list-hosts
						  --start-at-task="任务名称"
						  --tags="标签"
 
 
tasks任务的模块语法格式：
纵向格式：
    模块名:
	  参数1: 值
      参数2: "{{变量名}}"
		....
横向格式：
    模块名: 参数1=值  参数2={{变量名}} ....
 
		
with_items 和 vars 的语法格式
纵向格式：
  - name:
    with_items:
    - 值1
    - 值2
    ....
    模块名: 参数={{item}}
 
  vars:
    变量名:
	- 值1
	- 值2
    ....
  tasks:
  - name:
    模块名: 参数={{item}}
    with_items: "{{变量名}}"
 
  #值为对象类型（键值对字段）时：
    with_items:
    - key1: 值1
      key2: 值2
    - key1: 值3
      key2: 值4
    ....
 
  vars:
    变量名:
    - key1: 值1
      key2: 值2
    - key1: 值3
      key2: 值4
    ....
	
横向格式：
  #值为纯量类型时：
    with_items: [值1, 值2, ....]
 
  vars:
    变量名: [值1, 值2, ....]
 
  #值为对象类型（键值对字段）时：
    with_items:
    - {key1: 值1, key2: 值2}
    - {key1: 值3, key2: 值4}
    ....
 
 
template配置模板模块
1）先准备一个 XXX.j2 配置模板文件，在模板文件中使用 {{变量名}} 格式引用主机变量、组变量、facts信息字段变量或vars字段自定义的变量的值
2）编辑 playbook 文件，在文件中的 tasks 任务中定义 template 模块配置（template: src=XXX.j2文件路径 dest=远程主机文件路径）
 
 
roles角色的作用？
可以把playbook剧本里的各个play看作为一个角色，将各个角色的tasks任务、vars变量、template模板和copy、script模块使用的相关文件等内容放置在指定角色的目录里统一管理，在需要的时候可在playbook中使用roles角色直接调用即可。也就是说roles角色可以在playbook中实现代码的复用。
 
roles/                         #角色总目录，其每个子目录就是一个角色目录
   nginx/                         #相当于playbook中的每一个play主题，目录名就是角色名
      files/                         #存放copy、script模块调用的文件
	  templates/                     #存放template模块调用的 XXX.j2 模板文件
	  tasks/main.yml                 #定义此角色的tasks普通任务列表
	  handlers/main.yml              #定义此角色通过notify触发时执行的handlers处理器任务列表
	  vars/main.yml                  #定义此角色用的自定义变量
	  defaults/main.yml              #定义此角色用的默认变量(一般不用)
	  meta/main.yml                  #定义此角色的元数据信息和依赖关系
   mysql/
     .... 
   php/
     ....
 
 
vim XXX.yaml
- name:
  hosts:
  remote_user:
  roles:
  - nginx
  - mysql
  - php
 
ansible-playbook XXX.yaml

//Templates 模块（做配置模板文件用的）

Jinja是基于Python的模板引擎。Template类是Jinja的一个重要组件，可以看作是一个编译过的模板文件，用来产生目标文本，传递Python的变量给模板去替换模板中的标记。

如果想要更多的机器去同时下载httpd或者其他的服务，ansible如果不改配置文件的变量，则要将对方的服务端一台一台的去修改，因此要在ansible服务端去弄一个变量，然后将j2的模板去传给对向的服务端去自动匹配端口服务名等

1.先准备一个以 .j2 为后缀的 template 模板文件，设置引用的变量
cp /etc/httpd/conf/httpd.conf /opt/httpd.conf.j2

vim /opt/httpd.conf.j2
Listen {{http_port}}				#42行，修改
ServerName {{server_name}}			#95行，修改
DocumentRoot "{{root_dir}}"          #119行，修改

2.修改主机清单文件，使用主机变量定义一个变量名相同，而值不同的变量
vim /etc/ansible/hosts       
[webservers]
192.168.10.14 http_port=192.168.10.14:80 server_name=www.accp.com:80 root_dir=/etc/httpd/htdocs

[dbservers]
192.168.10.15 http_port=192.168.0.15:80 server_name=www.benet.com:80 root_dir=/etc/httpd/htdocs

3.编写 playbook 
vim apache.yaml
---
- hosts: all
  remote_user: root
  vars:
    - package: httpd
    - service: httpd
  tasks:
    - name: install httpd package
      yum: name={{package}} state=latest
    - name: install configure file
      template: src=/opt/httpd.conf.j2 dest=/etc/httpd/conf/httpd.conf     #使用template模板
      notify:
        - restart httpd
    - name: create root dir
	  file: path=/etc/httpd/htdocs state=directory
    - name: start httpd server
      service: name={{service}} enabled=true state=started
  handlers:
    - name: restart httpd
      service: name={{service}} state=restarted

ansible-playbook apache.yaml

修改主机清单文件 在ansible主机里面修改

vim /etc/ansible/hosts       
[webservers]
192.168.44.60 http_port=8080 server_name=www.test1.com:8080 
 
[dbservers]
192.168.44.50 http_port=8081 server_name=www.test2.com:8081 

随后，编写playbook

---
- name: install httpd
  hosts: webservers
  remote_user: root
  vars:
    - pk: httpd
    - service: httpd
  tasks:
    - name: install httpd pk
      yum: name={{pk}} state=latest
    - name: copy config file
      template: src=/opt/httpd.conf.j2 dest=/etc/httpd/conf/httpd.conf
      notify:
        - restart httpd
    - name: start httpd server
      service: name={{service}} enabled=true state=started
  handlers:
    - name: restart httpd
      service: name={{service}} state=restarted

~                             

随后，在webservers上面查看是否有httpd 都是有的

查看客户机的配置是否更改，并测试能否正常访问

Tags

可以在一个 playbook 中为某个或某些任务定义"标签"，在执行此 playbook 时通过 ansible-playbook 命令使用**--tags 选项能实现仅运行指定的 tasks。**

playbook 还提供了一个特殊的 tags 为 always。作用就是当使用 always 作为 tags 的 task 时，无论执行哪一个 tags 时，定义有 always 的 tags 都会执行。

单标签的使用

vim test1.yaml
---
- name: this is a play for testing variables
  hosts: webservers
  remote_user: root
  tasks:
   - name: position 1
     debug:
       msg: 'ls /opt'
     tags:
      - only
   - name: position 2
     debug:
       msg: 'ls /mnt'
 
ansible-playbook test1.yaml --tags="only"

多标签的使用

---
- name: this is a play for testing variables
  hosts: webservers
  remote_user: root
  tasks:
   - name: position 1
     debug:
       msg: '测试标签1'
     tags:
      - one
   - name: position 2
     debug:
       msg: '测试标签2'
     tags:
      - two
   - name: position 3
     debug:
       msg: '测试标签3'
     tags:
      - one

当没有指定标签的时候，都执行

当指定标签为one时，

通用标签 always 的运用

---
- name: this is a play for testing variables
  hosts: dbservers
  remote_user: root
  tasks:
   - name: position 1
     debug:
       msg: '测试标签1'
     tags:
      - one  #可自定义
   - name: position 2
     debug:
       msg: '测试通用标签always'
     tags:
      - always  #表示始终要运行的代码
   - name: position 3
     debug:
       msg: '测试标签3'
     tags:
      - one

随后，去执行

roles

简述 ansible 角色：

数据中心有各种不同类型的主机。如web服务器、数据库服务器，基于开发环境的服务器。随着时间的推移，具有处理所有这些情况的任务和人员的Ansible playbook将变得庞大而复杂。

• 角色允许将复杂的剧本组织成独立的、更小的剧本和文件，
• 角色提供了一种从外部文件加载任务、处理程序和变量的方法，
• 角色也可关联和引用静态的文件和模板。
• 角色可以编写成满足普通用途需求，并且能被重复利用。
• 定义角色的文件具有特定的名称，并以严格的目录结构进行组织。

roles 内各目录含义解释:

●files
用来存放由 copy 模块或 script 模块调用的文件。

●templates
用来存放 jinjia2 模板，template 模块会自动在此目录中寻找 jinjia2 模板文件。

●tasks
此目录应当包含一个 main.yml 文件，用于定义此角色的任务列表，此文件可以使用 include 包含其它的位于此目录的 task 文件。

●handlers
此目录应当包含一个 main.yml 文件，用于定义此角色中触发条件时执行的动作。

●vars
此目录应当包含一个 main.yml 文件，用于定义此角色用到的变量。

●defaults
此目录应当包含一个 main.yml 文件，用于为当前角色设定默认变量。

●meta
此目录应当包含一个 main.yml 文件，用于定义此角色的特殊设定及其依赖关系。

roles 的步骤

在一个 playbook 中使用 roles 的步骤：
（1）创建以 roles 命名的目录
mkdir /etc/ansible/roles/ -p    #yum装完默认就有
 
（2）创建全局变量目录（可选）
mkdir /etc/ansible/group_vars/ -p
touch /etc/ansible/group_vars/all     #文件名自己定义，引用的时候注意
 
（3）在 roles 目录中分别创建以各角色名称命令的目录，如 httpd、mysql
mkdir /etc/ansible/roles/httpd
mkdir /etc/ansible/roles/mysql
 
（4）在每个角色命令的目录中分别创建files、handlers、tasks、templates、meta、defaults和vars目录，用不到的目录可以创建为空目录，也可以不创建
mkdir /etc/ansible/roles/httpd/{files,templates,tasks,handlers,vars,defaults,meta}
mkdir /etc/ansible/roles/mysql/{files,templates,tasks,handlers,vars,defaults,meta}
 
（5）在每个角色的 handlers、tasks、meta、defaults、vars 目录下创建 main.yml 文件，千万不能自定义文件名
touch /etc/ansible/roles/httpd/{defaults,vars,tasks,meta,handlers}/main.yml
touch /etc/ansible/roles/mysql/{defaults,vars,tasks,meta,handlers}/main.yml
 
（6）修改 site.yml 文件，针对不同主机去调用不同的角色
vim /etc/ansible/site.yml
---
- hosts: webservers
  remote_user: root
  roles:
     - httpd
- hosts: dbservers
  remote_user: root
  roles:
     - mysql
	 
（7）运行 ansible-playbook
cd /etc/ansible
ansible-playbook site.yml

操作：搭建 LAMP

mkdir /etc/ansible/roles/httpd/{files,templates,tasks,handlers,vars,defaults,meta} -p
mkdir /etc/ansible/roles/mysql/{files,templates,tasks,handlers,vars,defaults,meta} -p
mkdir /etc/ansible/roles/php/{files,templates,tasks,handlers,vars,defaults,meta} -p
 
touch /etc/ansible/roles/httpd/{defaults,vars,tasks,meta,handlers}/main.yml
touch /etc/ansible/roles/mysql/{defaults,vars,tasks,meta,handlers}/main.yml
touch /etc/ansible/roles/php/{defaults,vars,tasks,meta,handlers}/main.yml
 
------编写httpd模块------
写一个简单的tasks/main.yml
vim /etc/ansible/roles/httpd/tasks/main.yml
- name: install apache
  yum: name={{pkg}} state=latest
- name: start apache
  service: enabled=true name={{svc}} state=started
 
//定义变量：可以定义在全局变量中，也可以定义在roles角色变量中，一般定义在角色变量中
vim /etc/ansible/roles/httpd/vars/main.yml
pkg: httpd
svc: httpd
 
-------编写mysql模块-------
vim /etc/ansible/roles/mysql/tasks/main.yml
- name: install mysql
  yum: name={{pkg}} state=latest
- name: start mysql
  service: enabled=true name={{svc}} state=started
  
vim /etc/ansible/roles/mysql/vars/main.yml
pkg:
  - mariadb
  - mariadb-server
svc: mariadb
 
-------编写php模块-----
vim /etc/ansible/roles/php/tasks/main.yml
- name: install php
  yum: name={{pkg}} state=latest
- name: start php-fpm
  service: enabled=true name={{svc}} state=started
 
vim /etc/ansible/roles/php/vars/main.yml
pkg:
  - php
  - php-fpm
svc: php-fpm
 
-----编写roles示例-----
vim /etc/ansible/site.yml
---
- hosts: webservers
  remote_user: root
  roles:
   - httpd
   - mysql
   - php
 
 
cd /etc/ansible
ansible-playbook site.yml

编写 httpd 模块

写一个简单的tasks/main.yml
vim /etc/ansible/roles/httpd/tasks/main.yml
- name: install apache
  yum: name={{pkg}} state=latest
- name: start apache
  service: enabled=true name={{svc}} state=started
 
//定义变量：可以定义在全局变量中，也可以定义在roles角色变量中，一般定义在角色变量中
vim /etc/ansible/roles/httpd/vars/main.yml
pkg: httpd
svc: httpd

编写 mysql 模块

vim /etc/ansible/roles/mysql/tasks/main.yml
- name: install mysql
  yum: name={{pkg}} state=latest
- name: start mysql
  service: enabled=true name={{svc}} state=started
  
vim /etc/ansible/roles/mysql/vars/main.yml
pkg:
  - mariadb
  - mariadb-server
svc: mariadb

编写php模块

vim /etc/ansible/roles/php/tasks/main.yml
- name: install php
  yum: name={{pkg}} state=latest
- name: start php-fpm
  service: enabled=true name={{svc}} state=started
 
vim /etc/ansible/roles/php/vars/main.yml
pkg:
  - php
  - php-fpm
svc: php-fpm

编写roles示例

vim /etc/ansible/site.yml
---
- hosts: webservers
  remote_user: root
  roles:
   - httpd
   - mysql
   - php

cd /etc/ansible
ansible-playbook site.yml