Im Artikel Die fünf besten Vim-Plug-ins für Systemadministratoren habe ich fünf Plug-ins plus einen Bonus behandelt, die Systemadministratoren das Leben bei der Verwendung von Vim erleichtern. Dieser Artikel erweitert dies, indem er ein Ansible-Playbook entwickelt, um eine anfängliche Vim-Umgebung mit diesen Plugins zu konfigurieren.
Dieses Playbook funktioniert auf dem Fedora-Linux-System, sollte aber ähnlich mit anderen Distributionen funktionieren, indem kleine Änderungen vorgenommen werden. In jedem der folgenden Abschnitte besprechen wir die Änderungen, die erforderlich sind, damit es auf anderen Systemen funktioniert.
Hinweis :Dieses Playbook überschreibt eine vorhandene .vimrc
Konfigurationsdatei, daher ist es sinnvoller, ein neues System einzurichten, auf dem Vim noch nicht konfiguriert ist. Wenn Sie eine vorhandene Vim-Konfigurationsdatei haben, sichern Sie sie, bevor Sie dieses Playbook ausführen.
Um dieses Playbook auszuführen, müssen Sie Ansible installieren. In Fedora können Sie Ansible mit dnf
installieren , etwa so:
$ sudo dnf install -y ansible
Weitere Einzelheiten zu Ansible-Installationsoptionen finden Sie im Ansible-Installationshandbuch.
1. Playbook starten
Erstellen Sie Ihre Ansible-Playbook-Datei vim-config.yaml
und bearbeiten Sie es mit Ihrem bevorzugten Texteditor. Wenn Sie neu bei Ansible sind, sehen Sie sich diesen Playbook-Link an, um mehr darüber zu erfahren.
$ vi vim-config.yaml
[ Das könnte Ihnen auch gefallen:Eine Einführung in den vi-Editor ]
Starten Sie nun Ihre Playbook-Definition, indem Sie einen Namen und die Liste der Zielhosts angeben. In diesem Fall zielen wir nur auf den localhost
ab um Vim lokal zu konfigurieren.
- name: Config Vim with plugins
hosts: localhost
Als nächstes setzen Sie gather_facts: yes
Möglichkeit, Fakten über Ihr System zu sammeln. Diese benötigen Sie, um im nächsten Schritt auf die Umgebungsvariablen zugreifen zu können:
gather_facts: yes
Setzen Sie abschließend die globale Option become: no
um darauf hinzuweisen, dass diese Aufgaben im Allgemeinen keine Rechteausweitung erfordern. Wir richten die Privilegienausweitung lokal für einzelne Aufgaben ein, die dies erfordern, wie z. B. das Installieren von Systempaketen.
become: no
Definieren Sie als Nächstes einige nützliche Variablen.
2. Variablen definieren
Das Konfigurieren von Vim und Vim-Plugins erfordert das Hinzufügen von Inhalten zu $HOME/.vim
Verzeichnis und in das Verzeichnis $HOME/.vimrc
Konfigurationsdatei. Um sicherzustellen, dass wir diese Werte konsistent verwenden und vermeiden, dass sie viele Male neu eingegeben werden, definieren wir zwei Variablen zum Speichern ihrer Werte:
vars:
vim_dir: "{{ ansible_env.HOME }}/.vim"
vimrc: "{{ ansible_env.HOME }}/.vimrc"
Beachten Sie, dass wir ansible_env.HOME
verwenden fact-Variable, um den Wert von $HOME
abzurufen Umgebungsvariable. Weitere Informationen zum Abrufen von Umgebungsvariablen finden Sie in der Dokumentation.
Beginnen wir nun damit, die Aufgaben zu definieren, die das Playbook ausführt.
3. Erforderliche Pakete installieren
Der nächste Schritt beim Erstellen eines Playbooks ist das Definieren der Aufgaben, die das Playbook ausführen wird. Beginnen Sie mit der Bereitstellung der tasks:
Playbook-Parameter:
tasks:
Da die erste Aufgabe darin besteht, Systempakete zu installieren, die von einigen der Vim-Plug-ins benötigt werden, die wir später installieren werden. Verwenden Sie das Paketmodul, um sie zu installieren, und geben Sie den Parameter become: yes
an So aktivieren Sie die Rechteausweitung, die zum Installieren von Systempaketen erforderlich ist:
- name: Install required packages
package:
name:
- vim-enhanced
- git
- powerline-fonts
- fzf
state: installed
become: yes
Das package
Das Modul funktioniert über verschiedene Distributionen hinweg, aber die Paketnamen sind unterschiedlich. Diese Werte gelten für Fedora 32. Wenn Sie dieses Playbook in einer anderen Distribution ausführen, ändern Sie die Paketnamen entsprechend Ihren Distributionsanforderungen.
Erstellen Sie als Nächstes die .vim
Verzeichnisstruktur.
4. Verzeichnisse erstellen
Verwenden Sie das Dateimodul mit dem Parameter state: directory
um die erforderlichen Verzeichnisse zu erstellen. Da es drei Verzeichnisse gibt, führen Sie dieses Modul in einer Schleife aus, um alle mit einer einzigen Aufgabe zu erstellen:
- 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"
Beachten Sie, dass wir vim_dir
verwenden Variable, die wir zuvor definiert haben, um .vim
darzustellen Verzeichnis. Wir verwenden die Jinja2-Syntax {{ vim_dir }}
.
Jetzt, wo die Verzeichnisse vorhanden sind, müssen Sie Pathogen herunterladen.
5. Erreger herunterladen
Lassen Sie uns für dieses Beispiel Vim-Pathogen als Vim-Plugin-Manager verwenden. Um es mit Ansible zu installieren, wenden Sie das get_url-Modul an, um die Plugin-Datei direkt in ihr Zielverzeichnis herunterzuladen:
- name: Ensure Pathogen is in place
get_url:
dest: "{{ vim_dir }}/autoload/pathogen.vim"
url: https://tpo.pe/pathogen.vim
Stellen Sie als Nächstes die erforderlichen Plugins bereit.
6. Bereitstellen von Plugins von Git
Sobald Pathogen installiert ist, verwenden wir das Git-Modul, um die erforderlichen Plugins bereitzustellen, indem wir ihr GitHub-Repository in das Zielverzeichnis klonen. Verwenden Sie ähnlich wie beim Erstellen von Verzeichnissen eine Schleife, um alle Repositories mit einer einzigen Aufgabe zu klonen:
- 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
Beachten Sie, dass wir eine Liste von Wörterbüchern als Eingabe für die Schleife verwenden und ihre Werte mit der Syntax {{ item.KEY }}
verwenden ggf. als Input für die Modulparameter.
Als nächstes kopieren Sie eine grundlegende Konfigurationsdatei für Vim.
7. Kopieren der anfänglichen Konfigurationsdatei
Verwenden Sie als letzte Aufgabe das Kopiermodul, um eine grundlegende Konfigurationsdatei für Vim zu kopieren. Erstellen Sie zunächst die Konfigurationsdatei in einem Unterverzeichnis 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 } }
Verwenden Sie dann die copy
Modul, um die Datei an den Zielort zu kopieren:
- name: Ensure .vimrc config in place
copy:
src: vimrc
dest: "{{ vimrc }}"
backup: yes
mode: 0640
Beachten Sie, dass Sie das Verzeichnis files
nicht angeben müssen im src
Weg. Standardmäßig sucht Ansible in diesem Unterverzeichnis nach zu kopierenden Dateien.
Führen Sie schließlich das Playbook aus.
8. Alles zusammenfügen
Ihr Playbook ist fertig. Als Referenz finden Sie hier das vollständige Playbook:
- 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
Speichern Sie jetzt Ihre Datei und schließen Sie dann den Texteditor.
Führen Sie das Playbook mit dem ansible-playbook
aus Befehl und den Namen des Playbooks. Da dieses Playbook auf localhost
abzielt Nur ist eine Bestandsaufnahme nicht unbedingt erforderlich. Sie können immer noch eine erstellen. Da für eine der Aufgaben eine Rechteausweitung erforderlich ist, geben Sie außerdem den Parameter -K
an um Ihr sudo
einzugeben Passwort, damit Ansible diese Aufgaben ausführen kann.
Hinweis :Sichern Sie eine vorhandene .vimrc
Konfigurationsdatei, bevor Sie dieses Playbook ausführen.
$ 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
Sie können jetzt Ihre neue Vim-Konfiguration testen, indem Sie vim
ausführen :
[ Brauchen Sie mehr zu Ansible? Nehmen Sie an einem kostenlosen technischen Überblickskurs von Red Hat teil. Ansible Essentials:Einfachheit in der Automatisierung Technischer Überblick. ]
Was kommt als nächstes?
Sie haben ein Playbook erstellt, um die Bereitstellung einer grundlegenden Vim-Konfiguration mit sechs nützlichen Plugins für Systemadministratoren zu automatisieren. Wenn Sie dasselbe Playbook verwenden möchten, um zusätzliche Plugins bereitzustellen, fügen Sie sie der Schleifenliste im Abschnitt Deploy plugins
hinzu Aufgaben. Fügen Sie außerdem alle erforderlichen Systempakete zu Install required packages
hinzu Aufgaben.
Mithilfe dieses Playbooks können Sie Ihre Vim-Konfiguration unter Verwendung von Infrastructure-as-Code-Prinzipien schnell bereitstellen und aktualisieren.
Weitere Informationen zu Ansible finden Sie in der offiziellen Dokumentation.