Gérer les règles Ignorer

Niveaux de service Standard (ancienne version), Standard, Premium et Enterprise (obsolète)

Le niveau de service Security Command Center Enterprise sera arrêté le 21 mai 2027.

Si votre organisation utilise le niveau de service Enterprise, elle passera automatiquement au niveau de service Premium le 21 mai 2027 ou après. Contactez votre responsable de compte ou un spécialiste des ventesGoogle Cloud si vous avez des questions.

Ce document explique comment créer et gérer des règles de désactivation pour désactiver automatiquement les résultats dans Security Command Center.

Rôles requis

Pour obtenir les autorisations nécessaires pour gérer les règles de désactivation, demandez à votre administrateur de vous accorder les rôles IAM suivants sur l'organisation, le dossier ou le 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)

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Créer une règle Ignorer

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

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 Ignorer, consultez Types de règles Ignorer.

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

Console

Définir la règle Ignorer

1. Dans la console Google Cloud , accédez à la page Résultats.

   Accéder aux résultats

2. Sélectionnez une organisation ou un projet.

3. Cliquez sur Options de blocage, puis sélectionnez Gérer les règles de blocage.

4. Cliquez sur Créer une règle Ignorer.

5. Saisissez un ID de règle Ignorer.

6. Recommandation : saisissez une description qui fournit des informations sur la raison pour laquelle les résultats sont ignorés.

7. Pour confirmer le champ d'application de la règle Ignorer, vérifiez la valeur Ressource parente.

Facultatif : Ajoutez une date d'expiration.

Vous pouvez ajouter une date d'expiration aux règles Ignorer dynamiques.

1. Sélectionnez Ignorer temporairement les résultats correspondants.

2. Pour configurer la date d'expiration de la règle Ignorer dynamique, sélectionnez le calendrier, puis choisissez une date et une heure situées au moins 24 heures dans le futur.

   Après la date d'expiration, la règle Ignorer n'a plus aucun effet.

Facultatif : Limiter la règle Ignorer avec une requête

Si vous ajoutez une requête, la règle Ignorer ne s'applique qu'aux résultats qui correspondent à la requête.

Pour limiter la règle Ignorer à l'aide d'une requête, dans la section Requête sur les résultats, cliquez sur Ajouter un filtre.

Le menu Ajouter un filtre vous permet de choisir les attributs et les valeurs de résultats compatibles.

1. Dans le menu Sélectionner un filtre, sélectionnez un attribut de résultat ou saisissez son nom dans la zone Rechercher des attributs de résultats. Une liste des sous-attributs disponibles s'affiche.
2. Sélectionnez un sous-attribut. Un champ de sélection s'affiche. Vous pouvez y créer l'instruction de requête à l'aide du sous-attribut 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 en savoir plus sur les opérateurs de requête et les fonctions qu'ils utilisent, consultez Opérateurs de requête dans le menu Ajouter des filtres.

   Si vous souhaitez recommencer, cliquez sur Réinitialiser.

4. Cliquez sur Appliquer.

   Le menu 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.

Pour vérifier les résultats de la requête, cliquez sur Prévisualiser les résultats correspondants. Un tableau liste les résultats correspondant à votre requête.

Si la requête ne correspond pas aux résultats corrects, modifiez-la si nécessaire et prévisualisez à nouveau les résultats. Répétez cette étape jusqu'à ce que vous soyez satisfait des résultats.

Enregistrer la règle Ignorer

Cliquez sur Enregistrer. La console Google Cloud affiche la liste de vos règles de blocage.

gcloud

