Wie man Ansible verwendet, um Vim zu konfigurieren

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.