Cette page a été traduite par l'API Cloud Translation.

Envoyer des données de Security Command Center à Elastic Stack à l'aide de Docker

Cette page explique comment utiliser un conteneur Docker pour héberger une installation Elastic Stack, et envoyer automatiquement les résultats, les éléments, les journaux d'audit et les sources de sécurité de Security Command Center à Elastic Stack. Elle décrit également comment gérer les données exportées.

Docker est une plate-forme permettant de gérer les applications en conteneurs. Elastic Stack est une plate-forme de gestion des informations et des événements de sécurité (SIEM, Security Information and Event Management) qui ingère des données provenant d'une ou de plusieurs sources. Elle permet aux équipes de sécurité de gérer les réponses aux incidents et d'effectuer des analyses en temps réel. La configuration Elastic Stack décrite dans ce guide comprend quatre composants :

Filebeat : agent léger installé sur des hôtes périphériques, tels que des machines virtuelles (VM), pouvant être configuré pour collecter et transférer des données.
Logstash : service de transformation qui ingère les données, les mappe dans les champs obligatoires et transmet les résultats à Elasticsearch.
Elasticsearch : moteur de recherche de base de données qui stocke des données.
Kibana : génère des tableaux de bord permettant de visualiser et d'analyser des données.

Dans ce guide, vous allez configurer Docker, vérifier que les services Security Command Center et Google Cloud requis sont correctement configurés, et utiliser un module personnalisé pour envoyer des résultats, des éléments, des journaux d'audit et des sources de sécurité à Elastic Stack.

La figure suivante illustre le cheminement des données lors de l'utilisation d'Elastic Stack avec Security Command Center.

Intégration de Security Command Center et d'Elastic Stack (cliquez pour agrandir)

Configurer l'authentification et l'autorisation

Avant de vous connecter à Elastic Stack, vous devez créer un Compte de service Identity and Access Management (IAM) dans chaque organisation Google Cloud que vous souhaitez connecter, et attribuez à ce compte des autorisations au niveau de l'organisation et au niveau du projet Rôles IAM dont Elastic Stack a besoin.

Créer un compte de service et attribuer des rôles IAM

Les étapes suivantes utilisent la console Google Cloud. Pour découvrir d'autres méthodes, consultez les liens à la fin de cette section.

Suivez ces étapes pour chaque organisation Google Cloud dans laquelle vous souhaitez importer Security Command Center des données.

Dans le projet dans lequel vous créez vos sujets Pub/Sub, utilisez la page Comptes de service de la console Google Cloud pour créer un compte de service. Pour obtenir des instructions, consultez la page Créer et gérer des comptes de service.
Attribuez les rôles suivants au compte de service :
- Administrateur Pub/Sub (roles/pubsub.admin)
- Propriétaire d'éléments Cloud (roles/cloudasset.owner)
Copiez le nom du compte de service que vous venez de créer.
Utilisez le sélecteur de projet dans la console Google Cloud pour passer au niveau de l'organisation.
Ouvrez la page IAM de l'organisation :

Accéder à IAM
Sur la page IAM, cliquez sur Accorder l'accès. Le panneau "Accorder l'accès" s'affiche.
Dans le panneau Accorder l'accès, procédez comme suit :
1. Dans la section Ajouter des comptes principaux du champ Nouveaux comptes principaux, collez le nom du compte de service.
2. Dans la section Attribuer des rôles, utilisez le champ Rôle pour attribuer les rôles IAM suivants au compte de service :
  - Éditeur administrateur du centre de sécurité (roles/securitycenter.adminEditor)
  - Éditeur de configuration des notifications du centre de sécurité (roles/securitycenter.notificationConfigEditor)
  - Lecteur d'organisation (roles/resourcemanager.organizationViewer)
  - Lecteur d'éléments Cloud (roles/cloudasset.viewer)
  - Rédacteur de configuration des journaux (roles/logging.configWriter)
3. Cliquez sur Enregistrer. Le compte de sécurité s'affiche dans l'onglet Autorisations de la page IAM sous Afficher par compte principal.
  
  Par héritage, le compte de service devient également un principal dans tous les projets enfants de l'organisation, et les rôles applicables au niveau du projet sont listés comme des rôles hérités.

Pour plus d'informations sur la création de comptes de service et l'attribution de rôles, consultez les rubriques suivantes :

Fournir les identifiants à Elastic Stack

Selon l'emplacement où vous hébergez Elastic Stack, la manière dont vous fournissez Les identifiants IAM diffèrent pour Elastic Stack.

Si vous hébergez le conteneur Docker dans Google Cloud, envisagez d'utiliser suivantes:
- Ajouter le service votre compte la VM qui hébergera vos nœuds Kubernetes. Si vous utilisez plusieurs Organisations Google Cloud, ajoutez ce compte de service à l'autre organisations et lui octroyons les rôles IAM décrits aux étapes 5 à 7 de la section Créer un compte de service et accorder rôles.
- Si vous déployez le conteneur Docker dans un périmètre de service, créez les règles d'entrée et de sortie. Pour obtenir des instructions, consultez la section Accorder l'accès à un périmètre dans VPC Service Controls.
Si vous hébergez le conteneur Docker dans votre environnement sur site, créez une clé de compte de service pour chaque organisation Google Cloud. Vous avez besoin des clés de compte de service au format JSON pour suivre ce guide.

Pour découvrir les bonnes pratiques permettant de stocker les clés de compte de service de manière sécurisée, consultez la page Bonnes pratiques pour la gestion des clés de compte de service.
Si vous installez le conteneur Docker dans un autre cloud, configurez la fédération d'identité de charge de travail et téléchargez les fichiers de configuration des identifiants. Si vous utilisez plusieurs organisations Google Cloud, ajoutez ce compte de service aux autres organisations et attribuez-lui les rôles IAM décrits aux étapes 5 à 7 de la section Créer un compte de service et attribuer des rôles IAM.

Configurer les notifications

Suivez ces étapes pour chaque organisation Google Cloud dans laquelle vous souhaitez importer Security Command Center des données.

Configurez les notifications de résultats en tant que ce qui suit:
1. Activez l'API Security Command Center.
2. Créez un filtre pour exporter les résultats et les éléments souhaités.
3. Créer quatre sujets Pub/Sub: un pour chacun d'eux les résultats, les ressources, les journaux d'audit et les éléments. NotificationConfig devez utiliser le sujet Pub/Sub que vous avez créé pour les résultats.
Vous aurez besoin de l'ID de votre organisation, de l'ID du projet et des noms des sujets Pub/Sub de cette tâche pour configurer Elastic Stack.
Activez l'API Cloud Asset pour votre projet.

Installer les composants Docker et Elasticsearch

Suivez cette procédure pour installer les composants Docker et Elasticsearch dans votre environnement.

Installer Docker Engine et Docker Compose

Vous pouvez installer Docker pour l'utiliser sur site ou avec un fournisseur cloud. Pour commencer, suivez les guides suivants de la documentation Docker :

Installer Elasticsearch et Kibana

L'image Docker que vous avez installée dans la section Installer Docker inclut Logstash et Filebeat. Si vous n'avez pas encore installé Elasticsearch et Kibana, suivez les guides suivants pour installer les applications :

Pour suivre ce guide, vous avez besoin des informations suivantes incluses dans ces tâches :

Elastic Stack: hôte, port, certificat, nom d'utilisateur et mot de passe
Kibana : hôte, port, certificat, nom d'utilisateur et mot de passe

Télécharger le module GoApp

Cette section explique comment télécharger le module GoApp, un programme Go géré par Security Command Center. Le module automatise le processus de planification des appels de l'API Security Command Center et récupère régulièrement les données de Security Command Center à utiliser dans Elastic Stack.

Pour installer GoApp, procédez comme suit :

Dans une fenêtre de terminal, installez wget, un utilitaire de logiciel gratuit permettant de récupérer le contenu des serveurs Web.

Pour les distributions Ubuntu et Debian, exécutez la commande suivante :
```
  # apt-get install wget
```
Pour les distributions RHEL, CentOS et Fedora, exécutez la commande suivante :
```
  # yum install wget
```
Installez unzip, un utilitaire de logiciel gratuit permettant d'extraire le contenu des fichiers ZIP.

Pour les distributions Ubuntu et Debian, exécutez la commande suivante :
```
# apt-get install unzip
```
Pour les distributions RHEL, CentOS et Fedora, exécutez la commande suivante :
```
# yum install unzip
```
Créez un répertoire pour le package d'installation GoogleSCCElasticIntegration :
```
mkdir GoogleSCCElasticIntegration
```

Téléchargez le package d'installation GoogleSCCElasticIntegration :

wget -c https://storage.googleapis.com/security-center-elastic-stack/GoogleSCCElasticIntegration-Installation.zip

Extrayez le contenu du package d'installation GoogleSCCElasticIntegration dans le répertoire GoogleSCCElasticIntegration :
```
unzip GoogleSCCElasticIntegration-Installation.zip -d GoogleSCCElasticIntegration
```
Créez un répertoire de travail pour stocker et exécuter les composants du module GoApp :
```
mkdir WORKING_DIRECTORY
```
Remplacez WORKING_DIRECTORY par le nom du répertoire.
Accédez au répertoire d'installation GoogleSCCElasticIntegration :
```
cd ROOT_DIRECTORY/GoogleSCCElasticIntegration/
```
Remplacez ROOT_DIRECTORY par le chemin d'accès au répertoire contenant le répertoire GoogleSCCElasticIntegration.
Déplacez install, config.yml, dashboards.ndjson et le dossier templates (contenant les fichiers filebeat.tmpl, logstash.tmpl et docker.tmpl) dans votre espace de travail. .
```
mv install/install install/config.yml install/templates/docker.tmpl install/templates/filebeat.tmpl install/templates/logstash.tmpl install/dashboards.ndjson WORKING_DIRECTORY
```
Remplacez WORKING_DIRECTORY par le chemin d'accès au répertoire de travail.

Installer le conteneur Docker

Pour configurer le conteneur Docker, vous devez télécharger et installer une image préformatée à partir de Google Cloud, contenant Logstash et Filebeat. Pour en savoir plus sur l'image Docker, accédez au dépôt Container Registry dans la console Google Cloud.

Accéder à Container Registry

Lors de l'installation, vous configurez le module GoApp avec les identifiants Security Command Center et Elastic Stack.

Accédez à votre répertoire de travail :
```
cd /WORKING_DIRECTORY
```
Remplacez WORKING_DIRECTORY par le chemin d'accès au répertoire de travail.

Vérifiez que les fichiers suivants apparaissent dans votre répertoire de travail :

  ├── config.yml
  ├── install
  ├── dashboards.ndjson
  ├── templates
      ├── filebeat.tmpl
      ├── docker.tmpl
      ├── logstash.tmpl

Dans un éditeur de texte, ouvrez le fichier config.yml et ajoutez les variables demandées. Si une variable n'est pas requise, vous pouvez la laisser vide.

