Terraform-Associate-004 HashiCorp Certified: Terraform Associate (004) (HCTA0-004) Questions and Answers

You can install third party plugins using terraform init, as long as you specify the plugin directory in your configuration or as a command-line argument. You can also use the terraform providers mirror command to create a local mirror of providers from any source.

The correct answers are A and C. To update a registry module from version 4.2.1 to 5.0.0, you must first update the module block’s version argument so Terraform knows which module version is required. After changing the module version constraint, you must reinitialize the working directory so Terraform can install the selected module version into the local .terraform directory. In many real workflows, terraform init is sufficient after changing the version, while terraform init -upgrade is commonly used when refreshing already-installed modules to newer acceptable versions. terraform pull is not a Terraform command for updating modules. Removing the version argument is not a controlled upgrade because Terraform may then choose the newest available version, which can reduce reproducibility and increase upgrade risk.

Detailed Explanation:

Rationale for Correct Answer: The import block declaratively tells Terraform to associate an existing infrastructure object with a Terraform resource address. After the configuration is applied, Terraform imports the existing resource and updates Terraform state so that Terraform can manage it.

Analysis of Incorrect Options (Distractors):

A: Moving resources between state addresses or state files is a state-management operation; it is not the purpose of an import block.

B: The import block does not merge Terraform state files.

C: Modules are downloaded during initialization, not by an import block.

Key Concept: Bringing existing infrastructure under Terraform management by importing it into state.

According to theofficial Terraform documentationhere:

???? Terraform Docs – Declaring an Output Value

In Terraform 0.12 and later, you can directly use expressions in outputs without interpolation syntax:

output " instance_ip_addr " {

value = aws_instance.server.private_ip

}

This aligns perfectly withOption A:

output " instance_ip_addr " {

value = aws_instance.main.private_ip

}

Why not the others?

❌Option B: Incorrect syntax. " ${main.private_ip} " is referencing main as if it were a global variable or resource, but it isn’t defined. Plus, the output name is oddly written as aws_instance.instance_ip_addr, which is not a valid identifier format.

❌Option C: Although valid in older versions ( < = 0.11), interpolation with " ${} " isdeprecatedin Terraform 0.12+. The docs clearly advise using direct expressions instead.

❌Option D: Terraform hasno return statement; this is syntactically invalid in Terraform’s HCL.

Detailed Explanation:

Rationale for Correct Answer:

A is correct because Terraform may replace (destroy and recreate) resources when changes cannot be applied in-place. This behavior depends on the provider and resource type (e.g., immutable infrastructure changes).

B is correct because terraform apply operates on the configuration in the current working directory and uses the currently selected workspace, which determines the state being modified.

Analysis of Incorrect Options (Distractors):

C. You must pass the output of a terraform plan command to it. Incorrect because passing a saved plan file is optional. Running terraform apply without a plan will generate and apply a plan automatically.

D. By default, it does not refresh your state file. Incorrect because Terraform does refresh state by default before applying changes (unless explicitly disabled).

E. You cannot target specific resources. Incorrect because you can use the -target flag to apply changes to specific resources.

Key Concept:Behavior of terraform apply, including execution scope, state refresh, and resource lifecycle (create/update/replace).

The terraform refresh-only command is intended to detect state file drift. This command synchronizes the state file with the actual infrastructure, updating the state to reflect any changes that have occurred outside of Terraform.

From terraform plan -refresh-only:

" Use this to detectdrift, i.e., changes made outside of Terraform. "

It compares actual infrastructure to what ' s recorded in the state file.

If you update the version constraint in your Terraform configuration, Terraform will update your lock file the next time you run terraform init3. This will ensure that you use the same provider versions across different machines and runs.

This is how Terraform manages most dependencies between resources, by using the references between them in the configuration files. For example, if resource A depends on resource B, Terraform will create resource B first and then pass its attributes to resource A.

The correct answers are A and C. Terraform custom conditions let you define validation rules through precondition and postcondition blocks. When a resource uses count or for_each, Terraform evaluates preconditions separately for each resource instance, which allows instance-specific checks using values such as count.index or each.key. A precondition must pass before Terraform proceeds with the resource action, so it can block creation, update, or replacement when the configured condition is not satisfied. Option B is incorrect because Terraform can evaluate some conditions later if values are unknown during planning, depending on the expression and dependency graph. Option D is incorrect because a failed postcondition prevents downstream resources from relying on an invalid result, helping stop dependent changes from proceeding with bad assumptions.

In Terraform, a data block is used to fetch or compute information from external sources for use elsewhere in the Terraform configuration. Unlike resource blocks that manage infrastructure, data blocks gather information without directly managing any resources. This can include querying for data from cloud providers, external APIs, or other Terraform states.References = This definition and usage of data blocks are covered in Terraform ' s official documentation, highlighting their role in fetching external information to inform Terraform configurations.

Rationale for Correct Answer: A resource block creates/updates/destroys an infrastructure object and contains the configuration settings for that managed object (e.g., a VM, bucket, network). This is how Terraform manages real infrastructure.

Analysis of Incorrect Options (Distractors):

B (provider): Configures how Terraform connects to an API (region, credentials), not an infrastructure object.

C (data): Reads existing infrastructure; it does not manage (create/update/destroy) it.

D (locals): Defines named expressions for reuse; it doesn’t manage infrastructure.

Key Concept: Managed infrastructure is defined with resource blocks.

You should use the force-unlock command when automatic unlocking failed. Terraform will lock your state for all operations that could write state, such as plan, apply, or destroy. This prevents others from acquiring the lock and potentially corrupting your state. State locking happens automatically on all operations that could write state and you won’t see any message that it is happening. If state locking fails, Terraform will not continue. You can disable state locking for most commands with the -lock flag but it is not recommended. If acquiring the lock is taking longer than expected, Terraform will output a status message. If Terraform doesn’t output a message, state locking is still occurring if your backend supports it. Terraform has a force-unlock command to manually unlock the state if unlocking failed. Be very careful with this command. If you unlock the state when someone else is holding the lock it could cause multiple writers. Force unlock should only be used to unlock your own lock in the situation where automatic unlocking failed. To protect you, the force-unlock command requires a unique lock ID. Terraform will output this lock ID if unlocking fails. This lock ID acts as a nonce, ensuring that locks and unlocks target the correct lock. The other situations are not valid reasons to use the force-unlock command. You should not use the force-unlock command if you have a high priority change, if apply failed due to a state lock, or if you see a status message that you cannot acquire the lock. These situations indicate that someone else is holding the lock and you should wait for them to finish theiroperation or contact them to resolve the issue. Using the force-unlock command in these cases could result in data loss or inconsistency. References = [State Locking], [Command: force-unlock]

