What is an Ansible Playbook and How to Write One on Your Own

What is an Ansible Playbook?

An Ansible playbook is a file that contains a set of instructions that Ansible can use to automate tasks on remote hosts. Playbooks are written in YAML, a human-readable markup language.

A playbook typically consists of one or more plays, a collection of tasks run in sequence. Each task is a single instruction that Ansible can execute, such as installing a package, configuring a service, or copying a file.

By using Ansible playbooks, IT operations teams can automate infrastructure provisioning, configuration management, application deployment, and other operational tasks. Playbooks provide a concise and human-readable way to describe the desired automation workflows, making managing and scaling infrastructure configurations easier.

How Do Ansible Playbooks Work?

Ansible playbooks work by using a simple but powerful language called YAML. YAML is a human-readable markup language that is easy to learn and use.

A playbook typically consists of one or more plays, which are a collection of tasks that are run in sequence. Each task is a single instruction that Ansible can execute, such as installing a package, configuring a service, or copying a file.

When you run an Ansible playbook, Ansible first reads the playbook file and parses the YAML syntax. Then, Ansible connects to the remote hosts listed in the playbook and executes the tasks in sequence.

Ansible uses a concept called "modules" to execute tasks. Modules are small, reusable programs that are written in Python. It has a large library of modules that are used to perform a range of tasks.

For example, the apt module can be used to install packages from the APT repository, the service module can be used to start, stop, or restart services, and the copy module are used to copy files from one location to another.

When Ansible executes a task, it first looks for a module that matches the task's name. Ansible executes the module on the remote host if a matching module is found.

Ansible will try to execute the task as a shell command if a matching module is not found. This means that you can use Ansible to execute any command that you can run from the command line.

Ansible playbooks are a powerful tool for automating IT tasks. They are easy to learn and use, and they can be used to manage a large number of hosts.

Here are some of the steps involved in how Ansible playbooks work:

1. The Ansible playbook is parsed and the tasks are executed in sequence.
2. For each task, Ansible looks for a matching module.
3. If a matching module is found, the module is executed on the remote host.
4. The task is executed as a shell command if a matching module is not found.
5. Ansible continues to execute the tasks in the playbook until all of the tasks have been completed.

How to Use Ansible Playbooks?

To use Ansible playbooks, follow these steps:

• Install Ansible: Ensure that Ansible is installed on your control machine. Refer to the official Ansible documentation for installation instructions specific to your operating system.
• Inventory Configuration: Create an inventory file that lists the target hosts or groups of hosts you want to manage with Ansible. The inventory file can be a simple text file or an INI/JSON/YAML file. Define hostnames, IP addresses, and any necessary connection parameters (such as SSH credentials) in the inventory file.
• Create a Playbook: Create a YAML file with a .yaml or .yml extension to define your playbook. Playbooks consist of plays, which are sets of tasks to be executed on specific hosts or host groups.
• Define Plays and Tasks: Within the playbook, define one or more plays, each with a set of tasks. Tasks represent individual units of work to be executed on the target hosts. Specify the modules to be used, along with their parameters, to perform the desired actions.
• Optional: Use Variables and Templates: Leverage variables to make your playbook dynamic and reusable. Define variables within the playbook or in separate variable files. Use Jinja2 templates to generate configuration files or customize values based on variables dynamically.
• Run the Playbook: Execute the playbook using the ansible-playbook command followed by the path to your playbook file. Ansible will read the playbook, connect to the target hosts specified in the inventory, and execute the defined tasks.
• Monitor and Verify: During playbook execution, Ansible will provide feedback on each task's status. Monitor the output to ensure that the playbook runs without errors and performs the desired actions on the target hosts. Verify the changes made by the playbook on the target systems.
• Iterate and Refine: Modify your playbook as needed to meet your specific requirements. Iterate, test, and refine your playbooks to automate additional tasks, manage different systems, or handle more complex scenarios.

How to Write an Ansible Playbook?

The above examples were simple and straightforward. Ansible playbooks can potentially get quite larger and more complex. But whether you’re creating a short and sweet playbook or a sweeping epic, here is how you put one together.

Every playbook breaks down into the same standard sections:

• Playbooks begin with three hyphens. ---

• Host

The host section defines the target machines where the playbook will run. This information is based on the Ansible inventory file. The host section is, therefore, a list of devices.

• Variable

The variable section is optional and includes any variables that the playbook requires. It can be as large or as small as needed, if at all.

