8 pasos para desarrollar un rol de Ansible en Linux

En el artículo Cómo usar Ansible para configurar Vim, desarrollé un Ansible libro de jugadas para configurar un entorno Vim inicial usando algunos complementos de Vim. En este artículo actual, sigo construyendo sobre el ejemplo anterior al convertir el libro de jugadas en un Ansible papel.

Los roles de Ansible le permiten desarrollar componentes de automatización reutilizables al agrupar y encapsular artefactos de automatización relacionados, como archivos de configuración, plantillas, tareas y controladores. Debido a que los roles aíslan estos componentes, es más fácil reutilizarlos y compartirlos con otros. También puede hacer que sus roles sean configurables al exponer las variables que los usuarios pueden establecer al invocar el rol, lo que les permite configurar su sistema según requisitos específicos.

En este artículo, convierto el libro de jugadas original vim-config.yaml en un papel reutilizable. En este momento, no agregaré ninguna función nueva, pero ampliaré este ejemplo en el próximo artículo. Puede encontrar el libro de jugadas original y vimrc archivo de configuración aquí.

Índice

1. Comenzar un nuevo rol

Para crear un rol de Ansible, todo lo que tiene que hacer es crear un directorio siguiendo la estructura de directorios estándar documentada en el documentos oficiales.

Para facilitar las cosas y seguir el estándar, utilice el ansible-galaxy role init role_name comando para crear este directorio para usted. Este comando crea la estructura necesaria, incluidas algunas plantillas de documentación que puede actualizar. Úselo para inicializar el vim papel bajo el roles directorio telefónico. Primero, crea el roles directorio y vaya a él:

$ mkdir roles
$ cd roles

Luego usa el comando ansible-galaxy para inicializar el rol:

$ ansible-galaxy role init vim
- Role vim was created successfully

Ahora verifique la estructura del directorio de roles:

$ tree vim
vim
├── defaults
│   └── main.yml
├── files
├── handlers
│   └── main.yml
├── meta
│   └── main.yml
├── README.md
├── tasks
│   └── main.yml
├── templates
├── tests
│   ├── inventory
│   └── test.yml
└── vars
    └── main.yml

8 directories, 8 files

Si bien esto no es necesario para que la función funcione, se recomienda enfáticamente que documente su función actualizando los archivos. README.md y meta/main.yml. Si su rol depende de otros roles a desempeñar, es importante documentar estas dependencias en meta/main.yml, lo que permite que Ansible los descargue automáticamente si es necesario.

Cambie al directorio recién creado:

$ cd vim

Su rol de Vim no requiere ninguna dependencia. Este es un ejemplo de un archivo de metaconfiguración en funcionamiento. Actualícelo con su nombre, el nombre de la empresa y una licencia adecuada, si es necesario:

$ vim meta/main.yml
galaxy_info:
  author: <YOUR NAME>
  description: Deploy and configure Vim with plugins
  company: <YOUR COMPANY>

  license: MIT

  min_ansible_version: 2.8

  platforms:
  - name: Fedora
    versions:
    - 33

  galaxy_tags: []

dependencies: []

El archivo original contiene comentarios adicionales, que he eliminado por razones de brevedad.

A continuación, defina las tareas a realizar.

2. Definir las tareas

Por lo general, su función realizará una o más tareas para configurar el sistema de destino de acuerdo con los requisitos de la función. En este caso, deberá instalar y configurar Vim. De forma predeterminada, cuando ejecuta un rol, busca un archivo llamado main.yml en el tasks subdirectorio y realizar todas las tareas enumeradas allí. Puede dividir tareas en varios archivos para roles más complejos y llamarlos desde main.yml utilizando el include_tasks Donde import_tasks módulos.

Para este rol, incluya todas las tareas requeridas en el tasks/main.yml archivar:

$ vim tasks/main.yml

---
# tasks file for vim
- name: Install required packages
  package:
    name: "{{ install_packages }}"
    state: present
  become: yes
  tags:
    - install_packages

- name: Ensure .vim/{autoload,bundle} directory exists
  file:
    path: "{{ item }}"
    state: directory
    recurse: no
    mode: 0750
  loop:
    - "{{ vim_dir }}"
    - "{{ vim_dir }}/autoload"
    - "{{ vim_dir }}/bundle"

- name: Ensure Pathogen is in place
  get_url:
    dest: "{{ vim_dir }}/autoload/pathogen.vim"
    url: https://tpo.pe/pathogen.vim

