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

Artigo
10/23/2023

Terraform permite a definição, visualização e implantação de infraestrutura em nuvem. Usando Terraform, você cria arquivos de configuração usando a 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 fiapos e formato.
Execute terraform validate para verificar a sintaxe do arquivo de configuração.
Execute o plano de terraforma para garantir que a configuração funcione conforme o esperado.

Neste artigo, vai 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 não tem uma subscrição do Azure, crie uma conta gratuita antes de começar.

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

Organização e projeto do Azure DevOps: se você não tiver um, crie uma organização do Azure DevOps.
Extensão Terraform Build & Release Tasks: instale a extensão de tarefas de compilação/liberação do Terraform em sua organização do Azure DevOps.
Conceder acesso ao 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 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 src diretório.
Execute terraform init para inicializar o diretório de trabalho.
```
terraform init
```
Execute terraform validate para validar a sintaxe dos arquivos de configuração.
```
terraform validate
```
Pontos principais:
- Você verá uma mensagem indicando que a configuração do Terraform é válida.
Editar o ficheiro main.tf.
Na linha 5, insira um erro de digitação que invalide a sintaxe. Por exemplo, substitua var.location por var.loaction
Guarde o ficheiro.
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 correr 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 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 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. A execução 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 o plano Terraform. 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. É dizer-lhe o que vai acontecer se você aplicar o plano.

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

terraform plan

Após a execução 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, pode fazer sentido 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 seu editor de escolha, navegue até o clone local do projeto de exemplo Terraform no GitHub.
Abra o ficheiro samples/integration-testing/src/azure-pipeline.yaml.
Role para baixo até a seção de etapas, onde você verá um conjunto padrão de etapas usadas para executar várias rotinas de instalação e validação.
Revise a linha que lê, Etapa 1: execute a Análise de Código Estático Checkov. Nesta etapa, o Checkov projeto 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 $(terraformWorkingDirectory) variável é definida no azure-pipeline.yaml arquivo.
Analise a linha que lê, 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 nomeada terraformVersion e definida no azure-pipeline.yaml arquivo.
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 command entrada especifica qual comando Terraform executar.
- A workingDirectory entrada indica o caminho do diretório Terraform.
- A $(terraformWorkingDirectory) variável é definida no azure-pipeline.yaml arquivo.

Revise a linha que lê, Etapa 4: execute a validação do Terraform para validar a sintaxe HCL. Uma vez 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 lê, Etapa 5: execute 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 environmentServiceName entrada 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 commandOptions entrada é usada para passar argumentos para o comando Terraform. Nesse caso, um local está sendo especificado. A $(azureLocation) variável é 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 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 seu pipeline, escolha iniciar a partir de um pipeline YAML existente.
Quando a página Selecionar pipeline YAML existente for exibida, especifique a ramificação master e insira o caminho para o pipeline YAML: samples/integration-testing/src/azure-pipeline.yaml.
Selecione Continuar para carregar o pipeline do Azure YAML do GitHub.
Quando a página Revisar seu pipeline YAML for exibida, selecione Executar para criar e acionar 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 samples/integration-testing/src pasta do seu repositório bifurcado. A alteração acionará automaticamente um novo pipeline na ramificação na qual você está enviando o código.

Pipeline executado a partir do GitHub