Resource block syntax in Terraform - Step-by-Step Execution

Process Flow - Resource block syntax

Start Terraform config

↓

Define resource block

↓

Specify resource type and name

↓

Add resource arguments

↓

Terraform reads and validates

↓

Resource created or updated

Terraform reads the resource block, identifies the resource type and name, applies the arguments, then creates or updates the resource.

Execution Sample

Terraform

resource "aws_instance" "example" {
  ami           = "ami-12345678"
  instance_type = "t2.micro"
}

Defines an AWS EC2 instance resource with a specific AMI and instance type.

Process Table

Step	Action	Resource Type	Resource Name	Arguments Parsed	Result
1	Start parsing resource block				Begin reading resource block
2	Identify resource type	aws_instance			Resource type set to aws_instance
3	Identify resource name	aws_instance	example		Resource name set to example
4	Parse argument ami	aws_instance	example	ami = "ami-12345678"	AMI argument stored
5	Parse argument instance_type	aws_instance	example	instance_type = "t2.micro"	Instance type argument stored
6	Validate resource block	aws_instance	example	ami and instance_type present	Validation successful
7	Apply resource	aws_instance	example	ami and instance_type	Resource created or updated
8	End parsing				Resource block processed successfully

💡 Resource block fully parsed and resource created or updated by Terraform

Status Tracker

Variable	Start	After Step 4	After Step 5	Final
resource_type		aws_instance	aws_instance	aws_instance
resource_name		example	example	example
ami		ami-12345678	ami-12345678	ami-12345678
instance_type			t2.micro	t2.micro

Key Moments - 2 Insights

Why do we need both resource type and resource name?

The resource type tells Terraform what kind of resource to create (like EC2 instance), and the resource name is a unique label to reference this resource in the configuration. See execution_table steps 2 and 3.

What happens if required arguments are missing?

Terraform will fail validation at step 6 in the execution_table because it checks if all required arguments like 'ami' and 'instance_type' are present.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the resource name identified?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Check the 'Resource Name' column in execution_table rows

At which step does Terraform validate the resource block arguments?

A Step 4

B Step 6

C Step 5

D Step 7

💡 Hint

Look for the row mentioning 'Validation successful' in the Result column

If the 'instance_type' argument was missing, what would change in the execution_table?

A Step 5 would be skipped and validation at step 6 would fail

B Step 4 would fail parsing

C Resource creation at step 7 would succeed anyway

D Resource name would not be identified

💡 Hint

Refer to key_moments about missing required arguments and validation step

Concept Snapshot

Terraform resource block syntax:
resource "resource_type" "resource_name" {
  argument1 = value1
  argument2 = value2
}
- resource_type: type of cloud resource
- resource_name: unique label
- arguments: configure resource details
Terraform reads, validates, then creates or updates the resource.

Full Transcript

This visual execution traces how Terraform processes a resource block. It starts reading the block, identifies the resource type and name, parses each argument, validates the presence of required arguments, and finally creates or updates the resource. Variables like resource_type, resource_name, ami, and instance_type are tracked as they get assigned values. Key moments include understanding why both resource type and name are needed and what happens if required arguments are missing. The quizzes test knowledge of the parsing steps and validation process.

Practice

1. What is the correct way to start a resource block in Terraform?

easy

A. resource "aws_instance" { example }

B. resource aws_instance example { }

C. resource "example" "aws_instance" { }

D. resource "aws_instance" "example" { }

Solution

1. Step 1: Understand resource block syntax

   A resource block starts with the keyword resource, followed by the resource type in quotes, then the resource name in quotes.

2. Step 2: Match the correct syntax

   resource "aws_instance" "example" { } correctly uses resource "aws_instance" "example" { }, which matches the required syntax.

3. Final Answer:

   resource "aws_instance" "example" { } -> Option D

4. Quick Check:

   Resource block syntax = resource "type" "name" { } [OK]

Hint: Resource block always uses resource "type" "name" [OK]

Common Mistakes:

• Omitting quotes around type or name
• Swapping type and name order
• Using braces incorrectly

2. Which of the following is a valid property assignment inside a Terraform resource block?

easy

A. instance_type = t2.micro

B. instance_type => "t2.micro"

C. instance_type = "t2.micro"

D. instance_type: "t2.micro"

Solution

1. Step 1: Identify correct property syntax

   Terraform uses = to assign values, and string values must be in quotes.

