Ansible es una herramienta de automatización que se utiliza para la gestión de la configuración, la implementación de aplicaciones y la orquestación de implementaciones en la nube. Es una herramienta de código abierto escrita en Python que se comunica con hosts remotos a través del protocolo SSH.

1. Introducción relacionada y plataformas similares:
- Introducción relacionada: Ansible es una herramienta de automatización basada en agentes que utiliza una sintaxis simple y liviana. Su objetivo principal es hacer que el proceso de automatización sea simple y fácil de usar, al mismo tiempo que proporciona funciones poderosas para administrar infraestructura a gran escala.
- Plataformas similares: las herramientas de automatización similares a Ansible incluyen Puppet, Chef, SaltStack, etc. Todas estas herramientas proporcionan una funcionalidad similar, pero tienen una sintaxis, principios de funcionamiento y modelos de implementación ligeramente diferentes.

2. Por qué utilizar Ansible, qué puede hacer y sus ventajas:
   - Fácil de usar: Ansible utiliza una sintaxis basada en YAML, que es fácil de entender y escribir sin conocimientos de programación. También cuenta con buena documentación y soporte comunitario activo.
   - Sin agente: Ansible utiliza el protocolo SSH para comunicarse sin necesidad de instalar ningún agente en el host remoto, lo que hace que la implementación y configuración sea más sencilla y segura.
   - Basado en scripts: Ansible utiliza un enfoque basado en scripts para describir y ejecutar tareas automatizadas, lo que hace que la organización y gestión de tareas sean más flexibles y escalables.
   - Altamente configurable: Ansible admite varias plataformas y sistemas operativos, y proporciona una gran cantidad de módulos y complementos para administrar varios tipos de recursos, incluidos servidores, dispositivos de red, plataformas en la nube, etc.
   - Extensibilidad: Ansible tiene una gran extensibilidad y los módulos y complementos personalizados se pueden escribir de acuerdo con necesidades específicas o integrarse con herramientas y sistemas existentes.

3. Cómo funciona:
   - Ansible utiliza un nodo de control para administrar múltiples hosts remotos. El archivo de configuración de Ansible en el nodo de control describe las tareas que deben realizarse y la información del host relacionada.
   - Cuando el nodo de control ejecuta un comando de Ansible, se conecta al host remoto a través de SSH y realiza las tareas correspondientes en el host remoto.
   - Ansible utiliza un enfoque basado en módulos para administrar y configurar hosts remotos. Puede realizar diversas operaciones a través de módulos integrados, como gestión de archivos, instalación de paquetes de software, gestión de servicios, etc.
   - Ansible también admite el uso de playbooks para definir y organizar múltiples tareas, así como el uso de variables y condiciones para implementar procesos de automatización más complejos.

En general, Ansible es una herramienta de automatización potente, fácil de usar y sin agentes que puede ayudar a simplificar el proceso de gestión de la configuración y la implementación de aplicaciones, mejorar la eficiencia del trabajo y la capacidad de mantenimiento.

Componentes principales

• Inventario: información del host administrada por Ansible, incluida la dirección IP, el puerto SSH, el número de cuenta, la contraseña, etc.;

• Módulos : las tareas se completan mediante módulos y los módulos también se pueden personalizar, como scripts de uso frecuente;

• Complementos : utilice complementos para aumentar las funciones principales de Ansible . Proporciona muchos complementos y también puede agregarlos usted mismo.

Definir complemento. Por ejemplo, el complemento de conexión se utiliza para conectarse al host de destino. El complemento callback k puede generar los resultados El complemento vars inyecta variables de proporción definidas en Ansible para su ejecución.

• Playbooks : "scripts", definen de forma modular una serie de tareas para una llamada externa unificada. Funcionalidad central de Ansible .

Ansible se puede ejecutar en cualquier máquina con Python 2 (versión 2.6 o 2.7) o Python 3 (versión 3.5 y superior) instalado (Windows no es compatible con máquinas de administración ) .

2. Instalación

Antes de comenzar el experimento, primero sincronizamos la hora del clúster y realizamos ssh sin contraseña.

