Masquer des résultats dans Security Command Center

Cette page explique comment réduire le volume de résultats que vous recevez dans Security Command Center en masquant les résultats.

Si vous ignorez un résultat, celui-ci n'apparaît plus dans la vue par défaut de vos résultats dans la console Google Cloud. Vous pouvez désactiver manuellement ou automatiquement les résultats, et créer des filtres pour désactiver automatiquement les résultats existants et futurs en fonction des critères que vous spécifiez.

Les services de détection de Security Command Center fournissent des évaluations de sécurité générales de votre déploiement Google Cloud, mais vous pouvez constater que certains résultats ne sont pas appropriés ou pertinents pour votre organisation ou vos projets. Un grand nombre de résultats peut également compliquer l'identification et la résolution des risques les plus critiques pour vos analystes de sécurité. Ignorer les résultats vous fait gagner du temps lors de l'examen ou de la réponse aux résultats de sécurité des éléments isolés ou relevant des paramètres d'entreprise acceptables.

Ignorer les résultats présente plusieurs avantages par rapport à la désactivation des détecteurs :

• Vous pouvez créer des filtres personnalisés pour affiner les résultats qui sont ignorés.
• Vous pouvez utiliser des règles d'exclusion pour ignorer temporairement ou définitivement des résultats.
• La désactivation des résultats n'empêche pas l'analyse des éléments sous-jacents. Les résultats sont toujours générés, mais restent masqués jusqu'à ce que vous décidiez de les afficher.

Autorisations

Pour ignorer des résultats, vous avez besoin de l'une des solutions Identity and Access Management (IAM) suivantes au niveau de l'organisation, du dossier ou du projet:

• Afficher les règles de blocage :
  • Lecteur administrateur du centre de sécurité (roles/securitycenter.adminViewer)
  • Lecteur de paramètres du centre de sécurité (roles/securitycenter.settingsViewer)
  • Lecteur des configurations de mise en sourdine du centre de sécurité (roles/securitycenter.muteConfigsViewer)
• Affichez, créez, mettez à jour et supprimez des règles de blocage :
  • Administrateur du centre de sécurité (roles/securitycenter.admin)
  • Éditeur administrateur du centre de sécurité (roles/securitycenter.adminEditor)
  • Éditeur de paramètres du centre de sécurité (roles/securitycenter.settingsEditor)
  • Éditeur des configurations de mise en sourdine du centre de sécurité (roles/securitycenter.muteConfigsEditor)
• Désactiver manuellement les résultats :
  • Éditeur de données du centre de sécurité (roles/securitycenter.findingsEditor)

Vous pouvez également créer et attribuer des rôles personnalisés avec tout ou partie des autorisations suivantes :

• Ignorer les autorisations de lecture des règles
  • securitycenter.muteconfigs.get
  • securitycenter.muteconfigs.list
• Ignorer les autorisations d'écriture des règles
  • securitycenter.muteconfigs.create
  • securitycenter.muteconfigs.update
  • securitycenter.muteconfigs.delete
• Rechercher des autorisations en écriture
  • securitycenter.findings.setMute
  • securitycenter.findings.bulkMuteUpdate

Votre capacité à ignorer les résultats dépend des rôles attribués au sein de l’organisation, d'un dossier ou d'un projet. Vous pouvez ignorer les résultats de dossiers ou de projets spécifiques, et limiter la capacité d'autres personnes à ignorer les résultats en fonction de l'accès qui leur est accordé. Par exemple, si vous avez accès à un seul projet, vous ne pouvez ignorer les résultats que dans ce projet. Si vous avez accès à un dossier, vous pouvez ignorer les résultats de n'importe quel sous-dossier ou projet dans ce dossier.

Pour en savoir plus sur les rôles Security Command Center, consultez la page Contrôle des accès.

Créer et gérer des règles Ignorer

Les règles Ignorer sont des configurations Security Command Center qui utilisent des filtres que vous créez pour ignorer automatiquement les résultats futurs et existants en fonction de critères que vous spécifiez. Vous pouvez créer des filtres avec des règles Ignorer statiques ou dynamiques.

Les règles Ignorer statiques ignorent les futurs résultats indéfiniment. Les règles de masquage dynamique masquent temporairement les résultats futurs et existants jusqu'à une date spécifiée ou indéfiniment jusqu'à ce qu'un résultat ne corresponde plus à la configuration.

Types de règles Ignorer

Security Command Center est compatible avec les configurations de règles Ignorer statiques et dynamiques. Bien que vous pouvez utiliser simultanément des règles de coupure du son statiques et dynamiques, nous vous déconseillons de le faire. Les règles Ignorer statiques remplacent les règles Ignorer dynamiques lorsqu'elles sont appliquées au même trouver. Par conséquent, les règles de coupure du son dynamiques ne fonctionnent pas comme prévu, ce qui peut créer de la confusion lors de la gestion de vos résultats. Par conséquent, nous vous recommandons d'utiliser un seul type de règle de masquage.

Sauf si vous utilisez déjà des règles de masquage statiques, nous vous recommandons d'utiliser exclusivement des règles de masquage dynamiques, car elles offrent plus de flexibilité.

Le tableau suivant présente une comparaison générale des deux types de règles de masquage. Pour en savoir plus, consultez les sections Règles Ignorer statiques et Règles les règles Ignorer.

Règles Ignorer statiques	Règles Ignorer dynamiques
Intervenir indéfiniment en fonction des résultats.	Peut agir sur un vous pouvez trouver soit temporairement avec un délai d'expiration, soit indéfiniment si aucun délai d'expiration n'est défini.
Ne s'appliquent pas aux résultats existants.	S'applique aux résultats existants et nouveaux.
Elles ont priorité sur les règles Ignorer dynamiques.	Elles ont une priorité inférieure et sont remplacées par les règles de masquage statiques lorsque les deux types s'appliquent à une observation.

Règles Ignorer statiques

• Les règles Ignorer statiques fonctionnent indéfiniment. Lorsqu'un résultat correspond à votre configuration de masquage statique, Security Command Center définit automatiquement la propriété mute du résultat sur MUTED jusqu'à ce que vous la modifiiez manuellement.
• Les règles Ignorer statiques n'ont aucun effet sur les résultats existants. Elles ne s'appliquent qu'aux de résultats nouvellement créés ou mis à jour après la définition de la règle. Si vous également ignorer les résultats existants similaires, utilisez les mêmes filtres pour de manière groupée Ignorer des résultats.
• Les règles Ignorer statiques sont prioritaires sur les règles Ignorer dynamiques. Par conséquent, toutes les nouvelles découvertes qui correspondent à une règle de masquage statique définie sont considérées comme masquées, même si elles correspondent également à une règle de masquage dynamique définie.

Règles Ignorer dynamiques

• Les règles d'ignorer dynamique peuvent agir sur un résultat de façon temporaire avec une date d'expiration ou indéfiniment si aucune date d'expiration n'est définie. Lorsqu'un réseau existant ou nouvellement le résultat créé correspond à votre configuration de désactivation dynamique, Security Command Center définit automatiquement la propriété mute du résultat sur MUTED jusqu'à ce que le date d'expiration spécifiée, ou tant que le résultat ou la valeur la configuration proprement dite. Lorsqu'une règle Ignorer dynamique expire, Security Command Center supprime la règle du résultat. Si le résultat ne correspond à aucune autre règle de blocage dynamique, la propriété mute est automatiquement réinitialisée sur UNDEFINED.
• Les règles Ignorer dynamiques s'appliquent automatiquement aux résultats existants qui correspondent à vos configuration, ainsi qu'aux résultats nouvellement créés ou mis à jour.
• Les règles Ignorer dynamiques ont une priorité inférieure et sont remplacées par des règles Ignorer statiques lorsque les deux types s'appliquent à un résultat.

Nous vous recommandons d'utiliser exclusivement des règles de masquage dynamique. La possibilité de désactiver temporairement et de réactiver automatiquement les résultats rend les règles Ignorer dynamiques plus flexibles que les règles Ignorer statiques.

Si vous utilisez des règles Ignorer statiques pour réduire le nombre de résultats que vous examinez manuellement et que vous souhaitez passer aux règles Ignorer dynamiques, consultez Passer des règles Ignorer statiques aux règles Ignorer dynamiques.

Portée des règles Ignorer

Tenez compte du champ d'application d'une règle Ignorer lorsque vous créez des filtres.

Par exemple, si un filtre est écrit pour ignorer les résultats dans Project A, mais que le filtre lui-même est créé sous Project B, il est possible qu'il ne corresponde pas des résultats.

De même, si la résidence des données est activé, le champ d'application d'une règle Ignorer est limitée à l'emplacement Security Command Center dans lequel la règle Ignorer créé. Par exemple, si vous créez une règle Ignorer aux États-Unis (us), la règle Ignorer n'ignore pas les résultats stockés dans Union européenne (eu) ou Monde (global). Pour en savoir plus sur la résidence des données et les règles de blocage, consultez la section Règles de blocage, exportations continues et résidence des données.

Pour en savoir plus sur la création de filtres, consultez Filtrer les notifications.

Restrictions des règles Ignorer

Les règles de blocage ne sont pas compatibles avec toutes les propriétés de résultats. Pour une liste d'établissements ne sont pas compatibles avec les règles Ignorer, Propriétés de résultat non compatibles avec les règles Ignorer.

Remarque: Les résultats appartenant à la classe de résultats SCC errors signalent des problèmes qui empêchent Security Command Center de fonctionner comme prévu. Par conséquent, les résultats d'erreurs ne peuvent pas être ignorés. Pour en savoir plus, consultez la page Présentation des erreurs Security Command Center.

Vous pouvez créer, afficher, mettre à jour et supprimer des règles Ignorer en fonction du champ d'application de votre IAM. Les rôles au niveau de l'organisation s'affichent pour tous les dossiers et projets de l'organisation. Si vous disposez de rôles au niveau des dossiers, vous pouvez accéder aux règles de blocage pour des dossiers spécifiques, ainsi que tous les sous-dossiers et projets de ces dossiers, et les gérer. Les rôles au niveau du projet vous permettent de gérer les règles de blocage dans des projets spécifiques.

Security Command Center Premium permet d'accorder des rôles au niveau de l'organisation, du dossier et du projet. Security Command Center Standard n'accepte que l'attribution de rôles au niveau de l'organisation. Pour plus d'informations, consultez la section Contrôle des accès.

Résidence des données et règles de masquage

Preview — Data residency

Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Si la résidence des données est activée, le qui définissent des règles de masquage (muteConfig ressources) soumis au contrôle de résidence des données et sont stockés Emplacement Security Command Center que vous sélectionnez.

Pour appliquer une règle de masquage aux résultats d'un emplacement Security Command Center, vous devez créer la règle de masquage au même emplacement que les résultats auxquels elle s'applique.

Comme les filtres utilisés dans les règles Ignorer peuvent contenir des données soumises à des contrôles de résidence, veillez à spécifier le bon emplacement avant de les créer. Security Command Center ne limite pas l'emplacement que vous créez des règles Ignorer ou des exportations en flux continu.

Les règles Ignorer ne sont stockées que dans l'emplacement où elles sont créées et ne peuvent pas être consultées ni modifiées dans d'autres emplacements.

Une fois que vous avez créé une règle de masquage, vous ne pouvez plus modifier son emplacement. Pour modifier le lieu, vous devez supprimer la règle Ignorer et la recréer dans le nouvel emplacement.

Pour afficher les règles Ignorer dans la console Google Cloud, vous devez d'abord définir de la console Google Cloud vers l'emplacement ont été créées.

Les mêmes règles s'appliquent à la représentation de l'API d'une règle de masquage, MuteConfig.

Pour récupérer un MuteConfig à l'aide d'appels d'API, vous devez spécifier l'emplacement dans le nom de ressource complet de l'MuteConfig. Exemple :

GET https://securitycenter.googleapis.com/v2/{name=organizations/123/locations/eu/muteConfigs/my-mute-rule-01}

De même, pour récupérer un muteConfig à l'aide de la CLI gcloud, vous pouvez spécifier l'emplacement à l'aide de l'option --locations. Exemple :

gcloud scc muteconfigs list --organizations=123
--location=us

Créer une règle de mise en sourdine

Votre organisation peut créer jusqu'à 1 000 règles de blocage.

Vous pouvez créer des règles de masquage statiques ou dynamiques à l'aide de la console Google Cloud, de la gcloud CLI ou de l'API Security Command Center. Nous vous recommandons d'utiliser exclusivement des règles Ignorer dynamiques dans vos configurations de règles Ignorer, car elles sont plus flexibles que les règles Ignorer statiques. Pour comparer les types de règles de masquage, consultez Types de règles de masquage.

Pour obtenir un exemple de code qui crée une règle de blocage, consultez la section Créer une règle de blocage.

Pour créer une règle de masquage, cliquez sur l'onglet de la procédure que vous souhaitez utiliser :

Console

1. Dans la console Google Cloud, accédez à la page Résultats de Security Command Center.

   Accéder

2. Si nécessaire, sélectionnez votre projet ou votre organisation GooglenCloud.

