Terraform

Conceptos base y ecosistema

  • IInfraestructura como codigo
  • devops
  • cloud
  • Automatizacion
  • Aws
  • GCP Google cloud
  • Terraform permite definir, versionar y desplegar infraestructura mediante archivos declarativos
  • Lenguajes soportados:
    • HCL (HashiCorp Configuration Language) como estándar
    • JSON como alternativa menos legible
  • Enfoque declarativo:
    • Se define el estado deseado
    • Terraform calcula el delta entre estado actual y deseado

Casos de uso y ejemplos

  • Gestión de recursos de proveedores cloud
    • Máquinas virtuales, almacenamiento, bases de datos, IAM
  • Redes y seguridad
    • Redes privadas (VPC/VNet)
    • Subredes públicas y privadas
    • Reglas de firewall y security groups
  • Balanceo de carga
    • Load balancers para distribuir tráfico entre instancias
  • Gestión de entornos híbridos
    • Infraestructura local + cloud
    • Conexión de red on-premise con VPC de AWS
  • DNS y routing
    • Gestión de DNS con Route53 o Cloudflare
  • Automatización de despliegues
    • Integración con GitLab CI/CD o GitHub Actions
    • Infraestructura desplegada como parte de pipelines
  • Contenedores y orquestación
    • Implementación de clústeres Kubernetes
    • EKS (AWS), AKS (Azure), GKE (GCP)

Infraestructura mutable vs inmutable

  • Infraestructura mutable
    • Cambios aplicados directamente sobre recursos existentes
    • Herramientas típicas: Ansible, Puppet
  • Infraestructura inmutable
    • Recursos se reemplazan en lugar de modificarse
    • Mayor trazabilidad y consistencia
  • Versionado y migraciones
    • Control de cambios mediante Git
    • Rollback sencillo a versiones previas

      Configuración vs estado

  • Configuración
    • Archivos .tf que definen recursos deseados
  • Estado (state)
    • Archivo que refleja la infraestructura real
    • Puede contener información sensible
  • Backend de estado
    • Local (por defecto)
    • Backend cloud (recomendado en equipos)
      • Terraform Cloud / Enterprise
      • S3 + DynamoDB (AWS)
    • Control de bloqueos y concurrencia
  • Gestión de apply
    • Evitar ejecuciones simultáneas
    • Auditoría de cambios

Planificación y aplicación

  • terraform plan
    • Simula los cambios sin aplicarlos
    • Muestra:
      • values
      • instance_type
      • ami
      • arn, id, IPs
    • Detecta diferencias entre AWS y el estado de Terraform
  • terraform apply
    • Aplica los cambios calculados
    • Opción de corrección directa:
      • terraform apply -auto-approve

Integración con on-premise

  • Interacción con infraestructura local
    • Cisco Intersight (ITS)
    • Conectores híbridos
  • Casos habituales
    • Extensión de red local a la nube
    • Gestión centralizada de recursos

Documentación y recursos

Pasos básicos de trabajo

Comandos principales

Inicialización y formato

terraform init
terraform fmt

