It's time to write real Terraform. The language is called HCL (HashiCorp Configuration Language) and is organized into blocks. In this subsection, you'll learn about the four most important blocks you'll use constantly: resource, variable, output, and locals. With these, you can already describe real infrastructure.

Terraform code is written in files with the .tf extension. Everything in HCL is structured in blocks, which have this general form:

Don't worry about the exact syntax now; you'll see it with examples. The important thing: HCL is readable, similar to filling out a form with data. Let's go over the four key blocks.

The resource block is the most important of all. It describes an infrastructure resource you want to exist: a server, a network, a bucket...

Let's break it down:

• resource → the block type.
• "aws_instance" → the resource type (an AWS EC2 instance). The aws_ prefix indicates it's from AWS.
• "my_server" → the name YOU give it to refer to it within your code (it's not the name in AWS, it's an internal label).
• Inside { } → the arguments that configure the resource (which AMI to use, what instance type... remember Chapter 4?).

Analogy: A resource block is like filling out the order form for a resource: "I want an instance, of type t3.micro, with this image." Terraform reads the form and creates it for you.

Every AWS resource you saw in Part II (EC2, S3, VPC...) has its own resource type in Terraform: aws_instance, aws_s3_bucket, aws_vpc, etc.

The variable block defines configurable values that you can change without touching the rest of the code. They're like the "parameters" of your configuration.

Then you use that variable in your resources with the var.name syntax:

Why they're useful: Variables make your code reusable and flexible. For example, you can use t3.micro in testing and m5.large in production by changing only the variable's value, without touching the server definition. We'll see more in Chapter 19 (environments).

Analogy: Variables are like the configurable settings of an appliance. The washing machine is the same, but you adjust the temperature and program according to the laundry. Your code is the same, but you adjust the variables according to the environment.

The output block displays useful information after applying your configuration. It's used to "output" data you need to know, like a server's IP or a website's URL.

When you run terraform apply, at the end you'll see:

Why they're useful: After creating infrastructure, you need to know things like "what's my server's IP?" or "what's my database address?" Outputs show them to you automatically, without having to look them up in the AWS console. They're also used to pass information between modules (Chapter 18).

Analogy: Outputs are like the receipt or summary you get at the end: "here are the important details of what you just created."

The locals block defines internal reusable values within your code. Unlike variables (which come from outside), locals are values you define and calculate inside your configuration.

And you use them with local.name:

When to use them: to avoid repeating values or calculations. If you use the same name or combination of values in many places, define it once in locals and reuse it. If it changes, you change it in just one place.

Variable vs Local — the key difference:

• variable: comes from outside (set by whoever uses the code). "Input parameter."
• local: is defined and calculated inside the code. "Reusable internal value."

This code: takes an environment as a variable, calculates a name with a local, creates a server tagged with that name, and shows its IP as an output. You're already reading Terraform!

• HCL is organized in blocks, written in .tf files.
• resource: the most important block; describes the infrastructure you want to create (servers, networks, buckets...).
• variable: configurable values that come from outside; used with var.name. Make the code reusable.
• output: shows useful information after apply (IPs, URLs...); used with the resource reference.
• locals: reusable internal values you define inside the code; used with local.name.
• Key difference: variable = comes from outside; local = calculated inside.

In the next subsection, we'll look at HCL's data types (string, number, list, map, object...) to shape your variables and values.