Fastly Next-Gen WAF-Logs (früher Signal Sciences) erfassen

Unterstützt in:

In diesem Dokument wird beschrieben, wie Sie Fastly Next-Gen WAF-Logs (früher Signal Sciences) mit Google Cloud Storage V2 in Google Security Operations aufnehmen.

Fastly Next-Gen WAF (ehemals Signal Sciences) ist eine cloudbasierte Web Application Firewall, die Bedrohungen für Webanwendungen, APIs und Mikrodienste in Echtzeit erkennt und blockiert. Es verwendet einen signalbasierten Ansatz, um Angriffe wie SQL-Injection, Cross-Site-Scripting, Kontoübernahme und Anwendungsmissbrauch zu erkennen und abzuwehren. Die Signal Sciences REST API bietet programmatischen Zugriff auf Anfragefeeddaten, die detaillierte Informationen zu gekennzeichneten und blockierten Anfragen enthalten.

Hinweis

Folgende Voraussetzungen müssen erfüllt sein:

  • Eine Google SecOps-Instanz
  • Ein Google Cloud -Projekt mit aktivierter Cloud Storage API
  • Berechtigungen zum Erstellen und Verwalten von GCS-Buckets
  • Berechtigungen zum Verwalten von IAM-Richtlinien für GCS-Buckets
  • Berechtigungen zum Erstellen von Cloud Run-Diensten, Pub/Sub-Themen und Cloud Scheduler-Jobs
  • Privilegierter Zugriff auf das Fastly WAF-Dashboard der nächsten Generation mit API-Zugriffsberechtigungen
  • Ein Fastly Next-Gen WAF-Konto mit einem Unternehmensnamen und mindestens einer konfigurierten Website

Google Cloud -Storage-Bucket erstellen

  1. Rufen Sie die Google Cloud Console auf.
  2. Wählen Sie Ihr Projekt aus oder erstellen Sie ein neues.
  3. Rufen Sie im Navigationsmenü Cloud Storage > Buckets auf.
  4. Klicken Sie auf Bucket erstellen.
  5. Geben Sie die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Bucket benennen Geben Sie einen global eindeutigen Namen ein (z. B. sigsci-waf-logs).
    Standorttyp Wählen Sie die Option, die am besten zu Ihren Anforderungen passt (Region, Dual-Region, Multi-Region).
    Standort Wählen Sie den Standort aus (z. B. us-central1).
    Speicherklasse Standard (empfohlen für Logs, auf die häufig zugegriffen wird)
    Zugriffssteuerung Einheitlich (empfohlen)
    Schutztools Optional: Objektversionsverwaltung oder Aufbewahrungsrichtlinie aktivieren
  6. Klicken Sie auf Erstellen.

Fastly Next-Gen WAF API-Anmeldedaten erfassen

API-Zugriffstoken abrufen

  1. Melden Sie sich im Fastly WAF-Dashboard der nächsten Generation an.
  2. Klicken Sie oben rechts auf Ihren Nutzernamen und wählen Sie Mein Profil aus.
  3. Rufen Sie API-Zugriffstokens auf.
  4. Klicken Sie auf API-Zugriffstoken hinzufügen.
  5. Geben Sie einen aussagekräftigen Namen für das Token ein (z. B. Google SecOps Integration).
  6. Klicken Sie auf API-Zugriffstoken erstellen.
  7. Kopieren und speichern Sie die folgenden Details an einem sicheren Ort:

    • API-Token: Der generierte Tokenwert (wird nur einmal angezeigt)
    • E-Mail-Adresse: Die E-Mail-Adresse Ihres Kontos, die für die Authentifizierung verwendet wird.

Namen von Unternehmen und Standorten abrufen

  1. Melden Sie sich im Fastly WAF-Dashboard der nächsten Generation an.
  2. Klicken Sie auf Verwalten > Corp > Corp-Übersicht.
  3. Notieren Sie sich den Kurznamen des Unternehmens, der auf der Seite angezeigt wird (z. B. my_corp).
  4. Gehen Sie zu Verwalten > Websites.
  5. Notieren Sie sich den Kurznamen des Standorts, von dem Sie Logs erfassen möchten (z. B. my_site).

Berechtigungen prüfen

