In this section, we will cover the fundamental concepts of Terraform, including its core components and how they interact. By the end of this module, you should have a solid understanding of the basic building blocks of Terraform and be ready to create your first configuration.

• Definition: Infrastructure as Code (IaC) is the practice of managing and provisioning computing infrastructure through machine-readable configuration files, rather than through physical hardware configuration or interactive configuration tools.
• Benefits:
  • Consistency: Ensures that the same configuration is applied every time.
  • Version Control: Configuration files can be versioned and tracked.
  • Automation: Infrastructure can be automatically provisioned and managed.

• File Extension: Terraform configuration files use the .tf extension.
• Structure: These files are written in HashiCorp Configuration Language (HCL) and define the desired state of your infrastructure.

• Definition: Providers are responsible for understanding API interactions and exposing resources.
• Examples: AWS, Azure, Google Cloud, Kubernetes.
• Configuration: Providers need to be configured in your Terraform files to interact with the respective cloud services.

• Definition: Resources are the most important element in the Terraform language. Each resource block describes one or more infrastructure objects, such as virtual networks, compute instances, or higher-level components such as DNS records.
• Example:

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

• Definition: Variables allow you to parameterize your Terraform configurations.
• Types: String, Number, Boolean, List, Map.
• Example:

  variable "instance_type" {
    description = "Type of instance to create"
    type        = string
    default     = "t2.micro"
  }
  

• Definition: Outputs are used to display information after a Terraform run.
• Example:

  output "instance_id" {
    value = aws_instance.example.id
  }
  

Let's create a simple Terraform configuration to launch an AWS EC2 instance.

1. Create a Directory: Create a new directory for your Terraform configuration files.

   mkdir terraform-basics
   cd terraform-basics
   

2. Create a Configuration File: Create a file named main.tf and add the following content:

   provider "aws" {
     region = "us-west-2"
   }
   
   resource "aws_instance" "example" {
     ami           = "ami-0c55b159cbfafe1f0"
     instance_type = "t2.micro"
   }
   
   output "instance_id" {
     value = aws_instance.example.id
   }
   

3. Initialize Terraform: Initialize your Terraform configuration. This will download the necessary provider plugins.

   terraform init
   

4. Plan the Configuration: Generate and show an execution plan.

   terraform plan
   

5. Apply the Configuration: Apply the changes required to reach the desired state of the configuration.

   terraform apply
   

6. Verify the Output: After the apply command completes, you should see the instance ID in the output.

• Provider Configuration: Ensure that your provider configuration is correct and that you have the necessary credentials.
• Resource Naming: Use meaningful names for your resources to make your configuration more readable.
• State Management: Be aware that Terraform maintains a state file to keep track of the resources it manages. This file is crucial for Terraform to function correctly.

• Task: Change the instance type from t2.micro to t2.small in the main.tf file.
• Solution:

  resource "aws_instance" "example" {
    ami           = "ami-0c55b159cbfafe1f0"
    instance_type = "t2.small"
  }
  

• Task: Add a tag to the EC2 instance with the key Name and value MyInstance.
• Solution:

  resource "aws_instance" "example" {
    ami           = "ami-0c55b159cbfafe1f0"
    instance_type = "t2.micro"
  
    tags = {
      Name = "MyInstance"
    }
  }
  

In this section, we covered the basics of Terraform, including its core concepts and components. You learned how to create a simple Terraform configuration to launch an AWS EC2 instance. With this foundational knowledge, you are now ready to dive deeper into Terraform's configuration language and explore more advanced features.

Next, we will explore the HashiCorp Configuration Language (HCL) in detail, which is essential for writing effective Terraform configurations.