Ansible pentru începători 2026

Table of Contents
Ansible pentru începători: ghid complet de automatizare IT pentru 2026
Ansible a devenit o platformă de automatizare de top. Potrivit sursei, peste 80% dintre companiile Fortune 500 o folosesc pentru a gestiona infrastructuri IT complexe. În 2026, Ansible rămâne o soluție importantă, ușor de utilizat și cu funcții pentru companii.
Acest ghid te ajută să treci de la noțiunile de bază la utilizarea sigură a Ansible. Acoperă conceptele fundamentale, tehnicile avansate, exemplele practice și bunele practici pentru 2026.
Ce este Ansible? Noțiuni de bază
Ansible este o platformă open source de automatizare care simplifică gestionarea infrastructurii IT prin automatizare declarativă fără agenți. Spre deosebire de instrumentele tradiționale de gestionare a configurației, nu necesită agenți pe nodurile gestionate. Folosește SSH pentru Linux și Unix sau WinRM pentru Windows pentru gestionarea de la distanță.
Caracteristici principale ale Ansible
1. Arhitectură fără agenți:
- Nu necesită instalarea de software pe nodurile gestionate
- Folosește protocoalele SSH sau WinRM existente
- Reduce suprafața de atac și efortul de întreținere
- Este mai ușor de folosit decât instrumentele bazate pe agenți
2. Limbaj declarativ (YAML):
- Fișiere de configurare ușor de citit
- Infrastructura este descrisă ca stare dorită
- Operațiuni idempotente, sigure la rulări repetate
- Ușor de înțeles fără experiență de programare
3. Model push:
- Nodul de control trimite configurațiile către nodurile gestionate
- Execută sarcinile imediat, fără să aștepte agenții
- Control și vizibilitate centralizate
- Potrivit pentru automatizare la cerere
4. Bibliotecă extinsă de module:
- Peste 5.000 de module integrate (în 2026)
- Suportă Linux, Windows, dispozitive de rețea și platforme cloud
- Module create de comunitate și furnizori
- Modulele personalizate se scriu ușor în Python
Ce poate automatiza Ansible?
Ansible este potrivit pentru automatizarea:
- Gestionării configurației: menținerea unor configurații consecvente ale serverelor
- Implementării aplicațiilor: implementarea aplicațiilor în medii diferite
- Provisionării: crearea și configurarea infrastructurii
- Livrării continue: integrarea cu pipeline-uri CI/CD
- Securității și conformității: aplicarea politicilor de securitate și conformitate
- Orchestrării: coordonarea implementărilor complexe, pe mai multe niveluri
- Automatizării cloud: gestionarea AWS, Azure, GCP și a altor servicii cloud
- Automatizării rețelelor: configurarea switch-urilor, routerelor și firewall-urilor
- Automatizării Windows: gestionarea serverelor și stațiilor de lucru Windows
Evoluția Ansible: 2012-2026
Cronologie:
- 2012: Michael DeHaan creează Ansible
- 2015: Red Hat achiziționează Ansible
- 2019: Ansible Engine 2.8 introduce colecțiile
- 2020: Ansible 2.10+ se împarte în ansible-core și colecții
- 2023: Ansible 8.x extinde integrările cloud
- 2026: Ansible 10.x adaugă generarea de playbook-uri asistată de AI, suport Windows îmbunătățit și funcții de securitate extinse
Comparație rapidă între Ansible și alternative
| Funcție | Ansible | Terraform | Puppet | Chef |
|---|---|---|---|---|
| Tip | Gestionarea configurației | Provisionarea infrastructurii | Gestionarea configurației | Gestionarea configurației |
| Limbaj | YAML | HCL | Puppet DSL (similar cu Ruby) | Ruby DSL |
| Necesită agent | Nu | Nu | Da | Da |
| Curba de învățare | Ușoară | Moderată | Abruptă | Abruptă |
| Potrivit pentru | Gestionarea configurației, implementare | Infrastructură cloud | Companii mari | Fluxuri de lucru complexe |
| Gestionarea stării | Model push | Fișier declarativ de stare | Model pull | Model pull |
| Suport Windows | Excelent (2026) | Limitat | Bun | Bun |
| Dimensiunea comunității | Foarte mare | Foarte mare | Mare | Medie |
| Utilizare principală | Operațiuni zilnice | Provisionarea infrastructurii | Configurații enterprise | Implementarea aplicațiilor |
Când să alegi Ansible:
- ✅ Gestionarea configurațiilor în medii hibride
- ✅ Automatizarea implementării aplicațiilor
- ✅ Este necesară o curbă de învățare scurtă
- ✅ Este preferată o arhitectură fără agenți
- ✅ Este nevoie de automatizare Windows avansată (îmbunătățiri din 2026)
- ✅ Există deja o infrastructură SSH
Când să iei în considerare alternative:
- Terraform: în principal pentru provisionarea infrastructurii (AWS, Azure, GCP)
- Puppet: companii mari cu mii de noduri
- Chef: fluxuri de lucru complexe centrate pe aplicații
Primii pași: instalarea Ansible în 2026
Cerințe de sistem
Nodul de control, unde rulează Ansible:
- Linux, macOS sau WSL2 pe Windows
- Python 3.9 sau mai nou (Python 3.11+ recomandat pentru 2026)
- Minimum 2 GB RAM, se recomandă 4 GB sau mai mult
- 5 GB spațiu pe disc pentru colecții
Noduri gestionate:
- Acces SSH (Linux/Unix) sau WinRM (Windows)
- Python 2.7 sau Python 3.6+ (Linux)
- PowerShell 5.1+ (Windows)
- Nu necesită instalarea unui agent
Metode de instalare
Metoda 1: manager de pachete (recomandat începătorilor)
Ubuntu/Debian:
# Adaugă PPA Ansible pentru cea mai recentă versiune
sudo apt-add-repository ppa:ansible/ansible
sudo apt update
sudo apt install ansible -y
RHEL/CentOS/Rocky Linux:
# Activează depozitul EPEL
sudo dnf install epel-release -y
sudo dnf install ansible -y
macOS:
# Folosește Homebrew
brew install ansible
Metoda 2: Python pip (funcții mai noi)
# Instalează pipx (mediu izolat recomandat)
python3 -m pip install --user pipx
python3 -m pipx ensurepath
# Instalează Ansible cu pipx
pipx install --include-deps ansible
# Verifică instalarea
ansible --version
Metoda 3: Docker (portabil)
# Obține containerul oficial Ansible
docker pull quay.io/ansible/ansible:latest
# Rulează Ansible într-un container
docker run --rm -it quay.io/ansible/ansible:latest ansible --version
Verificarea instalării
# Verifică versiunea Ansible
ansible --version
# Rezultat așteptat (2026):
# ansible [core 2.16.5]
# config file = /etc/ansible/ansible.cfg
# python version = 3.11.8
# jinja version = 3.1.3
Configurarea inițială
Creează fișierul de configurare Ansible:
# Creează directorul de configurare
mkdir -p ~/.ansible
# Creează ansible.cfg
cat > ~/.ansible/ansible.cfg << 'EOF'
[defaults]
inventory = ~/ansible/inventory
host_key_checking = False
retry_files_enabled = False
gathering = smart
fact_caching = jsonfile
fact_caching_connection = /tmp/ansible_facts
fact_caching_timeout = 3600
[privilege_escalation]
become = True
become_method = sudo
become_user = root
become_ask_pass = False
EOF
Concepte esențiale: componentele Ansible
1. Inventar: definirea infrastructurii
Un inventar definește gazdele și grupurile gestionate de Ansible. Poate fi static (fișier INI sau YAML) ori dinamic (scripturi sau pluginuri).
Inventar static (format INI)
# inventory/hosts.ini
# Grup de servere web
[webservers]
web1.example.com
web2.example.com
web3.example.com
# Grup de servere de baze de date
[databases]
db1.example.com ansible_host=192.168.1.100
db2.example.com ansible_host=192.168.1.101
# Echilibratoare de sarcină
[loadbalancers]
lb1.example.com
# Grup de grupuri
[production:children]
webservers
databases
loadbalancers
# Variabile pentru toate serverele web
[webservers:vars]
ansible_user=deploy
ansible_port=22
http_port=80
https_port=443
# Variabile pentru toate gazdele
[all:vars]
ansible_python_interpreter=/usr/bin/python3
Inventar static (format YAML, recomandat în 2026)
# inventory/hosts.yml
all:
vars:
ansible_python_interpreter: /usr/bin/python3
children:
webservers:
hosts:
web1.example.com:
web2.example.com:
web3.example.com:
vars:
ansible_user: deploy
http_port: 80
https_port: 443
databases:
hosts:
db1.example.com:
ansible_host: 192.168.1.100
db2.example.com:
ansible_host: 192.168.1.101
vars:
ansible_user: dbadmin
production:
children:
webservers:
databases:
Inventar dinamic (furnizori cloud)
Pentru medii cloud, folosește pluginuri de inventar dinamic:
AWS EC2:
# inventory/aws_ec2.yml
plugin: amazon.aws.ec2
regions:
- us-east-1
- us-west-2
filters:
tag:Environment: production
keyed_groups:
- key: tags.Application
prefix: app
Azure:
# inventory/azure_rm.yml
plugin: azure.azcollection.azure_rm
include_vm_resource_groups:
- production-rg
keyed_groups:
- key: tags.role
prefix: role
2. Playbook-uri: planuri de automatizare
Playbook-urile sunt fișiere YAML care descriu fluxuri de automatizare și starea dorită a infrastructurii.
Exemplu simplu de playbook
# simple_playbook.yml
---
- name: Configurează serverele web
hosts: webservers
become: yes
tasks:
- name: Instalează Nginx
apt:
name: nginx
state: present
update_cache: yes
when: ansible_os_family == "Debian"
- name: Pornește și activează Nginx
service:
name: nginx
state: started
enabled: yes
- name: Copiază conținutul site-ului
copy:
src: ./website/
dest: /var/www/html/
owner: www-data
group: www-data
mode: '0644'
- name: Configurează paravanul de protecție
ufw:
rule: allow
port: '{{ item }}'
proto: tcp
loop:
- 80
- 443
Rularea playbook-urilor
# Execuție de bază
ansible-playbook simple_playbook.yml
# Cu inventar specific
ansible-playbook -i inventory/hosts.yml simple_playbook.yml
# Limitează la gazde specifice
ansible-playbook simple_playbook.yml --limit web1.example.com
# Rulare de probă (mod de verificare)
ansible-playbook simple_playbook.yml --check
# Rezultat detaliat pentru depanare
ansible-playbook simple_playbook.yml -vvv
3. Module: unități reutilizabile de sarcini
Modulele Ansible sunt elementele de bază ale automatizării. Fiecare modul execută o sarcină specifică.
Module frecvent folosite (2026)
Module de sistem:
# Gestionarea pachetelor
- name: Instalează pachetele (apt)
apt:
name:
- nginx
- git
- python3-pip
state: present
# Gestionarea serviciilor
- name: Gestionează serviciile
systemd:
name: nginx
state: started
enabled: yes
Module pentru fișiere:
# Operațiuni cu fișiere
- name: Creează un director
file:
path: /opt/myapp
state: directory
owner: appuser
mode: '0755'
# Copiază fișiere
- name: Implementează configurația
copy:
src: config.yml
dest: /etc/myapp/config.yml
backup: yes
# Șablon cu variabile
- name: Implementează configurația nginx
template:
src: nginx.conf.j2
dest: /etc/nginx/nginx.conf
notify: restart nginx
Module cloud (exemplu AWS):
# Creează o instanță EC2
- name: Pornește o instanță EC2
amazon.aws.ec2_instance:
name: webserver-01
instance_type: t3.medium
image_id: ami-0c55b159cbfafe1f0
region: us-east-1
vpc_subnet_id: subnet-12345678
security_group: web-sg
key_name: my-keypair
tags:
Environment: production
Application: web
# Creează un bucket S3
- name: Creează un bucket S3
amazon.aws.s3_bucket:
name: my-app-bucket
region: us-east-1
versioning: yes
encryption: AES256
Module pentru baze de date:
# Gestionarea bazelor de date MySQL
- name: Creează o bază de date MySQL
mysql_db:
name: webapp_db
state: present
login_user: root
login_password: "{{ mysql_root_password }}"
- name: Creează un utilizator MySQL
mysql_user:
name: webapp_user
password: "{{ db_password }}"
priv: 'webapp_db.*:ALL'
state: present
4. Variabile: playbook-uri flexibile
Variabilele permit reutilizarea playbook-urilor în medii diferite.
Prioritatea variabilelor (de la cea mai mare)
- Variabile suplimentare (
-eîn linia de comandă) - Variabile de sarcină
- Variabile de bloc
- Variabile de rol și include
- Variabile de play
- Fapte despre gazdă
host_varsale playbook-uluigroup_varsale playbook-uluihost_varsale inventaruluigroup_varsale inventarului- Valori implicite pentru roluri
Exemple de variabile
Variabile de playbook:
---
- name: Implementează aplicația
hosts: webservers
vars:
app_name: myapp
app_version: 2.5.0
app_port: 8080
tasks:
- name: Implementează {{ app_name }} versiunea {{ app_version }}
docker_container:
name: "{{ app_name }}"
image: "registry.example.com/{{ app_name }}:{{ app_version }}"
ports:
- "{{ app_port }}:8080"
group_vars (specifice mediului):
# group_vars/production.yml
app_environment: production
db_host: prod-db.example.com
db_port: 3306
log_level: warning
max_connections: 1000
# group_vars/development.yml
app_environment: development
db_host: dev-db.example.com
db_port: 3306
log_level: debug
max_connections: 100
Ansible Vault (variabile criptate):
# Creează un fișier criptat
ansible-vault create secrets.yml
# Editează un fișier criptat
ansible-vault edit secrets.yml
# Conținutul secrets.yml:
# db_password: supersecret123
# api_key: abc123xyz789
# Folosește în playbook
ansible-playbook deploy.yml --ask-vault-pass
5. Roluri: organizarea automatizării complexe
Rolurile oferă o modalitate structurată de organizare a playbook-urilor, făcându-le modulare și reutilizabile.
Structura completă a unui rol
roles/
└── nginx/
├── defaults/
│ └── main.yml # Variabile implicite
├── vars/
│ └── main.yml # Variabile ale rolului
├── tasks/
│ ├── main.yml # Lista principală de sarcini
│ ├── install.yml # Sarcini de instalare
│ └── configure.yml # Sarcini de configurare
├── handlers/
│ └── main.yml # Gestionare (repornirea serviciilor)
├── templates/
│ ├── nginx.conf.j2 # Șabloane Jinja2
│ └── site.conf.j2
├── files/
│ └── custom_module.sh # Fișiere statice
├── meta/
│ └── main.yml # Dependențele rolului
└── README.md # Documentație
Exemplu de rol: nginx
defaults/main.yml:
---
nginx_port: 80
nginx_user: www-data
nginx_worker_processes: auto
nginx_worker_connections: 1024
tasks/main.yml:
---
- name: Include variabile specifice sistemului de operare
include_vars: "{{ ansible_os_family }}.yml"
- name: Instalează Nginx
include_tasks: install.yml
- name: Configurează Nginx
include_tasks: configure.yml
- name: Asigură-te că Nginx rulează
service:
name: nginx
state: started
enabled: yes
tasks/install.yml:
---
- name: Instalează Nginx (Debian)
apt:
name: nginx
state: present
update_cache: yes
when: ansible_os_family == "Debian"
- name: Instalează Nginx (RedHat)
yum:
name: nginx
state: present
when: ansible_os_family == "RedHat"
handlers/main.yml:
---
- name: Repornește nginx
service:
name: nginx
state: restarted
- name: Reîncarcă nginx
service:
name: nginx
state: reloaded
templates/nginx.conf.j2:
user {{ nginx_user }};
worker_processes {{ nginx_worker_processes }};
events {
worker_connections {{ nginx_worker_connections }};
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
server {
listen {{ nginx_port }};
server_name {{ ansible_fqdn }};
location / {
root /var/www/html;
index index.html;
}
}
}
Utilizarea rolului:
---
- name: Configurează serverele web cu rolul Nginx
hosts: webservers
become: yes
roles:
- role: nginx
vars:
nginx_port: 8080
nginx_worker_processes: 4
Concepte avansate Ansible (2026)
Colecții Ansible
Colecțiile sunt un format de distribuție pentru conținut Ansible, precum module, roluri și pluginuri.
Instalarea colecțiilor
# Instalează din Ansible Galaxy
ansible-galaxy collection install community.general
ansible-galaxy collection install amazon.aws
ansible-galaxy collection install ansible.windows
# Instalează din fișierul de cerințe
# requirements.yml:
collections:
- name: community.general
version: ">=6.0.0"
- name: amazon.aws
version: "5.2.0"
ansible-galaxy collection install -r requirements.yml
Utilizarea modulelor din colecții
---
- name: Folosește modulele colecției
hosts: localhost
tasks:
- name: Folosește modulul Docker din community.general
community.general.docker_container:
name: webapp
image: nginx:latest
- name: Folosește modulul AWS EC2
amazon.aws.ec2_instance:
name: webserver
instance_type: t3.micro
Ansible Tower / AWX (funcții pentru companii)
Ansible Tower (comercial) și AWX (open source) oferă:
- Interfață web pentru executarea playbook-urilor
- Controlul accesului bazat pe roluri (RBAC)
- Programarea sarcinilor și fluxuri de lucru
- Înregistrare și audit centralizate
- API REST pentru integrare
- Gestionarea acreditărilor
- Sincronizarea inventarelor
Instalarea AWX cu Docker Compose:
# Clonează depozitul AWX
git clone https://github.com/ansible/awx.git
cd awx
# Implementează cu docker-compose
cd tools/docker-compose
docker-compose -f docker-compose.yml up -d
# Accesează http://localhost:80
# Autentificare implicită: admin / password
Automatizarea Windows cu Ansible
În 2026, Ansible oferă un suport Windows mult îmbunătățit:
Cerințe Windows:
# Activează WinRM pe gazda Windows
$url = "https://raw.githubusercontent.com/ansible/ansible/devel/examples/scripts/ConfigureRemotingForAnsible.ps1"
$file = "$env:temp\ConfigureRemotingForAnsible.ps1"
(New-Object -TypeName System.Net.WebClient).DownloadFile($url, $file)
powershell.exe -ExecutionPolicy ByPass -File $file
Inventar pentru Windows:
[windows]
win1.example.com
[windows:vars]
ansible_user=Administrator
ansible_password=SecurePassword123
ansible_connection=winrm
ansible_winrm_transport=ntlm
ansible_winrm_server_cert_validation=ignore
ansible_port=5986
Playbook de automatizare Windows:
---
- name: Configurarea serverului Windows
hosts: windows
gather_facts: yes
tasks:
- name: Instalează IIS
win_feature:
name: Web-Server
state: present
include_management_tools: yes
- name: Implementează site-ul web
win_copy:
src: ./website/
dest: C:\inetpub\wwwroot\
- name: Configurează paravanul de protecție
win_firewall_rule:
name: Permite HTTP
localport: 80
protocol: tcp
action: allow
direction: in
enabled: yes
- name: Instalează software prin Chocolatey
win_chocolatey:
name:
- googlechrome
- 7zip
- notepadplusplus
state: present
Automatizarea rețelelor cu Ansible
Ansible acceptă principalii furnizori de echipamente de rețea, inclusiv Cisco, Juniper, Arista și F5.
Playbook pentru dispozitive de rețea:
---
- name: Configurează switch-urile Cisco
hosts: cisco_switches
gather_facts: no
connection: network_cli
vars:
ansible_network_os: ios
ansible_user: admin
ansible_password: "{{ vault_switch_password }}"
tasks:
- name: Configurează VLAN-urile
cisco.ios.ios_vlans:
config:
- vlan_id: 10
name: DATA
- vlan_id: 20
name: VOICE
- vlan_id: 30
name: GUEST
state: merged
- name: Configurează interfața
cisco.ios.ios_interfaces:
config:
- name: GigabitEthernet1/0/1
description: Uplink to Core
enabled: true
- name: Salvează configurația
cisco.ios.ios_config:
save_when: always
Exemple și scenarii reale de utilizare
Scenariu 1: implementarea completă a unei aplicații web
Structura proiectului:
webapp-deployment/
├── ansible.cfg
├── inventory/
│ ├── production
│ └── staging
├── group_vars/
│ ├── all.yml
│ ├── production.yml
│ └── staging.yml
├── roles/
│ ├── common/
│ ├── nginx/
│ ├── postgresql/
│ └── application/
└── playbooks/
├── site.yml
└── deploy.yml
site.yml (implementarea întregii stive):
---
- name: Configurează toate serverele
hosts: all
become: yes
roles:
- common
- name: Configurează serverele de baze de date
hosts: databases
become: yes
roles:
- postgresql
- name: Configurează serverele web
hosts: webservers
become: yes
roles:
- nginx
- application
- name: Configurează echilibratoarele de sarcină
hosts: loadbalancers
become: yes
roles:
- haproxy
Scenariu 2: configurarea unui cluster Kubernetes
---
- name: Configurează clusterul Kubernetes
hosts: k8s_cluster
become: yes
tasks:
- name: Instalează Docker
apt:
name: docker.io
state: present
- name: Adaugă cheia apt Kubernetes
apt_key:
url: https://packages.cloud.google.com/apt/doc/apt-key.gpg
state: present
- name: Adaugă depozitul Kubernetes
apt_repository:
repo: deb https://apt.kubernetes.io/ kubernetes-xenial main
state: present
- name: Instalează componentele Kubernetes
apt:
name:
- kubelet=1.28.0-00
- kubeadm=1.28.0-00
- kubectl=1.28.0-00
state: present
- name: Inițializează masterul Kubernetes
hosts: k8s_master
become: yes
tasks:
- name: Inițializează clusterul
command: kubeadm init --pod-network-cidr=10.244.0.0/16
args:
creates: /etc/kubernetes/admin.conf
- name: Creează directorul .kube
file:
path: /home/{{ ansible_user }}/.kube
state: directory
owner: "{{ ansible_user }}"
- name: Copiază admin.conf
copy:
src: /etc/kubernetes/admin.conf
dest: /home/{{ ansible_user }}/.kube/config
remote_src: yes
owner: "{{ ansible_user }}"
Scenariu 3: automatizarea consolidării securității
---
- name: Consolidează securitatea
hosts: all
become: yes
tasks:
- name: Actualizează toate pachetele
apt:
upgrade: dist
update_cache: yes
- name: Instalează instrumente de securitate
apt:
name:
- fail2ban
- ufw
- aide
state: present
- name: Configurează fail2ban
copy:
src: jail.local
dest: /etc/fail2ban/jail.local
notify: restart fail2ban
- name: Configurează paravanul de protecție
ufw:
rule: "{{ item.rule }}"
port: "{{ item.port }}"
proto: "{{ item.proto }}"
loop:
- { rule: 'allow', port: '22', proto: 'tcp' }
- { rule: 'allow', port: '80', proto: 'tcp' }
- { rule: 'allow', port: '443', proto: 'tcp' }
- { rule: 'deny', port: '3306', proto: 'tcp' }
- name: Activează paravanul de protecție
ufw:
state: enabled
- name: Dezactivează autentificarea root
lineinfile:
path: /etc/ssh/sshd_config
regexp: '^PermitRootLogin'
line: 'PermitRootLogin no'
notify: restart sshd
- name: Setează politica parolelor
lineinfile:
path: /etc/login.defs
regexp: '^PASS_MAX_DAYS'
line: 'PASS_MAX_DAYS 90'
handlers:
- name: Repornește fail2ban
service:
name: fail2ban
state: restarted
- name: Repornește sshd
service:
name: sshd
state: restarted
Bune practici Ansible (ediția 2026)
1. Folosește controlul versiunilor (Git)
Structura depozitului:
ansible-infrastructure/
├── .gitignore
├── README.md
├── ansible.cfg
├── inventory/
├── group_vars/
├── host_vars/
├── roles/
├── playbooks/
└── files/
.gitignore:
*.retry
*.pyc
.vault_pass
secrets.yml
*.log
2. Aplică idempotenta
Greșit (nu este idempotent):
- name: Adaugă o linie în fișier
shell: echo "new line" >> /etc/myconfig
Corect (idempotent):
- name: Asigură-te că linia se află în fișier
lineinfile:
path: /etc/myconfig
line: "new line"
state: present
3. Folosește Ansible Lint pentru calitatea codului
# Instalează ansible-lint
pip install ansible-lint
# Rulează linterul
ansible-lint playbook.yml
# Repară automat problemele frecvente
ansible-lint --fix playbook.yml
4. Implementează testarea cu Molecule
# Instalează Molecule
pip install molecule molecule-docker
# Inițializează un rol nou cu teste
molecule init role my_role --driver-name docker
# Rulează testele
cd my_role
molecule test
# Etapele testării:
# - Creează mediul de testare
# - Convergență (rulează playbook-ul)
# - Verificare (rulează testele)
# - Distruge mediul
Exemplu molecule.yml:
---
dependency:
name: galaxy
driver:
name: docker
platforms:
- name: ubuntu2204
image: geerlingguy/docker-ubuntu2204-ansible:latest
pre_build_image: true
provisioner:
name: ansible
verifier:
name: ansible
5. Folosește etichete pentru execuție selectivă
---
- name: Configurare completă a serverului
hosts: webservers
become: yes
tasks:
- name: Instalează pachetele
apt:
name: nginx
state: present
tags:
- packages
- nginx
- name: Configurează Nginx
template:
src: nginx.conf.j2
dest: /etc/nginx/nginx.conf
tags:
- configuration
- nginx
- name: Implementează aplicația
copy:
src: app/
dest: /var/www/html/
tags:
- deployment
- application
# Rulează doar sarcinile nginx
# ansible-playbook play.yml --tags nginx
# Omite implementarea
# ansible-playbook play.yml --skip-tags deployment
6. Gestionarea erorilor și depanare
---
- name: Executare robustă a sarcinilor
hosts: webservers
tasks:
- name: Încearcă o operațiune riscantă
command: /usr/bin/risky_command
register: result
failed_when: false
changed_when: result.rc == 0
- name: Ieșire de depanare
debug:
var: result
verbosity: 2
- name: Gestionează eșecul
debug:
msg: "Comanda a eșuat, dar execuția continuă..."
when: result.rc != 0
- name: Bloc cu recuperare
block:
- name: Încearcă mai întâi acest lucru
command: /may/fail
- name: Dacă reușește, fă acest lucru
debug:
msg: "Succes!"
rescue:
- name: Dacă eșuează, fă acest lucru în schimb
debug:
msg: "Recuperare după eșec"
always:
- name: Rulează întotdeauna acest lucru
debug:
msg: "Operațiuni de curățare"
7. Optimizarea performanței
Activarea pipelining
# ansible.cfg
[defaults]
pipelining = True
Folosește Mitogen (performanță de 3-7 ori mai bună)
# Instalează Mitogen
pip install mitogen
# ansible.cfg
[defaults]
strategy_plugins = /path/to/mitogen/ansible_mitogen/plugins/strategy
strategy = mitogen_linear
Execuție paralelă
---
- name: Actualizări paralele
hosts: all
strategy: free # Nu aștepta toate gazdele
serial: 10 # Procesează câte 10 gazde
tasks:
- name: Actualizează pachetele
apt:
upgrade: dist
Depanarea problemelor comune
Problema 1: erori de conexiune SSH
Problema: nu te poți conecta la gazdele gestionate
Soluții:
# Testează conexiunea SSH brută
ssh -vvv user@host
# Testează conexiunea Ansible
ansible host -m ping -vvv
# Adaugă în inventar
[all:vars]
ansible_ssh_common_args='-o StrictHostKeyChecking=no'
Problema 2: acces refuzat (sudo)
Problema: sarcinile eșuează din cauza erorilor de permisiune
Soluție:
---
- hosts: webservers
become: yes
become_method: sudo
become_user: root
tasks:
- name: Sarcină care necesită root
file:
path: /etc/myconfig
state: touch
Problema 3: modul negăsit
Problema: erori care indică lipsa modulului
Soluție:
# Asigură-te că este instalată colecția
ansible-galaxy collection install community.general
# Verifică colecția
ansible-galaxy collection list
# Folosește FQCN (numele complet calificat al colecției)
community.general.docker_container:
name: mycontainer
Problema 4: executarea lentă a playbook-ului
Soluții:
- Activează pipelining (vezi secțiunea Performanță)
- Folosește pluginul de strategie Mitogen
- Dezactivează colectarea faptelor dacă nu este necesară:
- hosts: all gather_facts: no - Folosește execuția asincronă pentru sarcini de durată:
- name: Sarcină de lungă durată command: /usr/bin/long_task async: 3600 poll: 0
Parcurs profesional și certificări Ansible
Evoluția competențelor
Începător (0-6 luni):
- Scrie playbook-uri de bază
- Înțelege inventarul și variabilele
- Folosește module comune
- Execută playbook-uri
Intermediar (6-18 luni):
- Creează roluri reutilizabile
- Implementează gestionarea erorilor
- Folosește Ansible Vault
- Integrează cu CI/CD
- Gestionează mai multe medii
Avansat (peste 18 luni):
- Proiectează framework-uri complexe de automatizare
- Creează module și pluginuri personalizate
- Proiectează implementări Tower/AWX
- Optimizează performanța
- Îi îndrumă pe alții
Certificări
Red Hat Certified Specialist in Ansible Automation (EX407)
- Demonstrează competența în Ansible
- Examen practic, bazat pe performanță
- Valabilă 3 ani
- Recunoscută în industrie
Resurse de pregătire:
- Red Hat Learning Subscription
- Documentația Ansible
- Laboratoare practice (A Cloud Guru, Udemy)
- Forumuri ale comunității
Piața muncii (2026)
Salarii medii în SUA:
- Inginer Ansible junior: $75,000-$95,000
- Inginer DevOps de nivel mediu (Ansible): $110,000-$140,000
- Arhitect senior de automatizare: $150,000-$190,000
Competențe căutate:
- Ansible și Kubernetes
- Ansible și Terraform (IaC hibrid)
- Ansible și CI/CD (Jenkins, GitLab)
- Ansible și cloud (AWS, Azure, GCP)
- Administrarea Ansible Tower/AWX
Resurse de învățare și comunitate
Documentație oficială
- Documentația Ansible
- Ansible Galaxy - platformă de partajare a rolurilor
- Ansible pe GitHub
Cursuri online
- Red Hat Learning Subscription
- Udemy:
Ansible pentru începători absoluți - A Cloud Guru:
Ansible practic - Linux Academy:
Pornire rapidă cu Ansible
Cărți
Ansible for DevOpsde Jeff Geerling (actualizată în 2025)Ansible: Up and Runningde Lorin HochsteinMastering Ansiblede James Freeman
Comunitate
- Lista de distribuție Ansible
- Ansible pe Reddit
- Serverul Ansible pe Discord
- Întâlniri Ansible locale și online
Platforme de practică
- Scenarii Ansible pe Katacoda
- Ansible Playground
- Laborator local cu Vagrant sau Docker
Concluzie: începe parcursul tău cu Ansible
Ansible a devenit instrumentul de automatizare ales de organizații din întreaga lume. În 2026 oferă mai multe funcționalități, gestionare Windows mai simplă, integrări cloud îmbunătățite și generarea de playbook-uri asistată de AI. Competențele dobândite îți vor fi utile de-a lungul carierei IT, indiferent dacă gestionezi infrastructură tradițională, medii cloud sau implementări hibride.
Idei principale:
- Începe simplu: creează playbook-uri de bază pentru câteva servere
- Exersează regulat: configurează un laborator acasă și experimentează
- Învață prin practică: automatizează sarcini reale din activitatea zilnică
- Respectă bunele practici: folosește controlul versiunilor, teste și documentație
- Alătură-te comunității: învață de la alții și împărtășește ce știi
- Ține pasul: Ansible evoluează rapid, continuă să înveți
- Combină instrumente: Ansible, Terraform și Kubernetes oferă împreună automatizare extinsă
Pașii următori:
- Instalează Ansible pe sistemul tău
- Creează un inventar simplu cu servere de test, mașini virtuale sau containere
- Scrie primul playbook, de exemplu pentru instalarea unui pachet
- Adaugă treptat șabloane, variabile și roluri
- Contribuie cu roluri comunitare pe Ansible Galaxy
- Ia în considerare o certificare pentru a-ți valida competențele
Parcursul de la începător la expert Ansible este satisfăcător și deschide oportunități în DevOps, SRE și ingineria cloud. Cu noțiunile de bază din acest ghid, poți începe să automatizezi infrastructura și să dezvolți competențe valoroase pentru domeniul IT modern.
Bine ai venit în lumea automatizării infrastructurii cu Ansible!
Referințe
- Documentația oficială Ansible
- Ansible Galaxy - depozit de roluri
- Depozitul Ansible pe GitHub
- Red Hat Ansible Automation Platform
- AWX - Ansible Tower open source
- Bune practici Ansible
- Framework-ul de testare Molecule
- Ansible Lint
- Ansible for DevOps de Jeff Geerling
- Indexul colecțiilor Ansible






