Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

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

Niveaux de service Standard (ancienne version), Standard, Premium et Enterprise (obsolète) Si votre organisation utilise le niveau de service Enterprise, elle passera automatiquement au niveau de service Premium le 21 mai 2027 ou après. Contactez votre responsable de compte ou un spécialiste des ventesGoogle Cloud si vous avez des questions.

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

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 :

Champ	Description
`source_id`	Identifiant unique que Security Command Center attribue à la source d'un résultat. Par exemple, tous les résultats de la source Détection d'anomalies dans le cloud ont la même valeur `source_id`. Exemple : `1234567890`
`finding_id`	Identifiant unique qui représente le résultat. Il est unique au sein d'une source pour une organisation. Il est alphanumérique et comporte 32 caractères ou moins.
`event_time`	Heure à laquelle l'événement s'est produit ou heure de la mise à jour du résultat. Par exemple, si le résultat représente un pare-feu ouvert, `event_time` capture l'heure à laquelle le détecteur estime que le pare-feu a été ouvert. Si le résultat est résolu par la suite, cette valeur indique l'heure de résolution du résultat. Exemple : `2019-09-26 12:48:00.985000 UTC`
`bulk_export_id`	Pour les exportations groupées, il s'agit d'un UUID. Pour les exportations continues, ce champ est vide.
`finding`	Enregistrement d'informations d'évaluation, telles que la sécurité, les risques, l'état ou la confidentialité, qui sont ingérées dans Security Command Center pour la présentation, la notification, l'analyse, les tests de règles et l'application. Par exemple, une faille de script intersites (XSS) dans une application App Engine est un résultat. Pour en savoir plus sur les champs imbriqués, consultez la documentation de référence de l'API pour l'objet `Finding`.
`resource`	Informations concernant la ressource Google Cloud associée à ce résultat. Pour en savoir plus sur les champs imbriqués, consultez la documentation de référence de l'API pour l'objet `Resource`.

Coût

Des frais BigQuery liés à cette fonctionnalité vous seront 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 flux continu 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 des résultats dans 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, assurez-vous de 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. Elles ne peuvent pas être consultées ni modifiées dans 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 savoir comment utiliser Security Command Center lorsque la résidence des données est activée, consultez Points de terminaison régionaux Security Command Center.

Exportation de Security Command Center vers BigQuery

Lorsqu'un attribut d'un résultat est mis à jour dans Security Command Center, un instantané du résultat est pris, et Security Command Center tente d'envoyer cet instantané à BigQuery.

Cette tentative entraîne l'un des résultats suivants :

Si les attributs du résultat dans l'instantané correspondent au filtre d'exportation défini dans l'exportation BigQuery, l'instantané est envoyé à BigQuery, où il devient l'enregistrement actuel du résultat dans BigQuery.
Si les attributs du résultat ne correspondent pas au filtre, l'instantané n'est pas envoyé à BigQuery. Si un instantané précédent du résultat existe dans BigQuery, il reste le dernier enregistrement disponible dans l'ensemble de données, même s'il ne reflète pas les dernières mises à jour dans Security Command Center.

Par exemple, si le filtre d'une exportation BigQuery contient l'état actif, un résultat est généré avec l'état actif et un instantané du résultat est exporté vers BigQuery.

L'état de ce résultat dans Security Command Center est ensuite défini sur "Inactif". La mise à jour déclenche l'exportation d'un nouvel instantané du résultat vers BigQuery, mais comme la valeur de l'état ne correspond plus au filtre, celui-ci bloque l'exportation de l'instantané du résultat.

Par conséquent, l'instantané du résultat dans BigQuery est toujours à l'état actif, mais le même résultat dans Security Command Center est à l'état inactif.

Cela entraîne également une incohérence entre le nombre de résultats actifs dans Security Command Center et celui dans BigQuery. Le nombre de résultats actifs est presque toujours plus élevé dans BigQuery que dans Security Command Center.

