Cette page a été traduite par l'API Cloud Translation.

Collecter les journaux Sentry

Compatible avec :

Google SecOps SIEM

Ce document explique comment ingérer des journaux Sentry dans Google Security Operations à l'aide d'Amazon S3. Sentry produit des données opérationnelles sous forme d'événements, de problèmes, de données de surveillance des performances et d'informations de suivi des erreurs. Cette intégration vous permet d'envoyer ces journaux à Google SecOps pour analyse et surveillance. Vous obtenez ainsi une visibilité sur les erreurs d'application, les problèmes de performances et les interactions utilisateur dans vos applications surveillées par Sentry.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

Une instance Google SecOps.
Accès privilégié au locataire Sentry (jeton d'authentification avec des champs d'application d'API).
Accès privilégié à AWS (S3, Identity and Access Management (IAM), Lambda, EventBridge).

Collecter les prérequis Sentry (ID, clés API, ID d'organisation, jetons)

Connectez-vous à Sentry.
Trouvez le slug de votre organisation :
- Accédez à Paramètres> Organisation> Paramètres> ID de l'organisation (le slug s'affiche à côté du nom de l'organisation).
Créez un jeton d'authentification :
- Accédez à Paramètres> Paramètres pour les développeurs> Jetons personnels.
- Cliquez sur Créer.
- Niveaux d'accès (minimum) : org:read, project:read, event:read.
- Copiez la valeur du jeton (affichée une seule fois). Il est utilisé comme suit : Authorization: Bearer <token>.
(Si vous l'hébergez vous-même) Notez votre URL de base (par exemple, https://<your-domain>). Sinon, utilisez https://sentry.io.

Configurer un bucket AWS S3 et IAM pour Google SecOps

Créez un bucket Amazon S3 en suivant ce guide de l'utilisateur : Créer un bucket.
Enregistrez le Nom et la Région du bucket pour référence ultérieure (par exemple, sentry-logs).
Créez un utilisateur en suivant ce guide de l'utilisateur : Créer un utilisateur IAM.
Sélectionnez l'utilisateur créé.
Sélectionnez l'onglet Informations d'identification de sécurité.
Cliquez sur Créer une clé d'accès dans la section Clés d'accès.
Sélectionnez Service tiers comme Cas d'utilisation.
Cliquez sur Suivant.
Facultatif : Ajoutez un tag de description.
Cliquez sur Créer une clé d'accès.
Cliquez sur Télécharger le fichier CSV pour enregistrer la clé d'accès et la clé d'accès secrète pour référence ultérieure.
Cliquez sur OK.
Sélectionnez l'onglet Autorisations.
Cliquez sur Ajouter des autorisations dans la section Règles relatives aux autorisations.
Sélectionnez Ajouter des autorisations.
Sélectionnez Joindre directement des règles.
Recherchez la règle AmazonS3FullAccess.
Sélectionnez la règle.
Cliquez sur Suivant.
Cliquez sur Ajouter des autorisations.

Configurer la stratégie et le rôle IAM pour les importations S3

Dans la console AWS, accédez à IAM > Stratégies.
Cliquez sur Créer une règle > onglet JSON.
Copiez et collez le règlement suivant.

JSON de la règle (remplacez sentry-logs si vous avez saisi un autre nom de bucket) :

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowPutObjects",
      "Effect": "Allow",
      "Action": "s3:PutObject",
      "Resource": "arn:aws:s3:::sentry-logs/*"
    },
    {
      "Sid": "AllowGetStateObject",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::sentry-logs/sentry/events/state.json"
    }
  ]
}

Cliquez sur Suivant > Créer une règle.
Accédez à IAM > Rôles > Créer un rôle > Service AWS > Lambda.
Associez la règle que vous venez de créer.
Nommez le rôle WriteSentryToS3Role, puis cliquez sur Créer un rôle.

Créer la fonction Lambda

Dans la console AWS, accédez à Lambda > Fonctions > Créer une fonction.
Cliquez sur Créer à partir de zéro.
Fournissez les informations de configuration suivantes :

Paramètre Valeur

Nom sentry_to_s3

Durée d'exécution Python 3.13

Architecture x86_64

Rôle d'exécution WriteSentryToS3Role

Paramètre	Valeur
Nom	`sentry_to_s3`
Durée d'exécution	Python 3.13
Architecture	x86_64
Rôle d'exécution	`WriteSentryToS3Role`

Une fois la fonction créée, ouvrez l'onglet Code, supprimez le stub et collez le code suivant (sentry_to_s3.py).

#!/usr/bin/env python3
# Lambda: Pull Sentry project events (raw JSON) to S3 using Link "previous" cursor for duplicate-safe polling

import os, json, time
from urllib.request import Request, urlopen
from urllib.parse import urlencode, urlparse, parse_qs
import boto3

