Administrar reglas de silencio

Niveles de servicio Standard-legacy, Standard, Premium y Enterprise

El nivel de servicio Enterprise de Security Command Center se cerrará el 21 de mayo de 2027. Si tu organización usa el nivel de servicio Enterprise, se cambiará automáticamente al nivel de servicio Premium a partir del 21 de mayo de 2027. Si tienes preguntas, comunícate con tu representante de cuenta o con un Google Cloud especialista en ventas.

En este documento, se explica cómo crear y administrar reglas de silencio para silenciar automáticamente los hallazgos en Security Command Center.

Roles obligatorios

Para obtener los permisos que necesitas para administrar reglas de silencio, pídele a tu administrador que te otorgue los siguientes roles de IAM en la organización, la carpeta o el proyecto:

• Visualiza las reglas de silenciamiento:
  • Visualizador administrador del centro de seguridad (roles/securitycenter.adminViewer)
  • Visualizador de configuración del centro de seguridad (roles/securitycenter.settingsViewer)
  • Visualizador de la configuración de elementos silenciados del centro de seguridad (roles/securitycenter.muteConfigsViewer)
• Visualización, creación, actualización y eliminación de las reglas de silenciamiento:
  • Administrador del centro de seguridad (roles/securitycenter.admin)
  • Editor administrador del centro de seguridad (roles/securitycenter.adminEditor)
  • Editor de configuración del centro de seguridad (roles/securitycenter.settingsEditor)
  • Editor de parámetros de configuración de elementos silenciados del centro de seguridad (roles/securitycenter.muteConfigsEditor)

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Crea una regla de silenciamiento

Tu organización puede crear un máximo de 1,000 reglas de silenciamiento.

Te recomendamos usar reglas de silenciamiento dinámicas solo en los parámetros de configuración de las reglas de silenciamiento, ya que son más flexibles que las estáticas. Para comparar los tipos de reglas de silenciamiento, consulta Tipos de reglas de silenciamiento.

Para crear una regla de silenciamiento, haz clic en la pestaña del procedimiento que deseas usar:

Console

Define la regla de silenciamiento

1. En la consola de Google Cloud , ve a la página Problemas.

   Acceder a Hallazgos

2. Selecciona una organización o un proyecto.

3. Haz clic en Opciones para silenciar y, luego, selecciona Administrar reglas de silenciamiento.

4. Haz clic en Crear regla de silenciamiento.

5. Ingresa un ID de regla de silenciamiento.

6. Recomendado: Ingresa una Descripción que proporcione contexto sobre los motivos por los que se silencian los resultados.

7. Para confirmar el alcance de la regla de silenciamiento, verifica el valor del recurso principal.

Opcional: Agrega una fecha de vencimiento

Puedes agregar una fecha de vencimiento a las reglas de silenciamiento dinámicas.

1. Selecciona Silenciar los resultados coincidentes temporalmente.

2. Para configurar la fecha de vencimiento de la regla de silenciamiento dinámica, selecciona el calendario y elige una fecha y hora dentro de las próximas 24 horas como mínimo.

   Después de la fecha de vencimiento, la regla de silenciamiento no tiene efecto.

Opcional: Limita la regla de silenciamiento con una búsqueda

Si agregas una búsqueda, la regla de silenciamiento solo se aplicará a los hallazgos que coincidan con la búsqueda.

Para limitar la regla de silenciamiento con una búsqueda, en la sección Búsqueda de hallazgos, haz clic en Agregar filtro.

El menú Agregar filtro te permite elegir atributos y valores admitidos de resultados.

1. En el menú Seleccionar filtro, selecciona un atributo de resultado o escribe su nombre en el cuadro Buscar atributos de los hallazgos. Se mostrará una lista de los subatributos disponibles.
2. Selecciona un atributo secundario. Se mostrará un campo de selección en el que podrás compilar la instrucción de consulta con el subatributo que seleccionaste, un operador de consulta y uno o más valores para el subatributo.

3. Selecciona el operador y uno o más valores para el atributo secundario en el panel. Para obtener más información sobre los operadores de consulta y las funciones que utilizan, consulta Operadores de consulta en el menú Agregar filtros.

   Si quieres comenzar de nuevo, haz clic en Restablecer.

4. Haz clic en Aplicar.

   Se cerrará el menú y se actualizará tu búsqueda.

5. Repite hasta que la consulta de los resultados contenga todos los atributos que deseas.

