Implementera integreringstester för Terraform-projekt i Azure

Artikel
10/23/2023

Terraform möjliggör definition, förhandsversion och distribution av molninfrastruktur. Med Terraform skapar du konfigurationsfiler med hjälp av HCL-syntax. Med HCL-syntaxen kan du ange molnleverantören – till exempel Azure – och de element som utgör din molninfrastruktur. När du har skapat konfigurationsfilerna skapar du en körningsplan som gör att du kan förhandsgranska ändringarna i infrastrukturen innan de distribueras. När du har verifierat ändringarna tillämpar du körningsplanen för att distribuera infrastrukturen.

Integreringstester verifierar att en nyligen introducerad kodändring inte bryter befintlig kod. I DevOps refererar kontinuerlig integrering (CI) till en process som skapar hela systemet när kodbasen ändras , till exempel någon som vill slå samman en PR till en Git-lagringsplats. Följande lista innehåller vanliga exempel på integreringstester:

Analysverktyg för statisk kod, till exempel lint och format.
Kör terraform validate för att verifiera syntaxen för konfigurationsfilen.
Kör terraform-planen för att säkerställa att konfigurationen fungerar som förväntat.

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

Lär dig grunderna i integreringstestning för Terraform-projekt.
Använd Azure DevOps för att konfigurera en pipeline för kontinuerlig integrering.
Kör statisk kodanalys på Terraform-kod.
Kör terraform validate för att verifiera Terraform-konfigurationsfiler på den lokala datorn.
Kör terraform plan för att verifiera att Terraform-konfigurationsfiler ur ett fjärrtjänstperspektiv.
Använd en Azure Pipeline för att automatisera kontinuerlig integrering.

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:

Azure DevOps-organisation och -projekt: Om du inte har något skapar du en Azure DevOps-organisation.
Tillägg för Terraform Build & Release Tasks: Installera tillägget Terraform build/release tasks i din Azure DevOps-organisation.
Ge Azure DevOps åtkomst till din Azure-prenumeration: Skapa en Azure-tjänstanslutning med namnet terraform-basic-testing-azure-connection så att Azure Pipelines kan ansluta till dina Azure-prenumerationer
Exempelkod och resurser: Ladda ned integrationstestprojektet från GitHub. Katalogen som du laddar ned exemplet till kallas exempelkatalogen.

2. Verifiera en lokal Terraform-konfiguration

Kommandot terraform validate körs från kommandoraden i katalogen som innehåller Dina Terraform-filer. Huvudmålet med de här kommandona är att validera syntaxen.

Navigera till katalogen i exempelkatalogen src .
Kör terraform init för att initiera arbetskatalogen.
```
terraform init
```
Kör terraform validate för att verifiera syntaxen för konfigurationsfilerna.
```
terraform validate
```
Viktiga punkter:
- Du ser ett meddelande som anger att Terraform-konfigurationen är giltig.
Redigera filen main.tf.
På rad 5 infogar du ett stavfel som ogiltigförklarar syntaxen. Ersätt till exempel var.location med var.loaction
Spara filen.
Kör valideringen igen.
```
terraform validate
```
Viktiga punkter:
- Du ser ett felmeddelande som anger kodraden i fel och en beskrivning av felet.

Som du ser har Terraform identifierat ett problem i konfigurationskodens syntax. Det här problemet förhindrar att konfigurationen distribueras.

Det är en bra idé att alltid köra terraform validate mot dina Terraform-filer innan du skickar dem till versionskontrollsystemet. Den här valideringsnivån bör också vara en del av pipelinen för kontinuerlig integrering. Senare i den här artikeln utforskar vi hur du konfigurerar en Azure-pipeline för automatisk verifiering.

3. Verifiera Terraform-konfiguration

I föregående avsnitt såg du hur du verifierar en Terraform-konfiguration. Den testnivån var specifik för syntax. Det testet tog inte hänsyn till vad som kanske redan har distribuerats i Azure.

