Terraform en Azure: Guía práctica para principiantes sobre la IaC

Si alguna vez te has encontrado haciendo clic en el portal de Azure, intentando reconstruir manualmente los recursos de la nube, yo también he pasado por eso, y se hace viejo enseguida. Ahí es donde entra Terraform. Es una herramienta de infraestructura como código (IaC) que te permite definir y gestionar la configuración de tu nube con unas pocas líneas de código.

En este tutorial, nos centraremos en el uso de Terraform con Azure. Te explicaré qué es Terraform, cómo funciona en el ecosistema Azure y cómo empezar con ejemplos prácticos. También cubriremos algunas de las mejores prácticas para ayudarte a crear implantaciones seguras y fiables desde el principio.

Si eres nuevo en el ecosistema Azure, este programa de fundamentos de Azure ofrece una introducción estructurada a los servicios y principios básicos.

¿Por qué utilizar Terraform en Azure?

Terraform, desarrolladod por HashiCorp, es una herramienta IaC de código abierto que te permite definir y gestionar infraestructuras en la nube mediante una sintaxis declarativa. Cuando se combina con Microsoft Azure, te permite programar recursos como redes virtuales, máquinas virtuales y bases de datos en archivos de configuración legibles por humanos.

¿Por qué utilizar Terraform con Azure? Se trata de coherencia, escalabilidad y velocidad. Tanto si estás poniendo en marcha una única máquina virtual como orquestando una aplicación compleja de varios niveles, Terraform simplifica el proceso al tiempo que reduce los errores humanos.

Si eres completamente nuevo en Terraform, esta guía de Terraform para principiantesexplica los fundamentos y cómo empezar a utilizarlo para la infraestructura como código.

Conceptos básicos de Terraform en Azure

La integración de Terraform con Azure ofrece un conjunto de funciones que hacen que la gestión de la infraestructura sea intuitiva y potente. Examinemos los componentes clave y los tipos de recursos Terraform disponibles.

Gestión declarativa de infraestructuras

El enfoque declarativo de Terraform te permite definir el aspecto que debe tener tu infraestructura Azure en archivos .tf utilizando el Lenguaje de Configuración de HashiCorp (HCL). 

Por ejemplo, puedes especificar una VM de Azure con su tamaño, ubicación y configuración de red, y Terraform se encarga del cómo de crearla. Aquí tienes un vistazo rápido:

resource "azurerm_virtual_machine" "example" {
  name                  = "my-vm"
  location              = "East US"
  resource_group_name   = "my-resource-group"
  vm_size               = "Standard_D2s_v3"
  network_interface_ids = [azurerm_network_interface.example.id]
  # ... other necessary configurations like OS disk, admin details
}

La definición anterior garantiza la idempotencia: ejecutar el mismo código varias veces da el mismo resultado sin duplicados ni errores. 

Ahora, vamos a desglosar los conceptos básicos de Terraform que hacen que este enfoque declarativo funcione.

Estado de Terraform (.tfstate)

El archivo terraform.tfstate es el corazón del modelo declarativo de Terraform. Es un archivo JSON que registra el estado actual de tus recursos Azure: lo que está desplegado, sus configuraciones y sus relaciones. 

Cuando ejecutas terraform apply, Terraform compara tus archivos .tf (el estado deseado) con el archivo .tfstate (el estado real) para determinar qué cambios realizar. Por ejemplo, si actualizas el tamaño de una VM en tu código, Terraform comprueba el archivo .tfstate y modifica sólo ese atributo en Azure. 

Puedes almacenar este archivo localmente, pero para los equipos, utiliza Azure Blob Storage para permitir la colaboración y el bloqueo de estados para evitar conflictos.

Variables de Terraform (.tfvars)

Las variables hacen que tus configuraciones sean flexibles y reutilizables. Definidos en variables.tf y terraform.tfvars, te permiten parametrizar valores como nombres de recursos o regiones. 

Por ejemplo:

# variables.tf
variable "location" {
  type        = string
  default     = "East US"
  description = "The Azure region where resources will be deployed."
}

