← All articles
AutomationFeb 12, 202319 min read

Ansible Automation — 4

File module in Ansible are used to automate common tasks, such as managing files and directories, configuring network settings, and managing services. By using file module, Ansible makes it easier for organizations…

File Modules:

Here are some examples of file modules in Ansible and how they can be used:

  1. file module:
    This module is used to manage files and directories, such as creating, copying, or deleting files and directories, and setting permissions and ownership. For example, the following playbook will create a directory:
- name: Create a directory
  hosts: localhost
  tasks:
    - name: Create the directory
      file:
        path: /tmp/ansible-example
        state: directory

2. template module:
This module is used to generate files based on a template and a set of variables. The template module uses Jinja2, a powerful templating language, to generate the final file. For example, the following playbook will generate a configuration file based on a template and a set of variables:

- name: Generate a configuration file
  hosts: localhost
  vars:
    database_name: mydatabase
    database_user: dbuser
    database_password: secretpassword
  tasks:
    - name: Generate the configuration file
      template:
        src: templates/database.conf.j2
        dest: /etc/database.conf
      vars:
        database_name: "{{ database_name }}"
        database_user: "{{ database_user }}"
        database_password: "{{ database_password }}"

3. copy module:
This module is used to copy files from the local machine to a remote machine, or from one remote machine to another. For example, the following playbook will copy a file from the local machine to a remote machine:

- name: Copy a file
  hosts: remote
  tasks:
    - name: Copy the file
      copy:
        src: /tmp/file.txt
        dest: /tmp/file.txt
        owner: root
        group: root
        mode: 0644

4. lineinfile module:
This module is used to add, change, or remove a line in a file. For example, the following playbook will add a line to a file:

- name: Add a line to a file
  hosts: localhost
  tasks:
    - name: Add the line
      lineinfile:
        dest: /etc/file.conf
        line: "This is a new line"
        state: present

5. stat module:
This module is used to retrieve information about a file, such as its size, owner, and last modification time. For example, the following playbook will retrieve information about a file:

- name: Retrieve information about a file
  hosts: localhost
  tasks:
    - name: Retrieve the information
      stat:
        path: /tmp/file.txt
      register: file_info
 
    - name: Display the information
      debug:
        var: file_info

6. fetch module:
This module is used to copy files from a remote machine to the local machine. For example, the following playbook will copy a file from a remote machine to the local machine:

- name: Fetch a file
  hosts: remote
  tasks:
    - name: Fetch the file
      fetch:
        src: /tmp/file.txt
        dest: /tmp/file.txt
        flat: yes

7. synchronize module:
This module is used to synchronize files between the local machine and a remote machine. The synchronize module is similar to the rsync command, and can be used to transfer files over SSH. For example, the following playbook will synchronize a directory between the local machine and a remote machine:

- name: Synchronize a directory
  hosts: remote
  tasks:
    - name: Synchronize the directory
      synchronize:
        src: /tmp/dir
        dest: /tmp/dir
        mode: pull

8. backup:
This option is used to create a backup of a file before making changes to it. For example, the following playbook will create a backup of a file before adding a line to it:

- name: Add a line to a file and create a backup
  hosts: remote
  tasks:
    - name: Add the line
      lineinfile:
        path: /tmp/file.txt
        line: Hello, Ansible!
        state: present
        backup: yes

In conclusion, file modules are an important aspect of Ansible automation, and are used to automate common tasks such as managing files, generating configuration files, copying files, and modifying files. By using file modules, organizations can simplify and streamline their IT operations, and improve the efficiency and reliability of their automation workflows.

Error handling:

Fail module:
The fail module in Ansible is used to explicitly fail a task and halt playbook execution. It is often used to enforce control flow in playbooks or to stop execution when certain conditions are not met. The fail module takes two mandatory arguments: msg and rc.

msg is a string message that provides information about the failure. rc is an integer that represents the return code of the task. The return code can be used to indicate the type of failure, for example, a return code of 1 can indicate a critical error, while a return code of 2 can indicate a less severe error.

