Terraform no Azure: Guia prático de IaC para iniciantes

Se você já se viu clicando no portal do Azure, tentando reunir os recursos da nuvem manualmente, eu também já passei por isso - e isso fica velho rapidamente. É aí que entra o Terraform. É uma ferramenta de infraestrutura como código (IaC) que permite que você defina e gerencie sua configuração de nuvem com apenas algumas linhas de código.

Neste tutorial, vamos nos concentrar no uso do Terraform com o Azure. Vou mostrar a você o que é o Terraform, como ele funciona no ecossistema do Azure e como começar com exemplos práticos. Também abordaremos algumas práticas recomendadas para ajudar você a criar implementações seguras e confiáveis desde o início.

Se você é novo no ecossistema do Azure, este programa de fundamentos do Azure oferece uma introdução estruturada aos principais serviços e princípios.

Por que usar o Terraform no Azure?

O Terraform, desenvolvidopela HashiCorp, é uma ferramenta de IaC de código aberto que permite que você defina e gerencie a infraestrutura de nuvem usando uma sintaxe declarativa. Quando combinado com o Microsoft Azure, ele permite que você crie scripts de recursos como redes virtuais, VMs e bancos de dados em arquivos de configuração legíveis por humanos.

Por que usar o Terraform com o Azure? O que importa é a consistência, o dimensionamento e a velocidade. Não importa se você está criando uma única VM ou orquestrando um aplicativo complexo de várias camadas, o Terraform simplifica o processo e reduz o erro humano.

Se você é completamente novo no Terraform, este guia para iniciantes no Terraformexplica os fundamentos e como começar a usá-lo para infraestrutura como código.

Conceitos básicos do Terraform no Azure

A integração do Terraform com o Azure oferece um conjunto de recursos que tornam o gerenciamento da infraestrutura intuitivo e avançado. Vamos examinar os principais componentes e tipos de recursos do Terraform disponíveis.

Gerenciamento de infraestrutura declarativa

A abordagem declarativa do Terraform permite que você defina como deve ser sua infraestrutura do Azure em arquivos .tf usando a HCL (HashiCorp Configuration Language). 

Por exemplo, você pode especificar uma VM do Azure com seu tamanho, local e configurações de rede, e o Terraform cuida do processo de criação. Aqui está uma rápida olhada:

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
}

A definição acima garante a idempotência - a execução do mesmo código várias vezes fornece o mesmo resultado sem duplicatas ou erros. 

Agora, vamos detalhar os principais conceitos do Terraform que fazem essa abordagem declarativa funcionar.

Estado do Terraform (.tfstate)

O arquivo terraform.tfstate é o coração do modelo declarativo do Terraform. É um arquivo JSON que registra o estado atual dos seus recursos do Azure - o que está implantado, suas configurações e seus relacionamentos. 

Quando você executa terraform apply, o Terraform compara seus arquivos .tf (o estado desejado) com o arquivo .tfstate (o estado real) para determinar quais alterações devem ser feitas. Por exemplo, se você atualizar o tamanho de uma VM no seu código, o Terraform verificará o arquivo .tfstate e modificará apenas esse atributo no Azure. 

Você pode armazenar esse arquivo localmente, mas, para equipes, use o Azure Blob Storage para permitir a colaboração e o bloqueio de estado para evitar conflitos.

Variáveis do Terraform (.tfvars)

As variáveis tornam suas configurações flexíveis e reutilizáveis. Definidos em variables.tf e terraform.tfvars, eles permitem que você parametrize valores como nomes de recursos ou regiões. 

Por exemplo:

# 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
}

O arquivo terraform.tfvars substitui os padrões, de modo que você pode implantar o mesmo código em diferentes regiões sem editar os arquivos .tf principais. Isso pode ser usado para gerenciar vários ambientes (por exemplo, desenvolvimento, produção).

Arquivos de configuração do Terraform (.tf)

Esses arquivos contêm o código da infraestrutura, que é escrito em HCL. Eles definem recursos, provedores, módulos e muito mais. Você pode organizá-los como um único main.tf ou dividi-los em vários arquivos (por exemplo, variables.tf, outputs.tf, network.tf, compute.tf) para maior clareza e melhor organização.

Plano de Terraform

