Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Gestisci regole di disattivazione

Questo documento spiega come creare e gestire le regole di disattivazione per disattivare automaticamente i risultati in Security Command Center.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per gestire le regole di disattivazione, chiedi all'amministratore di concederti i seguenti ruoli IAM nell'organizzazione, nella cartella o nel progetto:

Visualizza regole di disattivazione:
- Visualizzatore amministratore Security Center (roles/securitycenter.adminViewer)
- Visualizzatore delle impostazioni del Centro sicurezza (roles/securitycenter.settingsViewer)
- Visualizzatore delle configurazioni di disattivazione del Centro sicurezza (roles/securitycenter.muteConfigsViewer)
Visualizza, crea, aggiorna ed elimina le regole di disattivazione:
- Amministratore Security Center (roles/securitycenter.admin)
- Editor amministratore Centro sicurezza (roles/securitycenter.adminEditor)
- Editor impostazioni Centro sicurezza (roles/securitycenter.settingsEditor)
- Security Center Mute Configurations Editor (roles/securitycenter.muteConfigsEditor)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Crea una regola di silenziamento

La tua organizzazione può creare un massimo di 1000 regole di disattivazione.

Ti consigliamo di utilizzare le regole di silenziamento dinamiche esclusivamente nelle configurazioni delle regole di silenziamento, perché sono più flessibili di quelle statiche. Per un confronto tra i tipi di regole di silenziamento, vedi Tipi di regole di silenziamento.

Per creare una regola di silenziamento, fai clic sulla scheda della procedura che vuoi utilizzare:

Console

Definisci la regola di silenziamento

Nella console Google Cloud , vai alla pagina Risultati.

Vai a Risultati
Seleziona un'organizzazione o un progetto.
Fai clic su Opzioni di disattivazione e poi seleziona Gestisci regole di disattivazione.
Fai clic su Crea regola di silenziamento.
Inserisci un ID regola di silenziamento.
Consigliato: inserisci una Descrizione che fornisca il contesto del motivo per cui i risultati sono disattivati.
Per confermare l'ambito della regola di silenziamento, controlla il valore di Risorsa padre.

(Facoltativo) Aggiungi una data di scadenza

Puoi aggiungere una data di scadenza alle regole di disattivazione dinamica.

Seleziona Disattiva temporaneamente i risultati corrispondenti.
Per configurare la data di scadenza della regola di silenziamento dinamica, seleziona il calendario e scegli una data e un'ora di almeno 24 ore successive a quella attuale.

Dopo la data di scadenza, la regola di silenziamento non ha effetto.

(Facoltativo) Limita la regola di silenziamento con una query

Se aggiungi una query, la regola di silenziamento si applica solo ai risultati che corrispondono alla query.

Per limitare la regola di silenziamento con una query, nella sezione Query sui risultati, fai clic su Aggiungi filtro.

Il menu Aggiungi filtro ti consente di scegliere attributi e valori delle vulnerabilità supportati.

Nel menu Seleziona filtro, seleziona un attributo del risultato o digita il suo nome nella casella Cerca attributi del risultato. Viene visualizzato un elenco dei sottoattributi disponibili.
Seleziona un attributo secondario. Viene visualizzato un campo di selezione in cui puoi creare l'istruzione della query utilizzando l'attributo secondario selezionato, un operatore di query e uno o più valori per l'attributo secondario.
Seleziona l'operatore e uno o più valori per l'attributo secondario dal riquadro. Per saperne di più sugli operatori di query e sulle funzioni che utilizzano, vedi Operatori di query nel menu Aggiungi filtri.

Se vuoi ricominciare, fai clic su Reimposta.
Fai clic su Applica.

Il menu si chiude e la query viene aggiornata.
Ripeti l'operazione finché la query sui risultati non contiene tutti gli attributi che ti interessano.

Per controllare i risultati della query, fai clic su Visualizza in anteprima i risultati corrispondenti. Una tabella elenca i risultati che corrispondono alla tua query.

Se la query non corrisponde ai risultati corretti, rivedila in base alle tue esigenze e visualizza di nuovo l'anteprima dei risultati. Ripeti questo passaggio finché non sei soddisfatto dei risultati.

Salva la regola di silenziamento

Fai clic su Salva. La console Google Cloud mostra un elenco delle regole di disattivazione.

