Unlock Ansible Mastery: Complete Guide to Automation, Playbooks & Roles

Introduction to Ansible

Ansible is an agentless automation tool written in Python that uses SSH for remote execution. It supports a wide range of modules for tasks such as command execution, file manipulation, package management, and service control.

Installation

Ansible can be installed via package managers, EPEL repositories, source compilation, Git, or pip. Verify the installation with ansible --version.

Core Concepts

Inventory : Defines target hosts and groups, supporting static INI files and dynamic sources.

Modules : Reusable units of work (e.g., yum, service, copy, template).

Ad‑hoc Commands : Quick one‑off tasks using ansible CLI.

Playbooks : YAML files that describe a series of plays, each targeting hosts and running ordered tasks.

Basic Commands

# List hosts
ansible all --list-hosts
# Run a command on all hosts
ansible all -m ping
# Install a package
ansible webservers -m yum -a "name=httpd state=present"

Playbook Structure

A playbook consists of hosts, optional remote_user, and a list of tasks. Each task specifies a module and its arguments. Example:

---
- hosts: webservers
  remote_user: root
  tasks:
    - name: Install Apache
      yum:
        name: httpd
        state: present
    - name: Deploy config
      copy:
        src: httpd.conf
        dest: /etc/httpd/conf/httpd.conf
        backup: yes
      notify: Restart Apache
    - name: Ensure service is running
      service:
        name: httpd
        state: started
        enabled: yes

handlers:
  - name: Restart Apache
    service:
      name: httpd
      state: restarted

Variables

Variables can be defined in playbooks, external files, inventory, or passed via the command line ( -e var=value). Access them with {{ variable_name }}.

Templates

Jinja2 templates allow dynamic configuration files. Store templates in a templates/ directory and use the template module.

# templates/nginx.conf.j2
worker_processes {{ ansible_processor_vcpus }};

Handlers & Notifications

Handlers run only when notified by a task that reports a change, enabling idempotent service restarts.

Tags

Tag tasks or entire plays to run subsets of a playbook with --tags or skip with --skip-tags.

Conditional Execution

Use when statements to run tasks based on facts or variables.

Loops

Iterate over lists with with_items to apply a task multiple times.

Roles

Roles provide a reusable directory structure ( tasks/, handlers/, templates/, vars/) for modular playbooks. Example role layout:

roles/
  nginx/
    tasks/main.yml
    handlers/main.yml
    templates/nginx.conf.j2
    vars/main.yml

Include roles in a playbook with the roles keyword.

Practical Examples

Creating users and groups with the user and group modules.

Deploying a MySQL server using an archive, configuration file, and service management.

Setting up Nginx with templated configuration and conditional handling for different OS versions.

Using with_items to install multiple packages in a single task.

Advanced Topics

Serial execution for rolling updates.

Gathering facts with the setup module.

Using when with distribution version checks.

Combining loops and conditionals in templates.

These concepts enable you to build robust, repeatable automation pipelines for server provisioning, configuration, and application deployment.