`

Planificación

terraform plan

Aplicación y destrucción

terraform apply
terraform destroy
terraform apply -auto-approve

Configuración inicial de proyecto

  • Archivos base
    • main.tf
    • vars.tf
  • Provider
    • Definición del proveedor cloud
    • Uso de credenciales por variables o entorno
  • Variables
    • Uso de .tfvars
      • terraform apply -var-file=vars.tfvars
      • -var
      • -var-file
      • .auto.tfvars o auto.tfvars.json
  • Variables locales
    • Constructor de objetos locales
      • Ejemplo: extra_tag = "extra_tag"

Recursos y outputs

  • Definición de recursos
    • resource
  • Outputs
    • Mostrar IPs y datos relevantes
output "instance_ip_addr" {
	value = aws_instance.example.private_ip
}

Creación de instancias EC2 en AWS

  • Recursos EC2
    • Definición de AMI, tipo de instancia y tags
  • Uso de funciones y bucles
    • for_each para múltiples instancias
    • Interpolación de claves
tags = {
	Name = "EC2-${each.key}"
	ExtraTag = local.extra_tagName
}

Integración con CloudWatch

  • Creación de recursos adicionales
resource "aws_cloudwatch_log_group" "ec2_log_group" {
	tags = {
		Environment = "test"
		Service = each.key
	}
}

Output de logs y direcciones

output "ec2_private_ips" {
	value = {
		for service, i in aws_instance.example :
		service => i.private_ip
	}
}

Uso de módulos: VPC y Security Groups

  • Registro oficial
  • Ventajas de módulos
    • Reutilización
    • Código más limpio
    • Buenas prácticas integradas
  • Configuración de networking
module "vpc" {
	source = "terraform-aws-modules/vpc/aws"
}

module "terraform-sg" {
	source = "terraform-aws-modules/security-group/aws"
	vpc_id = module.vpc.vpc_id
}

Referencia de módulos en recursos

resource "aws_instance" "example" {
	subnet_id = module.vpc.public_subnets[0]
	vpc_security_group_ids = [module.terraform-sg.security_group_id]
}

Workspaces y diseño de código

  • Uso de workspaces
    • Separación lógica de entornos
    • dev, prod, test
  • Comandos
terraform workspace list
terraform workspace new prod
terraform workspace select default

Lógica condicional por entorno

resource "aws_instance" "example" {
	count = terraform.workspace == "prod" ? 2 : 1

	tags = {
		env  = terraform.workspace
		Name = format("%s-%s", terraform.workspace, count.index)
	}
}

`

Ejemplos de app web con Aws

Arquitectura base

  • Aplicación web simple sobre instancia EC2 t3_micro
  • Servidor web nginx
  • Despliegue automatizado con Terraform
  • Acceso remoto mediante ssh
  • Red aislada mediante VPC

EC2 con Nginx usando user_data

  • Instalación automática de Nginx
  • Uso de user_data en el recurso aws_instance
  • Script bash ejecutado al iniciar la instancia

Script user_data (bash)

#!/bin/bash
yum update -y
amazon-linux-extras install nginx1 -y
systemctl start nginx
systemctl enable nginx

