Local-exec provisioner in Terraform - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ service_behavior

intermediate

What is the output of this Terraform local-exec provisioner?

Given the following Terraform resource with a local-exec provisioner, what will be printed to the console when the resource is created?

Terraform

resource "null_resource" "example" {
  provisioner "local-exec" {
    command = "echo Hello from Terraform"
  }
}

A Terraform apply fails with syntax error

B Error: command not found

C Hello from Terraform

D No output is printed

💡 Hint

The local-exec provisioner runs commands on the machine where Terraform runs.

The local-exec provisioner runs the specified command locally and prints its output to the console during resource creation.

❓ Configuration

intermediate

Which option correctly runs a shell script using local-exec provisioner?

You want to run a shell script named 'setup.sh' located in the same directory as your Terraform configuration using a local-exec provisioner. Which option correctly specifies the command?

A command = "./setup.sh"

B command = "run setup.sh"

C command = "sh ./setup.sh"

D command = "bash setup.sh"

💡 Hint

Consider how to explicitly run a script with bash.

Using 'bash setup.sh' explicitly runs the script with bash, ensuring compatibility. './setup.sh' requires executable permission and correct shebang. 'sh ./setup.sh' may work but is less explicit. 'run setup.sh' is invalid.

❓ Architecture

advanced

What is a key limitation of using local-exec provisioner in Terraform for cloud resource setup?

Which of the following best describes a limitation when using local-exec provisioner to configure cloud resources?

A It requires the command to be run on the machine where Terraform is executed

B It runs commands on the remote cloud resource directly

C It automatically retries failed commands until success

D It can only run commands written in Python

💡 Hint

Think about where local-exec commands actually run.

Local-exec provisioner runs commands locally on the machine running Terraform, not on remote cloud resources. This can limit its use for configuring remote machines directly.

❓ security

advanced

What is a security risk when using local-exec provisioner with sensitive data?

You use local-exec provisioner to run a command that includes sensitive credentials as part of the command string. What is the main security risk?

A Credentials may be exposed in Terraform logs or process list

B Terraform automatically encrypts all command strings

C Local-exec provisioner prevents any data leakage

D Credentials are stored securely in the cloud provider

💡 Hint

Consider where command strings might be visible during execution.

Commands run by local-exec may appear in logs or system process lists, exposing sensitive data if included directly in the command string.

✅ Best Practice

expert

Which approach best follows Terraform best practices when using local-exec provisioner?

You need to run a local script after creating a resource. Which practice aligns best with Terraform's recommended usage of local-exec provisioner?

A Use local-exec provisioner to run all configuration and deployment scripts regardless of complexity

B Use local-exec provisioner only for simple, non-critical commands and avoid complex scripts

C Avoid local-exec provisioner and run all commands manually outside Terraform

D Embed sensitive credentials directly in local-exec commands for convenience

💡 Hint

Think about maintainability and idempotency in Terraform.

Terraform recommends using local-exec provisioner sparingly for simple tasks. Complex or critical configuration is better handled by dedicated configuration management tools or remote-exec provisioner.

Practice

1. What does the local-exec provisioner do in Terraform?

easy

A. Runs commands inside the cloud resource

B. Executes Terraform plan without applying changes

C. Creates a local copy of the Terraform state file

D. Runs commands on your local machine after resource creation

Solution

1. Step 1: Understand provisioner types

   Terraform provisioners run scripts or commands either locally or remotely after resource creation.

2. Step 2: Identify local-exec purpose

   The local-exec provisioner specifically runs commands on your local machine, not inside the cloud resource.

3. Final Answer:

   Runs commands on your local machine after resource creation -> Option D

4. Quick Check:

   local-exec runs commands locally [OK]

Hint: Local-exec runs commands on your own computer [OK]

Common Mistakes:

• Confusing local-exec with remote-exec
• Thinking it runs inside the cloud resource
• Assuming it manages Terraform state files

2. Which of the following is the correct syntax to use a local-exec provisioner in a Terraform resource?

