Reutilizar manuales

Reutilizar manuales

Los dos mecanismos de reutilización admitidos por Ansible son Roles e Incluye.

• RolesEs una colección de tareas y variables reutilizables, un concepto similar a los paquetes en los lenguajes de programación.

• IncludesEs un método para descomponer un Playbook en varios archivos. Puede colocar algunas tareas y variables de uso común en archivos separados y luego hacer referencia a estos archivos en el Playbook requerido.

incluir declaración

En Ansible, puede utilizar la palabra clave include para introducir uno o más archivos en un Playbook para lograr 重用el propósito del código. Al escribir tareas comunes y de uso común en un archivo, los códigos para estas tareas se pueden incluir 避免en cada Playbook 重复编写, lo que reduce en gran medida la carga de trabajo. Además, usar declaraciones de inclusión está bien 提高代码的可读性和可理解性porque se abstrae el código común 使得Playbook的代码更加简洁清晰，易于维护和更新. Al mismo tiempo, también es útil usar la declaración de inclusión 降低代码的耦合性, porque abstraer tareas comunes puede aclarar las dependencias entre diferentes Playbooks, evitando así el problema del acoplamiento excesivo de código.

El siguiente es un ejemplo sencillo que utiliza la declaración de inclusión:

Supongamos que tenemos un proyecto ansible en el que se utilizan dos manuales: web.yaml y db.yaml, que se utilizan para implementar el servidor web y el servidor de base de datos respectivamente. Ahora queremos introducir un archivo de tarea común: common.yaml en los dos Playbooks para evitar escribir repetidamente el mismo código de tarea en los dos Playbooks.

Primero, cree una carpeta llamada tareas en el directorio raíz del proyecto para almacenar el archivo de tareas comunes common.yml. Luego cree un archivo llamado common.yml en la carpeta con el siguiente contenido:

  - name: install packages
    remote_user: root
    yum:
     name: git,vim,curl,wget,unzip,zip,net-tools
     state: present

Esta tarea se utiliza para instalar algunos paquetes de software de uso común, que deben instalarse tanto en servidores web como en servidores de bases de datos.

A continuación, podemos usar la declaración de inclusión en web.yaml y db.yaml para presentar el archivo, el código es el siguiente:

Archivo web.yaml:

- name: Deploy web server
  hosts: test1
  tasks:
  - include: tasks/common.yaml
  - name: install and configure Apache
    yum:
     name: httpd
     state: present
  - service:
     name: httpd
     enabled: true
     state: started

Archivo db.yaml:

- name: Deploy database server
  hosts: test2
  tasks:
  - include: tasks/common.yaml
  - name: install and configure Mysql
    yum:
     name: mariadb-server
     state: present
  - service:
     name: mariadb
     enabled: true
     state: started

En el código anterior, usamos la declaración de inclusión para introducir las tareas en el archivo task/common.yml, lo que evita escribir repetidamente códigos de tareas para instalar paquetes de software comunes en web.yaml y db.yaml.

Cómo escribir papel

Role tiene un mecanismo de reutilización e intercambio de código más potente y flexible que include. Incluir es similar a incluir en el lenguaje de programación, reutiliza un solo archivo y la función de reutilización es limitada.

La función es similar a un "Paquete" en un lenguaje de programación, que puede reutilizar un conjunto de archivos para formar una función completa. Por ejemplo, instalar y configurar Apache requiere no solo tareas para implementar el paquete de instalación y copiar plantillas, sino también archivos de plantilla para httpd.conf e index.html, así como la función de reinicio implementada por el archivo controlador. Estos archivos se pueden colocar en una función para su reutilización en diferentes archivos de Playbook.

Definir la estructura de directorio completa del rol.

在Ansible中，通过遵循特定的目录结构，就可以实现对role定义。

Entonces, ¿cómo se crea un directorio de roles?

ansible-galaxy init myrole
# 上述命令会在当前目录下创建一个名为myrole的目录，其默认包含了标准的角色目录结构。

Una estructura de directorio de funciones estándar es la siguiente:

Si desea llamar al rol en ansible.yaml

---
- hosts: test1
  remote_user: root
  roles:
   - myrole

Ansible no requiere que el rol contenga todos los directorios y archivos anteriores, puede agregar los directorios y archivos correspondientes según la función del rol. Estas son las funciones de cada directorio y archivo:

• Directorio de tareas: almacena los archivos de tareas de roles, que main.yamlson necesarios, y se pueden agregar otros archivos de tareas según sea necesario.
• Directorio de plantillas: almacena archivos de plantilla Jinja2 utilizados por roles.
• Directorio de archivos: almacena archivos comunes utilizados por los personajes.
• Directorio vars: almacena archivos variables utilizados por roles, que main.yamlson necesarios, y se pueden agregar otros archivos variables según sea necesario.
• Directorio predeterminado: almacena las variables predeterminadas del rol, que main.yamlson necesarias. Se pueden agregar otros archivos de variables predeterminadas según sea necesario.
• metadirectorio: almacena archivos de metadatos de personajes, incluido el nombre del personaje, el autor, las dependencias y otra información.
• Directorio de controladores: almacena los controladores de roles, que main.yamlson necesarios, y se pueden agregar otros controladores según sea necesario.
• README.md: el archivo de descripción del rol, incluido el propósito del rol, cómo usarlo y otra información.
• El directorio de pruebas contiene los siguientes archivos:
  • inventory: el archivo de lista de hosts del caso de prueba del rol, que define la información del host y del grupo de hosts que debe usarse en el caso de prueba.
  • test.yaml: El archivo de caso de prueba del rol, que define las tareas y los métodos de prueba que deben realizarse en el caso de prueba.

Además, los siguientes archivos no necesitan ser rutas absolutas o relativas, se pueden usar directamente como archivos ubicados en el mismo directorio.

copiar o scipt usa archivos bajo roles/x/files/

La plantilla utiliza archivos bajo roles/x/templates

incluir archivos de usos en roles/x/tareas

Al escribir una función, generalmente se debe incluir el archivo de entrada de funciones roles/x/tasks/main.yaml. Se pueden agregar otros archivos y directorios según sus propias necesidades.

rol con parametros

A continuación se define un rol con parámetros, llamado myrole, y su estructura de directorio es la siguiente

main.yaml
  roles
    myrole
      tasks
        main.yaml

En roles/myrole/tasks/main.yaml, simplemente use las variables definidas por { { }}

---

- name: use param
  debug: 
   msg="{
    
    { param }}"

Usar rol con parámetros

En main.yaml, puedes usar myrole de la siguiente manera:

---

- hosts: test1
  remote_user: root
  roles:
   - role: myrole
     param: 'Test ansible'
   - role: myrole
     param: 'Test ansible2'

El rol especifica los parámetros predeterminados.

Después de especificar los parámetros predeterminados, si se pasan parámetros al llamar, se usarán los valores de los parámetros pasados. Si no se pasan parámetros al llamar, se usarán los valores de los parámetros predeterminados.

Especificar parámetros predeterminados es muy simple, tome los parámetros anteriores como ejemplo

main.yaml
  roles
    myrole
      tasks
        main.yaml
      defaults
        main.yaml

En roles/myrole/defaults/main.yaml

---

- hosts: test1
  remote_user: root
  roles:
   - role: myrole
   - role: myrole
     param: "I am the value from external"

La diferencia entre variables predeterminadas y variables ordinarias.

En la definición anterior, es posible que tenga curiosidad por saber por qué las variables en la carpeta default y vars se agregan a Play ¿Son diferentes de las anteriores?

default/main.yaml son variables predeterminadas. La prioridad es la más baja entre todas las variables y se utiliza para colocar algunas variables que deben sobrescribirse

Las variables en vars/main.yaml son variables de rol con una prioridad relativamente alta. Algunas variables se colocan y no desean sobrescribirse. Por lo tanto, el nombre del rol generalmente se agrega como prefijo al nombrar las variables. Si se colocan, se puede ser sobrescrito accidentalmente por variables definidas en el Playbook.

task/main.yaml Cómo usar variables, archivos estáticos y plantillas

Las tareas son el núcleo de los Playbooks y los roles. Los roles son una forma de organizar los Playbooks e incluir recursos como tareas, plantillas, variables y archivos. En el rol, el archivo de tareas task/main.yaml es el archivo de entrada, en el que se pueden utilizar recursos como variables, archivos estáticos y plantillas. Aprender a utilizar estos recursos es la clave para escribir roles.

Los recursos en función se pueden dividir en dos categorías:

• Una clase se carga automáticamente y generalmente se coloca en x/*/main.yaml
• El otro tipo debe llamarse explícitamente y normalmente se coloca en x/*/other_but_main.yaml.

Usar variables en x/*/main.yaml

Utilice variables y controladores en x/*/main.yaml

Utilice variables y controladores en x/*/main.yaml como recursos en el mismo Playbook

Utilice archivos en x/{files,template}/

Utilice las variables colocadas aquí como si fueran archivos en el mismo directorio. Requiere que el módulo y el tipo de archivo utilizados coincidan

copiar y escribir corresponden a archivos en el directorio de archivos

la plantilla corresponde al archivo bajo plantillas

Por ejemplo, el directorio del rol x es el siguiente

[root@localhost ansible]# tree myrole/
myrole/
├── files
│   └── index.html
├── tasks
│   └── main.yml
├── templates
│   └── httpd.conf.j2
└── vars
    └── main.yml

Los archivos debajo de los archivos son

<!DOCTYPE html>
<html>
<head>
<title>hello world</title>
</head>
<body>
 hi I am csq
</body>
</html>

Los archivos bajo vars son

---
# http.conf vars
http_port: 9999

Los archivos bajo tareas son

---
- name: Deploy server web
  yum: 
   name: httpd
   state: present
- name: copy index.html
  copy: 
   src: index.html
   dest: /var/www/html/index.html
- name: copy http.conf
  template:
   src: httpd.conf.j2
   dest: /etc/httpd/conf/httpd.conf
- name: service restart
  service:
   name: httpd
   enabled: true
   state: restarted
- name: Release Port
  firewalld:
   port: 9999/tcp
   permanent: true
   state: enabled

Ejecutar este rol

---

- hosts: test1
  remote_user: root
  roles:
   - myrole

Utilice recursos de x/*/other_but_main.yaml

