Recopilar registros de Sentry

Disponible en:

SecOps de Google SIEM

Nota: Esta función está cubierta por los Términos de las Ofertas Previas a la Disponibilidad General de los Términos Específicos del Servicio de Google Security Operations. Las funciones previas a la disponibilidad general pueden tener una asistencia limitada y los cambios que se produzcan en ellas podrían no ser compatibles con otras versiones previas a la disponibilidad general. Para obtener más información, consulta las directrices del servicio de asistencia técnica de Google SecOps y los Términos Específicos de los Servicios de Google SecOps.

En este documento se explica cómo ingerir registros de Sentry en Google Security Operations mediante Amazon S3. Sentry genera datos operativos en forma de eventos, problemas, datos de monitorización del rendimiento e información de seguimiento de errores. Esta integración te permite enviar estos registros a Google SecOps para analizarlos y monitorizarlos, lo que te proporciona visibilidad sobre los errores de las aplicaciones, los problemas de rendimiento y las interacciones de los usuarios en las aplicaciones monitorizadas por Sentry.

Antes de empezar

Asegúrate de que cumples los siguientes requisitos previos:

• Una instancia de Google SecOps.
• Acceso privilegiado al cliente de Sentry (token de autenticación con ámbitos de API).
• Acceso privilegiado a AWS (S3, Gestión de Identidades y Accesos [IAM], Lambda y EventBridge).

Recoger los requisitos previos de Sentry (IDs, claves de API, IDs de organización y tokens)

1. Inicia sesión en Sentry.
2. Busca el slug de tu organización:
   • Ve a Configuración > Organización > Configuración > ID de organización (el slug aparece junto al nombre de la organización).
3. Crea un token de autenticación:
   • Ve a Ajustes > Ajustes para desarrolladores > Tokens personales.
   • Haz clic en Crear.
   • Ámbitos (mínimo): org:read, project:read y event:read.
   • Copia el valor del token (se muestra una vez). Se usa como Authorization: Bearer <token>.
4. Si está alojado por ti mismo, anota tu URL base (por ejemplo, https://<your-domain>). De lo contrario, usa https://sentry.io.

Configurar un segmento de AWS S3 y IAM para Google SecOps

1. Crea un segmento de Amazon S3 siguiendo esta guía de usuario: Crear un segmento.
2. Guarda el nombre y la región del segmento para consultarlos más adelante (por ejemplo, sentry-logs).
3. Crea un usuario siguiendo esta guía: Crear un usuario de gestión de identidades y accesos.
4. Selecciona el Usuario creado.
5. Selecciona la pestaña Credenciales de seguridad.
6. En la sección Claves de acceso, haz clic en Crear clave de acceso.
7. Selecciona Servicio de terceros en Caso práctico.
8. Haz clic en Siguiente.
9. Opcional: añade una etiqueta de descripción.
10. Haz clic en Crear clave de acceso.
11. Haz clic en Descargar archivo CSV para guardar la clave de acceso y la clave de acceso secreta para futuras consultas.
12. Haz clic en Listo.
13. Selecciona la pestaña Permisos.
14. En la sección Políticas de permisos, haz clic en Añadir permisos.
15. Selecciona Añadir permisos.
16. Seleccione Adjuntar políticas directamente.
17. Busca la política AmazonS3FullAccess.
18. Selecciona la política.
19. Haz clic en Siguiente.
20. Haz clic en Añadir permisos.

Configurar la política y el rol de gestión de identidades y accesos para las subidas de S3

1. En la consola de AWS, ve a IAM > Políticas.
2. Haz clic en Crear política > pestaña JSON.
3. Copia y pega la siguiente política.

4. JSON de la política (sustituye sentry-logs si has introducido otro nombre de contenedor):

   {
     "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"
       }
     ]
   }
   

5. Haz clic en Siguiente > Crear política.

6. Ve a IAM > Roles > Crear rol > Servicio de AWS > Lambda.

7. Adjunte la política que acaba de crear.

8. Dale el nombre WriteSentryToS3Role al rol y haz clic en Crear rol.

Crear la función Lambda

1. En la consola de AWS, ve a Lambda > Funciones > Crear función.
2. Haz clic en Crear desde cero.

3. Proporciona los siguientes detalles de configuración:

   Ajuste	Valor
   Nombre	sentry_to_s3
   Tiempo de ejecución	Python 3.13
   Arquitectura	x86_64
   Rol de ejecución	WriteSentryToS3Role

4. Una vez creada la función, abra la pestaña Código, elimine el stub y pegue el siguiente código (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())
   

