8 Schritte zur Entwicklung einer Ansible-Rolle in Linux

Im Artikel How to use Ansible to configure Vim habe ich ein Ansible-Playbook entwickelt, um eine anfängliche Vim-Umgebung mit einigen Vim-Plug-ins zu konfigurieren. In diesem aktuellen Artikel baue ich auf dem vorherigen Beispiel auf, indem ich das Playbook in eine Ansible-Rolle umwandele.

Mit Ansible-Rollen können Sie wiederverwendbare Automatisierungskomponenten entwickeln, indem Sie zugehörige Automatisierungsartefakte wie Konfigurationsdateien, Vorlagen, Aufgaben und Handler gruppieren und kapseln. Da Rollen diese Komponenten isolieren, ist es einfacher, sie wiederzuverwenden und für andere Personen freizugeben. Sie können Ihre Rollen auch konfigurierbar machen, indem Sie Variablen verfügbar machen, die Benutzer beim Aufrufen der Rolle festlegen können, sodass sie ihr System gemäß den spezifischen Anforderungen konfigurieren können.

[Das könnte Ihnen auch gefallen: Die vier Dinge, die Sie in Vim können müssen]

In diesem Artikel konvertiere ich das ursprüngliche Playbook vim-config.yaml in eine wiederverwendbare Rolle. Zu diesem Zeitpunkt werde ich keine neuen Funktionen hinzufügen, aber ich werde dieses Beispiel im nächsten Artikel weiter ausbauen. Sie können das ursprüngliche Playbook und vimrc finden Konfigurationsdatei hier.

1. Beginn einer neuen Rolle

Um eine Ansible-Rolle zu erstellen, reicht es aus, ein Verzeichnis zu erstellen, das der in der offiziellen Dokumentation dokumentierten Standardverzeichnisstruktur folgt.

Um es einfacher zu machen und dem Standard zu folgen, verwenden Sie die ansible-galaxy role init role_name  Befehl, um dieses Verzeichnis für Sie zu erstellen. Dieser Befehl erstellt die erforderliche Struktur, einschließlich einiger Vorlagen für die Dokumentation, die Sie aktualisieren können. Verwenden Sie es, um den vim zu initialisieren Rolle unter roles Verzeichnis. Erstellen Sie zuerst die roles Verzeichnis und wechseln Sie dorthin:

$ mkdir roles
$ cd roles

Verwenden Sie dann den Befehl ansible-galaxy um die Rolle zu initialisieren:

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

Überprüfen Sie nun die Rollenverzeichnisstruktur:

$ 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

Obwohl dies für das Funktionieren der Rolle nicht erforderlich ist, wird dringend empfohlen, Ihre Rolle zu dokumentieren, indem Sie die Dateien README.md aktualisieren und meta/main.yml . Wenn Ihre Rolle von anderen auszuführenden Rollen abhängt, ist es wichtig, diese Abhängigkeiten in meta/main.yml zu dokumentieren , sodass Ansible sie bei Bedarf automatisch herunterladen kann.

Wechseln Sie in das neu erstellte Verzeichnis:

$ cd vim

Ihre Vim-Rolle erfordert keine Abhängigkeiten. Hier ist ein Beispiel für eine funktionierende Meta-Konfigurationsdatei. Aktualisieren Sie es gegebenenfalls mit Ihrem Namen, Firmennamen und einer geeigneten Lizenz:

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

Die Originaldatei enthält zusätzliche Kommentare, die ich der Kürze halber entfernt habe.

Definieren Sie als Nächstes die auszuführenden Aufgaben.

2. Aufgaben definieren

Im Allgemeinen führt Ihre Rolle eine oder mehrere Aufgaben aus, um das Zielsystem gemäß den Anforderungen der Rolle zu konfigurieren. In diesem Fall sollten Sie Vim installieren und konfigurieren. Wenn Sie eine Rolle ausführen, sucht sie standardmäßig nach einer Datei namens main.yml in den tasks Unterverzeichnis und führen Sie alle darin aufgeführten Aufgaben aus. Sie können die Aufgaben für komplexere Rollen in mehrere Dateien aufteilen und sie von main.yml aufrufen mit den include_tasks oder import_tasks Module.

Fügen Sie für diese Rolle alle erforderlichen Aufgaben in tasks/main.yml ein Datei:

$ 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

Beachten Sie, dass Sie im Gegensatz zum ursprünglichen Playbook die Liste der zu installierenden Pakete oder Plug-ins nicht direkt in die Aufgabendefinition aufnehmen. Stattdessen verwenden Sie die Variablen install_packages und plugins .

Indem Sie Variablen definieren, anstatt die Werte fest zu codieren, machen Sie Ihre Rollen wiederverwendbarer und einfacher zu warten. Definieren Sie nun Werte für diese Variablen auf zwei verschiedene Arten. Beginnen Sie mit den plugins Variable, als nächstes behandelt.

3. Standardvariablen definieren

Wenn Sie eine Ansible-Rolle entwickeln, möchten Sie Rollennutzern möglicherweise erlauben, Werte bereitzustellen, um anzupassen, wie die Rolle ihre Aufgaben ausführt. Diese Variablen machen Ihre Rolle besser wiederverwendbar, sodass Benutzer das Ergebnis basierend auf ihren spezifischen Anforderungen ändern können.

Für dieses Beispiel die plugins -Variable ermöglicht es den Benutzern anzugeben, welche Plugins sie mit Vim installieren möchten, wodurch die Rolle flexibel für ihre Bedürfnisse wird. Es wird empfohlen, dafür einen Standardwert in der defaults/main.yml zu definieren Datei, um sicherzustellen, dass die Rollen erfolgreich ausgeführt werden, auch wenn der Benutzer dieser Variablen keinen Wert bereitstellt.