3. Facultatif : Si la résidence des données est activée pour Security Command Center, modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'établissements s'affiche. Sélectionnez le nouvel emplacement.

4. Cliquez sur Ignorer les options, puis sélectionnez Gérer les règles de blocage.

5. Cliquez sur Créer une règle de blocage, puis sélectionnez Règle de blocage dynamique ou Règle de blocage statique. Pour en savoir plus sur les types de règles de blocage, consultez la section Types de règles de blocage.

6. Saisissez un ID de règle de blocage. Veuillez indiquer une valeur.

7. Saisissez une description de la règle de blocage qui fournit des informations sur la raison pour laquelle les résultats sont ignorés. Cette valeur est facultative, mais recommandée.

   La ressource parente indique le champ d'application auquel la règle de blocage sera créée et appliquée.

8. Si vous créez une règle Ignorer statique ou dynamique d'expiration, passez à l'étape suivante. Si vous créez une règle de masquage dynamique pour désactiver temporairement les résultats, procédez comme suit :

   1. Cochez la case Ignorer temporairement les résultats correspondants.
   2. Sélectionnez ou saisissez la date d'expiration de la règle de masquage dynamique. Cette valeur indique la durée pendant laquelle la règle ignorera les résultats correspondants.

9. Dans le champ Requête de résultats, créez vos instructions de requête en cliquant sur Ajouter un filtre. Vous pouvez également saisir manuellement les instructions de requête.

   La boîte de dialogue Sélectionner un filtre vous permet de choisir les attributs et les valeurs de résultats compatibles.

   1. Sélectionnez un attribut de résultat ou saisissez son nom dans la zone Rechercher des attributs de résultats. La liste des sous-attributs disponibles s'affiche.
   2. Sélectionnez un sous-attribut. Un champ de sélection s'affiche, dans lequel vous pouvez créer l'instruction de requête à l'aide du sous-attribut que vous avez sélectionné, d'un opérateur de requête et d'une ou plusieurs valeurs pour le sous-attribut.
   3. Sélectionnez l'opérateur et une ou plusieurs valeurs pour le sous-attribut dans le panneau. Pour plus d'informations sur les opérateurs de requête et les fonctions qu'ils utilisent, consultez Requête dans le menu "Ajouter des filtres".
   4. Cliquez sur Appliquer.

      La boîte de dialogue se ferme et votre requête est mise à jour.

   5. Répétez l'opération jusqu'à ce que la requête de résultats contienne tous les attributs souhaités.

10. Vérifiez l'exactitude du filtre. Pour apporter des modifications, supprimez ou ajoutez des propriétés et filtrez les valeurs si nécessaire.

11. Cliquez sur Prévisualiser les résultats correspondants.

    Une table affiche les résultats correspondant à votre requête.

12. Cliquez sur Enregistrer.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour créer des règles de blocage, exécutez la commande gcloud scc muteconfigs create :

   gcloud scc muteconfigs create CONFIG_ID \
   --PARENT=PARENT_ID \
   --location=LOCATION
   --description="RULE_DESCRIPTION" \
   --filter="FILTER" \
   --type=MUTE_TYPE \
   --expiry-time=TIMESTAMP
   

   Remplacez les éléments suivants :

   • CONFIG_ID: nom de la règle Ignorer. L'ID doit comporter entre 1 et 63 caractères, et être composé de caractères alphanumériques et de traits d'union.
   • PARENT : champ d'application dans la hiérarchie des ressources auquel la règle de masquage s'applique, organization, folder ou project.
   • PARENT_ID : ID de l'organisation, du dossier ou du projet parent, spécifié au format organizations/123, folders/456 ou projects/789.
   • LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel créer une règle de masquage. Si la résidence des données n'est pas activée, utilisez la valeur global.
   • RULE_DESCRIPTION: description de la désactivation du son ne dépassant pas 1 024 caractères.
   • FILTER : expression que vous définissez pour filtrer les résultats. Par exemple, pour ignorer OPEN_FIREWALL résultats, votre filtre peut être FILTER="category=\"OPEN_FIREWALL\"".
   • MUTE_TYPE: type de règle Ignorer que vous souhaitez créer. Les types de règles Ignorer valides sont DYNAMIC et STATIC Le type de règle de masquage est défini sur STATIC par défaut. Une fois que vous avez créé une règle Ignorer, vous ne pouvez plus modifier son type.
   • TIMESTAMP : ne s'applique que si vous créez une règle de blocage dynamique. Chaîne de date/heure indiquant quand la valeur la règle Ignorer expire. La valeur doit être définie sur au moins un jour à l'avance, sinon la demande sera refusée. Pour des informations sur les formats d'heure, consultez gcloud topic datetimes. Lorsque le son est coupé de façon dynamique expire, elle est supprimée de tous les résultats correspondants. Si vous souhaitez que règle Ignorer dynamique pour agir indéfiniment sur les résultats correspondants, omettez cette .

   La réponse inclut l'ID de la règle de blocage, que vous pouvez utiliser pour afficher, mettre à jour et supprimer des règles de blocage, comme décrit dans la section Gérer les règles de blocage.

Go

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2 et ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv1"
	"cloud.google.com/go/securitycenter/apiv1/securitycenterpb"
)

// createMuteRule: Creates a mute configuration under a given scope that will mute
// all new findings that match a given filter.
// Existing findings will not be muted.
func createMuteRule(w io.Writer, parent string, muteConfigId string) error {
	// parent: Use any one of the following options:
	//             - organizations/{organization_id}
	//             - folders/{folder_id}
	//             - projects/{project_id}
	// parent := fmt.Sprintf("projects/%s", "your-google-cloud-project-id")
	// muteConfigId: Set a random id; max of 63 chars.
	// muteConfigId := "random-mute-id-" + uuid.New().String()
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	muteConfig := &securitycenterpb.MuteConfig{
		Description: "Mute low-medium IAM grants excluding 'compute' ",
		// Set mute rule(s).
		// To construct mute rules and for supported properties, see:
		// https://cloud.google.com/security-command-center/docs/how-to-mute-findings#create_mute_rules
		Filter: "severity=\"LOW\" OR severity=\"MEDIUM\" AND " +
			"category=\"Persistence: IAM Anomalous Grant\" AND " +
			"-resource.type:\"compute\"",
	}

	req := &securitycenterpb.CreateMuteConfigRequest{
		Parent:       parent,
		MuteConfigId: muteConfigId,
		MuteConfig:   muteConfig,
	}

	response, err := client.CreateMuteConfig(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to create mute rule: %w", err)
	}
	fmt.Fprintf(w, "Mute rule created successfully: %s", response.Name)
	return nil
}

Java

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où "PARENT" correspond à organizations, folders, ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

import com.google.cloud.securitycenter.v1.CreateMuteConfigRequest;
import com.google.cloud.securitycenter.v1.MuteConfig;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import java.io.IOException;
import java.util.UUID;

public class CreateMuteRule {

  public static void main(String[] args) {
    // TODO: Replace the variables within {}

    // parentPath: Use any one of the following options:
    //             - organizations/{organization_id}
    //             - folders/{folder_id}
    //             - projects/{project_id}
    String parentPath = String.format("projects/%s", "your-google-cloud-project-id");

    // muteConfigId: Set a random id; max of 63 chars.
    String muteConfigId = "random-mute-id-" + UUID.randomUUID();
    createMuteRule(parentPath, muteConfigId);
  }

  // Creates a mute configuration under a given scope that will mute
  // all new findings that match a given filter.
  // Existing findings will not be muted.
  public static void createMuteRule(String parentPath, String muteConfigId) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      MuteConfig muteConfig =
          MuteConfig.newBuilder()
              .setDescription("Mute low-medium IAM grants excluding 'compute' ")
              // Set mute rule(s).
              // To construct mute rules and for supported properties, see:
              // https://cloud.google.com/security-command-center/docs/how-to-mute-findings#create_mute_rules
              .setFilter(
                  "severity=\"LOW\" OR severity=\"MEDIUM\" AND "
                      + "category=\"Persistence: IAM Anomalous Grant\" AND "
                      + "-resource.type:\"compute\"")
              .build();

      CreateMuteConfigRequest request =
          CreateMuteConfigRequest.newBuilder()
              .setParent(parentPath)
              .setMuteConfigId(muteConfigId)
              .setMuteConfig(muteConfig)
              .build();

      // ExecutionException is thrown if the below call fails.
      MuteConfig response = client.createMuteConfig(request);
      System.out.println("Mute rule created successfully: " + response.getName());
    } catch (IOException e) {
      System.out.println("Mute rule creation failed! \n Exception: " + e);
    }
  }
}

Python

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

def create_mute_rule(parent_path: str, mute_config_id: str) -> None:
    """
    Creates a mute configuration under a given scope that will mute
    all new findings that match a given filter.
    Existing findings will NOT BE muted.
    Args:
        parent_path: use any one of the following options:
                     - organizations/{organization_id}
                     - folders/{folder_id}
                     - projects/{project_id}
        mute_config_id: Set a unique id; max of 63 chars.
    """

    from google.cloud import securitycenter

    client = securitycenter.SecurityCenterClient()

    mute_config = securitycenter.MuteConfig()
    mute_config.description = "Mute low-medium IAM grants excluding 'compute' "
    # Set mute rule(s).
    # To construct mute rules and for supported properties, see:
    # https://cloud.google.com/security-command-center/docs/how-to-mute-findings#create_mute_rules
    mute_config.filter = (
        'severity="LOW" OR severity="MEDIUM" AND '
        'category="Persistence: IAM Anomalous Grant" AND '
        '-resource.type:"compute"'
    )

    request = securitycenter.CreateMuteConfigRequest()
    request.parent = parent_path
    request.mute_config_id = mute_config_id
    request.mute_config = mute_config

    mute_config = client.create_mute_config(request=request)
    print(f"Mute rule created successfully: {mute_config.name}")

API REST

Dans l'API Security Command Center, utilisez la méthode muteConfigs create pour créer une règle Ignorer. Le corps de la requête est une instance de MuteConfig.

Sauf si la résidence des données est activée, vous pouvez utiliser la version 1 ou la version 2 de l'API Security Command Center. L'API v2 est disponible en version preview. Lorsque la résidence des données est activée, L'API v2 est la seule API disponible.

Si vous utilisez la version 1 de l'API Security Command Center, utilisez le point de terminaison de la version 1 pour appeler muteConfigs create. Dans le corps de la requête, utilisez la définition MuteConfig de la version 1 :

POST https://securitycenter.googleapis.com/v1/PARENT/PARENT_ID/muteConfigs?muteConfigId=MUTE_CONFIG_ID -d

  {
    "description": "RULE_DESCRIPTION",
    "filter": "FILTER",
    "type": "MUTE_TYPE",
    "expiryTime": "TIMESTAMP"
  }

Si vous utilisez la version 2 de l'API Security Command Center, utilisez le point de terminaison de la version 2 pour appeler muteConfigs create. Dans le corps de la requête, utilisez la définition de la version 2 de MuteConfig :

POST https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/locations/LOCATION/muteConfigs?muteConfigId=MUTE_CONFIG_ID -d

  {
    "description": "RULE_DESCRIPTION",
    "filter": "FILTER",
    "type": "MUTE_TYPE",
    "expiryTime": "TIMESTAMP"
  }

Remplacez les éléments suivants :

