Creare un modello Terraform di base in Azure con Yeoman

Articolo
03/21/2023

Terraform consente di definire, visualizzare in anteprima e distribuire l'infrastruttura cloud. Con Terraform è possibile creare file di configurazione usando la sintassi HCL. La sintassi HCL consente di specificare il provider di servizi cloud, ad esempio Azure, e gli elementi che costituiscono l'infrastruttura cloud. Dopo aver creato i file di configurazione, è necessario creare un piano di esecuzione che consenta di visualizzare in anteprima le modifiche apportate all'infrastruttura prima che vengano distribuite. Dopo aver verificato le modifiche, è possibile applicare il piano di esecuzione per distribuire l'infrastruttura.

Questo articolo illustra come usare la combinazione di Terraform e Yeoman. Terraform è uno strumento per la creazione di un'infrastruttura in Azure. Yeoman semplifica la creazione di moduli Terraform.

In questo articolo si apprenderà come eseguire le attività seguenti:

Creare un modello Terraform di base usando il generatore di moduli Yeoman.
Testare il modello Terraform procedendo in due modi diversi.
Eseguire il modulo Terraform con un file Docker.
Eseguire il modulo Terraform in modalità nativa in Azure Cloud Shell.

1. Configurare l'ambiente

Sottoscrizione di Azure: se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Configurare Terraform: se non è già stato fatto, configurare Terraform usando una delle opzioni seguenti:

Visual Studio Code: scaricare Visual Studio Code per la piattaforma.
Docker: installare Docker per eseguire il modulo creato dal generatore Yeoman.
Linguaggio di programmazione Go: installare Go come test case generati da Yeoman sono codice usando il linguaggio Go.
Nodejs:Install Node.js
Installare Yeoman: eseguire il comando seguente: npm install -g yo.
Modello Yeoman: eseguire il comando seguente per installare il modello Yeoman per il modulo Terraform: npm install -g generator-az-terra-module.

2. Creare la directory per il modulo generato da Yeoman

Il modello Yeoman genera i file nella directory corrente. Per questo motivo è necessario creare una directory.

Questa directory vuota deve essere inserita in $GOPATH/src. Per altre informazioni su questo percorso, vedere l'articolo Impostazione di GOPATH.

Passare alla directory padre da cui creare una nuova directory.
Eseguire il comando seguente sostituendo il segnaposto. Per questo esempio, viene usato il nome di directory GeneratorDocSample.
```
mkdir <new-directory-name>
```
Passare alla nuova directory:
```
cd <new-directory-name>
```

3. Creare un modello di modulo di base

Esegui questo comando:
```
yo az-terra-module
```
Seguire le istruzioni indicate sullo schermo per fornire le informazioni seguenti:
- Terraform module project Name: per l'esempio viene usato il valore doc-sample-module.
- Si desidera includere il file di immagine Docker? : immettere y. Se si immette n, il codice del modulo generato supporterà l'esecuzione solo in modalità nativa.
Elencare il contenuto della directory per visualizzare i file risultanti che vengono creati:
```
ls
```

4. Esaminare il codice del modulo generato

Avviare Visual Studio Code
Nella barra dei menu selezionare File > Apri cartella e selezionare la cartella creata.

I file seguenti sono stati creati dal generatore di moduli Yeoman:

main.tf: definisce un modulo denominato random-shuffle. L'input è un oggetto string_list. L'output è il numero di permutazioni.
variables.tf: definisce le variabili di input e output usate dal modulo.
outputs.tf: definisce l'output del modulo. In questo caso è il valore restituito da random_shuffle, ovvero un modulo Terraform predefinito.
Rakefile: definisce i passaggi di compilazione. Questi passaggi includono:
- build: convalida la formattazione del file main.tf.
- unit: lo scheletro del modulo generato non include codice per uno unit test. Se si desidera specificare uno scenario di unit test, si deve aggiungere codice qui.
- e2e: esegue un test end-to-end del modulo.
test
- I test case sono scritti in Go.
- Tutti i codici dei test sono test end-to-end.
- I test end-to-end tentano di effettuare il provisioning di tutti gli elementi definiti in fixture. I risultati nel file template_output.go vengono confrontati con i valori previsti predefiniti.
- Gopkg.lock e Gopkg.toml: definisce le dipendenze.

