Silenciar resultados en Security Command Center

En esta página se explica cómo reducir el volumen de resultados que recibe en Security Command Center silenciando resultados.

Si silencias una detección, se ocultará de la vista predeterminada de las detecciones en laGoogle Cloud consola. Puedes silenciar manualmente o mediante programación las detecciones y crear filtros para silenciar automáticamente las detecciones actuales y futuras en función de los criterios que especifiques.

Los servicios de detección de Security Command Center proporcionan evaluaciones de seguridad amplias de tu Google Cloud implementación, pero es posible que algunos hallazgos no sean adecuados o relevantes para tu organización o tus proyectos. Un gran volumen de resultados también puede dificultar que tus analistas de seguridad identifiquen y corrijan de forma eficaz los riesgos más críticos. Al silenciar resultados, ahorras tiempo, ya que no tienes que revisar ni responder a los resultados de seguridad de los recursos aislados o que se ajustan a los parámetros empresariales aceptables.

Silenciar resultados tiene varias ventajas con respecto a inhabilitar detectores:

  • Puedes crear filtros personalizados para ajustar qué resultados se silencian.
  • Puedes usar reglas de silencio para silenciar resultados de forma temporal o indefinida.
  • Silenciar resultados no impide que se analicen los recursos subyacentes. Las conclusiones se siguen generando, pero permanecen ocultas hasta que decides verlas.

Permisos

Para silenciar resultados, debes tener uno de los siguientes roles de gestión de identidades y accesos (IAM) a nivel de organización, carpeta o proyecto:

  • Ver reglas de silencio:
    • Lector de administración del centro de seguridad (roles/securitycenter.adminViewer)
    • Lector de configuración del centro de seguridad (roles/securitycenter.settingsViewer)
    • Visor de configuraciones de silencio del Centro de Seguridad (roles/securitycenter.muteConfigsViewer)
  • Para ver, crear, actualizar y eliminar reglas de silencio, sigue estos pasos:
    • Administrador del Centro de Seguridad (roles/securitycenter.admin)
    • Editor de administración del centro de seguridad (roles/securitycenter.adminEditor)
    • Editor de configuración del centro de seguridad (roles/securitycenter.settingsEditor)
    • Editor de configuraciones de silencio del Centro de Seguridad (roles/securitycenter.muteConfigsEditor)
  • Silenciar hallazgos manualmente:
    • Editor de resultados del centro de seguridad (roles/securitycenter.findingsEditor)

También puedes crear y conceder roles personalizados con algunos o todos los permisos siguientes:

  • Permisos de lectura de reglas de silencio
    • securitycenter.muteconfigs.get
    • securitycenter.muteconfigs.list
  • Permisos de escritura de reglas de silencio
    • securitycenter.muteconfigs.create
    • securitycenter.muteconfigs.update
    • securitycenter.muteconfigs.delete
  • Buscar permisos de escritura
    • securitycenter.findings.setMute
    • securitycenter.findings.bulkMuteUpdate

Tu capacidad para silenciar resultados se ajusta a los roles concedidos a nivel de organización, carpeta o proyecto. Puedes silenciar resultados en carpetas o proyectos específicos, así como restringir la capacidad de otros usuarios para silenciar resultados en función del acceso que se les haya concedido. Por ejemplo, si tienes acceso a un solo proyecto, solo puedes silenciar las detecciones de ese proyecto. Si tienes acceso a una carpeta, puedes silenciar las detecciones de cualquier subcarpeta o proyecto que contenga.

Para obtener más información sobre los roles de Security Command Center, consulta Control de acceso.

Crear y gestionar reglas de silencio

Las reglas de silencio son configuraciones de Security Command Center que usan filtros que creas para silenciar automáticamente los hallazgos futuros y actuales en función de los criterios que especifiques. Puedes crear filtros con reglas de silencio estáticas o dinámicas.

Las reglas de silencio estáticas silencian las detecciones futuras indefinidamente. Las reglas de silencio dinámico silencian futuros y actuales hallazgos temporalmente hasta una fecha especificada o indefinidamente hasta que un hallazgo deje de coincidir con la configuración.

Tipos de reglas de silencio

Security Command Center admite configuraciones de reglas de silencio estáticas y dinámicas. Aunque puedes usar reglas de silencio estáticas y dinámicas al mismo tiempo, no te lo recomendamos. Las reglas de silencio estáticas anulan las reglas de silencio dinámicas cuando se aplican a la misma detección. Por lo tanto, las reglas de silenciado dinámico no funcionarán como deberían, lo que puede generar confusión al gestionar las detecciones. Por lo tanto, te recomendamos que uses un solo tipo de regla de silencio.

A menos que ya estés usando reglas de silencio estáticas, te recomendamos que uses exclusivamente reglas de silencio dinámicas, ya que ofrecen más flexibilidad.

En la siguiente tabla se ofrece una comparación general de los dos tipos de reglas de silenciar. Para obtener más información, consulta las secciones Reglas de silencio estáticas y Reglas de silencio dinámicas.

Reglas de silencio estáticas Reglas de silencio dinámicas
Actuar indefinidamente en función de los resultados. Puede actuar sobre un resultado de forma temporal con un tiempo de vencimiento o indefinidamente si no se establece ningún tiempo de vencimiento.
No se aplica a las detecciones que ya haya. Se aplica a las detecciones nuevas y las que ya existían.
Tienen prioridad sobre las reglas de silencio dinámico. Tienen una prioridad inferior y se anulan mediante reglas de silencio estáticas cuando ambos tipos se aplican a un hallazgo.

Reglas de silencio estáticas

  • Las reglas de silencio estáticas actúan indefinidamente. Cuando un resultado coincide con tu configuración de silencio estático, Security Command Center asigna automáticamente el valor mute a la propiedad MUTED del resultado hasta que lo cambies manualmente.
  • Las reglas de silencio estáticas no tienen ningún efecto en las detecciones que ya haya, a menos que se creen mediante la consola Google Cloud , en cuyo caso la regla silenciará retroactivamente las detecciones que ya haya. De lo contrario, solo se aplicarán a las detecciones que se creen o actualicen después de definir la regla. Si también quieres silenciar las detecciones existentes similares sin usar la consola, usa los mismos filtros para silenciar detecciones en bloque. Google Cloud
  • Las reglas de silencio estáticas tienen prioridad sobre las dinámicas. Por lo tanto, todas las nuevas detecciones que coincidan con una regla de silencio estática definida se considerarán silenciadas, aunque también coincidan con una regla de silencio dinámica definida.

Reglas de silencio dinámicas

  • Las reglas de silencio dinámico pueden aplicarse a un resultado de forma temporal con un tiempo de vencimiento o indefinidamente si no se establece ningún tiempo de vencimiento. Cuando un resultado nuevo o ya existente coincida con tu configuración de silencio dinámico, Security Command Center asignará automáticamente el valor MUTED a la propiedad mute del resultado hasta la fecha de vencimiento especificada o hasta que haya cambios en el resultado o en la propia configuración. Cuando caduca una regla de silencio dinámica, Security Command Center elimina la regla del resultado. Si el resultado no coincide con ninguna otra regla de silencio dinámico, la propiedad mute se restablece automáticamente a UNDEFINED.
  • Las reglas de silencio dinámico se aplican automáticamente a las detecciones que coincidan con tu configuración, así como a las detecciones que se creen o actualicen.
  • Las reglas de silencio dinámicas tienen una prioridad inferior y se anulan por las reglas de silencio estáticas cuando ambos tipos se aplican a un hallazgo.

