Masquer des résultats dans Security Command Center

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

Présentation

Ignorer un résultat le masque de la vue par défaut de vos résultats dans la console Google Cloud. Vous pouvez ignorer les résultats manuellement ou de manière automatisée, et créer des filtres pour désactiver automatiquement les résultats existants et futurs en fonction des critères que vous spécifiez.

Les fournisseurs de résultats dans Security Command Center fournissent des évaluations de sécurité générales de votre déploiement Google Cloud, mais vous pouvez constater que certains résultats ne sont pas appropriés ou pertinents pour votre organisation ou vos projets. Un grand nombre de résultats peut également compliquer l'identification et la résolution des risques les plus critiques pour vos analystes de sécurité. La désactivation des résultats vous fait gagner du temps, car vous n'avez plus besoin d'examiner les résultats de sécurité ou d'y répondre pour les éléments isolés ou qui correspondent à des paramètres métier acceptables.

Ignorer des résultats et des listes d'autorisation

La désactivation des résultats fonctionne différemment des solutions de gestion des volumes existantes. Security Health Analytics vous permet d'utiliser des marques de sécurité dédiées pour ajouter des éléments aux listes d'autorisation, ce qui empêche les détecteurs de créer des résultats de sécurité pour des éléments spécifiques. Security Command Center vous permet également de désactiver les détecteurs.

Cependant, la désactivation des résultats présente plusieurs avantages par rapport aux listes d'autorisation et la désactivation des détecteurs:

• Vous pouvez ignorer les résultats sans localiser leurs éléments sous-jacents.
• Les résultats qui ne sont associés à aucune ressource peuvent être ignorés.
• Vous pouvez créer des filtres personnalisés pour affiner la fonctionnalité de désactivation personnalisée.
• La désactivation des résultats n'empêche pas l'analyse des éléments sous-jacents. Les résultats sont toujours générés, mais restent masqués jusqu'à ce que vous décidiez de les afficher.

Autorisations

Pour ignorer des résultats, vous devez disposer de l'un des rôles IAM (Identity and Access Management) suivants au niveau de l'organisation, du dossier ou du projet:

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

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

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

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

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

Ignorer les résultats

Vous pouvez ignorer manuellement un résultat spécifique, désactiver plusieurs résultats à la fois avec des filtres de blocage groupé ou créer des règles de blocage qui suppriment automatiquement les résultats futurs en fonction des filtres que vous définissez.

Attention:Soyez prudent lorsque vous ignorez des résultats dont le niveau de gravité est élevé ou critique. Vous devez vous assurer que les menaces, les erreurs de configuration ou les failles ne constituent pas un risque, ou que ces risques ne sont pas éliminés.

Les résultats contiennent un attribut mute que vous pouvez définir sur MUTED ou UNMUTED. Lorsque vous désactivez et réactivez les résultats, vous modifiez la valeur de l'attribut. Pour en savoir plus, consultez la section Ignorer les propriétés de résultats.

Ignorer des résultats est pertinent dans de nombreux cas d'utilisation, y compris dans les cas suivants:

• Éléments au sein d'environnements hors production pour lesquels certaines exigences plus strictes peuvent ne pas être applicables.
• Recommandations d'utilisation de clés de chiffrement gérées par le client dans les projets qui ne contiennent pas de données critiques.
• Lors de l'octroi d'un accès étendu à un datastore, qui est intentionnellement ouvert au public et diffuse des informations publiques.
• Résultats qui ne sont pas pertinents pour votre organisation ou votre projet par rapport aux règles de votre entreprise.

Les résultats ignorés continuent d'être enregistrés à des fins d'audit et de conformité, et peuvent être affichés si nécessaire. Toutefois, elles n'apparaissent pas par défaut dans la console Google Cloud. Vous pouvez également filtrer les résultats ignorés à partir des notifications Pub/Sub et des appels d'API Security Command Center à l'aide de l'attribut mute du résultat.

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 de Security Command Center.

Ignorer un résultat individuel

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

Pour obtenir un exemple de code permettant d'ignorer un résultat, consultez la section Ignorer un résultat.

Pour ignorer un résultat individuel, cliquez sur l'onglet correspondant à la procédure que vous souhaitez utiliser:

Console

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

   Accéder

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

3. Si la résidence des données est activée pour Security Command Center, utilisez le sélecteur d'emplacement situé juste en dessous du sélecteur de projet pour choisir l'emplacement du résultat dans Security Command Center. Exemple :

   