Environment variables and connection configurations outside of Terraform are secure options for storing secrets for connecting to a Terraform remote backend. Environment variables can be used to set values for input variables that contain secrets, such as backend access keys or tokens. Terraform will read environment variables that start with TF_VAR_ and match the name of an input variable. For example, if you have an input variable called backend_token, you can set its value with the environment variable TF_VAR_backend_token1. Connection configurations outside of Terraform are files or scripts that provide credentials or other information for Terraform to connect to a remote backend. For example, you can use a credentials file for the S3 backend2, or a shell script for the HTTP backend3. These files or scripts are not part of the Terraform configuration and can be stored securely in a separate location. The other options are not secure for storing secrets. A variable file is a file that contains values for input variables. Variable files are usually stored in the same directory as the Terraform configuration or in a version control system. This exposes the secrets to anyone who can access the files or the repository. You should not store secrets in variable files1. Inside the backend block within the Terraform configuration is where you specify the type and settings of the remote backend. The backend block is part of the Terraform configuration and is usually stored in a version control system. This exposes the secrets to anyone who can access the configuration or the repository. You should not store secrets in the backend block4. References = [Terraform Input Variables] 1, [Backend Type: s3]2, [Backend Type: http] 3, [Backend Configuration]4

Detailed Explanation:

Rationale for Correct Answer: Infrastructure as Code best practice is to make infrastructure changes through version-controlled configuration. With HCP Terraform, a common and recommended workflow is to modify Terraform code in a branch, submit a pull request, review and approve the change, merge it, and let HCP Terraform execute the run based on that VCS-driven workflow. This preserves review history, auditability, collaboration, and consistency.

Analysis of Incorrect Options (Distractors):

A. Clone the repository containing your infrastructure code, and then run the code. Incorrect. Running locally can bypass centralized HCP Terraform workflow controls, policy checks, approvals, and audit trails.

B. Use the public cloud console to make the change. Incorrect. Console changes create configuration drift and bypass Terraform state and version control.

C. Make the change through the public cloud API endpoint. Incorrect. Direct API changes bypass Terraform and can cause drift.

D. Run the public cloud CLI tool to make the change. Incorrect. Cloud CLI changes are imperative changes outside Terraform’s managed workflow.

Key Concept: Infrastructure changes should be made through version-controlled Terraform configuration and reviewed before being applied.

Setting the TF_LOG environment variable to DEBUG causes debug messages to be logged into stdout, along with other log levels such as TRACE, INFO, WARN, and ERROR. This can be useful for troubleshooting or debugging purposes.

Detailed Explanation:

Rationale for Correct Answer: The configuration uses a data block, not a resource block. In Terraform, a data block reads information about existing infrastructure from a provider. It does not create, update, or delete infrastructure. This data source searches for an existing AWS EC2 instance with the tag Name = web.

Analysis of Incorrect Options (Distractors):

A. True. Incorrect. A new AWS instance would be created using a resource block such as resource " aws_instance " " web " { ... }, not a data source.

Key Concept: Terraform data blocks are used to query existing infrastructure, while resource blocks manage infrastructure lifecycle.

Rationale for Correct Answer: The Terraform import block (used with configuration-driven import) must specify:

id: the resource ID from the provider (the remote object identifier).

to: the target resource address in your configuration (where the imported object should map in state, e.g., aws_s3_bucket.example).These are the essential inputs Terraform needs to associate an existing remote object with a resource address in state.

Analysis of Incorrect Options (Distractors):

B (Provider): Not required as a parameter in the import block. Provider selection is determined by the configuration/provider setup (and optionally by provider meta-arguments on the resource), not by a required import block field.

D (Backend): Backends configure state storage and are set in the terraform block, unrelated to the import block’s required arguments.

Key Concept: Configuration-driven import requires mapping an existing remote object (id) to a resource address (to).

This is the meta-argument that you must include in any non-default provider configurations, as it allows you to give a friendly name to the configuration and reference it in other parts of your code. The other options are either invalid or irrelevant for this purpose.

Rationale for Correct Answer:Terraform detects drift by refreshing state during terraform apply. Since the VM no longer exists but is still declared in configuration, Terraform will plan and recreate the missing resource.

Analysis of Incorrect Options (Distractors):

B. Error: Terraform treats this as drift, not an error.

C. Remove from state: Terraform does not remove resources automatically unless instructed.

D. No changes: Incorrect because drift is detected and corrected.

Key Concept:Terraform enforces the desired state defined in configuration, correcting drift automatically.

Detailed Explanation:

Rationale for Correct Answer: In refresh-only mode, Terraform updates the state based on the existing state and the real infrastructure returned by provider APIs. It does not use resource configuration arguments to propose infrastructure changes. The goal is to reconcile Terraform state with remote objects, not to change infrastructure to match configuration.

Analysis of Incorrect Options (Distractors):

B. Authentication credentials for the provider. Incorrect. Terraform needs provider credentials to query the real infrastructure.

C. The most recent state file. Incorrect. Terraform uses the current state as the baseline for determining which managed objects to refresh.

D. The actual infrastructure as reported by the provider API. Incorrect. This is exactly what Terraform consults to refresh state.

Key Concept: terraform apply -refresh-only updates Terraform state from real infrastructure without applying configuration-driven infrastructure changes.

Terraform validate reports configuration consistency errors, such as declaring a resource identifier more than once. This means that the same resource type and name combination is used for multiple resource blocks, which is not allowed in Terraform. For example, resource " aws_instance " " example " {...} cannot be used more than once in the same configuration. Terraform validate does not report errors related to module versions, state differences, or formatting issues, as these are not relevant for checking the configuration syntax and structure. References = [Validate Configuration], [Resource Syntax]

Detailed Explanation:

Rationale for Correct Answer:Changing count changes the desired number of resource instances. To reconcile real infrastructure with the updated configuration, you run terraform apply (typically after reviewing the plan). Terraform will create/destroy instances as needed to match the new count value.

Analysis of Incorrect Options (Distractors):

A: Incorrect. terraform init is required when you add/change providers, modules, or backend configuration—not for simple variable value changes.

B: Incorrect. Outputs do not change infrastructure; they only display derived values.

C: Incorrect. You generally should not edit state to reflect intended changes; you apply configuration changes and let Terraform update state.

Key Concept:Terraform workflow: update configuration → plan/apply to converge infrastructure to desired state.

Rationale for Correct Answer:

A: The plan is stale because state changed after it was created. The correct fix is to recreate the plan against the latest state and apply that new plan.

B: Running terraform apply without specifying the old plan causes Terraform to re-plan using the current state and configuration, then apply the resulting changes.

Analysis of Incorrect Options (Distractors):

C: -lock=false disables locking; it does not make an old plan valid and is unsafe in team environments.

D: -refresh-only changes what’s recorded in state (when applied) but does not “unstale” an existing saved plan file.

E: terraform state push is for advanced/manual state management and does not update a saved plan file; using it here is inappropriate and risky.

Key Concept: Saved plans are tied to a specific state snapshot; if state changes, you must re-plan.

