OpenPipeline masquage : filtrer, masquer les données sensibles et réduire le coût

OpenPipeline masquage : masquez IP, e-mails et jetons à l’ingestion, supprimez les champs inutiles et écartez les logs de debug pour réduire le coût.
OpenPipeline masquage : filtrer, masquer les données sensibles et réduire le coût

Un développeur ajoute une ligne de debug qui journalise la requête complète : adresse e-mail, adresse IP, jeton d’autorisation. Une semaine plus tard, ces données sont stockées avec 35 jours de rétention, lisibles par toute personne qui a accès aux logs. La réponse tient en deux mots, OpenPipeline, masquage : les données sensibles sont transformées à l’ingestion, avant le stockage dans Grail.

Le même pipeline sert aussi à réduire le coût : supprimer les champs que personne ne lit, écarter les logs de debug d’un environnement de test, envoyer les logs bavards vers un bucket à rétention courte. Pour un SRE, c’est du toil en moins (plus de purge manuelle) et un risque de conformité maîtrisé.

Objectif de ce tutoriel : configurer un pipeline de logs qui masque les IP, les e-mails et les jetons, supprime les champs inutiles et écarte les logs sans valeur, puis vérifier le résultat avec DQL. OpenPipeline repose sur Grail : le contenu vaut pour Dynatrace SaaS. En Dynatrace Managed, le masquage passe par d’autres mécanismes, évoqués dans la FAQ.

Prérequis

  • Un environnement Dynatrace SaaS avec Grail et les droits d’administration d’OpenPipeline.
  • Des logs déjà ingérés (OneAgent, API ou OpenTelemetry) ; voir le module logs et OpenPipeline pour les bases.
  • La liste des données à protéger, validée avec votre DPO : e-mails, IP, jetons, identifiants clients.
  • Un accès à Notebooks pour la vérification.

Comment OpenPipeline traite un log

Un enregistrement entre par une source d’ingestion, est routé vers un pipeline selon une condition DQL, puis traverse des étapes. L’étape de traitement (processing) applique des processeurs dans l’ordre : processeur DQL, suppression de champs, renommage, suppression d’enregistrement. Chaque processeur a une condition de correspondance (matcher) qui limite son action aux enregistrements concernés. Une étape de stockage choisit ensuite le bucket, donc la rétention.

Conséquence pratique : tout ce qui est masqué dans l’étape de traitement n’est jamais écrit en clair dans Grail. Un masquage appliqué plus tard, dans une requête ou un tableau de bord, ne protège rien.

OpenPipeline : masquage des données sensibles pas à pas

Étape 1 : créer un pipeline et sa route

Dans l’écran OpenPipeline, section Logs, créez un pipeline nommé par exemple logs-app-paiement. Ajoutez une route dynamique avec une condition qui sélectionne uniquement les logs visés :

matchesValue(k8s.namespace.name, "paiement")

Commencez par un périmètre étroit : un namespace ou une application. Vous élargirez une fois le résultat vérifié.

Étape 2 : masquer les adresses IP

Ajoutez un processeur DQL dans l’étape de traitement. Pour remplacer toutes les adresses IP présentes dans le message :

fieldsAdd content = replacePattern(content, "IPADDR", "xxx.xxx.xxx.xxx")

Si une adresse est déjà isolée dans un champ et que vous voulez garder le réseau pour l’analyse, tronquez-la plutôt que de l’effacer :

fieldsAdd client.ip = ipMask(client.ip, 24)

ipMask(..., 24) met le dernier octet à zéro : vous savez encore de quel réseau vient le trafic, sans identifier la machine. Adaptez le nom du champ (client.ip ici) à vos données.

Étape 3 : masquer les e-mails

Un deuxième processeur DQL extrait l’adresse, la remplace, puis supprime le champ temporaire :

parse content, "LD ([a-zA-Z0-9.!#$%&*+-/=?^_{|}~]+'@' LD '.' LD):email"
| fieldsAdd content = replaceString(content, email, "[email protected]")
| fieldsRemove email

Matcher conseillé : contains(content, "@"). Le processeur ne s’exécute alors que sur les lignes susceptibles de contenir une adresse, ce qui limite le coût de traitement. Ce motif traite la première adresse de la ligne : testez-le sur vos formats réels avec la fonction d’aperçu du processeur.

Étape 4 : masquer les jetons

