Implementare i test di conformità con Terraform e Azure

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.

Molte volte, i test di conformità fanno parte del processo di integrazione continua e vengono usati per garantire che vengano seguiti i criteri definiti dall'utente. Ad esempio, è possibile definire convenzioni di denominazione geopolitiche per le risorse di Azure. Un altro esempio comune è la creazione di macchine virtuali da un subset definito di immagini. I test di conformità vengono usati per applicare regole in questi e molti altri scenari.

In questo articolo vengono illustrate le operazioni seguenti:

Quando usare i test di conformità
Informazioni su come eseguire un test di conformità
Vedere ed eseguire un esempio di test di conformità

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:

Docker:Install Docker.
Python:Install Python.
Strumento terraform-compliance: installare lo strumento di conformità Terraform eseguendo il comando seguente: pip install terraform-compliance.
Codice e risorse di esempio: usando lo strumento DownGit, scaricare da GitHub il progetto di test della conformità e decomprimere in una nuova directory per contenere il codice di esempio. Questa directory viene definita directory di esempio.

2. Comprendere i test di conformità e i controlli

Il test di conformità è una tecnica di test non funzionale per determinare se un sistema soddisfa gli standard prestabiliti. I test di conformità sono noti anche come test di conformità.

La maggior parte dei team software esegue un'analisi per verificare che gli standard siano imposti e implementati correttamente. Spesso lavorano simultaneamente per migliorare gli standard che, a loro volta, generano una qualità più elevata.

Con i test di conformità, esistono due concetti importanti da considerare: test di conformità e controlli di conformità.

I test di conformità assicurano che l'output di ogni fase del ciclo di vita di sviluppo sia conforme ai requisiti concordati.
I controlli di conformità devono essere integrati nel ciclo di sviluppo all'inizio dei progetti. Il tentativo di aggiungere i controlli di conformità in una fase successiva diventa sempre più difficile quando il requisito stesso non è documentato in modo adeguato.

L'esecuzione dei controlli di conformità è un'operazione semplice. Un set di standard e procedure viene sviluppato e documentato per ogni fase del ciclo di vita di sviluppo. L'output di ogni fase viene confrontato con i requisiti documentati. I risultati del test sono costituiti dagli eventuali "scostamenti" non conformi agli standard predeterminati. Il test di conformità viene eseguito tramite il processo di ispezione e il risultato del processo di revisione deve essere documentato.

Ora verrà esaminato un esempio specifico.

Un problema comune è costituito dall'interruzione degli ambienti quando più sviluppatori applicano modifiche incompatibili. Si supponga che uno sviluppatore stia implementando una modifica e applichi risorse quali la creazione di una macchina virtuale in un ambiente di test. Un altro sviluppatore applica quindi una versione diversa del codice che effettua il provisioning di una versione diversa di tale macchina virtuale. In questo caso serve una supervisione per garantire la conformità alle regole definite.

Un modo per risolvere questo problema consiste nel definire un criterio di assegnazione di tag alle risorse, ad esempio con i tag role e creator. Dopo aver definito i criteri, viene usato uno strumento come Terraform-compliance per garantire che i criteri vengano seguiti.

Terraform-compliance esegue il test negativo. Il test negativo è il processo che garantisce che un sistema possa gestire normalmente un input imprevisto o un comportamento indesiderato. Il test con dati casuali è un esempio di test negativo. Con il test con dati casuali, viene testato un sistema che riceve input per assicurarsi che possa gestire in modo sicuro l'input imprevisto.

Fortunatamente, Terraform è un livello di astrazione per qualsiasi API che crei, aggiorni o elimini entità dell'infrastruttura cloud. Terraform garantisce anche che la configurazione locale e le risposte dell'API remota siano sincronizzate. Poiché Terraform viene usato principalmente per le API cloud, è comunque necessario un modo per garantire che il codice distribuito nell'infrastruttura segua criteri specifici. Terraform-compliance, uno strumento gratuito e open source, fornisce questa funzionalità per le configurazioni di Terraform.

Usando l'esempio di macchina virtuale, un criterio di conformità potrebbe essere il seguente: "Se si sta creando una risorsa di Azure, deve contenere un tag".

Lo strumento Terraform-compliance fornisce un framework di test in cui è possibile creare criteri come quello illustrato nell'esempio. Questi criteri vengono quindi eseguiti nel piano di esecuzione di Terraform.

