Słowem wstępu...

Aktualnie wdrażanie i konfigurowanie serwerów przeżywa prawdziwy renesans. Zmieniło się podejście z konfigurowania wszystkiego ręcznie, na takie które umożliwia pisanie scenariuszy w formie kodu, Są one  następnie wykonywane w pełni automatycznie, co skraca znacząco całą procedurę ich utrzymania. Dziś pokażę Ci od czego zacząc i stworzymy prosty scenariusz, który umożliwi Ci integrację serwera z usługą BackupPC

Logowanie

Pracę z ansible rozpoczynamy od założenia, że nasze logowanie na serwery zostanie będzie się odbywało z użyciem technologi passwordless. Aby tego dokonać, na początku należy wygenerować klucze RSA na lokalnym komputerze.

ssh-keygen -f ~/.ssh/ansible -t rsa -C  ansible -b 4096
chmod 700 ~/.ssh
chmod 600 ~/.ssh/*

Które następnie wrzucamy na naszą docelową, zdalną maszynę (nasz serwer musi mieć dodane wczesniej konto o nazwie ansible):

ssh-copy-id -f -i ~/.ssh/ansible.pub ansible@10.0.30.1

Następnie, przeprowadzamy test logowania.

ssh 'ansible@10.0.30.1' -i ~/.ssh/ansible

W przypadku powodzenia, zostaniemy zalogowani bez proszenia o hasło. Następnie dla poprawy bezpieczeństwa, możemy za pomocą poniższej komendy usunąć możliwość logowania się po haśle do naszego konta.

passwd -d ansible

Inventory

Następnie przechodząc do właściwej pracy, zaczynamy od utworzenia pliku z naszą listą maszyn (inventory) na którym będziemy pracować.

backuppc/hosts

all:
    vars:
        ansible_ssh_private_key_file: "{{ ssh_key }}"   
        ansible_user: "{{ ssh_user | default('developer') }}"
    vars_files:
        - common.yml    
    children:
        blog_1:       
            hosts:
                prod:
                    ansible_host: 10.0.50.2
                dev:
                    ansible_host: 10.0.30.2
        webpage:       
            hosts:
               prod:
                   ansible_host: 10.0.50.1
               dev:
                   ansible_host: 10.0.30.1

Do tego tworzymy plik z naszymi zmiennymi, które możemy (bazując na nazwach grup) nadpisywać z naszego invetory.

backuppc/group_vars/blog_1/common.yml

ssh_key: ~/.ssh/ansible
ssh_user: ansible

Playbooki

Pora na nasz główny scenariusz. Stwórzmy teraz plik main.yml który będzie importował wszystkie nasze dodatkowe playbooki.

backuppc/main.yml

- import_playbook: playbooks/backuppc.yml

Teraz możemy dodać nasze podrole, które będą importowane w głównymi playbooku. W przypadku dodawania kolejnych hostów, scenariuszy, warto stosować podział, w którym odzielimy playbooki dotyczące wdrożeń na dev od tych produkcyjnych.

backuppc/playbooks/backuppc.yml

- hosts: all
  become: yes
  become_method: sudo
  gather_facts: yes
  roles:
    - ../roles/backuppc
  handlers:
    - import_tasks: ../handlers/restart_ssh.yml

Do roli jeszcze wrócimy, na ten moment aby zakończyć ten paragraf pokażę Ci jak docelowo powinien wyglądać plik handlers który będzie restartował naszą usługę ssh w zależności od potrzeb.

backuppc/handlers/restart_ssh.yml

- name: Restart SSH Server
  service:
    name: sshd
    state: restarted

Role

Definiując naszą pierwszą rolę:

- upewnimy się że mamy zainstalowane potrzebne pakiety,

- dodamy użytkownika backuppc, który będzie się logował z użyciem klucza publicznego, który dostarczymy mu w odzielnym pliku,

-  sprawdziwmy czy wszystkie uprawnienia do naszego klucza są poprawne.

backuppc/roles/backuppc/defaults/tasks.yml

- name: Install rsync
  package:
    name: "rsync"
    state: present
  tags: [apt]

- name: Creating '{{ uusername }}' user
  ansible.builtin.user:
    state: present
    name: "{{ uusername }}"
    password: '!' # For remove password
  tags: [user]

- name: Allow '{{ uusername }}' to use sudo rsync witchout password
  community.general.sudoers:
    name: allow-backup
    state: present
    user: "{{ uusername }}"
    commands:
      - /usr/bin/rsync --server --sender *
  tags: [user]

- name: Enable pubkey authentication for SSH
  lineinfile:
    dest: "/etc/ssh/sshd_config"
    regex: "#PubkeyAuthentication yes"
    line: "PubkeyAuthentication yes"
  notify: "Restart SSH Server"
  tags: [create_key]
    
- name: Ensure permissions for '{{ uusername }}'
  file:
    path: "/home/{{ uusername }}"
    state: directory
    mode: 0700
    owner: "{{ uusername }}"
    group: "{{ uusername }}"
    recurse: yes
  tags: [create_key]

- name: Ensure permissions for '{{ uusername }}/.ssh'
  file:
    path: "/home/{{ uusername }}/.ssh"
    state: directory
    mode: 0700
    owner: "{{ uusername }}"
    group: "{{ uusername }}"
    recurse: yes
  tags: [create_key]

- name: Add authorized keys
  authorized_key:
    user: "{{ uusername }}"
    key: "{{ lookup('file', 'files/'+ uusername + '.pub') }}"
  tags: [create_key]

Aby powyższy kod zadziałał musimy dostarczyć mu plik .ssh/authorized_keys. Więcej informacji pod tym linkiem.

backuppc/roles/backuppc/files/backuppc.pub

ssh-rsa AAAAB3[wartość klucza ukryłem]DASDASDASDASD== backuppc@10.0.30.1

Dodatkowo wyniesiemy też część naszych zmiennych, do naszego pliku env.

backuppc/roles/backuppc/defaults/main.yml

uusername: backuppc

Uruchomienie

Instalujemy wymagane zależności

apt install ansible
ansible-galaxy collection install community.general

Po czym cały nasz kod możemy uruchomić pojedynczą komendą.

ansible-playbook -i hosts main.yml

 W przypadku powodzenia otrzymamy informację że wszystkie reguły zostały prawidłowo wykonane.

Powyższy artykuł stanowi jedynie wprowadzenie do technologi automatyzacji. Po więcej informacji polecam zajrzeć do dokumentacji.