Concepto clave

En el mundo de la infraestructura como código, Terraform te permite definir y gestionar recursos de AWS de manera declarativa. Imagina que estás construyendo una casa: en lugar de contratar a diferentes trabajadores para cada parte (fontanero, electricista, albañil), escribes un plano detallado que especifica exactamente cómo debe ser cada componente. Terraform es ese plano para tu infraestructura cloud, donde S3 actúa como el almacén de objetos (como un garaje gigante para archivos) y RDS como la base de datos gestionada (similar a un archivador inteligente que se mantiene solo).

La clave aquí es la declaratividad: tú describes el estado deseado ("quiero un bucket S3 con cifrado y una instancia RDS MySQL"), y Terraform se encarga de hacerlo realidad, gestionando las dependencias y cambios de forma automática. Esto es fundamental para DevOps, ya que permite replicar entornos de desarrollo, staging y producción de manera idéntica, reduciendo errores humanos y acelerando despliegues.

Cómo funciona en la práctica

Para configurar almacenamiento con S3 y bases de datos RDS en AWS usando Terraform, sigues un flujo estructurado. Primero, defines los proveedores y configuraciones básicas en un archivo main.tf. Luego, creas recursos específicos: un bucket S3 para almacenar datos estáticos como logs o backups, y una instancia RDS para bases de datos relacionales como MySQL o PostgreSQL. Terraform calcula un plan de ejecución, mostrando qué se creará, modificará o destruirá, y al aplicar, provisiona los recursos en AWS.

Un ejemplo paso a paso: 1) Configura el proveedor AWS con credenciales, 2) Define un bucket S3 con propiedades como versionado y cifrado, 3) Define una instancia RDS con parámetros como motor, tamaño y almacenamiento, 4) Ejecuta terraform init, terraform plan y terraform apply. Esto crea recursos idénticos cada vez que se ejecuta, asegurando consistencia en entornos múltiples.

Código en acción

Aquí tienes un ejemplo funcional que configura un bucket S3 y una instancia RDS MySQL en AWS. Copia este código en un archivo main.tf y ajústalo con tus valores.

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

# Recurso para crear un bucket S3
resource "aws_s3_bucket" "mi_bucket" {
  bucket = "mi-bucket-unico-2023"
  acl    = "private"

  versioning {
    enabled = true
  }

  server_side_encryption_configuration {
    rule {
      apply_server_side_encryption_by_default {
        sse_algorithm = "AES256"
      }
    }
  }

  tags = {
    Name        = "MiBucket"
    Environment = "Dev"
  }
}

# Recurso para crear una instancia RDS MySQL
resource "aws_db_instance" "mi_base_datos" {
  identifier           = "midbinstance"
  engine              = "mysql"
  engine_version      = "5.7"
  instance_class      = "db.t3.micro"
  allocated_storage   = 20
  storage_type        = "gp2"
  username            = "admin"
  password            = "TuContrasenaSegura123"  # Usa variables o secretos en producción
  parameter_group_name = "default.mysql5.7"
  skip_final_snapshot = true
  publicly_accessible = false

  tags = {
    Name        = "MiRDS"
    Environment = "Dev"
  }
}

Antes de refactorizar, podrías tener configuraciones hardcodeadas. Después, mejora usando variables para mayor flexibilidad:

# variables.tf
variable "bucket_name" {
  description = "Nombre del bucket S3"
  type        = string
  default     = "mi-bucket-modular"
}

variable "db_password" {
  description = "Contraseña para la base de datos RDS"
  type        = string
  sensitive   = true
}

# main.tf actualizado
resource "aws_s3_bucket" "mi_bucket" {
  bucket = var.bucket_name
  # ... resto de configuración
}

resource "aws_db_instance" "mi_base_datos" {
  password = var.db_password
  # ... resto de configuración
}

Errores comunes

Olvidar el versionado en S3: Sin versionado, sobrescribes archivos accidentalmente. Siempre habilita versioning para recuperación de datos.
Configurar RDS como públicamente accesible: Esto expone tu base de datos a internet. Usa publicly_accessible = false y gestiona el acceso con grupos de seguridad.
Hardcodear credenciales en código: Nunca pongas contraseñas en texto plano. Usa variables de Terraform con sensitive = true o integra con AWS Secrets Manager.
Ignorar el cifrado en S3: Los datos en tránsito y en reposo deben cifrarse. Configura server_side_encryption_configuration para cumplir con estándares de seguridad.
No usar tags consistentes: Las etiquetas ayudan en gestión de costos y organización. Define un estándar de tagging y aplícalo en todos los recursos.

Checklist de dominio

¿Puedes crear un bucket S3 con Terraform que incluya versionado y cifrado?
¿Sabes configurar una instancia RDS con parámetros como engine, instance_class y storage_type?
¿Utilizas variables en Terraform para evitar hardcoding y mejorar reusabilidad?
¿Aplicas buenas prácticas de seguridad como deshabilitar acceso público y usar contraseñas sensibles?
¿Ejecutas terraform plan antes de apply para revisar cambios?
¿Gestionas el estado de Terraform remotamente (e.g., con S3 backend) para trabajo en equipo?
¿Entiendes cómo destruir recursos con terraform destroy sin afectar otros?

Despliega una infraestructura básica con S3 y RDS usando módulos de Terraform

Sigue estos pasos para crear una infraestructura repeatable en AWS que incluya un bucket S3 y una instancia RDS, utilizando módulos de Terraform para mejor organización.

Prepara tu entorno: Asegúrate de tener Terraform instalado y credenciales AWS configuradas (usando AWS CLI o variables de entorno).
Crea una estructura de directorios: Organiza tu proyecto en carpetas como modules/s3, modules/rds, y environments/dev.
Desarrolla módulos reusables: En modules/s3/main.tf, define un módulo para crear un bucket S3 con parámetros configurables como nombre, versionado y cifrado. Haz lo mismo en modules/rds/main.tf para RDS, incluyendo opciones como engine y instance_class.
Configura el entorno de desarrollo: En environments/dev/main.tf, llama a los módulos S3 y RDS, pasando valores específicos para el entorno dev (e.g., bucket_name = "dev-mi-bucket").
Ejecuta Terraform: Navega a environments/dev, ejecuta terraform init, terraform plan para revisar, y terraform apply para desplegar. Verifica en la consola AWS que los recursos se crearon correctamente.
Documenta y limpia: Anota los outputs como el endpoint de RDS, y luego ejecuta terraform destroy para eliminar los recursos y evitar costos innecesarios.

Pistas

Usa la documentación oficial de Terraform para AWS para ver ejemplos de módulos.
Considera usar un backend remoto en S3 para almacenar el estado de Terraform y permitir colaboración.
Prueba con valores pequeños en RDS (e.g., db.t3.micro) para minimizar costos durante el ejercicio.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Configurar Almacenamiento con S3 y Bases de Datos RDS