JSON / YAML → Terraform HCL
Ingénierie d'infrastructure Terraform HCL

Générateur de variables et locals Terraform HCL depuis JSON / YAML

Convertissez des structures JSON et YAML en contraintes de types HCL Terraform (type = object({...})), valeurs par défaut, blocs locals et fichiers terraform.tfvars.

Zéro transmission au serveur
Terraform 1.3+ optional()
Préréglages :
Charge utile d'entrée (JSON / YAML)yaml
variable "app_config" {
  description = "Auto-generated Terraform variable constraint for app_config"
  type = object({
    cidr_block           = string
    enable_dns_hostnames = bool
    enable_dns_support   = bool
    max_azs              = number
    nat_gateways         = list(string)
    subnets              = list(object({
      az             = string
      cidr           = string
      is_public      = bool
      name           = string
      route_table_id = string
    }))
    tags                 = map(string)
    vpc_name             = string
  })
  default = {
    cidr_block           = "10.100.0.0/16"
    enable_dns_hostnames = true
    enable_dns_support   = true
    max_azs              = 3
    nat_gateways         = ["nat-08127394821a", "nat-09823412344b"]
    subnets              = [
      {
        az             = "us-east-1a"
        cidr           = "10.100.1.0/24"
        is_public      = true
        name           = "public-1a"
        route_table_id = "rtb-01a9b2c3d4"
      },
      {
        az             = "us-east-1b"
        cidr           = "10.100.2.0/24"
        is_public      = true
        name           = "public-1b"
        route_table_id = "rtb-01a9b2c3d4"
      },
      {
        az             = "us-east-1a"
        cidr           = "10.100.10.0/24"
        is_public      = false
        name           = "private-app-1a"
        route_table_id = "rtb-09f8e7d6c5"
      },
      {
        az             = "us-east-1b"
        cidr           = "10.100.11.0/24"
        is_public      = false
        name           = "private-app-1b"
        route_table_id = "rtb-09f8e7d6c5"
      }
    ]
    tags                 = {
      CostCenter  = "infra-0091"
      Environment = "production"
      ManagedBy   = "terraform"
      Owner       = "cloud-platform-team"
    }
    vpc_name             = "prod-useast1-vpc"
  }
}
Complexité du schéma
13 Champs déduitsProfondeur 2
Attributs optionnels
0 Optionnels détectésv1.3+ Activé
Dialectes d'exportation
4 Formats de sortie.tf / .tfvars / .json

Synthèse AST 100% côté client

L'analyse syntaxique JSON et YAML, le parcours d'arbre AST et la synthèse de types Terraform HCL s'exécutent localement dans la mémoire de votre navigateur, sans requête réseau ni télémétrie.

Conformité Terraform 1.3+ & optionnels

Détecte automatiquement les champs manquants ou nullables et les enveloppe dans la syntaxe standard optional(type, default), évitant ainsi les erreurs de type lors de l'exécution de terraform plan.

Export d'infrastructure multi-dialecte

Exporte en toute fluidité les contraintes de type variables.tf, les définitions de valeurs terraform.tfvars, les blocs de configuration locals.tf et les fichiers tfvars.json prêts pour la production.

Référence technique et guide d'architecture

Guide Développeur : Générateur de Variables et Locals Terraform HCL depuis JSON / YAML — Guide de référence

Convertissez des structures JSON et YAML en contraintes de types HCL Terraform (type = object({...})), valeurs par défaut, blocs locals et fichiers terraform.tfvars.

Paramètres clés et contrôles

source_formatstring

Définit le format de la charge utile source à analyser ('json' ou 'yaml').

Par défaut : "json"
target_modestring

Détermine la structure HCL générée : 'variable' (avec contrainte de type et valeur par défaut), 'locals' (expression interne) ou 'tfvars' (affectation brute).

Par défaut : "variable"
variable_namestring

Identifiant attribué au bloc de variable HCL ou à la clé du bloc locals.

Par défaut : "app_config"
use_optional_attributesboolean

Active la syntaxe optional() de Terraform 1.3+ avec valeur de repli pour les attributs d'objet pouvant être omis ou nuls.

Par défaut : true
indent_spacesnumber

Nombre d'espaces utilisés pour l'indentation du code HCL généré.

Par défaut : 2

Conseils de pro et bonnes practices

Dans les schémas d'objets imbriqués

Dans les schémas d'objets imbriqués, encapsulez les attributs facultatifs avec optional(type, valeur_defaut). Vous éviterez les exceptions de pointeur nul et supprimerez les appels fastidieux à coalesce().

