---
# System prepended metadata

title: Dépannage Terraform

---

# Dépannage Terraform

![terraformer](https://upload.wikimedia.org/wikipedia/commons/thumb/0/04/Terraform_Logo.svg/2880px-Terraform_Logo.svg.png)

## Introduction

Le dépannage de Terraform consiste à identifier et à résoudre les problèmes qui peuvent survenir au cours du processus de provisionnement de l'infrastructure. Cela nécessite une approche systématique, une analyse minutieuse des messages d'erreur et une compréhension approfondie des concepts Terraform et de l'infrastructure sous-jacente. Le dépannage peut impliquer la vérification des versions de Terraform et du fournisseur, la validation de la syntaxe de configuration, l'examen de l'état de Terraform à la recherche d'incohérences et le débogage avec une verbosité accrue. 
Les problèmes courants à résoudre incluent les problèmes de compatibilité entre Terraform et les fournisseurs, les erreurs de dépendance des ressources et les erreurs de configuration. En tirant parti des ressources de la communauté, en consultant la documentation et en expérimentant différentes commandes, le dépannage permet d'assurer un déploiement et une gestion fluides de l'infrastructure avec Terraform.

## Identification des problèmes courants, leurs causes et solutions potentielles

Voici quelques problèmes courants dans Terraform, leurs causes possibles et leurs solutions potentielles :

### **Erreurs de syntaxe :** 

Ces erreurs se produisent lorsque la configuration ne respecte pas le format et la syntaxe corrects attendus par Terraform. Voici quelques exemples courants d'erreurs de syntaxe de configuration :

- Parenthèses, crochets ou guillemets manquants ou incompatibles.
- Indentation ou espacement incorrect.
- Fautes de frappe ou mots-clés mal orthographiés, noms de ressources ou références de variables.
- Utilisation incorrecte de caractères spéciaux ou de symboles.
- Bloc ou argument de configuration invalide ou non reconnu.
- Blocs incomplets ou mal imbriqués.
- Utilisation de mots-clés ou de noms réservés.

Les erreurs de syntaxe de configuration empêchent Terraform d'analyser et d'interpréter correctement les fichiers de configuration, ce qui entraîne des échecs lors des étapes de planification ou d'exécution. En cas d'erreurs de syntaxe de configuration, Terraform fournira des messages d'erreur indiquant l'emplacement et la nature spécifiques du problème de syntaxe.
Il est important d'utiliser les commandes `terraform fmt` et `terraform validate` pour formater et valider la syntaxe avant les commandes `terraform plan` et `terraform apply`


### **Problèmes de compatibilité du fournisseur :** 

Les problèmes de compatibilité du fournisseur dans Terraform surviennent lorsqu'il existe une incompatibilité entre la version de Terraform utilisée et la version d'un plug-in de fournisseur spécifique. Les fournisseurs sont responsables de l'interaction avec diverses plates-formes d'infrastructure, telles qu'AWS, Azure ou Google Cloud, et chaque fournisseur gère son propre plug-in qui s'intègre à Terraform.

Des problèmes de compatibilité de fournisseur peuvent survenir pour les raisons suivantes :

1. Incompatibilité de version de Terraform : la version du plug-in du fournisseur utilisé peut ne pas être compatible avec la version de Terraform installée. Les fournisseurs publient souvent des mises à jour pour prendre en charge de nouvelles fonctionnalités ou des correctifs de bugs dans Terraform, et l'utilisation d'une version obsolète du fournisseur avec une version plus récente de Terraform peut entraîner des problèmes de compatibilité.

2. Contraintes de version du fournisseur : dans certains cas, le fichier de configuration Terraform (fichier `.tf`) peut spécifier des versions de fournisseur spécifiques à l'aide de contraintes de version. Si ces contraintes sont trop restrictives ou mal définies, Terraform peut ne pas être en mesure de localiser une version de fournisseur compatible, ce qui entraîne des problèmes de compatibilité.

Pour résoudre les problèmes de compatibilité des fournisseurs, envisagez les solutions suivantes :

1. Mettre à niveau ou rétrograder la version du fournisseur : consultez la documentation du fournisseur pour obtenir des informations sur la compatibilité avec les différentes versions de Terraform. Mettez à niveau ou rétrogradez le plug-in du fournisseur vers une version compatible qui s'aligne sur la version Terraform installée.

2. Mettre à jour les contraintes de version de Terraform : si des contraintes de version spécifiques sont définies dans votre configuration Terraform, examinez-les et mettez-les à jour si nécessaire. Assurez-vous que les contraintes sont compatibles avec la version du fournisseur et la version de Terraform souhaitées.

3. Épinglage de la version du fournisseur : envisagez de spécifier explicitement une version du fournisseur dans votre configuration Terraform à l'aide de contraintes de version ou de l'épinglage de version. Cela garantit qu'une version de fournisseur spécifique est utilisée de manière cohérente dans différents environnements et évite les problèmes de compatibilité inattendus.

Il est essentiel de consulter la documentation et les notes de publication du fournisseur pour obtenir des informations sur la compatibilité avec les différentes versions de Terraform. Les fournisseurs fournissent souvent des conseils sur les versions compatibles et sur les étapes spécifiques requises pour la mise à niveau ou la rétrogradation du plug-in du fournisseur.

Si vous avez suivi les étapes précédentes et que le problème persiste, il peut s'agir d'un problème dans le code source de Terraform ou du fournisseur. Dans ce cas il est important d'activer la journalisation de Terraform, il existe 5 niveaux de journalisation (par ordre décroissant de verbosité) `TRACE`, `DEBUG`, `INFO`, `WARN` ou `ERROR` pour modifier la verbosité des journaux.

Sur Linux:

```!bash
export TF_LOG=TRACE
export TF_LOG_PATH=logs.txt
terraform refresh
```

Sur Windows:
```!powershell
$env:TF_LOG=TRACE
$env:TF_LOG_PATH=logs.txt
terraform refresh
```

Après avoir activer la journalisation, 
s'il s'agit d'une erreur liée au provider signalez votre problème sur le repo Github du provider en question. 

![](https://hackmd.io/_uploads/ByWLiiHdn.png)

s'il s'agit d'une erreur liée à Terraform signalez votre problème sur le repo Github de Terraform.

![](https://hackmd.io/_uploads/SJd8gmDu3.png)


### **Problèmes corruption de l'état :** 

La corruption de l'état de Terraform fait référence à des situations dans lesquelles le fichier d'état de Terraform devient incohérent, incorrect ou inutilisable. La corruption d'état peut se produire pour diverses raisons, telles que des modifications manuelles du fichier d'état, des conflits dans des opérations simultanées ou des problèmes avec le système de stockage principal. Voici quelques exemples de problèmes de corruption d'état de Terraform :

1. Modifications manuelles : si le fichier d'état est édité ou modifié manuellement en dehors de Terraform, cela peut entraîner une corruption. La modification directe du fichier d'état peut introduire des incohérences et entraîner l'échec de Terraform ou produire des résultats inattendus.

2. Opérations simultanées : lorsque plusieurs utilisateurs ou processus tentent de modifier simultanément le même fichier d'état, des conflits peuvent survenir. Des opérations simultanées sans mécanismes de verrouillage appropriés peuvent entraîner des conditions de concurrence et corrompre l'état.

3. Problèmes de connectivité backend : s'il y a des problèmes avec le système de stockage backend où le fichier d'état est stocké, comme des pannes de réseau ou des configurations incorrectes, cela peut entraîner une corruption de l'état. Des écritures incomplètes ou interrompues sur le backend peuvent entraîner un état incohérent.

4. Échec des opérations : si une opération Terraform (par exemple, appliquer ou détruire) échoue partiellement en raison d'erreurs ou d'interruptions, le fichier d'état peut se retrouver dans un état incohérent. Les opérations échouées peuvent laisser derrière elles des ressources qui ont été partiellement créées ou détruites, entraînant la corruption de l'État.

5. Ressources supprimées ou manquantes : si les ressources gérées par Terraform sont supprimées manuellement en dehors du contrôle de Terraform, ou si le stockage principal perd la trace des métadonnées des ressources, le fichier d'état peut devenir incohérent.

Pour résoudre les problèmes de corruption de l'état de Terraform, procédez comme suit :

1. Sauvegardes régulières : maintenez des sauvegardes régulières du fichier d'état pour minimiser l'impact de la corruption. Les sauvegardes fournissent un point de restauration au cas où l'état deviendrait inutilisable.

2. Contrôle de version : stockez les fichiers de configuration et le fichier d'état de Terraform dans un système de contrôle de version (VCS) pour suivre les modifications et restaurer les versions précédentes si nécessaire. Cela permet de détecter et de résoudre les problèmes de corruption d'État.

3. Mécanismes de verrouillage : utilisez les mécanismes de verrouillage principaux fournis par Terraform pour empêcher les modifications simultanées du fichier d'état. Le verrouillage garantit qu'une seule opération peut modifier l'état à la fois, ce qui minimise les risques de corruption.

4. Commandes Terraform : utilisez les commandes Terraform telles que `terraform state list`, `terraform state show` et `terraform state mv` pour inspecter, modifier et corriger le fichier d'état si des incohérences sont détectées. Soyez prudent lorsque vous modifiez manuellement le fichier d'état et utilisez ces commandes avec précaution.

5. Recréer l'état : dans les cas graves de corruption, si des sauvegardes sont disponibles ou si l'infrastructure est reproductible, il peut être nécessaire de recréer le fichier d'état à partir de zéro. Cela implique de détruire les ressources existantes et de les recréer avec un nouveau fichier d'état.

Il est essentiel de suivre les meilleures pratiques tel que l'utilisation d'un fichier d'état distant pour gérer l'état de Terraform.

Le stockage à distance est important dans Terraform pour plusieurs raisons :

1. Collaboration : lorsque plusieurs membres de l'équipe travaillent sur la même infrastructure, le stockage à distance leur permet de partager et de synchroniser leurs modifications. Il fournit un emplacement centralisé pour stocker l'état, permettant la collaboration et évitant les conflits qui peuvent survenir lorsque plusieurs personnes gèrent les mêmes ressources.

2. Gestion de l'état : l'état de Terraform contient des informations critiques sur l'infrastructure déployée, telles que les métadonnées des ressources, les dépendances et les valeurs d'attribut. En stockant l'état à distance, il devient accessible à tous les membres de l'équipe, assurant la cohérence et fournissant une source unique de vérité pour l'état actuel de l'infrastructure.

3. Opérations cohérentes : le stockage d'état à distance garantit que chaque membre de l'équipe travaille avec la même version de l'état. Cette cohérence est cruciale pour l'exécution d'opérations Terraform telles que planifier, appliquer et détruire. Cela évite les incohérences qui peuvent se produire lorsque différents membres de l'équipe ont des versions différentes de l'état, ce qui peut entraîner des modifications ou des conflits involontaires.

4. Historique et vérifiabilité de l'infrastructure : en stockant l'état de manière persistante, le stockage d'état à distance permet de suivre les modifications de l'infrastructure au fil du temps. Il fournit un enregistrement historique de l'évolution de l'infrastructure, ce qui facilite l'examen, l'analyse et l'audit des modifications. Ceci est particulièrement important à des fins de conformité et de gouvernance.

5. Sécurité et contrôle d'accès : les solutions de stockage à distance offrent souvent des contrôles d'accès et une gestion des autorisations. Cela vous permet de limiter qui peut voir ou modifier l'état, améliorant la sécurité et garantissant que seules les personnes autorisées peuvent apporter des modifications à l'infrastructure.

6. Reprise après sinistre : le stockage à distance de l'état de Terraform offre des capacités de résilience et de reprise après sinistre. Si l'état local est perdu ou corrompu, le fait d'avoir une copie à distance vous permet de récupérer l'état et de continuer à gérer l'infrastructure sans perdre de progression ni recommencer à zéro.

Les options populaires de stockage à distance dans Terraform incluent les services de stockage d'objets cloud comme Terraform cloud, Amazon S3, Azure Blob Storage ou Google Cloud Storage. De plus, Terraform propose une configuration backend à distance, vous permettant de configurer et de vous connecter à diverses solutions de stockage à distance.

**Demonstration de sauvegarde sur AWS**

- Pour la sauvegarde distante du fichier d'état, la prémière étape consiste à créer les resources `s3 bucket` et `dynamodb`.

```!hcl
provider "aws" {
  region = "us-west-2"
}

resource "aws_s3_bucket" "remote-state" {
  bucket = "tfm-state-bucket"
  tags = {
    Name        = "Dev-Bucket"
    Environment = "Dev"
  }
}

resource "aws_s3_bucket_versioning" "remote-state-versioning" {
  bucket = aws_s3_bucket.remote-state.id
  versioning_configuration {
    status = "Enabled"
  }
}

resource "aws_dynamodb_table" "dynamo-table" {
  name         = "tfstate-locking"
  billing_mode = "PAY_PER_REQUEST"
  hash_key     = "LockID"

  attribute {
    name = "LockID"
    type = "S"
  }
}
```

Lorsque vous utilisez AWS comme stockage d'état distant dans Terraform, il est courant de créer un compartiment S3 et une table DynamoDB. Voici pourquoi:

1. Compartiment S3 pour le stockage d'état : le compartiment S3 agit comme le backend de stockage pour le fichier d'état Terraform. Il fournit un emplacement fiable et évolutif pour stocker l'état, permettant un accès et une récupération faciles par Terraform. Le stockage de l'état dans un compartiment S3 garantit la durabilité et la disponibilité, car S3 fournit une redondance intégrée et une haute disponibilité pour les objets qui y sont stockés.

2. Table DynamoDB pour le verrouillage : la table DynamoDB est utilisée pour le verrouillage d'état dans Terraform. Le verrouillage empêche les modifications simultanées du fichier d'état, garantissant qu'une seule opération Terraform peut modifier l'état à la fois. Les opérations atomiques et les garanties de cohérence de DynamoDB le rendent adapté à la gestion efficace des verrous. Terraform utilise la table DynamoDB pour acquérir et libérer des verrous pendant les opérations, évitant ainsi les conflits lorsque plusieurs utilisateurs ou processus tentent de modifier l'état simultanément.

En combinant un compartiment S3 pour le stockage d'état et une table DynamoDB pour le verrouillage, vous établissez une solution de stockage d'état à distance robuste et évolutive pour Terraform sur AWS. Cette configuration garantit que l'état est stocké en toute sécurité, facilement accessible et fournit le contrôle de simultanéité nécessaire pour la gestion collaborative de l'infrastructure.

- La deuxième étape consiste à configurer le backend s3 

```hcl
terraform {
  backend "s3" {
    bucket = "tfm-state-bucket"
    region = "us-west-2"
    key = "terraform.tfstate"
    dynamodb_table = "tfstate-locking"
  }
}
```

**Resultats**
![](https://hackmd.io/_uploads/SyLRE6rO3.png)

### **Problèmes de dépendances :** 

Les erreurs de dépendance des ressources dans Terraform font référence aux problèmes qui surviennent lorsqu'il existe des dépendances entre les ressources qui ne sont pas correctement définies ou résolues. Dans Terraform, les ressources peuvent avoir des dépendances sur d'autres ressources, ce qui signifie qu'elles doivent être créées ou modifiées dans un ordre spécifique pour conserver un état cohérent.

Lorsque des erreurs de dépendance de ressource se produisent, cela signifie généralement que Terraform ne peut pas satisfaire aux exigences de dépendance entre les ressources pendant le processus de provisionnement. Cela peut entraîner des erreurs lors des étapes de planification ou d'application. Les erreurs de dépendance aux ressources peuvent se manifester sous diverses formes, telles que :

1. Dépendances manquantes : une ressource dépend d'une autre ressource qui n'est pas déclarée dans la configuration ou qui est absente de l'état Terraform.

2. Dépendances circulaires : Deux ressources ou plus ont une dépendance circulaire les unes par rapport aux autres, créant une boucle sans fin et empêchant le processus de provisionnement de se terminer.

3. Ordre des dépendances : les ressources sont déclarées dans le bon ordre, mais Terraform rencontre des difficultés pour déterminer la séquence de provisionnement exacte en raison de dépendances complexes.

Pour résoudre les erreurs de dépendance des ressources dans Terraform, vous pouvez suivre les étapes suivantes :

1. Examinez les messages d'erreur : analysez attentivement le message d'erreur fourni par Terraform pour comprendre le problème de dépendance spécifique. Le message d'erreur fournit souvent des informations sur les dépendances manquantes ou conflictuelles.

2. Définir les dépendances : utilisez l'attribut `depends_on` pour définir explicitement les dépendances entre les ressources. Assurez-vous que chaque ressource référence correctement les ressources dont elle dépend.

3. Interpolation des ressources : utilisez l'interpolation des ressources (syntaxe `${}`) pour référencer les attributs d'une ressource dans la configuration d'une autre ressource. Cela garantit que Terraform comprend correctement les dépendances.

4. Utiliser les sorties du module : Lorsque vous utilisez des modules, définissez les sorties dans le module et utilisez-les comme entrées pour d'autres ressources. Cela aide à établir des dépendances appropriées et évite les références circulaires.

5. Fractionner les ressources : si vous rencontrez des erreurs de dépendance circulaire, envisagez de fractionner les ressources en unités logiques ou modules distincts. Cela vous permet de gérer plus efficacement les dépendances.

6. Utiliser des provisionneurs : dans certains cas, vous pouvez utiliser des provisionneurs (par exemple, `local-exec`, `remote-exec`) pour effectuer une configuration ou un script supplémentaire après le provisionnement d'une ressource. Cela peut aider à résoudre les problèmes de dépendance dans certains scénarios.

En définissant et en gérant soigneusement les dépendances des ressources, vous pouvez vous assurer que Terraform provisionne les ressources dans le bon ordre et maintient un état d'infrastructure cohérent.

Pou résoudre les problèmes de dépendances il est utile d'exploiter la commande `terraform graph`. 
La commande `terraform graph` est utile pour visualiser et comprendre le graphique de dépendance des ressources définies dans votre configuration Terraform. Il génère une représentation visuelle des dépendances des ressources, ce qui peut vous aider à comprendre comment les ressources sont liées les unes aux autres et comment les modifications apportées à une ressource peuvent avoir un impact sur les autres.

**Demonstration de terraform graph**

Pour utiliser cette commande sur linux il est nécéssaire d'installer l'outil `graphviz`

Une fois installer utilisez la commande `terraform graph | dot -Tsvg  > graph.svg` celle ci génere un visuel graphique des dépendences

![](https://hackmd.io/_uploads/r1j8pqrun.png)

Le graphe ci-dessus a été générer à parti des fichiers `.tf` suivants:

- `main.tf`
```hcl!
resource "aws_instance" "app_server" {
  ami           = var.ami
  instance_type = var.instance_type 
  vpc_security_group_ids = [aws_security_group.ssh-access.id]
  key_name = "${aws_key_pair.dev-server.key_name}"

  tags = {
    Name = "Dev-Server"
    Environment = "Dev"
  }
}

resource "aws_key_pair" "dev-server" {
  public_key = file(var.public_key)
  key_name = "server-key"
}

resource "aws_security_group" "ssh-access" {
  name = "ssh-access"
  description = "Allow ssh from internet"

  ingress {
    from_port = 22
    to_port = 22
    protocol = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
  egress {
    from_port = 0
    to_port = 0
    protocol = "-1"
    cidr_blocks = ["0.0.0.0/0"]
    ipv6_cidr_blocks = ["::/0"]
  }
}

output publicip {
  value = aws_instance.app_server.public_ip
}
```
- `providers.tf`
```hcl!
provider "aws" {
  region = "us-west-2"
}
```

- `terraform.tf`
```hcl!
terraform {
  backend "s3" {
    bucket = "tfm-state-bucket"
    region = "us-west-2"
    key = "terraform.tfstate"
    dynamodb_table = "tfstate-locking"
  }
}
```

- `variables.tf`
```hcl!
variable "region" {
    default = "us-west-2"
}
variable "instance_type" {
    default = "t2.micro"
}
variable "ami" {
    default = "ami-07dfed28fcf95241c"
}
variable "public_key" {
  default = "~/.ssh/dev-server.pub"
}
```

En tirant parti de la commande `terraform graph`, vous pouvez mieux comprendre les dépendances des ressources de votre infrastructure, prendre des décisions éclairées lors des modifications de l'infrastructure et résoudre les problèmes liés à l'ordre de provisionnement des ressources et aux dépendances circulaires.

## Conclusion

En conclusion, le dépannage de Terraform est une compétence cruciale pour gérer efficacement les déploiements d'infrastructure et maintenir un état cohérent. En comprenant les problèmes courants et leurs causes, vous pouvez résoudre efficacement les problèmes qui surviennent lors de l'exécution de Terraform. Qu'il s'agisse de résoudre des erreurs de dépendance aux ressources, de gérer des problèmes liés aux fournisseurs ou de résoudre des problèmes de configuration, une approche systématique et l'utilisation des fonctionnalités et outils intégrés de Terraform peuvent vous aider à surmonter les défis. De plus, un dépannage efficace implique souvent l'analyse des messages d'erreur, l'examen des journaux, l'utilisation des commandes Terraform et la consultation de la communauté Terraform pour obtenir de l'aide. En maîtrisant les techniques de dépannage de Terraform, vous pouvez optimiser votre processus de provisionnement d'infrastructure, garantir des déploiements fiables et, en fin de compte, fournir des environnements d'infrastructure stables et évolutifs.