Gerenciar regras de silenciamento

Níveis de serviço Standard legada, Standard, Premium e Enterprise

O nível de serviço do Security Command Center Enterprise será desativado em 21 de maio de 2027. Se sua organização usa o nível de serviço Enterprise, ela será movida automaticamente para o nível Premium em 21 de maio de 2027 ou depois dessa data. Entre em contato com seu representante de contas ou um especialista em vendas doGoogle Cloud se tiver dúvidas.

Neste documento, explicamos como criar e gerenciar regras de exclusão para silenciar automaticamente descobertas no Security Command Center.

Funções exigidas

Para receber as permissões necessárias para gerenciar regras de silenciamento, peça ao administrador para conceder a você os seguintes papéis do IAM na organização, na pasta ou no projeto:

• Ver regras de silenciamento:
  • Leitor administrador da Central de segurança (roles/securitycenter.adminViewer)
  • Leitor de configurações da Central de segurança (roles/securitycenter.settingsViewer)
  • Leitor de configurações de desativação de som da Central de segurança (roles/securitycenter.muteConfigsViewer)
• Veja, crie, atualize e exclua regras de silenciamento:
  • Administrador da Central de segurança (roles/securitycenter.admin)
  • Editor administrador da Central de segurança (roles/securitycenter.adminEditor)
  • Editor de configurações da Central de segurança (roles/securitycenter.settingsEditor)
  • Editor de configurações de desativação de sons da Central de segurança (roles/securitycenter.muteConfigsEditor)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

Criar uma regra de silenciamento

Sua organização pode criar no máximo 1.000 regras de silenciamento.

Recomendamos usar regras de silenciamento dinâmicas exclusivamente nas configurações de regras de silenciamento, porque elas são mais flexíveis do que as estáticas. Para uma comparação dos tipos de regras de silenciamento, consulte Tipos de regras de silenciamento.

Para criar uma regra de silenciamento, clique na guia do procedimento que você quer usar:

Console

Definir a regra de silenciamento

1. No console Google Cloud , acesse a página Descobertas.

   Acessar descobertas

2. Selecione uma organização ou um projeto.

3. Clique em Opções de silenciamento e selecione Gerenciar regras de silenciamento.

4. Clique em Criar regra de silenciamento.

5. Insira um ID da regra de silenciamento.

6. Recomendado: insira uma Descrição que forneça contexto para explicar por que as descobertas são silenciadas.

7. Para confirmar o escopo da regra de silenciamento, verifique o valor do Recurso pai.

Opcional: adicione uma data de validade

É possível adicionar uma data de validade às regras de silenciamento dinâmico.

1. Selecione Silenciar descobertas correspondentes temporariamente.

2. Para configurar a data de validade da regra de silenciamento dinâmico, selecione o calendário e escolha uma data e hora pelo menos 24 horas no futuro.

   Após a data de expiração, a regra de silenciamento não tem efeito.

Opcional: limitar a regra de para ignorar com uma consulta

Se você adicionar uma consulta, a regra de silenciamento será aplicada apenas às descobertas que corresponderem a ela.

Para limitar a regra de exclusão com uma consulta, na seção Consulta de descobertas, clique em Adicionar filtro.

O menu Adicionar filtro permite escolher os atributos e valores de descoberta compatíveis.

1. No menu Selecionar filtro, escolha um atributo de descoberta ou digite o nome dele na caixa Pesquisar atributos de descoberta. Uma lista dos subatributos disponíveis será exibida.
2. Selecione um subatributo. Um campo de seleção aparece para que você possa criar a instrução de consulta usando o subatributo selecionado, um operador de consulta e um ou mais valores para o subatributo.

3. Selecione o operador e um ou mais valores para o subatributo no painel. Para mais informações sobre operadores de consulta e funções que eles usam, consulte Operadores de consulta no menu Adicionar filtros.

   Se quiser começar de novo, clique em Redefinir.

4. Clique em Aplicar.

   O menu é fechado, e a consulta é atualizada.

5. Repita até que a consulta de descobertas contenha todos os atributos que você quer.

Para verificar os resultados da consulta, clique em Visualizar descobertas correspondentes. Uma tabela lista as descobertas que correspondem à sua consulta.

Se a consulta não corresponder às descobertas corretas, revise-a conforme necessário e visualize as descobertas novamente. Repita essa etapa até ficar satisfeito com os resultados.

Salvar a regra de silenciamento