Here is an example of using the fail module in Ansible:

- name: Fail if variable is not defined
  fail:
    msg: "Variable 'variable_name' is not defined"
  when: variable_name is not defined

In this example, the task will fail and display the message “Variable ‘variable_name’ is not defined” if the variable variable_name is not defined. The when clause is used to check if the variable is defined and only fail the task if it is not defined.

Error handling is an important aspect of any automation process, and Ansible is no exception. In this blog post, we’ll take a look at how to handle errors in Ansible playbooks.

  1. Using the ignore_errors option: The ignore_errors option is a simple and effective way to handle errors in Ansible playbooks. When this option is set to yes, Ansible will continue to execute subsequent tasks even if a task fails. For example, the following playbook will continue to execute the next task even if the first task fails:
- name: Handle errors
  hosts: remote
  tasks:
    - name: Task 1
      shell: false_command
      ignore_errors: yes

    - name: Task 2
      shell: echo "This task will be executed even if Task 1 fails"

2. Using the failed_when option: The failed_when option is used to specify the conditions under which a task should be considered as failed. For example, the following playbook will consider the task as failed if the command returns a non-zero exit code:

- name: Handle errors
  hosts: remote
  tasks:
    - name: Task 1
      shell: false_command
      failed_when: "'false_command' in result.stderr"

3. Using the register option: The register option is used to store the result of a task in a variable. This variable can then be used to check the outcome of a task and take appropriate action. For example, the following playbook will check the exit code of a task and display an error message if the task fails:

- name: Handle errors
  hosts: remote
  tasks:
    - name: Task 1
      shell: false_command
      register: result

    - name: Display an error message
      shell: echo "Task 1 failed with exit code {{ result.rc }}"
      when: result.rc != 0

4. Using error-handling blocks: Ansible provides several error-handling blocks that can be used to handle errors in playbooks. The most commonly used blocks are ignore_errors, failed_when, and rescue. For example, the following playbook will display an error message if the first task fails and continue to execute the next task:

- name: Handle errors
  hosts: remote
  tasks:
    - name: Task 1
      shell: false_command
      ignore_errors: yes

    - name: Task 2
      shell: echo "This task will be executed even if Task 1 fails"
  rescue:
      - name: Display an error message
        shell: echo "Task 1 failed with exit code {{ task_result.rc }}"

5. ignore_task: The ignore_task option is used to ignore a task in Ansible playbooks. This option can be used to ignore a task based on certain conditions. For example, the following playbook will ignore the task if the variable x is not equal to 10:

- name: Handle errors
  hosts: remote
  tasks:
    - name: Task 1
      shell: echo "Task 1"
      when: x == 10
    - name: Task 2
      shell: echo "Task 2"
      ignore_task: yes
      when: x != 10

These are just a few of the many ways to handle errors in Ansible playbooks. By using these techniques, organizations can ensure that their automation processes continue to run smoothly even in the face of errors and failures.

Error handling is an important aspect of any automation process, and Ansible provides several options for handling errors in playbooks. By using these options, organizations can ensure that their automation processes continue to run smoothly, even in the face of errors and failures.

Introduction of Dynamic Inventory:

Jinja is a popular template engine for Python that is widely used in web development. It is also used in Ansible as the default template engine. In this blog post, we’ll take a look at the basics of Jinja and how it can be used in Ansible.

What is Jinja? Jinja is a fast, expressive, and extensible template engine that was designed specifically for Python. It is used to generate HTML, XML, or any other kind of text-based content based on templates. Jinja allows developers to write custom logic in the templates and control the flow of data in a clean and concise way.

Why use Jinja in Ansible? Ansible uses Jinja as its default template engine because it is a powerful tool for generating dynamic content. It provides a simple and elegant way to define the structure of the content, and then populate it with data from Ansible variables and facts.

