Implementera integreringstester för Terraform-projekt i Azure

Artikel
12/03/2021
7 minuter för att läsa

Integreringstester verifierar att en nyligen introducerad kodändring inte bryter befintlig kod. I DevOps refererar kontinuerlig integrering (CI) till en process som bygger hela systemet när kodbasen ändras – till exempel någon som vill sammanslå en PR till en Git-lagringsplatsen. 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 Terraform-konfigurationsfilerna 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ågon skapar du en Azure DevOps-organisation.
Terraform Build Versionsuppgifter- tillägg:Installera Terraform-tillägget för build/release-uppgifter i din Azure DevOps-organisation.
Ge Azure DevOps åtkomst till din Azure-prenumeration:Skapa en Azure-tjänstanslutning med namnet så att Azure Pipelines kan ansluta till dina Azure-prenumerationer
Exempelkod och resurser: Med verktyget DownGit laddar du ned från GitHub integreringstestprojektet och packa upp det i en ny katalog som innehåller exempelkoden. Den här katalogen kallas för exempelkatalogen.

2. Verifiera en lokal Terraform-konfiguration

Kommandot terraform validate körs från kommandoraden i katalogen som innehåller terraform-filerna. Det här kommandots huvudmål är att verifiera syntaxen.

Navigera till katalogen i src exempelkatalogen.
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:
- Ett meddelande visas som anger att Terraform-konfigurationen är giltig.
Redigera filen main.tf.
Infoga ett skrivfel på rad 5 som gör syntaxen ogiltig. 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 Terraform-filer innan du push-överförar dem till ditt versionskontrollsystem. Den här valideringsnivån bör också vara en del av din pipeline för kontinuerlig integrering. Senare i den här artikeln utforskar vi hur du konfigurerar en Azure-pipeline för att automatiskt verifiera.

3. Verifiera Terraform-konfigurationen

I föregående avsnitt såg du hur du verifierar en Terraform-konfiguration. Den testnivån var specifik för syntaxen. 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 slutresultat. Anta till exempel att du har 10 virtuella datorer i en resursgrupp. Sedan skapar du en Terraform-fil som definierar tre virtuella datorer. Om du tillämpar den här planen ökas inte det totala antalet till 13. I stället tar Terraform bort sju av de virtuella datorerna så att du slutar med tre. Genom terraform plan att köra 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 fastställer sedan de ändringar som krävs för att uppfylla kraven som anges i Terraform-filen. I det här skedet distribuerar Inte Terraform något. Den talar om för dig vad som händer om du tillämpar planen.

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

terraform plan

När du terraform plan har kört visar Terraform 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 synkroniserade. Terraform har stöd för att lösa det här problemet genom 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 bra att automatisera det här valideringssteget som en del av din pipeline för kontinuerlig integrering.

4. Kör analys av statisk kod

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 efterlevnad.

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. De här testerna kräver inte att du skapar en körningsplan eller distribution. Därför körs de snabbare än andra tester och körs vanligtvis först i den kontinuerliga integreringsprocessen.

5. Automatisera integreringstester med Azure Pipeline

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

Med val av redigeringsprogram bläddrar du till den lokala klonen av Terraform-exempelprojektet på GitHub.
Öppna filen samples/integration-testing/src/azure-pipeline.yaml.
Rulla ned till avsnittet steg där du ser en standarduppsättning med steg som används för att köra olika installations- och valideringsrutiner.
Granska raden steg 1: kör Checkov Static Code Analysis. I det här steget kör Checkov projektet 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. Det är enklare att köra verktyg i en Docker-container och du behöver inte installera Checkov på Azure Pipeline-agenten.
- Variabeln $(terraformWorkingDirectory) definieras i azure-pipeline.yaml filen .
Granska raden steg 2: installera Terraform på Azure Pipelines-agenten. Terraform Build Release Task-tillägget 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:
- Vilken version av Terraform som ska installeras anges via en Azure Pipeline-variabel med terraformVersion namnet och definieras i azure-pipeline.yaml filen .
Granska raden 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 steg 4: kör Terraform validate för att verifiera HCL-syntaxen. När projektkatalogen har initierats terraform validate körs 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 steg 5: kör Terraform-plan för att verifiera HCL-syntaxen. Som vi nämnde tidigare görs genereringen av körningsplanen för att verifiera 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 environmentServiceName Anslutningen gör att Terraform kan 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 finns din kod? väljer du GitHub (YAML).
Nu kan du behöva ge Azure DevOps åtkomst till din organisation. Mer information om det här ämnet finns i artikeln Build GitHub repositories.
I listan över lagringslager väljer du förklistraren för den lagringsplats som du skapade i GitHub organisationen.
I steget Konfigurera din pipeline väljer du att starta från en befintlig YAML-pipeline.
När sidan Välj befintlig YAML-pipeline visas anger du -grenen 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 sidan Granska din pipeline-YAML visas väljer du Kör för att skapa och utlösa pipelinen manuellt för första gången.

Verifiera resultaten

Du kan köra pipelinen manuellt från Azure DevOps-användargränssnittet. Artikeln handlar dock om att visa automatiserad kontinuerlig integrering. Testa processen genom att utföra en ändring i samples/integration-testing/src mappen för den fördelade lagringsplatsen. Ändringen utlöser automatiskt en ny pipeline på den gren där du push-kodar.

Pipeline som körs från GitHub