EX294 Transform data with filters and plugins Practice Test 6 — 15 Questions

Question 1

An Ansible playbook uses the "community.general" collection to manage firewall rules. The engineer wants to use a lookup plugin to fetch the current IPv4 address of a host to include in a dynamic inventory script. Which TWO of the following options correctly describe the usage of lookup plugins in Ansible?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Lookup plugins are executed on the control node and return data to the Ansible controller.. Lookup plugins in Ansible are designed to run on the control node (the machine where Ansible is executed), not on the remote host. They fetch data from external sources (e.g., files, databases, environment variables) and return that data to the Ansible controller for use in playbooks or inventory scripts. This aligns with the requirement to fetch the current IPv4 address of a host for a dynamic inventory script, as the lookup plugin can query local or network sources without needing to execute on the target host.

Answer

Lookup plugins are always executed on the remote host.

Answer

Lookup plugins must be imported using the "lookup" keyword.

Answer

The "file" lookup plugin reads the content of a file from the remote host.

Question 2

An administrator is writing a playbook to manage multiple web servers. The playbook uses a variable "server_facts" which is a list of dictionaries with keys "hostname", "ip", and "status". The administrator needs to extract a list of all hostnames where status is "online". The administrator writes:

- name: Get online hosts
  set_fact:
    online_hosts: "{{ server_facts | selectattr('status', '==', 'online') | map(attribute='hostname') | list }}"

However, when running the playbook, the "selectattr" filter fails with an error: "Invalid data passed to filter". The administrator checks the structure of "server_facts" and confirms it is a list of dicts with the expected keys. What is the most likely cause of the error?

Accepted Answer

The "status" key exists but its value is not consistently a string; some entries have integer 0/1 instead of "online"/"offline".. The `selectattr` filter in Ansible uses Jinja2's `selectattr` which relies on Python's `attrgetter` and comparison operators. If the `status` key exists but its value is not consistently a string (e.g., some entries have integer 0/1 instead of 'online'/'offline'), the equality comparison `'==', 'online'` will fail because an integer cannot be compared to a string in this context, causing an 'Invalid data passed to filter' error. The administrator confirmed the structure is correct, so the issue is likely a type mismatch in the values.

Answer

The "map" filter cannot be chained with "selectattr" directly.

Answer

The "list" filter is unnecessary and causes the error.

Answer

The "selectattr" filter requires Python 3.8 or later.

Question 3

An Ansible playbook is used to generate configuration files for network devices. The variables are defined in a vars file like:
---
interfaces:
  - name: GigabitEthernet1
    ip: 192.168.1.1/24
  - name: GigabitEthernet2
    ip: 10.0.0.1/24

The playbook uses a Jinja2 template to render the config. The template iterates over interfaces and writes "ip address" lines. However, the designer wants to support an additional field "secondary_ips" which is a list of IP addresses (e.g., ["192.168.2.1/24", "192.168.3.1/24"]). In the template, they want to generate multiple "ip address" lines for each interface, one for the primary IP and one for each secondary IP. The following template fragment is used:
{% for iface in interfaces %}
interface {{ iface.name }}
 ip address {{ iface.ip }}
{% for sec in iface.secondary_ips|default([]) %}
 ip address {{ sec }}
{% endfor %}
{% endfor %}

This works when secondary_ips is defined. However, some interfaces have secondary_ips defined as a string (e.g., "192.168.2.1/24") instead of a list. The playbook fails because the inner loop tries to iterate over a string. The engineer wants to normalize the data in the playbook before passing to the template, so that secondary_ips is always a list. Which of the following set_fact tasks will correctly transform the interfaces list to ensure secondary_ips is always a list (even if missing or a string)?

Accepted Answer

- set_fact:
    interfaces: "{{ interfaces | map('combine', {'secondary_ips': (item.secondary_ips is undefined or item.secondary_ips is none) | ternary([], (item.secondary_ips is string) | ternary(item.secondary_ips | split(','), item.secondary_ips))}) }}"
  loop: "{{ interfaces }}". Ly uses the `ternary` filter to handle three cases: when `secondary_ips` is undefined or None (returns an empty list), when it is a string (splits it into a list), and when it is already a list (returns it unchanged). This ensures the template always receives a list for iteration, preventing the 'iteration over string' error.

