Nalevingstests implementeren met Terraform en Azure

Artikel
10/23/2023

Terraform maakt de definitie, preview en implementatie van de cloudinfrastructuur mogelijk. Met Behulp van Terraform maakt u configuratiebestanden met behulp van de HCL-syntaxis. Met de HCL-syntaxis kunt u de cloudprovider opgeven, zoals Azure, en de elementen waaruit uw cloudinfrastructuur bestaat. Nadat u uw configuratiebestanden hebt gemaakt, maakt u een uitvoeringsplan waarmee u een voorbeeld van uw infrastructuurwijzigingen kunt bekijken voordat ze worden geïmplementeerd. Zodra u de wijzigingen hebt gecontroleerd, past u het uitvoeringsplan toe om de infrastructuur te implementeren.

Nalevingstests maken vaak deel uit van het continue integratieproces en worden gebruikt om ervoor te zorgen dat door de gebruiker gedefinieerde beleidsregels worden gevolgd. U kunt bijvoorbeeld geopolitieke naamconventies definiëren voor uw Azure-resources. Een ander veelvoorkomend voorbeeld is het maken van virtuele machines op basis van een gedefinieerde subset van installatiekopieën. Nalevingstests worden gebruikt voor het afdwingen van regels in deze en vele andere scenario's.

In dit artikel leert u het volgende:

Meer informatie over het gebruik van nalevingstests
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, maakt u een gratis Azure-account aan voordat u begint.

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

Docker:Docker installeren.
Python:Installeer Python.
Terraform-compliance tool: Installeer het Terraform-nalevingsprogramma door de volgende opdracht uit te voeren: pip install terraform-compliance
Voorbeeldcode en resources: Download met het hulpprogramma DownGit het nalevingstestproject van GitHub en pak het uit in een nieuwe map om de voorbeeldcode te bevatten. 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 nalevingstests genoemd.

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

Bij nalevingstests zijn er twee belangrijke concepten waarmee u rekening moet houden: nalevingstests en nalevingscontroles.

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

Het uitvoeren van nalevingscontroles is eenvoudig. Een set standaarden en procedures wordt 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 'hiaten' die niet voldoen aan de vooraf vastgestelde normen. Nalevingstests worden uitgevoerd via het inspectieproces en het resultaat van het beoordelingsproces moet worden gedocumenteerd.

Laten we eens kijken naar een specifiek voorbeeld.

Een veelvoorkomend probleem is omgevingen die breken wanneer meerdere ontwikkelaars incompatibele wijzigingen toepassen. Stel dat één persoon aan een wijziging werkt en resources toepast, zoals het maken van een VIRTUELE machine in een testomgeving. Een andere persoon past vervolgens een andere versie van de code toe die een andere versie van die VM in richt. Wat hier nodig is, is toezicht op naleving van de vermelde 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 hebt gedefinieerd, wordt een hulpprogramma zoals Terraform-compliance gebruikt om ervoor te zorgen dat het beleid wordt gevolgd.

Terraform-compliance richt zich op negatieve tests. Negatieve tests zijn het proces om ervoor te zorgen dat een systeem onverwachte invoer of ongewenst gedrag correct kan verwerken. Fuzzing is een voorbeeld van negatieve tests. Bij fuzzing wordt een systeem dat invoer ontvangt getest om ervoor te zorgen dat het onverwachte invoer veilig kan verwerken.

Gelukkig is Terraform een abstractielaag voor elke API die entiteiten in de cloudinfrastructuur maakt, bijwerken of vernietigt. Terraform zorgt er ook voor dat de lokale configuratie en de externe API-antwoorden gesynchroniseerd 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 is geïmplementeerd op basis van de infrastructuur, een specifiek beleid volgt. Terraform-compliance - een gratis en opensource-hulpprogramma - biedt deze functionaliteit voor Terraform-configuraties.

Met behulp van het VM-voorbeeld kan een nalevingsbeleid er als volgt uitzien: 'Als u een Azure-resource maakt, moet deze een tag bevatten'.

Het hulpprogramma Terraform-compliance biedt een testframework waarin u beleidsregels maakt, zoals in het voorbeeld. Vervolgens voert u deze beleidsregels uit op uw Terraform-uitvoeringsplan.

Met Terraform-compliance kunt u BDD, of gedraggestuurde ontwikkeling, principes toepassen. BDD is een samenwerkingsproces waarbij alle belanghebbenden samenwerken om te bepalen wat een systeem moet doen. Deze belanghebbenden omvatten over het algemeen de ontwikkelaars, testers en iedereen met een gevestigd belang in - of wie wordt beïnvloed door - het systeem dat wordt ontwikkeld. Het doel van BDD is om teams aan te moedigen concrete voorbeelden te bouwen die een gemeenschappelijk inzicht geven in hoe het systeem zich moet gedragen.

3. Bekijk een voorbeeld van een nalevingstest

Eerder in dit artikel leest u over een voorbeeld van nalevingstests voor het maken van een VIRTUELE machine voor een testomgeving. In deze sectie ziet u hoe u dat voorbeeld vertaalt in een BDD-functie en -scenario. De regel wordt eerst uitgedrukt met komkommer, een hulpmiddel dat wordt gebruikt ter 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. Voer het voorbeeld van de nalevingstest uit

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-validatie 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 uit om het uitvoeringsplan te converteren naar JSON voor de nalevingsstap.
```
terraform show -json main.tfplan > main.tfplan.json
```
Voer docker-pull uit om de terraform-compliance-installatiekopie te downloaden.
```
docker pull eerkunt/terraform-compliance
```
Voer docker uit om de tests in een docker-container uit te voeren.
```
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 waarvoor tags moeten bestaan, slaagt, de tweede regel mislukt omdat de Role tags Creator ontbreken.
Los de fout op door deze als volgt te main.tf wijzigen (waarbij een Role en Creator tag worden toegevoegd).
```
  tags = {
    Environment = "dev"
    Application = "Azure Compliance"
    Creator     = "Azure Compliance"
    Role        = "Azure Compliance"
  } 
```
Belangrijkste punten:
- De configuratie voldoet nu aan het beleid.

5. Controleer de resultaten

Voer opnieuw uit terraform validate 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 uit om het uitvoeringsplan te converteren naar JSON voor de nalevingsstap.
```
terraform show -json main.tfplan > main.tfplan.json
```
Voer docker 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
```
Terraform uitvoeren is van toepassing 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>.

Problemen met Terraform in Azure oplossen

Veelvoorkomende problemen oplossen bij het gebruik van Terraform in Azure

Volgende stappen

Meer informatie over het gebruik van Terraform in Azure