Dynamic HCL Configuration practice questions

object

Why wrong: object is for fixed schemas with known keys.

list

Why wrong: list is for ordered sequences of a single type.

tuple

Why wrong: tuple is for ordered lists of fixed types.

Wrap in ()

Why wrong: Parentheses are for grouping expressions.

Wrap in []

Why wrong: Brackets [] create a list.

It is optional

Why wrong: The content block is required.

It is not allowed inside a dynamic block

Why wrong: It is the core component of a dynamic block.

It must be empty

Why wrong: It must contain the configuration attributes.

Using map(any)

Why wrong: Too loose for schema validation.

Using count = null

Why wrong: Not valid syntax.

keys()

Why wrong: keys returns the keys of a map, not a set from a list.

distinct()

Why wrong: distinct removes duplicates but does not change the type to a set.

compact()

Why wrong: compact removes null or empty strings, it does not change collection types.

The result is coerced to a string

Why wrong: There is no automatic coercion to string.

It defaults to the true result type

Why wrong: Terraform does not assume the true branch type is the target.

Terraform automatically casts to the most flexible type

Why wrong: Terraform is strictly typed regarding conditional branches and requires explicit conversion.

tolist()

Why wrong: tolist converts to a list, not a map.

flatten()

Why wrong: flatten reduces nested structures, it does not create map keys from list values.

merge()

Why wrong: merge combines maps, it does not transform a list into a map.

count.index

Why wrong: count.index is for the count meta-argument.

each.value

Why wrong: each.value is used in resource-level for_each, not dynamic blocks.

item

Why wrong: Terraform does not use 'item' as a default iterator name.

each.key

Why wrong: each.key accesses the map key, not the value.

item.value

Why wrong: This is not a valid Terraform object.

count.index

Why wrong: count.index is used with the count meta-argument.

concat()

Why wrong: concat joins two lists together.

lookup()

Why wrong: lookup retrieves values from a map.

merge()

Why wrong: merge combines maps.

try()

Why wrong: try is used for error handling, not resource lifecycle control.

dynamic block

Why wrong: Dynamic blocks are for nested resources, not the resource itself.

for_each

Why wrong: for_each creates multiple resources, it is not used for simple boolean toggling of a single resource.

instance_count

Why wrong: This is not a valid Terraform meta-argument.

count

Why wrong: While count can work with index lookups, for_each is specifically designed for collections.

dynamic

Why wrong: Dynamic blocks are for nested resource structures, not top-level resource instances.

for_each is only for maps

Why wrong: for_each works with sets of strings as well.

for_each does not support complex objects

Why wrong: for_each supports any collection that can be converted to a set or map.

count is faster than for_each

Why wrong: Performance difference is negligible for typical configurations.

It pauses execution and waits for input

Why wrong: Terraform does not pause for empty collections.

It throws a configuration error

Why wrong: An empty collection is valid and simply results in no blocks being created.

It generates a single block with null values

Why wrong: Terraform does not create blocks for empty inputs.

var.key

Why wrong: This does not reference the iteration context.

count.key

Why wrong: This is not a valid Terraform object.

each.value

Why wrong: each.value provides the value, not the key.

type = map(any)

Why wrong: map(any) is too loose and does not enforce specific key presence.

type = list(object)

Why wrong: This is not valid syntax for a type constraint.

type = tuple([...])

Why wrong: Tuple is for ordered sequences of specific types, not key-value objects.

try()

Why wrong: While try() can work, lookup() is the idiomatic map-specific tool.

element()

Why wrong: element() is for list indexing.

coalesce()

Why wrong: coalesce returns the first non-null argument, not map-specific.

tomap()

Why wrong: This would require keys to be defined.

distinct()

Why wrong: distinct is for filtering, not type conversion.

distinct()

Why wrong: distinct removes duplicates but doesn't guarantee the same type constraints for iteration as toset.

tolist()

Why wrong: This keeps it a list, which is not recommended for for_each.

using try()

Why wrong: try() is for error handling, though possible, it is not the standard way for null coalescing.

using count

Why wrong: count does not handle null values for resource attributes.

using for_each

Why wrong: for_each is for iteration.

Use count instead

Why wrong: count has its own stability issues.

Use the index

Why wrong: for_each doesn't use the index directly.

Nothing, it's always stable

Why wrong: List order changes can cause resource destruction/recreation.