Insérer les résultats en flux continu dans BigQuery à des fins d'analyse

Cette page explique comment diffuser des résultats nouveaux et mis à jour vers un ensemble de données BigQuery à l'aide de la fonction d'exportation de Security Command Center pour BigQuery. Les résultats existants ne sont pas envoyés à BigQuery, sauf s'ils sont mis à jour.

Google BigQuery est l'entrepôt de données d'analyse de Google Cloud, entièrement géré à l'échelle du pétaoctet et à faible coût, qui vous permet d'exécuter des analyses sur de grandes quantités de données en quasi-temps réel. Vous pouvez utiliser BigQuery pour exécuter des requêtes sur les résultats nouveaux et mis à jour, filtrer les données pour trouver ce dont vous avez besoin et générer des rapports personnalisés. Pour en savoir plus sur BigQuery, consultez la documentation BigQuery.

Présentation

Lorsque vous activez cette fonctionnalité, les nouveaux résultats écrits dans Security Command Center sont exportés vers une table BigQuery quasiment en temps réel. Vous pouvez ensuite intégrer les données dans des workflows existants et créer des analyses personnalisées. Vous pouvez activer cette fonctionnalité au niveau de l'organisation, du dossier et du projet pour exporter les résultats en fonction de vos besoins.

Cette fonctionnalité est recommandée pour exporter les résultats de Security Command Center vers BigQuery, car elle est entièrement gérée et ne nécessite pas d'effectuer des opérations manuelles ni d'écrire du code personnalisé.

Structure de l'ensemble de données

Cette fonctionnalité ajoute chaque nouveau résultat et ses mises à jour ultérieures sous forme de nouvelles lignes dans la table findings, qui est mise en cluster par source_id, finding_id et event_time.

Lorsqu'un résultat est mis à jour, cette fonctionnalité crée plusieurs enregistrements de résultats avec les mêmes valeurs source_id et finding_id, mais avec des valeurs event_time différentes. Cette structure d'ensemble de données vous permet de voir l'évolution de l'état de chaque résultat au fil du temps.

Notez que votre ensemble de données peut contenir des entrées en double. Pour les analyser, vous pouvez utiliser la clause DISTINCT, comme indiqué dans le premier exemple de requête.

Chaque ensemble de données contient une table findings, qui contient les champs suivants:

Coût

Des frais BigQuery liés à cette fonctionnalité vous sont facturés. Pour en savoir plus, consultez l'article sur la tarification BigQuery.

Avant de commencer

Vous devez suivre cette procédure avant d'activer cette fonctionnalité.

Configurer les autorisations

Pour suivre ce guide, vous devez disposer des rôles Identity and Access Management (IAM) suivants :

• Dans l'organisation, le dossier ou le projet à partir duquel vous souhaitez exporter les résultats, utilisez l'une des méthodes suivantes:

  • Éditeur des exportations BigQuery du centre de sécurité (roles/securitycenter.bigQueryExportsEditor)
  • Administrateur du centre de sécurité (roles/securitycenter.admin)

  Pour en savoir plus sur les rôles Security Command Center, consultez la page Contrôle des accès.

• Dans l'ensemble de données BigQuery, Propriétaire de données BigQuery (roles/bigquery.dataOwner).

Créer un ensemble de données BigQuery

Créez un ensemble de données BigQuery. Pour en savoir plus, consultez la page Créer des ensembles de données.

Planifier la résidence des données

Si la résidence des données est activée pour Security Command Center, les configurations qui définissent les exportations en streaming vers BigQuery (ressources BigQueryExport) sont soumises au contrôle de la résidence des données et sont stockées dans un emplacement Security Command Center que vous sélectionnez.

Pour exporter les résultats d'un emplacement Security Command Center vers BigQuery, vous devez configurer l'exportation BigQuery dans le même emplacement Security Command Center que les résultats.

Étant donné que les filtres utilisés dans les exportations BigQuery peuvent contenir des données soumises à des contrôles de résidence, veillez à spécifier le bon emplacement avant de les créer. Security Command Center ne limite pas l'emplacement dans lequel vous créez des exportations.

Les exportations BigQuery ne sont stockées que dans l'emplacement où elles sont créées et ne peuvent pas être consultées ni modifiées à d'autres emplacements.

Une fois que vous avez créé une exportation BigQuery, vous ne pouvez plus modifier son emplacement. Pour modifier l'emplacement, vous devez supprimer l'exportation BigQuery et la recréer dans le nouvel emplacement.

