Configurare regole di esclusione specifiche per i modelli

Puoi configurare regole di esclusione specifiche per i template in Model Armor per mitigare i rilevamenti di falsi positivi. Le regole di esclusione sono regole specifiche del template che contengono espressioni regolari o frasi da escludere dal rilevamento.

Filtri supportati

Puoi utilizzare le regole di esclusione per i seguenti filtri:

Quando utilizzare le regole di esclusione

Utilizza le regole di esclusione specifiche per i template quando devi eliminare i rilevamenti di falsi positivi noti per workload specifici senza disattivare completamente un filtro:

  • Terminologia tecnica o specifica del dominio: la tua applicazione elabora un vocabolario specializzato, come i comandi di amministrazione di sistema (kill process, abort transaction), la terminologia dei test di sicurezza (penetration testing), i termini scientifici (blast search) o le espressioni idiomatiche del settore, che si sovrappone alle categorie di sicurezza dell'AI responsabile.
  • Istruzioni operative o di formattazione innocue: i tuoi utenti o i template di prompt includono istruzioni legittime che utilizzano verbi imperativi (come "ignore case when sorting this list", "ignore empty rows" o "Summarize my inbox and ignore the emails from the marketing vendor.") che attivano falsi positivi nel rilevamento di prompt injection e jailbreak.
  • Mitigazione mirata in attesa degli aggiornamenti del modello: hai bisogno di una soluzione alternativa immediata per un falso positivo verificato in un flusso di lavoro specifico dell'applicazione, mantenendo il filtro attivo per tutti gli altri input.

La tabella seguente descrive quando utilizzare ogni combinazione di tipo di regola e ambito di corrispondenza. Per saperne di più su come funzionano le corrispondenze con dizionari ed espressioni regolari, consulta Regole per dizionari ed espressioni regolari e Come funzionano le corrispondenze.

Configurazione della regola Quando utilizzarlo Esempio
Regola del dizionario con corrispondenza parziale (MATCHING_SCOPE_PARTIAL_MATCH) Hai un elenco fisso di parole o frasi statiche che possono apparire ovunque all'interno di un prompt o di una risposta. Per saperne di più sul comportamento di corrispondenza del dizionario, consulta Regole per dizionari ed espressioni regolari.

Il dizionario contiene la frase ignore empty rows

Risultati:

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

Non corrisponde a:

  • ignore rows
  • ignore the empty rows
