Wstęp

Czy zdarzyło Ci się zarządzać wieloma serwerami i ręcznie konfigurować każdy z nich? Możliwe, że już słyszałeś o narzędziach do automatyzacji, ale nie wiedziałeś od czego zacząć. W tym artykule pokażę Ci, jak rozpocząć przygodę z Ansible - jednym z najpopularniejszych narzędzi do automatyzacji konfiguracji i zarządzania infrastrukturą.

Ansible to potężne narzędzie, które pozwala na zarządzanie wieloma serwerami jednocześnie, bez konieczności instalowania agentów na docelowych maszynach. Wystarczy, że masz dostęp SSH do swoich serwerów, a Ansible zrobi resztę. W moim przypadku, kiedy zarządzałem kilkoma serwerami VPS i musiałem na każdym z nich wykonać te same czynności, Ansible okazał się prawdziwym zbawieniem.

Co to jest Ansible?

Ansible to narzędzie do automatyzacji infrastruktury IT, które pozwala na:

• Konfigurację serwerów - instalację pakietów, konfigurację usług, zarządzanie plikami
• Wdrażanie aplikacji - automatyzację procesu deploymentu
• Orkiestrację - zarządzanie wieloma serwerami jednocześnie
• Zarządzanie konfiguracją - utrzymanie spójności konfiguracji na wielu maszynach

Główną zaletą Ansible jest to, że działa w modelu “agentless” - nie wymaga instalacji żadnego oprogramowania na docelowych serwerach. Wystarczy Python (który jest domyślnie dostępny na większości systemów Linux) i dostęp SSH.

Ansible używa języka YAML do definiowania zadań, co czyni go bardzo czytelnym i łatwym do zrozumienia. Nawet jeśli nie jesteś programistą, po krótkim czasie będziesz w stanie tworzyć własne playbooki.

Po co używać Ansible?

Wyobraź sobie sytuację: masz pięć serwerów i musisz na każdym z nich:

• Zainstalować podstawowe pakiety (curl, git, vim)
• Skonfigurować firewall
• Zainstalować i skonfigurować nginx
• Dodać użytkownika z odpowiednimi uprawnieniami

Bez Ansible, musiałbyś zalogować się na każdy serwer osobno i wykonać te same polecenia pięć razy. Z Ansible, tworzysz jeden plik konfiguracyjny (playbook), który wykonasz raz, a wszystkie serwery zostaną skonfigurowane automatycznie.

Dodatkowe korzyści:

• Idempotencja - możesz uruchomić playbook wielokrotnie, a Ansible upewni się, że stan końcowy jest zawsze taki sam
• Dokumentacja - Twój playbook jest jednocześnie dokumentacją tego, co zostało skonfigurowane
• Wersjonowanie - możesz trzymać konfigurację w Git i śledzić zmiany
• Testowanie - możesz testować konfigurację na środowisku testowym przed wdrożeniem na produkcję

Instalacja Ansible z użyciem pipx

Istnieje kilka sposobów instalacji Ansible. W tym artykule pokażę instalację za pomocą pipx, które jest rekomendowanym sposobem dla użytkowników, którzy chcą mieć Ansible zainstalowany lokalnie, bez wpływu na systemowe pakiety Pythona.

pipx to narzędzie, które instaluje aplikacje Pythona w izolowanych środowiskach, co zapobiega konfliktom zależności. Jeśli nie masz jeszcze pipx zainstalowanego, możesz go zainstalować na Ubuntu/Debian:

# Instalacja pipx na Ubuntu/Debian
sudo apt update
sudo apt install pipx
pipx ensurepath

Po zainstalowaniu pipx, możesz zainstalować Ansible:

# Instalacja Ansible za pomocą pipx
pipx install ansible

Po instalacji, możesz zweryfikować, że Ansible działa poprawnie:

# Sprawdzenie wersji Ansible
ansible --version

Powinieneś zobaczyć coś podobnego do:

