Performance Optimization

# ansible.cfg — enable pipelining
[ssh_connection]
pipelining = True

# Prerequisite: requiretty must be disabled in /etc/sudoers on managed nodes
# Add this line to sudoers (via visudo):
# Defaults !requiretty
# This is already the default on most modern distributions (Ubuntu 20+, RHEL 8+)

# ansible.cfg — enable fact caching
[defaults]
fact_caching            = jsonfile
fact_caching_connection = /tmp/ansible_facts_cache
fact_caching_timeout    = 3600    # cache facts for 1 hour (seconds)

# Alternative: redis backend for shared caches across multiple control nodes
# fact_caching            = redis
# fact_caching_connection = localhost:6379:0

# Per-play: disable fact gathering for plays that don't use any facts
- name: Rotate application logs
  hosts: appservers
  gather_facts: false    # saves 1-3s per host — only skip if no ansible_* vars used
  tasks:
    - name: Find old log files
      ansible.builtin.find:
        paths: /var/log/app
        age: 30d
        recurse: true
      register: old_logs

    - name: Remove old log files
      ansible.builtin.file:
        path: "{{ item.path }}"
        state: absent
      loop: "{{ old_logs.files }}"

# Per-play: use cached facts instead of re-gathering
- name: Configure servers using cached facts
  hosts: webservers
  gather_facts: true     # will use cache if available and not expired
  tasks:
    - name: Set shared_buffers based on cached RAM fact
      ansible.builtin.template:
        src: postgresql.conf.j2
        dest: /etc/postgresql/15/main/postgresql.conf
      # ansible_memtotal_mb comes from the cached fact — no SSH round trip

# ansible.cfg
[defaults]
forks = 20    # process 20 hosts in parallel per task

# Rule of thumb:
# Small fleet (< 50 hosts):   forks = 10-20
# Medium fleet (50-200):      forks = 20-50
# Large fleet (200+ hosts):   forks = 50-100 (test and tune — CPU/network bound)
# Never set forks higher than your control node's CPU core count × 4

# Fire-and-forget with polling — best for long single tasks
- name: Run database backup (takes up to 10 minutes)
  ansible.builtin.command:
    cmd: /usr/local/bin/backup-db.sh
  async: 600        # task is allowed up to 600 seconds (10 min) to complete
  poll: 30          # Ansible checks back every 30 seconds
  register: backup_job

# Run multiple slow tasks in parallel across the same host
- name: Upgrade packages on all hosts (async — don't wait)
  ansible.builtin.package:
    name: "*"
    state: latest
  async: 300
  poll: 0           # poll: 0 = fire and forget, don't wait at all
  register: upgrade_jobs

- name: Wait for all upgrades to complete
  ansible.builtin.async_status:
    jid: "{{ item.ansible_job_id }}"
  loop: "{{ upgrade_jobs.results }}"
  register: upgrade_results
  until: upgrade_results.finished
  retries: 30
  delay: 10

# Native async — run slow tasks across hosts in parallel
- name: Download large artifact on all hosts simultaneously
  ansible.builtin.get_url:
    url: "https://releases.example.com/app-{{ app_version }}.tar.gz"
    dest: "/tmp/app-{{ app_version }}.tar.gz"
  async: 120
  poll: 0
  register: download_jobs

- name: Wait for all downloads to finish
  ansible.builtin.async_status:
    jid: "{{ item.ansible_job_id }}"
  loop: "{{ download_jobs.results }}"
  register: download_results
  until: download_results.finished
  retries: 20
  delay: 10

# ansible.cfg — enable timing callbacks
[defaults]
callbacks_enabled = timer, profile_tasks

# timer:         prints total playbook run time at the end
# profile_tasks: prints per-task timing sorted by duration

[defaults]
inventory               = ./inventory/production
remote_user             = ansible
forks                   = 20                    # parallel host processing
gathering               = smart                 # only gather facts if not cached
fact_caching            = jsonfile
fact_caching_connection = /tmp/ansible_facts_cache
fact_caching_timeout    = 3600                  # 1 hour cache
stdout_callback         = yaml                  # cleaner output
callbacks_enabled       = timer, profile_tasks  # per-task timing on every run

[ssh_connection]
pipelining              = True                  # stream modules over existing SSH
ssh_args                = -C -o ControlMaster=auto -o ControlPersist=60s
                          # -C: compression (helps on slow links)
                          # ControlMaster: reuse SSH connections across invocations
                          # ControlPersist: keep master connection open 60s