Cum instalezi și configurezi Ansible pe un VPS Linux: ghid complet pentru automatizarea infrastructurii

Dacă administrezi mai multe servere sau dorești să elimini sarcinile repetitive din fluxul tău de lucru, Ansible este unealta de care ai nevoie. Este un instrument de automatizare open-source, agentless (nu necesită instalarea unui agent pe serverele gestionate) și extrem de ușor de învățat. În acest ghid, vei afla cum să instalezi și să configurezi Ansible pe un VPS NVMe sau VPS SSD, cu exemple practice.

Ce este Ansible și de ce să-l folosești?

Ansible este o platformă de automatizare IT dezvoltată de Red Hat, care îți permite să:

Provisionezi servere noi în câteva minute
Configurezi servicii (Nginx, Apache, MySQL etc.) identic pe zeci de mașini
Deploiezi aplicații fără intervenție manuală
Orkestrezi fluxuri complexe de operații

Față de soluții precum Puppet sau Chef, Ansible nu necesită instalarea unui agent pe noduri. Comunicarea se face prin SSH, ceea ce îl face ideal pentru orice VPS Linux sau server dedicat.

Arhitectura Ansible

Control Node – mașina de pe care rulezi Ansible (VPS-ul tău principal)
Managed Nodes – serverele pe care le administrezi
Inventory – lista serverelor gestionate
Playbook – fișierul YAML care descrie ce operații se execută
Module – unitatea de bază de acțiune (ex: apt, copy, service)

Cerințe preliminare

Înainte de a începe, asigură-te că ai:

Un VPS cu Ubuntu 22.04 sau Debian 12 (control node)
Acces root sau un utilizator cu privilegii sudo
Autentificare prin chei SSH configurată
Python 3 instalat (vine implicit pe Ubuntu 22.04)

Dacă nu ai încă un server, poți comanda rapid un VPS NVMe CLIQHOST cu Ubuntu preinstalat.

Pasul 1: Instalarea Ansible pe Control Node

Pe Ubuntu 22.04 / Debian 12

sudo apt update
sudo apt install -y software-properties-common
sudo add-apt-repository --yes --update ppa:ansible/ansible
sudo apt install -y ansible

Verificarea instalării

ansible --version

Output așteptat:

ansible [core 2.16.x]
  python version = 3.10.x
  jinja version = 3.x.x

Pe CentOS / AlmaLinux 9

sudo dnf install -y epel-release
sudo dnf install -y ansible

Pasul 2: Configurarea fișierului de inventar

Inventarul este inima oricărei configurări Ansible. El definește care servere vor fi administrate și cum sunt grupate.

Inventar simplu (`/etc/ansible/hosts`)

[webservers]
192.168.1.10
192.168.1.11

[dbservers]
192.168.1.20

[all:vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=~/.ssh/id_rsa

Inventar YAML (recomandat pentru proiecte complexe)

Creează un fișier inventory.yml:

all:
  children:
    webservers:
      hosts:
        web01:
          ansible_host: 192.168.1.10
        web02:
          ansible_host: 192.168.1.11
    dbservers:
      hosts:
        db01:
          ansible_host: 192.168.1.20
  vars:
    ansible_user: ubuntu
    ansible_ssh_private_key_file: ~/.ssh/id_rsa

Testarea conexiunii

ansible all -m ping -i inventory.yml

Răspuns de succes:

web01 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}

Pasul 3: Configurarea fișierului `ansible.cfg`

Creează un fișier ansible.cfg în directorul proiectului tău:

[defaults]
inventory = ./inventory.yml
remote_user = ubuntu
private_key_file = ~/.ssh/id_rsa
host_key_checking = False
retry_files_enabled = False

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

Notă: host_key_checking = False este util în medii de test. În producție, pe un server dedicat managed, menține verificarea activă pentru securitate.

Pasul 4: Primele comenzi Ad-Hoc

Comenzile ad-hoc sunt utile pentru acțiuni rapide, fără a scrie un playbook:

# Verifică uptime-ul tuturor serverelor
ansible all -m command -a "uptime"

# Instalează un pachet pe toate serverele web
ansible webservers -m apt -a "name=nginx state=present" --become

# Copiază un fișier pe noduri
ansible webservers -m copy -a "src=/local/file.conf dest=/etc/nginx/file.conf"

# Repornește un serviciu
ansible webservers -m service -a "name=nginx state=restarted" --become

# Verifică spațiul pe disc
ansible all -m shell -a "df -h"

Pasul 5: Scrierea primului Playbook

Playbook-ul este un fișier YAML care descrie starea dorită a sistemelor tale. Iată un exemplu complet pentru instalarea și configurarea Nginx:

---
- name: Instalare si configurare Nginx
  hosts: webservers
  become: true

  vars:
    nginx_port: 80
    site_name: "exemplu.com"

  tasks:
    - name: Actualizare cache APT
      apt:
        update_cache: yes
        cache_valid_time: 3600

    - name: Instalare Nginx
      apt:
        name: nginx
        state: present

    - name: Copiere configuratie site
      template:
        src: templates/nginx_site.conf.j2
        dest: "/etc/nginx/sites-available/{{ site_name }}"
        owner: root
        group: root
        mode: '0644'
      notify: Restart Nginx

    - name: Activare site
      file:
        src: "/etc/nginx/sites-available/{{ site_name }}"
        dest: "/etc/nginx/sites-enabled/{{ site_name }}"
        state: link
      notify: Restart Nginx

    - name: Pornire si activare Nginx
      service:
        name: nginx
        state: started
        enabled: yes

  handlers:
    - name: Restart Nginx
      service:
        name: nginx
        state: restarted