Para verificar los resultados de la búsqueda, haz clic en Obtener una vista previa de los resultados de coincidencias. En una tabla, se enumeran los resultados que coinciden con tu búsqueda.

Si la búsqueda no coincide con los hallazgos correctos, revisa la búsqueda según sea necesario y vuelve a obtener una vista previa de los hallazgos. Repite este paso hasta que estés conforme con los resultados.

Guarda la regla de silenciamiento

Haz clic en Guardar. En la Google Cloud consola, se muestra una lista de tus reglas de silencio.

gcloud

1. En la consola de Google Cloud , activa Cloud Shell.

   Activa Cloud Shell

   En la parte inferior de la consola de Google Cloud , se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

2. Para crear reglas de silenciamiento, ejecuta el 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

   Reemplaza lo siguiente:

   • CONFIG_ID: Es el nombre de la regla de silenciamiento. El ID debe usar caracteres alfanuméricos y guiones, y tener entre 1 y 63 caracteres.
   • PARENT: Es el alcance en la jerarquía de recursos al que se aplica la regla de silenciamiento: organization, folder o project.
   • PARENT_ID: Es el ID numérico de la organización, la carpeta o el proyecto principal, o bien el ID alfanumérico del proyecto principal.
   • LOCATION: la ubicación de Security Command Center en la que se administrarán las reglas de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.
   • RULE_DESCRIPTION: Es una descripción de la regla de silenciamiento de no más de 1,024 caracteres.
   • FILTER: Es la expresión que defines para filtrar los resultados. Por ejemplo, para silenciar los resultados de OPEN_FIREWALL, tu filtro puede ser FILTER="category=\"OPEN_FIREWALL\"".
   • MUTE_TYPE: Es el tipo de regla de silenciamiento que deseas crear. Los tipos de reglas de silenciamiento válidos son DYNAMIC y STATIC. De forma predeterminada, el tipo de regla de silenciamiento se establece en STATIC. No puedes cambiar el tipo de una regla de silenciamiento después de crearla.
   • TIMESTAMP: Solo se aplica si creas una regla de silenciamiento dinámica. Es la cadena de fecha y hora que indica cuándo vence la regla de silenciamiento dinámico. El valor debe establecerse en al menos un día en el futuro, o se rechazará la solicitud. Para obtener información sobre los formatos de hora, consulta gcloud topic datetimes. Cuando vence una regla de silencio dinámico, se quita de todos los resultados coincidentes. Para que la regla de silenciamiento dinámica actúe de forma indefinida en los hallazgos coincidentes, omite este campo.

   La respuesta incluye el ID de la regla de silenciamiento, que puedes usar para ver, actualizar y borrar reglas de silenciamiento, como se describe en Administra reglas de silenciamiento.

Terraform

Sigue estos pasos para crear una regla de silenciamiento para una organización:

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"
}

Sigue estos pasos para crear una regla de silenciamiento para una carpeta:

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"
}

Sigue estos pasos para crear una regla de silenciamiento para un proyecto:

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

En la API de Security Command Center, usa el método muteConfigs.create para crear una regla de silenciamiento. El cuerpo de la solicitud es una instancia de MuteConfig:

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

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

Reemplaza lo siguiente:

• PARENT: El recurso superior de la regla de silenciamiento (organizations, folders o projects)
• PARENT_ID: Es el ID de la organización, la carpeta o el proyecto principal.
• LOCATION: Ubicación de Security Command Center en la que se administrarán las reglas de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.
• MUTE_CONFIG_ID: El nombre de la regla de silenciamiento (entre 1 y 63 caracteres)
• RULE_DESCRIPTION: Una descripción de la regla de silenciamiento (máx.: 1,024 caracteres)

• FILTER: Es la expresión que defines para filtrar los resultados.

  Por ejemplo, para silenciar los resultados de OPEN_FIREWALL, tu filtro puede ser "category=\"OPEN_FIREWALL\"".

• MUTE_TYPE: Es el tipo de regla de silenciamiento que deseas crear. Los tipos de reglas de silenciamiento válidos son DYNAMIC y STATIC. No puedes cambiar el tipo de una regla de silenciamiento después de crearla.

• TIMESTAMP: Solo se aplica si creas una regla de silenciamiento dinámica. Es la cadena de fecha y hora que indica cuándo vence la regla de silenciamiento dinámico. El valor debe establecerse en al menos un día en el futuro, o se rechazará la solicitud. Para obtener información sobre los formatos de hora, consulta gcloud topic datetimes. Cuando vence una regla de silencio dinámico, se quita de todos los resultados coincidentes. Si deseas que la regla de silenciamiento dinámica actúe de forma indefinida sobre los hallazgos coincidentes, omite este campo.

