Druva-Sicherungsprotokolle erfassen

Parserversion: 2.0

Unterstützt in:

In diesem Dokument wird beschrieben, wie Sie Druva Backup-Logs erfassen. Dazu richten Sie eine Google Cloud Run-Funktion ein, die Ereignisse aus der Druva REST API abruft und in einen Google Cloud Storage-Bucket schreibt. Anschließend konfigurieren Sie einen Google Security Operations-Feed mit Google Cloud Storage V2.

Druva ist eine cloudnative Plattform für Datenschutz und Datenverwaltung, die Dienste für Sicherung, Notfallwiederherstellung und Archivierung für Endpunkte, SaaS-Anwendungen und Unternehmensarbeitslasten bietet. Die Plattform generiert umfassende Audit-Trails, Sicherungsereignisse, Wiederherstellungsaktivitäten und Sicherheitswarnungen, die zur Überwachung und Compliance in SIEM-Lösungen eingebunden werden können.

Hinweis

Prüfen Sie, ob folgende Voraussetzungen erfüllt sind:

  • Eine Google SecOps-Instanz
  • Ein Google Cloud-Projekt mit aktivierter Abrechnung
  • Die folgenden Google Cloud APIs sind aktiviert:
    • Cloud Run Functions API
    • Cloud Scheduler API
    • Cloud Storage API
    • Pub/Sub API
    • IAM API
  • Druva Cloud-Administratorzugriff auf die Druva Cloud Platform Console
  • Zugriff auf das Druva Integration Center zum Erstellen von API-Anmeldedaten

