Implementera efterlevnadstestning med Terraform och Azure

Ofta är efterlevnadstestning en del av den kontinuerliga integreringsprocessen och används för att säkerställa att användardefinierade principer följs. Du kan till exempel definiera geopolitiska namngivningskonventioner för dina Azure-resurser. Ett annat vanligt exempel är att skapa virtuella datorer från en definierad delmängd av avbildningar. Efterlevnadstestning skulle användas för att framtvinga regler i dessa och många andra scenarier.

I den här artikeln kan du se hur du:

• Förstå när du ska använda efterlevnadstestning
• Lär dig hur du gör ett kompatibilitetstest
• Visa och köra ett exempel på ett kompatibilitetstest

1. Konfigurera din miljö

• Azure-prenumeration: Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.

• Konfigurera Terraform: Om du inte redan har gjort det konfigurerar du Terraform med något av följande alternativ:

  • Konfigurera Terraform i Azure Cloud Shell med Bash
  • Konfigurera Terraform i Azure Cloud Shell med PowerShell
  • Konfigurera Terraform i Windows med Bash
  • Konfigurera Terraform i Windows med PowerShell

• Docker:Installera Docker.

• Python:Installera Python.

• Terraform-efterlevnadsverktyg: Installera Terraform-kompatibilitetsverktyget genom att köra följande kommando: .

• Exempelkod och resurser: Med verktyget DownGit laddar du ned GitHub från projektet för efterlevnadstestning och packa upp det i en ny katalog som innehåller exempelkoden. Den här katalogen kallas för exempelkatalogen.

2. Förstå efterlevnadstestning och -kontroller

Efterlevnadstestning är en icke-funktionell testteknik för att avgöra om ett system uppfyller föreskrivna standarder. Efterlevnadstestning kallas även för överensstämmelsetestning.

De flesta programvaruteam gör en analys för att kontrollera att standarderna tillämpas och implementeras korrekt. Arbetar ofta samtidigt för att förbättra de standarder som i sin tur leder till ökad kvalitet.

När det gäller efterlevnadstestning finns det två viktiga begrepp att tänka på: efterlevnadstestning och efterlevnadskontroller.

• Kompatibilitetstestning säkerställer att utdata för varje utvecklingslivscykelfas överensstämmer med de krav som överenskommits.
• Efterlevnadskontroller bör integreras i utvecklingscykeln i början av projekten. Försök att lägga till efterlevnadskontroller i ett senare skede blir allt svårare när själva kravet inte är tillräckligt dokumenterat.

Det är rätt att utföra efterlevnadskontroller. En uppsättning standarder och procedurer utvecklas och dokumenteras för varje fas i utvecklingslivscykeln. Utdata för varje fas jämförs med de dokumenterade kraven. Resultatet av testet är eventuella "luckor" i att inte följa de förutbestämda standarderna. Efterlevnadstestning utförs genom inspektionsprocessen och resultatet av granskningsprocessen bör dokumenteras.

Låt oss ta en titt på ett specifikt exempel.

Ett vanligt problem är miljöer som bryts när flera utvecklare tillämpar inkompatibla ändringar. Anta att en person arbetar med en ändring och använder resurser som att skapa en virtuell dator i en testmiljö. En annan person tillämpar sedan en annan version av koden som tillerer en annan version av den virtuella datorn. Det som behövs här är tillsyn för att säkerställa att de angivna reglerna följs.

Ett sätt att åtgärda det här problemet är att definiera en princip för taggning av resurser , till exempel med rolecreator taggarna och . När du har definierat principerna används ett verktyg som Terraform-compliance för att säkerställa att principerna följs.

Terraform-efterlevnad fokuserar på negativ testning. Negativ testning är processen att säkerställa att ett system på ett smidigt sätt kan hantera oväntade indata eller oönskade beteenden. Fuzzing är ett exempel på negativ testning. Med fuzzing testas ett system som tar emot indata för att säkerställa att det på ett säkert sätt kan hantera oväntade indata.

Lyckligtvis är Terraform ett abstraktionslager för alla API:er som skapar, uppdaterar eller förstör entiteter i molninfrastrukturen. Terraform ser också till att den lokala konfigurationen och fjärr-API-svaren är synkroniserade. Eftersom Terraform främst används mot moln-API:er behöver vi fortfarande ett sätt att se till att koden som distribueras mot infrastrukturen följer specifika principer. Terraform-efterlevnad – ett kostnadsfritt verktyg med öppen källkod – ger den här funktionen för Terraform-konfigurationer.