Using Jinja in Ansible Jinja can be used in Ansible playbooks in several ways. Here are a few examples:

  1. Template a configuration file In Ansible, you can use Jinja to template a configuration file that needs to be deployed to multiple servers. For example, you can use Jinja to template a nginx configuration file that needs to be deployed to multiple web servers.
  2. Generate dynamic content Jinja can also be used to generate dynamic content in Ansible playbooks. For example, you can use Jinja to generate a list of users that need to be created on multiple servers.
  3. Render a template in Ansible You can also use Jinja to render a template in Ansible. For example, you can use Jinja to render a template that generates a configuration file for a specific server based on its hostname and IP address.

Jinja syntax Jinja uses a simple and intuitive syntax for creating templates. Here are a few of the key elements of Jinja syntax:

  • Variables: Variables in Jinja are defined using curly braces ({{ }}). For example, to print the value of a variable named foo, you would write {{ foo }}.
  • Loops: Jinja supports loops, which allow you to repeat a block of code multiple times.

For example, to loop over a list of users, you would write:

{% for user in users %}
  {{ user }}
{% endfor %}
  • Conditionals: Jinja also supports conditionals, which allow you to control the flow of data in a template.

For example, to print a message if a variable is true, you would write:

{% if condition %}
  The condition is true
{% else %}
  The condition is false
{% endif %}
  • Macros: Jinja macros are reusable blocks of code that can be called multiple times in a template.

For example, to define a macro that prints a message, you would write:

{% macro print_message() %}
  This is a message
{% endmacro %}

In conclusion, Jinja is a powerful and versatile template engine that is widely used in web development and in Ansible as the default template engine. By using Jinja in Ansible, organizations can generate dynamic content and control the flow of data in a clean and concise way. Whether you are templating a configuration file, generating dynamic content, or rendering a template in Ansible.Whether you’re a seasoned developer or just starting out with automation, Jinja is a tool that can help you take your automation to the next level.

Ansible provides two modules for copying files from one location to another: the copy module and the template module. Both modules can be used to transfer files from a source location to a target location, but there are some key differences between them. In this blog post, we'll explore the differences between copy and template and when you might use one over the other.

The copy module is used to copy files from the local system or a remote system to the target host. The copy module is best used for copying static files, such as configuration files, scripts, and other resources, to the target host. For example, you might use the copy module to copy a script that you want to run on the target host.

Here’s an example of using the copy module in a playbook:

- name: Copy file to target host
  hosts: target
  tasks:
    - name: Copy file
      copy:
        src: /path/to/file
        dest: /destination/path

In this example, the copy module is used to copy a file from the local system to the target host. The src parameter specifies the source location of the file, and the dest parameter specifies the destination location on the target host.

The template module, on the other hand, is used to transfer a file from the local system or a remote system to the target host, but also renders the file using Jinja2, a template engine for Python. The template module is best used for generating dynamic files, such as configuration files or scripts, based on variables. For example, you might use the template module to generate a configuration file that depends on the environment or specific host settings.

Here’s an example of using the template module in a playbook:

- name: Generate configuration file
  hosts: target
  tasks:
    - name: Generate configuration file
      template:
        src: /path/to/template
        dest: /destination/path
        owner: root
        group: root

In this example, the template module is used to generate a configuration file based on a Jinja template. The src parameter specifies the source location of the Jinja template, and the dest parameter specifies the destination location on the target host. The owner and group parameters specify the owner and group for the generated configuration file.

$ cat test.conf
YOU CAN SEE ME {{myname}}

---
- hosts: demo
  tasks:
  - name: copy module
    copy: src=test.conf dest=/tmp/test.conf

output: cat /tmp/test.conf   # view the content of destination file
YOU CAN SEE ME {{myname}}


$ cat test.conf.j2
YOU CAN SEE ME {{myname}}

---
- hosts: demo
  tasks:
  - name: Template
    template: src=test.conf.j2 dest=/tmp/test.conf