ansible [core 2.15.x]
  config file = None
  configured module search path = ['/home/user/.local/share/ansible/plugins/modules']
  ansible python module location = /home/user/.local/pipx/venvs/ansible/lib/python3.x/site-packages/ansible
  ansible collection location = /home/user/.local/share/ansible/collections
  executable location = /home/user/.local/bin/ansible
  python version = 3.x.x
  jinja version = 3.x.x
  libyaml = True

Proponowany układ projektu

Zgodnie z oficjalną dokumentacją Ansible, zalecany jest następujący układ katalogów dla projektu:

ansible-project/
├── ansible.cfg          # Konfiguracja Ansible
├── inventory/           # Definicje hostów
│   ├── hosts.yml        # Plik z definicjami serwerów
│   └── group_vars/      # Zmienne dla grup hostów
│       └── all.yml
├── playbooks/           # Playbooki
│   └── site.yml         # Główny playbook
├── roles/               # Role Ansible
│   ├── common/
│   ├── security/
│   └── nginx/
└── requirements.yml     # Zależności (role z Ansible Galaxy)

Stwórzmy ten katalog krok po kroku:

# Utworzenie struktury katalogów
mkdir -p ansible-project/{inventory/group_vars,playbooks,roles}
cd ansible-project

Następnie stwórzmy podstawowy plik ansible.cfg:

# ansible.cfg
[defaults]
inventory = inventory/hosts.yml
roles_path = roles
host_key_checking = False
retry_files_enabled = False

[privilege_escalation]
become = True
become_method = sudo
become_user = root
become_ask_pass = False

Teraz stwórzmy podstawowy plik inventory inventory/hosts.yml:

# inventory/hosts.yml
all:
  children:
    web:
      hosts:
        web1:
          ansible_host: 192.168.1.10
          ansible_user: ubuntu
        web2:
          ansible_host: 192.168.1.11
          ansible_user: ubuntu
    db:
      hosts:
        db1:
          ansible_host: 192.168.1.20
          ansible_user: ubuntu

Tworzenie roli za pomocą ansible-galaxy init

Role w Ansible to sposób na organizację i ponowne wykorzystanie zadań. Zamiast pisać wszystkie zadania w jednym playbooku, możesz stworzyć role, które można używać w różnych projektach.

Ansible Galaxy to narzędzie, które pomaga w tworzeniu nowych ról. Użyjmy go do stworzenia przykładowej roli common:

# Przejście do katalogu roles
cd roles

# Utworzenie nowej roli za pomocą ansible-galaxy
ansible-galaxy init common

To polecenie utworzy następującą strukturę:

roles/common/
├── defaults/
│   └── main.yml          # Domyślne zmienne roli
├── files/                # Pliki statyczne do kopiowania
├── handlers/
│   └── main.yml          # Handlery (np. restart usługi)
├── meta/
│   └── main.yml          # Metadane roli
├── tasks/
│   └── main.yml          # Główne zadania roli
├── templates/            # Szablony Jinja2
├── tests/
│   ├── inventory
│   └── test.yml
└── vars/
    └── main.yml          # Zmienne roli (wyższy priorytet niż defaults)

Teraz stwórzmy prostą rolę common, która zainstaluje podstawowe pakiety. Edytujmy plik roles/common/tasks/main.yml:

# roles/common/tasks/main.yml
---
- name: Update apt cache
  apt:
    update_cache: yes
    cache_valid_time: 3600

- name: Install basic packages
  apt:
    name:
      - curl
      - git
      - vim
      - htop
      - wget
    state: present

- name: Ensure timezone is set to Europe/Warsaw
  timezone:
    name: Europe/Warsaw

Możemy również zdefiniować zmienne w roles/common/defaults/main.yml:

# roles/common/defaults/main.yml
---
common_packages:
  - curl
  - git
  - vim
  - htop
  - wget

timezone: Europe/Warsaw

I zaktualizować tasks/main.yml, aby używał tych zmiennych:

# roles/common/tasks/main.yml
---
- name: Update apt cache
  apt:
    update_cache: yes
    cache_valid_time: 3600

- name: Install basic packages
  apt:
    name: "{{ common_packages }}"
    state: present

- name: Ensure timezone is set
  timezone:
    name: "{{ timezone }}"