Clique em Salvar. O console do Google Cloud mostra uma lista das suas regras de silenciamento.

gcloud

1. No console do Google Cloud , ative o Cloud Shell.

   Ativar o Cloud Shell

   Na parte de baixo do console Google Cloud , uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

2. Para criar regras de silenciamento, execute o 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

   Substitua:

   • CONFIG_ID: o nome da regra de silenciamento. O ID precisa usar caracteres alfanuméricos e hifens e ter entre 1 e 63 caracteres.
   • PARENT: o escopo na hierarquia de recursos a que a regra de silenciamento se aplica, organization, folder ou project.
   • PARENT_ID: o ID numérico da organização, pasta ou projeto pai ou o ID alfanumérico do projeto pai.
   • LOCATION: o local do Security Command Center em que gerenciar regras de exclusão temporária. Se a residência de dados estiver ativada, use eu, sa ou us. Caso contrário, use o valor global.
   • RULE_DESCRIPTION: uma descrição da regra de silenciamento de no máximo 1.024 caracteres.
   • FILTER: a expressão definida para filtrar descobertas. Por exemplo, para silenciar descobertas OPEN_FIREWALL, seu filtro pode ser FILTER="category=\"OPEN_FIREWALL\"".
   • MUTE_TYPE: o tipo de regra de silenciamento que você quer criar. Os tipos de regras de silenciamento válidos são DYNAMIC e STATIC. Por padrão, o tipo de regra de silenciamento é definido como STATIC. Não é possível mudar o tipo de uma regra de desativação após a criação.
   • TIMESTAMP: só se aplica se você estiver criando uma regra de silenciamento dinâmico. A string de data e hora que indica quando a regra de desativação dinâmica expira. O valor precisa ser definido para pelo menos um dia no futuro, caso contrário, a solicitação será rejeitada. Para informações sobre formatos de tempo, consulte gcloud topic datetimes. Quando uma regra de silenciamento dinâmico expira, ela é removida de todas as descobertas correspondentes. Para que a regra de silenciamento dinâmico funcione indefinidamente nas descobertas correspondentes, omita esse campo.

   A resposta inclui o ID da regra de silenciamento, que pode ser usado para ver, atualizar e excluir regras de silenciamento, conforme descrito em Gerenciar regras de silenciamento.

Terraform

Crie uma regra de silenciamento para uma organização:

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

Criar uma regra para ignorar uma pasta:

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

Crie uma regra de silenciamento para um projeto:

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

Na API Security Command Center, use o método muteConfigs.create para criar uma regra de exclusão. O corpo da solicitação é uma instância 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"
  }

Substitua:

• PARENT: o recurso pai da regra de silenciamento (organizations, folders ou projects);
• PARENT_ID: o ID da organização, pasta ou projeto principal
• LOCATION: o local do Security Command Center em que gerenciar regras de exclusão temporária. Se a residência de dados estiver ativada, use eu, sa ou us. Caso contrário, use o valor global.
• MUTE_CONFIG_ID: o nome da regra de silenciamento (entre 1 e 63 caracteres).
• RULE_DESCRIPTION: uma descrição da regra de silenciamento (máximo de 1.024 caracteres).

• FILTER: a expressão definida para filtrar descobertas

  Por exemplo, para silenciar descobertas OPEN_FIREWALL, seu filtro pode ser "category=\"OPEN_FIREWALL\"".

• MUTE_TYPE: o tipo de regra de silenciamento que você quer criar. Os tipos de regras de silenciamento válidos são DYNAMIC e STATIC. Não é possível mudar o tipo de uma regra de silêncio depois de criá-la.

• TIMESTAMP: só se aplica se você estiver criando uma regra de silenciamento dinâmico. A string de data e hora que indica quando a regra de desativação dinâmica expira. O valor precisa ser definido para pelo menos um dia no futuro, caso contrário, a solicitação será rejeitada. Para informações sobre formatos de tempo, consulte gcloud topic datetimes. Quando uma regra de silenciamento dinâmico expira, ela é removida de todas as descobertas correspondentes. Se você quiser que a regra de silenciamento dinâmico funcione indefinidamente em descobertas correspondentes, omita esse campo.

A resposta inclui o ID de configuração de desativação de som que pode ser usado para ver, atualizar e excluir regras de desativação de som, conforme descrito em Gerenciar regras de desativação de som.

Novas descobertas que correspondem exatamente ao filtro estão ocultas, e o atributo mute para as descobertas é definido como MUTED.