easy

A. provisioner "local-exec" { command = "echo Hello" }

B. provisioner local-exec { run = "echo Hello" }

C. local_exec { command = "echo Hello" }

D. provisioner "local_exec" { execute = "echo Hello" }

Solution

1. Step 1: Recall Terraform provisioner syntax

   Provisioners use the keyword provisioner followed by the provisioner type in quotes.

2. Step 2: Check correct attribute names

   The local-exec provisioner uses command to specify the shell command to run.

3. Final Answer:

   provisioner "local-exec" { command = "echo Hello" } -> Option A

4. Quick Check:

   Correct syntax uses provisioner "local-exec" and command [OK]

Hint: Use quotes and 'command' attribute for local-exec [OK]

Common Mistakes:

• Omitting quotes around local-exec
• Using wrong attribute names like run or execute
• Using underscore instead of dash in local-exec

3. Given this Terraform snippet, what will happen when the resource is created?

resource "null_resource" "example" {
  provisioner "local-exec" {
    command = "echo Resource created"
  }
}

medium

A. Terraform will fail because null_resource cannot have provisioners

B. Terraform will print 'Resource created' inside the cloud resource

C. Terraform will print 'Resource created' on your local machine

D. Terraform will ignore the provisioner and create the resource silently

Solution

1. Step 1: Understand null_resource and local-exec

   The null_resource is a Terraform resource that supports provisioners for running commands.

2. Step 2: Analyze the command execution

   The local-exec provisioner runs the command on your local machine, so it will print the message locally.

3. Final Answer:

   Terraform will print 'Resource created' on your local machine -> Option C

4. Quick Check:

   local-exec runs commands locally, so output appears locally [OK]

Hint: local-exec runs commands locally, not remotely [OK]

Common Mistakes:

• Thinking output appears inside cloud resource
• Believing null_resource disallows provisioners
• Assuming provisioners are ignored silently

4. You wrote this Terraform code but get an error when applying:

resource "null_resource" "fail_example" {
  provisioner "local-exec" {
    command = echo "Hello"
  }
}

What is the cause of the error?

medium

A. Missing quotes around the command string

B. local-exec provisioner cannot be used with null_resource

C. The command attribute should be named run

D. Terraform does not support echo commands

Solution

1. Step 1: Check command syntax

   The command value must be a string enclosed in quotes in Terraform configuration.

2. Step 2: Identify missing quotes

   Here, command = echo "Hello" lacks quotes around the entire command string, causing a syntax error.

3. Final Answer:

   Missing quotes around the command string -> Option A

4. Quick Check:

   Command must be a quoted string [OK]

Hint: Always quote command strings in local-exec [OK]

Common Mistakes:

• Forgetting quotes around command
• Using wrong attribute names
• Assuming null_resource disallows provisioners

5. You want to run a local script setup.sh after creating an AWS EC2 instance using Terraform. Which is the best way to use local-exec provisioner to achieve this safely?

hard

A. Run setup.sh manually after Terraform apply

B. Use remote-exec provisioner to run setup.sh on the EC2 instance

C. Use local-exec with command = "./setup.sh" inside the EC2 resource without dependencies

D. Use local-exec with command = "./setup.sh" inside the EC2 resource and add depends_on for the instance

Solution

1. Step 1: Understand local-exec vs remote-exec

   The local-exec provisioner runs commands on your local machine, which is not suitable for running scripts on the EC2 instance itself.

2. Step 2: Use remote-exec for remote commands

   To run a script on the EC2 instance, use the remote-exec provisioner which executes commands on the remote resource.

3. Final Answer:

   Use remote-exec provisioner to run setup.sh on the EC2 instance -> Option B

4. Quick Check:

   remote-exec runs commands on the remote resource [OK]

Hint: Use remote-exec to run scripts on remote instances [OK]

Common Mistakes:

• Using remote-exec for a local script
• Running scripts manually instead of automating
• Adding unnecessary depends_on inside the resource