Antes de aplicar as alterações, o comando terraform plan mostra uma prévia do que o Terraform fará - criar, atualizar ou excluir recursos - com base na diferença entre os arquivos .tf e .tfstate. É como um teste de funcionamento que detecta problemas potenciais antecipadamente, exibindo um resumo detalhado das ações propostas.

Aplicar o Terraform

O comando terraform apply executa as alterações identificadas por terraform plan, atualizando o Azure para que corresponda ao estado desejado por você e atualizando o arquivo .tfstate. Você será solicitado a confirmar antes que as alterações sejam aplicadas, o que proporciona uma rede de segurança.

Espaços de trabalho

Os espaços de trabalho do Terraform permitem que você gerencie vários ambientes (por exemplo, desenvolvimento, preparação, produção) com um único conjunto de arquivos .tf. Cada espaço de trabalho tem seu próprio arquivo .tfstate, para que você possa implantar uma infraestrutura semelhante com configurações diferentes (por exemplo, tamanhos de VM diferentes para desenvolvimento e produção). 

Para criar um novo espaço de trabalho, você pode usar:

terraform workspace new production

Em seguida, você pode alternar para o espaço de trabalho:

terraform workspace select production

Módulos

Os módulos são pacotes reutilizáveis de código do Terraform. Por exemplo, você pode criar um módulo para uma rede virtual do Azure e reutilizá-lo em projetos, reduzindo a duplicação e promovendo a padronização. Falaremos mais sobre módulos na seção de práticas recomendadas.

Esses conceitos -.tfstate, .tfvars e o fluxo de trabalho declarativo - trabalham juntos para garantir que sua infraestrutura do Azure seja previsível, reproduzível e fácil de gerenciar.

Gerenciamento e colaboração do estado

O arquivo terraform.tfstate programa o estado da sua infraestrutura. Para as equipes, armazená-lo no Azure Blob Storage é uma prática recomendada essencial para permitir o acesso compartilhado e o controle de versão. Essa configuração de backend remoto permite que todos os membros da equipe trabalhem com uma visão consistente da infraestrutura. 

O bloqueio de estado, um recurso fornecido automaticamente por muitos back-ends remotos, como o Azure Blob Storage, evita conflitos quando vários membros da equipe tentam executar comandos do Terraform simultaneamente, garantindo a integridade dos dados.

Aqui está um exemplo de configuração de um backend do 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 executar o terraform init com essa configuração, você precisaria criar a conta de armazenamento e o contêiner do Azure manualmente ou por meio de uma configuração separada do Terraform. Essa configuração garante o gerenciamento seguro e colaborativo dos recursos do Azure.

Ecossistema de provedores e AzureRM

O provedor azurerm éa ponte do Terraformpara o Azure, traduzindo HCL em chamadas de API para gerenciar serviços como VMs, redes e bancos de dados.

Ele oferece suporte a centenas de tipos de recursos, desde computação (azurerm_linux_virtual_machine, azurerm_windows_virtual_machine) até análises (azurerm_synapse_workspace). Alguns de seus recursos incluem:

• Ampla cobertura: Gerencie uma vasta gama de serviços do Azure, incluindo máquinas virtuais, contas de armazenamento, Serviço de Kubernetes do Azure (AKS), Banco de Dados SQL do Azure, Azure Cosmos DB com API MongoDB, Azure Functions e muito mais. O provedor azurerm é desenvolvido ativamente para oferecer suporte a novos serviços e recursos do Azure à medida que são disponibilizados.
• Funções dinâmicas: Use funções definidas pelo provedor para gerar nomes exclusivos (por exemplo, azurerm_resource_group.example.name) ou buscar detalhes sobre recursos existentes (por exemplo, data.azurerm_virtual_network.existing.id). Isso permite configurações mais dinâmicas e inteligentes.
• Fontes de dados: O provedor azurerm aproveita as fontes de dados para obter informações sobre os recursos existentes do Azure. Isso é particularmente útil quando você precisa fazer referência a recursos que não foram provisionados pela sua configuração atual do Terraform. Por exemplo, você pode recuperar detalhes de uma rede virtual existente para implantar novas sub-redes ou máquinas virtuais sem recriar a VNet.