• PARENT : ressource parente de votre règle de blocage (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation parente. dossier ou projet
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel créer une règle de masquage. Si la résidence des données n'est pas activée, utilisez la valeur global.
• MUTE_CONFIG_ID: nom de la règle Ignorer (entre 1 et 63 caractères)
• RULE_DESCRIPTION: description de la désactivation du son règle (1 024 caractères max.)

• FILTER: expression que vous définissez pour filtrer résultats

  Par exemple, pour ignorer les résultats OPEN_FIREWALL, votre filtre peut être "category=\"OPEN_FIREWALL\"".

• MUTE_TYPE : type de règle de blocage que vous souhaitez créer. Les types de règles Ignorer valides sont DYNAMIC et STATIC Vous ne pouvez pas modifier le type d'une règle de masquage une fois qu'elle a été créée.

• TIMESTAMP : ne s'applique que si vous créez une règle de blocage dynamique. Chaîne de date/heure qui indique quand la règle de masquage dynamique expire. La valeur doit être définie sur au moins un jour de la période ou la demande sera rejetée. Pour des informations sur les formats d'heure, consultez gcloud topic datetimes. Lorsque le son est coupé de façon dynamique expire, elle est supprimée de tous les résultats correspondants. Si vous souhaitez que la règle Ignorer dynamique agisse indéfiniment sur les résultats correspondants, omettez ce champ.

La réponse inclut un ID de configuration de blocage, que vous pouvez utiliser pour afficher, mettre à jour et supprimer des règles de blocage, comme décrit dans la section Gérer les règles de blocage.

Les nouveaux résultats qui correspondent exactement au filtre sont masqués et l'attribut mute des résultats est défini sur MUTED.

Propriétés de résultats non compatibles avec les règles de blocage

Les règles de blocage ne sont pas compatibles avec toutes les propriétés de résultat dans les filtres. Les propriétés suivantes ne sont pas compatibles avec les filtres de règle de blocage.

• createTime
• eventTime
• mute
• mute_initiator
• mute_update_time
• name
• parent
• security_marks
• source_properties
• state

Répertorier les règles de blocage

Vous pouvez répertorier les règles Ignorer d'une organisation, d'un dossier ou d'un projet en à l'aide de la console Google Cloud, la gcloud CLI ou l'API Security Command Center.

Votre capacité à lister les règles Ignorer pour un champ d'application donné dépend de la les autorisations accordées à votre rôle IAM de rôles.

Si la résidence des données est activée pour Security Command Center, le champ d'application "list" est également limitée aux éléments sélectionnés Emplacement Security Command Center.

Pour obtenir un exemple de code qui liste les règles de blocage, consultez la section Liste des règles de blocage.

Pour afficher les règles de masquage d'une organisation, d'un dossier ou d'un projet, cliquez sur l'onglet correspondant à la procédure que vous souhaitez suivre :

Console

1. Dans la console Google Cloud, accédez à l'onglet Règles Ignorer dans Page Paramètres de Security Command Center.

   Accéder aux règles Ignorer

2. Si nécessaire, sélectionnez votre projet ou votre organisation GooglenCloud.

3. Facultatif : Si la résidence des données est activée pour Security Command Center, modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'emplacements s'affiche. Sélectionnez le nouvel emplacement.

4. La section Règles de blocage affiche les détails des règles de blocage actives, y compris les suivantes :

   • Nom : ID de la règle de blocage
   • Ressource parente : ressource où réside la règle de blocage
   • Description : description de la règle de blocage, si disponible
   • Dernière mise à jour par : compte principal qui a mis à jour la règle pour la dernière fois.
   • Dernière mise à jour : date et heure de la dernière mise à jour de la règle.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour répertorier les règles Ignorer, exécutez la commande gcloud scc muteconfigs list:

   gcloud scc muteconfigs list --PARENT=PARENT_ID
   --location=LOCATION
   

   Remplacez les éléments suivants :

   • PARENT : organization, folder ou project parent pour lequel lister les règles de blocage
   • PARENT_ID : ID de l'organisation, du dossier ou du projet parent
   • LOCATION: si la résidence des données est activée, le Security Command Center location de la liste des règles de masquage si la résidence des données n'est pas activée, utilisez la valeur global

Go

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2 et ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION au nom de la ressource après /sources/SOURCE_ID, où SOURCE_ID est l'ID du service Security Command Center qui a généré le résultat.

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv1"
	"cloud.google.com/go/securitycenter/apiv1/securitycenterpb"
	"google.golang.org/api/iterator"
)

// listMuteRules lists mute configs at the organization level will return all the configs
// at the org, folder, and project levels.
// Similarly, listing configs at folder level will list all the configs
// at the folder and project levels.
func listMuteRules(w io.Writer, parent string) error {
	// Use any one of the following resource paths to list mute configurations:
	//         - organizations/{organization_id}
	//         - folders/{folder_id}
	//         - projects/{project_id}
	// parent := fmt.Sprintf("projects/%s", "your-google-cloud-project-id")
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	req := &securitycenterpb.ListMuteConfigsRequest{Parent: parent}

	// List all mute configs present in the resource.
	it := client.ListMuteConfigs(ctx, req)
	for {
		muteconfig, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("it.Next: %w", err)
		}
		fmt.Fprintf(w, "Muteconfig Name: %s, ", muteconfig.Name)
	}
	return nil
}

Java

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

import com.google.cloud.securitycenter.v1.ListMuteConfigsRequest;
import com.google.cloud.securitycenter.v1.MuteConfig;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import java.io.IOException;

public class ListMuteRules {

  public static void main(String[] args) {
    // TODO: Replace variables enclosed within {}

    // parent: Use any one of the following resource paths to list mute configurations:
    //         - organizations/{organization_id}
    //         - folders/{folder_id}
    //         - projects/{project_id}
    String parentPath = String.format("projects/%s", "your-google-cloud-project-id");
    listMuteRules(parentPath);
  }

  // Listing mute configs at the organization level will return all the configs
  // at the org, folder, and project levels.
  // Similarly, listing configs at folder level will list all the configs
  // at the folder and project levels.
  public static void listMuteRules(String parent) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      ListMuteConfigsRequest listMuteConfigsRequest =
          ListMuteConfigsRequest.newBuilder().setParent(parent).build();

      // List all mute configs present in the resource.
      for (MuteConfig muteConfig : client.listMuteConfigs(listMuteConfigsRequest).iterateAll()) {
        System.out.println(muteConfig.getName());
      }
    } catch (IOException e) {
      System.out.println("Listing Mute rule failed! \n Exception: " + e);
    }
  }
}

Python

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION au nom de la ressource après /sources/SOURCE_ID, où SOURCE_ID est l'ID du service Security Command Center qui a généré le résultat.

def list_mute_rules(parent: str) -> None:
    """
    Listing mute configs at organization level will return all the configs
    at the org, folder and project levels.
    Similarly, listing configs at folder level will list all the configs
    at the folder and project levels.
    Args:
        parent: Use any one of the following resource paths to list mute configurations:
                - organizations/{organization_id}
                - folders/{folder_id}
                - projects/{project_id}
    """
    from google.cloud import securitycenter

    client = securitycenter.SecurityCenterClient()

    request = securitycenter.ListMuteConfigsRequest()
    request.parent = parent

    # List all Mute Configs present in the resource.
    for mute_config in client.list_mute_configs(request):
        print(mute_config.name)

API REST

Dans l'API Security Command Center, utilisez la méthode muteConfigs list pour répertorier règles Ignorer. Le corps de la requête est vide.

Sauf si la résidence des données est activée, vous pouvez utiliser la version 1 ou la version 2 de l'API Security Command Center. API v2 est disponible en tant que Version Preview. Lorsque la résidence des données est activée, l'API V2 est la seule API disponible.

Si vous utilisez la version 1 de l'API Security Command Center, utilisez le point de terminaison v1 pour appeler muteConfigs list:

GET https://securitycenter.googleapis.com/v1/PARENT/PARENT_ID/muteConfigs

Si vous utilisez la version 2 de l'API Security Command Center, utilisez le point de terminaison v2 pour appeler muteConfigs list :

GET https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/locations/LOCATION/muteConfigs

Remplacez les éléments suivants :

• PARENT : ressource parente de votre règle de blocage (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation parente. dossier ou projet
• LOCATION: si la résidence des données est activée, le Security Command Center location de la liste des règles de masquage si la résidence des données n'est pas activée, utilisez la valeur global

La réponse inclut les noms, les descriptions et les ID de configuration de blocage pour vos règles de blocage.

Afficher la configuration d'une règle de blocage

Vous pouvez afficher la configuration d'une règle de masquage à l'aide de la console Google Cloud, de gcloud CLI ou de l'API Security Command Center.

Pour obtenir un exemple de code qui récupère une configuration de règle Ignorer, consultez la section Affichez une règle Ignorer.

Pour afficher la configuration d'une règle de masquage, cliquez sur l'onglet correspondant à la procédure que vous souhaitez utiliser :

Console

1. Dans la console Google Cloud, accédez à l'onglet Règles Ignorer dans Page Paramètres de Security Command Center.

   Accéder à la page "Règles de masquage"

2. Si nécessaire, sélectionnez votre projet ou votre organisation GooglenCloud.

3. Facultatif: Si la résidence des données est activée pour Security Command Center, puis modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'établissements s'affiche. Sélectionnez le nouvel emplacement.

4. La section Règles de blocage s'affiche dans la section.

5. Cliquez sur le nom de la règle que vous souhaitez afficher.

   La page qui s'ouvre affiche la configuration de la règle de blocage.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour afficher la configuration d'une règle Ignorer, exécutez la Commande gcloud scc muteconfigs get:

   gcloud scc muteconfigs get MUTE_CONFIG_ID \
    --PARENT=PARENT_ID --location=LOCATION
   

   Remplacez les éléments suivants :

   • MUTE_CONFIG_ID: ID de la règle Ignorer
   • PARENT : ressource parente de votre règle de blocage (organization, folder ou project)
   • PARENT_ID : ID de l'organisation, du dossier ou du projet
   • LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel afficher la configuration de la règle de masquage. Si la résidence des données n'est pas activée, utilisez la valeur global.

Go

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2 et ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où "PARENT" correspond à organizations, folders, ou projects.

Pour les résultats, ajoutez /locations/LOCATION au nom de la ressource après /sources/SOURCE_ID, où SOURCE_ID est l'ID du service Security Command Center qui a généré le résultat.

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv1"
	"cloud.google.com/go/securitycenter/apiv1/securitycenterpb"
)

// getMuteRule retrieves a mute configuration given its resource name.
func getMuteRule(w io.Writer, parent string, muteConfigId string) error {
	// Use any one of the following resource paths to get mute configuration:
	//         - organizations/{organization_id}
	//         - folders/{folder_id}
	//         - projects/{project_id}
	// parent := fmt.Sprintf("projects/%s", "your-google-cloud-project-id")
	//
	// Name of the mute config to retrieve.
	// muteConfigId := "mute-config-id"
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	req := &securitycenterpb.GetMuteConfigRequest{
		Name: fmt.Sprintf("%s/muteConfigs/%s", parent, muteConfigId),
	}

	muteconfig, err := client.GetMuteConfig(ctx, req)
	if err != nil {
		return fmt.Errorf("Failed to retrieve Muteconfig: %w", err)
	}
	fmt.Fprintf(w, "Muteconfig Name: %s ", muteconfig.Name)
	return nil
}

Java

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où "PARENT" correspond à organizations, folders, ou projects.

Pour les résultats, ajoutez /locations/LOCATION au nom de la ressource après /sources/SOURCE_ID, où SOURCE_ID est l'ID du service Security Command Center qui a généré le résultat.

import com.google.cloud.securitycenter.v1.MuteConfig;
import com.google.cloud.securitycenter.v1.MuteConfigName;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import java.io.IOException;

public class GetMuteRule {

  public static void main(String[] args) {
    // TODO(Developer): Replace the following variables

    // parentPath: Use any one of the following options:
    //             - organizations/{organization_id}
    //             - folders/{folder_id}
    //             - projects/{project_id}
    String parentPath = String.format("projects/%s", "your-google-cloud-project-id");

    // muteConfigId: Name of the mute config to retrieve.
    String muteConfigId = "mute-config-id";

    getMuteRule(parentPath, muteConfigId);
  }

  // Retrieves a mute configuration given its resource name.
  public static void getMuteRule(String projectId, String muteConfigId) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {
      // Use appropriate MuteConfigName methods depending on the type of parent.
      // (org -> MuteConfigName.ofOrganizationMuteConfigName()
      // folder -> MuteConfigName.ofFolderMuteConfigName()
      // project -> MuteConfigName.ofProjectMuteConfigName)
      MuteConfig muteConfig =
          client.getMuteConfig(MuteConfigName.ofProjectMuteConfigName(projectId, muteConfigId));

      System.out.println("Retrieved the mute config: " + muteConfig);
    } catch (IOException e) {
      System.out.println("Mute rule retrieval failed! \n Exception: " + e);
    }
  }
}

Python

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

def get_mute_rule(mute_config_name: str) -> None:
    """
    Retrieves a mute configuration given its resource name.
    Args:
        mute_config_name: Name of the mute config to retrieve.
                          Use any one of the following formats:
                          - organizations/{organization}/muteConfigs/{config_id}
                          - folders/{folder}/muteConfigs/{config_id}
                          - projects/{project}/muteConfigs/{config_id}
    """
    from google.cloud import securitycenter

    client = securitycenter.SecurityCenterClient()

    request = securitycenter.GetMuteConfigRequest()
    request.name = mute_config_name

    mute_config = client.get_mute_config(request)
    print(f"Retrieved the mute rule: {mute_config.name}")

API REST

Dans l'API Security Command Center, utilisez la méthode muteConfigs get pour renvoyer la configuration d'une règle de masquage. Le corps de la requête est vide.

Pour obtenir la valeur CONFIG_ID d'une règle de blocage, commencez par exécuter un appel d'API vers Répertorier les règles de blocage. La réponse inclut des ID de configuration pour les règles de blocage renvoyées.

Si la résidence des données n'est pas activée, vous pouvez utiliser les versions v1 ou 2 l'API Security Command Center. La version 2 de l'API est disponible en version preview. Lorsque la résidence des données est activée, l'API V2 est la seule API disponible.

Si vous utilisez la version 1 de l'API Security Command Center, utilisez le point de terminaison v1 pour appeler muteConfigs get :

GET https://securitycenter.googleapis.com/v1/PARENT/PARENT_ID/muteConfigs/CONFIG_ID

Si vous utilisez la version 2 de l'API Security Command Center, utilisez le point de terminaison v2 pour appeler muteConfigs get :