Te recomendamos que uses exclusivamente reglas de silencio dinámicas. La posibilidad de silenciar y reactivar automáticamente los resultados de forma temporal hace que las reglas de silencio dinámicas sean una opción más flexible que las reglas de silencio estáticas.

Si utilizas reglas de silencio estáticas para reducir el número de resultados que revisas manualmente y quieres migrar a reglas de silencio dinámicas, consulta el artículo Migrar de reglas de silencio estáticas a dinámicas.

Ámbito de las reglas de silencio

Ten en cuenta el ámbito de una regla de silencio al crear filtros.

Por ejemplo, si se escribe un filtro para silenciar los resultados de Project A, pero el filtro se crea en Project B, es posible que no coincida con ningún resultado.

Del mismo modo, si la residencia de datos está habilitada, el ámbito de una regla de silencio se limita a la ubicación de Security Command Center en la que se crea la regla. Por ejemplo, si creas una regla de silencio en la ubicación Estados Unidos (us), no se silenciarán las detecciones almacenadas en la ubicación Unión Europea (eu).

Para obtener más información sobre cómo crear filtros, consulta el artículo Filtrar notificaciones.

Restricciones de las reglas de silencio

Las reglas de silencio no admiten todas las propiedades de los resultados. Para ver una lista de las propiedades que no admiten las reglas de silencio, consulta Propiedades de resultados no admitidas en reglas de silencio.

Puedes crear, ver, actualizar y eliminar reglas de silencio en función del ámbito de tus roles de gestión de identidades y accesos. Con los roles a nivel de organización, verás las reglas de silenciar de todas las carpetas y proyectos de la organización. Si tienes roles a nivel de carpeta, puedes acceder a las reglas de silenciar y gestionarlas en carpetas específicas, así como en todas las subcarpetas y proyectos que contengan. Los roles a nivel de proyecto te permiten gestionar las reglas de silencio en proyectos específicos.

Security Command Center Premium permite asignar roles a nivel de organización, carpeta y proyecto. Security Command Center Standard solo permite asignar roles a nivel de organización. Para obtener más información, consulta Control de acceso.

Residencia de datos y reglas de silencio

Si la residencia de datos está habilitada, las configuraciones que definen las reglas de silencio (recursos muteConfig) están sujetas a los controles de residencia de datos y se almacenan en una ubicación de Security Command Center que elijas.

Para aplicar una regla de silencio a los resultados de una ubicación de Security Command Center, debes crearla en la misma ubicación que los resultados a los que se aplica.

Como los filtros que se usan en las reglas de silenciar pueden contener datos sujetos a controles de residencia, asegúrate de especificar la ubicación correcta antes de crearlos. Security Command Center no restringe la ubicación en la que creas reglas de silencio o exportaciones de streaming.

Las reglas de silencio solo se almacenan en la ubicación en la que se crean y no se pueden ver ni editar en otras ubicaciones.

Una vez que hayas creado una regla de silencio, no podrás cambiar su ubicación. Para cambiar la ubicación, debes eliminar la regla de silencio y volver a crearla en la nueva ubicación.

Para saber cómo usar Security Command Center cuando la residencia de datos está habilitada, consulta Endpoints regionales de Security Command Center.

Crear una regla de silencio

Tu organización puede crear un máximo de 1000 reglas de silencio.

Te recomendamos que uses reglas de silencio dinámicas exclusivamente en tus configuraciones de reglas de silencio, ya que son más flexibles que las reglas de silencio estáticas. Para ver una comparación de los tipos de reglas de silenciar, consulta Tipos de reglas de silenciar.

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

Consola

Para crear una regla de silencio mediante la consola de Google Cloud , haz clic en la pestaña de tu nivel de servicio:

Estándar o Premium

  1. En la Google Cloud consola, ve a la página Resultados de Security Command Center.

    Ir a Resultados

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

  3. Haz clic en Opciones de silencio y, a continuación, selecciona Gestionar reglas de silencio.

  4. Haz clic en Crear regla de silencio.

  5. Introduce un ID de regla de silencio. Este valor es obligatorio.

  6. Introduce una descripción de la regla de silencio que explique por qué se han silenciado los resultados. Este valor es opcional, pero se recomienda.

  7. Para confirmar el ámbito de la regla de silencio, comprueba el valor de Recurso principal.

  8. Si vas a crear una regla de silencio sin fecha de vencimiento, ve al paso siguiente. Si vas a crear una regla de silencio dinámico para silenciar temporalmente las detecciones, sigue estos pasos:

    1. Seleccione la casilla Silenciar coincidencias temporalmente.
    2. Selecciona o introduce la fecha de vencimiento de la regla de silencio dinámica. Este valor indica durante cuánto tiempo la regla silenciará las coincidencias.

  9. En el campo Consulta de resultados, crea tus instrucciones de consulta haciendo clic en Añadir filtro. También puedes escribir las instrucciones de consulta manualmente.

    El cuadro de diálogo Seleccionar filtro le permite elegir atributos y valores de búsqueda admitidos.

    1. Seleccione un atributo de la detección o escriba su nombre en el cuadro Buscar atributos de la detección. Se muestra una lista de los subatributos disponibles.
    2. Selecciona un subatributo. Se muestra un campo de selección en el que puedes crear la instrucción de consulta con el subatributo que has seleccionado, un operador de consulta y uno o varios valores del subatributo.
    3. Seleccione el operador y uno o varios valores del subatributo en el panel. Para obtener más información sobre los operadores de consulta y las funciones que utilizan, consulta Operadores de consulta del menú Añadir filtros.
    4. Haz clic en Aplicar.

      El cuadro de diálogo se cierra y la consulta se actualiza.

    5. Repita el proceso hasta que la consulta de resultados contenga todos los atributos que quiera.

  10. Haga clic en Ver coincidencias. En una tabla se muestran los resultados que coinciden con tu consulta.

  11. Haz clic en Guardar.

