Masquer des résultats dans Security Command Center

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 de blocage statique ou une règle de blocage dynamique sans 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 en savoir plus sur les opérateurs de requête et les fonctions qu'ils utilisent, consultez la section Opérateurs de 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 de masquage. 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 numérique de l'organisation, du dossier ou du projet parent, ou ID alphanumérique du projet parent.
   • 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 règle de masquage ne dépassant pas 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 FILTER="category=\"OPEN_FIREWALL\"".
   • MUTE_TYPE: type de règle de blocage que vous souhaitez créer. Les types de règles de masquage valides sont DYNAMIC et STATIC. Le type de règle de masquage est défini sur STATIC par défaut. 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 à l'avance, 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 masquage dynamique expire, elle est supprimée de toutes les correspondances. Si vous souhaitez que la règle Ignorer dynamique agisse indéfiniment sur les résultats correspondants, omettez ce champ.

   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

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 de masquage. 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 de blocage (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 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 de blocage (entre 1 et 63 caractères)
• RULE_DESCRIPTION : description de la règle de masquage (1 024 caractères au plus)

• 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 souhaitez créer. Les types de règles de masquage 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 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 en savoir plus sur les formats de date et d'heure, consultez gcloud topic datetimes. Lorsqu'une règle de masquage dynamique expire, elle est supprimée de toutes les correspondances. 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.

Console

1. Dans Google Cloud Console, accédez à l'onglet Règles de blocage de la 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, 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 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 : si la résidence des données est activée, l'emplacement Security Command Center dans lequel lister les règles de masquage. Si la résidence des données n'est pas activée, 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 masquage:

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, du dossier ou du projet parent
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel lister les 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.

Console

1. Dans Google Cloud Console, accédez à l'onglet Règles de blocage de la 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, 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 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 de blocage, 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 de blocage
   • 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

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 de masquage:

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

Console

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

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

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 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 mettre à jour la 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 règle de blocage (1 024 caractères au plus)

   • 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 de blocage que vous mettez à jour. Les types de règles de masquage valides sont DYNAMIC et STATIC. Une fois la règle de masquage créée, vous ne pouvez plus en modifier le type.

   • TIMESTAMP: ne s'applique que si vous mettez à jour 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 à l'avance, 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 masquage dynamique expire, elle est supprimée de toutes les correspondances. Si vous souhaitez que la règle Ignorer dynamique agisse indéfiniment sur les 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 de masquage. 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 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 mettre à jour 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
• RULE_DESCRIPTION: description de la règle de blocage (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 de masquage valides sont DYNAMIC et STATIC. Une fois la règle de masquage créée, vous ne pouvez plus en modifier le type.

• TIMESTAMP: ne s'applique que si vous mettez à jour une règle de blocage dynamique. Chaîne de date/heure indiquant quand la règle de masquage dynamique expire. La valeur doit être définie sur au moins un jour à venir, sinon la requête sera rejetée. Pour en savoir plus sur les formats de date et 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.

Console

1. Dans Google Cloud Console, accédez à l'onglet Règles de blocage de la 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, 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 delete 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 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 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 supprimer la règle de masquage. 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

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 de masquage:

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'organisation, du dossier ou du projet
• LOCATION : si la résidence des données est activée, l'emplacement Security Command Center dans lequel supprimer 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

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'emplacements 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 devez 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 "Résultats".

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

1. Dans le panneau Résultats de la requête de résultats de la page Résultats, dans la colonne Catégorie, cliquez sur le nom d'un résultat. Le panneau d'informations du résultat s'ouvre.
2. Cliquez sur Prendre des mesures.

3. Dans le menu Prendre des mesures, sélectionnez Appliquer le forçage de la désactivation du son.

   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 de résultat est la dernière partie de l'attribut canonicalName, par 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, 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 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

import (
	"context"
	"fmt"
	"io"

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

// setMute mutes an individual finding.
// If a finding is already muted, muting it again has no effect.
// Various mute states are: MUTE_UNSPECIFIED/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

import com.google.cloud.securitycenter.v2.Finding;
import com.google.cloud.securitycenter.v2.Finding.Mute;
import com.google.cloud.securitycenter.v2.SecurityCenterClient;
import com.google.cloud.securitycenter.v2.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/{org_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //  - folders/{folder_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //  - projects/{project_id}/sources/{source_id}/locations/{location}/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.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      SetMuteRequest setMuteRequest =
          SetMuteRequest.newBuilder()
              // Relative path for the finding.
              .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

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_v2

    client = securitycenter_v2.SecurityCenterClient()

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

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

REST

Dans l'API Security Command Center, utilisez la méthode findings.setMute pour désactiver un résultat. Le corps de la requête est une énumération qui indique l'état de blocage résultant:

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 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 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 manière de récupérer l'ID d'une source, consultez la section Obtenir l'ID d'une 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 afin de 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.

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.

   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 que les résultats masqués 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'établissements 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 masqué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électionner 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 la réactivation.

   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 "Résultats".

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

1. Dans le panneau Résultats de la requête de résultats de la page Résultats, dans la colonne Catégorie, cliquez sur le nom d'un résultat. Le panneau d'informations du résultat s'ouvre.
2. Cliquez sur Prendre des mesures.
3. Dans le menu Prendre une mesure, sélectionnez Appliquer le forçage de la désactivation du masquage 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 afin de 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.

   • 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, 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 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

import (
	"context"
	"fmt"
	"io"

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

// setUnmute unmutes an individual finding.
// Unmuting a finding that isn't muted has no effect.
// Various mute states are: MUTE_UNSPECIFIED/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

import com.google.cloud.securitycenter.v2.Finding;
import com.google.cloud.securitycenter.v2.Finding.Mute;
import com.google.cloud.securitycenter.v2.SecurityCenterClient;
import com.google.cloud.securitycenter.v2.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/{org_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //  - folders/{folder_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //  - projects/{project_id}/sources/{source_id}/locations/{location}/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.
    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

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_v2

    client = securitycenter_v2.SecurityCenterClient()

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

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

REST

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

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, du dossier ou du projet parent
• 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 manière de récupérer l'ID d'une source, consultez la section Obtenir l'ID d'une 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 afin de 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.

Console

1. Dans la console Google Cloud, 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, 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. À 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 sur les résultats sont mis à jour pour inclure les résultats ignorés de manière statique et ceux qui ne le sont pas.

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 à côté du résultat que vous souhaitez réinitialiser. Vous pouvez sélectionner 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 des résultats sélectionnés est défini sur UNDEFINED, et le résultat est supprimé du panneau Résultats de la requête "Résultats".

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

1. Dans le panneau Résultats de la requête de résultats de la page Résultats, dans la colonne Catégorie, cliquez sur le nom d'un résultat. Le panneau d'informations du résultat s'ouvre.
2. Cliquez sur Prendre des mesures.
3. Dans le menu Prendre une mesure, sélectionnez Supprimer les forçages de mise en sourdine.

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 que vous souhaitez 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 de résultat est la dernière partie de l'attribut canonicalName, par 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, l'emplacement Security Command Center dans lequel supprimer le forçage de l'état de masquage 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.

REST

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

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, l'emplacement Security Command Center dans lequel supprimer le forçage de l'état de masquage 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

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 numérique de l'organisation, du dossier ou du projet parent, ou ID alphanumérique 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 masqué de manière statique ou non. 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.

REST

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

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

{
  "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 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.