Antes de mergulhar no Terraform, é útil entender como configurar manualmenteo Azure - esteguia para iniciantes orienta você sobre os aspectos essenciais.

Configuração de um ambiente Terraform-Azure

Vamos colocar a mão na massa! Esta seção orienta você na configuração inicial necessária para usar o Terraform com sua assinatura do Azure.

Ferramentas de autenticação e CLI

Para interagir com o Azure, primeiro você precisa instalar e configurara interface de linha de comando (CLI) do Azure. A CLI do Azure pfornece as ferramentas necessárias para autenticação e gerenciamento dos recursos do Azure. Depois de instalado, faça login na sua conta do Azure:

az login

O comando acima abrirá uma janela do navegador para autenticação interativa. Para uma referência rápida, esta folha de dicas da CLI do Azure podesimplificar seus fluxos de trabalho de linha de comando.

Para implantações automatizadas com o Terraform, especialmente em pipelines de CI/CD, é altamente recomendável que você crie e utilize as entidades de serviço do Azure Active Directory (AAD). As entidades de serviço fornecem uma maneira segura e programática para o Terraform se autenticar com sua assinatura do Azure sem exigir logins interativos.

Para criar uma entidade de serviço com a função "Colaborador" no escopo da assinatura, execute:

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

O resultado fornecerá appId, password e tenant (ID do locatário). Você pode então defini-las como variáveis de ambiente para o Terraform:

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

Inicialização de um projeto

Um projeto típico do Terraform segue um layout de diretório estruturado, geralmente com arquivos .tf separados para diferentes tipos de recursos ou módulos (por exemplo, main.tf, variables.tf, outputs.tf, network.tf, compute.tf). 

Para iniciar qualquer projeto do Terraform, navegue até o diretório do projeto e execute o comando terraform init. Esse comando inicializa o diretório de trabalho, faz o download dos plug-ins de provedor necessários (como azurerm) e configura o backend para o gerenciamento de estado, conforme definido em sua configuração.

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

Esse comando prepara seu diretório para as operações do Terraform, garantindo que todos os plug-ins necessários estejam instalados.

Provisionamento de recursos do Azure

Esta seção fornece exemplos práticos de provisionamento de recursos comuns do Azure usando o Terraform, demonstrando como defini-los e implantá-los programaticamente.

Redes e sub-redes virtuais

O Terraform é excelente para definir e implantar a infraestrutura de rede no Azure. Você pode definir facilmente redes virtuais (VNets) e segmentá-las em sub-redes, controlando os espaços de endereços IP e o isolamento da rede. 

O gerenciamento de dependências inerente do Terraform garante que os recursos sejam criados na ordem correta; por exemplo, as sub-redes só serão provisionadas depois que a VNet principal tiver sido criada com sucesso. Aqui está um exemplo:

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 virtuais com nuvem-init

O provisionamento de máquinas virtuais (VMs) com o Terraform é simples. Para automatizar a configuração pós-implantação e a instalação inicial, você pode aproveitar os scripts do cloud-init. 

cloud-init permite que você injete scripts que são executados na primeira inicialização da VM, permitindo tarefas como instalação de software, configuração de usuários ou configuração de serviços, diretamente da configuração do Terraform.

Aqui está um exemplo de provisionamento de uma VM Linux com um simples script cloud-init para instalar o 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
  )
}

Modularização da infraestrutura

À medida que sua infraestrutura do Azure cresce, a modularização das configurações do Terraform se torna crucial para a reutilização, a manutenção e a escalabilidade. 

Os módulos encapsulam um conjunto de recursos relacionados e suas configurações em unidades reutilizáveis. Esta seção fornecerá orientações sobre como estruturar o código do Terraform em módulos e demonstrará como invocar esses módulos nas configurações principais, promovendo uma base de código mais limpa e organizada.

Exemplo: Estrutura do 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
}

Exemplo: Invocando o módulo (main.tf no diretório raiz):

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
}

Essa estrutura facilita a reutilização da lógica de implantação de aplicativos da Web em diferentes ambientes ou projetos.

Fluxos de trabalho avançados do Terraform

Esta seção explora recursos mais sofisticados do Terraform que aumentam a flexibilidade e o poder das suas implantações de infraestrutura, indo além do provisionamento básico de recursos.