1. Dans la console Google Cloud , activez Cloud Shell.

   Activer Cloud Shell

   En bas de la console Google Cloud , une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

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 alphanumériques et traits d'union.
   • PARENT : champ d'application dans la hiérarchie des ressources auquel la règle Ignorer s'applique (organization, folder ou project).
   • PARENT_ID : ID numérique de l'organisation, du dossier ou du projet parent, ou ID alphanumérique du projet parent.
   • LOCATION : emplacement Security Command Center dans lequel gérer les règles de désactivation. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, utilisez la valeur global.
   • RULE_DESCRIPTION : description de la règle de blocage (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 que vous souhaitez créer. Les types de règles Ignorer valides sont DYNAMIC et STATIC. Le type de règle Ignorer est défini sur STATIC par défaut. Vous ne pouvez pas modifier le type d'une règle Ignorer une fois que vous l'avez créée.
   • TIMESTAMP : ne s'applique que si vous créez une règle Ignorer dynamique. Chaîne de date et d'heure indiquant la date d'expiration de la règle de désactivation dynamique. La valeur doit être définie sur au moins un jour dans le futur, sinon la demande sera refusée. Pour en savoir plus sur les formats de date et d'heure, consultez gcloud topic datetimes. Lorsqu'une règle de désactivation dynamique expire, elle est supprimée de tous les résultats correspondants. Pour que la règle Ignorer dynamique s'applique indéfiniment aux résultats correspondants, omettez ce champ.

   La réponse inclut un ID de 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.

Terraform

Créez une règle de mise en sourdine pour une organisation :

resource "google_scc_v2_organization_mute_config" "default" {
  mute_config_id    = "my-config"
  organization = "123456789"
  location     = "global"
  description  = "My custom Cloud Security Command Center Finding Organization mute Configuration"
  filter = "severity = \"HIGH\""
  type = "STATIC"
}

Créez une règle de mise en sourdine pour un dossier :

resource "google_folder" "folder" {
  parent       = "organizations/123456789"
  display_name = "folder-name"
}

resource "google_scc_v2_folder_mute_config" "default" {
  mute_config_id    = "my-config"
  folder = google_folder.folder.folder_id
  location     = "global"
  description  = "My custom Cloud Security Command Center Finding Folder mute Configuration"
  filter = "severity = \"HIGH\""
  type = "STATIC"
}

Créez une règle de blocage pour un projet :

resource "google_scc_v2_project_mute_config" "default" {
  mute_config_id    = "my-config"
  project = "my-project-name"
  location     = "global"
  description  = "My custom Cloud Security Command Center Finding Project mute Configuration"
  filter = "severity = \"HIGH\""
  type = "STATIC"
}

Go

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv2"
	"cloud.google.com/go/securitycenter/apiv2/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\"",
		Type: securitycenterpb.MuteConfig_STATIC,
	}

	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

import com.google.cloud.securitycenter.v2.LocationName;
import com.google.cloud.securitycenter.v2.MuteConfig;
import com.google.cloud.securitycenter.v2.MuteConfig.MuteConfigType;
import com.google.cloud.securitycenter.v2.SecurityCenterClient;
import java.io.IOException;
import java.util.UUID;

public class CreateMuteRule {

  public static void main(String[] args) throws IOException {
    // TODO: Replace the following variables.
    // projectId: Google Cloud Project id.
    String projectId = "google-cloud-project-id";

    // Specify the location of the mute config.
    String location = "global";

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

    createMuteRule(projectId, location, muteConfigId);
  }

  // Creates a mute configuration in a project under a given location.
  public static void createMuteRule(String projectId, String location, String muteConfigId)
      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()) {

      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\"")
              .setType(MuteConfigType.STATIC)
              .build();

      // You can also create mute rules in an organization/ folder.
      // Construct the parameters according to the parent resource.
      //  * Organization -> client.createMuteConfig(OrganizationLocationName.of(...
      //  * Folder -> client.createMuteConfig(FolderLocationName.of(...
      MuteConfig response = client.createMuteConfig(
          LocationName.of(projectId, location), muteConfig, muteConfigId);
      System.out.println("Mute rule created successfully: " + response.getName());
    }
  }
}

Python

