TERRAFORM is used to automate deployment in infrastructure across multi providers in both public and private clouds. Provisioning of infrastructure through 'software' to achieve 'consistent' and 'predictable' environments is Infrastructure as code
IaC - In simple words replacement of SOPs which is automated on top of it.
core concepts to achieve this:
- Defined in Code: Iac should be defined in code weather in form of json yaml or hcl.
- Stored in source control: the code should be stored somewhere in version source control repository like GitHub.
- Declarative & Imperative: In imperative I am going to tell software each and everything which it needs to do the job. In declarative software already have some sort of Idea or a predefined routine, what it is going to do with taking some references.so terraform is an example of declarative approach to deploy IaC
- Idempotent & consistence: once a job is done, and if again I get a request to do the same job it is Idempotent behavior of terraform to not repeat the steps done while fulfilling this job, instead will say there is no change in configuration and current requirement is same as the desired one so no changes needs to be made. otherwise in non-idempotent world each time this job comes it gonna repeat the same steps again and again to fulfil the requirement which is already in place.
- Push & pull : terraform works on the principle of push mechanism where it pushes the configuration to its target.
Key benefit here is - everything is documented in code, which makes you understand about your infrastructure in more details.
key terraform components
In this exercise I am trying to demonstrate as how you can quickly deploy t2.micro instance of amazon linux without login into aws console by just writing a terraform plan
to being with you need to fulfill a prerequisite:
"you should have an IAM user with AWS CLI access"
to being with you need to fulfill a prerequisite:
"you should have an IAM user with AWS CLI access"
and to form a terraform configuration file with .tf as extension, below are few blocks which terraform tend to use to define things
#VARIABLES - input variables ca be declared here
#PROVIDER - AWS, google like providers can be declared here
#DATA - data from provider collected here in form of data source
#RESOURCE - feeding info about resources from provider here
#OUTPUT - data is outputted when apply is called
defining variables in terraform can be achieved in multiple ways, so here I tried to define variable from an external file
To persist variable values, create a file and assign variables within this file. Create a file named terraform.tfvars with the following contents:
aws_access_key = "AKIA5O3GDEMOVOBSE4RA"
aws_secret_key = "+bh/vVqoDEMOErxv7YlrSs/sdRwN9ZzeKDtAjCP" key_name = "tfkeypair"
private_key_path = "C:\\tfkeypair.pem"
aws_access_key = "AKIA5O3GDEMOVOBSE4RA"
aws_secret_key = "+bh/vVqoDEMOErxv7YlrSs/sdRwN9ZzeKDtAjCP" key_name = "tfkeypair"
private_key_path = "C:\\tfkeypair.pem"
For all files which match terraform.tfvars or *.auto.tfvars present in the config directory terraform reads the variable
So in this exercise I tried to deploy an t2.micro instance on Amazon EC instance with nginx up and running on it.
and at the end your terraform configuration files structure will look like:
let start composing a terraform configuration file
#VARIABLES
first we are going to define set of variables here, that are used during the configuration. I have defined keypairs so that we can SSH to our AWS instance, with default region where my instance will be deployed#VARIABLES
variable "aws_access_key" {}
variable "aws_secret_key" {}
variable "key_name" {}
variable "private_key_path" {}
variable "region" {
default = "us-east-1"
}
#PROVIDER
here we are defining our providers, and feeding information about our key details defined in our variable section with syntax var.variableName
#PROVIDER
provider "aws" {
provider "aws" {
access_key = var.aws_access_key
secret_key = var.aws_secret_key
region = var.region
}
#DATA
here in data source block we are pulling data from the provider, in this exercise we are using amazon as provider and using linux ami for our EC2 instance
#DATA
data "aws_ami" "aws-linux" {
most_recent = true
owners = ["amazon"]
filter {
name = "name"
values = ["amzn-ami-hvm*"]
}
filter {
name = "root-device-type"
values = ["ebs"]
}
filter {
name = "virtualization-type"
values = ["hvm"]
}
}
#RESOURCE
In this block we can define more then one resources, here I have used default VPC, so that it will not be deleted on destroying the instance. Next we have defined security group so that we can SSH to our instance which is going to run nginx in this example, and opening port 80 & 22 ; and for that we need to define VPC id so that it will create the security group.
#RESOURCE
resource "aws_default_vpc" "default" {
}
resource "aws_security_group" "allow_ssh" {
name = "nginx_demo"
description = "allow ports for nginx demo"
vpc_id = aws_default_vpc.default.id
# to allow traffic from outside to inside
ingress {
from_port = 22
to_port = 22
protocol = "tcp"
cidr_blocks = ["0.0.0.0/0"]
}
ingress {
from_port = 80
to_port = 80
protocol = "tcp"
cidr_blocks = ["0.0.0.0/0"]
}
# to allow traffic from inside to outside i.e. from instance to internet
egress {
from_port = 0
to_port = 0
protocol = "-1"
cidr_blocks = ["0.0.0.0/0"]
}
}
# in this block we are actually defining out instance which will be nginx with t2.micro as resource type
resource "aws_instance" "nginx" {
ami = data.aws_ami.aws-linux.id
instance_type = "t2.micro"
key_name = var.key_name
vpc_security_group_ids = [aws_security_group.allow_ssh.id]
# since we are doing SSH so we need to define a connection in resource block, so that terraform understand where to connect with
connection {
type = "ssh"
host = self.public_ip
user = "ec2-user"
private_key = file(var.private_key_path)
}
# since we want to remotely exec command so
provisioner "remote-exec" {
inline = [
"sudo yum install nginx -y" ,
"sudo service nginx start"
]
}
}
#OUTPUT
this block will help to give you the output of your configuration#OUTPUT
output "aws_instance_public_dns" {
value = aws_instance.nginx.public_dns
}
#END
now to deploy above configuration, terraform deployment process follows a cycle:
Initialization
Planning
Application
destruction
$ terraform init
this initializes the terraform configuration and check for provider modules/plugins if its already not available and downloads the modules as shown below
this initializes the terraform configuration and check for provider modules/plugins if its already not available and downloads the modules as shown below
$ terraform plan -out ami.tfplan
it looks for configuration file in pwd and loads any variables if found in form of terraform.tfvars file , and stores out the plan as shown below
$ terraform apply "ami.tfplan"
it performs the configuration you created as code, applies it to provider and does the magic
now test the configuration by hitting above highlighted url and you will see result as:
and validate from your aws console you will see this:
now if you dont want the configs to be active and charge you money you can destroy it
$ terraform destroy
now if you dont want the configs to be active and charge you money you can destroy it
$ terraform destroy
lastly from your config folder you can destroy the config you applied and it will destroy everything corresponding to your config
Br,
Punit
