AWS provider Dynamic HCL Configuration Practice Test 3 — 15 Questions

Question 1

What is the primary difference between 'count' and 'for_each' regarding state management?

Accepted Answer

count uses index-based indexing, causing potential recreation when items are removed. The primary difference is that `count` uses index-based indexing, so removing an item from the middle of a list causes all subsequent resources to be re-indexed, potentially leading to unnecessary recreation. `for_each` uses key-based indexing, so removing an item only affects that specific resource, avoiding recreation of others.

Answer

for_each is only for maps

Answer

for_each does not support complex objects

Answer

count is faster than for_each

Question 2

What happens if you use a dynamic block with a 'for_each' expression that evaluates to an empty set?

Accepted Answer

It renders no blocks. Terraform's dynamic blocks iterate over the collection given to 'for_each'; if that collection is empty (empty set, list, or map), the iterator produces zero iterations and therefore zero nested blocks are rendered. This is the documented and intended behaviour, allowing conditional block generation without 'count' hacks.

Answer

It pauses execution and waits for input

Answer

It throws a configuration error

Answer

It generates a single block with null values

Question 3

You are iterating over a map using for_each. You need to access the key of the current map element. Which object do you use?

Accepted Answer

each.key. When using for_each with a map, Terraform automatically creates an each object that contains two attributes: each.key and each.value. each.key gives you the map key for the current iteration, while each.value gives the corresponding value. Therefore, to access the key of the current map element, you use each.key.

Answer

var.key

Answer

count.key

Answer

each.value

Question 4

You want to pass a complex object type to a module, but you need to ensure specific attributes are present. How do you define this in the variable block?

Accepted Answer

type = object({...}). The object({...}) type constraint lets you define a schema with specific named attributes and their types, ensuring required attributes are present and correctly typed. This is the correct way to pass a complex object with enforced structure to a module. It validates at plan time and rejects missing or extra attributes as configured.

Answer

type = map(any)

Answer

type = list(object)

Answer

type = tuple([...])

Question 5

Which function allows you to safely access a map value even if the key might not exist?

Accepted Answer

lookup(). The lookup() function is specifically designed to retrieve a value from a map by key while providing a fallback default if the key is absent, preventing errors. Its signature is lookup(map, key, default), so it safely handles missing keys without throwing an error. This makes it the idiomatic choice for optional map attributes in Terraform configurations.

Answer

try()

Answer

element()

Answer

coalesce()

Question 6

When using 'for_each' on a list of strings, what must you do to ensure the configuration is stable?

Accepted Answer

Convert the list to a set. for_each requires a map or set of strings, not a list, because list indices are positional and unstable — inserting or removing an element shifts every subsequent index, causing Terraform to destroy and recreate resources. Converting the list to a set (e.g., toset(var.list)) gives each element a stable key based on its value, so resource addresses remain consistent across changes.

Answer

Use count instead

Answer

Use the index

Answer

Nothing, it's always stable

Question 7

Which of these is a valid use case for a dynamic block?

Accepted Answer

Defining nested repeatable blocks. A dynamic block in Terraform generates nested repeatable blocks within a resource, data source, provider, or module — for example, multiple `ingress` blocks in an `aws_security_group` or multiple `tag` blocks. It iterates over a collection and produces one nested block per element, using an iterator to reference each item. This is its sole purpose.

Answer

Conditional module inclusion

Answer

Changing the provider configuration dynamically

Answer

Defining multiple separate resources

Question 8

Which meta-argument is best for deploying resources that are strictly dependent on the number of items in a configuration?

Accepted Answer

count. The `count` meta-argument is best for deploying resources that are strictly dependent on the number of items in a configuration. It takes an integer and creates that many instances of the resource. This is ideal when you need a specific number of identical resources, such as creating three EC2 instances.

Answer

for_each

Answer

provider

Answer

dynamic

Question 9

How can you debug the output of a complex 'for' expression in Terraform?

Accepted Answer

Use terraform console. terraform console launches an interactive REPL where you can evaluate HCL expressions — including complex for expressions, functions, and variable references — against the current configuration and state, printing the result immediately. This makes it the fastest way to inspect what a for expression actually produces without running a full plan. It's the standard debugging tool for expression logic in Terraform.

Answer

Check the state file

Answer

Use terraform plan

Answer

Use terraform debug

Question 10

Which TWO of the following are valid uses of the 'for' expression?

Accepted Answer

Generating a list. In Terraform, the 'for' expression is used to transform and produce collection values: option B is correct because a 'for' expression over a list or set returns a tuple/list, e.g. [for s in var.subnets : upper(s)], which generates a list. Option E is correct because using the curly-brace form, e.g. {for k, v in var.tags : k => upper(v)}, produces a map (object) of key-value pairs. Option A is not a use of 'for' because resources are declared with a 'resource' block, not an expression. Option C is wrong because provider configuration is handled by 'provider' blocks and required_providers, not 'for'. Option D is wrong because dynamic blocks are created with the 'dynamic' block and its 'for_each' argument, not with a 'for' expression.

