Module 4 — Déploiement Monaco Managed : projets, gabarits et dry-run

Déploiement Monaco Managed : structurer un projet, écrire config.yaml et gabarits JSON, gérer les dépendances et valider avec deploy –dry-run.
Module 4 — Déploiement Monaco Managed : projets, gabarits et dry-run

Module 4 du parcours Monaco Managed : le déploiement Monaco Managed transforme un dossier de fichiers YAML et JSON en configuration vivante dans votre cluster, après une validation à blanc.

Parcours : Monaco Managed · Module 4/5 · Durée : ~45 min · Niveau : Intermédiaire

Objectifs :

  • Organiser un projet Monaco : dossiers, config.yaml et gabarit JSON
  • Paramétrer un gabarit avec des variables et des références entre configurations
  • Surcharger une valeur par environnement
  • Valider avec deploy --dry-run, puis déployer

Prérequis : la CLI monaco installée et un manifeste (module 2), un projet exporté avec monaco download (module 3), un environnement Managed de recette.

Les modules précédents ont posé l’outil et récupéré une configuration existante. Ce module traite le geste central : le déploiement Monaco Managed. Il s’agit d’écrire ou de modifier des fichiers, de vérifier qu’ils sont cohérents, puis de les envoyer à l’environnement ciblé. Cette séquence remplace les clics en console et rend chaque changement relisible dans Git.

Le contenu vaut pour Dynatrace Managed uniquement : jeton d’API, API de configuration classiques et Settings 2.0. Les points vérifiés proviennent des pages Managed de la documentation officielle et du code du dépôt Dynatrace/dynatrace-configuration-as-code.

Déploiement Monaco Managed : anatomie d’un projet

Selon la documentation, un projet est un dossier. Il contient des sous-dossiers nommés d’après les API, et ceux-ci contiennent à leur tour les fichiers de chaque configuration. Une configuration se compose de deux éléments : un fichier YAML (paramètres, dépendances, nom, gabarit) et un gabarit JSON, c’est-à-dire la charge envoyée à l’API Dynatrace.

Arborescence d'un projet Monaco nommé alerting avec deux dossiers d'API, et manifest.yaml pointant vers un environnement Managed par variables d'environnement

Le manifeste désigne les projets à déployer et les environnements cibles. Ses clés de premier niveau sont manifestVersion, projects et environmentGroups. Chaque environnement appartient à exactement un groupe. Les noms de dossiers d’API (par exemple management-zone, alerting-profile, dashboard) figurent dans la page « Configuration types and access permissions » ; cette page recense aussi les schémas Settings 2.0.

Élément Rôle
manifest.yaml Quels projets, vers quels environnements, avec quel jeton (nom de variable)
Dossier de projet Regroupe logiquement les configurations (une équipe, un service)
config.yaml Liste de configurations : id, type, config
Gabarit JSON Corps de l’objet, avec des variables {{ .nom }}

Deux types de projet existent dans le manifeste : simple (par défaut, avec name et éventuellement path) et grouping, qui charge chaque sous-dossier comme un projet distinct, préfixé du nom du projet et d’un point (par exemple general.zones).

Le fichier config.yaml

Le fichier commence par la clé configs, une liste. Chaque entrée exige trois champs : id, type et config. L’id n’existe que pour Monaco : il doit être unique par type et par projet, et sert surtout aux références. Le type indique soit une API (api: dashboard, ou la forme courte type: dashboard), soit un schéma Settings 2.0 (settings avec schema et scope).

Le bloc config contient name, template, et en option skip et parameters. Pour une API classique, le name identifie l’objet dans l’environnement : il sert à décider entre création et mise à jour. Le gabarit doit donc l’utiliser tel quel, sans caractère parasite, sous la forme "{{ .name }}". Un espace en trop explique les doublons d’objets que l’on observe parfois après un déploiement.

Gabarits JSON et variables

