Implémenter des tests de conformité avec Terraform et Azure

Article
03/21/2023

Terraform permet la définition, l’aperçu et le déploiement d’une infrastructure cloud. Terraform vous permet de créer des fichiers de configuration à l’aide de la syntaxe HCL. La syntaxe HCL vous permet de spécifier un fournisseur de services 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 de vos modifications d’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.

Bien souvent, les tests de conformité font partie du processus d’intégration continue et sont utilisés pour vérifier que les stratégies 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é sont utilisés pour appliquer des règles dans ces scénarios et bien d’autres.

Dans cet article, vous apprendrez comment :

Comprendre quand utiliser les tests de conformité
Apprendre à effectuer 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 vous ne l’avez pas déjà fait, configurez Terraform à l’aide de l’une des options suivantes :

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

2. Présentation des tests et des vérifications de conformité

Le test de conformité est une technique de test non fonctionnelle visant à déterminer si un système répond aux normes prescrites. Les termes anglais utilisés sont « compliance testing » ou encore conformance testing.

La plupart des équipes de développement logiciel effectuent une analyse pour vérifier que les normes sont correctement appliquées et implémentées. Souvent, leurs membres travaillent simultanément à l’amélioration des normes qui, à son tour, conduit à une qualité accrue.

Il existe deux concepts importants à prendre en compte : les tests de conformité et les vérifications de conformité.

Les tests de conformité permettent de vérifier que la sortie de chaque phase du cycle de développement est conforme aux exigences convenues.
Les vérifications de conformité doivent être intégrées au cycle de développement au début des projets. Il devient de plus en plus difficile d’ajouter des vérifications de conformité à un stade ultérieur lorsque l’exigence elle-même n’est pas suffisamment documentée.

Il est facile de procéder à des vérifications de conformité. Un ensemble de normes et de procédures est élaboré et documenté pour chaque phase du cycle de développement. La sortie de chaque phase est comparée aux exigences documentées. Les résultats du test sont tout « écart » non conforme aux normes prédéterminées. Les tests de conformité sont effectués dans le cadre du processus d’inspection et le résultat du processus de révision doit être documenté.

Prenons un exemple précis.

Un problème courant est celui des environnements qui s’arrêtent 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 alors une version différente du code qui approvisionne une version différente de cette machine virtuelle. Ce qu’il faut ici, c’est un contrôle permettant d’assurer la conformité aux règles énoncées.

Une façon de résoudre ce problème consiste à définir une stratégie de marquage des ressources, par exemple avec les balises role et creator. Une fois que vous avez défini les stratégies, un outil comme Terraform-compliance est utilisé pour garantir que les stratégies sont respectées.

Terraform-compliance se focalise sur les tests négatifs. Un test négatif est le processus qui consiste à s’assurer qu’un système peut gérer correctement les entrées inattendues ou les comportements indésirables. Le test à données aléatoires (fuzzing) est un exemple de test négatif. Grâce au test à données aléatoires (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 garantit également que la configuration locale et les réponses d’API distantes sont synchronisées. Étant donné que Terraform est principalement utilisé sur les API cloud, nous avons toujours besoin d’un moyen de garantir que le code déployé sur l’infrastructure suit des stratégies 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 une infrastructure de test dans laquelle vous créez des stratégies telles que celles de l’exemple. Vous exécutez ensuite ces stratégies sur votre plan d’exécution Terraform.

Terraform-compliance vous permet d’appliquer des principes BDD, ou développement piloté par le comportement. BDD est un processus collaboratif dans lequel toutes les parties prenantes travaillent ensemble pour définir ce qu’un système doit 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 concernée par celui-ci. L’objectif du BDD est d’encourager les équipes à créer des exemples concrets qui expriment une compréhension commune de la façon dont le système doit se comporter.

3. Examiner un exemple de test de conformité

Précédemment dans cet article, vous avez découvert un exemple de test de conformité pour la création d’une machine virtuelle pour un environnement de test. Cette section montre comment traduire cet exemple en fonctionnalité et 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 est traduite comme suit :

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

Le code HCL Terraform adhère 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 stratégie 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 illustre 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écuter l’exemple de test de conformité

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

Dans le répertoire de l’exemple, accédez au répertoire src.
Exécutez terraform init pour initialiser le répertoire de travail.
```
terraform init
```
Exécutez terraform validate pour valider la syntaxe des fichiers config.
```
terraform validate
```
Points essentiels :
- Vous voyez un message indiquant que la configuration Terraform est valide.
Exécutez terraform plan pour créer un plan d’exécution.
```
terraform plan -out main.tfplan
```
Exécutez terraform show afin de convertir le plan d’exécution au format JSON pour l’étape de conformité.
```
terraform show -json main.tfplan > main.tfplan.json
```
Exécutez docker pull pour télécharger l’image de 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 essentiels :
- Bien que la première règle nécessitant l’existence d’étiquettes réussit, la deuxième règle échoue car les étiquettes Role et Creator sont manquantes. Le test se solde donc par un échec.
Corrigez l’erreur en modifiant main.tf comme suit (où les étiquettes Role et Creator sont ajoutées).
```
  tags = {
    Environment = "dev"
    Application = "Azure Compliance"
    Creator     = "Azure Compliance"
    Role        = "Azure Compliance"
  } 
```
Points essentiels :
- La configuration est désormais conforme à la stratégie.

5. Vérifier les résultats

Réexécutez terraform validate pour vérifier la syntaxe.
```
terraform validate
```
Réexécutez terraform plan pour créer un nouveau plan d’exécution.
```
terraform plan -out main.tfplan
```
Exécutez terraform show afin de convertir le plan d’exécution au format JSON pour l’étape de conformité.
```
terraform show -json main.tfplan > main.tfplan.json
```
Réexécutez docker run pour tester la configuration. Le test réussit, car la spécification complète a été implémentée.
```
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 essentiels :
- Un groupe de ressources est créé avec un nom suivant le modèle rg-hello-tf-<random_number>.

Résoudre les problèmes liés à Terraform sur Azure

Résoudre les problèmes courants liés à l’utilisation de Terraform sur Azure

Étapes suivantes

En savoir plus sur l’utilisation de Terraform dans Azure