Implementar testes de integração para projetos Terraform no Azure

Artigo
01/15/2025

Terraform permite a definição, visualização e implantação de infraestrutura em nuvem. Usando o Terraform, você cria arquivos de configuração usando sintaxe HCL. A sintaxe HCL permite especificar o provedor de nuvem - como o Azure - e os elementos que compõem sua infraestrutura de nuvem. Depois de criar os arquivos de configuração, você cria um plano de execução que permite visualizar as alterações na infraestrutura antes que elas sejam implantadas. Depois de verificar as alterações, você aplica o plano de execução para implantar a infraestrutura.

Os testes de integração validam que uma alteração de código recém-introduzida não quebra o código existente. Em DevOps, integração contínua (CI) refere-se a um processo que constrói todo o sistema sempre que a base de código é alterada - como alguém querendo mesclar um PR em um repositório Git. A lista a seguir contém exemplos comuns de testes de integração:

Ferramentas de análise de código estático, como Lint e ferramentas de formatação.
Execute terraform validate para verificar a sintaxe do ficheiro de configuração.
Execute plano de terraforma para garantir que a configuração funcione conforme o esperado.

Neste artigo, você aprenderá a:

Aprenda as noções básicas de testes de integração para projetos Terraform.
Use o Azure DevOps para configurar um pipeline de integração contínua.
Execute a análise de código estático no código Terraform.
Execute terraform validate para validar os arquivos de configuração do Terraform na máquina local.
Execute terraform plan para validar esses arquivos de configuração do Terraform de uma perspetiva de serviços remotos.
Use um Pipeline do Azure para automatizar a integração contínua.

1. Configure seu ambiente

Subscrição do Azure: Se ainda não tiver uma subscrição do Azure, crie uma conta gratuita antes de começares.

Configurar o Terraform: Se você ainda não tiver feito isso, configure o Terraform usando uma das seguintes opções:

organização ede projeto do Azure DevOps: se você não tiver um, criar uma organização do Azure DevOps.
Extensão Terraform Build & Tarefas de Lançamento: Instale a extensão de tarefas de construção/liberação do Terraform na sua organização do Azure DevOps.
Conceder acesso ao Azure DevOps ao seude Assinatura do Azure: Criar uma conexão de serviço do Azure chamada terraform-basic-testing-azure-connection para permitir que o Azure Pipelines se conecte às suas assinaturas do Azure
Exemplo de código e recursos: Baixe do GitHub o projeto de teste de integração . O diretório no qual você baixa o exemplo é chamado de diretório de exemplo .

2. Validar uma configuração local do Terraform

O comando terraform validate é executado a partir da linha de comando no diretório que contém seus arquivos Terraform. O objetivo principal deste comando é validar a sintaxe.

Dentro do diretório de exemplo, navegue até o diretório src.
Execute terraform init para inicializar o diretório de trabalho.
```
terraform init
```
Execute o comando terraform validate para validar a sintaxe dos ficheiros de configuração.
```
terraform validate
```
Pontos principais:
- Você verá uma mensagem indicando que a configuração do Terraform é válida.
Edite o arquivo main.tf.
Na linha 5, insira um erro de digitação que invalide a sintaxe. Por exemplo, substitua var.location por var.loaction
Salve o arquivo.
Execute a validação novamente.
```
terraform validate
```
Pontos principais:
- Você verá uma mensagem de erro indicando a linha de código em erro e uma descrição do erro.

Como você pode ver, Terraform detetou um problema na sintaxe do código de configuração. Esse problema impede que a configuração seja implantada.

É uma boa prática sempre executar terraform validate contra seus arquivos Terraform antes de enviá-los para o seu sistema de controle de versão. Além disso, esse nível de validação deve fazer parte do seu pipeline de integração contínua. Mais adiante neste artigo, exploraremos como configurar um pipeline do Azure para validar automaticamente.

3. Validar a configuração do Terraform

Na seção anterior, você viu como validar uma configuração do Terraform. Esse nível de teste era específico da sintaxe. Esse teste não levou em consideração o que já poderia ser implantado no Azure.