# terraform.tfvars (for a specific environment, e.g., production)
location = "West US"

# main.tf
resource "azurerm_resource_group" "example" {
  name     = "my-rg"
  location = var.location
}

El archivo terraform.tfvars anula los valores predeterminados, por lo que puedes desplegar el mismo código en diferentes regiones sin editar los archivos del núcleo .tf. Puede utilizarse para gestionar varios entornos (por ejemplo, dev, prod).

Archivos de configuración de Terraform (.tf)

Estos archivos contienen el código de tu infraestructura, que está escrito en HCL. Definen recursos, proveedores, módulos y mucho más. Puedes organizarlos como un único main.tf o dividirlos en varios archivos (por ejemplo, variables.tf, outputs.tf, network.tf, compute.tf) para mayor claridad y mejor organización.

Plan Terraform

Antes de aplicar los cambios, el comando terraform plan muestra una vista previa de lo que Terraform hará -crear, actualizar o eliminar recursos- basándose en la diferencia entre tus archivos .tf y los .tfstate. Es como un simulacro que detecta posibles problemas con antelación, mostrando un resumen detallado de las acciones propuestas.

Aplicar Terraform

El comando terraform apply ejecuta los cambios identificados por terraform plan, actualizando Azure para que coincida con tu estado deseado y refrescando el archivo .tfstate. Se te pedirá confirmación antes de aplicar los cambios, lo que proporciona una red de seguridad.

Espacios de trabajo

Los espacios de trabajo de Terraform te permiten gestionar varios entornos (por ejemplo, dev, staging, prod) con un único conjunto de archivos .tf. Cada espacio de trabajo tiene su propio archivo .tfstate, por lo que puedes desplegar una infraestructura similar con diferentes configuraciones (por ejemplo, diferentes tamaños de VM para dev vs. prod). 

Para crear un nuevo espacio de trabajo, puedes utilizar:

terraform workspace new production

A continuación, puedes cambiar al espacio de trabajo:

terraform workspace select production

Módulos

Los módulos son paquetes reutilizables de código Terraform. Por ejemplo, puedes crear un módulo para una red virtual Azure y reutilizarlo en todos los proyectos, reduciendo la duplicación y fomentando la estandarización. Cubriremos más módulos en la sección de mejores prácticas.

Estos conceptos (.tfstate, .tfvars y el flujo de trabajo declarativo) funcionan conjuntamente para garantizar que tu infraestructura Azure sea predecible, reproducible y fácil de gestionar.

Gestión estatal y colaboración

El archivo terraform.tfstate hace un seguimiento del estado de tu infraestructura. Para los equipos, almacenarlo en Azure Blob Storage es una buena práctica fundamental para permitir el acceso compartido y el control de versiones. Esta configuración remota del backend permite a todos los miembros del equipo trabajar con una visión coherente de la infraestructura. 

El bloqueo de estado, una función que proporcionan automáticamente muchos backends remotos como Azure Blob Storage, evita conflictos cuando varios miembros del equipo intentan ejecutar comandos Terraform simultáneamente, garantizando la integridad de los datos.

Aquí tienes un ejemplo de configuración de un backend Azure Blob Storage:

terraform {
  backend "azurerm" {
    resource_group_name  = "my-terraform-state-rg"
    storage_account_name = "mystorageterraformstate"
    container_name  = "tfstate"
    key  = "production/terraform.tfstate" # Path within the container
  }
}

Antes de ejecutar terraform init con esta configuración, tendrías que crear la cuenta de almacenamiento Azure y el contenedor manualmente o mediante una configuración Terraform independiente. Esta configuración garantiza una gestión segura y colaborativa de los recursos de Azure.

Ecosistema de proveedores y AzureRM

El proveedor azurerm esel puente de Terraforma Azure, traduciendo HCL en llamadas a la API para gestionar servicios como máquinas virtuales, redes y bases de datos.

Admite cientos de tipos de recursos, desde los informáticos (azurerm_linux_virtual_machine, azurerm_windows_virtual_machine) hasta los analíticos (azurerm_synapse_workspace). Algunas de sus características son:

• Amplia cobertura: Gestiona un amplio arreglo de servicios Azure, incluyendo máquinas virtuales, cuentas de almacenamiento, Azure Kubernetes Service (AKS), Azure SQL Database, Azure Cosmos DB con MongoDB API, Azure Functions, y mucho más. El proveedor azurerm se desarrolla activamente para admitir nuevos servicios y funciones de Azure a medida que están disponibles.
• Funciones dinámicas: Utiliza funciones definidas por el proveedor para generar nombres únicos (por ejemplo, azurerm_resource_group.example.name) u obtener detalles sobre recursos existentes (por ejemplo, data.azurerm_virtual_network.existing.id). Esto permite configuraciones más dinámicas e inteligentes.
• Fuentes de datos: El proveedor azurerm aprovecha las fuentes de datos para obtener información sobre los recursos Azure existentes. Esto es especialmente útil cuando necesitas hacer referencia a recursos que no fueron aprovisionados por tu configuración Terraform actual. Por ejemplo, puedes recuperar los detalles de una red virtual existente para desplegar nuevas subredes o máquinas virtuales sin volver a crear la VNet.

Antes de sumergirte en Terraform, es útil entender cómo configurar manualmenteAzure: estaguía para principiantes te guía a través de lo esencial.

Configuración de un entorno Terraform-Azure

¡Pongámonos manos a la obra! Esta sección te guía a través de la configuración inicial necesaria para utilizar Terraform con tu suscripción a Azure.

Autenticación y herramientas CLI

Para interactuar con Azure, primero tendrás que instalar y configurarla interfaz de línea de comandos (CLI) de Azure. La CLI de Azure proporciona las herramientas necesarias para autenticar y gestionar tus recursos de Azure. Una vez instalado, inicia sesión en tu cuenta Azure:

az login

El comando anterior abrirá una ventana del navegador para la autenticación interactiva. Para una referencia rápidak, esta hoja de trucos de la CLI de Azure puedeagilizar tus flujos de trabajo de línea de comandos.

Para los despliegues automatizados con Terraform, especialmente en canalizaciones CI/CD, es muy recomendable crear y utilizar los principales de servicio de Azure Active Directory (AAD). Los principales de servicio proporcionan una forma segura y programática para que Terraform se autentique con tu suscripción de Azure sin requerir inicios de sesión interactivos.

Para crear una entidad de seguridad de servicio con el rol "Colaborador" en el ámbito de la suscripción, ejecuta

az ad sp create-for-rbac --name "http://myTerraformServicePrincipal" --role "Contributor" --scopes "/subscriptions/<your-subscription-id>"

La salida proporcionará appId, password, y tenant (ID de inquilino). Luego puedes establecerlas como variables de entorno para Terraform:

export ARM_CLIENT_ID="<appId>"
export ARM_CLIENT_SECRET="<password>"
export ARM_TENANT_ID="<tenant>"
export ARM_SUBSCRIPTION_ID="<your-subscription-id>"

Inicializar un proyecto

Un proyecto Terraform típico sigue una disposición de directorios estructurada, a menudo con archivos .tf separados para los distintos tipos de recursos o módulos (por ejemplo, main.tf, variables.tf, outputs.tf, network.tf, compute.tf). 

Para iniciar cualquier proyecto Terraform, navega hasta el directorio de tu proyecto y ejecuta el comando terraform init. Este comando inicializa el directorio de trabajo, descarga los plugins de proveedor necesarios (como azurerm), y configura el backend para la gestión de estados según lo definido en tu configuración.

mkdir my-azure-terraform-project
cd my-azure-terraform-project
# Create your .tf files here
terraform init

Este comando prepara tu directorio para las operaciones de Terraform, asegurándose de que todos los plugins necesarios están en su sitio.

Aprovisionamiento de recursos Azure

Esta sección proporciona ejemplos prácticos de aprovisionamiento de recursos comunes de Azure mediante Terraform, demostrando cómo definirlos y desplegarlos mediante programación.

Redes y subredes virtuales

