Hacer clic en una consola en la nube está bien para un servidor. Se estropea cuando se necesita la misma configuración en puesta en escena y producción, o cuando alguien pregunta quién cambió una regla de firewall en marzo pasado. Este tutorial de Terraform para principiantes le muestra una mejor manera: describir su infraestructura en código y dejar que una herramienta la haga realidad.

La mayoría de los tutoriales comienzan con una cuenta en la nube, lo que aumenta el riesgo de facturación antes de que haya aprendido algo. Comenzamos con el proveedor Terraform local, que simplemente crea archivos en su computadora, por lo que los errores no cuestan nada. Estos ejemplos y el resultado de muestra son ilustraciones estándar que no ejecutamos para este artículo y la redacción exacta varía según la versión.

¿Qué es Terraform?

Terraform es una herramienta de infraestructura como código (IaC) de HashiCorp. Usted escribe archivos de configuración en HCL, el lenguaje de configuración de HashiCorp, y describe el resultado final que desea. Luego, Terraform decide qué crear, cambiar o eliminar para llegar allí.

Se comunica con plataformas a través de complementos llamados proveedores. Hay proveedores para AWS, Azure, Google Cloud, Kubernetes, GitHub, Cloudflare y muchos otros, por lo que puedes utilizar un flujo de trabajo en todos ellos.

Una cosa que debe saber: en 2023, HashiCorp trasladó Terraform a la licencia de fuente comercial. Luego, la comunidad creó OpenTofu, una bifurcación de código abierto que utiliza comandos y configuraciones muy similares. Lo que aprende aquí se aplica en gran medida a ambos.

¿Por qué infraestructura como código?

Terraform también es declarativo. Usted dice “debería haber tres servidores”, no “crear un servidor tres veces”. Si ya existen dos, agrega uno. Un guión que simplemente repita sus pasos podría terminar creando tres más.

Instalar Terraform

Instálelo siguiendo las instrucciones oficiales de HashiCorp para su sistema operativo y luego confirme que funciona:

terraform -version

Cree una carpeta vacía para el proyecto. Terraform lee cada archivo .tf en la carpeta actual, por lo que una carpeta equivale a una configuración.

Tu primera configuración

Cree un archivo llamado main.tf:

terraform {
  required_providers {
    local = {
      source  = "hashicorp/local"
      version = "~> 2.5"
    }
  }
}

resource "local_file" "greeting" {
  filename = "${path.module}/hello.txt"
  content  = "Hello from Terraform\n"
}

Mira el bloque resource, ya que casi todo lo que escribes sigue esta forma. local_file es el tipo de recurso y greeting es su propio nombre dentro de la configuración. Juntos forman su dirección: local_file.greeting. Los argumentos internos describen lo que desea.

El flujo de trabajo: iniciar, planificar, aplicar

inicio de terraformación

Esto prepara la carpeta y descarga los proveedores que solicitó. Ejecútelo una vez al inicio y nuevamente cada vez que agregue un proveedor o módulo. También crea un archivo .terraform.lock.hcl, que registra las versiones exactas del proveedor. Confirme ese archivo en Git.

terraform init

plan de terraformación

Esto compara tu código con lo que existe y muestra los cambios planificados, sin tocar nada:

terraform plan

# local_file.greeting will be created
+ resource "local_file" "greeting" {
    + content  = "Hello from Terraform\n"
    + filename = "./hello.txt"
  }

Plan: 1 to add, 0 to change, 0 to destroy.

Aprende los símbolos, porque leerás muchos planos:

aplicar terraformar

Esto muestra nuevamente el plan, pide confirmación y realiza los cambios:

terraform apply

Escriba yes y aparecerá hello.txt. Ahora ejecute terraform plan nuevamente. No debería informar ningún cambio, porque la realidad ya coincide con su código. Esta propiedad, donde ejecutarla repetidamente no provoca más cambios, se llama idempotencia.

Cambiando y destruyendo

Edite la línea content y ejecute terraform plan. Terraform detecta la diferencia y propone un cambio. Para este recurso, reemplaza el archivo. Preste atención a los reemplazos en infraestructura real, ya que recrear una base de datos podría significar perder datos.

A continuación, elimine hello.txt a mano y planifique nuevamente. Terraform se da cuenta de que falta y se ofrece a recrearlo. Una diferencia entre tu código y la realidad se llama deriva, y detectarla es uno de los principales beneficios de la herramienta.

Para eliminar todo lo que administra esta configuración, ejecute:

terraform destroy

Variables y salidas

Los valores codificados le impiden reutilizar el código. Las variables de entrada hacen que la configuración sea flexible y las salidas informan valores útiles:

# variables.tf
variable "environment" {
  type        = string
  description = "Deployment environment"
  default     = "dev"

  validation {
    condition     = contains(["dev", "staging", "prod"], var.environment)
    error_message = "Use dev, staging or prod."
  }
}

