Implementare test di integrazione per i progetti Terraform in Azure

Articolo
01/15/2025

Terraform abilita la definizione, l'anteprima e la distribuzione dell'infrastruttura cloud. Usando Terraform, si creano file di configurazione usando 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, si crea un piano di esecuzione che consente di visualizzare in anteprima le modifiche dell'infrastruttura prima della distribuzione. Dopo aver verificato le modifiche, applicare il piano di esecuzione per distribuire l'infrastruttura.

I test di integrazione verificano che una modifica del codice appena introdotta non interrompa il codice esistente. In DevOps, l'integrazione continua (CI) fa riferimento a un processo che compila l'intero sistema ogni volta che la base di codice viene modificata, ad esempio quando qualcuno desidera unire una pull request in un repository Git. L'elenco seguente contiene esempi comuni di test di integrazione:

Strumenti di analisi del codice statici, ad esempio lint e formato.
Eseguire convalidare terraform per verificare la sintassi del file di configurazione.
Eseguire il comando terraform plan per assicurarsi che la configurazione funzioni come previsto.

Questo articolo illustra come:

Informazioni di base sui test di integrazione per i progetti Terraform.
Usare Azure DevOps per configurare una pipeline di integrazione continua.
Eseguire l'analisi statica del codice nel codice Terraform.
Eseguire terraform validate per convalidare i file di configurazione di Terraform nel computer locale.
Eseguire terraform plan per convalidare che i file di configurazione di Terraform siano corretti dal punto di vista dei servizi remoti.
Usare una pipeline di Azure per automatizzare l'integrazione continua.

1. Configurare l'ambiente

Abbonamento Azure: se non hai un abbonamento Azure, crea un account gratuito prima di iniziare.

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

l'organizzazione e il progetto di Azure DevOps: se non ne hai uno, crea un'organizzazione di Azure DevOps.
l'estensione delle attività di build e rilascio & Terraform: Installare l'estensione delle attività di build e rilascio di Terraform nell'organizzazione di Azure DevOps.
Concedere ad Azure DevOps l'accesso alla sottoscrizione di Azure: creare una connessione al servizio di Azure denominata terraform-basic-testing-azure-connection per consentire ad Azure Pipelines di connettersi alle sottoscrizioni di Azure
Codice e risorse di esempio: Scaricare da GitHub il progetto di test di integrazione . La directory in cui si scarica l'esempio viene definita directory di esempio .

2. Convalidare una configurazione Terraform locale

Il comando terraform validate viene eseguito dalla riga di comando nella cartella che contiene i file di Terraform. Questo obiettivo principale dei comandi consiste nel convalidare la sintassi.

All'interno della directory di esempio, naviga alla directory src.
Eseguire terraform init per inizializzare la directory di lavoro.
```
terraform init
```
Eseguire terraform validate per convalidare la sintassi dei file di configurazione.
```
terraform validate
```
Punti chiave:
- Viene visualizzato un messaggio che indica che la configurazione di Terraform è valida.
Modificare il file main.tf.
Nella riga 5 inserire un errore di digitazione che invalida la sintassi. Ad esempio, sostituire var.location con var.loaction
Salvare il file.
Eseguire di nuovo la convalida.
```
terraform validate
```
Punti chiave:
- Viene visualizzato un messaggio di errore che indica la riga di codice in errore e una descrizione dell'errore.

Come si può notare, Terraform ha rilevato un problema nella sintassi del codice di configurazione. Questo problema impedisce la distribuzione della configurazione.

È buona norma eseguire sempre terraform validate sui file Terraform prima di inviarli al sistema di controllo delle versioni. Inoltre, questo livello di convalida deve far parte della pipeline di integrazione continua. Più avanti in questo articolo, spiegheremo come configurare una pipeline di Azure per convalidare automaticamente.

3. Convalidare la configurazione di Terraform

Nella sezione precedente è stato illustrato come convalidare una configurazione terraform. Tale livello di test era specifico della sintassi. Questo test non ha preso in considerazione ciò che potrebbe essere già stato distribuito in Azure.