Empresa

  1. En la Google Cloud consola, ve a la página Resultados de Security Command Center.

    Ir a Resultados

  2. Si es necesario, selecciona tu Google Cloud proyecto u organización.
  3. Selecciona al menos un resultado.
  4. Haz clic en Opciones de silencio y, a continuación, selecciona Ver reglas de silencio.
  5. Haz clic en Crear regla de silencio.
  6. Introduce un ID de regla de silencio. Este valor es obligatorio.
  7. Introduce una descripción de la regla de silencio que explique por qué se han silenciado los resultados. Este valor es opcional, pero se recomienda.
  8. Confirma el ámbito de la regla de silencio comprobando el valor de Recurso principal.
  9. Si vas a crear una regla de silencio sin fecha de vencimiento, continúa con el siguiente paso. Si vas a crear una regla de silencio dinámicopara silenciar temporalmente las detecciones, sigue estos pasos:
    1. Seleccione la casilla Silenciar coincidencias temporalmente.
    2. Selecciona o introduce la fecha de vencimiento de la regla de silencio dinámica. Este valor indica durante cuánto tiempo la regla silenciará las coincidencias.
  10. En el campo Consulta de resultados, crea tus instrucciones de consulta haciendo clic en Añadir filtro. También puedes escribir las instrucciones de consulta manualmente.

    El cuadro de diálogo Seleccionar filtro le permite elegir atributos y valores de búsqueda admitidos.

    1. Seleccione un atributo de la detección o escriba su nombre en el cuadro Buscar atributos de la detección. Se muestra una lista de los subatributos disponibles.
    2. Selecciona un subatributo. Se muestra un campo de selección en el que puedes crear la instrucción de consulta con el subatributo que has seleccionado, un operador de consulta y uno o varios valores del subatributo.
    3. Seleccione el operador y uno o varios valores del subatributo en el panel. Para obtener más información sobre los operadores de consulta y las funciones que utilizan, consulta Operadores de consulta del menú Añadir filtros.
    4. Haz clic en Aplicar.

      El cuadro de diálogo se cierra y la consulta se actualiza.

    5. Repita el proceso hasta que la consulta de resultados contenga todos los atributos que quiera.
  11. Haga clic en Ver coincidencias. En una tabla se muestran los resultados que coinciden con tu consulta.
  12. Haz clic en Guardar.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Para crear reglas de silencio, 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

    Haz los cambios siguientes:

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

    La respuesta incluye el ID de la regla de silenciar, que puedes usar para ver, actualizar y eliminar reglas de silenciar, tal como se describe en el artículo Gestionar reglas de silenciar.

    3. Terraform

    Para crear una regla de silencio para una organización, haz lo siguiente:

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

    Para crear una regla de silencio para una carpeta, sigue estos pasos:

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

    Para crear una regla de silencio para un proyecto, sigue estos pasos:

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

    Haz los cambios siguientes:

    • PARENT: el recurso principal de tu regla de silencio (organizations, folders o projects)
    • PARENT_ID: el ID de la organización, la carpeta o el proyecto principal
    • LOCATION: la ubicación de Security Command Center en la que se va a crear una regla 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 silencio (entre 1 y 63 caracteres)
    • RULE_DESCRIPTION: descripción de la regla de silencio (máximo: 1024 caracteres).

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

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

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

    • TIMESTAMP: solo se aplica si creas una regla de silencio dinámica. Cadena de fecha y hora que indica cuándo caduca la regla de silencio dinámico. El valor debe ser de al menos un día en el futuro. De lo contrario, la solicitud se rechazará. Para obtener información sobre los formatos de hora, consulta gcloud topic datetimes. Cuando caduca una regla de silencio dinámico, se elimina de todos los resultados coincidentes. Si quieres que la regla de silencio dinámico actúe indefinidamente en las detecciones coincidentes, omite este campo.

    La respuesta incluye el ID de configuración de la función de silenciar, que puedes usar para ver, actualizar y eliminar reglas de silencio, tal como se describe en el artículo Gestionar reglas de silencio.

Los nuevos resultados que coincidan exactamente con el filtro se ocultarán y el atributo mute de los resultados se definirá como MUTED.

Propiedades de detecciones no admitidas para reglas de silencio

Las reglas de silencio no admiten todas las propiedades de las detecciones en los filtros. Amplía la siguiente sección para ver la lista de propiedades que no se admiten en los filtros de reglas de silencio.

Propiedades de hallazgos no admitidas

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

    • 1La propiedad gcpMetadata.folders contiene subcampos que se admiten en los filtros de silencio.

Lista de reglas de silenciado

Puedes consultar las reglas de silencio de una organización, una carpeta o un proyecto mediante la Google Cloud consola, la CLI de gcloud o la API de Security Command Center.

La posibilidad de enumerar las reglas de silencio de un ámbito determinado depende de los permisos que se hayan concedido a tus roles de gestión de identidades y accesos.

Si la residencia de datos está habilitada en Security Command Center, el ámbito 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 silencio, consulta Listar reglas de silencio.

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

Consola

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

    Ir a reglas de silencio

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

  3. En la sección Reglas de silencio, se muestran los detalles de las reglas de silencio activas, como los siguientes:

    • Nombre: ID de regla de silencio
    • Recurso superior: el recurso en el que se encuentra la regla de silencio
    • Descripción: la descripción de la regla de silencio, si está disponible.
    • Última actualización: el director que actualizó la regla por última vez.
    • Última actualización: la fecha y la hora en las que se actualizó la regla por última vez.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Para ver las reglas de silencio, ejecuta el comando gcloud scc muteconfigs list:

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

    Haz los cambios siguientes:

    • PARENT: el elemento superior organization, folder o project del que se van a mostrar las reglas de silencio
    • PARENT_ID: el ID de la organización, la carpeta o el proyecto principal
    • LOCATION: la ubicación del Security Command Centeren la que se deben enumerar las reglas de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.

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

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

    Haz los cambios siguientes:

    • PARENT: el recurso principal de tu regla de silencio (organizations, folders o projects)
    • PARENT_ID: el ID de la organización, la carpeta o el proyecto principal
    • LOCATION: la ubicación del Security Command Centeren la que se deben enumerar 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 IDs de configuración de silencio de tus reglas de silencio.

Ver la configuración de una regla de silencio

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

Para ver un código de muestra que obtiene una configuración de regla de silencio, consulta Ver una regla de silencio.

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

Consola

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

    Ir a reglas de silencio

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

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

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

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

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

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

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

    Haz los cambios siguientes:

    • MUTE_CONFIG_ID: el ID de la regla de silencio
    • PARENT: el recurso principal de tu regla de silencio (organization, folder o project)
    • PARENT_ID: el ID de la organización, la carpeta o el proyecto
    • LOCATION: la ubicación de Security Command Center en la que se verá la configuración de la regla de silencio; si la residencia de datos está habilitada, usa eu, sa o us; de lo contrario, usa el valor global

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

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

    Haz los cambios siguientes:

    • PARENT: el recurso principal de tu regla de silencio (organizations, folders o projects)
    • PARENT_ID: el ID de la organización, la carpeta o el proyecto
    • LOCATION: la ubicación de Security Command Center en la que se verá la configuración de la regla de silencio; si la residencia de datos está habilitada, usa eu, sa o us; de lo contrario, usa el valor global
    • CONFIG_ID: ID numérico de la regla de silencio

Actualizar reglas de silencio

Puedes actualizar la descripción o el filtro de resultados de una regla de silencio mediante la consola, la CLI de gcloud o la API de Security Command Center. Google Cloud

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

Si has reactivado alguna detección, se volverá a silenciar si coincide con una regla de silencio actualizada en la consola Google Cloud . Para obtener más información, consulta Activar el sonido de resultados concretos.

Para ver un código de muestra que actualiza una regla de silencio, consulta Actualizar una regla de silencio.

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

