Configurar regras de exclusão específicas do modelo

É possível configurar regras de exclusão específicas de modelo no Model Armor para mitigar detecções de falsos positivos. As regras de exclusão são regras específicas do modelo que contêm expressões regulares ou frases a serem excluídas da detecção.

Filtros compatíveis

É possível usar regras de exclusão para os seguintes filtros:

Quando usar regras de exclusão

Use regras de exclusão específicas do modelo quando precisar suprimir detecções de falsos positivos conhecidos para cargas de trabalho específicas sem desativar um filtro por completo:

  • Terminologia técnica ou específica do domínio: seu aplicativo processa vocabulário especializado, como comandos de administração do sistema (kill process, abort transaction), terminologia de teste de segurança (penetration testing), termos científicos (blast search) ou expressões idiomáticas do setor, que se sobrepõem às categorias de segurança da IA responsável.
  • Instruções operacionais ou de formatação benignas: seus usuários ou modelos de comandos incluem instruções legítimas que usam verbos no imperativo (como "ignore case when sorting this list", "ignore empty rows" ou "Summarize my inbox and ignore the emails from the marketing vendor.") que acionam falsos positivos na detecção de jailbreak e injeção de comando.
  • Mitigação direcionada enquanto aguarda atualizações do modelo: você precisa de uma solução alternativa imediata para um falso positivo verificado em um fluxo de trabalho de aplicativo específico, mantendo o filtro ativo para todas as outras entradas.

A tabela a seguir descreve quando usar cada combinação de tipo de regra e escopo de correspondência. Para mais informações sobre como a correspondência de dicionário e de expressão regular funciona, consulte Regras de dicionário e de expressão regular e Como a correspondência funciona.

Configuração da regra Quando usar Exemplo
Regra de dicionário com correspondência parcial (MATCHING_SCOPE_PARTIAL_MATCH) Você tem uma lista fixa de palavras ou frases estáticas que podem aparecer em qualquer lugar de um comando ou resposta. Para mais informações sobre o comportamento de correspondência de dicionário, consulte Regras de dicionário e expressão regular.

O dicionário contém a frase ignore empty rows

Correspondências:

  • ignore empty rows
  • ignore EMPTY-rows
  • please ignore empty rows

Não corresponde a:

  • ignore rows
  • ignore the empty rows
Regra de dicionário com correspondência total (MATCHING_SCOPE_FULL_MATCH) Seu aplicativo usa opções de comandos predefinidas (como botões de resposta rápida da UI ou comandos prontos) em que toda a entrada corresponde a uma frase conhecida, e você quer evitar que mais texto não filtrado bypasse o filtro. Para mais informações sobre o comportamento da correspondência de dicionário, consulte Regras de dicionário e de expressão regular.

O dicionário contém a frase ignore empty rows

Correspondências:

  • ignore empty rows
  • ignore EMPTY-rows

Não corresponde a:

  • please ignore empty rows
  • ignore rows
Regra de expressão regular com correspondência parcial (MATCHING_SCOPE_PARTIAL_MATCH) Você precisa excluir padrões estruturados, identificadores dinâmicos ou combinações específicas de verbo e substantivo em comandos ou respostas maiores. Para mais informações, consulte Exemplos de padrões de exclusão de expressões regulares.

Padrão de expressão regular: (?i)kill process [0-9]+

Correspondências:

  • kill process 1234
  • How do I Kill Process 99?

Não corresponde a:

  • kill process abc
  • kill the process 1234
Regra de expressão regular com correspondência total (MATCHING_SCOPE_FULL_MATCH) Todo o payload de entrada segue um formato estrutural rígido, como um identificador de teste automatizado ou um comando estruturado.

Padrão de expressão regular: (?i)^test_case_[0-9]+$

Correspondências:

  • test_case_42
  • TEST_CASE_001

Não corresponde a:

  • run test_case_42
  • test_case_alpha

Usar um endpoint regional ou multirregional

Ao trabalhar com um modelo do Model Armor, use um endpoint regional ou multirregional (modelarmor.LOCATION.rep.googleapis.com) que corresponda ao local do modelo. Para informações sobre como a residência de dados é aplicada em cada região ou multirregião, consulte Aplicação da residência de dados para modelos.

