Nell'articolo I primi cinque plug-in Vim per amministratori di sistema, ho trattato cinque plug-in più un bonus che semplificano la vita agli amministratori di sistema quando utilizzano Vim. Questo articolo approfondirà questo aspetto sviluppando un playbook Ansible per configurare un ambiente Vim iniziale utilizzando quei plug-in.
Questo playbook funziona sul sistema Fedora Linux ma dovrebbe funzionare in modo simile con altre distribuzioni apportando piccole modifiche. In ciascuna delle seguenti sezioni, discuteremo delle modifiche necessarie per farlo funzionare su altri sistemi.
Nota :questo playbook sovrascrive un .vimrc esistente file di configurazione, quindi è più utile impostare un nuovo sistema che non ha ancora Vim configurato. Se hai un file di configurazione Vim esistente, esegui il backup prima di eseguire questo playbook.
Per eseguire questo playbook, devi installare Ansible. In Fedora, puoi installare Ansible usando dnf , in questo modo:
$ sudo dnf install -y ansible Per maggiori dettagli sulle opzioni di installazione di Ansible, consulta la Guida all'installazione di Ansible.
1. Avvio del playbook
Crea il file del tuo playbook Ansible vim-config.yaml e modificalo usando il tuo editor di testo preferito. Se non conosci Ansible, controlla questo link al playbook per saperne di più.
$ vi vim-config.yaml [ Potrebbe piacerti anche: Un'introduzione all'editor vi ]
Ora, avvia la definizione del tuo playbook fornendo un nome e l'elenco degli host di destinazione. In questo caso, sceglieremo come target solo il localhost per configurare Vim localmente.
- name: Config Vim with plugins
hosts: localhost
Quindi, imposta gather_facts: yes opzione per raccogliere dati sul tuo sistema. Ti servirà per accedere alle variabili di ambiente nel passaggio successivo:
gather_facts: yes
Infine, imposta l'opzione globale become: no per indicare che, in generale, queste attività non richiedono l'escalation dei privilegi. Imposteremo l'escalation dei privilegi in locale per le singole attività che lo richiedono, come l'installazione di pacchetti di sistema.
become: no Quindi, definisci alcune variabili utili.
2. Definizione delle variabili
La configurazione dei plugin Vim e Vim richiede l'aggiunta di contenuto a $HOME/.vim directory e nella directory $HOME/.vimrc file di configurazione. Per assicurarci di utilizzare questi valori in modo coerente ed evitare di ridigitarli molte volte, definiamo due variabili per memorizzare i loro valori:
vars:
vim_dir: "{{ ansible_env.HOME }}/.vim"
vimrc: "{{ ansible_env.HOME }}/.vimrc"
Nota che stiamo usando ansible_env.HOME variabile fact per recuperare il valore di $HOME variabile d'ambiente. Per ulteriori informazioni sull'ottenimento delle variabili di ambiente, consultare la documentazione.
Ora iniziamo a definire le attività eseguite dal playbook.
3. Installazione dei pacchetti richiesti
Il passaggio successivo nella creazione di un playbook è la definizione delle attività che verranno eseguite dal playbook. Inizia fornendo le tasks: parametro playbook:
tasks:
Poiché la prima attività consiste nell'installare i pacchetti di sistema richiesti da alcuni dei plug-in Vim che installeremo in seguito. Usa il modulo del pacchetto per installarli e fornisci il parametro become: yes per abilitare l'escalation dei privilegi, necessaria per installare i pacchetti di sistema:
- name: Install required packages
package:
name:
- vim-enhanced
- git
- powerline-fonts
- fzf
state: installed
become: yes
Il package il modulo funziona su diverse distribuzioni, ma i nomi dei pacchetti sono diversi. Questi valori sono validi per Fedora 32. Se stai eseguendo questo playbook in una distribuzione diversa, cambia i nomi dei pacchetti in base ai tuoi requisiti di distribuzione.
Quindi, crea il .vim struttura della directory.
4. Creazione di directory
Utilizzare il modulo file con il parametro state: directory per creare le directory richieste. Poiché ci sono tre directory, esegui questo modulo in un ciclo per crearle tutte con un'unica attività:
- 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"
Nota che stiamo usando vim_dir variabile che abbiamo definito in precedenza per rappresentare il .vim directory. Stiamo usando la sintassi Jinja2 {{ vim_dir }} .
Ora che le directory sono a posto, devi scaricare Pathogen.
5. Download dell'agente patogeno
Per questo esempio, usiamo Vim-Pathogen come gestore di plugin Vim. Per installarlo utilizzando Ansible, applica il modulo get_url per scaricare il file del plug-in direttamente nella sua directory di destinazione:
- name: Ensure Pathogen is in place
get_url:
dest: "{{ vim_dir }}/autoload/pathogen.vim"
url: https://tpo.pe/pathogen.vim Quindi, distribuisci i plug-in richiesti.
6. Distribuzione di plug-in da Git
Una volta installato Pathogen, utilizziamo il modulo git per distribuire i plugin richiesti clonando il loro repository GitHub nella directory di destinazione. Simile alla creazione di directory, usa un ciclo per clonare tutti i repository con una singola attività:
- name: Deploy plugins
git:
dest: "{{ vim_dir }}/bundle/{{ item.name }}"
repo: "{{ item.url }}"
clone: yes
update: yes
recursive: no
loop:
- 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
Si noti che stiamo utilizzando un elenco di dizionari come input per il ciclo e utilizzando i loro valori con la sintassi {{ item.KEY }} dove richiesto come input per i parametri del modulo.
Quindi, copia un file di configurazione di base per Vim.
7. Copia del file di configurazione iniziale
Come compito finale, usa il modulo di copia per copiare un file di configurazione di base per Vim. Innanzitutto, crea il file di configurazione in una sottodirectory files :
$ mkdir files
$ 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 } }
Quindi, usa il copy modulo per copiare il file nella destinazione di destinazione:
- name: Ensure .vimrc config in place
copy:
src: vimrc
dest: "{{ vimrc }}"
backup: yes
mode: 0640
Nota che non è necessario specificare la directory files nel src il percorso. Per impostazione predefinita, Ansible cerca i file da copiare in questa sottodirectory.
Infine, esegui il playbook.
8. Mettere tutto insieme
Il tuo playbook è finito. Per riferimento, ecco il playbook completo:
- name: Config Vim with plugins
hosts: localhost
gather_facts: yes
become: no
vars:
vim_dir: "{{ ansible_env.HOME }}/.vim"
vimrc: "{{ ansible_env.HOME }}/.vimrc"
tasks:
- name: Install required packages
package:
name:
- vim-enhanced
- git
- powerline-fonts
- fzf
state: installed
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:
- 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
- name: Ensure .vimrc config in place
copy:
src: vimrc
dest: "{{ vimrc }}"
backup: yes
mode: 0640 Ora salva il file, quindi chiudi l'editor di testo.
Esegui il playbook utilizzando ansible-playbook comando e il nome del playbook. Poiché questo playbook ha come target il localhost solo, un inventario non è strettamente richiesto. Puoi ancora crearne uno. Inoltre, poiché una delle attività richiede l'escalation dei privilegi, fornisci il parametro -K per digitare il tuo sudo password, consentendo ad Ansible di eseguire tali attività.
Nota :Backup di un .vimrc esistente file di configurazione prima di eseguire questo playbook.
$ ansible-playbook -K vim-config.yaml
BECOME password:
PLAY [Config Vim with plugins] *************************************
TASK [Gathering Facts] *********************************************
ok: [localhost]
TASK [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 [Ensure Pathogen is in place] *********************************
changed: [localhost]
TASK [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.c
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=5 changed=5 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
Ora puoi testare la tua nuova configurazione Vim eseguendo vim :
[ Hai bisogno di più su Ansible? Partecipa a un corso di panoramica tecnica gratuito di Red Hat. Ansible Essentials:Semplicità nell'automazione Panoramica tecnica. ]
Cosa c'è dopo?
Hai creato un playbook per automatizzare la distribuzione di una configurazione Vim di base con sei utili plugin per gli amministratori di sistema. Se desideri utilizzare lo stesso playbook per distribuire plug-in aggiuntivi, aggiungili all'elenco dei loop in Deploy plugins compiti. Inoltre, aggiungi tutti i pacchetti di sistema richiesti a Install required packages compiti.
Usando questo playbook, puoi distribuire e aggiornare rapidamente la tua configurazione Vim usando i principi Infrastructure as Code.
Per ulteriori informazioni su Ansible, consulta la sua documentazione ufficiale.