In this blog I will show you how to build an AWS VPC with Terraform.
Terraform is a cloud management tool that helps you manage your infrastructure as code. It’s main use cases are helping make building, changing and scaling up or down on the fly easier by managing resources across multiple providers like Amazon Web Services (AWS), Google Cloud Platform (GCP) and Microsoft Azure.
If you’ve been looking into alternatives for deploying apps in the cloud but aren’t considering blockchain yet, then today might be your lucky day! We’ll take a deep dive into what it actually means to “have a single source of truth” that can help us decide whether we should go ahead with our plans for blockchain based application deployment or not.
The “terraform create vpc example” is a step-by-step guide on how to create an AWS VPC with Terraform.
You might use the AWS Management Console to create an AWS Virtual Private Cloud (VPC), but automating it is so much more fun! Building AWS services using tools like Terraform is a more scalable and automated method to cloud resource provisioning in a DevOps setting.
In this article, you’ll learn how to create and execute a Terraform configuration to create a VPC from the ground up!
Prerequisites
This article will be a step-by-step guide. If you want to join in, make sure you have the following items:
- Terraform — This lesson will utilize Terraform v0.14.9 on Ubuntu 18.04.5 LTS, however Terraform should function on any operating system.
How to Install Terraform on Windows is a related topic.
- A code editor — While you may work with Terraform configuration files with any text editor, you should have one that understands the HCL Terraform language. Visual Studio (VS) Code is a good place to start.
Understanding AWS Virtual Private Clouds (VPCs)
The AWS cloud offers a wide range of services, including computation, storage, networking, and more. Each of these services may interact with one another in the same way as services in an on-premise datacenter can. However, each of these services is distinct from the others and is not necessarily isolated from others. This is changed by the AWS VPC.
AWS Virtual Private Cloud (VPC) is a single network that enables you to deploy AWS services from inside a single isolated network. Technically, an AWS VPC is similar to owning a datacenter, but it comes with extra features like as scalability, fault tolerance, and limitless storage.
VPC architecture on AWS
Region-based restrictions apply to AWS VPCs. With up to five VPCs supported per area, you can’t have one VPC that spans several regions.
Constructing an AWS VPC Terraform Configuration
Let’s get down to business and start developing!
To begin, create a folder in which to save your Terraform configuration files. This instruction will create a folder in your home directory named terraform-vpc-demo.
mkdir /terraform-vpc-demo/terraform-vpc-demo/terraform-vpc-demo/terraform- cd /terraform-vpc-demo/terraform-vpc-demo/terraform-vpc-demo/terraform
2. Open your preferred code editor and copy/paste the configuration that has already been produced for you, saving it as main.tf in the /terraform-vpc-demo directory. Inline information is provided for each resource to be created.
All of the resources that must be supplied are included in the main.tf file.
Terraform makes use of a variety of configuration files. Each file is written in one of two formats: plain text or JSON. They have a special naming convention, which is either.tf or.tfjson.
The following is a Terraform configuration:
- Creates and connects an Internet Gateway to the VPC, allowing traffic inside the VPC to be accessed from the outside world.
- Creates a subnet that is both public and private.
Networks inside networks are referred to as subnets. They’re designed to make network traffic flow more efficient and to give smaller, easier-to-manage ‘chunks’ of IP addresses.
- Creates a route table for both the public and private subnets, and correlates it with both.
- Creates a NAT Gateway that allows private subnets to connect to the internet without the requirement for each resource to have an externally routable IP address.
Create the “aws vpc” “Main” VPC resource. # We’re going to make a VPC here. cidr block = var.main vpc cidr cidr block = var.main vpc cidr cidr block = # For the demo, use 10.0.0.0/24 in the CIDR block. instance tenancy = “default” Create an Internet Gateway and connect it to the “aws internet gateway” “IGW” VPC resource. # Setting up an Internet Gateway vpc id = aws vpc.Main.id # The vpc id will be produced after the VPC has been created. Create a Public Subnets resource with the following parameters: “aws subnet” “publicsubnets” # Configuring Public Subnets aws vpc.Main.id = vpc id “$var.public subnets” cidr block = “$var.public subnets” # A public subnet CIDR block # Creating Private Subnets resource “aws subnet” “privatesubnets” # Creating Private Subnets resource “aws subnet” “privatesubnets” cidr block = “$var.private subnets” vpc id = aws vpc.Main.id # Private subnets’ CIDR block “aws route table” “PublicRT” route table for Public Subnet’s resource “aws route table” vpc id = aws vpc.Main.id route # Creating RT for Public Subnet cidr block = “0.0.0.0/0” cidr block = “0.0.0.0/0” cidr block = “0.0.0.0/ # Traffic from the Public Subnet enters the Internet via the Internet Gateway gateway id = aws internet gateway.IGW.id aws route table” “PrivateRT” # Creating RT for the Private Subnet vpc id = aws vpc.Main.id # Traffic from Private Subnet accesses Internet through NAT Gateway nat gateway id = aws nat gateway.NATgw.id cidr block = “0.0.0.0/0” Route table association with Public Subnet’s resource “aws route table association” “PublicRTassociation” subnet id = aws subnet.publicsubnets.id route table id = aws route table.PublicRT.id route table id = aws route table.PublicRT.id route table id = aws route table.PublicRT.id route table Subnet id = aws subnet.privatesubnets.id route table id = aws route table.PrivateRT.id resource “aws eip” “nateIP” vpc = true vpc = true vpc = true vpc = true vpc = true vpc = true vpc = true vpc = true vpc = true Using the subnet id and allocation id resources to create the NAT Gateway “aws nat gateway” “NATgw” allocation id = aws eip.nateIP.id subnet id = aws subnet.publicsubnets.id
3. Create a new file called vars.tf in the /terraform-vpc-demo directory and paste the text below into it.
Vars.tf is a Terraform variables file that lists all of the variables referenced in the configuration file.
Variable references may be found in the configuration file by:
- var.region
- var.main vpc cidr
- var.public subnets
- var.private subnets
variable “region” variable “main vpc cidr” variable “public subnets” variable “private subnets” variable “region” variable “region” variable “region” variable “region” variable “region” variable “region” variable “region” variable “region” variable “region” variable “region” variable “region” variable “region” variable “region” variable “
All configuration settings may be stored in a single configuration file. Breaking things out is vital to keep things clear and make things simpler for developers and administrators.
4. To specify the AWS provider, create a new file in the /terraform-vpc-demo directory, paste in the following code, and call it provider.tf. The focus of the lesson will be on resource creation in the US-East-2 area.
The providers file specifies cloud service providers such as AWS, Oracle, and Azure, among others, so Terraform may connect to the appropriate cloud services. region = “us-east-2” provider “aws”
region = “us-east-2” provider “aws”
5. Finally, within the /terraform-vpc-demo directory, create a new file called terraform.tfvars and paste the code below into it. Terraform will utilize the values in this variables file to replace the variable references in the configuration file.
main vpc cidr = “10.0.0.0/24” main vpc cidr = “10.0.0.0/24” 10.0.0.128/26 public subnets = “10.0.0.128/26” public subnets = “10.0.0.128/26” “10.0.0.192/26” is the private subnets value.
Now, open your preferred terminal (in this example, Bash) and use the tree command to make sure the folder has all of the essential files.
Terraform files are organized in folders.
Terraform is used to create an AWS VPC.
It’s time to start Terraform and construct the VPC now that you have the Terraform configuration file and variables files ready to go! Terraform normally employs a three-stage process to provide a Terraform configuration: terraform init, terraform plan, and terraform apply. Let’s have a look at each step now.
1. Navigate to the terraform-vpc-demo directory in a terminal.
2. In the same directory, run the terraform init command. The terraform init command sets up the necessary plugins and providers to operate with resources.
If everything works properly, the message Terraform has been successfully started should appear in the output, as seen below.
Terraform was successfully started.
3. Now, use the terraform plan command to create a plan. This is an optional, but highly recommended, step that ensures the syntax of your configuration is valid and offers you an overview of the resources that will be supplied in your infrastructure. strategy for terraforming
If the command was successful, you should see a message in the output that says Plan: “X” to add, “Y” to alter, or “Z” to destroy. Terraform will also show you every AWS resource it proposes to generate.
Make a plan for command execution.
4. Finally, inform Terraform to use terraform apply to provide the AWS VPC and resources. Terraform will read the configuration (main.tf) and the other files to generate a configuration when you run terraform apply. The settings will then be sent to AWS as instructions for creating the VPC and other components.
Execution of Terraform commands
Take note of the IDs in the Terraform output. These IDs will be required to link the resources established in the next step.
Let’s check the AWS Management Console to see whether the VPC and components were established correctly after the Terraform script ran successfully.
AWS VPC Verification
You should have constructed the VPC using Terraform by now. Let’s double-check on the AWS Management Console by manually looking for the VPC.
1. Go to the AWS Management Console in your chosen web browser and log in.
2. While in the Console, type ‘vpc’ into the search box at the top and choose the VPC menu option.
Accessing the VPC service
3. Go to the VPC page and choose Your VPCs. The VPC established with the same ID Terraform returned previously should appear.
VPC was established.
4. Because Terraform built not only the VPC resource but all of the resources necessary for the VPC, each resource should be found on this page as well.
Subnets have been constructed.
Route tables have been constructed.
The Internet Gateway was established.
NAT Gateway has been established.
This VPC is now ready to use after all of the components were successfully constructed using Terraform.
Conclusion
You’ve learnt how to use Terraform to deploy an AWS VPC and its components using Terraform in this tutorial.
Terraform lets you to rapidly, easily, and consistently construct resources in an Amazon Virtual Private Cloud. You’re now ready to apply what you’ve learned to additional AWS services and develop powerful applications on top of them.
The “terraform vpc example github” is a step-by-step guide on how to create an AWS VPC with Terraform. The guide provides examples of what can be done and how to do it.
Related Tags
- terraform-aws vpc module
- terraform create vpc and subnets
- create aws vpc using terraform
- terraform-aws vpc template
- terraform aws subnet resource