Terraform é uma linguagem declarativa significa que você declara o que deseja como resultado final. Por exemplo, digamos que você tenha 10 máquinas virtuais em um grupo de recursos. Em seguida, você cria um arquivo Terraform definindo três máquinas virtuais. A aplicação deste plano não aumenta a contagem total para 13. Em vez disso, o Terraform exclui sete das máquinas virtuais para que você termine com três. Executar terraform plan permite confirmar os resultados potenciais da aplicação de um plano de execução para evitar surpresas.

Para gerar o plano de execução Terraform, execute terraform plan. Esse comando se conecta à assinatura do Azure de destino para verificar qual parte da configuração já está implantada. Terraform então determina as mudanças necessárias para atender aos requisitos declarados no arquivo Terraform. Nesta fase, a Terraform não está implantando nada. Isto diz-lhe o que acontecerá se aplicar o plano.

Se você estiver acompanhando o artigo e tiver feito as etapas na seção anterior, execute o comando terraform plan:

terraform plan

Depois de executar terraform plan, Terraform exibe o resultado potencial da aplicação do plano de execução. A saída indica os recursos do Azure que serão adicionados, alterados e destruídos.

Por padrão, o Terraform armazena o estado no mesmo diretório local que o arquivo Terraform. Esse padrão funciona bem em cenários de usuário único. No entanto, quando várias pessoas trabalham nos mesmos recursos do Azure, os arquivos de estado local podem ficar fora de sincronia. Para resolver esse problema, o Terraform oferece suporte à gravação de arquivos de estado em um armazenamento de dados remoto (como o Armazenamento do Azure). Nesse cenário, pode ser problemático executar terraform plan em uma máquina local e direcionar uma máquina remota. Como resultado, poderá ser sensato automatizar essa etapa de validação como parte do seu pipeline de integração contínua.

4. Execute a análise de código estático

A análise de código estático pode ser feita diretamente no código de configuração do Terraform, sem executá-lo. Essa análise pode ser útil para detetar problemas como problemas de segurança e inconsistência de conformidade.

As seguintes ferramentas fornecem análise estática para arquivos Terraform:

A análise estática geralmente é executada como parte de um pipeline de integração contínua. Esses testes não exigem a criação de um plano de execução ou implantação. Como resultado, eles são executados mais rapidamente do que outros testes e geralmente são executados primeiro no processo de integração contínua.

5. Automatize testes de integração usando o Azure Pipeline

A integração contínua envolve o teste de um sistema inteiro quando uma alteração é introduzida. Nesta seção, você verá uma configuração do Pipeline do Azure usada para implementar a integração contínua.

Usando o editor da sua preferência, aceda ao clone local do projeto de exemplo Terraform no GitHub.
Abra o arquivo samples/integration-testing/src/azure-pipeline.yaml.
Role para baixo até a seção de etapas , onde verá um conjunto padrão de passos usados para executar várias rotinas de instalação e validação.
Reveja a linha que diz Etapa 1: execute a Análise de Código Estático Checkov. Nesta etapa, o projeto Checkov mencionado anteriormente executa uma análise de código estático na configuração Terraform de exemplo.
```
- bash: $(terraformWorkingDirectory)/checkov.sh $(terraformWorkingDirectory)
  displayName: Checkov Static Code Analysis
```
Pontos principais:
- Esse script é responsável por executar o Checkov no espaço de trabalho Terraform montado dentro de um contêiner do Docker. Os agentes gerenciados pela Microsoft são habilitados para Docker. Executar ferramentas dentro de um contêiner do Docker é mais fácil e elimina a necessidade de instalar o Checkov no agente do Azure Pipeline.
- A variável $(terraformWorkingDirectory) é definida no arquivo azure-pipeline.yaml.
Analisar a linha que diz Etapa 2: instalar o Terraform no agente do Azure Pipelines. A extensão Terraform Build & Release Task que você instalou anteriormente tem um comando para instalar o Terraform no agente que executa o Pipeline do Azure. Esta tarefa é o que está sendo feito nesta etapa.
```
- task: charleszipp.azure-pipelines-tasks-terraform.azure-pipelines-tasks-terraform-installer.TerraformInstaller@0
  displayName: 'Install Terraform'
  inputs:
    terraformVersion: $(terraformVersion)
```
Pontos principais:
- A versão do Terraform a ser instalada é especificada por meio de uma variável do Azure Pipeline chamada terraformVersion e definida no arquivo azure-pipeline.yaml.
Revise a linha que lê Etapa 3: execute o Terraform init para inicializar o espaço de trabalho. Agora que o Terraform está instalado no agente, o diretório Terraform pode ser inicializado.
```
- task: charleszipp.azure-pipelines-tasks-terraform.azure-pipelines-tasks-terraform-cli.TerraformCLI@0
  displayName: 'Run terraform init'
  inputs:
    command: init
    workingDirectory: $(terraformWorkingDirectory)
```
Pontos principais:
- A entrada command especifica qual comando Terraform executar.
- A entrada workingDirectory indica o caminho do diretório Terraform.
- A variável $(terraformWorkingDirectory) é definida no arquivo azure-pipeline.yaml.

