Ergebnisse zur Analyse in BigQuery streamen

Auf dieser Seite wird beschrieben, wie Sie neue und aktualisierte Ergebnisse in eine BigQuery-Dataset mithilfe von Security Command Center Exportfunktion für BigQuery. Vorhandene Ergebnisse werden nicht an BigQuery, es sei denn, sie werden aktualisiert.

BigQuery ist das vollständig verwaltete, kostengünstige Data Warehouse für Analysen im Petabyte-Bereich von Google Cloud. Damit können Sie große Datenmengen nahezu in Echtzeit analysieren. Sie können BigQuery zum Ausführen von Abfragen für neue und aktualisierte Ergebnisse, Daten nach Bedarf filtern und benutzerdefinierte Berichte erstellen. Weitere Informationen Weitere Informationen zu BigQuery finden Sie in der BigQuery-Dokumentation

Übersicht

Wenn Sie dieses Feature aktivieren, werden neue Ergebnisse, die in das Security Command Center geschrieben werden, nahezu in Echtzeit in eine BigQuery-Tabelle exportiert. Anschließend können Sie die Daten in vorhandene Workflows integrieren. und erstellen Sie benutzerdefinierte Analysen erstellen. Sie können diese Funktion in der Organisation, im Ordner, und auf Projektebene können Sie Ergebnisse basierend auf Ihren Anforderungen exportieren.

Dieses Feature ist die empfohlene Methode zum Exportieren von Security Command Center-Ergebnissen in BigQuery, da es vollständig verwaltet wird und keine manuellen Vorgänge oder das Schreiben von benutzerdefiniertem Code erfordert.

Dataset-Struktur

Dieses Feature fügt jedes neue Ergebnis und die nachfolgenden Aktualisierungen als neue Zeilen in die findings-Tabelle ein. Diese ist geclustert nach source_id ,finding_id und event_time.

Wenn ein Ergebnis aktualisiert wird, erstellt dieses Feature mehrere Ergebnisdatensätze mit denselben source_id- und finding_id-Werten, aber mit unterschiedlichen event_time-Werten. Mit dieser Dataset-Struktur können Sie sehen, wie sich der Zustand jedes Ergebnisses im Laufe der Zeit ändert.

Beachten Sie, dass doppelte Einträge in Ihrem Dataset vorhanden sein können. Zum Herausfiltern dieser Einträge können Sie die Klausel DISTINCT verwenden, wie in der ersten Beispielabfrage gezeigt.

Jedes Dataset enthält die Tabelle findings mit den folgenden Feldern:

Kosten

Für diese Funktion fallen BigQuery-Gebühren an. Weitere Informationen finden Sie unter BigQuery-Preise.

Hinweis

Führen Sie die folgenden Schritte aus, bevor Sie diese Funktion aktivieren.

Berechtigungen einrichten

Zum Durcharbeiten dieser Anleitung benötigen Sie die folgenden IAM-Rollen (Identity and Access Management):

• Verwenden Sie für die Organisation, den Ordner oder das Projekt, aus dem Sie Ergebnisse exportieren möchten, eine der folgenden Optionen:

  • Sicherheitscenter-BigQuery-Exporteditor (roles/securitycenter.bigqueryExportsEditor):
  • Sicherheitscenter-Administrator (roles/securitycenter.admin):

  Weitere Informationen zu Security Command Center-Rollen finden Sie unter Zugriffssteuerung.

• Für das BigQuery-Dataset: BigQuery-Dateninhaber (roles/bigquery.dataOwner).

BigQuery-Dataset erstellen

BigQuery-Dataset erstellen Weitere Informationen finden Sie unter Datasets erstellen.

Datenstandort planen

Wenn der Datenstandort für Security Command Center aktiviert, die Konfigurationen, Streaming von Exporten nach BigQuery (BigQueryExport Ressourcen) unterliegen der und werden in einem Speicherort von Security Command Center die Sie auswählen.

So exportieren Sie Ergebnisse an einem Security Command Center-Speicherort nach BigQuery müssen Sie die BigQuery- und zwar am selben Security Command Center-Speicherort wie die Ergebnisse.

Da die in BigQuery verwendeten Filter Exporte können Daten enthalten, die Standortkontrollen unterliegen, achten Sie darauf, dass Sie den richtigen Speicherort angeben, bevor Sie sie erstellen. Security Command Center schränkt nicht ein, welchen Standort Sie erstellen die Exporte enthalten sollen.

BigQuery-Exporte werden nur an dem Speicherort gespeichert in die erstellt wurden und an anderen Orten nicht angezeigt oder bearbeitet werden können.

Nachdem Sie einen BigQuery-Export erstellt haben, Standort verwendet wird. Um den Standort zu ändern, müssen Sie Folgendes löschen: und erstellen Sie ihn am neuen Speicherort neu.