Par exemple, si un filtre d'exportation spécifie l'état actif et que 100 résultats sont générés avec l'état actif, les 100 sont exportés vers BigQuery. Plus tard, dans Security Command Center, 50 de ces résultats sont définis comme inactifs. Le filtre bloque l'exportation déclenchée par les mises à jour, car la valeur de l'état ne correspond plus au filtre. Par conséquent, dans BigQuery, les 100 résultats sont toujours actifs, tandis que dans Security Command Center, seuls 50 résultats le restent.

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 :

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

Accéder à la bibliothèque d'API
Sélectionnez le projet pour lequel vous souhaitez activer l'API Security Command Center.
Dans le champ de recherche, saisissez Security Command Center, puis cliquez sur Security Command Center dans les résultats de recherche.
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 comptes principaux et les projets à partir desquels vous exportez les résultats. Les règles permettent d'accéder 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

Console

Accéder au périmètre de service

Dans la console Google Cloud , accédez à la page VPC Service Controls.

Accéder à VPC Service Controls
Sélectionner votre organisation.
Dans la liste déroulante, sélectionnez la règle d'accès contenant le périmètre de service auquel vous souhaitez accorder l'accès.

Les périmètres de service associés à la règle d'accès apparaissent dans la liste.
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
```
Cliquez sur Modifier.

Ajouter une règle de sortie

Cliquez sur Règle de sortie.
Cliquez sur Ajouter une règle de sortie.
Dans la section De, définissez les détails suivants :
1. Pour Identités > Identité, sélectionnez Sélectionner des identités et des groupes.
2. Cliquez sur Ajouter des identités.
3. Saisissez l'adresse e-mail qui identifie le principal utilisé pour appeler l'API Security Command Center.
4. Sélectionnez le compte principal ou appuyez sur ENTRÉE, puis cliquez sur Ajouter des identités.
Dans la section À, définissez les détails suivants :
1. Pour Ressources > Projets, sélectionnez Tous les projets.
2. Pour Opérations ou rôles IAM, sélectionnez Sélectionner des opérations.
3. Cliquez sur Ajouter des opérations, puis ajoutez les opérations suivantes :
  - Ajoutez le service bigquery.googleapis.com.
    1. Cliquez sur Tous les modes.
    2. Cliquez sur Ajouter toutes les méthodes.

Ajouter une règle d'entrée

Cliquez sur Règle d'entrée.
Cliquez sur Ajouter une règle d'entrée.
Dans la section De, définissez les détails suivants :
1. Pour Identités > Identité, sélectionnez Sélectionner des identités et des groupes.
2. Cliquez sur Ajouter des identités.
3. Saisissez l'adresse e-mail qui identifie le principal utilisé pour appeler l'API Security Command Center.
4. Sélectionnez le compte principal ou appuyez sur ENTRÉE, puis cliquez sur Ajouter des identités.
Dans la section À, définissez les détails suivants :
1. Pour Ressources > Projets, sélectionnez Sélectionner des projets.
2. Cliquez sur Ajouter des projets, puis ajoutez le projet contenant l'ensemble de données BigQuery.
3. Pour Opérations ou rôles IAM, sélectionnez Sélectionner des opérations.
4. Cliquez sur Ajouter des opérations, puis ajoutez les opérations suivantes :
  - Ajoutez le service bigquery.googleapis.com.
    1. Cliquez sur Tous les modes.
    2. Cliquez sur Ajouter toutes les méthodes.
Cliquez sur Enregistrer.

gcloud

Si aucun projet de quota n'est déjà défini, définissez-en un. Choisissez un projet pour lequel l'API Access Context Manager est activée.
```
gcloud config set billing/quota_project QUOTA_PROJECT_ID
```
Remplacez QUOTA_PROJECT_ID par l'ID du projet que vous souhaitez utiliser pour la facturation et le quota.

Créez un fichier nommé egress-rule.yaml avec le contenu suivant :

- egressFrom:
    identities:
    - PRINCIPAL_ID
  egressTo:
    operations:
    - serviceName: bigquery.googleapis.com
      methodSelectors:
      - method: '*'
    resources:
    - '*'

Remplacez PRINCIPAL_ID par l'identifiant du compte principal utilisé pour appeler l'API Security Command Center.

Créez un fichier nommé ingress-rule.yaml avec le contenu suivant :

- ingressFrom:
    identities:
    - PRINCIPAL_ID
    sources:
    - accessLevel: '*'
  ingressTo:
    operations:
    - serviceName: bigquery.googleapis.com
      methodSelectors:
      - method: '*'
    resources:
    - '*'

Remplacez PRINCIPAL_ID par l'identifiant du compte principal utilisé pour appeler l'API Security Command Center.

Ajoutez la règle de sortie au périmètre :
```
gcloud access-context-manager perimeters update PERIMETER_NAME \
    --set-egress-policies=egress-rule.yaml
