create AWS service it includes 2 public subnet and 2 private subnet AutoScaler Load balancer abd kubernets using terraform

To create an AWS service with 2 public subnets and 2 private subnets, AutoScaler, Load Balancer, and Kubernetes using Terraform, follow the steps below:

1. First, create a new Terraform configuration file and define the AWS provider. Add your AWS access key and secret key as environment variables or use a profile.

provider "aws" {
  region = "us-west-2"
}

2. Next, define the VPC and its subnets. Create two public subnets and two private subnets in different availability zones.

resource "aws_vpc" "example" {
  cidr_block = "10.0.0.0/16"
  
  tags = {
    Name = "example-vpc"
  }
}

resource "aws_subnet" "public1" {
  vpc_id = aws_vpc.example.id
  cidr_block = "10.0.1.0/24"
  availability_zone = "us-west-2a"
  
  tags = {
    Name = "public1-subnet"
  }
}

resource "aws_subnet" "public2" {
  vpc_id = aws_vpc.example.id
  cidr_block = "10.0.2.0/24"
  availability_zone = "us-west-2b"
  
  tags = {
    Name = "public2-subnet"
  }
}

resource "aws_subnet" "private1" {
  vpc_id = aws_vpc.example.id
  cidr_block = "10.0.3.0/24"
  availability_zone = "us-west-2a"
  
  tags = {
    Name = "private1-subnet"
  }
}

resource "aws_subnet" "private2" {
  vpc_id = aws_vpc.example.id
  cidr_block = "10.0.4.0/24"
  availability_zone = "us-west-2b"
  
  tags = {
    Name = "private2-subnet"
  }
}

3. Create an internet gateway and attach it to the VPC.

resource "aws_internet_gateway" "example" {
  vpc_id = aws_vpc.example.id
  
  tags = {
    Name = "example-igw"
  }
}

resource "aws_route_table" "public" {
  vpc_id = aws_vpc.example.id
  
  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.example.id
  }
  
  tags = {
    Name = "public-route-table"
  }
}

resource "aws_route_table_association" "public1" {
  subnet_id = aws_subnet.public1.id
  route_table_id = aws_route_table.public.id
}

resource "aws_route_table_association" "public2" {
  subnet_id = aws_subnet.public2.id
  route_table_id = aws_route_table.public.id
}

4. Create a security group for the instances in the private subnets.

resource "aws_security_group" "private" {
  name_prefix = "private"
  vpc_id = aws_vpc.example.id
  
  ingress {
    from_port = 0
    to_port = 65535
    protocol = "tcp"
    cidr_blocks = ["10.0.0.0/16"]
  }
  
  egress {
    from_port = 0
    to_port = 65535
    protocol = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  
  tags = {
    Name = "private-security-group"
  }
}

5. Create an Auto Scaling group with launch configuration, specifying the private subnets and instance type.

resource "aws_launch_configuration" "example" {
  name = "example-launch-config"
  image_id = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
  security_groups = [aws_security_group.private.id]
  
  lifecycle {
    create_before_destroy = true
  }
}

resource "aws_autoscaling_group" "example" {
  name = "example-asg"
  launch_configuration = aws_launch_configuration.example.id
  min_size = 2
  max_size = 4
  desired_capacity = 2
  vpc_zone_identifier = [aws_subnet.private1.id, aws_subnet.private2.id]
  
  tag {
    key = "Name"
    value = "example"
    propagate_at_launch = true
  }
}

6. Create a Load Balancer with listener and target group, specifying the public subnets and Auto Scaling group as target.

resource "aws_lb" "example" {
  name = "example-lb"
  subnets = [aws_subnet.public1.id, aws_subnet.public2.id]
  
  tags = {
    Name = "example-lb"
  }
}

resource "aws_lb_listener" "example" {
  load_balancer_arn = aws_lb.example.arn
  port = "80"
  protocol = "HTTP"
  
  default_action {
    type = "forward"
    target_group_arn = aws_lb_target_group.example.arn
  }
}

resource "aws_lb_target_group" "example" {
  name = "example-tg"
  port = "80"
  protocol = "HTTP"
  vpc_id = aws_vpc.example.id
  
  health_check {
    path = "/"
    protocol = "HTTP"
    matcher = "200"
    timeout = 5
    interval = 30
    healthy_threshold = 2
    unhealthy_threshold = 2
  }
}

resource "aws_lb_target_group_attachment" "example" {
  target_group_arn = aws_lb_target_group.example.arn
  target_id = aws_autoscaling_group.example.id
  port = "80"
}

7. Create a Kubernetes cluster using the EKS module.

module "eks" {
  source = "terraform-aws-modules/eks/aws"
  
  cluster_name = "example"
  subnets = [
    aws_subnet.private1.id,
    aws_subnet.private2.id
  ]
  tags = {
    Terraform   = "true"
    Environment = "dev"
  }
  vpc_id = aws_vpc.example.id
}

8. Save the Terraform configuration file with a .tf extension, and run the following commands to initialize Terraform, plan the deployment, and apply the changes.

terraform init
terraform plan
terraform apply

This will create an AWS service with 2 public subnets and 2 private subnets, AutoScaler, Load Balancer, and Kubernetes using Terraform.