O endpoint global (modelarmor.googleapis.com) não oferece suporte ao gerenciamento de modelos do Model Armor nem à limpeza de comandos e respostas.

Antes de começar

Antes de começar, conclua as tarefas a seguir.

Receber as permissões necessárias

Para receber as permissões necessárias para configurar regras de exclusão em modelos do Model Armor, peça ao administrador para conceder a você o papel do IAM de Administrador do Model Armor (roles/modelarmor.admin) no projeto que contém o modelo do Model Armor. 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.

Ativar APIs

É necessário ativar a API Model Armor antes de usar o Model Armor.

Console

  1. Ative a API Model Armor, se ela ainda não estiver ativada.

    Funções necessárias para ativar APIs

    Para ativar APIs, você precisa da permissão serviceusage.services.enable. Se você criou o projeto, provavelmente já tem essa permissão pelo papel de proprietário (roles/owner). Caso contrário, é possível receber essa permissão pelo papel de administrador do Service Usage (roles/serviceusage.serviceUsageAdmin). Saiba como conceder papéis.

    Ativar a API

  2. Selecione o projeto em que você quer ativar o Model Armor.

gcloud

Antes de começar, siga estas etapas usando a Google Cloud CLI com a API Model Armor:

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

    Ativar o Cloud Shell

    Na parte inferior do console do 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. Ative a API Model Armor, se ela ainda não estiver ativada:

    Funções necessárias para ativar APIs

    Para ativar APIs, você precisa da permissão serviceusage.services.enable. Se você criou o projeto, provavelmente já tem essa permissão pelo papel de Proprietário (roles/owner). Caso contrário, é possível receber essa permissão pelo papel de Administrador do Service Usage (roles/serviceusage.serviceUsageAdmin). Saiba como conceder papéis. 

    gcloud services enable modelarmor.googleapis.com

  3. Defina a substituição do endpoint de API usando a CLI gcloud.

Definir a substituição do endpoint de API usando a CLI gcloud

Esta etapa só é necessária se você usar a CLI gcloud com o Model Armor e quiser usar uma região ou multirregião diferente da multirregião padrão us. É necessário definir manualmente a substituição do endpoint de API para garantir que a CLI gcloud roteie corretamente as solicitações para o serviço Model Armor.

Execute o comando a seguir para definir o endpoint de API do serviço Model Armor.

gcloud config set api_endpoint_overrides/modelarmor "https://modelarmor.LOCATION.rep.googleapis.com/"

Substitua LOCATION pela região ou multirregião em que você quer usar o Model Armor.

Como as regras de exclusão funcionam

Configure as regras de exclusão usando a API Model Armor.

Regras de dicionário e de expressão regular

É possível definir dois tipos de regras de exclusão em um modelo do Model Armor:

  • Regras de dicionário: especifique uma lista de palavras ou frases (wordList, até 128 KB por dicionário) para excluir. Um dicionário precisa ter pelo menos uma frase, e cada frase precisa ter pelo menos dois caracteres que sejam letras ou dígitos. A correspondência de dicionário funciona da seguinte maneira:
    • Não diferenciação de maiúsculas de minúsculas: as palavras e frases do dicionário não diferenciam maiúsculas de minúsculas.
    • Caracteres não alfanuméricos: ao procurar correspondências, todos os caracteres que não sejam letras e dígitos no Plano Multilíngue Básico do Unicode são substituídos por espaços em branco. Por exemplo, a frase do dicionário Sam Johnson corresponde a sam johnson, Sam, Johnson e Sam (Johnson). Frases de dicionário que contêm muitos caracteres que não são letras ou dígitos podem produzir correspondências inesperadas porque esses caracteres são tratados como espaços em branco.
    • Limites de caracteres: os caracteres ao redor de uma correspondência precisam ser de um tipo diferente dos caracteres adjacentes na palavra do dicionário. As letras precisam ser adjacentes a não letras, e os dígitos precisam ser adjacentes a não dígitos. Por exemplo, a palavra do dicionário jen corresponde às três primeiras letras de jen123, mas não corresponde a jennifer.
  • Regras de expressão regular: especifique um padrão de expressão regular (até 1.000 caracteres) para corresponder e excluir. Por padrão, as correspondências de expressões regulares diferenciam maiúsculas de minúsculas. Para realizar uma correspondência que não diferencia maiúsculas de minúsculas, inclua a flag (?i) no seu padrão. Por exemplo, (?i)kill process [0-9]+ corresponde a kill process 1234 e Kill Process 1234.

