Implementera Terratest-testning från end-to-end till Terraform-projekt

E2E-testning (end-to-end) används för att verifiera att ett program fungerar innan det distribueras till produktion. Ett exempelscenario kan vara en Terraform-modul som distribuerar två virtuella datorer till ett virtuellt nätverk. Du kanske vill förhindra att de två datorerna pingar varandra. I det här exemplet kan du definiera ett test för att verifiera det avsedda resultatet före distributionen.

E2E-testning är vanligtvis en trestegsprocess.

1. En konfiguration tillämpas på en testmiljö.
2. Koden körs för att verifiera resultatet.
3. Testmiljön initieras antingen på nytt eller tas bort (till exempel att ta bort en virtuell dator).

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

• Förstå grunderna för testning från slutet till slut med Terratest
• Lär dig hur du skriver ett end-to-end-test med Golang
• Lär dig hur du använder Azure DevOps för att automatiskt utlösa end-to-end-tester när kod skickas till din lagringsplatsen

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

• Programmeringsspråket Go:Installera Go.

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

2. Förstå testning från slutet till slut

End-to-end-tester validerar att ett system fungerar som en samlad helhet. Den här typen av testning är i stället för att testa specifika moduler. För Terraform-projekt möjliggör testning från slutet till slut validering av vad som har distribuerats. Den här typen av testning skiljer sig från många andra typer som testar fördistributionsscenarier. Tester från slutet till slut är kritiska för testning av komplexa system som innehåller flera moduler och som agerar på flera resurser. I sådana scenarier är testning från slutet till slut det enda sättet att avgöra om de olika modulerna interagerar korrekt.

Den här artikeln fokuserar på hur du använder Terratest för att implementera testning från slutet till slut. Terratest tillhandahåller alla steg som krävs för att utföra följande uppgift:

• Distribuera en Terraform-konfiguration
• Gör att du kan skriva ett test med språket Go för att verifiera vad som har distribuerats
• Samordna testerna i faser
• Ta bort den distribuerade infrastrukturen

3. Förstå testexempel

I den här artikeln använder vi ett exempel som är tillgängligt i Azure/terraform-exempellagringsplatsen.

Det här exemplet definierar en Terraform-konfiguration som distribuerar två virtuella Linux-datorer till samma virtuella nätverk. En virtuell dator med namnet vm-linux-1 har en offentlig IP-adress. Endast port 22 öppnas för att tillåta SSH-anslutningar. Den andra virtuella datorn vm-linux-2 – – har ingen definierad offentlig IP-adress.

Testet validerar följande scenarier:

• Infrastrukturen distribueras korrekt
• Med port 22 går det att öppna en SSH-session för att vm-linux-1
• Med hjälp av vm-linux-1 SSH-sessionen på går det att pinga vm-linux-2

Om du laddade nedexemplet finns Terraform-konfigurationen för det här scenariot i filen . Filen main.tf innehåller allt som behövs för att distribuera Azure-infrastrukturen som representeras i föregående bild.

Om du inte är bekant med hur du skapar en virtuell dator kan du gå till Skapa en virtuell Linux-dator med infrastruktur i Azure med Terraform.

4. Granska testexempel

Hela testet är skrivet på språket Go och använder Terratest-ramverket. Om du laddade nedexemplet definieras testet i filen .

Följande källkod visar standardstrukturen för ett Golang-test med Terratest:

package test

import (
    "testing"

    "github.com/gruntwork-io/terratest/modules/terraform"
    test_structure "github.com/gruntwork-io/terratest/modules/test-structure"
)

func TestEndToEndDeploymentScenario(t *testing.T) {
    t.Parallel()

    fixtureFolder := "../"

    // Use Terratest to deploy the infrastructure
    test_structure.RunTestStage(t, "setup", func() {
        terraformOptions := &terraform.Options{
            // Indicate the directory that contains the Terraform configuration to deploy
            TerraformDir: fixtureFolder,
        }

        // Save options for later test stages
        test_structure.SaveTerraformOptions(t, fixtureFolder, terraformOptions)

        // Triggers the terraform init and terraform apply command
        terraform.InitAndApply(t, terraformOptions)
    })

    test_structure.RunTestStage(t, "validate", func() {
        // run validation checks here
        terraformOptions := test_structure.LoadTerraformOptions(t, fixtureFolder)
		    publicIpAddress := terraform.Output(t, terraformOptions, "public_ip_address")
    })

    // When the test is completed, teardown the infrastructure by calling terraform destroy
    test_structure.RunTestStage(t, "teardown", func() {
        terraformOptions := test_structure.LoadTerraformOptions(t, fixtureFolder)
        terraform.Destroy(t, terraformOptions)
    })
}

Som du ser i föregående kodfragment består testet av tre steg:

• installation:Kör Terraform för att distribuera konfigurationen
• validate': Kontrollerar och kontrollerar valideringen
• teardown:Rensar infrastrukturen när testet har körts

I följande lista visas några av de viktiga funktioner som tillhandahålls av Terratest-ramverket:

• Terraform. InitAndApply:Aktiverar körning och terraform apply från Go-kod
• Terraform. Utdata:Hämtar värdet för utdatavariabeln för distributionen.
• Terraform. Destroy: Kör kommandot från Go-koden.
• test_structure. LoadTerraformOptions:Läser in Terraform-alternativ – till exempel konfiguration och variabler – från tillståndet
• test_structure. SaveTerraformOptions:Sparar Terraform-alternativ – till exempel konfiguration och variabler – i tillståndet

5. Kör testexempel

Följande steg kör testet mot exempelkonfigurationen och distributionen.

1. Öppna ett bash-/terminalfönster.

2. Logga in på ditt Azure-konto.

3. Om du vill köra det här exempeltestet behöver du ett namn på ett privat/offentligt SSH-nyckelpar id_rsaid_rsa.pub och i din hemkatalog. Ersätt <your_user_name> med namnet på din hemkatalog.

   export TEST_SSH_KEY_PATH="~/.ssh/id_rsa"
   

4. Navigera till katalogen i src/test exempelkatalogen.

5. Kör testet.

   go test -v ./ -timeout 10m
   

6. Verifiera resultaten

När du har go test kört visas resultat som liknar följande utdata:

--- PASS: TestEndToEndDeploymentScenario (390.99s)
PASS
ok      test    391.052s

Felsöka Terraform på Azure

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

Nästa steg