Ansible Data Structures - The Silent Architect Way

The Silent Architect Way

You install Ansible.
You automate the first system.
The gain is visible.
It feels liberating.

Projects. Inventories. Variables. Secrets.

New items pop up.
They're scattered around.
Then they're duplicated in different places.

Confusion.
Errors.
Bug hunts.

Re-architect your growing data - like a Silent Architect.

Variables Haunt You - Everywhere

You start it simple.

Variables thrive in tasks. Roles. Playbooks.
Defaults, vars files. Even in templates.

name: DeadSwitch
slogan: Fear the silence, Fear the Switch.

You just use it.

- name: Using a variable
  ansible.builtin.debug:
    msg: "The variable is: {{ slogan }}."

Then you realize you need structure.
You build lists.

occupations:
  - Ghost Operator
  - Silent Architect
  - Digital Resistance Leader

The occupations variable is a list.
Comfortable.
You don't pick one element. You iterate the structure.

- name: Iterating a list
  ansible.builtin.debug:
    msg: The element is: {{ item }}.
  loop: "{{ occupations }}"

The silent echo comes:

ok: [localhost] => (item=Ghost Operator) => The element is: Ghost Operator
ok: [localhost] => (item=Silent Architect) => The element is: Silent Architect
ok: [localhost] => (item=Digital Resistance Leader) => The element is: Digital Resistance Leader

With dictionaries you identify the values.
They have keys.

user:
  deadswitch:
    name: DeadSwitch
    slogan: Fear the silence, Fear the Switch.
    occupation: Silent Architect

You can pick an element.

- name: Picking a dictionary element
  ansible.builtin.debug:
    msg: "The user's occupation is: {{ user.deadswitch.occupation }}."

Clean and dry.

Then Dark Ghosts possess the structure.
The Architect must tame them.

When The Structure Is Haunted - Embedded Data Structures

The lists were clean.
The dictionaries were sharp.

Then they merge.
They nest.
They twist inside each other.

servers:
  web:
    hosts:
      - web1.ghostnet.local
      - web2.ghostnet.local
    vars:
      role: frontend
      ssl: true
  db:
    hosts:
      - db1.ghostnet.local
    vars:
      role: backend
      replication: enabled

Now the structure is alive.
Keys hold lists. Lists hide keys.
Ghost Operators must know the paths.

- name: Access a nested dictionary
  ansible.builtin.debug:
    msg: "DB role is: {{ servers.db.vars.role }}"

- name: Iterate hosts of the web group
  ansible.builtin.debug:
    msg: "Web host: {{ item }}"
  loop: "{{ servers.web.hosts }}"

Haunted structures demand clarity.
Without discipline, you chase ghosts.

Walk The Path Of The Ghosts - Iterate The Structure

You tamed the Dark Ghosts.
The paths are clear.
Now you want to walk it.
A part of it. Or the entire system.

users:
  - name: ghost1
    role: watcher
  - name: ghost2
    role: operator
  - name: ghost3
    role: architect

Iterating a list of dictionaries:

- name: Walk through each ghost
  ansible.builtin.debug:
    msg: "{{ item.name }} takes the role: {{ item.role }}"
  loop: "{{ users }}"

But sometimes the dictionary itself must be walked:

secrets:
  key1: shadow
  key2: fog
  key3: silence

- name: Dict to items
  ansible.builtin.debug:
    msg: "Key: {{ item.key }} | Value: {{ item.value }}"
  loop: "{{ secrets | dict2items }}"

When the map is too twisted, flatten it.
When the ghosts hide, reveal them.

Exorcism Tools - Filters And Transforms

Walking the paths is not enough.
Sometimes you reshape them.
Bend them.
Burn away the noise.

Filters are the exorcism tools.

users:
  - name: ghost1
    role: watcher
  - name: ghost2
    role: operator
  - name: ghost3
    role: architect

Map reveals only what you need:

- name: Extract only the roles
  ansible.builtin.debug:
    msg: "Role: {{ item }}"
  loop: "{{ users | map(attribute='role') | list }}"

It whispers:

ok: [localhost] => (item=watcher) => Role: watcher
ok: [localhost] => (item=operator) => Role: operator
ok: [localhost] => (item=architect) => Role: architect

Select banishes what does not fit:

- name: Keep only operators
  ansible.builtin.debug:
    msg: "Operator: {{ item.name }}"
  loop: "{{ users | selectattr('role', 'equalto', 'operator') | list }}"

When the maze grows darker, json_query cuts through.
(JMESPath is your blade.)

- name: Using json_query
  ansible.builtin.debug:
    msg: "Architect: {{ users | json_query('[?role==`architect`].name') }}"

The echo is:

ok: [localhost] => Architect: ['ghost3']

Sometimes you want a clean string.

- name: Using json_query
  ansible.builtin.debug:
    msg: "Architect: {{ users | json_query('[?role==`architect`].name') | first }}"

The answer comes in a form of a string:

ok: [localhost] => Architect: ghost3

The Ghost Operator does not drown in data.
He transforms it.
The Architect reshapes the chaos into silence.

Final Whisper

The Operator is you.
You write the data. Architect the structure.
Then you bend it.

Lists grow, Dictionaries bind, Filters cut.