GET https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/locations/LOCATION/muteConfigs/CONFIG_ID

Remplacez les éléments suivants :

• PARENT : ressource parente de votre règle de blocage (organizations, folders ou projects)
• PARENT_ID : ID de l'organisation, du dossier ou du projet
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel afficher la configuration de la règle de masquage. Si la résidence des données n'est pas activée, utilisez la valeur global.
• CONFIG_ID : ID numérique de la règle de blocage

Mettre à jour les règles de blocage

Vous pouvez modifier la description ou le filtre de recherche d'une règle de masquage à l'aide de la console Google Cloud, de la CLI gcloud ou de l'API Security Command Center.

Vous ne pouvez pas modifier l'ID, l'organisation, le dossier ou le projet parent, ni l'emplacement d'une règle de masquage. Pour modifier l'une de ces valeurs, vous devez créer une règle de blocage.

Si vous avez précédemment réactivé les résultats, ils seront de nouveau ignorés s'ils sont mis en correspondance par une règle de blocage mise à jour dans la console Google Cloud. Pour en savoir plus, consultez la section Réactiver des résultats individuels.

Remarque: Les résultats appartenant à la classe de résultats SCC errors signalent des problèmes qui empêchent Security Command Center de fonctionner comme prévu. Par conséquent, les résultats d'erreurs ne peuvent pas être ignorés. Pour en savoir plus, consultez la page Présentation des erreurs Security Command Center.

Pour obtenir un exemple de code qui met à jour une règle de blocage, consultez la section Mettre à jour une règle de blocage.

Pour mettre à jour une règle de blocage, cliquez sur l'onglet correspondant à la procédure que vous souhaitez utiliser :

Console

1. Dans la console Google Cloud, accédez à l'onglet Règles Ignorer dans Page Paramètres de Security Command Center.

   Accéder aux règles Ignorer

2. Sélectionnez le projet ou l'organisation Google Cloud qui est la ressource parente de la règle de blocage que vous souhaitez modifier.

3. Facultatif : Si la résidence des données est activée pour Security Command Center, modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'établissements s'affiche. Sélectionnez le nouvel emplacement.

4. Cliquez sur le nom de la règle de blocage que vous souhaitez modifier.

   Si vous n'avez pas sélectionné le projet ou l'organisation appropriés, une note peut vous informer que vous n'êtes pas autorisé à modifier la règle de blocage.

5. Saisissez une nouvelle description, puis cliquez sur Enregistrer.

6. Pour les règles de masquage dynamiques, mettez à jour ou modifiez la date/heure d'expiration de la règle.

7. Mettez à jour le filtre.

   Pour obtenir des instructions, consultez l'article Créer des règles de blocage.

8. Pour afficher les résultats correspondant au filtre mis à jour, cliquez sur Prévisualiser les résultats correspondants.

   Une table se charge avec les résultats correspondant à la nouvelle requête.

9. Cliquez sur Enregistrer.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour mettre à jour les règles de blocage, exécutez la commande gcloud scc muteconfigs update :

     gcloud scc muteconfigs update MUTE_CONFIG_ID \
       --PARENT=PARENT_ID \
       --location=LOCATION
       --description=RULE_DESCRIPTION \
       --filter=FILTER
       --type=MUTE_TYPE \
       --expiry-time=TIMESTAMP
   

   Remplacez les éléments suivants :

   • MUTE_CONFIG_ID : ID de la règle de blocage.
   • PARENT: ressource parente de votre règle Ignorer (organization, folder ou project).
   • PARENT_ID : ID de l'organisation, du dossier ou du projet.
   • LOCATION: si la résidence des données est activée, le Security Command Center emplacement de mise à jour de la règle Ignorer ; si la résidence des données n'est pas activée, utilisez la valeur global
   • RULE_DESCRIPTION: description de la désactivation du son (1 024 caractères maximum).

   • FILTER: expression que vous définissez pour filtrer les résultats.

     Par exemple, pour ignorer les résultats OPEN_FIREWALL, votre filtre peut être FILTER="category=\"OPEN_FIREWALL\"".

   • MUTE_TYPE: type de règle Ignorer dont vous êtes en cours de mise à jour. Les types de règles Ignorer valides sont DYNAMIC et STATIC Une fois la règle de masquage créée, vous ne pouvez plus en modifier le type.

   • TIMESTAMP: s'applique uniquement si vous mettez à jour la règle Ignorer dynamique. Chaîne de date/heure qui indique quand la règle de mise en sourdine dynamique expire. La valeur doit être définie sur au moins un jour à l'avance, sinon la demande sera refusée. Pour obtenir des informations sur l'heure , consultez gcloud topic datetimes. Lorsque le son est coupé de façon dynamique expire, elle est supprimée de tous les résultats correspondants. Si vous souhaitez que la règle Ignorer dynamique agisse indéfiniment sur les résultats correspondants, omettez ce champ.

Go

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2 et ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION au nom de la ressource après /sources/SOURCE_ID, où SOURCE_ID est l'ID du service Security Command Center qui a généré le résultat.

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv1"
	"cloud.google.com/go/securitycenter/apiv1/securitycenterpb"
	"google.golang.org/protobuf/types/known/fieldmaskpb"
)

// updateMuteRule Updates an existing mute configuration.
// The following can be updated in a mute config: description and filter.
func updateMuteRule(w io.Writer, muteConfigName string) error {
	// Specify the name of the mute config to delete.
	// muteConfigName: Use any one of the following formats:
	//                 - organizations/{organization}/muteConfigs/{config_id}
	//                 - folders/{folder}/muteConfigs/{config_id}
	//                 - projects/{project}/muteConfigs/{config_id}
	// muteConfigName := fmt.Sprintf("projects/%s/muteConfigs/%s", "project-id", "mute-config")
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	updateMuteConfig := &securitycenterpb.MuteConfig{
		Name:        muteConfigName,
		Description: "Updated mute config description",
	}

	req := &securitycenterpb.UpdateMuteConfigRequest{
		MuteConfig: updateMuteConfig,
		// Set the update mask to specify which properties of the mute config should be
		// updated.
		// If empty, all mutable fields will be updated.
		// Make sure that the mask fields match the properties changed in 'updateMuteConfig'.
		// For more info on constructing update mask path, see the proto or:
		// https://cloud.google.com/security-command-center/docs/reference/rest/v1/folders.muteConfigs/patch?hl=en#query-parameters
		UpdateMask: &fieldmaskpb.FieldMask{
			Paths: []string{
				"description",
			},
		},
	}

	response, err := client.UpdateMuteConfig(ctx, req)
	if err != nil {
		return fmt.Errorf("mute rule update failed! %w", err)
	}
	fmt.Fprintf(w, "Mute rule updated %s", response.Name)
	return nil
}

Java

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où "PARENT" correspond à organizations, folders, ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

import com.google.cloud.securitycenter.v1.MuteConfig;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import com.google.cloud.securitycenter.v1.UpdateMuteConfigRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;

public class UpdateMuteRule {

  public static void main(String[] args) {
    // TODO: Replace the variables within {}

    // Specify the name of the mute config to delete.
    // muteConfigName: Use any one of the following formats:
    //                 - organizations/{organization}/muteConfigs/{config_id}
    //                 - folders/{folder}/muteConfigs/{config_id}
    //                 - projects/{project}/muteConfigs/{config_id}
    String muteConfigName = "{any-one-of-the-above-formats}";
    updateMuteRule(muteConfigName);
  }

  // Updates an existing mute configuration.
  // The following can be updated in a mute config: description and filter.
  public static void updateMuteRule(String muteConfigName) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SecurityCenterClient securityCenterClient = SecurityCenterClient.create()) {

      MuteConfig updateMuteConfig =
          MuteConfig.newBuilder()
              .setName(muteConfigName)
              .setDescription("Updated mute config description")
              .build();

      UpdateMuteConfigRequest updateMuteConfigRequest =
          UpdateMuteConfigRequest.newBuilder()
              .setMuteConfig(updateMuteConfig)
              // Set the update mask to specify which properties of the mute config should be
              // updated.
              // If empty, all mutable fields will be updated.
              // Make sure that the mask fields match the properties changed in 'updateMuteConfig'.
              // For more info on constructing update mask path, see the proto or:
              // https://cloud.google.com/security-command-center/docs/reference/rest/v1/folders.muteConfigs/patch?hl=en#query-parameters
              .setUpdateMask(FieldMask.newBuilder().addPaths("description").build())
              .build();

      MuteConfig response = securityCenterClient.updateMuteConfig(updateMuteConfigRequest);
      System.out.println(response);
    } catch (IOException e) {
      System.out.println("Mute rule update failed! \n Exception: " + e);
    }
  }
}

Python

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

def update_mute_rule(mute_config_name: str) -> None:
    """
    Updates an existing mute configuration.
    The following can be updated in a mute config: description, and filter/ mute rule.
    Args:
        mute_config_name: Specify the name of the mute config to delete.
                          Use any one of the following formats:
                          - organizations/{organization}/muteConfigs/{config_id}
                          - folders/{folder}/muteConfigs/{config_id}
                          - projects/{project}/muteConfigs/{config_id}
    """
    from google.cloud import securitycenter
    from google.protobuf import field_mask_pb2

    client = securitycenter.SecurityCenterClient()

    update_mute_config = securitycenter.MuteConfig()
    update_mute_config.name = mute_config_name
    update_mute_config.description = "Updated mute config description"

    field_mask = field_mask_pb2.FieldMask(paths=["description"])

    request = securitycenter.UpdateMuteConfigRequest()
    request.mute_config = update_mute_config
    # Set the update mask to specify which properties of the Mute Config should be updated.
    # If empty, all mutable fields will be updated.
    # Make sure that the mask fields match the properties changed in 'update_mute_config'.
    # For more info on constructing update mask path, see the proto or:
    # https://cloud.google.com/security-command-center/docs/reference/rest/v1/folders.muteConfigs/patch?hl=en#query-parameters
    request.update_mask = field_mask

    mute_config = client.update_mute_config(request)
    print(f"Updated mute rule : {mute_config}")

API REST

Dans l'API Security Command Center, utilisez la méthode muteConfigs patch pour une règle Ignorer. Le corps de la requête est une instance de MuteConfig.

Pour obtenir la valeur CONFIG_ID d'une règle de blocage, exécutez un appel d'API pour répertorier les règles de blocage. La réponse inclut des ID de configuration pour les règles de blocage renvoyées.

Sauf si la résidence des données est activée, vous pouvez utiliser la version 1 ou la version 2 de l'API Security Command Center. API v2 est disponible en tant que Version Preview. Lorsque la résidence des données est activée, l'API v2 est la seule API disponible.

Si vous utilisez la version 1 de l'API Security Command Center, utilisez le point de terminaison v1 pour appeler muteConfigs patch :

PATCH https://securitycenter.googleapis.com/v1/PARENT/PARENT_ID/muteConfigs/CONFIG_ID

  {
    "description": "RULE_DESCRIPTION",
    "filter": "FILTER",
    "type": "MUTE_TYPE",
    "expiryTime": "TIMESTAMP"
  }

Si vous utilisez la version 2 de l'API Security Command Center, utilisez le point de terminaison v2 pour appeler muteConfigs patch :

PATCH https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/locations/LOCATION/muteConfigs/CONFIG_ID

  {
    "description": "RULE_DESCRIPTION",
    "filter": "FILTER",
    "type": "MUTE_TYPE",
    "expiryTime": "TIMESTAMP"
  }

Remplacez les éléments suivants :

• PARENT : ressource parente de votre règle de blocage (organizations, folders ou projects)
• PARENT_ID: ID de l'événement organisation, dossier ou projet
• LOCATION: si la résidence des données est activée, le Security Command Center emplacement où mettre à jour la règle Ignorer ; si la résidence des données n'est pas activée, utilisez la valeur global
• CONFIG_ID : ID numérique de la règle de blocage
• RULE_DESCRIPTION: description de la règle Ignorer (max: 1 024 caractères)

• FILTER : expression que vous définissez pour filtrer les résultats

  Par exemple, pour ignorer les résultats OPEN_FIREWALL, votre filtre peut être "category=\"OPEN_FIREWALL\"".

• MUTE_TYPE : type de règle de blocage que vous mettez à jour. Les types de règles Ignorer valides sont DYNAMIC et STATIC Une fois la règle de masquage créée, vous ne pouvez plus en modifier le type.

• TIMESTAMP: s'applique uniquement si vous mettez à jour la règle Ignorer dynamique. Chaîne de date/heure indiquant à quel moment le son expire. La valeur doit être définie sur au moins un jour à venir, sinon la requête sera refusée. Pour en savoir plus sur les formats d'heure, consultez gcloud topic datetimes. Lorsqu'une règle Ignorer dynamique expire, elle est supprimée de tous les résultats correspondants. Si vous souhaitez que la règle Ignorer dynamique agisse indéfiniment sur les résultats correspondants, omettez ce champ.

Les nouveaux résultats qui correspondent exactement au filtre sont masqués et l'attribut mute des résultats est défini sur MUTED.

Supprimer les règles de blocage

