Introduction

La gestion des infrastructures à l'aide d'outils comme Terraform offre une flexibilité inégalée, mais elle peut parfois être complexe à déboguer. Dans cet article, nous explorerons une méthode efficace pour simplifier le processus de débogage en intégrant un switch dans vos pipelines YAML. Plus précisément, nous examinerons comment tirer parti des fonctionnalités offertes par Azure DevOps pour faciliter l'analyse de l'exécution des traitements de déploiement de votre infrastructure via l'IaC Terraform.

Les défis du débogage Terraform

Le débogage des configurations Terraform peut s'avérer fastidieux, en particulier dans des environnements complexes. Les erreurs peuvent être difficiles à identifier et à résoudre, ce qui peut entraîner des retards dans le déploiement et des inefficacités opérationnelles. Dans cette optique, l'ajout d'un switch dans vos configurations peut grandement simplifier ce processus en vous permettant de contrôler le flux d'exécution de manière plus granulaire.

Utiliser Azure DevOps pour une analyse efficace

Azure DevOps offre une gamme d'outils puissants pour la gestion du cycle de vie du développement logiciel, mais ses fonctionnalités s'étendent également au domaine de l'Infrastructure as Code. En intégrant votre processus Terraform avec Azure DevOps, vous pouvez automatiser le déploiement, la validation et le débogage de vos infrastructures, offrant ainsi une meilleure visibilité et un contrôle accru sur votre environnement. Dans les sections suivantes, nous détaillerons les étapes pour mettre en place cette intégration et exploiter au mieux ses avantages pour simplifier votre processus de développement et de gestion d'infrastructure.

Configuration du paramètre pour Azure DevOps

Azure DevOps offre une multitude de fonctionnalités pour automatiser et simplifier le processus de développement logiciel et d'infrastructure. L'une de ces fonctionnalités puissantes est la possibilité de configurer des paramètres, permettant ainsi une personnalisation fine de vos pipelines et workflows. Les paramètres dans Azure DevOps peuvent être utilisés pour stocker des valeurs telles que des chaînes de connexion, des clés d'API, des adresses de serveur, etc., offrant ainsi une flexibilité accrue dans la gestion des configurations.

La configuration des paramètres dans Azure DevOps est relativement simple. Vous pouvez définir des paramètres au niveau du projet ou au niveau du pipeline, en fonction de vos besoins spécifiques. Une fois les paramètres définis, vous pouvez les utiliser dans vos tâches de pipeline, ce qui vous permet de séparer les valeurs sensibles de votre code et de les gérer de manière centralisée.

Ce code YAML définit un paramètre de journalisation pour Terraform dans un pipeline Azure DevOps:

parameters:
- name: tflog
  displayName: Terraform logs
  type: string
  default: WARN
  values:
  - TRACE
  - DEBUG
  - INFO
  - WARN
  - ERROR

Ce paramètre va nous permettre de rajouter le switch suivant dans l'interface Azure DevOps à l'exécution du pipeline associé:

A l'exécution du pipeline Azure DevOps associé vous pourrait donc choisir le niveau de logs associé aux activités de Terraform.

Maintenant nous allons voir comment utiliser ce paramètre pour que les activités Terraform prenne en compte cette information.

Utilisation du paramètre pour définir une variable d'environnement

La variable d'environnement TF_LOG est utilisée dans le contexte d'exécution du code Terraform pour contrôler le niveau de détail des journaux générés pendant l'exécution. Elle permet de spécifier le niveau de verbosité des journaux Terraform, ce qui peut être extrêmement utile lors du débogage ou de la surveillance de l'exécution des configurations Terraform.

Voici comment fonctionne TF_LOG :

• Aucun : Aucun journal n'est généré. Cela signifie que Terraform n'enregistrera aucune sortie, même en cas d'erreur.

• ERROR : Seuls les messages d'erreur critiques seront enregistrés.

• WARN : Seuls les messages d'avertissement et les erreurs seront enregistrés.

• INFO : Les informations générales sur l'exécution seront enregistrées, en plus des avertissements et des erreurs.

• DEBUG : Les informations de débogage supplémentaires seront enregistrées, en plus des niveaux INFO, WARN et ERROR.

• TRACE : Les journaux les plus détaillés seront enregistrés, y compris les requêtes HTTP, les détails de l'état interne de Terraform, etc.

En définissant TF_LOG avec l'un de ces niveaux, vous pouvez contrôler le volume et le niveau de détail des informations de journalisation affichées pendant l'exécution de votre code Terraform. Cela peut être particulièrement utile pour diagnostiquer les problèmes, comprendre le flux d'exécution et surveiller les performances de votre infrastructure tout en minimisant la quantité de données enregistrées lorsqu'elles ne sont pas nécessaires.

Le paramètre définit dans le premier chapitre peut être utiliser dans les activités Plan et Apply de Terraform via cette définition de variable d'environnement :

env:
    TF_LOG: $(TF_LOG)

Pour plus de simplicité, retrouvez le code complet de ces deux activités dans les chapitres suivants.

Terraform Plan

    - task: TerraformTaskV4@4
      displayName: 'Terraform Plan'
      env:
          TF_LOG: $(TF_LOG)
      inputs:
        command: 'plan'
        commandOptions: '-out=plan.tfplan -input=false'
        workingDirectory: $(System.DefaultWorkingDirectory)
        environmentServiceNameAzureRM: $(AZ_SERVICE_CONNECTION)

Terraform Apply

      - task: TerraformTaskV4@4
        displayName: 'Terraform Apply'
        env:
          TF_LOG: $(TF_LOG)
        inputs:
          command: 'apply'
          commandOptions: -auto-approve plan.tfplan
          environmentServiceNameAzureRM: $(AZ_SERVICE_CONNECTION)
          workingDirectory: $(Pipeline.Workspace)/tfplan

