Automatyzacja konfiguracji VPS za pomocą Ansible: Inwentarz i pierwszy playbook

Wprowadzenie

Ansible to narzędzie open source do automatyzacji używane do zarządzania konfiguracją, wdrażania aplikacji i udostępniania infrastruktury. Łączy się z serwerami przez SSH i nie wymaga instalacji żadnego agenta na zdalnych maszynach, co czyni go prostym i bezpiecznym w użyciu. Typowe przypadki użycia obejmują automatyzację konfiguracji serwerów, utrzymywanie spójności konfiguracji i wdrażanie aplikacji na wielu systemach jednocześnie.

W tym samouczku skonfigurujesz Ansible na swoim lokalnym komputerze i użyjesz go do automatyzacji konfiguracji wielu instancji VPS. Zamiast konfigurować każdy serwer ręcznie, definiujesz zadania raz i stosujesz je wszędzie. Tworzysz inwentarz, piszesz swój pierwszy playbook i wdrażasz działający stos aplikacji webowej.

Zrozumienie podstawowych pojęć Ansible

Nie piszesz skryptu, który uruchamia polecenia jedno po drugim. Opisujesz, jak powinny wyglądać twoje serwery po zakończeniu playbooka.

W tym samouczku używasz tylko kilku podstawowych komponentów. Plik inwentarza definiuje twoje serwery VPS i sposób, w jaki Ansible się z nimi łączy. Playbook to miejsce, w którym opisujesz pożądany stan swoich serwerów. W playbooku zadania definiują poszczególne elementy tego pożądanego stanu, takie jak zainstalowane pakiety, działające usługi czy pliki konfiguracyjne.

Najważniejszym pojęciem tutaj jest deklaratywność. Zamiast pisać dokładne polecenia, jak w skrypcie powłoki, opisujesz wynik, który chcesz osiągnąć. Na przykład, nie mówisz Ansible, aby uruchomił polecenie instalacji Nginx. Definiujesz, że Nginx musi być zainstalowany. Nie mówisz mu, aby ręcznie uruchomił usługę. Definiujesz, że usługa musi być uruchomiona i włączona. Ansible decyduje, jakie działania są potrzebne, aby osiągnąć ten stan.

To różni się od tradycyjnego podejścia, w którym ręcznie uruchamiasz polecenia w określonej kolejności. W takich skryptach musisz samodzielnie obsłużyć każdą możliwą sytuację. W Ansible logika jest wbudowana w używane moduły, takie jak zarządzanie pakietami, kontrola usług, zarządzanie plikami i sprawdzanie HTTP.

Kolejnym kluczowym pojęciem jest idempotencja. Oznacza to, że wielokrotne uruchamianie tego samego playbooka nie powoduje niepotrzebnych zmian. Jeśli system już odpowiada pożądanemu stanowi, Ansible pozostawia go bez zmian. Na przykład, jeśli Nginx jest już zainstalowany, nie zostanie ponownie zainstalowany. Jeśli plik konfiguracyjny już odpowiada temu, co zdefiniowałeś, nie zostanie przepisany.

Dzięki deklaratywności i idempotencji możesz bezpiecznie uruchamiać playbook wielokrotnie. Podczas pierwszego uruchomienia Ansible instaluje i konfiguruje wszystko. Podczas kolejnych uruchomień tylko sprawdza stan systemu i zmienia go, jeśli to konieczne.

Wymagania wstępne

• Docelowa grupa odbiorców: Początkujący administratorzy systemów
• Szacowany czas: ~40–60 minut
• System operacyjny: Debian 13 na lokalnym komputerze i wszystkich węzłach VPS
• Węzły VPS:
  • ans0: 192.168.10.10
  • ans1: 192.168.10.11
  • ans2: 192.168.10.12
• Dostęp:
  • Dostęp SSH do wszystkich instancji VPS
  • Użytkownik z uprawnieniami sudo na każdym VPS
• Sieć:
  • Port 22 otwarty dla SSH
  • Port 80 otwarty dla HTTP
• Lokalna maszyna:
  • Zainstalowany Python 3
  • Dostęp do Internetu
• Cel końcowy: Na końcu tego samouczka automatycznie skonfigurujesz wiele serwerów VPS, zainstalujesz Nginx, wdrożysz PocketBase i uczynisz go dostępnym przez serwer webowy.

Krok 1: Zainstaluj Ansible na lokalnej maszynie

Ansible działa na twojej lokalnej maszynie i łączy się z zdalnymi serwerami. Instalujesz go tylko raz.

Zaktualizuj listy pakietów:

sudo apt update

Zainstaluj Ansible:

sudo apt install ansible -y

Sprawdź instalację:

ansible --version

Oczekiwany wynik: Widzisz informacje o wersji. To potwierdza, że Ansible jest zainstalowany i gotowy do użycia.

Krok 2: Przygotuj dostęp SSH

Ansible używa SSH do łączenia się z serwerami. Aby uniknąć wpisywania haseł za każdym razem, używasz kluczy SSH.

Wygeneruj klucz SSH:

ssh-keygen

Naciśnij Enter, aby zaakceptować domyślne ustawienia. To tworzy parę kluczy:

• Klucz prywatny pozostaje na twoim komputerze
• Klucz publiczny jest kopiowany na serwery

Skopiuj klucz na VPS:

ssh-copy-id <YOUR_USERNAME>@192.168.10.10

ssh-copy-id <YOUR_USERNAME>@192.168.10.11

ssh-copy-id <YOUR_USERNAME>@192.168.10.12

Przetestuj dostęp:

ssh <YOUR_USERNAME>@192.168.10.10

Oczekiwany wynik: Logujesz się bez wpisywania hasła.