Vous pouvez supprimer une règle de masquage à l'aide de la console Google Cloud, de la CLI gcloud ou de l'API Security Command Center.

Avant de supprimer les règles de blocage, prenez en compte les points suivants :

• Vous ne pouvez pas récupérer les règles de blocage supprimées.
• La suppression des règles Ignorer statiques ne réactive pas automatiquement les résultats qui sont coupés. Vous devez réactiver le son, manuellement ou par programme, résultats.
• La suppression des règles de blocage dynamiques supprime automatiquement la règle de tous les résultats précédemment correspondants et les réactive s'ils ne correspondent à aucune règle supplémentaire.
• Les futurs résultats qui correspondent aux filtres dans les règles de blocage supprimées ne sont pas ignorés.

Pour obtenir un exemple de code permettant de supprimer une règle Ignorer, consultez Supprimer une règle Ignorer

Pour supprimer une règle de blocage, cliquez sur l'onglet correspondant à la procédure que vous souhaitez suivre :

Console

1. Dans la console Google Cloud, accédez à l'onglet Règles Ignorer dans Page Paramètres de Security Command Center.

   Accéder aux règles Ignorer

2. Si nécessaire, sélectionnez votre projet ou votre organisation GooglenCloud.

3. Facultatif: Si la résidence des données est activée pour Security Command Center, puis modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'emplacements s'affiche. Sélectionnez le nouvel emplacement.

4. Cliquez sur le nom de la règle de blocage que vous souhaitez supprimer.

5. Cliquez sur Supprimer.

6. Lisez la boîte de dialogue et, si vous êtes satisfait, cliquez sur Supprimer.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour supprimer les règles Ignorer, exécutez la commande gcloud scc muteconfigs delete:

   gcloud scc muteconfigs delete MUTE_CONFIG_ID \
    --PARENT=PARENT_ID --location=LOCATION
   

   Remplacez les éléments suivants :

   • MUTE_CONFIG_ID : ID de la configuration de blocage
   • PARENT : ressource parente de votre règle de blocage (organization, folder ou project)
   • PARENT_ID: ID de l'événement organisation, dossier ou projet
   • LOCATION: si la résidence des données est activée, le Security Command Center emplacement dans lequel supprimer la règle Ignorer ; si la résidence des données n'est pas activée, utilisez la valeur global

3. Confirmez votre demande de suppression de la règle de blocage.

Go

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2 et ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv1"
	"cloud.google.com/go/securitycenter/apiv1/securitycenterpb"
)

// deleteMuteRule deletes a mute configuration given its resource name.
// Note: Previously muted findings are not affected when a mute config is deleted.
func deleteMuteRule(w io.Writer, parent string, muteConfigId string) error {
	// parent: Use any one of the following options:
	//             - organizations/{organization_id}
	//             - folders/{folder_id}
	//             - projects/{project_id}
	// parent := fmt.Sprintf("projects/%s", "your-google-cloud-project-id")
	//
	// muteConfigId: Specify the name of the mute config to delete.
	// muteConfigId := "mute-config-id"
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	req := &securitycenterpb.DeleteMuteConfigRequest{
		Name: fmt.Sprintf("%s/muteConfigs/%s", parent, muteConfigId),
	}

	if err := client.DeleteMuteConfig(ctx, req); err != nil {
		return fmt.Errorf("failed to delete Muteconfig: %w", err)
	}
	fmt.Fprintf(w, "Mute rule deleted successfully: %s", muteConfigId)
	return nil
}

Java

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

import com.google.cloud.securitycenter.v1.MuteConfigName;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import java.io.IOException;

public class DeleteMuteRule {

  public static void main(String[] args) {
    // TODO(Developer): Replace the following variables
    // parentPath: Use any one of the following options:
    //             - organizations/{organization_id}
    //             - folders/{folder_id}
    //             - projects/{project_id}
    String parentPath = String.format("projects/%s", "your-google-cloud-project-id");

    // muteConfigId: Specify the name of the mute config to delete.
    String muteConfigId = "mute-config-id";

    deleteMuteRule(parentPath, muteConfigId);
  }

  // Deletes a mute configuration given its resource name.
  // Note: Previously muted findings are not affected when a mute config is deleted.
  public static void deleteMuteRule(String projectId, String muteConfigId) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {
      // Use appropriate MuteConfigName methods depending on the type of parent.
      // org -> MuteConfigName.ofOrganizationMuteConfigName()
      // folder -> MuteConfigName.ofFolderMuteConfigName()
      // project -> MuteConfigName.ofProjectMuteConfigName)
      client.deleteMuteConfig(MuteConfigName.ofProjectMuteConfigName(projectId, muteConfigId));

      System.out.println("Mute rule deleted successfully: " + muteConfigId);
    } catch (IOException e) {
      System.out.println("Mute rule deletion failed! \n Exception: " + e);
    }
  }
}

Python

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

def delete_mute_rule(mute_config_name: str) -> None:
    """
    Deletes a mute configuration given its resource name.
    Note: Previously muted findings are not affected when a mute config is deleted.
    Args:
        mute_config_name: Specify the name of the mute config to delete.
                          Use any one of the following formats:
                          - organizations/{organization}/muteConfigs/{config_id}
                          - folders/{folder}/muteConfigs/{config_id} or
                          - projects/{project}/muteConfigs/{config_id}
    """
    from google.cloud import securitycenter

    client = securitycenter.SecurityCenterClient()

    request = securitycenter.DeleteMuteConfigRequest()
    request.name = mute_config_name

    client.delete_mute_config(request)
    print(f"Mute rule deleted successfully: {mute_config_name}")

API REST

Dans l'API Security Command Center, utilisez la méthode muteConfigs delete pour supprimer une règle de masquage. Le corps de la requête est vide.

Pour obtenir le CONFIG_ID d'une règle Ignorer, exécutez un appel d'API pour Répertorier les règles Ignorer La réponse inclut des ID de configuration pour les règles de blocage renvoyées.

Si la résidence des données n'est pas activée, vous pouvez utiliser les versions v1 ou 2 l'API Security Command Center. La version 2 de l'API est disponible en version preview. Lorsque la résidence des données est activée, l'API v2 est la seule API disponible.

Si vous utilisez la version 1 de l'API Security Command Center, utilisez le point de terminaison v1 pour appeler muteConfigs delete:

DELETE https://securitycenter.googleapis.com/v1/PARENT/PARENT_ID/muteConfigs/CONFIG_ID

Si vous utilisez l'API Security Command Center version 2, utilisez le point de terminaison v2 pour appeler muteConfigs delete:

DELETE https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/locations/LOCATION/muteConfigs/CONFIG_ID

Remplacez les éléments suivants :

• PARENT : ressource parente de votre règle de blocage (organizations, folders ou projects)
• PARENT_ID: ID de l'événement organisation, dossier ou projet
• LOCATION: si la résidence des données est activée, le Security Command Center emplacement dans lequel supprimer la règle Ignorer ; si la résidence des données n'est pas activée, utilisez la valeur global
• CONFIG_ID : ID numérique de la règle de blocage

Ignorer un résultat individuel

Vous pouvez statiquement désactiver un résultat individuel à l'aide de la console Google Cloud, de la gcloud CLI ou de l'API Security Command Center.

La désactivation statique d'un résultat n'a aucune incidence sur son activation ou non. Si un résultat actif est masqué, l'attribut state reste inchangé : state="ACTIVE". Le résultat est masqué, mais reste actif jusqu'à ce que la faille, la configuration incorrecte ou la menace sous-jacente soient résolues. De plus, en en désactivant de manière statique un résultat, vous remplacez les règles de masquage dynamiques qui s’appliquer au résultat.

Si vous désactivez une combinaison toxique, la demande correspondante est clôturée.

Pour ignorer tous les résultats futurs correspondant aux critères que vous spécifiez, consultez la section Créer des règles de blocage.

Pour obtenir un exemple de code permettant de désactiver un résultat, consultez Désactiver un résultat.

Pour désactiver de manière statique un résultat individuel, cliquez sur l'onglet de la procédure qui que vous souhaitez utiliser:

Console

1. Dans la console Google Cloud, accédez à la page Résultats de Security Command Center.

   Accéder

2. Si nécessaire, sélectionnez votre projet ou votre organisation GooglenCloud.

3. Facultatif : Si la résidence des données est activée pour Security Command Center, modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'établissements s'affiche. Sélectionnez le nouvel emplacement.

4. Si le résultat que vous devez désactiver ne s'affiche pas dans le panneau Résultats de la requête de résultats, sélectionnez la catégorie du résultat dans la section Catégorie du panneau Filtres rapides.

5. Cochez la case à côté du résultat que vous souhaitez ignorer. Vous pouvez sélectionner un ou plusieurs résultats.

6. Dans la barre d'action Résultats de la requête sur les résultats, cliquez sur Options de blocage, puis sélectionnez Appliquer le forçage de la désactivation du son.

   L'attribut mute des résultats sélectionnés est défini sur MUTED, et le résultat est supprimé du panneau Résultats de la requête "Findings".

Vous pouvez également ignorer un résultat depuis son panneau d'informations :

1. Dans le panneau Finding query results (Trouver les résultats de la requête) de la page Findings (Résultats), Dans la colonne Catégorie, cliquez sur le nom d'un résultat. Le volet d'informations du résultat s'ouvre.
2. Cliquez sur Prendre des mesures.

3. Dans le menu Effectuer une action, sélectionnez Ignorer l'action.

   Si vous sélectionnez plutôt Ignorer les résultats comme celui-ci, la page Créer une règle de blocage s'ouvre. Vous pouvez y créer une règle de blocage des résultats du même type ou qui incluent le même attribut Indicator.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour définir l'état de blocage d'un résultat sur MUTED, utilisez la commande set-mute dans gcloud CLI  :

   gcloud scc findings set-mute FINDING_ID \
    --PARENT=PARENT_ID \
    --location=LOCATION --source=SOURCE_ID \
    --mute=MUTED
   

   Remplacez les éléments suivants :

   • FINDING_ID : ID du résultat que vous souhaitez ignorer.

     Pour récupérer les ID de résultats, utilisez l'API Security Command Center afin de répertorier les résultats. L'ID du résultat est la dernière partie de l'attribut canonicalName, pour exemple : projects/123456789012/sources/1234567890123456789/findings`/5ee30aa342e799e4e1700826de053aa9

   • PARENT : ressource parente (project, folder ou organization), sensible à la casse

   • PARENT_ID : ID de l'organisation, du dossier ou du projet parent

   • LOCATION: si la résidence des données est activée, le Security Command Center lieu pour ignorer le résultat ; si la résidence des données n'est pas activée, utilisez la valeur global

   • SOURCE_ID : ID de la source

     Pour obtenir des instructions sur la récupération d'un ID de source, consultez Obtenir l'ID de la source

Go

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2 et ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv1"
	"cloud.google.com/go/securitycenter/apiv1/securitycenterpb"
)

// setMute mutes an individual finding, can also unmute or reset the mute state of a finding.
// If a finding is already muted, muting it again has no effect.
// Various mute states are: UNDEFINED/MUTE/UNMUTE.
func setMute(w io.Writer, findingPath string) error {
	// findingPath: The relative resource name of the finding. See:
	// https://cloud.google.com/apis/design/resource_names#relative_resource_name
	// Use any one of the following formats:
	//  - organizations/{organization_id}/sources/{source_id}/finding/{finding_id}
	//  - folders/{folder_id}/sources/{source_id}/finding/{finding_id}
	//  - projects/{project_id}/sources/{source_id}/finding/{finding_id}
	// findingPath := fmt.Sprintf("projects/%s/sources/%s/finding/%s", "your-google-cloud-project-id", "source", "finding-id")
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	req := &securitycenterpb.SetMuteRequest{
		Name: findingPath,
		Mute: securitycenterpb.Finding_MUTED}

	finding, err := client.SetMute(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to set the specified mute value: %w", err)
	}
	fmt.Fprintf(w, "Mute value for the finding: %s is %s", finding.Name, finding.Mute)
	return nil
}

Java

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION au nom de la ressource après /sources/SOURCE_ID, où SOURCE_ID est l'ID du service Security Command Center qui a généré le résultat.

import com.google.cloud.securitycenter.v1.Finding;
import com.google.cloud.securitycenter.v1.Finding.Mute;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import com.google.cloud.securitycenter.v1.SetMuteRequest;
import java.io.IOException;

public class SetMuteFinding {

  public static void main(String[] args) throws IOException {
    // TODO: Replace the variables within {}

    // findingPath: The relative resource name of the finding. See:
    // https://cloud.google.com/apis/design/resource_names#relative_resource_name
    // Use any one of the following formats:
    //  - organizations/{organization_id}/sources/{source_id}/finding/{finding_id}
    //  - folders/{folder_id}/sources/{source_id}/finding/{finding_id}
    //  - projects/{project_id}/sources/{source_id}/finding/{finding_id}
    String findingPath = "{path-to-the-finding}";
    setMute(findingPath);
  }

