Implémenter des tests d’intégration pour des projets Terraform dans Azure

Article
03/23/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.

Les tests d’intégration vérifient qu’une modification de code récemment introduite ne casse pas le code existant. Dans DevOps, l’intégration continue (CI) fait référence à un processus qui génère l’ensemble du système chaque fois que la base de code est modifiée, par exemple lorsqu’une personne souhaite fusionner une demande de tirage (pull request) en référentiel Git. La liste suivante contient des exemples courants de tests d’intégration :

Les outils d’analyse statique du code tels que lint et format.
Exécutez terraform validate pour vérifier la syntaxe du fichier config.
Exécutez terraform plan pour vous assurer que la configuration fonctionnera comme prévu.

Dans cet article, vous apprendrez comment :

Découvrir les principes de base des tests d’intégration pour les projets Terraform.
Utiliser Azure DevOps pour configurer un pipeline d’intégration continue.
Exécuter une analyse statique du code sur le code Terraform.
Exécuter terraform validate pour valider les fichiers config de Terraform sur l’ordinateur local.
Exécuter terraform plan pour valider les fichiers config de Terraform du point de vue des services à distance.
Utiliser un pipeline Azure pour automatiser l’intégration continue.

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 :

Organisation et projet Azure DevOps : si vous n’en avez pas, créez une organisation Azure DevOps.
Extension Terraform Build &Release Tasks : installez l’extension de tâches de build/de mise en production Terraform dans votre organisation Azure DevOps.
Accorder à Azure DevOps l’accès à votre abonnement Azure : créez une connexion de service Azure nommée terraform-basic-testing-azure-connection pour autoriser Azure Pipelines à se connecter à vos abonnements Azure
Exemple de code et de ressources : Téléchargez à partir de GitHub le projet de test d’intégration. Le répertoire dans lequel vous téléchargez l’exemple est appelé exemple de répertoire.

2. Valider une configuration Terraform locale

La commande terraform validate est exécutée à partir de la ligne de commande dans le répertoire contenant vos fichiers Terraform. L’objectif principal de cette commande est de valider la syntaxe.

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.
Modifiez le fichier main.tf.
Sur la ligne 5, insérez une faute de frappe qui invalide la syntaxe. Par exemple, remplacez var.location par var.loaction.
Enregistrez le fichier.
Réexécutez la validation.
```
terraform validate
```
Points essentiels :
- Un message d’erreur s’affiche, indiquant la ligne de code erronée et une description de l’erreur.

Comme vous pouvez le voir, Terraform a détecté un problème dans la syntaxe du code de configuration. Ce problème empêche le déploiement de la configuration.

Il est recommandé de toujours exécuter terraform validate sur vos fichiers Terraform avant de les envoyer (push) vers votre système de gestion de version. En outre, ce niveau de validation doit faire partie de votre pipeline d’intégration continue. Plus loin dans cet article, nous allons découvrir comment configurer un pipeline Azure à valider automatiquement.

3. Valider une configuration Terraform

Dans la section précédente, vous avez vu comment valider une configuration Terraform. Ce niveau de test était spécifique à la syntaxe. Ce test n’a pas pris en compte les éléments qui peuvent déjà être déployés sur Azure.

Terraform est un langage déclaratif, ce qui signifie que vous déclarez ce que vous souhaitez comme résultat final. Par exemple, supposons que vous avez dix machines virtuelles dans un groupe de ressources. Ensuite, vous créez un fichier Terraform qui définit trois machines virtuelles. L’application de ce plan n’incrémente pas le nombre total à 13. Au lieu de cela, Terraform supprime sept des machines virtuelles afin que vous n’en ayez plus que trois. L’exécution de terraform plan vous permet de confirmer les résultats potentiels de l’application d’un plan d’exécution afin d’éviter les surprises.