Pour récupérer une exportation BigQuery à l'aide d'appels d'API, vous devez spécifier l'emplacement dans le nom complet de la ressource de bigQueryExport. Exemple :

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

De même, pour récupérer une exportation BigQuery à l'aide de gcloud CLI, vous devez spécifier l'emplacement à l'aide de l'option --location. Exemple :

gcloud scc bqexports get myBigQueryExport --organization=123 \
    --location=us

Exporter les résultats de Security Command Center vers BigQuery

Pour exporter les résultats, commencez par activer l'API Security Command Center.

Activer l'API Security Command Center

Pour activer l'API Security Command Center, procédez comme suit :

1. Accédez à la page "Bibliothèque d'API" de la console Google Cloud.

   Accéder à la bibliothèque d'API

2. Sélectionnez le projet pour lequel vous souhaitez activer l'API Security Command Center.

3. Dans le champ de recherche, saisissez Security Command Center, puis cliquez sur Security Command Center dans les résultats de recherche.

4. Dans la page de l'API qui s'affiche, cliquez sur Activer.

L'API Security Command Center est désormais activée pour votre projet. Ensuite, vous allez utiliser gcloud CLI pour créer une configuration d'exportation vers BigQuery.

Accorder l'accès à un périmètre dans VPC Service Controls

Si vous utilisez VPC Service Controls et que votre ensemble de données BigQuery fait partie d'un projet dans un périmètre de service, vous devez accorder l'accès aux projets afin d'exporter les résultats.

Pour accorder l'accès aux projets, créez des règles d'entrée et de sortie pour les principaux et les projets à partir desquels vous exportez les résultats. Les règles autorisent l'accès aux ressources protégées et permettent à BigQuery de vérifier que les utilisateurs disposent de l'autorisation setIamPolicy sur l'ensemble de données BigQuery.

Avant de configurer une nouvelle exportation vers BigQuery

1. Accédez à la page "VPC Service Controls" dans Google Cloud Console.

   Accéder à VPC Service Controls

2. Si nécessaire, sélectionnez votre organisation.

3. Cliquez sur le nom du périmètre de service que vous souhaitez modifier.

   Pour trouver le périmètre de service que vous devez modifier, vous pouvez rechercher dans vos journaux les entrées indiquant des cas de non-respect de RESOURCES_NOT_IN_SAME_SERVICE_PERIMETER. Dans ces entrées, vérifiez le champ servicePerimeterName : accessPolicies/ACCESS_POLICY_ID/servicePerimeters/SERVICE_PERIMETER_NAME.

4. Cliquez sur Modifier le périmètre.

5. Dans le menu de navigation, cliquez sur Règle d'entrée.

6. Pour configurer des règles d'entrée pour les utilisateurs ou les comptes de service, utilisez les paramètres suivants:

   • Attributs "FROM" du client API :
     • Dans le menu Identités, choisissez Identités sélectionnées.
     • Dans le menu Source, sélectionnez Toutes les sources.
     • Cliquez sur Sélectionner, puis saisissez le principal utilisé pour appeler l'API Security Command Center.
   • Attributs "TO" des services/ressources Google Cloud :
     • Dans le menu Projet, choisissez Projets sélectionnés.
     • Cliquez sur Sélectionner, puis saisissez le projet contenant l'ensemble de données BigQuery.
     • Dans le menu Services, choisissez Services sélectionnés, puis API BigQuery.
     • Dans le menu Méthodes, choisissez Toutes les actions.

7. Cliquez sur Enregistrer.

8. Dans le menu de navigation, cliquez sur Règle de sortie.

9. Cliquez sur Add Rule (Ajouter une règle).

10. Pour configurer des règles de sortie pour les comptes utilisateur ou de service, saisissez les paramètres suivants:

    • Attributs "FROM" du client API :
      • Dans le menu Identités, choisissez Identités sélectionnées.
      • Cliquez sur Sélectionner, puis saisissez le principal utilisé pour appeler l'API Security Command Center.
    • Attributs "TO" des services/ressources Google Cloud :
      • Dans le menu Projet, choisissez Tous les projets.
      • Dans le menu Services, choisissez Sélectionner des services, puis API BigQuery.
      • Dans le menu Méthodes, choisissez Toutes les actions.

11. Cliquez sur Enregistrer.

Configurer une nouvelle exportation vers BigQuery