##每台主机
ssh-keygen
ssh-copy-id 192.168.115.131
##在192.168.115.131
for i in 136 140 ;do scp /root/.ssh/authorized_keys 192.168.115.$i:/root/.ssh ;done
##同步集群时间
for i in 131 136 140 ;do ssh 192.168.115.$i yum -y install ntp;done
for i in 131 136 140 ;do ssh 192.168.115.$i systemctl restart ntpd;done

1. Seleccionar fuente

cd /etc/yum.repos.d
mkdir back
mv * bcak
yum clean all
yum makecache
yum update
wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo
curl-o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo
yum makecache frist
yum update

2. Instalar ansible

yum -y install epel-release.noarch
yum -y install ansible

3. Vista del módulo

###模块列表
ansible-doc -l

###模块用法查看
ansible-doc 模块名

3. Experimentar

1. Topología

2. Configurar grupo y módulo de ping

Éxito verde, fracaso rojo

Camino 1

vim /etc/ansible/hosts
###插入
[group]
192.168.115.131
192.168.115.136
192.168.115.140
###利用模块ping
ansible -m ping group

Camino 2

#如果主机数量太多就这样表示
[group]
192.168.115.[136:140]

Camino 3

##指定端口
[group]
192.168.115.136:22

Camino 4

###别名
[group]
192.168.115.136:22
hy ansible_ssh_host=192.168.115.140 ansible_ssh_port=22

Camino 5

##没有ssh免密的也可以
[group]
ansible_ssh_host=192.168.115.140 ansible_ssh_port=22 ansible_ssh_user=用户名 ansible_ssh_pass="密码"

Camino 6

###利用别名分组
[group]
192.168.115.136:22
hy ansible_ssh_host=192.168.115.136 ansible_ssh_port=22 ansible_ssh_user=root ansible_ssh_pass="123.com"
nginx ansible_ssh_host=192.168.115.140 ansible_ssh_port=22 ansible_ssh_user=root ansible_ssh_pass="123.com"
[nginx]
nginx
[hy]
hy

3. módulo de nombre de host

El formato básico es: nombre de la máquina o nombre del grupo para la operación ansible -m nombre del módulo -a argumento "parámetro 1=valor 1 parámetro 2=valor 2"

El amarillo indica éxito

###修改192.168.115.136的主机名hy
###修改192.168.115.140的主机名nginx
ansible hy -m hostname -a 'name=hy'
ansible nginx -m hostname -a 'name=nginx'

4. módulo de archivo

1. Crea un directorio

##创建一个目录
ansible hy -m file -a "path=/opt/hy.txt state=directory"

2. Crea archivos


ansible hy -m file -a "path=/opt/hy.txt/test.tst state=touch"

3. Modificar el grupo de propietarios y los permisos.

####修改属主为hy，属组hy 权限777
ansible hy -m file -a "path=/opt/hy.txt recurse=yes owner=hy group=hy mode=777"

4. Elimine el directorio (incluidos los archivos del directorio)

###删除/opt/hy.txt
 ansible hy -m file -a "path=/opt/hy.txt state=absent"

5. Crea conexiones suaves y duras

#软
ansible hy -m file -a "src=/etc/fstab path=/opt/fstab2 state=link"
#硬
ansible hy -m file -a "src=/etc/fstab path=/opt/fstab1 state=hard"

5. módulo de estadísticas

###用来获取文件的信息状态
ansible hy -m file -a "path=/opt/hy.txt state=touch"
ansible hy -m stat -a "path=/opt/hy.txt"

6. Copiar módulo (copiar localmente a remoto)

Prepare un archivo para copiarlo a 2 agentes en ansible

 echo 192.168.115.131 > 1.txt
ansible group -m copy -a "src=/root/1.txt dest=/opt"

Utilice contenido para escribir contenido de forma remota y sobrescribir el contenido original

ansible group -m copy -a "content="hello\n" dest=/opt/1.txt"

Si se debe utilizar el parámetro de fuerza para forzar la cobertura

##写入
echo 192.168.115.131 > 1.txt
ansible group -m copy -a "content="hello" dest=/opt/1.txt force=no"#如果目标文件存在，不覆盖
ansible group -m copy -a "content="hello" dest=/opt/1.txt force=yes"#如果目标文件存在，覆盖

Utilice el módulo de copia de seguridad para realizar copias de seguridad de archivos locales en el extremo remoto.