```
Remplacez les éléments suivants :
- PERIMETER_NAME : nom du périmètre. Exemple : accessPolicies/1234567890/servicePerimeters/example_perimeter.
  
  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
```
Ajoutez la règle d'entrée au périmètre :
```
gcloud access-context-manager perimeters update PERIMETER_NAME \
    --set-ingress-policies=ingress-rule.yaml
```
Remplacez les éléments suivants :
- PERIMETER_NAME : nom du périmètre. Exemple : accessPolicies/1234567890/servicePerimeters/example_perimeter.
  
  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
```

Pour en savoir plus, consultez Règles d'entrée et de sortie.

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.

Remarque : Si vous migrez vers l'API Security Command Center v2, gardez à l'esprit que les ressources BigQueryExport créées avec l'API v1 ne sont pas visibles dans l'API v2. Pour en savoir plus, consultez Configurations de notifications et configurations BigQuery Export.

Pour gérer les ressources BigQueryExport créées avec l'API v1, ne spécifiez pas d'emplacement lorsque vous exécutez des commandes gcloud CLI. L'API v1 n'est pas compatible avec la résidence des données.

gcloud

Accédez à la console Google Cloud .

Accéder à la console Google Cloud
Sélectionnez le projet pour lequel vous avez activé l'API Security Command Center.
Cliquez sur Activer Cloud Shell.
Pour créer une configuration d'exportation, exécutez la commande suivante :
```
gcloud scc bqexports create BIGQUERY_EXPORT \
    --dataset=DATASET_NAME \
    --folder=FOLDER_ID | --organization=ORGANIZATION_ID | --project=PROJECT_ID \
    --location=LOCATION \
    [--description=DESCRIPTION] \
    [--filter=FILTER]