Variable	Description	Obligatoire
`elasticsearch`	Section de votre configuration Elasticsearch.	Obligatoire
`host`	Adresse IP de votre hôte Elastic Stack.	Obligatoire
`password`	Votre mot de passe Elasticsearch.	Facultatif
`port`	Port de votre hôte Elastic Stack.	Obligatoire
`username`	Votre nom d'utilisateur Elasticsearch.	Facultatif
`cacert`	Certificat du serveur Elasticsearch (par exemple, `path/to/cacert/elasticsearch.cer`)	Facultatif
`http_proxy`	Un lien avec le nom d'utilisateur, le mot de passe, l'adresse IP et le port de votre hôte proxy (par exemple, `http://USER:PASSWORD@PROXY_IP:PROXY_PORT`).	Facultatif
`kibana`	Section de votre configuration Kibana.	Obligatoire
`host`	Adresse IP ou nom d'hôte auquel le serveur Kibana sera lié.	Obligatoire
`password`	Votre mot de passe Kibana	Facultatif
`port`	Port du serveur Kibana.	Obligatoire
`username`	Votre nom d'utilisateur Kibana.	Facultatif
`cacert`	Certificat du serveur Kibana (par exemple, `path/to/cacert/kibana.cer`)	Facultatif
`cron`	Section de votre configuration Cron.	Facultatif
`asset`	Section de la configuration Cron de l'élément (par exemple, `0 /45 * * *`).	Facultatif
`source`	Section de votre configuration Cron source (par exemple, `0 /45 * * *`). Pour en savoir plus, consultez Générateur d'expressions Cron.	Facultatif
`organizations`	Section de configuration de votre organisation Google Cloud. Pour ajouter plusieurs organisations Google Cloud, copiez tout le contenu de `- id:` vers `subscription_name` sous `resource`.	Obligatoire
`id`	Votre ID d'organisation.	Obligatoire
`client_credential_path`	Au choix : Chemin d'accès à votre fichier JSON, si vous utilisez des clés de compte de service. Fichier de configuration des identifiants, si vous utilisez la fédération d'identité de charge de travail, comme décrit dans la section Avant de commencer. Ne spécifiez rien si c'est l'organisation Google Cloud dans laquelle vous installez le conteneur Docker.	Facultatif, selon votre environnement
`update`	Définit si vous effectuez ou non une mise à niveau à partir d'une version antérieure ; `n` pour non ou `y` pour oui	Facultatif
`project`	Section de votre ID de projet.	Obligatoire
`id`	ID du projet contenant le sujet Pub/Sub.	Obligatoire
`auditlog`	Section du sujet Pub/Sub et de l'abonnement pour les journaux d'audit.	Facultatif
`topic_name`	Nom du sujet Pub/Sub pour les journaux d'audit	Facultatif
`subscription_name`	Nom de l'abonnement Pub/Sub pour les journaux d'audit	Facultatif
`findings`	Section du sujet et de l'abonnement Pub/Sub pour les résultats.	Facultatif
`topic_name`	Nom du sujet Pub/Sub pour les résultats.	Facultatif
`start_date`	Date facultative à partir de laquelle commencer la migration des résultats (par exemple, `2021-04-01T12:00:00+05:30`)	Facultatif
`subscription_name`	Nom de l'abonnement Pub/Sub pour les résultats.	Facultatif
`asset`	Section de configuration de l'élément.	Facultatif
`iampolicy`	Section sur le sujet et l'abonnement Pub/Sub pour les stratégies IAM.	Facultatif
`topic_name`	Nom du sujet Pub/Sub pour les stratégies IAM.	Facultatif
`subscription_name`	Le nom de l'abonnement Pub/Sub pour Stratégies IAM.	Facultatif
`resource`	Section du sujet Pub/Sub et de l'abonnement pour les ressources.	Facultatif
`topic_name`	Nom du sujet Pub/Sub pour les ressources.	Facultatif
`subscription_name`	Nom de l'abonnement Pub/Sub pour les ressources.	Facultatif

Fichier `config.yml` d'exemple

L'exemple suivant montre un fichier config.yml incluant deux organisations Google Cloud.

elasticsearch:
  host: 127.0.0.1
  password: changeme
  port: 9200
  username: elastic
  cacert: path/to/cacert/elasticsearch.cer
http_proxy: http://user:password@proxyip:proxyport
kibana:
  host: 127.0.0.1
  password: changeme
  port: 5601
  username: elastic
  cacert: path/to/cacert/kibana.cer
cron:
  asset: 0 */45 * * * *
  source: 0 */45 * * * *
organizations:
  – id: 12345678910
    client_credential_path:
    update:
    project:
      id: project-id-12345
    auditlog:
      topic_name: auditlog.topic_name
      subscription_name: auditlog.subscription_name
    findings:
      topic_name: findings.topic_name
      start_date: 2021-05-01T12:00:00+05:30
      subscription_name: findings.subscription_name
    asset:
      iampolicy:
        topic_name: iampolicy.topic_name
        subscription_name: iampolicy.subscription_name
      resource:
        topic_name: resource.topic_name
        subscription_name: resource.subscription_name
  – id: 12345678911
    client_credential_path:
    update:
    project:
      id: project-id-12346
    auditlog:
      topic_name: auditlog2.topic_name
      subscription_name: auditlog2.subscription_name
    findings:
      topic_name: findings2.topic_name
      start_date: 2021-05-01T12:00:00+05:30
      subscription_name: findings1.subscription_name
    asset:
      iampolicy:
        topic_name: iampolicy2.topic_name
        subscription_name: iampolicy2.subscription_name
      resource:
        topic_name: resource2.topic_name
        subscription_name: resource2.subscription_name

Exécutez les commandes suivantes pour installer l'image Docker et configurer le module GoApp.
```
chmod +x install
./install
```
Le module GoApp télécharge l'image Docker, installe l'image et configure le conteneur.

Une fois le processus terminé, copiez l'adresse e-mail du compte de service WriterIdentity à partir du résultat d'installation.

docker exec googlescc_elk ls
docker exec googlescc_elk cat Sink_&#125;&#125;HashId&#123;&#123;