Pour générer le plan d’exécution Terraform, vous devez exécuter terraform plan. Cette commande permet de se connecter à l’abonnement Azure cible pour vérifier quelle partie de la configuration est déjà déployée. Terraform détermine ensuite les modifications nécessaires pour répondre aux exigences indiquées dans le fichier Terraform. À ce stade, Terraform ne déploie rien. Il vous indique ce qui se produit si vous appliquez le plan.

Si vous suivez la procédure décrite dans l’article et que vous avez effectué les étapes décrites dans la section précédente, exécutez la commande terraform plan :

terraform plan

Après l’exécution de terraform plan, Terraform affiche le résultat potentiel de l’application du plan d’exécution. La sortie indique les ressources Azure qui seront ajoutées, modifiées et détruites.

Par défaut, Terraform stocke l’état dans le même répertoire local que le fichier Terraform. Ce modèle fonctionne bien dans les scénarios à utilisateur unique. Toutefois, lorsque plusieurs personnes travaillent sur les mêmes ressources Azure, les fichiers d’état local peuvent être synchronisés. Pour résoudre ce problème, Terraform prend en charge l’écriture de fichiers d’état dans un magasin de données distant (par exemple, Stockage Azure). Dans ce scénario, il peut être difficile d’exécuter terraform plan sur un ordinateur local et de cibler un ordinateur distant. Par conséquent, il peut être judicieux d’automatiser cette étape de validation dans le cadre de votre pipeline d’intégration continue.

4. Exécuter une analyse statique du code

L’analyse statique du code peut être effectuée directement sur le code de configuration Terraform, sans l’exécuter. Cette analyse peut être utile pour détecter des problèmes tels que les problèmes de sécurité et l’incohérence de la conformité.

Les outils suivants fournissent une analyse statique des fichiers Terraform :

L’analyse statique est souvent exécutée dans le cadre d’un pipeline d’intégration continue. Ces tests ne nécessitent pas la création d’un plan d’exécution ou d’un déploiement. Par conséquent, ils s’exécutent plus rapidement que d’autres tests et sont généralement exécutés en premier dans le processus d’intégration continue.

5. Automatiser les tests d’intégration à l’aide d’Azure Pipelines

L’intégration continue consiste à tester l’ensemble d’un système lorsqu’une modification est introduite. Dans cette section, vous allez examiner une configuration Azure Pipelines utilisée pour implémenter une intégration continue.