Run-it !

En choisissant une trace WARN j'obtiens ce niveau de détail lors de l'exécution de mon code Terraform:

Lier le niveau de logs Terraform à l'option "Enable system diagnostics"

L'option "Enable system diagnostics" (Activer les diagnostics système) dans les pipelines Azure DevOps est une fonctionnalité qui permet d'activer la journalisation détaillée des diagnostics pour un pipeline spécifique. Cette fonctionnalité est utile pour déboguer les problèmes liés à l'exécution du pipeline et pour obtenir des informations détaillées sur les performances et les erreurs éventuelles rencontrées pendant le processus de build ou de déploiement.

Elle est accessible lors de l'exécution du pipeline au travers d'une case à cocher:

Pour lier le fait de passer en mode TRACE lorsque celle-ci est coché vous pouvez rajouter dans votre pipeline YAML ces éléments:

• Utilisez les étapes Plan et Apply précédents puis ajouter ce bloc pour définir une variable TF_LOG dans votre pipeline:

variables:
- name: TF_LOG
  value: "INFO"

• Cette étape optionnelle qui, quand la case est cochée, force la valeur à TRACE

- bash: |
         echo "##vso[task.setvariable variable=TF_LOG;]TRACE"
      condition: eq(variables['System.debug'], true)
      displayName: 'If debug, set TF_LOG to TRACE'

Si la case n'est pas cochée alors cette étape sera ignorée :

Sinon :

Et vous aurez alors l'ensemble des TRACE Terraform :

Pipeline complet

Pour rendre plus simple l'intégration voici le pipeline complet :

parameters:
- name: tflog
  displayName: Terraform logs
  type: string
  default: INFO
  values:
  - TRACE
  - DEBUG
  - INFO
  - WARN
  - ERROR

trigger: none # This pipeline will be triggered by the quality-check pipeline

variables:
- name: TF_LOG
  value: "${{ parameters.tflog }}"
- name: AZ_SERVICE_CONNECTION
  value: "Azure"
- name: AZ_TFVERSION
  value: "1.7.3"

pool:
    vmImage: 'ubuntu-latest'

stages:
- stage: Terraform_Plan
  displayName: 'Terraform Init & Plan'
  jobs:
  - job: Terraform_init_and_Plan
    displayName: 'Terraform Init & Plan'
    steps:

    - bash: |
         echo "##vso[task.setvariable variable=TF_LOG;]TRACE"
      condition: eq(variables['System.debug'], true)
      displayName: 'If debug, set TF_LOG to TRACE'

    - task: TerraformInstaller@0
      displayName: 'Install Terraform v$(AZ_TFVERSION)'
      inputs:
        terraformVersion: $(AZ_TFVERSION)

    - task: TerraformTaskV4@4
      displayName: 'Terraform Init'
      inputs:
        provider: azurerm
        command: init
        workingDirectory: $(System.DefaultWorkingDirectory)
        backendServiceArm: $(AZ_SERVICE_CONNECTION)
        backendAzureRmResourceGroupName: shsprdstorg002
        backendAzureRmStorageAccountName: shsprdstosa002
        backendAzureRmContainerName: tfstate
        backendAzureRmKey: terraform_logs.tfstate

    - task: TerraformTaskV4@4
      displayName: 'Terraform Plan'
      env:
          TF_LOG: $(TF_LOG)
      inputs:
        command: 'plan'
        commandOptions: '-out=plan.tfplan -input=false'
        workingDirectory: $(System.DefaultWorkingDirectory)
        environmentServiceNameAzureRM: $(AZ_SERVICE_CONNECTION)

    - publish: $(System.DefaultWorkingDirectory)
      displayName: Publish Plan Artifact
      artifact: tfplan


- stage: Terrafom_Validation
  jobs:
  - job: ValidationStep
    displayName: Wait for task validation
    pool: server
    timeoutInMinutes: 60 # task times out in 2 hours
    steps:
    - task: ManualValidation@0
      timeoutInMinutes: 60 # task times out in 2 hours

- stage: Terrafom_Apply
  displayName: 'Terraform Apply'
  jobs:
  - job: Terraform_Apply
    displayName: 'Terraform Apply'    
    steps:
      - checkout: none

      - download: current
        artifact: tfplan

      - task: TerraformInstaller@0
        displayName: 'Install Terraform v$(AZ_TFVERSION)'
        inputs:
          terraformVersion: $(AZ_TFVERSION)

      - task: TerraformTaskV4@4
        displayName: 'Terraform Apply'
        env:
          TF_LOG: $(TF_LOG)
        inputs:
          command: 'apply'
          commandOptions: -auto-approve plan.tfplan
          environmentServiceNameAzureRM: $(AZ_SERVICE_CONNECTION)
          workingDirectory: $(Pipeline.Workspace)/tfplan

Conclusion

Dans cet article, nous avons exploré une approche efficace pour simplifier le processus de débogage des configurations Terraform en intégrant un switch dans vos pipelines Azure DevOps. Cette méthode offre un moyen pratique de contrôler le flux d'exécution de vos configurations, ce qui peut considérablement réduire le temps nécessaire à l'identification et à la résolution des erreurs. En exploitant les fonctionnalités offertes par Azure DevOps, vous pouvez automatiser et rationaliser l'analyse de votre Infrastructure as Code, améliorant ainsi l'efficacité et la fiabilité de vos déploiements.

Liens utiles

Comme a mon habitude voici quelques liens pour vous aider sur ce sujet:

• Antoine LOIZEAU Blog's - Comment activer les logs Terraform ?

• Microsoft Learn - Use parameters in pipelines

• GitHub - Azure Pipeline Terraform

• Hashicorp Terraform - Debugging