`

Red y seguridad

  • Uso de VPC dedicada
  • Puertos abiertos:
    • 80 (HTTP)
    • 22 (SSH)
  • Acceso permitido desde 0.0.0.0/0 (solo para pruebas)

Gestión de claves SSH

  • Generar par de claves
ssh-keygen -t rsa 2048 -f "nginx-server.key"
  • Subir clave pública a AWS
  • Uso del recurso aws_key_pair

Recurso aws_key_pair

resource "aws_key_pair" "nginx-server-ssh" {
	key_name   = "nginx-server-key"
	public_key = file("nginx-server.key.pub")
}

Security Group

  • Definición de reglas de entrada y salida
  • Asociación a la VPC
  • Asignación del security group a la instancia

Recurso aws_security_group

resource "aws_security_group" "nginx-server-sg" {
	name   = "nginx-server-sg"
	vpc_id = aws_vpc.main.id

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

	ingress {
		from_port   = 80
		to_port     = 80
		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"]
	}
}

Asociación del SG a la instancia

vpc_security_group_ids = [aws_security_group.nginx-server-sg.id]

Tags y metadatos

  • Uso de variables como objeto de tags
  • Identificación clara del entorno y recurso

Tags en recursos

tags = {
	Name        = var.server_name
	Environment = var.environment
}

Outputs y verificación

  • Visualización de información tras el despliegue
  • Uso de terraform output

Outputs definidos

output "server_public_ip" {
	value = aws_instance.nginx-server.public_ip
}

output "server_public_dns" {
	value = aws_instance.nginx-server.public_dns
}

Pruebas de acceso

  • Probar servidor web
curl http://<public_ip>
  • Conexión SSH
ssh ec2-user@3.232.132.177 -i ./nginx-server.key

Variables y entornos

  • Variables con valores por defecto
  • Separación por entorno: dev, qa, prod
  • Archivos:
    • variables.tf
    • terraform.tfvars

Variable de ejemplo

variable "server_name" {
	type    = string
	default = "nginx-server"
}

Uso de módulos

  • Reutilización de código
  • Mismo módulo para distintos entornos
  • Diferentes claves SSH por entorno
  • Outputs expuestos por módulo

Output desde módulo

value = module.nginx_server_dev.server_public_ip

Gestión de estado (tf state)

  • Colaboración en equipos
  • Almacenamiento remoto en Backend
  • Uso de buckets S3 en Aws

Planes en pipelines CI/CD

  • Guardar plan para revisión
terraform plan -out server_qa.tfplan
  • Integración con CICD

Importación de infraestructura existente

  • Importar recursos creados manualmente en AWS
  • Ejemplo: instancia EC2 existente

Importar recurso

terraform import aws_instance.server-web i-23234235fdg

Recurso vacío inicial

resource "aws_instance" "server-web" {}

Inspección del estado

terraform state show aws_instance.server-web
  • Copiar propiedades al recurso:
    • ami
    • instance_type
    • tags
    • vpc_security_group_ids

AWS CLI

  • Uso de Aws CLI
  • Configuración inicial
aws configure

Ciclo de vida de recursos

  • Inicialización de plugins con terraform init
  • Creación con plan
  • Aplicación con apply
  • Verificación desde el panel de AWS

Terraform con Aws y Docker

Terraform como imagen Docker

Buckets S3

  • Almacenamiento de artifacts
  • Almacenamiento del estado Terraform

Recursos S3

resource "aws_s3_bucket" "codepipeline_artifacts" {}
resource "aws_s3_bucket" "terraformstate" {}

Makefile y automatización

  • Uso de bash y Makefile
  • Ejecución de Terraform en Docker
  • Gestión de variables de entorno

Comando de ejemplo

make apply

Backend remoto y provider

Configuración de backend S3

backend "s3" {
	bucket = "es3"
}

Provider AWS

provider "aws" {
	region = "eu-west-1"
}

Docker Compose

  • Volumen compartido /infra
  • Persistencia de estado y configuraciones

Credenciales IAM Gestión de Identidades y Acceso

  • Uso de roles y policies
  • Acceso mínimo necesario
  • Integración con CI/CD
  • Compatibilidad con jenkins

Terraform – conceptos avanzados y temas no cubiertos

Fuentes de datos (data sources)

  • Permiten leer información existente sin crear recursos
  • Casos comunes:
    • Obtener AMIs oficiales o custom
    • Consultar VPCs, subredes o security groups existentes
  • Diferencia clave:
    • resource crea o gestiona
    • data solo consulta

Uso típico

data "aws_ami" "amazon_linux" {
	most_recent = true
	owners      = ["amazon"]
}

`

Dependencias explícitas

  • Terraform infiere dependencias por referencias
  • En casos complejos se usa depends_on
  • Útil cuando:
    • Recursos externos
    • Scripts o side-effects no detectables

Ejemplo

depends_on = [aws_security_group.nginx-server-sg]

Ciclo de vida de recursos

  • Control del comportamiento ante cambios
  • Prevención de errores en producción

lifecycle

lifecycle {
	prevent_destroy = true
	create_before_destroy = true
}
  • prevent_destroy
    • Evita borrados accidentales
  • create_before_destroy
    • Minimiza downtime

Bloques dinámicos

  • Generación dinámica de configuraciones repetitivas
  • Ideal para:
    • Reglas de firewall
    • Configuraciones variables

dynamic block

dynamic "ingress" {
	for_each = var.ingress_rules
	content {
		from_port   = ingress.value.port
		to_port     = ingress.value.port
		protocol    = "tcp"
		cidr_blocks = ingress.value.cidr
	}
}

Locals avanzados

  • Centralizan lógica de negocio
  • Reducen duplicación
  • Permiten expresiones complejas

locals

locals {
	env_prefix = "${var.project}-${var.environment}"
	common_tags = {
		Project = var.project
		Env     = var.environment
	}
}

IAM Roles para EC2

  • Alternativa segura a access keys
  • Uso recomendado en producción
  • Integración con servicios AWS
  • Ventajas:
    • No credenciales hardcodeadas
    • Rotación automática
    • Menor superficie de ataque