So rufen Sie einen BigQuery-Export mithilfe von API-Aufrufen ab: müssen Sie den Standort im vollständigen Ressourcennamen der bigQueryExport Beispiel:

GET https://securitycenter.googleapis.com/v2/{name=organizations/123/locations/eu/bigQueryExports/my-export-01}

Zum Abrufen eines BigQuery-Exports der gcloud CLI verwenden, müssen Sie den Standort entweder im vollständigen Ressourcennamen der Konfiguration oder mithilfe der Methode --locations melden. Beispiel:

gcloud scc scc bqexports get myBigQueryExport organizations/123 \
    --location=locations/us

Ergebnisse aus Security Command Center in BigQuery exportieren

Aktivieren Sie zum Exportieren der Ergebnisse zuerst die Security Command Center API.

Security Command Center API aktivieren

So aktivieren Sie das Security Command Center API:

1. Rufen Sie in der Google Cloud Console die Seite „API-Bibliothek“ auf.

   Zur API-Bibliothek

2. Wählen Sie das Projekt aus, für das Sie die Security Command Center API aktivieren möchten.

3. Geben Sie im Feld Suchen Security Command Center ein und klicken Sie dann in den Suchergebnissen auf Security Command Center.

4. Klicken Sie auf der angezeigten API-Seite auf Aktivieren.

Die Security Command Center API ist für Ihr Projekt aktiviert. Als Nächstes erstellen Sie mit der gcloud CLI eine neue Exportkonfiguration nach BigQuery.

Perimeterzugriff in VPC Service Controls gewähren

Wenn Sie VPC Service Controls und Ihr BigQuery-Dataset Teil eines Projekts in einem Dienst ist Perimeter müssen Sie Zugriff auf Projekte gewähren, um Ergebnisse exportieren zu können.

Um Zugriff auf Projekte zu gewähren, erstellen Sie Regeln für eingehenden und ausgehenden Traffic für die Hauptkonten und Projekte, aus denen Sie Ergebnisse exportieren. Regeln Zugriff auf geschützte Ressourcen zulassen und BigQuery prüfen lassen, Nutzer haben die Berechtigung setIamPolicy für die BigQuery-Datei Dataset.

Vor dem Einrichten eines neuen Exports nach BigQuery

1. Rufen Sie in der Google Cloud Console die Seite „VPC Service Controls“ auf.

   Zu „VPC Service Controls“

2. Wählen Sie gegebenenfalls Ihre Organisation aus.

3. Klicken Sie auf den Namen des Dienstperimeters, den Sie ändern möchten.

   Den zu ändernden Dienstperimeter finden Sie in Ihren Logs. für Einträge, die RESOURCES_NOT_IN_SAME_SERVICE_PERIMETER Verstöße zeigen. Prüfen Sie in diesen Einträgen das Feld servicePerimeterName: accessPolicies/ACCESS_POLICY_ID/servicePerimeters/SERVICE_PERIMETER_NAME.

4. Klicken Sie auf Perimeter bearbeiten.

5. Klicken Sie im Navigationsmenü auf Richtlinie für eingehenden Traffic.

6. Bis Regeln für eingehenden Traffic konfigurieren Für Nutzer oder Dienstkonten verwenden Sie die folgenden Parameter:

   • FROM-Attribute des API-Clients:
     • Wähle im Dropdown-Menü Identitäten die Option Ausgewählt aus. Identitäten.
     • Wählen Sie im Drop-down-Menü Quelle die Option Alle Quellen aus.
     • Klicken Sie auf Auswählen und geben Sie das gewünschte Hauptkonto ein. zum Aufrufen der Security Command Center API.
   • TO-Attribute von Google Cloud-Diensten/-Ressourcen:
     • Wählen Sie im Drop-down-Menü Projekt die Option Ausgewählte Projekte aus.
     • Klicken Sie auf Auswählen und geben Sie das Projekt ein, enthält das BigQuery-Dataset .
     • Wählen Sie im Dropdown-Menü Services die Option Ausgewählt aus. Dienste und wählen Sie dann BigQuery API aus.
     • Wählen Sie im Drop-down-Menü Methoden die Option Alle Aktionen aus.

7. Klicken Sie auf Speichern.

8. Klicken Sie im Navigationsmenü auf Richtlinie für ausgehenden Traffic.

9. Klicken Sie auf Add Rule (Regel hinzufügen).

10. Bis Regeln für ausgehenden Traffic konfigurieren Für Nutzer- oder Dienstkonten geben Sie die folgenden Parameter ein:

    • FROM-Attribute des API-Clients:
      • Wählen Sie im Drop-down-Menü Identitäten die Option Ausgewählte Identitäten aus.
      • Klicken Sie auf Auswählen und geben Sie dann das gewünschte Hauptkonto ein. zum Aufrufen der Security Command Center API.
    • TO-Attribute von Google Cloud-Diensten/-Ressourcen:
      • Wählen Sie im Drop-down-Menü Projekt die Option Alle Projekte aus.
      • Wählen Sie im Dropdown-Menü Services die Option Ausgewählt aus. Dienste und wählen Sie dann BigQuery API aus.
      • Wählen Sie im Drop-down-Menü Methoden die Option Alle Aktionen aus.