# main.tf
resource "local_file" "config" {
  filename = "${path.module}/${var.environment}.txt"
  content  = "environment=${var.environment}\n"
}

# outputs.tf
output "config_path" {
  value = local_file.config.filename
}

Establezca valores en la línea de comando o guárdelos en un archivo llamado terraform.tfvars, que se carga automáticamente:

terraform apply -var="environment=staging"

El uso de local_file.config.filename en la salida también es la forma en que los recursos se refieren entre sí. Terraform lee esas referencias para determinar el orden correcto en el que crear las cosas.

Estado de terraformación

Después de realizar la solicitud, encontrará un archivo llamado terraform.tfstate. Este es el registro de Terraform de lo que gestiona, asignando su código a objetos reales. Sin él, Terraform no sabría que local_file.greeting es ese archivo específico.

Aquí importan tres reglas:

1. Nunca confirmes el estado en Git. Puede contener contraseñas y otros secretos en texto sin formato.
2. No lo edites a mano. Utiliza comandos como terraform state list y terraform state mv.
3. Utilice un backend remoto para proyectos de equipo. Un backend compartido almacena el estado de forma centralizada y lo bloquea, por lo que dos personas no pueden postularse a la vez.

A continuación se muestra un backend típico que utiliza Amazon S3, con un depósito que usted crea con anticipación:

terraform {
  backend "s3" {
    bucket       = "my-company-terraform-state"
    key          = "shop/prod/terraform.tfstate"
    region       = "ap-south-1"
    encrypt      = true
    use_lockfile = true
  }
}

Un verdadero recurso en la nube

El flujo de trabajo no cambia cuando pasa a una nube. Aquí hay un depósito de S3 en AWS. Primero verifique los precios y destruya todo lo que cree mientras practica:

provider "aws" {
  region = "ap-south-1"
}

resource "aws_s3_bucket" "reports" {
  bucket = "my-unique-reports-bucket-2026"

  tags = {
    Environment = var.environment
    ManagedBy   = "terraform"
  }
}

Terraform obtiene credenciales de la configuración de AWS CLI o de las variables de entorno. Nunca escriba claves de acceso en un archivo .tf.

Módulos

Un módulo es simplemente una carpeta de archivos Terraform a los que puedes llamar con diferentes entradas. Funciona de forma muy parecida a una función, permitiéndote definir un patrón una vez y reutilizarlo:

project/
  main.tf
  modules/
    reports_bucket/
      main.tf
      variables.tf
      outputs.tf

module "staging_reports" {
  source      = "./modules/reports_bucket"
  environment = "staging"
}

module "prod_reports" {
  source      = "./modules/reports_bucket"
  environment = "prod"
}

El Registro público de Terraform también tiene módulos listos para usar, pero léalos antes de confiar en ellos y fije la versión. No cree módulos demasiado pronto. Espere hasta haber repetido un patrón al menos dos veces.

Un flujo de trabajo de equipo seguro

1. Cree una rama y cambie los archivos .tf. Consulta nuestro tutorial de Git para principiantes si necesitas un repaso.
2. Ejecute terraform fmt y terraform validate.
3. Abra una solicitud de extracción, con el resultado de terraform plan adjunto para su revisión.
4. Después de la aprobación, aplique ese plan guardado desde un lugar controlado, idealmente una tubería.

Guardar el plan garantiza que usted aplique exactamente lo que se revisó:

terraform plan -out=tfplan
terraform apply tfplan

Esto encaja naturalmente en CI/CD y GitHub Actions. Terraform generalmente aprovisiona el clúster y herramientas como Kubernetes luego ejecutan aplicaciones sobre él.

Errores comunes

• Solicitar sin leer el plan. Un -/+ en una base de datos puede ser una sorpresa muy costosa.
• Mantener el estado en una computadora portátil. Si pierde esa computadora portátil, Terraform perderá el seguimiento de su infraestructura.
• Realizar cambios manuales en la consola. Provocan desviaciones y la siguiente aplicación puede deshacerlas.
• Usar versiones no fijadas. Fijar las versiones del proveedor y del módulo para que las actualizaciones se realicen a propósito.
• Usar una configuración enorme. Dividir por entorno o sistema limita el daño de cualquier error.

Conclusión

Ya ha visto las ideas detrás de casi todo el trabajo de Terraform: declarar recursos, revisar el plan, aplicarlo y proteger el estado. Practique con el proveedor local hasta que el flujo de trabajo le parezca natural y luego administre un pequeño recurso real en una cuenta de nivel gratuito. Coloque los módulos y el estado remoto una vez que esté involucrada más de una persona o más de un entorno.

Preguntas frecuentes

sigue aprendiendo