Concepto clave

En el mundo de la infraestructura cloud, una VPC (Virtual Private Cloud) es como el plano arquitectónico de tu propio centro de datos virtual dentro de AWS. Imagina que estás construyendo un edificio: la VPC define los límites de tu propiedad, mientras que las subredes son las habitaciones específicas dentro de ese edificio. Cada habitación tiene un propósito diferente (oficinas, salas de servidores, áreas públicas) y reglas de acceso específicas.

Con Terraform, no solo dibujas este plano una vez, sino que creas un blueprint reutilizable que puedes versionar, compartir y aplicar consistentemente. Esto elimina los errores manuales de configuración y permite replicar entornos idénticos para desarrollo, staging y producción. La magia está en que tu código describe el estado deseado, y Terraform se encarga de hacerlo realidad.

Cómo funciona en la práctica

El proceso sigue un flujo predecible que se convierte en rutina para cualquier DevOps Engineer. Primero, defines tus recursos en archivos .tf usando la sintaxis HCL de Terraform. Luego, ejecutas terraform init para preparar tu entorno, seguido de terraform plan para ver qué cambios se aplicarán. Finalmente, terraform apply despliega todo en AWS.

Para nuestra VPC, comenzaremos con una red principal de 10.0.0.0/16 (eso son 65,536 direcciones IP disponibles). Dentro de ella, crearemos dos subredes públicas (10.0.1.0/24 y 10.0.2.0/24) para recursos accesibles desde internet, y dos privadas (10.0.3.0/24 y 10.0.4.0/24) para bases de datos y servicios internos. Cada subred residirá en una zona de disponibilidad diferente para garantizar alta disponibilidad.

Código en acción

Aquí tienes el archivo principal main.tf que define nuestra infraestructura básica:

# Configuración del proveedor AWS
provider "aws" {
  region = "us-east-1"
}

# Creación de la VPC
resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true
  
  tags = {
    Name = "vpc-produccion"
    Env  = "produccion"
  }
}

# Creación de subred pública en us-east-1a
resource "aws_subnet" "public_1a" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.1.0/24"
  availability_zone       = "us-east-1a"
  map_public_ip_on_launch = true
  
  tags = {
    Name = "subnet-publica-1a"
    Tipo = "publica"
  }
}

# Creación de subred pública en us-east-1b
resource "aws_subnet" "public_1b" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.2.0/24"
  availability_zone       = "us-east-1b"
  map_public_ip_on_launch = true
  
  tags = {
    Name = "subnet-publica-1b"
    Tipo = "publica"
  }
}

Ahora, mejoramos nuestro código agregando un archivo variables.tf para hacerlo más reutilizable:

# Antes: valores hardcodeados
# resource "aws_vpc" "main" {
#   cidr_block = "10.0.0.0/16"
# }

# Después: usando variables
variable "vpc_cidr" {
  description = "CIDR block para la VPC"
  type        = string
  default     = "10.0.0.0/16"
}

variable "environment" {
  description = "Entorno de despliegue"
  type        = string
  default     = "produccion"
}

# Actualización del recurso VPC
resource "aws_vpc" "main" {
  cidr_block           = var.vpc_cidr
  enable_dns_hostnames = true
  enable_dns_support   = true
  
  tags = {
    Name = "vpc-${var.environment}"
    Env  = var.environment
  }
}

Errores comunes

Solapamiento de CIDR blocks: Intentar crear una VPC con un rango IP que ya existe en tu cuenta AWS. Siempre verifica tus redes existentes antes de desplegar.
Olvidar habilitar DNS: Sin enable_dns_support = true, las instancias EC2 no podrán resolver nombres internos de AWS.
Tags inconsistentes: No etiquetar recursos correctamente dificulta la gestión de costos y la identificación en la consola AWS.
Subredes demasiado pequeñas: Usar máscaras como /28 (16 direcciones) limita el crecimiento futuro. Planifica con margen.
No versionar el estado de Terraform: Guardar el archivo terraform.tfstate localmente sin respaldo puede causar pérdida de estado.

Checklist de dominio

Puedo explicar la diferencia entre subredes públicas y privadas en una VPC de AWS.
Sé cómo configurar el proveedor AWS en Terraform con credenciales seguras.
He creado una VPC con al menos dos subredes en diferentes zonas de disponibilidad.
Utilizo variables en Terraform para hacer mi código reutilizable entre entornos.
Verifico los cambios con terraform plan antes de aplicar.
Etiqueto todos mis recursos siguiendo un estándar de nomenclatura.
Configuro un backend remoto (como S3) para almacenar el estado de Terraform.

Despliega una VPC con subredes públicas y privadas en AWS

En este ejercicio práctico, crearás una infraestructura de red completa en AWS usando Terraform. Sigue estos pasos:

Configura tu entorno: Asegúrate de tener Terraform instalado y credenciales AWS configuradas (via AWS CLI o variables de entorno).
Crea la estructura de archivos:
- main.tf - Recursos principales
- variables.tf - Variables reutilizables
- outputs.tf - Valores de salida útiles
Define la VPC: Crea una VPC con CIDR block 192.168.0.0/16 en la región us-east-1.
Crea subredes:
- Dos subredes públicas en us-east-1a y us-east-1b con CIDR 192.168.1.0/24 y 192.168.2.0/24
- Dos subredes privadas en las mismas zonas con CIDR 192.168.3.0/24 y 192.168.4.0/24
- Habilita IP pública automática solo para las subredes públicas
Agrega tags: Etiqueta todos los recursos con:
- Name: según el tipo de recurso
- Project: terraform-vpc-lab
- ManagedBy: terraform
Ejecuta el despliegue:
1. terraform init
2. terraform plan (revisa los cambios)
3. terraform apply (confirma con 'yes')
Verifica: Revisa en la consola AWS que la VPC y subredes se crearon correctamente.

Pistas

Usa el bloque 'provider' al inicio de main.tf para especificar la región
Recuerda que map_public_ip_on_launch solo debe ser true para subredes públicas
Puedes usar aws_vpc.main.id como referencia para el parámetro vpc_id en las subredes

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Ejercicio Práctico: Desplegar una VPC con Subredes en AWS