SAMPLE01-EC2-VPC-Ubuntu-Win-SSH-RDP.md

SAMPLE-01: Provisioning EC2s (Windows 2019 Server, Ubuntu 20.04) on VPC (Subnet), Creating Key-Pair, Connecting Ubuntu using SSH, and Connecting Windows Using RDP

This sample shows:

• how to create Key-pairs (public and private keys) on AWS.
• how to create EC2s (Ubuntu 20.04, Windows 2019 Server).
• how to create Virtual Private Cloud (VPC), VPC Components (Public Subnet, Internet Gateway, Route Table) and link to each others.
• how to create Security Groups (for SSH and Remote Desktop).

Code: https://github.com/omerbsezer/Fast-Terraform/tree/main/samples/ec2-vpc-ubuntu-win-ssh-rdp

Prerequisite

• You should have a look following lab:
  • LAB-00: Terraform Install, AWS Configuration with Terraform

Steps

• SSH key-pairs (public and private key) are used to connect remote server. Public key (xx.pub) is on the remote server, with private key, user can connect using SSH.

• There are 2 ways of creating key-pairs (public and private key):

  • Creating them on cloud (AWS)
    • EC2 > Key-pairs > Create Key-Pair
  • Creating them on on-premise
    • "ssh-keygen -t rsa -b 2048"

• Creating key-pairs on AWS: Go to EC2 > Key-pairs

• After creating key-pairs, public key is listed on AWS:

• Private key (testkey.pem) is downloaded on your PC:

• Copy this testkey.pem into your directory on which main.tf exists.

• Create main.tf under count directory and copy the code:

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

provider "aws" {
	region = "eu-central-1"
}

resource "aws_vpc" "my_vpc" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  tags = {
    Name = "My VPC"
  }
}

resource "aws_subnet" "public" {
  vpc_id            = aws_vpc.my_vpc.id
  cidr_block        = "10.0.0.0/24"
  availability_zone = "eu-central-1c"
  tags = {
    Name = "Public Subnet"
  }
}

resource "aws_internet_gateway" "my_vpc_igw" {
  vpc_id = aws_vpc.my_vpc.id
  tags = {
    Name = "My VPC - Internet Gateway"
  }
}

resource "aws_route_table" "my_vpc_eu_central_1c_public" {
    vpc_id = aws_vpc.my_vpc.id
    route {
        cidr_block = "0.0.0.0/0"
        gateway_id = aws_internet_gateway.my_vpc_igw.id
    }
    tags = {
        Name = "Public Subnet Route Table"
    }
}
resource "aws_route_table_association" "my_vpc_eu_central_1c_public" {
    subnet_id      = aws_subnet.public.id
    route_table_id = aws_route_table.my_vpc_eu_central_1c_public.id
}

resource "aws_security_group" "allow_ssh" {
  name        = "allow_ssh_sg"
  description = "Allow SSH inbound connections"
  vpc_id      = aws_vpc.my_vpc.id
  # for SSH
  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  # for HTTP Apache Server
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  # for RDP
  ingress {
    from_port        = 3389
    to_port          = 3389
    protocol         = "tcp"
    cidr_blocks      = ["0.0.0.0/0"]
  }
  # for ping
  ingress {
    from_port        = -1
    to_port          = -1
    protocol         = "icmp"
    cidr_blocks      = ["10.0.0.0/16"]
  }
  egress {
    from_port       = 0
    to_port         = 0
    protocol        = "-1"
    cidr_blocks     = ["0.0.0.0/0"]
  }
  tags = {
    Name = "allow_ssh_sg"
  }
}

resource "aws_instance" "ubuntu2004" {
  ami                         = "ami-0e067cc8a2b58de59" # Ubuntu 20.04 eu-central-1 Frankfurt
  instance_type               = "t2.nano"
  key_name                    = "testkey"
  vpc_security_group_ids      = [aws_security_group.allow_ssh.id]
  subnet_id                   = aws_subnet.public.id
  associate_public_ip_address = true
  user_data = <<-EOF
		           #! /bin/bash
                           sudo apt-get update
		           sudo apt-get install -y apache2
		           sudo systemctl start apache2
		           sudo systemctl enable apache2
		           echo "<h1>Deployed via Terraform from $(hostname -f)</h1>" | sudo tee /var/www/html/index.html
  EOF
  tags = {
    Name = "Ubuntu 20.04"
  }
}

resource "aws_instance" "win2019" {
	ami                         = "ami-02c2da541ae36c6fc" # Windows 2019 Server eu-central-1 Frankfurt
	instance_type               = "t2.micro"
        key_name                    = "testkey"
        vpc_security_group_ids      = [aws_security_group.allow_ssh.id]
        subnet_id                   = aws_subnet.public.id  
	associate_public_ip_address = true
        tags = {
		Name = "Win 2019 Server"
	}
}

output "instance_ubuntu2004_public_ip" {
  value = "${aws_instance.ubuntu2004.public_ip}"
}

output "instance_win2019_public_ip" {
  value = "${aws_instance.win2019.public_ip}"
}

Code: https://github.com/omerbsezer/Fast-Terraform/blob/main/samples/ec2-vpc-ubuntu-win-ssh-rdp/main.tf

• Run init command:

terraform init

• Validate file:

terraform validate

• Run plan command:

terraform plan

• Run apply command to create resources. Then, Terraform asks to confirm, write "yes":

terraform apply

• On AWS EC2 > Instances, Ubuntu 20.04:

• Security groups (SSG), for SSH (port 22), RDP (port 3389), HTTP (80), ICMP (for ping):

• On AWS EC2 > Instances, Window 2019 Server:

• Windows has same SSG like Ubuntu.

• Storage, Elastic Block Storage default:

• On AWS VPC (Virtual Private Cloud) Service:

• While installing Ubuntu20.04, userdata is used to install Apache Server on it. With SSG Port 80, using public IP, we can see the index.html, like hosting server:

• SSH to Ubuntu 20.04 (ssh -i testkey.pem ubuntu@):

• Run:

sudo apt install net-tools
ifconfig 

• Private IP can be seen:

• Make remote connection to Windows (RDP):

• Download RDP App:

• To get password, upload testkey.pem file:

• Now, we reach Windows using RDP:

• Pinging to Ubuntu20.04 from Windows:

• Opening firewall rules to ping from Ubuntu to Windows:
• Windows Defender -> Advance Settings -> Inbound Rules -> File and Printer Sharing (Echo Request - ICMPv4 - In) -> Right Click (Enable)

• Pinging to Windows 2019 Server from Ubuntu20.04:

• Viewing Ubuntu CPU, RAM:

• Destroy infrastructure:

terraform destroy 

• Be sure that instances are terminated. Because if they works, we pay the fee of them:

• We can also monitor the CPU, Disk, Network Usage on AWS EC2: