Configurer des notifications de recherche

>

Activez la fonctionnalité de notification de l'API Security Command Center. Les notifications envoient des informations à un sujet Pub/Sub afin de fournir des mises à jour sur les résultats et de nouveaux résultats en quelques minutes. Étant donné que Security Command Center fonctionne au niveau de l'organisation, les notifications de l'API Security Command Center incluent toutes les informations sur les résultats affichées dans le tableau de bord de Security Command Center.

Vous pouvez associer des notifications Pub/Sub de Security Command Center directement à des actions Cloud Functions. Pour obtenir des exemples de fonctions de sécurité capables de réponse, d'enrichissement et de résolution, consultez l'exemple d'application Alertes des outils de Security Command Center.

Avant de commencer

  • Pour activer les notifications de l'API Security Command Center, vous devez disposer du rôle IAM Administrateur du centre de sécurité.
  • Pour accéder au tableau de bord Security Command Center, vous devez disposer du rôle IAM Lecteur administrateur du centre de sécurité.
  • Pour attribuer des rôles appropriés au compte de service des notifications ou au compte de l'outil gcloud, vous devez disposer du rôle IAM Administrateur de l'organisation.

Apprenez-en plus sur les rôles Security Command Center.

Configurer les notifications de l'API Security Command Center

Pour configurer les notifications, 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 dans Cloud Console.
    Accéder à la page "Bibliothèque d'API"
  2. Sélectionnez le projet pour lequel vous souhaitez activer l'API de notifications.
  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. Utilisez ensuite l'outil gcloud ou les bibliothèques clientes pour vous abonner à un sujet Pub/Sub et configurer les autorisations.

Configurer un sujet Pub/Sub

Lors de cette étape, vous allez créer et vous abonner au sujet Pub/Sub auquel vous souhaitez envoyer des notifications. Si vous n'avez pas besoin d'appeler l'API par programmation, les commandes de l'outil gcloud sont recommandées, car elles sont plus faciles à configurer.

gcloud

Pour configurer la fonctionnalité de notifications de l'API Security Command Center à l'aide de l'outil gcloud, procédez comme suit :

  1. Configurez un sujet et un abonnement Pub/Sub.
  2. Configurez les autorisations du compte de l'outil gcloud.

Étape 1 : Configurer Pub/Sub

Pour configurer un sujet Pub/Sub et vous y abonner, procédez comme suit :

  1. Accédez à Google Cloud Console.
    Accéder à Google Cloud Console
  2. Sélectionnez le projet pour lequel vous avez activé l'API Security Command Center.
  3. Cliquez sur Activer Cloud Shell
  4. Créez un sujet ou réutilisez un sujet existant. Pour créer un sujet, procédez come suit :

       gcloud pubsub topics create topic-id
    
  5. Définissez les variables d'environnement :

    1. Définissez l'ID du sujet :

        export TOPIC_ID=topic-id
      
  6. Créez un abonnement associé au sujet :

       gcloud pubsub subscriptions create subscription-id --topic topic-id
    

Pour en savoir plus sur la configuration de Pub/Sub, consultez la page Gérer les sujets et les abonnements. Vous devez ensuite définir des autorisations pour votre compte.

Étape 2 : Configurer les autorisations du compte de l'outil gcloud

Pour créer un objet NotificationConfig, vous devez disposer des rôles IAM (Identity and Access Management) suivants sur le compte de l'outil gcloud :

  • roles/securitycenter.admin ou roles/securitycenter.notificationConfigEditor
  • roles/pubsub.admin sur le sujet Pub/Sub qui reçoit des notifications

Pour accorder ces autorisations, procédez comme suit :

  1. Accédez à Google Cloud Console.
    Accéder à Google Cloud Console
  2. Sélectionnez le projet pour lequel vous avez activé l'API Security Command Center.
  3. Cliquez sur Activer Cloud Shell

    1. Définissez le nom de votre organisation :

        export ORGANIZATION_ID=organization-id
      
    2. Définissez l'ID du projet auquel appartient le sujet Pub/Sub :

        export PUBSUB_PROJECT=project-id
      
    3. Définissez le compte d'outil gcloud que vous utilisez :

        export GCLOUD_ACCOUNT=your-username@email.com
      
    4. Définissez l'ID du sujet ou utilisez le sujet défini à l'étape 1.

        export TOPIC_ID=topic-id
      
    5. Attribuez au compte de l'outil gcloud un rôle Pub/Sub disposant de l'autorisation pubsub.topics.setIamPolicy :

        gcloud pubsub topics add-iam-policy-binding \
          projects/$PUBSUB_PROJECT/topics/$TOPIC_ID \
          --member="user:$GCLOUD_ACCOUNT" \
          --role='roles/pubsub.admin'
      
    6. Attribuez au compte de l'outil gcloud un rôle pour l'organisation qui inclut toutes les autorisations securitycenter.notification, telles que roles/securitycenter.notificationConfigEditor ou roles/securitycenter.admin.

        gcloud organizations add-iam-policy-binding $ORGANIZATION_ID \
          --member="user:$GCLOUD_ACCOUNT" \
          --role='role-name'
      

Vous devez ensuite créer un objet NotificationConfig.

Bibliothèques clientes

Pour configurer la fonctionnalité de notifications de l'API Security Command Center à l'aide des bibliothèques clientes, procédez comme suit :

  1. Configurez un compte de service.
  2. Téléchargez les bibliothèques clientes de l'API.
  3. Configurez un environnement de développement.
  4. Configurez un sujet et un abonnement Pub/Sub.

Étape 1 : Configurer un compte de service

La fonctionnalité de notifications de l'API Security Command Center utilise un compte de service disposant des autorisations appropriées pour configurer les notifications. Ce compte de service n'est utilisé que pour la mise en place initiale d'une configuration. Vous pouvez le réutiliser pour créer d'autres configurations de notifications ultérieurement. Ce compte est distinct du compte de service qui a été créé lors de la configuration de Security Command Center.

Pour créer un compte de service :

  1. Accédez à Google Cloud Console.
    Accéder à Google Cloud Console
  2. Sélectionnez le projet pour lequel vous avez activé l'API Security Command Center.
  3. Cliquez sur Activer Cloud Shell
  4. Définissez les variables d'environnement :

    1. Définissez le nom de votre organisation :

        export ORGANIZATION_ID=organization-id
      
    2. Définissez l'ID du projet dans lequel vous souhaitez activer l'API de notifications :

        export PROJECT_ID=project-id
      
    3. Définissez l'ID personnalisé que vous souhaitez utiliser pour le nouveau compte de service, par exemple scc-notifications. Le nom du compte de service doit comporter entre 6 et 30 caractères, commencer par une lettre, et ne se composer que de caractères alphanumériques et de tirets :

        export SERVICE_ACCOUNT=custom-id
      
    4. Définissez le chemin d'accès à la clé du compte de service, par exemple export KEY_LOCATION=/home/$USER/mykeys/$SERVICE_ACCOUNT.json :

        export KEY_LOCATION=full-key-location-path
        # This is used by client libraries to find the key
        export GOOGLE_APPLICATION_CREDENTIALS=$KEY_LOCATION
      
  5. Créez un compte de service associé à votre ID de projet :

       gcloud iam service-accounts create $SERVICE_ACCOUNT  --display-name \
        "Service Account for [USER]"  --project $PROJECT_ID
    
  6. Créez une clé à associer au compte de service. La clé est utilisée lorsque vous créez un objet NotificationConfig et est stockée de manière permanente à l'emplacement KEY_LOCATION que vous avez spécifié lors des étapes précédentes.

       gcloud iam service-accounts keys create $KEY_LOCATION  --iam-account \
        $SERVICE_ACCOUNT@$PROJECT_ID.iam.gserviceaccount.com
    
  7. Attribuez au compte de service un rôle pour l'organisation qui inclut toutes les autorisations securitycenter.notification, telles que roles/securitycenter.notificationConfigEditor ou roles/securitycenter.admin.

       gcloud beta organizations add-iam-policy-binding $ORGANIZATION_ID \
         --member="serviceAccount:$SERVICE_ACCOUNT@$PROJECT_ID.iam.gserviceaccount.com" \
         --role='role-name'
    

Le compte de service est maintenant configuré pour être utilisé avec les notifications, et la clé du compte de service est stockée à l'emplacement KEY_LOCATION que vous avez spécifié. Pour en savoir plus sur les comptes de service, consultez la page Créer et gérer les clés de comptes de service.

Étape 2 : Configurer un environnement de développement

Pour utiliser la fonctionnalité de notifications de l'API Security Command Center, vous pouvez utiliser l'outil gcloud ou télécharger les bibliothèques clientes et configurer votre environnement de développement pour le langage de votre choix.

Python

  1. Facultatif : avant d'installer la bibliothèque Python, nous vous recommandons d'utiliser Virtualenv pour créer un environnement Python isolé.

     virtualenv your-env
     source your-env/bin/activate
    
  2. Installez pip pour gérer l'installation de la bibliothèque Python.

  3. Exécutez les commandes suivantes pour installer la bibliothèque Python :

     pip install google-cloud-securitycenter
    

Java

Pour inclure la bibliothèque Java Security Command Center en tant que dépendance dans votre projet, sélectionnez un artefact dans le dépôt Maven. Les notifications sont incluses dans la version 0.119.0 et ultérieures de la bibliothèque.

Si vous utilisez Intellij, définissez la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS sur le chemin absolu de la clé du compte de service des notifications que vous avez téléchargé lors des étapes précédentes :

  1. Dans Intellij, cliquez sur Exécuter > Modifier les configurations.
  2. Définissez la variable suivante sous Application > Run_Configuration_For_Sample > Variables d'environnement :

      GOOGLE_APPLICATION_CREDENTIALS=absolute-path-to-service-account-key
    

Go

Pour installer les dépendances Go de l'API de notifications, exécutez la commande suivante :

Pour télécharger la bibliothèque Go, exécutez la commande suivante :

  go get -u cloud.google.com/go/securitycenter/apiv1

Node.js

Dans le dossier du projet, utilisez npm pour installer les dépendances nécessaires à l'API de notifications :

  npm install --save @google-cloud/security-center/

Étape 3 : Configurer Pub/Sub

Pour envoyer des notifications à Pub/Sub, vous devez vous abonner à un sujet Pub/Sub et attribuer au compte de service des notifications un rôle IAM incluant l'autorisation pubsub.topics.setIamPolicy :

  1. Créez un sujet ou réutilisez un sujet existant. Pour créer un sujet, procédez come suit :

       gcloud pubsub topics create topic-id
    
  2. Définissez les variables d'environnement :

    1. Définissez l'ID du sujet :

        export TOPIC_ID=topic-id
      
    2. Définissez l'ID du projet dans lequel vous avez activé l'API de notifications :

        export CONSUMER_PROJECT=project-id
      
    3. Définissez l'adresse e-mail du compte de service que vous avez créé lors des étapes précédentes :

        export SERVICE_ACCOUNT_EMAIL=service-account-name@$CONSUMER_PROJECT.iam.gserviceaccount.com
      
  3. Créez un abonnement associé au sujet :

       gcloud pubsub subscriptions create subscription-id --topic topic-id
    
  4. Attribuez au compte de service des notifications un rôle doté de l'autorisation pubsub.topics.setIamPolicy :

       gcloud pubsub topics add-iam-policy-binding \
         projects/$CONSUMER_PROJECT/topics/$TOPIC_ID \
         --member="serviceAccount:$SERVICE_ACCOUNT_EMAIL" \
         --role='roles/pubsub.admin'
    

Pour en savoir plus sur la configuration de Pub/Sub, consultez la page Gérer les sujets et les abonnements. À l'étape suivante, vous allez terminer la configuration en créant un objet NotificationConfig.

Créer un objet NotificationConfig

Avant de créer un objet NotificationConfig, tenez compte des points suivants :

  • Chaque organisation peut avoir un nombre limité de fichiers NotificationConfig. Pour en savoir plus, consultez la page Quotas et limites.
  • Vous devez disposer du rôle IAM Administrateur de l'organisation pour pouvoir attribuer les rôles appropriés au compte de service des notifications ou au compte de l'outil gcloud.

L'objet NotificationConfig inclut un champ filter qui limite les notifications aux événements utiles. Ce champ accepte tous les filtres disponibles dans la méthode findings.list de l'API Security Command Center.

Pour attribuer au compte le rôle IAM Éditeur des configurations des notifications du centre de sécurité à l'aide de l'outil de ligne de commande gcloud, procédez comme suit :

  1. Définissez les variables d'environnement :

    1. Définissez le nom de votre organisation :

        export ORGANIZATION_ID=organization-id
      
    2. Définissez l'adresse e-mail du compte de service que vous avez créé lors de la configuration des notifications de résultats ou du compte que vous utilisez pour exécuter les commandes de l'outil gcloud :

      • Définissez l'adresse e-mail du compte utilisé pour exécuter les commandes de l'outil gcloud :

        export EMAIL=your-username@email.com
        
      • Ou définissez l'adresse e-mail du compte de service :

        export EMAIL=service-account-name@$CONSUMER_PROJECT.iam.gserviceaccount.com
        
  2. Attribuez le rôle nécessaire au compte de service ou au compte que vous avez utilisé avec les commandes de l'outil gcloud :

    • Accordez le rôle au compte utilisé pour exécuter les commandes de l'outil gcloud :

         gcloud organizations add-iam-policy-binding \
           $ORGANIZATION_ID \
           --member="user:$EMAIL" \
           --role='roles/securitycenter.notificationConfigEditor'
           ```
      
    • Ou attribuez le rôle au compte de service :

         gcloud organizations add-iam-policy-binding \
           $ORGANIZATION_ID \
           --member="serviceAccount:$EMAIL" \
           --role='roles/securitycenter.notificationConfigEditor'
           ```
      

Après avoir accordé les autorisations au compte de service ou au compte de l'outil gcloud, créez l'objet NotificationConfig à l'aide du langage ou de la plate-forme de votre choix :

gcloud

  # The numeric ID of the organization
  ORGANIZATION_ID=organization-id

  # The topic to which the notifications are published
  PUBSUB_TOPIC="projects/project-id/topics/topic-id"

  # The description for the NotificationConfig
  DESCRIPTION="Notifies for active findings"

  # Filters for active findings
  FILTER="state=\"ACTIVE\""

  gcloud alpha scc notifications create notification-name \
    --organization "$ORGANIZATION_ID" \
    --description "$DESCRIPTION" \
    --pubsub-topic $PUBSUB_TOPIC \
    --filter "$FILTER"

Python

from google.cloud import securitycenter as securitycenter

client = securitycenter.SecurityCenterClient()

# TODO: organization_id = "your-org-id"
# TODO: notification_config_id = "your-config-id"
# TODO: pubsub_topic = "projects/{your-project-id}/topics/{your-topic-ic}"
# Ensure this ServiceAccount has the "pubsub.topics.setIamPolicy" permission on the new topic.

org_name = "organizations/{org_id}".format(org_id=organization_id)

created_notification_config = client.create_notification_config(
    org_name,
    notification_config_id,
    {
        "description": "Notification for active findings",
        "pubsub_topic": pubsub_topic,
        "streaming_config": {"filter": 'state = "ACTIVE"'},
    },
)