Diese Datei definiert Variablen mit einer sehr niedrigen Priorität, was bedeutet, dass Ansible sie nur verwendet, wenn der Wert nirgendwo anders definiert wurde.

Definieren Sie nun den Standardwert für die plugins Variable wie folgt:

$ 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 diesem Fall definieren Sie den Standardwert mit denselben Werten aus dem ursprünglichen Playbook. Wenn Sie also die Rolle aufrufen, ohne einen Wert für diese Variable anzugeben, verhält sie sich genau wie das ursprüngliche Playbook und installiert diese sechs Plug-ins.

Definieren Sie die internen Variablen.

4. Rollenvariablen definieren

Eine weitere Klasse von Variablen sind Rollenvariablen oder interne Variablen. Indem Sie diese Variablen in einer von den Aufgaben getrennten Datei definieren, erleichtern Sie die Wartung Ihrer Rolle. Sie können diese Variablen an vielen Stellen wiederverwenden, und es ist einfacher, sie an einer zentralen Stelle zu aktualisieren. Sie möchten es Benutzern jedoch nicht zu einfach machen, sie zu überschreiben, indem Sie sie an allgemeinen Orten wie dem Playbook oder dem Inventar festlegen.

Die Variablen install_packages , das eine Liste der erforderlichen zu installierenden Pakete definiert, und vimrc , die den Ort der Konfigurationsdatei von Vim angeben, sind gute Beispiele für interne Variablen. Definieren Sie sie in vars/main.yml . Diese Datei definiert Variablen mit höherer Priorität, die nicht einfach überschrieben werden können. Nutzer können bei Bedarf weiterhin Werte bereitstellen, indem sie diese beim Aufrufen der Rolle explizit festlegen, aber in diesem Fall können Sie davon ausgehen, dass sie wissen, was sie tun.

$ 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

Weitere Einzelheiten zur Funktionsweise der Ansible-Variablenpriorität finden Sie unter Grundlegendes zur Variablenpriorität in der Dokumentation.

5. Kopieren von Dateien

Der letzte Schritt zum Erstellen dieser Rolle besteht darin, die Datei vimrc zu kopieren zu den files Verzeichnis. Standardmäßig bei Verwendung von copy Modul als Rollenaufgabe, sucht es nach Dateien, die in files kopiert werden sollen Unterverzeichnis. Definieren Sie den vimrc Datei wie folgt:

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

Speichern und schließen Sie die Datei, um Ihre Rolle abzuschließen. Jetzt ist es an der Zeit, das Playbook für die Verwendung der Rolle zu definieren.

6. Aufrufen der Rolle aus einem Playbook

Jetzt, da Ihre Rolle vollständig ist, können Sie sie aus Ihren Playbooks aufrufen. Standardmäßig sucht Ansible nach Rollen in den roles Unterverzeichnis relativ zur Playbook-Datei oder zum Systemverzeichnis /etc/ansible/roles . Sie können auch die Ansible-Konfiguration roles_path verwenden um alternative Rollenstandorte zu definieren.

Erstellen Sie für dieses Beispiel ein Playbook in demselben Verzeichnis, in dem Sie die roles erstellt haben Verzeichnis. Wechseln Sie dazu:

$ cd ../..
$ ls
roles

Erstellen Sie das Playbook vim-config.yaml , ähnlich dem ursprünglichen Playbook, aber dieses Mal, anstatt die Aufgaben zu definieren, verwenden Sie das Modul import_role um Ihr neues vim zu importieren Rolle in das 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

Sie können die Rolle auch mit dem Modul include_role in das Playbook aufnehmen . Auf die Unterschiede zwischen diesen beiden Modulen gehe ich in einem separaten Artikel ein. Wenn Sie nicht warten können, überprüfen Sie die Dokumentation.

Führen Sie schließlich das Playbook aus.

8. Führen Sie das Playbook aus

Führen Sie das Playbook mit dem ansible-playbook aus Befehl mit dem -K Parameter und geben Sie Ihren sudo ein Passwort, damit Ansible Systempakete installieren kann.

Hinweis :Sichern Sie alle vorhandenen .vimrc Konfigurationsdatei, bevor Sie dieses Playbook ausführen.

$ 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   

Dieses Playbook läuft und führt alle Aufgaben im localhost aus. Wenn Sie ein Remote-System konfigurieren möchten, erstellen Sie eine Inventardatei mit den gewünschten Systemen und aktualisieren Sie das Playbook hosts Liste.

[ Suchen Sie nach mehr Informationen zur Systemautomatisierung? Beginnen Sie mit The Automated Enterprise, einem kostenlosen Buch von Red Hat. ] 

Abschluss

Jetzt haben Sie eine Rolle, die Vim installiert und konfiguriert, die Sie wiederverwenden und freigeben können. Im nächsten Artikel dieser Serie werde ich diese Rolle verbessern, indem ich eine Vorlagendatei hinzufüge, um die Konfiguration noch flexibler zu gestalten.

Sie können Molecule auch verwenden, um Ihre Rollen mithilfe von Containern oder virtuellen Maschinen zu testen. Wenn Sie mehr über dieses Tool erfahren möchten, lesen Sie meinen Artikel Developing and Testing Ansible Roles with Molecule and Podman – Part 1 im offiziellen Ansible-Blog.

Weitere Informationen zu Ansible finden Sie in der offiziellen Dokumentation.