ORG = os.environ["SENTRY_ORG"].strip()
TOKEN = os.environ["SENTRY_AUTH_TOKEN"].strip()
S3_BUCKET = os.environ["S3_BUCKET"]
S3_PREFIX = os.environ.get("S3_PREFIX", "sentry/events/")
STATE_KEY = os.environ.get("STATE_KEY", "sentry/events/state.json")
BASE = os.environ.get("SENTRY_API_BASE", "https://sentry.io").rstrip("/")
MAX_PROJECTS = int(os.environ.get("MAX_PROJECTS", "100"))
MAX_PAGES_PER_PROJECT = int(os.environ.get("MAX_PAGES_PER_PROJECT", "5"))

s3 = boto3.client("s3")
HDRS = {"Authorization": f"Bearer {TOKEN}", "Accept": "application/json", "User-Agent": "chronicle-s3-sentry-lambda/1.0"}

def _get_state() -> dict:
    try:
        obj = s3.get_object(Bucket=S3_BUCKET, Key=STATE_KEY)
        raw = obj["Body"].read()
        return json.loads(raw) if raw else {"projects": {}}
    except Exception:
        return {"projects": {}}

def _put_state(state: dict):
    s3.put_object(Bucket=S3_BUCKET, Key=STATE_KEY, Body=json.dumps(state, separators=(",", ":")).encode("utf-8"))

def _req(path: str, params: dict | None = None):
    url = f"{BASE}{path}"
    if params:
        url = f"{url}?{urlencode(params)}"
    req = Request(url, method="GET", headers=HDRS)
    with urlopen(req, timeout=60) as r:
        data = json.loads(r.read().decode("utf-8"))
        link = r.headers.get("Link")
        return data, link

def _parse_link(link_header: str | None):
    """Return (prev_cursor, prev_has_more, next_cursor, next_has_more)."""
    if not link_header:
        return None, False, None, False
    prev_cursor, next_cursor = None, None
    prev_more, next_more = False, False
    parts = [p.strip() for p in link_header.split(",")]
    for p in parts:
        if "<" not in p or ">" not in p:
            continue
        url = p.split("<", 1)[1].split(">", 1)[0]
        rel = "previous" if 'rel="previous"' in p else ("next" if 'rel="next"' in p else None)
        has_more = 'results="true"' in p
        try:
            q = urlparse(url).query
            cur = parse_qs(q).get("cursor", [None])[0]
        except Exception:
            cur = None
        if rel == "previous":
            prev_cursor, prev_more = cur, has_more
        elif rel == "next":
            next_cursor, next_more = cur, has_more
    return prev_cursor, prev_more, next_cursor, next_more

def _write_page(project_slug: str, payload: object, page_idx: int) -> str:
    ts = time.gmtime()
    key = f"{S3_PREFIX.rstrip('/')}/{time.strftime('%Y/%m/%d', ts)}/sentry-{project_slug}-{page_idx:05d}.json"
    s3.put_object(Bucket=S3_BUCKET, Key=key, Body=json.dumps(payload, separators=(",", ":")).encode("utf-8"))
    return key

def list_projects(max_projects: int):
    projects, cursor = [], None
    while len(projects) < max_projects:
        params = {"cursor": cursor} if cursor else {}
        data, link = _req(f"/api/0/organizations/{ORG}/projects/", params)
        for p in data:
            slug = p.get("slug")
            if slug:
                projects.append(slug)
                if len(projects) >= max_projects:
                    break
        # advance pagination
        _, _, next_cursor, next_more = _parse_link(link)
        cursor = next_cursor if next_more else None
        if not next_more:
            break
    return projects

def fetch_project_events(project_slug: str, start_prev_cursor: str | None):
    # If we have a stored "previous" cursor, poll forward (newer) until no more results.
    # If not (first run), fetch the latest page, then optionally follow "next" (older) for initial backfill up to the limit.
    pages = 0
    total = 0
    latest_prev_cursor_to_store = None

    def _one(cursor: str | None):
        nonlocal pages, total, latest_prev_cursor_to_store
        params = {"cursor": cursor} if cursor else {}
        data, link = _req(f"/api/0/projects/{ORG}/{project_slug}/events/", params)
        _write_page(project_slug, data, pages)
        total += len(data) if isinstance(data, list) else 0
        prev_c, prev_more, next_c, next_more = _parse_link(link)
        # capture the most recent "previous" cursor observed to store for the next run
        latest_prev_cursor_to_store = prev_c or latest_prev_cursor_to_store
        pages += 1
        return prev_c, prev_more, next_c, next_more

    if start_prev_cursor:
        # Poll new pages toward "previous" until no more
        cur = start_prev_cursor
        while pages < MAX_PAGES_PER_PROJECT:
            prev_c, prev_more, _, _ = _one(cur)
            if not prev_more:
                break
            cur = prev_c
    else:
        # First run: start at newest, then (optionally) backfill a few older pages
        prev_c, _, next_c, next_more = _one(None)
        cur = next_c
        while next_more and pages < MAX_PAGES_PER_PROJECT:
            _, _, next_c, next_more = _one(cur)
            cur = next_c

    return {"project": project_slug, "pages": pages, "written": total, "store_prev_cursor": latest_prev_cursor_to_store}