• Tasks

The task section lists all tasks that the target machine must run and specifies the use of Modules. Every task gets a name, usually a small description of what the task does and is listed when the playbook runs.

• End

Most playbooks end with three periods. …

And here are some useful pointers to remember when working with Ansible playbooks:

• Playbooks are written in the YAML format and have a .yml file extension
• Use this command to run a playbook: $ ansible-playbook <playbook.yml>
• Use this command to check the playbook for syntax errors: $ ansible-playbook <playbook.yml> --syntax-check
• Create lists. Lists define elements within playbook variables. Use the – symbol to create a list
• Include whitespaces. If you put a blank line between each task or block, it makes the playbook easier to scan
• Name your tasks. Task naming is optional, but it comes in handy. Pick names that explain what each task does
• Include the state. Although the ‘state’ parameter isn’t mandatory, you may want to use state settings such as ‘state=present’ or ‘state=absent’ for the sake of clarity
• Employ comments. Even if you name tasks and states, some instances require more information. Add a comment (starting the line with an #) to help users understand (or to remind yourself!), what a task or play is doing, how it’s doing it, and why

A Practical Example of an Ansible Playbook

YAML

---

- hosts: all

  tasks:

    - name: Install the Apache web server

      apt:

        name: apache2

        state: present

    - name: Configure the Apache web server

      service:

        name: apache2

        state: started

        enabled: yes

    - name: Copy the index.html file to the web root

      copy:

        src: index.html

        dest: /var/www/html/index.html

This playbook would install the Apache web server on all of the hosts listed in the hosts variable, and then configure it to start automatically when the system boots. It would also copy the index.html file to the web root.

The hosts variable specifies the hosts that the playbook will run on. In this case, the playbook will run on all of the hosts in the inventory file.

The tasks section of the playbook specifies the tasks that will be executed. Each task is a single instruction that Ansible can execute.

In this example, there are three tasks:

• The first task installs the Apache web server using the apt module.
• The second task configures the Apache web server using the service module.
• The third task copies the index.html file to the web root using the copy module.

To run this playbook, you would need to save it as a file with a .yaml extension. Then, you would run the playbook using the ansible-playbook command. For example, to run the playbook on all of the hosts in the inventory file, you would run the following command:

ansible-playbook playbook.yaml

What Are Ansible Playbooks Used For?

Ansible playbooks run multiple tasks, assign roles, and define configurations, deployment steps, and variables. If you’re using multiple servers, Ansible playbooks organize the steps between the assembled machines or servers and get them organized and running in the way the users need them to. Consider playbooks as the equivalent of instruction manuals.

Users can employ Ansible playbooks to manage deployments to and configurations of remote machines. Furthermore, playbooks can sequence a multi-tiered rollout that uses rolling updates—launching tasks either synchronously or asynchronously.

In summary, Ansible playbooks help users easily control multiple machines and have all affected units act in harmony. It is an immensely powerful resource for DevOps professionals to have under their belts.

What Kinds of Variables Do Ansible Playbooks Have?

Ansible uses variables to help users deal with the differences between systems, as no two systems are precisely alike. Variable names consist of letters, numbers, and underscores, though they should always begin with a letter. Also, variables never contain blank spaces.

You can define variables directly in playbooks by using the “vars:” command. Variables can be anything from proper nouns, ports to web servers, or a given command. For instance, you could arrange a playbook to greet people with “How’s it going, eh?” by creating a variable name “greeting,” with a value of “How’s it going, eh?” When the user executes the playbook, it displays the message on the terminals.

Variables store values, and you can create almost any kind of variable you need. There are group and host variables, inventory file variables, array variables, dictionary variables, and special variables. Special variables are built-in variables that can’t be set by the user, and Ansible always overrides them.

You can also keep variables in a separate file and, when needed, import it with the vars_files command.

Note that your playbook doesn’t have to include variables if there is no need for them. They are purely optional.

A Word About Ad-Hoc Commands

Ad-hoc commands automate a single task on one or more managed nodes, using the /usr/bin/ansible command-line tool. These commands are fast and easy to create, but are not reusable. They are ideal for tasks that you don’t perform very often. For instance, you can use an ad-hoc command to copy a file.

It’s necessary to master ad-hoc commands because they not only show the simplicity and versatility of Ansible, but many ad-hoc command concepts apply to playbooks.

DevOps Tool Resources

DevOps is a commonly used software development process that has spawned many useful tools. Of course, we’ve already touched upon Ansible, but there are other equally valuable resources out there. Simplilearn has gathered a collection of these resources for you to benefit from.

For starters, check out this Ansible vs. Kubernetes article that compares these two tools and how they stack up for DevOps professionals. Ansible vs. Puppet compares and contrasts these two worthy configuration management (CM) tools, and finally, Ansible vs. Chef breaks down the differences between these two useful resources.

If you want to expand your DevOps knowledge even further after seeing the available variety of tools, check out the Post Graduate Program in DevOps. Designed in collaboration with CalTech CTME, this program sharpens your expertise in Chef, Ansible, and Puppet while helping you master the means of improving your team’s DevOps capabilities. It’s an “all in one” program that will boost your DevOps understanding and help you be a better team leader, while it familiarizes you with the most popular tools available today.

Choose The Right DevOps Program

This table compares various DevOps programs offered by Simplilearn, based on several key features and details. The table provides an overview of the courses' duration, skills you will learn, additional benefits, among other important factors, to help you make an informed decision about which course best suits your needs.

Program Name	DevOps Engineer Masters Program	Post Graduate Program in DevOps
Geo	All	All
University	Simplilearn	Caltech
Course Duration	11 Months	9 Months
Coding Experience Required	Basic Knowledge	Basic Knowledge
Skills You Will Learn	40+ Skills Including Ansible, Puppet, Chef, Jenkins, etc.	10+ Skills Including CI,CD, DevOps on Cloud, Deployment Automation, etc.
Additional Benefits	Masters Certification Real Life Projects Learn 40+ Skills and Tools	Caltech Campus Connect Career Services Masterclasses by Caltech Instructors
Cost	$$	$$$
	Explore Program	Explore Program

How Would You Like to Be a DevOps Engineer?

DevOps engineers are responsible for managing the IT infrastructure that handles software development. They communicate with development teams, assist in coding and scripting, and deliver the results of testing, and troubleshooting, and user feedback.

If this sounds like the type of career you’d like to get into, Simplilearn’s DevOps Engineer Master’s program will prepare you for a DevOps career that offers excitement, challenges, and the chance to work with IT teams. You will acquire expertise in the principles of continuous development and deployment, automation of configuration management, inter-team collaboration, and IT service agility, using DevOps tools such as Git, Docker, Jenkins, and more.

The program consists of seven courses, introducing you to over 40 in-demand skills and more than 15 DevOps-related tools. According to Payscale, DevOps Engineers can earn an annual average of USD 94,660, with a high mark of around USD 136,000.

If you’re not ready to tackle a massive DevOps Engineer program but would like to get acquainted with Ansible, check out Simplilearn’s Ansible Foundation Training Course. The course offers you four and a half hours of self-paced learning. It is ideal for beginners who want to understand Ansible 2.0 installation better, create their own playbooks, manage an entire cloud region, and configure network devices across Linux or Windows operating systems.

Whether you want to take those first steps in a DevOps Engineer career or are only interested in becoming proficient with Ansible, Simplilearn has everything you need to meet your goals. Check them out today!

FAQs

1. What is Ansible playbook for?

Ansible playbooks are used for automation and configuration management. They allow you to define a set of tasks and configurations in a structured format to be executed on target hosts. Playbooks help streamline operations, ensure consistency, and automate tasks such as provisioning infrastructure, deploying applications, and managing configurations.

2. What file type is Ansible playbook?

Ansible playbooks are YAML files. They typically have a .yaml or .yml file extension. YAML (YAML Ain't Markup Language) is a human-readable data serialization format that uses indentation and key-value pairs to represent data structures. Ansible leverages YAML's simplicity and readability to define playbooks in a concise and structured manner.

3. What is the difference between Ansible play and task?

In Ansible, a play is a high-level structure within a playbook that associates a set of tasks with a specific group of hosts. A play defines the scope, hosts, and other parameters for executing a sequence of tasks. On the other hand, a task represents an individual unit of work within a play. Tasks define the actions to be performed on the target hosts, such as installing packages, copying files, or running commands.

4. What is playbook syntax?

Playbook syntax refers to the structure and format used to define Ansible playbooks. Ansible playbooks use YAML syntax, which includes indentation, key-value pairs, and a hierarchical structure to organize plays, tasks, and other components. Proper indentation and adherence to YAML syntax rules are crucial for the correct interpretation and execution of Ansible playbooks.