Não há suporte para as propriedades de descoberta nas regras de silenciamento

As regras de silenciamento não são compatíveis com todas as propriedades de descoberta em filtros. Abra a seção a seguir para conferir a lista de propriedades que não são compatíveis com filtros de regras de silenciamento.

Propriedades de descoberta sem suporte

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

¹A propriedade gcpMetadata.folders contém subcampos compatíveis com filtros de silenciamento.

Listar regras de silenciamento

É possível listar as regras de exclusão em uma organização, pasta ou projeto usando o console Google Cloud , a CLI gcloud ou a API Security Command Center.

A capacidade de listar regras de silenciamento para um determinado escopo depende das permissões concedidas aos seus papéis do IAM.

Se a residência de dados estiver ativada para o Security Command Center, o escopo do comando list também será limitado ao local do Security Command Center selecionado.

Para um exemplo de código que lista regras de silenciamento, consulte Listar regras de silenciamento.

Para listar as regras de silenciamento de uma organização, pasta ou projeto, clique na guia do procedimento que você quer usar:

Console

1. No console do Google Cloud , acesse a guia Regras de desativação na página Configurações do Security Command Center.

   Acessar "Ignorar regras"

2. Se necessário, selecione o Google Cloud projeto ou a organização.

3. Na seção Ignorar regras, você vê detalhes sobre as regras de silenciamento ativas, incluindo o seguinte:

   • Nome: ID da regra de silenciamento
   • Recurso pai: o recurso em que a regra para silenciar fica.
   • Descrição: a descrição da regra de silenciamento, se disponível
   • Última atualização feita por: o principal que atualizou a regra pela última vez.
   • Última atualização: a data e a hora em que a regra foi atualizada pela última vez

gcloud

1. No console do Google Cloud , ative o Cloud Shell.

   Ativar o Cloud Shell

   Na parte de baixo do console Google Cloud , uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

2. Para listar regras de silenciamento, execute o comando gcloud scc muteconfigs list:

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

   Substitua:

   • PARENT: o organization, folder ou project principal para listar regras de silenciamento.
   • PARENT_ID: o ID da organização, pasta ou projeto principal
   • LOCATION: o local do Security Command Center em que gerenciar regras de exclusão temporária. Se a residência de dados estiver ativada, use eu, sa ou us. Caso contrário, use o valor global.

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

Java

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

public class ListMuteRules {

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

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

    listMuteRules(projectId, location);
  }

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

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

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

Python

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

    client = securitycenter_v2.SecurityCenterClient()

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

REST

Na API Security Command Center, use o método muteConfigs.list para listar regras de exclusão:

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

Substitua:

• PARENT: o recurso pai da regra de silenciamento (organizations, folders ou projects);
• PARENT_ID: o ID da organização, pasta ou projeto principal
• LOCATION: o local do Security Command Center em que gerenciar regras de exclusão temporária. Se a residência de dados estiver ativada, use eu, sa ou us. Caso contrário, use o valor global.

A resposta inclui os nomes, as descrições e os códigos de configuração de desativação de som das regras de silenciamento.

Ver a configuração de uma regra de silenciamento

É possível conferir a configuração de uma regra de exclusão usando o console Google Cloud , a CLI gcloud ou a API Security Command Center.

Para ver um exemplo de código que recupera uma configuração de regra de silenciamento, consulte Ver uma regra de silenciamento.

Para ver a configuração de uma regra de silenciamento, clique na guia do procedimento que você quer usar:

Console

1. No console do Google Cloud , acesse a guia Regras de desativação na página Configurações do Security Command Center.

   Acessar "Ignorar regras"

2. Se necessário, selecione o Google Cloud projeto ou a organização.

3. Na seção Ignorar regras, você vê uma lista das regras de silenciamento.

4. Clique no nome da regra que você quer ver.

   Uma página é aberta com a configuração da regra de silenciamento.

gcloud

1. No console do Google Cloud , ative o Cloud Shell.

   Ativar o Cloud Shell

   Na parte de baixo do console Google Cloud , uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

2. Para conferir a configuração de uma regra de silenciamento, execute o comando gcloud scc muteconfigs get:

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

   Substitua:

   • MUTE_CONFIG_ID: o ID da regra de silenciamento
   • PARENT: o recurso pai da regra de silenciamento (organization, folder ou project);
   • PARENT_ID: o ID da organização, pasta ou projeto
   • LOCATION: o local do Security Command Center em que gerenciar regras de exclusão temporária. Se a residência de dados estiver ativada, use eu, sa ou us. Caso contrário, use o valor global.

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