La structure de votre répertoire de travail doit se présenter comme suit :

  ├── config.yml
  ├── dashboards.ndjson
  ├── docker-compose.yml
  ├── install
  ├── templates
      ├── filebeat.tmpl
      ├── logstash.tmpl
      ├── docker.tmpl
  └── main
      ├── client_secret.json
      ├── filebeat
      │          └── config
      │                   └── filebeat.yml
      ├── GoApp
      │       └── .env
      └── logstash
                 └── pipeline
                            └── logstash.conf

Mettre à jour les autorisations pour les journaux d'audit

Procédez comme suit pour mettre à jour les autorisations, afin que les journaux d'audit puissent transiter par votre solution SIEM :

Accédez à la page des sujets Pub/Sub.

Accéder à Pub/Sub
Sélectionnez le projet qui inclut vos sujets Pub/Sub.
Sélectionnez le sujet Pub/Sub que vous avez créé pour les journaux d'audit.
Dans Autorisations, ajoutez le compte de service WriterIdentity (que vous avez copié à l'étape 4 de la procédure d'installation) en tant que nouveau compte principal et attribuez-lui le rôle Éditeur Pub/Sub. La stratégie des journaux d'audit est mise à jour.

Les configurations Docker et Elastic Stack sont terminées. Vous pouvez maintenant configurer Kibana.

Afficher les journaux Docker

Ouvrez un terminal et exécutez la commande suivante pour afficher les informations de votre conteneur, y compris ses ID. Notez l'ID du conteneur dans lequel Elastic Stack est installé.
```
docker container ls
```
Pour démarrer un conteneur et afficher ses journaux, exécutez les commandes suivantes :
```
docker exec -it CONTAINER_ID /bin/bash
cat go.log
```
Remplacez CONTAINER_ID par l'ID du conteneur dans lequel Elastic Stack est installé.

Configurer Kibana

Effectuez ces étapes lorsque vous installez le conteneur Docker pour la première fois.

Ouvrez kibana.yml dans un éditeur de texte.
```
sudo vim KIBANA_DIRECTORY/config/kibana.yml
```
Remplacez KIBANA_DIRECTORY par le chemin d'accès à votre dossier d'installation Kibana.
Mettez à jour les variables suivantes :
- server.port : port à utiliser pour le serveur backend Kibana. La valeur par défaut est 5601.
- server.host : adresse IP ou nom d'hôte auquel le serveur Kibana sera lié.
- elasticsearch.hosts : adresse IP et port de l'instance Elasticsearch à utiliser pour les requêtes.
- server.maxPayloadBytes : taille maximale de la charge utile en octets pour les requêtes de serveur entrantes. La valeur par défaut est 1 048 576.
- url_drilldown.enabled : valeur booléenne qui contrôle la possibilité de passer du tableau de bord Kibana aux URL internes ou externes. La valeur par défaut est true.
La configuration terminée ressemble à ce qui suit :
```
  server.port: PORT
  server.host: "HOST"
  elasticsearch.hosts: ["http://ELASTIC_IP_ADDRESS:ELASTIC_PORT"]
  server.maxPayloadBytes: 5242880
  url_drilldown.enabled: true
```

Importer des tableaux de bord Kibana

Ouvrez l'application Kibana.
Dans le menu de navigation, accédez à Stack Management (Gestion de la pile), puis cliquez sur Saved Objects (Objets enregistrés).
Cliquez sur Import (Importer), accédez au répertoire de travail et sélectionnez dashboards.ndjson. Les tableaux de bord sont importés et des schémas d'index sont créés.

Mettre à jour le conteneur Docker

Si vous avez déployé une version antérieure du module GoApp, vous pouvez passer à une version plus récente. Lorsque vous mettez à jour le conteneur Docker vers une version plus récente, vous pouvez conserver la configuration existante de votre compte de service, les sujets Pub/Sub et les composants Elasticsearch.

Si vous effectuez une mise à niveau à partir d'une intégration qui n'a pas utilisé de conteneur Docker, consultez la section Passer à la dernière version.

