Criar um modelo base Terraform no Azure usando Yeoman

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.

Neste artigo, você aprende a usar a combinação de Terraform e Yeoman. Terraform é uma ferramenta para criar infraestrutura no Azure. Yeoman facilita a criação de módulos Terraform.

Neste artigo, você aprenderá a executar as seguintes tarefas:

Crie um modelo Terraform base usando o gerador de módulos Yeoman.
Teste o modelo Terraform usando dois métodos diferentes.
Execute o módulo Terraform usando um arquivo Docker.
Execute o módulo Terraform nativamente no Azure Cloud Shell.

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:

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 Go como casos de teste gerados pelo Yeoman são código usando a linguagem Go .
Nodejs:Instalar nó.js
Instale Yeoman: Execute o seguinte comando:npm install -g yo.
Modelo Yeoman: Execute o seguinte comando para instalar o modelo Yeoman para o módulo Terraform:npm install -g generator-az-terra-module.

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

O modelo do Yeoman gera ficheiros no diretório atual. Assim, terá de criar um diretório.

Este diretório vazio tem de ser colocado em $GOPATH/src. Para obter mais informações sobre esse caminho, consulte o artigo Definindo GOPATH.

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

3. Criar modelo de módulo base

Execute o seguinte comando:
```
yo az-terra-module
```
Siga as instruções no ecrã para fornecer as seguintes informações:
- Nome do projeto do módulo Terraform - Um valor de doc-sample-module é usado para o exemplo.
- Pretende incluir o ficheiro de imagem do Docker? - Digite y. Se você inserir no , o código do módulo gerado suportará a execução somente no modo nativo.
Liste o conteúdo do diretório para exibir os arquivos resultantes que são criados:
```
ls
```

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

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

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

main.tf - Define um módulo chamado random-shuffle. A entrada é um string_listarquivo . O resultado é a contagem das permutas.
variables.tf - Define as variáveis de entrada e saída utilizadas pelo módulo.
outputs.tf - Define o que o módulo produz. Aqui, é o valor retornado pelo random_shuffle, que é um módulo Terraform integrado.
Rakefile - Define as etapas de construção. Essas etapas incluem:
- build - Valida a formatação do arquivo main.tf.
- unit - O esqueleto do módulo gerado não inclui código para um teste de unidade. Se pretender especificar um cenário de teste de unidades, terá de adicionar esse código aqui.
- e2e - Executa um teste de ponta a ponta do módulo.
test
- Os casos de teste são escritos em Go.
- Todos os códigos de teste são testes ponto a ponto.
- Os testes de ponta a ponta tentam provisionar todos os itens definidos em fixture. Os resultados no template_output.go arquivo são comparados com os valores esperados predefinidos.
- Gopkg.lock e Gopkg.toml: Define as dependências.

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

5. Teste o módulo Terraform usando um arquivo Docker

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

Nota

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

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

Numa linha de comandos, introduza docker version.

Docker version

O resultado confirma que o Docker está instalado.

Para confirmar que o Docker está mesmo em execução, introduza docker info.

Docker info

Configurar um contentor do Docker

Numa linha de comandos, introduza

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á apresentada.
No prompt de comando, entre docker image ls para ver o módulo terra-mod-example criado listado.
Introduzir docker run -it terra-mod-example /bin/sh. Depois de executar o docker run comando, você está no ambiente do Docker. Nesse ponto, você pode descobrir o arquivo usando o ls comando.

Construa o módulo

Execute o seguinte comando:
```
bundle install
```
Execute o seguinte comando:
```
rake build
```

Executar o teste de ponta a ponta

Execute o seguinte comando:
```
rake e2e
```
Após alguns momentos, a mensagem PASS será apresentada.
Entre exit para concluir o teste e sair do ambiente do Docker.

6. Use o gerador 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 muito o processo. Usando o Cloud Shell, os seguintes produtos são todos 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, do shell.azure.com ou do aplicativo móvel do Azure.
A página Bem-vindo ao Azure Cloud Shell é aberta. Selecione Bash (Linux).
Se ainda não tiver configurado uma conta de armazenamento do Azure, aparecerá o seguinte ecrã. Selecione Create storage (Criar armazenamento).
O Azure Cloud Shell é iniciado no shell que selecionou anteriormente e apresenta informações para a unidade de cloud que acabou de criar.

Prepare um diretório para armazenar seu módulo Terraform

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

Crie e teste seu módulo Terraform

Execute o seguinte comando e siga as instruções. Quando perguntado se você deseja criar os arquivos do Docker, digite N.
```
yo az-terra-module
```
Execute o seguinte comando para instalar as dependências:
```
bundle install
```
Execute o seguinte comando para construir 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óximos passos

Instale e use a extensão Azure Terraform Visual Studio Code.