Si el contenido debajo del rol x es más complejo y necesita clasificar más tareas o vars, puede usar archivos distintos de main.yaml. ¿Cómo debo usar tareas o vars de otros archivos? Ansible proporciona dos palabras clave: include e include_vars, que se utilizan para introducir tareas y vars contenidas en otros archivos distintos de main.yaml en la función.

Por ejemplo, en el siguiente rol

myrole/
├── tasks
│   └── main.yml
│   └── http_install.yaml
│   └── http_configure.yaml
│   └── mysql_install.yaml
│   └── mysql_configure.yaml
├── templates
│   └── httpd.conf.j2
│   └── mysql.conf.j2
└── vars
    └── httpd.yaml
    └── mysql.yaml

Luego, en x/*/main.yaml, después de introducir las variables httpd a través de include_var, puedes cargar las tareas en los archivos install.yaml y configure.yaml a través de include.

---
- name: add the os specific varibles
  include_vars: httpd.yaml
- name: install packages
  yum:
   name: {
    
    {
    
    packages}}
   state: present
- include: http_install.yaml
- include: http_configure.yaml

dependencias de roles

La instalación de un Nginx requiere configurar el repositorio yum. Si no desea volver a implementar la función de configurar el repositorio yum en Nginx Playbook, puede resolverlo mediante dependencias de roles. El archivo de definición de dependencia de roles es x/meta/main.yaml. Si el rol x se define como dependiente del rol y, se llamará al rol y antes de que se llame al rol x en el Playbook. Cuando varios roles dependen del mismo rol, Ansible filtrará automáticamente para evitar llamar repetidamente a roles con los mismos parámetros.

En el siguiente ejemplo, tanto la función db como Web dependen de la función común. Si se llama a db y Web en el Playbook, Ansible se asegurará de que el rol común se ejecute primero y solo una vez antes de ejecutar el rol db y Web.

playbook.yaml
roles
├── common
│   └── tasks
│       └── main.yaml
├── db
│   ├── meta
│   │   └── main.yaml
│   └── tasks
│       └── main.yaml
└── web
    ├── meta
    │   └── main.yaml
    └── tasks
        └── main.yaml

Agregue {web,db}/meta/main.yaml

dependencies:
- {
    
     role: common }

El contenido de main.yaml a continuación común es

- name: xiugai quanxian
  command: chattr -a csq.txt

El contenido de main.yaml debajo de la web es

- name: shuru xinxi
  shell: echo "I am web,hi csq" >> csq.txt
- name: jia quanxian
  command: chattr +a csq.txt

El contenido de main.yaml debajo de db es

- name: shuru xinxi
  shell: echo "I am db,hi csq" >> csq.txt
- name: jia quanxian
  command: chattr +a csq.txt

El contenido de playbook.yaml es

---

- hosts: test1
  remote_user: root
  roles:
   - common
   - db
   - web

Resultados de la

[root@localhost ansible]# ansible-playbook main.yaml 

PLAY [test1] ***********************************************************************************************************************************************

TASK [Gathering Facts] *************************************************************************************************************************************
ok: [192.168.200.30]

TASK [common : xiugai quanxian] ****************************************************************************************************************************
changed: [192.168.200.30]

TASK [db : shuru xinxi] ************************************************************************************************************************************
changed: [192.168.200.30]

TASK [db : jia quanxian] ***********************************************************************************************************************************
changed: [192.168.200.30]

TASK [web : shuru xinxi] ***********************************************************************************************************************************
changed: [192.168.200.30]

TASK [web : jia quanxian] **********************************************************************************************************************************
changed: [192.168.200.30]

PLAY RECAP *************************************************************************************************************************************************
192.168.200.30             : ok=6    changed=5    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0   

Luego verifique si el contenido del host remoto ha cambiado y si los permisos ocultos todavía están ahí.

[root@localhost ansible]# ansible test1 -m shell -a "cat csq.txt &&  lsattr  csq.txt"
192.168.200.30 | CHANGED | rc=0 >>
I am web,hi csq
I am web,hi csq
-----a---------- csq.txt