The Project | About Us | Contribute | Donations | License

HOME

Performance tuning in Ansible is crucial for ensuring that your automation tasks run efficiently and effectively, especially when managing a large number of nodes or complex playbooks. This section will cover various strategies and best practices to optimize the performance of your Ansible playbooks and roles.

Key Concepts

Parallelism and Forks
Fact Caching
Task Optimization
Efficient Use of Modules
Reducing SSH Overhead
Using Asynchronous Actions
Profiling and Benchmarking

Parallelism and Forks

Ansible can run tasks in parallel across multiple hosts. By default, Ansible uses a fork value of 5, meaning it will run tasks on 5 hosts simultaneously. You can increase this number to improve performance.

Example

# ansible.cfg
[defaults]
forks = 20

Explanation:

Increasing the number of forks allows Ansible to manage more hosts concurrently, reducing the overall execution time.

Fact Caching

Gathering facts can be time-consuming, especially in large environments. Fact caching allows Ansible to store facts and reuse them, reducing the need to gather facts repeatedly.

Example

# ansible.cfg
[defaults]
gathering = smart
fact_caching = jsonfile
fact_caching_connection = /tmp/ansible_facts
fact_caching_timeout = 86400

Explanation:

gathering = smart: Gathers facts only when necessary.
fact_caching = jsonfile: Uses JSON files for caching.
fact_caching_connection: Directory where facts are stored.
fact_caching_timeout: Time in seconds before cached facts expire.

Task Optimization

Optimizing individual tasks can significantly improve performance. This includes minimizing the number of tasks, using efficient modules, and avoiding unnecessary loops.

Example

# playbook.yml
- name: Install packages
  apt:
    name: "{{ item }}"
    state: present
  with_items:
    - git
    - curl
    - vim

Explanation:

Using with_items to install multiple packages in a single task reduces the overhead of multiple task executions.

Efficient Use of Modules

Some modules are more efficient than others. For example, using the command module instead of shell can be faster and more secure.

Example

# Inefficient
- name: Create directory
  shell: mkdir -p /path/to/directory

# Efficient
- name: Create directory
  file:
    path: /path/to/directory
    state: directory

Explanation:

The file module is more efficient and safer for creating directories compared to using the shell module.

Reducing SSH Overhead

SSH connections can add significant overhead. Using persistent connections can help reduce this.

Example

# ansible.cfg
[ssh_connection]
pipelining = True
control_path = %(directory)s/%%h-%%r

Explanation:

pipelining = True: Reduces the number of SSH operations required to execute a module.
control_path: Specifies the path for SSH control sockets, enabling persistent connections.

Using Asynchronous Actions

For long-running tasks, using asynchronous actions can free up Ansible to perform other tasks while waiting for the long-running task to complete.

Example

# playbook.yml
- name: Long running task
  command: /path/to/long_running_script.sh
  async: 3600
  poll: 0

- name: Check on long running task
  async_status:
    jid: "{{ long_running_task.ansible_job_id }}"
  register: job_result
  until: job_result.finished
  retries: 30
  delay: 60

Explanation:

async: Specifies the maximum runtime for the task.
poll: Set to 0 to run the task in the background.
async_status: Checks the status of the asynchronous task.

Profiling and Benchmarking

Profiling and benchmarking your playbooks can help identify bottlenecks and areas for improvement.

Example

ansible-playbook playbook.yml --profile

Explanation:

The --profile option provides detailed timing information for each task, helping you identify slow tasks.

Practical Exercise

Task

Create an Ansible playbook that installs multiple packages on multiple hosts.
Optimize the playbook for performance using the techniques discussed above.

Solution

# optimized_playbook.yml
- name: Install packages on multiple hosts
  hosts: all
  gather_facts: no
  tasks:
    - name: Install packages
      apt:
        name: "{{ item }}"
        state: present
      with_items:
        - git
        - curl
        - vim
      async: 3600
      poll: 0

    - name: Check on package installation
      async_status:
        jid: "{{ install_packages.ansible_job_id }}"
      register: job_result
      until: job_result.finished
      retries: 30
      delay: 60

Explanation:

The playbook installs multiple packages using the apt module.
Asynchronous actions are used to handle long-running tasks efficiently.

Conclusion

Performance tuning in Ansible involves a combination of strategies, including parallelism, fact caching, task optimization, efficient module usage, reducing SSH overhead, and using asynchronous actions. By applying these techniques, you can significantly improve the efficiency and speed of your Ansible automation tasks.

Performance Tuning

Key Concepts

Parallelism and Forks

Example

Fact Caching

Example

Task Optimization

Example

Efficient Use of Modules

Example

Reducing SSH Overhead

Example

Using Asynchronous Actions

Example

Profiling and Benchmarking

Example

Practical Exercise

Task

Solution

Conclusion

Ansible: From Beginner to Advanced

Module 1: Introduction to Ansible

Module 2: Ansible Basics

Module 3: Playbooks

Module 4: Roles

Module 5: Advanced Playbook Techniques

Module 6: Ansible Galaxy

Module 7: Ansible Tower

Module 8: Ansible for DevOps

Module 9: Ansible Best Practices

Module 10: Advanced Ansible Topics