Introducción a Terraform: Infraestructura Moderna como Código

Introducción

Terraform ha revolucionado cómo aprovisionamos y gestionamos infraestructura al introducir un enfoque declarativo a infraestructura-como-código. Creado por HashiCorp, Terraform te permite definir tu infraestructura completa usando archivos de configuración legibles por humanos, versionar tu infraestructura junto con tu código de aplicación, y aplicar cambios de forma segura a través de múltiples proveedores de nube y servicios mediante un flujo de trabajo único y consistente.

A diferencia de los scripts imperativos tradicionales que describen paso a paso cómo crear infraestructura, Terraform usa un modelo declarativo donde defines cómo debería verse tu infraestructura, y Terraform determina cómo hacerlo realidad. Este cambio de paradigma permite a los equipos tratar la infraestructura como código, implementando las mismas prácticas usadas en desarrollo de software: control de versiones, revisión de código, pruebas y despliegue continuo.

En el mundo multi-nube actual, el ecosistema de proveedores de Terraform soporta cientos de servicios incluyendo AWS, Azure, Google Cloud, Kubernetes, GitHub, Datadog y muchos más. Esta guía completa te introducirá a los conceptos centrales de Terraform, te llevará a través de instalación y configuración, y proporcionará ejemplos prácticos para comenzar con automatización de infraestructura.

¿Por Qué Elegir Terraform para Infraestructura como Código?

Ventajas Clave

Agnóstico de Nube: Terraform funciona con todos los principales proveedores de nube a través de su sistema de plugins de proveedores. Escribe código de infraestructura una vez y despliégalo en cualquier lugar, o gestiona infraestructura multi-nube desde una sola herramienta.

Sintaxis Declarativa: HashiCorp Configuration Language (HCL) es legible por humanos y expresivo, haciendo el código de infraestructura fácil de entender y mantener.

Gestión de Estado: Terraform mantiene un archivo de estado que rastrea tu infraestructura, permitiéndole determinar qué cambios son necesarios y prevenir deriva.

Planificar Antes de Aplicar: El comando terraform plan muestra exactamente qué cambios se realizarán antes de ejecutarlos, previniendo modificaciones inesperadas a infraestructura de producción.

Grafo de Recursos: Terraform construye un grafo de dependencias de todos los recursos, permitiendo creación paralela y ordenamiento apropiado de recursos dependientes.

Modular y Reutilizable: Crea módulos reutilizables para estandarizar patrones de infraestructura a través de tu organización.

Infraestructura Inmutable: Terraform fomenta prácticas de infraestructura inmutable, donde los servidores se reemplazan en lugar de modificarse en el lugar.

Terraform vs Otras Herramientas

Terraform vs Ansible: Ansible sobresale en gestión de configuración y despliegue de aplicaciones, mientras que Terraform se especializa en aprovisionamiento de infraestructura. Se complementan bien en un flujo de trabajo DevOps completo.

Terraform vs CloudFormation: CloudFormation es específico de AWS, mientras que Terraform funciona a través de múltiples proveedores de nube. La sintaxis de Terraform también es más concisa y fácil de leer.

Terraform vs Pulumi: Pulumi usa lenguajes de programación de propósito general (Python, TypeScript, Go) mientras que Terraform usa HCL. Terraform tiene una comunidad más grande y ecosistema más maduro.

Prerrequisitos

Antes de comenzar con Terraform, asegúrate de tener:

Sistema Operativo: Linux, macOS o Windows
Conocimiento de Línea de Comandos: Familiaridad básica con terminal/símbolo del sistema
Cuenta de Proveedor de Nube: AWS, Azure, GCP u otro proveedor soportado
Credenciales de API: Claves de acceso o credenciales de cuenta de servicio para tu proveedor de nube
Control de Versiones: Git instalado y conocimiento básico de Git
Editor de Texto: VS Code, Vim o cualquier editor de código (VS Code con extensión de Terraform recomendado)
Redes Básicas: Comprensión de direcciones IP, subnets y firewalls

Conocimientos Recomendados

Comprensión básica de conceptos de computación en la nube
Familiaridad con componentes de infraestructura (VMs, redes, almacenamiento)
Experiencia con herramientas de línea de comandos
Comprensión de control de versiones con Git

Instalación y Configuración

Instalando Terraform en Linux

Ubuntu/Debian:

# Agregar clave GPG de HashiCorp
wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg

# Agregar repositorio de HashiCorp
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list