Terraform destaca en la definición y despliegue de infraestructura de red en Azure. Puedes definir fácilmente redes virtuales (VNets) y segmentarlas en subredes, controlando los espacios de direcciones IP y el aislamiento de la red. 

La gestión de dependencias inherente a Terraform garantiza que los recursos se creen en el orden correcto; por ejemplo, las subredes sólo se aprovisionarán después de que su VNet matriz se haya creado correctamente. He aquí un ejemplo:

resource "azurerm_resource_group" "network_rg" {
  name     = "my-network-rg"
  location = "East US"
}

resource "azurerm_virtual_network" "main_vnet" {
  name                = "my-vnet"
  address_space       = ["10.0.0.0/16"]
  location            = azurerm_resource_group.network_rg.location
  resource_group_name = azurerm_resource_group.network_rg.name
}

resource "azurerm_subnet" "web_subnet" {
  name                 = "web-subnet"
  resource_group_name  = azurerm_resource_group.network_rg.name
  virtual_network_name = azurerm_virtual_network.main_vnet.name
  address_prefixes     = ["10.0.1.0/24"]
}

resource "azurerm_subnet" "app_subnet" {
  name                 = "app-subnet"
  resource_group_name  = azurerm_resource_group.network_rg.name
  virtual_network_name = azurerm_virtual_network.main_vnet.name
  address_prefixes     = ["10.0.2.0/24"]
}

Máquinas virtuales con cloud-init

Aprovisionar máquinas virtuales (VM) con Terraform es sencillo. Para automatizar la configuración posterior a la implantación y la configuración inicial, puedes aprovechar los scripts de cloud-init. 

cloud-init te permite inyectar scripts que se ejecutan en el primer arranque de la máquina virtual, permitiendo tareas como instalar software, configurar usuarios o establecer servicios, directamente desde tu configuración de Terraform.

Aquí tienes un ejemplo de aprovisionamiento de una máquina virtual Linux con un sencillo script cloud-init para instalar Nginx:

resource "azurerm_resource_group" "vm_rg" {
  name     = "my-vm-rg"
  location = "East US"
}

resource "azurerm_network_interface" "vm_nic" {
  name                = "my-vm-nic"
  location            = azurerm_resource_group.vm_rg.location
  resource_group_name = azurerm_resource_group.vm_rg.name

  ip_configuration {
    name                          = "internal"
    subnet_id                     = azurerm_subnet.web_subnet.id # Assuming web_subnet defined above
    private_ip_address_allocation = "Dynamic"
    public_ip_address_id          = azurerm_public_ip.vm_public_ip.id
  }
}

resource "azurerm_public_ip" "vm_public_ip" {
  name                = "my-vm-public-ip"
  location            = azurerm_resource_group.vm_rg.location
  resource_group_name = azurerm_resource_group.vm_rg.name
  allocation_method   = "Static"
}

resource "azurerm_linux_virtual_machine" "my_vm" {
  name                  = "my-linux-vm"
  location              = azurerm_resource_group.vm_rg.location
  resource_group_name   = azurerm_resource_group.vm_rg.name
  size                  = "Standard_B2s"
  admin_username        = "azureuser"
  admin_password        = "P@ssw0rd1234!" # In a real scenario, use Azure Key Vault or variables
  network_interface_ids = [azurerm_network_interface.vm_nic.id]

  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
  }

  source_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "18.04-LTS"
    version   = "latest"
  }

  # cloud-init script to install Nginx
  custom_data = base64encode(<<EOF
#cloud-config
packages:
  - nginx
runcmd:
  - systemctl start nginx
  - systemctl enable nginx
EOF
  )
}

Modularizar la infraestructura

A medida que crece tu infraestructura Azure, modularizar tus configuraciones Terraform se convierte en algo crucial para la reutilización, el mantenimiento y la escalabilidad. 

Los módulos encapsulan un conjunto de recursos relacionados y sus configuraciones en unidades reutilizables. Esta sección proporcionará orientación sobre la estructuración de tu código Terraform en módulos y demostrará cómo invocar estos módulos dentro de tus configuraciones principales, promoviendo una base de código más limpia y organizada.