Terraform è un linguaggio dichiarativo significa dichiarare ciò che si desidera come risultato finale. Si supponga, ad esempio, di avere 10 macchine virtuali in un gruppo di risorse. Si crea quindi un file Terraform che definisce tre macchine virtuali. L'applicazione di questo piano non incrementa il conteggio totale a 13. Terraform elimina invece sette delle macchine virtuali in modo da terminare con tre. L'esecuzione di terraform plan consente di confermare i potenziali risultati dell'applicazione di un piano di esecuzione per evitare sorprese.

Per generare il piano di esecuzione di Terraform, eseguire il comando terraform plan. Questo comando si connette alla sottoscrizione di Azure di destinazione per verificare quale parte della configurazione è già stata distribuita. Terraform determina quindi le modifiche necessarie per soddisfare i requisiti indicati nel file Terraform. In questa fase Terraform non distribuisce nulla. Ti sta dicendo cosa accadrà se applichi il piano.

Se si segue l'articolo ed è stata eseguita la procedura descritta nella sezione precedente, eseguire il comando terraform plan:

terraform plan

Dopo aver eseguito terraform plan, Terraform visualizza il risultato potenziale dell'applicazione del piano di esecuzione. L'output indica le risorse di Azure che verranno aggiunte, modificate e eliminate.

Per impostazione predefinita, Terraform archivia lo stato nella stessa directory locale del file Terraform. Questo modello funziona bene in scenari a utente singolo. Tuttavia, quando più persone lavorano sulle stesse risorse di Azure, i file di stato locali possono uscire dalla sincronizzazione. Per risolvere questo problema, Terraform supporta la scrittura di file di stato in un archivio dati remoto, ad esempio Archiviazione di Azure. In questo scenario, potrebbe essere problematico eseguire terraform plan in un computer locale e specificare come destinazione un computer remoto. Di conseguenza, potrebbe essere opportuno automatizzare questo passaggio di convalida come parte della pipeline di integrazione continua.

4. Eseguire l'analisi statica del codice

L'analisi statica del codice può essere eseguita direttamente sul codice di configurazione Terraform, senza eseguirlo. Questa analisi può essere utile per rilevare problemi quali problemi di sicurezza e incoerenze di conformità.

Gli strumenti seguenti forniscono l'analisi statica per i file Terraform:

L'analisi statica viene spesso eseguita come parte di una pipeline di integrazione continua. Questi test non richiedono la creazione di un piano di esecuzione o di una distribuzione. Di conseguenza, vengono eseguiti più velocemente rispetto ad altri test e vengono in genere eseguiti per primi nel processo di integrazione continua.

5. Automatizzare i test di integrazione con Azure Pipeline

L'integrazione continua comporta il test di un intero sistema quando viene introdotta una modifica. In questa sezione viene visualizzata una configurazione di Azure Pipeline usata per implementare l'integrazione continua.

