Configurer et gérer des pipelines de traitement de données

Compatible avec :

La fonctionnalité Traitement des données vous offre un contrôle robuste et pré-analytique sur l'ingestion des données Google Security Operations. Vous pouvez filtrer les événements, transformer les champs ou masquer les valeurs sensibles pour optimiser la compatibilité des données, réduire les coûts et protéger les informations sensibles dans Google SecOps.

Ce document vous guide tout au long du workflow complet d'ingestion et de traitement des données à l'aide de la console Bindplane. Vous pouvez ainsi apprendre à :

  • Configurez la connexion à une instance de destination Google SecOps.
  • Créez un pipeline Google SecOps.
  • Configurer le traitement des données, y compris les flux et les processeurs
  • Déployez le pipeline pour lancer l'ingestion et le traitement des données.
  • Surveillez les flux et les processeurs de pipeline dans la console Google SecOps.

Vous pouvez configurer le traitement des flux de données sur site et dans le cloud à l'aide de la console de gestion Bindplane ou directement à l'aide des API Google SecOps Data Pipeline publiques.

Le traitement des données comprend les éléments suivants :

  • Flux : un ou plusieurs flux alimentent le pipeline de traitement des données. Chaque flux est configuré pour un type de flux spécifique.
  • Nœud de processeur : le traitement des données comporte un nœud de processeur qui contient un ou plusieurs processeurs. Chaque processeur spécifie une action à effectuer sur les données (par exemple, filtrer, transformer et masquer) lorsqu'elles transitent par le pipeline.
  • Destination : l'instance de destination Google SecOps est l'endroit où les données traitées sont envoyées.

Cas d'utilisation

Voici quelques exemples de cas d'utilisation :

  • Supprimez les paires clé-valeur vides des journaux bruts.
  • Masquer les données sensibles.
  • Ajoutez des libellés d'ingestion à partir du contenu brut des journaux.
  • Dans les environnements à plusieurs instances, appliquez des libellés d'ingestion aux données de journaux à ingestion directe pour identifier l'instance de flux source (par exemple,Google Cloud Workspace).
  • Filtrez les données Palo Alto Cortex par valeurs de champ.
  • Réduisez les données SentinelOne par catégorie.
  • Extrayez les informations sur l'hôte des journaux de flux et d'ingestion directe, puis mappez-les au champ ingestion_source pour Cloud Monitoring.

Prérequis

Si vous prévoyez d'utiliser la console Bindplane pour gérer le traitement de vos données Google SecOps, procédez comme suit :

  1. Dans la console Google Security Operations, accordez à l'installateur les rôles d'administrateur prédéfinis requis. Pour en savoir plus, consultez Attribuer le rôle d'administrateur IAM de projet dans un projet dédié.

  2. Sous Attribuer des rôles, sélectionnez les rôles IAM (Identity and Access Management) prédéfinis suivants :

    • Administrateur de l'API Chronicle (roles/chronicle.admin)

  3. Installez la console Bindplane Server. Pour SaaS ou sur site, consultez Installer la console Bindplane Server.

  4. Dans la console Bindplane, connectez une instance de destination Google SecOps à votre projet Bindplane. Pour en savoir plus, consultez Se connecter à une instance Google SecOps.

Gérer les délais de confirmation des données SecOps à faible volume

Les utilisateurs de l'API d'ingestion qui configurent leur propre agent peuvent constater une augmentation du temps d'accusé de réception pour les pipelines SecOps à faible volume dans le pipeline de traitement des données.

Les latences moyennes peuvent passer de 700 ms à 2 secondes. Augmentez les délais d'attente et la mémoire si nécessaire. Le temps d'accusé de réception diminue lorsque le débit de données dépasse 4 Mo.

Se connecter à une instance Google SecOps

Avant de commencer, vérifiez que vous disposez des autorisations d'administrateur de projet Bindplane pour accéder à la page Intégrations de projet.

L'instance Google SecOps sert de destination pour les données générées.