11. Klicken Sie auf Speichern.

Neuen Export nach BigQuery einrichten

In diesem Schritt erstellen Sie eine Exportkonfiguration, um Ergebnisse in eine BigQuery-Instanz zu exportieren. Sie können Exportkonfigurationen auf Projekt-, Ordner- oder Organisationsebene erstellen. Wenn Sie beispielsweise Ergebnisse aus einem Projekt in ein BigQuery-Dataset exportieren möchten, erstellen Sie eine Exportkonfiguration auf Projektebene, um nur die Ergebnisse zu exportieren, die sich auf dieses Projekt beziehen. Optional können Sie Filter angeben, um nur bestimmte Ergebnisse zu exportieren.

Erstellen Sie Ihre Exportkonfigurationen auf der entsprechenden Ebene. Wenn Sie beispielsweise eine Exportkonfiguration in Projekt B erstellen, um Ergebnisse aus Projekt A zu exportieren, und Sie Filter wie resource.project_display_name: project-a-id definieren, exportiert die Konfiguration keine Ergebnisse.

Sie können für Ihre Organisation maximal 500 Exportkonfigurationen in BigQuery erstellen. Sie können dasselbe Dataset für mehrere Exportkonfigurationen verwenden. Wenn Sie dasselbe Dataset verwenden, werden alle Aktualisierungen in derselben Ergebnistabelle vorgenommen.

Wenn Sie Ihre erste Exportkonfiguration erstellen, wird automatisch ein Dienstkonto für Sie angelegt. Dieses Dienstkonto ist erforderlich, um die Ergebnistabelle in einem Dataset zu erstellen oder zu aktualisieren und Ergebnisse in die Tabelle zu exportieren. Es hat das Format service-org-ORGANIZATION_ID@gcp-sa-scc-notification.iam.gservicaccount.com und erhält die Rolle „BigQuery-Datenbearbeiter“ (roles/bigquery.dataEditor) auf BigQuery-Dataset-Ebene.

import com.google.cloud.securitycenter.v1.BigQueryExport;
import com.google.cloud.securitycenter.v1.CreateBigQueryExportRequest;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import java.io.IOException;
import java.util.UUID;

public class CreateBigQueryExport {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Modify the following variable values.

    // parent: Use any one of the following resource paths:
    //              - organizations/{organization_id}
    //              - folders/{folder_id}
    //              - projects/{project_id}
    String parent = String.format("projects/%s", "your-google-cloud-project-id");

    // filter: Expression that defines the filter to apply across create/update events of findings.
    String filter =
        "severity=\"LOW\" OR severity=\"MEDIUM\" AND "
            + "category=\"Persistence: IAM Anomalous Grant\" AND "
            + "-resource.type:\"compute\"";

    // bigQueryDatasetId: The BigQuery dataset to write findings' updates to.
    String bigQueryDatasetId = "your-bigquery-dataset-id";

    // bigQueryExportId: Unique identifier provided by the client.
    // For more info, see:
    // https://cloud.google.com/security-command-center/docs/how-to-analyze-findings-in-big-query#export_findings_from_to
    String bigQueryExportId = "default-" + UUID.randomUUID().toString().split("-")[0];

    createBigQueryExport(parent, filter, bigQueryDatasetId, bigQueryExportId);
  }

  // Create export configuration to export findings from a project to a BigQuery dataset.
  // Optionally specify filter to export certain findings only.
  public static void createBigQueryExport(
      String parent, String filter, String bigQueryDatasetId, String bigQueryExportId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      // Create the BigQuery export configuration.
      BigQueryExport bigQueryExport =
          BigQueryExport.newBuilder()
              .setDescription(
                  "Export low and medium findings if the compute resource "
                      + "has an IAM anomalous grant")
              .setFilter(filter)
              .setDataset(String.format("%s/datasets/%s", parent, bigQueryDatasetId))
              .build();

      CreateBigQueryExportRequest bigQueryExportRequest =
          CreateBigQueryExportRequest.newBuilder()
              .setParent(parent)
              .setBigQueryExport(bigQueryExport)
              .setBigQueryExportId(bigQueryExportId)
              .build();

      // Create the export request.
      BigQueryExport response = client.createBigQueryExport(bigQueryExportRequest);

      System.out.printf("BigQuery export request created successfully: %s\n", response.getName());
    }
  }
}

