End-to-end Terratest-tests implementeren in Terraform-projecten

End-to-end -tests (E2E) worden gebruikt om te controleren of een programma werkt voordat het in productie wordt geïmplementeerd. Een voorbeeldscenario is een Terraform-module die twee virtuele machines in een virtueel netwerk implementeert. Mogelijk wilt u voorkomen dat de twee computers elkaar pingen. In dit voorbeeld kunt u een test definiëren om het beoogde resultaat vóór de implementatie te controleren.

E2E-tests zijn doorgaans een proces dat uit drie stappen bestaat.

1. Een configuratie wordt toegepast op een testomgeving.
2. Code wordt uitgevoerd om de resultaten te controleren.
3. De testomgeving wordt opnieuw geinialiseerd of uit de testomgeving genomen (zoals het verplaatsen van de toewijzing van een virtuele machine).

In dit artikel leert u het volgende:

• De basisbeginselen van end-to-end testen met Terratest
• Meer informatie over end-to-end-test schrijven met Golang
• Meer informatie over het gebruik van Azure DevOps om automatisch end-to-end-tests te activeren wanneer code wordt vastgelegd in uw repo

1. Uw omgeving configureren

• Azure-abonnement: Als u nog geen abonnement op Azure hebt, maak dan een gratis account aan voordat u begint.

• Terraform configureren: Als u dit nog niet hebt gedaan, configureert u Terraform met een van de volgende opties:

  • Terraform configureren in Azure Cloud Shell met Bash
  • Terraform configureren in Azure Cloud Shell met PowerShell
  • Terraform configureren in Windows met Bash
  • Terraform configureren in Windows met PowerShell

• Go-programmeertaal:installeer Go.

• Voorbeeldcode en resources: Download met behulp van het hulpprogramma DownGit van GitHub het end-to-end-testproject en uit te voeren in een nieuwe map om de voorbeeldcode op te nemen. Deze map wordt de voorbeelddirectory genoemd.

2. End-to-end testen begrijpen

End-to-end tests valideren of een systeem werkt als een geheel. Dit type test is in tegenstelling tot het testen van specifieke modules. Voor Terraform-projecten kunt u end-to-end testen om te valideren wat er is geïmplementeerd. Dit type tests verschilt van veel andere typen die scenario's vóór de implementatie testen. End-to-end-tests zijn essentieel voor het testen van complexe systemen die meerdere modules bevatten en op meerdere resources reageren. In dergelijke scenario's is end-to-end testen de enige manier om te bepalen of de verschillende modules correct communiceren.

Dit artikel is gericht op het gebruik van Terratest om end-to-end testen te implementeren. Terratest biedt alle aansluitingen die nodig zijn om de volgende taak uit te voeren:

• Een Terraform-configuratie implementeren
• Hiermee kunt u een test schrijven met behulp van de Go-taal om te valideren wat er is geïmplementeerd
• De tests in fasen in orchestrate
• De geïmplementeerde infrastructuur afbreken

3. Het testvoorbeeld begrijpen

Voor dit artikel gebruiken we een voorbeeld dat beschikbaar is in de voorbeeld-repo van Azure/terraform.

Dit voorbeeld definieert een Terraform-configuratie die twee virtuele Linux-machines in hetzelfde virtuele netwerk implementeert. Eén VM met de vm-linux-1 naam heeft een openbaar IP-adres. Alleen poort 22 wordt geopend om SSH-verbindingen toe te staan. De tweede VM vm-linux-2 heeft geen gedefinieerd openbaar IP-adres.

De test valideert de volgende scenario's:

• De infrastructuur is correct geïmplementeerd
• Met behulp van poort 22 is het mogelijk om een SSH-sessie te openen voor vm-linux-1
• Met behulp van de SSH-sessie op is vm-linux-1 het mogelijk om te pingen vm-linux-2

Als u het voorbeeld hebt gedownload,kunt u de Terraform-configuratie voor dit scenario vinden in het bestand . Het main.tf bestand bevat alles wat nodig is om de Azure-infrastructuur te implementeren die in de voorgaande afbeelding wordt weergegeven.

Zie Een virtuele Linux-machine maken met infrastructuur in Azure met behulp van Terraformals u niet bekend bent met het maken van een virtuele machine.

4. Het testvoorbeeld bekijken

De end-to-end-test is geschreven in de Go-taal en maakt gebruik van het Terratest-framework. Als u het voorbeeld hebt gedownload,wordt de test gedefinieerd in het bestand .

De volgende broncode toont de standaardstructuur van een Golang-test met behulp van 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)
    })
}

Zoals u in het vorige codefragment kunt zien, bestaat de test uit drie fasen:

• setup:Terraform wordt uitgevoerd om de configuratie te implementeren
• validate': Worden de validatiecontroles en -asserty's uitgevoerd
• teardown:schoont de infrastructuur op nadat de test is uitgevoerd

In de volgende lijst ziet u enkele van de belangrijkste functies van het Terratest-framework:

• Terraform. InitAndApply:hiermee schakelt u het uitvoeren van en van terraform apply Go-code in
• Terraform. Uitvoer:haalt de waarde van de uitvoervariabele voor de implementatie op.
• Terraform. Vernietigen:voert de opdracht uit vanuit Go-code.
• test_structure. Load HebtformOptions:laadt Terraform-opties , zoals configuratie en variabelen, vanuit de status
• test_structure. SaveVermenigvuldigenformOptions:Hiermee worden Terraform-opties, zoals configuratie en variabelen, op de status op slaan

5. Het testvoorbeeld uitvoeren

Met de volgende stappen wordt de test uitgevoerd op basis van de voorbeeldconfiguratie en -implementatie.

1. Open een bash-/terminalvenster.

2. Meld u aan bij uw Azure-account.

3. Als u deze voorbeeldtest wilt uitvoeren, hebt u de naam van het persoonlijke/openbare SSH-sleutelpaar en id_rsaid_rsa.pub in uw basismap nodig. Vervang <your_user_name> door de naam van uw basismap.

   export TEST_SSH_KEY_PATH="~/.ssh/id_rsa"
   

4. Navigeer in de voorbeeldmap naar de src/test map .

5. Voer de test uit.

   go test -v ./ -timeout 10m
   

6. De resultaten controleren

Nadat is go test uitgevoerd, ziet u resultaten die vergelijkbaar zijn met de volgende uitvoer:

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

Problemen met Terraform in Azure oplossen

Veelvoorkomende problemen bij het gebruik van Terraform in Azure oplossen

Volgende stappen