Pour vous connecter à une instance Google SecOps à l'aide de la console Bindplane, procédez comme suit :

  1. Dans la console Bindplane, accédez à la page Gérer votre projet.
  2. Accédez à la fiche Intégrations, puis cliquez sur Se connecter à Google SecOps pour ouvrir la fenêtre Modifier l'intégration.

  3. Saisissez les informations concernant l'instance de destination Google SecOps.
     : cette instance ingère les données traitées (résultats du traitement des données), comme suit :

    Champ Description
    Région Région de votre instance Google SecOps.
     Pour trouver l'instance dans la consoleGoogle Cloud , accédez à Sécurité > Détections et contrôles > Google Security Operations > Détails de l'instance.
    Numéro client Numéro client de votre instance Google SecOps.

    Dans la console Google SecOps, accédez à Paramètres du SIEM > Profil > Détails de l'organisation.
    Google Cloud  : numéro du projet Google Cloud Numéro de projet de votre instance Google SecOps.

    Pour trouver le numéro de projet dans la console Google SecOps, accédez à Paramètres SIEM > Profil > Détails de l'organisation.
    Identifiants Les identifiants de compte de service sont la valeur JSON requise pour s'authentifier et accéder aux API Google SecOps Data Pipeline. Récupérez cette valeur JSON à partir du fichier d'identifiants du compte de service Google.

     Le compte de service doit se trouver dans le même Google Cloud projet que votre instance Google SecOps et nécessite les droits du rôle Administrateur de l'API Chronicle (roles/chronicle.admin).

     Pour savoir comment créer un compte de service et télécharger le fichier JSON, consultez Créer et supprimer des clés de compte de service.

  4. Cliquez sur Se connecter. Si vos informations de connexion sont correctes et que vous parvenez à vous connecter à Google SecOps, vous pouvez vous attendre à ce qui suit :

    • Une connexion à l'instance Google SecOps s'ouvre.
    • La première fois que vous vous connectez, SecOps Pipelines s'affiche dans la console Bindplane.
    • La console Bindplane affiche toutes les données traitées que vous avez précédemment configurées pour cette instance à l'aide de l'API. Le système convertit certains processeurs que vous avez configurés à l'aide de l'API en processeurs Bindplane, et affiche les autres dans leur format brut OpenTelemetry Transformation Language (OTTL). Vous pouvez utiliser la console Bindplane pour modifier les pipelines et les processeurs précédemment configurés à l'aide de l'API.

  5. Une fois que vous avez créé une connexion à une instance Google SecOps, vous pouvez créer un pipeline SecOps et configurer le traitement des données à l'aide de la console Bindplane.

Configurer le traitement des données à l'aide de la console Bindplane

La console Bindplane vous permet de gérer vos données traitées Google SecOps, y compris les pipelines configurés à l'aide de l'API.

Avant de commencer

Avant de commencer, nous vous recommandons de lire ces recommandations importantes :

  • Les flux basés sur le push qui appellent l'API Backstory sont obsolètes et ne prennent plus en charge le traitement des données. Migrez vos intégrations pour utiliser l'API Chronicle Ingestion.
  • Pour installer la console Bindplane pour la première fois ou pour connecter une instance de destination Google SecOps à votre projet Bindplane, consultez Conditions requises.
  • Au lieu d'utiliser la console Bindplane, vous pouvez appeler directement les API Google SecOps pour configurer et gérer le traitement des données. Pour en savoir plus, consultez Utiliser les API Google SecOps Data Pipeline.
  • Les données ingérées à partir des forwarders et de Bindplane sont taguées avec un collectorID distinct des flux d'ingestion directe. Pour bénéficier d'une visibilité complète des journaux, vous devez sélectionner toutes les méthodes d'ingestion lorsque vous interrogez des sources de données ou référencer explicitement le collectorID concerné lorsque vous interagissez avec l'API.

Pour provisionner et déployer un nouveau pipeline de traitement des journaux dans Google SecOps, généralement à l'aide de la console Bindplane, procédez comme suit :

  1. Créez un pipeline SecOps.
  2. Configurez le traitement des données.
    1. Configurez les flux.
    2. Configurer les processeurs
  3. Déployez un pipeline de traitement des données.

Créer un pipeline Google SecOps

Un pipeline Google SecOps est un conteneur qui vous permet de configurer un conteneur de traitement des données. Pour créer un conteneur de pipeline Google SecOps :

  1. Dans la console Bindplane, cliquez sur l'onglet Pipelines SecOps pour ouvrir la page Pipelines SecOps.
  2. Cliquez sur Create SecOps Pipeline (Créer un pipeline SecOps).
  3. Dans la fenêtre Create new SecOps Pipeline (Créer un pipeline SecOps), définissez le SecOps Pipeline type (Type de pipeline SecOps) sur Google SecOps (par défaut).

  4. Saisissez un Nom du pipeline SecOps et une Description.

  5. Cliquez sur Créer. Vous pouvez voir le nouveau conteneur de pipeline sur la page Pipelines SecOps.

  6. Configurez les flux et les processeurs du conteneur de traitement des données.