# Actualizar e instalar
sudo apt update && sudo apt install terraform

# Verificar instalación
terraform version

CentOS/Rocky Linux:

# Agregar repositorio de HashiCorp
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo

# Instalar Terraform
sudo yum install terraform

# Verificar instalación
terraform version

Instalación Manual (Universal):

# Descargar última versión
TERRAFORM_VERSION="1.7.0"
wget https://releases.hashicorp.com/terraform/${TERRAFORM_VERSION}/terraform_${TERRAFORM_VERSION}_linux_amd64.zip

# Extraer e instalar
unzip terraform_${TERRAFORM_VERSION}_linux_amd64.zip
sudo mv terraform /usr/local/bin/

# Verificar instalación
terraform version

# Salida esperada:
# Terraform v1.7.0
# on linux_amd64

Instalando Terraform en macOS

# Usando Homebrew (recomendado)
brew tap hashicorp/tap
brew install hashicorp/tap/terraform

# Verificar instalación
terraform version

# Actualizar Terraform
brew upgrade hashicorp/tap/terraform

Instalando Terraform en Windows

Usando Chocolatey:

# Instalar vía Chocolatey
choco install terraform

# Verificar instalación
terraform version

Instalación Manual:

Descarga el ZIP de Windows 64-bit desde https://www.terraform.io/downloads
Extrae el archivo ZIP
Mueve terraform.exe a un directorio en tu PATH (ej., C:\Windows\System32)
Abre Command Prompt y ejecuta: terraform version

Configurando Autocompletado de Shell

# Bash
terraform -install-autocomplete
echo 'complete -C /usr/local/bin/terraform terraform' >> ~/.bashrc
source ~/.bashrc

# Zsh
terraform -install-autocomplete
echo 'complete -o nospace -C /usr/local/bin/terraform terraform' >> ~/.zshrc
source ~/.zshrc

Configurando Credenciales de Proveedor de Nube

Configuración de AWS:

# Instalar AWS CLI
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

# Configurar credenciales de AWS
aws configure
# Ingresa tu AWS Access Key ID, Secret Access Key, región y formato de salida

# Verificar configuración
aws sts get-caller-identity

# Alternativa: Variables de entorno
export AWS_ACCESS_KEY_ID="tu-clave-de-acceso"
export AWS_SECRET_ACCESS_KEY="tu-clave-secreta"
export AWS_DEFAULT_REGION="us-east-1"

Configuración de Azure:

# Instalar Azure CLI
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

# Iniciar sesión en Azure
az login

# Establecer suscripción
az account set --subscription "tu-id-de-suscripción"

# Crear service principal para Terraform
az ad sp create-for-rbac --name "terraform" --role="Contributor" --scopes="/subscriptions/tu-id-de-suscripción"

# Anota la salida para uso en configuración de Terraform

Configuración de Google Cloud:

# Instalar Google Cloud SDK
curl https://sdk.cloud.google.com | bash
exec -l $SHELL

# Inicializar y autenticar
gcloud init
gcloud auth application-default login

# Establecer proyecto
gcloud config set project tu-id-de-proyecto

Conceptos Centrales de Terraform

Infraestructura como Código

Terraform trata la infraestructura como código, lo que significa:

La infraestructura se define en archivos de configuración legibles por humanos
La configuración de infraestructura se versiona como código de aplicación
Los cambios se rastrean, revisan y pueden revertirse
La infraestructura puede probarse, validarse y desplegarse continuamente

HashiCorp Configuration Language (HCL)

HCL es el lenguaje de configuración de Terraform, diseñado para ser legible por humanos y compatible con máquinas:

# Sintaxis básica de HCL
resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"

  tags = {
    Name = "ServidorWeb"
    Environment = "Producción"
  }
}

# Variables
variable "instance_count" {
  description = "Número de instancias a crear"
  type        = number
  default     = 2
}

# Salidas
output "instance_ip" {
  description = "IP pública de la instancia"
  value       = aws_instance.web.public_ip
}

Flujo de Trabajo de Terraform

El flujo de trabajo estándar de Terraform consiste en tres comandos principales:

terraform init: Inicializar el directorio de trabajo, descargar proveedores
terraform plan: Previsualizar cambios antes de aplicar
terraform apply: Ejecutar los cambios planificados

# Inicializar Terraform
terraform init

# Validar configuración
terraform validate

# Previsualizar cambios
terraform plan

# Aplicar cambios
terraform apply

# Destruir infraestructura
terraform destroy

