Skip to main content

Experiment 11 (Content Beyond Syllabus) Title: Demonstrating Infrastructure as Code (IaC) with Terraform

 Experiment 11 (Content Beyond Syllabus)

Title: Demonstrating Infrastructure as Code (IaC) with Terraform


The objective of this experiment is to introduce you to Terraform and demonstrate how to create, modify, and destroy infrastructure resources locally using Terraform's configuration files and commands.


Terraform is a powerful Infrastructure as Code (IaC) tool that allows you to define and provision infrastructure using a declarative configuration language. In this experiment, we will demonstrate how to use Terraform on your local machine to create and manage infrastructure resources in a cloud environment.

Terraform is an open-source Infrastructure as Code (IaC) tool developed by HashiCorp. It enables the creation, management, and provisioning of infrastructure resources and services across various cloud providers, on-premises environments, and third-party services. Terraform follows a declarative syntax and is designed to make infrastructure provisioning predictable, repeatable, and automated.

Key Concepts and Features:

  • Declarative Syntax: Terraform uses a declarative configuration language (HCL - HashiCorp Configuration Language) to define infrastructure as code. Instead of specifying step-by-step instructions, you declare what resources you want, and Terraform figures out how to create and manage them.

  • Infrastructure as Code (IaC): Terraform treats infrastructure as code, allowing you to version, share, and collaborate on infrastructure configurations just like you would with application code.

  • Providers: Terraform supports a wide range of providers, including AWS, Azure, Google Cloud, and more. Each provider allows you to manage resources specific to that platform.

  • Resources: Resources are the individual infrastructure components you define in your Terraform configuration. Examples include virtual machines, databases, networks, and security groups.

  • State Management: Terraform maintains a state file that keeps track of the real-world resources it manages. This state file helps Terraform understand the current state of the infrastructure and determine what changes are needed to align it with the desired configuration.

  • Plan and Apply: Terraform provides commands to plan and apply changes to your infrastructure. The "plan" command previews changes before applying them, ensuring you understand the impact.

  • Dependency Management: Terraform automatically handles resource dependencies. If one resource relies on another, Terraform determines the order of provisioning.

  • Modularity: Terraform configurations can be organized into modules, allowing you to create reusable and shareable components.

  • Community and Ecosystem: Terraform has a large and active community, contributing modules, providers, and best practices. The Terraform Registry hosts a wealth of pre-built modules and configurations.

Typical Workflow:

  • Configuration Definition: Define your infrastructure configuration using Terraform's declarative syntax. Describe the resources, providers, and dependencies in your *.tf files.

  • Initialization: Run terraform init to initialize your Terraform project. This command downloads required providers and sets up your working directory.

  • Planning: Execute terraform plan to create an execution plan. Terraform analyzes your configuration and displays what changes will be made to the infrastructure.

  • Provisioning: Use terraform apply to apply the changes and provision resources. Terraform will create, update, or delete resources as needed to align with your configuration.

  • State Management: Terraform maintains a state file (by default, terraform.tfstate) that tracks the current state of the infrastructure.

  • Modifications: As your infrastructure requirements change, update your Terraform configuration files and run terraform apply again to apply the changes incrementally.

  • Destruction: When resources are no longer needed, you can use terraform destroy to remove them. Be cautious, as this action can't always be undone.

