# HashiCorp Configuration Language

The syntax used for declaring Terraform configurations is called HashiCorp Configuration Language (HCL). Terraform uses configuration files written in HCL that are named with `.tf` extension.

## HashiCorp Configuration Language Syntax

```
resource "aws_instance" "syntx_example" {
    ami = "abc123"

    network_interface {
        # ...
    }
}
```

* Single line comments start with `#`.
* Multiline comments are wrappend with `/*` and `*/`.
* Values are assigned with the syntac of `key = value`.
* Strings are in double quotes.
* Strings can interpolate other values using syntax wrapped in `${}`, for example `${var.foo}`.
* Numbers are assumed to be base 10.
* `true` and `false` respresents boolean value.
* List of primitives can be create by using `[ ]`, for example `["foo", "bar", "baz"]`.
* Maps can be made with `{ }`, for exampe `{ "foo": "bar", "bar": "baz" }`.

Also, when it comes to common coding styles with HCL, it prefers indenting with two spaces for each nesting level and aligning multiple arguments with their equal sign.

### Example

In this example I'm trying to deploy a Docker container.

Setup the environment:

```
> mkdir terraform-basics
> cd terraform-basics
```

Next let's create the Terraform program with `main.tf` file,

`main.tf`

```
# Download the latest Ghost image
resource "docker_image" "image_id" {
  name = "ghost:latest"
}

# Start the Container
resource "docker_container" "container_id" {
  name  = "ghost_blog"
  image = "${docker_image.image_id.latest}"
  ports {
    internal = "2368"
    external = "80"
  }
}
```

Validate `main.tf`,

```
> terraform validate
```

Terraform plan,

```
> terraform plan
```

Apply the changes,

```
> terraform apply
```

List the Docker containers,

```
docker container ls
```

Reset the environment,

```
> terraform destroy
```

### Example

This example provides a couple of simple examples of different use cases with variables.

Create a faile called `main.tf`.

```
variable "myvar" {
  type    = string
  default = "hello terraform"
}

variable "mymap" {
  type = map(string)
  default = {
    mykey = "my value"
  }
}

variable "mylist" {
  type    = list(any)
  default = [1, 2, 3]
}
```

In here, we first define a variable named `myvar` of type `string` and it's default value is `hello terraform`. Next it we declare a variable of type `map` with the name `mymap`. In maps we can specify the type of value it is going to keep like this `map(TYPE)`. In a similar approach, we can specify lists. Next, we have declared a variable of type `list` with name `myname` and it's default value is `1, 2, 3`, an array of integers.

These can be verified by invoking the Terraform console,

```
> terraform console
```

Check the value of `myvar`,

```
$ var.myvar
"hello terraform"

$ "${var.myvar}"
"hello terraform"
```

Check the value of `mymap`,

```
$ var.mymap
tomap({
  "mykey" = "my value"
})

$ var.mymap["mykey"]
"my value"
```

Check the value of `mylist`,

```
$ var.mylist
tolist([
  1,
  2,
  3,
])

$ var.mylist[0]
1

$ element(var.mylist, 1)
1

$ slice(var.mylist, 0, 2)
[
  1,
  2,
]
```

Create a file called `resources.tf`,

```
provider "aws" {
  ...
}

variable "AWS_REGION" {
  type    = string
  default = "eu-west-1"
}

variable "AMIS" {
  type = map(string)
  default = {
    eu-west-1 = "my ami"
  }
}

resource "aws_instance" "example" {
  ami           = var.AMIS[var.AWS.REGION]
  instance_type = "t2.micro"
}
```

This file uses the AWS Terraform module. First it declares a variable to specify the AWS region with the default value `eu-west-1`. Then it spefies an AMIS resource, and finally an EC2 instance. It is important to notice here that machine image (ami) is specifed by refering to the AMIS and AWS REGION variables that we declared.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://isurus.gitbook.io/infrastructure-and-platform-notes/terraform-20/terraform-basics/02-hashicorp-configuration-language.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.