La respuesta incluye el ID de configuración de silenciamiento que puedes usar para ver, actualizar y borrar reglas de silenciamiento, como se describe en Administra reglas de silenciamiento.

Los resultados nuevos que coinciden con exactitud con el filtro se ocultan y el atributo mute de los resultados se establece en MUTED.

Propiedades de hallazgos no compatibles con reglas de silenciamiento

Las reglas de silenciamiento no admiten todas las propiedades de los resultados en los filtros. Expande la siguiente sección para ver la lista de propiedades que no se admiten en los filtros de reglas de silenciamiento.

Propiedades de los hallazgos no admitidas

• 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 propiedad gcpMetadata.folders contiene subcampos que se admiten en los filtros de silencio.

Muestra una lista de reglas de silenciamiento

Puedes enumerar las reglas de silenciamiento en una organización, una carpeta o un proyecto con la Google Cloud consola, la gcloud CLI o la API de Security Command Center.

Tu capacidad para enumerar reglas de silenciamiento para un alcance determinado depende de los permisos que se otorgan a tus roles de IAM.

Si la residencia de datos está habilitada para Security Command Center, el alcance del comando list también se limita a la ubicación de Security Command Center seleccionada.

Para ver un código de muestra que enumera las reglas de silenciamiento, consulta Enumera reglas de silenciamiento.

Para enumerar las reglas de silenciamiento de una organización, una carpeta o un proyecto, haz clic en la pestaña del procedimiento que deseas usar:

Console

1. En la consola de Google Cloud , ve a la pestaña Reglas de silencio en la página Configuración de Security Command Center.

   Ir a las reglas de silencio

2. Si es necesario, selecciona tu Google Cloud organización o proyecto.

3. En la sección Reglas de silencio, verás detalles de las reglas de silenciamiento activas, incluidos los siguientes:

   • Nombre: ID de la regla de silenciamiento
   • Recurso superior: El recurso en el que reside la regla de silenciamiento
   • Descripción: La descripción de la regla de silenciamiento, si está disponible
   • Última actualización por: La principal que actualizó por última vez la regla
   • Última actualización: La fecha y hora en que se actualizó la regla por última vez

gcloud

1. En la consola de Google Cloud , activa Cloud Shell.

   Activa Cloud Shell

   En la parte inferior de la consola de Google Cloud , se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

2. Para enumerar las reglas de silenciamiento, ejecuta el comando gcloud scc muteconfigs list:

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

   Reemplaza lo siguiente:

   • PARENT: Es el organization, folder o project principal para el que se enumerarán las reglas de silenciamiento.
   • PARENT_ID: Es el ID de la organización, la carpeta o el proyecto principal.
   • LOCATION: Ubicación de Security Command Center en la que se administrarán las reglas de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor 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

En la API de Security Command Center, usa el método muteConfigs.list para enumerar las reglas de silenciamiento:

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

Reemplaza lo siguiente:

• PARENT: El recurso superior de la regla de silenciamiento (organizations, folders o projects)
• PARENT_ID: Es el ID de la organización, la carpeta o el proyecto principal.
• LOCATION: Ubicación de Security Command Center en la que se administrarán las reglas de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.

La respuesta incluye los nombres, las descripciones y los ID de configuración de silenciamiento de tus reglas de silenciamiento.

Cómo ver la configuración de una regla de silenciamiento

Puedes ver la configuración de una regla de silenciamiento con la consola Google Cloud , la gcloud CLI o la API de Security Command Center.

Para ver un código de muestra que recupera la configuración de una regla de silenciamiento, consulta Visualiza una regla de silenciamiento.

Para ver la configuración de una regla de silenciamiento, haz clic en la pestaña del procedimiento que deseas usar:

Console

1. En la consola de Google Cloud , ve a la pestaña Reglas de silencio en la página Configuración de Security Command Center.

   Ir a las reglas de silencio

2. Si es necesario, selecciona tu Google Cloud organización o proyecto.

3. En la sección Reglas de silencio, verás una lista de reglas de silenciamiento.

4. Haz clic en el nombre de la regla que deseas ver.

   Se abrirá una página con la configuración de la regla de silenciamiento.

gcloud

1. En la consola de Google Cloud , activa Cloud Shell.

   Activa Cloud Shell

   En la parte inferior de la consola de Google Cloud , se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

