Module 2 : import Terraform Dynatrace Managed, état et dérive

Import Terraform Dynatrace Managed : backend distant, export et import de l’existant, détection de dérive et modules, avec exercice et quiz.
Module 2 : import Terraform Dynatrace Managed, état et dérive

Module 2 du parcours Terraform Dynatrace Managed : l’import Terraform Dynatrace Managed permet de reprendre sous contrôle une configuration créée à la main, de la stocker dans un état partagé et de détecter les modifications faites hors du code.

Parcours : Terraform Dynatrace Managed · Module 2/3 · Durée : ~45 min · Niveau : Intermédiaire

Objectifs :

  • Expliquer le rôle de l’état Terraform et choisir un backend distant
  • Exporter une configuration existante avec l’utilitaire du fournisseur Dynatrace
  • Importer des objets dans l’état, avec l’option -import-state ou un bloc import
  • Détecter la dérive et organiser le code en modules

Prérequis : le module 1 (fournisseur installé, URL d’environnement Managed, jeton d’API) et un environnement de test, jamais la production pour un premier essai.

Les modules précédents partaient d’un environnement vide. Or le cluster contient déjà des années de configuration créée dans l’interface. Sans import, Terraform ignore ces objets et un apply en créerait des doublons.

L’état Terraform : ce qu’il contient et où le stocker

Terraform compare trois choses : le code, l’état et l’environnement réel. L’état est le registre qui relie chaque bloc resource à l’objet correspondant dans Dynatrace. Par défaut, il vit dans un fichier local nommé terraform.tfstate. Cela suffit pour un essai, pas pour une équipe : chacun doit disposer de la dernière version.

Le backend distant règle ces deux problèmes. D’après la documentation HashiCorp, l’état est alors écrit dans un stockage partagé, et les backends complets offrent un verrouillage qui empêche les exécutions concurrentes. Le choix du backend (S3, Azure Blob Storage, Google Cloud Storage, HCP Terraform…) relève de votre infrastructure.

Fichiers providers.tf avec le fournisseur dynatrace-oss/dynatrace en version ~> 1.0 et backend.tf avec un backend S3 d'exemple et use_lockfile à true

Deux points de vigilance :

  • L’état est sensible. HashiCorp précise qu’il peut contenir des valeurs secrètes (jetons, mots de passe) et qu’un état local est un fichier en clair. Excluez-le de Git, chiffrez-le au repos si le backend le permet.
  • Le verrouillage dépend du backend. Pour S3, il s’active avec l’argument use_lockfile, désactivé par défaut. Vérifiez l’option équivalente de votre backend.

Exporter l’existant avec l’utilitaire du fournisseur

Le fournisseur Dynatrace sert aussi d’exécutable autonome pour exporter une configuration existante. La documentation le présente comme une alternative à l’écriture manuelle et un moyen de créer des gabarits. Cet utilitaire n’est pas le binaire terraform : c’est le binaire du fournisseur, que la documentation situe typiquement dans le répertoire .terraform/providers/registry.terraform.io/dynatrace-oss/dynatrace/, sous le dossier de version et de système.

Pour Managed, l’environnement se désigne par DYNATRACE_ENV_URL, de la forme https://<dynatrace-host>/e/<identifiant>, et le jeton d’API par DYNATRACE_API_TOKEN (README du fournisseur). Le dossier de sortie se règle par DYNATRACE_TARGET_FOLDER.

export DYNATRACE_ENV_URL="https://cluster.example.com/e/EXEMPLE"
export DYNATRACE_API_TOKEN="<jeton, jamais dans le dépôt>"
export DYNATRACE_TARGET_FOLDER="./export"

./terraform-provider-dynatrace -export -list-exclusions
./terraform-provider-dynatrace -export dynatrace_alerting

La première commande liste les ressources exclues par défaut, dont dynatrace_json_dashboard : un tableau de bord ne sort que s’il est demandé explicitement. La seconde exporte les profils d’alerte. Les options utiles sont :