I exemplet med den virtuella datorn kan en efterlevnadsprincip vara följande: "Om du skapar en Azure-resurs måste den innehålla en tagg".

Terraform-efterlevnadsverktyget tillhandahåller ett testramverk där du skapar principer som i exemplet. Sedan kör du dessa principer mot terraform-körningsplanen.

Med Terraform-efterlevnad kan du tillämpa principer för BDD eller beteendedrivenutveckling. BDD är en samarbetsprocess där alla intressenter arbetar tillsammans för att definiera vad ett system ska göra. Dessa intressenter omfattar vanligtvis utvecklare, testare och alla som är intresserade av – eller som påverkas av – det system som utvecklas. Målet med BDD är att uppmuntra team att skapa konkreta exempel som uttrycker en gemensam förståelse för hur systemet ska bete sig.

3. Granska ett exempel på kompatibilitetstest

Tidigare i den här artikeln läste du om ett exempel på efterlevnadstestning för att skapa en virtuell dator för en testmiljö. Det här avsnittet visar hur du översätter det exemplet till en BDD-funktion och ett BDD-scenario. Regeln uttrycks först med Hjälp av 1.0, vilket är ett verktyg som används för att stödja BDD.

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

Den tidigare regeln översätts på följande sätt:

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

Terraform HCL-koden följer sedan regeln enligt följande.

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"
  } 
}

Den första principen kan skrivas som ett BDD-funktionsscenario på följande sätt:

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

Följande kod visar ett test för en viss tagg:

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. Kör exemplet på efterlevnadstest

I det här avsnittet laddar du ned och testar exemplet.

1. Navigera till katalogen i src exempelkatalogen.

2. Kör terraform init för att initiera arbetskatalogen.

   terraform init
   

3. Kör terraform validate för att verifiera syntaxen för konfigurationsfilerna.

   terraform validate
   

   Viktiga punkter:

   • Ett meddelande visas som anger att Terraform-konfigurationen är giltig.

4. Kör terraform-plan för att skapa en körningsplan.

   terraform plan -out main.tfplan
   

5. Kör terraform show för att konvertera körningsplanen till JSON för kompatibilitetssteget.

   terraform show -json main.tfplan > main.tfplan.json
   

6. Kör terraform apply för att tillämpa körningsplanen.

   terraform apply main.tfplan -target=random_uuid.uuid
   

   Viktiga punkter:

   • En resursgrupp skapas med ett namn som följer mönstret: rg-hello-tf-<random_number> .

7. Kör docker pull för att ladda ned terraform-compliance-avbildningen.

   docker pull eerkunt/terraform-compliance
   

8. Kör docker run för att köra testerna i en Docker-container.

   docker run --rm -v $PWD:/target -it eerkunt/terraform-compliance -f features -p main.tfplan.json
   

   Viktiga punkter:

   • Testet misslyckas eftersom den andra regeln, även om den första regeln som kräver att det finns taggar lyckas, misslyckas eftersom RoleCreator taggarna och saknas.

   

9. Åtgärda felet genom att ändra main.tf på följande sätt (där en - och RoleCreator -tagg läggs till).

     tags = {
       Environment = "dev"
       Application = "Azure Compliance"
       Creator     = "Azure Compliance"
       Role        = "Azure Compliance"
     } 
   
   

   Viktiga punkter:

   • Konfigurationen följer nu principen.

5. Verifiera resultaten

1. Kör terraform validate igen för att verifiera syntaxen.

   terraform validate
   

2. Kör terraform plan igen för att skapa en ny körningsplan.

   terraform plan -out main.tfplan
   

3. Kör terraform show för att konvertera körningsplanen till JSON för kompatibilitetssteget.

   terraform show -json main.tfplan > main.tfplan.json
   

4. Kör docker-körningen igen för att testa konfigurationen. Om den fullständiga specifikationen har implementerats lyckas testet.

   docker run --rm -v $PWD:/target -it eerkunt/terraform-compliance -f features -p main.tfplan.json
   

   

Felsöka Terraform på Azure

Felsöka vanliga problem när du använder Terraform på Azure

Nästa steg