Rétention des logs Auth0 : conformité RGPD, PCI et bonnes pratiques

Configurez la rétention des logs Auth0 pour satisfaire vos obligations légales : streaming vers S3/Datadog, anonymisation des IPs et politique de rétention par réglementation.

Par Auth0.Expert · 2025-06-30 · 10 min de lecture

Logs Rétention RGPD Conformité Auth0

Rétention des logs Auth0 : conformité et bonnes pratiques

TL;DR

Auth0 retient les logs 2 à 30 jours selon le plan. Pour la conformité RGPD (suppression sur demande), PCI-DSS (12 mois accessibles) et SOC2 (13 mois), configurez le Log Streaming vers votre propre infrastructure dès le premier jour.

Limites de rétention Auth0 native

Ce tableau récapitule la durée de conservation des logs selon le plan Auth0, et montre que le Log Streaming n’est disponible qu’à partir du plan Professional.

Plan Auth0 → Rétention des logs :
┌───────────────────┬──────────────┬─────────────────────┐
│ Plan              │ Rétention    │ Log Streaming       │
├───────────────────┼──────────────┼─────────────────────┤
│ Free              │ 2 jours      │ Non disponible      │
│ Developer Pro     │ 7 jours      │ Non disponible      │
│ Professional      │ 30 jours     │ ✅ Disponible       │
│ Enterprise        │ 30 jours     │ ✅ Disponible       │
└───────────────────┴──────────────┴─────────────────────┘

⚠️ Les logs Auth0 natifs ne suffisent JAMAIS pour la conformité !
→ Configurez Log Streaming immédiatement.

Configuration Log Streaming vers S3

Voici comment configurer le streaming des logs Auth0 vers un bucket S3 pour une conservation conforme et centralisée, en appliquant automatiquement du chiffrement et des métadonnées pour la gestion du cycle de vie.

// Auth0 Log Stream vers AWS S3 (archivage long terme)
// Auth0 Dashboard > Log Streams > Create > Amazon S3

const s3StreamConfig = {
  name: "Compliance-Archive-S3",
  type: "amazon-eventbridge",  // Via EventBridge ou directement S3

  // Alternative : webhook vers votre endpoint
  // qui écrit dans S3 avec chiffrement SSE-KMS
};

// Votre endpoint d'ingestion (Lambda)
exports.handler = async (event) => {
  const logs = JSON.parse(event.body);

  const s3Client = new S3Client({ region: "eu-west-1" });

  for (const log of logs.logs) {
    const date = new Date(log.date);
    const key = `auth0-logs/${date.getFullYear()}/${
      String(date.getMonth() + 1).padStart(2, "0")
    }/${String(date.getDate()).padStart(2, "0")}/${log._id}.json`;

    await s3Client.send(new PutObjectCommand({
      Bucket: process.env.COMPLIANCE_BUCKET,
      Key: key,
      Body: JSON.stringify(log),
      // Chiffrement SSE-KMS obligatoire pour PCI/HDS
      ServerSideEncryption: "aws:kms",
      SSEKMSKeyId: process.env.KMS_KEY_ID,
      // Métadonnées pour la gestion du cycle de vie
      Metadata: {
        "log-type": log.type,
        "user-id": log.user_id || "anonymous",
        "retention-class": getRetentionClass(log.type)
      }
    }));
  }

  return { statusCode: 200 };
};

function getRetentionClass(logType) {
  // Différentes classes de rétention selon le type
  const retentionMap = {
    "f": "security-90d",       // Failed login → 90 jours
    "slo": "standard-30d",     // Logout → 30 jours
    "admin": "security-365d",  // Actions admin → 1 an
    "pwd_leak": "security-365d" // Incident sécurité → 1 an
  };

  return retentionMap[logType] || "standard-30d";
}

Ce code reçoit les logs depuis Auth0, les classe dans S3 selon leur type, applique le chiffrement KMS, et facilite le respect des exigences de conservation.

Politique de lifecycle S3

Dans cet exemple, une politique de cycle de vie S3 gère automatiquement l’archivage et la suppression des logs selon leur étiquette de rétention.

{
  "Rules": [
    {
      "Id": "auth0-logs-standard",
      "Filter": { "Tag": { "Key": "retention-class", "Value": "standard-30d" } },
      "Status": "Enabled",
      "Transitions": [
        { "Days": 30, "StorageClass": "GLACIER" }
      ],
      "Expiration": { "Days": 365 }
    },
    {
      "Id": "auth0-logs-security-90d",
      "Filter": { "Tag": { "Key": "retention-class", "Value": "security-90d" } },
      "Status": "Enabled",
      "Transitions": [
        { "Days": 90, "StorageClass": "GLACIER" }
      ],
      "Expiration": { "Days": 365 }
    },
    {
      "Id": "auth0-logs-security-365d",
      "Filter": { "Tag": { "Key": "retention-class", "Value": "security-365d" } },
      "Status": "Enabled",
      "Transitions": [
        { "Days": 90, "StorageClass": "GLACIER_INSTANT_RETRIEVAL" }
      ],
      "Expiration": { "Days": 1095 }
    },
    {
      "Id": "auth0-logs-pci",
      "Filter": { "Prefix": "pci/" },
      "Status": "Enabled",
      "Transitions": [
        { "Days": 90, "StorageClass": "GLACIER_INSTANT_RETRIEVAL" }
      ],
      "Expiration": { "Days": 365 }
    }
  ]
}