Fontes de dados e configurações dinâmicas

As fontes de dados no Terraform permitem que você obtenha informações sobre os recursos existentes, tanto os gerenciados pelo Terraform quanto os não gerenciados. Isso é incrivelmente útil para a integração com a infraestrutura pré-existente ou para pesquisas dinâmicas. 

Juntamente com configurações dinâmicas (como for_each e count), as fontes de dados permitem scripts do Terraform altamente flexíveis e adaptáveis que podem reagir a várias condições e à disponibilidade de recursos.

Exemplo: Usando uma fonte de dados para localizar uma VNet existente e adicionar uma nova sub-rede:

# 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"]
}

Exemplo: Criação dinâmica de várias VMs usando for_each e uma variável 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 com o Sentinel

Para organizações que exigem conformidade e governança rigorosas, o HashiCorp Sentinel fornece uma estrutura de política como código que se integra ao Terraform Enterprise (ou pode ser adaptada para uso personalizado com o Terraform Cloud). 

O Sentinel permite que você defina políticas granulares que reforcem as práticas recomendadas de segurança, custo e operação antes que a infraestrutura seja provisionada.

Por exemplo, uma política pode impedir a criação de VMs maiores que um determinado tamanho ou garantir que todos os recursos tenham tags específicas. As políticas pré-criadas podem impor padrões de conformidade, impedindo que implantações fora de conformidade cheguem ao seu ambiente do Azure.

Estratégias de otimização de custos

O Terraform, em conjunto com o Azure Policy, pode ser uma ferramenta poderosa para impor controles de custo no seu ambiente do Azure. 

Ao definir as Políticas do Azure que restringem as SKUs de recursos, impõem a marcação para alocação de custos ou impedem a implantação de recursos caros, você pode implementar medidas eficazes de economia de custos diretamente nos fluxos de trabalho de IaC. 

O Terraform também pode implantar e gerenciar as Políticas do Azure, garantindo que suas regras de governança sejam controladas por versão e aplicadas de forma consistente.

Exemplo: Implantando uma definição de política do Azure com o 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" {}

Essa combinação permite que você aplique políticas de custos organizacionais automaticamente, evitando gastos excessivos e promovendo a eficiência dos recursos.

Integração de CI/CD

Esta seção se concentra na integração do Terraform aos seus pipelines de integração contínua/entrega contínua (CI/CD) para implantações automatizadas e confiáveis, tornando as alterações de infraestrutura uma parte perfeita do seu ciclo de vida de desenvolvimento de software.

Azure DevOps pipelines

O Azure DevOps fornece uma plataforma robusta para a criação de pipelines de CI/CD. Um fluxo de trabalho comum inclui:

1. Inicializar: terraform init para baixar provedores e configurar o back-end.
2. Plano: terraform plan -out para gerar um plano de execução e salvá-lo.
3. Revisão (aprovação manual): Um estágio em que o plano gerado é revisado por um ser humano para aprovação antes da aplicação.
4. Aplicar: terraform apply tfplan para executar as alterações.

Você pode explorar como o Azure DevOps oferece suporte a fluxos de trabalho de CI/CD de ponta a ponta para implantação de aplicativosneste tutorial prático.

Ações do GitHub

O GitHub Actions oferece uma maneira flexível e eficiente de automatizar os fluxos de trabalho do Terraform diretamente nos repositórios do GitHub. Ele usa arquivos YAML para definir fluxos de trabalho que respondem a eventos como solicitações push ou pull.

Aqui estão as etapas para uma implantação básica do Terraform usando o GitHub Actions:

1. Definir o acionador do fluxo de trabalho: Normalmente, on: push é um ramo específico (por exemplo, main).
2. Código de checkout: Use actions/checkout@v3.
3. Configure as credenciais do Azure: Configure as variáveis de ambiente usando GitHub Secrets (por exemplo, AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_TENANT_ID, AZURE_SUBSCRIPTION_ID).
4. Instale o Terraform: Use hashicorp/setup-terraform@v2.
5. Inicialização do Terraform: Inicializar o diretório de trabalho.
6. Plano de Terraform: Crie e produza o plano de execução.
7. Aplicar o Terraform (condicional): Aplicar alterações, geralmente condicionadas a uma etapa de aprovação manual ou a uma ramificação específica.

