10-Day4-2-BlockRescueAlways

Day 4: Lab Exercise- Block, Rescue, and Always Constructs for Error Handling

Objective:

Participants will learn to use block, rescue, and always constructs in Ansible playbooks to handle errors effectively, perform recovery actions, and ensure certain tasks always execute, regardless of errors.

Lab 2.1: Basic Use of Block and Rescue

Scenario:

Try to create a directory under /root/ (restricted path). If it fails, log an error message and create the directory under /tmp/ instead.

Steps:

  1. Create the Playbook:

    • Save as ~/day4/block_rescue_basic.yaml:

      - name: Block and Rescue Demo - Basic
  hosts: localhost
  become: yes
  tasks:
    - name: Demonstrate block and rescue
      block:
        - name: Attempt to create directory in /root/
          file:
            path: /root/sample_directory
            state: directory
      rescue:
        - name: Log the error message
          debug:
            msg: "Failed to create directory in /root/, attempting in /tmp/."

        - name: Create directory in /tmp/ instead
          file:
            path: /tmp/sample_directory
            state: directory

  2. Run the Playbook:

    ansible-playbook ~/day4/block_rescue_basic.yaml

  3. Expected Output:

    • The playbook fails to create the directory in /root/ and rescues the failure by creating it in /tmp/.

Lab 2.2: Using Always for Cleanup Actions

Scenario:

Create a temporary file during execution. Clean it up regardless of whether the tasks succeed or fail.

Steps:

  1. Create the Playbook:

    • Save as ~/day4/block_always.yaml:

      - name: Block and Always Demo
  hosts: localhost
  become: yes
  tasks:
    - name: Demonstrate block and always
      block:
        - name: Create a temporary file
          file:
            path: /tmp/temp_file.txt
            state: touch

        - name: Force an error
          command: /bin/false
      always:
        - name: Clean up temporary file
          file:
            path: /tmp/temp_file.txt
            state: absent

  2. Run the Playbook:

    ansible-playbook ~/day4/block_always.yaml

  3. Expected Output:

    • The playbook fails at the forced error step, but the cleanup task ensures the temporary file is deleted.

Alternative Example for Lab 2.3: Comprehensive Example with Block, Rescue, and Always

Scenario:

Configure an Apache web server. If the Apache package installation fails, fall back to logging the issue and installing an alternative package (e.g., Nginx). Always ensure that any temporary files created during the process are cleaned up.

Steps:

  1. Create the Playbook:

    • Save as ~/day4/block_rescue_always_alternative.yaml:

      - name: Comprehensive Example - Apache Setup with Error Handling
  hosts: localhost
  become: yes
  tasks:
    - name: Web Server Setup with Error Handling
      block:
        - name: Create a temporary marker file
          file:
            path: /tmp/setup_marker.txt
            state: touch

        - name: Install Apache
          yum:
            name: httpd
            state: present

        - name: Start and enable Apache
          service:
            name: httpd
            state: started
            enabled: true

      rescue:
        - name: Log Apache installation failure
          debug:
            msg: "Apache installation failed. Attempting to install Nginx."

        - name: Install Nginx instead
          yum:
            name: nginx
            state: present

        - name: Start and enable Nginx
          service:
            name: nginx
            state: started
            enabled: true

      always:
        - name: Clean up temporary files
          file:
            path: /tmp/setup_marker.txt
            state: absent

        - name: Log the completion of the playbook
          debug:
            msg: "Web server setup process completed, regardless of the outcome."

  1. Run the Playbook:

    ansible-playbook ~/day4/block_rescue_always_alternative.yaml

  1. Expected Output:

    • Successful Apache Installation: The playbook installs Apache, starts it, and cleans up the temporary file.

    • Apache Installation Fails: The playbook logs the error, installs Nginx as an alternative, starts Nginx, and cleans up the temporary file.

    • The always block ensures cleanup and logs the playbook completion message.

Key Learning Points:

  1. Block and Rescue:

    • Handle service setup failures gracefully and switch to an alternative configuration.

  2. Always:

    • Ensure cleanup and logging, independent of the success or failure of the block tasks.

  3. Real-World Application:

    • This example mirrors a common scenario in real-world deployments, teaching participants how to handle package or service installation failures dynamically.

Optional Challenge:

  • Modify the playbook to test whether Apache or Nginx is running after the playbook execution and print a message indicating which web server is active.

  • Add additional error handling for Nginx installation failure, ensuring that a detailed log is created in /var/log/web_server_setup.log.

Lab 2.3: Comprehensive Example with Block, Rescue, and Always

Scenario:

Set up a file server, ensuring key steps have error handling and cleanup.

Steps:

  1. Create the Playbook:

    • Save as ~/day4/block_rescue_always_comprehensive.yaml:

      - name: Comprehensive Error Handling Example
  hosts: localhost
  become: yes
  tasks:
    - name: File Server Setup with Error Handling
      block:
        - name: Install NFS server package
          yum:
            name: nfs-utils
            state: present

        - name: Create export directory
          file:
            path: /exports/shared
            state: directory

        - name: Add an export to /etc/exports
          lineinfile:
            path: /etc/exports
            line: "/exports/shared *(rw,sync,no_root_squash)"
            state: present

        - name: Start and enable NFS server
          service:
            name: nfs-server
            state: started
            enabled: true

      rescue:
        - name: Log error and rollback
          debug:
            msg: "Error occurred during setup. Rolling back changes."

        - name: Remove export directory
          file:
            path: /exports/shared
            state: absent

        - name: Remove export from /etc/exports
          lineinfile:
            path: /etc/exports
            line: "/exports/shared *(rw,sync,no_root_squash)"
            state: absent

      always:
        - name: Ensure NFS service is stopped
          service:
            name: nfs-server
            state: stopped

  2. Run the Playbook:

    ansible-playbook ~/day4/block_rescue_always_comprehensive.yaml

  3. Expected Output:

    • If any step fails, the rollback tasks remove the export directory and configuration.

    • The always block ensures the NFS service is stopped.

Optional Lab: Nested Block and Rescue

Scenario:

Create a user and set permissions on their home directory. If user creation fails, create a default user instead. Always log actions regardless of success or failure.

  1. Create the Playbook:

    • Save as ~/day4/nested_block_rescue.yaml:

      - name: Nested Block and Rescue Demo
  hosts: localhost
  become: yes
  tasks:
    - name: Create User with Nested Error Handling
      block:
        - name: Create primary user
          user:
            name: primary_user
            state: present

        - name: Set permissions on home directory
          file:
            path: /home/primary_user
            state: directory
            mode: '0755'
      rescue:
        - name: Log error and create default user
          debug:
            msg: "Primary user creation failed, creating default_user."

        - name: Create default user
          user:
            name: default_user
            state: present
      always:
        - name: Log completion
          debug:
            msg: "User creation process completed."

  2. Run the Playbook:

    ansible-playbook ~/day4/nested_block_rescue.yaml

  3. Expected Output:

    • If primary user creation fails, the playbook rescues by creating a default user.

    • Logs actions regardless of success or failure.

Key Learning Points:

  1. Block and Rescue:

    • Handle expected errors and recover gracefully.

  2. Always:

    • Ensure cleanup or important tasks are executed regardless of playbook success.

  3. Comprehensive Error Handling:

    • Combine constructs to create robust, fault-tolerant playbooks.

  4. Optional Exercises:

    • Provide additional learning opportunities for participants to explore nested error handling scenarios.

This lab enables participants to effectively manage errors in their Ansible playbooks with real-world applications.

Previous1-Day1-1-InstallationNext11-Day4-3-Jinja2Template

Last updated