Krok 3: Utwórz projekt Ansible i inwentarz

Ansible używa pliku inwentarza, aby wiedzieć, które serwery zarządzać.

Utwórz katalog projektu:

mkdir ~/ansible-vps

cd ~/ansible-vps

Utwórz plik inwentarza:

nano inventory.ini

Wstaw następującą zawartość do pliku inwentarza:

[vps]
ans0 ansible_host=192.168.10.10
ans1 ansible_host=192.168.10.11
ans2 ansible_host=192.168.10.12
[vps:vars]
ansible_user=<YOUR_USERNAME>
ansible_python_interpreter=/usr/bin/python3

Wyjaśnienie:

• [vps] to nazwa grupy
• ans0, ans1, ans2 to nazwy logiczne
• ansible_host definiuje rzeczywiste adresy IP
• ansible_user mówi Ansible, jako który użytkownik się logować

Przetestuj łączność:

ansible -i inventory.ini vps -m ping

Oczekiwany wynik: Każdy serwer zwraca "pong".

Krok 4: Utwórz swój pierwszy playbook

Playbook to plik, w którym opisujesz zadania, które chcesz uruchomić na serwerach.

Utwórz plik:

nano playbook.yml

Wstaw następującą zawartość do pliku playbook:

- name: Configure VPS nodes
  hosts: vps
  become: true
  tasks:
    - name: Test connectivity
      ping:
    - name: Update apt cache
      apt:
        update_cache: yes
    - name: Upgrade packages
      apt:
        upgrade: dist
    - name: Install Nginx
      apt:
        name: nginx
        state: present
    - name: Ensure Nginx is running
      service:
        name: nginx
        state: started
        enabled: true
    - name: Test HTTP connectivity
      uri:
        url: http://127.0.0.1/
        return_content: no
    - name: Create directory for PocketBase
      file:
        path: /opt/pocketbase/pb_public
        state: directory
    - name: Install unzip
      apt:
        name: unzip
        state: present
    - name: Download PocketBase
      get_url:
        url: https://github.com/pocketbase/pocketbase/releases/download/v0.36.7/pocketbase_0.36.7_linux_amd64.zip
        dest: /opt/pocketbase/pocketbase.zip
    - name: Unpack PocketBase
      unarchive:
        src: /opt/pocketbase/pocketbase.zip
        dest: /opt/pocketbase/
        remote_src: yes
    - name: Create Pocketbase index.html
      copy:
        dest: /opt/pocketbase/pb_public/index.html
        content: |
          <h1>Pocketbase</h1>
    - name: Create systemd service
      copy:
        dest: /etc/systemd/system/pocketbase.service
        content: |
          [Unit]
          Description=PocketBase Service
          After=network.target
          [Service]
          Type=simple
          ExecStart=/opt/pocketbase/pocketbase serve --http=127.0.0.1:8090
          Restart=always
          [Install]
          WantedBy=multi-user.target
    - name: Reload systemd
      command: systemctl daemon-reexec
    - name: Enable and start PocketBase
      service:
        name: pocketbase
        enabled: true
        state: started
    - name: Configure Nginx site
      copy:
        dest: /etc/nginx/sites-available/pocketbase
        content: |
          server {
              listen 80;
              server_name _;
              location / {
                  proxy_pass http://127.0.0.1:8090;
                  proxy_set_header Host $host;
                  proxy_set_header X-Real-IP $remote_addr;
              }
          }
    - name: Enable Nginx site
      file:
        src: /etc/nginx/sites-available/pocketbase
        dest: /etc/nginx/sites-enabled/pocketbase
        state: link
    - name: Remove default site
      file:
        path: /etc/nginx/sites-enabled/default
        state: absent
    - name: Restart Nginx
      service:
        name: nginx
        state: restarted
    - name: Check PocketBase availability
      uri:
        url: http://127.0.0.1:8090/_/
        return_content: no

Wyjaśnienie:

• hosts: vps oznacza wszystkie serwery w grupie
• become: true uruchamia zadania z podwyższonymi uprawnieniami
• Każde zadanie opisuje jedną akcję
• Moduły takie jak apt, service, file są wbudowane w Ansible

Krok 5: Uruchom playbook

ansible-playbook -i inventory.ini playbook.yml

Oczekiwany wynik: Zadania wykonują się na wszystkich węzłach bez błędów.

Weryfikacja

Sprawdź serwer webowy:

curl http://192.168.10.10/

Oczekiwany wynik: Zwracana jest odpowiedź HTTP.

Otwórz w przeglądarce: http://192.168.10.10/_/

Oczekiwany wynik: Ładuje się interfejs PocketBase.

Powtórz dla innych węzłów.

Cofanie zmian

sudo systemctl stop pocketbase

sudo systemctl disable pocketbase

sudo rm /etc/systemd/system/pocketbase.service

sudo rm -rf /opt/pocketbase

sudo apt remove nginx unzip -y

Przeładuj systemd:

sudo systemctl daemon-reload

Rozwiązywanie problemów

• SSH nie działa: sprawdź klucze i użytkownika
• Ansible ping nie działa: upewnij się, że istnieje połączenie sieciowe między hostami
• Problemy z Nginx: systemctl status nginx
• Problemy z PocketBase: journalctl -u pocketbase

Podsumowanie

Zainstalowałeś narzędzie do automatyzacji Ansible, stworzyłeś inwentarz i napisałeś swój pierwszy playbook. Zautomatyzowałeś wdrożenie Nginx i PocketBase na wielu serwerach.

Kolejne kroki:

• Użyj ról dla lepszej struktury
• Dodaj zmienne i szablony
• Skonfiguruj HTTPS