###把本机的文件备份到远端
ansible group -m copy -a "src=/root/1.txt dest=/opt/2.txt backup=yes owner=root group=root mode=644"

La diferencia entre / al copiar y sin /

ansible hy -m copiar -a "src=/etc/yum.repos.d dest=/etc/yum.repos.d"

ansible nginx -m copiar -a "src=/etc/yum.repos.d/dest=/etc/yum.repos.d"

7. El módulo de recuperación es similar al módulo de copia, pero tiene el efecto opuesto. Se utiliza para copiar archivos desde una máquina remota a la máquina local.

Nota : El módulo de recuperación no puede copiar directorios de remoto a local

##两台agent上创建同名、路径文件
echo 192.168.115.136 hy > test.txt
echo 192.168.115.140 nginx > test.txt
###ansible上操作
group -m fetch -a "src=/etc/yum.repos.d/test.txt dest=/etc/yum.repos.d"

8. módulo de usuario

El módulo de usuario se utiliza para administrar cuentas de usuario y atributos de usuario.

##创建aaa用户,默认为普通用户,创建家目录
ansible hy -m user -a "name=aaa state=present"

###创建系统用户
ansible hy -m user -a'name=bbb state=present system=yes shell="/sbin/nologin"'

##创建ccc用户, 使用uid参数指定uid, 使用password参数传密码
echo 123.com |openssl passwd -stdin
ansible hy -m user -a 'name=ccc state=present uid=6666 password="密码"'

##创建一个普通用户叫ddd,并产生空密码 密钥对
ansible hy -m user -a 'name=ddd state=present generate_ssh_key=yes'

##删除aaa用户,但家目录默认没有删除
ansible hy -m user -a 'name=aaa state=absent'

##删除aaa用户、家目录
ansible hy -m user -a 'name=aaa state=absent remove=yes'

9. módulo de grupo

El módulo de grupo se utiliza para administrar grupos de usuarios y atributos de grupos de usuarios.

###创建组
ansible hy -m group -a 'name=web gid=2000 state=present'

##删除组（如果有用户的gid为此组，则删除不了)
ansible hy -m group -a 'name=web state=absent'

10. módulo cron

El módulo cron se utiliza para gestionar tareas de tiempo periódicas.

##创建一个cron任务,不指定user的话,默认就是root（因为我这里是用root操作的)。
如果minute,hour,day,month,week不指定的话，默认都为*
ansible hy -m cron -a 'name="test1" user=root job="touch /etc/6666" minute=26'

删除cron任务
ansible hy -m cron -a 'name="test1" state=sbsent'

4. módulo yum_repository

El módulo yum_repository se utiliza para configurar el repositorio yum.

### yum_repository模块yum_repository模块用于配置yum仓库。
注意：此模块只帮助配置yum仓库,但如果仓库里没有软件包，安装一样会失败。所以可以手动去挂载光驱到/mnt目录


ansible hy -m yum_repository -a "name=local description=localyum baseurl=file:///mnt/ enabled=yes gpgcheck=no"


##删除/etc/yum.repos.d/local.repo配置文件
ansible hy -m yum_repository -a "name=local state=absent"

5. módulo yum

El módulo yum se utiliza para instalar y desinstalar paquetes de software mediante el comando yum. Requisito previo: la configuración de yum en la máquina del grupo está bien. Si usa fuentes locales, debe montarlas.

##安装http
ansible group -m yum -a 'name=httpd state=present'

######使用网络源
##在ansible上安安装网络源
wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo
##copy到其他主机

Utilice yum para instalar httpd, software httpd-devel, state=latest significa instalar la última versión

ansible grupo1 -m yum -a 'nombre=httpd,httpd-devel estado=último'

Utilice yum para desinstalar el software httpd y httpd-devel

ansible grupo1 -m yum -a 'nombre=httpd,httpd-devel estado=ausente'

6. módulo de servidor

### service模块(重点)service模块用于控制服务的启动,关闭,开机自启动等。
启动vsftpd服务，并设为开机自动启动
master# ansible group -m service -a 'name=vsftpd state=started enabled=on'

关闭vsftpd服务，并设为开机不自动启动
master# ansible group -m service -a 'name=vsftpd state=stoped enabled=false'

Instalamos un servicio mariadb y lo configuramos para que se inicie automáticamente al arrancar