print(created_notification_config)

Java

import com.google.cloud.securitycenter.v1.CreateNotificationConfigRequest;
import com.google.cloud.securitycenter.v1.NotificationConfig;
import com.google.cloud.securitycenter.v1.NotificationConfig.StreamingConfig;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import java.io.IOException;
  public static NotificationConfig createNotificationConfig(
      String organizationId, String notificationConfigId, String projectId, String topicName)
      throws IOException {
    // String organizationId = "{your-org-id}";
    // String notificationConfigId = {"your-unique-id"};
    // String projectId = "{your-project}"";
    // String topicName = "{your-topic}";

    String orgName = String.format("organizations/%s", organizationId);

    // Ensure this ServiceAccount has the "pubsub.topics.setIamPolicy" permission on the topic.
    String pubsubTopic = String.format("projects/%s/topics/%s", projectId, topicName);

    try (SecurityCenterClient client = SecurityCenterClient.create()) {
      CreateNotificationConfigRequest request =
          CreateNotificationConfigRequest.newBuilder()
              .setParent(orgName)
              .setConfigId(notificationConfigId)
              .setNotificationConfig(
                  NotificationConfig.newBuilder()
                      .setDescription("Java notification config")
                      .setPubsubTopic(pubsubTopic)
                      .setStreamingConfig(
                          StreamingConfig.newBuilder().setFilter("state = \"ACTIVE\"").build())
                      .build())
              .build();

      NotificationConfig response = client.createNotificationConfig(request);
      System.out.println(String.format("Notification config was created: %s", response));
      return response;
    }
  }

Go

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv1"
	securitycenterpb "google.golang.org/genproto/googleapis/cloud/securitycenter/v1"
)

func createNotificationConfig(w io.Writer, orgID string, pubsubTopic string, notificationConfigID string) error {
	// orgID := "your-org-id"
	// pubsubTopic := "projects/{your-project}/topics/{your-topic}"
	// notificationConfigID := "your-config-id"

	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)

	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %v", err)
	}
	defer client.Close()

	req := &securitycenterpb.CreateNotificationConfigRequest{
		Parent:   fmt.Sprintf("organizations/%s", orgID),
		ConfigId: notificationConfigID,
		NotificationConfig: &securitycenterpb.NotificationConfig{
			Description: "Go sample config",
			PubsubTopic: pubsubTopic,
			NotifyConfig: &securitycenterpb.NotificationConfig_StreamingConfig_{
				StreamingConfig: &securitycenterpb.NotificationConfig_StreamingConfig{
					Filter: `state = "ACTIVE"`,
				},
			},
		},
	}

	notificationConfig, err := client.CreateNotificationConfig(ctx, req)
	if err != nil {
		return fmt.Errorf("Failed to create notification config: %v", err)
	}
	fmt.Fprintln(w, "New NotificationConfig created: ", notificationConfig)

	return nil
}

Node.js

// npm install @google-cloud/security-center/
const {SecurityCenterClient} = require('@google-cloud/security-center');

const client = new SecurityCenterClient();

// organizationId = "your-org-id";
// configId = "your-config-name";
// pubsubTopic = "projects/{your-project}/topics/{your-topic}";
// Ensure this Service Account has the "pubsub.topics.setIamPolicy" permission on this topic.

const orgName = client.organizationPath(organizationId);

async function createNotificationConfig() {
  const [response] = await client.createNotificationConfig({
    parent: orgName,
    configId: configId,
    notificationConfig: {
      description: 'Sample config for node.js',
      pubsubTopic: pubsubTopic,
      streamingConfig: {filter: 'state = "ACTIVE"'},
    },
  });
  console.log('Notification config creation succeeded: ', response);
}

createNotificationConfig();

PHP

use Google\Cloud\SecurityCenter\V1\SecurityCenterClient;
use Google\Cloud\SecurityCenter\V1\NotificationConfig;
use Google\Cloud\SecurityCenter\V1\NotificationConfig\StreamingConfig;