Como a correspondência funciona

Cada regra de exclusão é compatível com o campo matchingScope, que especifica como o Model Armor compara o conteúdo de entrada com a regra:

  • Correspondência parcial (MATCHING_SCOPE_PARTIAL_MATCH, padrão):
    • Regras de dicionário: correspondem quando uma palavra ou frase no dicionário corresponde a uma substring no conteúdo de entrada, sujeita às regras de limite de caracteres do dicionário. Por exemplo, a frase do dicionário ignore empty rows corresponde a ignore empty rows, ignore EMPTY-rows e Please ignore empty rows and summarize this table, mas não a ignore rows ou ignore the empty rows.
    • Regras de expressão regular: correspondem quando qualquer substring no conteúdo de entrada corresponde ao padrão de expressão regular.
  • Correspondência total (MATCHING_SCOPE_FULL_MATCH):
    • Regras de dicionário: só há correspondência quando a entrada do dicionário abrange todo o conteúdo de entrada. Por exemplo, a frase do dicionário ignore empty rows corresponde a ignore empty rows e ignore EMPTY-rows, mas não a please ignore empty rows ou ignore rows.
    • Regras de expressão regular: a correspondência só ocorre quando o padrão de expressão regular corresponde a todo o conteúdo de entrada.

Substituições de regras de exclusão durante a limpeza

Se um modelo incluir regras de exclusão, o Model Armor vai avaliar essas regras durante a sanitização de comandos e respostas do modelo sempre que um filtro de detecção de injeção de comandos e jailbreak (PROMPT_INJECTION_AND_JAILBREAK) ou de IA responsável (RESPONSIBLE_AI) identificar uma possível correspondência:

  • A regra corresponde à entrada: se uma regra de exclusão corresponder a uma substring (MATCHING_SCOPE_PARTIAL_MATCH, padrão) ou a toda a entrada do início ao fim (MATCHING_SCOPE_FULL_MATCH), o Model Armor vai substituir um resultado de filtro MATCH_FOUND ou EXECUTION_SKIPPED e definir matchState como NO_MATCH_FOUND para todo o tipo de filtro compatível (incluindo todas as categorias de segurança de IA responsável para RESPONSIBLE_AI), em vez de excluir frases ou intervalos individuais na entrada. Na resposta de higienização, filterMatchState é NO_MATCH_FOUND quando nada malicioso é detectado ou quando as regras de exclusão substituem os resultados da filtragem. Para resolver problemas, ative o Cloud Logging para operações de limpeza (logSanitizeOperations) no modelo e filtre os rótulos modelarmor.googleapis.com/exclusion_rule_overridden_filters ou modelarmor.googleapis.com/exclusion_rule_skipped_filters. O Model Armor registra esses rótulos quando as regras de exclusão substituem os resultados do filtro ou quando o executionState de um filtro é EXECUTION_SKIPPED. Para mais informações, consulte Visualizar registros de regras de exclusão.
  • A regra não corresponde à entrada completa (MATCHING_SCOPE_FULL_MATCH): se a entrada contiver texto adicional além da frase ou do padrão configurado, a regra não vai corresponder e o filtro vai manter MATCH_FOUND.
  • A entrada excede 130.000 tokens (0,5 MB): as regras de exclusão avaliam apenas os primeiros 130.000 tokens (0,5 MB) do texto de entrada. Se uma entrada exceder 130.000 tokens (0,5 MB) e um filtro detectar uma correspondência fora da parte inicial verificada, o filtro vai retornar EXECUTION_SKIPPED. Para detalhes sobre valores de messageItems e limites de payload, consulte Limites do sistema de regras de exclusão.

