Ansible is an open-source automation tool that helps in managing and configuring systems. One of the features of Ansible is its use of templates, which allows for the use of variables in configuration files. The Jinja2 template engine is the default template engine used in Ansible.

What is Jinja2 template?

Jinja2 is a powerful template engine for Python that allows for the use of variables, loops, and other advanced features. In Ansible, Jinja2 templates are used to generate configuration files for various systems. The template files are written in plain text and use special syntax to insert variables and control structures.

To use a Jinja2 template in Ansible, you first need to create the template file. The template file should have the “.j2” file extension. Once the template file is created, it can be referenced in an Ansible playbook using the “template” module. The “template” module takes the path to the template file and a destination path as arguments.

In the template file, variables are denoted by double curly braces {{ variable }}. These variables can be set in an Ansible playbook using the “vars” section or by using variables passed to the playbook using the command line.

Jinja2 also supports control structures such as “for” loops and “if” statements. These can be used in the template file to generate the desired output based on the values of the variables. For example, a “for” loop can be used to generate multiple configurations for multiple servers.

In addition to variables and control structures, Jinja2 also provides a number of useful filters that can be used to manipulate data in the template. These filters can be used to format data, perform calculations, and more.

One of the main advantages of using Jinja2 in Ansible is that it allows you to create reusable templates that can be easily configured and reused across multiple playbooks. Jinja2 also allows you to use control structures, such as loops and conditionals, in your templates to create more complex configurations.

Jinja2 Template Examples

To use Jinja2 in Ansible, you must first create a template file with the desired configuration. This template file should use Jinja2 syntax, which includes variables, control structures, and filters. For example, the following template file creates a simple Apache configuration file:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

Listen {{ http_port }}

<VirtualHost *:{{ http_port }}>
    ServerName {{ server_name }}
    DocumentRoot {{ document_root }}
    <Directory {{ document_root }}>
        Allow from all
        Options +Indexes
    </Directory>
</VirtualHost>

In this example, the template uses variables such as http_port, server_name, and document_root to create a dynamic configuration. These variables can be defined in Ansible’s inventory file or passed as variables in a playbook.

Once the template is created, you can use Ansible’s template module to render the template and create the final configuration file. For example, the following playbook uses the template above to create an Apache configuration file:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

- name: Configure Apache
  hosts: web
  vars:
    http_port: 80
    server_name: example.com
    document_root: /var/www/html
  tasks:
    - name: Render Apache config
      template:
        src: apache.j2
        dest: /etc/httpd/conf/httpd.conf

In addition to variables and control structures, Jinja2 also provides a wide range of filters that can be used to manipulate and format data in your templates. For example, you can use the upper filter to convert a string to uppercase, or the date filter to format a timestamp.

Jinja2 templates use a simple syntax that is easy to learn and use. The basic structure of a template is a series of variables and control structures, such as loops and conditionals, that are used to generate the final output.

Here is a simple example of a Jinja2 template:

1
2
3

{% for user in users %}
    {{ user.name }}: {{ user.email }}
{% endfor %}

This template takes a list of users as an input and generates a list of names and email addresses. The for loop iterates through the list of users, and the {{}} notation is used to output the name and email of each user.

Another example is generating a configuration file for a web server:

1
2
3

listen {{ ansible_interface }}:80
server_name {{ domain_name }}
root {{ document_root }}

In this example, the variables ansible_interface, domain_name, and document_root are replaced with the actual values during runtime.

To use a Jinja2 template in Ansible, you will need to use the template module. The template module takes a template file and a destination file, and it generates the final output by processing the template and replacing the variables with their actual values.

Here is an example of how to use the template module in an Ansible playbook:

1
2
3
4

- name: Generate configuration file
  template:
    src: webserver.j2
    dest: /etc/nginx/conf.d/webserver.conf

In this example, the src parameter specifies the Jinja2 template file, and the dest parameter specifies the destination file. When the playbook is executed, Ansible will process the template and create the final output in the destination file.

In summary, Jinja2 is a powerful and flexible template engine that can be used to generate dynamic configuration files and other documents. Ansible uses Jinja2 as its template engine, making it easy to use templates in your automation tasks. With examples and explanations, you can easily create and manage your templates in Ansible and automate your infrastructure and applications.

Suggested Article

If you’d like to refer to Ansible basics, checkout our Ansible basics article here. All other DevOps categories are listed here: DevOps Tools. Have a look at the posts as per your topic of interest.

Conclusion

In this article, we’ve explained what is Jinja2 template and its basic usage. We’ve also demonstrated examples for all the topics that are discussed in the article. We hope you have learned something new in this article.

Please feel free to share your thoughts about this article in the comments section below.