TLS, HTTPS y certificados

  • Uso de AWS ACM
  • Integración con:
    • Load Balancer
    • CloudFront
  • Automatización completa del ciclo TLS

    Load Balancer y Auto Scaling

  • Arquitecturas escalables y resilientes
  • Componentes:
    • ALB / NLB
    • Auto Scaling Group
    • Launch Templates
  • Casos de uso:
    • Alta disponibilidad
    • Escalado automático
    • Zero-downtime deployments

DNS y enrutamiento avanzado

  • Integración con Route53
  • Gestión de:
    • Registros A / CNAME
    • Alias a ALB
  • Infraestructura declarativa de DNS

Imágenes inmutables (AMI baking)

  • Crear AMIs preconfiguradas
  • Flujo recomendado:
    • Packer + Terraform
  • Beneficios: * Arranque más rápido * Menos lógica en user_data * Mayor reproducibilidad

Provisioners (uso limitado)

  • remote-exec
  • file
  • Considerados último recurso
  • Riesgos:
    • No idempotentes
    • Dependientes de red
  • Recomendación:
    • Usar AMIs o herramientas de configuración externas

      Testing y calidad de infraestructura

  • Validaciones:
    • terraform validate
    • terraform fmt
  • Testing:
    • terraform test
  • Linting:
    • tflint
    • tfsec

Seguridad y buenas prácticas

  • No subir terraform.tfstate a repositorios
  • Uso de:
    • Backends remotos cifrados
    • Secrets Manager
    • Variables sensibles

sensitive outputs

output "db_password" {
	value     = var.db_password
	sensitive = true
}

Gestión de costes

  • Etiquetado obligatorio
  • Uso de terraform plan para estimar impacto

  • Integración con:

    • AWS Cost Explorer
    • Presupuestos por entorno

Drift detection

  • Detección de cambios manuales en cloud
  • terraform plan como herramienta de auditoría
  • Importante en entornos compartidos

Destrucción controlada

  • Separación clara de entornos
  • Uso de workspaces o cuentas distintas
  • Protección de recursos críticos

Escalado organizativo

  • Terraform Cloud / Enterprise
  • Features clave:
    • Remote runs
    • Policy as Code (Sentinel)
    • Control de acceso por equipos

Integración con otras herramientas

Casos de uso empresariales

  • Landing zones
  • Multi-account AWS
  • Infraestructura regulada
  • Auditoría y compliance automatizado

Recursos Terraform (estado 2025)

Documentación y tutoriales oficiales

  • Terraform Tutorials – HashiCorp Developer
    Colección de tutoriales paso a paso para múltiples proveedores y casos de uso, incluyendo AWS, Azure, GCP y Docker.
    Terraform Tutorials

  • Terraform AWS Get Started – HashiCorp Developer
    Tutorial interactivo completo para crear, gestionar y destruir infraestructura AWS con Terraform.
    Terraform AWS Get Started

Guías y artículos actualizados

  • Terraform on AWS — The Most Complete Beginner Guide for 2025
    Guía reciente que cubre fundamentos, estructura de proyectos, módulos, estado remoto y buenas prácticas actuales.
    Terraform on AWS 2025

  • Terraform Tutorial for Beginners 2025
    Guía actualizada para principiantes con los conceptos esenciales y primeros pasos en Terraform.
    Terraform Beginners Guide 2025

  • Complete Terraform Guide (BuzzClan, 2025)
    Visión global de Terraform IaC, ciclo de vida, estado, módulos y uso empresarial.
    Complete Terraform Guide

Libros y cursos recomendados

  • Terraform YouTube & Video Playlists (2025 Edition)
    Curso completo en vídeo desde nivel básico hasta avanzado con ejemplos prácticos.
    Terraform Playlist

  • Tutorials en YouTube sobre IaC con Terraform (2025)
    Guías prácticas centradas en casos reales y buenas prácticas actuales.
    Terraform IaC YouTube

Versiones y estado del software

  • Terraform (software)
    Herramienta IaC desarrollada por HashiCorp en Go.
    Estado a 2025: versión estable Terraform v1.14.x.
    Terraform – Wikipedia

