Mettre en œuvre des tests de conformité avec Terraform et Azure

2025-06-21

Terraform active la définition, la préversion et le déploiement de l’infrastructure cloud. À l’aide de Terraform, vous créez des fichiers de configuration à l’aide de la syntaxe HCL. La syntaxe HCL vous permet de spécifier le fournisseur de cloud , tel qu’Azure, et les éléments qui composent votre infrastructure cloud. Après avoir créé vos fichiers de configuration, vous créez un plan d’exécution qui vous permet d’afficher un aperçu des modifications de votre infrastructure avant leur déploiement. Une fois que vous avez vérifié les modifications, vous appliquez le plan d’exécution pour déployer l’infrastructure.

Souvent, les tests de conformité font partie du processus d’intégration continue et sont utilisés pour s’assurer que les politiques définies par l’utilisateur sont respectées. Par exemple, vous pouvez définir des conventions d’affectation de noms géopolitiques pour vos ressources Azure. Un autre exemple courant est la création de machines virtuelles à partir d’un sous-ensemble défini d’images. Les tests de conformité seraient utilisés pour faire respecter les règles dans ces scénarios et dans bien d’autres.

Dans cet article, vous allez apprendre à :

Comprendre quand utiliser les tests de conformité
Apprenez à faire un test de conformité
Voir et exécuter un exemple de test de conformité

1. Configurer votre environnement

Abonnement Azure : si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

Configurez Terraform : Si ce n’est déjà fait, configurez Terraform à l’aide de l’une des options suivantes :

Docker :Installez Docker.
Python :Installez Python.
Outil de conformité Terraform : Installez l’outil de conformité Terraform en exécutant la commande suivante : pip install terraform-compliance.
Exemple de code et de ressources : À l’aide de l’outil DownGit, téléchargez à partir de GitHub le projet de test de conformité et décompressez-le dans un nouveau répertoire contenant l’exemple de code. Ce répertoire est appelé exemple de répertoire.

2. Comprendre les tests et les vérifications de conformité

Les tests de conformité sont une technique de test non fonctionnelle permettant de déterminer si un système répond aux normes prescrites. Les tests de conformité sont également connus sous le nom de tests de conformité.

La plupart des équipes logicielles effectuent une analyse pour vérifier que les normes sont correctement appliquées et mises en œuvre. Travaillant souvent simultanément à l’amélioration des normes qui, à leur tour, conduisent à une amélioration de la qualité.

Avec les tests de conformité, il y a deux concepts importants à prendre en compte : les tests de conformité et les contrôles de conformité.

Les tests de conformité permettent de s’assurer que les résultats de chaque phase du cycle de vie du développement sont conformes aux exigences convenues.
Les contrôles de conformité doivent être intégrés dans le cycle de développement au début des projets. Il devient de plus en plus difficile d’ajouter des contrôles de conformité à un stade ultérieur lorsque l’exigence elle-même n’est pas correctement documentée.

Effectuer des contrôles de conformité est simple. Un ensemble de normes et de procédures est élaboré et documenté pour chaque phase du cycle de vie du développement. Le rendement de chaque phase est comparé aux exigences documentées. Les résultats du test sont des « lacunes » dans la non-conformité aux normes prédéterminées. Les tests de conformité sont effectués dans le cadre du processus d’inspection et les résultats du processus d’examen doivent être documentés.

Prenons un exemple précis.

Un problème courant est celui des environnements qui ne fonctionnent pas lorsque plusieurs développeurs appliquent des modifications incompatibles. Supposons qu’une personne travaille sur une modification et applique des ressources telles que la création d’une machine virtuelle dans un environnement de test. Une autre personne applique ensuite une version différente du code qui provisionne une version différente de cette machine virtuelle. Ce qu’il faut ici, c’est une surveillance pour assurer la conformité aux règles énoncées.

Une façon de résoudre ce problème serait de définir une politique de balisage des ressources, comme avec role et balises creator . Une fois que vous avez défini les stratégies, un outil tel que Terraform-compliance est utilisé pour garantir le respect des stratégies.

Terraform-compliance se concentre sur les tests négatifs. Les tests négatifs consistent à s’assurer qu’un système peut gérer correctement des entrées inattendues ou un comportement indésirable. Le fuzzing est un exemple de test négatif. Avec le fuzzing, un système qui reçoit des entrées est testé pour s’assurer qu’il peut gérer en toute sécurité les entrées inattendues.