Per altre informazioni sul generatore Yeoman per Azure https://github.com/Azure/generator-az-terra-module, vedere la documentazione di Terratest.

5. Testare il modulo Terraform usando un file Docker

In questa sezione viene illustrato come testare un modulo Terraform con un file Docker.

Nota

Questo esempio esegue il modulo in locale, non in Azure.

Verificare che Docker sia installato e in esecuzione

Da un prompt dei comandi immettere docker version.

Docker version

L'output risultante conferma che Docker è installato.

Per verificare che Docker sia in esecuzione, immettere docker info.

Docker info

Configurare un contenitore Docker

Da un prompt dei comandi immettere

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 ..

Sarà visualizzato il messaggio Successfully built (Compilazione riuscita).
Al prompt dei comandi immettere docker image ls per vedere elencato il modulo creato terra-mod-example.
Immetti docker run -it terra-mod-example /bin/sh. Dopo aver eseguito il comando docker run, ci si trova nell'ambiente Docker. A questo punto è possibile individuare il file usando il comando ls.

Compilare il modulo

Esegui questo comando:
```
bundle install
```
Esegui questo comando:
```
rake build
```

Eseguire il test end-to-end

Esegui questo comando:
```
rake e2e
```
Dopo qualche istante sarà visualizzato il messaggio PASS.
Immettere exit per completare il test e uscire dall'ambiente Docker.

6. Usare il generatore Yeoman per creare e testare un modulo

In questa sezione viene usato il generatore Yeoman per creare e testare un modulo in Cloud Shell. L'uso di Cloud Shell al posto di un file Docker semplifica notevolmente il processo. Se si usa Cloud Shell, i prodotti seguenti sono tutti preinstallati:

Node.js
Yeoman
Terraform

Avviare una sessione di Cloud Shell

Avviare una sessione di Azure Cloud Shell tramite il portale di Azure, shell.azure.com o l'app per dispositivi mobili di Azure.
Verrà visualizzata la pagina Benvenuto in Azure Cloud Shell. Selezionare Bash (Linux).
Se non si è già configurato un account di archiviazione di Azure, viene visualizzata la schermata seguente. Selezionare Create storage (Crea risorsa di archiviazione).
Azure Cloud Shell viene avviato nella shell selezionata in precedenza e visualizza le informazioni per l'unità cloud appena creata per l'utente.

Preparare una directory in cui inserire il modulo Terraform

A questo punto, Cloud Shell avrà già configurato automaticamente GOPATH nelle variabili di ambiente. Per visualizzare il percorso, immettere go env.
Creare la directory $GOPATH, se non esiste già: immettere mkdir ~/go.
Creare una directory all'interno della directory $GOPATH. Tale directory viene usata per contenere le diverse directory di progetto create in questo esempio.
```
mkdir ~/go/src
```
Creare una directory in cui inserire il modulo Terraform sostituendo il segnaposto. Per questo esempio, viene usato il nome di directory my-module-name.
```
mkdir ~/go/src/<your-module-name>
```
Passare alla directory del modulo:
```
cd ~/go/src/<your-module-name>
```

Creare e testare il modulo Terraform

Eseguire questo comando e seguire le istruzioni. Quando viene chiesto se si vogliono creare i file Docker, immettere N.
```
yo az-terra-module
```
Eseguire il comando seguente per installare le dipendenze:
```
bundle install
```
Eseguire il comando seguente per compilare il modulo:
```
rake build
```
Eseguire questo comando per eseguire il test:
```
rake e2e
```

Risolvere i problemi di Terraform in Azure

Risolvere i problemi comuni relativi all'uso di Terraform in Azure

Passaggi successivi

Installare e usare l'estensione Azure Terraform di Visual Studio Code.