Answer

- set_fact:
    interfaces: "{{ interfaces | map('combine', {'secondary_ips': item.secondary_ips | default([]) | split(',') if item.secondary_ips is defined and item.secondary_ips is string else item.secondary_ips | default([])}) }}"
  loop: "{{ interfaces }}"

Answer

- set_fact:
    interfaces: "{{ interfaces | map('combine', {'secondary_ips': [item.secondary_ips | default('')] | flatten }) }}"
  loop: "{{ interfaces }}"

Answer

- set_fact:
    interfaces: "{{ interfaces | map('combine', {'secondary_ips': item.secondary_ips | default([]) | string | split(',') | list}) }}"
  loop: "{{ interfaces }}"

Question 4

An Ansible automation is used to manage firewall rules on a set of Linux servers. The playbook defines a variable "allow_rules" as:
allow_rules:
  - proto: tcp
    dport: 80
    comment: HTTP
  - proto: tcp
    dport: 443
    comment: HTTPS

The engineer needs to use the "iptables" module to create rules. The module expects "chain" to be specified, and the engineer wants to dynamically set the chain based on the port: ports 80 and 443 go to "INPUT" chain, while others go to "FORWARD". The engineer writes a loop:
- name: Add iptables rules
  iptables:
    chain: "{{ item.dport | map('some_filter') }}"
    protocol: "{{ item.proto }}"
    destination_port: "{{ item.dport }}"
    comment: "{{ item.comment }}"
  loop: "{{ allow_rules }}"

But this fails because the chain field expects a string, not a list. The engineer realizes the map filter returns a list. Which of the following modifications correctly sets the chain based on port number?

Accepted Answer

chain: "{{ (item.dport in [80,443]) | ternary('INPUT', 'FORWARD') }}". It uses the `ternary` filter to evaluate a condition (`item.dport in [80,443]`) and return 'INPUT' if true, or 'FORWARD' if false. This produces a single string, which is exactly what the `chain` parameter expects, avoiding the list output from `map`.

Answer

chain: "{{ item.dport | regex_replace('^(80|443)$', 'INPUT') | default('FORWARD', true) }}"

Answer

chain: "{{ item.dport | select('in', [80,443]) | list | first | default('FORWARD') }}"

Answer

chain: "{{ item.dport | replace('80','INPUT') | replace('443','INPUT') | default('FORWARD') }}"

Question 5

A playbook reads a JSON inventory file with `lookup('file', 'hosts.json') | from_json` and registers it as `hostdata`. The structure is a top-level dictionary where each key is a hostname and each value is a dictionary of attributes, for example `{"web1": {"env": "prod", "cpu": 4}, "db1": {"env": "dev", "cpu": 8}}`. You must build a list containing only the hostnames whose `env` attribute equals `prod`. Which task correctly produces that list?

Accepted Answer

- set_fact:
    prod_hosts: "{{ hostdata | dict2items | selectattr('value.env', 'equalto', 'prod') | map(attribute='key') | list }}". Because the source is a dictionary keyed by hostname, it must first be turned into an iterable list of pairs with `dict2items`. Each pair then exposes the hostname as `key` and the attribute dictionary as `value`, so the environment test must reference `value.env`. Extracting `key` afterwards yields exactly the list of prod hostnames the task requires.

Answer

- set_fact:
    prod_hosts: "{{ hostdata | dict2items | selectattr('value.env', 'equalto', 'prod') | map(attribute='value') | list }}"

Answer

- set_fact:
    prod_hosts: "{{ hostdata | dict2items | selectattr('env', 'equalto', 'prod') | map(attribute='key') | list }}"

Answer

- set_fact:
    prod_hosts: "{{ hostdata | selectattr('env', 'equalto', 'prod') | map(attribute='name') | list }}"

