Nalevingstests implementeren met Terraform en Azure

Artikel
12/03/2021
6 minuten om te lezen

Nalevingstests maken vaak deel uit van het continue integratieproces en worden gebruikt om ervoor te zorgen dat door de gebruiker gedefinieerd beleid wordt gevolgd. U kunt bijvoorbeeld geopolitieke naamconventie voor uw Azure-resources definiëren. Een ander veelvoorkomende voorbeeld is het maken van virtuele machines op basis van een gedefinieerde subset van afbeeldingen. Nalevingstests worden gebruikt om regels af te dwingen in deze en vele andere scenario's.

In dit artikel leert u het volgende:

Begrijpen wanneer u nalevingstests gebruikt

Meer informatie over het uitvoeren van een nalevingstest

Een voorbeeld van een nalevingstest bekijken en uitvoeren

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:

Docker:Installeer Docker.
Python:Installeer Python.
Terraform-nalevingshulpprogramma: Installeer het terraform-nalevingshulpprogramma door de volgende opdracht uit te voeren: .
Voorbeeldcode en resources: Download met behulp van het hulpprogramma DownGit van GitHub het project voor nalevingstests en uit te voeren in een nieuwe map om de voorbeeldcode op te nemen. Deze map wordt de voorbeeldmap genoemd.

2. Inzicht in nalevingstests en -controles

Nalevingstests zijn een niet-functionele testtechniek om te bepalen of een systeem voldoet aan de voorgeschreven normen. Nalevingstests worden ook wel conformiteitstests genoemd.

De meeste softwareteams voeren een analyse uit om te controleren of de standaarden correct worden afgedwongen en geïmplementeerd. Vaak wordt tegelijkertijd gewerkt om de standaarden te verbeteren die op hun beurt leiden tot betere kwaliteit.

Bij nalevingstests zijn er twee belangrijke concepten om rekening mee te houden: nalevingstests en nalevingscontroles.

Nalevingstests zorgen ervoor dat de uitvoer van elke fase van de ontwikkelingslevenscyclus voldoet aan overeengekomen vereisten.
Nalevingscontroles moeten worden geïntegreerd in de ontwikkelingscyclus aan het begin van de projecten. Het toevoegen van nalevingscontroles in een later stadium wordt steeds moeilijker wanneer de vereiste zelf niet voldoende wordt gedocumenteerd.

Het uitvoeren van nalevingscontroles is heel duidelijk. Er wordt een set standaarden en procedures ontwikkeld en gedocumenteerd voor elke fase van de ontwikkelingslevenscyclus. De uitvoer van elke fase wordt vergeleken met de gedocumenteerde vereisten. De resultaten van de test zijn eventuele 'hiaten' die niet voldoen aan de vooraf vastgestelde standaarden. Nalevingstests worden uitgevoerd via het inspectieproces en het resultaat van het beoordelingsproces moet worden gedocumenteerd.

Laten we eens kijken naar een specifiek voorbeeld.

Een veelvoorkomende probleem zijn omgevingen die niet werken wanneer meerdere ontwikkelaars incompatibele wijzigingen toepassen. Stel, één persoon werkt aan een wijziging en past resources toe, zoals het maken van een VM in een testomgeving. Een andere persoon past vervolgens een andere versie van de code toe die een andere versie van die VM inst mankt. Wat hier nodig is, is toezicht om ervoor te zorgen dat deze voldoen aan de opgegeven regels.

Een manier om dit probleem op te lossen, is door een beleid te definiëren voor het taggen van de resources, zoals met role en creator tags. Zodra u het beleid definieert, wordt een hulpprogramma zoals Terraform-compliance gebruikt om ervoor te zorgen dat het beleid wordt gevolgd.

Terraform-naleving is gericht op het testen van negatieven. Negatieve tests zijn het proces waarbij ervoor wordt gezorgd dat een systeem zonder problemen onverwachte invoer of ongewenst gedrag kan afhandelen. Fuzzing is een voorbeeld van een negatieve test. Met fuzzing wordt een systeem getest dat invoer ontvangt om ervoor te zorgen dat onverwachte invoer veilig kan worden verwerkt.

Gelukkig is Terraform een abstractielaag voor elke API die entiteiten in de cloudinfrastructuur maakt, bij werkt of vernietigt. Terraform zorgt er ook voor dat de lokale configuratie en de externe API-antwoorden synchroon zijn. Omdat Terraform voornamelijk wordt gebruikt voor Cloud-API's, hebben we nog steeds een manier nodig om ervoor te zorgen dat de code die wordt geïmplementeerd op de infrastructuur, aan specifieke beleidsregels wordt toegepast. Terraform-compliance, een gratis en opensource-hulpprogramma, biedt deze functionaliteit voor Terraform-configuraties.