Java

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

public class GetMuteRule {

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

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

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

    getMuteRule(projectId, location, muteConfigId);
  }

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

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

Python

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

    client = securitycenter_v2.SecurityCenterClient()

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

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

REST

Na API Security Command Center, use o método muteConfigs.get para retornar a configuração de uma regra de exclusão:

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

Substitua:

• PARENT: o recurso pai da regra de silenciamento (organizations, folders ou projects);
• PARENT_ID: o ID da organização, pasta ou projeto
• LOCATION: o local do Security Command Center em que gerenciar regras de exclusão temporária. Se a residência de dados estiver ativada, use eu, sa ou us. Caso contrário, use o valor global.
• CONFIG_ID: o ID numérico da regra de silenciamento

Atualizar regras de silenciamento

É possível atualizar a descrição ou o filtro de descobertas de uma regra de silenciamento usando o console Google Cloud , a CLI gcloud ou a API Security Command Center.

Não é possível mudar o ID, a organização, a pasta ou o projeto pai, nem o local de uma regra de silenciamento. Para mudar qualquer um desses valores, crie uma nova regra de silenciamento.

Se você ativou as descobertas anteriormente, elas serão desativadas novamente se forem correspondidas por uma regra de desativação atualizada no console do Google Cloud . Para mais informações, consulte Ativar descobertas individuais.

Observação: as descobertas que pertencem à classe SCC errors informam problemas que impedem o funcionamento do Security Command Center. Por esse motivo, não é possível desativar o som das descobertas. Para mais informações, consulte Visão geral da resposta do Security Command Center.

Para ver um exemplo de código que atualiza uma regra de silenciamento, consulte Atualizar uma regra de silenciamento.

Para atualizar uma regra de silenciamento, clique na guia do procedimento que você quer usar:

Console

1. No console do Google Cloud , acesse a guia Regras de desativação na página Configurações do Security Command Center.

   Acessar "Ignorar regras"

2. Selecione o projeto ou a organização Google Cloud que é o recurso pai da regra de silenciamento que você quer modificar.

3. Clique no nome da regra de silenciamento que você quer modificar.

   Se você não selecionou o projeto ou a organização apropriada, talvez veja uma observação informando que não tem permissão para modificar a regra de desativação de som.

4. Faça mudanças na regra de silenciamento.

5. Opcional: depois de atualizar o filtro, clique em Visualizar descobertas correspondentes para ver as descobertas que correspondem ao filtro atualizado. Uma tabela é carregada com descobertas que correspondem à nova consulta.

6. Clique em Save.

gcloud

1. No console do Google Cloud , ative o Cloud Shell.

   Ativar o Cloud Shell

   Na parte de baixo do console Google Cloud , uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

2. Para atualizar as regras de silenciamento, execute o 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
   

   Substitua:

   • MUTE_CONFIG_ID: o ID da regra de silenciamento.
   • PARENT: o recurso pai da regra de silenciamento (organization, folder ou project).
   • PARENT_ID: o ID da organização, pasta ou projeto.
   • LOCATION: o local do Security Command Center em que gerenciar regras de exclusão temporária. Se a residência de dados estiver ativada, use eu, sa ou us. Caso contrário, use o valor global.
   • RULE_DESCRIPTION: uma descrição da regra de silenciamento (máximo de 1.024 caracteres).

   • FILTER: a expressão definida para filtrar descobertas.

     Por exemplo, para silenciar OPEN_FIREWALL descobertas, seu filtro pode ser FILTER="category=\"OPEN_FIREWALL\"".

   • MUTE_TYPE: o tipo de regra de silenciamento que você está atualizando. Os tipos de regras de silenciamento válidos são DYNAMIC e STATIC. Não é possível mudar o tipo de uma regra de silenciamento depois de criada.

   • TIMESTAMP: só se aplica se você estiver atualizando uma regra de silenciamento dinâmico. A string de data e hora que indica quando a regra de desativação dinâmica expira. O valor precisa ser definido para pelo menos um dia no futuro, caso contrário, a solicitação será rejeitada. Para informações sobre formatos de hora, consulte gcloud topic datetimes. Quando uma regra de silenciamento dinâmico expira, ela é removida de todas as descobertas correspondentes. Se você quiser que a regra de silenciamento dinâmico funcione indefinidamente em descobertas correspondentes, omita esse campo.

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