Question 6

A playbook reads a YAML file containing a list of dictionaries named `packages`, where each dictionary has keys `name`, `version`, and `enabled`. You need to produce a comma-separated string of only the `name` values for all entries where `enabled` is true. Which Jinja2 expression accomplishes this in a single task variable assignment?

Accepted Answer

{{ packages | selectattr('enabled') | map(attribute='name') | join(',') }}. Filtering a list of dictionaries by a boolean attribute and then extracting a specific key is a common data transformation. The `selectattr` filter is designed to filter by attribute, `map(attribute=...)` extracts the desired key, and `join` combines the results into a string. The order of operations is critical: filter first, then map, then join.

Answer

Answer

{{ packages | select('enabled') | map(attribute='name') | join(',') }}

Answer

{{ packages | map(attribute='name') | selectattr('enabled') | join(',') }}

Question 7

A playbook reads a YAML configuration file with the `include_vars` module and registers the result. The variable `app_config` now holds a dictionary with keys `database`, `cache`, and `logging`. You need to produce a list containing only the top-level key names for a later loop. Which Jinja2 filter expression should you use in the task that builds this list?

Accepted Answer

{{ app_config | dict2items | map(attribute='key') | list }}. To turn dictionary keys into a list, the canonical approach is to convert the dictionary to a list of `{key, value}` dictionaries with `dict2items`, then extract the `key` attribute using `map`. The resulting list can be looped over directly. Filters like `items2dict`, `flatten`, and `subelements` operate on different data shapes and do not produce top-level key names from a plain dictionary.

Answer

Answer

Answer

{{ app_config | subelements('key') | map(attribute='key') | list }}

Question 8

A task registers the output of a command that returns a string containing a JSON document in `result.stdout`. You must extract the numeric value at `metrics.cpu.load` and use it as an integer in a subsequent comparison. Which expression correctly parses the string and retrieves the integer value?

Accepted Answer

{{ result.stdout | from_json | json_query('metrics.cpu.load') | int }}. The correct order is to parse the raw JSON string first with `from_json`, then traverse the nested structure with `json_query`, and finally cast the extracted value with `int`. Reversing or substituting `to_json` breaks the pipeline because it serializes rather than parses. Using `map` is inappropriate for a single dictionary input, and querying before parsing cannot succeed on a raw string.

Answer

{{ result.stdout | json_query('metrics.cpu.load') | from_json | int }}

Answer

{{ result.stdout | to_json | json_query('metrics.cpu.load') | int }}

Answer

{{ result.stdout | from_json | map(attribute='metrics.cpu.load') | int }}

Question 9

A playbook reads a JSON file on the control node with the `file` lookup and registers the content as a string named `raw_config`. A task must convert that string into a native Python dictionary so later tasks can reference keys such as `raw_config.database.port`. Which filter should be applied to the registered content?

Accepted Answer

from_json. The registered content is a string because the lookup returns file contents verbatim. To use nested keys, that string must be parsed into Ansible's native data structures. The `from_json` filter performs exactly this deserialization, turning a JSON object string into a dictionary that supports dotted access. The reverse filter or YAML-specific parsers would not produce the required dictionary from a JSON string.

Answer

combine

Answer

from_yaml

Answer

to_json

Question 10

A playbook registers the output of a command that returns a JSON string inside stdout. The string contains a top-level key 'services' with a nested list of dictionaries. You need to convert that string into native data so you can select only entries where the 'state' key equals 'running'. Which expression accomplishes this?

Accepted Answer

{{ (command_result.stdout | from_json).services | selectattr('state', 'equalto', 'running') | list }}. Parsing the JSON string with from_json is required before any attribute-based filtering can occur. Once parsed, the nested list must be dereferenced through the 'services' key. Only then can selectattr compare each dictionary's 'state' value to 'running' and return the matching subset as a list.

Answer

{{ command_result.stdout | from_json | selectattr('state', 'equalto', 'running') | list }}

Answer

{{ command_result.stdout | from_json | map(attribute='services') | selectattr('state', 'equalto', 'running') | list }}