4. Si vous ne voyez pas le résultat que vous devez ignorer 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 de résultats, cliquez sur Options Ignorer, puis sélectionnez Ignorer.

   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 de résultats.

Vous pouvez également ignorer un résultat depuis son panneau de détails:

1. Dans le panneau Finding query results (Rechercher des résultats de la requête) de la page Findings (Résultats), dans la colonne Category (Catégorie), cliquez sur le nom d'un résultat individuel. Le panneau de détails du résultat s'ouvre.
2. Cliquez sur Effectuer une action.

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

   Si vous sélectionnez Ignorer les résultats similaires, la page Créer une règle Ignorer s'ouvre. Elle vous permet de créer une règle Ignorer pour les résultats du même type ou qui incluent le même attribut Indicator.

gcloud

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

   Activer Cloud Shell

   En bas de la fenêtre 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 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, spécifiez l'emplacement Security Command Center dans lequel le résultat est stocké.

     Si la résidence des données n'est pas activée, la spécification de l'option --location bloque le résultat à l'aide de la version 2 de l'API Security Command Center. La seule valeur valide pour cet indicateur est global.

   • SOURCE_ID : ID de la source

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

Go

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

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

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

import (
	"context"
	"fmt"
	"io"

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

// setMute mutes an individual finding.
// 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

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

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

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

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

public class SetMuteFinding {

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

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

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

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

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

Python

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

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

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

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

    client = securitycenter.SecurityCenterClient()

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

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

API REST

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

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

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

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

{
  "mute": "MUTED"
}

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

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

{
  "mute": "MUTED"
}

Remplacez les éléments suivants :

• PARENT: ressource parente (organizations, folders ou projects).
• PARENT_ID: ID de l'organisation, du dossier ou du projet parent.
• LOCATION: pour la version 2 uniquement, spécifie l'emplacement Security Command Center dans lequel le résultat est stocké. Si le champ d'emplacement est omis, la valeur par défaut est 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.

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

Ignorer un résultat n'a aucune incidence sur son état actif ou non. Si un résultat actif est ignoré, l'attribut state reste inchangé : state="ACTIVE". Le résultat est masqué, mais reste actif jusqu'à ce que la faille, l'erreur de configuration ou la menace sous-jacente soit résolue.

Pour en savoir plus sur les règles Ignorer, consultez la page Créer des règles Ignorer.

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

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

Par exemple, la requête de résultats suivante n'affiche que les résultats actifs ayant été ignorés:

state="ACTIVE"
AND mute="MUTED"

Pour afficher tous les résultats actifs, ignorés et réactivés, omettez complètement l'attribut mute de la requête:

state="ACTIVE"

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

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

Réactiver les résultats individuels

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

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

Pour réactiver un résultat individuel, cliquez sur l'onglet correspondant à la procédure que vous souhaitez utiliser:

Console

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

   Accéder

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

   La page Résultats s'ouvre avec la requête par défaut affichée dans la section Aperçu de la requête. La requête par défaut filtre les résultats ignorés. Vous devez donc la modifier avant que les résultats ignorés n'apparaissent dans le panneau Résultats de la requête de résultats.

3. Si la résidence des données est activée pour Security Command Center, utilisez le sélecteur d'emplacement situé juste en dessous du sélecteur de projet pour choisir l'emplacement du résultat dans Security Command Center. Exemple :

   

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 de l'éditeur de requête, remplacez l'instruction de désactivation existante par ce qui suit:

   mute="MUTED"

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

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

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 Options Ignorer, puis sélectionnez Réactiver.

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

Vous pouvez également réactiver un résultat depuis son panneau de détails:

1. Dans le panneau Finding query results (Rechercher des résultats de la requête) de la page Findings (Résultats), dans la colonne Category (Catégorie), cliquez sur le nom d'un résultat individuel. Le panneau de détails du résultat s'ouvre.
2. Cliquez sur Effectuer une action.
3. Dans le menu Effectuer une action, sélectionnez Réactiver.

gcloud

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

   Activer Cloud Shell

   En bas de la fenêtre 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 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, spécifiez l'emplacement Security Command Center dans lequel le résultat est stocké.

     Si la résidence des données n'est pas activée, le fait de spécifier l'option --location réactive le résultat à l'aide de la version 2 de l'API Security Command Center. La seule valeur valide pour cet indicateur est global.

   • SOURCE_ID : ID de la source

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

Go

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

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

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

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

public class SetUnmuteFinding {

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

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

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

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

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

Python

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

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

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

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

    client = securitycenter.SecurityCenterClient()

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

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

API REST

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

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

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

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

{
  "mute": "UNMUTED"
}

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

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

{
  "mute": "UNMUTED"
}

Remplacez les éléments suivants :

• PARENT : ressource parente (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation, du dossier ou du projet parent
• LOCATION: pour la version 2 uniquement, spécifie l'emplacement Security Command Center dans lequel le résultat est stocké. Si le champ d'emplacement est omis, la valeur par défaut est global.

• SOURCE_ID : ID numérique de la source

  Pour obtenir des instructions sur la récupération d'un ID source, consultez la section Obtenir l'ID 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.

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

Les résultats désactivés ignorent les règles de blocage

Si un utilisateur désactive les notifications, elles restent ignorées même si les règles de blocage existantes correspondent toujours aux résultats. En effet, les actions de blocage créées par les utilisateurs ignorent les règles de blocage.

Les résultats ignorés ne sont à nouveau ignorés que si un utilisateur désactive manuellement les résultats ou crée une règle de blocage des correspondances dans la console Google Cloud. Les règles de blocage créées avec gcloud CLI ou l'API Security Command Center n'affectent pas les résultats obtenus par les utilisateurs.

Ignorer plusieurs résultats existants

Vous pouvez ignorer plusieurs résultats existants de manière groupée à l'aide de la commande gcloud CLI gcloud scc findings bulk-mute ou de la méthode bulkMute de l'API Security Command Center. Si vous devez ignorer des résultats futurs similaires, créez une règle Ignorer.

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

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

Attention :Les opérations de masquage groupée peuvent expirer si vous tentez d'ignorer plus de 4 000 000 résultats existants environ ou si l'opération prend plus de six heures. Si vous devez ignorer des millions de résultats existants, envisagez de diviser l'opération de masquage en utilisant plusieurs requêtes de résultat correspondant à un plus petit nombre de résultats.

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

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

Pour ignorer des résultats de manière groupée, cliquez sur l'onglet correspondant à la procédure que vous souhaitez utiliser:

Console

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

gcloud

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

   Activer Cloud Shell

   En bas de la fenêtre 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 ignorer 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" \
   

   Remplacez les éléments suivants :

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

   • LOCATION: si la résidence des données est activée, spécifiez l'emplacement Security Command Center dans lequel vous souhaitez ignorer les résultats de manière groupée. Seuls les résultats de cet emplacement sont ignorés.

     Si la résidence des données n'est pas activée, la spécification de l'option --location bloque les résultats à l'aide de la version 2 de l'API Security Command Center. La seule valeur valide pour cet indicateur est 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.project_display_name=\"internal-test\"".

Go

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

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

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

import (
	"context"
	"fmt"
	"io"

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

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

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

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

Java

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

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

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

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

public class BulkMuteFindings {

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

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

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

    bulkMute(parentPath, muteRule);
  }

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

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

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

Python

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

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

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

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

    client = securitycenter.SecurityCenterClient()

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

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

API REST

Dans l'API Security Command Center, utilisez la méthode bulkMute pour ignorer plusieurs résultats existants. Le corps de la requête contient l'expression utilisée pour filtrer les résultats.

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

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

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

{
  "filter": "FILTER"
}

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

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

{
  "filter": "FILTER"
}

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: pour la version 2 uniquement, spécifie l'emplacement Security Command Center dans lequel les résultats sont stockés. Si le champ d'emplacement est omis, la valeur par défaut est 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.project_display_name=\"internal-test\"".

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

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

Créer des règles de blocage

Les règles de blocage sont des configurations Security Command Center qui utilisent des filtres que vous créez pour ignorer automatiquement les résultats futures en fonction des critères que vous spécifiez. Les nouveaux résultats qui correspondent aux filtres de blocage sont automatiquement ignorés de manière continue. Si vous souhaitez également ignorer des résultats existants, utilisez les mêmes filtres pour ignorer des résultats de manière groupée.

Champ d'application des règles Ignorer

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

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

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

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

Restrictions liées aux règles Ignorer

Les règles de blocage ne sont pas compatibles avec toutes les propriétés de résultats. Pour obtenir la liste des propriétés non compatibles avec les règles de blocage, consultez la section Propriétés de résultats non compatibles avec les règles de blocage.

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 de Security Command Center.

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

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

Preview — Data residency

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

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

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

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

Les règles Ignorer ne sont stockées que à l'emplacement où elles sont créées. Elles ne peuvent pas être affichées ni modifiées ailleurs.

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

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

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

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

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

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

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

Créer une règle de blocage

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

Pour obtenir un exemple de code permettant de créer une règle Ignorer, consultez la section Créer une règle Ignorer.

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

Console

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

   Accéder

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

   

3. Si la résidence des données est activée pour Security Command Center, utilisez le sélecteur d'emplacement situé juste en dessous du sélecteur de projet pour choisir l'emplacement de Security Command Center dans lequel créer la règle Ignorer. Exemple :

   

4. Cliquez sur Options Ignorer, puis sélectionnez Créer une règle Ignorer.

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

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

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

8. 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 les instructions de requête manuellement.

   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ésultat. La liste des sous-attributs disponibles s'affiche.
   2. Sélectionnez un sous-attribut. Un champ de sélection pour vos options d'évaluation s'affiche au-dessus d'une liste de valeurs de sous-attributs trouvées dans les résultats du panneau Résultats de la requête de résultats.
   3. Sélectionnez une option d'évaluation pour les valeurs du sous-attribut sélectionné. Pour en savoir plus sur les options d'évaluation, ainsi que sur les opérateurs et les fonctions qu'elles utilisent, consultez la section Opérateurs de requête dans le menu "Ajouter des filtres".
   4. Sélectionnez Apply (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.

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

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

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

11. Cliquez sur Enregistrer.

gcloud

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

   Activer Cloud Shell

   En bas de la fenêtre 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 Ignorer, exécutez la commande gcloud scc muteconfigs create:

   gcloud scc muteconfigs create CONFIG_ID \
   --PARENT=PARENT_ID \
   --location=LOCATION
   --description="RULE_DESCRIPTION" \
   --filter="FILTER"
   

   Remplacez les éléments suivants :

   • CONFIG_ID: nom de la règle Ignorer. L'ID doit contenir des caractères alphanumériques et des traits d'union, et comporter entre 1 et 63 caractères.
   • PARENT: champ d'application de la hiérarchie des ressources auquel s'applique la règle Ignorer (organization, folder ou project).
   • PARENT_ID: ID de l'organisation, du dossier ou du projet parent, spécifié au format organizations/123, folders/456 ou projects/789.

   • LOCATION: si la résidence des données est activée, spécifiez l'emplacement Security Command Center dans lequel créer la règle Ignorer. La configuration de la règle Ignorer est stockée et ne s'applique qu'aux résultats à cet emplacement.

     Si la résidence des données n'est pas activée, spécifier l'option --location crée la règle Ignorer à l'aide de la version 2 de l'API Security Command Center. La seule valeur valide pour cette option est global.

   • RULE_DESCRIPTION: description de la règle Ignorer de 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\"".

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

Go

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

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

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

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

Java

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

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

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

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

public class CreateMuteRule {

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

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

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

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

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

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

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

Python

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

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

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

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

    from google.cloud import securitycenter

    client = securitycenter.SecurityCenterClient()

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

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

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

API REST

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

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

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

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

  {
    "description": "RULE_DESCRIPTION",
    "filter": FILTER
  }

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

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

  {
    "description": "RULE_DESCRIPTION",
    "filter": FILTER
    "type": "STATIC"
  }

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: pour la version 2 uniquement, spécifie l'emplacement de Security Command Center auquel la règle Ignorer s'applique. Si le champ d'emplacement est omis, la valeur par défaut est global.
• MUTE_CONFIG_ID: nom de la règle Ignorer (entre 1 et 63 caractères)
• RULE_DESCRIPTION : description de la règle Ignorer (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\"".

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

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

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

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

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

Ignorer les propriétés des résultats

Cette section répertorie les propriétés de blocage des résultats et décrit leur impact sur les opérations de blocage :

• mute : défini sur UNDEFINED lorsque des résultats sont créés et changent dans les scénarios suivants :
  • MUTED : le résultat est ignoré manuellement ou par une règle de blocage
  • UNMUTED : un utilisateur réactive le résultat
• mute_update_time : heure à laquelle un résultat est ignoré ou réactivé
• mute_initiator : identifiant de la règle principale ou de blocage qui a ignoré un résultat

Arrêter les notifications pour les résultats ignorés

Si vous activez les notifications de résultats, les résultats ignorés qui correspondent à vos filtres de notification déclenchent toujours des notifications dans Pub/Sub.

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

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

Gérer les règles de blocage

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

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

Répertorier les règles de blocage

Vous pouvez répertorier les règles Ignorer 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é à répertorier les règles Ignorer 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 répertoriant les règles Ignorer, consultez la section Répertorier les règles Ignorer.

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

Console

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

   Accéder aux règles Ignorer

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

   

3. Si la résidence des données est activée pour Security Command Center, utilisez le sélecteur d'emplacement situé juste en dessous du sélecteur de projet afin de choisir l'emplacement de Security Command Center dans lequel la règle Ignorer est stockée. Exemple :

   

4. Dans la section Règles Ignorer, vous pouvez consulter les détails des règles Ignorer 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. Dans la console Google Cloud, activez Cloud Shell.

   Activer Cloud Shell

   En bas de la fenêtre 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 répertorier les règles Ignorer, exécutez la commande gcloud scc muteconfigs list:

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

   Remplacez les éléments suivants :

   • PARENT: organization, folder ou project parent pour lesquels répertorier les règles Ignorer
   • PARENT_ID: ID de l'organisation, du dossier ou du projet parent

   • LOCATION: si la résidence des données est activée, spécifiez l'emplacement Security Command Center dans lequel répertorier les règles de masquage.

     Si la résidence des données n'est pas activée, vous pouvez spécifier l'option --location pour lister les règles Ignorer à l'aide de la version 2 de l'API Security Command Center. La seule valeur valide pour cet indicateur est global.

Go

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

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

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

import (
	"context"
	"fmt"
	"io"

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

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

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

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

Java

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

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

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

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

public class ListMuteRules {

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

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

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

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

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

Python

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

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

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

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

    client = securitycenter.SecurityCenterClient()

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

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

API REST

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

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

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

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

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

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

Remplacez les éléments suivants :

• PARENT : ressource parente de votre règle de blocage (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation, du dossier ou du projet parent
• LOCATION: pour la version 2 uniquement, spécifie l'emplacement de Security Command Center pour lequel vous souhaitez répertorier les règles de masquage. Si le champ d'emplacement est omis, la valeur par défaut est 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 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 la section Afficher une règle Ignorer.

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

Console

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

   Accéder aux règles Ignorer

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

   

3. Si la résidence des données est activée pour Security Command Center, utilisez le sélecteur d'emplacement situé juste en dessous du sélecteur de projet pour choisir l'emplacement de la règle Ignorer dans Security Command Center. Exemple :

   

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

   Activer Cloud Shell

   En bas de la fenêtre 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 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, spécifiez l'emplacement Security Command Center dans lequel la règle Ignorer est stockée. La valeur par défaut est global.

     Si la résidence des données n'est pas activée, le fait de spécifier l'option --location permet d'obtenir la règle Ignorer à l'aide de la version 2 de l'API Security Command Center. La seule valeur valide pour cet indicateur est global.

Go

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

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

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

import (
	"context"
	"fmt"
	"io"

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

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

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

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

Java

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

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

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

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

public class GetMuteRule {

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

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

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

    getMuteRule(parentPath, muteConfigId);
  }

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

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

Python

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

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

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

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

    client = securitycenter.SecurityCenterClient()

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

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

API REST

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

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

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

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

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

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

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

Remplacez les éléments suivants :

• PARENT : ressource parente de votre règle de blocage (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation, du dossier ou du projet
• LOCATION: pour la version 2 uniquement, spécifie l'emplacement de Security Command Center dans lequel la règle Ignorer est stockée. Si le champ d'emplacement est omis, la valeur par défaut est global.
• CONFIG_ID : ID numérique de la règle de blocage

Mettre à jour les règles de blocage

Vous pouvez mettre à jour la description ou le filtre de résultat d'une règle Ignorer à 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 Ignorer. 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 de blocage mise à jour dans la console Google Cloud. Pour en savoir plus, consultez la section Réactiver les règles de blocage des résultats.

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 de Security Command Center.

Pour obtenir un exemple de code mettant à jour une règle Ignorer, consultez la section Mettre à jour une règle Ignorer.

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

Console

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

   Accéder aux règles Ignorer

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

3. Si la résidence des données est activée pour Security Command Center, utilisez le sélecteur d'emplacement situé juste en dessous du sélecteur de projet pour choisir l'emplacement de la règle Ignorer dans Security Command Center. Exemple :

   

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. Mettez à jour le filtre.

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

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

8. Cliquez sur Enregistrer.

gcloud

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

   Activer Cloud Shell

   En bas de la fenêtre 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 Ignorer, 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
   

   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: si la résidence des données est activée, spécifiez l'emplacement Security Command Center dans lequel la règle Ignorer est stockée. La valeur par défaut est global.

     Si la résidence des données n'est pas activée, spécifier l'option --location met à jour la configuration de la règle Ignorer à l'aide de la version 2 de l'API Security Command Center. La seule valeur valide pour cet indicateur est global.

   • RULE_DESCRIPTION : description de la règle Ignorer (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\"".

Go

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

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

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

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

Java

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

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

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

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

public class UpdateMuteRule {

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

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

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

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

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

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

Python

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

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

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

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

    client = securitycenter.SecurityCenterClient()

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

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

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

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

API REST

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

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

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

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

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

  {
    "description": "RULE_DESCRIPTION",
    "filter": "FILTER",
    "type": "STATIC"
  }

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

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

  {
    "description": "RULE_DESCRIPTION",
    "filter": "FILTER",
  }

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: pour la version 2 uniquement, spécifie l'emplacement de Security Command Center dans lequel la règle Ignorer est stockée. Si le champ d'emplacement est omis, la valeur par défaut est global.
• CONFIG_ID : ID numérique de la règle de blocage
• RULE_DESCRIPTION : description de la règle Ignorer (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\"".

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

La mise à jour des règles de blocage ne réactive pas automatiquement les résultats ignorés par les règles précédentes. Vous devez réactiver manuellement les résultats.

Supprimer les règles de blocage

Vous pouvez supprimer une règle Ignorer à l'aide de la console Google Cloud, de 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 Ignorer ne réactive pas automatiquement les résultats ignorés. Vous devez réactiver les résultats manuellement ou par programmation.
• 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 la section Supprimer une règle Ignorer.

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

Console

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

   Accéder aux règles Ignorer

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

   

3. Si la résidence des données est activée pour Security Command Center, utilisez le sélecteur d'emplacement situé juste en dessous du sélecteur de projet afin de choisir l'emplacement de Security Command Center dans lequel la règle Ignorer est stockée. Exemple :

   

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

5. Cliquez sur Supprimer.

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

gcloud

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

   Activer Cloud Shell

   En bas de la fenêtre 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 des règles Ignorer, exécutez la commande gcloud scc muteconfigs delete:

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

   Remplacez les éléments suivants :

   • MUTE_CONFIG_ID : ID de la configuration de blocage
   • PARENT : ressource parente de votre règle de blocage (organization, folder ou project)
   • PARENT_ID: ID de l'organisation, du dossier ou du projet

   • LOCATION: si la résidence des données est activée, spécifiez l'emplacement Security Command Center dans lequel la configuration de la règle Ignorer est stockée. La valeur par défaut est global.

     Si la résidence des données n'est pas activée, spécifier l'option --location supprime la règle Ignorer à l'aide de la version 2 de l'API Security Command Center. La seule valeur valide pour cette option est global.

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

Go

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

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

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

import (
	"context"
	"fmt"
	"io"

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

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

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

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

Java

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

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

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

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

public class DeleteMuteRule {

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

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

    deleteMuteRule(parentPath, muteConfigId);
  }

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

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

Python

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

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

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

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

    client = securitycenter.SecurityCenterClient()

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

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

API REST

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

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

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

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

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

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

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

Remplacez les éléments suivants :

• PARENT : ressource parente de votre règle de blocage (organizations, folders ou projects)
• PARENT_ID: ID de l'organisation, du dossier ou du projet
• LOCATION: pour la version 2 uniquement, spécifie l'emplacement de Security Command Center dans lequel la règle Ignorer est stockée. Si le champ d'emplacement est omis, la valeur par défaut est global.
• CONFIG_ID : ID numérique de la règle de blocage

Étapes suivantes

Découvrez comment filtrer les notifications de résultats.

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