Terraform-compliance consente di applicare i principi di sviluppo basato su comportamento o BDD. Lo sviluppo basato su comportamento è un processo di collaborazione in cui tutti gli stakeholder cooperano insieme per definire le operazioni che un sistema deve eseguire. Tali stakeholder includono in genere gli sviluppatori, i tester e tutti coloro che hanno un interesse specifico o che saranno interessati dal sistema in fase di sviluppo. Lo sviluppo basato su comportamento ha l'obiettivo di incoraggiare i team a creare esempi concreti che esprimono principi comuni sulle modalità di comportamento del sistema.

3. Esaminare un esempio di test di conformità

In precedenza in questo articolo è stato descritto un esempio di test di conformità relativo alla creazione di una macchina virtuale per un ambiente di test. In questa sezione viene illustrato come convertire questo esempio in una funzionalità e in uno scenario di sviluppo basato su comportamento. La regola viene innanzitutto espressa con Cucumber, che è uno strumento usato per supportare lo sviluppo basato su comportamento.

when creating Azure resources, every new resource should have a tag

La regola precedente viene convertita come indicato di seguito:

If the resource supports tags
Then it must contain a tag
And its value must not be null

Il codice HCL Terraform aderirebbe alla regola, come indicato di seguito.

resource "random_uuid" "uuid" {}

resource "azurerm_resource_group" "rg" {
  name     = "rg-hello-tf-${random_uuid.uuid.result}"
  location = var.location

  tags = {
    environment = "dev"
    application = "Azure Compliance"
  } 
}

Il primo criterio può essere scritto come uno scenario di funzionalità BDD come indicato di seguito:

Feature: Test tagging compliance  # /target/src/features/tagging.feature
    Scenario: Ensure all resources have tags
        If the resource supports tags
        Then it must contain a tag
        And its value must not be null

Il codice seguente mostra un test per un tag specifico:

Scenario Outline: Ensure that specific tags are defined
    If the resource supports tags
    Then it must contain a tag <tags>
    And its value must match the "<value>" regex

    Examples:
      | tags        | value              |
      | Creator     | .+                 |
      | Application | .+                 |
      | Role        | .+                 |
      | Environment | ^(prod\|uat\|dev)$ |

4. Eseguire l'esempio di test di conformità

In questa sezione viene scaricato e testato l'esempio.

All'interno della directory di esempio passare alla src directory .
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 principali:
- Viene visualizzato un messaggio che indica che la configurazione di Terraform è valida.
Eseguire terraform plan per creare un piano di esecuzione.
```
terraform plan -out main.tfplan
```
Eseguire terraform show per convertire il piano di esecuzione in JSON per il passaggio di conformità.
```
terraform show -json main.tfplan > main.tfplan.json
```
Eseguire docker pull per scaricare l'immagine di terraform-compliance.
```
docker pull eerkunt/terraform-compliance
```
Eseguire docker run per eseguire i test in un contenitore Docker.
```
docker run --rm -v $PWD:/target -it eerkunt/terraform-compliance -f features -p main.tfplan.json
```
Punti principali:
- Il test avrà esito negativo perché, mentre la prima regola che richiede l'esistenza dei tag ha esito positivo, la seconda regola non riesce perché mancano i Role tag e Creator .
Correggere l'errore modificando come indicato di main.tf seguito (dove vengono aggiunti un Role tag e Creator ).
```
  tags = {
    Environment = "dev"
    Application = "Azure Compliance"
    Creator     = "Azure Compliance"
    Role        = "Azure Compliance"
  } 
```
Punti principali:
- La configurazione è ora conforme ai criteri.

5. Verificare i risultati

Eseguire di nuovo terraform validate per verificare la sintassi.
```
terraform validate
```
Eseguire di nuovo terraform plan per creare un nuovo piano di esecuzione.
```
terraform plan -out main.tfplan
```
Eseguire terraform show per convertire il piano di esecuzione in JSON per il passaggio di conformità.
```
terraform show -json main.tfplan > main.tfplan.json
```
Eseguire di nuovo docker run per testare la configurazione. Se la specifica completa è stata implementata, il test ha esito positivo.
```
docker run --rm -v $PWD:/target -it eerkunt/terraform-compliance -f features -p main.tfplan.json
```
Eseguire terraform apply per applicare il piano di esecuzione.
```
terraform apply main.tfplan -target=random_uuid.uuid
```
Punti principali:
- Viene creato un gruppo di risorse con un nome che segue il modello : rg-hello-tf-<random_number>.

Risolvere i problemi di Terraform in Azure

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

Passaggi successivi

Vedere altre informazioni sull'uso di Terraform in Azure