Dynatrace Monaco : la configuration en code, pas à pas

Dynatrace Monaco pas à pas : manifeste, download, profil d’alerte paramétré, dry-run, déploiement en CI et suppression propre, pour SaaS et Managed.
Dynatrace Monaco : la configuration en code, pas à pas

Un profil d’alerte modifié à la main en production, un autre oublié en préproduction, et personne ne sait qui a changé quoi. Dynatrace Monaco (Monitoring as Code) règle ce problème : la configuration de vos environnements vit dans des fichiers YAML et JSON versionnés dans Git, relus en merge request et déployés par la CI comme n’importe quel code.

Pour une équipe SRE, l’enjeu est concret. Une configuration reproductible réduit la dérive entre environnements, rend chaque changement réversible et supprime le toil des réglages à la main répétés sur dix environnements. En cas d’incident, un git log répond à la question « qu’est-ce qui a changé ? » en quelques secondes.

Objectif de ce tutoriel : installer la CLI, télécharger une configuration existante, créer un profil d’alerte paramétré, le déployer à blanc puis pour de bon, et l’intégrer dans un pipeline. Monaco fonctionne avec Dynatrace SaaS et Dynatrace Managed pour les API de configuration classiques et Settings 2.0 ; les objets de la plateforme (workflows, documents, buckets, SLO récents) ne concernent que SaaS.

Dynatrace Monaco : les trois fichiers à connaître

Fichier Rôle
manifest.yaml Déclare les projets (dossiers de configuration) et les environnements cibles, avec leurs URL et le nom des variables qui contiennent les secrets
config.yaml Dans chaque dossier de projet : la liste des configurations, leur type (API classique, schéma Settings 2.0, workflow…) et leurs paramètres
Modèle JSON Le corps de l’objet, avec des variables {{ .nom }} remplacées par les paramètres au déploiement

Ce découpage sépare ce qui change d’un environnement à l’autre (les paramètres) de ce qui ne change pas (le modèle).

Prérequis

  • La CLI monaco 2.x, téléchargée depuis les releases du dépôt Dynatrace/dynatrace-configuration-as-code.
  • Un token API avec les scopes adaptés aux objets gérés : au minimum settings.read et settings.write pour Settings 2.0, ReadConfig et WriteConfig pour les API classiques. En SaaS, un client OAuth ou un platform token pour les objets de la plateforme.
  • Un dépôt Git et un runner CI capable de lire des variables secrètes.

Un token refusé produit des 401 ou 403 peu parlants dans la sortie de Monaco : le guide Automatiser l’administration avec l’API rappelle comment tester un token avant de l’utiliser.

Tutoriel pas à pas

Étape 1 : installer la CLI

# Linux amd64 : remplacez <version> par la dernière release publiée
curl -L -o monaco https://github.com/Dynatrace/dynatrace-configuration-as-code/releases/download/v<version>/monaco-linux-amd64
chmod +x monaco
sudo mv monaco /usr/local/bin/
monaco version

Étape 2 : écrire le manifeste

manifestVersion: 1.0
projects:
  - name: alerting
environmentGroups:
  - name: preprod
    environments:
      - name: preprod
        url:
          type: environment
          value: DT_PREPROD_URL
        auth:
          token:
            name: DT_PREPROD_TOKEN
  - name: prod
    environments:
      - name: prod
        url:
          type: environment
          value: DT_PROD_URL
        auth:
          token:
            name: DT_PROD_TOKEN

Ligne critique : type: environment. La valeur n’est pas l’URL mais le nom de la variable qui la contient. Même logique pour token.name. Le fichier peut donc être commité sans secret. En Managed, l’URL a la forme https://<domaine>/e/<env-id> ; en SaaS, https://<env-id>.live.dynatrace.com.

Étape 3 : partir de l’existant avec download

Plutôt que d’écrire un modèle de zéro, téléchargez un objet existant pour obtenir le bon format :

export DT_PREPROD_URL="https://<env-id>.live.dynatrace.com"
export DT_PREPROD_TOKEN="dt0c01.XXXX"
monaco download --manifest manifest.yaml --environment preprod \
  --settings-schema builtin:alerting.profile \
  --output-folder download

Monaco écrit un dossier de projet avec un config.yaml et un JSON par objet. Il n’extrait que la valeur de l’objet, sans les métadonnées de l’API.

Étape 4 : paramétrer la configuration

Copiez l’objet téléchargé dans alerting/ et remplacez les valeurs propres à l’équipe par des variables. Le config.yaml :

configs:
  - id: profil-equipe-paiement
    type:
      settings:
        schema: builtin:alerting.profile
        scope: environment
    config:
      name: Paiement - production
      template: profil.json
      parameters:
        equipe: paiement

Et le modèle profil.json, simplifié à partir du téléchargement :