Buenas prácticas y guías prescriptivas

  • AWS Guía prescriptiva – Terraform AWS Provider Best Practices
    Recomendaciones oficiales de AWS para el uso de Terraform con AWS: módulos, versiones, estado remoto y seguridad IAM.
    Terraform AWS Provider Best Practices

  • HashiCorp Module Creation Patterns
    Patrones recomendados para crear módulos reutilizables y mantenibles.
    Terraform Module Creation Patterns

Investigación y tendencias

IaC y automatización con IA

  • Multi-Agent Code-Orchestrated Generation for Reliable IaC (2025)
    Investigación sobre generación de IaC modular y gobernada por políticas usando múltiples agentes de IA.
    arXiv – Multi-Agent IaC

  • IaC Generation with LLMs: Error Taxonomy and Configuration Knowledge Injection
    Estudio sobre errores comunes en IaC generado por LLMs y técnicas para mejorar Terraform generado por IA.
    arXiv – IaC Generation with LLMs

Calidad y sostenibilidad en IaC

  • Smells-sus: Sustainability Smells in IaC (2025)
    Investigación sobre patrones de IaC que impactan en costes y sostenibilidad.
    arXiv – Sustainability Smells in IaC

  • Multi-IaC-Eval: Benchmarking Cloud IaC Across Formats (2025)
    Benchmark para evaluar IaC en distintos formatos, incluyendo Terraform.
    arXiv – Multi-IaC-Eval

Proyectos alternativos y ecosistema

  • OpenTofu
    Proyecto open-source bajo la Linux Foundation como alternativa compatible con Terraform.
    OpenTofu

Recursos adicionales

Herramientas complementarias para Terraform

  • Validación y seguridad
    • TFLint
    • tfsec
    • Checkov

Integración y colaboración

  • Estado remoto
    • S3 + DynamoDB
    • Terraform Cloud / Enterprise
  • CI/CD
    • GitHub Actions
    • GitLab CI/CD
    • Pipelines automatizados

Repositorios útiles

Canales de aprendizaje rápido

  • Comunidad HashiCorp Discuss
  • Meetups y grupos DevOps
  • Blogs técnicos centrados en IaC y Terraform

Terraform – explicación con ejemplos de código

Estructura básica de un proyecto Terraform

  • Un proyecto Terraform se compone de archivos .tf
  • No importa el orden de los archivos
  • Terraform carga todo el directorio como una única configuración

Estructura típica:

  • main.tf → recursos principales
  • providers.tf → proveedores
  • variables.tf → definición de variables
  • outputs.tf → valores de salida
  • backend.tf → estado remoto

Provider

  • Define el proveedor cloud o servicio externo
  • Gestiona autenticación y región

Provider AWS

provider "aws" {
	region = "eu-west-1"
}