```
Remplacez les éléments suivants :
- BIGQUERY_EXPORT par le nom que vous souhaitez donner à cette configuration d'exportation.
- DATASET_NAME par le nom de l'ensemble de données BigQuery (par exemple, projects/PROJECT_ID/datasets/DATASET_ID).
- FOLDER_ID, ORGANIZATION_ID ou PROJECT_ID par le nom de votre dossier, organisation ou projet. Vous devez définir l'une de ces options. Pour les dossiers et les organisations, le nom est l'ID du dossier ou l'ID de l'organisation. Pour les projets, le nom est le numéro ou l'ID du projet.
- LOCATION : emplacement Security Command Center dans lequel créer une configuration d'exportation. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, utilisez la valeur global.
- DESCRIPTION par une description lisible de la configuration d'exportation. Cette variable est facultative.
- FILTER par une expression qui définit les résultats à inclure dans l'exportation. Par exemple, si vous souhaitez filtrer les résultats selon la catégorie XSS_SCRIPTING, saisissez "category=\"XSS_SCRIPTING\". Cette variable est facultative.

Terraform

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez Commandes Terraform de base. Pour en savoir plus, lisez la documentation de référence du fournisseur Terraform.

Créez une configuration d'exportation pour une organisation :

resource "google_bigquery_dataset" "default" {
  dataset_id                  = "my-dataset"
  friendly_name               = "test"
  description                 = "This is a test description"
  location                    = "US"
  default_table_expiration_ms = 3600000
  default_partition_expiration_ms = null

  labels = {
    env = "default"
  }

  lifecycle {
    ignore_changes = [default_partition_expiration_ms]
  }
}

resource "google_scc_v2_organization_scc_big_query_export" "custom_big_query_export_config" {
  name         = "my-export"
  big_query_export_id    = "my-export"
  organization = "123456789"
  dataset      = google_bigquery_dataset.default.id
  location     = "global"
  description  = "Cloud Security Command Center Findings Big Query Export Config"
  filter       = "state=\"ACTIVE\" AND NOT mute=\"MUTED\""
}

Créez une configuration d'exportation pour un dossier :

resource "google_folder" "folder" {
  parent       = "organizations/123456789"
  display_name = "folder-name"

  deletion_protection = false
}

resource "google_bigquery_dataset" "default" {
  dataset_id                  = "my_dataset_id"
  friendly_name               = "test"
  description                 = "This is a test description"
  location                    = "US"
  default_table_expiration_ms = 3600000
  default_partition_expiration_ms = null

  labels = {
    env = "default"
  }

  lifecycle {
    ignore_changes = [default_partition_expiration_ms]
  }
}

resource "google_scc_v2_folder_scc_big_query_export" "custom_big_query_export_config" {
  big_query_export_id    = "my-export"
  folder       = google_folder.folder.folder_id
  dataset      = google_bigquery_dataset.default.id
  location     = "global"
  description  = "Cloud Security Command Center Findings Big Query Export Config"
  filter       = "state=\"ACTIVE\" AND NOT mute=\"MUTED\""
}

Créez une configuration d'exportation pour un projet :

resource "google_bigquery_dataset" "default" {
  dataset_id                  = "my_dataset_id"
  friendly_name               = "test"
  description                 = "This is a test description"
  location                    = "US"
  default_table_expiration_ms = 3600000
  default_partition_expiration_ms = null

  labels = {
    env = "default"
  }

  lifecycle {
    ignore_changes = [default_partition_expiration_ms]
  }
}

resource "google_scc_v2_project_scc_big_query_export" "custom_big_query_export_config" {
  name         = "my-export"
  big_query_export_id    = "my-export"
  project      = "my-project-name"
  dataset      = google_bigquery_dataset.default.id
  location     = "global"
  description  = "Cloud Security Command Center Findings Big Query Export Config"
  filter       = "state=\"ACTIVE\" AND NOT mute=\"MUTED\""
}

Java

Pour vous authentifier auprès de Security Command Center, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer les ADC pour un environnement de développement local.


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;
    }
  }
}

Python



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'entrée 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.

Console

Accéder au périmètre de service

Ouvrez à nouveau le périmètre de service de la section précédente.

Accéder à VPC Service Controls

Ajouter une règle d'entrée

Cliquez sur Règle d'entrée.
Cliquez sur Ajouter une règle d'entrée.
Dans la section De, définissez les détails suivants :
1. Pour Identités > Identité, sélectionnez Sélectionner des identités et des groupes.
2. Cliquez sur Ajouter des identités.
3. Saisissez l'adresse e-mail qui identifie l'agent de service de configuration de l'exportation BigQuery. Cette adresse est au format suivant :
```
service-org-ORGANIZATION_ID@gcp-sa-scc-notification.iam.gserviceaccount.com
```
  Remplacez ORGANIZATION_ID par votre ID d'organisation.
4. Sélectionnez l'agent de service ou appuyez sur ENTRÉE, puis cliquez sur Ajouter des identités.
Dans la section À, définissez les détails suivants :
1. Pour Ressources > Projets, sélectionnez Sélectionner des projets.
2. Cliquez sur Ajouter des projets, puis ajoutez le projet contenant l'ensemble de données BigQuery.
3. Pour Opérations ou rôles IAM, sélectionnez Sélectionner des opérations.
4. Cliquez sur Ajouter des opérations, puis ajoutez les opérations suivantes :
  - Ajoutez le service bigquery.googleapis.com.
    1. Cliquez sur Tous les modes.
    2. Cliquez sur Ajouter toutes les méthodes.
Cliquez sur Enregistrer.

gcloud

Si aucun projet de quota n'est déjà défini, définissez-en un. Choisissez un projet pour lequel l'API Access Context Manager est activée.
```
gcloud config set billing/quota_project QUOTA_PROJECT_ID
```
Remplacez QUOTA_PROJECT_ID par l'ID du projet que vous souhaitez utiliser pour la facturation et le quota.

Créez un fichier nommé ingress-rule.yaml avec le contenu suivant :

- ingressFrom:
    identities:
    - serviceAccount:service-org-ORGANIZATION_ID@gcp-sa-scc-notification.iam.gserviceaccount.com
    sources:
    - accessLevel: '*'
  ingressTo:
    operations:
    - serviceName: bigquery.googleapis.com
      methodSelectors:
      - method: '*'
    resources:
    - '*'

Remplacez ORGANIZATION_ID par votre ID d'organisation.

Ajoutez la règle d'entrée au périmètre :
```
gcloud access-context-manager perimeters update PERIMETER_NAME \
    --set-ingress-policies=ingress-rule.yaml