def create_mute_rule(parent_path: str, location_id: str, mute_config_id: str) -> Dict:
    """
    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}
        location_id: Gcp location id; example: 'global'
        mute_config_id: Set a unique id; max of 63 chars.
    Returns:
        Dict: returns the mute rule details
    """

    from google.cloud import securitycenter_v2

    client = securitycenter_v2.SecurityCenterClient()

    mute_config = securitycenter_v2.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"'
    )
    mute_config.type = "STATIC"

    request = securitycenter_v2.CreateMuteConfigRequest()
    request.parent = parent_path + "/locations/" + location_id
    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}")
    return mute_config

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 :

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 Ignorer (organizations, folders ou projects)
• PARENT_ID : ID de l'organisation, du dossier ou du projet parent
• LOCATION : emplacement Security Command Center dans lequel gérer les règles de désactivation du son. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, utilisez la valeur global.
• MUTE_CONFIG_ID : nom de la règle de blocage (entre 1 et 63 caractères)
• RULE_DESCRIPTION : description de la règle de blocage (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 "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. Vous ne pouvez pas modifier le type d'une règle de désactivation une fois que vous l'avez créée.

• TIMESTAMP : ne s'applique que si vous créez une règle Ignorer dynamique. Chaîne de date et d'heure indiquant la date d'expiration de la règle de désactivation dynamique. La valeur doit être définie sur au moins un jour dans le futur, sinon la demande sera refusée. Pour en savoir plus sur les formats de date et d'heure, consultez gcloud topic datetimes. Lorsqu'une règle de désactivation dynamique expire, elle est supprimée de tous les résultats correspondants. Si vous souhaitez que la règle Ignorer dynamique s'applique indéfiniment aux 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. Développez la section suivante pour afficher la liste des propriétés non compatibles avec les filtres de règle de blocage.

Propriétés de résultats non compatibles

• caiResource
• canonicalName
• createTime
• description
• eventTime
• externalUri
• gcpMetadata.folders¹
• libraryPaths
• mute
• muteAnnotation
• muteInfo
• muteInitiator
• muteUpdateTime
• name
• nextSteps
• originalProviderId
• parent
• processes.binaryPath
• processes.libraryPaths
• propertyDataTypes
• resource.tags
• resourceName
• securityMarks
• sourceProperties
• state
• workflowState

¹ La propriété gcpMetadata.folders contient des sous-champs compatibles avec les filtres de blocage.

Répertorier les règles de blocage

Vous pouvez lister les règles de mise en sourdine dans une organisation, un dossier ou un projet à l'aide de la console Google Cloud , de la gcloud CLI ou de l'API Security Command Center.

Votre capacité à lister les règles de blocage pour un champ d'application donné dépend des autorisations accordées à vos rôles IAM.

Si la résidence des données est activée pour Security Command Center, le champ d'application de la commande list est également limité à l'emplacement Security Command Center sélectionné.

Pour obtenir un exemple de code qui liste les règles de blocage, consultez Lister les règles de blocage.

Pour lister les règles de blocage d'une organisation, d'un dossier ou d'un projet, 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 de blocage de la page Paramètres de Security Command Center.

   Accéder aux règles de masquage

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

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

   • Nom : ID de la règle Ignorer
   • Ressource parente : ressource où réside la règle Ignorer
   • Description : description de la règle Ignorer, 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. Dans la console Google Cloud , activez Cloud Shell.

   Activer Cloud Shell

   En bas de la console Google Cloud , une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

2. Pour lister les règles de blocage, 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 : emplacement Security Command Center dans lequel gérer les règles de désactivation du son. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, utilisez la valeur global.

Go

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv2"
	"cloud.google.com/go/securitycenter/apiv2/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

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

public class ListMuteRules {

  public static void main(String[] args) throws IOException {
    // TODO: Replace variables enclosed within {}
    // projectId: Google Cloud Project id.
    String projectId = "google-cloud-project-id";

    // Specify the location to list mute configs.
    String location = "global";

    listMuteRules(projectId, location);
  }

  // Lists all mute rules present under the resource type in the given location.
  public static void listMuteRules(String projectId, String location) 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()) {

      // Parent can also be one of:
      //  * "organizations/{org_id}/locations/{location}"
      //  * "folders/{folder_id}/locations/{location}"
      ListMuteConfigsRequest listMuteConfigsRequest = ListMuteConfigsRequest.newBuilder()
          .setParent(String.format("projects/%s/locations/%s", projectId, location))
          .build();

      // List all mute configs present in the resource.
      for (MuteConfig muteConfig : client.listMuteConfigs(listMuteConfigsRequest).iterateAll()) {
        System.out.println(muteConfig.getName());
      }
    }
  }
}

Python

def list_mute_rules(parent: str, location_id: str) -> Dict:
    """
    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}
        location_id: Gcp location id; example: 'global'
    Returns:
         Dict: returns the mute rule details
    """
    from google.cloud import securitycenter_v2

    client = securitycenter_v2.SecurityCenterClient()

    request = securitycenter_v2.ListMuteConfigsRequest()
    request.parent = parent + "/locations/" + location_id
    response = client.list_mute_configs(request)
    # List all Mute Configs present in the resource.
    for mute_config in response:
        print(mute_config.name)
    return response

