Saltar al contenido

Lección 6 de 20 · Lectura y práctica

Desplegar Instancias EC2 y Grupos de Seguridad

Concepto claveEn el mundo de la infraestructura como código, Terraform actúa como el arquitecto que diseña planos detallados para construir y mantener edificios (recursos cloud). Desplegar instancias EC2 y grupos de seguridad en.

Del concepto a la práctica

Taller de esta lección

Una instancia EC2 y su grupo de seguridad deben diseñarse juntos: la instancia necesita una subred y el grupo define qué tráfico puede llegar. Para un servidor web de laboratorio, permite HTTP desde el balanceador y SSH solo desde un rango administrativo autorizado; no conviertas SSH en acceso mundial.

Ejemplo resuelto

La regla de entrada web usa puerto 80 y origen del grupo del balanceador. La administración usa puerto 22 y CIDR 192.0.2.0/24, reservado aquí como dato documental. La salida puede mantenerse amplia en el prototipo, pero debe quedar registrada como decisión.

Pruébalo

  1. Crea el grupo en la VPC mediante referencia, no mediante un ID escrito a mano.

  2. Define las reglas de entrada con descripción y origen explícito.

  3. Asocia el grupo a una instancia en subred privada.

  4. Revisa el plan buscando puertos y CIDR inesperados.

Error frecuente: usar 0.0.0.0/0 para SSH por comodidad. Corrección: limitar el origen o usar un canal administrativo autorizado y documentado.

Ejercicio: entrega una matriz puerto, protocolo, origen y motivo.

Comprueba tu resultado

80 desde el grupo web, 22 desde 192.0.2.0/24 y ninguna regla administrativa abierta al mundo.

EC2 requiere subnet y conectividad administrativa

Un fragmento de cómputo revisado necesita cuatro entradas: ami_id string verificado para eu-west-1 y arquitectura elegida, subnet_id string de la subred privada, app_sg_id string del grupo y instance_type string compatible. La AMI histórica ami-0c55b159cbfafe1f0 no es una recomendación vigente ni trasladable entre regiones. Suponer IDs de ejemplo no permite desplegar.

hcl
variable "ami_id" { type = string }
variable "subnet_id" { type = string }
variable "app_sg_id" { type = string }
variable "instance_type" { type = string }
resource "aws_instance" "app" {
  ami = var.ami_id
  instance_type = var.instance_type
  subnet_id = var.subnet_id
  vpc_security_group_ids = [var.app_sg_id]
  associate_public_ip_address = false
  metadata_options {
    http_tokens = "required"
  }
  root_block_device {
    encrypted = true
  }
  tags = { Name = "reservas-dev-app" }
}

Usa el proveedor raíz de la lección1. El grupo se crea en la VPC correspondiente y admite80desde el grupo ALB; asignar solo su nombre puede seleccionar semánticas distintas del ID. El rango192.0.2.0/24 es documental: no abre administración desde una conexión real ni aporta ruta hacia una privada. Prefiere un canal aprobado como SSM con rol/endpoints o salida necesarios; si usas SSH, define camino y origen reales, sin abrirlo mundialmente. Una salida amplia se justifica por necesidad, no como requisito universal.

Capas de acceso, actualización, copias y respuesta a incidentes alrededor de un sistema.
CursaloMapa de práctica
La seguridad necesita varias capas

El control de acceso, las actualizaciones y las copias de seguridad cubren riesgos distintos. Una alerta necesita un procedimiento de respuesta para contener y recuperar el servicio. Varias capas reducen la exposición, pero ninguna garantiza seguridad absoluta.

Ver la infografía en tamaño completo ↗

Concepto clave

En el mundo de la infraestructura como código, Terraform actúa como el arquitecto que diseña planos detallados para construir y mantener edificios (recursos cloud). Desplegar instancias EC2 y grupos de seguridad en AWS es como construir una casa segura: necesitas definir la estructura (instancia) y las medidas de seguridad (grupo de seguridad) de manera precisa y repetible.

Imagina que eres un constructor que trabaja en múltiples proyectos. En lugar de dibujar planos a mano cada vez, usas plantillas digitales que garantizan que cada casa tenga las mismas características y cumpla con los códigos de construcción. Terraform hace lo mismo con tu infraestructura: define recursos como EC2 (servidores virtuales) y grupos de seguridad (firewalls) en archivos de configuración, permitiéndote recrear ententeros idénticos en cualquier momento.

Cómo funciona en la práctica

Para desplegar una instancia EC2 con Terraform, sigues un flujo estructurado que asegura consistencia. Primero, defines el proveedor AWS en tu archivo de configuración, especificando la región y credenciales. Luego, creas un grupo de seguridad que controle el tráfico de red hacia y desde tu instancia. Finalmente, defines la instancia EC2, asociándola al grupo de seguridad y configurando detalles como el tipo de instancia y la AMI (Amazon Machine Image).

Un ejemplo paso a paso incluye: 1) Inicializar Terraform con terraform init para descargar dependencias, 2) Planificar con terraform plan para revisar cambios, y 3) Aplicar con terraform apply para crear los recursos. Este proceso garantiza que cada despliegue sea predecible y evita errores manuales comunes en la consola de AWS.

Código en acción

Aquí tienes un ejemplo funcional que despliega una instancia EC2 con un grupo de seguridad básico. Este código es copiable y ejecutable en un entorno con Terraform configurado.