Google Cloud Storage-Bucket erstellen

  1. Öffnen Sie die Google Cloud Console.
  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. druva-backup-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, der Ihrer Google SecOps-Instanz am nächsten liegt (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.

Druva API-Anmeldedaten erfassen

Damit die Cloud Run-Funktion Ereignisse von Druva abrufen kann, müssen Sie API-Anmeldedaten mit OAuth 2.0-Authentifizierung erstellen.

API-Anmeldedaten erstellen

  1. Melden Sie sich in der Druva Cloud Platform Console an.
  2. Wählen Sie im Menü Globale Navigation die Option Integration Center aus.
  3. Klicken Sie im linken Bereich auf API-Anmeldedaten.
  4. Klicken Sie auf Neue Anmeldedaten.
  5. Geben Sie im Fenster Neue Anmeldedaten die folgenden Details ein: Name: Geben Sie einen aussagekräftigen Namen ein (z. B. Google SecOps Cloud Storage Integration).
  6. So wenden Sie Autorisierungseinschränkungen an:
    1. Wählen Sie Druva Cloud Administrator aus, um vollen Zugriff auf den Datenabruf und die Datenänderung zu gewähren.
    2. Alternativ können Sie Product Administrator auswählen und Folgendes festlegen: Cloud Admin (Lesezugriff) role: Damit wird der Zugriff auf das Abrufen von Daten beschränkt und es werden keine Änderungsrechte gewährt (empfohlen für die SIEM-Integration).
  7. Klicken Sie auf Speichern.

API-Anmeldedaten aufzeichnen

Nachdem Sie die API-Anmeldedaten erstellt haben, wird das Fenster Anmeldedatendetails angezeigt:

  1. Klicken Sie neben Client-ID auf das Symbol zum Kopieren, um den Wert in die Zwischenablage zu kopieren.
  2. Speichern Sie die Client-ID sicher (z. B. McNkxxxx4Vicxxxx4Ldpxxxx/09Uxxxx).
  3. Klicken Sie neben Geheimer Schlüssel auf das Symbol zum Kopieren, um den Wert in die Zwischenablage zu kopieren.

  4. Speichern Sie den geheimen Schlüssel sicher (z. B. Xmcxxxx8j5xxxx6NxxxxRbRxxxxNNyPt).

Dienstkonto erstellen

Erstellen Sie ein dediziertes Dienstkonto für die Cloud Run-Funktion, um auf Google Cloud Storage zuzugreifen.

  1. Rufen Sie in der Google Cloud Console die Seite IAM und Verwaltung > Dienstkonten auf.
  2. Klicken Sie auf Dienstkonto erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Dienstkontoname: Geben Sie druva-backup-function (oder einen aussagekräftigen Namen) ein.
    • Beschreibung des Dienstkontos: Geben Sie Service account for Druva Backup Cloud Run function 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 und wählen Sie Storage Object Admin aus.
    2. Klicken Sie auf Weitere Rolle hinzufügen und wählen Sie Cloud Run Invoker aus.
  6. Klicken Sie auf Weiter.
  7. Klicken Sie auf Fertig.

  8. Notieren Sie sich die E-Mail-Adresse des Dienstkontos (z. B. druva-backup-function@PROJECT_ID.iam.gserviceaccount.com).

Pub/Sub-Thema erstellen

Erstellen Sie ein Pub/Sub-Thema, das von Cloud Scheduler zum Auslösen der Cloud Run-Funktion verwendet wird.

  1. Rufen Sie in der Google Cloud Console Pub/Sub > Themen auf.
  2. Klicken Sie auf Thema erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Themen-ID: Geben Sie druva-backup-trigger ein.
  4. Entfernen Sie das Häkchen bei Standardabo hinzufügen.

  5. Klicken Sie auf Erstellen.

Cloud Run-Funktion erstellen

Funktionscode vorbereiten

Erstellen Sie eine Cloud Run-Funktion, die sich mit OAuth 2.0-Clientanmeldedaten bei der Druva API authentifiziert, Ereignisse über den Ereignisendpunkt mit Paginierung abruft und die Ergebnisse als NDJSON in den GCS-Bucket schreibt.

Cloud Run-Funktion bereitstellen

  1. Rufen Sie in der Google Cloud Console die Seite Cloud Run-Funktionen auf.
  2. Klicken Sie auf Funktion erstellen.

  3. Geben Sie die folgenden Konfigurationsdetails an:

    • Umgebung: Wählen Sie 2. Generation aus.
    • Funktionsname: Geben Sie druva-backup-to-gcs ein.
    • Region: Wählen Sie die Region aus, die Ihrem GCS-Bucket am nächsten liegt (z. B. us-central1).
    • Triggertyp: Wählen Sie Cloud Pub/Sub aus.
    • Cloud Pub/Sub-Thema: Wählen Sie druva-backup-trigger aus.
    • Dienstkonto: Wählen Sie druva-backup-function@PROJECT_ID.iam.gserviceaccount.com aus.
    • Zugewiesener Arbeitsspeicher: 512 MiB
    • Zeitüberschreitung: 540 Sekunden
    • Maximale Anzahl von Instanzen: 1

  4. Klicken Sie auf Weiter.

  5. Wählen Sie Python 3.11 als Laufzeit aus.

  6. Legen Sie für Einstiegspunkt den Wert main fest.

  7. Ersetzen Sie im Quellcode-Editor den Inhalt von main.py durch Folgendes:

    import base64
import json
import os
import time
from datetime import datetime, timezone, timedelta

import requests
from google.cloud import storage

GCS_BUCKET = os.environ["GCS_BUCKET"]
GCS_PREFIX = os.environ.get("GCS_PREFIX", "druva_backup")
STATE_KEY = os.environ.get("STATE_KEY", "druva_state.json")
DRUVA_BASE_URL = os.environ.get("DRUVA_BASE_URL", "apis.druva.com")
CLIENT_ID = os.environ["CLIENT_ID"]
CLIENT_SECRET = os.environ["CLIENT_SECRET"]
MAX_RECORDS = int(os.environ.get("MAX_RECORDS", "10000"))
PAGE_SIZE = int(os.environ.get("PAGE_SIZE", "500"))
LOOKBACK_HOURS = int(os.environ.get("LOOKBACK_HOURS", "24"))

def get_oauth_token():
    """Obtain OAuth 2.0 access token using client credentials grant."""
    token_url = f"https://{DRUVA_BASE_URL}/token"
    payload = {
        "grant_type": "client_credentials",
        "scope": "read",
    }
    resp = requests.post(
        token_url,
        data=payload,
        auth=(CLIENT_ID, CLIENT_SECRET),
        timeout=30,
    )
    resp.raise_for_status()
    return resp.json()["access_token"]

def load_state(storage_client):
    """Load the persisted state (last event time and tracker) from GCS."""
    bucket = storage_client.bucket(GCS_BUCKET)
    blob = bucket.blob(f"{GCS_PREFIX}/{STATE_KEY}")
    if blob.exists():
        return json.loads(blob.download_as_text())
    return {}

def save_state(storage_client, state):
    """Persist state to GCS."""
    bucket = storage_client.bucket(GCS_BUCKET)
    blob = bucket.blob(f"{GCS_PREFIX}/{STATE_KEY}")
    blob.upload_from_string(
        json.dumps(state),
        content_type="application/json",
    )

def fetch_events(token, state):
    """Fetch events from Druva API with pagination via nextPageToken."""
    events_url = f"https://{DRUVA_BASE_URL}/insync/eventmanagement/v2/events"
    headers = {
        "Authorization": f"Bearer {token}",
        "Accept": "application/json",
    }

    params = {"pageSize": PAGE_SIZE}

    tracker = state.get("tracker")
    last_event_time = state.get("last_event_time")

    if tracker:
        params["tracker"] = tracker
    elif last_event_time:
        params["fromTime"] = last_event_time
    else:
        lookback = datetime.now(timezone.utc) - timedelta(hours=LOOKBACK_HOURS)
        params["fromTime"] = lookback.strftime("%Y-%m-%dT%H:%M:%SZ")

    all_events = []
    total_fetched = 0

    while total_fetched < MAX_RECORDS:
        resp = requests.get(
            events_url,
            headers=headers,
            params=params,
            timeout=60,
        )
        resp.raise_for_status()
        data = resp.json()

        events = data.get("events", [])
        all_events.extend(events)
        total_fetched += len(events)

        new_tracker = data.get("tracker")
        next_page_token = data.get("nextPageToken")

        if new_tracker:
            state["tracker"] = new_tracker

        if next_page_token:
            params["nextPageToken"] = next_page_token
            params.pop("tracker", None)
            params.pop("fromTime", None)
        else:
            break

    if all_events:
        last_ts = all_events[-1].get("eventTime", "")
        if last_ts:
            state["last_event_time"] = last_ts

    return all_events, state

def write_events_to_gcs(storage_client, events):
    """Write events as NDJSON to GCS."""
    if not events:
        return

    now = datetime.now(timezone.utc)
    filename = now.strftime("%Y%m%d_%H%M%S") + ".ndjson"
    blob_path = f"{GCS_PREFIX}/{now.strftime('%Y/%m/%d')}/{filename}"

    ndjson_lines = "\n".join(json.dumps(event) for event in events)

    bucket = storage_client.bucket(GCS_BUCKET)
    blob = bucket.blob(blob_path)
    blob.upload_from_string(
        ndjson_lines,
        content_type="application/x-ndjson",
    )
    print(f"Wrote {len(events)} events to gs://{GCS_BUCKET}/{blob_path}")

def main(event, context):
    """Cloud Run function entry point triggered by Pub/Sub."""
    storage_client = storage.Client()

    token = get_oauth_token()

    state = load_state(storage_client)

    events, updated_state = fetch_events(token, state)

    write_events_to_gcs(storage_client, events)

    save_state(storage_client, updated_state)

    print(f"Completed: fetched {len(events)} events")
    return f"OK: {len(events)} events"

  8. Ersetzen Sie den Inhalt von requirements.txt durch Folgendes:

    requests>=2.31.0
google-cloud-storage>=2.14.0

Umgebungsvariablen konfigurieren

  1. Rufen Sie in der Cloud Run-Funktionskonfiguration den Abschnitt Laufzeit, Build, Verbindungen und Sicherheitseinstellungen auf.

  2. Fügen Sie unter Laufzeit-Umgebungsvariablen die folgenden Variablen hinzu:

    • GCS_BUCKET: Der Name Ihres GCS-Buckets (z. B. druva-backup-logs)
    • GCS_PREFIX: Der Präfixpfad für Logdateien (z. B. druva_backup)
    • STATE_KEY: Der Name der Statusdatei (z. B. druva_state.json)
    • DRUVA_BASE_URL: Die Druva API-Basis-URL:
      • apis.druva.com für Druva Cloud (Standard)
      • govcloudapis.druva.com für Druva GovCloud
    • CLIENT_ID: Die Client-ID aus den Druva API-Anmeldedaten
    • CLIENT_SECRET: Der geheime Schlüssel aus den Druva API-Anmeldedaten.
    • MAX_RECORDS: Maximale Anzahl von Datensätzen, die pro Aufruf abgerufen werden sollen (z. B. 10000)
    • PAGE_SIZE: Anzahl der Ereignisse pro API-Seite (maximal 500)
    • LOOKBACK_HOURS: Anzahl der Stunden, die bei der ersten Ausführung berücksichtigt werden sollen (z. B. 24)

  3. Klicken Sie auf Bereitstellen.

  4. Warten Sie, bis die Bereitstellung erfolgreich abgeschlossen ist.

Cloud Scheduler-Job erstellen

Erstellen Sie einen Cloud Scheduler-Job, um die Cloud Run-Funktion in regelmäßigen Abständen auszulösen.

  1. Rufen Sie in der Google Cloud Console Cloud Scheduler auf.
  2. Klicken Sie auf Job erstellen.

  3. Geben Sie die folgenden Konfigurationsdetails an:

    • Name: Geben Sie druva-backup-scheduler ein.
    • Region: Wählen Sie dieselbe Region wie für Ihre Cloud Run-Funktion aus (z. B. us-central1).
    • Beschreibung: Geben Sie Triggers Druva Backup log collection every 30 minutes ein.
    • Häufigkeit: Geben Sie */30 * * * * ein (alle 30 Minuten).
    • Zeitzone: Wählen Sie die gewünschte Zeitzone aus (z. B. UTC).

  4. Klicken Sie auf Weiter.

  5. Konfigurieren Sie das Ziel:

    • Zieltyp: Wählen Sie Pub/Sub aus.
    • Cloud Pub/Sub-Thema: Wählen Sie druva-backup-trigger aus.
    • Inhalt der Nachricht: Geben Sie {"trigger": "scheduled"} ein.

  6. Klicken Sie auf Erstellen.

Cloud Scheduler-Job testen

  1. Suchen Sie in der Liste Cloud Scheduler nach druva-backup-scheduler.
  2. Klicken Sie auf Ausführung erzwingen, um die Funktion sofort auszulösen.
  3. Prüfen Sie die Ausführung:
    • Die Cloud Run Functions-Logs unter Cloud Run Functions > druva-backup-to-gcs > Logs
    • Der GCS-Bucket für neue NDJSON-Dateien in Cloud Storage > druva-backup-logs

Google SecOps-Dienstkonto abrufen und Feed konfigurieren

E‑Mail-Adresse des Dienstkontos abrufen

  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. Druva Backup Events.
  5. Wählen Sie Google Cloud Storage V2 als Quelltyp aus.
  6. Wählen Sie Druva Backup als Protokolltyp 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, um sie im nächsten Schritt zu verwenden.

Feed konfigurieren

  1. Klicken Sie auf Weiter.

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

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

      gs://druva-backup-logs/druva_backup/

    • Option zum Löschen der Quelle: Wählen Sie die gewünschte Löschoption aus:

      • Nie: Dateien werden nach Übertragungen nie gelöscht (für Tests empfohlen)
      • Übertragene Dateien löschen: Dateien werden nach erfolgreicher Übertragung gelöscht.
      • Übertragene Dateien und leere Verzeichnisse löschen: Dateien und leere Verzeichnisse werden nach erfolgreicher Übertragung 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.

  3. Klicken Sie auf Weiter.

  4. 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 die Rolle Storage-Objekt-Betrachter für Ihren GCS-Bucket, um die von der Cloud Run-Funktion geschriebenen Logdateien zu lesen.

  1. Rufen Sie Cloud Storage > Buckets auf.
  2. Klicken Sie auf den Namen Ihres Buckets (z. B. druva-backup-logs).
  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 (z. B. chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com).
    • Rollen zuweisen: Wählen Sie Storage Object Viewer aus.

  6. Klicken Sie auf Speichern.

UDM-Zuordnungstabelle

Logfeld UDM-Zuordnung Logik
inSyncUserID, eventsGroupId, FilesMissed, FilesBackedup, TotalBackupSize, TotalBytesTransferred, facility, inSyncDataSourceID, initiator, event_type additional.fields Zusammengeführt mit Labels, die aus jedem Feld erstellt wurden, sofern nicht leer
initiator extensions.auth.type Auf „AUTHTYPE_UNSPECIFIED“ festgelegt, wenn der Initiator mit dem regulären Ausdruck für die E‑Mail-Adresse übereinstimmt
metadata.event_type Wird auf „USER_LOGIN“ gesetzt, wenn „has_target_user“ und „has_principal“ wahr sind; auf „STATUS_UPDATE“, wenn „has_principal“ wahr und „has_target“ falsch ist; andernfalls auf „GENERIC_EVENT“
eventID metadata.product_log_id In String umgewandelt
metadata.product_name Legen Sie diesen Wert auf „DRUVA_BACKUP“ fest.
clientVersion metadata.product_version Wert direkt kopiert
inSyncDataSourceName principal.asset.hostname Wert direkt kopiert
ip principal.asset.ip Zusammengeführt von IP
inSyncDataSourceName principal.hostname Wert direkt kopiert
ip principal.ip Zusammengeführt von IP
clientOS principal.platform Wird auf „LINUX“ gesetzt, wenn (?i)Linux übereinstimmt; auf „WINDOWS“, wenn (?i)windows übereinstimmt; auf „MAC“, wenn (?i)mac übereinstimmt
profileName principal.resource.name Wert direkt kopiert
profileID principal.resource.product_object_id In String umgewandelt
eventState security_result.action Auf „ALLOW“ setzen, wenn (?i)Success übereinstimmt, andernfalls auf „BLOCK“
eventState security_result.action_details Wert direkt kopiert
die Ausprägung security_result.severity Wird auf „LOW“ gesetzt, wenn der Wert [0,1,2,3,LOW] ist; auf „MEDIUM“, wenn der Wert [4,5,6,MEDIUM,SUBSTANTIAL,INFO] ist; auf „HIGH“, wenn der Wert [7,8,HIGH,SEVERE] ist; auf „CRITICAL“, wenn der Wert [9,10,VERY-HIGH,CRITICAL] ist
inSyncUserEmail, initiator target.user.email_addresses Zusammengeführt aus inSyncUserEmail; auch aus initiator, wenn mit regulärem Ausdruck für E‑Mail-Adressen übereinstimmend
inSyncUserName target.user.userid Wert direkt kopiert
metadata.vendor_name Legen Sie diesen Wert auf „DRUVA_BACKUP“ fest.

Änderungsprotokoll

Änderungsprotokoll für diesen Parser ansehen

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