Au cours de cette étape, vous allez créer une configuration d'exportation pour exporter les résultats vers une instance BigQuery. Vous pouvez créer des configurations d'exportation au niveau du projet, du dossier ou de l'organisation. Par exemple, si vous souhaitez exporter les résultats d'un projet vers un ensemble de données BigQuery, vous devez créer une configuration d'exportation au niveau du projet pour n'exporter que les résultats associés à ce projet. Vous pouvez éventuellement spécifier des filtres pour n'exporter que certains résultats.

Veillez à créer vos configurations d'exportation au niveau approprié. Par exemple, si vous créez une configuration d'exportation dans le projet B pour exporter les résultats du projet A et que vous définissez des filtres tels que resource.project_display_name: project-a-id, la configuration n'exporte aucun résultat.

Vous pouvez créer jusqu'à 500 configurations d'exportation vers BigQuery pour votre organisation. Vous pouvez utiliser le même ensemble de données pour plusieurs configurations d'exportation. Si vous utilisez le même ensemble de données, toutes les mises à jour seront appliquées à la même table de résultats.

Lorsque vous créez votre première configuration d'exportation, un compte de service est créé automatiquement. Ce compte de service est nécessaire pour créer ou mettre à jour la table de résultats dans un ensemble de données, et pour exporter des résultats dans la table. Elle est au format service-org-ORGANIZATION_ID@gcp-sa-scc-notification.iam.gservicaccount.com et dispose du rôle "Éditeur de données BigQuery" (roles/bigquery.dataEditor) au niveau de l'ensemble de données BigQuery.

Dans la console Google Cloud, certaines ressources BigQueryExport peuvent afficher un libellé Ancienne, ce qui indique qu'elles ont été créées avec l'API Security Command Center v1. Vous pouvez gérer ces ressources BigQueryExport avec la console Google Cloud, la gcloud CLI, l'API Security Command Center v1 ou les bibliothèques clientes v1 pour Security Command Center.

Pour gérer ces ressources BigQueryExport avec la CLI gcloud, vous ne devez pas spécifier d'emplacement lorsque vous exécutez la commande gcloud CLI.

