Dans l'article Comment utiliser Ansible pour configurer Vim, j'ai développé un playbook Ansible pour configurer un environnement Vim initial à l'aide de quelques plugins Vim. Dans cet article actuel, je continue à m'appuyer sur l'exemple précédent en convertissant le playbook en un rôle Ansible.
Les rôles Ansible vous permettent de développer des composants d'automatisation réutilisables en regroupant et en encapsulant des artefacts d'automatisation associés, tels que des fichiers de configuration, des modèles, des tâches et des gestionnaires. Étant donné que les rôles isolent ces composants, il est plus facile de les réutiliser et de les partager avec d'autres personnes. Vous pouvez également rendre vos rôles configurables en exposant des variables que les utilisateurs peuvent définir lors de l'appel du rôle, leur permettant de configurer leur système en fonction d'exigences spécifiques.
[ Vous pourriez également aimer : Les quatre choses que vous devez savoir faire dans Vim ]
Dans cet article, je convertis le playbook original vim-config.yaml dans un rôle réutilisable. Pour le moment, je n'ajouterai aucune nouvelle fonctionnalité, mais je développerai cet exemple dans le prochain article. Vous pouvez trouver le playbook original et vimrc fichier de configuration ici.
1. Commencer un nouveau rôle
Pour créer un rôle Ansible, il suffit de créer un répertoire suivant la structure de répertoire standard documentée dans la documentation officielle.
Pour faciliter les choses et suivre la norme, utilisez le ansible-galaxy role init role_name commande pour créer ce répertoire pour vous. Cette commande crée la structure requise, y compris quelques modèles de documentation que vous pouvez mettre à jour. Utilisez-le pour initialiser le vim rôle sous les roles annuaire. Tout d'abord, créez les roles répertoire et basculez-y :
$ mkdir roles
$ cd roles
Ensuite, utilisez la commande ansible-galaxy pour initialiser le rôle :
$ ansible-galaxy role init vim
- Role vim was created successfully Maintenant, vérifiez la structure du répertoire des rôles :
$ 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
Bien que cela ne soit pas obligatoire pour que le rôle fonctionne, il est fortement recommandé de documenter votre rôle en mettant à jour les fichiers README.md et meta/main.yml . Si votre rôle dépend d'autres rôles à exécuter, il est important de documenter ces dépendances dans meta/main.yml , permettant à Ansible de les télécharger automatiquement si nécessaire.
Basculez dans le répertoire nouvellement créé :
$ cd vim Votre rôle Vim ne nécessite aucune dépendance. Voici un exemple de fichier de méta-configuration fonctionnel. Mettez-le à jour avec votre nom, le nom de votre entreprise et une licence appropriée, si nécessaire :
$ 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: [] Le fichier d'origine contient des commentaires supplémentaires, que j'ai supprimés par souci de brièveté.
Ensuite, définissez les tâches à exécuter.
2. Définition des tâches
De manière générale, votre rôle exécutera une ou plusieurs tâches pour configurer le système cible en fonction des exigences du rôle. Dans ce cas, vous devrez installer et configurer Vim. Par défaut, lorsque vous exécutez un rôle, il recherche un fichier nommé main.yml dans les tasks sous-répertoire et exécutez toutes les tâches qui y sont répertoriées. Vous pouvez diviser les tâches en plusieurs fichiers pour des rôles plus complexes et les appeler depuis main.yml en utilisant les include_tasks ou import_tasks modules.
Pour ce rôle, incluez toutes les tâches requises dans le tasks/main.yml fichier :
$ 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
Notez que, contrairement au playbook d'origine, vous n'incluez pas la liste des packages ou des plugins à installer directement avec la définition de la tâche. Au lieu de cela, vous utilisez les variables install_packages et plugins .
En définissant des variables au lieu de coder en dur les valeurs, vous rendez vos rôles plus réutilisables et plus faciles à gérer. Maintenant, définissez les valeurs de ces variables de deux manières différentes. Commencez avec les plugins variable, couvert ensuite.
3. Définition des variables par défaut
Lorsque vous développez un rôle Ansible, vous pouvez autoriser les utilisateurs du rôle à fournir des valeurs pour personnaliser la manière dont le rôle exécute ses tâches. Ces variables rendent votre rôle plus réutilisable, permettant aux utilisateurs de modifier le résultat en fonction de leurs besoins spécifiques.
Pour cet exemple, les plugins La variable permet aux utilisateurs de spécifier les plugins qu'ils souhaitent installer avec Vim, ce qui rend le rôle flexible pour leurs besoins. Il est recommandé de lui définir une valeur par défaut dans le defaults/main.yml file pour s'assurer que les rôles s'exécutent correctement même si l'utilisateur ne fournit pas de valeur à cette variable.
Ce fichier définit des variables avec une priorité très faible, ce qui signifie qu'Ansible ne les utilisera que si la valeur n'a été définie nulle part ailleurs.
Maintenant, définissez la valeur par défaut pour les plugins variable comme ceci :
$ 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 Dans ce cas, vous définissez la valeur par défaut en utilisant les mêmes valeurs du playbook d'origine, ce qui signifie que si vous appelez le rôle sans fournir de valeur pour cette variable, il se comportera exactement comme le playbook d'origine, en installant ces six plugins.
Définissez les variables internes.
4. Définition des variables de rôle
Une autre classe de variables est celle des variables de rôle ou des variables internes. En définissant ces variables dans un fichier séparé des tâches, vous facilitez la maintenance de votre rôle. Vous pouvez réutiliser ces variables à de nombreux endroits et il est plus facile de les mettre à jour dans un emplacement central. Cependant, vous ne voulez pas qu'il soit trop facile pour les utilisateurs de les remplacer en les définissant dans des emplacements généraux tels que le playbook ou l'inventaire.
Les variables install_packages , qui définit une liste des packages requis à installer, et vimrc , qui spécifie l'emplacement du fichier de configuration de Vim, sont de bons exemples de variables internes. Définissez-les dans vars/main.yml . Ce fichier définit des variables avec une priorité plus élevée qui ne sont pas facilement remplacées. Les utilisateurs peuvent toujours fournir des valeurs si nécessaire en les définissant explicitement lors de l'appel du rôle, mais dans ce cas, vous pouvez supposer qu'ils savent ce qu'ils font.
$ 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 Pour plus de détails sur le fonctionnement de la priorité des variables Ansible, consultez Comprendre la priorité des variables dans la documentation.
5. Copie de fichiers
La dernière étape pour créer ce rôle est de copier le fichier vimrc aux files annuaire. Par défaut, lors de l'utilisation de la copy module en tant que tâche de rôle, il cherchera les fichiers à copier dans les files sous-répertoire. Définir le vimrc fichier comme celui-ci :
$ 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 } } Enregistrez et fermez le fichier pour terminer votre rôle. Il est maintenant temps de définir le playbook pour utiliser le rôle.
6. Appeler le rôle à partir d'un playbook
Maintenant que votre rôle est terminé, vous pouvez l'appeler à partir de vos playbooks. Par défaut, Ansible recherche les rôles dans les roles sous-répertoire relatif au fichier playbook ou au répertoire système /etc/ansible/roles . Vous pouvez également utiliser la configuration Ansible roles_path pour définir des emplacements de rôle alternatifs.
Pour cet exemple, créez un playbook dans le même répertoire où vous avez créé les roles annuaire. Basculez vers celui-ci :
$ cd ../..
$ ls
roles
Créer le playbook vim-config.yaml , similaire au playbook original mais cette fois, au lieu de définir les tâches, utilisez le module import_role pour importer votre nouveau vim rôle dans le 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
Vous pouvez également inclure le rôle dans le playbook à l'aide du module include_role . Je discuterai des différences entre ces deux modules dans un article séparé. Si vous ne pouvez pas attendre, consultez la documentation.
Enfin, exécutez le playbook.
8. Exécuter le playbook
Exécutez le playbook en utilisant le ansible-playbook commande avec le -K paramètre et tapez votre sudo mot de passe pour autoriser Ansible à installer les packages système.
Remarque :Sauvegardez tout fichier .vimrc existant fichier de configuration avant d'exécuter ce 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
Ce playbook exécute et exécute toutes les tâches dans l'hôte local. Si vous souhaitez configurer un système distant, créez un fichier d'inventaire avec les systèmes souhaités et mettez à jour le playbook hosts liste.
[ Vous souhaitez en savoir plus sur l'automatisation du système ? Démarrez avec The Automated Enterprise, un livre gratuit de Red Hat. ]
Récapitulez
Vous avez maintenant un rôle qui installe et configure Vim que vous pouvez réutiliser et partager. Dans le prochain article de cette série, j'améliorerai ce rôle en ajoutant un fichier modèle pour rendre la configuration encore plus flexible.
Vous pouvez également utiliser Molecule pour tester vos rôles à l'aide de conteneurs ou de machines virtuelles. Si vous souhaitez en savoir plus sur cet outil, lisez mon article Développer et tester des rôles Ansible avec Molecule et Podman - Partie 1 sur le blog officiel d'Ansible.
Pour plus d'informations sur Ansible, consultez la documentation officielle.