Heureusement, Terraform est une couche d’abstraction pour toute API qui crée, met à jour ou détruit des entités d’infrastructure cloud. Terraform s’assure également que la configuration locale et les réponses de l’API distante sont synchronisées. Étant donné que Terraform est principalement utilisé contre les API Cloud, nous avons toujours besoin d’un moyen de nous assurer que le code déployé sur l’infrastructure respecte des politiques spécifiques. Terraform-compliance - un outil gratuit et open-source - fournit cette fonctionnalité pour les configurations Terraform.

À l’aide de l’exemple de machine virtuelle, une stratégie de conformité peut être la suivante : « Si vous créez une ressource Azure, elle doit contenir une balise ».

L’outil Terraform-compliance fournit un cadre de test dans lequel vous créez des politiques comme dans l’exemple. Vous exécutez ensuite ces stratégies par rapport à votre plan d’exécution Terraform.

Terraform-compliance vous permet d’appliquer les principes BDD, ou développement piloté par le comportement. La BDD est un processus collaboratif dans lequel toutes les parties prenantes travaillent ensemble pour définir ce qu’un système devrait faire. Ces parties prenantes comprennent généralement les développeurs, les testeurs et toute personne ayant un intérêt direct dans le système en cours de développement ou qui sera touchée par celui-ci. L’objectif de la BDD est d’encourager les équipes à construire des exemples concrets qui expriment une compréhension commune de la façon dont le système devrait se comporter.

3. Examinez un exemple de test de conformité

Précédemment dans cet article, vous avez lu un exemple de test de conformité de la création d’une machine virtuelle pour un environnement de test. Cette section montre comment traduire cet exemple en une fonctionnalité et un scénario BDD. La règle est d’abord exprimée à l’aide de Cucumber, qui est un outil utilisé pour prendre en charge BDD.

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

La règle précédente se traduit comme suit :

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

Le code HCL Terraform respectera alors la règle comme suit.

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

La première politique peut être écrite sous la forme d’un scénario de fonctionnalité BDD comme suit :

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

Le code suivant montre un test pour une balise spécifique :

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. Exécutez l’exemple du test de conformité

Dans cette section, vous allez télécharger et tester l’exemple.

Dans l’exemple de répertoire, accédez au répertoire src.
Exécutez terraform init pour initialiser le répertoire de travail.
```
terraform init
```
Exécutez terraform validez pour valider la syntaxe des fichiers de configuration.
```
terraform validate
```
Points clés :
- Vous voyez un message indiquant que la configuration Terraform est valide.
Exécutez le plan terraform pour créer un plan d’exécution.
```
terraform plan -out main.tfplan
```
Exécutez terraform show pour convertir le plan d’exécution en JSON pour l’étape de conformité.
```
terraform show -json main.tfplan > main.tfplan.json
```
Exécutez docker pull pour télécharger l’image terraform-compliance.
```
docker pull eerkunt/terraform-compliance
```
Exécutez docker run pour exécuter les tests dans un conteneur docker.
```
docker run --rm -v $PWD:/target -it eerkunt/terraform-compliance -f features -p main.tfplan.json
```
Points clés :
- Le test échouera parce que, alors que la première règle exigeant l’existence de balises réussit, la deuxième règle échoue en ce sens que les Role balises et Creator sont manquantes.
Corrigez l’erreur en la modifiant main.tf comme suit (où a Role et Creator la balise sont ajoutées).
```
  tags = {
    Environment = "dev"
    Application = "Azure Compliance"
    Creator     = "Azure Compliance"
    Role        = "Azure Compliance"
  } 
```
Points clés :
- La configuration est maintenant conforme à la politique.

5. Vérifiez les résultats

Exécutez à nouveau l’exécution terraform validate pour vérifier la syntaxe.
```
terraform validate
```
Exécutez à nouveau l’exécution terraform plan pour créer un nouveau plan d’exécution.
```
terraform plan -out main.tfplan
```
Exécutez terraform show pour convertir le plan d’exécution en JSON pour l’étape de conformité.
```
terraform show -json main.tfplan > main.tfplan.json
```
Exécutez docker run à nouveau pour tester la configuration. Si la spécification complète a été mise en œuvre, le test réussit.
```
docker run --rm -v $PWD:/target -it eerkunt/terraform-compliance -f features -p main.tfplan.json
```
Exécutez terraform apply pour appliquer le plan d’exécution.
```
terraform apply main.tfplan -target=random_uuid.uuid
```
Points clés :
- Un groupe de ressources est créé avec un nom suivant le modèle : rg-hello-tf-<random_number>.

Résoudre les problèmes de Terraform sur Azure

Résoudre les problèmes courants lors de l’utilisation de Terraform sur Azure

Étapes suivantes

En savoir plus sur l’utilisation de Terraform dans Azure