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

Artigo
01/19/2025

Terraform habilita a definição, a pré-visualização e a implantação da infraestrutura de nuvem. Usando o Terraform, você cria arquivos de configuração utilizando a sintaxe HCL . A sintaxe HCL permite que você especifique o provedor de nuvem - como o Azure - e os elementos que compõem sua infraestrutura de nuvem. Depois de criar seus arquivos de configuração, você cria um plano de execução que permite visualizar as alterações de 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 interrompe o código existente. No DevOps, a CI (integração contínua) refere-se a um processo que cria todo o sistema sempre que a base de código é alterada , como alguém que deseja mesclar uma 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 formato.
Execute terraform validate para verificar a sintaxe do arquivo de configuração.
Executar o comando terraform plan para verificar se a configuração funciona conforme o esperado.

Neste artigo, você aprenderá a:

Conheça os conceitos básicos do teste de integração para projetos do 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 no computador local.
Execute terraform plan para validar os arquivos de configuração do Terraform de uma perspectiva de serviços remotos.
Use um Pipeline do Azure para automatizar a integração contínua.

1. Configurar seu ambiente

assinatura do Azure: se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

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

Organização e projeto do Azure DevOps: caso não tenha uma, crie uma organização do Azure DevOps.
Extensão de Tarefas de Compilação e Versão do Terraform: Instale a extensão de tarefas de build/versão do Terraform na sua organização do Azure DevOps.
Conceda acesso do Azure DevOps à sua Assinatura do Azure: crie 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: Baixar 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 na linha de comando, no diretório que contém os arquivos do Terraform. Essa meta principal de comandos é validar a sintaxe.

No 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 arquivos de configuração.
```
terraform validate
```
Pontos-chave:
- 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-chave:
- Você verá uma mensagem de erro indicando a linha de código em erro e uma descrição do erro.

Como você pode ver, o Terraform detectou 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 em seus arquivos Terraform antes de enviá-los para o sistema de controle de versão. Além disso, esse nível de validação deve fazer parte do pipeline de integração contínua. Posteriormente 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 para a sintaxe. Esse teste não levou em consideração o que pode já ser implantado no Azure.

Terraform é uma linguagem declarativa que 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 desse plano não incrementa 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 do Terraform, execute o comando terraform plan. Esse comando se conecta à assinatura do Azure de destino para verificar qual parte da configuração já está implantada. Em seguida, o Terraform determina as alterações necessárias para atender aos requisitos declarados no arquivo Terraform. Neste estágio, o Terraform não está implantando nada. Ele está dizendo o que acontecerá se você 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, o Terraform exibirá 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 sair da sincronização. Para solucionar esse problema, o Terraform dá 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 um computador local e ter como alvo um computador remoto. Como resultado, pode fazer sentido automatizar essa etapa de validação como parte de seu pipeline de integração contínua.

4. Executar 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 detectar problemas como problemas de segurança e inconsistência de conformidade.

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

Checkov
Terrascan
tfsec
Deepsource

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 rápido do que outros testes e geralmente são executados primeiro no processo de integração contínua.

5. Automatizar 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 Azure Pipeline usada para implementar a integração contínua.

Usando o editor de sua preferência, navegue até o clone local do projeto exemplo Terraform no GitHub.
Abra o arquivo samples/integration-testing/src/azure-pipeline.yaml.
Role para baixo até a seção de etapas , onde você vê um conjunto padrão de etapas usadas para executar várias rotinas de instalação e validação.
Revise 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 estática de código na configuração de exemplo do Terraform.
```
- bash: $(terraformWorkingDirectory)/checkov.sh $(terraformWorkingDirectory)
  displayName: Checkov Static Code Analysis
```
Pontos-chave:
- Esse script é responsável por executar Checkov no workspace do Terraform montado dentro de um contêiner do Docker. Os agentes gerenciados pela Microsoft estão habilitados para o Docker. Executar ferramentas dentro de um contêiner do Docker é mais fácil e remove a necessidade de instalar o Checkov no agente do Azure Pipeline.
- A variável $(terraformWorkingDirectory) é definida no arquivo azure-pipeline.yaml.
Examine a linha em que se lê, Etapa 2: instalar o Terraform no agente do Azure Pipelines. A extensão Tarefas de Compilação e Versão do Terraform que você instalou anteriormente tem um comando para instalar o Terraform no agente que executa o Azure Pipeline. Essa 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-chave:
- 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.
Examine a linha que diz, Etapa 3: execute o comando 'terraform init' para inicializar o workspace. 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-chave:
- 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.
Examine a linha em que se lê, Etapa 4: executar o comando terraform validate para validar a sintaxe da 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)
```
Examine a linha em que se lê, Etapa 5: executar o comando terraform plan para validar a sintaxe da HCL. Conforme 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-chave:
- A entrada environmentServiceName se refere ao nome da conexão de serviço do Azure criada em Configurar o seu ambiente. 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á seu código?, selecione GitHub (YAML).
Neste ponto, talvez seja necessário autorizar o Azure DevOps a acessar sua organização. Para obter mais informações sobre este tópico, consulte o artigo Criar repositórios do GitHub.
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 pipeline, selecione a opção de iniciar a partir de um pipeline YAML existente.
Quando a página Selecionar pipeline YAML existente for exibida, especifique o branch master e insira o caminho para o pipeline YAML: samples/integration-testing/src/azure-pipeline.yaml.
Selecione Continuar para carregar o pipeline YAML do Azure do GitHub.
Quando a página Examinar o pipeline YAML for exibida, selecione Executar para criar e disparar 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 vai disparar automaticamente um novo pipeline no branch em que você está efetuando push do código.

pipeline Pipeline em execução do GitHub