In het VM-voorbeeld kan een nalevingsbeleid er als volgt uit zien: 'Als u een Azure-resource maakt,moet het een tag bevatten'.

Het hulpprogramma Terraform-compliance biedt een test framework waarin u beleidsregels kunt maken zoals in het voorbeeld. Vervolgens kunt u deze beleidsregels uitvoeren op uw Terraform-uitvoeringsplan.

Met Terraform-naleving kunt u BDD of gedragsgestuurde ontwikkeling,principes toepassen. BDD is een samenwerkingsproces waarbij alle belanghebbenden samenwerken om te definiëren wat een systeem moet doen. Deze belanghebbenden omvatten in het algemeen de ontwikkelaars, testers en iedereen die geïnteresseerd is in het systeem dat wordt ontwikkeld of die worden beïnvloed door . Het doel van BDD is teams aan te sporen concrete voorbeelden te bouwen die een algemeen begrip tonen van hoe het systeem zich moet gedragen.

3. Bekijk een voorbeeld van een nalevingstest

Eerder in dit artikel hebt u meer gelezen over een voorbeeld van nalevingstests voor het maken van een VM voor een testomgeving. In deze sectie ziet u hoe u dat voorbeeld kunt vertalen naar een BDD-functie en -scenario. De regel wordt eerst uitgedrukt met Behulp van Het iseen hulpprogramma dat wordt gebruikt voor de ondersteuning van BDD.

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

De vorige regel wordt als volgt vertaald:

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

De Terraform HCL-code voldoet vervolgens als volgt aan de regel.

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

Het eerste beleid kan als volgt worden geschreven als een BDD-functiescenario:

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

De volgende code toont een test voor een specifieke tag:

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. Het voorbeeld nalevingstest uitvoeren

In deze sectie downloadt en test u het voorbeeld.

Navigeer in de voorbeeldmap naar de src map .
Voer terraform init uit om de werkmap te initialiseren.
```
terraform init
```
Voer terraform validate uit om de syntaxis van de configuratiebestanden te valideren.
```
terraform validate
```
Belangrijkste punten:
- U ziet een bericht dat aangeeft dat de Terraform-configuratie geldig is.
Voer terraform plan uit om een uitvoeringsplan te maken.
```
terraform plan -out main.tfplan
```
Voer terraform show uit om het uitvoeringsplan te converteren naar JSON voor de nalevingsstap.
```
terraform show -json main.tfplan > main.tfplan.json
```
Voer terraform apply uit om het uitvoeringsplan toe te passen.
```
terraform apply main.tfplan -target=random_uuid.uuid
```
Belangrijkste punten:
- Er wordt een resourcegroep gemaakt met een naam die het patroon volgt: rg-hello-tf-<random_number> .
Voer docker pull uit om de terraform-compliance-afbeelding te downloaden.
```
docker pull eerkunt/terraform-compliance
```
Voer docker run uit om de tests uit te voeren in een Docker-container.
```
docker run --rm -v $PWD:/target -it eerkunt/terraform-compliance -f features -p main.tfplan.json
```
Belangrijkste punten:
- De test mislukt omdat , terwijl de eerste regel die het bestaan van tags vereist, slaagt, de tweede regel mislukt omdat de tags en RoleCreator ontbreken.
Los de fout op door als main.tf volgt te wijzigen (waarbij een tag en Role worden Creator toegevoegd).
```
  tags = {
    Environment = "dev"
    Application = "Azure Compliance"
    Creator     = "Azure Compliance"
    Role        = "Azure Compliance"
  } 
```
Belangrijkste punten:
- De configuratie voldoet nu aan het beleid.

5. De resultaten controleren

Voer terraform validate opnieuw uit om de syntaxis te controleren.
```
terraform validate
```
Voer terraform plan opnieuw uit om een nieuw uitvoeringsplan te maken.
```
terraform plan -out main.tfplan
```
Voer terraform show uit om het uitvoeringsplan te converteren naar JSON voor de nalevingsstap.
```
terraform show -json main.tfplan > main.tfplan.json
```
Voer docker run opnieuw uit om de configuratie te testen. Als de volledige specificatie is geïmplementeerd, slaagt de test.
```
docker run --rm -v $PWD:/target -it eerkunt/terraform-compliance -f features -p main.tfplan.json
```

Problemen met Terraform in Azure oplossen

Veelvoorkomende problemen bij het gebruik van Terraform in Azure oplossen

Volgende stappen

Meer informatie over het gebruik van Terraform in Azure