Configurar regras de exclusão específicas do modelo

Visualizar

Este recurso está sujeito aos Termos das Soluções Pré-GA na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

É 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:

• Detecção de jailbreak e injeção de comando (PROMPT_INJECTION_AND_JAILBREAK)
• Filtros de segurança de IA responsável (RESPONSIBLE_AI)

Quando usar regras de exclusão

Use regras de exclusão específicas do modelo quando precisar suprimir detecções de falsos positivos conhecidas 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 comando incluem instruções legítimas que usam verbos imperativos (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 funcionam as correspondências de dicionário e expressão regular, consulte Regras de dicionário e expressão regular e Como funciona a correspondência.

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 Sem correspondência: ignore rows ignore the empty rows
Regra de dicionário com correspondência total (MATCHING_SCOPE_FULL_MATCH)	Seu aplicativo usa opções de comando predefinidas (como botões de resposta rápida da UI ou comandos predefinidos) em que toda a entrada corresponde a uma frase conhecida, e você quer impedir que outros textos não filtrados ignorem o filtro. 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 Sem correspondência: 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 verbos e substantivos 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? Sem correspondência: 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 estrito (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 Sem correspondência: 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 é compatível com o gerenciamento de modelos do Model Armor nem com a limpeza de comandos e respostas.

Antes de começar

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

Conseguir 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 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 conseguir 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. Instale a Google Cloud CLI e faça login na CLI gcloud com sua identidade federada. Depois de fazer login, inicialize a Google Cloud CLI executando o seguinte comando:

   gcloud init

2. Ative a API Model Armor, se 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 conseguir 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

Essa etapa só é necessária se você usa a CLI gcloud com o Model Armor e quer 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 encaminhe corretamente as solicitações para o serviço Model Armor.

Execute o comando a seguir para definir o endpoint de API para o 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

As regras de exclusão são configuradas usando a API Model Armor.

Regras de dicionário e 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 conter pelo menos uma frase, e cada frase precisa conter 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 correspondência e exclusão. 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 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: corresponde quando qualquer substring no conteúdo de entrada corresponde ao padrão de expressão regular.
  • Suporte a streaming: compatível com o modo de streaming em buffer (STREAMING_MODE_BUFFERED) e o modo de streaming em tempo real (STREAMING_MODE_REALTIME, padrão). Para mais informações, consulte Regras de exclusão na sanitização de streaming.
• Correspondência total (MATCHING_SCOPE_FULL_MATCH):
  • Regras de dicionário: faz a correspondência apenas 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: corresponde apenas quando o padrão de expressão regular corresponde a todo o conteúdo de entrada.
  • Suporte a streaming: compatível apenas no modo de streaming em buffer (STREAMING_MODE_BUFFERED). Para mais informações, consulte Regras de exclusão na limpeza de streaming.

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 esse 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 sanitização, filterMatchState é NO_MATCH_FOUND quando nada malicioso é detectado ou quando as regras de exclusão substituem os resultados do filtro. Para solução de 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 Ver registros de regras de exclusão.
• A regra não corresponde à entrada completa (MATCHING_SCOPE_FULL_MATCH): se a entrada tiver 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. Um payload de 0,5 MB é compatível com aproximadamente 130.000 tokens para texto em inglês (com cerca de 4 caracteres por token). Para textos em outros idiomas, o número de tokens compatíveis pode variar de acordo com o idioma, porque caracteres que não são em inglês exigem mais bytes por caractere. 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 os 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 de 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.

Regras de exclusão na sanitização de streaming

O Model Armor oferece suporte a regras de exclusão nos métodos de streaming StreamSanitizeUserPrompt e StreamSanitizeModelResponse. A forma como o Model Armor avalia as regras de exclusão depende do modo de streaming (streamingMode) especificado na solicitação:

• Modo armazenado em buffer (STREAMING_MODE_BUFFERED): compatível com MATCHING_SCOPE_PARTIAL_MATCH (padrão) e MATCHING_SCOPE_FULL_MATCH. O Model Armor coleta todos os blocos transmitidos e avalia as regras de exclusão em relação ao conteúdo transmitido completo:
  • Correspondência parcial (MATCHING_SCOPE_PARTIAL_MATCH): se uma frase do dicionário ou um padrão de expressão regular corresponder a qualquer substring no conteúdo transmitido, o Model Armor vai substituir o resultado do filtro e definir matchState como NO_MATCH_FOUND para esse tipo de filtro.
  • Correspondência completa (MATCHING_SCOPE_FULL_MATCH): se uma frase do dicionário ou um padrão de expressão regular corresponder a todo o conteúdo transmitido do início ao fim, o Model Armor vai substituir o resultado do filtro e definir matchState como NO_MATCH_FOUND para esse tipo de filtro. Se algum bloco adicionar texto além da frase ou do padrão configurado, a regra não será correspondente e o filtro vai reter MATCH_FOUND.
• Modo em tempo real (STREAMING_MODE_REALTIME, padrão): é compatível com MATCHING_SCOPE_PARTIAL_MATCH (padrão) e não é compatível com MATCHING_SCOPE_FULL_MATCH.
  • Correspondência parcial (MATCHING_SCOPE_PARTIAL_MATCH): o Model Armor avalia cada bloco processado de forma independente (retornado em sanitizationMetadata.streamChunkProcessed quando filterMatchState é NO_MATCH_FOUND). Se uma frase do dicionário ou um padrão de expressão regular corresponder a um bloco processado, o Model Armor vai substituir o resultado do filtro e definir matchState como NO_MATCH_FOUND para esse bloco, enquanto continua a avaliar os blocos subsequentes no stream de forma independente. Se uma frase ou padrão excluído for dividido em blocos processados separados, os fragmentos parciais não vão corresponder. Se um bloco anterior acionar um veredito MATCH_FOUND sem corresponder a uma regra de exclusão, o stream vai permanecer bloqueado para os blocos seguintes.
  • Correspondência completa (MATCHING_SCOPE_FULL_MATCH): não compatível. Se um modelo incluir uma regra de exclusão com MATCHING_SCOPE_FULL_MATCH e a solicitação usar o modo de streaming em tempo real, o Model Armor vai rejeitar a solicitação com o seguinte erro INVALID_ARGUMENT: Invalid filter rule settings: FULL_MATCH matching scope is not supported in real-time streaming mode. UsePARTIAL_MATCHorSTREAMING_MODE_BUFFERED`.

Para exemplos de sanitização de streaming com regras de exclusão, consulte Sanitizar um comando de streaming com uma regra de exclusão e Sanitizar uma resposta de streaming 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 aceita regras de exclusão nas configurações mínimas.
• Na higienização de streaming, o Model Armor é compatível com regras de exclusão de correspondência completa (MATCHING_SCOPE_FULL_MATCH) apenas no modo em buffer (STREAMING_MODE_BUFFERED). O uso de MATCHING_SCOPE_FULL_MATCH no modo em tempo real (STREAMING_MODE_REALTIME, o modo de streaming padrão) retorna o seguinte erro INVALID_ARGUMENT: Invalid filter rule settings: FULL_MATCH matching scope is not supported in real-time streaming mode. UsePARTIAL_MATCHorSTREAMING_MODE_BUFFERED`.
• 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 são compatíveis com a detecção de vários idiomas ou a tradução automática. Para excluir conteúdo em vários idiomas, adicione frases específicas do idioma ou padrões de expressão regular para cada idioma-alvo.
• As regras de exclusão têm suporte limitado para idiomas de script não latinos 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 completa (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 aos 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 comandos e jailbreak e os 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 contêm frases especificadas, como ignore case when sorting this list ou ignore empty rows, de 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 que serão excluídas da detecção de jailbreak e injeção de comando, como 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 de IA responsável, por exemplo, (?i)kill process [0-9]+.
• PROJECT_ID: o ID do projeto ao qual 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 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 que serão excluídas da detecção de jailbreak e injeção de comando, como 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 ao qual 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, limite seus padrões a termos de domínio específicos ou substantivos de destino para que o Model Armor exclua falsos positivos conhecidos sem ignorar violações de segurança genuínas. Ao transmitir padrões de expressão regular dentro de corpos de solicitação JSON ("pattern"), use uma segunda barra invertida para cada 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 mostra 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 falso positivo de injeção de comando e jailbreak.

Categoria de instrução	Termos de acionamento	Cenários de falsos positivos	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

Documentações técnicas, comandos de administração do sistema e expressões comuns geralmente contêm palavras que se sobrepõem às categorias de segurança de IA responsável. Para reduzir falsos positivos em comandos ou respostas maiores, 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.

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 falsos positivos	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 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, idiomas de entretenimento e equipamentos industriais ou 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, 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 os falsos positivos sem enfraquecer a postura de segurança do modelo:

• Defina regras de escopo restritas a contextos específicos: evite excluir verbos únicos ou termos amplos (como ignore, kill ou abort) ou usar caracteres curinga irrestritos (como .*ignore.*). Como MATCHING_SCOPE_PARTIAL_MATCH substitui matchState por NO_MATCH_FOUND em todo o filtro sempre que uma substring corresponde, regras excessivamente amplas podem mascarar violações genuínas em outras partes do mesmo comando ou resposta. Sempre combine verbos de acionamento 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 comandos predefinidos da UI, comandos predefinidos ou payloads de teste automatizados, defina matchingScope como MATCHING_SCOPE_FULL_MATCH (ou ancore expressões regulares com ^ e $). O escopo de correspondência completa impede que os usuários adicionem instruções adversárias a uma frase excluída para ignorar a detecção.
• Escreva 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ão regular para cada idioma compatível com o aplicativo.
• Revise e remova as regras temporárias após os upgrades de filtro: ao fazer upgrade de um modelo para uma versão de filtro mais recente, reavalie os casos de teste de falso positivo e remova as regras de exclusão que foram resolvidas pelos modelos de detecção atualizados.

A seguir

• Veja exemplos de como limpar comandos e limpar respostas do modelo com regras de exclusão.
• Revise os limites do sistema de regras de exclusão.
• Saiba como configurar a geração de registros para o Model Armor.
• Saiba como criar e gerenciar modelos do Model Armor.