Si vous passez de la version 1, procédez comme suit :
1. Ajoutez le rôle Rédacteur de configuration des journaux (roles/logging.configWriter) au compte de service.
2. Créez un sujet Pub/Sub pour vos journaux d'audit.
Si vous installez le conteneur Docker dans un autre cloud, configurez la fédération d'identité de charge de travail et téléchargez le fichier de configuration des identifiants.
Si vous le souhaitez, pour éviter les problèmes lors de l'importation des nouveaux tableaux de bord, supprimez les tableaux de bord existants de Kibana :
1. Ouvrez l'application Kibana.
2. Dans le menu de navigation, accédez à Stack Management (Gestion de la pile), puis cliquez sur Saved Objects (Objets enregistrés).
3. Recherchez Google SCC.
4. Sélectionnez tous les tableaux de bord à supprimer.
5. Cliquez sur Supprimer.
Supprimez le conteneur Docker existant :
1. Ouvrez un terminal et arrêtez le conteneur :
```
docker stop CONTAINER_ID
```
  Remplacez CONTAINER_ID par l'ID du conteneur dans lequel Elastic Stack est installé.
2. Supprimez le conteneur Docker :
```
docker rm CONTAINER_ID
```
  Si nécessaire, ajoutez -f avant l'ID du conteneur pour forcer sa suppression.
Suivez les étapes 1 à 7 de la section Télécharger le module GoApp.
Déplacez le fichier config.env existant de votre installation précédente dans le répertoire \update.
Si nécessaire, autorisez le fichier exécutable à exécuter ./update:
```
chmod +x ./update
./update
```
Exécutez ./update pour convertir config.env en config.yml.
Vérifiez que le fichier config.yml inclut votre configuration existante. Si ce n'est pas le cas, réexécutez ./update.
Pour accepter plusieurs organisations Google Cloud, ajoutez une autre configuration d'organisation au fichier config.yml.
Déplacez le fichier config.yml dans votre répertoire de travail, où se trouve le fichier install.
Suivez la procédure décrite dans la section Installer Docker.
Suivez la procédure décrite dans la section Mettre à jour les autorisations pour les journaux d'audit.
Importez les nouveaux tableaux de bord, comme décrit dans la section Importer des tableaux de bord Kibana. Cette étape va écraser vos tableaux de bord Kibana existants.

Afficher et modifier les tableaux de bord Kibana

Vous pouvez utiliser des tableaux de bord personnalisés dans Elastic Stack pour visualiser et analyser vos résultats, vos éléments et vos sources de sécurité. Les tableaux de bord affichent les résultats critiques et aident votre équipe de sécurité à hiérarchiser les correctifs.