Para exemplos de higienização de comandos e respostas do modelo com regras de exclusão, consulte Higienizar um comando com uma regra de exclusão e Higienizar uma resposta com uma regra de exclusão.

Considerações

Ao configurar regras de exclusão, considere o seguinte:

  • As regras de exclusão se aplicam apenas ao modelo em que são definidas. Não é possível compartilhar regras de exclusão entre modelos.
  • Só é possível configurar regras de exclusão para um tipo de filtro compatível quando esse filtro está ativado no modelo. Para detecção de jailbreak e injeção de comando (PROMPT_INJECTION_AND_JAILBREAK), defina filterEnforcement como ENABLED em piAndJailbreakFilterSettings. Para ativar os filtros de segurança de IA responsável (RESPONSIBLE_AI), configure pelo menos uma categoria de segurança de IA responsável em raiSettings.raiFilters.
  • O Model Armor não é compatível com regras de exclusão em APIs de streaming ou configurações mínimas.
  • O Model Armor avalia as regras de exclusão em relação ao texto de entrada bruto antes de realizar transformações de texto, como desidentificação ou tradução. As regras de exclusão não oferecem suporte à detecção de vários idiomas nem à tradução automática. Para excluir conteúdo em vários idiomas, adicione frases específicas ou padrões de expressão regular para cada idioma de destino.
  • As regras de exclusão têm suporte limitado para idiomas que não usam o alfabeto latino e caracteres UTF-8 de vários bytes. Em particular, as regras de dicionário (wordList) podem não corresponder ao esperado para scripts que usam marcas de combinação (como scripts índicos) ou scripts sem espaços entre palavras (como chinês e japonês). As regras de correspondência exata (MATCHING_SCOPE_FULL_MATCH) não correspondem a entradas que contêm caracteres UTF-8 de vários bytes. Ao excluir conteúdo em scripts não latinos ou entradas com caracteres multibyte, use regras de expressão regular (regex) com MATCHING_SCOPE_PARTIAL_MATCH.
  • As regras de exclusão estão sujeitas a limites do sistema. Para mais informações, consulte Limites do sistema de regras de exclusão.

Criar um modelo com regras de exclusão

Para criar um modelo com regras de exclusão, inclua o objeto filterRuleSettings em filterConfig em uma solicitação POST.

O exemplo a seguir cria um modelo que ativa a detecção de injeção de comando e jailbreak e filtros de segurança de IA responsável, além de configurar duas regras de exclusão com correspondência parcial (MATCHING_SCOPE_PARTIAL_MATCH):

  • Detecção de jailbreak e injeção de comando (PROMPT_INJECTION_AND_JAILBREAK): usa uma regra de dicionário para excluir entradas que contenham frases específicas, como ignore case when sorting this list ou ignore empty rows, das detecções de jailbreak e injeção de comando.
  • IA responsável (RESPONSIBLE_AI): usa uma regra de expressão regular para excluir entradas que correspondem a um padrão especificado, como (?i)kill process [0-9]+, das detecções de segurança de IA responsável.
export TEMPLATE_WITH_EXCLUSIONS='{
  "filterConfig": {
    "piAndJailbreakFilterSettings": {
      "filterEnforcement": "ENABLED",
      "confidenceLevel": "LOW_AND_ABOVE"
    },
    "raiSettings": {
      "raiFilters": [
        {
          "filterType": "DANGEROUS",
          "confidenceLevel": "LOW_AND_ABOVE"
        },
        {
          "filterType": "HARASSMENT",
          "confidenceLevel": "LOW_AND_ABOVE"
        },
        {
          "filterType": "HATE_SPEECH",
          "confidenceLevel": "LOW_AND_ABOVE"
        },
        {
          "filterType": "SEXUALLY_EXPLICIT",
          "confidenceLevel": "LOW_AND_ABOVE"
        }
      ]
    },
    "filterRuleSettings": {
      "ruleSets": [
        {
          "filterTypes": [
            "PROMPT_INJECTION_AND_JAILBREAK"
          ],
          "rules": [
            {
              "exclusionRule": {
                "dictionary": {
                  "wordList": {
                    "words": [
                      "EXCLUDED_PHRASE_1",
                      "EXCLUDED_PHRASE_2"
                    ]
                  }
                },
                "matchingScope": "MATCHING_SCOPE_PARTIAL_MATCH"
              }
            }
          ]
        },
        {
          "filterTypes": [
            "RESPONSIBLE_AI"
          ],
          "rules": [
            {
              "exclusionRule": {
                "regex": {
                  "pattern": "EXCLUDED_REGEX_PATTERN"
                },
                "matchingScope": "MATCHING_SCOPE_PARTIAL_MATCH"
              }
            }
          ]
        }
      ]
    }
  }
}'