Terraform är ett deklarativt språk , vilket innebär att du deklarerar vad du vill ha som ett slutresultat. Anta till exempel att du har 10 virtuella datorer i en resursgrupp. Sedan skapar du en Terraform-fil som definierar tre virtuella datorer. Att tillämpa den här planen ökar inte det totala antalet till 13. I stället tar Terraform bort sju av de virtuella datorerna så att du slutar med tre. När du kör terraform plan kan du bekräfta de potentiella resultaten av att tillämpa en körningsplan för att undvika överraskningar.

Om du vill generera Terraform-körningsplanen kör du terraform-planen. Det här kommandot ansluter till Azure-målprenumerationen för att kontrollera vilken del av konfigurationen som redan har distribuerats. Terraform bestämmer sedan de nödvändiga ändringarna för att uppfylla kraven som anges i Terraform-filen. I det här skedet distribuerar Terraform ingenting. Det säger dig vad som kommer att hända om du tillämpar planen.

Om du följer med i artikeln och har gjort stegen i föregående avsnitt kör terraform plan du kommandot:

terraform plan

När terraform har körts terraform planvisar det potentiella resultatet av att tillämpa körningsplanen. Utdata anger de Azure-resurser som ska läggas till, ändras och förstöras.

Som standard lagrar Terraform tillstånd i samma lokala katalog som Terraform-filen. Det här mönstret fungerar bra i scenarier med en användare. Men när flera personer arbetar med samma Azure-resurser kan lokala tillståndsfiler bli osynkroniserade. För att åtgärda det här problemet har Terraform stöd för att skriva tillståndsfiler till ett fjärrdatalager (till exempel Azure Storage). I det här scenariot kan det vara problematiskt att köra terraform plan på en lokal dator och rikta in sig på en fjärrdator. Därför kan det vara klokt att automatisera det här valideringssteget som en del av pipelinen för kontinuerlig integrering.

4. Kör statisk kodanalys

Statisk kodanalys kan göras direkt på Terraform-konfigurationskoden, utan att köra den. Den här analysen kan vara användbar för att identifiera problem som säkerhetsproblem och inkonsekvens i efterlevnaden.

Följande verktyg tillhandahåller statisk analys för Terraform-filer:

Statisk analys körs ofta som en del av en pipeline för kontinuerlig integrering. Dessa tester kräver inte att en körningsplan eller distribution skapas. Därför körs de snabbare än andra tester och körs vanligtvis först i processen för kontinuerlig integrering.

5. Automatisera integreringstester med Hjälp av Azure Pipeline

Kontinuerlig integrering innebär att testa ett helt system när en ändring införs. I det här avsnittet visas en Azure Pipeline-konfiguration som används för att implementera kontinuerlig integrering.