{
  "name": "{{ .name }}",
  "severityRules": [
    {
      "severityLevel": "AVAILABILITY",
      "delayInMinutes": 0,
      "tagFilterIncludeMode": "INCLUDE_ALL",
      "tagFilter": ["team:{{ .equipe }}"]
    }
  ],
  "eventFilters": []
}

Le champ name du config.yaml est exposé au modèle comme {{ .name }} ; chaque entrée de parameters l’est sous son propre nom. Gardez les noms de propriétés exactement tels que le download les a produits : c’est le schéma Settings 2.0 qui fait foi. La règle de tag suppose un tagging cohérent, voir Management zones et tagging automatique.

Étape 5 : valider, puis déployer

monaco deploy manifest.yaml --environment preprod --dry-run
monaco deploy manifest.yaml --environment preprod

Le mode --dry-run vérifie la syntaxe, les références et les paramètres sans appeler l’API en écriture. Le déploiement réel crée l’objet ou le met à jour s’il existe déjà : Monaco retrouve l’objet grâce à un identifiant externe dérivé du projet et de l’id de configuration. Relancer la commande ne crée donc pas de doublon.

Étape 6 : brancher la CI

# .gitlab-ci.yml (extrait)
monaco-preprod:
  stage: deploy
  script:
    - monaco deploy manifest.yaml --environment preprod --dry-run
    - monaco deploy manifest.yaml --environment preprod
  rules:
    - if: $CI_COMMIT_BRANCH == "main"

monaco-prod:
  stage: deploy
  script:
    - monaco deploy manifest.yaml --environment prod
  when: manual

Les variables DT_PREPROD_* et DT_PROD_* viennent des secrets du projet CI. La production reste manuelle : un humain valide après avoir vu la préproduction se comporter correctement.

Étape 7 : supprimer proprement

Retirer une entrée de config.yaml ne supprime rien dans Dynatrace. Listez l’objet dans un fichier delete.yaml :

delete:
  - project: alerting
    type: builtin:alerting.profile
    id: profil-equipe-paiement
monaco delete --manifest manifest.yaml --file delete.yaml --environment preprod

Comment vérifier que ça fonctionne

  • La sortie de monaco deploy se termine sans erreur et liste la configuration déployée.
  • Dans l’environnement, ouvrez les réglages des profils d’alerte : le profil « Paiement – production » existe avec la règle attendue.
  • Par l’API, l’objet apparaît sous le schéma :
curl -s -H "Authorization: Api-Token $DT_PREPROD_TOKEN" \
  "$DT_PREPROD_URL/api/v2/settings/objects?schemaIds=builtin:alerting.profile&fields=objectId,value" | jq '.items[].value.name'
  • Relancez monaco deploy : le résultat doit être identique, sans nouvel objet créé.

Bonnes pratiques

  • Une source de vérité : un objet géré par Monaco ne se modifie plus à la main. Annoncez-le, ou mieux, limitez les droits d’écriture dans l’interface.
  • Petits projets : un dossier par domaine (alerting, tagging, détection d’anomalies) et par équipe propriétaire. Les revues restent lisibles.
  • Dry-run systématique en merge request : l’erreur apparaît avant la fusion, pas pendant le déploiement.
  • Détection de dérive : un download planifié comparé au dépôt révèle les changements faits hors Git.
  • Alerting cohérent : les profils déployés doivent rester alignés avec les intégrations de notification, sinon l’alerte part dans le vide.

Questions fréquentes

Monaco fonctionne-t-il avec Dynatrace Managed ?

Oui pour les API de configuration classiques et les objets Settings 2.0, avec un token API. Les types propres à la plateforme SaaS (workflows, documents, buckets Grail) ne s’appliquent pas à Managed.

Monaco ou Terraform ?

Monaco est centré sur Dynatrace, avec un modèle de projets et d’environnements simple à prendre en main. Terraform convient si vos équipes l’utilisent déjà pour le reste de l’infrastructure. L’essentiel est de ne pas gérer le même objet avec les deux outils.

Comment gérer les secrets dans les modèles ?

Déclarez un paramètre de type environment qui lit une variable d’environnement au déploiement. Le secret ne passe jamais par le dépôt Git.

Conclusion

Avec Dynatrace Monaco, la configuration devient du code : un manifeste, des projets, des modèles paramétrés, un dry-run en merge request et un déploiement par la CI. Commencez par un domaine simple comme les profils d’alerte, puis étendez. Chaque changement devient traçable, réversible et identique d’un environnement à l’autre.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Dynatrace est une marque de son propriétaire. Les options de la CLI et les schémas évoluent : vérifiez-les dans la documentation officielle de Monaco.

Total
0
Shares
Laisser un commentaire

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

Previous Post
Pods en CrashLoopBackOff OOMKilled : diagnostiquer avec Dynatrace

Pods en CrashLoopBackOff OOMKilled : diagnostiquer avec Dynatrace

Next Post
Provider Terraform Dynatrace : alerting, management zones et tableaux de bord

Provider Terraform Dynatrace : alerting, management zones et tableaux de bord

Related Posts