Esta página foi traduzida pela API Cloud Translation.

Recolha registos de atividade do Rippling

Compatível com:

Google secops SIEM

Este documento explica como carregar registos de atividade do Rippling para o Google Security Operations através do Amazon S3.

Antes de começar

Certifique-se de que cumpre os seguintes pré-requisitos:

Uma instância do Google SecOps.
Acesso privilegiado ao Rippling (token de API com acesso à atividade da empresa).
Acesso privilegiado à AWS (S3, Identity and Access Management [IAM], Lambda e EventBridge).

Obtenha os pré-requisitos do Rippling

Inicie sessão no Rippling Admin.
Abra Pesquisar > chaves de API.
Caminho alternativo: Definições > Definições da empresa > Tokens da API.
Clique em Criar token de API.
Indique os seguintes detalhes de configuração:
- Nome: indique um nome exclusivo e significativo (por exemplo, Google SecOps S3 Export)
- Versão da API: API base (v1)
- Âmbitos/autorizações: ative company:activity:read (necessário para a Atividade da empresa).
Clique em Criar e guarde o valor do token num local seguro. (Vai usá-lo como um token de autorização).

Configure o contentor do AWS S3 e o IAM para o Google SecOps

Crie um contentor do Amazon S3 seguindo este guia do utilizador: Criar um contentor
Guarde o nome e a região do contentor para referência futura (por exemplo, rippling-activity-logs).
Crie um utilizador seguindo este guia do utilizador: criar um utilizador do IAM.
Selecione o utilizador criado.
Selecione o separador Credenciais de segurança.
Clique em Criar chave de acesso na secção Chaves de acesso.
Selecione Serviço de terceiros como Exemplo de utilização.
Clicar em Seguinte.
Opcional: adicione a etiqueta de descrição.
Clique em Criar chave de acesso.
Clique em Transferir ficheiro CSV para guardar a chave de acesso e a chave de acesso secreta para referência futura.
Clique em Concluído.
Selecione o separador Autorizações.
Clique em Adicionar autorizações na secção Políticas de autorizações.
Selecione Adicionar autorizações.
Selecione Anexar políticas diretamente.
Pesquise a política AmazonS3FullAccess.
Selecione a política.
Clicar em Seguinte.
Clique em Adicionar autorizações.

Configure a política e a função de IAM para carregamentos do S3

Na consola da AWS, aceda a IAM > Políticas.
Clique em Criar política > separador JSON.
Copie e cole a seguinte política.

JSON da política (substitua os valores se tiver introduzido um prefixo ou um contentor diferente):

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

Clique em Seguinte > Criar política.
Aceda a IAM > Funções > Criar função > Serviço AWS > Lambda.
Anexe a política criada recentemente.
Dê o nome WriteRipplingToS3Role à função e clique em Criar função.

Crie a função Lambda

Na consola da AWS, aceda a Lambda > Functions > Create function.
Clique em Criar do zero.
Faculte os seguintes detalhes de configuração:

Definição Valor

Nome rippling_activity_to_s3

Runtime Python 3.13

Arquitetura x86_64

Função de execução WriteRipplingToS3Role

Definição	Valor
Nome	`rippling_activity_to_s3`
Runtime	Python 3.13
Arquitetura	x86_64
Função de execução	`WriteRipplingToS3Role`

Depois de criar a função, abra o separador Código, elimine o stub e cole o seguinte código (rippling_activity_to_s3.py).

#!/usr/bin/env python3
# Lambda: Pull Rippling Company Activity logs to S3 (raw JSON, no transforms)

import os, json, time, urllib.parse
from urllib.request import Request, urlopen
from datetime import datetime, timezone, timedelta
import boto3

API_TOKEN = os.environ["RIPPLING_API_TOKEN"]
ACTIVITY_URL = os.environ.get("RIPPLING_ACTIVITY_URL", "https://api.rippling.com/platform/api/company_activity")
S3_BUCKET = os.environ["S3_BUCKET"]
S3_PREFIX = os.environ.get("S3_PREFIX", "rippling/activity/")
STATE_KEY = os.environ.get("STATE_KEY", "rippling/activity/state.json")

