Ansible to jedno z najpopularniejszych i najbardziej dostępnych narzędzi do automatyzacji zadań administracyjnych, zarządzania konfiguracjami i orkiestracji infrastruktury IT. Niniejszy przewodnik prowadzi od instalacji i konfiguracji, przez bezpieczne połączenia SSH, po pisanie wydajnych playbooków, ról i korzystanie z modułów.
Aby ułatwić nawigację, poniżej znajdziesz zestaw kluczowych tematów poruszanych w materiale:
- wprowadzenie do architektury bezagentowej i podstaw działania,
- instalacja na wiodących systemach oraz konfiguracja pliku ansible.cfg,
- zarządzanie inwentarzem, kluczami SSH i bezpieczeństwem komunikacji,
- tworzenie playbooków, użycie modułów, pętli, warunków i handlerów,
- role, zmienne, fakty, debugowanie oraz optymalizacja wydajności.
Wprowadzenie do Ansible i jego fundamentalnych założeń
Ansible to narzędzie automatyzacji oparte na architekturze bezagentowej. Brak agentów upraszcza wdrożenie i utrzymanie – wszystkie operacje są wykonywane z węzła kontrolnego poprzez bezpieczne połączenia SSH.
Podstawową jednostką pracy jest playbook, czyli plik w formacie YAML, który opisuje pożądany stan systemów oraz zadania (tasks) wykonywane sekwencyjnie na wskazanych hostach.
Jedną z kluczowych cech Ansible jest idempotentność – wielokrotne uruchomienie tego samego playbooka na tym samym zestawie maszyn nie wprowadza zbędnych zmian. Wielokrotne uruchomienie tych samych zadań nie wprowadza zmian, co znacząco podnosi przewidywalność i bezpieczeństwo automatyzacji.
Ansible działa nie tylko z Linuxem, ale także z Windows, macOS i wieloma platformami sieciowymi. Modułowa architektura i otwarty kod źródłowy pozwalają łatwo rozszerzać funkcjonalność narzędzia.
Instalacja Ansible na różnych dystrybucjach Linux
Instalacja na systemach Debian i Ubuntu
Pierwszym krokiem jest instalacja Ansible na węźle kontrolnym. Na Ubuntu/Debian możesz skorzystać z repozytorium PPA i menedżera APT:
Aby dodać repozytorium, zaktualizować listę pakietów i zainstalować Ansible, użyj poleceń:
sudo apt-add-repository ppa:ansible/ansible
sudo apt-get update
sudo apt-get install ansible
ansible --version
Po instalacji sprawdź wersję poleceniem ansible –version, aby potwierdzić poprawność środowiska.
Instalacja na systemach Red Hat i CentOS
W systemach Red Hat/CentOS najpierw zainstaluj EPEL, a następnie Ansible:
sudo yum install epel-release
sudo yum install ansible
ansible --version
Instalacja na macOS
Na macOS najprościej skorzystać z Homebrew:
brew install ansible
ansible --version
Dla szybkiej orientacji zobacz zestawienie komend instalacyjnych na popularnych systemach:
| System | Menedżer | Polecenia instalacji |
|---|---|---|
| Ubuntu / Debian | APT | sudo apt-add-repository ppa:ansible/ansiblesudo apt-get updatesudo apt-get install ansible |
| Red Hat / CentOS | YUM | sudo yum install epel-releasesudo yum install ansible |
| macOS | Homebrew | brew install ansible |
Konfiguracja Ansible i plik ansible.cfg
Konfigurację Ansible definiuje się głównie w pliku ansible.cfg (w /etc/ansible/ lub w katalogu projektu). Ustawisz tam m.in. ścieżki do kluczy SSH, poziom logowania, forks (równoległość) czy parametry połączeń.
Najistotniejsze sekcje to [defaults] (ustawienia ogólne), [ssh_connection] (parametry SSH) i [privilege_escalation] (podnoszenie uprawnień). Zmienne środowiskowe mogą nadpisywać wartości z pliku konfiguracyjnego. Użyj ansible-config, aby podejrzeć obowiązujące ustawienia.
Architektura Ansible i komponenty systemu
Węzeł kontrolny i węzły zarządzane
Węzeł kontrolny (control node) to maszyna, na której uruchamiasz Ansible. Węzły zarządzane (managed nodes) to hosty docelowe. Komunikacja przebiega przez SSH, bez instalowania agentów na hostach docelowych.
W praktyce logujesz się na węzeł kontrolny, a Ansible nawiązuje sesje SSH do hostów, wykonuje moduły i zwraca wyniki do dalszej obróbki.
Moduły Ansible
Moduły to „klocki funkcyjne” Ansible. Popularne przykłady: apt (Debian/Ubuntu), yum (Red Hat/CentOS), file (pliki/katalogi), service/systemd (usługi). Spójny interfejs modułów upraszcza ich użycie i łączenie w playbookach.
Zarządzanie kluczami SSH i bezpieczeństwo komunikacji
Generowanie i konfiguracja kluczy SSH
Aby korzystać z bezpiecznej, bezhasłowej autentykacji, wygeneruj parę kluczy SSH:
ssh-keygen
Dla algorytmu ED25519 użyj:
ssh-keygen -f ~/.ssh/ansible -t ed25519
Po wygenerowaniu otrzymasz klucz prywatny i plik .pub z kluczem publicznym.
Instalacja klucza publicznego na zdalnych serwerach
Skopiuj klucz publiczny na docelowy serwer poleceniem:
ssh-copy-id -i ~/.ssh/ansible.pub [email protected]
Klucz zostanie dodany do ~/.ssh/authorized_keys i umożliwi logowanie bez hasła.
Konfiguracja Ansible do użytku kluczy SSH
W inwentarzu wskaż ścieżkę do klucza prywatnego, aby Ansible używał go przy połączeniach:
all:
vars:
ansible_user: ta
hosts:
ta-lxlt:
ansible_host: 192.168.4.58
ansible_ssh_private_key_file: ~/.ssh/ansible
Jeśli klucz ma passphrase, skorzystaj z ssh-add, aby uniknąć interaktywnego pytania podczas uruchomień.
Zarządzanie inwentarzem hostów
Struktura i format pliku inwentarza
Inwentarz (inventory) zawiera listę hostów i grup wraz z parametrami połączeń. Może mieć format INI lub YAML. Przykład INI:
[webserwery]
web1.example.com
web2.example.com
[bazy_danych]
db1.example.com
db2.example.com
Ten sam inwentarz w YAML:
all:
children:
webserwery:
hosts:
web1.example.com:
web2.example.com:
bazy_danych:
hosts:
db1.example.com:
db2.example.com:
Grupy hostów i zmienne inwentarza
Twórz logiczne grupy (np. webserwery, bazy_danych) i przypisuj do nich zmienne. Przykład zmiennej dla hostów w INI:
[webserwery]
web1.example.com ansible_user=ubuntu
web2.example.com ansible_user=ubuntu
Aby wyświetlić hosty w grupie, użyj:
ansible -i inventory --list-hosts web_servers
Tworzenie i uruchamianie podstawowych playbooków
Anatomia playbooka
Playbook (YAML) definiuje na jakich hosts wykonać zadania, z jakimi uprawnieniami i w jakiej kolejności. Przykład instalacji Nginx:
---
- name: Instalacja Nginx
hosts: webservers
become: yes
tasks:
- name: Zainstaluj pakiet Nginx
apt:
name: nginx
state: present
Uruchamianie playbooków
Uruchom playbook poleceniem:
ansible-playbook install_nginx.yml
Jeśli inwentarz jest w innym miejscu:
ansible-playbook -i inventory.txt install_nginx.yml
Kolory wyników: zielony – brak zmian (ok), żółty – wprowadzono zmiany, czerwony – błąd.
Zaawansowane funkcjonalności playbooków
Handlery (obsługa zdarzeń)
Handlery uruchamiają się tylko po wykryciu zmian w systemie przez zadania z notify. Przykład:
---
- name: Konfiguracja Nginx
hosts: webservers
become: yes
tasks:
- name: Zaktualizuj konfigurację Nginx
template:
src: nginx.conf.j2
dest: /etc/nginx/nginx.conf
notify: restart nginx
handlers:
- name: restart nginx
systemd:
name: nginx
state: restarted
Instrukcje warunkowe (when)
Warunki pozwalają dopasować operacje do systemu/docelowego hosta. Przykład:
---
- name: Instalacja warunkowa
hosts: all
tasks:
- name: Zainstaluj Apache na systemach Debian
apt:
name: apache2
state: present
when: ansible_os_family == "Debian"
- name: Zainstaluj Apache na systemach Red Hat
yum:
name: httpd
state: present
when: ansible_os_family == "RedHat"
Pętle (loops)
Pętle ułatwiają powtarzanie identycznych operacji dla wielu elementów. Przykład:
---
- name: Instalacja wielu pakietów
hosts: all
tasks:
- name: Zainstaluj pakiety
apt:
name: "{{ item }}"
state: present
loop:
- curl
- wget
- git
- vim
Rejestrowanie zmiennych (register)
register zapisuje wynik zadania do zmiennej używanej później w warunkach lub kolejnych krokach:
---
- name: Rejestrowanie wyników poleceń
hosts: all
tasks:
- name: Sprawdź, czy plik istnieje
command: test -f /etc/myconfig.conf
register: config_file_exists
ignore_errors: yes
- name: Pokaż wynik
debug:
msg: "Plik konfiguracyjny istnieje"
when: config_file_exists.rc == 0
Moduły Ansible i ich praktyczne zastosowania
Moduły apt i yum do zarządzania pakietami
Wybór właściwego modułu dla danej dystrybucji zapewnia idempotentną i przewidywalną instalację oprogramowania. Przykład apt:
- name: Zainstaluj nginx
apt:
name: nginx
state: present
update_cache: yes
Moduł file do zarządzania plikami i katalogami
Do tworzenia, usuwania i modyfikacji atrybutów plików/katalogów użyj file. Przykład:
- name: Utwórz katalog aplikacji
file:
path: /opt/myapp
state: directory
owner: appuser
group: appgroup
mode: '0755'
Moduł systemd i service
Nowocześniejsze środowiska preferują systemd do zarządzania usługami:
- name: Uruchom i włącz nginx
systemd:
name: nginx
state: started
enabled: yes
daemon_reload: yes
Moduły shell i command
shell uruchamia polecenia przez /bin/sh (obsługuje operatory powłoki), a command – bez interpretacji powłoki:
- name: Uruchom z użyciem shell
shell: echo "Hello" > /tmp/output.txt
- name: Uruchom z użyciem command (to się nie powiedzie)
command: echo "Hello" > /tmp/output.txt
Moduł user do zarządzania użytkownikami
Tworzenie i modyfikowanie kont ułatwia moduł user:
- name: Utwórz użytkownika aplikacyjnego
user:
name: appuser
group: appgroup
home: /home/appuser
shell: /bin/bash
createhome: yes
Zarządzanie faktami i zmiennymi systemu
Zbieranie faktów (facts gathering)
Ansible automatycznie zbiera fakty o hostach (moduł setup). Umożliwia to warunkowe logiki oparte na rzeczywistym stanie systemu. Budowa zadań z użyciem faktów zwiększa elastyczność i niezawodność playbooków.
Aby pominąć zbieranie faktów i przyspieszyć wykonanie:
---
- name: Szybkie zadanie
hosts: all
gather_facts: no
tasks:
- name: Szybki ping
ping:
Definiowanie i używanie zmiennych
Zmiennych możesz używać w vars, plikach, inwentarzu lub przekazywać z CLI. Przykład:
---
- name: Wykorzystanie zmiennych
hosts: webservers
vars:
nginx_port: 80
nginx_user: www-data
ssl_enabled: true
tasks:
- name: Skonfiguruj Nginx
template:
src: nginx.conf.j2
dest: /etc/nginx/nginx.conf
vars:
config_file: /etc/nginx/nginx.conf
Role Ansible i modularyzacja kodu
Struktura ról
Role porządkują automatyzację w powtarzalną strukturę katalogów: tasks, handlers, templates, files, vars, defaults, meta. Utwórz szkielet rolą poleceniem:
ansible-galaxy init <nazwa_roli>
Używanie ról w playbookach
Dodaj role w sekcji roles, by wykonać ich domyślne zadania:
---
- name: Instalacja i konfiguracja serwera WWW
hosts: webservers
become: yes
roles:
- nginx
- php
- ssl_certificates
Najlepsze praktyki projektowania ról
Aby tworzyć role łatwe w utrzymaniu i ponownym użyciu, stosuj poniższe zasady:
- projektuj role pod funkcję (np. webserver), a nie pod konkretny produkt (np. nginx),
- przechowuj wartości domyślne w defaults, a parametryzację ujawniaj przez vars i dokumentację,
- dziel odpowiedzialności: szablony w templates, pliki binarne w files, handlery w handlers,
- unikaj efektów ubocznych: dbaj o idempotentność i czytelne warunki wykonania.
Obsługa błędów i debugowanie
Strategia ignore_errors
Kontynuuj wykonanie po błędzie zadania dzięki ignore_errors: yes:
- name: Spróbuj operacji, która może się nie powieść
command: /usr/bin/some_command
ignore_errors: yes
- name: Kontynuuj niezależnie od poprzedniej porażki
debug:
msg: "Playbook kontynuuje nawet po błędzie poprzedniego zadania"
Użycie until i retries
Ponawiaj zadania dla niestabilnych usług, korzystając z until, retries i delay:
- name: Utwórz AWS VPC z ponowieniami
ec2_vpc_net:
name: vpc_test
cidr_block: 10.0.0.0/16
region: us-west-2
register: create_vpc
until: create_vpc is not failed
retries: 5
delay: 10
Moduł debug do debugowania
debug wyświetla komunikaty i wartości zmiennych w konsoli:
- name: Pokaż wartości zmiennych
debug:
msg: "Port nginx to {{ nginx_port }}, a użytkownik to {{ nginx_user }}"
- name: Wyświetl zarejestrowaną zmienną
debug:
var: result_output
Zaawansowane tematy – vault i bezpieczeństwo
Ansible Vault do szyfrowania poufnych danych
Ansible Vault szyfruje hasła, tokeny i klucze API w repozytorium, chroniąc sekrety przed wyciekiem. Szyfrowanie sekretów w repozytorium pozwala bezpiecznie współdzielić konfiguracje w zespole.
Utwórz zaszyfrowany plik poleceniem:
ansible-vault create secrets.yml
Podnoszenie uprawnień (sudo)
Użyj become i become_user, aby wykonywać zadania z uprawnieniami administratora:
- name: Zadanie wymagające uprawnień administratora
apt:
name: nginx
state: present
become: yes
become_user: root
W razie potrzeby uruchom playbook z -K / --ask-become-pass, aby podać hasło sudo.
Praktyczne zastosowania i rzeczywiste scenariusze
Automatyzacja zarządzania użytkownikami i grupami
Twórz grupy, użytkowników i uprawnienia w sposób powtarzalny i bezpieczny:
---
- name: Zarządzanie użytkownikami i grupami
hosts: all_servers
become: yes
tasks:
- name: Utwórz grupy
group:
name: "{{ item }}"
state: present
loop:
- developers
- admins
- testers
- name: Utwórz użytkowników
user:
name: "{{ item.username }}"
groups: "{{ item.group }}"
state: present
loop:
- { username: 'john', group: 'developers' }
- { username: 'jane', group: 'admins' }
- { username: 'bob', group: 'testers' }
- name: Skonfiguruj sudoers
lineinfile:
path: /etc/sudoers
line: "%admins ALL=(ALL) NOPASSWD: ALL"
state: present
Zarządzanie zadaniami cron
Dodawaj lub modyfikuj zadania cron modułem cron:
- name: Zaplanuj dzienną kopię zapasową
cron:
name: "Daily backup job"
hour: "2"
minute: "0"
job: "/usr/local/bin/backup.sh"
user: backup
state: present
Wspólne harmonogramy z special_time:
- name: Zaplanuj zadanie z użyciem special_time
cron:
name: "Hourly sync"
special_time: hourly
job: "/usr/local/bin/sync_data.sh"
state: present
Zarządzanie aplikacjami Docker
Moduły docker_container, docker_image i docker_compose upraszczają operacje na kontenerach. Przykład:
- name: Wdróż kontener Nginx
docker_container:
name: web_server
image: nginx:latest
state: started
restart_policy: always
published_ports:
- "80:80"
- "443:443"
volumes:
- /data/www:/usr/share/nginx/html
Optymalizacja wydajności Ansible
Cachowanie faktów
Zachowuj fakty między uruchomieniami, aby skrócić czas wykonania:
[defaults]
fact_caching = jsonfile
fact_caching_connection = /tmp/ansible_facts_cache
fact_caching_timeout = 86400
SSH pipelining
Włącz pipelining, aby ograniczyć narzut operacji na SSH:
[ssh_connection]
pipelining = True
Zwiększenie równoległości
Zwiększ liczbę równoległych wątków (domyślnie 5) parametrem forks:
[defaults]
forks = 50
Zwiększenie wartości forks oraz włączenie pipelining to najszybsze sposoby na przyspieszenie działania playbooków w dużych środowiskach.
Integracja Ansible z systemami CI/CD i GitHub
Automatyzacja wdrażania za pośrednictwem GitHub Actions
Uruchamiaj playbooki w ramach workflow na push do gałęzi main:
name: Deploy application
on:
push:
branches:
- main
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Run Ansible playbook
run: |
ansible-playbook -i inventory.yml deploy.yml
Zarządzanie konfiguracją za pośrednictwem Git
Przechowywanie playbooków, ról i inwentarza w Git zapewnia kontrolę wersji i współpracę zespołową. Wersjonowanie infrastruktury jako kodu (IaC) zwiększa audytowalność i jakość zmian.