Regola del dizionario con corrispondenza completa (MATCHING_SCOPE_FULL_MATCH) La tua applicazione utilizza opzioni di prompt predefinite (come i pulsanti di risposta rapida dell'interfaccia utente o i comandi predefiniti) in cui l'intero input corrisponde a una frase nota e vuoi impedire che altro testo non filtrato aggiri il filtro. Per saperne di più sul comportamento di corrispondenza del dizionario, consulta Regole per dizionari ed espressioni regolari.

Il dizionario contiene la frase ignore empty rows

Risultati:

  • ignore empty rows
  • ignore EMPTY-rows

Non corrisponde a:

  • please ignore empty rows
  • ignore rows
Regola di espressione regolare con corrispondenza parziale (MATCHING_SCOPE_PARTIAL_MATCH) Devi escludere pattern strutturati, identificatori dinamici o combinazioni specifiche di verbi e sostantivi all'interno di prompt o risposte più ampi. Per saperne di più, consulta Esempi di pattern di esclusione delle espressioni regolari.

Pattern di espressione regolare: (?i)kill process [0-9]+

Risultati:

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

Non corrisponde a:

  • kill process abc
  • kill the process 1234
Regola di espressione regolare con corrispondenza completa (MATCHING_SCOPE_FULL_MATCH) L'intero payload di input segue un formato strutturale rigido (ad esempio un identificatore di test automatico o un comando strutturato).

Pattern di espressione regolare: (?i)^test_case_[0-9]+$

Risultati:

  • test_case_42
  • TEST_CASE_001

Non corrisponde a:

  • run test_case_42
  • test_case_alpha

Utilizza un endpoint regionale o multiregionale

Quando utilizzi un template Model Armor, devi utilizzare un endpoint regionale o multiregionale (modelarmor.LOCATION.rep.googleapis.com) corrispondente alla località del template. Per informazioni su come viene applicata la residenza dei dati per ogni regione o multi-regione, consulta Applicazione della residenza dei dati per i template.

L'endpoint globale (modelarmor.googleapis.com) non supporta la gestione dei template Model Armor o la sanitizzazione di prompt e risposte.

Prima di iniziare

Prima di iniziare, completa le seguenti attività.

Ottieni le autorizzazioni richieste

Per ottenere le autorizzazioni necessarie per configurare le regole di esclusione nei template di Model Armor, chiedi all'amministratore di concederti il ruolo IAM Amministratore di Model Armor (roles/modelarmor.admin) sul progetto Model Armor che contiene il template di Model Armor. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Abilita API

Per poter utilizzare Model Armor, devi abilitare l'API Model Armor.

Console

  1. Abilita l'API Model Armor, se non è già abilitata.

    Ruoli richiesti per abilitare le API

    Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente hai già questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.

    Abilitare l'API

  2. Seleziona il progetto in cui vuoi attivare Model Armor.

gcloud

Prima di iniziare, segui questi passaggi utilizzando Google Cloud CLI con l'API Model Armor:

  1. Installa Google Cloud CLI, quindi accedi a gcloud CLI con la tua identità federata. Dopo aver eseguito l'accesso, inizializza Google Cloud CLI eseguendo il comando seguente: 

    gcloud init

  2. Se non è già abilitata, abilita l'API Model Armor:

    Ruoli richiesti per abilitare le API

    Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente hai già questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore di Service Usage (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli. 

    gcloud services enable modelarmor.googleapis.com

  3. Imposta l'override dell'endpoint API utilizzando gcloud CLI.

Imposta l'override dell'endpoint API utilizzando gcloud CLI

Questo passaggio è obbligatorio solo se utilizzi gcloud CLI con Model Armor e vuoi utilizzare una regione o una multiregione diversa da quella predefinita us. Devi impostare manualmente l'override dell'endpoint API per assicurarti che gcloud CLI indirizzi correttamente le richieste al servizio Model Armor.

Esegui questo comando per impostare l'endpoint API per il servizio Model Armor.

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

Sostituisci LOCATION con la regione o multiregione in cui vuoi utilizzare Model Armor.

Come funzionano le regole di esclusione

Puoi configurare le regole di esclusione utilizzando l'API Model Armor.

Regole per dizionari ed espressioni regolari

Puoi definire due tipi di regole di esclusione all'interno di un template di Model Armor:

  • Regole del dizionario: specifica un elenco di parole o frasi (wordList, fino a 128 KB per dizionario) da escludere. Un dizionario deve contenere almeno una frase e ogni frase deve contenere almeno due caratteri costituiti da lettere o cifre. La corrispondenza del dizionario funziona nel seguente modo:
    • Insensibilità alle maiuscole: le parole e le frasi del dizionario non fanno distinzione tra maiuscole e minuscole.
    • Caratteri non alfanumerici: durante la ricerca di corrispondenze, tutti i caratteri diversi da lettere e cifre nel Basic Multilingual Plane Unicode vengono sostituiti con spazi vuoti. Ad esempio, la frase del dizionario Sam Johnson corrisponde a sam johnson, Sam, Johnson e Sam (Johnson). Le frasi del dizionario che contengono molti caratteri che non sono lettere o cifre potrebbero produrre corrispondenze impreviste perché questi caratteri vengono trattati come spazi vuoti.
    • Limiti dei caratteri: i caratteri che circondano una corrispondenza devono essere di un tipo diverso rispetto ai caratteri adiacenti all'interno della parola del dizionario. Le lettere devono essere adiacenti a caratteri non alfabetici e le cifre devono essere adiacenti a caratteri non numerici. Ad esempio, la parola del dizionario jen corrisponde alle prime tre lettere di jen123, ma non a jennifer.
  • Regole con espressioni regolari: specifica un pattern di espressione regolare (fino a 1000 caratteri) per la corrispondenza e l'esclusione. Per impostazione predefinita, le corrispondenze delle espressioni regolari sono sensibili alle maiuscole. Per eseguire una corrispondenza senza distinzione tra maiuscole e minuscole, includi il flag (?i) nel pattern. Ad esempio, (?i)kill process [0-9]+ corrisponde sia a kill process 1234 sia a Kill Process 1234.

Come funzionano le corrispondenze

Ogni regola di esclusione supporta il campo matchingScope, che specifica in che modo Model Armor confronta i contenuti di input con la regola:

  • Corrispondenza parziale (MATCHING_SCOPE_PARTIAL_MATCH, predefinita):
    • Regole del dizionario: corrispondenza quando una parola o una frase nel dizionario corrisponde a una sottostringa nei contenuti di input, in base alle regole dei limiti dei caratteri del dizionario. Ad esempio, la frase del dizionario ignore empty rows corrisponde a ignore empty rows, ignore EMPTY-rows e Please ignore empty rows and summarize this table, ma non a ignore rows o ignore the empty rows.
    • Regole per le espressioni regolari: corrisponde quando una sottostringa nei contenuti di input corrisponde al pattern dell'espressione regolare.
    • Supporto dello streaming: supportato sia in modalità di streaming con buffer (STREAMING_MODE_BUFFERED) sia in modalità di streaming in tempo reale (STREAMING_MODE_REALTIME, predefinita). Per saperne di più, consulta Regole di esclusione nella sanitizzazione in modalità flusso.
  • Corrispondenza completa (MATCHING_SCOPE_FULL_MATCH):
    • Regole del dizionario: corrisponde solo quando la voce del dizionario copre l'intero contenuto di input. Ad esempio, la frase del dizionario ignore empty rows corrisponde a ignore empty rows e ignore EMPTY-rows, ma non a please ignore empty rows o ignore rows.
    • Regole per le espressioni regolari: la corrispondenza viene rilevata solo quando il pattern dell'espressione regolare corrisponde all'intero contenuto di input.
    • Supporto dello streaming: supportato solo in modalità di streaming con buffer (STREAMING_MODE_BUFFERED). Per saperne di più, consulta Regole di esclusione nella sanitizzazione dello streaming.

Override delle regole esclusive durante la sanitizzazione

Se un template include regole di esclusione, Model Armor le valuta durante la sanitizzazione dei prompt e delle risposte del modello ogni volta che un filtro di rilevamento di prompt injection e jailbreak (PROMPT_INJECTION_AND_JAILBREAK) o di AI responsabile (RESPONSIBLE_AI) identifica una potenziale corrispondenza:

  • La regola corrisponde all'input: se una regola di esclusione corrisponde a una sottostringa (MATCHING_SCOPE_PARTIAL_MATCH, predefinita) o all'intero input dall'inizio alla fine (MATCHING_SCOPE_FULL_MATCH), Model Armor esegue l'override di un risultato del filtro MATCH_FOUND o EXECUTION_SKIPPED e imposta matchState su NO_MATCH_FOUND per l'intero tipo di filtro supportato (incluse tutte le categorie di sicurezza dell'AI responsabile per RESPONSIBLE_AI), anziché escludere singole frasi o intervalli all'interno dell'input. Nella risposta di sanitizzazione, filterMatchState è NO_MATCH_FOUND quando non viene rilevato nulla di dannoso o quando le regole esclusive sostituiscono i risultati dei filtri. Per la risoluzione dei problemi, attiva Cloud Logging per le operazioni di sanitizzazione (logSanitizeOperations) nel template e filtra in base alle etichette modelarmor.googleapis.com/exclusion_rule_overridden_filters o modelarmor.googleapis.com/exclusion_rule_skipped_filters. Model Armor registra queste etichette quando le regole esclusive eseguono l'override dei risultati del filtro o quando il valore executionState di un filtro è EXECUTION_SKIPPED. Per saperne di più, consulta Visualizza i log delle regole di esclusione.
  • La regola non corrisponde all'intero input (MATCHING_SCOPE_FULL_MATCH): se l'input contiene testo aggiuntivo oltre alla frase o al pattern configurati, la regola non corrisponde e il filtro mantiene MATCH_FOUND.
  • L'input supera i 130.000 token (0,5 MB): le regole di esclusione valutano solo i primi 130.000 token (0,5 MB) del testo di input. Un payload di 0,5 MB supporta circa 130.000 token per il testo in inglese (circa 4 caratteri per token). Per il testo non in inglese, il numero di token supportati può variare in base alla lingua, perché i caratteri non inglesi richiedono più byte per carattere. Se un input supera i 130.000 token (0,5 MB) e un filtro rileva una corrispondenza al di fuori della parte iniziale scansionata, il filtro restituisce EXECUTION_SKIPPED. Per informazioni dettagliate sui valori messageItems e sui limiti del payload, consulta Limiti di sistema delle regole di esclusione.

Per esempi di sanificazione dei prompt e delle risposte del modello con regole di esclusione, consulta Sanifica un prompt con una regola di esclusione e Sanifica una risposta con una regola di esclusione.

Regole di esclusione nella sanitizzazione dei flussi

Model Armor supporta le regole di esclusione nei metodi di streaming StreamSanitizeUserPrompt e StreamSanitizeModelResponse. Il modo in cui Model Armor valuta le regole di esclusione dipende dalla modalità di streaming (streamingMode) specificata nella richiesta:

  • Modalità con buffer (STREAMING_MODE_BUFFERED): supporta sia MATCHING_SCOPE_PARTIAL_MATCH (predefinita) sia MATCHING_SCOPE_FULL_MATCH. Model Armor raccoglie tutti i blocchi in streaming e valuta le regole esclusive rispetto ai contenuti in streaming completi:
    • Corrispondenza parziale (MATCHING_SCOPE_PARTIAL_MATCH): se una frase del dizionario o un pattern di espressione regolare corrisponde a una sottostringa all'interno dei contenuti in streaming, Model Armor esegue l'override del risultato del filtro e imposta matchState su NO_MATCH_FOUND per quel tipo di filtro.
    • Corrispondenza completa (MATCHING_SCOPE_FULL_MATCH): se una frase del dizionario o un pattern di espressione regolare corrisponde all'intero contenuto in streaming dall'inizio alla fine, Model Armor esegue l'override del risultato del filtro e imposta matchState su NO_MATCH_FOUND per quel tipo di filtro. Se un segmento aggiunge testo oltre alla frase o al pattern configurati, la regola non corrisponde e il filtro mantiene MATCH_FOUND.
  • Modalità in tempo reale (STREAMING_MODE_REALTIME, predefinita): supporta MATCHING_SCOPE_PARTIAL_MATCH (predefinito) e non supporta MATCHING_SCOPE_FULL_MATCH.
    • Corrispondenza parziale (MATCHING_SCOPE_PARTIAL_MATCH): Model Armor valuta ogni chunk elaborato in modo indipendente (restituito in sanitizationMetadata.streamChunkProcessed quando filterMatchState è NO_MATCH_FOUND). Se una frase del dizionario o un pattern di espressione regolare corrisponde all'interno di un chunk elaborato, Model Armor esegue l'override del risultato del filtro e imposta matchState su NO_MATCH_FOUND per quel chunk, continuando a valutare i chunk successivi nello stream in modo indipendente. Se una frase o un pattern escluso viene suddiviso in blocchi elaborati separati, i frammenti parziali non corrispondono. Se un chunk precedente attiva un esito MATCH_FOUND senza corrispondere a una regola di esclusione, lo stream rimane bloccato per i chunk successivi.
    • Corrispondenza completa (MATCHING_SCOPE_FULL_MATCH): non supportata. Se un template include una regola di esclusione con MATCHING_SCOPE_FULL_MATCH e la richiesta utilizza la modalità di streaming in tempo reale, Model Armor rifiuta la richiesta con il seguente errore INVALID_ARGUMENT: Invalid filter rule settings: FULL_MATCH matching scope is not supported in real-time streaming mode. UsePARTIAL_MATCHorSTREAMING_MODE_BUFFERED` invece.

Per esempi di sanitizzazione in streaming con regole di esclusione, vedi Sanitizza un prompt in streaming con una regola di esclusione e Sanitizza una risposta in streaming con una regola di esclusione.

Considerazioni

Quando configuri le regole di esclusione, tieni presente quanto segue:

  • Le regole di esclusione si applicano solo al modello in cui le definisci. Non puoi condividere le regole di esclusione tra i modelli.
  • Puoi configurare regole di esclusione per un tipo di filtro supportato solo quando questo filtro è abilitato nel modello. Per il rilevamento di prompt injection e jailbreaking (PROMPT_INJECTION_AND_JAILBREAK), imposta filterEnforcement su ENABLED in piAndJailbreakFilterSettings. Per attivare i filtri di sicurezza dell'AI responsabile (RESPONSIBLE_AI), configura almeno una categoria di sicurezza dell'AI responsabile in raiSettings.raiFilters.
  • Model Armor non supporta le regole di esclusione nelle impostazioni di base.
  • Nella sanitizzazione in streaming, Model Armor supporta le regole di esclusione con corrispondenza completa (MATCHING_SCOPE_FULL_MATCH) solo in modalità con buffer (STREAMING_MODE_BUFFERED). L'utilizzo di MATCHING_SCOPE_FULL_MATCH in modalità in tempo reale (STREAMING_MODE_REALTIME, la modalità di streaming predefinita) restituisce il seguente errore INVALID_ARGUMENT: Invalid filter rule settings: FULL_MATCH matching scope is not supported in real-time streaming mode. UsePARTIAL_MATCHorSTREAMING_MODE_BUFFERED` invece.
  • Model Armor valuta le regole di esclusione rispetto al testo di input non elaborato prima di eseguire trasformazioni del testo come l'anonimizzazione o la traduzione. Le regole di esclusione non supportano il rilevamento multilingue o la traduzione automatica. Per escludere contenuti in più lingue, aggiungi frasi specifiche per la lingua o pattern di espressioni regolari per ogni lingua di destinazione.
  • Le regole di esclusione hanno un supporto limitato per le lingue con caratteri non latini e i caratteri UTF-8 multi-byte. In particolare, le regole del dizionario (wordList) potrebbero non corrispondere come previsto per gli script che utilizzano segni di combinazione (come gli script indici) o script senza spazi tra le parole (come il cinese e il giapponese). Le regole di corrispondenza completa (MATCHING_SCOPE_FULL_MATCH) non corrispondono agli input contenenti caratteri UTF-8 multi-byte. Quando escludi contenuti in alfabeti non latini o input con caratteri multi-byte, utilizza le regole delle espressioni regolari (regex) con MATCHING_SCOPE_PARTIAL_MATCH.
  • Le regole di esclusione sono soggette ai limiti di sistema. Per saperne di più, consulta Limiti di sistema delle regole di esclusione.

Crea un modello con regole di esclusione

Per creare un template con regole di esclusione, includi l'oggetto filterRuleSettings all'interno di filterConfig in una richiesta POST.

L'esempio seguente crea un template che attiva il rilevamento di prompt injection e jailbreak e i filtri di sicurezza dell'AI responsabile, oltre a configurare due regole di esclusione con corrispondenza parziale (MATCHING_SCOPE_PARTIAL_MATCH):

  • Rilevamento di prompt injection e jailbreaking (PROMPT_INJECTION_AND_JAILBREAK): utilizza una regola del dizionario per escludere gli input contenenti frasi specificate, come ignore case when sorting this list o ignore empty rows, dai rilevamenti di prompt injection e jailbreaking.
  • AI responsabile (RESPONSIBLE_AI): utilizza una regola di espressione regolare per escludere gli input corrispondenti a un pattern specificato, ad esempio (?i)kill process [0-9]+, dai rilevamenti di sicurezza dell'AI responsabile.
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"

Sostituisci quanto segue:

  • EXCLUDED_PHRASE_1 e EXCLUDED_PHRASE_2: le parole o le frasi del dizionario da escludere dal rilevamento di prompt injection e jailbreaking, ad esempio ignore case when sorting this list e ignore empty rows.
  • EXCLUDED_REGEX_PATTERN: il pattern dell'espressione regolare da escludere dal rilevamento della sicurezza dell'AI responsabile, ad esempio (?i)kill process [0-9]+.
  • PROJECT_ID: l'ID del progetto a cui appartiene il template.
  • LOCATION: la posizione del template.
  • TEMPLATE_ID: l'ID del template.

Questo comando restituisce una risposta simile alla seguente:

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

Aggiorna le regole di esclusione in un modello

Per aggiornare le regole di esclusione in un template esistente, invia una richiesta PATCH con updateMask impostato su filterConfig.filterRuleSettings. Poiché l'aggiornamento sostituisce l'intero campo filterRuleSettings, includi tutte le regole che vuoi conservare insieme alle modifiche.

L'esempio seguente aggiorna le regole di esclusione dell'esempio precedente aggiungendo una regola di espressione regolare al set di regole PROMPT_INJECTION_AND_JAILBREAK e rimuovendo il set di regole 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"

Sostituisci quanto segue:

  • EXCLUDED_PHRASE_1 e EXCLUDED_PHRASE_2: le parole o le frasi del dizionario da escludere dal rilevamento di prompt injection e jailbreaking, ad esempio ignore case when sorting this list e ignore empty rows.
  • EXCLUDED_REGEX_PATTERN: il pattern dell'espressione regolare da escludere dal rilevamento di prompt injection e jailbreak, ad esempio (?i)\\b(?:ignore\\s+(?:the\\s+)?(?:emails?|spams?|warnings?|drafts?|typos?|duplicates?|noise))\\b.
  • PROJECT_ID: l'ID del progetto a cui appartiene il template.
  • LOCATION: la posizione del template.
  • TEMPLATE_ID: l'ID del template.

Esempi di pattern di esclusione di espressioni regolari

Quando scrivi regole di esclusione con espressioni regolari, limita i pattern a termini di dominio specifici o sostantivi target in modo che Model Armor escluda i falsi positivi noti senza ignorare le violazioni di sicurezza o protezione autentiche. Quando passi pattern di espressioni regolari all'interno dei corpi delle richieste JSON ("pattern"), utilizza una seconda barra rovesciata come carattere di escape per ogni barra rovesciata (ad esempio, utilizza \\b e \\s).

Esempi di rilevamento di prompt injection e jailbreaking

Verbi imperativi come ignore, disregard, bypass o override compaiono spesso sia nei prompt injection malevoli sia nelle istruzioni legittime per la classificazione delle email, la formattazione dei dati, la gestione degli errori o la configurazione del sistema. Per evitare di escludere ampie categorie di prompt, combina i limiti di parola (\\b), i gruppi non di acquisizione ((?:...)) e il flag senza distinzione tra maiuscole e minuscole ((?i)) con MATCHING_SCOPE_PARTIAL_MATCH per ancorare l'espressione regolare a sostantivi target operativi specifici.

La tabella seguente fornisce un esempio di pattern di espressione regolare con corrispondenza parziale (con barre rovesciate con escape JSON) e un esempio di prompt per uno scenario di falsi positivi di jailbreak e prompt injection comuni.

Categoria di istruzioni Termini di attivazione Scenari di falsi positivi Esempio di pattern di espressione regolare con corrispondenza parziale Prompt di esempio
Triage e filtro dei contenuti ignore, disregard Classificazione delle email, gestione degli errori e revisione delle bozze (?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.

Esempi di filtri di sicurezza dell'AI responsabile

La documentazione tecnica, i comandi di amministrazione di sistema e le espressioni comuni spesso contengono parole che si sovrappongono alle categorie di sicurezza dell'AI responsabile. Per ridurre i falsi positivi in prompt o risposte più ampi, combina i limiti delle parole (\\b), i gruppi non di acquisizione ((?:...)) e il flag senza distinzione tra maiuscole e minuscole ((?i)) con MATCHING_SCOPE_PARTIAL_MATCH.

La tabella seguente fornisce esempi di pattern di espressioni regolari con corrispondenza parziale (con barre rovesciate con escape JSON) ed esempi di prompt per scenari comuni di falsi positivi di AI responsabile.

Categoria di rischio Termini di attivazione Scenari di falsi positivi Esempio di pattern di espressione regolare con corrispondenza parziale Prompt di esempio
Violenza o danno kill Terminazione di processi, interruttori elettrici o di climatizzazione e modi di dire comuni (?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.
Tossicità o linguaggio offensivo abort, terminate Transazioni di database, ciclo di vita delle missioni e termini di impiego o di contratto (?i)\\b(?:abort\\s+(?:transactions?|missions?|requests?|connections?|retry|retries)|terminate\\s+(?:contracts?|sessions?|threads?|instances?|connections?))\\b Abort retry.
Corrispondenze di sottostringhe nei termini del dominio Sottostringhe di caratteri sovrapposte Termini accademici, botanica, ornitologia, aviazione e nomi propri (?i)\\b(?:class(?:room|ic)?|assess(?:ment)?|associate|passive|peacock|cockpit|cocktail|dickens)\\b I love reading Dickens.
Armi o esplosivi bomb, blast, detonate Bioinformatica, espressioni idiomatiche di intrattenimento e attrezzature o pulizia industriali (?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.

Visualizza i log delle regole di esclusione

Per registrare i risultati della valutazione delle regole di esclusione, imposta logSanitizeOperations su true quando configuri il logging nei template. Quando il logging è abilitato, Model Armor scrive le voci di log SanitizeOperationLogEntry per la risorsa monitorata modelarmor.googleapis.com/SanitizeOperation in Cloud Logging.

Per saperne di più sull'abilitazione e sulla query dei log di sanitizzazione, consulta Configura il logging.

Best practice per la configurazione delle regole di esclusione

Segui queste best practice per ridurre al minimo i falsi positivi senza indebolire la security posture del tuo template:

  • Definisci l'ambito delle regole in modo specifico per contesti particolari: evita di escludere singoli verbi o termini generici (come ignore, kill o abort) o di utilizzare caratteri jolly non vincolati (come .*ignore.*). Poiché MATCHING_SCOPE_PARTIAL_MATCH sostituisce matchState con NO_MATCH_FOUND per l'intero filtro ogni volta che una sottostringa corrisponde, regole troppo ampie possono mascherare violazioni reali altrove nello stesso prompt o nella stessa risposta. Abbina sempre i verbi di attivazione a sostantivi target specifici (ad esempio, ignore case when sorting this list o (?i)kill process [0-9]+).
  • Utilizza i limiti delle parole e consolida i pattern: nelle regole delle espressioni regolari, utilizza i limiti delle parole (\b) per evitare corrispondenze accidentali di sottostringhe all'interno di parole non correlate. Consolida le frasi correlate in un'unica espressione regolare utilizzando gruppi non di acquisizione ((?:...)) e alternanza (|) per rispettare il limite di sistema di 10 regole per set di regole.
  • Preferisci MATCHING_SCOPE_FULL_MATCH per input prevedibili: quando escludi prompt della UI predefiniti, comandi predefiniti o payload di test automatici, imposta matchingScope su MATCHING_SCOPE_FULL_MATCH (o ancora espressioni regolari con ^ e $). L'ambito di corrispondenza completa impedisce agli utenti di aggiungere istruzioni avversarie a una frase esclusa per bypassare il rilevamento.
  • Scrivi regole per il testo non elaborato e non trasformato: Model Armor valuta le regole di esclusione prima dell'anonimizzazione o della traduzione. Assicurati che i pattern corrispondano al formato originale prima dell'anonimizzazione e aggiungi frasi o pattern di espressioni regolari specifici per ogni lingua supportata dalla tua applicazione.
  • Esamina e ritira le regole temporanee dopo gli upgrade dei filtri: quando esegui l'upgrade di un template a una versione del filtro più recente, rivaluta gli scenari di test dei falsi positivi e rimuovi le regole di esclusione risolte dai modelli di rilevamento aggiornati.

Passaggi successivi