Terraform configuration can import modules from various sources, not only from the public registry. Modules can be sourced from local file paths, Git repositories, HTTP URLs, Mercurial repositories, S3 buckets, and GCS buckets. Terraform supports a number of common conventions and syntaxes for specifying module sources, as documented in the [Module Sources] page. References = [Module Sources]

Changing the Terraform backend after performing the initial terraform apply is technically possible but strongly discouraged. This is because changing backends can lead to complexities in state management, requiring manual intervention such as state migration to ensure consistency. Terraform ' s documentation and best practices advise planning the backend configuration carefully before applying Terraform configurations to avoid such changes.References = This guidance is consistent with Terraform ' s official documentation, which recommends careful consideration and planning of backend configurations to avoid the need for changes.

Module Versioning: To specify a version in a module block for modules in theTerraform Registry, you add the version attribute, e.g., version = " 1.0.0 " .

Terraform Registry Support: The public registrysupports versioningby enabling semantic constraints, allowing users to define specific versions compatible with their infrastructure requirements.

Refer to themodule versioning documentationin Terraform’s official registry guide.

The terraform validate command is used to check that your Terraform configuration files are syntactically valid and internally consistent. It is a useful command for ensuring your Terraform code is error-free before applying any changes to your infrastructure.

This is the command that always causes a state file to be updated with changes that might have been made outside of Terraform, as it will only refresh the state file with the current status of the real resources, without making any changes to them or creating a plan.

State locking prevents other users from modifying the state file while a Terraform operation is in progress. This prevents conflicts and data loss1.

Rationale for Correct Answer (False):

Any user with access to the saved plan file (terraform plan -out=planfile) can run terraform apply planfile. Terraform does not enforce user-specific restrictions.

Analysis of Incorrect Option:

True: Incorrect — Terraform doesn’t tie plan files to individual users.

Key Concept:

Plan files ensure predictability but are not bound to the identity of the user.

Rationale for Correct Answer:By default, terraform fmt modifies files in place to match Terraform’s canonical formatting. The -check flag is required to only check formatting without making changes.

Analysis of Incorrect Options (Distractors):

A: Incorrect because formatting changes are applied automatically by default.

Key Concept:terraform fmt enforces consistent formatting by rewriting files unless instructed otherwise.

The Terraform Cloud private registry provides the ability to restrict modules to members of Terraform Cloud or Enterprise organizations. This allows you to share modules within your organization without exposing them to the public. The private registry also supports importing modules from your private VCS repositories. The public Terraform Module Registry, on the other hand, publishes modules from public Git repositories and makes them available to any user of Terraform. References = : Private Registry - Terraform Cloud : Terraform Registry - Provider Documentation

Rationale for Correct Answer:When using count, Terraform creates resources indexed starting at 0.With count = 2, the instances are indexed as:

First instance → aws_instance.web[0]

Second instance → aws_instance.web[1]

To reference the name attribute of the second instance, the correct syntax is:

aws_instance.web[1].name

Analysis of Incorrect Options (Distractors):

A. [2]: Incorrect because indexing starts at 0 and only indices 0 and 1 exist.

B. *.name: Returns a list of all names, not a single instance value.

D. [1]: References the whole resource object, not the name attribute.

E. element(...): Incorrect syntax and wrong index; also unnecessary when direct indexing is available.

Key Concept:Understanding resource indexing with count and zero-based indexing in Terraform.