curl -X POST \
  -d "$TEMPLATE_WITH_EXCLUSIONS" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates?template_id=TEMPLATE_ID"

Substitua:

  • EXCLUDED_PHRASE_1 e EXCLUDED_PHRASE_2: as palavras ou frases do dicionário a serem excluídas da detecção de jailbreak e injeção de comando. Por exemplo, ignore case when sorting this list e ignore empty rows.
  • EXCLUDED_REGEX_PATTERN: o padrão de expressão regular a ser excluído da detecção de segurança da IA responsável, por exemplo, (?i)kill process [0-9]+.
  • PROJECT_ID: o ID do projeto a que o modelo pertence.
  • LOCATION: o local do modelo.
  • TEMPLATE_ID: o ID do modelo.

Esse comando retorna uma resposta semelhante a esta:

{
  "filterConfig": {
    "raiSettings": {
      "raiFilters": [
        {
          "filterType": "DANGEROUS",
          "confidenceLevel": "LOW_AND_ABOVE"
        },
        {
          "filterType": "HARASSMENT",
          "confidenceLevel": "LOW_AND_ABOVE"
        },
        {
          "filterType": "HATE_SPEECH",
          "confidenceLevel": "LOW_AND_ABOVE"
        },
        {
          "filterType": "SEXUALLY_EXPLICIT",
          "confidenceLevel": "LOW_AND_ABOVE"
        }
      ]
    },
    "piAndJailbreakFilterSettings": {
      "filterEnforcement": "ENABLED",
      "confidenceLevel": "LOW_AND_ABOVE"
    },
    "filterRuleSettings": {
      "ruleSets": [
        {
          "filterTypes": [
            "PROMPT_INJECTION_AND_JAILBREAK"
          ],
          "rules": [
            {
              "exclusionRule": {
                "dictionary": {
                  "wordList": {
                    "words": [
                      "ignore case when sorting this list",
                      "ignore empty rows"
                    ]
                  }
                },
                "matchingScope": "MATCHING_SCOPE_PARTIAL_MATCH"
              }
            }
          ]
        },
        {
          "filterTypes": [
            "RESPONSIBLE_AI"
          ],
          "rules": [
            {
              "exclusionRule": {
                "regex": {
                  "pattern": "(?i)kill process [0-9]+"
                },
                "matchingScope": "MATCHING_SCOPE_PARTIAL_MATCH"
              }
            }
          ]
        }
      ]
    }
  },
  "templateMetadata": {
    "dataResidencyCompliant": true
  }
}

Atualizar regras de exclusão em um modelo

Para atualizar as regras de exclusão em um modelo, envie uma solicitação PATCH com updateMask definido como filterConfig.filterRuleSettings. Como a atualização substitui todo o campo filterRuleSettings, inclua todas as regras que você quer manter junto com as modificações.

O exemplo a seguir atualiza as regras de exclusão do exemplo anterior adicionando uma regra de expressão regular ao conjunto de regras PROMPT_INJECTION_AND_JAILBREAK e removendo o conjunto de regras RESPONSIBLE_AI:

export EXCLUSION_RULES_UPDATE='{
  "filterConfig": {
    "filterRuleSettings": {
      "ruleSets": [
        {
          "filterTypes": [
            "PROMPT_INJECTION_AND_JAILBREAK"
          ],
          "rules": [
            {
              "exclusionRule": {
                "dictionary": {
                  "wordList": {
                    "words": [
                      "EXCLUDED_PHRASE_1",
                      "EXCLUDED_PHRASE_2"
                    ]
                  }
                },
                "matchingScope": "MATCHING_SCOPE_PARTIAL_MATCH"
              }
            },
            {
              "exclusionRule": {
                "regex": {
                  "pattern": "EXCLUDED_REGEX_PATTERN"
                },
                "matchingScope": "MATCHING_SCOPE_FULL_MATCH"
              }
            }
          ]
        }
      ]
    }
  }
}'

curl -X PATCH \
  -d "$EXCLUSION_RULES_UPDATE" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID?updateMask=filterConfig.filterRuleSettings"

Substitua:

  • EXCLUDED_PHRASE_1 e EXCLUDED_PHRASE_2: as palavras ou frases do dicionário a serem excluídas da detecção de jailbreak e injeção de comando, por exemplo, ignore case when sorting this list e ignore empty rows.
  • EXCLUDED_REGEX_PATTERN: o padrão de expressão regular a ser excluído da detecção de jailbreak e injeção de comando. Por exemplo, (?i)\\b(?:ignore\\s+(?:the\\s+)?(?:emails?|spams?|warnings?|drafts?|typos?|duplicates?|noise))\\b.
  • PROJECT_ID: o ID do projeto a que o modelo pertence.
  • LOCATION: o local do modelo.
  • TEMPLATE_ID: o ID do modelo.

Exemplos de padrões de exclusão de expressões regulares

Ao escrever regras de exclusão de expressões regulares, defina o escopo dos padrões para termos de domínio ou substantivos específicos. Assim, o Model Armor exclui falsos positivos conhecidos sem ignorar violações de segurança ou proteção genuínas. Ao transmitir padrões de expressão regular em corpos de solicitação JSON ("pattern"), faça o escape de cada barra invertida com uma segunda barra invertida. Por exemplo, use \\b e \\s.

Exemplos de detecção de jailbreak e injeção de comando

Verbos imperativos como ignore, disregard, bypass ou override aparecem com frequência tanto em injeções de comandos maliciosos quanto em instruções legítimas para triagem de e-mails, formatação de dados, tratamento de erros ou configuração do sistema. Para evitar a exclusão de categorias amplas de comandos, combine limites de palavras (\\b), grupos sem captura ((?:...)) e a flag que não diferencia maiúsculas de minúsculas ((?i)) com MATCHING_SCOPE_PARTIAL_MATCH para ancorar sua expressão regular a substantivos de destino operacional específicos.

A tabela a seguir fornece um exemplo de padrão de expressão regular de correspondência parcial (com barras invertidas com escape JSON) e um exemplo de comando para um cenário comum de injeção de comando e falso positivo de jailbreak.

Categoria de instrução Termos de acionamento Cenários de falso positivo Exemplo de padrão de expressão regular de correspondência parcial Exemplo de comando
Triagem e filtragem de conteúdo ignore, disregard Triagem de e-mails, tratamento de erros e revisão de rascunhos (?i)\\b(?:ignore\\s+(?:the\\s+)?(?:emails?|spams?|warnings?|drafts?|typos?|duplicates?|noise))\\b Summarize my inbox and ignore the emails from the marketing vendor.

Exemplos de filtros de segurança de IA responsável

A documentação técnica, os comandos de administração do sistema e as expressões idiomáticas comuns geralmente contêm palavras que se sobrepõem às categorias de segurança da IA responsável. Para reduzir os falsos positivos em comandos ou respostas maiores, combine limites de palavras (\\b), grupos não capturados ((?:...)) e a flag sem diferenciação de maiúsculas e minúsculas ((?i)) com MATCHING_SCOPE_PARTIAL_MATCH.

A tabela a seguir mostra exemplos de padrões de expressão regular de correspondência parcial (com barras invertidas com escape JSON) e exemplos de comandos para cenários comuns de falsos positivos de IA responsável.