5. Vaya a Configuración > Variables de entorno.

6. Haz clic en Editar > Añadir nueva variable de entorno.

7. Introduce las variables de entorno que se indican en la siguiente tabla y sustituye los valores de ejemplo por los tuyos.

   Variables de entorno

   Clave	Valor de ejemplo	Descripción
   S3_BUCKET	sentry-logs	Nombre del segmento de S3 en el que se almacenarán los datos.
   S3_PREFIX	sentry/events/	Prefijo de S3 opcional (subcarpeta) para los objetos.
   STATE_KEY	sentry/events/state.json	Clave de archivo de estado o punto de control opcional.
   SENTRY_ORG	your-org-slug	Slug de la organización de Sentry.
   SENTRY_AUTH_TOKEN	sntrys_************************	Token de autenticación de Sentry con org:read, project:read y event:read.
   SENTRY_API_BASE	https://sentry.io	URL base de la API de Sentry (autohospedada: https://<your-domain>).
   MAX_PROJECTS	100	Número máximo de proyectos que se van a procesar.
   MAX_PAGES_PER_PROJECT	5	Número máximo de páginas por proyecto y por ejecución.

8. Una vez creada la función, permanece en su página (o abre Lambda > Funciones > tu-función).

9. Seleccione la pestaña Configuración.

10. En el panel Configuración general, haz clic en Editar.

11. Cambia Tiempo de espera a 5 minutos (300 segundos) y haz clic en Guardar.

Nota: El tiempo de espera es un límite superior estricto, lo que significa que, si la función sigue ejecutándose cuando el temporizador llegue a los 5 minutos, AWS Lambda la finalizará. Si la ejecución es más corta, se completará con normalidad y solo se te cobrará por el tiempo de ejecución real.

Crear una programación de EventBridge

1. Ve a Amazon EventBridge > Scheduler > Create schedule (Amazon EventBridge > Programador > Crear programación).
2. Proporcione los siguientes detalles de configuración:
   • Programación periódica: Precio (1 hour).
   • Destino: tu función Lambda sentry_to_s3.
   • Nombre: sentry-1h.
3. Haz clic en Crear programación.

(Opcional) Crear un usuario y claves de IAM de solo lectura para Google SecOps

1. En la consola de AWS, ve a IAM > Usuarios.
2. Haz clic en Add users (Añadir usuarios).
3. Proporcione los siguientes detalles de configuración:
   • Usuario: introduce secops-reader.
   • Tipo de acceso: selecciona Clave de acceso > Acceso programático.
4. Haz clic en Crear usuario.
5. Asigna una política de lectura mínima (personalizada): Usuarios > secops-reader > Permisos > Añadir permisos > Asignar políticas directamente > Crear política.

6. 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"
       }
     ]
   }
   

7. Nombre = secops-reader-policy.

8. Haz clic en Crear política > busca o selecciona > Siguiente > Añadir permisos.

9. Crea una clave de acceso para secops-reader: Credenciales de seguridad > Claves de acceso.

10. Haz clic en Crear clave de acceso.

11. Descarga la .CSV. (Estos valores se pegarán en el feed).

Configurar un feed en Google SecOps para ingerir registros de Sentry

1. Ve a Configuración de SIEM > Feeds.
2. Haz clic en + Añadir nuevo feed.
3. En el campo Nombre del feed, introduce un nombre para el feed (por ejemplo, Sentry Logs).
4. Selecciona Amazon S3 V2 como Tipo de fuente.
5. Seleccione Sentry como Tipo de registro.
6. Haz clic en Siguiente.
7. Especifique los valores de los siguientes parámetros de entrada:
   • URI de S3: s3://sentry-logs/sentry/events/
   • Opciones de eliminación de la fuente: selecciona la opción de eliminación que prefieras.
   • Antigüedad máxima del archivo: incluye los archivos modificados en los últimos días. El valor predeterminado es 180 días.
   • ID de clave de acceso: clave de acceso de usuario con acceso al bucket de S3.
   • Clave de acceso secreta: clave secreta del usuario con acceso al bucket de S3.
   • Espacio de nombres de recursos: el espacio de nombres de recursos.
   • Etiquetas de ingestión: la etiqueta aplicada a los eventos de este feed.
8. Haz clic en Siguiente.
9. Revise la configuración de la nueva fuente en la pantalla Finalizar y, a continuación, haga clic en Enviar.

¿Necesitas más ayuda? Recibe respuestas de los miembros de la comunidad y de los profesionales de Google SecOps.