Configurer un conteneur de traitement des données

Un conteneur de traitement des données spécifie les flux de données à ingérer et les processeurs (par exemple, filtrer, transformer ou masquer) pour manipuler les données lorsqu'elles sont transférées vers l'instance Destination Google SecOps.

Une fiche de configuration de pipeline est une visualisation du pipeline de traitement des données dans laquelle vous pouvez configurer les flux de données et le nœud de processeur :

  • Un flux ingère les données en fonction des spécifications configurées et les transmet au conteneur. Un conteneur de traitement des données peut comporter un ou plusieurs flux, chacun étant configuré pour un flux différent.
  • Le nœud de traitement se compose de processeurs qui manipulent les données lorsqu'elles sont transmises à l'instance Destination Google SecOps.

Pour configurer un conteneur de traitement des données :

  1. Créez un pipeline SecOps.
  2. Dans la console Bindplane, cliquez sur l'onglet Pipelines SecOps pour ouvrir la page Pipelines SecOps.
  3. Sélectionnez le pipeline SecOps dans lequel vous souhaitez configurer le nouveau conteneur de traitement des données.

  4. Sur la fiche de configuration Pipeline :

    1. Ajoutez un flux.
    2. Configurez le nœud de processeur. Pour ajouter un processeur à l'aide de la console Bindplane, consultez Configurer des processeurs pour en savoir plus.

  5. Une fois ces configurations terminées, consultez Déployer le traitement des données pour commencer à traiter les données.

Ajouter un flux

Pour ajouter un flux :

  1. Dans la fiche de configuration Pipeline, cliquez sur Ajouter Ajouter un flux pour ouvrir la fenêtre Créer un flux.

  2. Dans la fenêtre Créer un flux SecOps, saisissez les informations suivantes :

    Champ Description
    Type de journal Sélectionnez le type de journal des données à ingérer. Exemple :CrowdStrike Falcon (CS_EDR)
    Remarque : L'icône Avertissement indique que le type de journal est déjà configuré dans un autre flux (dans ce pipeline ou dans un autre pipeline de votre instance Google SecOps).

    Pour utiliser un type de journal indisponible, vous devez d'abord le supprimer de l'autre configuration de flux.

     Pour savoir comment trouver la configuration du flux dans laquelle le type de journal est configuré, consultez Filtrer les configurations de pipeline SecOps.
    Méthode d'ingestion Sélectionnez la méthode d'ingestion à utiliser pour ingérer les données du type de journal sélectionné. Ces méthodes d'ingestion ont été précédemment définies pour votre instance Google SecOps.

    Vous devez sélectionner l'une des options suivantes :

    • Toutes les méthodes d'ingestion : inclut toutes les méthodes d'ingestion pour le type de journal sélectionné. Lorsque vous sélectionnez cette option, vous ne pouvez plus ajouter de flux ultérieurs qui utilisent des méthodes d'ingestion spécifiques pour ce même type de journal. Exception : Vous pouvez sélectionner d'autres méthodes d'ingestion spécifiques non configurées pour ce type de journal dans d'autres flux.
    • Méthode d'ingestion spécifique, telle que Cloud Native Ingestion, Feed, Ingestion API ou Workspace.
    Flux Si vous sélectionnez Feed comme méthode d'ingestion, un champ s'affiche avec la liste des noms de flux disponibles (préconfigurés dans votre instance Google SecOps) pour le type de journal sélectionné. Vous devez sélectionner le flux concerné pour terminer la configuration. Pour afficher et gérer vos flux disponibles, accédez à Paramètres SIEM > Tableau des flux.

  3. Cliquez sur Ajouter un flux pour enregistrer le nouveau flux de données.Il s'affiche immédiatement sur la fiche de configuration Pipeline. Le flux est automatiquement connecté au nœud du processeur et à la destination Google SecOps.

Filtrer les configurations du pipeline SecOps

La barre de recherche de la page Pipelines SecOps vous permet de filtrer et de localiser vos pipelines SecOps (conteneurs de traitement des données) en fonction de plusieurs éléments de configuration. Vous pouvez filtrer les pipelines en recherchant des critères spécifiques, tels que le type de journal, la méthode d'ingestion ou le nom du flux.