Advantages of Terraform:

  • Predictable and Repeatable: Terraform configurations are repeatable and idempotent. The same configuration produces the same results consistently.

  • Collaboration: Infrastructure configurations can be versioned, shared, and collaborated on by teams, promoting consistency.

  • Multi-Cloud: Terraform's multi-cloud support allows you to manage infrastructure across different cloud providers with the same tool.

  • Community and Modules: A rich ecosystem of modules, contributed by the community, accelerates infrastructure provisioning.

  • Terraform has become a fundamental tool in the DevOps and infrastructure automation landscape, enabling organizations to manage infrastructure efficiently and with a high degree of control.


  • A computer with Terraform installed (

  • Access to a cloud provider (e.g., AWS, Google Cloud, Azure) with appropriate credentials configured

Experiment Steps:

Step 1: Install and Configure Terraform

  • Download and install Terraform on your local machine by following the instructions for your operating system (

Verify the installation by running:

terraform version

  • Configure your cloud provider's credentials using environment variables or a configuration file. For example, if you're using AWS, you can configure your AWS access and secret keys as environment variables:

export AWS_ACCESS_KEY_ID=your_access_key

export AWS_SECRET_ACCESS_KEY=your_secret_key

Step 2: Create a Terraform Configuration File

Create a new directory for your Terraform project:

mkdir my-terraform-project

cd my-terraform-project

Inside the project directory, create a Terraform configuration file named This file will define your infrastructure resources. For a simple example, let's create an AWS S3 bucket:

provider "aws" {

  region = "us-east-1"  # Change to your desired region


resource "aws_s3_bucket" "example_bucket" {

  bucket = "my-unique-bucket-name"  # Replace with a globally unique name

  acl    = "private"


Step 3: Initialize and Apply the Configuration

  • Initialize the Terraform working directory to download the necessary provider plugins:

terraform init

  • Validate the configuration to ensure there are no syntax errors:

terraform validate

  • Apply the configuration to create the AWS S3 bucket:

terraform apply

  • Terraform will display a summary of the planned changes. Type "yes" when prompted to apply the changes.

Step 4: Verify the Infrastructure

After the Terraform apply command completes, you can verify the created infrastructure. For an S3 bucket, you can check the AWS Management Console or use the AWS CLI:

aws s3 ls

  • You should see your newly created S3 bucket.

Step 5: Modify and Destroy Infrastructure

  • To modify your infrastructure, you can edit the file and then re-run terraform apply. For example, you can add new resources or update existing ones.

  • To destroy the infrastructure when it's no longer needed, run:

terraform destroy

Confirm the destruction by typing "yes."


  • In this experiment, you created a simple Terraform configuration to provision an AWS EC2 instance.

  • The file defines an AWS provider, specifying the desired region, and a resource block that defines an EC2 instance with the specified Amazon Machine Image (AMI) and instance type.

  • Running terraform init initializes the Terraform project, and terraform plan provides a preview of the changes Terraform will make.

  • terraform applies the changes, creating the AWS EC2 instance.

  • To clean up resources, terraform destroy can be used.


In this experiment, you learned how to use Terraform on your local machine to create and manage infrastructure resources as code. Terraform simplifies infrastructure provisioning, modification, and destruction by providing a declarative way to define and maintain your infrastructure, making it a valuable tool for DevOps and cloud engineers.

Exercises / Questions 

  1. What is Terraform, and what is its primary purpose in the context of infrastructure management and automation?

  2. Explain the key difference between declarative and imperative programming approaches. How does Terraform use a declarative approach in its configuration files?

  3. What is the role of Terraform providers, and how do they enable the management of resources across various cloud platforms and services?

  4. Describe the significance of the Terraform state file. How does it help Terraform keep track of the current state of the infrastructure?

  5. In Terraform, what are resources, and how are they defined in configuration files? Provide examples of common resources.

  6. What is the purpose of Terraform modules, and how do they facilitate code reusability and modularity in infrastructure configurations?

  7. Explain the steps involved in a typical Terraform workflow, from defining infrastructure as code to applying changes to the infrastructure.

  8. How does Terraform handle resource dependencies and ensure the correct order of resource provisioning within a configuration?

  9. What are the benefits of using Terraform's plan and apply commands? How do they help prevent unintended changes to the infrastructure?

  10. Discuss Terraform's support for multi-cloud deployments. How can Terraform be used to manage resources across different cloud providers within the same configuration?


Popular posts from this blog

Experiment No. 5 Title: Applying CI/CD Principles to Web Development Using Jenkins, Git, and Local HTTP Server

  Experiment No. 5 Title: Applying CI/CD Principles to Web Development Using Jenkins, Git, and Local HTTP Server  Objective: The objective of this experiment is to set up a CI/CD pipeline for a web development project using Jenkins, Git, and webhooks, without the need for a Jenkinsfile. You will learn how to automatically build and deploy a web application to a local HTTP server whenever changes are pushed to the Git repository, using Jenkins' "Execute Shell" build step. Introduction: Continuous Integration and Continuous Deployment (CI/CD) is a critical practice in modern software development, allowing teams to automate the building, testing, and deployment of applications. This process ensures that software updates are consistently and reliably delivered to end-users, leading to improved development efficiency and product quality. In this context, this introduction sets the stage for an exploration of how to apply CI/CD principles specifically to web development using J

Experiment No. 6 Title: Exploring Containerization and Application Deployment with Docker

  Experiment No. 6 Title: Exploring Containerization and Application Deployment with Docker  Objective: The objective of this experiment is to provide hands-on experience with Docker containerization and application deployment by deploying an Apache web server in a Docker container. By the end of this experiment, you will understand the basics of Docker, how to create Docker containers, and how to deploy a simple web server application. Introduction Containerization is a technology that has revolutionised the way applications are developed, deployed, and managed in the modern IT landscape. It provides a standardised and efficient way to package, distribute, and run software applications and their dependencies in isolated environments called containers. Containerization technology has gained immense popularity, with Docker being one of the most well-known containerization platforms. This introduction explores the fundamental concepts of containerization, its benefits, and how it differs

Experiment No. 10 Title: Create the GitHub Account to demonstrate CI/CD pipeline using Cloud Platform.

  Experiment No. 10 Title: Create the GitHub Account to demonstrate CI/CD pipeline using Cloud Platform. Objective: The objective of this experiment is to help you create a GitHub account and set up a basic CI/CD pipeline on GCP. You will learn how to connect your GitHub repository to GCP, configure CI/CD using Cloud Build, and automatically deploy web pages to an Apache web server when code is pushed to your repository. Introduction: Continuous Integration and Continuous Deployment (CI/CD) pipelines are essential for automating the deployment of web applications. In this experiment, we will guide you through creating a GitHub account and setting up a basic CI/CD pipeline using Google Cloud Platform (GCP) to copy web pages for an Apache HTTP web application. Continuous Integration and Continuous Deployment (CI/CD) is a crucial practice in modern software development. It involves automating the processes of code integration, testing, and deployment to ensure that software changes are co