`

Recursos (resource)

  • Representan infraestructura real
  • Cada recurso tiene:
    • tipo
    • nombre lógico
    • configuración

Recurso EC2 básico

resource "aws_instance" "web" {
	ami           = "ami-0abcdef1234567890"
	instance_type = "t3.micro"
}

Variables

  • Permiten reutilizar código
  • Evitan valores hardcodeados
  • Se pueden sobreescribir por entorno

Definición de variable

variable "instance_type" {
	type    = string
	default = "t3.micro"
}

Uso de variable

instance_type = var.instance_type

Variables por entorno (.tfvars)

  • Separan configuraciones dev, qa, prod
  • Se cargan automáticamente o por CLI

Archivo dev.tfvars

instance_type = "t3.micro"

Aplicar variables

terraform apply -var-file=dev.tfvars

Variables locales (locals)

  • Lógica reutilizable dentro del proyecto
  • Ideal para tags y nombres compuestos

locals

locals {
	name_prefix = "${var.project}-${var.environment}"
}

Tags

  • Clave para costes, auditoría y organización
  • Buenas prácticas en AWS

Tags comunes

tags = {
	Name        = local.name_prefix
	Environment = var.environment
}

Outputs

  • Devuelven información útil tras el despliegue
  • Usados por humanos o por otros módulos

Output de IP pública

output "public_ip" {
	value = aws_instance.web.public_ip
}

Data sources

  • Consultan recursos existentes
  • No crean infraestructura

Obtener AMI más reciente

data "aws_ami" "amazon_linux" {
	most_recent = true
	owners      = ["amazon"]
}

Uso del data source

ami = data.aws_ami.amazon_linux.id

user_data

  • Script ejecutado al arrancar la instancia
  • Ideal para bootstrap básico

user_data con Nginx

user_data = <<EOF
#!/bin/bash
yum install -y nginx
systemctl start nginx
systemctl enable nginx
EOF

Security Groups

  • Controlan tráfico de red
  • Reglas ingress y egress

Security Group básico

resource "aws_security_group" "web_sg" {
	name = "web-sg"

	ingress {
		from_port   = 80
		to_port     = 80
		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"]
	}
}

Dependencias

  • Terraform infiere dependencias automáticamente
  • depends_on fuerza el orden cuando es necesario

depends_on

depends_on = [aws_security_group.web_sg]

Bucles y for_each

  • Permiten crear múltiples recursos dinámicamente

Crear varias instancias

resource "aws_instance" "servers" {
	for_each = var.servers

	ami           = each.value.ami
	instance_type = each.value.type
	tags = {
		Name = each.key
	}
}

Condiciones

  • Cambian comportamiento según entorno

count condicional

count = var.environment == "prod" ? 2 : 1

Módulos

  • Agrupan recursos reutilizables
  • Aumentan mantenibilidad y escalabilidad

Llamada a módulo

module "web_server" {
	source        = "./modules/web"
	instance_type = "t3.micro"
}

Outputs en módulos

  • Exponen información del módulo al root

Output en módulo

output "server_ip" {
	value = aws_instance.web.public_ip
}

Backend remoto

  • Permite colaboración en equipo
  • Evita conflictos de estado

Backend S3

terraform {
	backend "s3" {
		bucket = "terraform-states"
		key    = "web/terraform.tfstate"
		region = "eu-west-1"
	}
}

Workspaces

  • Separan entornos lógicos
  • Usan el mismo código

Uso de workspace

terraform workspace new prod
terraform workspace select prod

Uso en código

tags = {
	Environment = terraform.workspace
}

lifecycle

  • Controla cómo se crean o destruyen recursos

lifecycle

lifecycle {
	prevent_destroy = true
	create_before_destroy = true
}

Importar infraestructura existente

  • Permite adoptar recursos manuales

Import

terraform import aws_instance.legacy i-0123456789abcdef0

Plan y apply

  • plan muestra cambios
  • apply los ejecuta

Guardar plan

terraform plan -out=tfplan
terraform apply tfplan

Buenas prácticas

  • Un módulo por responsabilidad
  • Variables explícitas
  • Estado remoto siempre
  • No usar provisioners salvo excepción
  • Usar IAM Roles en vez de access keys

Terraform – glosario de conceptos

Conceptos generales

  • Terraform
  • Infrastructure as Code (IaC)
    • Práctica de definir infraestructura mediante código versionable
  • Declarativo
    • Se describe el estado deseado, no los pasos para alcanzarlo
  • Idempotencia
    • Ejecutar varias veces produce el mismo resultado
  • Drift
    • Diferencia entre la infraestructura real y la definida en Terraform

Lenguaje y sintaxis

  • HCL (HashiCorp Configuration Language)
    • Lenguaje principal de Terraform, legible y expresivo
  • Bloque
    • Unidad básica de configuración (resource, provider, variable, etc.)
  • Interpolación
    • Uso de valores dinámicos dentro de strings
  • Expresiones
    • Operaciones lógicas, condicionales y matemáticas

Providers

  • Provider
    • Plugin que permite a Terraform interactuar con APIs externas
  • Provider AWS
    • Permite gestionar recursos en Aws
  • Inicialización de providers
    • Descarga automática mediante terraform init
  • Versionado de providers
    • Control de compatibilidad y estabilidad

Recursos

  • Resource
    • Representa un objeto de infraestructura real
  • Tipo de recurso
    • Define la clase del recurso (aws_instance, aws_s3_bucket)
  • Nombre lógico
    • Identificador interno del recurso en Terraform
  • Lifecycle
    • Controla creación, actualización y destrucción

Variables

  • Variable
    • Parámetro reutilizable y configurable
  • Variable por defecto
    • Valor usado si no se sobrescribe
  • Variables de entorno
    • Variables exportadas como TF_VAR_name
  • tfvars
    • Archivos de valores por entorno
  • Variables sensibles
    • Ocultan valores en outputs y logs

Variables locales

  • locals
    • Valores calculados internos
  • Normalización
    • Centralización de nombres y tags
  • Reutilización
    • Evita duplicación de lógica

Estado (state)

  • State
    • Representación de la infraestructura real
  • Archivo de estado
    • Mapea recursos Terraform con recursos reales
  • Estado local
    • Guardado en disco
  • Estado remoto
  • Locking
    • Evita ejecuciones simultáneas
  • Sensitive data
    • El estado puede contener secretos

Backend

  • Backend
    • Mecanismo de almacenamiento del estado
  • S3 Backend
    • Uso de buckets S3 con bloqueo DynamoDB
  • Terraform Cloud
    • Backend gestionado por HashiCorp
  • Migración de estado
    • Cambio de backend sin perder datos

Planificación y ejecución

  • Plan
    • Vista previa de cambios
  • Apply
    • Ejecución real de cambios
  • Destroy
    • Eliminación de infraestructura
  • Auto-approve
    • Salta confirmación manual
  • Saved plan
    • Plan guardado para ejecución controlada

Outputs

  • Output
    • Valores exportados tras el apply
  • Outputs sensibles
    • No visibles en consola
  • Outputs para módulos
    • Comunicación entre módulos

Data sources

  • Data source
    • Lectura de recursos existentes
  • No gestionados
    • Terraform no crea ni destruye
  • Uso típico
    • AMIs, VPCs, subredes existentes

Dependencias

  • Dependencia implícita
    • Inferida por referencias
  • depends_on
    • Fuerza orden de creación
  • Grafo de dependencias
    • Orden interno de ejecución

Bucles y condiciones

  • count
    • Crea múltiples recursos indexados
  • for_each
    • Crea recursos basados en mapas o sets
  • Condicional
    • Expresiones ternarias
  • Dynamic blocks
    • Generación dinámica de bloques

Módulos

  • Module
    • Conjunto reutilizable de recursos
  • Root module
    • Directorio principal del proyecto
  • Child module
    • Módulo importado
  • Module registry
    • Repositorio de módulos reutilizables
  • Versionado de módulos
    • Control de cambios y compatibilidad

Workspaces

  • Workspace
    • Entorno lógico aislado
  • Default workspace
    • Workspace inicial
  • Uso típico
    • dev, qa, prod
  • Limitación
    • No sustituyen cuentas cloud separadas

Seguridad

  • IAM
    • Gestión de identidades y permisos en Aws
  • IAM Role
    • Autenticación recomendada para EC2 y CI/CD
  • Secrets Manager
    • Almacenamiento seguro de secretos
  • Least privilege
    • Permisos mínimos necesarios

Networking

  • VPC
    • Red virtual aislada
  • Subnet
    • Segmento de red dentro de la VPC
  • Security Group
    • Firewall a nivel de instancia
  • Ingress / Egress
    • Reglas de entrada y salida
  • CIDR
    • Rango de direcciones IP

Compute y servicios

  • EC2
    • Máquina virtual en Aws
  • AMI
    • Imagen de sistema
  • user_data
    • Script de inicialización
  • Auto Scaling
    • Escalado automático de instancias
  • Load Balancer
    • Distribución de tráfico

Contenedores y orquestación

  • Docker
    • Contenedores y entornos reproducibles
  • Terraform en Docker
    • Ejecución aislada de Terraform
  • Kubernetes
    • Orquestación de contenedores
  • EKS
    • Kubernetes gestionado en Aws

CI/CD

  • Pipeline
    • Flujo automatizado de despliegue
  • Plan en CI
    • Validación antes del apply
  • Apply automático
    • Despliegue sin intervención
  • Artifacts
    • Outputs del pipeline
  • CICD
    • Integración y despliegue continuos

Testing y calidad

  • terraform validate
    • Validación sintáctica
  • terraform fmt
    • Formato estándar
  • terraform test
    • Tests de infraestructura
  • tflint
    • Linting de buenas prácticas
  • tfsec / checkov
    • Análisis de seguridad

Importación y adopción

  • terraform import
    • Adopta recursos existentes
  • State show
    • Inspección del estado
  • Refactor
    • Reorganización sin recrear recursos

Alternativas y ecosistema

  • OpenTofu
    • Fork open-source compatible con Terraform
  • Packer
    • Creación de imágenes inmutables
  • Ansible
    • Configuración post-provisión
  • Vault
    • Gestión avanzada de secretos

Terraform – cheatsheet de comandos y código

Inicialización y configuración

  • Inicializar proyecto y descargar providers
terraform init

`

  • Reconfigurar backend
