Coletar registros do Sentry

Compatível com:

Este documento explica como ingerir registros do Sentry no Google Security Operations usando o Amazon S3. O Sentry gera dados operacionais na forma de eventos, problemas, dados de monitoramento de desempenho e informações de rastreamento de erros. Com essa integração, é possível enviar esses registros ao Google SecOps para análise e monitoramento, oferecendo visibilidade sobre erros de aplicativos, problemas de desempenho e interações do usuário nos aplicativos monitorados pelo Sentry.

Antes de começar

Verifique se você tem os pré-requisitos a seguir:

  • Uma instância do Google SecOps.
  • Acesso privilegiado ao locatário do Sentry (token de autenticação com escopos de API).
  • Acesso privilegiado à AWS (S3, Identity and Access Management (IAM), Lambda, EventBridge).

Coletar pré-requisitos do Sentry (IDs, chaves de API, IDs de organização, tokens)

  1. Faça login no Sentry.
  2. Encontre o slug da organização:
    • Acesse Configurações > Organização > Configurações > ID da organização. O slug aparece ao lado do nome da organização.
  3. Crie um token de autenticação:
    • Acesse Configurações > Configurações do desenvolvedor > Tokens pessoais.
    • Clique em Criar nova.
    • Escopos (mínimo): org:read, project:read, event:read.
    • Copie o valor do token (mostrado uma vez). Isso é usado como: Authorization: Bearer <token>.
  4. Se você estiver usando um servidor próprio, anote o URL base (por exemplo, https://<your-domain>). Caso contrário, use https://sentry.io.

Configurar o bucket do AWS S3 e o IAM para o Google SecOps

  1. Crie um bucket do Amazon S3 seguindo este guia do usuário: Como criar um bucket
  2. Salve o Nome e a Região do bucket para referência futura (por exemplo, sentry-logs).
  3. Crie um usuário seguindo este guia: Como criar um usuário do IAM.
  4. Selecione o usuário criado.
  5. Selecione a guia Credenciais de segurança.
  6. Clique em Criar chave de acesso na seção Chaves de acesso.
  7. Selecione Serviço de terceiros como Caso de uso.
  8. Clique em Próxima.
  9. Opcional: adicione uma tag de descrição.
  10. Clique em Criar chave de acesso.
  11. Clique em Fazer o download do arquivo CSV para salvar a chave de acesso e a chave de acesso secreta para referência futura.
  12. Clique em Concluído.
  13. Selecione a guia Permissões.
  14. Clique em Adicionar permissões na seção Políticas de permissões.
  15. Selecione Adicionar permissões.
  16. Selecione Anexar políticas diretamente.
  17. Pesquise a política AmazonS3FullAccess.
  18. Selecione a política.
  19. Clique em Próxima.
  20. Clique em Adicionar permissões

Configurar a política e o papel do IAM para uploads do S3

  1. No console da AWS, acesse IAM > Políticas.
  2. Clique em Criar política > guia JSON.
  3. Copie e cole a política a seguir.

  4. JSON da política (substitua sentry-logs se você tiver inserido um nome de bucket diferente):

    {
  "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. Clique em Próxima > Criar política.

  6. Acesse IAM > Funções > Criar função > Serviço da AWS > Lambda.

  7. Anexe a política recém-criada.

  8. Nomeie a função como WriteSentryToS3Role e clique em Criar função.

Criar a função Lambda

  1. No console da AWS, acesse Lambda > Functions > Create function.
  2. Clique em Criar do zero.

  3. Informe os seguintes detalhes de configuração:

    Configuração Valor
    Nome sentry_to_s3
    Ambiente de execução Python 3.13
    Arquitetura x86_64
    Função de execução WriteSentryToS3Role

  4. Depois que a função for criada, abra a guia Código, exclua o stub e cole o código a seguir (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. Acesse Configuração > Variáveis de ambiente.

  6. Clique em Editar > Adicionar nova variável de ambiente.

  7. Insira as variáveis de ambiente fornecidas na tabela a seguir, substituindo os valores de exemplo pelos seus.

    Variáveis de ambiente

    Chave Valor de exemplo Descrição
    S3_BUCKET sentry-logs Nome do bucket do S3 em que os dados serão armazenados.
    S3_PREFIX sentry/events/ Prefixo do S3 opcional (subpasta) para objetos.
    STATE_KEY sentry/events/state.json Chave opcional do arquivo de estado/checkpoint.
    SENTRY_ORG your-org-slug Slug da organização do Sentry.
    SENTRY_AUTH_TOKEN sntrys_************************ Token de autenticação do Sentry com org:read, project:read, event:read.
    SENTRY_API_BASE https://sentry.io URL base da API Sentry (autohospedado: https://<your-domain>).
    MAX_PROJECTS 100 Número máximo de projetos a serem processados.
    MAX_PAGES_PER_PROJECT 5 Número máximo de páginas por projeto e execução.

  8. Depois que a função for criada, permaneça na página dela ou abra Lambda > Functions > sua-função.

  9. Selecione a guia Configuração.

  10. No painel Configuração geral, clique em Editar.

  11. Mude Tempo limite para 5 minutos (300 segundos) e clique em Salvar.

Criar uma programação do EventBridge

  1. Acesse Amazon EventBridge > Scheduler > Criar programação.
  2. Informe os seguintes detalhes de configuração:
    • Programação recorrente: Taxa (1 hour).
    • Destino: sua função Lambda sentry_to_s3.
    • Nome: sentry-1h.
  3. Clique em Criar programação.

(Opcional) Criar um usuário e chaves do IAM somente leitura para o Google SecOps

  1. No console da AWS, acesse IAM > Usuários.
  2. Clique em Add users.
  3. Informe os seguintes detalhes de configuração:
    • Usuário: insira secops-reader.
    • Tipo de acesso: selecione Chave de acesso — Acesso programático.
  4. Clique em Criar usuário.
  5. Anexe a política de leitura mínima (personalizada): Usuários > secops-reader > Permissões > Adicionar permissões > Anexar políticas diretamente > Criar 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. Name = secops-reader-policy.

  8. Clique em Criar política > pesquisar/selecionar > Próxima > Adicionar permissões.

  9. Crie uma chave de acesso para secops-reader: Credenciais de segurança > Chaves de acesso.

  10. Clique em Criar chave de acesso.

  11. Faça o download do .CSV. Cole esses valores no feed.

Configurar um feed no Google SecOps para ingerir registros do Sentry

  1. Acesse Configurações do SIEM > Feeds.
  2. Clique em + Adicionar novo feed.
  3. No campo Nome do feed, insira um nome para o feed (por exemplo, Sentry Logs).
  4. Selecione Amazon S3 V2 como o Tipo de origem.
  5. Selecione Sentry como o Tipo de registro.
  6. Clique em Próxima.
  7. Especifique valores para os seguintes parâmetros de entrada:
    • URI do S3: s3://sentry-logs/sentry/events/
    • Opções de exclusão de fontes: selecione a opção de exclusão de acordo com sua preferência.
    • Idade máxima do arquivo: inclui arquivos modificados no último número de dias. O padrão é de 180 dias.
    • ID da chave de acesso: chave de acesso do usuário com acesso ao bucket do S3.
    • Chave de acesso secreta: chave secreta do usuário com acesso ao bucket do S3.
    • Namespace do recurso: o namespace do recurso.
    • Rótulos de ingestão: o rótulo aplicado aos eventos deste feed.
  8. Clique em Próxima.
  9. Revise a nova configuração do feed na tela Finalizar e clique em Enviar.

Precisa de mais ajuda? Receba respostas de membros da comunidade e profissionais do Google SecOps.