Cree una nube privada virtual (VPC) en AWS con Terraform

En este artículo, le mostraré cómo crear una VPC junto con subredes, puerta de enlace de Internet, puertas de enlace NAT y tablas de rutas. Crearemos 1 VPC con 4 subredes:2 privadas y 2 públicas, 2 puertas de enlace NAT, 1 puerta de enlace de Internet y 4 tablas de rutas.

Antes de continuar, supongo que tiene conocimientos básicos de Terraform y VPC en AWS. Para conocer la VPC y su creación desde la consola de AWS, puede hacer clic aquí y para conocer los conceptos básicos de Terraform, puede buscar "¿Qué es Terraform y cómo instalarlo en la instancia EC2 de AWS?"

Requisitos previos

1. Comprensión básica de Terraform.
2. Terraform instalado en su sistema.
3. Cuenta de AWS (cree si no tiene una).
4. 'access_key' y 'secret_key' de un usuario de AWS IAM. (Haga clic aquí para aprender a crear un usuario de IAM con 'access_key' y 'secret_key' en AWS)

Lo que haremos

1. Escribir archivos de configuración de Terraform para crear una VPC con otros recursos dependientes.
2. Cree una VPC y otros recursos dependientes utilizando los archivos de configuración de Terraform
3. Elimine la VPC creada y otros recursos dependientes mediante Terraform

Escribir archivos de configuración de Terraform para crear una VPC con otros recursos dependientes.

Cree un directorio dedicado donde pueda crear archivos de configuración de terraform.

Use el siguiente comando para crear un directorio y cambiar su directorio de trabajo actual a él.

mkdir terraform
cd terraform/

Estoy usando "vim" como editor para escribir en archivos. Puede usar un editor de su elección y copiar y pegar las siguientes configuraciones para crear variables.tf, terraform.tfvars y main.tf

Cree 'main.tf', que es responsable de crear VPC en AWS con los recursos dependientes. Este main.tf leerá valores de variables de variables.tf y terraform.tfvars.

vim main.tf

provider "aws" {
      region     = "${var.region}"
      access_key = "${var.access_key}"
      secret_key = "${var.secret_key}"
}


# VPC resources: This will create 1 VPC with 4 Subnets, 1 Internet Gateway, 4 Route Tables. 

resource "aws_vpc" "default" {
  cidr_block           = var.cidr_block
  enable_dns_support   = true
  enable_dns_hostnames = true
}

resource "aws_internet_gateway" "default" {
  vpc_id = aws_vpc.default.id
}

resource "aws_route_table" "private" {
  count = length(var.private_subnet_cidr_blocks)

  vpc_id = aws_vpc.default.id
}

resource "aws_route" "private" {
  count = length(var.private_subnet_cidr_blocks)

  route_table_id         = aws_route_table.private[count.index].id
  destination_cidr_block = "0.0.0.0/0"
  nat_gateway_id         = aws_nat_gateway.default[count.index].id
}

resource "aws_route_table" "public" {
  vpc_id = aws_vpc.default.id
}

resource "aws_route" "public" {
  route_table_id         = aws_route_table.public.id
  destination_cidr_block = "0.0.0.0/0"
  gateway_id             = aws_internet_gateway.default.id
}

resource "aws_subnet" "private" {
  count = length(var.private_subnet_cidr_blocks)

  vpc_id            = aws_vpc.default.id
  cidr_block        = var.private_subnet_cidr_blocks[count.index]
  availability_zone = var.availability_zones[count.index]
}

resource "aws_subnet" "public" {
  count = length(var.public_subnet_cidr_blocks)

  vpc_id                  = aws_vpc.default.id
  cidr_block              = var.public_subnet_cidr_blocks[count.index]
  availability_zone       = var.availability_zones[count.index]
  map_public_ip_on_launch = true
}

resource "aws_route_table_association" "private" {
  count = length(var.private_subnet_cidr_blocks)

  subnet_id      = aws_subnet.private[count.index].id
  route_table_id = aws_route_table.private[count.index].id
}