# Archivo: main.tf
provider "aws" {
  region = "us-east-1"
}

resource "aws_security_group" "web_sg" {
  name        = "web-security-group"
  description = "Permite tráfico HTTP y SSH"

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "aws_instance" "web_server" {
  ami           = "ami-0c55b159cbfafe1f0"  # Amazon Linux 2 AMI en us-east-1
  instance_type = "t2.micro"
  security_groups = [aws_security_group.web_sg.name]

  tags = {
    Name = "WebServerTerraform"
  }
}

Para mejorar este código y hacerlo más mantenible, puedes refactorizarlo usando variables. Aquí el antes y después:

Antes: Valores fijos en el código.

resource "aws_instance" "web_server" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

Después: Uso de variables para mayor flexibilidad.

variable "instance_type" {
  description = "Tipo de instancia EC2"
  default     = "t2.micro"
}

variable "ami_id" {
  description = "ID de la AMI"
  default     = "ami-0c55b159cbfafe1f0"
}

resource "aws_instance" "web_server" {
  ami           = var.ami_id
  instance_type = var.instance_type
}

Errores comunes

  • Olvidar definir egress en grupos de seguridad: Por defecto, Terraform no permite tráfico saliente si no se especifica. Esto puede bloquear conexiones necesarias. Siempre incluye una regla egress con protocolo "-1" para permitir todo el tráfico saliente, o define reglas específicas según tu caso.
  • Usar AMIs no disponibles en la región: Cada AMI es específica de una región AWS. Si usas un ID de AMI de us-west-2 en us-east-1, Terraform fallará. Verifica la AMI en la consola de AWS o usa data sources para buscarla dinámicamente.
  • No gestionar dependencias implícitas: Terraform crea recursos en paralelo cuando puede. Si una instancia EC2 depende de un grupo de seguridad, asegúrate de referenciarlo correctamente (como en security_groups = [aws_security_group.web_sg.name]) para que Terraform entienda el orden.
  • Ignorar el estado de Terraform: El archivo terraform.tfstate guarda el estado de tu infraestructura. No lo modifiques manualmente ni lo excluyas del control de versiones sin un backend remoto, ya que puede causar inconsistencias.
  • Sobreescribir tags manualmente: Si modificas tags de recursos en la consola de AWS, Terraform puede revertirlos en el próximo apply. Define todos los tags en la configuración para mantener el control.

Checklist de dominio

  1. Puedo escribir un archivo Terraform que despliegue una instancia EC2 con un grupo de seguridad personalizado.
  2. Sé cómo usar variables para hacer mi código más flexible y reutilizable.
  3. Entiendo la importancia de las reglas ingress y egress en grupos de seguridad y puedo configurarlas correctamente.
  4. Puedo ejecutar terraform init, plan, y apply sin errores para crear recursos en AWS.
  5. Reconozco y evito errores comunes como AMIs regionales o dependencias mal definidas.
  6. Sé cómo agregar tags a mis recursos para mejor organización y costeo.
  7. Puedo destruir recursos de manera segura usando terraform destroy cuando ya no son necesarios.

Despliega una instancia EC2 con un grupo de seguridad mejorado

En este ejercicio, crearás una instancia EC2 en AWS usando Terraform, con un grupo de seguridad que permita tráfico específico y use variables para personalización. Sigue estos pasos:

  1. Crea un nuevo directorio para tu proyecto Terraform y navega a él en tu terminal.
  2. Dentro del directorio, crea un archivo llamado main.tf y define el proveedor AWS para la región us-east-1.
  3. Define una variable llamada allowed_cidr con un valor por defecto de "192.168.1.0/24" para restringir el acceso SSH.
  4. Crea un recurso aws_security_group llamado app_sg que permita:
    • Entrada en el puerto 22 (SSH) solo desde la CIDR definida en la variable.
    • Entrada en el puerto 80 (HTTP) desde cualquier dirección (0.0.0.0/0).
    • Salida en todos los puertos hacia cualquier dirección.
  5. Crea un recurso aws_instance llamado app_server con:
    • AMI: ami-0c55b159cbfafe1f0 (Amazon Linux 2 en us-east-1).
    • Tipo de instancia: t2.micro.
    • Asociación al grupo de seguridad app_sg.
    • Un tag Name con valor "AppServerExercise".
  6. Ejecuta terraform init para inicializar el proyecto.
  7. Ejecuta terraform plan para revisar los recursos a crear y asegúrate de que no haya errores.
  8. Ejecuta terraform apply y confirma con yes para desplegar la infraestructura.
  9. Verifica en la consola de AWS que la instancia EC2 y el grupo de seguridad se hayan creado correctamente.
Pistas
  • Recuerda que las variables en Terraform se definen con un bloque 'variable' y se referencian con 'var.nombre_variable'.
  • Asegurate de que las reglas ingress usen 'cidr_blocks' con la variable para SSH y un valor fijo para HTTP.
  • Si encuentras errores en 'terraform plan', revisa la sintaxis HCL y la disponibilidad de la AMI en la region especificada.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Sigue con Terraform en AWS: Infraestructura como Código para DevOps

Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.

Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.

01 / ELEGIR UNA RUTA

El próximo paso

Aprende IA mientras construyes algo que sí necesitas.

Empieza por el curso inicial o explora el catálogo para encontrar una práctica alineada con tu trabajo.