Criar um modelo de base do Terraform no Azure usando o Yeoman

Artigo
10/23/2023

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.

Neste artigo, saiba como usar a combinação entre o Terraform e o Yeoman. Terraform é uma ferramenta para a criação de infraestrutura no Azure. O Yeoman facilita a criação de módulos do Terraform.

Neste artigo, você aprende a realizar as seguintes tarefas:

Criar um modelo de base do Terraform usando o gerador de módulo do Yeoman.
Testar o modelo do Terraform usando dois métodos diferentes.
Executar o módulo do Terraform usando um arquivo do Docker.
Executar o módulo do Terraform nativamente no Azure Cloud Shell.

1. Configurar seu ambiente

Assinatura do Azure: caso você não tenha 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:

Visual Studio Code: Baixe o Visual Studio Code para sua plataforma.
Docker: Instale o Docker para executar o módulo criado pelo gerador Yeoman.
Linguagem de programação Go: Instale o Go como os casos de teste gerados pelo Yeoman são códigos usando a linguagem Go .
Nodejs:Nó de instalação.js
Instale o Yeoman: execute o seguinte comando: npm install -g yo.
Modelo do Yeoman: execute o seguinte comando a fim de instalar o modelo do Yeoman para o módulo do Terraform: npm install -g generator-az-terra-module.

2. Criar um diretório para o módulo gerado pelo Yeoman

O modelo do Yeoman gera arquivos no diretório atual. Por esse motivo, você precisará criar um diretório.

Esse diretório vazio precisa ser colocado em $GOPATH/src. Para obter mais informações sobre esse caminho, consulte o artigo Setting GOPATH (Configuração de GOPATH).

Navegue até o diretório pai do qual criar um diretório.
Execute o seguinte comando, substituindo o espaço reservado. Para este exemplo, é usado um nome de diretório de GeneratorDocSample.
```
mkdir <new-directory-name>
```
Navegue até o novo diretório:
```
cd <new-directory-name>
```

3. Criar um modelo de módulo base

Execute o comando a seguir:
```
yo az-terra-module
```
Siga as instruções na tela para fornecer as seguintes informações:
- Nome do projeto de módulo do Terraform – Um valor de doc-sample-module é usado para o exemplo.
- Você gostaria de incluir o arquivo de imagem do Docker? – Digite y. Se você inserir n, o código de módulo gerado dará suporte para execução somente no modo nativo.
Insira o conteúdo do diretório para exibir os arquivos resultantes que forem criados:
```
ls
```

4. Examinar o código do módulo gerado

Iniciar o Visual Studio Code
Na barra de menus, selecione Arquivo > Abrir Pasta e selecione a pasta que você criou.

Os seguintes arquivos foram criados pelo gerador de módulo do Yeoman:

main.tf – Define um módulo chamado random-shuffle. A entrada é uma string_list. A saída é a contagem de permutações.
variables.tf – Define as variáveis de entrada e saída usadas pelo módulo.
outputs.tf – Define o que o módulo gera. Aqui, ele é o valor retornado por random_shuffle, que é um módulo interno do Terraform.
Rakefile – Define as etapas de compilação. Essas etapas incluem:
- build – Valida a formatação do arquivo main.tf.
- unit – O esqueleto do módulo gerado não inclui o código para um teste de unidade. Se você quiser especificar um cenário de teste de unidade, adicione o código aqui.
- e2e – Executa um teste de ponta a ponta no módulo.
test
- Os casos de teste são escritos em linguagem Go.
- Todos os códigos de teste são testes de ponta a ponta.
- Os testes de ponta a ponta tentam provisionar todos os itens definidos em fixture. Os resultados no arquivo template_output.go são comparados com os valores predefinidos esperados.
- Gopkg.lock e Gopkg.toml: Define as dependências.

Para obter mais informações sobre o gerador do Yeoman para o Azure https://github.com/Azure/generator-az-terra-module, confira a documentação do Terratest.

5. Testar o módulo do Terraform usando um arquivo do Docker

Esta seção mostra como testar um módulo do Terraform usando um arquivo do Docker.

Observação

Este exemplo executa o módulo localmente, não no Azure.

Confirmar se o Docker está instalado e em execução

Em um prompt de comando, insira docker version.

Docker version

A saída resultante confirma que o Docker está instalado.

Para confirmar que o Docker está realmente em execução, digite docker info.

Docker info

Configurar um contêiner do Docker

Em um prompt de comando, insira

docker build --build-arg BUILD_ARM_SUBSCRIPTION_ID= --build-arg BUILD_ARM_CLIENT_ID= --build-arg BUILD_ARM_CLIENT_SECRET= --build-arg BUILD_ARM_TENANT_ID= -t terra-mod-example ..

A mensagem Criado com êxito será exibida.
No prompt de comando, digite docker image ls para ver o módulo criado terra-mod-example listado.
Digite docker run -it terra-mod-example /bin/sh. Depois de executar o comando docker run, você estará no ambiente do Docker. Nesse ponto, você pode descobrir o arquivo usando o comando ls.

Criar o módulo

Execute o comando a seguir:
```
bundle install
```
Execute o comando a seguir:
```
rake build
```

Executar o teste de ponta a ponta

Execute o comando a seguir:
```
rake e2e
```
Após alguns instantes, a mensagem APROVADO será exibida.
Insira exit para concluir o teste e sair do ambiente do Docker.

6. Usar o gerador do Yeoman para criar e testar um módulo

Nesta seção, o gerador Yeoman é usado para criar e testar um módulo no Cloud Shell. Usar o Cloud Shell em vez de usar um arquivo do Docker simplifica bastante o processo. Usando o Cloud Shell, os seguintes produtos são pré-instalados:

Node.js
Yeoman
Terraform

Iniciar uma sessão do Cloud Shell

Inicie uma sessão do Azure Cloud Shell por meio do portal do Azure, de shell.azure.com ou do aplicativo móvel do Azure.
A página Boas-vindas ao Azure Cloud Shell é aberta. Selecione Bash (Linux).
Se você ainda não configurou uma conta de armazenamento do Azure, a tela a seguir será exibida. Selecione Criar armazenamento.
O Azure Cloud Shell é iniciado no shell que você selecionou anteriormente e exibe informações para a unidade de nuvem que acabou de ser criada.

Preparar um diretório para armazenar seu módulo do Terraform

Neste ponto, o Cloud Shell já terá configurado o GOPATH em suas variáveis de ambiente. Para ver o caminho, insira go env.
Crie o diretório $GOPATH, se ainda não existir: Digite mkdir ~/go.
Crie um diretório dentro do diretório $GOPATH. Esse diretório é usado para manter os diferentes diretórios de projeto criados neste exemplo.
```
mkdir ~/go/src
```
Crie um diretório para manter o seu módulo do Terraform substituindo o espaço reservado. Para este exemplo, é usado um nome de diretório de my-module-name.
```
mkdir ~/go/src/<your-module-name>
```
Navegue até o diretório do módulo:
```
cd ~/go/src/<your-module-name>
```

Criar e testar seu módulo do Terraform

Execute o comando a seguir e siga as instruções. Quando perguntado se deseja criar os arquivos do Docker, insira N.
```
yo az-terra-module
```
Execute o comando a seguir para instalar as dependências:
```
bundle install
```
Execute o comando a seguir para compilar o módulo:
```
rake build
```
Execute o seguinte comando para executar o teste:
```
rake e2e
```

Solucionar problemas do Terraform no Azure

Solucionar problemas comuns ao usar o Terraform no Azure

Próximas etapas

Instalar e usar a extensão Visual Studio Code do Azure Terraform.