Terraform IAM: roles y policies automáticos

Configura en minutos una base sólida de infraestructura como código en AWS con Terraform, módulos IAM, policies, roles y estado remoto en S3. Aprenderás a estructurar carpetas, crear policies en json, conectar módulos con outputs y ejecutar los comandos clave: init, fmt, plan y apply. Resultado: un rol con permisos para RDS y logs en CloudWatch listo para tus funciones Lambda.

¿Cómo preparar el entorno con Make y Terraform?

Para automatizar y versionar la infraestructura se usan infraestructura como código, Make y Terraform. La verificación y la instalación correcta evitan fallos al ejecutar los planes.

¿Qué herramientas instalar y cómo verificar la instalación?

• Instala Make en Mac o Linux por defecto. En Windows: instalar manualmente.
• Verifica que quedó instalado: make --version.
• Descarga Terraform desde su landing para Mac, Windows o Linux.

¿Cómo organizar la carpeta infra y el backend en S3?

• En la raíz del proyecto crea una carpeta: infra o terraform.
• Dentro vivirá todo: módulos, policies, roles y archivos .tf.
• Configura el backend en S3 para guardar el estado remoto: bucket platzi-tf-security, key predeterminada terraform.tfstate, región us-east-2 (Ohio).

terraform {
  backend "s3" {
    bucket = "platzi-tf-security"
    key    = "terraform.tfstate"
    region = "us-east-2"
  }
}

• Define que trabajarás con AWS y usa la región más cercana a ti.

¿Cómo modelar IAM con módulos, policies y roles en Terraform?

La sintaxis de Terraform “trae” valores de afuera hacia adentro y los referencia por nombre. Usa módulos para separar responsabilidades: iam/policies y iam/roles.

¿Cómo definir policies en json para RDS y logs?

• Crea dos policies: una para acceso a RDS y otra para logs en CloudWatch.
• Usa un recurso aws_iam_policy con jsonencode y genera el json con el AWS Policy Generator.

# policies/can_access_rds.tf
resource "aws_iam_policy" "can_access_RDS" {
  name        = "can_access_RDS"
  path        = "/"
  description = "Databases for queries."
  policy = jsonencode({
    Version = "2012-10-17",
    Statement = [{
      Effect   = "Allow",
      Action   = [/* acciones de RDS */],
      Resource = "*"
    }]
  })
}

output "can_access_RDS_arn" {
  value = aws_iam_policy.can_access_RDS.arn
}

# policies/can_log.tf
resource "aws_iam_policy" "can_log" {
  name        = "can_log"
  path        = "/"
  description = "Allow logs to CloudWatch."
  policy = jsonencode({
    Version = "2012-10-17",
    Statement = [{
      Effect = "Allow",
      Action = [
        "logs:CreateLogGroup",
        "logs:CreateLogStream",
        "logs:PutLogEvents"
      ],
      Resource = "*"
    }]
  })
}

output "can_log_arn" {
  value = aws_iam_policy.can_log.arn
}

• Habilidades y conceptos aplicados: definición de recursos aws_iam_policy, uso de jsonencode, diseño de permisos con efecto Allow, acciones y resource, y exposición de ARNs con outputs.

¿Cómo crear el rol RepoCollectorPlatzi y pasar ARNs entre módulos?

• En iam/roles, define variables para recibir los ARNs: RDSpolicy_arn y logPolicy_arn.
• Crea el rol RepoCollectorPlatzi con su documento de asunción.

# roles/vars.tf
variable "RDSpolicy_arn" { type = string }
variable "logPolicy_arn" { type = string }

# roles/role.tf
data "aws_iam_policy_document" "assume_role" {
  # documento para asumir el rol (Lambda u otro servicio)
}

resource "aws_iam_role" "RepoCollectorPlatzi" {
  name               = "RepoCollectorPlatzi"
  assume_role_policy = data.aws_iam_policy_document.assume_role.json
}

# adjunta las policies usando los ARNs recibidos por variables
# (recurso de attachment según corresponda)

output "repo_collector_role_arn" {
  value = aws_iam_role.RepoCollectorPlatzi.arn
}

• Conecta los módulos en main.tf para pasar ARNs de policies al módulo de roles y exponer el output del rol:

module "policies" {
  source = "./iam/policies"
}

module "roles" {
  source         = "./iam/roles"
  RDSpolicy_arn  = module.policies.can_access_RDS_arn
  logPolicy_arn  = module.policies.can_log_arn
}

output "repo_collector_role_arn" {
  value = module.roles.repo_collector_role_arn
}

¿Cómo ejecutar terraform init, plan y apply para desplegar en AWS?

Una vez creados los archivos, inicializa, formatea, valida el plan y aplica los cambios. Si el plan no muestra cambios, revisa que el main.tf importe los módulos.

¿Qué hace cada comando y cómo interpretar el plan?

• terraform init: inicializa módulos y estado en S3.
• terraform fmt -recursive: formatea archivos .tf.
• terraform plan: muestra qué creará, cambiará o borrará, sin ejecutar.
• terraform apply: aplica el plan y solicita confirmación con yes.

terraform init
terraform fmt -recursive
terraform plan
terraform apply

• Expectativa del plan: crear 2 policies (RDS y logs) y 1 rol RepoCollectorPlatzi con las policies adjuntas.

¿Cómo validar en IAM que se creó todo?

• En la consola de AWS IAM: verifica el rol RepoCollectorPlatzi.
• Revisa que tenga adjuntas las policies can_access_RDS y can_log.
• Abre cada policy para confirmar el json de permisos.

¿Tienes dudas sobre la estructura de módulos, el backend en S3 o las policies en json? Cuéntame en los comentarios qué parte te gustaría profundizar.