The static inventory files you have worked with so far are easy to write and are convenient for managing small infrastructures. However, these static lists require manual administration to keep them up-to-date. This can be inconvenient or challenging, especially when an organization wants to run the playbooks against hosts that are dynamically created in a virtual or cloud computing environment.

In that scenario, it is useful to use a dynamically generated inventory.

Dynamic inventories are scripts which, when run, dynamically determine which hosts and host groups should be in the inventory, based on information from an external source. These can include the API for cloud providers, Cobbler, LDAP directories, or other third-party configuration management database (CMDB) software. Using a dynamically generated inventory is a recommended practice in a large and rapidly changing IT environment, where systems are frequently deployed, tested, and then removed.

Ansible supports two types of dynamically generated inventories:

An inventory plug-in is a piece of Python code that generates an inventory object from a dynamic source. Ansible ships with inventory plug-ins for a number of external inventory sources, including:

Ansible provides inventory plug-ins through Ansible Content Collections. Third-party content collections provide additional inventory plug-ins for specific products.

Developing inventory plug-ins is beyond the scope of this course.

plugin: redhat.satellite.foreman   
url: https://satellite.example.com 
user: ansibleinventory
password: Sup3r53cr3t
host_filters: 'organization="Development"' 

[user@host ~]$ ansible-navigator doc --mode stdout --type inventory --list
...output omitted...
ini                        Uses an Ansible INI file as inventory source
script                     Executes an inventory script that returns JSON
redhat.satellite.foreman   Foreman inventory source
toml                       Uses a specific TOML file as an inventory source
yaml                       Uses a specific YAML file as an inventory source

[user@host ~]$ ansible-navigator doc --mode stdout --type inventory \
> redhat.satellite.foreman

[user@host ~]$ ansible-navigator run --inventory ./satellite.yml my_playbook.yml

An inventory script is a program that collects information from an external source and returns the inventory in JSON format. You can write the custom program in any programming language as long as it returns inventory information in JSON format.

The ansible-navigator inventory command is a helpful tool for learning how to write Ansible inventories in JSON format. This command takes an inventory file and returns it in JSON format.

To display the contents of an inventory file in JSON format, use the --list option. You can also add the --inventory (or -i) option to specify the location of the inventory file to process instead of the default inventory set by the current Ansible configuration.

The following example runs the ansible-navigator inventory command to process an inventory file in INI format and output it in JSON format.

[user@host ~]$ cat inventory
monitor.example.com

[webservers]
web1.example.com
web2.example.com

[databases]
db1.example.com
db2.example.com

[user@host ~]$ ansible-navigator inventory --mode stdout -i inventory --list
{
    "_meta": {
        "hostvars": {}
    },
    "all": {
        "children": [
            "databases",
            "ungrouped",
            "webservers"
        ]
    },
    "databases": {
        "hosts": [
            "db1.example.com",
            "db2.example.com"
        ]
    },
    "ungrouped": {
        "hosts": [
            "monitor.example.com"
        ]
    },
    "webservers": {
        "hosts": [
            "web1.example.com",
            "web2.example.com"
        ]
    }
}

To develop your own dynamic inventory script, refer to Inventory scripts in the Ansible Developer Guide.

Start the script with an appropriate interpreter line (for example, #!/usr/bin/python) and make sure that it is executable so that Ansible can run it.

The script must support the --list and --host managed-host options.

When called with the --list option, the script must print a JSON dictionary of all the hosts and groups in the inventory.

In its simplest form, a group is a list of managed hosts. In the following example, the webservers group includes the web1.example.com and web2.example.com hosts. The databases group includes the db1.example.com and db2.example.com hosts.

[user@host ~]$ ./inventoryscript --list
{
  "webservers": [ "web1.example.com", "web2.example.com" ],
  "databases": [ "db1.example.com", "db2.example.com" ]
}

Alternatively, each group value can be a JSON dictionary containing a list of managed hosts, a list of child groups, and group variables that might be set. The following example shows the JSON output for a more complex dynamic inventory. The boston group has two child groups, backup and ipa, three managed hosts, and a group variable set (example_host: false).

{
    "boston": {
        "children": [
            "backup",
            "ipa"
        ],
        "vars": {
            "example_host": false
        },
        "hosts": [
            "server1.example.com",
            "server2.example.com",
            "server3.example.com"
        ]
    },
    "backup": [
        "server4.example.com"
    ],
    "ipa": [
        "server5.example.com"
    ]
}

The script must also support the --host managed-host option. When you run the script with that option, it must print a JSON dictionary consisting of the variables associated with the host, or an empty JSON dictionary if there are no variables for that host.

[user@host ~]$ ./inventoryscript --host server5.example.com
{
    "ntpserver": "ntp.example.com",
    "dnsserver": "dns.example.com"
}

[user@host ~]$ ansible-navigator run --inventory ./inventoryscript my_playbook.yml

Ansible supports the use of multiple inventories in the same run. If the location of the inventory is a directory (whether set by the -i option, the value of the inventory parameter, or in some other way), then all inventory files included in the directory, either static or dynamic, are combined to determine the inventory. The executable files within that directory are used to retrieve dynamic inventories, and the other files are used as static inventories or configuration files for inventory plug-ins.

Inventory files should not depend on other inventory files or scripts in order to resolve. For example, if a static inventory file specifies that a particular group should be a child of another group, then it also needs to have a placeholder entry for that group, even if all members of that group come from the dynamic inventory. Consider the cloud-east group in the following example:

[cloud-east]

[servers]
test.example.com

[servers:children]
cloud-east

This ensures that no matter the order in which inventory files are parsed, they are all internally consistent.

Ansible ignores files in an inventory directory if they end with certain suffixes. This can be controlled with the inventory_ignore_extensions directive in the Ansible configuration file. That directive defaults to .pyc, .pyo, .swp, .bak, ~, .rpm, .md, .txt, .rst, .orig, .ini, .cfg, and .retry.