2. Step 2: Check each option

   instance_type = "t2.micro" uses instance_type = "t2.micro", which is correct. instance_type = t2.micro misses quotes, B and C use invalid assignment symbols.

3. Final Answer:

   instance_type = "t2.micro" -> Option C

4. Quick Check:

   Property assignment uses = and quotes for strings [OK]

Hint: Use = and quotes for string values inside resource blocks [OK]

Common Mistakes:

• Forgetting quotes around string values
• Using colon or arrow instead of =
• Missing equal sign

3. Given this resource block snippet, what will Terraform create?

resource "aws_s3_bucket" "mybucket" {
  bucket = "my-unique-bucket-123"
  acl    = "private"
}

medium

A. An S3 bucket named "mybucket" with public access

B. An S3 bucket named "my-unique-bucket-123" with private access

C. An S3 bucket named "aws_s3_bucket" with private access

D. A storage container with default public access

Solution

1. Step 1: Identify resource type and name

   The resource type is aws_s3_bucket, and the resource name is mybucket. The bucket property sets the actual bucket name.

2. Step 2: Understand properties

   The bucket property sets the bucket's real name to "my-unique-bucket-123". The acl is set to "private", meaning no public access.

3. Final Answer:

   An S3 bucket named "my-unique-bucket-123" with private access -> Option B

4. Quick Check:

   Bucket name = property value, ACL = private [OK]

Hint: Bucket name is from bucket property, not resource name [OK]

Common Mistakes:

• Confusing resource name with actual bucket name
• Assuming default ACL is public
• Ignoring property values inside the block

4. Identify the error in this Terraform resource block:

resource "aws_instance" "web" {
  ami = "ami-123456"
  instance_type = t2.micro
}

medium

A. Missing quotes around the instance_type value

B. Resource block missing closing brace

C. Incorrect resource type name

D. Missing resource name

Solution

1. Step 1: Check property value syntax

   The instance_type property value t2.micro is missing quotes, which is required for string values.

2. Step 2: Verify block structure

   The resource block has correct braces and resource type/name, so no errors there.

3. Final Answer:

   Missing quotes around the instance_type value -> Option A

4. Quick Check:

   String values must be quoted [OK]

Hint: Always quote string values inside resource blocks [OK]

Common Mistakes:

• Forgetting quotes around string properties
• Assuming braces are optional
• Mixing resource type and name order

5. You want to create two AWS EC2 instances with different names but the same AMI and instance type using resource blocks. Which is the best way to write this in Terraform?

hard

A. resource "aws_instance" "web1" {
ami = "ami-abc123"
instance_type = "t2.micro"
}
resource "aws_instance" "web2" {
ami = "ami-abc123"
instance_type = "t2.micro"
}

B. resource "aws_instance" "web" {
count = 2
ami = "ami-abc123"
instance_type = "t2.micro"
}

C. resource "aws_instance" "web" {
ami = "ami-abc123"
instance_type = "t2.micro"
name = ["web1", "web2"]
}

D. resource "aws_instance" "web" {
ami = "ami-abc123"
instance_type = "t2.micro"
for_each = ["web1", "web2"]
}

Solution

1. Step 1: Understand resource naming and duplication

   Each resource block must have a unique name.

   resource "aws_instance" "web1" {
     ami = "ami-abc123"
     instance_type = "t2.micro"
   }
   resource "aws_instance" "web2" {
     ami = "ami-abc123"
     instance_type = "t2.micro"
   }

   defines two separate resources with different names.

2. Step 2: Evaluate other options

   resource "aws_instance" "web" {
     count = 2
     ami = "ami-abc123"
     instance_type = "t2.micro"
   }

   uses count but does not differentiate names.

   resource "aws_instance" "web" {
     ami = "ami-abc123"
     instance_type = "t2.micro"
     name = ["web1", "web2"]
   }

   tries to assign a list to name property, which is invalid.

   resource "aws_instance" "web" {
     ami = "ami-abc123"
     instance_type = "t2.micro"
     for_each = ["web1", "web2"]
   }

   uses for_each incorrectly without mapping names.

3. Final Answer:

   Define two separate resource blocks with unique names -> Option A

4. Quick Check:

   Unique resource names needed for multiple instances [OK]

Hint: Use separate resource blocks with unique names for multiple instances [OK]

Common Mistakes:

• Using count without unique names
• Assigning list to single property
• Misusing for_each without proper keys