2. Para ver la configuración de una regla de silenciamiento, ejecuta el comando gcloud scc muteconfigs get:

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

   Reemplaza lo siguiente:

   • MUTE_CONFIG_ID: Es el ID de la regla de silenciamiento
   • PARENT: El recurso superior de la regla de silenciamiento (organization, folder o project)
   • PARENT_ID: Es el ID de la organización, la carpeta o el proyecto.
   • LOCATION: Ubicación de Security Command Center en la que se administrarán las reglas de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor 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

En la API de Security Command Center, usa el método muteConfigs.get para devolver la configuración de una regla de silenciamiento:

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

Reemplaza lo siguiente:

• PARENT: El recurso superior de la regla de silenciamiento (organizations, folders o projects)
• PARENT_ID: Es el ID de la organización, la carpeta o el proyecto.
• LOCATION: Ubicación de Security Command Center en la que se administrarán las reglas de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.
• CONFIG_ID: Es el ID numérico de la regla de silenciamiento

Actualiza las reglas de silenciamiento

Puedes actualizar la descripción o el filtro de hallazgos de una regla de silenciamiento con la consola, la gcloud CLI o la API de Security Command Center. Google Cloud

No puedes cambiar el ID, la organización, la carpeta o el proyecto principal, ni la ubicación de una regla de silenciamiento. Para cambiar cualquiera de estos valores, debes crear una regla de silenciamiento nueva.

Si dejaste de silenciar los resultados, se volverán a silenciar si coinciden con una regla de silenciamiento que se actualizó en la consola de Google Cloud . Para obtener más información, consulta Cómo dejar de silenciar resultados individuales.

Nota: Los hallazgos que pertenecen a la clase de resultado SCC errors informan problemas que impiden que Security Command Center funcione según lo previsto. Por este motivo, no se pueden silenciar los resultados de los errores. Para obtener más información, consulta Descripción general de los errores de Security Command Center.

Para ver un código de muestra que actualiza una regla de silenciamiento, consulta Actualiza una regla de silenciamiento.

Para actualizar una regla de silenciamiento, haz clic en la pestaña del procedimiento que deseas usar:

Console

1. En la consola de Google Cloud , ve a la pestaña Reglas de silencio en la página Configuración de Security Command Center.

   Ir a las reglas de silencio

2. Selecciona el Google Cloud proyecto o la organización que es el recurso principal de la regla de silenciamiento que deseas modificar.

3. Haz clic en el nombre de la regla de silenciamiento que deseas modificar.

   Si no seleccionaste el proyecto o la organización adecuados, es posible que veas una nota en la que se te informe que no tienes permiso para modificar la regla de silenciamiento.

4. Realiza cambios en la regla de silenciamiento.

5. Opcional: Después de actualizar el filtro, haz clic en Obtener una vista previa de los resultados de coincidencias para ver los resultados que coinciden con el filtro actualizado. Se cargará una tabla con los resultados que coinciden con la consulta nueva.

6. Haz clic en Guardar.

gcloud

1. En la consola de Google Cloud , activa Cloud Shell.

   Activa Cloud Shell

   En la parte inferior de la consola de Google Cloud , se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

2. Para actualizar las reglas de silenciamiento, ejecuta el 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
   

   Reemplaza lo siguiente:

   • MUTE_CONFIG_ID: Es el ID de la regla de silenciamiento.
   • PARENT: Es el recurso principal de la regla de silenciamiento (organization, folder o project).
   • PARENT_ID: Es el ID de la organización, la carpeta o el proyecto.
   • LOCATION: la ubicación de Security Command Center en la que se administrarán las reglas de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.
   • RULE_DESCRIPTION: Es una descripción de la regla de silenciamiento (máx.: 1,024 caracteres).

   • FILTER: Es la expresión que defines para filtrar los resultados.

     Por ejemplo, para silenciar los resultados de OPEN_FIREWALL, tu filtro podría ser FILTER="category=\"OPEN_FIREWALL\"".

   • MUTE_TYPE: Es el tipo de regla de silenciamiento que deseas actualizar. Los tipos de reglas de silenciamiento válidos son DYNAMIC y STATIC. No puedes cambiar el tipo de una regla de silenciamiento después de crearla.

   • TIMESTAMP: Solo se aplica si actualizas una regla de silenciamiento dinámica. Es la cadena de fecha y hora que indica cuándo vence la regla de silenciamiento dinámico. El valor debe establecerse en al menos un día en el futuro, o se rechazará la solicitud. Para obtener información sobre los formatos de hora, consulta gcloud topic datetimes. Cuando vence una regla de silencio dinámico, se quita de todos los resultados coincidentes. Si deseas que la regla de silenciamiento dinámica actúe de forma indefinida sobre los hallazgos coincidentes, omite este 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