Tableau de bord Overview (Vue d'ensemble)

Le tableau de bord Vue d'ensemble contient une série de graphiques qui affichent le total Nombre de résultats dans vos organisations Google Cloud par niveau de gravité, catégorie et état. Les résultats sont compilés à partir des services intégrés de Security Command Center, tels que Security Health Analytics, Web Security Scanner, Event Threat Detection et Container Threat Detection, ainsi que de tous les services intégrés que vous activez.

Vous pouvez sélectionner la classe de résultats (Finding class) pour filtrer le contenu en fonction de critères tels que des erreurs de configuration ou des failles.

D'autres graphiques indiquent les catégories, les projets et les éléments qui génèrent le plus de résultats.

Tableau de bord Assets (Éléments)

Le tableau de bord Assets (Éléments) affiche des tables qui présentent vos éléments Google Cloud. Les tables indiquent les propriétaires des éléments, le nombre d'éléments par type de ressource et par projet, ainsi que les derniers éléments ajoutés et mis à jour.

Vous pouvez filtrer les données d'élément par organisation, nom, type et parents, et afficher rapidement les résultats correspondant à des éléments spécifiques. Si vous cliquez sur le nom d'un élément, vous êtes redirigé vers la page Éléments de Security Command Center dans la console Google Cloud, sur laquelle vous pouvez voir les détails de l'élément sélectionné.

Tableau de bord Audit logs (Journaux d'audit)

Le tableau de bord Audit logs (Journaux d'audit) affiche une série de graphiques et de tableaux présentant les informations des journaux d'audit. Les journaux d'audit inclus dans le tableau de bord sont l'activité d'administration, l'accès aux données, les événements système et les journaux d'audit de refus de règles. Le tableau indique l'horodatage, la gravité, le type de journal, le nom du journal, le nom du service, ainsi que le nom et le type de la ressource.

Vous pouvez filtrer les données par organisation, par source (par exemple un projet), par gravité, par type de journal et par type de ressource.

Tableau de bord Findings (Résultats)

Le tableau de bord Findings (Résultats) inclut un graphique affichant les résultats les plus récents. Les graphiques fournissent des informations sur le nombre de résultats, leur gravité, leur catégorie et leur état. Vous pouvez également afficher les résultats actifs au fil du temps, et identifier les projets ou ressources contenant le plus de résultats.

Vous pouvez filtrer les données par organisation et par classe de résultat.

Si vous cliquez sur le nom d'un résultat, vous êtes redirigé vers la page Résultats de Security Command Center dans la console Google Cloud, sur laquelle vous pouvez voir les détails du résultat sélectionné.

Tableau de bord Sources

Le tableau de bord Sources indique le nombre total de résultats et de sources de sécurité, le nombre de résultats par nom de source et une table de toutes les sources de sécurité. Les colonnes de la table incluent le nom, le nom à afficher et la description.

Ajouter des colonnes

Accédez à un tableau de bord.
Cliquez sur Edit (Modifier), puis sur Edit visualization (Modifier la visualisation).
Sous Add sub-bucket (Ajouter un sous-bucket), sélectionnez Split rows (Scinder les lignes).
Dans la liste, sélectionnez l'agrégation Termes.
Dans le menu déroulant Descending (Décroissant), sélectionnez un ordre croissant ou décroissant. Dans le champ Size (Taille), saisissez le nombre maximal de lignes de la table.
Sélectionnez la colonne que vous souhaitez ajouter, puis cliquez sur Mettre à jour.
Enregistrez les modifications.

Masquer ou supprimer des colonnes

Accédez au tableau de bord.
Cliquez sur Modifier.
Pour masquer une colonne, cliquez sur l'icône de visibilité (ou en forme d'œil) à côté de son nom.
Pour supprimer une colonne, cliquez sur l'icône de suppression X à côté de son nom.

Désinstaller l'intégration avec Elasticsearch

Renseignez les sections suivantes pour supprimer l'intégration entre Security Command Center et Elasticsearch.

Supprimer des tableaux de bord, des indices et des formats d'index

Supprimez les tableaux de bord lorsque vous souhaitez désinstaller cette solution.

Accédez aux tableaux de bord.
Recherchez Google SCC et sélectionnez tous les tableaux de bord.
Cliquez sur Supprimer les tableaux de bord.
Accédez à Gestion de la pile > Gestion des index
Fermez les index suivants:
- gccassets
- gccfindings
- gccsources
- gccauditlogs
Accédez à Gestion de la pile > Formats d'index.
Fermez les formats suivants:
- gccassets
- gccfindings
- gccsources
- gccauditlogs

Désinstaller Docker

Supprimez la NotificationConfig pour Pub/Sub. Pour trouver le nom de NotificationConfig, exécutez la commande suivante :
```
docker exec googlescc_elk ls
docker exec googlescc_elk cat NotificationConf_&#125;&#125;HashId&#123;&#123;
```
Supprimez les flux Pub/Sub des éléments, des résultats, des stratégies IAM et des journaux d'audit. Pour trouver les noms des flux, exécutez la commande suivante :
```
docker exec googlescc_elk ls
docker exec googlescc_elk cat Feed_&#125;&#125;HashId&#123;&#123;
```
Supprimez le récepteur des journaux d'audit. Pour trouver le nom du récepteur, exécutez la commande suivante :
```
docker exec googlescc_elk ls
docker exec googlescc_elk cat Sink_&#125;&#125;HashId&#123;&#123;
```
Pour afficher les informations sur votre conteneur, y compris ses ID, ouvrez le terminal et exécutez la commande suivante :
```
docker container ls
```
Arrêtez le conteneur :
```
docker stop CONTAINER_ID
```
Remplacez CONTAINER_ID par l'ID du conteneur dans lequel Elastic Stack est installé.
Supprimez le conteneur Docker :
```
docker rm CONTAINER_ID
```
Si nécessaire, ajoutez -f avant l'ID du conteneur pour forcer sa suppression.

Supprimez l'image Docker :

docker rmi us.gcr.io/security-center-gcr-host/googlescc_elk_v3:latest

Supprimez le répertoire de travail et le fichier docker-compose.yml:
```
rm -rf ./main docker-compose.yml
```

Étape suivante

En savoir plus sur la configuration la recherche de notifications dans Security Command Center.
Découvrez comment filtrer les notifications de résultats dans Security Command Center.