/** Uncomment and populate these variables in your code */
// $organizationId = "{your-org-id}";
// $notificationConfigId = {"your-unique-id"};
// $projectId = "{your-project}"";
// $topicName = "{your-topic}";

$securityCenterClient = new SecurityCenterClient();
$organizationName = $securityCenterClient::organizationName($organizationId);
$pubsubTopic = $securityCenterClient::topicName($projectId, $topicName);

$streamingConfig = (new StreamingConfig())->setFilter("state = \"ACTIVE\"");
$notificationConfig = (new NotificationConfig())
    ->setDescription('A sample notification config')
    ->setPubsubTopic($pubsubTopic)
    ->setStreamingConfig($streamingConfig);

$response = $securityCenterClient->createNotificationConfig(
    $organizationName,
    $notificationConfigId,
    $notificationConfig
);
printf('Notification config was created: %s' . PHP_EOL, $response->getName());

Ruby

require "google/cloud/security_center"

# Your organization id. e.g. for "organizations/123", this would be "123".
# org_id = "YOUR_ORGANZATION_ID"

# Your notification config id. e.g. for
# "organizations/123/notificationConfigs/my-config" this would be "my-config".
# config_id = "YOUR_CONFIG_ID"

# The PubSub topic where notifications will be published.
# pubsub_topic = "YOUR_TOPIC"

client = Google::Cloud::SecurityCenter.security_center

org_path = client.organization_path organization: org_id

notification_config = {
  description:      "Sample config for Ruby",
  pubsub_topic:     pubsub_topic,
  streaming_config: { filter: 'state = "ACTIVE"' }
}

response = client.create_notification_config(
  parent:              org_path,
  config_id:           config_id,
  notification_config: notification_config
)
puts "Created notification config #{config_id}: #{response}."

C#


using Google.Api.Gax.ResourceNames;
using Google.Cloud.SecurityCenter.V1;
using System;

///<summary> Create NotificationConfig Snippet. </summary>
public class CreateNotificationConfigSnippets
{
    public static NotificationConfig CreateNotificationConfig(
        string organizationId, string notificationConfigId, string projectId, string topicName)
    {
        OrganizationName orgName = new OrganizationName(organizationId);
        TopicName pubsubTopic = new TopicName(projectId, topicName);

        SecurityCenterClient client = SecurityCenterClient.Create();
        CreateNotificationConfigRequest request = new CreateNotificationConfigRequest
        {
            ParentAsOrganizationName = orgName,
            ConfigId = notificationConfigId,
            NotificationConfig = new NotificationConfig
            {
                Description = ".Net notification config",
                PubsubTopicAsTopicName = pubsubTopic,
                StreamingConfig = new NotificationConfig.Types.StreamingConfig { Filter = "state = \"ACTIVE\"" }
            }
        };

        NotificationConfig response = client.CreateNotificationConfig(request);
        Console.WriteLine($"Notification config was created: {response}");
        return response;
    }
}

Les notifications sont maintenant publiées sur le sujet Pub/Sub que vous avez spécifié. Pour publier des notifications, Security Command Center utilise un compte de service au niveau de l'organisation sous la forme service-org-organization-id@gcp-sa-scc-notification.iam.gserviceaccount.com avec le rôle securitycenter.notificationServiceAgent. Ce rôle de compte de service au niveau de l'organisation est requis pour que les notifications fonctionnent.

Lors des étapes précédentes, vous avez soit créé un compte de service des notifications au niveau du projet sous la forme service-account-id@project-id.iam.gserviceaccount.com, soit employé un compte utilisateur avec l'outil gcloud. Vous pouvez éventuellement révoquer les autorisations que vous avez accordées à ce compte. Pour en savoir plus, consultez la page Attribuer, modifier et révoquer les accès dans la documentation IAM.

Étape suivante