Template Jinja2 pentru Nginx (`templates/nginx_site.conf.j2`)

server {
    listen {{ nginx_port }};
    server_name {{ site_name }};

    root /var/www/{{ site_name }};
    index index.html index.php;

    access_log /var/log/nginx/{{ site_name }}_access.log;
    error_log  /var/log/nginx/{{ site_name }}_error.log;

    location / {
        try_files $uri $uri/ =404;
    }
}

Rularea playbook-ului

# Dry-run (verificare fara modificari)
ansible-playbook playbook_nginx.yml --check

# Rulare efectiva
ansible-playbook playbook_nginx.yml

# Cu output detaliat
ansible-playbook playbook_nginx.yml -v

Pasul 6: Organizarea proiectului cu Roluri Ansible

Pentru proiecte mai mari, rolurile permit reutilizarea și organizarea codului. Structura unui rol:

roles/
  nginx/
    tasks/
      main.yml
    handlers/
      main.yml
    templates/
      nginx_site.conf.j2
    defaults/
      main.yml
    vars/
      main.yml
    files/
    meta/
      main.yml

Crearea automată a structurii

ansible-galaxy init roles/nginx
ansible-galaxy init roles/mariadb
ansible-galaxy init roles/php

Playbook care folosește roluri

---
- name: Configurare stack LEMP
  hosts: webservers
  become: true
  roles:
    - nginx
    - mariadb
    - php

Pasul 7: Variabile și Ansible Vault

Fișiere de variabile per grup

group_vars/
  webservers.yml
  dbservers.yml
host_vars/
  web01.yml

group_vars/webservers.yml:

nginx_worker_processes: 4
nginx_worker_connections: 1024
php_version: "8.2"

Ansible Vault – protejarea secretelor

# Criptare fișier cu parole/credentiale
ansible-vault create group_vars/all/vault.yml

# Editare fișier criptat
ansible-vault edit group_vars/all/vault.yml

# Rulare playbook cu vault
ansible-playbook site.yml --ask-vault-pass
# sau cu fișier de parolă
ansible-playbook site.yml --vault-password-file ~/.vault_pass

vault.yml (conținut decriptat):

db_root_password: "SuperParola123!"
db_app_password: "AppParola456!"
api_key: "sk-xxxxxxxxxxxx"

Pasul 8: Exemple practice avansate

Playbook pentru securizarea unui VPS nou

---
- name: Securizare initiala VPS
  hosts: all
  become: true

  tasks:
    - name: Actualizare sistem
      apt:
        upgrade: dist
        update_cache: yes

    - name: Instalare pachete de securitate
      apt:
        name:
          - ufw
          - fail2ban
          - unattended-upgrades
        state: present

    - name: Configurare UFW - allow SSH
      ufw:
        rule: allow
        port: "22"
        proto: tcp

    - name: Configurare UFW - allow HTTP/HTTPS
      ufw:
        rule: allow
        port: "{{ item }}"
        proto: tcp
      loop:
        - "80"
        - "443"

    - name: Activare UFW
      ufw:
        state: enabled
        policy: deny

    - name: Activare fail2ban
      service:
        name: fail2ban
        state: started
        enabled: yes

    - name: Dezactivare autentificare root prin SSH
      lineinfile:
        path: /etc/ssh/sshd_config
        regexp: '^PermitRootLogin'
        line: 'PermitRootLogin no'
      notify: Restart SSH

  handlers:
    - name: Restart SSH
      service:
        name: ssh
        state: restarted

Sfaturi pentru utilizarea Ansible în producție

Folosește întotdeauna --check înainte de rulare pe servere de producție
Versionează playbook-urile cu Git pentru trasabilitate
Separă mediile (dev/staging/prod) prin inventare distincte
Testează rolurile cu Molecule înainte de deployment
Criptează toate secretele cu Ansible Vault
Documentează fiecare playbook cu comentarii și name descriptive

Pentru infrastructuri de producție complexe, o soluție de administrare servere dedicată îți poate economisi timp considerabil.

Structura unui proiect Ansible complet

ansible-project/
├── ansible.cfg
├── inventory/
│   ├── production/
│   │   ├── hosts.yml
│   │   └── group_vars/
│   └── staging/
│       ├── hosts.yml
│       └── group_vars/
├── roles/
│   ├── common/
│   ├── nginx/
│   ├── mariadb/
│   └── php/
├── playbooks/
│   ├── site.yml
│   ├── deploy.yml
│   └── security.yml
└── README.md

Concluzie

Ansible transformă administrarea serverelor dintr-o activitate manuală și repetitivă într-un proces automatizat, reproductibil și documentat. Cu câteva playbook-uri bine scrise, poți configura zeci de servere identic în câteva minute, elimini erorile umane și ai mereu o imagine clară a stării infrastructurii tale.

Pentru a pune în practică tot ce ai învățat, ai nevoie de o infrastructură solidă. Explorează ofertele de VPS NVMe de la CLIQHOST sau contactează-ne pentru un plan de administrare servere personalizat. Avem și resurse suplimentare pe blogul CLIQHOST pentru a-ți aprofunda cunoștințele de Linux și DevOps.

Cum instalezi și configurezi Ansible pe un VPS Linux: ghid complet pentru automatizarea infrastructurii