```
Remplacez les éléments suivants :
- PERIMETER_NAME : nom du périmètre. Exemple : accessPolicies/1234567890/servicePerimeters/example_perimeter.
  
  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
```

Pour en savoir plus, consultez Règles d'entrée et de sortie.

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 compte 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

gcloud

Accédez à la console Google Cloud .

Accéder à la console Google Cloud
Sélectionnez le projet pour lequel vous avez activé l'API Security Command Center.
Cliquez sur Activer Cloud Shell .
Pour vérifier les détails de la configuration d'exportation, exécutez la commande suivante :
```
gcloud scc bqexports get BIGQUERY_EXPORT \
    --folder=FOLDER_ID | --organization=ORGANIZATION_ID | --project=PROJECT_ID \
    --location=LOCATION
```
Remplacez les éléments suivants :
- BIGQUERY_EXPORT par le nom de cette configuration d'exportation.
- FOLDER_ID, ORGANIZATION_ID ou PROJECT_ID par le nom de votre dossier, organisation ou projet. Vous devez définir l'une de ces options. Pour les dossiers et les organisations, le nom est l'ID du dossier ou l'ID de l'organisation. Pour les projets, le nom est le numéro ou l'ID du projet.
- LOCATION : emplacement Security Command Center dans lequel créer une configuration d'exportation. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, utilisez la valeur global.
  
  Par exemple, pour obtenir une configuration d'exportation nommée my-bq-export d'une organisation avec un ID d'organisation défini sur 123, exécutez :
```
gcloud scc bqexports get my-bq-export \
    --organization=123 \
    --location=global
```

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.

gcloud

Accédez à la console Google Cloud .

Accéder à la console Google Cloud
Sélectionnez le projet pour lequel vous avez activé l'API Security Command Center.
Cliquez sur Activer Cloud Shell.
Pour mettre à jour une configuration d'exportation, exécutez la commande suivante :
```
gcloud scc bqexports update BIGQUERY_EXPORT \
    --dataset=DATASET_NAME \
    --folder=FOLDER_ID | --organization=ORGANIZATION_ID | --project=PROJECT_ID \
    --location=LOCATION \
    [--description=DESCRIPTION] \
    [--filter=FILTER]
```
Remplacez les éléments suivants :
- BIGQUERY_EXPORT par le nom de la configuration d'exportation que vous souhaitez mettre à jour.
- DATASET_NAME par le nom de l'ensemble de données BigQuery (par exemple, projects/PROJECT_ID/datasets/DATASET_ID).
- FOLDER_ID, ORGANIZATION_ID ou PROJECT_ID par le nom de votre dossier, organisation ou projet. Vous devez définir l'une de ces options. Pour les dossiers et les organisations, le nom est l'ID du dossier ou l'ID de l'organisation. Pour les projets, le nom est le numéro ou l'ID du projet.
- LOCATION : emplacement Security Command Center dans lequel mettre à jour la configuration d'exportation. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, utilisez la valeur global.
- DESCRIPTION par une description lisible de la configuration d'exportation. Cette variable est facultative.
- FILTER par une expression qui définit les résultats à inclure dans l'exportation. Par exemple, si vous souhaitez filtrer les résultats selon la catégorie XSS_SCRIPTING, saisissez "category=\"XSS_SCRIPTING\". Cette variable est facultative.

Afficher toutes les configurations d'exportation

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

gcloud

Accédez à la console Google Cloud .