À l’aide de l’éditeur de votre choix, accédez au clone local de l’exemple de projet Terraform sur GitHub.
Ouvrez le fichier samples/integration-testing/src/azure-pipeline.yaml .
Faites défiler la page jusqu’à la section Étapes où sont présentées un ensemble standard d’étapes utilisées pour exécuter diverses routines d’installation et de validation.
Passez en revue la ligne qui indique : Étape 1 : exécuter l’analyse statique du code Checkov. Dans cette étape, le projet Checkov mentionné précédemment exécute une analyse statique du code sur l’exemple de configuration Terraform.
```
- bash: $(terraformWorkingDirectory)/checkov.sh $(terraformWorkingDirectory)
  displayName: Checkov Static Code Analysis
```
Points essentiels :
- Ce script est responsable de l’exécution de Checkov dans l’espace de travail Terraform monté dans un conteneur Docker. Les agents gérés par Microsoft sont compatibles avec Docker. L’exécution d’outils au sein d’un conteneur Docker est plus facile et rend inutile l’installation de Checkov sur l’agent Azure Pipelines.
- La variable $(terraformWorkingDirectory) est définie dans le fichier azure-pipeline.yaml.
Passez en revue la ligne qui indique : Étape 2 : installer Terraform sur l’agent Azure Pipelines. L’extension Terraform Build & Release Task que vous avez installée précédemment possède une commande permettant d’installer Terraform sur l’agent exécutant le pipeline Azure. C’est cette tâche qui est accomplie dans cette étape.
```
- task: charleszipp.azure-pipelines-tasks-terraform.azure-pipelines-tasks-terraform-installer.TerraformInstaller@0
  displayName: 'Install Terraform'
  inputs:
    terraformVersion: $(terraformVersion)
```
Points essentiels :
- La version de Terraform à installer est spécifiée via une variable Azure Pipelines nommée terraformVersion et définie dans le fichier azure-pipeline.yaml.
Passez en revue la ligne qui indique : Étape 3 : exécuter « terraform init » pour initialiser l’espace de travail. Maintenant que Terraform est installé sur l’agent, le répertoire Terraform peut être initialisé.
```
- task: charleszipp.azure-pipelines-tasks-terraform.azure-pipelines-tasks-terraform-cli.TerraformCLI@0
  displayName: 'Run terraform init'
  inputs:
    command: init
    workingDirectory: $(terraformWorkingDirectory)
```
Points essentiels :
- L’entrée command spécifie la commande Terraform à exécuter.
- L’entrée workingDirectory indique le chemin d’accès du répertoire Terraform.
- La variable $(terraformWorkingDirectory) est définie dans le fichier azure-pipeline.yaml.
Passez en revue la ligne qui indique : Étape 4 : exécuter « terraform validate » pour valider la syntaxe HCL. Une fois le répertoire du projet initialisé, terraform validate est exécuté pour valider la configuration sur le serveur.
```
- task: charleszipp.azure-pipelines-tasks-terraform.azure-pipelines-tasks-terraform-cli.TerraformCLI@0
  displayName: 'Run terraform validate'
  inputs:
    command: validate
    workingDirectory: $(terraformWorkingDirectory)
```
Passez en revue la ligne qui indique : Étape 5 : exécuter « terraform plan » pour valider la syntaxe HCL. Comme expliqué précédemment, le plan d’exécution est généré pour vérifier si la configuration Terraform est valide avant le déploiement.
```
- 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)
```
Points essentiels :
- L’entrée environmentServiceName fait référence au nom de la connexion au service Azure créée dans Configurer votre environnement. La connexion permet à Terraform d’accéder à votre abonnement Azure.
- L’entrée commandOptions est utilisée pour transmettre des arguments à la commande Terraform. Dans ce cas, un emplacement est spécifié. La variable $(azureLocation) est définie précédemment dans le fichier YAML.

Importer le pipeline dans Azure DevOps

Ouvrez votre projet Azure DevOps et accédez à la section Azure Pipelines.
Sélectionnez le bouton Créer un pipeline.
Pour l’option Où se trouve votre code ?, sélectionnez GitHub (YAML).
À ce stade, vous devrez peut-être autoriser Azure DevOps à accéder à votre organisation. Pour plus d’informations sur ce sujet, reportez-vous à l’article Créer des référentiels GitHub.
Dans la liste des référentiels, sélectionnez la fourche du référentiel que vous avez créée dans votre organisation GitHub.
À l’étape Configurer votre pipeline, choisissez de commencer à partir d’un pipeline YAML existant.
Lorsque la page Sélectionner un pipeline YAML existant s’affiche, spécifiez la branche master et entrez le chemin d’accès au pipeline YAML : samples/integration-testing/src/azure-pipeline.yaml.
Sélectionnez Continuer pour charger le pipeline YAML Azure à partir de GitHub.
Lorsque la page Vérifier votre pipeline YAML s’affiche, sélectionnez Exécuter pour créer et déclencher manuellement le pipeline pour la première fois.

Vérifier les résultats

Vous pouvez exécuter le pipeline manuellement à partir de l’interface utilisateur d’Azure DevOps. Toutefois, le but de l’article est de montrer une intégration continue automatisée. Testez le processus en validant une modification dans le dossier samples/integration-testing/src de votre référentiel dupliqué. La modification déclenchera automatiquement un nouveau pipeline sur la branche sur laquelle vous envoyez (push) le code.

Pipeline exécuté à partir de GitHub