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

Artigo
04/16/2024

O Terraform permite a definição, a visualização e a implantação da infraestrutura de nuvem. Usando o Terraform, você cria arquivos de configuração usando sintaxe de HCL. A sintaxe da 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 os arquivos de configuração, você cria um plano de execução que permite visualizar as alterações de infraestrutura antes de serem implantadas. Depois de verificar as alterações, aplique o plano de execução para implantar a infraestrutura.

Os testes de integração validam se uma alteração de código introduzida recentemente não causa falha no código existente. No DevOps, a CI (integração contínua) se refere a um processo que compila o sistema inteiro sempre que a base do código é alterada, como alguém que deseja mesclar uma PR em um repositório do Git. A seguinte lista contém exemplos comuns de testes de integração:

Ferramentas de análise de código estática, como lint e format.
Executar o comando 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á como:

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 uma análise de código estática no código do 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 ainda não tiver feito isso, configure o Terraform usando uma das seguintes opções:

Organização e projeto de DevOps do Azure: se você não tiver um, crie uma organização de DevOps do Azure.
Extensão Terraform Build & Release Tasks: instale a extensão de tarefas de compilação/liberação Terraform em sua organização do Azure DevOps.
Conceder acesso do Azure DevOps à sua Assinatura do Azure: crie uma conexão de serviço do Azure nomeada 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 na linha de comando, no diretório que contém os arquivos do Terraform. A meta principal desse comando é validar a sintaxe.

No diretório de exemplo, acesse o diretório src.
Execute o comando 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 principais:
- Veja uma mensagem indicando se a configuração do Terraform é válida.
Edite o arquivo main.tf.
Na linha 5, insira um erro de grafia 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 com o erro e uma descrição dele.

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 prática recomendada sempre executar terraform validate em seus arquivos do Terraform antes de efetuar push deles ao 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. Mais adiante neste artigo, vamos explorar como configurar um pipeline do Azure para validação automática.

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 foi específico para a sintaxe. O teste não levou em consideração o que poderia já estar implantado no Azure.

O Terraform é uma linguagem declarativa, o que significa que você declara o que deseja obter como resultado final. Por exemplo, digamos que você tenha 10 máquinas virtuais em um grupo de recursos. Então, você cria um arquivo do Terraform definindo três máquinas virtuais. A aplicação desse plano não incrementa a contagem total de VMs para 13. Em vez disso, o Terraform exclui sete das máquinas virtuais existentes para que você termine com apenas três. A execução de terraform plan permite que você confirme os possíveis resultados 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 de destino do Azure para verificar que parte da configuração já está implantada. Então, o Terraform determina as alterações necessárias para atender aos requisitos declarados no arquivo do Terraform. Nesta fase, o Terraform não está implantando nada. Ele está informando o que acontecerá se você aplicar o plano.

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

terraform plan

Depois de executar terraform plan, o Terraform exibe o possível resultado 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 do 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 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 a análise de código estático

A análise de código estática 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 falhas de segurança e inconsistências de conformidade.

As seguintes ferramentas fornecem análise estática para arquivos do 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 de uma 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. Automatizar testes de integração usando um pipeline do Azure

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

Usando o editor de sua preferência, navegue até o clone local do projeto de exemplo do Terraform no GitHub.
Abra o arquivo samples/integration-testing/src/azure-pipeline.yaml .
Role a página para baixo até a seção Etapas, em que você verá um conjunto padrão de etapas usadas para executar várias rotinas de instalação e validação.
Examine a linha em que se lê, Etapa 1: executar a Análise de Código Estática do Checkov. Nesta etapa, o projeto Checkov mencionado anteriormente executa uma análise de código estática na configuração de exemplo do Terraform.
```
- bash: $(terraformWorkingDirectory)/checkov.sh $(terraformWorkingDirectory)
  displayName: Checkov Static Code Analysis
```
Pontos principais:
- Esse script é responsável por executar o Checkov no workspace do Terraform, montado dentro de um contêiner do Docker. Os agentes gerenciados pela Microsoft são habilitados para Docker. A execução de ferramentas dentro de um contêiner do Docker é mais fácil e elimina a necessidade de instalar o Checkov no agente de Pipeline do Azure.
- 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 das 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 Pipeline do Azure. 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 principais:
- A versão do Terraform a ser instalada é especificada por meio de uma variável do Pipeline do Azure chamada terraformVersion e definida no arquivo azure-pipeline.yaml.
Examine a linha em que se lê, Etapa 3: executar o comando terraform init para inicializar o workspace. Agora que o Terraform está instalado no agente, o diretório do 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 do Terraform deve ser executado.
- A entrada workingDirectory indica o caminho do diretório do 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 for inicializado, terraform validate será 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 principais:
- A entrada environmentServiceName refere-se ao nome da conexão de serviço do Azure criada em Configurar seu ambiente. A conexão permite que o Terraform acesse sua assinatura do Azure.
- A entrada commandOptions é usada para passar argumentos para o comando do 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 o projeto do Azure DevOps e vá para a seção do 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, confira o artigo Criar repositórios do GitHub.
Na lista de repositórios, selecione a bifurcação do repositório que você criou na sua organização do GitHub.
Na etapa Configurar seu pipeline, escolha Iniciar 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.

Verifique os resultados

Você pode executar o pipeline manualmente da interface do usuário do Azure DevOps. Contudo, 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 em execução do GitHub