Mengumpulkan log aktivitas Rippling

Didukung di:

Google SecOps SIEM

Catatan: Fitur ini tercakup dalam Persyaratan Penawaran Pra-GA dari Persyaratan Khusus Layanan Google Security Operations. Fitur pra-GA mungkin memiliki dukungan terbatas, dan perubahan pada fitur pra-GA mungkin tidak kompatibel dengan versi pra-GA lainnya. Untuk mengetahui informasi selengkapnya, lihat Panduan Layanan Dukungan Teknis Google SecOps dan Persyaratan Khusus Layanan Google SecOps.

Dokumen ini menjelaskan cara menyerap log aktivitas Rippling ke Google Security Operations menggunakan Amazon S3.

Sebelum memulai

Pastikan Anda memenuhi prasyarat berikut:

• Instance Google SecOps.
• Akses istimewa ke Rippling (token API dengan akses ke Aktivitas Perusahaan).
• Akses istimewa ke AWS (S3, Identity and Access Management (IAM), Lambda, EventBridge).

Mendapatkan prasyarat Rippling

1. Login ke Admin Rippling.
2. Buka Search > API Tokens.
   Jalur alternatif: Setelan > Setelan Perusahaan > Token API.
3. Klik Create API token.
4. Berikan detail konfigurasi berikut:
   • Nama: Berikan nama yang unik dan bermakna (misalnya, Google SecOps S3 Export)
   • Versi API: Base API (v1)
   • Cakupan/Izin: Aktifkan company:activity:read (diperlukan untuk Aktivitas Perusahaan).
5. Klik Buat dan simpan nilai token di lokasi yang aman. (Anda akan menggunakannya sebagai token pembawa).

Mengonfigurasi bucket AWS S3 dan IAM untuk Google SecOps

1. Buat bucket Amazon S3 dengan mengikuti panduan pengguna ini: Membuat bucket
2. Simpan Name dan Region bucket untuk referensi di masa mendatang (misalnya, rippling-activity-logs).
3. Buat Pengguna dengan mengikuti panduan pengguna ini: Membuat pengguna IAM.
4. Pilih Pengguna yang dibuat.
5. Pilih tab Kredensial keamanan.
6. Klik Create Access Key di bagian Access Keys.
7. Pilih Layanan pihak ketiga sebagai Kasus penggunaan.
8. Klik Berikutnya.
9. Opsional: Tambahkan tag deskripsi.
10. Klik Create access key.
11. Klik Download CSV file untuk menyimpan Access Key dan Secret Access Key untuk referensi di masa mendatang.
12. Klik Selesai.
13. Pilih tab Permissions.
14. Klik Tambahkan izin di bagian Kebijakan izin.
15. Pilih Tambahkan izin.
16. Pilih Lampirkan kebijakan secara langsung.
17. Cari kebijakan AmazonS3FullAccess.
18. Pilih kebijakan.
19. Klik Berikutnya.
20. Klik Add permissions.

Mengonfigurasi kebijakan dan peran IAM untuk upload S3

1. Di konsol AWS, buka IAM > Policies.
2. Klik Buat kebijakan > tab JSON.
3. Salin dan tempel kebijakan berikut.

4. JSON Kebijakan (ganti nilai jika Anda memasukkan bucket atau awalan yang berbeda):

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

5. Klik Berikutnya > Buat kebijakan.

6. Buka IAM > Roles > Create role > AWS service > Lambda.

7. Lampirkan kebijakan yang baru dibuat.

8. Beri nama peran WriteRipplingToS3Role, lalu klik Buat peran.

Buat fungsi Lambda

1. Di Konsol AWS, buka Lambda > Functions > Create function.
2. Klik Buat dari awal.

3. Berikan detail konfigurasi berikut:

   Setelan	Nilai
   Nama	rippling_activity_to_s3
   Runtime	Python 3.13
   Arsitektur	x86_64
   Peran eksekusi	WriteRipplingToS3Role

4. Setelah fungsi dibuat, buka tab Code, hapus stub, dan tempelkan kode berikut (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}
   

5. Buka Configuration > Environment variables.

6. Klik Edit > Tambahkan variabel lingkungan baru.

7. Masukkan variabel lingkungan yang diberikan dalam tabel berikut, dengan mengganti nilai contoh dengan nilai Anda.

   Variabel lingkungan

   Kunci	Nilai contoh
   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

8. Setelah fungsi dibuat, tetap buka halamannya (atau buka Lambda > Functions > your-function).

9. Pilih tab Configuration

10. Di panel General configuration, klik Edit.

11. Ubah Waktu Tunggu menjadi 5 menit (300 detik), lalu klik Simpan.

Catatan: Waktu tunggu adalah batas atas yang ketat, artinya jika fungsi masih berjalan saat timer mencapai 5 menit, AWS Lambda akan menghentikannya. Eksekusi yang lebih singkat akan selesai secara normal; Anda hanya ditagih untuk waktu proses sebenarnya.

Membuat jadwal EventBridge

1. Buka Amazon EventBridge > Scheduler > Create schedule.
2. Berikan detail konfigurasi berikut:
   • Jadwal berulang: Tarif (1 hour).
   • Target: Fungsi Lambda Anda rippling_activity_to_s3.
   • Name: rippling-activity-logs-1h.
3. Klik Buat jadwal.

(Opsional) Buat pengguna & kunci IAM hanya baca untuk Google SecOps

1. Di AWS Console, buka IAM > Users > Add users.
2. Klik Add users.
3. Berikan detail konfigurasi berikut:
   • Pengguna: Masukkan secops-reader.
   • Jenis akses: Pilih Kunci akses — Akses terprogram.
4. Klik Buat pengguna.
5. Lampirkan kebijakan baca minimal (kustom): Pengguna > secops-reader > Izin > Tambahkan izin > Lampirkan kebijakan secara langsung > Buat kebijakan.

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

7. Nama = secops-reader-policy.

8. Klik Buat kebijakan > cari/pilih > Berikutnya > Tambahkan izin.

9. Buat kunci akses untuk secops-reader: Kredensial keamanan > Kunci akses.

10. Klik Create access key.

11. Download .CSV. (Anda akan menempelkan nilai ini ke feed).

Mengonfigurasi feed di Google SecOps untuk memproses Log Aktivitas Rippling

1. Buka Setelan SIEM > Feed.
2. Klik + Tambahkan Feed Baru.
3. Di kolom Nama feed, masukkan nama untuk feed (misalnya, Rippling Activity Logs).
4. Pilih Amazon S3 V2 sebagai Jenis sumber.
5. Pilih Rippling Activity Logs sebagai Log type.
6. Klik Berikutnya.
7. Tentukan nilai untuk parameter input berikut:
   • URI S3: s3://rippling-activity-logs/rippling/activity/
   • Opsi penghapusan sumber: Pilih opsi penghapusan sesuai preferensi Anda.
   • Usia File Maksimum: Menyertakan file yang diubah dalam jumlah hari terakhir. Defaultnya adalah 180 hari.
   • ID Kunci Akses: Kunci akses pengguna dengan akses ke bucket S3.
   • Kunci Akses Rahasia: Kunci rahasia pengguna dengan akses ke bucket S3.
   • Namespace aset: rippling.activity
   • Opsional: Label penyerapan: Tambahkan label penyerapan.
8. Klik Berikutnya.
9. Tinjau konfigurasi feed baru Anda di layar Selesaikan, lalu klik Kirim.

Perlu bantuan lain? Dapatkan jawaban dari anggota Komunitas dan profesional Google SecOps.