gcloud

Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.
Per creare regole di disattivazione, esegui il comando gcloud scc muteconfigs create:
```
gcloud scc muteconfigs create CONFIG_ID \
  --PARENT=PARENT_ID \
  --location=LOCATION \
  --description="RULE_DESCRIPTION" \
  --filter="FILTER" \
  --type=MUTE_TYPE \
  --expiry-time=TIMESTAMP
```
Sostituisci quanto segue:
- CONFIG_ID: il nome della regola di silenziamento. L'ID deve utilizzare caratteri alfanumerici e trattini e deve essere compreso tra 1 e 63 caratteri.
- PARENT: l'ambito nella gerarchia delle risorse a cui si applica la regola di silenziamento, organization, folder o project.
- PARENT_ID: l'ID numerico dell'organizzazione, della cartella o del progetto padre oppure l'ID alfanumerico del progetto padre.
- LOCATION: la posizione di Security Command Center in cui gestire le regole di disattivazione; se la residenza dei dati è abilitata, utilizza eu, sa o us; altrimenti, utilizza il valore global.
- RULE_DESCRIPTION: una descrizione della regola di disattivazione di massimo 1024 caratteri.
- FILTER: l'espressione che definisci per filtrare i risultati. Ad esempio, per disattivare le risultanze di OPEN_FIREWALL, il filtro può essere FILTER="category=\"OPEN_FIREWALL\"".
- MUTE_TYPE: il tipo di regola di silenziamento che vuoi creare. I tipi di regole di silenziamento validi sono DYNAMIC e STATIC. Per impostazione predefinita, il tipo di regola di silenziamento è impostato su STATIC. Non puoi modificare il tipo di regola di silenziamento dopo averla creata.
- TIMESTAMP: si applica solo se stai creando una regola di silenziamento dinamica. La stringa di data e ora che indica la scadenza della regola di silenziamento dinamica. Il valore deve essere impostato su almeno un giorno nel futuro, altrimenti la richiesta verrà rifiutata. Per informazioni sui formati dell'ora, vedi gcloud topic datetimes. Quando una regola di disattivazione dinamica scade, viene rimossa da tutti i risultati corrispondenti. Per fare in modo che la regola di silenziamento dinamica agisca a tempo indeterminato sui risultati corrispondenti, ometti questo campo.
La risposta include l'ID della regola di silenziamento, che puoi utilizzare per visualizzare, aggiornare ed eliminare le regole di silenziamento, come descritto in Gestire le regole di silenziamento.

Terraform

Per creare una regola di silenziamento per un'organizzazione:

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

Crea una regola di silenziamento per una cartella:

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

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

Creare una regola di silenziamento per un progetto:

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

Go


import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

Java


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

public class CreateMuteRule {

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

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

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