REST

Dans l'API Security Command Center, utilisez la méthode muteConfigs.list pour lister les règles de désactivation :

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

Remplacez les éléments suivants :

• PARENT : ressource parente de votre règle Ignorer (organizations, folders ou projects)
• PARENT_ID : ID de l'organisation, du dossier ou du projet parent
• LOCATION : emplacement Security Command Center dans lequel gérer les règles de désactivation du son. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, 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 Ignorer

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

Pour obtenir un exemple de code permettant de récupérer la configuration d'une règle Ignorer, consultez Afficher une règle Ignorer.

Pour afficher la configuration d'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 de blocage de la page Paramètres de Security Command Center.

   Accéder aux règles de masquage

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

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

4. 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. Dans la console Google Cloud , activez Cloud Shell.

   Activer Cloud Shell

   En bas de la console Google Cloud , une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

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 Ignorer (organization, folder ou project)
   • PARENT_ID : ID de l'organisation, du dossier ou du projet
   • LOCATION : emplacement Security Command Center dans lequel gérer les règles de désactivation du son. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, utilisez la valeur global.

Go

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv2"
	"cloud.google.com/go/securitycenter/apiv2/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

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

public class GetMuteRule {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Replace the following variables
    // projectId: Google Cloud Project id.
    String projectId = "google-cloud-project-id";

    // Specify the location of the mute config. If the mute config was
    // created with v1 API, it can be accessed with "global".
    String location = "global";

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

    getMuteRule(projectId, location, muteConfigId);
  }

  // Retrieves a mute configuration given its resource name.
  public static MuteConfig getMuteRule(String projectId, String location, String muteConfigId)
      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()) {
      // Use appropriate `MuteConfigName` methods depending on the parent type.
      //  * organization -> MuteConfigName.ofOrganizationLocationMuteConfigName()
      //  * folder -> MuteConfigName.ofFolderLocationMuteConfigName()

      MuteConfigName muteConfigName = MuteConfigName.ofProjectLocationMuteConfigName(projectId,
          location, muteConfigId);
      return client.getMuteConfig(muteConfigName);
    }
  }
}

Python

def get_mute_rule(parent_path: str, location_id: str, mute_config_id: str) -> Dict:
    """
    Retrieves a mute configuration given its resource name.
    Args:
        parent_path: use any one of the following options:
                     - organizations/{organization_id}
                     - folders/{folder_id}
                     - projects/{project_id}
        location_id: Gcp location id; example: 'global'
        mute_config_id: Set a unique id; max of 63 chars.
    Returns:
         Dict: returns the mute rule details
    """
    from google.cloud import securitycenter_v2

    client = securitycenter_v2.SecurityCenterClient()

    request = securitycenter_v2.GetMuteConfigRequest()
    request.name = (
        parent_path + "/locations/" + location_id + "/muteConfigs/" + mute_config_id
    )

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

REST

Dans l'API Security Command Center, utilisez la méthode muteConfigs.get pour renvoyer la configuration d'une règle Ignorer :

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 Ignorer (organizations, folders ou projects)
• PARENT_ID : ID de l'organisation, du dossier ou du projet
• LOCATION : emplacement Security Command Center dans lequel gérer les règles de désactivation du son. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, utilisez la valeur global.
• CONFIG_ID : ID numérique de la règle Ignorer

Mettre à jour les règles de blocage

Vous pouvez modifier la description ou le filtre de résultats d'une règle de mise en sourdine à l'aide de la console Google Cloud , de gcloud CLI 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 blocage. Pour modifier l'une de ces valeurs, vous devez créer une règle Ignorer.

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 Ignorer mise à jour dans la console Google Cloud . Pour en savoir plus, consultez Réactiver des résultats individuels.

Remarque : Les résultats appartenant à la classe de résultats SCC errors signalent les 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 permettant de mettre à jour une règle Ignorer, consultez Mettre à jour une règle Ignorer.

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 de blocage de la page Paramètres de Security Command Center.

   Accéder aux règles de masquage

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

