8 passaggi per sviluppare un ruolo Ansible in Linux

Nell'articolo Come utilizzare Ansible per configurare Vim, ho sviluppato un playbook Ansible per configurare un ambiente Vim iniziale utilizzando alcuni plug-in Vim. In questo articolo, continuo a basarmi sull'esempio precedente convertendo il playbook in un ruolo Ansible.

I ruoli Ansible consentono di sviluppare componenti di automazione riutilizzabili raggruppando e incapsulando gli artefatti di automazione correlati, come file di configurazione, modelli, attività e gestori. Poiché i ruoli isolano questi componenti, è più facile riutilizzarli e condividerli con altre persone. Puoi anche rendere configurabili i tuoi ruoli esponendo le variabili che gli utenti possono impostare quando chiamano il ruolo, consentendo loro di configurare il proprio sistema in base a requisiti specifici.

[ Potrebbe piacerti anche: Le quattro cose che devi essere in grado di fare in Vim ]

In questo articolo, converto il playbook originale vim-config.yaml in un ruolo riutilizzabile. Al momento, non aggiungerò alcuna nuova funzionalità, ma amplierò ulteriormente questo esempio nel prossimo articolo. Puoi trovare il playbook originale e vimrc file di configurazione qui.

1. Iniziare un nuovo ruolo

Per creare un ruolo Ansible è sufficiente creare una directory seguendo la struttura di directory standard documentata nella documentazione ufficiale.

Per semplificare e seguire lo standard, usa il ansible-galaxy role init role_name  comando per creare questa directory per te. Questo comando crea la struttura richiesta, inclusi alcuni modelli per la documentazione che puoi aggiornare. Usalo per inizializzare il vim ruolo sotto i roles directory. Innanzitutto, crea i roles directory e passare ad essa:

$ mkdir roles
$ cd roles

Quindi, usa il comando ansible-galaxy per inizializzare il ruolo:

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

Ora verifica la struttura della directory dei ruoli:

$ 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

Sebbene non sia necessario per il funzionamento del ruolo, si consiglia vivamente di documentare il proprio ruolo aggiornando i file README.md e meta/main.yml . Se il tuo ruolo dipende da altri ruoli da eseguire, è importante documentare queste dipendenze in meta/main.yml , consentendo ad Ansible di scaricarli automaticamente se necessario.

Passa alla directory appena creata:

$ cd vim

Il tuo ruolo Vim non richiede alcuna dipendenza. Ecco un esempio di un file di meta configurazione funzionante. Aggiornalo con il tuo nome, ragione sociale e una licenza adeguata, se necessario:

$ 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: []

Il file originale ha commenti aggiuntivi, che ho rimosso per brevità.

Quindi, definisci le attività da eseguire.

2. Definizione delle attività

In generale, il tuo ruolo eseguirà una o più attività per configurare il sistema di destinazione in base ai requisiti del ruolo. In questo caso, ti consigliamo di installare e configurare Vim. Per impostazione predefinita, quando esegui un ruolo, cerca un file denominato main.yml nelle tasks sottodirectory ed eseguire tutte le attività elencate al suo interno. Puoi suddividere le attività in più file per ruoli più complessi e chiamarli da main.yml utilizzando include_tasks o import_tasks moduli.

Per questo ruolo, includi tutte le attività richieste in tasks/main.yml file:

$ 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

Nota che, a differenza del playbook originale, non includi l'elenco di pacchetti o plug-in da installare direttamente con la definizione dell'attività. Invece, stai usando le variabili install_packages e plugins .

Definendo le variabili invece di codificare i valori, rendi i tuoi ruoli più riutilizzabili e più facili da mantenere. Ora, definisci i valori per queste variabili in due modi diversi. Inizia con i plugins variabile, trattato di seguito.

3. Definizione delle variabili predefinite

Quando sviluppi un ruolo Ansible, potresti voler consentire agli utenti del ruolo di fornire valori per personalizzare il modo in cui il ruolo svolge le proprie attività. Queste variabili rendono il tuo ruolo più riutilizzabile, consentendo agli utenti di modificare il risultato in base alle loro esigenze specifiche.

Per questo esempio, i plugins La variabile consente agli utenti di specificare quali plugin vogliono installare con Vim, rendendo il ruolo flessibile per le loro esigenze. Si consiglia di definire un valore predefinito per esso in defaults/main.yml per garantire che i ruoli vengano eseguiti correttamente anche se l'utente non fornisce un valore a questa variabile.