Teraz stwórzmy prosty playbook playbooks/site.yml, który użyje tej roli:

# playbooks/site.yml
---
- name: Configure all servers
  hosts: all
  become: yes
  roles:
    - common

Możesz teraz przetestować swoją rolę:

# Test połączenia z hostami
ansible all -m ping

# Uruchomienie playbooka (dry-run)
ansible-playbook playbooks/site.yml --check

# Uruchomienie playbooka
ansible-playbook playbooks/site.yml

Złote Zasady Tworzenia Ról (Best Practices)

Oto zestaw zasad, które sprawią, że Twoje role będą profesjonalne i łatwe w utrzymaniu.

1. Nazewnictwo ról

Zamiast używać numeracji w nazwach ról (co sugeruje kolejność wykonania), używaj opisowych nazw:

Zamiast:

roles/
├── 00-checks/
├── 01-common/
├── 02-security/
└── 10-nginx/

Stosuj:

roles/
├── common/         # Podstawowe pakiety (curl, git, vim)
├── security/       # Fail2ban, SSH hardening, Firewall
├── nginx/          # Tylko instalacja i konfig serwera WWW
├── app_deploy/     # Logika specyficzna dla Twojej aplikacji
└── monitoring/     # Np. node_exporter

Kolejność wykonania ról definiuj w playbooku, nie w nazwach katalogów.

2. Organizacja playbooków

A kolejność zdefiniuj w pliku playbooks/site.yml:

# playbooks/site.yml
---
- name: Configure all servers
  hosts: all
  become: yes
  roles:
    - common
    - security
    - monitoring

- name: Configure web servers
  hosts: web
  become: yes
  roles:
    - nginx
    - app_deploy

To podejście jest czytelne, elastyczne i zgodne ze standardami branżowymi.

3. Używaj zmiennych

Zamiast hardkodować wartości, używaj zmiennych w defaults/main.yml:

# roles/nginx/defaults/main.yml
---
nginx_user: www-data
nginx_worker_processes: auto
nginx_worker_connections: 1024

4. Idempotencja

Upewnij się, że Twoje zadania są idempotentne - możesz je uruchomić wielokrotnie bez zmiany wyniku:

# Dobrze - idempotentne
- name: Ensure package is installed
  apt:
    name: nginx
    state: present

# Źle - nie idempotentne
- name: Install nginx
  command: apt-get install -y nginx

5. Używaj handlerów do restartowania usług

Zamiast restartować usługi w każdym zadaniu, używaj handlerów:

# roles/nginx/tasks/main.yml
- name: Configure nginx
  template:
    src: nginx.conf.j2
    dest: /etc/nginx/nginx.conf
  notify: restart nginx

# roles/nginx/handlers/main.yml
- name: restart nginx
  systemd:
    name: nginx
    state: restarted

6. Dokumentuj swoje role

Dodaj opis w meta/main.yml:

# roles/common/meta/main.yml
---
galaxy_info:
  role_name: common
  description: Installs common packages and basic configuration
  author: Twoje Imię
  license: MIT
  min_ansible_version: '2.9'

Podsumowanie

W tym artykule dowiedziałeś się:

• Czym jest Ansible i dlaczego warto go używać
• Jak zainstalować Ansible za pomocą pipx
• Jak zorganizować projekt Ansible zgodnie z najlepszymi praktykami
• Jak stworzyć własną rolę za pomocą ansible-galaxy init
• Złote zasady tworzenia ról

Ansible to potężne narzędzie, które może znacznie uprościć zarządzanie Twoją infrastrukturą. Zacznij od prostych ról i stopniowo rozbudowuj swoją automatyzację. Pamiętaj, że każdy playbook to jednocześnie dokumentacja tego, co zostało skonfigurowane.

W następnych krokach możesz:

• Stworzyć role dla konkretnych usług (nginx, PostgreSQL, Redis)
• Poznać zaawansowane funkcje Ansible (templates, loops, conditionals)
• Zintegrować Ansible z CI/CD
• Używać Ansible Vault do przechowywania wrażliwych danych

Powodzenia w automatyzacji!