- name: Deploy plugins
  git:
    dest: "{{ vim_dir }}/bundle/{{ item.name }}"
    repo: "{{ item.url }}"
    clone: yes
    update: yes
    recursive: no
  loop: "{{ plugins }}"

- name: Ensure .vimrc config in place
  copy:
    src: vimrc
    dest: "{{ vimrc }}"
    backup: yes
    mode: 0640

Tenga en cuenta que, a diferencia del libro de jugadas original, no incluye la lista de paquetes o complementos para instalar directamente con la definición de la tarea. En su lugar, utiliza las variables install_packages y plugins.

Al definir variables en lugar de codificar valores, hace que sus roles sean más reutilizables y fáciles de administrar. Ahora establezca los valores de estas variables de dos maneras diferentes. Comience con el plugins variable, luego cubierto.

3. Definir las variables por defecto

Cuando desarrolla un rol de Ansible, es posible que desee permitir que los usuarios del rol proporcionen valores para personalizar la forma en que el rol realiza sus tareas. Estas variables hacen que su rol sea más reutilizable, lo que permite a los usuarios modificar el resultado según sus necesidades específicas.

Para este ejemplo, el plugins La variable permite a los usuarios especificar qué complementos desean instalar con Vim, lo que hace que el rol sea flexible para sus necesidades. Se recomienda definir un valor predeterminado para ello en el defaults/main.yml para garantizar que los roles se ejecuten correctamente incluso si el usuario no proporciona un valor para esta variable.

Este archivo establece variables con una prioridad muy baja, lo que significa que Ansible solo las usará si el valor no se ha establecido en otro lugar.

Ahora establezca el valor predeterminado para el plugins variables como esta:

$ vim defaults/main.yml

---
# defaults file for vim
plugins:
  - name: vim-airline
    url: https://github.com/vim-airline/vim-airline
  - name: nerdtree
    url: https://github.com/preservim/nerdtree
  - name: fzf-vim
    url: https://github.com/junegunn/fzf.vim
  - name: vim-gitgutter
    url: https://github.com/airblade/vim-gitgutter
  - name: vim-fugitive
    url: https://github.com/tpope/vim-fugitive
  - name: vim-floaterm
    url: https://github.com/voldikss/vim-floaterm

En este caso, establece el valor predeterminado utilizando los mismos valores que el libro de jugadas original, lo que significa que si llama al rol sin proporcionar un valor para esta variable, se comportará exactamente como el libro de jugadas original, al instalar estos seis complementos. .

Defina las variables internas.

4. Definición de variables de rol

Otra clase de variables son las variables de rol o variables internas. Al definir estas variables en un archivo de tareas separado, facilita la administración de su función. Puede reutilizar estas variables en muchos lugares y es más fácil actualizarlas en una ubicación central. Sin embargo, no desea que sea demasiado fácil para los usuarios anularlos configurándolos en ubicaciones generales como el libro de jugadas o el inventario.

las variables install_packages, que define una lista de paquetes necesarios para instalar, y vimrc, que especifica la ubicación del archivo de configuración de Vim, son buenos ejemplos de variables internas. definirlos en vars/main.yml. Este archivo define variables con una prioridad más alta que no se reemplazan fácilmente. Los usuarios aún pueden proporcionar valores según sea necesario configurándolos explícitamente al llamar al rol, pero en este caso, puede asumir que saben lo que están haciendo.

$ vim vars/main.yml

---
# vars file for vim
vim_dir: "{{ ansible_env.HOME }}/.vim"
vimrc: "{{ ansible_env.HOME }}/.vimrc"
install_packages:
  - vim-enhanced
  - git
  - powerline-fonts
  - fzf

Para obtener más detalles sobre cómo funciona la precedencia de variables de Ansible, consulte Comprender la prioridad de las variables en la documentación.

5. Copiar archivos

El último paso para crear este rol es copiar el archivo vimrc a la files directorio telefónico. De forma predeterminada, cuando utiliza el copy módulo como una tarea de rol, buscará archivos para copiar en el files subcarpeta. Definir el vimrc archivo como este:

$ vim files/vimrc

execute pathogen#infect()
syntax on
filetype plugin indent on

colo darkblue

" Configuration vim Airline
set laststatus=2

let g:airline#extensions#tabline#enabled=1
let g:airline_powerline_fonts=1