  // Mute an individual finding.
  // If a finding is already muted, muting it again has no effect.
  // Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE.
  public static Finding setMute(String findingPath) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      SetMuteRequest setMuteRequest =
          SetMuteRequest.newBuilder().setName(findingPath).setMute(Mute.MUTED).build();

      Finding finding = client.setMute(setMuteRequest);
      System.out.println(
          "Mute value for the finding " + finding.getName() + " is: " + finding.getMute());
      return finding;
    }
  }
}

Python

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

def set_mute_finding(finding_path: str) -> None:
    """
      Mute an individual finding.
      If a finding is already muted, muting it again has no effect.
      Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE.
    Args:
        finding_path: The relative resource name of the finding. See:
        https://cloud.google.com/apis/design/resource_names#relative_resource_name
        Use any one of the following formats:
        - organizations/{organization_id}/sources/{source_id}/finding/{finding_id},
        - folders/{folder_id}/sources/{source_id}/finding/{finding_id},
        - projects/{project_id}/sources/{source_id}/finding/{finding_id}.
    """
    from google.cloud import securitycenter

    client = securitycenter.SecurityCenterClient()

    request = securitycenter.SetMuteRequest()
    request.name = finding_path
    request.mute = securitycenter.Finding.Mute.MUTED

    finding = client.set_mute(request)
    print(f"Mute value for the finding: {finding.mute.name}")

API REST

Dans l'API Security Command Center, utilisez la méthode setMute pour ignorer un trouver. Le corps de la requête est une énumération qui indique l'état de blocage obtenu.

Sauf si la résidence des données est activée, vous pouvez utiliser la version 1 ou la version 2 de l'API Security Command Center. API v2 est disponible en tant que Version Preview. Lorsque la résidence des données est activée, l'API V2 est la seule API disponible.

Si vous utilisez la version 1 de l'API Security Command Center, appelez setMute à l'aide du point de terminaison v1 :

POST https://securitycenter.googleapis.com/v1/PARENT/PARENT_ID/sources/SOURCE_ID/findings/FINDING_ID:setMute

{
  "mute": "MUTED"
}

Si vous utilisez l'API Security Command Center version 2, appelez setMute à l'aide du point de terminaison v2:

POST https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/sources/SOURCE_ID/locations/LOCATION/findings/FINDING_ID:setMute

{
  "mute": "MUTED"
}

Remplacez les éléments suivants :

• PARENT: ressource parente (organizations, folders ou projects).
• PARENT_ID: ID du parent organisation, dossier ou projet.
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel couper le son du résultat. Si la résidence des données n'est pas activée, utilisez la valeur global.

• SOURCE_ID : ID numérique de la source.

  Pour obtenir des instructions sur la récupération d'un ID de source, consultez Obtenir l'ID de la source

• FINDING_ID : ID du résultat que vous souhaitez ignorer.

  Pour récupérer les ID de résultats, utilisez l'API Security Command Center pour : répertorier les résultats. L'ID de résultat est la dernière partie de l'attribut canonicalName, par exemple projects/123456789012/sources/1234567890123456789/findings/5ee30aa342e799e4e1700826de053aa9.

Une fois que vous avez désactivé un résultat, son attribut mute est défini sur MUTED.

Réactiver les résultats individuels

Vous pouvez réactiver de manière statique un résultat individuel à l'aide de la console Google Cloud, de la gcloud CLI ou l'API Security Command Center.

Réactiver un résultat est utile lorsque vous devez l'empêcher d'être soit masqué par une règle Ignorer trop large, soit par une règle trop complexe pour modifier pour exclure les résultats que vous jugez importants.

Pour obtenir un exemple de code permettant de réactiver un résultat, consultez la section Réactiver un résultat.

Les résultats ignorés ne sont à nouveau ignorés que si vous les désactivez manuellement. Les règles de blocage créées avec gcloud CLI ou l'API Security Command Center n'affectent pas les résultats obtenus par les utilisateurs.

Pour obtenir un exemple de code permettant de réactiver un résultat, consultez Réactiver un résultat.

Console

1. Dans Google Cloud Console, accédez à la page Résultats de Security Command Center.

   Accéder

2. Si nécessaire, sélectionnez votre projet ou votre organisation GooglenCloud.

   La page Résultats s'ouvre, et la requête par défaut s'affiche dans la section Aperçu de la requête. La requête par défaut filtre les résultats masqués. Vous devez donc modifier la requête avant qu'ils ne s'affichent dans le panneau Résultats de la requête de résultats.

3. Facultatif : Si la résidence des données est activée pour Security Command Center, modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'emplacements s'affiche. Sélectionnez le nouvel emplacement.

4. À droite de la section Aperçu de la requête, cliquez sur Modifier la requête pour ouvrir l'éditeur de requête.

5. Dans le champ Éditeur de requête, remplacez l'instruction de masquage existante par la suivante :

   mute="MUTED"

6. Cliquez sur Appliquer. Les résultats du panneau Résultats de la requête "Résultats" sont mis à jour pour n'inclure que les résultats ignorés.

7. Si nécessaire, filtrez les autres résultats ignorés. Par exemple, dans le panneau Filtres rapides, sous Catégorie, sélectionnez le nom de l'anomalie que vous devez réactiver pour filtrer toutes les autres catégories d'anomalies.

8. Cochez la case à côté du résultat que vous souhaitez réactiver. Vous pouvez sélectionnez un ou plusieurs résultats.

9. Dans la barre d'action Résultats de la requête de résultats, cliquez sur Ignorer les options. puis sélectionnez Appliquer le forçage de réactivation du son.

   L'attribut mute des résultats sélectionnés est défini sur UNMUTED, et le résultat est supprimé du panneau Résultats de la requête de résultats.

Vous pouvez également réactiver un résultat depuis son panneau d'informations :

1. Dans le panneau Finding query results (Trouver les résultats de la requête) de la page Findings (Résultats), Dans la colonne Catégorie, cliquez sur le nom d'un résultat. Le volet d'informations du résultat s'ouvre.
2. Cliquez sur Prendre des mesures.
3. Dans le menu Effectuer une action, sélectionnez Ignorer la réactivation du son.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour définir l'état de blocage d'un résultat sur UNMUTED, utilisez la commande set-mute dans gcloud CLI  :

   gcloud scc findings set-mute FINDING_ID \
    --PARENT=PARENT_ID \
    --location=LOCATION --source=SOURCE_ID \
    --mute=UNMUTED
   

   Remplacez les éléments suivants :

   • FINDING_ID : ID du résultat que vous souhaitez ignorer.

     Pour récupérer les ID de résultats, utilisez l'API Security Command Center pour : répertorier les résultats. L'ID du résultat est la dernière partie de l'attribut canonicalName, par exemple exemple : projects/123456789012/sources/1234567890123456789/findings/5ee30aa342e799e4e1700826de053aa9

   • PARENT : ressource parente (project, folder ou organization) sensible à la casse

   • PARENT_ID : ID de l'organisation, du dossier ou du projet parent

   • LOCATION: si la résidence des données est activée, le Security Command Center emplacement où réactiver le résultat si la résidence des données n'est pas activée, utilisez la valeur global

   • SOURCE_ID : ID de la source

     Pour obtenir des instructions sur la récupération d'un ID de source, consultez Obtenir l'ID de la source

Go

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2 et ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où "PARENT" correspond à organizations, folders, ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv1"
	"cloud.google.com/go/securitycenter/apiv1/securitycenterpb"
)

// setMute mutes an individual finding, can also unmute or reset the mute state of a finding.
// If a finding is already muted, muting it again has no effect.
// Various mute states are: UNDEFINED/MUTE/UNMUTE.
func setUnmute(w io.Writer, findingPath string) error {
	// findingPath: The relative resource name of the finding. See:
	// https://cloud.google.com/apis/design/resource_names#relative_resource_name
	// Use any one of the following formats:
	//  - organizations/{organization_id}/sources/{source_id}/finding/{finding_id}
	//  - folders/{folder_id}/sources/{source_id}/finding/{finding_id}
	//  - projects/{project_id}/sources/{source_id}/finding/{finding_id}
	// findingPath := fmt.Sprintf("projects/%s/sources/%s/finding/%s", "your-google-cloud-project-id", "source", "finding-id")
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	req := &securitycenterpb.SetMuteRequest{
		Name: findingPath,
		Mute: securitycenterpb.Finding_UNMUTED}

	finding, err := client.SetMute(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to set the specified mute value: %w", err)
	}
	fmt.Fprintf(w, "Mute value for the finding: %s is %s", finding.Name, finding.Mute)
	return nil
}

Java

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où "PARENT" correspond à organizations, folders, ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

import com.google.cloud.securitycenter.v1.Finding;
import com.google.cloud.securitycenter.v1.Finding.Mute;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import com.google.cloud.securitycenter.v1.SetMuteRequest;
import java.io.IOException;

public class SetUnmuteFinding {

  public static void main(String[] args) throws IOException {
    // TODO: Replace the variables within {}

    // findingPath: The relative resource name of the finding. See:
    // https://cloud.google.com/apis/design/resource_names#relative_resource_name
    // Use any one of the following formats:
    //  - organizations/{organization_id}/sources/{source_id}/finding/{finding_id}
    //  - folders/{folder_id}/sources/{source_id}/finding/{finding_id}
    //  - projects/{project_id}/sources/{source_id}/finding/{finding_id}
    String findingPath = "{path-to-the-finding}";
    setUnmute(findingPath);
  }

  // Unmute an individual finding.
  // Unmuting a finding that isn't muted has no effect.
  // Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE.
  public static Finding setUnmute(String findingPath) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      SetMuteRequest setMuteRequest =
          SetMuteRequest.newBuilder().setName(findingPath).setMute(Mute.UNMUTED).build();

      Finding finding = client.setMute(setMuteRequest);
      System.out.println(
          "Mute value for the finding " + finding.getName() + " is: " + finding.getMute());
      return finding;
    }
  }
}

Python

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION au nom de la ressource après /sources/SOURCE_ID, où SOURCE_ID est l'ID du service Security Command Center qui a généré le résultat.

def set_unmute_finding(finding_path: str) -> None:
    """
      Unmute an individual finding.
      Unmuting a finding that isn't muted has no effect.
      Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE.
    Args:
        finding_path: The relative resource name of the finding. See:
        https://cloud.google.com/apis/design/resource_names#relative_resource_name
        Use any one of the following formats:
        - organizations/{organization_id}/sources/{source_id}/finding/{finding_id},
        - folders/{folder_id}/sources/{source_id}/finding/{finding_id},
        - projects/{project_id}/sources/{source_id}/finding/{finding_id}.
    """
    from google.cloud import securitycenter

    client = securitycenter.SecurityCenterClient()

    request = securitycenter.SetMuteRequest()
    request.name = finding_path
    request.mute = securitycenter.Finding.Mute.UNMUTED

    finding = client.set_mute(request)
    print(f"Mute value for the finding: {finding.mute.name}")

API REST

Dans l'API Security Command Center, utilisez la méthode setMute pour réactiver le son d'une trouver. Le corps de la requête est une énumération qui indique le résultat le son coupé.

Si la résidence des données n'est pas activée, vous pouvez utiliser les versions v1 ou 2 l'API Security Command Center. API v2 est disponible en tant que Version Preview. Lorsque la résidence des données est activée, l'API V2 est la seule API disponible.

Si vous utilisez la version 1 de l'API Security Command Center, appelez setMute à l'aide du point de terminaison v1 :

POST https://securitycenter.googleapis.com/v1/PARENT/PARENT_ID/sources/SOURCE_ID/findings/FINDING_ID:setMute

{
  "mute": "UNMUTED"
}

Si vous utilisez l'API Security Command Center version 2, appelez setMute à l'aide du point de terminaison v2:

POST https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/sources/SOURCE_ID/locations/LOCATION/findings/FINDING_ID:setMute

{
  "mute": "UNMUTED"
}

Remplacez les éléments suivants :

