Budget d’erreur release gate : bloquer une mise en production avec Dynatrace (SaaS et Managed)

Budget d’erreur release gate : un Workflow Dynatrace calcule le budget restant et bloque le déploiement CI/CD s’il est trop bas, en SaaS et Managed.
Budget d'erreur release gate : bloquer une mise en production avec Dynatrace (SaaS et Managed)

Vendredi, 16 h : une mise en production part alors que le service a déjà consommé 90 % de son error budget du mois. Personne ne l’a vérifié, car l’information vit dans un tableau de bord que le pipeline ne lit pas. Un budget d’erreur release gate règle ce problème : le pipeline CI/CD interroge Dynatrace avant de déployer et s’arrête si le budget est trop bas.

Objectif de ce tutoriel : construire une porte de mise en production qui calcule le budget d’erreur restant d’un service, le compare à un seuil et renvoie un verdict exploitable par votre pipeline. La version Dynatrace SaaS utilise un Workflow avec une tâche DQL et une tâche JavaScript. La version Dynatrace Managed, qui n’a pas d’application Workflows, lit le SLO via l’API v2.

Ce tutoriel suppose un SLO déjà défini. Si ce n’est pas le cas, commencez par les alertes burn rate SLO dans Dynatrace, qui détaillent le calcul du budget.

Le principe d’un budget d’erreur release gate

L’error budget est ce que le SLO autorise à rater. Avec 99,9 % sur 30 jours, le budget vaut 0,1 % des requêtes. Tant qu’il en reste, l’équipe livre. Quand il est presque épuisé, elle ralentit et privilégie la fiabilité. C’est la politique d’error budget décrite dans la littérature SRE.

La porte applique cette politique sans réunion :

  • Budget restant ≥ 25 % : le déploiement continue.
  • Budget restant < 25 % : le déploiement est bloqué, sauf correctif de fiabilité validé par l’astreinte.
  • Burn rate élevé sur la dernière heure : blocage aussi, car un incident est en cours.

Les seuils sont des exemples. Fixez-les avec l’équipe produit et notez-les dans votre politique d’error budget.

Prérequis

  • SaaS : environnement sur Grail, accès à l’application Workflows, permissions de lecture des métriques. Pour lancer le Workflow depuis le CI : un client OAuth ou un platform token avec les droits d’exécution et de lecture des Workflows (portées du type automation:workflows:run et automation:workflows:read ; vérifiez les noms exacts dans la documentation).
  • Managed : un SLO classique existant, un token API avec le scope slo.read, et curl + jq sur l’agent CI.
  • Un service surveillé par OneAgent ou OpenTelemetry, avec du trafic régulier. Pour l’option OpenTelemetry, voir le Collector OpenTelemetry vers Dynatrace.

Étapes dans Dynatrace SaaS

Étape 1 — Écrire la requête DQL du budget

Testez d’abord la requête dans un Notebook. Elle calcule le SLI sur 30 jours, le budget restant et le burn rate de la dernière heure :

timeseries {
    total = sum(dt.service.request.count),
    failures = sum(dt.service.request.failure_count)
  },
  from: now() - 30d,
  filter: { dt.entity.service == "SERVICE-1234567890ABCDEF" }
| fieldsAdd t = arraySum(total), f = arraySum(failures)
| fieldsAdd sli = 100 * (t - f) / t
| fieldsAdd budget_restant = 100 * (1 - (f / t) / 0.001)
| fields sli, budget_restant

Lignes critiques : 0.001 correspond à l’erreur autorisée par un SLO de 99,9 %. budget_restant vaut 100 quand aucune erreur n’a eu lieu et devient négatif quand le budget est dépassé. Pour le burn rate récent, dupliquez la requête avec from: now() - 1h et calculez (f / t) / 0.001. Si vous utilisez déjà un SLO dans l’application Service-Level Objectives, gardez la même définition de SLI pour que la porte et le SLO affichent les mêmes chiffres.

Étape 2 — Créer le Workflow

  1. Ouvrez Workflows et créez un Workflow nommé release-gate-checkout.
  2. Gardez un déclencheur à la demande (on demand) : c’est le pipeline qui le lancera.
  3. Ajoutez une tâche Execute DQL Query nommée budget avec la requête de l’étape 1.
  4. Ajoutez une tâche Run JavaScript nommée verdict, qui dépend de budget.

Code de la tâche verdict :

import { execution } from '@dynatrace-sdk/automation-utils';

const SEUIL = 25; // budget restant minimal en %

export default async function ({ execution_id }) {
  const ex = await execution(execution_id);
  const res = await ex.result('budget');
  const ligne = res.records[0];
  if (!ligne || ligne.budget_restant === null) {
    throw new Error('Aucune donnée : porte fermée par prudence');
  }
  const budget = Number(ligne.budget_restant);
  if (budget < SEUIL) {
    throw new Error(`Budget restant ${budget.toFixed(1)} % < ${SEUIL} % : déploiement bloqué`);
  }
  return { budget, decision: 'go' };
}

Lignes critiques : une exception fait échouer la tâche, donc l’exécution du Workflow. Le pipeline n’a qu’un état à lire. L’absence de données ferme la porte : un SLI muet ne doit jamais valoir un feu vert. La forme exacte du résultat de la tâche DQL peut évoluer ; affichez-le une fois avec console.log(res) pour confirmer le chemin records.

Étape 3 — Appeler la porte depuis le pipeline