import com.google.cloud.securitycenter.v2.BigQueryExport;
import com.google.cloud.securitycenter.v2.CreateBigQueryExportRequest;
import com.google.cloud.securitycenter.v2.OrganizationLocationName;
import com.google.cloud.securitycenter.v2.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.
    // organizationId: Google Cloud Organization id.
    String organizationId = "{google-cloud-organization-id}";

    // projectId: Google Cloud Project id.
    String projectId = "{your-project}";

    // Specify the location.
    String location = "global";

    // filter: Expression that defines the filter to apply across create/update events of findings.
    String filter = "severity=\"LOW\" OR severity=\"MEDIUM\"";

    // bigQueryDatasetId: The BigQuery dataset to write findings' updates to.
    String bigQueryDatasetId = "{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(organizationId, location, projectId, 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 BigQueryExport createBigQueryExport(String organizationId, String location,
      String projectId, 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.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {
      OrganizationLocationName organizationName = OrganizationLocationName.of(organizationId,
          location);
      // 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("projects/%s/datasets/%s", projectId, bigQueryDatasetId))
              .build();

      CreateBigQueryExportRequest bigQueryExportRequest =
          CreateBigQueryExportRequest.newBuilder()
              .setParent(organizationName.toString())
              .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());
      return response;
    }
  }
}

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

    """
    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}/locations/{location_id}
             - folders/{folder_id}/locations/{location_id}
             - projects/{project_id}/locations/{location_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.
             - projects/{PROJECT_ID}/datasets/{BIGQUERY_DATASET_ID}
        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_v2.SecurityCenterClient()

    # Create the BigQuery export configuration.
    bigquery_export = securitycenter_v2.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 = bigquery_dataset_id

    request = securitycenter_v2.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")
    return response

Les résultats devraient s'afficher dans votre ensemble de données BigQuery dans les 15 minutes qui suivent la création de la configuration d'exportation. Une fois la table BigQuery créée, tous les résultats nouveaux et mis à jour correspondant à votre filtre et à votre champ d'application apparaissent quasiment en temps réel dans la table.

Pour examiner vos résultats, consultez la section Examiner les résultats.

Créer une règle d'importation pour la nouvelle exportation vers BigQuery

Si vous utilisez VPC Service Controls et que votre ensemble de données BigQuery fait partie d'un projet dans un périmètre de service, vous devez créer une règle d'entrée pour une nouvelle exportation vers BigQuery.

1. Ouvrez à nouveau le périmètre de service depuis Configurer une nouvelle exportation vers BigQuery.

   Accéder à VPC Service Controls

2. Cliquez sur Règle d'entrée.

3. Cliquez sur Add Rule (Ajouter une règle).

4. Pour configurer la règle d'entrée pour les configurations d'exportation, saisissez les paramètres suivants:

   • Attributs "FROM" du client API :
     • Dans le menu déroulant Source, sélectionnez Toutes les sources.
     • Dans le menu déroulant Identités, choisissez Identités sélectionnées.
     • Cliquez sur Sélectionner, puis saisissez le nom du compte de service de configuration d'exportation BigQuery : service-org-ORGANIZATION_ID@gcp-sa-scc-notification.iam.gserviceaccount.com
   • Attributs "TO" des services/ressources GCP :
     • Dans le menu déroulant Projet, choisissez Projets sélectionnés.
     • Cliquez sur Sélectionner, puis sur le projet contenant l'ensemble de données BigQuery.
     • Dans le menu déroulant Services, choisissez Services sélectionnés, puis API BigQuery.
     • Dans le menu déroulant Méthodes, choisissez Toutes les actions.

5. Dans le menu de navigation, cliquez sur Enregistrer.

Les projets, utilisateurs et comptes de service sélectionnés peuvent désormais accéder aux ressources protégées et exporter les résultats.

Si vous avez suivi toutes les étapes de ce guide et que les exportations fonctionnent correctement, vous pouvez maintenant supprimer les éléments suivants:

• Règle d'entrée pour le principal
• Règle de sortie pour le principal

Ces règles n'étaient nécessaires que pour configurer la configuration d'exportation. Toutefois, pour que les configurations d'exportation continuent de fonctionner, vous devez conserver la règle d'entrée que vous avez créée précédemment, qui permet à Security Command Center d'exporter les résultats vers votre ensemble de données BigQuery derrière le périmètre de service.

Afficher les détails d'une configuration d'exportation

Mettre à jour une configuration d'exportation

Si nécessaire, vous pouvez modifier le filtre, l'ensemble de données et la description d'une configuration d'exportation existante. Vous ne pouvez pas modifier le nom de la configuration d'exportation.

Afficher toutes les configurations d'exportation

Vous pouvez afficher toutes les configurations d'exportation de votre organisation, de votre dossier ou de votre projet.

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

public class ListBigQueryExports {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Modify the following variable values.
    // organizationId: Google Cloud Organization id.
    String organizationId = "{google-cloud-organization-id}";

    // Specify the location to list the findings.
    String location = "global";

    listBigQueryExports(organizationId, location);
  }

  // List BigQuery exports in the given parent.
  public static ListBigQueryExportsPagedResponse listBigQueryExports(String organizationId,
      String location) 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.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {
      OrganizationLocationName organizationName = OrganizationLocationName.of(organizationId,
          location);

      ListBigQueryExportsRequest request = ListBigQueryExportsRequest.newBuilder()
          .setParent(organizationName.toString())
          .build();

      ListBigQueryExportsPagedResponse response = client.listBigQueryExports(request);

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

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

    """
    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}/locations/{location_id}
                 - folders/{folder_id}/locations/{location_id}
                 - projects/{project_id}/locations/{location_id}
    """

    client = securitycenter_v2.SecurityCenterClient()

    request = securitycenter_v2.ListBigQueryExportsRequest()
    request.parent = parent

    response = client.list_big_query_exports(request)

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

Supprimer une configuration d'exportation

Si vous n'avez plus besoin d'une configuration d'exportation, vous pouvez la supprimer.

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

public class DeleteBigQueryExport {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Modify the following variable values.
    // organizationId: Google Cloud Organization id.
    String organizationId = "{google-cloud-organization-id}";

    // Specify the location to list the findings.
    String location = "global";

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

    deleteBigQueryExport(organizationId, location, bigQueryExportId);
  }

  // Delete an existing BigQuery export.
  public static void deleteBigQueryExport(String organizationId, String location,
      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.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {
      // Optionally BigQueryExportName or String can be used
      // String bigQueryExportName = String.format("organizations/%s/locations/%s
      // /bigQueryExports/%s",organizationId,location, bigQueryExportId);
      BigQueryExportName bigQueryExportName = BigQueryExportName.of(organizationId, location,
          bigQueryExportId);

      DeleteBigQueryExportRequest bigQueryExportRequest =
          DeleteBigQueryExportRequest.newBuilder()
              .setName(bigQueryExportName.toString())
              .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}/locations/{location_id}
                 - folders/{folder_id}/locations/{location_id}
                 - projects/{project_id}/locations/{location_id}
        bigquery_export_id: Unique identifier that is used to identify the export.
    """
    from google.cloud import securitycenter_v2

    client = securitycenter_v2.SecurityCenterClient()

    request = securitycenter_v2.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}")