def create_bigquery_export(
    parent: str, export_filter: str, bigquery_dataset_id: str, bigquery_export_id: str
):
    from google.cloud import securitycenter

    """
    Create export configuration to export findings from a project to a BigQuery dataset.
    Optionally specify filter to export certain findings only.

    Args:
        parent: Use any one of the following resource paths:
             - organizations/{organization_id}
             - folders/{folder_id}
             - projects/{project_id}
        export_filter: Expression that defines the filter to apply across create/update events of findings.
        bigquery_dataset_id: The BigQuery dataset to write findings' updates to.
        bigquery_export_id: Unique identifier provided by the client.
             - example id: f"default-{str(uuid.uuid4()).split('-')[0]}"
        For more info, see:
        https://cloud.google.com/security-command-center/docs/how-to-analyze-findings-in-big-query#export_findings_from_to
    """
    client = securitycenter.SecurityCenterClient()

    # Create the BigQuery export configuration.
    bigquery_export = securitycenter.BigQueryExport()
    bigquery_export.description = "Export low and medium findings if the compute resource has an IAM anomalous grant"
    bigquery_export.filter = export_filter
    bigquery_export.dataset = f"{parent}/datasets/{bigquery_dataset_id}"

    request = securitycenter.CreateBigQueryExportRequest()
    request.parent = parent
    request.big_query_export = bigquery_export
    request.big_query_export_id = bigquery_export_id

    # Create the export request.
    response = client.create_big_query_export(request)

    print(f"BigQuery export request created successfully: {response.name}\n")

Die Ergebnisse sollten innerhalb von etwa 15 Minuten nach dem Erstellen der Exportkonfiguration in Ihrem BigQuery-Dataset angezeigt werden. Nachdem die BigQuery-Tabelle erstellt wurde, werden neue und aktualisierte Ergebnisse, die Ihrem Filter und Bereich entsprechen, nahezu in Echtzeit in der Tabelle angezeigt.

Informationen zum Ansehen der Ergebnisse finden Sie unter Ergebnisse prüfen.

Eingangsregel für den neuen Export nach BigQuery erstellen

Wenn Sie VPC Service Controls und Ihr BigQuery-Dataset Teil eines Projekts in einem Dienst ist Perimeter müssen Sie eine Regel für eingehenden Traffic für einen neuen Export nach BigQuery erstellen.

1. Öffnen Sie den Dienstperimeter aus Neuen Export nach BigQuery einrichten noch einmal.

   Zu „VPC Service Controls“

2. Klicken Sie auf Richtlinie für eingehenden Traffic.

3. Klicken Sie auf Add Rule (Regel hinzufügen).

4. Um die Eingangsregel für die Exportkonfigurationen zu konfigurieren, geben Sie den Parameter folgende Parameter:

   • FROM-Attribute des API-Clients:
     • Wählen Sie im Drop-down-Menü Quelle die Option Alle Quellen aus.
     • Wählen Sie im Drop-down-Menü Identitäten die Option Ausgewählte Identitäten aus.
     • Klicken Sie auf Auswählen und geben Sie dann den Namen Dienstkonto für die BigQuery-Exportkonfiguration: service-org-ORGANIZATION_ID@gcp-sa-scc-notification.iam.gserviceaccount.com
   • TO-Attribute von GCP-Diensten/-Ressourcen:
     • Wählen Sie im Drop-down-Menü Projekt die Option Ausgewählte Projekte aus.
     • Klicken Sie auf Auswählen und wählen Sie das Projekt aus, enthält das BigQuery-Dataset.
     • Wählen Sie im Dropdown-Menü Services die Option Ausgewählt aus. Dienste und wählen Sie dann BigQuery API aus.
     • Wählen Sie im Drop-down-Menü Methoden die Option Alle Aktionen aus.

5. Klicken Sie im Navigationsmenü auf Speichern.

Die ausgewählten Projekte, Nutzer und Dienstkonten können jetzt auf die geschützten und die Ergebnisse exportieren.

Wenn Sie alle Schritte in dieser Anleitung befolgt haben und die Exporte funktionieren können Sie Folgendes löschen:

• Die Eingangsregel für das Hauptkonto
• Die Ausgangsregel für das Hauptkonto

Diese Regeln wurden nur zum Konfigurieren der Exportkonfiguration benötigt. Sie können jedoch Damit Exportkonfigurationen weiterhin funktionieren, müssen Sie die Eingangsregel beibehalten die Sie oben erstellt haben, damit Security Command Center Ergebnisse in Ihr BigQuery-Dataset hinter dem Dienstperimeter.

Details einer Exportkonfiguration aufrufen

import com.google.cloud.securitycenter.v1.BigQueryExport;
import com.google.cloud.securitycenter.v1.GetBigQueryExportRequest;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import java.io.IOException;

public class GetBigQueryExport {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Modify the following variable values.

    // parent: Use any one of the following resource paths:
    //              - organizations/{organization_id}
    //              - folders/{folder_id}
    //              - projects/{project_id}
    String parent = String.format("projects/%s", "your-google-cloud-project-id");

