HowtoForge

Tutoriales de Linux

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

Publicada · Actualizado

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

Antes de continuar, asumo que tienes un conocimiento básico de Terraform y de la VPC en AWS. Para conocer la VPC y su creación desde la consola de AWS, puedes hacer clic aquíy para conocer los fundamentos de Terraform puedes buscar «¿Qué es Terraform y cómo instalarlo en la Instancia AWS EC2?»

Requisitos previos

  1. Conocimiento básico de Terraform.
  2. Terraform instalado en tu sistema.
  3. Cuenta de AWS (Créala si no tienes una).
  4. ‘access_key’ & ‘secret_key’ de un usuario IAM de AWS. (Haz clic aquí para aprender a crear un usuario IAM con ‘access_key’ & ‘secret_key’ en AWS)

Qué vamos a hacer

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

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

Crea un directorio dedicado en el que puedas crear archivos de configuración de Terraform.

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

mkdir terraform
cd terraform/

Estoy utilizando «vim» como editor para escribir en los archivos. Puedes utilizar un editor de tu elección y copiar y pegar las siguientes configuraciones para crear variables.tf, terraform.tfvars y main.tf

Crea ‘main.tf’, que es el responsable de crear la VPC en AWS con los recursos dependientes. Este main.tf leerá los valores de las variables desde 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
}
 

Crea ‘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"
}

Crea ‘terraform.tfvars’ que contiene la definición de las variables access_key y secret_key definidas en el archivo anterior. Hemos mantenido la declaración de estas dos variables en el archivo ‘terraform.tfvars’.

Es necesario cambiar las siguientes claves con las claves de tu usuario IAM.

vim terraform.tfvars
access_key = "AKIAQ6GAIA5XIHHM2GJM"
secret_key = "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"

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

Crea una VPC y otros recursos dependientes utilizando los archivos de configuración de Terraform

Antes de ejecutar los siguientes comandos, asegúrate de haber configurado la access_key y la secret_key válidas.

El primer comando a utilizar es ‘terraform init’. Este comando descarga e instala los plugins de los proveedores utilizados en la configuración. En nuestro caso, es AWS.

terraform init

El segundo comando a utilizar es «terraform plan». Este comando se utiliza para ver los cambios que se producirán en la infraestructura.

terraform plan

El comando «terraformar aplicar» creará los recursos en la AWS mencionados en el archivo main.tf. Se te pedirá que proporciones tus datos para crear los recursos.

terraform apply

Cuando ejecutes el comando anterior, podrás ver que se han añadido 20 recursos nuevos y se han destruido 0 en la salida.

Puedes ir a la consola de la VPC de AWS para comprobar si se ha creado la VPC junto con las subredes, las tablas de rutas, las puertas de enlace NAT y una puerta de enlace de Internet.

Eliminar la VPC creada y otros recursos dependientes mediante Terraform

Si ya no necesitas los recursos que creaste con la configuración mencionada en el archivo main.tf, puedes utilizar el comando «terraform destroy» para eliminar todos esos recursos.

terraform destroy

Cuando ejecutes el comando anterior, podrás ver que en la salida se destruyen los 20 recursos que se han creado. Puedes comprobarlo visitando AWS en el Panel de Control de la VPC.

Conclusión

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

También te podría gustar...