Med valfri redigerare bläddrar du till den lokala klonen av Terraform-exempelprojektet på GitHub.
Öppna samples/integration-testing/src/azure-pipeline.yaml-filen.
Rulla ned till stegavsnittet där du ser en standarduppsättning med steg som används för att köra olika installations- och valideringsrutiner.
Granska raden som läser steg 1: kör Checkov Static Code Analysis. I det här steget kör projektet Checkov som nämndes tidigare en statisk kodanalys på Terraform-exempelkonfigurationen.
```
- bash: $(terraformWorkingDirectory)/checkov.sh $(terraformWorkingDirectory)
  displayName: Checkov Static Code Analysis
```
Viktiga punkter:
- Det här skriptet ansvarar för att köra Checkov på Terraform-arbetsytan som monterats i en Docker-container. Microsoft-hanterade agenter är Docker-aktiverade. Att köra verktyg i en Docker-container är enklare och tar bort behovet av att installera Checkov på Azure Pipeline-agenten.
- Variabeln $(terraformWorkingDirectory) definieras i azure-pipeline.yaml filen.
Granska raden med texten Steg 2: installera Terraform på Azure Pipelines-agenten. Tillägget Terraform Build & Release Task som du installerade tidigare har ett kommando för att installera Terraform på agenten som kör Azure Pipeline. Den här uppgiften är vad som görs i det här steget.
```
- task: charleszipp.azure-pipelines-tasks-terraform.azure-pipelines-tasks-terraform-installer.TerraformInstaller@0
  displayName: 'Install Terraform'
  inputs:
    terraformVersion: $(terraformVersion)
```
Viktiga punkter:
- Den version av Terraform som ska installeras anges via en Azure Pipeline-variabel med namnet terraformVersion och definieras i azure-pipeline.yaml filen.
Granska raden som läser steg 3: kör Terraform init för att initiera arbetsytan. Nu när Terraform har installerats på agenten kan Terraform-katalogen initieras.
```
- task: charleszipp.azure-pipelines-tasks-terraform.azure-pipelines-tasks-terraform-cli.TerraformCLI@0
  displayName: 'Run terraform init'
  inputs:
    command: init
    workingDirectory: $(terraformWorkingDirectory)
```
Viktiga punkter:
- Indata command anger vilket Terraform-kommando som ska köras.
- Indata workingDirectory anger sökvägen till Terraform-katalogen.
- Variabeln $(terraformWorkingDirectory) definieras i azure-pipeline.yaml filen.

Granska raden som läser steg 4: kör Terraform validate för att verifiera HCL-syntaxen. När projektkatalogen har initierats terraform validate körs den för att verifiera konfigurationen på servern.

- task: charleszipp.azure-pipelines-tasks-terraform.azure-pipelines-tasks-terraform-cli.TerraformCLI@0
  displayName: 'Run terraform validate'
  inputs:
    command: validate
    workingDirectory: $(terraformWorkingDirectory)

Granska raden som läser steg 5: kör Terraform-planen för att verifiera HCL-syntaxen. Som vi förklarade tidigare görs genereringen av körningsplanen för att kontrollera om Terraform-konfigurationen är giltig före distributionen.
```
- 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)
```
Viktiga punkter:
- Indata environmentServiceName refererar till namnet på azure-tjänstanslutningen som skapades i Konfigurera din miljö. Med anslutningen kan Terraform komma åt din Azure-prenumeration.
- Indata commandOptions används för att skicka argument till Terraform-kommandot. I det här fallet anges en plats. Variabeln $(azureLocation) definieras tidigare i YAML-filen.

Importera pipelinen till Azure DevOps

Öppna ditt Azure DevOps-projekt och gå till avsnittet Azure Pipelines.
Välj knappen Skapa pipeline .
För alternativet Var är din kod? väljer du GitHub (YAML).
Nu kan du behöva auktorisera Azure DevOps för att få åtkomst till din organisation. Mer information om det här avsnittet finns i artikeln Skapa GitHub-lagringsplatser.
I listan med lagringsplatser väljer du förgrening för den lagringsplats som du skapade i din GitHub-organisation.
I steget Konfigurera pipeline väljer du att starta från en befintlig YAML-pipeline.
När sidan Välj befintlig YAML-pipeline visas anger du grenen master och anger sökvägen till YAML-pipelinen: samples/integration-testing/src/azure-pipeline.yaml.
Välj Fortsätt för att läsa in Azure YAML-pipelinen från GitHub.
När yaml-sidan Granska din pipeline visas väljer du Kör för att skapa och utlöser pipelinen manuellt för första gången.

Verifiera resultatet

Du kan köra pipelinen manuellt från Azure DevOps-användargränssnittet. Poängen med artikeln är dock att visa automatiserad kontinuerlig integrering. Testa processen genom att göra en ändring i mappen för samples/integration-testing/src din förgrenade lagringsplats. Ändringen utlöser automatiskt en ny pipeline på den gren där du push-överför koden.

Pipeline som körs från GitHub