" Configuration NERDTree
map <F5> :NERDTreeToggle<CR>

" Configuration floaterm
let g:floaterm_keymap_toggle="<F12>"
let g:floaterm_width = 0.9
let g:floaterm_height = 0.9

" Configuration Vim.FZF
let g:fzf_preview_window = 'right:50%'
let g:fzf_layout = { 'window': { 'width': 0.9, 'height': 0.6  }  }

Guarde y cierre el archivo para completar su función. Ahora es el momento de configurar el libro de jugadas para usar el rol.

6. Recuperar el rol de un libro de jugadas

Ahora que ha terminado su rol, puede llamarlo desde sus libros de jugadas. De forma predeterminada, Ansible busca roles en el roles subdirectorio relativo al archivo del libro de jugadas o al directorio del sistema /etc/ansible/roles. También puede usar la configuración de Ansible roles_path para definir ubicaciones de funciones alternativas.

Para este ejemplo, cree un libro de jugadas en el mismo directorio donde creó el roles directorio telefónico. Enciéndelo:

$ cd ../..
$ ls
roles

Crear el libro de jugadas vim-config.yaml, similar al playbook original pero esta vez en lugar de definir tareas, usa el módulo import_role para importar tu nuevo vim papel en el libro de jugadas:

$ vim vim-config.yaml

- name: Config Vim with plugins
  hosts: localhost
  gather_facts: yes
  become: no

  tasks:
    - name: Configure Vim using role
      import_role:
        name: vim

También puede incluir el rol en el libro de jugadas usando el módulo include_role. Discutiré las diferencias entre estos dos módulos en un artículo separado. Si no puedes esperar, echa un vistazo a la Documentación.

Finalmente, ejecute el libro de jugadas.

8. Ejecute el libro de jugadas

Ejecute el libro de jugadas usando el ansible-playbook ordenar con el -K parámetro y escriba su sudo contraseña para permitir que Ansible instale paquetes del sistema.

Notar: Guardar todos los existentes .vimrc archivo de configuración antes de ejecutar este libro de jugadas.

$ ansible-playbook -K vim-config.yaml
BECOME password: 
[WARNING]: provided hosts list is empty, only localhost is available. Note that the implicit localhost does not match 'all'

PLAY [Config Vim with plugins] ***********************************************

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

TASK [vim : Install required packages] ***************************************
changed: [localhost]

TASK [Ensure .vim/{autoload,bundle} directory exists] ************************
changed: [localhost] => (item=/home/ricardo/.vim)
changed: [localhost] => (item=/home/ricardo/.vim/autoload)
changed: [localhost] => (item=/home/ricardo/.vim/bundle)

TASK [vim : Ensure Pathogen is in place] *************************************
changed: [localhost]

TASK [vim : Deploy plugins] **************************************************
changed: [localhost] => (item={'name': 'vim-airline', 'url': 'https://github.com/vim-airline/vim-airline'})
changed: [localhost] => (item={'name': 'nerdtree', 'url': 'https://github.com/preservim/nerdtree'})
changed: [localhost] => (item={'name': 'fzf-vim', 'url': 'https://github.com/junegunn/fzf.vim'})
changed: [localhost] => (item={'name': 'vim-gitgutter', 'url': 'https://github.com/airblade/vim-gitgutter'})
changed: [localhost] => (item={'name': 'vim-fugitive', 'url': 'https://github.com/tpope/vim-fugitive'})
changed: [localhost] => (item={'name': 'vim-floaterm', 'url': 'https://github.com/voldikss/vim-floaterm'})

TASK [Ensure .vimrc config in place] *****************************************
changed: [localhost]

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

Este libro de jugadas ejecuta y ejecuta todas las tareas en el host local. Si desea configurar un sistema remoto, cree un archivo de inventario con los sistemas deseados y actualice el libro de jugadas hosts listado.

Conclusión

Ahora tiene un rol que instala y configura Vim que puede reutilizar y compartir. En el próximo artículo de esta serie, mejoraré esta función agregando un archivo de plantilla para que la configuración sea aún más flexible.

También puedes usar Molécula para probar sus roles usando contenedores o máquinas virtuales. Si quieres saber más sobre esta herramienta, lee mi artículo Desarrollo y prueba de roles de Ansible con Molecule y Podman - Parte 1 en el blog oficial de Ansible.

Para obtener más información sobre Ansible, consulte la documentos oficiales.

Artículos de interés

Subir