• PARENT : ressource parente (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation parente. dossier ou projet
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel rétablir le son du résultat. Si la résidence des données n'est pas activée, utilisez la valeur global.

• SOURCE_ID : ID numérique de la source

  Pour obtenir des instructions sur la récupération d'un ID de source, consultez Obtenir l'ID de la source

• FINDING_ID : ID du résultat que vous souhaitez ignorer.

  Pour récupérer les ID de résultats, utilisez l'API Security Command Center pour : répertorier les résultats. L'ID du résultat est la dernière partie de l'attribut canonicalName, par exemple exemple : projects/123456789012/sources/1234567890123456789/findings/5ee30aa342e799e4e1700826de053aa9

Les résultats sélectionnés ne sont plus masqués et l'attribut mute des résultats est défini sur UNMUTED.

Supprimer un forçage de l'état de masquage pour des résultats individuels

Vous appliquez un remplacement de l'état Ignorer lorsque vous modifiez intentionnellement la désactivation d'un résultat. pour désactiver ou réactiver le résultat de manière statique. Par exemple, vous pouvez appliquer un forçage de l'état de masquage pour masquer un résultat de faible gravité pour lequel il n'est pas nécessaire de créer une règle de masquage dynamique.

Vous pouvez supprimer le remplacement de l'état "Ignorer" d'un résultat individuel à l'aide de la console Google Cloud, de la gcloud CLI ou l'API Security Command Center.

Avant de supprimer le forçage de l'état de masquage d'un résultat, tenez compte des points suivants :

• Un résultat dispose d'un forçage de l'état de désactivation du son s'il est coupé ou réactivé de manière statique. Vous pouvez appliquer un forçage de l'état de masquage à n'importe quel résultat manuellement ou automatiquement à l'aide de règles de masquage statiques.
• Un forçage de l'état de masquage s'applique indéfiniment à un résultat et prévaut sur toutes les règles de masquage correspondantes.
• Si vous supprimez le forçage de l'état de masquage d'un résultat, son état de masquage est réinitialisé afin qu'il puisse être traité par des règles de masquage statiques ou dynamiques.
• Supprimer le forçage de l'état Ignorer d'un résultat diffère de la réactivation d'un trouver. Lorsque vous réactivez un résultat (c'est-à-dire lorsque vous ignorez une règle), les règles Ignorer Impossible de désactiver ce résultat tant que vous n'avez pas désactivé manuellement le forçage de l'état de désactivation.

Pour supprimer le forçage de la fonction Ignorer d'un résultat individuel, procédez comme suit:

Console

1. Dans Google Cloud Console, accédez à la page Résultats de Security Command Center.

   Accéder

2. Sélectionnez votre projet ou votre organisation Google Cloud.

3. Facultatif: Si la résidence des données est activée pour Security Command Center, puis modifiez l'emplacement des données si nécessaire.

   Pour modifier l'emplacement des données, cliquez sur le sélecteur d'emplacement dans la barre d'action.

   

   Une liste d'emplacements s'affiche. Sélectionnez le nouvel emplacement.

4. À droite de la section Aperçu de la requête, cliquez sur Modifier la requête pour ouvrir l'éditeur de requête.

5. Dans le champ Éditeur de requête, remplacez l'instruction de masquage existante par la suivante :

   mute="MUTED" OR mute="UNMUTED"

6. Cliquez sur Appliquer. Les résultats du panneau Résultats de la requête de résultat sont mis à jour pour inclure les résultats ignorés de manière statique et réactivé.

7. Si nécessaire, filtrez les autres résultats. Par exemple, dans le panneau Filtres rapides, sous Catégorie, sélectionnez le nom de l'anomalie que vous devez réinitialiser pour filtrer toutes les autres catégories d'anomalies.

8. Cochez la case située à côté du résultat que vous souhaitez réinitialiser. Vous pouvez sélectionnez un ou plusieurs résultats.

9. Dans la barre d'action Résultats de la requête "Résultats", cliquez sur Options de blocage, puis sélectionnez Supprimer les forçages de blocage.

   L'attribut mute pour les résultats sélectionnés est défini sur UNDEFINED. le résultat est supprimé du panneau Résultats de la requête de résultat.

Vous pouvez également réactiver un résultat depuis son panneau d'informations :

1. Dans le panneau Finding query results (Trouver les résultats de la requête) de la page Findings (Résultats), Dans la colonne Catégorie, cliquez sur le nom d'un résultat. Le volet d'informations du résultat s'ouvre.
2. Cliquez sur Passer à l'action.
3. Dans le menu Effectuer une action, sélectionnez Supprimer les remplacements pour ignorer.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour définir l'état de blocage d'un résultat sur UNDEFINED, utilisez la commande set-mute dans gcloud CLI  :

   gcloud scc findings set-mute FINDING_ID \
    --PARENT=PARENT_ID \
    --location=LOCATION --source=SOURCE_ID \
    --mute=UNDEFINED
   

   Remplacez les éléments suivants :

   • FINDING_ID: ID du résultat souhaité réinitialiser

     Pour récupérer les ID de résultats, utilisez l'API Security Command Center afin de répertorier les résultats. L'ID du résultat est la dernière partie de l'attribut canonicalName, par exemple exemple : projects/123456789012/sources/1234567890123456789/findings/5ee30aa342e799e4e1700826de053aa9

   • PARENT : ressource parente (project, folder ou organization) sensible à la casse

   • PARENT_ID : ID de l'organisation, du dossier ou du projet parent

   • LOCATION: si la résidence des données est activée, le Security Command Center emplacement dans lequel supprimer le forçage de l'état de désactivation du son d'un résultat ; si la résidence des données n'est pas activée, utilisez la valeur global

   • SOURCE_ID : ID de la source

     Pour obtenir des instructions sur la manière de récupérer l'ID d'une source, consultez la section Obtenir l'ID d'une source.

Go

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2 et ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION au nom de la ressource après /sources/SOURCE_ID, où SOURCE_ID est l'ID du service Security Command Center qui a généré le résultat.

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv1"
	"cloud.google.com/go/securitycenter/apiv1/securitycenterpb"
)

// setMute mutes an individual finding, can also unmute or reset the mute state of a finding.
// If a finding is already muted, muting it again has no effect.
// Various mute states are: UNDEFINED/MUTE/UNMUTE.
func setMuteUndefined(w io.Writer, findingPath string) error {
	// findingPath: The relative resource name of the finding. See:
	// https://cloud.google.com/apis/design/resource_names#relative_resource_name
	// Use any one of the following formats:
	//  - organizations/{organization_id}/sources/{source_id}/finding/{finding_id}
	//  - folders/{folder_id}/sources/{source_id}/finding/{finding_id}
	//  - projects/{project_id}/sources/{source_id}/finding/{finding_id}
	// findingPath := fmt.Sprintf("projects/%s/sources/%s/finding/%s", "your-google-cloud-project-id", "source", "finding-id")
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	req := &securitycenterpb.SetMuteRequest{
		Name: findingPath,
		Mute: securitycenterpb.Finding_UNDEFINED}

	finding, err := client.SetMute(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to set the specified mute value: %w", err)
	}
	fmt.Fprintf(w, "Mute value for the finding: %s is %s", finding.Name, finding.Mute)
	return nil
}

Java

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où "PARENT" correspond à organizations, folders, ou projects.

Pour les résultats, ajoutez /locations/LOCATION au nom de la ressource après /sources/SOURCE_ID, où SOURCE_ID est l'ID du service Security Command Center qui a généré le résultat.

import com.google.cloud.securitycenter.v1.Finding;
import com.google.cloud.securitycenter.v1.Finding.Mute;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import com.google.cloud.securitycenter.v1.SetMuteRequest;
import java.io.IOException;

public class SetMuteUndefinedFinding {

  public static void main(String[] args) throws IOException {
    // TODO: Replace the variables within {}

    // findingPath: The relative resource name of the finding. See:
    // https://cloud.google.com/apis/design/resource_names#relative_resource_name
    // Use any one of the following formats:
    //  - organizations/{organization_id}/sources/{source_id}/finding/{finding_id}
    //  - folders/{folder_id}/sources/{source_id}/finding/{finding_id}
    //  - projects/{project_id}/sources/{source_id}/finding/{finding_id}
    String findingPath = "{path-to-the-finding}";
    setMuteUndefined(findingPath);
  }

  // Reset mute state of an individual finding.
  // If a finding is already reset, resetting it again has no effect.
  // Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE/UNDEFINED.
  public static Finding setMuteUndefined(String findingPath) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      SetMuteRequest setMuteRequest =
          SetMuteRequest.newBuilder().setName(findingPath).setMute(Mute.UNDEFINED).build();

      Finding finding = client.setMute(setMuteRequest);
      System.out.println(
          "Mute value for the finding " + finding.getName() + " is: " + finding.getMute());
      return finding;
    }
  }
}

Python

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où "PARENT" correspond à organizations, folders, ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

def set_undefined_finding(finding_path: str) -> None:
    """
      Reset mute state of an individual finding.
      Resetting a finding that isn't muted or unmuted has no effect.
      Various mute states are: UNDEFINED/MUTE/UNMUTE.
    Args:
        finding_path: The relative resource name of the finding. See:
        https://cloud.google.com/apis/design/resource_names#relative_resource_name
        Use any one of the following formats:
        - organizations/{organization_id}/sources/{source_id}/finding/{finding_id},
        - folders/{folder_id}/sources/{source_id}/finding/{finding_id},
        - projects/{project_id}/sources/{source_id}/finding/{finding_id}.
    """
    from google.cloud import securitycenter

    client = securitycenter.SecurityCenterClient()

    request = securitycenter.SetMuteRequest()
    request.name = finding_path
    request.mute = securitycenter.Finding.Mute.UNDEFINED

    finding = client.set_mute(request)
    print(f"Reset mute value for the finding: {finding.mute.name}")

API REST

Dans l'API Security Command Center, utilisez la méthode setMute pour réinitialiser le paramètre "Ignorer". l'état d'un résultat. Le corps de la requête est une énumération qui indique l'état de blocage obtenu.

Sauf si la résidence des données est activée, vous pouvez utiliser la version 1 ou la version 2 de l'API Security Command Center. La version 2 de l'API est disponible en version preview. Lorsque la résidence des données est activée, l'API v2 est la seule API disponible.

Si vous utilisez la version 1 de l'API Security Command Center, appelez setMute à l'aide du point de terminaison v1 :

POST https://securitycenter.googleapis.com/v1/PARENT/PARENT_ID/sources/SOURCE_ID/findings/FINDING_ID:setMute

{
  "mute": "UNDEFINED"
}

Si vous utilisez l'API Security Command Center version 2, appelez setMute. à l'aide du point de terminaison v2:

POST https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/sources/SOURCE_ID/locations/LOCATION/findings/FINDING_ID:setMute

{
  "mute": "UNDEFINED"
}

Remplacez les éléments suivants :

• PARENT : ressource parente (organizations, folders ou projects)
• PARENT_ID : ID de l'organisation, du dossier ou du projet parent
• LOCATION: si la résidence des données est activée, le Security Command Center emplacement dans lequel supprimer le forçage de l'état de désactivation du son d'un résultat ; si la résidence des données n'est pas activée, utilisez la valeur global
• SOURCE_ID : ID numérique de la source

Ignorer ou réinitialiser plusieurs résultats existants

Vous pouvez effectuer les opérations de masquage groupé suivantes pour plusieurs résultats existants à l'aide de la commande gcloud scc findings bulk-mute de la CLI gcloud ou de la méthode bulkMute de l'API Security Command Center :

• Masquez plusieurs résultats existants. Si vous ignorez des résultats de manière groupée, ils seront ignorés statiquement et remplace toutes les règles de masquage dynamique qui s'appliquent au résultat. Si vous devez ignorer des résultats futurs similaires, créez une règle de blocage.

• Suppression du remplacement de l'état Ignorer sur plusieurs résultats existants. En supprimant le forçage de l'état de masquage d'un résultat, vous réinitialisez l'état de masquage de MUTED (masqué de manière statique) ou UNMUTED (non masqué de manière statique) à UNDEFINED. Cette fonctionnalité peut être utile si vous passez de règles de masquage statiques à des règles de masquage dynamiques.

Spécifiez l'ensemble de résultats que vous devez ignorer en définissant un filtre de résultats. Les filtres de désactivation groupée ne sont pas compatibles avec toutes les propriétés de résultats. Pour obtenir la liste des propriétés non compatibles, consultez la section Propriétés de résultats non compatibles avec les règles de blocage.

Si la résidence des données est activée pour Security Command Center, la portée des opérations de masquage groupé est limitée à l'emplacement Security Command Center dans lequel elles sont exécutées.

Attention : Les opérations de masquage groupé peuvent expirer si vous essayez de masquer plus de 4 000 000 résultats existants ou si l'opération prend plus de six heures. Si vous avez besoin de couper le son de millions des résultats existants, envisagez de scinder l'opération Ignorer en utilisant plusieurs requêtes de résultats correspondant à un plus petit nombre de résultats.

Remarque: Les résultats appartenant à la classe de résultat SCC errors signalent des problèmes qui empêchent Security Command Center de fonctionner comme prévu. Par conséquent, les résultats d'erreurs ne peuvent pas être ignorés. Pour en savoir plus, consultez la page Présentation des erreurs Security Command Center.

Pour obtenir un exemple de code qui permet d'ignorer les résultats de manière groupée, consultez la section Ignorer les résultats de manière groupée.

Pour ignorer ou réinitialiser plusieurs résultats de manière groupée, cliquez sur l'onglet correspondant que vous souhaitez utiliser:

Console

Dans la console Google Cloud, vous ne pouvez ignorer les résultats de manière groupée qu'en créant des règles de blocage. Dans la console Google Cloud, la création de règles de blocage désactive les résultats existants et futurs.

