Rechercher des tableaux de données
Les tables de données sont des structures de données multicolonnes qui vous permettent d'importer vos propres données dans Google Security Operations. Les tables de données peuvent servir de tables de conversion avec des colonnes définies et des données stockées dans les lignes. Vous pouvez créer ou importer une table de données dans votre compte Google SecOps à l'aide de l'interface Web Google SecOps, de l'API des tables de données ou d'une requête Présentation de YARA-L 2.0.
Attribuer des champs d'application aux tables de données à l'aide du RBAC des données
Pour utiliser des tables de données, vous devez leur attribuer des champs d'application à l'aide du contrôle des accès basé sur les rôles (RBAC) des données. En attribuant des champs d'application à une table de données, vous pouvez contrôler quels utilisateurs et ressources peuvent y accéder et l'utiliser. Pour en savoir plus, consultez Configurer le RBAC des données pour les tables de données.
Gérer les tables de données à l'aide de l'interface Web Google SecOps
Les sections suivantes expliquent comment gérer les tableaux de données à l'aide de l'interface Web, y compris comment accéder à un tableau de données, en ajouter un, modifier son contenu, ajouter des lignes et supprimer un tableau de données de votre compte.
Accéder à vos tables de données
Pour accéder à la page Tables de données, procédez comme suit :
- Dans la barre latérale, sélectionnez Investigation > Tables de données.
Pour trouver une table de données spécifique, saisissez son nom dans le champ Rechercher en haut de la barre latérale Tables de données.
Ajouter un tableau de données
Lorsque vous ajoutez un tableau de données, vous pouvez saisir manuellement des données CSV, coller des données CSV ou importer un fichier CSV ou TSV dans le tableau de données.
Les configurations suivantes sont permanentes et ne peuvent pas être modifiées après l'enregistrement d'une table de données :
- En-têtes de colonnes
- Mappage de données
- Clés primaires
- Champs répétés
- Mappage des noms de colonnes aux champs d'entités
Pour ajouter une table de données à Google SecOps, procédez comme suit :
Dans la barre latérale, sélectionnez Investigation > Tables de données.
En haut de la barre latérale Tables de données, cliquez sur Créer.
Dans la boîte de dialogue Créer une table de données, attribuez un nom à la table et, si vous le souhaitez, ajoutez une description.
Effectuez l'une des opérations suivantes :
- Saisissez manuellement les données CSV ou collez-les dans la zone Texte (mode Édition).
- Pour importer des données d'un fichier CSV ou TSV dans le tableau de données, procédez comme suit :
- Cliquez sur Importer un fichier.
- Accédez au fichier et cliquez sur Ouvrir. La boîte de dialogue Importer un fichier s'ouvre.
- Si vous avez sélectionné un fichier TSV à l'étape précédente, procédez comme suit :
- Dans la liste Type de séparateur, sélectionnez Détecter automatiquement ou Tabulation.
- Dans la liste Démarrer l'importation à la ligne, spécifiez la ligne du fichier à partir de laquelle importer les données.
- Cliquez sur Import data (Importer les données).
Sélectionnez le mode de modification Table et configurez les éléments suivants selon vos besoins :
Cliquez sur Enregistrer. La nouvelle table de données s'affiche dans la barre latérale Tables de données et est prête à accepter des données supplémentaires.
Mapper les types de données avec les colonnes du tableau de données
Lorsque vous ajoutez un tableau de données, vous pouvez mapper des types de données (chaîne, expression régulière, CIDR ou nombre) aux colonnes du tableau de données.
Vous pouvez mapper des champs de données uniques à une colonne de données, et mapper des champs de données répétés à une colonne de données à l'aide de l'interface Web ou de l'API, comme suit :
Dans l'interface Web et l'API, séparez les valeurs des champs de données à l'aide d'une barre verticale (
|). Dans l'interface Web, si une valeur inclut une barre verticale (|), elle est traitée par défaut comme une valeur répétée.Pour les requêtes API, définissez
repeated_valuessurtrue.
Pour en savoir plus, consultez Champs répétés.
Dans l'exemple suivant, la colonne de table de données Field_value contient des valeurs pour plusieurs champs :
| Field_value | Field_name |
|---|---|
| altostrat.com | Nom de domaine complet |
| 192.0.2.135 | IP |
| charlie | userid |
| exemple | nom d'hôte |
Le tableau précédent est divisé en quatre colonnes, chacune d'elles étant mappée à un seul type de champ avant de pouvoir être utilisée pour l'un des cas d'utilisation de tableau de données présentés dans ce document.
| Nom de domaine complet | IP | Userid | Nom d'hôte |
|---|---|---|---|
| altostrat.com | 192.0.2.135 | charlie | exemple |
| … | … | … | … |
Désigner des colonnes de clé
Lorsque vous ajoutez une table de données, vous pouvez désigner des colonnes spécifiques comme colonnes de clé.
Le fait de définir une colonne comme colonne de clé permet d'identifier de manière unique les valeurs de cette colonne, d'éviter la duplication des données et de faciliter la découverte des données pour les règles et les recherches.
Désigner des colonnes pour accepter les champs répétés
Lorsque vous ajoutez une table de données, vous pouvez désigner des colonnes spécifiques pour accepter les champs répétés.
Les colonnes destinées à stocker des champs à valeurs multiples ou des champs répétés doivent être explicitement désignées comme répétées lors de la création de la table de données.
Mapper les noms de colonnes sur les champs d'entité (facultatif)
Lorsque vous ajoutez une table de données, vous pouvez mapper les noms de ses colonnes avec des champs d'entité.
Dans l'exemple de tableau de données suivant, les colonnes Userid et Role sont mappées respectivement sur entity.user.userid et entity.user.attribute.role.name :
| Userid (mappé sur entity.user.userid) |
Rôle (mappé sur entity.user.attribute.role.name) |
|
|---|---|---|
| jack | jack123@gmail.com | administrateur |
| tony | tony123@gmail.com | ingénieur |
Vous pouvez mapper une colonne de table de données à un champ proto d'entité à l'aide du champ mapped_column_path de la ressource DataTable.
Pour les colonnes sans chemin d'entité défini, comme Email dans cet exemple de table, vous devez spécifier manuellement un type de données. Comme pour les listes de référence, les types de données compatibles avec les tables de données sont number, string, regex et cidr.
Vous pouvez inclure des colonnes mappées et non mappées dans un tableau de données en spécifiant une condition join.
Les colonnes non mappées sont stockées dans le champ additional de l'entité à laquelle la table est jointe. Ils sont ajoutés sous forme de paires clé/valeur, où key est le nom de la colonne et value est la valeur de la ligne correspondante.
Ajouter une ligne à un tableau de données
Pour ajouter une ligne, procédez comme suit :
- Dans l'onglet Détails, sélectionnez le mode de modification Table.
- Effectuez un clic droit sur une ligne existante, puis sélectionnez Ajouter une ligne au-dessus.
- Saisissez les données d'une nouvelle ligne. La première ligne est traitée comme un en-tête de tableau. Veillez à faire correspondre chaque élément de données à la colonne de données et au type de données appropriés.
- Cliquez sur Enregistrer.
Modifier une ligne dans un tableau de données
Pour modifier une ligne, procédez comme suit :
- Cliquez sur le champ que vous souhaitez modifier. Le champ devient modifiable.
- Apportez les modifications souhaitées.
- Cliquez sur Enregistrer.
Rechercher dans les lignes du tableau de données
Vous pouvez rechercher des informations spécifiques dans une table de données à l'aide de l'interface Web. Dans l'onglet Détails, saisissez une chaîne de recherche dans le champ de recherche, puis cliquez sur Rechercher. Les lignes contenant votre chaîne de recherche s'affichent.
Gérer la valeur TTL des lignes de table
Pour gérer la valeur de valeur TTL (Time To Live) des lignes d'une table, procédez comme suit :
Cliquez sur Afficher la valeur TTL par ligne. Une colonne TTL s'affiche, indiquant si chaque ligne a expiré. Si elle n'a pas expiré, elle indique le temps restant avant l'expiration.
Cliquez sur le délai d'expiration par défaut des lignes pour afficher la boîte de dialogue Modifier le délai d'expiration par défaut des lignes et ajuster la valeur TTL des lignes de la table.
Saisissez une nouvelle valeur TTL en heures ou en jours. La valeur minimale est de 1 heure. La valeur maximale est de 365 jours.
Cliquez sur Enregistrer.
Comportement de remplacement de la valeur TTL au niveau de la ligne
Les lignes héritent du TTL appliqué au niveau de la table. Vous pouvez également définir une valeur TTL spécifique pour chaque ligne. Cette valeur TTL au niveau de la ligne prévaut sur la valeur par défaut au niveau de la table. Lorsque vous ajoutez une ligne, sa valeur TTL commence à partir de l'heure de création.
Supprimer une ligne de tableau
Pour supprimer une ligne, effectuez un clic droit dessus, puis sélectionnez Supprimer la ou les lignes.
Pour supprimer plusieurs lignes, sélectionnez chacune d'elles. Ensuite, effectuez un clic droit sur l'une des lignes sélectionnées, puis choisissez Supprimer la ou les lignes.
Supprimer un tableau de données
Pour supprimer un tableau de données :
Sélectionnez une table de données dans la liste Tables de données de la barre latérale.
Cliquez sur Supprimer.
Gérer les tables de données à l'aide de l'API Chronicle
Vous pouvez également utiliser les ressources REST disponibles dans l'API Chronicle pour gérer les tables de données dans Google SecOps. L'API peut répliquer toutes les fonctionnalités disponibles dans l'interface Web et inclut des fonctionnalités supplémentaires qui vous permettent de gérer les tables de données avec plus de performances et à plus grande échelle.
Voici les ressources REST de la table de données :
Exemple : Syntaxe de filtre
L'exemple d'API Chronicle suivant montre comment utiliser la syntaxe filter pour rechercher google.com dans les lignes d'une table de données :
curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
"https://staging-chronicle.sandbox.googleapis.com/v1alpha/projects/{$PROJECT}/locations/${REGION}/instances/${INSTANCE}/dataTables/${DATA_TABLE_NAME}/dataTableRows?filter=google.com"
Utiliser des tables de données dans Google SecOps
Une fois que vous avez ajouté des tables de données à votre instance Google SecOps, vous pouvez les utiliser pour filtrer, améliorer et enrichir vos données à l'aide de requêtes YARA-L. Ce document inclut de nombreux exemples de syntaxe YARA-L que vous pouvez intégrer à Google SecOps.
Vous pouvez utiliser des tables de données conjointement avec des requêtes YARA-L dans la recherche et les règles.
Les tables de données peuvent être utilisées de différentes manières :
Filtrer les données d'événement ou d'entité UDM à l'aide d'un tableau de données
Vous pouvez filtrer les événements et les entités de télémétrie UDM en les comparant aux entrées d'une table de données.
Utiliser un tableau de données comme liste de référence multicolonne
Vous pouvez utiliser un tableau de données comme liste de référence multicolonne. Une liste de référence peut accéder aux données d'une seule dimension, tandis que les tableaux de données vous permettent d'accéder aux données de plusieurs dimensions, ce qui permet de filtrer les données.
Associer un tableau de données à un événement ou à une entité
Vous pouvez associer des événements UDM à une table de données à l'aide de l'opérateur d'égalité (
=) pour les comparaisons basées sur les lignes. Cette comparaison vous permet de filtrer les données. Une comparaison basée sur les lignes n'est évaluée commetrueque si toutes les conditions de l'instruction correspondent à une seule ligne de la table de données.
Filtrer les données d'événements et d'entités UDM à l'aide d'un tableau de données
Vous pouvez filtrer les événements et les entités UDM en les comparant aux entrées d'une table de données. Joignez la table de données à un événement ou une entité UDM à l'aide de comparaisons basées sur les lignes ou basées sur les colonnes.
Comparaisons basées sur les lignes et les colonnes dans les tableaux de données
| Type de comparaison | Logique de clé | Opérateurs courants | Exemple de syntaxe | Cas d'utilisation |
|---|---|---|---|---|
| Basé sur les lignes | Toutes les conditions doivent correspondre dans la MÊME ligne | =, !=, >, >=, <, <= |
$e.field = %table.col_a |
Lorsque la relation entre plusieurs valeurs de colonne dans la même ligne est importante. |
| Basé sur des colonnes | La valeur doit exister N'IMPORTE OÙ dans la colonne | IN, IN regex, IN cidr |
$e.field IN %table.col_b |
Lorsque vous vérifiez la présence d'une valeur dans un ensemble de valeurs d'une même colonne. |
Associez des événements UDM à des tables de données à l'aide des méthodes de comparaison basées sur les lignes ou basées sur les colonnes :
Comparaison basée sur les lignes pour associer des événements UDM à des tables de données
Pour associer des événements UDM à des tables de données à l'aide d'une comparaison basée sur les lignes, utilisez des opérateurs d'égalité (
=,!=,>,>=,<,<=).Par exemple :
$<udm_variable>.<field_path> = %<data_table_name>.<column_name>- Si vous utilisez plusieurs instructions de comparaison, tous les champs ou conditions doivent correspondre sur la même ligne de la table de données.
Pour utiliser des opérateurs (tels que
not,!=,>,>=,<,<=) dans votre requête, vous devez inclure au moins une conditionjoinentre les champs UDM et les lignes de la table de données.Google SecOps traite toute règle comportant une table de données
joincomme une règle à événements multiples, ce qui nécessite une sectionmatchdans la définition de la règle.
Pour filtrer les données en comparant les valeurs des événements UDM aux lignes de la table de données, tenez compte de la syntaxe de jointure suivante :
Syntaxe de jointure correcte :
Règles de détection (anti-jointure gauche) : pour exclure des événements lorsqu'une combinaison spécifique de plusieurs champs correspond à la même ligne d'une table de données (anti-jointure), liez les champs d'événement aux colonnes de la table de données à l'aide de l'égalité (
=) dans la sectionevents, puis spécifiez$e and #<data_table_name> = 0dans la sectioncondition. Vous pouvez également inclure#<data_table_name> >= 0dans la sectionconditionpour que le compilateur effectue une jointure externe gauche (par exemple,$e and #<data_table_name> >= 0 and $match_count = 0lors du comptage des lignes correspondantes dansoutcomeà l'aide de$match_count = count(%<data_table_name>.<column_name>)). Si une ligne de la table de données correspond à toutes les colonnes liées, le nombre de lignes est supérieur à zéro et la règle exclut l'événement. Pour en savoir plus, consultez Exemples d'anti-jointure gauche (exclusion) dans les règles.Recherche et tableaux de bord :
- Avec une section
match(recherche et tableaux de bord agrégés) : répétezleft joinsur chaque colonne jointe dans la sectionevents(par exemple,left join $e.field1 = %<data_table_name>.col1etleft join $e.field2 = %<data_table_name>.col2), puis ajoutez#<data_table_name> = 0dans la sectioncondition(ou comptez une colonne correspondante dansoutcomeet évaluez$match_count = 0danscondition). - Sans section
match(recherche et tableaux de bord multi-étagés non agrégés) : placez les instructionsleft joinrépétées dans unstagenommé qui génère une colonne de table de données dansoutcome(par exemple,$matched_col = %<data_table_name>.<column_name>), filtrez pour$<stage_name>.matched_col = ""dans la sectioneventsprincipale (les sorties de chaîne d'étape non correspondantes sont définies par défaut sur des chaînes vides plutôt que sur des valeurs nulles) et projetez les champs d'étape nécessaires dans la sectionoutcomeprincipale.
- Avec une section
Syntaxe de jointure incorrecte :
N'encapsulez pas
NOTautour de plusieurs conditions d'égalité basées sur des lignes (par exemple,NOT ($e.field1 = %table.col1 AND $e.field2 = %table.col2)). La correspondance est évaluée ligne par ligne par rapport au tableau de données. Si une ligne ne remplit pas la condition combinée interne,NOTest évalué àtrue, ce qui peut inclure l'événement au lieu de l'exclure.N'utilisez pas d'opérateurs d'inégalité indépendants sur plusieurs colonnes (par exemple,
$e.field1 != %table.col1 AND $e.field2 != %table.col2) sans condition de jointure positive (=), car cela entraîne une erreur de compilation. Même lorsqu'ils sont associés à une jointure positive sur une autre colonne, les opérateurs d'inégalité évaluent les colonnes sur la même ligne jointe et renvoient une correspondance chaque fois qu'une ligne jointe diffère, au lieu de vérifier qu'aucune ligne ne correspond au tuple.Ne confondez pas les comparaisons basées sur les lignes avec les vérifications d'appartenance basées sur les colonnes (
not $e.field1 in %table.col1 and not $e.field2 in %table.col2). Les vérificationsinbasées sur les colonnes évaluent chaque colonne indépendamment dans l'ensemble de la table de données, en excluant un événement sifield1apparaît dans une ligne etfield2dans une autre, même si les deux valeurs n'apparaissent jamais ensemble dans la même ligne.
Pour utiliser une colonne de table de données de type
CIDRouregexpour une comparaison basée sur les lignes, utilisez la syntaxe suivante :net.ip_in_range_cidr($e.principal.ip, %<data_table_name>.<column_name>) re.regex($e.principal.hostname, %<data_table_name>.<column_name>)
Comparaison basée sur les colonnes pour associer des événements UDM à des tables de données
Pour associer des événements UDM à des tables de données à l'aide d'une comparaison basée sur des colonnes, utilisez le mot clé
in.Par exemple :
$<udm_variable>.<field_path> in %<data_table_name>.<column_name>Pour exclure les événements dont la valeur de champ existe dans la colonne spécifiée (par exemple, une liste de blocage ou une liste d'autorisation), utilisez la syntaxe suivante :
NOT (... IN %table.column)Par exemple :
not ($evt_username in %my_data_table.username)Pour utiliser une colonne de table de données de type
CIDRouregexpour une comparaison basée sur une colonne, utilisez la syntaxe suivante :$e.principal.ip in cidr %cidr_data_table.column_name $e.principal.hostname in regex %regex_data_table.column_nameLorsque vous comparez des colonnes dans des tableaux de données de type CIDR ou expression régulière, les mots clés
cidretregexsont facultatifs.Vous pouvez également utiliser l'opérateur
notavec des tables de données.L'exemple de requête suivant filtre les entrées dont les adresses IP (
$e.principal.ip) ne correspondent à aucune des plages CIDR listées dans la colonnebenign_ipdecidr_data_table:not $e.principal.ip in %data_table.benign_ip
Utiliser un tableau de données comme liste de référence multicolonne
Vous pouvez utiliser un tableau de données comme liste de référence multicolonne. Bien qu'une liste de référence puisse accéder aux données d'une seule dimension (une colonne), les tableaux de données acceptent plusieurs colonnes, ce qui vous permet de filtrer les données et d'y accéder dans plusieurs dimensions.
Vous pouvez associer des événements UDM à une table de données à l'aide du mot clé in pour une comparaison basée sur les colonnes, ce qui vous permet de faire correspondre les valeurs d'un champ UDM spécifique avec les valeurs d'une seule colonne de la table de données.
Dans l'exemple suivant, la table de données badApps contient deux colonnes : hostname et ip. La requête met en correspondance les deux valeurs (valeur basée sur le champ UDM et valeur basée sur la table de données, toutes deux de type de données chaîne) indépendamment.
Exemple de règle :
rule udm_in_data_table { meta: description = "Use data table as multicolumn reference list" events: $e.metadata.event_type = "NETWORK_CONNECTION" $e.security_result.action = "ALLOW" $e.target.asset.asset_id = $assetid // Event hostname matches at least one value in table column hostname. $e.target.hostname in %badApps.hostname // Event IP matches at least one value in table column ip. $e.target.ip in %badApps.ip match: $assetid over 1h condition: $e }Exemple de recherche :
events: $e.metadata.event_type = "NETWORK_CONNECTION" $e.security_result.action = "ALLOW" $e.target.asset.asset_id = $assetid // Event hostname matches at least one value in table column hostname. $e.target.hostname in %badApps.hostname // Event IP matches at least one value in table column ip. $e.target.ip in %badApps.ip
Jointures basées sur les lignes entre une table de données et un événement ou une entité UDM
Vous pouvez associer des événements UDM à une table de données à l'aide d'opérateurs d'égalité et de comparaison (=, !=, >, >=,
<, <=) pour effectuer des comparaisons basées sur les lignes. Cette approche vous permet de filtrer les données en comparant les valeurs des événements UDM aux lignes de la table de données. Si vous utilisez plusieurs instructions de comparaison, tous les champs ou conditions doivent correspondre sur la même ligne de la table de données.
Vous devez inclure au moins une condition join entre les champs UDM et les lignes de la table de données pour utiliser des opérateurs (tels que not, !=, >, >=, <, <=) dans votre requête.
Google SecOps traite toute règle comportant une table de données join comme une règle à événements multiples, ce qui nécessite une section match correspondante dans la définition de la règle.
Lorsqu'une jointure se produit, les lignes de la table de données associée sont visibles dans la recherche. Pour en savoir plus, consultez Afficher les lignes d'un tableau de données dans la recherche.
Les espaces réservés sont acceptés pour les tables de données dans la section
eventd'une requête, mais ils doivent être connectés à un événement UDM ou à une entité UDM.L'exemple suivant utilise une colonne de table de données de type
string.Cet exemple de requête YARA-L vérifie si un événement de connexion utilisateur correspond à une ligne de la liste
example_table.- Une condition est que
user IDexiste dansexample_table. - Les deux conditions doivent correspondre sur la même ligne de la
example_tablepour que la règle se déclenche.
- Une condition est que
Exemple de règle :
// Check if user exists in a data table and is active in all user login events. rule udm_join_data_table { meta: description = "Join data table with UDM event" events: $e.metadata.event_type = "USER_LOGIN" $e.security_result.action = "ALLOW" $e.principal.user.userid = $userid // Event must match at least 1 row in the data table // where the uid in the data table row is the userid on the event // and the active date in the same data table row is before the event timestamp. %example_table.uid = $userid $e.principal.hostname = %example_table.hostname match: $userid over 1h condition: $e }Exemple de recherche :
events: $e.metadata.event_type = "USER_LOGIN" $e.security_result.action = "ALLOW" $e.principal.user.userid = $userid // Event must match at least 1 row in the data table // where the uid in the data table row is the userid on the event // and the active date in the same data table row is before the event timestamp %example_table.uid = $userid $e.principal.hostname = %example_table.hostname
L'exemple suivant illustre la synergie entre une table de données et les données d'événement UDM.
Sur la base de la logique de la requête YARA-L précédente, un utilisateur avec
user ID 32452apparaît dans la détection en tant quehostnamede l'utilisateur à partir du système, et correspond auhostnamedans la table de données.Tableau de données uid title hostname 32452 RH host1 64452 Finance host2 46364 IT host3 Table des événements UDM principal metadata security_result principal 32452 USER_LOGIN AUTORISER host1 64589 USER_LOGIN AUTORISER host9 87352 USER_LOGIN AUTORISER host4
Exclure des événements à l'aide d'une anti-jointure basée sur des lignes multicolonnes
Pour exclure des événements uniquement lorsqu'une combinaison spécifique de champs correspond à la même ligne d'un tableau de données d'exclusion (anti-jointure gauche), associez chaque champ d'événement à la colonne correspondante du tableau de données dans la section events et spécifiez #<data_table_name> = 0 dans la section condition.
L'exemple de règle de détection suivant exclut les événements lorsque le nom de la règle et le nom d'hôte principal correspondent à la même ligne dans exclusion_table :
rule multi_column_row_exclusion {
meta:
author = "Google SecOps"
description = "Excludes events matching a specific rule and hostname combination in the same row of an exclusion data table."
events:
$e.metadata.event_type = "USER_LOGIN"
$e.security_result.rule_name = $rule_name
$e.principal.hostname = $hostname
// Both fields must match the SAME row in the exclusion data table
$rule_name = %exclusion_table.rule_name
$hostname = %exclusion_table.hostname
match:
$rule_name, $hostname over 5m
condition:
// Triggers only when the event exists and no matching combination row exists in the data table
$e and #exclusion_table = 0
}
Pour obtenir d'autres exemples de jointures externes et d'anti-jointures, consultez Mettre en corrélation des données à l'aide de jointures externes.
Écrire les résultats des requêtes YARA-L dans des tables de données
Vous pouvez écrire les résultats des requêtes YARA-L dans une table de données. Cette fonctionnalité vous permet de créer des tables de données à partir de vos données Google SecOps et de les utiliser pour filtrer et améliorer d'autres données.
Vous pouvez utiliser la syntaxe d'écriture de requête YARA-L pour les opérations suivantes :
Définissez la syntaxe YARA-L pour écrire les résultats de requête dans des tables de données.
Utilisez des tables de données pour le renseignement sur les menaces, la réponse aux incidents et d'autres cas d'utilisation de sécurité.
Les données doivent être conformes à la syntaxe et aux conventions YARA-L.
Écrire des détections et des alertes dans des tables de données à l'aide de YARA-L
Vous pouvez utiliser une requête YARA-L pour envoyer des détections et des alertes à des tables de données.
La fonction write_row vous permet d'écraser une ligne de table de données avec la clé correspondante dans la table de données à l'aide des résultats d'une règle. Si la clé est introuvable dans la table, ajoutez une nouvelle ligne à la place.
Spécifiez la fonction write_row dans la section d'exportation d'une requête YARA-L. L'écriture de données dans la table de données doit être la dernière action de la requête. Les variables de résultat sont alors écrites dans la table de données.
Exemple
export: %<data_table_name>.write_row( data_table_column_x_name: <value>, data_table_column_y_name: <value>, ..., ..., data_table_column_z_name: <value> ) // depending on the key column(s), the rows will be updated for existing keys and appended for new keysExemple : Exporter les résultats de recherche vers une table de données
events: $e.metadata.event_type = "USER_LOGIN" $e.security_result.action = "ALLOW" outcome: $user = $e.principal.user.userid $ip = $e.target.ip[0] // Assuming target.ip is an array $timestamp = $e.metadata.event_timestamp.seconds export: // Write to the data table named 'successful_logins' %successful_logins.write_row( user: $user, // Maps $user variable to 'user' column ip: $ip, // Maps $ip variable to 'ip' column first_seen: $timestamp // Maps $timestamp variable to 'first_seen' column )
Modifier un tableau de données à l'aide de YARA-L
Voici comment modifier une table de données à l'aide de YARA-L :
TableName : ip_user_domain_table (les colonnes de clé pour la clé primaire sont définies lors de la création)
| Adresse IP | employee_id* | domain |
|---|---|---|
| 192.0.2.10 | Dana | altostrat.com |
| 192.0.2.20 | Quinn | altostrat.com |
| 192.0.2.30 | Lee | cymbalgroup.com |
* indique la clé primaire.
La requête suivante capture des combinaisons uniques de principal.ip, principal.user.employee_id et target.domain. Il filtre les résultats en fonction de la prévalence de target.domain :
Exemple
events: $e.principal.ip = $principal_ip $e.principal.user.employee_id = $principal_user_employee_id $e.target.domain.name = $target_domain $e.target.domain.prevalence.day_count < 5 // To run this query as a rule, add Condition Section here // condition:$e
Résultats de la requête :
| ip | empid | domain |
|---|---|---|
| 192.0.2.10 | Dana | altostrat.com |
| 192.0.2.30 | Lee | examplepetstore.com |
| 192.0.2.20 | Quinn | altostrat.com |
Exemple : Utiliser write_row pour écrire le résultat d'une requête dans une table de données
Exemple de règle :
rule udm_write_data_table { meta: description = "Writeto data table" events: $e.principal.user.employee_id = $principal_user_employee_id $e.target.domain.name = $target_domain $e.target.domain.prevalence.day_count < 5 outcome: $hostname = $target_domain $principal_emp_id = $principal_user_employee_id condition: $e export: %ips_with_hostnames.write_row( employeeid:$principal_emp_id, hostname:$hostname ) }Exemple de recherche :
events: $e.principal.user.employee_id = $principal_user_employee_id $e.target.domain.name = $target_domain $e.target.domain.prevalence.day_count < 5 outcome: $hostname = $target_domain $principal_emp_id = $principal_user_employee_id export: %ips_with_hostnames.write_row( employeeid:$principal_emp_id, hostname:$hostname )
Exemple : Comprendre write_row
Dans l'exemple suivant, user et ip sont utilisés comme clés primaires. Chaque détection qui persiste dans la table des détections entraîne une évaluation de l'appel de fonction dans la section d'exportation de la requête.
Exemple de règle :
rule udm_write_data_table { meta: description = "Write data table" events: $e.metadata.event_type = "USER_LOGIN" all $e.security_result.action != "BLOCK" all $e.security_result.action != "UNKNOWN_ACTION" $user = $e.principal.user.userid $ip = $e.target.ip $ts = $e.metadata.event_timestamp.seconds match: $user, $ip over 1h outcome: $first_seen = min($ts) condition: $e export: %successful_logins.write_row(user:$user, ip:$ip) }Exemple de recherche :
events: $e.metadata.event_type = "USER_LOGIN" all $e.security_result.action != "BLOCK" all $e.security_result.action != "UNKNOWN_ACTION" $ts = $e.metadata.event_timestamp.seconds outcome: $user = $e.principal.user.userid $ip = $e.target.ip[0] export: %successful_logins.write_row(user:$user, ip:$ip)Voici les données d'événement :
metadata: { event_type: USER_LOGIN event_timestamp: { seconds: 1283299200 } } principal: { user: { userid: "charlie" } } target: { ip: ["192.0.2.135", "192.0.2.136"] } security_result: { action: ALLOW }Les détections suivantes sont renvoyées lorsque cette requête est exécutée en tant que règle :
ID de détection Match $user Match $ip 0 charlie 192.0.2.135 1 charlie 192.0.2.136 La table de données contient les éléments suivants :
utilisateur ip charlie 192.0.2.135 charlie 192.0.2.136 La requête de recherche suivante illustre la compatibilité incluse dans Search pour l'écriture de valeurs scalaires dans des tables de données.
events: $e.metadata.event_type = "NETWORK_CONNECTION" export: %summary_table.write_row(col_name: $e.metadata.product_name, Vendor_name: $e.metadata.vendor_name)
Enrichir le graphique d'entités avec une table de données
Vous pouvez utiliser des tables de données pour ajouter, supprimer ou remplacer les entités présentées dans un graphique d'entités à partir de règles. Utilisez des fonctions dans la section setup de la règle pour indiquer comment la table de données doit être fusionnée avec les événements d'entité référencés dans la section events, ajoutée à ceux-ci ou utilisée pour en supprimer des entités.
Vous pouvez utiliser le modèle de règle suivant pour modifier un graphique d'entités :
Modèle de règle
rule entity_graph_template { meta: ... setup: // import the data table into entity graph <enrichment_keyword> <join_condition> events: ... match: ... condition: ... }
Vous pouvez utiliser les fonctions YARA-L 2.0 suivantes pour enrichir le graphique d'entités avec une table de données :
graph_override: écrase les lignes du graphique d'entités qui correspondent à la condition de jointure avec les données de la table de données.Par exemple :
[graph_override](?tab=t.0#heading=h.v0fps7eke1if)graph_append: ajoute les lignes de la table de données aux lignes du graphique d'entités. L'opérationgraph_appendnécessite un tableau incluant une variable de table de données et une variable d'événement d'entité, plutôt qu'une condition de jointure.Dans l'exemple suivant,
$g1est la variable du graphique d'entités etexample_tableest la table de données :graph_append [$g1, %example_table]Pour la fonction
append, les tables de données doivent inclure les colonnes suivantes pour valider l'entité :start_time(mappé surmetadata.interval.start_time.seconds)end_time(mappé surmetadata.interval.end_time.seconds)
Les colonnes de la table de données ne peuvent pas être mappées aux champs de métadonnées à l'aide de l'interface Web. Pour les cas d'utilisation de
append, les tables de données doivent être créées à l'aide de l'API Chronicle (https://docs.cloud.google.com/chronicle/docs/reference/rest/v1alpha/projects.locations.instances.dataTables/create).graph_exclude: supprime les lignes du graphique d'entités qui correspondent à la conditionjoin.Par exemple :
[graph_exclude](?tab=t.0#heading=h.o0qbb5paki6g)
La condition de jointure doit être une expression d'égalité entre la colonne de la table de données et le champ du graphique d'entités. Pour les fonctions graph_override et graph_exclude, la syntaxe permettant d'accéder à une table de données est la suivante :
<data_table_name>.<column_name>
Tout filtre spécifié pour <entity_variable> dans la section "Événement" est appliqué après son enrichissement avec le tableau de données.
Une fois que l'entité du graphique d'entités est enrichie avec l'entité de la table de données, la variable d'entité du graphique d'entités doit être jointe à l'entité UDM.
Remplacer le graphique d'entités par les données de la table de données
Avec la fonction graph_override, les champs présents à la fois dans le graphique d'entités et dans la table de données sont remplacés par les champs de la table de données. Les champs présents dans le graphique d'entités et non dans la table de données restent inchangés. Les champs qui ne sont pas présents dans le graphique d'entités, mais qui sont présents dans la table de données sont inclus.
Seules les colonnes de la table de données qui sont mappées remplacent les colonnes du graphique d'entités. Les colonnes non mappées sont ajoutées au champ additional du graphique d'entité auquel la table de données est jointe.
Exemple : Correspondance sur une seule jointure
Dans l'exemple suivant, les lignes du graphique d'entités qui correspondent à la condition de jointure entre la colonne de la table de données et le champ du graphique d'entités ($g1.graph.entity.ip = %example_table.my_ip) sont remplacées par la table de données.
Exemple
rule rule_override { meta: description = "Override entity context with data table before joining with UDM event" setup: //Rows in the entity graph that match the join condition are overridden by the data table graph_override ($g1.graph.entity.ip = %example_table.my_ip) events: $e.metadata.event_type = "NETWORK_CONNECTION" $e.security_result.action = "ALLOW" // Filter will be applied after graph is overridden by data table $g1.graph.entity.hostname = "ftp01" // Accessing unmapped columns $g1.graph.additional.fields["Owner"] = "alice" // Joining the UDM event with the enriched entity graph $e.target.ip = $iocip $g1.graph.entity.ip = $iocip match: $iocip over 1h condition: $e and $g1 }
Pour utiliser une colonne non mappée (par exemple, "Propriétaire") de la table de données, utilisez une instruction équivalente pour $g1.graph.entity.owner = "alice" is $g1.graph.additional.fields["Owner"] = "alice".
En effet, toutes les colonnes non mappées de la table de données sont placées dans le champ additional du graphique d'entité ($g1).
Les tableaux suivants illustrent une opération de remplacement dans laquelle les lignes du graphique d'entités sont enrichies lorsque le champ "IP" de la table de données correspond au champ "IP" du graphique d'entités.
| Graphique d'entités existant | ||
|---|---|---|
| Hostname (Nom d'hôte) | IP | MAC |
| ftp01 | 10.1.1.4 | …:01 |
| www01 | 10.1.1.5 | …:02 |
| Tableau de données | |||
|---|---|---|---|
| Hostname (Nom d'hôte) | IP | MAC | Propriétaire |
| ftp01 | 10.1.1.4 | …:bb | alice |
| h1 | 10.1.1.6 | …:cc | bob |
| h2 | 10.1.1.7 | …:dd | chris |
| h3 | 10.1.1.4 | …:ee | forme |
| Graphique d'entités enrichi | |||
|---|---|---|---|
| Hostname (Nom d'hôte) | IP | MAC | Propriétaire |
| ftp01 | 10.1.1.4 | …:bb | alice |
| www01 | 10.1.1.5 | …:02 | |
| h3 | 10.1.1.4 | …:ee | forme |
Exemple : Correspondance avec plusieurs jointures
Dans l'exemple suivant, les lignes du graphique d'entités qui correspondent aux multiples conditions de jointure ($g1.graph.entity.ip = %example_table.my_ip et $g1.graph.entity.hostname = %example_table.my_hostname) sont remplacées par la table de données.
Exemple
rule rule_override { meta: description = "Override Entity context with Data Table before joining with UDM event" setup: // example with more than one condition graph_override ($g1.graph.entity.ip = %example_table.my_ip and $g1.graph.entity.hostname = %example_table.my_hostname) events: $e.metadata.event_type = "NETWORK_CONNECTION" $e.security_result.action = "ALLOW" // Filter will be applied after graph is overridden by data table $g1.graph.entity.hostname = "ftp01" // joining the UDM event with the enriched entity graph $e.target.ip = $iocip $g1.graph.entity.ip = $iocip match: $iocip over 1h condition: $e and $g1 }
Les tableaux suivants illustrent une opération de remplacement dans laquelle les lignes du graphique d'entités sont enrichies lorsque le champ d'adresse IP et le champ de nom d'hôte de la table de données correspondent au champ d'adresse IP et au champ de nom d'hôte du graphique d'entités.
| Graphique d'entités existant | ||
|---|---|---|
| Hostname (Nom d'hôte) | IP | MAC |
| ftp01 | 10.1.1.4 | …:01 |
| www01 | 10.1.1.5 | …:02 |
| Tableau de données | |||
|---|---|---|---|
| Hostname (Nom d'hôte) | IP | MAC | Propriétaire |
| ftp01 | 10.1.1.4 | …:bb | alice |
| h1 | 10.1.1.5 | …:cc | bob |
| h2 | 10.1.1.6 | …:dd | chris |
| h3 | 10.1.1.4 | …:ee | forme |
| Graphique d'entités enrichi | |||
|---|---|---|---|
| Hostname (Nom d'hôte) | IP | MAC | Propriétaire |
| ftp01 | 10.1.1.4 | …:bb | alice |
| www01 | 10.1.1.5 | …:02 | |
Ajouter des données de la table de données au graphique d'entités
Avec la fonction graph_append, aucune condition de jointure n'est requise.
Dans l'exemple suivant, toutes les lignes de la table de données sont ajoutées aux lignes du graphique d'entités.
Exemple
rule rule_append { meta: description = "Data table append entity" setup: graph_append [$g1, %example_table] events: // filter UDM events $e.metadata.event_type = "NETWORK_CONNECTION" $e.security_result.action = "ALLOW" // Join the filtered UDM events with the enriched graph $e.target.ip = $iocip $g1.graph.entity.ip = $iocip match: $iocip over 1h condition: $e and $g1 }
L'exemple de tableau suivant illustre une opération d'ajout, où les lignes de la table de données sont ajoutées aux lignes du graphique d'entités :
| Graphique d'entités existant | ||
|---|---|---|
| Hostname (Nom d'hôte) | IP | MAC |
| ftp01 | 10.1.1.4 | …:01 |
| www01 | 10.1.1.5 | …:02 |
| Tableau de données | ||
|---|---|---|
| IP | MAC | Propriétaire |
| 10.1.1.4 | …:01 | alice |
| 10.1.1.6 | …:cc | bob |
| 10.1.1.7 | …:dd | chris |
| 10.1.1.4 | …:ee | forme |
| Graphique d'entités enrichi | |||
|---|---|---|---|
| Hostname (Nom d'hôte) | IP | MAC | Propriétaire |
| ftp01 | 10.1.1.4 | …:01 | |
| www01 | 10.1.1.5 | …:02 | |
| 10.1.1.4 | …:bb | alice | |
| 10.1.1.6 | …:cc | bob | |
| 10.1.1.7 | …:dd | chris | |
| 10.1.1.4 | …:ee | forme | |
Utiliser graph_exclude pour supprimer des lignes du graphique d'entités
Avec la fonction graph_exclude, les lignes du graphique d'entités qui correspondent à la condition de jointure sont supprimées du graphique d'entités.
Dans l'exemple suivant, toutes les lignes du graphique d'entités qui correspondent à la condition de jointure donnée (entre la colonne de la table de données et le champ du graphique d'entités) sont supprimées. Aucune ligne de la table de données n'est ajoutée au graphique d'entités.
Exemple
rule rule_exclude { meta: setup: graph_exclude ($g1.graph.entity.ip = %example_table.ip) events: $e.metadata.event_type = "NETWORK_CONNECTION" $e.security_result.action = "ALLOW" $e.target.ip = $iocip $g1.graph.entity.ip = $iocip match: $iocip over 1h condition: $e and $g1 }
Les tableaux suivants illustrent une opération d'exclusion dans laquelle les lignes du graphique d'entité qui correspondent au champ d'adresse IP de la table de données sont supprimées :
| Graphique d'entités existant | ||
|---|---|---|
| Hostname (Nom d'hôte) | IP | MAC |
| ftp01 | 10.1.1.4 | …:01 |
| www01 | 10.1.1.5 | …:02 |
| Tableau de données | ||
|---|---|---|
| IP | MAC | Propriétaire |
| 10.1.1.4 | …:bb | alice |
| 10.1.1.6 | …:cc | bob |
| 10.1.1.7 | …:dd | chris |
| Graphique d'entités enrichi | ||
|---|---|---|
| Hostname (Nom d'hôte) | IP | MAC |
| www01 | 10.1.1.5 | …:02 |
Limites de débit des API
Les quotas de requêtes par minute (RPM) suivants sont appliqués par projet et par utilisateur lors de l'appel des points de terminaison de l'API REST Google SecOps Data Table et Data Table Row :
| Ressource | Opération d'API | Limitation du débit (STANDARD) |
|---|---|---|
| DataTables | CreateDataTable (data_table/create_requests) |
60 RPM |
| DataTables | GetDataTable (data_table/get_requests) |
120 RPM |
| DataTables | ListDataTables (data_table/list_requests) |
120 RPM |
| DataTables | UpdateDataTable (data_table/update_requests) |
60 RPM |
| DataTables | DeleteDataTable (data_table/delete_requests) |
60 RPM |
| DataTableRows | CreateDataTableRow (data_table_row/create_requests) |
60 RPM |
| DataTableRows | GetDataTableRow (data_table_row/get_requests) |
120 RPM |
| DataTableRows | ListDataTableRows (data_table_row/list_requests) |
120 RPM |
| DataTableRows | UpdateDataTableRow (data_table_row/update_requests) |
60 RPM |
| DataTableRows | DeleteDataTableRow (data_table_row/delete_requests) |
60 RPM |
| DataTableRows | BulkCreateDataTableRows (synchrone/asynchrone) |
30 RPM |
| DataTableRows | BulkReplaceDataTableRows (synchrone/asynchrone) |
30 RPM |
| DataTableRows | BulkUpdateDataTableRows (synchrone/asynchrone) |
10 RPM |
| DataTableRows | BulkDeleteDataTableRows (synchrone/asynchrone) |
30 RPM |
| DataTableRows | BulkGetDataTableRows (data_table_row/bulk_get_requests) |
120 RPM |
Limites
Nombre maximal de tables de données pour un compte Google SecOps : 1 000.
Les tables de données n'acceptent que les données CSV. Les tables de données n'acceptent les valeurs séparées par une tabulation que lorsque vous ajoutez une nouvelle table de données et importez un fichier de valeurs séparées par une tabulation (TSV).
Les champs de table de données ne sont pas compatibles avec les virgules (
,).Les limites du nombre d'instructions
inlors du référencement d'une liste de référence dans une requête s'appliquent également aux instructionsind'une table de données.Nombre maximal d'instructions
indans une requête pour les colonnes typéesStringetNumber: 10.Nombre maximal d'instructions
inavec des opérateurs d'expression régulière : 5.Nombre maximal d'instructions
inavec des opérateurs CIDR : 5.Nombre maximal d'instructions
= (JOIN): 10.Nombre maximal de colonnes par table de données : 1 000.
Nombre maximal de lignes par tableau de données : 10 millions.
Limite d'affichage maximale sur une page Web pour les lignes de table de données dans la vue de l'éditeur de texte et de table : 10 000 lignes.
Volume de données maximal dans une table de données : 10 Go.
Les espaces réservés ne sont pas autorisés dans la section de configuration.
Les colonnes non mappées d'une table de données dont le type de données est défini sur
stringne peuvent être jointes qu'avec des champs de chaîne d'un événement UDM ou d'une entité UDM.N'utilisez que des colonnes non mappées dans un tableau de données dont le type de données est défini sur
cidrouregexpour le CIDR ou l'expression régulière.Recherches dans les tables de données : les caractères génériques d'expression régulière ne sont pas acceptés et les termes de recherche sont limités à 100 caractères.
Limites des jointures de tables de données dans les règles
Les limites suivantes s'appliquent aux jointures de tables de données dans les règles.
La récupération de tous les exemples d'événements pour les détections n'est pas possible lorsque vous utilisez des jointures de tables de données avec des événements.
Contrairement aux entités et à l'UDM, les tables de données ne sont pas compatibles avec les espaces réservés. Cela entraîne les limites suivantes :
Vous ne pouvez pas appliquer un ensemble de filtres à un tableau de données et le joindre à une entité UDM.
Vous ne pouvez pas appliquer un autre ensemble de filtres à la même table de données lorsque vous la joignez à un autre espace réservé UDM.
Par exemple, une table de données nommée
dtavec trois colonnes :my_hostname,orgetmy_email, et avec la règle suivante :events: $e1.principal.hostname = %dt.my_hostname %dt.org ="hr" $e2.principal.email = %dt.my_email %dt.org !="hr"
Tous les filtres d'une table de données sont d'abord appliqués, puis les lignes filtrées de la table de données sont jointes à l'UDM. Dans ce cas, les filtres contradictoires (%dt.org ="hr" and %dt.org !="hr") sur la table dt génèrent une table de données vide, qui est ensuite jointe à e1 et e2.
Limites de l'utilisation des tableaux de données avec des règles
Les limites suivantes s'appliquent aux tableaux de données lorsqu'ils sont utilisés avec des règles.
Limites concernant la fréquence d'exécution
La fréquence d'exécution en temps réel n'est pas disponible pour les règles avec des tableaux de données.
Limites de la sortie vers des tables de données
Les modificateurs
anyetallne sont pas acceptés pour les colonnes de champs répétés dans les tables de données.L'indexation de tableaux n'est pas acceptée pour les colonnes de champs répétés dans les tables de données.
Vous ne pouvez exporter des variables de résultat que vers une table de données. Vous ne pouvez pas exporter directement les chemins d'événements ni les colonnes du tableau de données.
Les listes de colonnes doivent inclure les colonnes de clé primaire pour les tables de données.
Vous pouvez avoir jusqu'à 20 résultats.
Si aucune table de données n'existe, une table est créée avec le type de données
stringpar défaut pour toutes les colonnes, dans l'ordre spécifié.Cinq règles au maximum peuvent écrire simultanément dans un tableau de données.
Rien ne garantit qu'une règle de producteur puisse ajouter des lignes à une table de données avant le démarrage d'une règle de consommateur pour cette table de données.
Une règle unique est limitée en termes de nombre de lignes de résultat. Une limite maximale de 10 000 lignes s'applique au résultat,aux données persistantes et aux tables de données.
Lorsque vous mettez à jour une ligne, les nouvelles valeurs de toutes les colonnes non clés remplacent les anciennes. Toutes les mises à jour, y compris l'ajout d'une ligne, sont disponibles pour les requêtes après environ cinq minutes.
Limites de l'enrichissement d'entités à partir de tables de données
Vous ne pouvez appliquer qu'une seule opération d'enrichissement (
override,appendouexclude) à une seule variable de graphique d'entités.Chaque opération d'enrichissement ne peut utiliser qu'une seule table de données.
Vous pouvez définir un maximum de deux opérations d'enrichissement de n'importe quel type dans la section
setupd'une règle YARA-L.
Dans l'exemple suivant, une opération override est appliquée à la variable de graphique d'entités $g1 et une opération append est appliquée à la variable de graphique d'entités $g2.
none setup: graph_override($g1.graph.entity.user.userid = %table1.myids) graph_append [$g2, %table1]
Dans l'exemple précédent, la même table de données (table1) est utilisée pour améliorer différents graphiques d'entités. Vous pouvez également utiliser différentes tables de données pour améliorer les différents graphiques d'entités, comme suit :
none setup: graph_override($g1.graph.entity.user.userid = %table1.myids) graph_append [$g2, %table2]
Limites d'utilisation des tableaux de données avec la recherche
Les limites suivantes s'appliquent aux tables de données lorsqu'elles sont utilisées avec la recherche :
Une seule exécution de requête peut générer un maximum de 1 million de lignes dans un tableau de données ou 1 Go, selon la limite atteinte en premier.
La sortie de recherche vers une table de données ignore les lignes d'événements si elles dépassent 5 Mo.
L'enrichissement d'entités n'est pas compatible avec Search.
Les tables de données ne sont pas compatibles avec les clés de chiffrement gérées par le client (CMEK).
Les écritures sont limitées à six par minute et par client.
Les tables de données et les jointures de tables de données ne sont compatibles qu'avec les événements UDM, et non avec les entités.
Compatible :
%datatable1.column1 = %datatable2.column1Non compatible :
graph.entity.hostname = %sample.testVous ne pouvez pas inclure de variable
matchdans la sectionexportd'une requête de statistiques.Par exemple, l'élément suivant n'est pas accepté :
match: principal.hostname export: %sample.write_row( row: principal.hostname )
Limites lors du changement de nom ou de la suppression de tables de données avec l'API Chronicle ou Terraform
- Il n'est pas possible de renommer un ensemble de données via la plate-forme ou l'API.
- Vous ne pouvez pas supprimer un tableau de données (via la plate-forme ou l'API) s'il est référencé par une règle.
- Dans Terraform, renommer une table de données déclenche une opération de destruction et de recréation. Si la table de données est référencée par une règle, cette opération échouera, car l'API bloque la suppression de l'ancienne table.
- Risque de perte de données dans Terraform : même si une table de données n'est pas référencée par une règle, la renommer à l'aide de Terraform entraîne une perte de données définitive. Terraform détruit la table existante et la remplace par une nouvelle table vide qui ne conserve aucune donnée de l'originale.
- Solution recommandée :
- Créez une table de données avec le nouveau nom.
- Mettez à jour la ou les règles pour commencer à utiliser le nouveau tableau de données.
- Supprimez l'ancienne table de données.
Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.