Categoria de risco Termos de acionamento Cenários de falso positivo Exemplo de padrão de expressão regular de correspondência parcial Exemplo de comando
Violência ou ofensa kill Encerramento de processos, interruptores elétricos ou de AVAC e expressões idiomáticas comuns (?i)\\b(?:kill\\s+(?:-9|all|process(?:es)?|switch(?:es)?|jobs?|pods?|sessions?|bill|lights?)|time\\s+to\\s+kill|dressed\\s+to\\s+kill)\\b Please kill all pods in the namespace.
Toxicidade ou linguagem ofensiva abort, terminate Transações de banco de dados, ciclo de vida da missão e termos de emprego ou contrato (?i)\\b(?:abort\\s+(?:transactions?|missions?|requests?|connections?|retry|retries)|terminate\\s+(?:contracts?|sessions?|threads?|instances?|connections?))\\b Abort retry.
Correspondências de substring em termos de domínio Substrings de caracteres sobrepostas Termos acadêmicos, botânica, ornitologia, aviação e nomes próprios (?i)\\b(?:class(?:room|ic)?|assess(?:ment)?|associate|passive|peacock|cockpit|cocktail|dickens)\\b I love reading Dickens.
Armas ou explosivos bomb, blast, detonate Bioinformática, expressões de entretenimento e equipamentos industriais ou de limpeza (?i)\\b(?:blast\\s+(?:search|alignment|radius|furnace)|box\\s+office\\s+bomb|had\\s+a\\s+blast)\\b Run a blast search on the genetic sequence.

Ver registros de regras de exclusão

Para registrar os resultados da avaliação da regra de exclusão de registros, defina logSanitizeOperations como true ao configurar a geração de registros em modelos. Quando a geração de registros está ativada, o Model Armor grava entradas de registro SanitizeOperationLogEntry para o recurso monitorado modelarmor.googleapis.com/SanitizeOperation no Cloud Logging.

Para mais informações sobre como ativar e consultar registros de sanitização, consulte Configurar a geração de registros.

Práticas recomendadas para configurar regras de exclusão

Siga estas práticas recomendadas para minimizar falsos positivos sem enfraquecer a postura de segurança do modelo:

  • Delimite as regras de escopo a contextos específicos: evite excluir verbos únicos ou termos gerais (como ignore, kill ou abort) ou usar caracteres curinga sem restrições (como .*ignore.*). Como MATCHING_SCOPE_PARTIAL_MATCH substitui matchState a NO_MATCH_FOUND em todo o filtro sempre que uma substring corresponde, regras muito amplas podem mascarar violações reais em outro lugar no mesmo comando ou resposta. Sempre combine verbos de gatilho com substantivos de destino específicos (por exemplo, ignore case when sorting this list ou (?i)kill process [0-9]+).
  • Use limites de palavras e consolide padrões: nas regras de expressão regular, use limites de palavras (\b) para evitar correspondências acidentais de substrings em palavras não relacionadas. Consolide frases relacionadas em uma única expressão regular usando grupos sem captura ((?:...)) e alternância (|) para permanecer dentro do limite do sistema de 10 regras por conjunto de regras.
  • Prefira MATCHING_SCOPE_FULL_MATCH para entradas previsíveis: ao excluir solicitações predefinidas da UI, comandos prontos ou payloads de teste automatizados, defina matchingScope como MATCHING_SCOPE_FULL_MATCH ou ancore expressões regulares com ^ e $. O escopo de correspondência exata impede que os usuários anexem instruções adversárias a uma frase excluída para burlar a detecção.
  • Escrever regras para texto bruto e não transformado: o Model Armor avalia as regras de exclusão antes da desidentificação ou tradução. Verifique se os padrões correspondem ao formato original antes da desidentificação e adicione frases específicas do idioma ou padrões de expressões regulares para cada idioma compatível com seu aplicativo.
  • Analise e desative regras temporárias após upgrades de filtro: quando você faz upgrade de um modelo para uma versão de filtro mais recente, reavalie seus casos de teste de falso positivo e remova as regras de exclusão que são resolvidas pelos modelos de detecção atualizados.

A seguir