Recursos y Proveedores

Recursos son el elemento más importante en Terraform. Cada bloque de recursos describe uno o más objetos de infraestructura:

resource "tipo_de_recurso" "nombre_del_recurso" {
  argumento1 = valor1
  argumento2 = valor2
}

Proveedores son plugins que permiten a Terraform interactuar con plataformas de nube y otros servicios:

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

Archivos de Estado

Terraform almacena información sobre tu infraestructura en un archivo de estado (terraform.tfstate). Este archivo:

Mapea recursos del mundo real a tu configuración
Rastrea metadata y dependencias de recursos
Mejora el rendimiento al cachear atributos de recursos
Debe compartirse entre miembros del equipo (usar estado remoto)

Importante: Nunca subas terraform.tfstate a control de versiones. Usa backends de estado remoto en su lugar.

Tu Primera Configuración de Terraform

Vamos a crear una infraestructura simple en AWS:

Estructura del Proyecto

# Crear directorio del proyecto
mkdir terraform-introduction
cd terraform-introduction

# Crear archivos de configuración
touch main.tf variables.tf outputs.tf terraform.tfvars

Estructura de proyecto recomendada:

terraform-introduction/
├── main.tf           # Configuración principal de infraestructura
├── variables.tf      # Definiciones de variables
├── outputs.tf        # Definiciones de salidas
├── terraform.tfvars  # Valores de variables (no subir secretos)
├── providers.tf      # Configuraciones de proveedores
└── README.md         # Documentación

Configuración Principal (main.tf)

# main.tf
terraform {
  required_version = ">= 1.0"

  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = var.aws_region
}

# VPC
resource "aws_vpc" "main" {
  cidr_block           = var.vpc_cidr
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = {
    Name        = "${var.project_name}-vpc"
    Environment = var.environment
    ManagedBy   = "Terraform"
  }
}

# Internet Gateway
resource "aws_internet_gateway" "main" {
  vpc_id = aws_vpc.main.id

  tags = {
    Name        = "${var.project_name}-igw"
    Environment = var.environment
  }
}

# Subnet Pública
resource "aws_subnet" "public" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = var.public_subnet_cidr
  availability_zone       = data.aws_availability_zones.available.names[0]
  map_public_ip_on_launch = true

  tags = {
    Name        = "${var.project_name}-public-subnet"
    Environment = var.environment
  }
}

# Tabla de Rutas
resource "aws_route_table" "public" {
  vpc_id = aws_vpc.main.id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.main.id
  }

  tags = {
    Name        = "${var.project_name}-public-rt"
    Environment = var.environment
  }
}

# Asociación de Tabla de Rutas
resource "aws_route_table_association" "public" {
  subnet_id      = aws_subnet.public.id
  route_table_id = aws_route_table.public.id
}

# Grupo de Seguridad
resource "aws_security_group" "web" {
  name        = "${var.project_name}-web-sg"
  description = "Grupo de seguridad para servidores web"
  vpc_id      = aws_vpc.main.id

  ingress {
    description = "HTTP desde cualquier lugar"
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    description = "HTTPS desde cualquier lugar"
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    description = "SSH desde IP específica"
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = [var.admin_ip]
  }

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

  tags = {
    Name        = "${var.project_name}-web-sg"
    Environment = var.environment
  }
}

# Fuente de datos para AMI
data "aws_ami" "ubuntu" {
  most_recent = true
  owners      = ["099720109477"] # Canonical

  filter {
    name   = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-*"]
  }

  filter {
    name   = "virtualization-type"
    values = ["hvm"]
  }
}

# Fuente de datos para zonas de disponibilidad
data "aws_availability_zones" "available" {
  state = "available"
}

# Instancia EC2
resource "aws_instance" "web" {
  ami                    = data.aws_ami.ubuntu.id
  instance_type          = var.instance_type
  subnet_id              = aws_subnet.public.id
  vpc_security_group_ids = [aws_security_group.web.id]
  key_name               = var.key_name

  user_data = <<-EOF
              #!/bin/bash
              apt-get update
              apt-get install -y nginx
              echo "<h1>Hola desde Terraform</h1>" > /var/www/html/index.html
              systemctl start nginx
              systemctl enable nginx
              EOF

  root_block_device {
    volume_size = 20
    volume_type = "gp3"
  }

  tags = {
    Name        = "${var.project_name}-web-server"
    Environment = var.environment
    ManagedBy   = "Terraform"
  }

  lifecycle {
    create_before_destroy = true
  }
}