ansible group -m yum -a 'name=mariadb,mariadb-server state=present'
ansible group -m service -a 'name=mariadb state=started enabled=yes'

Siete, módulo de secuencia de comandos

El módulo de script se utiliza para ejecutar scripts locales en máquinas remotas .

在master上准备一个脚本
master# vim /tmp/1.sh
#!/bin/bash
mkdir /tmp/haha
touch /tmp/haha/{1..10}

在group1的远程机器里都执行master上的/tmp/1.sh脚本（此脚本不用给执行权限)
master# ansible group1 -m script -a '/tmp/1.sh'

8. módulos de comando y shell

Ambos módulos se utilizan para ejecutar comandos de Linux, lo cual es muy fácil de usar para ingenieros que estén familiarizados con los comandos.

El módulo de shell es similar al módulo de comando (el módulo de comando no puede ejecutar símbolos como $HOME, >, <, |, etc., pero el shell sí).

ansible -m comando grupo1 -a "useradd usuario2" 
ansible -m comando grupo1 -a "id usuario2" 
ansible
-m comando grupo1 -a "cat /etc/passwd |wc -l" --报错
ansible -m shell grupo1 - a "cat /etc/passwd |wc -l" --成功
ansible
-m comando grupo1 -a "cd $HOME;pwd" --报错
ansible -m shell grupo1 -a "cd $HOME;pwd" --成功

Nota: El módulo shell no es 100% compatible con ningún comando, como vim o ll alias. No se recomienda que memorice qué comandos no están permitidos, solo debe desarrollar el hábito de probar cualquier comando en el entorno de producción en el entorno de prueba.

9. libro de jugadas

Playbook: es un libro de estrategias utilizado por Ansible para configurar, implementar y administrar nodos controlados. Orquestación para operaciones de Ansible.

El formato utilizado es el formato yaml (saltstack, elk, docker, docker-compose, kubernetes, etc. también usan el formato yaml)

formato YMAL

Terminar con .yaml o .yml

La primera línea del archivo comienza con "---", indicando el comienzo del archivo YMAL (opcional)
Comentarios que empiezan con el signo #
Todos los miembros de la lista comienzan en el mismo nivel de sangría y comienzan con "- "(un guión y un espacio)
Un diccionario se 键: 值compone de una forma simple (los dos puntos deben ir seguidos de un espacio)
==Nota: No utilice la tecla de tabulación al escribir este tipo de archivo, utilice espacios==

## playbook实例

先直接来看一个实例

**第1步: 创建一个存放playbook的目录(路径自定义)**

```powershell
master# mkdir /etc/ansible/playbook
```

**第2步: 准备httpd配置文件,并修改成你想要的配置**

```powershell
master# yum install httpd -y

按需要修改你想要的配置(为了测试可以随意改动标记一下)
master# vim /etc/httpd/conf/httpd.conf
```

**第3步: 写一个playbook文件(后缀为.yml或.yaml)**

```powershell
# vim /etc/ansible/playbook/example.yaml
---
- hosts: group1
  remote_user: root
  tasks:  
  - name: ensure apache is at the latest version	
    yum: name=httpd,httpd-devel state=latest
    
  - name: write the apache config file		
    copy: src=/etc/httpd/conf/httpd.conf dest=/etc/httpd/conf/httpd.conf
    
    notify:
    - restart apache
    
  - name: ensure apache is running (and enable it at boot)
    service: name=httpd state=started enabled=yes
    
  handlers:	
    - name: restart apache
      service: name=httpd state=restarted
```

第4步: 执行写好的palybook

- 会显示出执行的过程，并且执行的每一步都有ok,changed,failed等标识
- 执行如果有错误(failed)会回滚，解决问题后，直接再执行这条命令即可,并会把failed改为changed（幂等性)

```powershell
# ansible-playbook /etc/ansible/playbook/example.yaml
```



## Playbook常见语法

**hosts:** 用于指定要执行任务的主机，其可以是一个或多个由冒号分隔主机组.

**remote_user:** 用于指定远程主机上的执行任务的用户.

```powershell
- hosts: group1			
  remote_user: root	
```



**tasks:** 任务列表, 按顺序执行任务. 

- 如果一个host执行task失败, 整个tasks都会回滚, 修正playbook 中的错误, 然后重新执行即可.