Ejemplo: Estructura del módulo (modules/web-app/main.tf):

# modules/web-app/main.tf
resource "azurerm_app_service_plan" "app_plan" {
  name                = var.app_service_plan_name
  location            = var.location
  resource_group_name = var.resource_group_name
  kind                = "Linux"
  sku {
    tier = "Basic"
    size = "B1"
  }
}

resource "azurerm_app_service" "app_service" {
  name                = var.app_service_name
  location            = var.location
  resource_group_name = var.resource_group_name
  app_service_plan_id = azurerm_app_service_plan.app_plan.id
}

variable "app_service_plan_name" {
  type = string
}

variable "app_service_name" {
  type = string
}

variable "location" {
  type = string
}

variable "resource_group_name" {
  type = string
}

output "app_service_default_hostname" {
  value = azurerm_app_service.app_service.default_host_name
}

Ejemplo: Invocando el módulo (main.tf en el directorio raíz):

resource "azurerm_resource_group" "app_rg" {
  name     = "my-webapp-rg"
  location = "East US"
}

module "my_web_app" {
  source                = "./modules/web-app" # Path to your module
  app_service_plan_name = "my-webapp-plan"
  app_service_name      = "my-unique-webapp-2025"
  location              = azurerm_resource_group.app_rg.location
  resource_group_name   = azurerm_resource_group.app_rg.name
}

output "webapp_url" {
  value = module.my_web_app.app_service_default_hostname
}

Esta estructura facilita la reutilización de la lógica de despliegue de tu aplicación web en distintos entornos o proyectos.

Flujos de trabajo avanzados de Terraform

Esta sección explora funciones más sofisticadas de Terraform que mejoran la flexibilidad y la potencia de tus despliegues de infraestructura, yendo más allá del aprovisionamiento básico de recursos.

Fuentes de datos y configuraciones dinámicas

Las fuentes de datos en Terraform te permiten obtener información sobre los recursos existentes, tanto los gestionados por Terraform como los que no. Esto es increíblemente útil para integrarse con infraestructuras preexistentes o para búsquedas dinámicas. 

Junto con las configuraciones dinámicas (como for_each y count), las fuentes de datos permiten scripts Terraform muy flexibles y adaptables que pueden reaccionar ante diversas condiciones y disponibilidad de recursos.

Ejemplo: Utilizar una Fuente de Datos para encontrar una VNet existente y añadir una nueva subred:

# Data source to fetch an existing Virtual Network
data "azurerm_virtual_network" "existing_vnet" {
  name                = "production-vnet"
  resource_group_name = "production-network-rg"
}

# Create a new subnet within the existing VNet
resource "azurerm_subnet" "new_app_subnet" {
  name                 = "new-app-subnet"
  resource_group_name  = data.azurerm_virtual_network.existing_vnet.resource_group_name
  virtual_network_name = data.azurerm_virtual_network.existing_vnet.name
  address_prefixes     = ["10.0.3.0/24"]
}

Ejemplo: Creación dinámica de varias máquinas virtuales utilizando for_each y una variable de mapa:

variable "vm_configs" {
  type = map(object({
    size = string
    ip   = string
  }))
  default = {
    "web-server-01" = { size = "Standard_B1s", ip = "10.0.1.10" },
    "web-server-02" = { size = "Standard_B1s", ip = "10.0.1.11" }
  }
}

resource "azurerm_linux_virtual_machine" "web_servers" {
  for_each              = var.vm_configs
  name                  = each.key
  location              = azurerm_resource_group.main_rg.location
  resource_group_name   = azurerm_resource_group.main_rg.name
  size                  = each.value.size
  admin_username        = "azureuser"
  admin_password        = "StrongPassword!123" # Use Key Vault in production
  network_interface_ids = [azurerm_network_interface.web_servers_nic[each.key].id]

  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
  }

  source_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "18.04-LTS"
    version   = "latest"
  }
}