LIMIT = int(os.environ.get("LIMIT", "1000"))
MAX_PAGES = int(os.environ.get("MAX_PAGES", "10"))
LOOKBACK_MINUTES = int(os.environ.get("LOOKBACK_MINUTES", "60"))
END_LAG_SECONDS = int(os.environ.get("END_LAG_SECONDS", "120"))

s3 = boto3.client("s3")

def _headers():
    return {"Authorization": f"Bearer {API_TOKEN}", "Accept": "application/json"}

def _get_state():
    try:
        obj = s3.get_object(Bucket=S3_BUCKET, Key=STATE_KEY)
        j = json.loads(obj["Body"].read())
        return {"since": j.get("since"), "next": j.get("next")}
    except Exception:
        return {"since": None, "next": None}

def _put_state(since_iso, next_cursor):
    body = json.dumps({"since": since_iso, "next": next_cursor}, separators=(",", ":")).encode("utf-8")
    s3.put_object(Bucket=S3_BUCKET, Key=STATE_KEY, Body=body)

def _get(url):
    req = Request(url, method="GET")
    for k, v in _headers().items():
        req.add_header(k, v)
    with urlopen(req, timeout=60) as r:
        return json.loads(r.read().decode("utf-8"))

def _build_url(base, params):
    qs = urllib.parse.urlencode(params)
    return f"{base}?{qs}" if qs else base

def _parse_iso(ts):
    if ts.endswith("Z"):
        ts = ts[:-1] + "+00:00"
    return datetime.fromisoformat(ts)