Utilisez la syntaxe suivante pour filtrer :

  • logtype:value
  • ingestionmethod:value
  • feed:value

Par exemple, pour identifier les configurations de flux qui contiennent un type de journal spécifique, saisissez logtype: dans la barre de recherche, puis sélectionnez le type de journal dans la liste qui s'affiche.

Configurer les processeurs

Un conteneur de traitement des données comporte un nœud de processeur, qui contient un ou plusieurs processeurs. Chaque processeur manipule les données du flux de manière séquentielle :

  1. Le premier processeur traite les données brutes du flux.
  2. La sortie du premier processeur devient immédiatement l'entrée du processeur suivant de la séquence.
  3. Cette séquence se poursuit pour tous les processeurs suivants, dans l'ordre exact dans lequel ils apparaissent dans le volet Processeurs, la sortie de l'un devenant l'entrée du suivant.

Le tableau suivant répertorie les processeurs :

Type de processeur Capacité
Filtre Filtrer par condition
Filtre Filtrer par code d'état HTTP
Filtre Filtrer par nom de métrique
Filtre Filtrer par expression régulière
Filtre Filtrer par gravité
Occultation Masquer les données sensibles
Transformer Ajouter des champs
Transformer Coalesce
Transformer Concat
Transformer Copier le champ
Transformer Supprimer des champs
Transformer Marshal
Transformer Déplacer un champ
Transformer Analyser un fichier CSV
Transformer Analyser le code JSON
Transformer Analyser la clé-valeur
Transformer Analyser les champs de gravité
Transformer Analyse du code temporel
Transformer Analyser avec une expression régulière
Transformer Parse XML
Transformer renommer les champs ;
Transformer Réécrire le code temporel
Transformer Diviser
Transformer Transformer
  1. Configurez le nœud de processeur en ajoutant, en supprimant ou en modifiant la séquence d'un ou plusieurs processeurs.

Ajouter un processeur

Pour ajouter un processeur, procédez comme suit :

  1. Dans la fiche de configuration Pipeline, cliquez sur le nœud Processeur pour ouvrir la fenêtre Modifier les processeurs. La fenêtre Modifier les processeurs est divisée en plusieurs volets, organisés par flux de données :

    • Entrée (ou données sources) : données de journaux de flux entrants récents (avant traitement)
    • Configuration (ou liste de processeurs) : processeurs et leurs configurations
    • Sortie (ou résultats) : données de journaux de résultats sortants récents (après traitement)

    Si le pipeline a déjà été déployé, le système affiche les données de journaux entrantes récentes (avant traitement) et les données de journaux sortantes récentes (après traitement) dans les volets.

  2. Cliquez sur Ajouter un processeur pour afficher la liste des processeurs. Pour plus de commodité, la liste des processeurs est regroupée par type de processeur. Pour organiser la liste et ajouter vos propres groupes, sélectionnez un ou plusieurs processeurs, puis cliquez sur Ajouter des groupes de processeurs.

  3. Dans la liste des processeurs, sélectionnez un processeur à ajouter.

  4. Configurez le processeur selon vos besoins.

  5. Cliquez sur Enregistrer pour enregistrer la configuration du processeur dans le nœud Processeur.

Le système teste immédiatement la nouvelle configuration en traitant un nouvel échantillon des données du flux entrant (à partir du volet Entrée) et affiche les données sortantes résultantes dans le volet Sortie.

Déployer un pipeline de traitement de données

Une fois les configurations du flux et du processeur terminées, vous devez déployer le pipeline pour commencer à traiter les données, comme suit :

  1. Cliquez sur Lancer le déploiement. Cela active immédiatement le traitement des données et permet à l'infrastructure sécurisée de Google de commencer à traiter les données selon votre configuration.

  2. Si le déploiement réussit, le numéro de version du conteneur de traitement des données est incrémenté et affiché à côté du nom du conteneur.

Afficher les détails du traitement des données dans la console Google SecOps

Les sections suivantes expliquent comment afficher les détails du traitement des données dans la console Google SecOps :