resource "azurerm_network_interface" "web_servers_nic" {
  for_each            = var.vm_configs
  name                = "${each.key}-nic"
  location            = azurerm_resource_group.main_rg.location
  resource_group_name = azurerm_resource_group.main_rg.name

  ip_configuration {
    name                          = "internal"
    subnet_id                     = azurerm_subnet.web_subnet.id
    private_ip_address_allocation = "Static"
    private_ip_address            = each.value.ip
  }
}

Política como código con Sentinel

Para las organizaciones que requieren un cumplimiento y una gobernanza estrictos, HashiCorp Sentinel proporciona un marco de políticas como código que se integra con Terraform Enterprise (o puede adaptarse para un uso personalizado con Terraform Cloud). 

Sentinel te permite definir políticas granulares que apliquen las mejores prácticas operativas, de seguridad y de costes antes de que se aprovisione la infraestructura de de aprovisionar la infraestructura.

Por ejemplo, una política podría impedir la creación de máquinas virtuales mayores de un tamaño determinado o garantizar que todos los recursos tengan etiquetas específicas. Las políticas predefinidas pueden aplicar las normas de cumplimiento, impidiendo que las implantaciones no conformes lleguen nunca a tu entorno Azure.

Estrategias de optimización de costes

Terraform, junto con Azure Policy, puede ser una potente herramienta para imponer controles de costes en tu entorno Azure. 

Al definir políticas de Azure que restrinjan las SKU de recursos, impongan el etiquetado para la asignación de costes o impidan el despliegue de recursos caros, puedes aplicar medidas eficaces de ahorro de costes directamente dentro de tus flujos de trabajo de IaC. 

Terraform también puede desplegar y gestionar políticas de Azure, garantizando que tus normas de gobierno estén controladas por versiones y se apliquen de forma coherente.

Ejemplo: Despliegue de una definición de política de Azure con Terraform:

resource "azurerm_resource_group" "policy_rg" {
  name     = "azure-policy-rg"
  location = "global" # Policies are global resources
}

resource "azurerm_policy_definition" "deny_large_vms" {
  name         = "deny-large-vm-skus"
  policy_type  = "Custom"
  mode         = "All"
  display_name = "Deny creation of large VM SKUs (E-series)"
  description  = "This policy denies the creation of Azure Virtual Machines with SKUs from the E-series for cost management."

  policy_rule = <<POLICY_RULE
{
  "if": {
    "allOf": [
      {
        "field": "type",
        "equals": "Microsoft.Compute/virtualMachines"
      },
      {
        "field": "Microsoft.Compute/virtualMachines/sku.name",
        "like": "Standard_E*"
      }
    ]
  },
  "then": {
    "effect": "deny"
  }
}
POLICY_RULE
}

resource "azurerm_policy_assignment" "deny_large_vms_assignment" {
  name                 = "deny-large-vm-skus-assignment"
  scope                = "/subscriptions/${data.azurerm_subscription.current.id}" # Assign to entire subscription
  policy_definition_id = azurerm_policy_definition.deny_large_vms.id
  display_name         = "Deny large VM SKUs"
}

data "azurerm_subscription" "current" {}

Esta combinación te permite aplicar políticas de costes organizativos de forma automática, evitando el gasto excesivo y fomentando la eficiencia de los recursos.

Integración CI/CD

Esta sección se centra en la integración de Terraform en tus canalizaciones de Integración Continua/Entrega Continua (CI/CD) para realizar despliegues automatizados y fiables, convirtiendo los cambios de infraestructura en una parte fluida de tu ciclo de vida de desarrollo de software.

Azure DevOps pipelines

Azure DevOps proporciona una sólida plataforma para crear canalizaciones CI/CD. Un flujo de trabajo habitual incluye:

1. Inicializar: terraform init para descargar proveedores y configurar el backend.
2. Plan: terraform plan -out para generar un plan de ejecución y guardarlo.
3. Revisión (aprobación manual): Etapa en la que el plan generado es revisado por un humano para que lo apruebe antes de aplicarlo.
4. Aplicar: terraform apply tfplan para ejecutar los cambios.

Puedes explorar cómo Azure DevOps soporta los flujos de trabajo CI/CD de extremo a extremo para el despliegue de aplicacionesen este tutorial práctico.