Reveja a linha que diz, Etapa 4: execute o comando `terraform validate` para validar a sintaxe HCL. Depois que o diretório do projeto é inicializado, terraform validate é executado para validar a configuração no servidor.

- task: charleszipp.azure-pipelines-tasks-terraform.azure-pipelines-tasks-terraform-cli.TerraformCLI@0
  displayName: 'Run terraform validate'
  inputs:
    command: validate
    workingDirectory: $(terraformWorkingDirectory)

Revise a linha que diz, Etapa 5: executar o plano Terraform para validar a sintaxe HCL. Como explicado anteriormente, a geração do plano de execução é feita para verificar se a configuração do Terraform é válida antes da implantação.
```
- task: charleszipp.azure-pipelines-tasks-terraform.azure-pipelines-tasks-terraform-cli.TerraformCLI@0
  displayName: 'Run terraform plan'
  inputs:
    command: plan
    workingDirectory: $(terraformWorkingDirectory)
    environmentServiceName: $(serviceConnection)
    commandOptions: -var location=$(azureLocation)
```
Pontos principais:
- A entrada environmentServiceName refere-se ao nome da conexão de serviço do Azure criada em Configure your environment. A conexão permite que o Terraform acesse sua assinatura do Azure.
- A entrada commandOptions é usada para passar argumentos para o comando Terraform. Nesse caso, um local está sendo especificado. A variável $(azureLocation) é definida anteriormente no arquivo YAML.

Importar o pipeline para o Azure DevOps

Abra seu projeto do Azure DevOps e vá para a seção Azure Pipelines.
Selecione o botão Criar pipeline.
Para a opção Onde está o seu código?, selecione GitHub (YAML).
Neste ponto, talvez seja necessário autorizar o Azure DevOps para acessar sua organização. Para obter mais informações sobre este tópico, consulte o artigo Build GitHub repositories.
Na lista de repositórios, selecione a bifurcação do repositório que você criou em sua organização do GitHub.
Na etapa Configurar o seu pipeline, escolha começar a partir de um pipeline YAML existente.
Quando a página Selecionar pipeline YAML existente for exibida, especifique a ramificação e insira o caminho para o pipeline YAML: .
Selecione Continuar para carregar o pipeline do Azure YAML do GitHub.
Quando a página Rever o pipeline YAML for exibida, selecione Iniciar para criar e ativar manualmente o pipeline pela primeira vez.

Verificar os resultados

Você pode executar o pipeline manualmente na interface do usuário do Azure DevOps. No entanto, o objetivo do artigo é mostrar a integração contínua automatizada. Teste o processo confirmando uma alteração na pasta samples/integration-testing/src do repositório bifurcado. A alteração acionará automaticamente um novo pipeline na ramificação na qual você está enviando o código.

Pipeline em execução a partir do GitHub