7 Ansible Fundamentals: Understanding Plays and Playbooks

In the previous article, we covered Ansible installation and configuration—including how to create configuration files. Today, we’ll dive deeper into two fundamental Ansible concepts: Play and Playbook. Understanding these is essential for effective infrastructure automation with Ansible.

Play in Ansible

A Play is a mechanism in Ansible for executing a defined set of tasks on target hosts. It consists of one or more Tasks, where each Task represents a specific action (e.g., installing a package or copying a file) performed on the targeted hosts. The primary purpose of a Play is to apply a group of predefined tasks to a specified host group.

A basic Play structure looks like this:

- name: Example Play
  hosts: web_servers
  tasks:
    - name: Install Nginx
      apt:
        name: nginx
        state: present

In this example, we define a Play with the following key elements:

• name: A descriptive label explaining the purpose of the Play.
• hosts: Specifies the target host group (e.g., web_servers)—defined earlier in the inventory.
• tasks: A list of operations to execute; here, only one task installs Nginx.

Playbook in Ansible

A Playbook is a collection of one or more Plays, written in YAML. It enables you to declaratively define complex, multi-step automation workflows—spanning multiple hosts, roles, and operations—in a clean, human-readable, and maintainable format. As the core unit of Ansible automation, Playbooks make it possible to express sophisticated orchestration logic simply and reliably.

Here’s an example Playbook containing two Plays:

---
- name: Deploy Web Server
  hosts: web_servers
  tasks:
    - name: Install Nginx
      apt:
        name: nginx
        state: present

- name: Configure Nginx
  hosts: web_servers
  tasks:
    - name: Copy Nginx configuration file
      copy:
        src: /path/to/nginx.conf
        dest: /etc/nginx/nginx.conf

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

This Playbook contains two distinct Plays:

1. The first Play deploys the web server by installing Nginx.
2. The second Play configures the same host group—copying the Nginx configuration file and restarting the service.

Key Takeaways

• A Play is Ansible’s basic unit of execution: a set of tasks applied to a designated host group.
• A Playbook is a structured, reusable collection of one or more Plays, representing a complete automation workflow.
• Written in YAML, Playbooks emphasize readability, clarity, and maintainability.

Real-World Use Case

Suppose you’re managing a web server and need to deploy a simple Flask-based web application. You can automate the entire process using a single Playbook:

---
- name: Deploy Web Application
  hosts: web_servers
  tasks:
    - name: Update APT cache
      apt:
        update_cache: yes

    - name: Install Python3
      apt:
        name: python3
        state: present

    - name: Install Python dependencies
      pip:
        name: flask

    - name: Clone application code
      git:
        repo: 'https://github.com/yourusername/your-flask-app.git'
        dest: /var/www/your-flask-app

    - name: Start Flask application
      command: python3 /var/www/your-flask-app/app.py

In this example, the Playbook orchestrates the full deployment lifecycle: updating the package cache, installing Python and required dependencies, cloning the application source code from Git, and launching the Flask app—all in sequence and with clear, self-documenting steps.

Summary

Mastering Plays and Playbooks empowers you to build modular, reusable, and scalable automation workflows. In the next article, we’ll explore the structure and usage of Inventory files, helping you efficiently manage and organize your target host definitions.

We hope today’s overview strengthens your foundational understanding of Ansible—and sets you up for success in the articles ahead.