gcloud

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Pour désactiver ou réinitialiser plusieurs résultats de manière groupée, exécutez la commande gcloud scc findings bulk-mute :

   gcloud scc findings bulk-mute
   --PARENT=PARENT_ID \
   --location=LOCATION \
   --filter="FILTER" \
   --mute-state=MUTE_STATE
   

   Remplacez les éléments suivants :

   • PARENT : champ d'application dans la hiérarchie des ressources auquel la règle de masquage s'applique, organization, folder ou project.
   • PARENT_ID: ID de l'organisation parente. dossier ou projet, spécifié au format organizations/123, folders/456 ou projects/789.

   • LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel couper le son ou réinitialiser les résultats de manière groupée. Si la résidence des données n'est pas activée, utilisez la valeur global.

   • FILTER: expression que vous définissez pour filtrer les résultats.

     Par exemple, pour ignorer tous les résultats OPEN_FIREWALL et PUBLIC_IP_ADDRESS existants de faible gravité dans le projet internal-test, votre filtre peut être "category=\"OPEN_FIREWALL\" OR category=\"PUBLIC_IP_ADDRESS\" AND severity=\"LOW\" AND resource.projectDisplayName=\"internal-test\"".

   • MUTE_STATE: valeur indiquant si le est ignorée de manière statique. Les valeurs valides sont MUTED et UNDEFINED. La valeur est définie sur MUTED par défaut. Ne définissez cette valeur sur UNDEFINED que si vous réinitialisez l'état de masquage de plusieurs résultats existants.

Go

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2 et ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où "PARENT" correspond à organizations, folders, ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv1"
	"cloud.google.com/go/securitycenter/apiv1/securitycenterpb"
)

// bulkMute kicks off a long-running operation (LRO) to bulk mute findings for a parent based on a filter.
// The parent can be either an organization, folder, or project. The findings
// matched by the filter will be muted after the LRO is done.
func bulkMute(w io.Writer, parent string, muteRule string) error {
	// parent: Use any one of the following options:
	//             - organizations/{organization_id}
	//             - folders/{folder_id}
	//             - projects/{project_id}
	// parent := fmt.Sprintf("projects/%s", "your-google-cloud-project-id")
	// muteRule: Expression that identifies findings that should be muted.
	// To create mute rules, see:
	// https://cloud.google.com/security-command-center/docs/how-to-mute-findings#create_mute_rules
	// muteRule := "filter-condition"
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	req := &securitycenterpb.BulkMuteFindingsRequest{
		Parent: parent,
		Filter: muteRule,
	}

	op, err := client.BulkMuteFindings(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to bulk mute findings: %w", err)
	}
	response, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("failed to bulk mute findings: %w", err)
	}
	fmt.Fprintf(w, "Bulk mute findings completed successfully! %s", response)
	return nil
}

Java

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION au nom de la ressource après /sources/SOURCE_ID, où SOURCE_ID est l'ID du service Security Command Center qui a généré le résultat.

import com.google.cloud.securitycenter.v1.BulkMuteFindingsRequest;
import com.google.cloud.securitycenter.v1.BulkMuteFindingsResponse;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class BulkMuteFindings {

  public static void main(String[] args) {
    // TODO: Replace the variables within {}

    // parentPath: Use any one of the following options:
    //             - organizations/{organization_id}
    //             - folders/{folder_id}
    //             - projects/{project_id}
    String parentPath = String.format("projects/%s", "your-google-cloud-project-id");

    // muteRule: Expression that identifies findings that should be muted.
    // eg: "resource.project_display_name=\"PROJECT_ID\""
    String muteRule = "{filter-condition}";

    bulkMute(parentPath, muteRule);
  }

  // Kicks off a long-running operation (LRO) to bulk mute findings for a parent based on a filter.
  // The parent can be either an organization, folder, or project. The findings
  // matched by the filter will be muted after the LRO is done.
  public static void bulkMute(String parentPath, String muteRule) {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      BulkMuteFindingsRequest bulkMuteFindingsRequest =
          BulkMuteFindingsRequest.newBuilder()
              .setParent(parentPath)
              // To create mute rules, see:
              // https://cloud.google.com/security-command-center/docs/how-to-mute-findings#create_mute_rules
              .setFilter(muteRule)
              .build();

      // ExecutionException is thrown if the below call fails.
      BulkMuteFindingsResponse response =
          client.bulkMuteFindingsAsync(bulkMuteFindingsRequest).get();
      System.out.println("Bulk mute findings completed successfully! " + response);
    } catch (IOException | InterruptedException | ExecutionException e) {
      System.out.println("Bulk mute findings failed! \n Exception: " + e);
    }
  }
}

Python

L'exemple suivant utilise l'API v1. Pour modifier l'exemple pour la version 2, remplacez v1 par v2, puis ajoutez /locations/LOCATION au nom de la ressource.

Pour la plupart des ressources, ajoutez /locations/LOCATION au nom de la ressource après /PARENT/PARENT_ID, où PARENT est organizations, folders ou projects.

Pour les résultats, ajoutez /locations/LOCATION à la ressource nom après /sources/SOURCE_ID, où SOURCE_ID est l'identifiant Service Security Command Center à l'origine des résultats.

def bulk_mute_findings(parent_path: str, mute_rule: str) -> None:
    """
      Kicks off a long-running operation (LRO) to bulk mute findings for a parent based on a filter.
      The parent can be either an organization, folder, or project. The findings
      matched by the filter will be muted after the LRO is done.
    Args:
        parent_path: use any one of the following options:
                     - organizations/{organization}
                     - folders/{folder}
                     - projects/{project}
        mute_rule: Expression that identifies findings that should be updated.
    """
    from google.cloud import securitycenter

    client = securitycenter.SecurityCenterClient()

    request = securitycenter.BulkMuteFindingsRequest()
    request.parent = parent_path
    # To create mute rules, see:
    # https://cloud.google.com/security-command-center/docs/how-to-mute-findings#create_mute_rules
    request.filter = mute_rule

    response = client.bulk_mute_findings(request)
    print(f"Bulk mute findings completed successfully! : {response}")

API REST

Dans l'API Security Command Center, utilisez la méthode bulkMute pour désactiver les notifications ou les réinitialiser. l'état Ignorer de plusieurs résultats existants. Le corps de la requête contient utilisée pour filtrer les résultats.

Si la résidence des données n'est pas activée, vous pouvez utiliser les versions v1 ou 2 l'API Security Command Center. La version 2 de l'API est disponible en version preview. Lorsque la résidence des données est activée, l'API v2 est la seule API disponible.

Si vous utilisez l'API Security Command Center version 1, appelez bulkMute à l'aide du point de terminaison v1:

POST https://securitycenter.googleapis.com/v1/PARENT/PARENT_ID/findings:bulkMute -d

{
  "filter": "FILTER",
  "muteState": "MUTE_STATE"
}

Si vous utilisez la version 2 de l'API Security Command Center, appelez bulkMute à l'aide du point de terminaison v2 :

POST https://securitycenter.googleapis.com/v2/PARENT/PARENT_ID/locations/LOCATION/findings:bulkMute -d

{
  "filter": "FILTER",
  "muteState": "MUTE_STATE"
}

Remplacez les éléments suivants :

• PARENT: ressource parente (organizations, folders ou projects).
• PARENT_ID : ID de l'organisation, du dossier ou du projet parent.
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel couper le son ou réinitialiser les résultats de manière groupée. Si la résidence des données n'est pas activée, utilisez la valeur global.

• FILTER: expression que vous définissez pour filtrer les résultats.

  Par exemple, pour ignorer tous les résultats OPEN_FIREWALL et PUBLIC_IP_ADDRESS existants de faible gravité dans le projet internal-test, votre filtre peut être "category=\"OPEN_FIREWALL\" OR category=\"PUBLIC_IP_ADDRESS\" AND severity=\"LOW\" AND resource.projectDisplayName=\"internal-test\"".

• MUTE_STATE : valeur qui indique si le résultat est ignoré ou non. Les valeurs valides sont MUTED ou UNDEFINED. La est définie sur MUTED par défaut. Ne définissez cette valeur sur UNDEFINED que si vous réinitialisez l'état de masquage de plusieurs résultats existants.

Tous les résultats existants de la ressource que vous sélectionnez et qui correspondent exactement au filtre sont masqués. L'attribut mute des résultats est défini sur MUTED.

La désactivation de résultats ne modifie pas leur état. Si les résultats actifs sont ignorés, ils sont masqués, mais restent actifs jusqu'à ce que les failles sous-jacentes, les erreurs de configuration ou les menaces soient résolues.

Afficher les résultats ignorés dans la console Google Cloud

Vous pouvez afficher les résultats ignorés dans la console Google Cloud en modifiant le résultat pour sélectionner les résultats qui incluent la valeur de propriété mute="MUTED".

Par exemple, la requête de résultats suivante n'affiche que les résultats actifs dont le son est coupé:

state="ACTIVE"
AND mute="MUTED"

Pour afficher tous les résultats actifs, qu'ils soient masqués ou réactivés, omettez la méthode mute de la requête:

state="ACTIVE"

Par défaut, la requête de résultats dans la console Google Cloud n'affiche que les résultats qui ne sont pas masqués.

Afficher les résultats ignorés par le type de règle Ignorer

Les sections suivantes expliquent comment interroger les résultats actifs par type de règle de blocage.

Pour savoir comment répertorier des résultats spécifiques, consultez la section Filtrer résultats.

Résultats de requête ignorés par des règles Ignorer statiques

Pour afficher les résultats actifs qui ont été masqués par une règle de masquage statique après un délai spécifié, utilisez la requête suivante et inspectez l'attribut muteInitiator pour déterminer si le résultat a été masqué par une règle de masquage statique.

state="ACTIVE" AND
muteInfo.staticMute.applyTime>=TIMESTAMP AND
muteInfo.staticMute.state="MUTED"

Remplacez TIMESTAMP par la chaîne de date/heure qui indique le début de la période que vous souhaitez interroger. Pour plus d'informations sur les formats d'heure, consultez gcloud topic datetimes.

Résultats de requête ignorés par des règles Ignorer dynamiques

Pour afficher les résultats actifs qui ont été masqués par une règle Ignorer dynamique après une à l'heure spécifiée, utilisez la requête suivante:

state="ACTIVE" AND
muteUpdateTime>=TIMESTAMP AND
contains(muteInfo.dynamicMuteRecords, muteConfig="PARENT_ID/muteConfigs/CONFIG_ID")

Remplacez les éléments suivants :

• TIMESTAMP : chaîne de date/heure indiquant le début de la période que vous souhaitez interroger. Pour obtenir des informations sur l'heure , consultez gcloud topic datetimes.
• PARENT_ID: ID de l'organisation, du dossier et ou projet, spécifié au format organizations/123, folders/456 ou projects/789
• CONFIG_ID : nom de la règle de masquage. La pièce d'identité doit utiliser caractères alphanumériques et traits d'union, et compter entre 1 et 63 caractères.

Pour en savoir plus sur la modification des requêtes de résultats, consultez la section Créer ou modifier une requête de résultats dans le tableau de bord.

Rechercher les propriétés liées à la désactivation des notifications

Cette section répertorie les propriétés de recherche liées à l'état de désactivation du son un résultat et décrit comment ils sont affectés par les opérations Ignorer:

• mute : défini sur UNDEFINED lorsque des résultats sont créés et changent dans les scénarios suivants :
  • MUTED : le résultat est ignoré manuellement ou par une règle de blocage
  • UNMUTED : un utilisateur réactive le résultat
• muteUpdateTime: heure à laquelle le son d'un résultat est coupé ou réactivé.
• muteInitiator: identifiant du compte principal ou de la règle Ignorer ayant ignoré un élément trouver.
• muteInfo: ignorer les informations concernant le résultat, telles que le type de règle Ignorer (statique ou dynamique) et qui masquent les règles auxquelles le résultat correspond.
• muteInfo.staticMute : un état de masquage statique remplace toutes les règles de masquage dynamique qui s'appliquent à ce résultat.
  • state: état statique de désactivation du son qui peut être défini en désactivant le résultat ou une règle Ignorer statique.
  • applyTime : heure à laquelle l'état d'inactivation statique a été appliqué au résultat.
• muteInfo.dynamicMuteRecords: enregistrement d'une règle Ignorer dynamique qui correspond au résultat.
  • muteConfig: est le nom de ressource relatif de la règle Ignorer, représenté par la configuration de désactivation du son qui a créé l'enregistrement. Exemple : organizations/123/muteConfigs/examplemuteconfig.
  • matchTime: date/heure à laquelle une règle Ignorer dynamique correspond au résultat.

Arrêter les notifications et l'exportation des résultats ignorés

Si vous activez les notifications de résultats, les résultats ignorés nouveaux ou mis à jour qui correspondent à vos filtres de notification sont toujours exportés vers Pub/Sub.

Afin d'arrêter les exportations et les notifications pour les résultats ignorés, utilisez l'mute pour exclure les résultats ignorés dans votre filtre NotificationConfig. Par exemple, le filtre suivant n'envoie de notification que pour les résultats actifs qui ne sont pas ignorés ou pour lesquels l'attribut de désactivation n'a pas été défini :

FILTER="state=\"ACTIVE\" AND -mute=\"MUTED\""

Étape suivante

En savoir plus sur filtrer les notifications de résultats.

Consultez d'autres exemples de filtres que vous pouvez utiliser.