Consola

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

    Ir a reglas de silencio

  2. Selecciona el Google Cloud proyecto o la organización que sea el recurso principal de la regla de silencio que quieras modificar.

  3. Haz clic en el nombre de la regla de silencio que quieras modificar.

    Si no ha seleccionado el proyecto o la organización adecuados, es posible que vea una nota en la que se le informe de que no tiene permiso para modificar la regla de silencio.

  4. Cambia la regla de silencio.

  5. Opcional: Si actualiza el filtro, haga clic en Vista previa de las coincidencias para ver los resultados que coinciden con el filtro actualizado. Se carga una tabla con los hallazgos que coinciden con la nueva consulta.

  6. Haz clic en Guardar.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

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

    Haz los cambios siguientes:

    • MUTE_CONFIG_ID: el ID de la regla de silencio.
    • PARENT: el recurso principal de tu regla de silencio (organization, folder o project).
    • PARENT_ID: el ID de la organización, la carpeta o el proyecto.
    • LOCATION: la ubicación de Security Command Center en la que se va a actualizar la regla de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.
    • RULE_DESCRIPTION: descripción de la regla de silencio (máximo: 1024 caracteres).

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

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

    • MUTE_TYPE: el tipo de regla de silencio que quieres actualizar. Los tipos de reglas de silencio válidos son DYNAMIC y STATIC. No puedes cambiar el tipo de una regla de silencio una vez que la hayas creado.

    • TIMESTAMP: solo se aplica si actualizas una regla de silencio dinámica. Cadena de fecha y hora que indica cuándo caduca la regla de silencio dinámico. El valor debe ser de al menos un día en el futuro. De lo contrario, la solicitud se rechazará. Para obtener información sobre los formatos de hora, consulta gcloud topic datetimes. Cuando caduca una regla de silencio dinámico, se elimina de todos los resultados coincidentes. Si quieres que la regla de silencio dinámico actúe indefinidamente en las detecciones coincidentes, omite este campo.

    3. 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 silencio. 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"
  }

    Haz los cambios siguientes:

    • PARENT: el recurso principal de tu regla de silencio (organizations, folders o projects)
    • PARENT_ID: el ID de la organización, la carpeta o el proyecto
    • LOCATION: la ubicación de Security Command Center en la que se va a actualizar la regla de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.
    • CONFIG_ID: ID numérico de la regla de silencio
    • RULE_DESCRIPTION: descripción de la regla de silencio (máximo: 1024 caracteres).

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

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

    • MUTE_TYPE: el tipo de regla de silencio que quieres actualizar. Los tipos de reglas de silencio válidos son DYNAMIC y STATIC. No puedes cambiar el tipo de una regla de silencio una vez que la hayas creado.

    • TIMESTAMP: solo se aplica si actualizas una regla de silencio dinámica. Cadena de fecha y hora que indica cuándo caduca la regla de silencio dinámico. El valor debe ser de al menos un día en el futuro o la solicitud se rechazará. Para obtener información sobre los formatos de hora, consulta gcloud topic datetimes. Cuando caduca una regla de silencio dinámica, se elimina de todos los resultados coincidentes. Si quieres que la regla de silencio dinámico actúe indefinidamente en las detecciones coincidentes, omite este campo.

Los nuevos resultados que coincidan exactamente con el filtro se ocultarán y el atributo mute de los resultados se definirá como MUTED.

Eliminar reglas de silencio

Puedes eliminar una regla de silencio mediante la Google Cloud consola, la CLI de gcloud o la API de Security Command Center.

Antes de eliminar reglas de silencio, debes tener en cuenta lo siguiente:

  • No puedes recuperar las reglas de silencio eliminadas.
  • Si eliminas las reglas de silencio estáticas, no se reactivará automáticamente el sonido de las detecciones que estén silenciadas. Debes activar el sonido de los resultados manualmente o mediante programación.
  • Si eliminas las reglas de silenciación dinámicas, se quitarán automáticamente de todas las detecciones que coincidan con ellas y se reactivará el sonido de las que no coincidan con ninguna otra regla.
  • Las futuras detecciones que coincidan con los filtros de las reglas de silencio eliminadas no se silenciarán.

Para ver un código de muestra que elimina una regla de silencio, consulta Eliminar una regla de silencio.

Para eliminar una regla de silencio, haz clic en la pestaña del procedimiento que quieras usar:

Consola

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

    Ir a reglas de silencio

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

  3. Haz clic en el nombre de la regla de silencio que quieras eliminar.

  4. Haz clic en Eliminar.

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

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Para eliminar reglas de silencio, ejecuta el comando gcloud scc muteconfigs delete:

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

    Haz los cambios siguientes:

    • MUTE_CONFIG_ID: el ID de la configuración de silencio
    • PARENT: el recurso principal de tu regla de silencio (organization, folder o project)
    • PARENT_ID: el ID de la organización, la carpeta o el proyecto
    • LOCATION: la ubicación de Security Command Centeren la que se va a eliminar la regla de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.

  3. Confirma que quieres eliminar la regla de silencio.

    4. 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 eliminar una regla de silencio:

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

    Haz los cambios siguientes:

    • PARENT: el recurso principal de tu regla de silencio (organizations, folders o projects)
    • PARENT_ID: el ID de la organización, la carpeta o el proyecto
    • LOCATION: la ubicación de Security Command Centeren la que se va a eliminar la regla de silencio. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.
    • CONFIG_ID: ID numérico de la regla de silencio

Silenciar un resultado concreto

Puedes silenciar estáticamente un resultado concreto mediante la consola, la CLI de gcloud o la API de Security Command Center.Google Cloud

Silenciar un hallazgo de forma estática no afecta a si está activo o no. Si se silencia un resultado activo, el atributo state no cambia: state="ACTIVE". El hallazgo está oculto, pero sigue activo hasta que se resuelva la vulnerabilidad, la configuración incorrecta o la amenaza subyacente. Además, al silenciar de forma estática un resultado, anulas cualquier regla de silencio dinámico que se aplique al resultado.

Si silencias un hallazgo de combinación tóxica, se cierra el caso de combinación tóxica correspondiente.

Para silenciar todos los resultados futuros que coincidan con los criterios que especifiques, consulta Crear reglas de silencio.

Para ver un código de muestra para silenciar un resultado, consulta Silenciar un resultado.

Para silenciar de forma estática un resultado concreto, haz clic en la pestaña del procedimiento que quieras usar:

Consola

Para silenciar un hallazgo individual mediante la consola de Google Cloud , haz clic en la pestaña de tu nivel de servicio:

Estándar o Premium

  1. En la Google Cloud consola, ve a la página Resultados de Security Command Center.

    Ir a Resultados

  2. Si es necesario, selecciona tu Google Cloud proyecto u organización.
  3. Si no ves el resultado que quieres silenciar en el panel Resultados de la consulta de detecciones, selecciona la categoría del resultado en la sección Categoría del panel Filtros rápidos.
  4. Selecciona la casilla situada junto al resultado que quieras silenciar. Puedes seleccionar uno o varios resultados.

  5. En la barra de acciones Resultados de la consulta de detecciones, haga clic en Opciones de silenciar y, a continuación, seleccione Aplicar anulación de silenciar.

    El atributo mute de las detecciones seleccionadas se define como MUTED y la detección se elimina del panel Resultados de la consulta de detecciones. También puedes silenciar un resultado desde su panel de detalles:

  6. En el panel Resultados de la consulta de la página Resultados, en la columna Categoría, haga clic en el nombre de un resultado concreto. Se abrirá el panel de detalles de la detección.

  7. Haz clic en Tomar medidas.

  8. En el menú Tomar medidas, selecciona Aplicar anulación de silencio.

    Si selecciona Silenciar resultados como este, se abrirá la página Crear regla de silencio, donde podrá crear una regla de silencio para los resultados del mismo tipo o que incluyan el mismo atributo Indicator.

Empresa

  1. En la Google Cloud consola, ve a la página Resultados de Security Command Center.

    Ir a Resultados

  2. Si es necesario, selecciona tu Google Cloud proyecto u organización.
  3. Si no ves el resultado que quieres silenciar en el panel Resultados de la consulta de detecciones, selecciona la categoría del resultado en la sección Categoría del panel Filtros rápidos.
  4. Selecciona la casilla situada junto al resultado que quieras silenciar. Puedes seleccionar uno o varios resultados.
  5. En la barra de acciones Resultados de la consulta de detecciones, haga clic en Opciones de silenciar y, a continuación, seleccione Aplicar anulación de silenciar.

El atributo mute de las detecciones seleccionadas se define como MUTED y la detección se elimina del panel Resultados de la consulta de detecciones.