Acciones de GitHub

Las Acciones de GitHub ofrecen una forma flexible y potente de automatizar tus flujos de trabajo de Terraform directamente dentro de tus repositorios de GitHub. Utiliza archivos YAML para definir flujos de trabajo que respondan a eventos como solicitudes push o pull.

Estos son los pasos para un despliegue básico de Terraform utilizando GitHub Actions:

1. Define el desencadenante del flujo de trabajo: Normalmente on: push a una rama específica (por ejemplo, main).
2. Código de pago: Utiliza actions/checkout@v3.
3. Configura las credenciales de Azure: Configura las variables de entorno utilizando los Secretos de GitHub (por ejemplo, AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_TENANT_ID, AZURE_SUBSCRIPTION_ID).
4. Instala Terraform: Utiliza hashicorp/setup-terraform@v2.
5. Terraform init: Inicializa el directorio de trabajo.
6. Plan de terraformación: Crea y da salida al plan de ejecución.
7. Terraformar aplicar (condicional): Aplicar cambios, a menudo condicionados a un paso de aprobación manual o a una rama específica.

Ejemplo: YAML para un flujo de trabajo de Acciones de GitHub (.github/workflows/terraform-azure.yml):

name: 'Terraform Azure CI/CD'

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

env:
  ARM_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
  ARM_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
  ARM_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
  ARM_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
  TF_STATE_RG: 'my-terraform-state-rg'
  TF_STATE_SA: 'mystorageterraformstate'
  TF_STATE_CONTAINER: 'tfstate'
  TF_STATE_KEY: 'production/terraform.tfstate'

jobs:
  terraform:
    name: 'Terraform Actions'
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: './terraform' # Assuming Terraform files are in a 'terraform' folder

    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - name: Setup Terraform
        uses: hashicorp/setup-terraform@v2
      - name: Terraform Init
        id: init
        run: terraform init -backend-config="resource_group_name=${{ env.TF_STATE_RG }}" -backend-config="storage_account_name=${{ env.TF_STATE_SA }}" -backend-config="container_name=${{ env.TF_STATE_CONTAINER }}" -backend-config="key=${{ env.TF_STATE_KEY }}"
      - name: Terraform Plan
        id: plan
        run: terraform plan -no-color
      - name: Terraform Apply
        if: github.ref == 'refs/heads/main' && github.event_name == 'push'
        run: terraform apply -auto-approve

Seguridad y cumplimiento

Esta sección destaca las consideraciones de seguridad y cumplimiento al trabajar con Terraform en Azure, haciendo hincapié en las prácticas seguras para los datos sensibles y el acceso a la red.

Integración con Azure Key Vault

Gestionar datos sensibles como claves de API, cadenas de conexión, credenciales de bases de datos y certificados dentro de tus configuraciones de Terraform puede ser arriesgado si no se gestionan adecuadamente. Azure Key Vault proporciona una solución segura y centralizada para almacenar y gestionar secretos, claves y certificados. 

Ejemplo: Recuperar la contraseña de una base de datos de Key Vault:

# Data source to retrieve an existing Azure Key Vault
data "azurerm_key_vault" "my_key_vault" {
  name                = "my-secure-keyvault"
  resource_group_name = "my-secrets-rg"
}

# Data source to retrieve a specific secret from the Key Vault
data "azurerm_key_vault_secret" "db_password" {
  name         = "DbPassword"
  key_vault_id = data.azurerm_key_vault.my_key_vault.id
}

resource "azurerm_sql_server" "example" {
  administrator_login          = "sqladmin"
  administrator_login_password = data.azurerm_key_vault_secret.db_password.value # Securely retrieve password
}

Este método garantiza que los datos sensibles nunca queden expuestos en tu código Terraform o en tu archivo de estado directamente, respetando las mejores prácticas de seguridad.

Grupos de Seguridad de Red (GSN)

Los Grupos de Seguridad de Red (NSG) son fundamentales para aplicar reglas de tráfico y proteger tus redes virtuales Azure. Actúan como un cortafuegos virtual, permitiendo o denegando el tráfico de red entrante y saliente a tus recursos de Azure en función de las reglas que definas.