$ ansible-playbook jinja.yml --extra-vars "myname=Mohan" 

$ cat /tmp/test.conf       # view the content of destination file
YOU CAN SEE ME Mohan

Now, let’s see how we can use this template in a playbook to generate a dynamic string:

- name: Generate list of names
  hosts: localhost
  tasks:
    - name: Generate list of names
      set_fact:
        names:
          - Syed
          - Vittal
          - Param
          - Rajesh
          - Sachin
          - Swamy
    - name: Render template
      template:
        src: /path/to/template
        dest: /destination/path
      vars:
        names: "{{ names }}"

In this playbook, we use the set_fact module to set a list of names as a variable. Then, we use the template module to render the Jinja template and generate the dynamic string. The vars parameter is used to pass the names variable to the template, so that the template can access the list of names.

In summary, The main difference between copy and template is that copy is used for copying static files, while template is used for generating dynamic files based on Jinja templates. Both modules are useful for transferring files from a source location to a target host, but it's important to choose the right module for the task at hand. If you're copying a static file, use copy, but if you need to generate a dynamic file based on variables, use template.

Tags Concept:

Tags are a powerful feature in Ansible that allow you to control which tasks or roles in a playbook are executed. By using tags, you can create playbooks that can perform different actions based on the tags assigned to each task. This makes it easier to manage and organize complex playbooks, and to run only specific portions of a playbook as needed.

To assign a tag to a task in a playbook, you simply add the tags parameter to the task, and provide a list of one or more tags. For example:

- name: Install and configure Apache web server
  hosts: webservers
  tasks:
    - name: Install Apache
      apt: name=apache2 state=present
      tags:
        - apache
        - install
    - name: Configure Apache
      template: src=templates/httpd.conf.j2 dest=/etc/httpd/conf/httpd.conf
      tags:
        - apache
        - config

In this example, the first task is assigned the tags apache and install, while the second task is assigned the tags apache and config.

Now, when you run the playbook, you can use the --tags option to run only tasks with specific tags. For example:

ansible-playbook playbook.yml --tags apache

This command will run only tasks with the tag apache, so in this case both the Install Apache and Configure Apache tasks would be executed.

---
- hosts: demo
  tasks:
  - name: Print Arun
    command: echo Arun
    tags:
     - Arun
     - group1
  - name: Print Param
    command: echo Param
    tags:
     - Param
     - group1
  - name: Print Rohit
    command: echo Rohit
    tags:
     - Rohit
     - group1
  - name: Print Palani
    command: echo Palani
    tags:
     - Palani
     - group1
  - name: Print Subash
    command: echo Subash
    tags:
     - Subash
     - group1
  - name: Print Venkat
    command: echo Venkat
    tags:
     - Venkat
     - group2
  - name: Print Vittal
    command: echo Vittal
    tags:
     - Vittal
     - group2
  - name: Print Sreeni
    command: echo Sreeni
    tags:
     - Sreeni
     - group2
  - name: Print Syed
    command: echo Syed
    tags:
     - Syed
     - group2

$ ansible-playbook tags.yml --tags Arun --tags Venkat

This command will run only tasks with the tag Arun and Venkatso in this case both the Print tasks would be executed.

On the other hand, if you want to run all tasks except for those with a specific tag, you can use the --skip-tags option. For example:

- name: Install and configure Apache web server
  hosts: webservers
  tasks:
    - name: Install Apache
      apt: name=apache2 state=present
      tags:
        - apache
        - install
    - name: Configure Apache
      template: src=templates/httpd.conf.j2 dest=/etc/httpd/conf/httpd.conf
      tags:
        - apache
        - config

$ ansible-playbook playbook.yml --skip-tags config

This command will run all tasks except those with the tag config, so in this case only the Install Apache task would be executed.

You can also use tags in an ad-hoc command, by using the -t or --tags option. For example:

ansible webservers -m apt -a "name=apache2 state=present" -t install