Exemplo: YAML para um fluxo de trabalho do GitHub Actions (.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

Segurança e conformidade

Esta seção destaca as considerações de segurança e conformidade ao trabalhar com o Terraform no Azure, enfatizando práticas seguras para dados confidenciais e acesso à rede.

Integração com o Azure Key Vault

O gerenciamento de dados confidenciais, como chaves de API, cadeias de conexão, credenciais de banco de dados e certificados nas configurações do Terraform, pode ser arriscado se você não lidar com eles adequadamente. O Azure Key Vault fornece uma solução segura e centralizada para armazenar e gerenciar segredos, chaves e certificados. 

Exemplo: Recuperação de uma senha de banco de dados do 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
}

Esse método garante que os dados confidenciais nunca sejam expostos diretamente no código do Terraform ou no arquivo de estado, aderindo às práticas recomendadas de segurança.

Grupos de segurança de rede (NSGs)

Os grupos de segurança de rede (NSGs) são fundamentais para aplicar regras de tráfego e proteger suas redes virtuais do Azure. Eles atuam como um firewall virtual, permitindo ou negando o tráfego de rede de entrada e saída para seus recursos do Azure com base nas regras que você define.

Exemplo: Configuração de um NSG para um aplicativo da 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
}

Práticas recomendadas para implementações corporativas

Esta seção descreve as práticas recomendadas essenciais para implantar e gerenciar o Terraform em escala em um ambiente corporativo, com foco em design, manutenção e monitoramento.

Arquiteturas de referência

Para obter implantações robustas e eficientes do Azure, alinhe suas configurações do Terraformcom a estrutura bem arquitetada do Azure. Essaestrutura fornece planos para que você projete soluções de nuvem de alta qualidade, seguras e econômicas, orientando seus projetos do Terraform quanto à confiabilidade, segurança, otimização de custos, excelência operacional e eficiência de desempenho.

Higiene do arquivo estadual

O arquivo de estado do Terraform é a única fonte de verdade da sua infraestrutura. Garantir sua integridade e segurança:

• Armazenamento remoto: Sempre use um backend remoto, como o Azure Blob Storage, para o gerenciamento de estado colaborativo.
• Criptografia e controle de acesso: Verifique se o seu estado remoto está criptografado em repouso e aplique o RBAC estrito do Azure para limitar o acesso.
• Bloqueio de estado e controle de versão: Aproveite o bloqueio de estado integrado para evitar conflitos e habilite o controle de versão no contêiner de armazenamento para rastreamento e recuperação de histórico.

Monitoramento e detecção de desvios

Mantenha a consistência da infraestrutura monitorando ativamente o "desvio de configuração" - desvios não autorizados do estado definido do Terraform.

• Detecção proativa: Implemente execuções regulares do terraform plan em seus pipelines de CI/CD (por exemplo, todas as noites) para identificar alterações.
• Monitoramento do Azure: Utilize o Azure Monitor e o Log Analytics para rastrear a integridade e os eventos dos recursos.
• Correção automatizada: Desenvolva processos (manuais ou automatizados) para executar novamente o site terraform apply para que os recursos desviados voltem a estar em conformidade com seu IaC.

Para monitorar e otimizar ainda mais sua infraestrutura, o Azure Monitor fornece insights valiosos - esteguia mostra a você como começar.

Conclusão

E isso é tudo! Até agora, você já viu como o Terraform pode tornar o gerenciamento dos recursos do Azure muito mais eficiente e previsível. Vimos como trazer a automação para o seu fluxo de trabalho com ferramentas de CI/CD, como o Azure DevOps e o GitHub Actions, e como manter as coisas seguras usando recursos como o Azure Key Vault e os Grupos de Segurança de Rede.

Também abordamos algumas práticas recomendadas importantes, como o uso de arquiteturas de referência, o gerenciamento cuidadoso dos arquivos de estado e a observação das alterações com monitoramento e detecção de desvios.

Com essas ferramentas e dicas, você está no caminho certo para criar uma infraestrutura mais confiável e dimensionável no Azure.

Você está procurando validar suas habilidades? Essas perguntas da entrevista do Terraform podem ajudar você a se preparar para oportunidades de emprego ou certificações!