In this lesson, you will learn about Ansible handlers, their importance in playbook design, and how to effectively use them to manage service states or perform tasks based on the results of other tasks. Handlers are special tasks in Ansible that run only when notified by another task. This mechanism is particularly useful for optimizing your automation scripts by ensuring certain actions, like restarting a service, are only performed when necessary.

Understanding Ansible Handlers

Handlers are triggered by other tasks in your Ansible playbook that might make changes requiring a service restart or another follow-up action. For instance, if you're deploying a new version of a web application and need to restart the web server to apply the changes, you'd use a handler for the restart action. The beauty of handlers is that they run at the end of your playbook's execution and only if they've been 'notified' by another task, ensuring that a service is not unnecessarily restarted multiple times, which could cause service downtime or other issues.

How to Define and Use Handlers

To define a handler, you'll usually place it under the handlers section in your Ansible playbook or inside role's handlers/main.yml.

Let's create a handler that will restart the Nginx service. Nano the following file to create the handler YAML file:

nano roles/webserver/handlers/handlers.yml

Next, create the handlerlike so:

- name: restart nginx
  become: yes
  service:
    name: nginx
    state: restarted

Save and close the file.

handlers:
  - name: restart nginx
    become: yes
    service:
      name: nginx
      state: restarted

This handler, named restart nginx, uses the service module to restart the Nginx service. To trigger this handler, you must notify it from a task. Let's update our webservers main task to include the notify action on our template task with the notify block:

---
# Tasks for webserver role
- name: Install Nginx
  apt:
    name: nginx
    state: present
  become: yes

- name: Template index.html.j2 to web directory
  template:
    src: index.html.j2
    dest: /var/www/html/index.html
  become: yes
  notify: restart nginx

In this task, if the template module changes the nginx.conf file (indicating that the file on the server was replaced with a new version), the restart nginx handler is notified. However, the actual restart doesn't happen immediately but is instead deferred until all tasks in the playbook have run. If multiple tasks notify the handler, the handler still runs only once, avoiding unnecessary restarts.

Let's update our playbook to use the role. Edit first_playbook.yml to use the webserver role:

---
- hosts: webservers
  vars_files:
    - secret.yml
  roles:
    - webserver

Now execute the playbook:

ansible-playbook first_playbook.yml

What you'll notice is that the restart does not happen because we did not make any changes to the template.

nano roles/webserver/templates/index.html.j2

Best Practices with Handlers

Verifying Handlers

To verify that your handler has executed correctly, you can check the status of the service you expected to restart or the outcome of any action your handler was supposed to perform. For instance, for a service restart, you might run:

systemctl status nginx

If the service status indicates it's active and running, your handler has successfully restarted the service.

Conclusion

Handlers are a powerful feature in Ansible that allows for efficient management of service states and other actions that should only occur in response to changes. By using handlers, you can make your playbooks more efficient and maintainable. Remember to test your playbooks and handlers thoroughly to ensure they perform as expected. Great job on completing this lesson on Ansible handlers! See you in the next lesson.

Server Academy Members Only

Sorry, this lesson is only available to Server Academy Full Access members. Become a Full-Access Member now and you’ll get instant access to all of our courses.

Sign In Get Instant Access