    // bigQueryExportId: Unique identifier that is used to identify the export.
    String bigQueryExportId = "export-id";

    getBigQueryExport(parent, bigQueryExportId);
  }

  // Retrieve an existing BigQuery export.
  public static void getBigQueryExport(String parent, String bigQueryExportId) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      GetBigQueryExportRequest bigQueryExportRequest =
          GetBigQueryExportRequest.newBuilder()
              .setName(String.format("%s/bigQueryExports/%s", parent, bigQueryExportId))
              .build();

      BigQueryExport response = client.getBigQueryExport(bigQueryExportRequest);
      System.out.printf("Retrieved the BigQuery export: %s", response.getName());
    }
  }
}

def get_bigquery_export(parent: str, bigquery_export_id: str):
    from google.cloud import securitycenter

    """
    Retrieve an existing BigQuery export.
    Args:
        parent: Use any one of the following resource paths:
                 - organizations/{organization_id}
                 - folders/{folder_id}
                 - projects/{project_id}
        bigquery_export_id: Unique identifier that is used to identify the export.
    """

    client = securitycenter.SecurityCenterClient()

    request = securitycenter.GetBigQueryExportRequest()
    request.name = f"{parent}/bigQueryExports/{bigquery_export_id}"

    response = client.get_big_query_export(request)
    print(f"Retrieved the BigQuery export: {response.name}")

Exportkonfiguration aktualisieren

Bei Bedarf können Sie den Filter, das Dataset und die Beschreibung einer vorhandenen Exportkonfiguration ändern. Der Name der Exportkonfiguration kann nicht geändert werden.

import com.google.cloud.securitycenter.v1.BigQueryExport;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import com.google.cloud.securitycenter.v1.UpdateBigQueryExportRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;

public class UpdateBigQueryExport {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Modify the following variable values.

    // parent: Use any one of the following resource paths:
    //              - organizations/{organization_id}
    //              - folders/{folder_id}
    //              - projects/{project_id}
    String parent = String.format("projects/%s", "your-google-cloud-project-id");

    // filter: Expression that defines the filter to apply across create/update events of findings.
    String filter =
        "severity=\"LOW\" OR severity=\"MEDIUM\" AND "
            + "category=\"Persistence: IAM Anomalous Grant\" AND "
            + "-resource.type:\"compute\"";

    // bigQueryExportId: Unique identifier provided by the client.
    // For more info, see:
    // https://cloud.google.com/security-command-center/docs/how-to-analyze-findings-in-big-query#export_findings_from_to
    String bigQueryExportId = "big-query-export-id";

    updateBigQueryExport(parent, filter, bigQueryExportId);
  }

  // Updates an existing BigQuery export.
  public static void updateBigQueryExport(String parent, String filter, String bigQueryExportId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      //  Set the new values for export configuration.
      BigQueryExport bigQueryExport =
          BigQueryExport.newBuilder()
              .setName(String.format("%s/bigQueryExports/%s", parent, bigQueryExportId))
              .setFilter(filter)
              .build();

      UpdateBigQueryExportRequest request =
          UpdateBigQueryExportRequest.newBuilder()
              .setBigQueryExport(bigQueryExport)
              // Set the update mask to specify which properties should be updated.
              // If empty, all mutable fields will be updated.
              // For more info on constructing field mask path, see the proto or:
              // https://cloud.google.com/java/docs/reference/protobuf/latest/com.google.protobuf.FieldMask
              .setUpdateMask(FieldMask.newBuilder().addPaths("filter").build())
              .build();

      BigQueryExport response = client.updateBigQueryExport(request);
      if (!response.getFilter().equalsIgnoreCase(filter)) {
        System.out.println("Failed to update BigQueryExport!");
        return;
      }
      System.out.println("BigQueryExport updated successfully!");
    }
  }
}

def update_bigquery_export(parent: str, export_filter: str, bigquery_export_id: str):
    """
    Updates an existing BigQuery export.
    Args:
        parent: Use any one of the following resource paths:
                 - organizations/{organization_id}
                 - folders/{folder_id}
                 - projects/{project_id}
        export_filter: Expression that defines the filter to apply across create/update events of findings.
        bigquery_export_id: Unique identifier provided by the client.
        For more info, see:
        https://cloud.google.com/security-command-center/docs/how-to-analyze-findings-in-big-query#export_findings_from_to
    """
    from google.cloud import securitycenter
    from google.protobuf import field_mask_pb2

    client = securitycenter.SecurityCenterClient()

    # Set the new values for export configuration.
    bigquery_export = securitycenter.BigQueryExport()
    bigquery_export.name = f"{parent}/bigQueryExports/{bigquery_export_id}"
    bigquery_export.filter = export_filter

    # Field mask to only update the export filter.
    # Set the update mask to specify which properties should be updated.
    # If empty, all mutable fields will be updated.
    # For more info on constructing field mask path, see the proto or:
    # https://googleapis.dev/python/protobuf/latest/google/protobuf/field_mask_pb2.html
    field_mask = field_mask_pb2.FieldMask(paths=["filter"])

    request = securitycenter.UpdateBigQueryExportRequest()
    request.big_query_export = bigquery_export
    request.update_mask = field_mask

    response = client.update_big_query_export(request)

    if response.filter != export_filter:
        print("Failed to update BigQueryExport!")
        return
    print("BigQueryExport updated successfully!")