Exemple en bash, utilisable dans GitLab CI, GitHub Actions ou Jenkins :

#!/usr/bin/env bash
set -euo pipefail
BASE="https://${DT_ENV}.apps.dynatrace.com/platform/automation/v1"
AUTH="Authorization: Bearer ${DT_PLATFORM_TOKEN}"

EXEC_ID=$(curl -sf -X POST "$BASE/workflows/${WF_ID}/run" \
  -H "$AUTH" -H "Content-Type: application/json" -d '{}' | jq -r '.id')

for i in $(seq 1 30); do
  STATE=$(curl -sf "$BASE/executions/${EXEC_ID}" -H "$AUTH" | jq -r '.state')
  case "$STATE" in
    SUCCESS) echo "Porte ouverte"; exit 0 ;;
    ERROR|CANCELLED) echo "Porte fermée ($STATE)"; exit 1 ;;
  esac
  sleep 10
done
echo "Délai dépassé : porte fermée"; exit 1

Lignes critiques : .id est l’identifiant de l’exécution ; .state passe par RUNNING puis un état final. Vérifiez les chemins et les valeurs d’état dans la documentation Workflows et la référence de l’API Automation. Le délai maximal ferme la porte, là encore par prudence.

Étape équivalente dans Dynatrace Managed

Managed n’a pas Workflows. Le pipeline lit directement le SLO classique via l’API Environment v2 :

SLO=$(curl -sf "https://${DT_DOMAIN}/e/${DT_ENV_ID}/api/v2/slo/${SLO_ID}?timeFrame=CURRENT" \
  -H "Authorization: Api-Token ${DT_API_TOKEN}")
BUDGET=$(echo "$SLO" | jq -r '.errorBudget')
echo "Error budget : $BUDGET"
# errorBudget est exprimé en points de pourcentage du SLI (ex. 0.08 sur une cible de 99,9)
awk -v b="$BUDGET" 'BEGIN { exit !(b >= 0.025) }' || { echo "Porte fermée"; exit 1; }

Le champ errorBudget renvoie la marge entre le SLI et la cible, pas un pourcentage du budget initial. Avec une cible de 99,9, la marge maximale vaut 0,1 : 25 % du budget correspondent donc à 0,025. Confirmez la sémantique du champ et le paramètre timeFrame dans la documentation de l’API SLO pour votre version de cluster.

Comment vérifier que ça fonctionne

  1. Cas passant : lancez le Workflow à la main. L’exécution doit finir en succès, et le résultat de verdict afficher decision: "go" avec le budget.
  2. Cas bloquant : passez temporairement SEUIL à 101. L’exécution doit échouer avec le message « déploiement bloqué », et le script du pipeline sortir avec le code 1.
  3. Cas sans données : remplacez l’identifiant du service par un identifiant inexistant. La porte doit se fermer.
  4. Traçabilité : dans Workflows, l’onglet des exécutions conserve chaque verdict. En Managed, gardez la sortie du job CI.

Rétablissez ensuite les vraies valeurs. Un test qui n’a jamais vu la porte fermée ne prouve rien.

Bonnes pratiques

  • Prévoyez une dérogation explicite (variable de pipeline, approbation manuelle) pour les correctifs de fiabilité : bloquer le correctif d’un incident aggrave le MTTR.
  • Un SLO par parcours utilisateur, pas par microservice. La porte d’un service lit le SLO du parcours qu’il sert.
  • Combinez budget restant et burn rate récent : un budget large ne protège pas d’un incident en cours.
  • Après un blocage, faites une revue blameless : la porte signale un risque, elle ne désigne pas de coupable.
  • Pour des contrôles plus riches (plusieurs objectifs, comparaison avant/après), regardez Site Reliability Guardian dans la documentation, qui répond au même besoin côté SaaS.
  • Gérez vos Workflows comme du code : voir le module Workflows et automatisation.

Questions fréquentes

Pourquoi ne pas lire directement le SLO dans le Workflow SaaS ?

C’est possible si votre SLO expose ses valeurs via DQL ou une action dédiée. La requête explicite a un avantage : le calcul est visible et testable dans un Notebook. Gardez une seule définition du SLI pour éviter deux vérités.

Quel seuil choisir pour bloquer ?

Commencez large (par exemple 25 %) et ajustez après quelques semaines. Un seuil trop strict bloque souvent, et l’équipe finit par contourner la porte.

La porte remplace-t-elle les tests ?

Non. Les tests valident le code livré ; la porte vérifie que le service supporte un nouveau risque. Les deux se complètent.

Conclusion

Un budget d’erreur release gate transforme la politique d’error budget en règle automatique : le pipeline lit Dynatrace et décide. Démarrez avec un service critique et un seuil prudent, testez le cas bloquant, puis étendez aux autres équipes. Pour la culture SRE derrière cette pratique, lisez IA et fiabilité : ce que les SRE doivent savoir.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Dynatrace est une marque de Dynatrace LLC. Les fonctionnalités SaaS évoluent vite : vérifiez leur disponibilité dans votre environnement et dans la documentation officielle.

Total
0
Shares
Laisser un commentaire

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

Previous Post
SLO Dynatrace Terraform : un SLO pour chaque service, généré en masse

SLO Dynatrace Terraform : un SLO pour chaque service, généré en masse

Next Post
OneAgent OpenTelemetry doublons : éviter les spans en double et le contexte cassé

OneAgent OpenTelemetry doublons : éviter les spans en double et le contexte cassé

Related Posts