Ejemplo: Configurar una NSG para una aplicación web:

resource "azurerm_network_security_group" "web_nsg" {
  name                = "web-nsg"
  location            = azurerm_resource_group.network_rg.location
  resource_group_name = azurerm_resource_group.network_rg.name

  security_rule {
    name                       = "AllowHTTPInbound"
    priority                   = 100
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "80"
    source_address_prefix      = "Internet"
    destination_address_prefix = "*"
  }
  security_rule {
    name                       = "AllowSSHInbound"
    priority                   = 120
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "22"
    source_address_prefix      = "YourTrustedIPRange" # IMPORTANT: Restrict to known IPs
    destination_address_prefix = "*"
  }
}

# Associate NSG with a subnet 
resource "azurerm_subnet_network_security_group_association" "web_subnet_nsg_association" {
  subnet_id                 = azurerm_subnet.web_subnet.id
  network_security_group_id = azurerm_network_security_group.web_nsg.id
}

Buenas prácticas para implantaciones en empresas

Esta sección describe las mejores prácticas esenciales para desplegar y gestionar Terraform a escala en un entorno empresarial, centrándose en el diseño, el mantenimiento y la supervisión.

Arquitecturas de referencia

Para que las implantaciones en Azure sean sólidas y eficientes, alinea tus configuraciones de Terraformcon el Azure Well-Architected Framework. Estemarco proporciona planos para diseñar soluciones en la nube de alta calidad, seguras y rentables, guiando tus diseños Terraform en cuanto a fiabilidad, seguridad, optimización de costes, excelencia operativa y eficiencia de rendimiento.

Higiene del archivo estatal

El archivo de estado de Terraform es la única fuente de verdad de tu infraestructura. Garantizar su integridad y seguridad

• Almacenamiento remoto: Utiliza siempre un backend remoto como Azure Blob Storage para la gestión colaborativa del estado.
• Cifrado y control de acceso: Comprueba que tu estado remoto está cifrado en reposo y aplica Azure RBAC estricto para limitar el acceso.
• Bloqueo de estado y versionado: Aprovecha el bloqueo de estado integrado para evitar conflictos y habilita el control de versiones en tu contenedor de almacenamiento para el seguimiento histórico y la recuperación.

Vigilancia y detección de desviaciones

Mantén la coherencia de la infraestructura controlando activamente la "deriva de la configuración", es decir, las desviaciones no autorizadas de tu estado Terraform definido.

• Detección proactiva: Implementa ejecuciones regulares de terraform plan dentro de tus pipelines CI/CD (por ejemplo, cada noche) para identificar los cambios.
• Supervisión de Azure: Utiliza Azure Monitor y Log Analytics para hacer un seguimiento del estado de los recursos y los eventos.
• Reparación automatizada: Desarrolla procesos (manuales o automatizados) para volver a ejecutar terraform apply para que los recursos desviados vuelvan a cumplir tu IaC.

Para supervisar y optimizar aún más tu infraestructura, Azure Monitor proporciona información valiosa: estaguía te muestra cómo empezar.

Conclusión

¡Y ya está! A estas alturas, ya habrás visto cómo Terraform puede hacer que la gestión de los recursos de Azure sea mucho más eficiente y predecible. Hemos visto cómo introducir la automatización en tu flujo de trabajo con herramientas de CI/CD como Azure DevOps y GitHub Actions, y cómo mantener la seguridad utilizando funciones como Azure Key Vault y Network Security Groups.

También abordamos algunas prácticas recomendadas importantes, como el uso de arquitecturas de referencia, la gestión cuidadosa de los archivos de estado y el control de los cambios mediante la supervisión y la detección de desviaciones.

Con estas herramientas y consejos, estarás bien encaminado para crear una infraestructura más fiable y escalable en Azure.

¿Buscas validar tus competencias? ¡Estas preguntas de la entrevista Terraform pueden ayudarte a prepararte para las oportunidades de trabajo o certificaciones!