# IP Elástica
resource "aws_eip" "web" {
  instance = aws_instance.web.id
  domain   = "vpc"

  tags = {
    Name        = "${var.project_name}-web-eip"
    Environment = var.environment
  }

  depends_on = [aws_internet_gateway.main]
}

Configuración de Variables (variables.tf)

# variables.tf
variable "aws_region" {
  description = "Región de AWS para recursos"
  type        = string
  default     = "us-east-1"
}

variable "project_name" {
  description = "Nombre del proyecto para nombrado de recursos"
  type        = string
  default     = "miproyecto"
}

variable "environment" {
  description = "Nombre del entorno"
  type        = string
  default     = "development"

  validation {
    condition     = contains(["development", "staging", "production"], var.environment)
    error_message = "El entorno debe ser development, staging o production."
  }
}

variable "vpc_cidr" {
  description = "Bloque CIDR para VPC"
  type        = string
  default     = "10.0.0.0/16"
}

variable "public_subnet_cidr" {
  description = "Bloque CIDR para subnet pública"
  type        = string
  default     = "10.0.1.0/24"
}

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

variable "key_name" {
  description = "Nombre de clave SSH"
  type        = string
}

variable "admin_ip" {
  description = "Dirección IP permitida para acceso SSH"
  type        = string
}

variable "tags" {
  description = "Tags adicionales para recursos"
  type        = map(string)
  default     = {}
}

Configuración de Salidas (outputs.tf)

# outputs.tf
output "vpc_id" {
  description = "ID de la VPC"
  value       = aws_vpc.main.id
}

output "public_subnet_id" {
  description = "ID de la subnet pública"
  value       = aws_subnet.public.id
}

output "instance_id" {
  description = "ID de la instancia EC2"
  value       = aws_instance.web.id
}

output "instance_public_ip" {
  description = "IP pública de la instancia EC2"
  value       = aws_eip.web.public_ip
}

output "instance_public_dns" {
  description = "DNS público de la instancia EC2"
  value       = aws_instance.web.public_dns
}

output "security_group_id" {
  description = "ID del grupo de seguridad"
  value       = aws_security_group.web.id
}

output "web_url" {
  description = "URL para acceder al servidor web"
  value       = "http://${aws_eip.web.public_ip}"
}

Valores de Variables (terraform.tfvars)

# terraform.tfvars
# NO subir este archivo si contiene datos sensibles

aws_region         = "us-east-1"
project_name       = "terraform-intro"
environment        = "development"
instance_type      = "t2.micro"
key_name           = "mi-clave-ssh"
admin_ip           = "TU_DIRECCION_IP/32"  # Reemplazar con tu IP

tags = {
  Project = "Introducción a Terraform"
  Owner   = "Equipo DevOps"
}

Desplegando Tu Primera Infraestructura

Paso 1: Inicializar Terraform

# Navegar al directorio del proyecto
cd terraform-introduction

# Inicializar Terraform
terraform init

# Salida esperada:
# Initializing the backend...
# Initializing provider plugins...
# - Finding hashicorp/aws versions matching "~> 5.0"...
# - Installing hashicorp/aws v5.x.x...
# ¡Terraform se ha inicializado exitosamente!

Paso 2: Validar Configuración

# Verificar sintaxis y validar configuración
terraform validate

# Salida esperada:
# ¡Éxito! La configuración es válida.

# Formatear código (opcional pero recomendado)
terraform fmt -recursive

Paso 3: Planificar Cambios de Infraestructura

# Previsualizar qué creará Terraform
terraform plan

# Guardar plan en archivo para revisión
terraform plan -out=tfplan

# Revisar el plan
# Verás una lista de recursos a crear, modificar o destruir

Paso 4: Aplicar Configuración

# Aplicar la configuración
terraform apply

# O aplicar plan guardado
terraform apply tfplan

# Terraform pedirá confirmación
# Escribe 'yes' para proceder

# La salida esperada muestra progreso de creación de recursos:
# aws_vpc.main: Creating...
# aws_vpc.main: Creation complete after 2s
# aws_internet_gateway.main: Creating...
# ...
# ¡Apply complete! Resources: 8 added, 0 changed, 0 destroyed.

Paso 5: Verificar Despliegue

# Mostrar estado actual
terraform show

# Listar todos los recursos
terraform state list

# Obtener valores de salida específicos
terraform output instance_public_ip
terraform output web_url