Anonymisation des IPs après 30 jours (RGPD)

Voici un exemple de fonction Python pour automatiser l’anonymisation des adresses IP dans les logs S3, conforme au RGPD dès que le délai de 30 jours est dépassé.

# Lambda ou cron : anonymiser les IPs dans les logs archivés
# RGPD : l'IP est une donnée personnelle

import boto3
import json
import ipaddress

def anonymize_ip(ip_str: str) -> str:
    """Anonymiser une IP (supprimer dernier octet)"""
    try:
        ip = ipaddress.ip_address(ip_str)
        if ip.version == 4:
            parts = ip_str.split(".")
            return f"{parts[0]}.{parts[1]}.{parts[2]}.0"
        else:  # IPv6
            # Garder seulement les 4 premiers groupes
            parts = ip.exploded.split(":")
            return ":".join(parts[:4]) + ":0:0:0:0"
    except ValueError:
        return "0.0.0.0"

def anonymize_old_logs(bucket: str, days_threshold: int = 30):
    """
    Anonymiser les IPs dans les logs Auth0 de plus de N jours.
    À exécuter comme Lambda schedule (quotidien).
    """
    s3 = boto3.client("s3", region_name="eu-west-1")

    cutoff = datetime.utcnow() - timedelta(days=days_threshold)

    paginator = s3.get_paginator("list_objects_v2")

    for page in paginator.paginate(Bucket=bucket, Prefix="auth0-logs/"):
        for obj in page.get("Contents", []):
            # Parser la date depuis la clé S3
            # Format: auth0-logs/YYYY/MM/DD/log_id.json
            parts = obj["Key"].split("/")
            try:
                log_date = datetime(int(parts[1]), int(parts[2]), int(parts[3]))
            except (IndexError, ValueError):
                continue

            if log_date > cutoff:
                continue  # Pas encore à anonymiser

            # Récupérer et anonymiser
            response = s3.get_object(Bucket=bucket, Key=obj["Key"])
            log_data = json.loads(response["Body"].read())

            if "ip" in log_data and log_data["ip"] != "anonymized":
                log_data["ip"] = anonymize_ip(log_data["ip"])
                log_data["ip_anonymized_at"] = datetime.utcnow().isoformat()

                s3.put_object(
                    Bucket=bucket,
                    Key=obj["Key"],
                    Body=json.dumps(log_data),
                    ServerSideEncryption="aws:kms"
                )

Ce script parcours automatiquement les fichiers logs de plus de 30 jours, anonymise l’IP et met à jour l’objet dans S3.

Tableau de rétention par réglementation

Ce tableau synthétise les durées minimales recommandées pour la rétention des logs selon les principales réglementations, afin d’assurer conformité et traçabilité.

| Réglementation | Type de log | Durée min | Durée recommandée | |---|---|---|---| | RGPD | Logs connexion | 30 jours | 90 jours | | RGPD | Logs admin | 90 jours | 1 an | | PCI-DSS | Tous logs | 12 mois | 13 mois | | PCI-DSS (accessible) | Tous logs | 3 mois | 3 mois | | SOC2 | Logs sécurité | 13 mois | 13 mois | | NIS2 | Incidents | Durée procédure | 3 ans | | Fiscal (France) | Logs transactions | 10 ans | 10 ans | | HDS | Accès données santé | 10 ans | 10 ans |

Pour appliquer la rétention recommandée, utilisez cette matrice pratique qui détermine pour chaque régime combien de jours la donnée doit rester stockée à chaque niveau.

# Matrice de rétention consolidée
RETENTION_MATRIX = {
    "standard": {
        "hot": 30,      # jours en stockage rapide
        "warm": 90,     # jours en stockage archive accessible
        "cold": 365,    # jours en stockage glacier
        "delete": 365   # supprimer après
    },
    "pci": {
        "hot": 90,
        "warm": 365,
        "cold": None,
        "delete": 365
    },
    "soc2": {
        "hot": 30,
        "warm": 90,
        "cold": 395,    # 13 mois
        "delete": 395
    },
    "hds": {
        "hot": 30,
        "warm": 90,
        "cold": 3650,   # 10 ans
        "delete": 3650
    }
}

Cette matrice facilite la configuration automatisée de vos cycles de vie S3 pour un stockage conforme et économique.

Auth0.Expert configure des pipelines de log streaming conformes à vos obligations réglementaires, avec anonymisation automatique et politique de rétention adaptée.

Autres articles