Le gabarit s’écrit en JSON, avec la syntaxe Go templates. La documentation recommande de rester simple : référencer un paramètre avec {{ .NOM_DU_PARAMETRE }} suffit dans la plupart des cas. Les valeurs YAML sont échappées avant d’être insérées, ce qui garantit un JSON valide même avec des guillemets ou des retours à la ligne.

Un piège : certaines charges contiennent déjà des doubles accolades. Il faut alors les échapper ({{`{{`}} pour ouvrir, {{`}}`}} pour fermer). Monaco le fait automatiquement pour les fichiers produits par monaco download.

Les paramètres existent en plusieurs types : valeur (forme courte : seuil: 15), environment (lit une variable d’environnement, avec un default facultatif), reference, compound, list et file. Un paramètre est évalué seulement si une configuration déployée le référence. Si une variable d’environnement manque et qu’aucun default n’est défini, le déploiement échoue. Le module 5 revient sur les secrets.

Dépendances entre configurations

Un paramètre reference lit une propriété d’une autre configuration, le plus souvent son id Dynatrace réel. Monaco en déduit l’ordre : la configuration référencée est déployée en premier. Un cycle de dépendances fait échouer le déploiement. La forme courte est [projet, type, configId, propriété] ; les niveaux de tête peuvent être omis s’ils sont identiques à ceux de la configuration courante.

Fichier config.yaml d'un alerting-profile avec une référence à une management zone et une surcharge par environnement, et son gabarit profil.json avec displayName et mzId

Dans l’exemple, zoneId résout l’identifiant de la management zone zone-prod, défini dans le dossier management-zone du même projet. Le champ mzId du gabarit correspond à celui de l’API des profils d’alerte ; son type est une chaîne. Comme la valeur est insérée entre guillemets, le résultat reste du JSON valide.

La section environmentOverrides change des valeurs pour un environnement (ici le nom), et groupOverrides le fait pour tout un groupe. Avec skip: true dans une surcharge, une configuration n’est pas déployée dans ce groupe.

Valider avec deploy –dry-run

La commande de base est monaco deploy manifest.yaml. Son option --dry-run (abréviation -d) valide la structure du manifeste, des projets et des configurations : elle résout les paramètres et produit les gabarits JSON. La documentation précise qu’un dry-run ne se connecte pas à Dynatrace et ne peut pas valider le contenu des charges. Un déploiement peut donc encore échouer avec une erreur HTTP 400 si un gabarit est incorrect.

D’autres options aident à cibler un déploiement :

  • --environment (-e) : un ou plusieurs environnements du manifeste ;
  • --group (-g) : un groupe d’environnements, exclusif avec --environment ;
  • --project (-p) : un projet, avec ses dépendances ;
  • --continue-on-error (-c) : poursuit malgré les erreurs, au risque d’erreurs en cascade sur les configurations dépendantes.

Pour une équipe SRE, le dry-run est un contrôle peu coûteux à placer sur chaque merge request : il attrape les références cassées, les variables manquantes et les JSON mal formés avant qu’ils n’atteignent un environnement. Il ne remplace pas un déploiement sur un environnement de recette.

Bonnes pratiques

  • Partir d’un objet exporté avec monaco download plutôt que d’écrire un JSON de mémoire.
  • Garder les gabarits simples ; déplacer la logique dans les paramètres.
  • Déployer d’abord en recette (-e), puis dans le groupe de production.
  • Ne jamais écrire de jeton dans le manifeste : seul le nom de la variable y figure.

Exercice pratique

Les commandes ci-dessous n’ont pas été exécutées pour la rédaction de ce module : le résultat attendu s’appuie sur la documentation et le code de la CLI. Utilisez un environnement Managed de recette.

Étape 1 — Préparer le projet

Créez le dossier monaco-demo avec le manifeste de l’illustration et un projet alerting. Exportez deux objets existants (une management zone et un profil d’alerte) avec monaco download (module 3) pour les utiliser comme gabarits. Résultat attendu : un dossier par type d’API, chacun avec un config.yaml et un fichier JSON.

