Druva Backup-Protokolle erfassen

Unterstützt in:

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

Druva ist eine cloudnative Plattform für Datenschutz und ‑verwaltung, die Sicherungs-, Notfallwiederherstellungs- und Archivierungsdienste 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.

Hinweise

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 je nach Bedarf aus (Region, Dual-Region, Multi-Region).
    Standort Wählen Sie den Standort aus, der Ihrer Google SecOps-Instanz am nächsten ist (z. B. us-central1).
    Speicherklasse Standard (empfohlen für Logs, auf die häufig zugegriffen wird)
    Zugriffskontrolle Einheitlich (empfohlen)
    Schutzmaßnahmen 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 an: 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 vollständigen Zugriff auf das Abrufen und Ändern von Daten zu ermöglichen.
    2. Alternativ können Sie Produktadministrator auswählen und dann: Rolle „Cloud-Administrator (schreibgeschützt)“: Um den Zugriff auf den Datenabruf ohne Änderungsrechte einzuschränken (empfohlen für die SIEM-Integration)
  7. Klicken Sie auf Speichern.

API-Anmeldedaten aufzeichnen

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

  1. Klicken Sie neben Client-ID auf das Symbol „Kopieren“, um den Wert in die Zwischenablage zu kopieren.
  2. Speichern Sie die Client-ID sicher (z. B. McNkxxxx4Vicxxxx4Ldpxxxx/09Uxxxx).
  3. Klicken Sie neben Secret Key (Geheimer Schlüssel) auf das Symbol „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. Wechseln Sie in der Google Cloud Console zu IAM & Verwaltung > Dienstkonten.
  2. Klicken Sie auf Dienstkonto erstellen.
  3. Geben Sie die folgenden Konfigurationsdetails an:
    • Name des Dienstkontos: Geben Sie druva-backup-function (oder einen beschreibenden 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-Objekt-Administrator 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. Wechseln Sie in der Google Cloud Console zu Cloud Run-Funktionen.
  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 ist, 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 den Einstiegspunkt auf main fest.

  7. Ersetzen Sie im Editor Quellcode 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 Konfiguration der Cloud Run-Funktion den Abschnitt Laufzeit, Build, Verbindungen und Sicherheitseinstellungen auf.

  2. Fügen Sie unter Umgebungsvariablen der Laufzeit 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 der Datensätze, 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 beim ersten Lauf berücksichtigt werden sollen (z. B. 24)

  3. Klicken Sie auf Bereitstellen.

  4. Warten Sie, bis die Bereitstellung 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 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 * * * * (alle 30 Minuten) ein.
    • Zeitzone: Wählen Sie Ihre bevorzugte 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.
    • Nachrichtentext: 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 Force Run (Ausführung erzwingen), um die Funktion sofort auszulösen.
  3. Prüfen Sie die Ausführung anhand der folgenden Punkte:
    • Die Cloud Run-Funktionslogs finden Sie 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 SIEM-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 Logtyp aus.

  7. Klicken Sie auf Dienstkonto abrufen. Es wird eine eindeutige E-Mail-Adresse für das Dienstkonto angezeigt, z. B.:

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com

  8. Kopieren Sie diese E‑Mail-Adresse für den nächsten Schritt.

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

    • Maximales Dateialter: Dateien einschließen, die in den letzten Tagen geändert wurden (Standard ist 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-Objekt-Betrachter 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 Mit Labels zusammengeführt, 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 E‑Mail-Adressen übereinstimmt
metadata.event_type Auf „USER_LOGIN“ festgelegt, wenn „has_target_user“ auf „true“ und „has_principal“ auf „true“ festgelegt ist; auf „STATUS_UPDATE“, wenn „has_principal“ auf „true“ und „has_target“ auf „false“ festgelegt ist; andernfalls „GENERIC_EVENT“
eventID metadata.product_log_id In String umgewandelt
metadata.product_name Auf „DRUVA_BACKUP“ festlegen
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 Auf „LINUX“ festlegen, 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 zutrifft, andernfalls „BLOCK“
eventState security_result.action_details Wert direkt kopiert
die Ausprägung security_result.severity Auf „LOW“ setzen, wenn in [0,1,2,3,LOW]; „MEDIUM“, wenn in [4,5,6,MEDIUM,SUBSTANTIAL,INFO]; „HIGH“, wenn in [7,8,HIGH,SEVERE]; „CRITICAL“, wenn in [9,10,VERY-HIGH,CRITICAL]
inSyncUserEmail, initiator target.user.email_addresses Zusammengeführt aus inSyncUserEmail; auch vom Initiator, wenn er mit dem regulären Ausdruck für E‑Mail-Adressen übereinstimmt
inSyncUserName target.user.userid Wert direkt kopiert
metadata.vendor_name Auf „DRUVA_BACKUP“ festlegen

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