# Probar el servidor web
curl $(terraform output -raw web_url)

Paso 6: Hacer Cambios

Edita main.tf para agregar tags o modificar recursos:

resource "aws_instance" "web" {
  # ... configuración existente ...

  tags = {
    Name        = "${var.project_name}-web-server"
    Environment = var.environment
    ManagedBy   = "Terraform"
    UpdatedAt   = timestamp()  # Agregar nuevo tag
  }
}

Aplicar los cambios:

# Planificar cambios
terraform plan

# Aplicar cambios
terraform apply

Paso 7: Destruir Infraestructura

# Previsualizar qué se destruirá
terraform plan -destroy

# Destruir todos los recursos
terraform destroy

# Terraform pedirá confirmación
# Escribe 'yes' para proceder

# Verificar destrucción
terraform show  # Debe mostrar estado vacío

Referencia de Comandos de Terraform

Comandos Esenciales

# Inicializar directorio de trabajo
terraform init

# Validar configuración
terraform validate

# Formatear archivos de configuración
terraform fmt

# Mostrar plan de ejecución
terraform plan

# Aplicar cambios
terraform apply

# Destruir infraestructura
terraform destroy

# Mostrar estado actual
terraform show

# Listar recursos en estado
terraform state list

# Mostrar recurso específico
terraform state show aws_instance.web

# Obtener valores de salida
terraform output

# Refrescar estado
terraform refresh

# Importar recurso existente
terraform import aws_instance.web i-1234567890abcdef0

# Marcar recurso (para recreación)
terraform taint aws_instance.web

# Desmarcar recurso
terraform untaint aws_instance.web

# Crear espacio de trabajo
terraform workspace new production

# Listar espacios de trabajo
terraform workspace list

# Cambiar espacio de trabajo
terraform workspace select production

Comandos Avanzados

# Mostrar grafo de recursos
terraform graph | dot -Tpng > graph.png

# Validar y verificar sintaxis
terraform validate

# Aplicar con auto-aprobación (usar con cuidado)
terraform apply -auto-approve

# Aplicar recurso específico
terraform apply -target=aws_instance.web

# Plan con sobreescritura de variable
terraform plan -var="instance_type=t2.small"

# Aplicar con archivo de variables
terraform apply -var-file="production.tfvars"

# Mostrar proveedores
terraform providers

# Mostrar versión
terraform version

# Actualizar proveedores
terraform init -upgrade

Mejores Prácticas

1. Control de Versiones

# .gitignore para Terraform
*.tfstate
*.tfstate.backup
*.tfvars
.terraform/
.terraform.lock.hcl
crash.log
override.tf
override.tf.json

Siempre subir:

Archivos *.tf
Archivos *.tf.json
.terraform.lock.hcl (bloqueo de versión de proveedor)
README.md

Nunca subir:

Archivos *.tfstate
*.tfvars con secretos
Directorio .terraform/

2. Estado Remoto

Usa estado remoto para colaboración en equipo:

terraform {
  backend "s3" {
    bucket         = "mi-estado-terraform"
    key            = "prod/terraform.tfstate"
    region         = "us-east-1"
    encrypt        = true
    dynamodb_table = "terraform-lock"
  }
}

3. Usar Variables

Haz configuraciones reutilizables:

# Malo: Valores codificados
resource "aws_instance" "web" {
  instance_type = "t2.micro"
  ami           = "ami-0c55b159cbfafe1f0"
}

# Bueno: Usando variables
resource "aws_instance" "web" {
  instance_type = var.instance_type
  ami           = data.aws_ami.ubuntu.id
}

4. Usar Fuentes de Datos

Consulta infraestructura existente:

data "aws_vpc" "existing" {
  default = true
}

resource "aws_subnet" "app" {
  vpc_id = data.aws_vpc.existing.id
  # ...
}

5. Etiquetar Todo

locals {
  common_tags = {
    Environment = var.environment
    ManagedBy   = "Terraform"
    Project     = var.project_name
  }
}

resource "aws_instance" "web" {
  # ...
  tags = merge(local.common_tags, {
    Name = "servidor-web"
    Role = "frontend"
  })
}

6. Usar Módulos

Crea componentes reutilizables:

module "vpc" {
  source = "./modules/vpc"

  cidr_block = var.vpc_cidr
  environment = var.environment
}

module "web_servers" {
  source = "./modules/ec2"

  vpc_id     = module.vpc.vpc_id
  subnet_ids = module.vpc.public_subnet_ids
}