3. 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.

4. Modifiez la règle Ignorer.

5. Facultatif : Après avoir mis à jour le filtre, cliquez sur Prévisualiser les résultats correspondants pour afficher les résultats correspondant au filtre mis à jour. Une table se charge avec les résultats correspondant à la nouvelle requête.

6. Cliquez sur Enregistrer.

gcloud

1. Dans la console Google Cloud , activez Cloud Shell.

   Activer Cloud Shell

   En bas de la console Google Cloud , une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

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 Ignorer.
   • PARENT : ressource parente de votre règle Ignorer (organization, folder ou project).
   • PARENT_ID : ID de l'organisation, du dossier ou du projet.
   • LOCATION : emplacement Security Command Center dans lequel gérer les règles de désactivation. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, utilisez la valeur global.
   • RULE_DESCRIPTION : description de la règle de blocage (1 024 caractères au 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 que vous mettez à jour. Les types de règles Ignorer valides sont DYNAMIC et STATIC. Une fois une règle Ignorer créée, vous ne pouvez plus en modifier le type.

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

Go

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv2"
	"cloud.google.com/go/securitycenter/apiv2/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

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

public class UpdateMuteRule {

  public static void main(String[] args) throws IOException {
    // TODO: Replace the variables within {}
    // projectId: Google Cloud Project id.
    String projectId = "google-cloud-project-id";

    // Specify the location of the mute config to update. If the mute config was
    // created with v1 API, it can be accessed with "global".
    String location = "global";

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

    updateMuteRule(projectId, location, muteConfigId);
  }

  // Updates an existing mute configuration.
  // The following can be updated in a mute config: description and filter.
  public static void updateMuteRule(String projectId, String location, String muteConfigId)
      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 securityCenterClient = SecurityCenterClient.create()) {

      MuteConfig updateMuteConfig =
          MuteConfig.newBuilder()
              // Construct the name according to the parent type of the mute rule.
              // Parent can also be one of:
              //  * "organizations/{org_id}/locations/{location}/muteConfigs/{muteConfig_id}"
              //  * "folders/{folder_id}/locations/{location}/muteConfigs/{muteConfig_id}"
              .setName(String.format("projects/%s/locations/%s/muteConfigs/%s", projectId, location,
                  muteConfigId))
              .setDescription("Updated mute config description")
              .build();

      UpdateMuteConfigRequest updateMuteConfigRequest =
          UpdateMuteConfigRequest.newBuilder()
              .setMuteConfig(updateMuteConfig)
              // Make sure that the mask fields match the properties changed in
              // 'updateMuteConfig' object.
              // For more info on constructing update mask path, see the proto or:
              // https://cloud.google.com/security-command-center/docs/reference/rest/v2/folders.muteConfigs/patch?hl=en#query-parameters
              .setUpdateMask(FieldMask.newBuilder().addPaths("description").build())
              .build();

      MuteConfig response = securityCenterClient.updateMuteConfig(updateMuteConfigRequest);
      System.out.println(response);
    }
  }
}

Python

def update_mute_rule(parent_path: str, location_id: str, mute_config_id: str) -> Dict:
    """
    Updates an existing mute configuration.
    The following can be updated in a mute config: description, and filter/ mute rule.
    Args:
        parent: Use any one of the following resource paths to list mute configurations:
                - organizations/{organization_id}
                - folders/{folder_id}
                - projects/{project_id}
        location_id: Gcp location id; example: 'global'
        mute_config_id: Set a unique id; max of 63 chars.
    Returns:
         Dict: returns the mute rule details
    """
    from google.cloud import securitycenter_v2
    from google.protobuf import field_mask_pb2

    client = securitycenter_v2.SecurityCenterClient()

    update_mute_config = securitycenter_v2.MuteConfig()
    update_mute_config.name = (
        parent_path + "/locations/" + location_id + "/muteConfigs/" + mute_config_id
    )
    update_mute_config.description = "Updated mute config description"

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

    request = securitycenter_v2.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}")
    return mute_config