Alle Exportkonfigurationen anzeigen

Sie können alle Exportkonfigurationen in Ihrer Organisation, in Ihrem Ordner oder in Ihrem Projekt anzeigen.

import com.google.cloud.securitycenter.v1.BigQueryExport;
import com.google.cloud.securitycenter.v1.ListBigQueryExportsRequest;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import com.google.cloud.securitycenter.v1.SecurityCenterClient.ListBigQueryExportsPagedResponse;
import java.io.IOException;

public class ListBigQueryExports {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Modify the following variable values.

    // parent: The parent, which owns the collection of BigQuery exports.
    //         Use any one of the following resource paths:
    //              - organizations/{organization_id}
    //              - folders/{folder_id}
    //              - projects/{project_id}
    String parent = String.format("projects/%s", "your-google-cloud-project-id");

    listBigQueryExports(parent);
  }

  // List BigQuery exports in the given parent.
  public static void listBigQueryExports(String parent) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      ListBigQueryExportsRequest request =
          ListBigQueryExportsRequest.newBuilder().setParent(parent).build();

      ListBigQueryExportsPagedResponse response = client.listBigQueryExports(request);

      System.out.println("Listing BigQuery exports:");
      for (BigQueryExport bigQueryExport : response.iterateAll()) {
        System.out.println(bigQueryExport.getName());
      }
    }
  }
}

def list_bigquery_exports(parent: str):
    from google.cloud import securitycenter

    """
    List BigQuery exports in the given parent.
    Args:
         parent: The parent which owns the collection of BigQuery exports.
             Use any one of the following resource paths:
                 - organizations/{organization_id}
                 - folders/{folder_id}
                 - projects/{project_id}
    """

    client = securitycenter.SecurityCenterClient()

    request = securitycenter.ListBigQueryExportsRequest()
    request.parent = parent

    response = client.list_big_query_exports(request)

    print("Listing BigQuery exports:")
    for bigquery_export in response:
        print(bigquery_export.name)

Exportkonfiguration löschen

Wenn Sie eine Exportkonfiguration nicht mehr benötigen, können Sie sie löschen.

import com.google.cloud.securitycenter.v1.DeleteBigQueryExportRequest;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import java.io.IOException;

public class DeleteBigQueryExport {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Modify the following variable values.

    // parent: Use any one of the following resource paths:
    //              - organizations/{organization_id}
    //              - folders/{folder_id}
    //              - projects/{project_id}
    String parent = String.format("projects/%s", "your-google-cloud-project-id");

    // bigQueryExportId: Unique identifier that is used to identify the export.
    String bigQueryExportId = "export-id";

    deleteBigQueryExport(parent, bigQueryExportId);
  }

  // Delete an existing BigQuery export.
  public static void deleteBigQueryExport(String parent, String bigQueryExportId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      DeleteBigQueryExportRequest bigQueryExportRequest =
          DeleteBigQueryExportRequest.newBuilder()
              .setName(String.format("%s/bigQueryExports/%s", parent, bigQueryExportId))
              .build();

      client.deleteBigQueryExport(bigQueryExportRequest);
      System.out.printf("BigQuery export request deleted successfully: %s", bigQueryExportId);
    }
  }
}

def delete_bigquery_export(parent: str, bigquery_export_id: str):
    """
    Delete an existing BigQuery export.
    Args:
        parent: Use any one of the following resource paths:
                 - organizations/{organization_id}
                 - folders/{folder_id}
                 - projects/{project_id}
        bigquery_export_id: Unique identifier that is used to identify the export.
    """
    from google.cloud import securitycenter

    client = securitycenter.SecurityCenterClient()

    request = securitycenter.DeleteBigQueryExportRequest()
    request.name = f"{parent}/bigQueryExports/{bigquery_export_id}"

    client.delete_big_query_export(request)
    print(f"BigQuery export request deleted successfully: {bigquery_export_id}")

Nachdem Sie die Exportkonfiguration gelöscht haben, können Sie die Daten aus Looker Studio entfernen. Weitere Informationen finden Sie unter Datenquelle entfernen, löschen und wiederherstellen.

Ergebnisse in BigQuery prüfen

Nachdem Sie eine Exportkonfiguration erstellt haben, werden neue Ergebnisse in das BigQuery-Dataset in dem von Ihnen angegebenen Projekt exportiert.

So prüfen Sie die Ergebnisse in BigQuery:

1. Wechseln Sie zum Projekt in BigQuery.

   BigQuery aufrufen

2. Wenn Sie sich nicht im richtigen Projekt befinden, gehen Sie so vor:

   1. Klicken Sie in der Symbolleiste auf die Projektauswahl arrow_drop_down.
   2. Wählen Sie neben Auswählen aus Ihre Organisation aus.
   3. Wählen Sie in der Projektliste Ihr Projekt aus.

3. Maximieren Sie im Bereich Explorer den Knoten für Ihr Projekt.

4. Erweitern Sie Ihr Dataset.

5. Klicken Sie auf die Tabelle Ergebnisse.

6. Klicken Sie im geöffneten Tab auf Vorschau. Ein Beispielsatz mit Daten wird angezeigt:

Nützliche Abfragen

Dieser Abschnitt enthält Beispielabfragen für die Analyse von Ergebnisdaten. Ersetzen Sie in den folgenden Beispielen DATASET durch den Ihrem Dataset zugewiesenen Namen und PROJECT_ID durch den Projektnamen für Ihr Dataset.

Informationen zur Behebung von Fehlern finden Sie unter Fehlermeldungen.

Die Anzahl neuer Ergebnisse, die täglich erstellt und aktualisiert werden

SELECT
    FORMAT_DATETIME("%Y-%m-%d", event_time) AS date,
    count(DISTINCT finding_id)
FROM `PROJECT_ID.DATASET.findings`
GROUP BY date
ORDER BY date DESC

Der neueste Ergebnisdatensatz für jedes Ergebnis

SELECT
    * EXCEPT(row)
FROM (
    SELECT *, ROW_NUMBER() OVER(
        PARTITION BY finding_id
        ORDER BY event_time DESC, finding.mute_update_time DESC
    ) AS row
    FROM `PROJECT_ID.DATASET.findings`
)
WHERE row = 1

Aktive Ergebnisse, sortiert nach Zeit

WITH latestFindings AS (
    SELECT * EXCEPT(row)
    FROM (
        SELECT *, ROW_NUMBER() OVER(
            PARTITION BY finding_id
            ORDER BY event_time DESC, finding.mute_update_time DESC
        ) AS row
        FROM `PROJECT_ID.DATASET.findings`
    ) WHERE row = 1
)
SELECT finding_id, event_time, finding
FROM latestFindings
WHERE finding.state = "ACTIVE"
ORDER BY event_time DESC

Aktuelle Ergebnisse in einem Projekt

WITH latestFindings AS (
    SELECT * EXCEPT(row)
    FROM (
        SELECT *, ROW_NUMBER() OVER(
            PARTITION BY finding_id
            ORDER BY event_time DESC, finding.mute_update_time DESC
        ) AS row
        FROM `PROJECT_ID.DATASET.findings`
    ) WHERE row = 1
)
SELECT finding_id, event_time, finding, resource
FROM latestFindings
WHERE resource.project_display_name = 'PROJECT'

Ersetzen Sie PROJECT durch den Projektnamen.

Aktuelle Ergebnisse in einem Ordner

WITH latestFindings AS(
    SELECT * EXCEPT(row)
    FROM (
        SELECT *, ROW_NUMBER() OVER(
            PARTITION BY finding_id
            ORDER BY event_time DESC, finding.mute_update_time DESC
        ) AS row
        FROM `PROJECT_ID.DATASET.findings`
    ) WHERE row = 1
)
SELECT finding_id, event_time, finding, resource
FROM latestFindings
CROSS JOIN UNNEST(resource.folders) AS folder
WHERE folder.resource_folder_display_name = 'FOLDER'

Ersetzen Sie FOLDER durch den Ordnernamen.

Aktuelle Ergebnisse des Scanners Logging Scanner

WITH latestFindings AS (
    SELECT * EXCEPT(row)
    FROM (
        SELECT *, ROW_NUMBER() OVER(
            PARTITION BY finding_id
            ORDER BY event_time DESC, finding.mute_update_time DESC
        ) AS row
        FROM `PROJECT_ID.DATASET.findings`
    ) WHERE row = 1
)
SELECT finding_id, event_time, finding
FROM latestFindings
CROSS JOIN UNNEST(finding.source_properties) AS source_property
WHERE source_property.key = "ScannerName"
  AND source_property.value = "LOGGING_SCANNER"

Aktuell aktive Ergebnisse vom Typ Persistence: IAM Anomalous Grant

WITH latestFindings AS(
    SELECT * EXCEPT(row)
    FROM (
        SELECT *, ROW_NUMBER() OVER(
            PARTITION BY finding_id
            ORDER BY event_time DESC, finding.mute_update_time DESC
        ) AS row
        FROM `PROJECT_ID.DATASET.findings`
    ) WHERE row = 1
)
SELECT finding_id, event_time, finding
FROM latestFindings
WHERE finding.state = "ACTIVE"
  AND finding.category = "Persistence: IAM Anomalous Grant"

