Gain insights into Ansible's core features like inventory, playbooks, and roles. Delve into writing playbooks, using Jinja2, and organize tasks for efficient, stable IT infrastructure management.

ansible.tar.gz

ansible_spa

nginx_demo

Configuration management plays a pivotal role in maintaining a stable and organized IT infrastructure by enabling the systematic gathering of information from remote hosts, facilitating server provisioning, and streamlining application upgrades or deployments.

You will learn the core features of Ansible, such as inventory, variables, playbooks, roles, and handlers, which serve as the building blocks for configuration management. You will learn how to write playbooks that define and execute complex orchestration tasks with ease. Next, you’ll learn how to use roles to maintain consistency across configuration management projects and how to harness the power of Jinja2 to apply logic and control structures and generate configuration files dynamically.

After completing this course, you will be equipped with the necessary skills for customizing configurations, organizing automation tasks efficiently, and maintaining a desired state for your infrastructure.

Configuration Management Using Ansible

# Introduction to Jinja2 templating

**Jinja2** is a powerful templating engine used in Ansible for creating dynamic content in configuration files, templates, and playbooks. It allows us to insert variables, loops, conditional statements, and more into our Ansible tasks. Jinja2 template files usually have the `.j2` extension, but it's not compulsory to use it in our Ansible configuration.

# Jinja2 delimiters

Jinja2 uses three major delimiters to indicate where it should process content and how to replace it: 

- Variable substitution (`{{ }}`)
- Embedding expressions and control statements (`{% %}`)
- Comment (`{# #}`)

## Variable substitution (`{{ }}`)

The `{{ }}` double curly braces are used for variable substitution. We can insert variable values into our templates and playbooks using this syntax. Here is an example:

---
- name: Playbook 1
  hosts: web_servers
  tasks:
    - name: Display a variable
      debug:
        msg: "Hello, {{ user_name }}"

In this example, `{{ user_name }}` will be replaced with the actual value of the `user_name` variable.

## Embedding expressions and control statements (`{% %}`)

Jinja2 uses the curly braces with a percentage sign `{% %}` for embedding expressions and control statements. Below is an example:

---
- hosts: web_servers
  vars:
    user_name: "DevOps"
  tasks:
    - name: Print a personalized greeting
      debug:
        msg: "Hello, {% if user_name %}{{ user_name }}{% else %}Guest{% endif %}!"

In the above example, the `debug` task will print a message with a personalized greeting based on the `user_name` variable. If the `user_name` is defined, it will print `"Hello, John!"`; otherwise, it will print `"Hello, Guest!"`.

## Comment (`{# #}`)

Any content enclosed within the `{# #}` delimiter is treated as a comment and is ignored by the templating engine. Here is an example:

---
- name: Playbook 3
  hosts: web_servers
  tasks:
    - name: Regular task
      debug:
        msg: "This is a message."
    - name: {# A comment #}
      debug:
        msg: "This won't be executed."

In the example above, the first task named `"Regular task"` prints a `debug` message saying `"This is a message"` when executed. The second task is a comment using Jinja2 templating syntax and won't execute any action.

# Common use cases for Jinja2 templating

Jinja2 templating provides flexibility and is useful whether we're trying to dynamically generate a file or an inventory, or using it for another purpose. In no particular order, here are a couple of scenarios where we might want to employ Jinja2 templating.

## Configuration file templating
Jinja2 templating comes in handy in situations when we need to embed variables or dynamic configurations in a file. This is useful when we have configuration files with parameters that are dependent on certain criteria. Let's imagine that we have a playbook for configuring NGINX on multiple servers, and we want to dynamically set the server's  `server_port` listening port and `document_root`. The following code snippet shows the corresponding playbook and its `nginx.conf.j2` NGINX configuration file :

Learn how to manage placeholders and add dynamic values in your Ansible configuration using Jinja2.

Getting Started

What Is Configuration Management?

Basics of Ansible

Major Concepts in Ansible

Ansible Variables and Other Elements

Manage Configuration with Ansible

Wrap Up

Deploy a Web Application Using Ansible

Basics of Jinja2 Templating

Introduction to Jinja2 templating

Jinja2 delimiters

Variable substitution (`{{ }}`)

Embedding expressions and control statements (`{% %}`)

Comment (`{# #}`)