def _iso_from_epoch(sec):
    return datetime.fromtimestamp(sec, tz=timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")

def _write(payload, run_ts_iso, page_index, source="company_activity"):
    day_path = _parse_iso(run_ts_iso).strftime("%Y/%m/%d")
    key = f"{S3_PREFIX.strip('/')}/{day_path}/{run_ts_iso.replace(':','').replace('-','')}-page{page_index:05d}-{source}.json"
    s3.put_object(Bucket=S3_BUCKET, Key=key, Body=json.dumps(payload, separators=(",", ":")).encode("utf-8"))
    return key

def lambda_handler(event=None, context=None):
    state = _get_state()
    run_end = datetime.now(timezone.utc) - timedelta(seconds=END_LAG_SECONDS)
    end_iso = run_end.replace(microsecond=0).isoformat().replace("+00:00", "Z")

    since_iso = state["since"]
    next_cursor = state["next"]

    if since_iso is None:
        since_iso = _iso_from_epoch(time.time() - LOOKBACK_MINUTES * 60)
    else:
        try:
            since_iso = (_parse_iso(since_iso) + timedelta(seconds=1)).replace(microsecond=0).isoformat().replace("+00:00", "Z")
        except Exception:
            since_iso = _iso_from_epoch(time.time() - LOOKBACK_MINUTES * 60)

    run_ts_iso = end_iso
    pages = 0
    total = 0
    newest_ts = None
    pending_next = None

    while pages < MAX_PAGES:
        params = {"limit": str(LIMIT)}
        if next_cursor:
            params["next"] = next_cursor
        else:
            params["startDate"] = since_iso
            params["endDate"] = end_iso

        url = _build_url(ACTIVITY_URL, params)
        data = _get(url)
        _write(data, run_ts_iso, pages)

        events = data.get("events") or data.get("items") or data.get("data") or []
        total += len(events) if isinstance(events, list) else 0

        if isinstance(events, list):
            for ev in events:
                t = ev.get("timestamp") or ev.get("time") or ev.get("event_time")
                if isinstance(t, str):
                    try:
                        dt_ts = _parse_iso(t)
                        if newest_ts is None or dt_ts > newest_ts:
                            newest_ts = dt_ts
                    except Exception:
                        pass

        nxt = data.get("next") or data.get("next_cursor") or None
        pages += 1

        if nxt:
            next_cursor = nxt
            pending_next = nxt
            continue
        else:
            pending_next = None
            break

    new_since_iso = (newest_ts or run_end).replace(microsecond=0).isoformat().replace("+00:00", "Z")
    _put_state(new_since_iso, pending_next)

    return {"ok": True, "pages": pages, "events": total, "since": new_since_iso, "next": pending_next}

Aceda a Configuração > Variáveis de ambiente.
Clique em Editar > Adicionar nova variável de ambiente.

Introduza as variáveis de ambiente fornecidas na tabela seguinte, substituindo os valores de exemplo pelos seus valores.

Variáveis de ambiente

Chave	Valor de exemplo
`S3_BUCKET`	`rippling-activity-logs`
`S3_PREFIX`	`rippling/activity/`
`STATE_KEY`	`rippling/activity/state.json`
`RIPPLING_API_TOKEN`	`your-api-token`
`RIPPLING_ACTIVITY_URL`	`https://api.rippling.com/platform/api/company_activity`
`LIMIT`	`1000`
`MAX_PAGES`	`10`
`LOOKBACK_MINUTES`	`60`
`END_LAG_SECONDS`	`120`

Depois de criar a função, permaneça na respetiva página (ou abra Lambda > Functions > a sua função).
Selecione o separador Configuração.
No painel Configuração geral, clique em Editar.
Altere Tempo limite para 5 minutos (300 segundos) e clique em Guardar.

Crie um horário do EventBridge

Aceda a Amazon EventBridge > Scheduler > Create schedule.
Indique os seguintes detalhes de configuração:
- Agenda recorrente: Taxa (1 hour).
- Destino: a sua função Lambda rippling_activity_to_s3.
- Nome: rippling-activity-logs-1h.
Clique em Criar programação.

(Opcional) Crie um utilizador e chaves da IAM só de leitura para o Google SecOps

Na consola da AWS, aceda a IAM > Utilizadores > Adicionar utilizadores.
Clique em Adicionar utilizadores.
Indique os seguintes detalhes de configuração:
- Utilizador: introduza secops-reader.
- Tipo de acesso: selecione Chave de acesso – Acesso programático.
Clique em Criar utilizador.
Anexe a política de leitura mínima (personalizada): Users > secops-reader > Permissions > Add permissions > Attach policies directly > Create policy.

JSON:

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

Nome = secops-reader-policy.
Clique em Criar política > procure/selecione > Seguinte > Adicionar autorizações.
Crie uma chave de acesso para secops-reader: Credenciais de segurança > Chaves de acesso.
Clique em Criar chave de acesso.
Transfira o .CSV. (Vai colar estes valores no feed).

Configure um feed no Google SecOps para carregar registos de atividade do Rippling

Aceda a Definições do SIEM > Feeds.
Clique em + Adicionar novo feed.
No campo Nome do feed, introduza um nome para o feed (por exemplo, Rippling Activity Logs).
Selecione Amazon S3 V2 como o Tipo de origem.
Selecione Registos de atividade do Rippling como o Tipo de registo.
Clicar em Seguinte.
Especifique valores para os seguintes parâmetros de entrada:
- URI do S3: s3://rippling-activity-logs/rippling/activity/
- Opções de eliminação de origens: selecione a opção de eliminação de acordo com a sua preferência.
- Idade máxima do ficheiro: inclua ficheiros modificados no último número de dias. A predefinição é 180 dias.
- ID da chave de acesso: chave de acesso do utilizador com acesso ao contentor do S3.
- Chave de acesso secreta: chave secreta do utilizador com acesso ao contentor do S3.
- Espaço de nomes de recursos: rippling.activity
- Opcional: Etiquetas de carregamento: adicione a etiqueta de carregamento.
Clicar em Seguinte.
Reveja a nova configuração do feed no ecrã Finalizar e, de seguida, clique em Enviar.

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