Étape 2 — Paramétrer le gabarit

Dans le JSON du profil, remplacez le nom par "{{ .name }}" et l’identifiant de zone par une variable alimentée par une référence vers la management zone, comme dans l’exemple. Résultat attendu : aucune valeur propre à un environnement ne reste en dur, hormis celles des paramètres.

Étape 3 — Valider à blanc

export DT_PREPROD_URL="<URL de votre environnement Managed de recette>"
export DT_PREPROD_TOKEN="<jeton d'API de test>"
monaco deploy manifest.yaml --dry-run

Résultat attendu : le code source de la CLI journalise « Validation finished without errors » lorsque tout est cohérent (libellé non confirmé sur toutes les versions).

Étape 4 — Provoquer une erreur volontaire

Remplacez le configId de la référence par un identifiant inexistant, relancez --dry-run, puis rétablissez-le. Résultat attendu : une erreur au chargement ou à la validation, sans appel à l’environnement.

Étape 5 — Déployer

monaco deploy manifest.yaml -e preprod-managed

Résultat attendu : la management zone est créée avant le profil d’alerte, qui lui est rattaché. Relancez la commande : l’objet est mis à jour, pas dupliqué, car le name est identique.

Quiz

  1. Quels sont les trois champs obligatoires d’une entrée de configs ? a) name, template, skip b) id, type, config c) id, name, scope d) project, type, parameters
  2. Que vérifie --dry-run ? a) Que l’API Dynatrace accepte la charge JSON b) La structure des fichiers et le rendu des gabarits, sans connexion c) Les portées du jeton d’API d) Rien, il déploie en lecture seule
  3. Un paramètre de type reference sert à : a) lire une variable d’environnement b) lire une propriété d’une autre configuration et imposer l’ordre de déploiement c) importer un fichier d) désactiver une configuration
  4. Comment déployer uniquement vers un environnement précis ? a) --group b) --project c) --environment d) --continue-on-error

Corrigé

  1. b) Chaque configuration exige id, type et config.
  2. b) Le dry-run ne se connecte pas à Dynatrace : le contenu des charges n’est pas validé.
  3. b) La référence crée une dépendance : la configuration visée est déployée d’abord.
  4. c) -e cible un ou plusieurs environnements du manifeste.

Pour aller plus loin

← Module 3 : export Monaco Managed · Sommaire du parcours · Module 5 : secrets Monaco Managed →

Questions fréquentes

Le dry-run garantit-il que le déploiement réussira ?

Non. Il valide la structure et le rendu des gabarits, sans contacter Dynatrace. Une charge JSON invalide pour l’API peut encore provoquer une erreur HTTP 400 au déploiement réel.

Pourquoi un objet est-il créé en double au lieu d’être mis à jour ?

Pour une API classique, c’est le name qui identifie l’objet. Si le nom du gabarit diffère de celui du YAML (espace ou caractère en trop), Monaco ne retrouve pas l’objet existant. Vérifiez que le gabarit utilise "{{ .name }}" sans rien autour.

Peut-on forcer l’ordre de déploiement ?

Oui, par les dépendances : un paramètre reference impose que la configuration référencée passe d’abord. Pour l’ordre de certains objets Settings 2.0, la documentation décrit aussi un paramètre insertAfter (CLI 2.14.0 ou plus récente).

Vous savez maintenant structurer un projet, relier des configurations, valider à blanc et déployer vers un environnement ciblé. Le module suivant traite des secrets, des environnements multiples et de la commande delete.

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 3 — Export Monaco SaaS : télécharger sa configuration Dynatrace

Module 3 — Export Monaco SaaS : télécharger sa configuration Dynatrace

Next Post
Déploiement Monaco SaaS : projets, gabarits et dry-run

Déploiement Monaco SaaS : projets, gabarits et dry-run

Related Posts