def lambda_handler(event=None, context=None):
    state = _get_state()
    state.setdefault("projects", {})

    projects = list_projects(MAX_PROJECTS)
    summary = []
    for slug in projects:
        start_prev = state["projects"].get(slug, {}).get("prev_cursor")
        res = fetch_project_events(slug, start_prev)
        if res.get("store_prev_cursor"):
            state["projects"][slug] = {"prev_cursor": res["store_prev_cursor"]}
        summary.append(res)

    _put_state(state)
    return {"ok": True, "projects": len(projects), "summary": summary}

if __name__ == "__main__":
    print(lambda_handler())

Accédez à Configuration > Variables d'environnement.
Cliquez sur Modifier > Ajouter une variable d'environnement.

Saisissez les variables d'environnement fournies dans le tableau suivant, en remplaçant les exemples de valeurs par les vôtres.

Variables d'environnement

Clé	Exemple de valeur	Description
`S3_BUCKET`	`sentry-logs`	Nom du bucket S3 dans lequel les données seront stockées.
`S3_PREFIX`	`sentry/events/`	Préfixe S3 facultatif (sous-dossier) pour les objets.
`STATE_KEY`	`sentry/events/state.json`	Clé de fichier d'état/de point de contrôle facultative.
`SENTRY_ORG`	`your-org-slug`	Slug de l'organisation Sentry.
`SENTRY_AUTH_TOKEN`	`sntrys_************************`	Jeton d'authentification Sentry avec les autorisations org:read, project:read et event:read.
`SENTRY_API_BASE`	`https://sentry.io`	URL de base de l'API Sentry (auto-hébergée : `https://<your-domain>`).
`MAX_PROJECTS`	`100`	Nombre maximal de projets à traiter.
`MAX_PAGES_PER_PROJECT`	`5`	Nombre maximal de pages par projet et par exécution.

Une fois la fonction créée, restez sur sa page (ou ouvrez Lambda > Fonctions > votre-fonction).
Accédez à l'onglet Configuration.
Dans le panneau Configuration générale, cliquez sur Modifier.
Définissez le délai avant expiration sur 5 minutes (300 secondes), puis cliquez sur Enregistrer.

Créer une programmation EventBridge

Accédez à Amazon EventBridge> Scheduler> Create schedule.
Fournissez les informations de configuration suivantes :
- Planning récurrent : Tarif (1 hour).
- Cible : votre fonction Lambda sentry_to_s3.
- Nom : sentry-1h.
Cliquez sur Créer la programmation.

(Facultatif) Créez un utilisateur et des clés IAM en lecture seule pour Google SecOps

Dans la console AWS, accédez à IAM > Utilisateurs.
Cliquez sur Add users (Ajouter des utilisateurs).
Fournissez les informations de configuration suivantes :
- Utilisateur : saisissez secops-reader.
- Type d'accès : sélectionnez Clé d'accès – Accès programmatique.
Cliquez sur Créer un utilisateur.
Associez une stratégie de lecture minimale (personnalisée) : Utilisateurs > secops-reader > Autorisations > Ajouter des autorisations > Associer des stratégies directement > Créer une stratégie.

JSON :

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::sentry-logs/*"
    },
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket"],
      "Resource": "arn:aws:s3:::sentry-logs"
    }
  ]
}

Nom = secops-reader-policy.
Cliquez sur Créer une règle> recherchez/sélectionnez > Suivant> Ajouter des autorisations.
Créez une clé d'accès pour secops-reader : Identifiants de sécurité > Clés d'accès.
Cliquez sur Créer une clé d'accès.
Téléchargez le fichier .CSV. (Vous collerez ces valeurs dans le flux.)

Configurer un flux dans Google SecOps pour ingérer les journaux Sentry

Accédez à Paramètres SIEM> Flux.
Cliquez sur + Ajouter un flux.
Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Sentry Logs).
Sélectionnez Amazon S3 V2 comme type de source.
Sélectionnez Sentry comme Type de journal.
Cliquez sur Suivant.
Spécifiez les valeurs des paramètres d'entrée suivants :
- URI S3 : s3://sentry-logs/sentry/events/
- Options de suppression de la source : sélectionnez l'option de suppression de votre choix.
- Âge maximal des fichiers : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.
- ID de clé d'accès : clé d'accès utilisateur ayant accès au bucket S3.
- Clé d'accès secrète : clé secrète de l'utilisateur ayant accès au bucket S3.
- Espace de noms de l'élément : espace de noms de l'élément.
- Libellés d'ingestion : libellé appliqué aux événements de ce flux.
Cliquez sur Suivant.
Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.