A secure string is not a valid option to keep secrets out of Terraform configuration files. A secure string is a feature of AWS Systems Manager Parameter Store that allows you to store sensitive data encrypted with a KMS key. However, Terraform does not support secure strings natively and requires a custom data source to retrieve them. The other options are valid ways to keep secrets out of Terraform configuration files. A Terraform provider can expose secrets as data sources that can be referenced in the configuration. Environment variables can be used to set values for input variables that contain secrets. A -var flag can be used to pass values for input variables that contain secrets from the command line or a file. References = [AWS Systems Manager Parameter Store], [Terraform AWS Provider Issue #55] , [Terraform Providers], [Terraform Input Variables]

Rationale for Correct Answer: To expose values from a child module to a parent module, you define an output in the child module (e.g., output " public_ip " { value = aws_instance.example.public_ip }). The parent module can then reference it via module. < child_name > .public_ip.

Analysis of Incorrect Options (Distractors):

B: A data source in the parent could look up an instance, but that’s unnecessary and brittle compared to using module outputs (and may require extra identifiers).

C: Import is for bringing existing resources into state; it doesn’t expose attributes between modules.

D: Locals are only scoped within the module; they are not accessible from the parent.

Key Concept: Module composition: outputs are the contract for passing data from child to parent.

This is the command that lets you experiment with Terraform expressions, by providing an interactive console that allows you to evaluate expressions and see their results. You can use this command to test your expressions before using them in your configuration files.

This is not true, as modules can be either public or private, depending on your needs and preferences. You can use the Terraform Registry to publish and consume public modules, or use Terraform Cloud or Terraform Enterprise to host and manage private modules.

You cannot access state stored with the local backend by using the terraform_remote_state data source. The terraform_remote_state data source is used to retrieve the root module output values from some other Terraform configuration using the latest state snapshot from the remote backend. It requires a backend that supports remote state storage, such as S3, Consul, AzureRM, or GCS. The local backend stores the state file locally on the filesystem, which terraform_remote_state cannot access.

Detailed Explanation:

Rationale for Correct Answer:

C (tfe_outputs data source): This automates step #2 by allowing the example-compute workspace to read output values directly from the example-network workspace, eliminating manual copying of outputs into input variables. This aligns with Terraform objectives around using HCP Terraform capabilities to share data between workspaces safely and consistently.

E (Run trigger on example-compute): This automates step #3 by making example-compute automatically run (plan, and then apply depending on settings) after HCP Terraform successfully applies changes in example-network. Run triggers are specifically designed to orchestrate workspace dependencies so downstream infrastructure reacts to upstream changes.

Analysis of Incorrect Options (Distractors):

A: Incorrect. Health checks are not used to orchestrate cross-workspace plans/applies. They are for monitoring run status/health signals, not dependency automation.

B: Incorrect for the same reason as A—health checks don’t trigger downstream runs based on upstream applies.

D: Incorrect. The run trigger should be configured on the downstream workspace (example-compute) so it is triggered by upstream changes. Configuring it “on the network workspace” is the wrong direction for this dependency flow in typical HCP Terraform orchestration.

Key Concept:Automating dependencies between HCP Terraform workspaces using:

Cross-workspace output consumption (tfe_outputs) and

Run triggers to automatically start downstream runs after upstream applies.

Infrastructure as Code (IaC) refers to managing infrastructureprogrammatically, enabling automation and repeatability.

Ais incorrect becauseIaC is not just about software delivery pipelines; it specifically deals with infrastructure.

Bis incorrect because " Write once, run anywhere " applies more to software development than IaC.

Dis incorrect becauseIaC does not enforce vendor-agnostic APIs; it depends on the tool and provider.

Official Terraform Documentation Reference:

What is Infrastructure as Code?

Detailed Explanation:

Rationale for Correct Answer: terraform plan generates an execution plan so that you can preview the infrastructure changes Terraform intends to perform. It is commonly used to validate configuration changes and confirm that the proposed actions match your expectations before applying them.

Analysis of Incorrect Options (Distractors):

B: This describes state-refresh/synchronization behavior rather than the primary purpose of a normal plan.

C: terraform init initializes the working directory.

D: terraform fmt formats Terraform configuration files.

Key Concept: The Terraform workflow of previewing changes before applying them.

The terraform import command is used to import existing infrastructure into your Terraform state. This command takes the existing resource and associates it with a resource defined in your Terraform configuration, updating the state file accordingly. It does not generate configuration for the resource, only the state.

Rationale for Correct Answer: To enforce constraints on an input variable, Terraform provides variable validation using a validation block inside the variable block. If the condition fails, Terraform produces an error and prevents the operation (plan/apply) from continuing with invalid input.

Analysis of Incorrect Options (Distractors):

A (Top-level check block): check blocks validate conditions, but they are not the standard mechanism for constraining input variable values at the point of declaration; variable validation is.

C (Top-level validation block): Terraform does not support a standalone top-level validation block.

D (check block in the variable block): check is not placed inside variable blocks for input validation; the correct construct is validation.

Key Concept: Input variable validation to enforce constraints and fail fast.

These are features of Terraform Cloud, which is a hosted service that provides a web-based UI, remote state storage, remote operations, collaboration features, and more for managing your Terraform infrastructure.

This is not a valid backend for Terraform, as it does not support locking or versioning of state files4. The other options are valid backends that can store state files in a central location.

Rationale for Correct Answer:

C: Securely managed .tfvars files are acceptable if not committed to version control.

D: HCP Terraform provides secure storage for sensitive variables.

E: HashiCorp Vault is designed for secrets management and integrates with Terraform.

Analysis of Incorrect Options (Distractors):

A: Plaintext storage is insecure.

B: Secrets should never be committed to version control.

Key Concept:Sensitive values must be stored using secure secret management solutions.

Detailed Explanation:

Rationale for Correct Answer: A remote backend is the recommended way to share Terraform state across teams. Remote backends provide centralized state storage and often support locking, access control, encryption, and collaboration workflows.

Analysis of Incorrect Options (Distractors):

B. No additional configuration is recommended. Incorrect. Local state is not suitable for team collaboration.

C. Store the terraform.tfstate file in version control. Incorrect. State files can contain secrets and frequently change. Storing them in version control is unsafe and prone to conflicts.

D. Store the terraform.tfstate file in HashiCorp Vault. Incorrect. Vault is designed for secrets management, not as a standard Terraform state backend.

Key Concept: Remote backends enable safe Terraform state sharing and collaboration.

Terraform state files are not automatically encrypted by default. Sensitive values are stored in plaintext within the state file. However, you can protect the state file by using remote backends that support encryption, such as AWS S3 with server-side encryption enabled or Terraform Cloud, which offers encrypted state storage.

This is the command that does not cause Terraform to refresh its state, as it only lists the resources that are currently managed by Terraform in the state file. The other commands will refresh the state file before performing their operations, unless you use the -refresh=false flag.

B (terraform init)–Must be run firstto initialize the Terraform working directory, download providers, and configure the backend.

A (terraform apply)– Requires initialization first, so itcannotbe run before terraform init.

C (terraform plan)– Also requires terraform init first to generate a plan.

D (terraform show)– Displays the state,not relevantfor first-time deployment.

Official Terraform Documentation Reference:

terraform init - HashiCorp Documentation

E (✅Correct)–IaC aims to eliminate manual cloud console workflowsby using code-based automation.

A, B, C (✅Advantages of IaC)– IaC enablesself-service deployment, API-driven workflows, and dynamic resource scaling.

D (diff command)– While useful, troubleshooting via diff is not acore advantageof IaC.

Official Terraform Documentation Reference:

What is Infrastructure as Code?

Detailed Explanation:

Rationale for Correct Answer: A failed Terraform check block assertion does not block the current operation from executing. check blocks are used for non-blocking validation. If an assertion fails, Terraform reports a warning, but it does not stop the plan or apply operation. This is a common exam trap: check blocks differ from variable validation, preconditions, and postconditions, which can block execution when they fail.

Analysis of Incorrect Options (Distractors):

A. True. Incorrect. Terraform does not block execution because of a failed check block assertion.

Key Concept: Terraform check blocks perform non-blocking assertions and report failures as warnings.

The terraform apply command changes both the cloud infrastructure and the state file after you approve the execution plan. The command creates, updates, or destroys the infrastructure resources to match theconfiguration. It also updates the state file to reflect the new state of the infrastructure. The .terraform directory, the execution plan, and the Terraform code are not changed by the terraform apply command. References = Command: apply and Purpose of Terraform State

Detailed Explanation:

Rationale for Correct Answer:

A: terraform plan -out=planfile saves the proposed execution plan so you can later run terraform apply planfile. This supports review and controlled deployments.

B: terraform plan shows what Terraform would change (create/update/destroy) so you can verify changes before applying—this is one of the primary purposes of plan.

Analysis of Incorrect Options (Distractors):

C: Incorrect. Scheduling runs is not a capability of terraform plan (that’s handled by external schedulers/CI systems or HCP Terraform scheduling features—not the CLI plan command itself).

D: Incorrect. Workspaces are selected via terraform workspace select < name > (or by using separate working directories / automation). terraform plan itself doesn’t “execute in a different workspace” without switching context first.

Key Concept:terraform plan for previewing changes and optionally saving an execution plan file for later application.

Rationale for Correct Answer (B):

The file() function reads a file from disk and returns its content as a string. This is commonly used for public keys (.pub files).

Analysis of Incorrect Options:

A. fileset(): Returns a set of filenames matching a pattern, not file contents.

C. filebase64(): Reads file and returns Base64 encoded string — unnecessary for .pub.

D. templatefile(): Used for rendering templates with variables, not raw file contents.

Key Concept:

Terraform’s file() function is used for injecting file content directly.

terraform apply can runwithout explicitly running terraform plan first.

Running terraform plan before apply isrecommendedbutnot mandatory.

If no plan file is provided, terraform applyautomatically creates and executes a planbefore applying changes.

Official Terraform Documentation Reference:

terraform apply - HashiCorp Documentation

Terraform state can contain highly sensitive resource attributes, including passwords, private keys, API tokens, database credentials, and other provider-returned values. Consequently, committing terraform.tfstate to Git or another version-control system risks exposing secrets to repository users and permanently retaining them in repository history. HashiCorp explicitly recommends excluding Terraform state and state backups from version control. State should normally be stored in HCP Terraform or an appropriate remote backend where access controls, encryption, and state-locking capabilities can be applied. Option B is incorrect because the principal risk is infrastructure and secret data rather than personal information about the last operator. Option C is false because Terraform uses the local backend by default. Option D is false because Terraform requires persistent state for subsequent infrastructure management.

================

Detailed Explanation:

Rationale for Correct Answer: Terraform state can contain sensitive values, including passwords, private keys, access tokens, generated secrets, database credentials, and provider-returned sensitive attributes. Even when values are marked sensitive in Terraform output, they may still exist in state.

Analysis of Incorrect Options (Distractors):

B. It stores all environment variables from the machine that created it. Incorrect. Terraform state does not store all local environment variables.

C. It can be manually edited to change deployed resources. Incorrect. Manual state editing can affect Terraform’s understanding of infrastructure, but it does not directly change real deployed resources.

D. It contains personal information about the last user to update it. Incorrect. This is not the primary sensitivity concern for Terraform state.

Key Concept: Terraform state may contain plaintext sensitive infrastructure data and must be protected.

Detailed Explanation:

Rationale for Correct Answer:Terraform requires provider aliases when you configure the same provider multiple times in one configuration. You must define the second AWS provider with an alias, then explicitly tell the resource to use it with the provider meta-argument:

provider " aws " {

region = " us-east-1 "

}

provider " aws " {

alias = " west "

region = " us-west-2 "

}

resource " aws_instance " " example_us_west_2 " {

provider = aws.west

ami = data.aws_ami.ubuntu.id

instance_type = " t3.micro "

}

This is a core Terraform objective: selecting the correct provider configuration for a resource when multiple instances exist.

Analysis of Incorrect Options (Distractors):

B: Incorrect. Provider blocks do not support the syntax provider " aws " " west " { ... }. Aliasing is done with alias = " west " .

C: Incorrect. You cannot invent a new provider type name like aws_west. The provider remains aws; you differentiate configurations via alias.

D: Incorrect. Terraform will not automatically choose between multiple provider configurations for the same provider; you must disambiguate using aliases and provider = ....

Key Concept:Provider aliases and the provider meta-argument for multi-region (or multi-account) deployments.

This is the Terraform style convention for indenting a nesting level compared to the one above it. The other options are not consistent with the Terraform style guide.

Rationale for Correct Answer: A parent/root module can only read values from a child module if the child module exports them via an output block. The error indicates vnet_id is not an exported output from module.my_network. Defining output " vnet_id " { value = ... } inside the networking (child) module makes module.my_network.vnet_id valid.

Analysis of Incorrect Options (Distractors):

A: Incorrect—Terraform does not use module. < name > .outputs. < output > ; module outputs are referenced directly as module. < name > . < output > .

B: Incorrect—variables are inputs to a module, not values exported from it.

C: Incorrect—missing the module. prefix and still uses an invalid .outputs path.

Key Concept: Module outputs are the contract for exposing child module values to the root/parent.

Sentinel policies are checked after the plan stage of a Terraform run, but before it can be confirmed or the terraform apply is executed3. This allows you to enforce rules on your infrastructure before it is created or modified.

Rationale for Correct Answer: depends_on explicitly adds a dependency edge in Terraform’s graph. By adding depends_on = [azurerm_role_assignment.kv_access] to the web app resource, you force Terraform to create the role assignment first, even if Terraform can’t infer the dependency from attribute references.

Analysis of Incorrect Options (Distractors):

B: create_before_destroy is a lifecycle setting relevant to replacement behavior, not initial create ordering between independent resources.

C: File/block order does not control creation order; Terraform uses its dependency graph.

D: count controls quantity, not ordering.

Key Concept: Dependency graph and explicit dependencies via depends_on.

Detailed Explanation:

Rationale for Correct Answer: Terraform uses the .terraform directory as working-directory data and caches downloaded dependencies there, including modules and provider/plugin-related files. HashiCorp ' s tutorial describes .terraform as containing modules and plugins used to provision infrastructure.

Analysis of Incorrect Options (Distractors):

A: .terraform.lock.hcl is stored in the root working directory, not inside .terraform.

C: With the default local backend, terraform.tfstate is normally in the working directory, not the .terraform dependency directory.

D: .tf configuration files belong in the module ' s working directory.

Key Concept: Terraform working-directory structure and initialization artifacts.

Rationale for Correct Answer (B):

IaC best practice is to manage infrastructure through version-controlled code. Changes should be reviewed and approved (via PRs), ensuring collaboration, traceability, and automation.

Analysis of Incorrect Options:

A, D, E: Making direct/manual changes bypasses IaC practices and causes drift.

C: Running code without PR review skips collaboration and approval.

Key Concept:

Infrastructure as Code emphasizes version control + peer review + automation.

Detailed Explanation:

Rationale for Correct Answer:A local value in Terraform allows you to define reusable expressions within a module. By combining the random_id and a variable into a local value, you can reference it multiple times without repeating the expression. This improves readability and maintainability, which aligns with Terraform best practices for configuration design.

Example:

locals {

combined_name = " ${random_id.example.hex}-${var.name} "

}

You can then reuse local.combined_name throughout your configuration.

Analysis of Incorrect Options (Distractors):

A. Use a data source. Incorrect because data sources are used to fetch information from existing infrastructure, not to define reusable expressions.

B. Use a module. Incorrect because modules are used for grouping and reusing infrastructure components, not for simple expression reuse.

D. Add an output value. Incorrect because outputs are used to expose values outside a module, not for internal reuse within the same configuration.

Key Concept:Local values (locals) are used to simplify and reuse expressions within a Terraform configuration.

You cannot reference a resource created with for_each using a splat (*) expression, as it will not work with resources that have non-numeric keys. You need to use a for expression instead to iterate over the resource instances.

Detailed Explanation:

Rationale for Correct Answer:

B: HashiCorp Vault is designed for securely storing and dynamically generating secrets, with access controls and auditing.

D: Using environment variables (including TF_VAR_... for input variables) avoids committing secrets to code and works well in CI/CD.

E: HCP Terraform sensitive variables (workspace variables marked sensitive) are a recommended way to store secrets for runs in HCP Terraform without exposing them in the UI or logs (they are masked).

Analysis of Incorrect Options (Distractors):

A: Incorrect. Plaintext on a shared drive is insecure and lacks access control/auditing best practices.

C: Incorrect. Committing secrets to version control is strongly discouraged; even private repos can leak, and history is hard to scrub.

Key Concept:Secrets management best practices in Terraform workflows: keep secrets out of code and VCS; use Vault, HCP Terraform sensitive vars, or environment variables.

You should run terraform init after you start coding a new Terraform project and before you run terraform plan for the first time. This command will initialize the working directory by downloading the required providers and modules, creating the initial state file, and performing other necessary tasks. References = : Initialize a Terraform Project

The Terraform collection type that should be used to store key/value pairs is map. A map is a collection of values that are accessed by arbitrary labels, called keys. The keys and values can be of any type, but the keys must be unique within a map. For example, var = { key1 = " value1 " , key2 = " value2 " } is a map with two key/value pairs. Maps are useful for grouping related values together, such as configuration options or metadata. References = [Collection Types], [Map Type Constraints]

The public Terraform Module Registry is free to use, as it is a public service that hosts thousands of self-contained packages called modules that are used to provision infrastructure. You can browse, use, and publish modules to the registry without any cost.

Detailed Explanation:

Rationale for Correct Answer: Terraform uses local state by default, but you can later configure another backend and migrate the existing state. Remote state is therefore an architectural choice rather than something that must be configured before the first apply. HashiCorp explicitly documents migration from local state to HCP Terraform.

Analysis of Incorrect Options (Distractors):

A: Changing to a remote backend is not inherently discouraged; remote state is commonly used for collaboration and centralized state management.

B: Terraform does not require you to migrate away from the local backend.

D: Backend migration is supported, so changing the backend is not impossible.

Key Concept: Backend configuration and state migration.

To prevent two Terraform runs from changing the same state file simultaneously, state locking is used. State locking ensures that when one Terraform operation is running, others will be blocked from making changes to the same state, thus preventing conflicts and data corruption. This is achieved by configuring the state backend to support locking, which will lock the state for all operations that could write to the state.References = This information is supported by Terraform ' s official documentation, which explains the importance of state locking and how it can be configured for different backends to prevent concurrent state modifications .

terraform validate does not confirm that your infrastructure matches the Terraform state file. It only checks whether the configuration files in a directory are syntactically valid and internally consistent3. To confirm that your infrastructure matches the Terraform state file, you need to use terraform plan or terraform apply with the -refresh-only option.

Detailed Explanation:

Rationale for Correct Answer: The terraform force-unlock command is used to manually remove a state lock only when Terraform fails to release it automatically. This situation typically occurs due to interruptions (e.g., crashed process, network failure) that leave the state locked. Terraform’s locking mechanism prevents concurrent operations, so force-unlock should be used cautiously and only when you are certain no other process is actively using the state.

Analysis of Incorrect Options (Distractors):

A. When apply has failed due to a state lock. Incorrect because failure alone does not justify force-unlock; the lock may still be valid and held by another process.

B. When you have a high-priority change. Incorrect because urgency does not justify bypassing Terraform’s locking mechanism.

D. When you see a status message stating that you cannot acquire the lock. Incorrect because this usually means another process is currently holding the lock; force-unlock should not be used unless you are sure the lock is stale.

Key Concept: Terraform state locking and safe use of force-unlock to recover from stale locks.

These are some of the ways that a ticket-based system can slow down infrastructure provisioning and limit the ability to scale, as they introduce delays, bottlenecks, and manual interventions in the process of creating and modifying infrastructure.

To make Terraform ' s logging more verbose for troubleshooting purposes, you must configure the TF_LOG environment variable. This variable controls the level of logging and can be set to TRACE, DEBUG, INFO, WARN, or ERROR, with TRACE providing the most verbose output.References = Detailed debugging instructions and the use of environment variables like TF_LOG for increasing verbosity are part of Terraform ' s standard debugging practices

Detailed Explanation:

Rationale for Correct Answer: terraform force-unlock should be used only when Terraform’s normal automatic unlocking has failed and you are sure no other Terraform process is actively using the state. It manually removes a stale lock.

Analysis of Incorrect Options (Distractors):

A. When terraform apply has failed due to a state lock. Incorrect. A lock error alone does not justify force unlocking. Another valid Terraform operation may still be running.

B. When you have a high-priority change. Incorrect. Urgency is not a valid reason to bypass state locking safeguards.

D. When you see a status message stating that Terraform cannot acquire the lock. Incorrect. This may simply mean another run is active. You should investigate before using force-unlock.

Key Concept: Force unlocking is a recovery action for stale locks, not a normal operational shortcut.

You can configure Terraform to log to a file using the TF_LOG environment variable. This variable can be set to one of the log levels: TRACE, DEBUG, INFO, WARN or ERROR. You can also use the TF_LOG_PATH environment variable to specify a custom log file location. References = : Debugging Terraform

Detailed Explanation:

Rationale for Correct Answer: terraform init initializes the working directory. It downloads required providers, installs modules, and configures the backend. You must run it before running terraform plan or terraform apply for the first time in a new configuration directory.

Analysis of Incorrect Options (Distractors):

B. terraform workspace. Incorrect. This command manages Terraform workspaces but does not initialize providers, modules, or backends.

C. terraform validate. Incorrect. Validation is useful, but it is not the required initialization step before planning or applying.

D. terraform import. Incorrect. Import brings existing infrastructure into Terraform state. It is not required before planning or applying a new configuration.

Key Concept: Terraform working directories must be initialized with terraform init.

This is the kind of configuration block that will create an infrastructure object with settings specified within the block. The other options are not used for creating infrastructure objects, but for configuring providers, accessing state data, or querying data sources.

The error messageindicates an authentication issue (403 - Access Denied), which requiresdebugging Terraform logs.

Setting TF_LOG=DEBUG enablesdetailed logs, providing insights into API requests, state loading, and authentication errors.

Terraformdoes not log errors in /var/log/terraform.log or syslog, making optionsC and D incorrect.

A (terraform login)is only relevant forTerraform Cloud, but this error appears to be related toprovider authentication.

Official Terraform Documentation Reference:

Debugging Terraform

terraform validatechecks for syntax errors and internal consistencyin the configuration files.

However, itdoes notcheck if resource configurations are valid with the provider.

Official Terraform Documentation Reference:

terraform validate - HashiCorp Documentation

This is the method for sharing Terraform configurations that fulfills the following criteria:

Keeps the configurations confidential within your organization

Supports Terraform’s semantic version constraints

Provides a browsable directory

The Terraform Cloud private registry is a feature of Terraform Cloud that allows you to host and manage your own modules within your organization, and use them in your Terraform configurations with versioning and access control.

Rationale for Correct Answer (A):

Providers only interact with one specific platform or API. Terraform itself can work with multiple providers in one configuration, but a single provider is not responsible for provisioning across multiple cloud providers.

Analysis of Incorrect Options:

B. Managing actions to take based on resource differences: This is a provider responsibility (through the resource schema).

C. Managing resources and data sources based on an API: Correct — providers define resources/data sources and map them to API calls.

D. Understanding API interactions with a hosted service: Correct — providers encapsulate API logic to allow Terraform to manage resources.

Key Concept:

Providers are API adapters. They handle CRUD operations for resources in their own ecosystem but do not span across multiple cloud platforms.

This is the best way to delete the newly-created VM with Terraform, as it will only affect the resource that was created by your configuration and state file. The other options are either incorrect or inefficient.

Terraform allows usingprivate module sourceshosted in:

C (Internally hosted VCS platforms, e.g., GitLab, Bitbucket, GitHub Enterprise)✅

D (Private GitHub repositories)✅

A (Public GitHub repository)❌–GitHubis supported, but apublic repo is not " private " .

B (Public Terraform Registry)❌–The public registryis not a private source.

Official Terraform Documentation Reference:

Terraform Module Sources

C (✅Correct)– If changes require aresource replacement(e.g., changing an immutable attribute like instance type), Terraform willdestroy and recreate the resource.

E (✅Correct)– Terraform only appliesthe configuration in the current directory or workspace.

In Terraform, the correct way to reference a resource attribute is:

pgsql

CopyEdit

resource_type.resource_name.attribute

For example, if the resource block is:

hcl

CopyEdit

resource " kubernetes_namespace " " example " {

metadata {

name = " my-namespace "

}

}

To reference the name attribute, use:

pgsql

CopyEdit

kubernetes_namespace.example.name

Explanation of incorrect answers:

A (resource.kubernetes_namespace.example.name)– Incorrect. Terraform does not use the resource. prefix when referencing resources.

C (data.kubernetes.namespace.name)– Incorrect. This syntax is used fordata sources, not resources.

D (kubernetes_namespace.test.name)– Incorrect. The resource name is " example " , not " test " .

Official Terraform Documentation Reference:

Terraform Resource References

Detailed Explanation:

Rationale for Correct Answer:Setting version = " 3.1.4 " pins the module to that exact version, preventing Terraform from selecting any newer version. This is the strongest guard against unexpected changes (including potential breaking changes) because it does not allow upgrades unless you explicitly change the version constraint.

Analysis of Incorrect Options (Distractors):

A: Incorrect. This allows any version < 3.2 (including 3.1.5, 3.1.9, etc.). Those may still introduce behavioral changes you want to avoid.

B: Incorrect. This forces Terraform to use 3.1.5 or newer, the opposite of what you want.

D: Incorrect. ~ > 3.1.4 allows patch-level updates (e.g., 3.1.5, 3.1.9) and could still introduce changes your team wants to avoid.

Key Concept:Module version constraints and pinning to avoid unexpected upgrades.

Rationale for Correct Answer:

B: Providers can manage on-premises services (e.g., vSphere, Kubernetes, GitHub, DNS, databases), not just public cloud.

C: Providers provision and manage public cloud resources (AWS, Azure, Google Cloud, etc.).

D: Providers are the plugin layer that interacts with APIs (cloud/service APIs) to create, read, update, and delete resources.

Analysis of Incorrect Options (Distractors):

A: This describes how Terraform configuration and state are organized (root module/workspace/state), not a provider function.

E: Policy enforcement is handled by separate policy-as-code systems (e.g., Sentinel/OPA integrations) rather than being a core provider responsibility.

Key Concept: Providers as plugins that implement resource/data source types and perform API interactions for many platforms.

The terraform fmt command is used to format Terraform configuration files to a canonical format and style. This ensures that all team members are using a consistent style, making the code easier to read and maintain. It automatically applies Terraform ' s standard formatting conventions to your configuration files, helping maintain consistency across the team ' s codebase.

This is the recommended way to use a remote backend that needs authentication, as it allows you to provide the credentials via environment variables, command-line arguments, or interactive prompts, without storing them in the Terraform configuration files.

Rationale for Correct Answers:

B. View the execution plan: Correct — terraform plan shows what Terraform intends to do (create, update, or destroy).

C. Save a generated execution plan: Correct — using terraform plan -out=planfile lets you save the plan to apply later with terraform apply planfile.

Analysis of Incorrect Options:

A. Schedule runs in the future: Incorrect, Terraform does not provide scheduling; external tools (like cron, CI/CD) are required.

D. Execute a plan in a different workspace: Incorrect, execution happens in the current workspace; switching workspaces must be done before running the plan.

Key Concept:

terraform plan is used for previewing and optionally saving an execution plan for controlled and predictable infrastructure changes.

Rationale for Correct Answer:When multiple provider configurations are defined using an alias, Terraform requires the provider meta-argument inside the resource block to explicitly reference the aliased provider.In this case, the provider is defined as aws with alias = " west " , so resources targeting us-west-2 must specify:

provider = aws.west

This tells Terraform exactly which provider configuration to use.

Analysis of Incorrect Options (Distractors):

B. alias = aws.west: Incorrect — alias is only used inside the provider block, not in resources.

C. provider = west: Incorrect — Terraform requires the full provider name (aws.west), not just the alias.

D. alias = west: Incorrect — resources do not support an alias meta-argument.

Key Concept:Using aliased provider configurations and the provider meta-argument to deploy resources across multiple regions or accounts.

Destroy Command Options: Theterraform destroycommand is the correct method to destroy resources, and it requires either manual approval or the -auto-approve flag.

Unsupported Triggering Method: The--destroy flagis not a recognized option for plan or apply commands, making B the correct answer as it isnota valid way to initiate resource destruction.

For more on destroying resources, refer to theterraform destroy command documentationin the Terraform CLI reference.

In Terraform, the max function can be used to select the largest number from a list of numbers. The max function takes multiple arguments and returns the highest one. For the list numcpus = [18, 3, 7, 11, 2], using max(numcpus...) will return 18, which is the largest number in the list.

The Terraform Registry allows any user to publish and share modules. Published modules support versioning, automatically generate documentation, allow browsing version histories, show examples and READMEs, and more. Public modules are managed via Git and GitHub, and publishing a module takes only a few minutes. Once a module is published, releasing a new version of a module is as simple as pushing a properly formed Git tag1.

References = The information can be verified from the Terraform Registry documentation on Publishing Modules provided by HashiCorp Developer1.

Rationale for Correct Answer (D):

The terraform.lock.hcl file is automatically created and maintained by Terraform. It records the specific versions and checksums of providers used in a configuration, ensuring consistent runs across environments and machines.

Analysis of Incorrect Options:

A. There is no such file: Incorrect — the lock file exists and is crucial for dependency management.

B. Storing references to workspaces: Incorrect — workspaces are tracked in the state file, not the lock file.

C. Preventing Terraform runs: Incorrect — the lock file does not block runs; it enforces consistent provider versions.

Key Concept:

The terraform.lock.hcl file enforces provider version consistency, which is critical for reproducible and reliable Terraform deployments.

The correct answer is A because Terraform logging is controlled primarily by environment variables. TF_LOG_PATH only tells Terraform where to write the log file; it does not enable logging or choose the log verbosity. To generate detailed logs, you must set TF_LOG. The TRACE level is the most verbose logging level and includes very detailed operational information, including debug-level messages and provider/plugin communication details. Common TF_LOG values include TRACE, DEBUG, INFO, WARN, and ERROR. There is no valid log argument inside the terraform block for enabling runtime logs. Updating the Terraform CLI configuration file is not the documented way to enable standard Terraform logging. The terraform output command only displays output values from state and is unrelated to diagnostic logging.

Detailed Explanation:Rationale for Correct Answer:When using multiple configurations of the same provider (e.g., AWS in different regions), Terraform requires the use of an aliasto distinguishalias argument:provider " aws " { alias = " west " region = " us-west-2 " }This allows resources to explicitly reference the aliased provider using:provider = aws.westThis is the standard Terraform pattern for multi-region or multi-account deployments.Analysis of Incorrect Options (Distractors):

Answer: Resource block only — Incorrect because it does not define how to use a different region; it relies on provider configuration.

Answer: provider " aws " " west " — Incorrect syntax; Terraform does not support naming providers this way. The correct method is using the alias argument.

Answer: provider " aws_west " — Incorrect because provider names must match actual providers (e.g., aws). You cannot invent a new provider name. Key Concept:Provider aliasing enables multiple configurations of the same provider (e.g., multiple AWS regions).

In Terraform Cloud, you can switch between workspaces using both the web UI and CLI. The statement that you " must use the CLI " is false. Workspaces can securely store cloud credentials, offer role-based access control, and integrate with VCS to trigger plan and apply operations.

Detailed Explanation:

Rationale for Correct Answer: The Terraform Registry provides module documentation, including required inputs, optional inputs with default values, outputs, dependencies, resources, and usage examples.

Analysis of Incorrect Options (Distractors):

A. Required input variables. Correct but incomplete.

B. Outputs. Correct but incomplete.

C. Optional input variables and default values. Correct but incomplete.

Key Concept: Terraform Registry module documentation exposes inputs, outputs, versions, and usage details.

The terraform plan command does not update the state file. Instead, it reads the current state and the configuration files to determine what changes would be made to bring the real-world infrastructure into the desired state defined in the configuration. The plan operation is a read-only operation and does not modify the state or the infrastructure. It is the terraform apply command that actually applies changes and updates the state file.References = Terraform ' s official guidelines and documentation clarify the purpose of the terraform plan command, highlighting its role in preparing and showing an execution plan without making any changes to the actual state or infrastructure .

The public Terraform Module Registry automatically exposes all the information about published modules, including required input variables, optional input variables and default values, and outputs. This helps users to understand how to use and configure the modules.

Detailed Explanation:

Rationale for Correct Answer: To configure Terraform to use HCP Terraform for remote state storage and workspace-based runs, you add a cloud block inside the terraform block. The cloud block specifies the HCP Terraform organization and workspace configuration.

Analysis of Incorrect Options (Distractors):

B. Add a backend block inside the terraform block. This is valid for configuring other remote backends, such as S3, AzureRM, or GCS. However, for HCP Terraform workspaces, the modern and recommended configuration is the cloud block.

C. Set the TERAFORM_CLOUD environment variable. Incorrect. This environment variable is misspelled and is not how Terraform configures remote state.

D. Set the TERRAFORM_BACKEND environment variable. Incorrect. Terraform does not use this environment variable to configure a backend.

Key Concept: HCP Terraform remote state and workspace integration are configured using the cloud block.

The required_providers block is used to specify the provider versions that the configuration can work with. The version argument accepts a version constraint string, which must be enclosed in double quotes. The version constraint string can use operators such as  > =, ~ > , =, etc. to specify the minimum, maximum, or exact version of the provider. For example, version = " > = 3.1 "  means that theconfiguration can work with any provider version that is 3.1 or higher. References = [Provider Requirements] and [Version Constraints]

Detailed Explanation:

Rationale for Correct Answer: Terraform logging is enabled by setting the TF_LOG environment variable. Common values include TRACE, DEBUG, INFO, WARN, and ERROR. For example: export TF_LOG=DEBUG.

Analysis of Incorrect Options (Distractors):

A. Set the log level command-line flag. Incorrect. Terraform does not use a general CLI flag for verbose log level control.

C. Set the log level in your terraform block. Incorrect. Logging is not configured in the Terraform configuration block.

Key Concept: Terraform troubleshooting logs are controlled through environment variables.

Rationale for Correct Answer: terraform output shows the root module’s outputs (the outputs defined in the current working directory’s root module). Outputs from child modules are not directly listed unless the root module re-exports them via its own output blocks (e.g., output " child_public_ip " { value = module.child.public_ip }).

Analysis of Incorrect Options (Distractors):

A (True): Incorrect because child module outputs are accessible via module. < name > . < output > , but terraform output displays only outputs defined in the root module.

Key Concept: Module outputs scope: child outputs must be exposed through root outputs to be shown by terraform output.

The key principle of infrastructure as code that is not listed among the options is golden images. Golden images are pre-configured, ready-to-use virtual machine images that contain a specific set of software and configuration. They are often used to create multiple identical instances of the same environment, such as for testing or production. However, golden images are not a principle of infrastructure as code, but rather a technique that can be used with or without infrastructure as code. The other options are all key principles of infrastructure as code, as explained below:

Self-describing infrastructure: This means that the infrastructure is defined in code that describes its desired state, rather than in scripts that describe the steps to create it. This makes the infrastructure easier to understand, maintain, and reproduce.

Idempotence: This means that applying the same infrastructure code multiple times will always result in the same state, regardless of the initial state. This makes the infrastructure consistent and predictable, and avoids errors or conflicts caused by repeated actions.

Versioned infrastructure: This means that the infrastructure code is stored in a version control system, such as Git, that tracks the changes and history of the code. This makes the infrastructure code reusable, auditable, and collaborative, and enables practices such as branching, merging, and rollback. References = [Introduction to Infrastructure as Code with Terraform], [Infrastructure as Code in a Private or Public Cloud]

Rationale for Correct Answer: With immutable infrastructure, you don’t modify running servers/resources in place; you replace them with new versions built from a known image/artifact. This reduces configuration drift and “snowflake” issues, making deployments and rollbacks more predictable—often resulting in less operational complexity compared with troubleshooting in-place changes.

Analysis of Incorrect Options (Distractors):

A: Incorrect—immutable infrastructure specifically avoids in-place upgrades.

B: Not the best answer—upgrades can be fast in some setups, but “quicker” is not guaranteed; replacing infrastructure may take time depending on provisioning and rollout strategy.

C: Incorrect—immutability doesn’t inherently mean upgrades are “automatic”; automation is a separate practice/tooling choice.

Key Concept: Immutable vs mutable infrastructure; replace instead of modify to reduce drift and simplify operations.

Detailed Explanation:

Rationale for Correct Answer: In Terraform, data sources are referenced using the format:data. < DATA_SOURCE_TYPE > . < NAME > . < ATTRIBUTE >

In this case:

Data source type = aws_ami

Name = web

Attribute = id

Therefore, the correct reference is:

data.aws_ami.web.id

This follows Terraform syntax for accessing attributes from data sources, which is a key concept in configuration authoring.

Analysis of Incorrect Options (Distractors):

B. aws_ami.web.id Incorrect because this format is used for resources, not data sources.

C. web.id Incorrect because it omits both the data prefix and the resource type.

D. data.web.id Incorrect because it is missing the data source type (aws_ami).

Key Concept: Proper referencing of data sources using data. < type > . < name > . < attribute > syntax.