resource "aws_route_table_association" "public" {
  count = length(var.public_subnet_cidr_blocks)

  subnet_id      = aws_subnet.public[count.index].id
  route_table_id = aws_route_table.public.id
}


# NAT resources: This will create 2 NAT gateways in 2 Public Subnets for 2 different Private Subnets.

resource "aws_eip" "nat" {
  count = length(var.public_subnet_cidr_blocks)

  vpc = true
}

resource "aws_nat_gateway" "default" {
  depends_on = ["aws_internet_gateway.default"]

  count = length(var.public_subnet_cidr_blocks)

  allocation_id = aws_eip.nat[count.index].id
  subnet_id     = aws_subnet.public[count.index].id
}
 

Cree 'variables.tf' que contiene la declaración y definición de las variables.

vim variables.tf

variable "access_key" {
     description = "Access key to AWS console"
     
}
variable "secret_key" {
     description = "Secret key to AWS console"
     
}

variable "region" {
  default     = "eu-west-3"
  type        = string
  description = "Region of the VPC"
}


variable "cidr_block" {
  default     = "10.0.0.0/16"
  type        = string
  description = "CIDR block for the VPC"
}

variable "public_subnet_cidr_blocks" {
  default     = ["10.0.0.0/24", "10.0.2.0/24"]
  type        = list
  description = "List of public subnet CIDR blocks"
}

variable "private_subnet_cidr_blocks" {
  default     = ["10.0.1.0/24", "10.0.3.0/24"]
  type        = list
  description = "List of private subnet CIDR blocks"
}

variable "availability_zones" {
  default     = ["eu-west-3a", "eu-west-3b"]
  type        = list
  description = "List of availability zones"
}
 

Cree 'terraform.tfvars' que contiene la definición de las variables access_key y secret_key definidas en el archivo anterior. Hemos guardado la declaración de estas dos variables en el archivo 'terraform.tfvars'.

Las siguientes claves deben cambiarse con las claves de su usuario de IAM.

vim terraform.tfvars

access_key = "AKIAQ6GAIA5XIHHM2GJM"
secret_key = "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"

Ahora, debería tener 3 archivos, a saber, variables.tf, terraform.tfvars y main.tf

Crear una VPC y otros recursos dependientes usando los archivos de configuración de Terraform

Antes de ejecutar los siguientes comandos, asegúrese de haber configurado access_key y secret_key válidos.

El primer comando que se utilizará es 'terraform init'. Este comando descarga e instala complementos para proveedores utilizados dentro de la configuración. En nuestro caso, es AWS.

terraform init

El segundo comando que se utilizará es 'plan de terraformación'. Este comando se utiliza para ver los cambios que se producirán en la infraestructura.

terraform plan

El comando 'terraform apply' creará los recursos en AWS mencionados en el archivo main.tf. Se le pedirá que proporcione su entrada para crear los recursos.

terraform apply

Cuando ejecuta el comando anterior, puede ver que se agregaron 20 nuevos recursos y 0 se destruyó en la salida.

Puede ir a la consola de AWS VPC para verificar si la VPC se crea junto con subredes, puertas de enlace NAT de tablas de ruta y una puerta de enlace de Internet.

Elimine la VPC creada y otros recursos dependientes mediante Terraform

Si ya no necesita los recursos que creó usando la configuración mencionada en el archivo main.tf, puede usar el comando "terraform destroy" para eliminar todos esos recursos.

terraform destroy

Cuando ejecuta el comando anterior, puede ver que 20 recursos que se han creado se destruyen en la salida. Puede verificar lo mismo visitando AWS en el Panel de VPC.

Conclusión

En este artículo, vimos los pasos para crear una VPC con 4 subredes, 4 tablas de rutas, 2 puertas de enlace NAT y 1 puerta de enlace de Internet. También vimos cómo se pueden destruir los recursos que se crearon.