terraform init -reconfigure
  • Actualizar providers
terraform init -upgrade

Formato y validación

  • Formatear archivos .tf
terraform fmt
  • Formatear recursivamente
terraform fmt -recursive
  • Validar configuración
terraform validate

Planificación

  • Generar plan
terraform plan
  • Plan con variables
terraform plan -var="env=dev"
  • Plan con archivo tfvars
terraform plan -var-file=dev.tfvars
  • Guardar plan
terraform plan -out=tfplan

Aplicación y destrucción

  • Aplicar cambios
terraform apply
  • Aplicar plan guardado
terraform apply tfplan
  • Aplicar sin confirmación
terraform apply -auto-approve
  • Destruir infraestructura
terraform destroy
  • Destruir sin confirmación
terraform destroy -auto-approve

Variables

  • Variable por CLI
terraform apply -var="instance_type=t3.micro"
  • Variable por entorno
export TF_VAR_instance_type=t3.micro

Outputs

  • Mostrar outputs
terraform output
  • Output específico
terraform output public_ip
  • Output en JSON
terraform output -json

Estado (state)

  • Listar recursos en el estado
terraform state list
  • Mostrar recurso
terraform state show aws_instance.web
  • Mover recurso
terraform state mv aws_instance.old aws_instance.new
  • Eliminar recurso del estado
