0Pricing
Terraform Infrastructure as Code · Lección

Estructura del código y convenciones de nombres

Adopte buenas prácticas para organizar sus archivos y módulos de Terraform, junto con convenciones de nombres coherentes para recursos y variables.

Estructura del código y convenciones de nombres es una lección gratuita de Terraform Infrastructure as Code en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Terraform Infrastructure as Code, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Terraform Infrastructure as Code incluye 4 lecciones en total.

¿Por qué estructurar el código de Terraform?

Al igual que organizar su espacio de trabajo físico, estructurar su código de Terraform facilita su comprensión, gestión y uso colaborativo.

Una buena estructura mejora la legibilidad, reduce los errores y ayuda a los nuevos miembros del equipo a ponerse al día rápidamente.

Archivos esenciales de Terraform

Los proyectos de Terraform suelen comenzar con algunos archivos clave. Organizar la configuración en estos archivos es una práctica recomendada habitual:

  • main.tf: Define los recursos y módulos.
  • variables.tf: Declara todas las variables de entrada.
  • outputs.tf: Define los valores de salida de la infraestructura.
  • versions.tf: Especifica las versiones de Terraform y de los proveedores.

Asignar nombres a los recursos

Los nombres coherentes facilitan la identificación de los recursos. Siga estas directrices generales para el nombre local (por ejemplo, my_instance en resource "aws_instance" "my_instance"):

  • Utilice nombres descriptivos: ¿Qué hace el recurso?
  • Utilice guiones o guiones bajos: Para mejorar la legibilidad (por ejemplo, web-server-sg o web_server_sg).
  • Evite los nombres genéricos: server es menos útil que app-frontend-server.

Los nombres locales de los recursos de Terraform deben ser únicos dentro de un módulo.

Convenciones para las variables

Las variables hacen que sus configuraciones sean flexibles. Es fundamental asignarles buenos nombres:

  • Minúsculas con guiones bajos: Es la convención más habitual (por ejemplo, instance_type, vpc_id).
  • Sea específico: ¿Qué controla esta variable?
  • Añada descripciones: Explique el propósito de la variable para facilitar su comprensión.

Los nombres descriptivos de las variables ayudan a los demás a comprender qué entradas espera su módulo.

Asignar nombres a los valores de salida

Las salidas exponen información importante sobre la infraestructura implementada. Asignarles nombres coherentes ayuda a los consumidores:

  • Minúsculas con guiones bajos: De forma similar a las variables, por ejemplo, web_server_ip.
  • Describa el valor: ¿Qué información proporciona?
  • Añada descripciones: Son esenciales en las salidas de los módulos para explicar qué devuelven.

Ejemplo: configuración sencilla

Este archivo main.tf completo demuestra buenas prácticas para asignar nombres a un recurso, una variable y una salida. Puede ejecutar terraform init y terraform plan con él.

terraform {
  required_providers {
    null = {
      source = "hashicorp/null"
      version = "~> 3.0"
    }
  }
}

resource "null_resource" "example_web_server" {
  # Descriptive resource name
  triggers = {
    always_run = timestamp()
  }
}

variable "app_environment" {
  description = "The application's deployment environment (e.g., dev, prod)."
  type        = string
  default     = "development"
}

output "resource_unique_id" {
  description = "The unique ID of the example null resource."
  value       = null_resource.example_web_server.id
}

Estructurar los módulos de Terraform

Los módulos tienen su propia estructura clara para permitir la reutilización de componentes:

  • Módulo raíz: Directorio de nivel superior que contiene su configuración principal.
  • Módulos secundarios: Subdirectorios, cada uno con su propio main.tf, variables.tf, outputs.tf, etc.
  • README.md: Esencial para explicar el propósito, las entradas y las salidas del módulo.

Esto mantiene los módulos autocontenidos y facilita su reutilización.

Organizar las carpetas del proyecto

Además de los archivos, la forma de organizar las carpetas del proyecto es fundamental, especialmente en configuraciones grandes:

  • Separe los entornos: Cree carpetas específicas para dev, staging y prod, cada una con su propia configuración.
  • Utilice una carpeta para módulos comunes: Un directorio modules para sus módulos personalizados y reutilizables.
  • Utilice la carpeta raíz para los proveedores: La carpeta de nivel superior suele definir los proveedores y el backend del estado.

Esto evita la desviación de la configuración y mejora la capacidad de gestión entre entornos.

Ejemplo de carpeta del proyecto

Un proyecto típico de Terraform con varios entornos podría tener el siguiente aspecto, proporcionando una separación clara y reutilización:

. ├── modules/ │ ├── vpc/ │ │ ├── main.tf │ │ ├── variables.tf │ │ └── outputs.tf │ └── ec2-instance/ │ ├── main.tf │ └── variables.tf ├── environments/ │ ├── dev/ │ │ └── main.tf │ ├── staging/ │ │ └── main.tf │ └── prod/ │ └── main.tf └── README.md

Compruebe su comprensión

¿Cuál de las siguientes es la mejor práctica para asignar un nombre a una variable de entrada de Terraform que especifica el número de instancias?

Repaso: estructura y nombres

Hemos aprendido que un código de Terraform bien estructurado y con nombres coherentes es fundamental para la legibilidad, el mantenimiento y la colaboración en equipo.

  • Organice los archivos en main.tf, variables.tf y outputs.tf.
  • Utilice nombres descriptivos en minúsculas y con guiones bajos para los recursos, las variables y las salidas.
  • Estructure los módulos y las carpetas del proyecto para facilitar la reutilización y la separación de entornos.

¡Estas prácticas sientan las bases para una gestión eficaz de la IaC!

Preguntas frecuentes

¿La lección «Estructura del código y convenciones de nombres» es gratis?

Sí — el texto completo de «Estructura del código y convenciones de nombres» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Terraform Infrastructure as Code, actualiza a CoddyKit PRO. El curso de Terraform Infrastructure as Code incluye 4 lecciones en total.

¿Qué aprenderé en «Estructura del código y convenciones de nombres»?

Adopte buenas prácticas para organizar sus archivos y módulos de Terraform, junto con convenciones de nombres coherentes para recursos y variables. Practicas Terraform Infrastructure as Code con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Terraform Infrastructure as Code?

No se requiere experiencia previa. Terraform Infrastructure as Code en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Estructura del código y convenciones de nombres»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Terraform Infrastructure as Code?

Sí. Cada lección de Terraform Infrastructure as Code incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Estructura del código y convenciones de nombres
  2. Control de versiones con Git
  3. Colaboración en equipo y flujos de trabajo
  4. Documentación y flujos de autoservicio
← Volver a Terraform Infrastructure as Code