This ad-hoc command will run the apt module on the webservers group, and will only run tasks with the tag install.

---
- hosts: demo
  tasks:
  - name: Print Mohan
    command: echo Mohan
    tags:
     - Mohan
     - group1
  - name: Print Sachin
    command: echo Sachin
    tags:
     - Sachin
     - group1
  - name: Print Swamy
    command: echo Swamy
    tags:
     - Swamy
     - group1
  - name: Print Vittal
    command: echo Vittal
    tags:
     - Vittal
     - group2
  - name: Print Sreeni
    command: echo Sreeni
    tags:
     - Sreeni
     - group2
  - name: Print Syed
    command: echo Syed
    tags:
     - Syed
     - group2

$ ansible-playbook tags.yml --skip-tags group1

This command will run all tasks except those with the taggroup1 .

In summary, tags are a powerful feature in Ansible that can help you control which tasks in a playbook are executed, and make it easier to manage and organize complex playbooks. By using tags, you can run only specific portions of a playbook as needed, which can save time and improve efficiency in your automation workflows.

Wait_for:

The wait_for module in Ansible is used to wait for a condition to be met before proceeding with the execution of the next task. This is useful in situations where you need to wait for a service or resource to be available before performing other tasks. For example, you might need to wait for a database to be up and running before you can start installing an application.

The wait_for module has several options that can be used to specify the conditions that you want to wait for. For example, you can wait for a port to be open, or for a file to exist, or for a string to be present in a file.

Here’s an example of using the wait_for module to wait for a port to be open:

- name: Wait for the database to be up and running
  wait_for:
    host: db.example.com
    port: 5432
  tags:
    - database

In this example, the wait_for module will wait for the host db.example.com on port 5432 to be open before proceeding with the execution of the next task.

You can also specify a timeout for the wait operation, which determines how long to wait for the condition to be met before giving up and failing the task. For example:

- name: Wait for the database to be up and running
  wait_for:
    host: db.example.com
    port: 5432
    timeout: 60
  tags:
    - database

In this example, the wait_for module will wait for the host db.example.com on port 5432 to be open for a maximum of 60 seconds before giving up and failing the task.

You can also use the wait_for module in an ad-hoc command, by specifying the wait_for module and its options as arguments. For example:

ansible all -m wait_for -a "host=db.example.com port=5432"

In summary, the wait_for module is a helpful tool for managing how Ansible playbooks and ad-hoc actions are executed. Your automation workflows’ dependability and stability may be increased by utilising the wait_for module to make sure that activities are carried out only after a certain condition has been satisfied.

---
- hosts: demo
  become: yes
  tasks:
  - name: wait for the service to start listening on port 80
    wait_for:
     port: 80
     state: started
     timeout: 300
 - name: wait until the file is present before continuing
   wait_for:
    path: /tmp/dummy
    search_regex: "Hi Mohan"
    delay: 10
    timeout: 30
  - name: Print Dinesh
    command: echo Dinesh

In this example, the wait_for module will wait for the host port 80 to be started/ to be open for a maximum of 300 seconds before giving up and failing the task and in the another task, The path option is used to specify the file path that the wait_for module should look for. In this example, the file path is /tmp/dummy.

The search_regex option is used to specify a regular expression that the wait_for module should look for within the file. In this example, the regular expression is "Hi Mohan". The wait_for module will wait until the specified file contains the specified string before continuing with the playbook execution.

The delay option is used to specify the amount of time to wait between each check for the file and the string. In this example, the wait_for module will wait for 10 seconds between each check.

The timeout option is used to specify the amount of time to wait for the file and string to be present before giving up and failing the task. In this example, the wait_for module will wait for a maximum of 30 seconds for the file and string to be present before giving up and failing the task.

MK
Mohankrishna PodileDevOps Engineer & Cloud Architect · Irving, Texas

Comments

Questions, corrections, war stories — all welcome. Sign in with GitHub to join the discussion.