Aktive Ergebnisse eines bestimmten Typs mit Cloud-Audit-Logs korrelieren

Diese Beispielabfrage hilft, anomale IAM-Erteilungsergebnisse aus Event Threat Detection mithilfe von Cloud-Audit-Logs zu untersuchen. Dazu wird die Sequenz der Administratoraktivitätsaktion während des Zeitfensters vor und auf die Ausführung der anomalen IAM-Zuweisungsaktion angezeigt. Die folgende Abfrage korreliert Administratoraktivitätslogs zwischen einer Stunde vor und einer Stunde nach dem Zeitstempel des Ergebnisses.

WITH latestFindings AS(
    SELECT * EXCEPT(row)
    FROM (
        SELECT *, ROW_NUMBER() OVER(
            PARTITION BY finding_id
            ORDER BY event_time DESC, finding.mute_update_time DESC
        ) AS row
        FROM `PROJECT_ID.DATASET.findings`
    ) WHERE row = 1
)
SELECT
  finding_id,
  ANY_VALUE(event_time) as event_time,
  ANY_VALUE(finding.access.principal_email) as grantor,
  JSON_VALUE_ARRAY(ANY_VALUE(finding.source_properties_json), '$.properties.sensitiveRoleGrant.members') as grantees,
  ARRAY_AGG(
    STRUCT(
      timestamp,
      IF(timestamp < event_time, 'before', 'after') as timeline,
      protopayload_auditlog.methodName,
      protopayload_auditlog.resourceName,
      protopayload_auditlog.serviceName
    )
    ORDER BY timestamp ASC
  ) AS recent_activity
FROM (
  SELECT
    f.*,
    a.*,
  FROM latestFindings AS f
  LEFT JOIN `PROJECT_ID.DATASET.cloudaudit_googleapis_com_activity` AS a
  ON a.protopayload_auditlog.authenticationInfo.principalEmail = f.finding.access.principal_email
  WHERE f.finding.state = "ACTIVE"
    AND f.finding.category = "Persistence: IAM Anomalous Grant"
    AND a.timestamp >= TIMESTAMP_SUB(f.event_time, INTERVAL 1 HOUR)
    AND a.timestamp <= TIMESTAMP_ADD(f.event_time, INTERVAL 1 HOUR)
  )
GROUP BY
  finding_id
ORDER BY
  event_time DESC

Die entsprechende Ausgabe sieht etwa so aus:

Diagramme in Looker Studio erstellen

Mit Looker Studio können Sie interaktive Berichte und Dashboards.

Im Allgemeinen fallen BigQuery-Nutzungskosten an. wenn Sie über Looker Studio auf BigQuery zugreifen. Weitere Informationen finden Sie unter BigQuery-Daten mit Looker Studio visualisieren

So erstellen Sie ein Diagramm, das die Ergebnisdaten nach Schweregrad und Kategorie visualisiert:

1. Öffnen Sie Looker Studio und melden Sie sich an.
2. Wenn Sie dazu aufgefordert werden, geben Sie zusätzliche Informationen an und richten Sie andere Einstellungen ein. Lesen Sie die Nutzungsbedingungen und fahren Sie fort, wenn Sie zufrieden sind.
3. Klicken Sie auf Leerer Bericht.
4. Klicken Sie auf dem Tab Datenverbindung herstellen auf die Karte BigQuery.
5. Autorisieren Sie Looker Studio für den Zugriff auf BigQuery, falls Sie dazu aufgefordert werden Projekten.
6. Stellen Sie eine Verbindung zu Ihren Ergebnisdaten her:
   1. Wählen Sie unter Projekt das Projekt für Ihr Dataset aus. Geben Sie alternativ auf dem Tab Meine Projekte Ihre Projekt-ID ein, um danach zu suchen.
   2. Klicken Sie unter Dataset auf den Namen Ihres Datasets.
   3. Klicken Sie unter Tabelle auf Ergebnisse.
   4. Klicken Sie auf Add.
   5. Klicken Sie im Dialogfeld auf Zum Bericht hinzufügen.
7. Nachdem der Bericht hinzugefügt wurde, klicken Sie auf Diagramm hinzufügen.

8. Klicken Sie auf Gestapeltes Säulendiagramm und dann auf den Bereich, in dem Sie das Diagramm platzieren möchten.

   

9. Legen Sie im Bereich Diagramm > Balken auf dem Tab Daten die folgenden Felder fest:

   1. Wählen Sie im Feld Dimension die Option finding.severity aus.
   2. Wählen Sie im Feld Aufschlüsselungsdimension die Option finding.category aus.

   

Der Bericht wird so aktualisiert, dass er mehrere Spalten mit nach Schweregrad und Kategorie aufgeschlüsselten Ergebnissen enthält.

Nächste Schritte

Abfrage in BigQuery ausführen.