Afficher toutes les configurations de traitement des données

  1. Dans la console Google SecOps, accédez à Paramètres SIEM > Traitement des données pour afficher tous les pipelines que vous avez configurés.
  2. Dans la barre de recherche Pipelines de données entrants, recherchez un pipeline que vous avez créé. Vous pouvez effectuer une recherche par éléments, tels que le nom du pipeline ou les composants. Les résultats de recherche affichent les processeurs du pipeline et un récapitulatif de sa configuration.
  3. À partir du récapitulatif du pipeline, vous pouvez effectuer l'une des actions suivantes :
    • Vérifiez les configurations du processeur.
    • Copiez les détails de la configuration.
    • Cliquez sur Ouvrir dans Bindplane pour accéder au pipeline et le gérer directement dans la console Bindplane.

Afficher les flux configurés

Pour afficher les flux configurés dans votre système, procédez comme suit :

  1. Dans la console Google SecOps, accédez à Paramètres du SIEM > Flux. La page Flux affiche tous les flux que vous avez configurés dans votre système.
  2. Pointez sur chaque ligne pour afficher le menu ⋮ Plus, dans lequel vous pouvez afficher les détails du flux, le modifier, le désactiver ou le supprimer.
  3. Cliquez sur Afficher les détails pour ouvrir la fenêtre d'informations.
  4. Cliquez sur Ouvrir dans Bindplane pour ouvrir la configuration du flux pour ce flux dans la console Bindplane.

Afficher les détails du traitement des données (types de journaux disponibles)

Pour afficher les détails du traitement des données sur la page Types de journaux disponibles, où vous pouvez voir tous les types de journaux disponibles, procédez comme suit :

  1. Dans la console Google SecOps, accédez à Paramètres du SIEM > Types de journaux disponibles. La page principale affiche tous vos types de journaux.
  2. Pointez sur chaque ligne du flux pour afficher le menu  more_vert Plus. Ce menu vous permet d'afficher, de modifier, de désactiver ou de supprimer les détails du flux.
  3. Cliquez sur Afficher le traitement des données pour afficher la configuration du flux.
  4. Cliquez sur Ouvrir dans Bindplane pour ouvrir la configuration du processeur dans la console Bindplane.

Utiliser les méthodes de pipeline de données Google SecOps

Les méthodes de pipeline de données Google SecOps fournissent des outils complets pour gérer vos données traitées. Ces méthodes de pipeline de données incluent la création, la mise à jour, la suppression et la liste des pipelines, ainsi que l'association de flux et de types de journaux aux pipelines.

Cas d'utilisation

Cette section contient des exemples de cas d'utilisation typiques liés aux méthodes de pipeline de données.

Pour utiliser les exemples de cette section, procédez comme suit :

  • Remplacez les paramètres spécifiques au client (par exemple, les URL et les ID de flux) par des paramètres adaptés à votre propre environnement.
  • Insérez votre propre authentification. Dans cette section, les jetons du porteur sont masqués par ******.

Lister tous les pipelines d'une instance Google SecOps spécifique

La commande suivante liste tous les pipelines qui existent dans une instance Google SecOps spécifique :

curl --location 'https://abc.def.googleapis.com/v123/projects/projectabc-byop/locations/us/instances/aaaa1aa1-111a-11a1-1111-11111a1aa1aa/logProcessingPipelines' \
--header 'Authorization: Bearer ******'

Créer un pipeline de base avec un seul processeur

Pour créer un pipeline de base avec le processeur "Transformer" et y associer trois sources, procédez comme suit :

  1. Exécutez la commande suivante :

    curl --location 'https://abc.def.googleapis.com/v123/projects/projectabc-byop/locations/us/instances/aaaa1aa1-111a-11a1-1111-11111a1aa1aa/logProcessingPipelines' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer ******' \
--data '{
    "displayName": "Example Pipeline",
    "description": "My description",
    "processors": [
        {
            "transformProcessor": {
                "statements": [
                    "set(attributes[\"myKey1\"], \"myVal1\")",
                    "set(attributes[\"myKey2\"], \"myVal2\")"
                ]
            }
        }
    ]
}'

  2. Dans la réponse, copiez la valeur du champ displayName.

  3. Exécutez la commande suivante pour associer trois flux (type de journal, type de journal avec ID de collecteur et flux) au pipeline. Utilisez la valeur du champ displayName comme valeur {pipelineName}.

    curl --location 'https://abc.def.googleapis.com/v123/{pipelineName}:associateStreams' \
    --header 'Content-Type: application/json' \