Java

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

public class UpdateMuteRule {

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

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

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

    updateMuteRule(projectId, location, muteConfigId);
  }

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

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

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

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

Python

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

    client = securitycenter_v2.SecurityCenterClient()

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

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

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

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

REST

Na API Security Command Center, use o método muteConfigs.patch para atualizar uma regra de exclusão. O corpo da solicitação é uma instância 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"
  }

Substitua:

• PARENT: o recurso pai da regra de silenciamento (organizations, folders ou projects);
• PARENT_ID: o ID da organização, pasta ou projeto
• LOCATION: o local do Security Command Center em que gerenciar regras de exclusão temporária. Se a residência de dados estiver ativada, use eu, sa ou us. Caso contrário, use o valor global.
• CONFIG_ID: o ID numérico da regra de silenciamento
• RULE_DESCRIPTION: uma descrição da regra de silenciamento (máximo de 1.024 caracteres).
• FILTER: a expressão definida para filtrar descobertas
• MUTE_TYPE: o tipo de regra de silenciamento que você está atualizando. Os tipos de regras de silenciamento válidos são DYNAMIC e STATIC. Não é possível mudar o tipo de uma regra de silenciamento depois de criada.
• TIMESTAMP: só se aplica se você estiver atualizando uma regra de silenciamento dinâmico. A string de data e hora que indica quando a regra de desativação dinâmica expira. O valor precisa ser definido para pelo menos um dia no futuro, caso contrário, a solicitação será rejeitada. Para informações sobre formatos de hora, consulte gcloud topic datetimes. Quando uma regra de silenciamento dinâmico expira, ela é removida de todas as descobertas correspondentes. Se você quiser que a regra de silenciamento dinâmico funcione indefinidamente em descobertas correspondentes, omita esse campo.

Excluir regras de silenciamento

É possível excluir uma regra de silenciamento usando o console Google Cloud , a CLI gcloud ou a API Security Command Center.

Antes de excluir regras de silenciamento, entenda o seguinte:

• Não é possível recuperar as regras de silenciamento excluídas.
• A exclusão de regras de silenciamento estáticas não ativa automaticamente o som de descobertas que estão silenciadas. É necessário ativar as descobertas de maneira manual ou programática.
• A exclusão de regras de silenciamento dinâmicas remove automaticamente a regra de todas as descobertas correspondentes anteriores e cancela o silenciamento delas se não corresponderem a nenhuma regra adicional.
• As descobertas futuras que corresponderem aos filtros nas regras de silenciamento excluídas não serão silenciadas.

Para ver um exemplo de código que exclui uma regra de silenciamento, consulte Excluir uma regra de silenciamento.

Para excluir uma regra de silenciamento, clique na guia do procedimento que você quer usar:

Console

1. No console do Google Cloud , acesse a guia Regras de desativação na página Configurações do Security Command Center.

   Acessar "Ignorar regras"

2. Se necessário, selecione o Google Cloud projeto ou a organização.

3. Clique no nome da regra de silenciamento que você quer excluir.

4. Clique em Excluir

5. Leia a caixa de diálogo e, se estiver tudo certo, clique em Excluir.

gcloud

1. No console do Google Cloud , ative o Cloud Shell.

   Ativar o Cloud Shell

   Na parte de baixo do console Google Cloud , uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

2. Para excluir regras de silenciamento, execute o comando gcloud scc muteconfigs delete:

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

   Substitua:

   • MUTE_CONFIG_ID: o ID da configuração de desativação de som
   • PARENT: o recurso pai da regra de silenciamento (organization, folder ou project);
   • PARENT_ID: o ID da organização, pasta ou projeto
   • LOCATION: o local do Security Command Center em que gerenciar regras de exclusão temporária. Se a residência de dados estiver ativada, use eu, sa ou us. Caso contrário, use o valor global.

3. Confirme sua solicitação para excluir a regra de silenciamento.

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

Na API Security Command Center, use o método muteConfigs.delete para excluir uma regra de exclusão de ruído:

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

Substitua:

• PARENT: o recurso pai da regra de silenciamento (organizations, folders ou projects);
• PARENT_ID: o ID da organização, pasta ou projeto
• LOCATION: o local do Security Command Center em que gerenciar regras de exclusão temporária. Se a residência de dados estiver ativada, use eu, sa ou us. Caso contrário, use o valor global.
• CONFIG_ID: o ID numérico da regra de silenciamento