Accéder à la console Google Cloud
Sélectionnez le projet pour lequel vous avez activé l'API Security Command Center.
Cliquez sur Activer Cloud Shell.
Pour répertorier les configurations d'exportation, exécutez la commande suivante :
```
gcloud scc bqexports list \
    --folder=FOLDER_ID | --organization=ORGANIZATION_ID | --project=PROJECT_ID \
    --location=LOCATION \
    [--limit=LIMIT] \
    [--page-size=PAGE_SIZE]
```
Remplacez les éléments suivants :
- FOLDER_ID, ORGANIZATION_ID ou PROJECT_ID par le nom de votre dossier, organisation ou projet. Vous devez définir l'une de ces options. Pour les dossiers et les organisations, le nom est l'ID du dossier ou l'ID de l'organisation. Pour les projets, le nom est le numéro ou l'ID du projet.
  
  Si vous spécifiez un ID d'organisation, la liste inclut toutes les configurations d'exportation définies dans cette organisation, y compris celles au niveau du dossier et du projet. Si vous spécifiez un ID de dossier, la liste comprend toutes les configurations d'exportation définies au niveau du dossier et dans les projets de ce dossier. Si vous spécifiez un numéro ou un ID de projet, la liste n'inclut que les configurations d'exportation de ce projet.
- LOCATION : emplacement Security Command Center dans lequel lister les configurations d'exportation. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, utilisez la valeur global.
- LIMIT par le nombre de configurations d'exportation que vous souhaitez afficher. Cette variable est facultative.
- PAGE_SIZE par une valeur de taille de page. Cette variable est facultative.

Java


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;
    }
  }
}

Python

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.

gcloud

Accédez à la console Google Cloud .

Accéder à la console Google Cloud
Sélectionnez le projet pour lequel vous avez activé l'API Security Command Center.
Cliquez sur Activer Cloud Shell.
Pour supprimer une configuration d'exportation, exécutez la commande suivante :
```
gcloud scc bqexports delete BIGQUERY_EXPORT \
    --folder=FOLDER_ID | --organization=ORGANIZATION_ID | --project=PROJECT_ID \
    --location=LOCATION
```
Remplacez les éléments suivants :
- BIGQUERY_EXPORT par le nom de la configuration d'exportation que vous souhaitez supprimer.
- FOLDER_ID, ORGANIZATION_ID ou PROJECT_ID par le nom de votre dossier, organisation ou projet. Vous devez définir l'une de ces options. Pour les dossiers et les organisations, le nom est l'ID du dossier ou l'ID de l'organisation. Pour les projets, le nom est le numéro ou l'ID du projet.
- LOCATION : emplacement Security Command Center dans lequel supprimer la configuration d'exportation. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, utilisez la valeur global.
  
  Par exemple, pour supprimer une configuration d'exportation nommée my-bq-export d'une organisation avec un ID d'organisation défini sur 123, exécutez la commande suivante :
```
gcloud scc bqexports delete my-bq-export \
    --organization=123 \
    --location=global
```

Java


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);
    }
  }
}

Python

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 Data 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 :

Accédez au projet dans BigQuery.

Accéder à BigQuery
Sélectionnez un projet.
Dans le volet Explorateur, développez le nœud de votre projet.
Développez votre ensemble de données.
Cliquez sur la table des résultats.
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 page 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 Data Studio

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

En général, l'accès à BigQuery via Data Studio entraîne des frais d'utilisation BigQuery. Pour en savoir plus, consultez la page Visualiser des données BigQuery à l'aide de Data 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 :

Ouvrez Data Studio et connectez-vous.
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.
Cliquez sur Rapport vide.
Dans l'onglet Se connecter aux données, cliquez sur la fiche BigQuery.
Si vous y êtes invité, autorisez Data Studio à accéder aux projets BigQuery.
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.
Une fois le rapport ajouté, cliquez sur Ajouter un graphique.
Cliquez sur Histogramme empilé, puis sur la zone dans laquelle vous souhaitez le placer.
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.

Étapes suivantes

Découvrez comment créer une exportation groupée vers BigQuery.
Découvrez comment exécuter une requête dans BigQuery.

Insérer les résultats en flux continu dans BigQuery à des fins d'analyse Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

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