```powershell
  tasks:
  - name: ensure apache is at the latest version	
    yum: name=httpd,httpd-devel state=latest
    
  - name: write the apache config file		
    copy: src=/etc/httpd/conf/httpd.conf dest=/etc/httpd/conf/httpd.conf
```



**handlers:**  类似task，但需要使用notify通知调用。

- 不管有多少个通知者进行了notify，等到play中的所有task执行完成之后，handlers也只会被执行一次.
- handlers最佳的应用场景是用来重启服务,或者触发系统重启操作.除此以外很少用到了.

```powershell
    notify:				  
    - restart apache
    
  - name: ensure apache is running (and enable it at boot)
    service: name=httpd state=started enabled=yes
    
  handlers:
  - name: restart apache
    service: name=httpd state=restarted
```



**练习:** 修改httpd的端口为8080,再执行playbook测试



**variables:** 变量

- 定义变量可以被多次方便调用

```powershell
master# vim /etc/ansible/playbook/example2.yaml
---
- hosts: group1
  remote_user: root
  vars:
  - user: test1
  tasks:
  - name: create user
    user: name={
   
   {user}} state=present
~                                           
```

```powershell
master# ansible-playbook /etc/ansible/playbook/example2.yaml
```



### 案例: playbook编排vsftpd

写一个playbook实现 

1. 配置yum
2. 安装vsftpd包
3. 修改配置文件(要求拒绝匿名用户登录)
4. 启动服务并实现vsftpd服务开机自动启动

```powershell
---
- hosts: group1                 
  remote_user: root                     
  tasks:                                
  - name: rm yum repository      
    file: path=/etc/yum.repos.d/ state=absent
    
  - name: 同步master上的yum源到group1
    copy: src=/etc/yum.repos.d dest=/etc/
    
  - name: ensure vsftpd is at the latest version        
    yum: name=vsftpd state=latest
    
  - name: write the apache config file          
    copy: src=/etc/vsftpd/vsftpd.conf dest=/etc/vsftpd/vsftpd.conf 
    
    notify:                             
    - restart vsftpd
    
  - name: ensure vsftpd is running (and enable it at boot)
    service: name=vsftpd state=started enabled=yes
    
  handlers:                     
    - name: restart vsftpd              
      service: name=vsftpd state=restarted
```



## **playbook编排多个hosts任务**

~~~powershell
---			# ---代表开始(可选项,不写也可以)
- hosts: 10.1.1.12
  remote_user: root
  tasks:
  - name: 创建/test1/目录
    file: path=/test1/ state=directory
# 这里不能用---分隔,会报语法错误(后面课程玩k8s编排也写YAML文件,是可以用---来分隔段落的)
- hosts: 10.1.1.13
  remote_user: root
  tasks:
  - name: 创建/test2/目录
    file: path=/test2/ state=directory
...			# ...代表结束(可选项,不写也可以)
~~~



### 案例: 编排nfs搭建与客户端挂载

1, 在master上准备nfs配置文件

~~~powershell
# vim /etc/exports
/share  *(ro)
~~~

2, 编写yaml编排文件

~~~powershell
# vim /etc/ansible/playbook/nfs.yml
---
- hosts: 10.1.1.12
  remote_user: root
  tasks:
  - name: 安装nfs服务相关软件包
    yum: name=nfs-utils,rpcbind,setup  state=latest

  - name: 创建共享目录
    file: path=/share/ state=directory

  - name: 同步nfs配置文件
    copy: src=/etc/exports dest=/etc/exports

    notify: restart nfs

  - name: 启动rpcbind服务,并设置为开机自启动
    service: name=rpcbind state=started enabled=on

  - name: 启动nfs服务,并设置为开机自启动
    service: name=nfs state=started enabled=on

  handlers:
  - name: restart nfs
    service: name=nfs state=restarted

- hosts: 10.1.1.13
  remote_user: root
  tasks:
  - name: 安装nfs客户端软件包
    yum: name=nfs-utils state=latest

  - name: 挂载nfs服务器的共享
    shell: mount 10.1.1.12:/share /mnt
~~~

3, 执行playbook

~~~powershell
# ansible-playbook /etc/ansible/playbook/nfs.yaml
~~~

Instalación ansible y uso de bloques simples.

I. Descripción general