Les jetons Bearer finissent souvent dans les logs d’accès. Un motif DPL ciblé les remplace :

fieldsAdd content = replacePattern(content, "'Bearer ' [a-zA-Z0-9._-]+", "Bearer ***")

Validez ce motif dans l’aperçu avec des exemples de vos propres logs : la forme des jetons varie d’un fournisseur d’identité à l’autre.

Étape 5 : supprimer les champs inutiles

Ajoutez un processeur de suppression de champs, ou un processeur DQL :

fieldsRemove http.request.header.cookie, debug.payload

Chaque attribut stocké coûte, et un cookie de session est aussi une donnée sensible. Supprimez ce qui n’a jamais servi dans une requête depuis trois mois.

Étape 6 : écarter les logs sans valeur

Ajoutez un processeur de suppression d’enregistrement (Drop record) avec ce matcher :

matchesValue(loglevel, "DEBUG") and matchesValue(deployment.environment, "test")

Ces lignes ne sont pas stockées. Pour les logs que l’on veut garder mais peu longtemps, préférez l’étape de stockage : assignez-les à un bucket à rétention courte plutôt que de les supprimer.

Comment vérifier que ça fonctionne

Générez quelques lignes de test, attendez une à deux minutes, puis lancez dans un Notebook :

fetch logs, from:now()-30m
| filter k8s.namespace.name == "paiement"
| summarize {
    total = count(),
    ip_masquees = countIf(contains(content, "xxx.xxx.xxx.xxx")),
    emails_masques = countIf(contains(content, "[email protected]")),
    emails_restants = countIf(contains(content, "@") and not contains(content, "[email protected]"))
  }

emails_restants doit valoir zéro. Sinon, affichez ces lignes avec filter pour voir le format qui échappe au motif. Vérifiez aussi qu’aucune ligne DEBUG de l’environnement de test n’apparaît, et que les champs supprimés ont disparu des nouveaux enregistrements. Les logs écrits avant l’activation du pipeline restent inchangés.

Pour suivre l’effet sur le volume ingéré, comparez le nombre de lignes par jour avant et après la mise en place, avec les requêtes de surveillance de l’ingestion des logs.

Bonnes pratiques

  • Masquez au plus tôt : dans l’application si possible, sinon dans le Collector OpenTelemetry, sinon dans OpenPipeline. Plusieurs couches valent mieux qu’une.
  • Testez avec l’aperçu de chaque processeur avant d’activer le pipeline.
  • Restreignez chaque processeur avec un matcher : moins d’enregistrements traités, moins de surprises.
  • Documentez les règles de masquage pour votre DPO, et versionnez la configuration (Monaco ou Terraform).
  • Gardez le contexte utile : masquer un trace_id casserait la corrélation entre logs et traces (voir les logs OpenTelemetry avec trace_id).

Questions fréquentes

Le masquage s’applique-t-il aux logs déjà stockés ?

Non. OpenPipeline agit à l’ingestion. Pour des données déjà stockées, il faut passer par les mécanismes de suppression de données de Grail, décrits dans la documentation.

Comment masquer des données sensibles avec Dynatrace Managed ?

OpenPipeline n’est pas disponible sans Grail. En Managed, utilisez les options de masquage des données sensibles de OneAgent et de la gestion des logs, ou masquez dans le Collector OpenTelemetry avec le processeur transform avant l’envoi.

Supprimer des logs avec Drop record réduit-il vraiment la facture ?

Les enregistrements supprimés ne sont pas stockés ni conservés, ce qui réduit les volumes de rétention et de requête. L’effet exact sur la facture dépend de votre modèle de licence : vérifiez-le avec votre contrat et les événements de consommation.

Conclusion

Quelques processeurs bien ciblés suffisent : replacePattern et ipMask pour les IP, un parse pour les e-mails, un motif pour les jetons, fieldsRemove et Drop record pour le volume. Vérifiez avec DQL, documentez pour la conformité, et la prochaine ligne de debug trop bavarde ne deviendra pas un incident de données.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC. Dynatrace est une marque de son propriétaire. Les noms d’écrans, de processeurs et de fonctions évoluent : vérifiez-les 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
DQL avancé : lookup, join, parse et fonctions de fenêtre

DQL avancé : lookup, join, parse et fonctions de fenêtre

Next Post
Licence DPS Dynatrace : comprendre et maîtriser la consommation

Licence DPS Dynatrace : tarification, rate card et consommation

Related Posts