terraform state rm aws_instance.temp
  • Reemplazar recurso
terraform apply -replace="aws_instance.web"

Importación de recursos

  • Importar recurso existente
terraform import aws_instance.server i-0123456789abcdef0

Workspaces

  • Listar workspaces
terraform workspace list
  • Crear workspace
terraform workspace new prod
  • Seleccionar workspace
terraform workspace select dev
  • Mostrar workspace actual
terraform workspace show

Providers

  • Bloque provider
provider "aws" {
	region = "eu-west-1"
}

Recursos

  • Recurso básico
resource "aws_instance" "web" {
	ami           = "ami-xxxx"
	instance_type = "t3.micro"
}

Variables

  • Definición
variable "environment" {
	type    = string
	default = "dev"
}
  • Uso
environment = var.environment

Variables locales

locals {
	name_prefix = "${var.project}-${var.environment}"
}

Tags

tags = {
	Name        = local.name_prefix
	Environment = var.environment
}

Data sources

data "aws_ami" "amazon_linux" {
	most_recent = true
	owners      = ["amazon"]
}

Outputs

output "public_ip" {
	value = aws_instance.web.public_ip
}

user_data

user_data = <<EOF
#!/bin/bash
yum install -y nginx
systemctl start nginx
EOF

Security Groups

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

count y for_each

  • count
count = var.environment == "prod" ? 2 : 1
  • for_each
for_each = var.servers

Dynamic blocks

dynamic "ingress" {
	for_each = var.ingress_rules
	content {
		from_port = ingress.value.port
	}
}

Dependencias explícitas

depends_on = [aws_security_group.web_sg]

lifecycle

lifecycle {
	prevent_destroy = true
	create_before_destroy = true
}

Módulos

  • Llamada a módulo
module "web" {
	source = "./modules/web"
}

Backend remoto (S3)

terraform {
	backend "s3" {
		bucket = "terraform-states"
		key    = "app/terraform.tfstate"
		region = "eu-west-1"
	}
}

Debug y troubleshooting

  • Logs detallados
export TF_LOG=TRACE
  • Log a archivo
export TF_LOG_PATH=terraform.log

Limpieza

  • Borrar caché local
rm -rf .terraform

Utilidades

  • Mostrar versión
terraform version
  • Ayuda
terraform -help