Une fois la configuration de l'exportation supprimée, vous pouvez supprimer les données de Looker Studio. Pour plus d'informations, consultez la page Retirer, supprimer et restaurer une source de données.

Examiner les résultats dans BigQuery

Après avoir créé une configuration d'exportation, les nouveaux résultats sont exportés vers l'ensemble de données BigQuery dans le projet que vous avez spécifié.

Pour examiner les résultats dans BigQuery, procédez comme suit :

1. Accédez au projet dans BigQuery.

   Accéder à BigQuery

2. Sélectionnez un projet.

3. Dans le volet Explorateur, développez le nœud de votre projet.

4. Développez votre ensemble de données.

5. Cliquez sur la table des résultats.

6. Dans l'onglet qui s'affiche, cliquez sur Aperçu. Un échantillon de données s'affiche.

Requêtes utiles

Cette section fournit des exemples de requêtes d'analyse des données de résultats. Dans les exemples suivants, remplacez DATASET par le nom attribué à votre ensemble de données et PROJECT_ID par le nom de projet de votre ensemble de données.

Pour résoudre les erreurs que vous rencontrez, consultez la section Messages d'erreur.

Le nombre de résultats créés et mis à jour quotidiennement

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

Dernier enregistrement de résultat pour chaque résultat

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

Résultats actuels actifs, triés par ordre chronologique

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

Résultats actuels dans un projet

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'

Remplacez PROJECT par le nom du projet.

Résultats actuels situés dans un dossier

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'

Remplacez FOLDER par le nom du dossier.

Résultats actuels de l'outil d'analyse 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"

Résultats actifs de type 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"

Corréler les résultats actifs d'un type donné avec Cloud Audit Logs

Cet exemple de requête permet d'examiner les résultats d'octroi IAM anormaux du service Event Threat Detection à l'aide de Cloud Audit Logs en affichant la séquence d'actions d'administration de l'approbateur au cours de la période précédente et en effectuant l'action d'octroi IAM anormale. Cette requête correspond aux journaux d'activité d'administration entre une heure avant et une heure après l'horodatage du résultat.

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

Le résultat ressemble à ce qui suit :

Créer des graphiques dans Looker Studio

Looker Studio vous permet de créer des rapports et des tableaux de bord interactifs.

En général, l'accès à BigQuery via Looker Studio entraîne des frais d'utilisation BigQuery. Pour en savoir plus, consultez la page Visualiser des données BigQuery à l'aide de Looker Studio.

Pour créer un graphique qui représente les données de résultats par gravité et par catégorie, procédez comme suit:

1. Ouvrez Looker Studio et connectez-vous.
2. Si vous y êtes invité, indiquez des informations supplémentaires et configurez d'autres préférences. Lisez les conditions d'utilisation et, si vous êtes satisfait, continuez.
3. Cliquez sur Rapport vide.
4. Dans l'onglet Se connecter aux données, cliquez sur la fiche BigQuery.
5. Si vous y êtes invité, autorisez Looker Studio à accéder aux projets BigQuery.

6. Connectez-le à vos données de résultats:

   1. Pour Projet, sélectionnez ce projet pour votre ensemble de données. Vous pouvez également saisir votre ID de projet dans l'onglet Mes projets pour le rechercher.
   2. Dans le champ Ensemble de données, cliquez sur le nom de l'ensemble de données.
   3. Dans le champ Table, cliquez sur résultats.
   4. Cliquez sur Ajouter.
   5. Dans la boîte de dialogue, cliquez sur Ajouter au rapport.

7. Une fois le rapport ajouté, cliquez sur Ajouter un graphique.

8. Cliquez sur Histogramme empilé, puis sur la zone dans laquelle vous souhaitez le placer.

   

9. Dans le volet Graphique > Barre, accédez à l'onglet Données, puis définissez les champs suivants :

   1. Dans le champ Dimension, sélectionnez finding.severity.
   2. Dans le champ Dimension de répartition, sélectionnez finding.category.

   

Le rapport est mis à jour pour afficher plusieurs colonnes avec des résultats répartis par niveau de gravité et par catégorie.

Étape suivante

Découvrez comment exécuter une requête dans BigQuery.