So prüfen Sie, ob das Konto die erforderlichen Berechtigungen hat:

  1. Melden Sie sich im Fastly WAF-Dashboard der nächsten Generation an.
  2. Gehen Sie zu Verwalten > Corp > Corp-Nutzer.
  3. Suchen Sie Ihr Nutzerkonto in der Liste.
  4. Prüfen Sie, ob Sie die Rolle Administrator, Inhaber oder Beobachter haben. Diese Rollen haben den erforderlichen API-Zugriff, um Daten aus dem Anfragefeed abzurufen.
  5. Wenn Ihre Rolle keinen API-Zugriff hat, wenden Sie sich an Ihren Fastly Next-Gen WAF-Administrator, um die entsprechende Rolle zu erhalten.

API-Zugriff testen

  • Testen Sie Ihre Anmeldedaten mit dem Anfragefeed-Endpunkt, den der Collector verwendet. Der Anfragefeed akzeptiert nur from- und until-Werte in vollen Minuten, wobei until mindestens fünf Minuten in der Vergangenheit und from nicht mehr als 24 Stunden in der Vergangenheit liegen darf. Der Test fordert die 10 Minuten an, die vor fünf Minuten endeten:

    SIGSCI_EMAIL="your-email@example.com"
    SIGSCI_TOKEN="your-api-token"
    SIGSCI_CORP="your-corp-name"
    SIGSCI_SITE="your-site-name"
    
    UNTIL=$(( ($(date +%s) - 300) / 60 * 60 ))
    FROM=$(( UNTIL - 600 ))
    curl -sS -o feed-test.json -w "HTTP %{http_code}\n" \
        -H "x-api-user: ${SIGSCI_EMAIL}" \
        -H "x-api-token: ${SIGSCI_TOKEN}" \
        "https://dashboard.signalsciences.net/api/v0/corps/${SIGSCI_CORP}/sites/${SIGSCI_SITE}/feed/requests?from=${FROM}&until=${UNTIL}"
    head -c 500 feed-test.json; echo
    

Wenn die Anmeldedaten funktionieren, beginnt die Ausgabe mit HTTP 200 und feed-test.json enthält ein data-Array, das leer sein kann, wenn die Website in diesen 10 Minuten keine gekennzeichneten Anfragen hatte. HTTP 401 bedeutet, dass die E-Mail-Adresse oder das Token falsch ist. HTTP 400 mit Invalid timestamp param bedeutet, dass der Wert from oder until gegen die oben genannten Einschränkungen verstoßen hat.

Dienstkonto für die Cloud Run-Funktion erstellen

Die Cloud Run-Funktion benötigt ein Dienstkonto mit Berechtigungen zum Schreiben in den GCS-Bucket und zum Aufrufen durch Pub/Sub.

Dienstkonto erstellen

  1. Rufen Sie in der GCP Console die Seite IAM und Verwaltung > Dienstkonten auf.
  2. Klicken Sie auf Dienstkonto erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Name des Dienstkontos: Geben Sie sigsci-waf-collector-sa ein.
    • Beschreibung des Dienstkontos: Geben Sie Service account for Cloud Run function to collect Fastly Next-Gen WAF logs ein.
  4. Klicken Sie auf Erstellen und fortfahren.
  5. Fügen Sie im Abschnitt Diesem Dienstkonto Zugriff auf das Projekt erteilen die folgenden Rollen hinzu:
    1. Klicken Sie auf Rolle auswählen.
    2. Suchen Sie nach Storage Object Admin und wählen Sie die Rolle aus.
    3. Klicken Sie auf + Weitere Rolle hinzufügen.
    4. Suchen Sie nach Cloud Run Invoker und wählen Sie die Rolle aus.
    5. Klicken Sie auf + Weitere Rolle hinzufügen.
    6. Suchen Sie nach Cloud Functions-Aufrufer und wählen Sie die Rolle aus.
  6. Klicken Sie auf Weiter.
  7. Klicken Sie auf Fertig.

Diese Rollen sind erforderlich für:

  • Storage-Objekt-Administrator: Logs in den GCS-Bucket schreiben und Statusdateien verwalten
  • Cloud Run-Aufrufer: Pub/Sub erlauben, die Funktion aufzurufen
  • Cloud Functions-Invoker: Funktionsaufruf zulassen

IAM-Berechtigungen für Cloud Storage-Bucket gewähren