Answer

{{ command_result.stdout | to_json | selectattr('state', 'equalto', 'running') | list }}

Question 11

A playbook defines the variable `packages` as a list of dictionaries, each containing `name` and `version` keys. You need to build a new list of strings in the form `name-version` for use in a log message. Which filter combination produces this result?

Accepted Answer

{{ packages | map(attribute='name') | zip(packages | map(attribute='version')) | map('join', '-') | list }}. Building `name-version` strings from a list of dictionaries requires extracting both attributes separately and then pairing them. The `zip` filter aligns the two extracted lists element-wise, and `map('join', '-')` converts each pair into a hyphenated string. Filters like `combine`, `dict2items`, and `selectattr` operate on different data shapes and do not produce the desired formatted strings.

Answer

Answer

Answer

Question 12

A playbook registers the output of the `package_facts` module and must build a list containing only the version strings of installed packages whose name begins with 'httpd'. Which filter pipeline extracts those versions?

Accepted Answer

ansible_facts.packages | dict2items | selectattr('key', 'match', '^httpd') | map(attribute='value') | flatten | map(attribute='version') | list. Package facts are stored as a dictionary keyed by package name, with each value being a list of records. Extracting versions therefore requires converting the mapping to items, filtering keys, unwrapping the value lists with flatten, and then mapping the version attribute. Pipelines that skip the flatten step or that treat the dictionary as a list of objects cannot reach the nested version field.

Answer

ansible_facts.packages | dict2items | selectattr('key', 'match', '^httpd') | map(attribute='value.version') | list

Answer

ansible_facts.packages | selectattr('name', 'match', '^httpd') | map(attribute='version') | list

Answer

ansible_facts.packages | dict2items | selectattr('key', 'match', '^httpd') | map(attribute='value') | list

Question 13

A template must emit a comma-separated string of hostnames from a list variable `web_nodes`, sorted alphabetically, for use in a configuration file. Which expression produces that string?

Accepted Answer

{{ web_nodes | sort | join(',') }}. The order of filters matters: sorting must happen while the data is still a list, then joining converts it to a string. Applying join before sort would sort characters, and filters like unique or flatten do not impose alphabetical order. Only sorting the list first and then joining with a comma delimiter meets the requirement.

Answer

Answer

Answer

Question 14

You maintain a variable inventory_hostnames that is a list of FQDN strings such as 'web01.example.com'. A template must produce a new list containing only the hostname portion before the first dot for each entry, preserving order. Which Jinja2 expression using Ansible filters achieves this?

Accepted Answer

{{ inventory_hostnames | map('regex_replace', '^(.*?)\..*$', '\1') | list }}. Transforming each element of a list while preserving order is best done with map combined with a transformation filter. regex_replace with a capture group extracts the portion before the first dot for every FQDN, and list materializes the generator so the template emits an actual list. Selecting or joining would either leave the strings unchanged or collapse the collection, so mapping is the appropriate technique.

Answer

{{ inventory_hostnames | join('.') | regex_replace('\..*$', '') }}

Answer

Answer

Question 15

A playbook must normalize a list of dictionaries read from a YAML file. Each dictionary has keys 'name' and 'ports', where 'ports' is a comma-separated string such as '80,443'. You need to produce a new list where each dictionary has the same 'name' but 'ports' is a list of integers. Which TWO filter usages are required to accomplish this transformation? (Choose two.)

Accepted Answer

map('int') applied to the resulting token list to convert each string to an integer.. Converting a comma-separated string into a list of integers requires two distinct operations. Splitting on the comma produces string tokens, and mapping the int filter over those tokens converts each to a number. Together they yield the desired list of integer ports, which can then be assembled into each dictionary entry, satisfying the normalization requirement without manual iteration.

Answer

select('match', '^[0-9]+$') applied to the tokens to filter valid ports.

Answer

json_query('ports') applied to each dictionary to extract the ports field as a list.

Answer

combine() applied to the dictionaries to merge the new ports list into each entry.