Usando l'editor preferito, passare al clone locale del progetto di esempio terraform in GitHub.
Aprire il file samples/integration-testing/src/azure-pipeline.yaml.
Scorrere verso il basso fino alla sezione passaggi, dove si trova un set standard di passaggi usati per eseguire varie routine di installazione e convalida.
Esaminare la riga che legge Passaggio 1: eseguire l'analisi del codice statico Checkov. In questo passaggio, il progetto Checkov menzionato in precedenza esegue un'analisi statica del codice sulla configurazione terraform di esempio.
```
- bash: $(terraformWorkingDirectory)/checkov.sh $(terraformWorkingDirectory)
  displayName: Checkov Static Code Analysis
```
Punti chiave:
- Questo script è responsabile dell'esecuzione di Checkov nell'area di lavoro Terraform montata all'interno di un contenitore Docker. Gli agenti gestiti da Microsoft sono abilitati per Docker. L'esecuzione di strumenti all'interno di un contenitore Docker è più semplice e rimuove la necessità di installare Checkov nell'agente di Azure Pipeline.
- La variabile $(terraformWorkingDirectory) è definita nel file azure-pipeline.yaml.
Rivedere la riga che recita Passaggio 2: installare Terraform nell'agente di Azure Pipelines. L'estensione dell'attività di rilascio di Terraform Build & installata in precedenza include un comando per installare Terraform sull'agente che esegue Azure Pipeline. Questa attività viene eseguita in questo passaggio.
```
- task: charleszipp.azure-pipelines-tasks-terraform.azure-pipelines-tasks-terraform-installer.TerraformInstaller@0
  displayName: 'Install Terraform'
  inputs:
    terraformVersion: $(terraformVersion)
```
punti chiave:
- La versione di Terraform da installare viene specificata tramite una variabile di Azure Pipeline denominata terraformVersion e definita nel file azure-pipeline.yaml.
Esaminare la riga che dice Passaggio 3: eseguire Terraform init per inizializzare l'area di lavoro. Ora che Terraform è installato nell'agente, è possibile inizializzare la directory Terraform.
```
- task: charleszipp.azure-pipelines-tasks-terraform.azure-pipelines-tasks-terraform-cli.TerraformCLI@0
  displayName: 'Run terraform init'
  inputs:
    command: init
    workingDirectory: $(terraformWorkingDirectory)
```
punti chiave :
- L'input command specifica il comando Terraform da eseguire.
- L'input workingDirectory indica il percorso della directory Terraform.
- La variabile $(terraformWorkingDirectory) è definita nel file azure-pipeline.yaml.
Esaminare la riga con scritto Passaggio 4: eseguire Terraform validate per verificare la sintassi HCL. Dopo aver inizializzato la directory del progetto, terraform validate viene eseguita per convalidare la configurazione nel server.
```
- task: charleszipp.azure-pipelines-tasks-terraform.azure-pipelines-tasks-terraform-cli.TerraformCLI@0
  displayName: 'Run terraform validate'
  inputs:
    command: validate
    workingDirectory: $(terraformWorkingDirectory)
```
Esaminare la riga che recita Passaggio 5: eseguire il Terraform plan per convalidare la sintassi HCL. Come spiegato in precedenza, la generazione del piano di esecuzione viene eseguita per verificare se la configurazione terraform è valida prima della distribuzione.
```
- 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)
```
Punti chiave:
- L'input environmentServiceName fa riferimento al nome della connessione al servizio di Azure creata nella sezione Configurare l'ambiente. La connessione consente a Terraform di accedere alla sottoscrizione di Azure.
- L'input commandOptions viene usato per passare argomenti al comando Terraform. In questo caso, viene specificata una posizione. La variabile $(azureLocation) è definita in precedenza nel file YAML.

Importare la pipeline in Azure DevOps

Aprire il progetto Azure DevOps e passare alla sezione Azure Pipelines.
Selezionare il pulsante Crea Pipeline.
Per l'opzione Dove si trova il tuo codice?, selezionare GitHub (YAML).
A questo punto, potrebbe essere necessario autorizzare Azure DevOps ad accedere all'organizzazione. Per altre informazioni su questo argomento, vedere l'articolo Compilare repository GitHub.
Nell'elenco dei repository, seleziona il fork del repository che hai creato nella tua organizzazione GitHub.
Nel passaggio Configurare la pipeline, scegli di iniziare da una "pipeline YAML" esistente.
Quando la pagina Selezionare pipeline YAML esistente viene visualizzata, specificare il branch master e inserire il percorso della pipeline YAML: samples/integration-testing/src/azure-pipeline.yaml.
Seleziona Continua per caricare da GitHub la pipeline YAML di Azure.
Quando viene visualizzata la pagina Rivedi il tuo YAML della pipeline, selezionare Esegui per configurare e avviare manualmente la pipeline per la prima volta.

Verificare i risultati

È possibile eseguire la pipeline manualmente dall'interfaccia utente di Azure DevOps. Tuttavia, il punto dell'articolo consiste nello mostrare l'integrazione continua automatizzata. Mettere alla prova il processo committando una modifica alla cartella samples/integration-testing/src del repository che hai forkato. La modifica attiverà automaticamente una nuova pipeline nel ramo in cui si esegue il push del codice.

pipeline in esecuzione su GitHub