Gewähren Sie dem Dienstkonto Schreibberechtigungen für den GCS-Bucket:

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf den Namen Ihres Buckets (z. B. sigsci-waf-logs).
  3. Wechseln Sie zum Tab Berechtigungen.
  4. Klicken Sie auf Zugriff erlauben.
  5. Geben Sie die folgenden Konfigurationsdetails an:
    • Hauptkonten hinzufügen: Geben Sie die E-Mail-Adresse des Dienstkontos ein (z. B. sigsci-waf-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
    • Rollen zuweisen: Wählen Sie Storage-Objekt-Administrator aus.
  6. Klicken Sie auf Speichern.

Pub/Sub-Thema erstellen

Erstellen Sie ein Pub/Sub-Thema, in dem Cloud Scheduler Nachrichten veröffentlicht und das die Cloud Run-Funktion abonniert.

  1. Wechseln Sie in der GCP Console zu Pub/Sub > Themen.
  2. Klicken Sie auf Thema erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Themen-ID: Geben Sie sigsci-waf-logs-trigger ein.
    • Übernehmen Sie die anderen Einstellungen.
  4. Klicken Sie auf Erstellen.

Cloud Run-Funktion zum Erfassen von Logs erstellen

Die Cloud Run-Funktion wird durch Pub/Sub-Nachrichten von Cloud Scheduler ausgelöst, um Anfragefeeddaten von der Fastly WAF API der nächsten Generation abzurufen und die Logs in GCS zu schreiben.

  1. Rufen Sie in der GCP Console Cloud Run auf.
  2. Klicken Sie auf Funktion schreiben.
  3. Geben Sie im Abschnitt Konfigurieren die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Dienstname sigsci-waf-collector
    Region Wählen Sie die Region aus, die Ihrem GCS-Bucket entspricht (z. B. us-central1).
    Laufzeit Wählen Sie Python 3.12 oder höher aus.
  4. Klicken Sie im Abschnitt Trigger auf Trigger hinzufügen und wählen Sie Pub/Sub-Trigger aus.

  5. Geben Sie im Bereich Eventarc-Trigger die folgenden Konfigurationsdetails an:

    • Triggername: Behalten Sie den generierten Namen bei oder geben Sie einen Namen für den Trigger ein.
    • Triggertyp: Wählen Sie Google-Quellen aus.
    • Ereignisanbieter: Wählen Sie Pub/Sub aus.
    • Ereignistyp: Wählen Sie google.cloud.pubsub.topic.v1.messagePublished aus.
    • Cloud Pub/Sub-Thema auswählen: Wählen Sie das Thema sigsci-waf-logs-trigger aus.
    • Region: Wählen Sie dieselbe Region wie für die Funktion aus.
    • Dienstkonto: Wählen Sie das Dienstkonto sigsci-waf-collector-sa aus.
  6. Klicken Sie auf Trigger speichern.

  7. Im Abschnitt Authentifizierung:

    1. Wählen Sie Authentifizierung erforderlich aus.
    2. Identity and Access Management (IAM) auswählen.
  8. Scrollen Sie zu Container, Netzwerk, Sicherheit und maximieren Sie den Bereich.

  9. Rufen Sie den Tab Sicherheit auf:

    • Dienstkonto: Wählen Sie das Dienstkonto sigsci-waf-collector-sa aus.
  10. Rufen Sie den Tab Container auf:

    1. Klicken Sie auf Variablen und Secrets.
    2. Klicken Sie für jede Umgebungsvariable auf + Variable hinzufügen:
    Variablenname Beispielwert Beschreibung
    GCS_BUCKET sigsci-waf-logs Name des GCS-Buckets
    GCS_PREFIX sigsci-waf Präfix für Logdateien
    STATE_KEY sigsci-waf-state.json Zustandspfad, außerhalb des Logpräfixes
    SIGSCI_EMAIL your-email@example.com E-Mail-Adresse des Fastly Next-Gen WAF API-Nutzers
    SIGSCI_TOKEN your-api-token Fastly Next-Gen WAF API-Zugriffstoken
    SIGSCI_CORP your-corp-name Kurzname des Unternehmens
    SIGSCI_SITE your-site-name Kurzname der Website
    LOOKBACK_HOURS 1 Stunden, die bei der ersten Ausführung erfasst werden sollen (maximal 24)
    WINDOW_MINUTES 10 Minuten an Daten pro Anfrage und pro GCS-Objekt
    MAX_WINDOW_MB 200 Größtes Fenster, das im Arbeitsspeicher gehalten wird; größere Fenster werden aufgeteilt
    RUN_BUDGET_SECONDS 480 Nach dieser Zeit keine neuen Fenster mehr starten
    HTTP_TIMEOUT 60 API-Lesezeitlimit in Sekunden
    MAX_RETRIES 5 Wiederholungsversuche bei HTTP-Antworten 429 und 5xx
  11. Scrollen Sie im Bereich Variablen und Secrets zu Anfragen:

    • Zeitüberschreitung bei Anfrage: Geben Sie 600 Sekunden (10 Minuten) ein.
  12. Wechseln Sie zum Tab Einstellungen:

    • Im Abschnitt Ressourcen:
      • Arbeitsspeicher: Wählen Sie 1 GiB oder mehr aus.
      • CPU: Wählen Sie 1 aus.
  13. Im Abschnitt Versionsskalierung:

    • Mindestanzahl von Instanzen: Geben Sie 0 ein.
    • Maximale Anzahl von Instanzen: Geben Sie 1 ein.
  14. Klicken Sie auf Erstellen.

  15. Warten Sie, bis der Dienst erstellt wurde (1–2 Minuten).

  16. Nachdem der Dienst erstellt wurde, wird der Inline-Code-Editor automatisch geöffnet.

Funktionscode hinzufügen

  1. Geben Sie main in das Feld Einstiegspunkt ein.
  2. Erstellen Sie im Inline-Code-Editor zwei Dateien:

    • main.py:
    import functions_framework
    from google.api_core import exceptions as gcs_exceptions
    from google.cloud import storage
    import json
    import os
    import time
    from datetime import datetime, timedelta, timezone
    from urllib.parse import parse_qs, urlencode, urlsplit
    import urllib3
    
    http = urllib3.PoolManager(retries=False)
    storage_client = storage.Client()
    
    API_HOST = 'https://dashboard.signalsciences.net'
    # The request feed only serves full minutes that ended at least 5 minutes ago
    # and are no older than 24 hours and 5 minutes.
    FEED_DELAY = timedelta(minutes=5)
    FEED_MAX_AGE = timedelta(hours=24)
    RETRY_STATUSES = (429, 500, 502, 503, 504)
    
    class FeedApiError(Exception):
      """The request feed API returned an error that must stop the run."""
    
    class WindowTooLarge(Exception):
      """The records of one window do not fit in MAX_WINDOW_MB."""
    
    @functions_framework.cloud_event
    def main(cloud_event):
      """Fetch the Fastly Next-Gen WAF request feed and write it to GCS, one object per time window."""
      bucket_name = os.environ['GCS_BUCKET']
      prefix = os.environ.get('GCS_PREFIX', 'sigsci-waf').strip('/')
      state_key = os.environ.get('STATE_KEY', 'sigsci-waf-state.json')
      corp = os.environ['SIGSCI_CORP']
      site = os.environ['SIGSCI_SITE']
      headers = {
        'x-api-user': os.environ['SIGSCI_EMAIL'],
        'x-api-token': os.environ['SIGSCI_TOKEN'],
        'Accept': 'application/json',
        'User-Agent': 'GoogleSecOps-SignalSciencesWAFCollector/2.0',
      }
      lookback_hours = int(os.environ.get('LOOKBACK_HOURS', '1'))
      window = timedelta(minutes=int(os.environ.get('WINDOW_MINUTES', '10')))
      max_window_bytes = int(float(os.environ.get('MAX_WINDOW_MB', '200')) * 1024 * 1024)
      http_timeout = int(os.environ.get('HTTP_TIMEOUT', '60'))
      max_retries = int(os.environ.get('MAX_RETRIES', '5'))
      run_budget = int(os.environ.get('RUN_BUDGET_SECONDS', '480'))
    
      feed_path = f'/api/v0/corps/{corp}/sites/{site}/feed/requests'
      bucket = storage_client.bucket(bucket_name)
      state, generation = load_state(bucket, state_key)
      deadline = time.monotonic() + run_budget
    
      now = datetime.now(timezone.utc)
      latest_until = minute_floor(now - FEED_DELAY)
      oldest_from = minute_floor(now) - FEED_MAX_AGE
      start = resume_point(state) or minute_floor(now - timedelta(hours=lookback_hours))
      if start < oldest_from:
        print(f'WARNING: Records from {start.isoformat()} to {oldest_from.isoformat()} are older than '
            f'24 hours and can no longer be read from the request feed. Continuing from {oldest_from.isoformat()}.')
        start = oldest_from
    
      windows_done = 0
      while start < latest_until and time.monotonic() < deadline:
        end = min(start + window, latest_until)
        while True:
          try:
            written = write_window(bucket, prefix, feed_path, headers, start, end,
                        max_window_bytes, http_timeout, max_retries)
            break
          except WindowTooLarge:
            if end - start <= timedelta(minutes=1):
              raise RuntimeError(
                f'The records from {start.isoformat()} to {end.isoformat()} exceed MAX_WINDOW_MB. '
                'Increase MAX_WINDOW_MB and the function memory.')
            end = start + max(timedelta(minutes=1), minute_floor_delta((end - start) / 2))
            print(f'Window too large, retrying with {start.isoformat()} to {end.isoformat()}')
    
        # The window is stored, so the next run starts where this one ended.
        state = {'next_from': int(end.timestamp())}
        generation = save_state(bucket, state_key, state, generation)
        print(f'{start.isoformat()} to {end.isoformat()}: {written}')
        start = end
        windows_done += 1
    
      if start < latest_until:
        print(f'Run time budget reached after {windows_done} windows. The next run continues from {start.isoformat()}.')
      else:
        print(f'Request feed is up to date until {latest_until.isoformat()} ({windows_done} windows).')
    
    def minute_floor(dt):
      return dt.replace(second=0, microsecond=0)
    
    def minute_floor_delta(delta):
      return timedelta(minutes=int(delta.total_seconds() // 60))
    
    def resume_point(state):
      """Where the previous run stopped, or None for the first run."""
      if 'next_from' in state:
        return datetime.fromtimestamp(state['next_from'], tz=timezone.utc)
      if 'last_event_time' in state:
        # State written by the previous version of this function. It recorded the
        # run time, so start 5 minutes earlier to read records it could not see yet.
        return minute_floor(datetime.fromisoformat(state['last_event_time']) - FEED_DELAY)
      return None
    
    def write_window(bucket, prefix, feed_path, headers, start, end, max_window_bytes, timeout, max_retries):
      """Write all records from [start, end) to one GCS object and return a summary."""
      blob_name = (f'{prefix}/{start:%Y/%m/%d}/'
            f'{start:%Y%m%dT%H%M%SZ}_{end:%Y%m%dT%H%M%SZ}.ndjson')
      if bucket.get_blob(blob_name) is not None:
        # A previous run stored this window but did not save the state.
        return f'already stored in {blob_name}'
    
      lines = []
      size = 0
      for record in fetch_feed(feed_path, headers, start, end, timeout, max_retries):
        line = json.dumps(record, ensure_ascii=False).encode('utf-8') + b'\n'
        size += len(line)
        if size > max_window_bytes:
          raise WindowTooLarge()
        lines.append(line)
    
      if not lines:
        return 'no records'
      try:
        # if_generation_match=0 creates the object only if it does not exist.
        bucket.blob(blob_name).upload_from_string(
          b''.join(lines), content_type='application/x-ndjson', if_generation_match=0)
      except gcs_exceptions.PreconditionFailed:
        return f'already stored in {blob_name}'
      return f'wrote {len(lines)} records to gs://{bucket.name}/{blob_name}'
    
    def fetch_feed(feed_path, headers, start, end, timeout, max_retries):
      """Yield every record of the request feed between start and end."""
      query = urlencode({'from': int(start.timestamp()), 'until': int(end.timestamp())})
      page = call_api('GET', f'{API_HOST}{feed_path}?{query}', headers, None, timeout, max_retries)
      while True:
        yield from page.get('data') or []
        next_uri = (page.get('next') or {}).get('uri') or ''
        if not next_uri:
          return
    
        parsed = urlsplit(next_uri)
        cursors = parse_qs(parsed.query).get('next')
        if parsed.scheme or parsed.netloc or parsed.path != feed_path or not cursors:
          raise FeedApiError(f'Unexpected next.uri: {next_uri}')
    
        # Later pages are requested with POST and the decoded next cursor as a form field.
        # The cursor is valid for one minute.
        page = call_api('POST', f'{API_HOST}{parsed.path}', headers,
                {'next': cursors[0]}, timeout, max_retries)
    
    def call_api(method, url, headers, form, timeout, max_retries):
      """Return the decoded JSON response, retrying throttling and server errors."""
      failures = 0
      while True:
        try:
          if form is None:
            response = http.request(method, url, headers=headers,
                        timeout=urllib3.Timeout(connect=10.0, read=timeout))
          else:
            response = http.request(method, url, headers=headers, fields=form, encode_multipart=False,
                        timeout=urllib3.Timeout(connect=10.0, read=timeout))
        except urllib3.exceptions.HTTPError as e:
          response, error = None, str(e)
    
        if response is not None and response.status == 200:
          return json.loads(response.data)
        if response is not None:
          error = f'HTTP {response.status}: {response.data[:500].decode("utf-8", errors="replace")}'
          if response.status not in RETRY_STATUSES:
            raise FeedApiError(error)
    
        failures += 1
        if failures > max_retries:
          raise FeedApiError(f'{error} (after {max_retries} retries)')
        wait = min(30, 2 ** failures)
        retry_after = response.headers.get('Retry-After', '') if response is not None else ''
        if retry_after.isdigit():
          wait = int(retry_after)
        print(f'{error}. Retry {failures}/{max_retries} in {wait}s')
        time.sleep(wait)
    
    def load_state(bucket, key):
      """Return the saved state and its object generation (0 if there is no state yet)."""
      blob = bucket.get_blob(key)
      if blob is None:
        return {}, 0
      return json.loads(blob.download_as_text()), blob.generation
    
    def save_state(bucket, key, state, generation):
      """Save the state only if no other run changed it since it was loaded."""
      blob = bucket.blob(key)
      try:
        blob.upload_from_string(json.dumps(state), content_type='application/json',
                    if_generation_match=generation)
      except gcs_exceptions.PreconditionFailed:
        raise RuntimeError(f'{key} was changed by another run; stopping to avoid duplicate collection.')
      return blob.generation
    
    • requirements.txt:
    functions-framework==3.*
    google-cloud-storage==2.*
    urllib3>=2.0.0
    
  3. Klicken Sie auf Bereitstellen, um die Funktion zu speichern und bereitzustellen.

  4. Warten Sie, bis die Bereitstellung abgeschlossen ist (2–3 Minuten).

Cloud Scheduler-Job erstellen

Cloud Scheduler veröffentlicht in regelmäßigen Abständen Nachrichten im Pub/Sub-Thema und löst so die Cloud Run-Funktion aus.

  1. Rufen Sie in der GCP Console Cloud Scheduler auf.
  2. Klicken Sie auf Job erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:

    Einstellung Wert
    Name sigsci-waf-collector-hourly
    Region Wählen Sie dieselbe Region wie für die Cloud Run-Funktion aus.
    Frequenz 5 * * * * (jede Stunde, fünf Minuten nach der vollen Stunde)
    Zeitzone Zeitzone auswählen (UTC empfohlen)
    Zieltyp Pub/Sub
    Thema Wählen Sie das Thema sigsci-waf-logs-trigger aus.
    Inhalt der Nachricht {} (leeres JSON-Objekt)
  4. Klicken Sie auf Erstellen.

Optionen für die Häufigkeit des Zeitplans

Der Anfragefeed wird jede Minute ab fünf Minuten nach dem Ende bis 24 Stunden später bereitgestellt. Bei jeder Ausführung werden alle Daten ab dem Zeitpunkt erfasst, an dem die vorherige Ausführung beendet wurde, bis zu fünf Minuten vor dem aktuellen Zeitpunkt. Ein kürzeres Intervall verringert also nur die Latenz. Führen Sie den Job mindestens einmal pro Stunde aus: Wenn die Funktion länger als 24 Stunden angehalten wird, können die Datensätze, die älter als 24 Stunden sind, nicht mehr erfasst werden.

Häufigkeit Cron-Ausdruck Anwendungsfall
Alle 5 Minuten */5 * * * * Hohes Volumen, niedrige Latenz
Alle 15 Minuten */15 * * * * Mittleres Suchvolumen
Stündlich 5 * * * * Standard (empfohlen)

Integration testen

  1. Suchen Sie in der Cloud Scheduler-Konsole nach Ihrem Job.
  2. Klicken Sie auf Ausführung erzwingen, um den Job manuell auszulösen.
  3. Warte einige Sekunden.
  4. Rufen Sie Cloud Run > Dienste auf.
  5. Klicken Sie auf sigsci-waf-collector.
  6. Klicken Sie auf den Tab Logs.
  7. Prüfen Sie, ob die Funktion erfolgreich ausgeführt wurde. Suchen Sie nach Zeilen wie den folgenden, eine pro 10-Minuten-Fenster:

    2026-01-15T09:00:00+00:00 to 2026-01-15T09:10:00+00:00: wrote 42 records to gs://sigsci-waf-logs/sigsci-waf/2026/01/15/20260115T090000Z_20260115T091000Z.ndjson
    2026-01-15T09:10:00+00:00 to 2026-01-15T09:20:00+00:00: no records
    Request feed is up to date until 2026-01-15T10:00:00+00:00 (6 windows).
    
  8. Rufen Sie Cloud Storage > Buckets auf.

  9. Klicken Sie auf den Namen Ihres Buckets (sigsci-waf-logs).

  10. Rufen Sie den Ordner sigsci-waf/ auf.

  11. Prüfen Sie, ob .ndjson-Dateien im Ordner YYYY/MM/DD/ erstellt wurden. Jeder Dateiname enthält den Anfang und das Ende des Fensters.

Wenn die Funktion fehlschlägt, wird die Ausführung beendet, ohne den Status zu speichern. Bei der nächsten Ausführung wird dasselbe Fenster noch einmal erfasst. Suchen Sie in den Logs nach:

  • HTTP 401: Prüfen Sie die API-E-Mail-Adresse und das Token in den Umgebungsvariablen.
  • HTTP 403: Prüfen Sie, ob das Konto im Fastly Next-Gen WAF-Dashboard die Rolle „Admin“, „Owner“ oder „Observer“ hat.
  • HTTP 400 Invalid timestamp param: Der Wert from oder until hat die Einschränkungen für den Anfragefeed verletzt. Prüfen Sie, ob der Funktionscode mit dieser Seite übereinstimmt.
  • HTTP 429, 500, 502, 503 oder 504: Die Funktion versucht es bis zu MAX_RETRIES-mal und bricht dann ab. Bei der nächsten Ausführung wird das Fenster noch einmal versucht.
  • can no longer be read from the request feed: Die Funktion wurde länger als 24 Stunden nicht ausgeführt. Einträge, die älter als 24 Stunden sind, sind im Anfragefeed nicht mehr verfügbar.
  • exceed MAX_WINDOW_MB: Die Datensätze einer Minute sind größer als MAX_WINDOW_MB. Erhöhen Sie MAX_WINDOW_MB und den Funktionsspeicher.
  • was changed by another run: Zwei Ausführungen haben sich überschnitten. Prüfen Sie, ob die Maximale Anzahl von Instanzen 1 ist.
  • KeyError: Eine erforderliche Umgebungsvariable fehlt.

Feed in Google SecOps konfigurieren, um Fastly Next-Gen WAF-Logs aufzunehmen

  1. Rufen Sie die Einstellungen > Datenverwaltung > Feeds auf. Wenn Sie eine reine SIEM-Plattform verwenden, rufen Sie die Einstellungen > Feeds auf.
  2. Klicken Sie auf Neuen Feed hinzufügen.
  3. Klicken Sie auf Einzelnen Feed konfigurieren.
  4. Geben Sie im Feld Feedname einen Namen für den Feed ein, z. B. Signal Sciences WAF Logs.
  5. Wählen Sie Google Cloud Storage V2 als Quelltyp aus.
  6. Wählen Sie Signal Sciences WAF als Logtyp aus.
  7. Klicken Sie auf Dienstkonto abrufen. Eine eindeutige E-Mail-Adresse für das Dienstkonto wird angezeigt, z. B.:

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
    
  8. Kopieren Sie diese E-Mail-Adresse.

  9. Klicken Sie auf Weiter.

  10. Geben Sie Werte für die folgenden Eingabeparameter an:

    • Storage-Bucket-URL: Geben Sie den GCS-Bucket-URI mit dem Präfixpfad ein:

      gs://sigsci-waf-logs/sigsci-waf/
      
      • Ersetzen Sie:
        • sigsci-waf-logs: Der Name Ihres GCS-Buckets.
        • sigsci-waf: Optionaler Präfix-/Ordnerpfad, in dem Logs gespeichert werden (leer lassen für Stammverzeichnis).
    • Option zum Löschen der Quelle: Wählen Sie die gewünschte Löschoption aus:

      • Dateien nie löschen: Dateien werden nie aus der Quelle gelöscht (empfohlen für Tests).
      • Übertragene Dateien und leere Verzeichnisse löschen: Dateien und leere Verzeichnisse werden nach einem erfolgreichen Abruf aus der Quelle gelöscht.
    • Maximales Dateialter: Dateien einschließen, die in den letzten Tagen geändert wurden (Standardwert: 180 Tage)

    • Asset-Namespace: Der Asset-Namespace

    • Labels für Datenaufnahme: Das Label, das auf die Ereignisse aus diesem Feed angewendet werden soll.

  11. Klicken Sie auf Weiter.

  12. Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

Dem Google SecOps-Dienstkonto IAM-Berechtigungen gewähren

Das Google SecOps-Dienstkonto benötigt zwei Rollen für Ihren GCS-Bucket: Storage-Objekt-Betrachter zum Lesen der Logobjekte und eine Rolle auf Bucket-Ebene zum Lesen der Bucket-Metadaten.

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf den Namen Ihres Buckets.
  3. Wechseln Sie zum Tab Berechtigungen.
  4. Klicken Sie auf Zugriff erlauben.
  5. Geben Sie die folgenden Konfigurationsdetails an:
    • Hauptkonten hinzufügen: Fügen Sie die E‑Mail-Adresse des Google SecOps-Dienstkontos ein.
    • Rollen zuweisen: Wählen Sie die beiden folgenden Rollen aus:
      • Storage-Objekt-Betrachter: Liest die Logobjekte.
      • Storage Legacy Bucket Reader: Liest die Bucket-Metadaten. Wenn Sie die Löschoption Übertragene Dateien und leere Verzeichnisse löschen ausgewählt haben, wählen Sie stattdessen Storage Legacy Bucket Writer aus. Dadurch wird auch die Löschberechtigung gewährt.
  6. Klicken Sie auf Speichern.

UDM-Zuordnungstabelle

Logfeld UDM-Zuordnung Logik
message_data metadata.description Direkt zugeordnet
created metadata.event_timestamp Geparst als ISO8601
timestamp metadata.event_timestamp Geparst als RFC3339
event_type metadata.event_type Direkt zugeordnet
has_target metadata.event_type Zugeordnet: true → NETWORK_HTTP, false → STATUS_UPDATE
label metadata.ingestion_labels Zusammengeführt
eventType metadata.product_event_type Direkt zugeordnet
proto network.application_protocol Zugeordnet: HTTP/1.1 → HTTP
protocol network.application_protocol Zugeordnet: HTTP/1.1 → HTTP
details.method network.http.method Direkt zugeordnet
method network.http.method Direkt zugeordnet
details.uri network.http.referral_url Direkt zugeordnet
msgData.detailLink network.http.referral_url Direkt zugeordnet
uri network.http.referral_url Direkt zugeordnet
respcode network.http.response_code Umbenannt/zugeordnet
responseCode network.http.response_code Umbenannt/zugeordnet
details.userAgent network.http.user_agent Direkt zugeordnet
msgData.sites network.http.user_agent Direkt zugeordnet
userAgent network.http.user_agent Direkt zugeordnet
resSize network.received_bytes Umbenannt/zugeordnet
responseSize network.received_bytes Umbenannt/zugeordnet
details.tlsCipher network.tls.cipher Direkt zugeordnet
tlsCipher network.tls.cipher Direkt zugeordnet
O network.tls.client.certificate.issuer Umbenannt/zugeordnet
details.tlsProtocol network.tls.version Direkt zugeordnet
tlsProtocol network.tls.version Direkt zugeordnet
details.serverHostname principal.asset.hostname Direkt zugeordnet
serverHostname principal.asset.hostname Direkt zugeordnet
details.serverName principal.asset.network_domain Direkt zugeordnet
serverName principal.asset.network_domain Direkt zugeordnet
details.serverHostname principal.hostname Direkt zugeordnet
serverHostname principal.hostname Direkt zugeordnet
details.id principal.process.pid Direkt zugeordnet
id principal.process.pid Direkt zugeordnet
security_result_headin security_result Zusammengeführt
security_result_headout security_result Zusammengeführt
security_result_tag security_result Zusammengeführt
sec_res_headOut security_result.about.resource.attribute.labels Zusammengeführt
sec_res_headin security_result.about.resource.attribute.labels Zusammengeführt
security_result_action security_result.action Zusammengeführt
msgData.conditions security_result.description Direkt zugeordnet
detector_field security_result.detection_fields Zusammengeführt
link_field security_result.detection_fields Zusammengeführt
location_field security_result.detection_fields Zusammengeführt
redaction_field security_result.detection_fields Zusammengeführt
type_field security_result.detection_fields Zusammengeführt
value_field security_result.detection_fields Zusammengeführt
msgData.reason security_result.summary Direkt zugeordnet
details.remoteHostname target.asset.hostname Direkt zugeordnet
remoteHostname target.asset.hostname Direkt zugeordnet
remoteIP target.asset.ip Zusammengeführt
target_ip target.asset.ip Zusammengeführt
details.remoteHostname target.hostname Direkt zugeordnet
remoteHostname target.hostname Direkt zugeordnet
remoteIP target.ip Zusammengeführt
target_ip target.ip Zusammengeführt
client_port target.port Direkt zugeordnet
changes_label target.resource.attribute.labels Zusammengeführt
msgData.name target.resource.name Direkt zugeordnet
URI target.url Direkt zugeordnet
username target.user.user_display_name Direkt zugeordnet
userid target.user.userid Direkt zugeordnet
– metadata.event_type Konstante: NETWORK_HTTP
– metadata.product_name Konstante: Signal Sciences WAF
– metadata.vendor_name Konstante: Signal Sciences
– network.application_protocol Konstante: HTTP

Benötigen Sie weitere Hilfe? Antworten von Community-Mitgliedern und Google SecOps-Experten erhalten