Les tableaux JSON uniformes se

Les tableaux JSON uniformes se convertissent en list(string). En présence d'éléments de structures ou types différents, privilégiez tuple([type1, type2]) plutôt que list(any) pour conserver un typage strict.

Si vos pipelines automatisés créent

Si vos pipelines automatisés créent des configurations JSON dynamiques, enregistrez-les sous terraform.auto.tfvars.json. Terraform lit directement les fichiers variables JSON sans conversion HCL intermédiaire.

En HCL

En HCL, les identifiants sans guillemets avec tirets sont interprétés comme des soustractions arithmétiques. Si vos clés comportent des tirets, écrivez-les entre guillemets doubles : "service-name" = string.

Pièges courants et dépannage

Erreur : Invalid attribute name en raison de tirets non échappés

Les identifiants comportant des tirets doivent obligatoirement être entourés de guillemets doubles dans les corps d'objets : "ingress-rule" = object({...}).

Incompatibilité de type lors du passage de valeurs null

Les attributs d'objets Terraform rejettent la valeur null par défaut. Déclarez l'attribut avec le modificateur optional(string) ou définissez nullable = true sur le bloc variable principal.

Erreur d'analyse sur des scalaires multilignes YAML mal indentés

Veillez à ce que les blocs multilignes (| ou >) conservent une indentation régulière de 2 espaces sans aucune tabulation (\t), non autorisée en YAML.

Foire aux questions (FAQ)

Comment le générateur déduit-il les types HCL à partir du JSON/YAML ?▼

Les chaînes deviennent string, les nombres number et les booléens bool. Les listes d'éléments identiques deviennent list(type), les listes hétérogènes tuple([...]), les dictionnaires uniformes map(type) et les objets structurés object({...}).

Quelle est la différence entre un bloc variable et un bloc locals ?▼

Un bloc variable définit un contrat d'entrée externe exposé avec validation de types et valeurs par défaut. Un bloc locals stocke des expressions internes immuables, inaccessibles depuis l'extérieur du module.

Pourquoi privilégier type = object({...}) plutôt que type = any ?▼

Le type any désactive la vérification statique lors du terraform validate, repoussant la découverte des erreurs à l'exécution. Un schéma explicite fiabilise le code et active l'autocomplétion dans l'IDE.

Le code HCL généré est-il directement utilisable avec Terraform Cloud ou Terragrunt ?▼

Oui. Les déclarations de variables s'insèrent dans variables.tf, et les valeurs peuvent être injectées via terraform.tfvars ou le bloc inputs d'un fichier terragrunt.hcl.

Outils et utilitaires connexes

Tous les outils →
Guide Développeur : Convertisseur OpenAPI / Swagger vers GraphQL SDLDéveloppement

Convertissez les points de terminaison REST, corps de requête et schémas JSON OpenAPI 3.0/3.1 et Swagger 2.0 en types, requêtes, mutations et entrées GraphQL SDL.

Ouvrir l'outil→
Guide développeur du générateur de schémas TypeScript TypeBox depuis SQL DDLDéveloppement

Convertissez les instructions SQL CREATE TABLE en schémas de validation à l'exécution @sinclair/typebox utilisant Type.Object, Type.String, Type.Number et Type.Optional.

Ouvrir l'outil→
Guide Développeur du Générateur de Code cURL vers Rust (reqwest & tokio)Développement

Convertissez des commandes cURL en requêtes HTTP asynchrones et idiomatiques en Rust à l'aide de reqwest, serde_json, d'en-têtes personnalisés et du runtime Tokio.

Ouvrir l'outil→
Guide développeur du générateur de code cURL vers Ruby (Net::HTTP & Faraday)Développement

Convertissez vos requêtes cURL en code Ruby propre et idiomatique avec Net::HTTP, URI, Faraday et la gestion native du JSON.

Ouvrir l'outil→
Générateur de NetworkPolicy K8S Guide DéveloppeurDéveloppement

Référence technique pour générer des manifestes Kubernetes NetworkPolicy déclaratifs, l'isolation de pods zero-trust, les règles d'ingress/egress, les blocs CIDR et les ports multiples.

Ouvrir l'outil→
Guide Développeur : Générateur YAML Kubernetes RBAC Role & ClusterRoleBindingDéveloppement

Concevez des manifestes Kubernetes RBAC pour Role, ClusterRole, RoleBinding et ClusterRoleBinding avec groupes d'API, verbes de ressources et comptes de service.

Ouvrir l'outil→