--header 'Authorization: Bearer ******' \
--data '{
    "streams": [
        {
            "logType": "MICROSOFT_SENTINEL"
        },
        {
            "logType": "A10_LOAD_BALANCER",
            "collectorId": "dddddddd-dddd-dddd-dddd-dddddddddddd"
        },
        {
            "feed": "1a1a1a1a-1a1a-1a1a-1a1a-1a1a1a1a1a1a"
        }
    ]
}'

Créer un pipeline avec trois processeurs

Le pipeline utilise les processeurs suivants :

  • Transformer : transforme et analyse le corps du journal au format JSON.
  • Filtrer : filtre les journaux qui correspondent à une condition basée sur le corps analysé.
  • Occultation : occulte les données qui correspondent aux valeurs sensibles prédéfinies de Bindplane.

Pour créer un pipeline et y associer trois sources, procédez comme suit :

  1. Exécutez la commande suivante :

    curl --location 'https://abc.def.googleapis.com/v123/projects/projectabc-byop/locations/us/instances/aaaa1aa1-111a-11a1-1111-11111a1aa1aa/logProcessingPipelines' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer ******' \
--data-raw '{
    "displayName": "My Pipeline 2",
    "description": "My description 2",
    "processors": [
        {
            "transformProcessor": {
                "statements": [
                    "merge_maps(\n  body,\n  ParseJSON(\n    body\n  ),\n  \"upsert\"\n) where IsMap(body) and true\n",
                    "set(\n  body,\n  ParseJSON(\n    body\n  )\n) where not IsMap(body) and true\n"
                ],
                "errorMode": "IGNORE"
            }
        },
        {
            "filterProcessor": {
                "logConditions": [
                    "true and severity_number != 0 and severity_number < 9"
                ]
            }
        },
        {
            "redactProcessor": {
                "blockedValues": [
                    "\\b[A-Z]{2}\\d{2}(?: ?[A-Z0-9]){11,31}(?:\\s[A-Z0-9])*\\b",
                    "\\b([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}\\b",
                    "\\b(?:(?:(?:\\d{4}[- ]?){3}\\d{4}|\\d{15,16}))\\b",
                    "\\b(?:(?:19|20)?\\d{2}[-/])?(?:0?[1-9]|1[0-2])[-/](?:0?[1-9]|[12]\\d|3[01])(?:[-/](?:19|20)?\\d{2})?\\b",
                    "\\b[a-zA-Z0-9._/\\+\\-—|]+@[A-Za-z0-9\\-—|]+\\.[a-zA-Z|]{2,6}\\b",
                    "\\b(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\\b",
                    "\\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\\b",
                    "\\b((\\+|\\b)[1l][\\-\\. ])?\\(?\\b[\\dOlZSB]{3,5}([\\-\\. ]|\\) ?)[\\dOlZSB]{3}[\\-\\. ][\\dOlZSB]{4}\\b",
                    "\\+[1-9]\\d{0,2}(?:[-.\\s]?\\(?\\d+\\)?(?:[-.\\s]?\\d+)*)\\b",
                    "\\b\\d{3}[- ]\\d{2}[- ]\\d{4}\\b",
                    "\\b[A-Z][A-Za-z\\s\\.]+,\\s{0,1}[A-Z]{2}\\b",
                    "\\b\\d+\\s[A-z]+\\s[A-z]+(\\s[A-z]+)?\\s*\\d*\\b",
                    "\\b\\d{5}(?:[-\\s]\\d{4})?\\b",
                    "\\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}\\b"
                ],
                "allowAllKeys": true,
                "allowedKeys": [
                    "__bindplane_id__"
                ],
                "ignoredKeys": [
                    "__bindplane_id__"
                ],
                "redactAllTypes": true
            }
        }
    ]
}'

  2. Dans la réponse, copiez la valeur du champ displayName.

  3. Exécutez la commande suivante pour associer trois flux (type de journal, type de journal avec ID de collecteur et flux) au pipeline. Utilisez la valeur du champ displayName comme valeur {pipelineName}. 

    curl --location 'https://abc.def.googleapis.com/v123/{pipelineName}:associateStreams' \
    --header 'Content-Type: application/json' \
--header 'Authorization: Bearer ******' \
--data '{
    "streams": [
        {
            "logType": "MICROSOFT_SENTINEL"
        },
        {
            "logType": "A10_LOAD_BALANCER",
            "collectorId": "dddddddd-dddd-dddd-dddd-dddddddddddd"
        },
        {
            "feed": "1a1a1a1a-1a1a-1a1a-1a1a-1a1a1a1a1a1a"
        }
    ]
}'

Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.