Day3-Managing Resources 🔹How to define and manage resources using terraform

Terraform is an open-source infrastructure as code (IaC) tool that allows you to define and manage your infrastructure resources in a declarative manner. It provides a way to describe your infrastructure using a domain-specific language (DSL) called HashiCorp Configuration Language (HCL) or JSON.

Here are the key steps involved in defining and managing resources using Terraform:

Installation: Start by installing Terraform on your local machine or the environment where you plan to manage your infrastructure.
Configuration: Create a new Terraform configuration file with a .tf extension (e.g., main.tf). This file will contain the definitions of your resources and their configurations. You can also have multiple configuration files if needed.
Provider Configuration: Specify the provider you want to use to provision your resources. A provider is responsible for interacting with a specific infrastructure or service, such as AWS, Azure, or Google Cloud. You'll need to configure the provider with your credentials or access keys.
Resource Definition: Define the resources you want to create or manage using the Terraform configuration language. For example, if you're using AWS, you might define an EC2 instance, a VPC, or a security group. Each resource has its own set of configuration options.
Variables and Inputs: Use variables to make your Terraform configuration more dynamic and reusable. Variables allow you to parameterize your configuration, making it easier to deploy the same infrastructure with different values. You can define variables in separate .tf files or inline within your configuration.
Outputs: Define outputs to retrieve information from your infrastructure after it's been provisioned. Outputs can be useful for retrieving the IP addresses, DNS names, or other details of your resources. They are defined in the Terraform configuration and can be accessed once the infrastructure is deployed.
Initialization: Run terraform init to initialize your Terraform configuration. This command downloads the necessary provider plugins and sets up the backend where Terraform will store its state.
Planning: Use terraform plan to create an execution plan. Terraform will analyze your configuration and determine what changes need to be made to reach the desired state. It provides an overview of the resources that will be created, modified, or destroyed.
Deployment: Run terraform apapplyply to apply the changes defined in your configuration. Terraform will create or modify the resources as required to match the desired state. You'll be prompted to confirm the changes before they are applied.
Management: After the initial deployment, you can continue to manage your resources using Terraform. Make changes to your configuration files, such as modifying resource configurations or adding new resources. Run terraform plan and terraform apply as needed to update your infrastructure.
Destroy: When you no longer need your infrastructure, you can use terraform destroy to remove all the resources created by Terraform. This command will prompt you for confirmation before destroying the resources.

🔹Explore Various Resources types and there configuration

Here are explanations of various resource types and their configurations in AWS that you can define and manage using Terraform:

Amazon EC2 Instance (aws_instance):
- Configuration: You can define the instance type, AMI ID, key pair, security groups, and other settings. Additionally, you can specify user data to run scripts or configure the instance on launch.
Amazon S3 Bucket (aws_s3_bucket):
- Configuration: You can set the bucket name, region, access control, versioning, logging, and other options. You can also define lifecycle rules to automatically transition objects between storage classes.
Amazon RDS Instance (aws_db_instance):
- Configuration: You can specify the DB instance class, storage size, engine type, master username and password, security groups, and other database-specific settings.
Amazon VPC (aws_vpc):
- Configuration: You can define the VPC's CIDR block, enable DNS hostnames, and specify the tenancy (default or dedicated). Additionally, you can configure subnets, route tables, and network ACLs within the VPC.
Amazon IAM Role (aws_iam_role):
- Configuration: You can specify the role name, IAM policies, trust relationships, and assume role permissions. Roles are used to grant permissions to AWS services or entities.
Amazon Lambda Function (aws_lambda_function):
- Configuration: You can define the function's name, runtime, handler, memory size, and timeout. You can also specify the function's source code location, environment variables, and event triggers.
Amazon DynamoDB Table (aws_dynamodb_table):
- Configuration: You can set the table name, primary key schema, read/write capacity, and configure global secondary indexes. Additionally, you can define TTL (time to live) for automatic item expiration.
Amazon SNS Topic (aws_sns_topic):
- Configuration: You can specify the topic name and display name, along with access control policies. SNS topics are used for publishing messages to subscribers via various protocols like email, SMS, or HTTP.
Amazon SQS Queue (aws_sqs_queue):
- Configuration: You can define the queue name, access control, and configure attributes such as message retention period, visibility timeout, and dead-letter queue settings. SQS queues are used for message queuing and decoupling.
Amazon CloudFront Distribution (aws_cloudfront_distribution):
- Configuration: You can specify the distribution configuration, including the origin, cache behaviors, SSL settings, and access control. CloudFront distributions provide content delivery and edge caching.

These are just a few examples of resource types in AWS that can be managed using Terraform. Each resource type has its own set of configuration options and parameters. It's important to refer to the Terraform AWS provider documentation for detailed information on the specific resource you are working with.

Refer: - https://registry.terraform.io/providers/hashicorp/aws/latest/docs

Create Amazon EC2 Instance:

Set the Environment Variables:

In your operating system or shell environment, set the following environment variables:
- AWS_ACCESS_KEY_ID: Set this variable to your AWS access key ID.
- AWS_SECRET_ACCESS_KEY: Set this variable to your AWS secret access key.

The method to set environment variables may vary depending on your operating system. Here are a few examples:

On Linux or macOS:

  export AWS_ACCESS_KEY_ID=your_access_key_id
  export AWS_SECRET_ACCESS_KEY=your_secret_access_key

Here's an example of how to define an Amazon EC2 instance using Terraform:

Create a Terraform Configuration File:
- Create a new file with a .tf extension, such as main.tf, in a directory of your choice.
- Copy and paste the following Terraform configuration into the file:

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 4.16"
    }
  }
  required_version = ">= 1.2.0"
}

provider "aws" {
  region = "ap-south-1"
}

resource "aws_instance" "example" {
  ami           = "ami-0f5ee92e2d53afc20"
  instance_type = "t2.micro"
  key_name = "your_existing_key_pair_name"

  tags = {
    Name = "sample_instance"
  }
}

output "public_ips" {
  value = aws_instance.example.private_ip
}

To run the Terraform commands: -

Initialize the Configuration:

terraform init

Preview the Changes:

terraform plan

Apply the Changes:

terraform apply

When prompted for confirmation, enter "yes" and press Enter.

Destroy the Resources (Optional): If you want to destroy the resources created by Terraform and remove them from your AWS account, you can run the following command:

terraform destroy

🔹resource dependencies, provisioners and lifecycle management

Resource Dependencies: In Terraform, resource dependencies define the relationships between resources. By specifying dependencies, you can ensure that certain resources are created or modified before others. This ensures that the required resources are available when needed.

Dependencies are established implicitly based on resource references in the configuration. For example, if Resource B references Resource A, Terraform understands that B depends on A. When Terraform creates or modifies resources, it automatically handles the order of operations based on these dependencies.

Here's an example that demonstrates resource dependencies:

resource "aws_security_group" "web" {
  # ... configuration for the security group ...
}

resource "aws_instance" "web_server" {
  # ... configuration for the EC2 instance ...
  security_group_ids = [aws_security_group.web.id]
}

In this example, the aws_instance resource depends on the aws_security_group resource because it references its id in the security_group_ids attribute. Terraform ensures that the security group is created before the EC2 instance.

Provisioners: In Terraform, provisioners are used to execute scripts or commands on a resource during its lifecycle. They allow you to perform additional configuration, software installations, or custom actions on the resources you create or manage.

Terraform provides three types of provisioners:

File Provisioner: The file provisioner is used to copy files or directories from the machine running Terraform to a resource after it's created. It is commonly used for configuration files, scripts, or other files needed on the resource.

Example:
```
 resource "aws_instance" "web_server" {
   ami           = "ami-0f5ee92e2d63afc18"
   instance_type = "t2.micro"
   key_name      = "your_existing_key_pair_name"

   provisioner "file" {
     source      = "path/to/local/file"
     destination = "/path/on/instance/file"
     connection {
       type        = "ssh"
       user        = "ec2-user"  # or any other user on your instance
       private_key = file("path/to/private/key")
       host        = self.public_ip
     }
   }
   # ... other configuration ...
 }
```
Local-exec Provisioner: The local-exec provisioner executes commands locally on the machine running Terraform. It is useful for running scripts or commands that don't need to be executed on the resource itself.

Example:
```
 resource "aws_instance" "web_server" {
   # ... configuration for the EC2 instance ...

   provisioner "local-exec" {
     command = "echo 'Hello, World!'"
   }
 }
```
Remote-exec Provisioner: The remote-exec provisioner runs scripts or commands on a resource over SSH or WinRM connections. It is suitable for executing commands on remote instances or performing post-provisioning tasks.

Example:
```
 resource "aws_instance" "web_server" {
   # ... configuration for the EC2 instance ...

   provisioner "remote-exec" {
     inline = [
       "sudo apt-get update",
       "sudo apt-get install -y nginx",
     ]
   }
 }
```
Lifecycle Management: Terraform provides lifecycle management options to control how resources are created, updated, and destroyed. These options are used to customize the behavior of Terraform during different stages of a resource's lifecycle.

Common lifecycle options include:
- create_before_destroy: This option controls the order in which resources are created and destroyed. When set to true, Terraform creates the replacement resource before destroying the existing one. This helps to minimize downtime during resource updates.
- prevent_destroy: When set to true, this option prevents a resource from being destroyed. It can be useful for protecting critical resources from accidental deletion.
- ignore_changes: This option allows you to ignore changes in specific resource attributes. Terraform will not consider changes to ignored attributes when deciding whether to update a resource.
- depends_on: This option explicitly declares dependencies between resources. It allows you to specify dependencies that are not otherwise inferred from resource references.

Here's an example of using the lifecycle block to set lifecycle options:

    resource "aws_instance" "web_server" {
      # ... configuration for the EC2 instance ...

      lifecycle {
        create_before_destroy = true
        prevent_destroy       = true
      }