    createMuteRule(projectId, location, muteConfigId);
  }

  // Creates a mute configuration in a project under a given location.
  public static void createMuteRule(String projectId, String location, String muteConfigId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

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

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

Python

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

    from google.cloud import securitycenter_v2

    client = securitycenter_v2.SecurityCenterClient()

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

    request = securitycenter_v2.CreateMuteConfigRequest()
    request.parent = parent_path + "/locations/" + location_id
    request.mute_config_id = mute_config_id
    request.mute_config = mute_config

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

REST

Nell'API Security Command Center, utilizza il metodo muteConfigs.create per creare una regola di silenziamento. Il corpo della richiesta è un'istanza di MuteConfig:

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

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

Sostituisci quanto segue:

PARENT: la risorsa principale per la regola di silenziamento (organizations, folders o projects)
PARENT_ID: l'ID dell'organizzazione, della cartella o del progetto padre
LOCATION: la posizione di Security Command Center in cui gestire le regole di disattivazione; se la residenza dei dati è abilitata, utilizza eu, sa o us; altrimenti, utilizza il valore global
MUTE_CONFIG_ID: il nome della regola di silenziamento (tra 1 e 63 caratteri)
RULE_DESCRIPTION: una descrizione della regola di disattivazione (max: 1024 caratteri)
FILTER: l'espressione che definisci per filtrare i risultati

Ad esempio, per disattivare i risultati OPEN_FIREWALL, il filtro può essere "category=\"OPEN_FIREWALL\"".
MUTE_TYPE: il tipo di regola di silenziamento che vuoi creare. I tipi di regole di silenziamento validi sono DYNAMIC e STATIC. Non puoi modificare il tipo di regola di silenziamento dopo averla creata.
TIMESTAMP: si applica solo se stai creando una regola di silenziamento dinamica. La stringa di data e ora che indica la scadenza della regola di silenziamento dinamica. Il valore deve essere impostato su almeno un giorno nel futuro, altrimenti la richiesta verrà rifiutata. Per informazioni sui formati dell'ora, vedi gcloud topic datetimes. Quando una regola di disattivazione dinamica scade, viene rimossa da tutti i risultati corrispondenti. Se vuoi che la regola di silenziamento dinamica agisca a tempo indeterminato sui risultati corrispondenti, ometti questo campo.

La risposta include l'ID configurazione di disattivazione, che puoi utilizzare per visualizzare, aggiornare ed eliminare le regole di disattivazione, come descritto in Gestire le regole di disattivazione.

I nuovi risultati che corrispondono esattamente al filtro vengono nascosti e l'attributo mute per i risultati è impostato su MUTED.

Proprietà dei risultati non supportate per le regole di disattivazione

Le regole di disattivazione non supportano tutte le proprietà dei risultati nei filtri. Espandi la sezione seguente per visualizzare l'elenco delle proprietà non supportate nei filtri delle regole di silenziamento.

Proprietà dei risultati non supportate

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

¹La proprietà gcpMetadata.folders contiene campi secondari supportati nei filtri di disattivazione.

Elenca regole di disattivazione

Puoi elencare le regole di disattivazione in un'organizzazione, una cartella o un progetto utilizzando la console Google Cloud , gcloud CLI o l'API Security Command Center.

La possibilità di elencare le regole di disattivazione per un determinato ambito dipende dalle autorizzazioni concesse ai tuoi ruoli IAM.

Se la residenza dei dati è abilitata per Security Command Center, anche l'ambito del comando list è limitato alla posizione di Security Command Center selezionata.

Per un esempio di codice campione che elenca le regole di silenziamento, consulta Elenco delle regole di silenziamento.

Per elencare le regole di disattivazione per un'organizzazione, una cartella o un progetto, fai clic sulla scheda della procedura che vuoi utilizzare:

Console

Nella console Google Cloud , vai alla scheda Regole di disattivazione nella pagina Impostazioni di Security Command Center.
Vai a Regole di disattivazione
Se necessario, seleziona il tuo progetto Google Cloud o la tua organizzazione.
Nella sezione Regole di disattivazione, vengono visualizzati i dettagli delle regole di disattivazione attive, tra cui:
- Nome: ID della regola di silenziamento
- Risorsa padre: la risorsa in cui si trova la regola di silenziamento
- Descrizione: la descrizione della regola di silenziamento, se disponibile
- Ultimo aggiornamento di: il preside che ha aggiornato per ultimo la norma
- Ultimo aggiornamento: la data e l'ora dell'ultimo aggiornamento della regola

gcloud

Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.
Per elencare le regole di disattivazione, esegui il comando gcloud scc muteconfigs list:
```
gcloud scc muteconfigs list --PARENT=PARENT_ID \
  --location=LOCATION
```
Sostituisci quanto segue:
- PARENT: l'organization, folder o project principale per cui elencare le regole di disattivazione
- PARENT_ID: l'ID dell'organizzazione, della cartella o del progetto padre
- LOCATION: la posizione di Security Command Center in cui gestire le regole di disattivazione; se la residenza dei dati è abilitata, utilizza eu, sa o us; altrimenti, utilizza il valore global

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

Java


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

public class ListMuteRules {

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

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

    listMuteRules(projectId, location);
  }

  // Lists all mute rules present under the resource type in the given location.
  public static void listMuteRules(String projectId, String location) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

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

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

Python

def list_mute_rules(parent: str, location_id: str) -> Dict:
    """
    Listing mute configs at organization level will return all the configs
    at the org, folder and project levels.
    Similarly, listing configs at folder level will list all the configs
    at the folder and project levels.
    Args:
        parent: Use any one of the following resource paths to list mute configurations:
                - organizations/{organization_id}
                - folders/{folder_id}
                - projects/{project_id}
        location_id: Gcp location id; example: 'global'
    Returns:
         Dict: returns the mute rule details
    """
    from google.cloud import securitycenter_v2

    client = securitycenter_v2.SecurityCenterClient()

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

REST

Nell'API Security Command Center, utilizza il metodo muteConfigs.list per elencare le regole di disattivazione:

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

Sostituisci quanto segue:

PARENT: la risorsa principale per la regola di silenziamento (organizations, folders o projects)
PARENT_ID: l'ID dell'organizzazione, della cartella o del progetto padre
LOCATION: la posizione di Security Command Center in cui gestire le regole di disattivazione; se la residenza dei dati è abilitata, utilizza eu, sa o us; altrimenti, utilizza il valore global

La risposta include i nomi, le descrizioni e gli ID di configurazione di disattivazione per le tue regole di disattivazione.

Visualizzare la configurazione di una regola di silenziamento

Puoi visualizzare la configurazione di una regola di silenziamento utilizzando la console Google Cloud , gcloud CLI o l'API Security Command Center.

Per un codice campione che recupera una configurazione di regola di silenziamento, consulta Visualizzare una regola di silenziamento.

Per visualizzare la configurazione di una regola di silenziamento, fai clic sulla scheda della procedura che vuoi utilizzare:

Console

Nella console Google Cloud , vai alla scheda Regole di disattivazione nella pagina Impostazioni di Security Command Center.

Vai a Regole di disattivazione
Se necessario, seleziona il tuo progetto Google Cloud o la tua organizzazione.
Nella sezione Regole di disattivazione, vedrai un elenco di regole di disattivazione.
Fai clic sul nome della regola che vuoi visualizzare.

Si apre una pagina con la configurazione della regola di disattivazione dell'audio.

gcloud

Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.
Per visualizzare la configurazione di una regola di silenziamento, esegui il comando gcloud scc muteconfigs get:
```
gcloud scc muteconfigs get MUTE_CONFIG_ID \
  --PARENT=PARENT_ID --location=LOCATION
```
Sostituisci quanto segue:
- MUTE_CONFIG_ID: l'ID della regola di silenziamento
- PARENT: la risorsa principale per la regola di silenziamento (organization, folder o project)
- PARENT_ID: l'ID dell'organizzazione, della cartella o del progetto
- LOCATION: la posizione di Security Command Center in cui gestire le regole di disattivazione; se la residenza dei dati è abilitata, utilizza eu, sa o us; altrimenti, utilizza il valore global

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

Java


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

public class GetMuteRule {

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

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

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

    getMuteRule(projectId, location, muteConfigId);
  }

  // Retrieves a mute configuration given its resource name.
  public static MuteConfig getMuteRule(String projectId, String location, String muteConfigId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {
      // Use appropriate `MuteConfigName` methods depending on the parent type.
      //  * organization -> MuteConfigName.ofOrganizationLocationMuteConfigName()
      //  * folder -> MuteConfigName.ofFolderLocationMuteConfigName()

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

Python

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

    client = securitycenter_v2.SecurityCenterClient()

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

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

REST

Nell'API Security Command Center, utilizza il metodo muteConfigs.get per restituire la configurazione di una regola di silenziamento:

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

Sostituisci quanto segue:

PARENT: la risorsa principale per la regola di silenziamento (organizations, folders o projects)
PARENT_ID: l'ID dell'organizzazione, della cartella o del progetto
LOCATION: la posizione di Security Command Center in cui gestire le regole di disattivazione; se la residenza dei dati è abilitata, utilizza eu, sa o us; altrimenti, utilizza il valore global
CONFIG_ID: l'ID numerico della regola di silenziamento

Aggiorna regole di silenziamento

Puoi aggiornare la descrizione o il filtro dei risultati di una regola di silenziamento utilizzando la console Google Cloud , gcloud CLI o l'API Security Command Center.

Non puoi modificare l'ID, l'organizzazione, la cartella o il progetto padre né la posizione di una regola di silenziamento. Per modificare uno di questi valori, devi creare una nuova regola di silenziamento.

Se in precedenza hai riattivato i risultati, questi vengono nuovamente silenziati se corrispondono a una regola di silenziamento aggiornata nella console Google Cloud . Per ulteriori informazioni, vedi Riattivare l'audio dei singoli risultati.

Per un codice campione che aggiorna una regola di silenziamento, vedi Aggiorna una regola di silenziamento.

Per aggiornare una regola di silenziamento, fai clic sulla scheda relativa alla procedura che vuoi utilizzare:

Console

Nella console Google Cloud , vai alla scheda Regole di disattivazione nella pagina Impostazioni di Security Command Center.
Vai a Regole di disattivazione
Seleziona il Google Cloud progetto o l'organizzazione che è la risorsa principale per la regola di silenziamento che vuoi modificare.
Fai clic sul nome della regola di silenziamento che vuoi modificare.

Se non hai selezionato il progetto o l'organizzazione appropriati, potresti visualizzare una nota che ti informa che non disponi dell'autorizzazione per modificare la regola di disattivazione.
Apporta modifiche alla regola di silenziamento.
(Facoltativo) Dopo aver aggiornato il filtro, fai clic su Visualizza l'anteprima dei risultati corrispondenti per visualizzare i risultati che corrispondono al filtro aggiornato. Viene caricata una tabella con i risultati che corrispondono alla nuova query.
Fai clic su Salva.

gcloud

Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.
Per aggiornare le regole di silenziamento, esegui il comando gcloud scc muteconfigs update:
```
gcloud scc muteconfigs update MUTE_CONFIG_ID \
    --PARENT=PARENT_ID \
    --location=LOCATION \
    --description=RULE_DESCRIPTION \
    --filter=FILTER \
    --type=MUTE_TYPE \
    --expiry-time=TIMESTAMP
```
Sostituisci quanto segue:
- MUTE_CONFIG_ID: l'ID della regola di silenziamento.
- PARENT: la risorsa principale per la regola di silenziamento (organization, folder o project).
- PARENT_ID: l'ID dell'organizzazione, della cartella o del progetto.
- LOCATION: la posizione di Security Command Center in cui gestire le regole di disattivazione; se la residenza dei dati è abilitata, utilizza eu, sa o us; altrimenti, utilizza il valore global.
- RULE_DESCRIPTION: una descrizione della regola di disattivazione (max: 1024 caratteri).
- FILTER: l'espressione che definisci per filtrare i risultati.
  
  Ad esempio, per disattivare i risultati OPEN_FIREWALL, il filtro potrebbe essere FILTER="category=\"OPEN_FIREWALL\"".
- MUTE_TYPE: il tipo di regola di silenziamento che stai aggiornando. I tipi di regole di silenziamento validi sono DYNAMIC e STATIC. Non puoi modificare il tipo di una regola di silenziamento dopo averla creata.
- TIMESTAMP: si applica solo se stai aggiornando una regola di silenziamento dinamica. La stringa di data e ora che indica la scadenza della regola di silenziamento dinamica. Il valore deve essere impostato su almeno un giorno nel futuro, altrimenti la richiesta verrà rifiutata. Per informazioni sui formati dell'ora, vedi gcloud topic datetimes. Quando una regola di disattivazione dinamica scade, viene rimossa da tutti i risultati corrispondenti. Se vuoi che la regola di silenziamento dinamica agisca a tempo indeterminato sui risultati corrispondenti, ometti questo campo.

Go


import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

Java


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

public class UpdateMuteRule {

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

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

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

    updateMuteRule(projectId, location, muteConfigId);
  }

  // Updates an existing mute configuration.
  // The following can be updated in a mute config: description and filter.
  public static void updateMuteRule(String projectId, String location, String muteConfigId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient securityCenterClient = SecurityCenterClient.create()) {

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

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

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

Python

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

    client = securitycenter_v2.SecurityCenterClient()

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

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

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

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

REST

Nell'API Security Command Center, utilizza il metodo muteConfigs.patch per aggiornare una regola di silenziamento. Il corpo della richiesta è un'istanza di MuteConfig:

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

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

Sostituisci quanto segue:

PARENT: la risorsa principale per la regola di silenziamento (organizations, folders o projects)
PARENT_ID: l'ID dell'organizzazione, della cartella o del progetto
LOCATION: la posizione di Security Command Center in cui gestire le regole di disattivazione; se la residenza dei dati è abilitata, utilizza eu, sa o us; altrimenti, utilizza il valore global
CONFIG_ID: l'ID numerico della regola di silenziamento
RULE_DESCRIPTION: una descrizione della regola di silenziamento (max. 1024 caratteri)
FILTER: l'espressione che definisci per filtrare i risultati
MUTE_TYPE: il tipo di regola di silenziamento che stai aggiornando. I tipi di regole di silenziamento validi sono DYNAMIC e STATIC. Non puoi modificare il tipo di una regola di silenziamento dopo averla creata.
TIMESTAMP: si applica solo se stai aggiornando una regola di silenziamento dinamica. La stringa di data e ora che indica la scadenza della regola di silenziamento dinamica. Il valore deve essere impostato su almeno un giorno nel futuro, altrimenti la richiesta verrà rifiutata. Per informazioni sui formati dell'ora, vedi gcloud topic datetimes. Quando una regola di disattivazione dinamica scade, viene rimossa da tutti i risultati corrispondenti. Se vuoi che la regola di silenziamento dinamica agisca a tempo indeterminato sui risultati corrispondenti, ometti questo campo.

Eliminare regole di disattivazione

Puoi eliminare una regola di silenziamento utilizzando la console Google Cloud , gcloud CLI o l'API Security Command Center.

Prima di eliminare le regole di disattivazione dell'audio, tieni presente quanto segue:

Non puoi recuperare le regole di disattivazione eliminate.
L'eliminazione delle regole di disattivazione statiche non riattiva automaticamente i risultati disattivati. Devi riattivare manualmente i risultati.
L'eliminazione delle regole di disattivazione dinamiche rimuove automaticamente la regola da tutti i risultati corrispondenti precedenti e li riattiva se non corrispondono ad altre regole.
I risultati futuri che corrispondono ai filtri nelle regole di disattivazione eliminate non vengono disattivati.

Per un esempio di codice campione che elimina una regola di silenziamento, vedi Eliminare una regola di silenziamento.

Per eliminare una regola di silenziamento, fai clic sulla scheda della procedura che vuoi utilizzare:

Console

Nella console Google Cloud , vai alla scheda Regole di disattivazione nella pagina Impostazioni di Security Command Center.
Vai a Regole di disattivazione
Se necessario, seleziona il tuo progetto Google Cloud o la tua organizzazione.
Fai clic sul nome della regola di silenziamento che vuoi eliminare.
Fai clic su Elimina.
Leggi la finestra di dialogo e, se le impostazioni sono corrette, fai clic su Elimina.

gcloud

Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.
Per eliminare le regole di disattivazione dell'audio, esegui il comando gcloud scc muteconfigs delete:
```
gcloud scc muteconfigs delete MUTE_CONFIG_ID \
  --PARENT=PARENT_ID --location=LOCATION
```
Sostituisci quanto segue:
- MUTE_CONFIG_ID: l'ID della configurazione di disattivazione
- PARENT: la risorsa principale per la regola di silenziamento (organization, folder o project)
- PARENT_ID: l'ID dell'organizzazione, della cartella o del progetto
- LOCATION: la posizione di Security Command Center in cui gestire le regole di disattivazione; se la residenza dei dati è abilitata, utilizza eu, sa o us; altrimenti, utilizza il valore global
Conferma la richiesta di eliminazione della regola di silenziamento.

Go


import (
	"context"
	"fmt"
	"io"

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

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

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

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

Java


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

public class DeleteMuteRule {

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

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

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

    deleteMuteRule(projectId, location, muteConfigId);
  }

  // Deletes a mute configuration given its resource name.
  // Note: Previously muted findings are not affected when a mute config is deleted.
  public static void deleteMuteRule(String projectId, String location, String muteConfigId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {
      // Use appropriate `MuteConfigName` methods depending on the parent type.
      // folder -> MuteConfigName.ofFolderLocationMuteConfigName()
      // organization -> MuteConfigName.ofOrganizationLocationMuteConfigName()
      client.deleteMuteConfig(
          MuteConfigName.ofProjectLocationMuteConfigName(projectId, location, muteConfigId));

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

Python

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

    client = securitycenter_v2.SecurityCenterClient()

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

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

REST

Nell'API Security Command Center, utilizza il metodo muteConfigs.delete per eliminare una regola di silenziamento:

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

Sostituisci quanto segue:

PARENT: la risorsa principale per la regola di silenziamento (organizations, folders o projects)
PARENT_ID: l'ID dell'organizzazione, della cartella o del progetto
LOCATION: la posizione di Security Command Center in cui gestire le regole di disattivazione; se la residenza dei dati è abilitata, utilizza eu, sa o us; altrimenti, utilizza il valore global
CONFIG_ID: l'ID numerico della regola di silenziamento

Gestisci regole di disattivazione Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Ruoli obbligatori

Crea una regola di silenziamento

Console

Definisci la regola di silenziamento

(Facoltativo) Aggiungi una data di scadenza

(Facoltativo) Limita la regola di silenziamento con una query

Salva la regola di silenziamento

gcloud

Terraform

Go

Java

Python

REST

Proprietà dei risultati non supportate per le regole di disattivazione

Proprietà dei risultati non supportate

Elenca regole di disattivazione

Console

gcloud

Go

Java

Python

REST

Visualizzare la configurazione di una regola di silenziamento

Console

gcloud

Go

Java

Python

REST

Aggiorna regole di silenziamento

Console

gcloud

Go

Java

Python

REST

Eliminare regole di disattivazione

Console

gcloud

Go

Java

Python

REST

Gestisci regole di disattivazione