7. Implementar Reglas de Ciclo de Vida

resource "aws_instance" "web" {
  # ...

  lifecycle {
    create_before_destroy = true
    prevent_destroy       = true  # Protección de producción
    ignore_changes        = [tags.UpdatedAt]
  }
}

Resolución de Problemas

Problemas Comunes y Soluciones

Problema: Proveedor no encontrado

# Solución: Ejecutar terraform init
terraform init

Problema: Recurso ya existe

# Solución: Importar recurso existente
terraform import aws_instance.web i-1234567890abcdef0

Problema: Error de bloqueo de estado

# Solución: Forzar desbloqueo (usar con cuidado)
terraform force-unlock LOCK_ID

Problema: Credenciales inválidas

# Solución: Verificar credenciales
aws sts get-caller-identity

# O establecer variables de entorno
export AWS_ACCESS_KEY_ID="tu-clave"
export AWS_SECRET_ACCESS_KEY="tu-secreto"

Problema: Errores de dependencia

# Solución: Usar depends_on explícito
resource "aws_eip" "web" {
  instance = aws_instance.web.id

  depends_on = [aws_internet_gateway.main]
}

Modo de Depuración

# Habilitar logging detallado
export TF_LOG=DEBUG
terraform apply

# Registrar en archivo
export TF_LOG_PATH=./terraform.log
terraform apply

# Deshabilitar logging
unset TF_LOG
unset TF_LOG_PATH

Conclusión

Terraform es una herramienta poderosa para gestionar infraestructura como código, proporcionando un flujo de trabajo consistente a través de todos los proveedores de nube y servicios. Esta introducción cubrió los conceptos fundamentales, instalación, configuración y patrones de uso básicos que forman la base de la experiencia en Terraform.

Puntos clave:

Terraform usa configuración declarativa para definir infraestructura
El flujo de trabajo estándar es: init, plan, apply
La gestión de estado es crucial para rastrear infraestructura
Variables y salidas hacen las configuraciones reutilizables
El estado remoto habilita colaboración en equipo
Seguir mejores prácticas asegura código de infraestructura mantenible

Próximos pasos:

Explorar módulos de Terraform para reutilización de código
Implementar estado remoto con configuración de backend
Aprender sobre espacios de trabajo para gestión de entornos
Estudiar características avanzadas como aprovisionadores y bloques dinámicos
Integrar Terraform con pipelines de CI/CD
Explorar Terraform Cloud para colaboración en equipo

Con Terraform en tu conjunto de herramientas DevOps, puedes construir, cambiar y versionar infraestructura de manera segura y eficiente. Continúa practicando con diferentes proveedores de nube y gradualmente construye configuraciones de infraestructura más complejas.

Introducción a Terraform: Infraestructura Moderna como Código

Introducción a Terraform: Infraestructura Moderna como Código

Introducción

¿Por Qué Elegir Terraform para Infraestructura como Código?

Ventajas Clave

Terraform vs Otras Herramientas

Prerrequisitos

Conocimientos Recomendados

Instalación y Configuración

Instalando Terraform en Linux

Instalando Terraform en macOS

Instalando Terraform en Windows

Configurando Autocompletado de Shell

Configurando Credenciales de Proveedor de Nube

Conceptos Centrales de Terraform

Infraestructura como Código

HashiCorp Configuration Language (HCL)

Flujo de Trabajo de Terraform

Recursos y Proveedores

Archivos de Estado

Tu Primera Configuración de Terraform

Estructura del Proyecto

Configuración Principal (main.tf)

Configuración de Variables (variables.tf)

Configuración de Salidas (outputs.tf)

Valores de Variables (terraform.tfvars)

Desplegando Tu Primera Infraestructura

Paso 1: Inicializar Terraform

Paso 2: Validar Configuración

Paso 3: Planificar Cambios de Infraestructura

Paso 4: Aplicar Configuración

Paso 5: Verificar Despliegue

Paso 6: Hacer Cambios

Paso 7: Destruir Infraestructura

Referencia de Comandos de Terraform

Comandos Esenciales

Comandos Avanzados

Mejores Prácticas

1. Control de Versiones

2. Estado Remoto

3. Usar Variables

4. Usar Fuentes de Datos

5. Etiquetar Todo

6. Usar Módulos

7. Implementar Reglas de Ciclo de Vida

Resolución de Problemas

Problemas Comunes y Soluciones

Modo de Depuración

Conclusión

Latest Video

Get $20 Free Credit