Answer

Defining a resource

Answer

Managing provider blocks

Answer

Creating dynamic blocks

Question 11

Which TWO of the following statements are correct regarding 'for_each' and state?

Accepted Answer

for_each creates stable identifiers based on keys. Option A is correct because for_each keys each instance by a map key or set member, so the resulting resource addresses (for example aws_instance.web["web1"]) remain stable across reordering or insertion of other elements, which keeps state entries tied to the same object. Option D is correct because for_each is the recommended construct for map-based (and set-based) configurations, since it iterates over key/value pairs and avoids the index-shifting problems that count causes when list elements are added or removed. Option B is wrong because count is not preferred for all resource types; it is only suitable when instances are truly identical and index-based addressing is acceptable. Option C is wrong because count uses numeric indexes (resource[0], resource[1]), which are not key-based and therefore not stable when the list changes. Option E is wrong because for_each is a core Terraform meta-argument available to resources, data sources, and modules, not limited to cloud resources.

Answer

count is preferred for all resource types

Answer

count creates stable identifiers based on keys

Answer

for_each is only available for cloud resources

Question 12

Which THREE of the following are valid ways to transform data for Terraform configuration?

Accepted Answer

flatten(). Option A, flatten(), is correct because it is a built-in Terraform function that takes a list of lists and transforms it into a single flat list, which is a valid data transformation for configuration. Option B, merge(), is correct because it is a built-in Terraform function that combines multiple maps or objects into one map, a common way to transform and consolidate data in Terraform. Option E, for expressions, is correct because Terraform's for expressions iterate over lists, sets, maps, or objects to produce a new transformed list or map, making them a core transformation mechanism. Option C, split_map(), is not a valid Terraform function, so it cannot transform data. Option D, loop(), is not a Terraform construct; iteration is handled by for expressions, count, or for_each, not a loop() function.

Answer

split_map()

Answer

loop()

Question 13

Which TWO of the following functions are most useful for manipulating lists?

Accepted Answer

concat(). In this scenario, concat() (B) is correct because it joins two lists end-to-end into a single list, which is a core list-manipulation operation for combining sequences. flatten() (C) is also correct because it collapses nested lists into a single-level list, directly transforming list structure. The other options do not belong: keys() (A) is used to retrieve the key names of a map/object, not to manipulate lists; lookup() (D) retrieves a value associated with a key in a map or table, not a list operation; and merge() (E) typically combines maps/objects by key, not lists.

Answer

keys()

Answer

lookup()

Answer

merge()

Question 14

Which THREE of the following represent potential pitfalls when using 'count'?

Accepted Answer

Inability to use string keys for identification. Option A is correct because count-based resources are identified by numeric index in the state file, so you cannot use meaningful string keys to reference or target individual instances, making identification and targeting cumbersome. Option B is correct because conditionally creating or excluding specific instances with count requires awkward inline conditional expressions (for example, count = var.enabled ? 1 : 0) rather than clean per-item logic, which complicates configuration. Option C is correct because count indexes are positional, so removing an item from the middle of a list shifts the indexes of all subsequent items, causing Terraform to plan destruction and recreation of resources that should have remained unchanged. Option D is not correct because count itself does not inherently cause performance problems with large collections; performance depends on provider API calls and plan graph size, not the count meta-argument specifically. Option E is not correct because count is an integer meta-argument and does not introduce type mismatch errors; type mismatches arise from incorrect variable or attribute types, not from using count.

Answer

Performance issues with large collections

Answer

Type mismatch errors

Question 15

Which THREE of the following are valid ways to pass data to a module dynamically?

Accepted Answer

Using variables. Option A (Using variables) is correct because Terraform modules accept input values through declared input variables, and callers pass data dynamically via the module block's arguments (e.g., variable_name = value), which is the standard mechanism for parameterizing a module. Option D (Using for_each on a module block) is correct because Terraform supports for_each on module blocks, allowing multiple module instances to be created dynamically from a map or set, with each instance receiving distinct input values derived from the iteration. Option E (Using complex object types) is correct because input variables can be typed as complex types such as object({...}), map, list, or tuple, enabling structured, dynamic data to be passed into a module rather than only simple primitives. Option B (Directly editing the state) is not a valid way to pass data to a module, since the state file is a record of managed infrastructure and manually editing it is unsupported and does not feed inputs into module configuration. Option C (Using a dynamic block for module calling) is not valid because dynamic blocks only generate repeated nested configuration blocks within a resource, data, or module argument, not the module call itself, so they cannot be used to invoke modules dynamically.

Answer

Directly editing the state

Answer

Using a dynamic block for module calling