Option Effet (documentation officielle)
-ref inclut les ressources avec leurs sources de données et dépendances
-migrate inclut les dépendances, sans les sources de données
-import-state initialise les modules Terraform et importe les ressources dans l’état
-id affiche l’identifiant en commentaire dans les fichiers
-flat range tout dans le dossier cible, sans structure de modules
-exclude exclut les ressources indiquées
Extrait de la documentation du fournisseur Dynatrace : options ref, migrate, import-state, id, flat et exclude de l'utilitaire d'export, avec un exemple de commande

Sans -flat, l’export produit un fichier main.tf qui appelle un module par type de ressource. Le code du fournisseur écrit ces blocs sous la forme module "alerting" { source = "./modules/alerting" }. Les fichiers qui ne peuvent pas être traités sont déplacés dans .flawed (obsolètes ou à corriger) ou .required_attention (informations manquantes, par exemple des chaînes confidentielles qu’aucune API ne renvoie). Relisez ces deux dossiers avant tout apply.

Import Terraform Dynatrace Managed : deux chemins

Chemin 1 : l’option -import-state

L’export avec -import-state initialise les modules et importe les ressources exportées dans l’état en une seule passe. Le code du fournisseur le confirme : si le CLI Terraform est absent, l’import est ignoré avec un message. Configurez le backend avant, pour que l’état soit directement partagé.

Chemin 2 : le bloc import, ressource par ressource

Selon la documentation Terraform, un bloc import déclare l’adresse cible (to) et l’identifiant de l’objet (id). Un bloc resource de même adresse doit exister. L’identifiant dépend du type de ressource : la documentation Terraform renvoie à celle du fournisseur. Les pages de ressources du fournisseur n’indiquent pas de format générique ; utilisez l’option -id de l’export pour lire l’identifiant réel de chaque objet.

Fichier import.tf d'exemple avec un bloc import et une ressource dynatrace_alerting, puis les commandes terraform plan -detailed-exitcode et terraform plan -refresh-only

Ce chemin convient à un import progressif, objet par objet, sur un environnement qui contient déjà du code. Terraform sait aussi générer le code des ressources importées avec terraform plan -generate-config-out=PATH, mais la documentation le qualifie d’expérimental : relisez le résultat comme un export.

Dérive : détecter ce qui change hors du code

Un administrateur modifie un profil d’alerte dans l’interface pendant un incident : c’est la dérive. Le terraform plan actualise l’état depuis l’environnement, puis montre l’écart avec le code. Deux outils servent le SRE :

  • terraform plan -detailed-exitcode retourne 0 sans changement, 1 en cas d’erreur, 2 si des changements existent. Un job planifié peut donc alerter sur le code 2.
  • terraform plan -refresh-only met à jour l’état pour refléter les changements faits hors de Terraform, par exemple pendant un incident. À utiliser quand la modification manuelle est légitime : reportez-la ensuite dans le code.

Le bénéfice se mesure en MTTR et en toil : on identifie vite la modification manuelle qui explique un comportement inattendu. L’esprit reste « sans reproche » : la dérive signale un manque dans le processus, pas une faute.

Modules : factoriser la configuration

La documentation Dynatrace cite parmi les avantages du fournisseur le regroupement de composants en modules réutilisables. L’export en produit déjà un par type de ressource. Pour plusieurs environnements Managed, écrivez un module d’équipe (profil d’alerte, management zone, notification) appelé avec des variables : le même code se déploie en recette puis en production. Le module 3 relie cette idée au GitOps.

Pour comparer les deux outils, lisez Monaco ou Terraform et la configuration en code avec Monaco.

Exercice pratique

Environnement de test Managed uniquement. Les commandes ci-dessous n’ont pas été exécutées pour cet article : aucune sortie n’est donnée, et le comportement exact sur un cluster Managed est à constater chez vous.

Étape 1 — Configurer le backend