En la API de Security Command Center, usa el método muteConfigs.patch para actualizar una regla de silenciamiento. El cuerpo de la solicitud es una instancia de MuteConfig:

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

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

Reemplaza lo siguiente:

• PARENT: El recurso superior de la regla de silenciamiento (organizations, folders o projects)
• PARENT_ID: Es el ID de la organización, la carpeta o el proyecto.
• LOCATION: Ubicación de Security Command Center en la que se administrarán las reglas de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.
• CONFIG_ID: Es el ID numérico de la regla de silenciamiento
• RULE_DESCRIPTION: Una descripción de la regla de silenciamiento (máximo: 1,024 caracteres)
• FILTER: Es la expresión que defines para filtrar los resultados
• MUTE_TYPE: Es el tipo de regla de silenciamiento que deseas actualizar. Los tipos de reglas de silenciamiento válidos son DYNAMIC y STATIC. No puedes cambiar el tipo de una regla de silenciamiento después de crearla.
• TIMESTAMP: Solo se aplica si actualizas una regla de silenciamiento dinámica. Es la cadena de fecha y hora que indica cuándo vence la regla de silenciamiento dinámico. El valor debe establecerse en al menos un día en el futuro, o se rechazará la solicitud. Para obtener información sobre los formatos de hora, consulta gcloud topic datetimes. Cuando vence una regla de silencio dinámico, se quita de todos los resultados coincidentes. Si deseas que la regla de silenciamiento dinámica actúe de forma indefinida sobre los hallazgos coincidentes, omite este campo.

Borra reglas de silenciamiento

Puedes borrar una regla de silenciamiento con la consola de Google Cloud , la gcloud CLI o la API de Security Command Center.

Antes de borrar reglas de silenciamiento, debes comprender lo siguiente:

• No puedes recuperar las reglas de silenciamiento borradas.
• Si borras las reglas de silenciamiento estáticas, no se dejan de silenciar automáticamente los resultados que están silenciados. Debes dejar de silenciar los resultados de manera manual o programática.
• Si borras las reglas de silenciamiento dinámicas, se quitarán automáticamente de todos los hallazgos que coincidían anteriormente y se dejarán de silenciar si no coinciden con ninguna regla adicional.
• No se silencian los resultados futuros que coincidan con los filtros de las reglas de silenciamiento borradas.

Para ver un código de muestra que borra una regla de silenciamiento, consulta Borra una regla de silenciamiento.

Para borrar una regla de silenciamiento, haz clic en la pestaña del procedimiento que deseas usar:

Console

1. En la consola de Google Cloud , ve a la pestaña Reglas de silencio en la página Configuración de Security Command Center.

   Ir a las reglas de silencio

2. Si es necesario, selecciona tu Google Cloud organización o proyecto.

3. Haz clic en el nombre de la regla de silenciamiento que deseas borrar.

4. Haz clic en Borrar.

5. Lee el cuadro de diálogo y, si estás de acuerdo, haz clic en Borrar.

gcloud

1. En la consola de Google Cloud , activa Cloud Shell.

   Activa Cloud Shell

   En la parte inferior de la consola de Google Cloud , se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

2. Para borrar reglas de silenciamiento, ejecuta el comando gcloud scc muteconfigs delete:

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

   Reemplaza lo siguiente:

   • MUTE_CONFIG_ID: Es el ID de la configuración de silenciamiento
   • PARENT: El recurso superior de la regla de silenciamiento (organization, folder o project)
   • PARENT_ID: Es el ID de la organización, la carpeta o el proyecto.
   • LOCATION: Ubicación de Security Command Center en la que se administrarán las reglas de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.

3. Confirma tu solicitud para borrar la regla de silenciamiento.

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

En la API de Security Command Center, usa el método muteConfigs.delete para borrar una regla de silenciamiento:

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

Reemplaza lo siguiente:

• PARENT: El recurso superior de la regla de silenciamiento (organizations, folders o projects)
• PARENT_ID: Es el ID de la organización, la carpeta o el proyecto.
• LOCATION: Ubicación de Security Command Center en la que se administrarán las reglas de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.
• CONFIG_ID: Es el ID numérico de la regla de silenciamiento