REST

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

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 Ignorer (organizations, folders ou projects)
• PARENT_ID : ID de l'organisation, du dossier ou du projet
• LOCATION : emplacement Security Command Center dans lequel gérer les règles de désactivation du son. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, utilisez la valeur global.
• CONFIG_ID : ID numérique de la règle Ignorer
• RULE_DESCRIPTION : description de la règle Ignorer (1 024 caractères maximum)
• FILTER : expression que vous définissez pour filtrer les résultats
• MUTE_TYPE : type de règle Ignorer que vous mettez à jour. Les types de règles Ignorer valides sont DYNAMIC et STATIC. Une fois une règle Ignorer créée, vous ne pouvez plus en modifier le type.
• TIMESTAMP : ne s'applique que si vous mettez à jour une règle Ignorer dynamique. Chaîne de date et d'heure indiquant la date d'expiration de la règle de désactivation dynamique. La valeur doit être définie sur au moins un jour dans le futur, sinon la demande sera refusée. Pour en savoir plus sur les formats d'heure, consultez gcloud topic datetimes. Lorsqu'une règle de désactivation dynamique expire, elle est supprimée de tous les résultats correspondants. Si vous souhaitez que la règle Ignorer dynamique s'applique indéfiniment aux résultats correspondants, omettez ce champ.

Supprimer les règles de blocage

Vous pouvez supprimer une règle Ignorer à l'aide de la console Google Cloud , de la gcloud CLI 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 statiques Ignorer ne réactive pas automatiquement les résultats ignorés. Vous devez réactiver les résultats manuellement ou de manière automatisée.
• La suppression des règles Ignorer dynamiques supprime automatiquement la règle de tous les résultats correspondants précédents 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 utiliser :

Console

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

   Accéder aux règles de masquage

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

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

4. Cliquez sur Supprimer.

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

gcloud

1. Dans la console Google Cloud , activez Cloud Shell.

   Activer Cloud Shell

   En bas de la console Google Cloud , une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

2. Pour supprimer les règles de blocage, 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 Ignorer (organization, folder ou project)
   • PARENT_ID : ID de l'organisation, du dossier ou du projet
   • LOCATION : emplacement Security Command Center dans lequel gérer les règles de désactivation du son. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, utilisez la valeur global.

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

Go

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv2"
	"cloud.google.com/go/securitycenter/apiv2/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

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

public class DeleteMuteRule {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Replace the following variables
    // projectId: Google Cloud Project id.
    String projectId = "google-cloud-project-id";

    // Specify the location of the mute config. If the mute config was
    // created with v1 API, it can be accessed with "global".
    String location = "global";

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

    deleteMuteRule(projectId, location, 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 location, String muteConfigId)
      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()) {
      // Use appropriate `MuteConfigName` methods depending on the parent type.
      // folder -> MuteConfigName.ofFolderLocationMuteConfigName()
      // organization -> MuteConfigName.ofOrganizationLocationMuteConfigName()
      client.deleteMuteConfig(
          MuteConfigName.ofProjectLocationMuteConfigName(projectId, location, muteConfigId));

      System.out.println("Mute rule deleted successfully: " + muteConfigId);
    }
  }
}

Python

def delete_mute_rule(parent_path: str, location_id: str, mute_config_id: str) -> None:
    """
    Deletes a mute configuration given its resource name.
    Note: Previously muted findings are not affected when a mute config is deleted.
    Args:
         parent_path: use any one of the following options:
                     - organizations/{organization_id}
                     - folders/{folder_id}
                     - projects/{project_id}
        location_id: Gcp location id; example: 'global'
        mute_config_id: Set a unique id; max of 63 chars.
    Returns:
         None: returns none mute rule is deleted
    """
    from google.cloud import securitycenter_v2

    client = securitycenter_v2.SecurityCenterClient()

    request = securitycenter_v2.DeleteMuteConfigRequest()
    request.name = (
        parent_path + "/locations/" + location_id + "/muteConfigs/" + mute_config_id
    )

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

REST

Dans l'API Security Command Center, utilisez la méthode muteConfigs.delete pour supprimer une règle Ignorer :

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 Ignorer (organizations, folders ou projects)
• PARENT_ID : ID de l'organisation, du dossier ou du projet
• LOCATION : emplacement Security Command Center dans lequel gérer les règles de désactivation du son. Si la résidence des données est activée, utilisez eu, sa ou us. Sinon, utilisez la valeur global.
• CONFIG_ID : ID numérique de la règle Ignorer