Dans un dossier de travail, créez providers.tf et backend.tf comme sur la première capture, avec un backend de votre infrastructure. Lancez terraform init. Résultat attendu : Terraform signale l’initialisation du backend et du fournisseur.

Étape 2 — Exporter un type de ressource

Définissez DYNATRACE_ENV_URL, DYNATRACE_API_TOKEN et DYNATRACE_TARGET_FOLDER, puis lancez l’export de dynatrace_alerting avec -id. Résultat attendu : un dossier contenant main.tf et un sous-dossier modules. Vérifiez .flawed et .required_attention.

Étape 3 — Importer et contrôler

Relancez l’export avec -import-state, puis, dans le dossier exporté, terraform plan. Résultat attendu : idéalement aucun changement ; sinon, analysez chaque écart avant d’appliquer quoi que ce soit.

Étape 4 — Provoquer une dérive

Modifiez un profil d’alerte dans l’interface, puis lancez terraform plan -detailed-exitcode et notez le code de sortie. Résultat attendu : code 2 et un écart décrit. Corrigez soit le code, soit l’environnement.

Quiz

  1. Pourquoi préférer un backend distant à un fichier d’état local en équipe ? a) Il rend Terraform plus rapide b) Il partage l’état et, selon le backend, verrouille les exécutions concurrentes c) Il supprime le besoin de jeton d’API d) Il chiffre le code HCL
  2. Quelle option de l’export importe les ressources dans l’état ? a) -ref b) -flat c) -import-state d) -id
  3. Que signifie le code de sortie 2 de terraform plan -detailed-exitcode ? a) Erreur b) Aucun changement c) Succès avec des changements présents d) Plan annulé
  4. Que contient le dossier .required_attention ? a) Les logs de l’export b) Des fichiers auxquels il manque des informations essentielles, par exemple des données sensibles c) Les sauvegardes de l’état d) Les modules réutilisables

Corrigé

  1. b. L’état est partagé et, avec un backend complet, verrouillé pendant les exécutions.
  2. c. -import-state initialise les modules et importe les ressources dans l’état.
  3. c. 0 signifie aucun changement, 1 une erreur, 2 des changements présents.
  4. b. Ces fichiers manquent d’informations, comme les secrets que l’API ne renvoie pas.

Pour aller plus loin

← Module 1 : provider Terraform · Sommaire du parcours · Module 3 : GitOps →

Questions fréquentes

Faut-il importer ou repartir de zéro ?

Importez si l’environnement porte déjà de la configuration utile : repartir de zéro risque de créer des doublons ou d’écraser des réglages. Repartez de zéro seulement sur un environnement vide.

Les tableaux de bord sont-ils exportés ?

Pas par défaut. La documentation indique que dynatrace_json_dashboard et d’autres ressources sont exclus, sauf demande explicite. -list-exclusions donne la liste complète.

L’OAuth ou le jeton de plateforme s’applique-t-il à Managed ?

Les pages d’export de la documentation parlent de jeton de plateforme et d’OAuth, notions de la plateforme SaaS. Pour Managed, ce module s’appuie sur DYNATRACE_ENV_URL et DYNATRACE_API_TOKEN. La page d’export n’existe pas dans la documentation Managed : l’usage de l’export sur un cluster Managed n’a pas été testé ici.

L’état, l’import et le contrôle de dérive transforment un cluster configuré à la main en configuration reproductible. Le module 3 assemble ces briques dans un pipeline GitOps avec revues et promotion entre environnements.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Ce parcours ne remplace pas les formations et certifications officielles de Dynatrace University. Vérifiez les fonctionnalités dans la documentation officielle de votre version.

Total
0
Shares
Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Previous Post
Module 1 — Provider Terraform Dynatrace SaaS : installer et authentifier

Module 1 — Provider Terraform Dynatrace SaaS : installer et authentifier

Next Post
Module 2 — Import Terraform Dynatrace SaaS : état, export et dérive

Module 2 — Import Terraform Dynatrace SaaS : état, export et dérive

Related Posts