Questo file definisce le variabili con una precedenza molto bassa, il che significa che Ansible le utilizzerà solo nel caso in cui il valore non sia stato definito da nessun'altra parte.

Ora definisci il valore predefinito per i plugins variabile come questa:

$ 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

In questo caso, stai definendo il valore predefinito utilizzando gli stessi valori del playbook originale, il che significa che se chiami il ruolo senza fornire un valore per questa variabile, si comporterà esattamente come il playbook originale, installando questi sei plugin.

Definire le variabili interne.

4. Definizione delle variabili di ruolo

Un'altra classe di variabili sono le variabili ruolo o le variabili interne. Definendo queste variabili in un file separato dalle attività, semplifichi la gestione del tuo ruolo. Puoi riutilizzare queste variabili in molte posizioni ed è più facile aggiornarle in una posizione centrale. Tuttavia, non vuoi rendere troppo facile per gli utenti sovrascriverli impostandoli in posizioni generali come il playbook o l'inventario.

Le variabili install_packages , che definisce un elenco di pacchetti richiesti da installare, e vimrc , che specifica la posizione del file di configurazione di Vim, sono buoni esempi di variabili interne. Definiscili in vars/main.yml . Questo file definisce le variabili con precedenza più alta che non possono essere facilmente sovrascritte. Gli utenti possono comunque fornire valori, se necessario, impostandoli esplicitamente quando chiamano il ruolo, ma in questo caso puoi presumere che sappiano cosa stanno facendo.

$ 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

Per maggiori dettagli su come funziona la precedenza delle variabili Ansible, consulta Comprendere la precedenza delle variabili nella documentazione.

5. Copiare file

L'ultimo passaggio per creare questo ruolo è copiare il file vimrc ai files directory. Per impostazione predefinita, quando si utilizza copy modulo come attività di ruolo, cercherà i file da copiare nei files sottodirectory. Definisci il vimrc file come questo:

$ 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  }  }

Salva e chiudi il file per completare il tuo ruolo. Ora è il momento di definire il playbook per utilizzare il ruolo.

6. Richiamare il ruolo da un playbook

Ora che il tuo ruolo è completo, puoi richiamarlo dai tuoi playbook. Per impostazione predefinita, Ansible cerca i ruoli nei roles sottodirectory relativa al file del playbook o alla directory di sistema /etc/ansible/roles . Puoi anche utilizzare la configurazione Ansible roles_path per definire posizioni di ruolo alternative.

Per questo esempio, crea un playbook nella stessa directory in cui hai creato i roles directory. Passa ad esso:

$ cd ../..
$ ls
roles

Crea il playbook vim-config.yaml , simile al playbook originale ma questa volta, invece di definire le attività, usa il modulo import_role per importare il tuo nuovo vim ruolo nel playbook:

$ 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

Puoi anche includere il ruolo nel playbook usando il modulo include_role . Discuterò le differenze tra questi due moduli in un articolo separato. Se non puoi aspettare, controlla la documentazione.

Infine, esegui il playbook.

8. Esegui il playbook

Esegui il playbook utilizzando ansible-playbook comando con il -K parametro e digita il tuo sudo password per consentire ad Ansible di installare i pacchetti di sistema.

Nota :Effettua il backup di qualsiasi .vimrc esistente file di configurazione prima di eseguire questo playbook.

$ 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   

Questo playbook esegue ed esegue tutte le attività nel localhost. Se desideri configurare un sistema remoto, crea un file di inventario con i sistemi desiderati e aggiorna il playbook hosts elenco.

[ Cerchi ulteriori informazioni sull'automazione dei sistemi? Inizia con The Automated Enterprise, un libro gratuito di Red Hat. ] 

Concludi

Ora hai un ruolo che installa e configura Vim che puoi riutilizzare e condividere. Nel prossimo articolo di questa serie migliorerò questo ruolo aggiungendo un file modello per rendere la configurazione ancora più flessibile.

Puoi anche utilizzare Molecule per testare i tuoi ruoli utilizzando container o macchine virtuali. Se vuoi saperne di più su questo strumento, leggi il mio articolo Developing and Testing Ansible Roles with Molecule and Podman - Part 1 nel blog ufficiale di Ansible.

Per ulteriori informazioni su Ansible, consulta la documentazione ufficiale.