También puedes silenciar un resultado desde su panel de detalles:

  1. En el panel Resultados de la consulta de la página Resultados, en la columna Categoría, haga clic en el nombre de un resultado concreto. Se abrirá el panel de detalles de la detección.

  2. En el menú Opciones de silencio, selecciona Aplicar anulación de silencio.

    Si selecciona Silenciar resultados como este, se abrirá la página Crear regla de silencio, donde podrá crear una regla de silencio para los resultados del mismo tipo o que incluyan el mismo atributo Indicator.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Para definir el estado de silencio de una detección como MUTED, usa el comando set-mute en gcloud CLI:

    gcloud scc findings set-mute FINDING_ID \
  --PARENT=PARENT_ID \
  --location=LOCATION \
  --source=SOURCE_ID \
  --mute=MUTED

    Haz los cambios siguientes:

    • FINDING_ID: el ID del resultado que quieres silenciar

      Para obtener los IDs de los resultados, usa la API de Security Command Center para listar los resultados. El ID del problema es la última parte del atributo canonicalName. Por ejemplo, projects/123456789012/sources/1234567890123456789/findings`/5ee30aa342e799e4e1700826de053aa9.

    • PARENT: el recurso principal (project, folder o organization). Se distingue entre mayúsculas y minúsculas.

    • PARENT_ID: el ID de la organización, la carpeta o el proyecto principal

    • LOCATION: la ubicación de Security Command Center en la que silenciar la detección. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.

    • SOURCE_ID: el ID de la fuente

      Para obtener instrucciones sobre cómo recuperar un ID de fuente, consulta el artículo Obtener el ID de fuente.

    3. Go

    import (
	"context"
	"fmt"
	"io"

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

// setMute mutes an individual finding.
// If a finding is already muted, muting it again has no effect.
// Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE.
func setMute(w io.Writer, findingPath string) error {
	// findingPath: The relative resource name of the finding. See:
	// https://cloud.google.com/apis/design/resource_names#relative_resource_name
	// Use any one of the following formats:
	//  - organizations/{organization_id}/sources/{source_id}/finding/{finding_id}
	//  - folders/{folder_id}/sources/{source_id}/finding/{finding_id}
	//  - projects/{project_id}/sources/{source_id}/finding/{finding_id}
	// findingPath := fmt.Sprintf("projects/%s/sources/%s/finding/%s", "your-google-cloud-project-id", "source", "finding-id")
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	req := &securitycenterpb.SetMuteRequest{
		Name: findingPath,
		Mute: securitycenterpb.Finding_MUTED}

	finding, err := client.SetMute(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to set the specified mute value: %w", err)
	}
	fmt.Fprintf(w, "Mute value for the finding: %s is %s", finding.Name, finding.Mute)
	return nil
}

    Java

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

public class SetMuteFinding {

  public static void main(String[] args) throws IOException {
    // TODO: Replace the variables within {}
    // findingPath: The relative resource name of the finding. See:
    // https://cloud.google.com/apis/design/resource_names#relative_resource_name
    // Use any one of the following formats:
    //  - organizations/{org_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //  - folders/{folder_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //  - projects/{project_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //
    String findingPath = "{path-to-the-finding}";

    setMute(findingPath);
  }

  // Mute an individual finding.
  // If a finding is already muted, muting it again has no effect.
  // Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE.
  public static Finding setMute(String findingPath) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

      SetMuteRequest setMuteRequest =
          SetMuteRequest.newBuilder()
              // Relative path for the finding.
              .setName(findingPath)
              .setMute(Mute.MUTED)
              .build();

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

    Python

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

    client = securitycenter_v2.SecurityCenterClient()

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

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

    REST

    En la API de Security Command Center, usa el método findings.setMute para silenciar un resultado. El cuerpo de la solicitud es una enumeración que indica el estado de silencio resultante:

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

{
  "mute": "MUTED"
}

    Haz los cambios siguientes:

    • PARENT: el recurso principal (organizations, folders o projects).
    • PARENT_ID: el ID de la organización, la carpeta o el proyecto principal.
    • LOCATION: la ubicación de Security Command Center en la que silenciar la detección. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.

    • SOURCE_ID: ID numérico de la fuente.

      Para obtener instrucciones sobre cómo recuperar un ID de fuente, consulta el artículo Obtener el ID de fuente.

    • FINDING_ID: el ID de la detección que quieres silenciar.

      Para obtener los IDs de los resultados, usa la API de Security Command Center para listar los resultados. El ID del problema es la última parte del atributo canonicalName. Por ejemplo, projects/123456789012/sources/1234567890123456789/findings/5ee30aa342e799e4e1700826de053aa9.

Cuando silencias un resultado, su atributo mute se define como MUTED.

Activar el sonido de los resultados concretos

Puedes desactivar el silencio de un resultado concreto de forma estática mediante la Google Cloud consola, la CLI de gcloud o la API de Security Command Center.

Desactivar el silencio de un resultado es útil cuando necesitas evitar que se oculte por una regla de silencio demasiado general o por una regla que sea demasiado compleja para modificarla y excluir los resultados que consideres importantes.

Para ver un código de muestra para reactivar una detección, consulta Reactivar una detección.

Las detecciones que se han reactivado solo se vuelven a silenciar si se silencian manualmente. Las reglas de silencio creadas con la CLI de gcloud o la API de Security Command Center no afectarán a los resultados que los usuarios hayan reactivado.

Para ver un código de muestra para reactivar el sonido de un resultado, consulta Reactivar el sonido de un resultado.

Consola

Para reactivar una detección concreta mediante la Google Cloud consola, haz clic en la pestaña de tu nivel de servicio:

Estándar o Premium

  1. En la Google Cloud consola, ve a la página Resultados de Security Command Center.

    Ir a Resultados

  2. Si es necesario, selecciona tu Google Cloud proyecto u organización. Se abre la página Resultados con la consulta predeterminada en la sección Vista previa de la consulta. La consulta predeterminada excluye los resultados silenciados, por lo que debes editarla para que aparezcan en el panel Resultados de la consulta de hallazgos.
  3. A la derecha de la sección Vista previa de la consulta, haz clic en Editar consulta para abrir el editor de consultas.
  4. En el campo Editor de consultas, sustituye la instrucción de silencio por la siguiente: 
    mute="MUTED"
  5. Haz clic en Aplicar. Las detecciones del panel Resultados de la consulta de detecciones se actualizan para incluir solo las detecciones silenciadas.
  6. Si es necesario, filtra otros resultados silenciados. Por ejemplo, en el panel Filtros rápidos, en Categoría, selecciona el nombre del resultado que quieras reactivar para filtrar todas las demás categorías de resultados.
  7. Selecciona la casilla situada junto al resultado que quieras reactivar. Puedes seleccionar uno o varios resultados.
  8. En la barra de acciones Resultados de la consulta de detecciones, haga clic en Opciones de silenciar y, a continuación, seleccione Aplicar anulación de silenciar. El atributo mute de las detecciones seleccionadas se define como UNMUTED y la detección se elimina del panel Resultados de la consulta de detecciones. También puedes reactivar el sonido de un resultado desde su panel de detalles:
  9. En el panel Resultados de la consulta de la página Resultados, en la columna Categoría, haga clic en el nombre de un resultado concreto. Se abrirá el panel de detalles de la detección.
  10. Haz clic en Tomar medidas.
  11. En el menú Tomar medidas, selecciona Aplicar anulación de silencio.

Empresa

  1. En la Google Cloud consola, ve a la página Resultados de Security Command Center.

    Ir a Resultados

  2. Si es necesario, selecciona tu Google Cloud proyecto u organización. Se abre la página Resultados con la consulta predeterminada en la sección Vista previa de la consulta. La consulta predeterminada excluye los resultados silenciados, por lo que debes editarla para que aparezcan en el panel Resultados de la consulta de hallazgos.
  3. A la derecha de la sección Vista previa de la consulta, haz clic en Editar consulta para abrir el editor de consultas.
  4. En el campo Editor de consultas, sustituye la instrucción de silencio por la siguiente: 
    mute="MUTED"
  5. Haz clic en Aplicar. Las detecciones del panel Resultados de la consulta de detecciones se actualizan para incluir solo las detecciones silenciadas.
  6. Si es necesario, filtra otros resultados silenciados. Por ejemplo, en el panel Filtros rápidos, en Categoría, selecciona el nombre del resultado que quieras reactivar para filtrar todas las demás categorías de resultados.
  7. Selecciona la casilla situada junto al resultado que quieras reactivar. Puedes seleccionar uno o varios resultados.
  8. En la barra de acciones Resultados de la consulta de detecciones, haga clic en Opciones de silenciar y, a continuación, seleccione Aplicar anulación de silenciar. El atributo mute de las detecciones seleccionadas se define como UNMUTED y la detección se elimina del panel Resultados de la consulta de detecciones. También puedes reactivar el sonido de un resultado desde su panel de detalles:
  9. En el panel Resultados de la consulta de la página Resultados, en la columna Categoría, haga clic en el nombre de un resultado concreto. Se abrirá el panel de detalles de la detección.
  10. Haz clic en Opciones de silencio.
  11. En el menú Opciones de silenciar, selecciona Aplicar anulación de silencio.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Para definir el estado de silencio de una detección como UNMUTED, usa el comando set-mute en gcloud CLI:

    gcloud scc findings set-mute FINDING_ID \
  --PARENT=PARENT_ID \
  --location=LOCATION \
  --source=SOURCE_ID \
  --mute=UNMUTED

    Haz los cambios siguientes:

    • FINDING_ID: el ID del resultado que quieres silenciar

      Para obtener los IDs de los resultados, usa la API de Security Command Center para listar los resultados. El ID del problema es la última parte del atributo canonicalName. Por ejemplo, projects/123456789012/sources/1234567890123456789/findings/5ee30aa342e799e4e1700826de053aa9.

    • PARENT: el recurso principal (project, folder o organization ), que distingue entre mayúsculas y minúsculas

    • PARENT_ID: el ID de la organización, la carpeta o el proyecto principal

    • LOCATION: la ubicación de Security Command Center en la que reactivar el sonido de la detección. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.

    • SOURCE_ID: el ID de la fuente

      Para obtener instrucciones sobre cómo recuperar un ID de fuente, consulta el artículo Obtener el ID de fuente.

    3. Go

    
import (
	"context"
	"fmt"
	"io"

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

// setUnmute unmutes an individual finding.
// Unmuting a finding that isn't muted has no effect.
// Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE.
func setUnmute(w io.Writer, findingPath string) error {
	// findingPath: The relative resource name of the finding. See:
	// https://cloud.google.com/apis/design/resource_names#relative_resource_name
	// Use any one of the following formats:
	//  - organizations/{organization_id}/sources/{source_id}/finding/{finding_id}
	//  - folders/{folder_id}/sources/{source_id}/finding/{finding_id}
	//  - projects/{project_id}/sources/{source_id}/finding/{finding_id}
	// findingPath := fmt.Sprintf("projects/%s/sources/%s/finding/%s", "your-google-cloud-project-id", "source", "finding-id")
	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %w", err)
	}
	defer client.Close()

	req := &securitycenterpb.SetMuteRequest{
		Name: findingPath,
		Mute: securitycenterpb.Finding_UNMUTED}

	finding, err := client.SetMute(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to set the specified mute value: %w", err)
	}
	fmt.Fprintf(w, "Mute value for the finding: %s is %s", finding.Name, finding.Mute)
	return nil
}

    Java

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

public class SetUnmuteFinding {

  public static void main(String[] args) throws IOException {
    // TODO: Replace the variables within {}
    // findingPath: The relative resource name of the finding. See:
    // https://cloud.google.com/apis/design/resource_names#relative_resource_name
    // Use any one of the following formats:
    //  - organizations/{org_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //  - folders/{folder_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //  - projects/{project_id}/sources/{source_id}/locations/{location}/finding/{finding_id}
    //
    String findingPath = "{path-to-the-finding}";

    setUnmute(findingPath);
  }

  // Unmute an individual finding.
  // Unmuting a finding that isn't muted has no effect.
  // Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE.
  public static Finding setUnmute(String findingPath) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

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

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

    Python

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

    client = securitycenter_v2.SecurityCenterClient()

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

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

    REST

    En la API de Security Command Center, usa el método findings.setMute para reactivar un hallazgo. El cuerpo de la solicitud es una enumeración que indica el estado de silencio resultante:

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

{
  "mute": "UNMUTED"
}

    Haz los cambios siguientes:

    • PARENT: el recurso principal (organizations, folders o projects)
    • PARENT_ID: el ID de la organización, la carpeta o el proyecto principal
    • LOCATION: la ubicación de Security Command Center en la que reactivar el sonido de la detección. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.

    • SOURCE_ID: el ID numérico de la fuente

      Para obtener instrucciones sobre cómo recuperar un ID de fuente, consulta el artículo Obtener el ID de fuente.

    • FINDING_ID: el ID de la detección que quieres silenciar.

      Para obtener los IDs de los resultados, usa la API de Security Command Center para listar los resultados. El ID del problema es la última parte del atributo canonicalName. Por ejemplo, projects/123456789012/sources/1234567890123456789/findings/5ee30aa342e799e4e1700826de053aa9.

Los resultados seleccionados ya no están ocultos y el atributo mute de los resultados se ha definido como UNMUTED.

Quitar la anulación del estado de silencio de resultados concretos

Se aplica una anulación del estado de silencio cuando se modifica intencionadamente el estado de silencio de un resultado para silenciarlo o reactivarlo de forma estática. Por ejemplo, puede aplicar una anulación del estado de silencio para ocultar un resultado de gravedad baja que no merezca la pena crear una regla de silencio dinámica.

Puedes quitar la anulación del estado de silencio de un resultado concreto mediante la consola Google Cloud , la CLI de gcloud o la API de Security Command Center.

Antes de quitar la anulación del estado de silencio de un resultado, debes tener en cuenta lo siguiente:

  • Un resultado tiene una anulación del estado de silencio si está silenciado o con el sonido activado de forma estática. Puedes aplicar una anulación del estado de silencio a cualquier resultado de forma manual o automática con reglas de silencio estáticas.
  • Una anulación del estado de silencio se aplica a un resultado de forma indefinida y tiene prioridad sobre cualquier regla de silencio coincidente.
  • Si quitas la anulación del estado de silencio de un resultado, se restablecerá el estado de silencio del resultado para que las reglas de silencio estáticas o dinámicas puedan procesarlo.
  • Quitar la anulación del estado de silencio de un resultado no es lo mismo que reactivar el sonido de un resultado. Cuando reactivas el sonido de un resultado (aplicas una anulación de la desactivación del sonido), las reglas de silencio no pueden silenciar ese resultado hasta que hayas quitado manualmente la anulación del estado de silencio.

Para quitar la anulación del silencio de un resultado concreto, haz lo siguiente:

Consola

Estándar o Premium

  1. En la Google Cloud consola, ve a la página Resultados de Security Command Center.

    Ir a Resultados

  2. Selecciona tu Google Cloud proyecto u organización.
  3. A la derecha de la sección Vista previa de la consulta, haz clic en Editar consulta para abrir el editor de consultas.
  4. En el campo Editor de consultas, sustituye la instrucción de silencio por la siguiente: 
    mute="MUTED" OR mute="UNMUTED"
  5. Haz clic en Aplicar. Los resultados del panel Resultados de la consulta de detecciones se actualizan para incluir las detecciones silenciadas y activadas de forma estática.
  6. Si es necesario, filtre otros resultados. Por ejemplo, en el panel Filtros rápidos, en Categoría, selecciona el nombre del hallazgo que quieras restablecer para filtrar todas las demás categorías de hallazgos.
  7. Selecciona la casilla situada junto al resultado que quieras restablecer. Puedes seleccionar uno o varios resultados.
  8. En la barra de acciones Resultados de la consulta de detecciones, haga clic en Opciones de silencio y, a continuación, seleccione Quitar anulaciones de silencio. El atributo mute de las detecciones seleccionadas se define como UNDEFINED, y la detección se elimina del panel Resultados de la consulta de detecciones. También puedes reactivar el sonido de un resultado desde su panel de detalles:
  9. En el panel Resultados de la consulta de la página Resultados, en la columna Categoría, haga clic en el nombre de un resultado concreto. Se abrirá el panel de detalles de la detección.
  10. Haz clic en Tomar medidas.
  11. En el menú Tomar medidas, selecciona Eliminar anulaciones de silencio.

Empresa

  1. En la Google Cloud consola, ve a la página Resultados de Security Command Center.

    Ir a Resultados

  2. Selecciona tu Google Cloud proyecto u organización.
  3. A la derecha de la sección Vista previa de la consulta, haz clic en Editar consulta para abrir el editor de consultas.
  4. En el campo Editor de consultas, sustituye la instrucción mute por la siguiente: 
    mute="MUTED" OR mute="UNMUTED"
  5. Haz clic en Aplicar. Los resultados del panel Resultados de la consulta de detecciones se actualizan para incluir las detecciones silenciadas y activadas de forma estática.
  6. Si es necesario, filtre otros resultados. Por ejemplo, en el panel Filtros rápidos, en Categoría, selecciona el nombre del resultado que quieras restablecer para filtrar todas las demás categorías de resultados.
  7. Selecciona la casilla situada junto al resultado que quieras restablecer. Puedes seleccionar uno o varios resultados.
  8. En la barra de acciones Resultados de la consulta de detecciones, haga clic en Opciones de silencio y, a continuación, seleccione Quitar anulaciones de silencio. El atributo mute de las detecciones seleccionadas se define como UNDEFINED y la detección se elimina del panel Resultados de la consulta de detecciones. También puedes reactivar el sonido de un resultado desde su panel de detalles:
  9. En el panel Resultados de la consulta de la página Resultados, en la columna Categoría, haga clic en el nombre de un resultado concreto. Se abrirá el panel de detalles de la detección.
  10. Haz clic en Opciones de silencio.
  11. En el menú Opciones de silencio, selecciona Eliminar anulaciones de silencio.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Para definir el estado de silencio de una detección como UNDEFINED, usa el comando set-mute en gcloud CLI:

    gcloud scc findings set-mute FINDING_ID \
  --PARENT=PARENT_ID \
  --location=LOCATION \
  --source=SOURCE_ID \
  --mute=UNDEFINED

    Haz los cambios siguientes:

    • FINDING_ID: el ID de la detección que quieras restablecer

      Para obtener los IDs de los resultados, usa la API de Security Command Center para listar los resultados. El ID del problema es la última parte del atributo canonicalName. Por ejemplo, projects/123456789012/sources/1234567890123456789/findings/5ee30aa342e799e4e1700826de053aa9.

    • PARENT: el recurso principal (project, folder o organization ), que distingue entre mayúsculas y minúsculas

    • PARENT_ID: el ID de la organización, la carpeta o el proyecto principal

    • LOCATION: la ubicación de Security Command Center en la que se va a quitar la anulación del estado de silencio de una detección. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.

    • SOURCE_ID: el ID de la fuente

      Para obtener instrucciones sobre cómo recuperar un ID de origen, consulte Obtener el ID de origen.

    3. REST

    En la API de Security Command Center, usa el método findings.setMute para restablecer el estado de silencio de un resultado. El cuerpo de la solicitud es un enum que indica el estado de silencio resultante:

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

{
  "mute": "UNDEFINED"
}

    Haz los cambios siguientes:

    • PARENT: el recurso principal (organizations, folders o projects)
    • PARENT_ID: el ID de la organización, la carpeta o el proyecto principal
    • LOCATION: la ubicación de Security Command Center en la que se va a quitar la anulación del estado de silencio de una detección. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.
    • SOURCE_ID: el ID numérico de la fuente

    Java

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

public class SetMuteUndefinedFinding {

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

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

  // Reset mute state of an individual finding.
  // If a finding is already reset, resetting it again has no effect.
  // Various mute states are: MUTE_UNSPECIFIED/MUTE/UNMUTE/UNDEFINED.
  public static Finding setMuteUndefined(String findingPath) throws IOException {
    // Initialize client that will be used to send requests. This client only needs
    // to be created once, and can be reused for multiple requests.
    try (SecurityCenterClient client = SecurityCenterClient.create()) {

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

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

Silenciar o restablecer varios hallazgos

Puedes realizar las siguientes operaciones de silenciado en bloque de varias detecciones mediante el comando gcloud scc findings bulk-mute de la CLI de gcloud o el método bulkMute de la API de Security Command Center:

  • Silenciar varios hallazgos. Al silenciar las detecciones actuales en bloque, se silencian de forma estática y se anulan las reglas de silencio dinámicas que se apliquen a la detección. Si quieres silenciar resultados similares en el futuro, crea una regla de silencio.

  • Quitar la anulación del estado de silencio en varios resultados. Si quitas la anulación del estado de silencio de un resultado, el estado de silencio pasará de MUTED (silencio estático) o UNMUTED (activación estática del sonido) a UNDEFINED. Esta función puede ser útil si vas a migrar de reglas de silencio estáticas a dinámicas.

Especifique el conjunto de resultados que quiere silenciar definiendo un filtro de resultados. Los filtros de silencio masivo no admiten todas las propiedades de los resultados. Para ver una lista de las propiedades no admitidas, consulta Propiedades de detecciones no admitidas para reglas de silencio.

Si la residencia de datos está habilitada en Security Command Center, el ámbito de las operaciones de silenciado masivo se limita a la ubicación de Security Command Center en la que se ejecutan.

Para ver un código de muestra que silencia resultados en bloque, consulta Silenciar resultados en bloque.

Para silenciar o restablecer los resultados en bloque, haz clic en la pestaña del procedimiento que quieras usar:

Consola

En la consola de Google Cloud , solo puedes silenciar hallazgos en bloque creando reglas de silencio. En la consola Google Cloud , al crear reglas de silencio, se silencian las detecciones actuales y futuras.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Para silenciar o restablecer varias detecciones en bloque, ejecuta el comando gcloud scc findings bulk-mute:

    gcloud scc findings bulk-mute \
  --PARENT=PARENT_ID \
  --location=LOCATION \
  --filter="FILTER" \
  --mute-state=MUTE_STATE

    Haz los cambios siguientes:

    • PARENT: el ámbito de la jerarquía de recursos al que se aplica la regla de silencio, organization, folder o project.
    • PARENT_ID: el ID numérico de la organización, la carpeta o el proyecto principal, o el ID alfanumérico del proyecto principal.
    • LOCATION: la ubicación de Security Command Center en la que silenciar o restablecer las detecciones en bloque. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.

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

      Por ejemplo, para silenciar todos los resultados de gravedad baja OPEN_FIREWALL y PUBLIC_IP_ADDRESS del proyecto internal-test, el filtro puede ser "category=\"OPEN_FIREWALL\" OR category=\"PUBLIC_IP_ADDRESS\" AND severity=\"LOW\" AND resource.projectDisplayName=\"internal-test\"".

    • MUTE_STATE: el valor que indica si el resultado está silenciado estáticamente o no. Los valores válidos son MUTED y UNDEFINED. El valor predeterminado es MUTED. Asigna el valor UNDEFINED solo si vas a restablecer el estado de silencio de varios resultados.

    3. REST

    En la API de Security Command Center, usa el método findings.bulkMute para silenciar o restablecer el estado de silencio de varios hallazgos. El cuerpo de la solicitud contiene la expresión utilizada para filtrar los resultados:

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

{
  "filter": "FILTER",
  "muteState": "MUTE_STATE"
}

    Haz los cambios siguientes:

    • PARENT: el recurso principal (organizations, folders o projects).
    • PARENT_ID: el ID de la organización, la carpeta o el proyecto principal.
    • LOCATION: la ubicación de Security Command Center en la que silenciar o restablecer las detecciones en bloque. Si la residencia de datos está habilitada, usa eu, sa o us. De lo contrario, usa el valor global.

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

      Por ejemplo, para silenciar todos los resultados de gravedad baja OPEN_FIREWALL y PUBLIC_IP_ADDRESS del proyecto internal-test, el filtro puede ser "category=\"OPEN_FIREWALL\" OR category=\"PUBLIC_IP_ADDRESS\" AND severity=\"LOW\" AND resource.projectDisplayName=\"internal-test\"".

    • MUTE_STATE: valor que indica si la detección está silenciada o no. Los valores válidos son MUTED y UNDEFINED. El valor es MUTED de forma predeterminada. Asigna a este valor el valor UNDEFINED solo si vas a restablecer el estado de silencio de varios resultados.

Se ocultan todos los hallazgos del recurso que selecciones que coincidan exactamente con el filtro. El atributo mute de los resultados se ha definido como MUTED.

Silenciar resultados no cambia su estado. Si se silencian las detecciones activas, se ocultan, pero siguen activas hasta que se resuelvan las vulnerabilidades, las configuraciones incorrectas o las amenazas subyacentes.

Ver los hallazgos silenciados en la consola Google Cloud

Puedes ver los resultados silenciados en la Google Cloud consola editando la consulta de resultados para seleccionar los que incluyan el valor de la propiedad mute="MUTED".

Por ejemplo, la siguiente consulta de resultados muestra solo los resultados activos que están silenciados:

state="ACTIVE"
AND mute="MUTED"

Para mostrar todos los resultados activos, tanto silenciados como no silenciados, omite por completo el atributo mute de la consulta:

state="ACTIVE"

De forma predeterminada, la consulta de resultados de la Google Cloud consola solo muestra los resultados que no están silenciados.

Ver las conclusiones ocultadas por tipo de regla de ocultación

En las siguientes secciones se describe cómo consultar las detecciones activas por tipo de regla de silencio.

Para obtener más información sobre cómo mostrar resultados específicos, consulta Filtrar resultados.

Consultar las conclusiones silenciadas por reglas de silencio estáticas

Para mostrar las detecciones activas que se han silenciado mediante una regla de silencio estática después de un tiempo especificado, utilice la siguiente consulta e inspeccione el atributo muteInitiator para determinar si la detección se ha silenciado mediante una regla de silencio estática.

state="ACTIVE" AND
muteInfo.staticMute.applyTime>=TIMESTAMP AND
muteInfo.staticMute.state="MUTED"

Sustituye TIMESTAMP por la cadena de fecha y hora que indica el inicio del periodo que quieres consultar. Para obtener información sobre los formatos de hora, consulta gcloud topic datetimes.

Problemas de consulta silenciados por reglas de silencio dinámicas

Para mostrar las detecciones activas que se han silenciado con una regla de silencio dinámica después de un tiempo especificado, usa la siguiente consulta:

state="ACTIVE" AND
muteUpdateTime>=TIMESTAMP AND
contains(muteInfo.dynamicMuteRecords, muteConfig="PARENT_ID/muteConfigs/CONFIG_ID")

Haz los cambios siguientes:

  • TIMESTAMP: cadena de fecha y hora que indica el inicio del periodo que quieres consultar. Para obtener información sobre los formatos de hora, consulta gcloud topic datetimes.
  • PARENT_ID: el ID de la organización, la carpeta o el proyecto principal, especificado en el formato organizations/123, folders/456 o projects/789.
  • CONFIG_ID: el nombre de la regla de silencio. El ID debe incluir caracteres alfanuméricos y guiones, y tener entre 1 y 63 caracteres.

Para obtener más información sobre cómo editar consultas de resultados, consulta el artículo Crear o editar una consulta de resultados en el panel de control.

Buscar propiedades relacionadas con la función de silenciar

En esta sección se enumeran las propiedades de las detecciones relacionadas con el estado de silencio de una detección y se describe cómo influyen las operaciones de silencio en ellas:

  • mute: se define como UNDEFINED cuando se crean resultados y se producen cambios en los siguientes casos:
    • MUTED: un hallazgo se silencia manualmente o mediante una regla de silencio.
    • UNMUTED: un usuario reactiva el sonido de un resultado.
  • muteUpdateTime: la hora en la que se silencia o se deja de silenciar un hallazgo.
  • muteInitiator: identificador de la regla principal o de silencio que ha silenciado un resultado.
  • muteInfo: información sobre el silencio de la detección, como el tipo de regla de silencio (estática o dinámica) y las reglas de silencio con las que coincide la detección.
  • muteInfo.staticMute: un estado de silencio estático anula cualquier regla de silencio dinámico que se aplique a este resultado.
    • state: estado de silencio estático que se puede definir silenciando el resultado directamente o mediante una regla de silencio estática.
    • applyTime: hora en la que se aplicó el estado de silencio estático al resultado.
  • muteInfo.dynamicMuteRecords: registro de una regla de silencio dinámico que coincide con la detección.
    • muteConfig: el nombre de recurso relativo de la regla de silencio, representado por la configuración de silencio que creó el registro. Por ejemplo, organizations/123/muteConfigs/examplemuteconfig.
    • matchTime: hora en la que una regla de silencio dinámico ha coincidido con el resultado.

Detener las notificaciones y las exportaciones de resultados silenciados

Si habilitas las notificaciones de resultados, los resultados silenciados nuevos o actualizados que coincidan con tus filtros de notificaciones se seguirán exportando a Pub/Sub.

Para detener las exportaciones y las notificaciones de las detecciones silenciadas, utilice el atributo mute para excluir las detecciones silenciadas en su filtro NotificationConfig. Por ejemplo, el siguiente filtro solo envía notificaciones de las detecciones activas que no están silenciadas o en las que no se ha definido el atributo de silencio:

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

Siguientes pasos

Consulta más información sobre cómo filtrar notificaciones de resultados.

Consulta más ejemplos de filtros que puedes usar.