Configura reglas de exclusión específicas de la plantilla

Puedes configurar reglas de exclusión específicas de la plantilla en Model Armor para mitigar las detecciones de falsos positivos. Las reglas de exclusión son reglas específicas de la plantilla que contienen expresiones regulares o frases que se deben excluir de la detección.

Filtros compatibles

Puedes usar reglas de exclusión para los siguientes filtros:

Cuándo usar las reglas de exclusión

Usa reglas de exclusión específicas de la plantilla cuando necesites suprimir detecciones de falsos positivos conocidas para cargas de trabajo específicas sin inhabilitar un filtro por completo:

  • Terminología técnica o específica del dominio: Tu aplicación procesa vocabulario especializado, como comandos de administración de sistemas (kill process, abort transaction), terminología de pruebas de seguridad (penetration testing), términos científicos (blast search) o modismos de la industria, que se superpone con las categorías de seguridad de la IA responsable.
  • Instrucciones operativas o de formato benignas: Tus usuarios o plantillas de instrucciones incluyen instrucciones legítimas que usan verbos imperativos (como "ignore case when sorting this list", "ignore empty rows" o "Summarize my inbox and ignore the emails from the marketing vendor.") que activan falsos positivos en la detección de inyección de instrucciones y jailbreak.
  • Mitigación orientada mientras se esperan las actualizaciones del modelo: Necesitas una solución alternativa inmediata para un falso positivo verificado en un flujo de trabajo de aplicación específico mientras mantienes el filtro activo para todas las demás entradas.

En la siguiente tabla, se describe cuándo usar cada combinación de tipo de regla y alcance de coincidencia. Para obtener más información sobre cómo funcionan las coincidencias de diccionarios y expresiones regulares, consulta Reglas de diccionarios y expresiones regulares y Cómo funcionan las coincidencias.

Configuración de la regla Cuándo usar Ejemplo
Regla de diccionario con coincidencia parcial (MATCHING_SCOPE_PARTIAL_MATCH) Tienes una lista fija de palabras o frases estáticas que pueden aparecer en cualquier parte de una instrucción o respuesta. Para obtener más información sobre el comportamiento de coincidencia de diccionarios, consulta Reglas de diccionarios y expresiones regulares.

El diccionario contiene la frase ignore empty rows

Coincidencias:

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

No coincide con lo siguiente:

  • ignore rows
  • ignore the empty rows
Regla de diccionario con coincidencia completa (MATCHING_SCOPE_FULL_MATCH) Tu aplicación usa opciones de instrucciones predefinidas (como botones de respuesta rápida de la IU o comandos predefinidos) en las que toda la entrada coincide con una frase conocida y deseas evitar que el texto adicional no filtrado omita el filtro. Para obtener más información sobre el comportamiento de coincidencia de diccionarios, consulta Reglas de diccionarios y expresiones regulares.

El diccionario contiene la frase ignore empty rows

Coincidencias:

  • ignore empty rows
  • ignore EMPTY-rows

No coincide con lo siguiente:

  • please ignore empty rows
  • ignore rows
Regla de expresión regular con coincidencia parcial (MATCHING_SCOPE_PARTIAL_MATCH) Debes excluir patrones estructurados, identificadores dinámicos o combinaciones específicas de verbos y sustantivos dentro de instrucciones o respuestas más grandes. Para obtener más información, consulta Ejemplos de patrones de exclusión de expresiones regulares.

Patrón de expresión regular: (?i)kill process [0-9]+

Coincidencias:

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

No coincide con lo siguiente:

  • kill process abc
  • kill the process 1234
Regla de expresión regular con coincidencia completa (MATCHING_SCOPE_FULL_MATCH) Toda la carga útil de entrada sigue un formato estructural estricto (como un identificador de prueba automatizado o un comando estructurado).

Patrón de expresión regular: (?i)^test_case_[0-9]+$

Coincidencias:

  • test_case_42
  • TEST_CASE_001

No coincide con lo siguiente:

  • run test_case_42
  • test_case_alpha

Usa un extremo regional o multirregional

Cuando trabajas con una plantilla de Model Armor, debes usar un extremo regional o multirregional (modelarmor.LOCATION.rep.googleapis.com) que coincida con la ubicación de la plantilla. Para obtener información sobre cómo se aplica la residencia de datos en cada región o multirregión, consulta Aplicación de la residencia de datos en las plantillas.

El extremo global (modelarmor.googleapis.com) no admite la administración de plantillas de Model Armor ni la limpieza de instrucciones y respuestas.

Antes de comenzar

Antes de comenzar, completa las siguientes tareas.

Obtén los permisos necesarios

Para obtener los permisos que necesitas para configurar reglas de exclusión en las plantillas de Model Armor, pídele a tu administrador que te otorgue el rol de IAM de administrador de Model Armor (roles/modelarmor.admin) en el proyecto que contiene la plantilla de Model Armor. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Habilita las APIs

Para poder usar Model Armor, debes habilitar su API.

Console

  1. Habilita la API de Model Armor si aún no está habilitada.

    Roles necesarios para habilitar las APIs

    Para habilitar las APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol de propietario (roles/owner). De lo contrario, puedes obtenerlo a través del rol de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén más información para otorgar roles.

    Habilitar la API

  2. Elige el proyecto en el que quieres activar Model Armor.

gcloud

Antes de empezar, sigue estos pasos a través de la Google Cloud CLI con la API de Model Armor:

  1. En la consola de Google Cloud , activa Cloud Shell.

    Activa Cloud Shell

    En la parte inferior de la consola de Google Cloud , se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

  2. Habilita la API de Model Armor si aún no está habilitada:

    Roles necesarios para habilitar las APIs

    Para habilitar las APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol de propietario (roles/owner). De lo contrario, puedes obtenerlo a través del rol de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén más información para otorgar roles.

    gcloud services enable modelarmor.googleapis.com

  3. Configura la anulación del extremo de API con la gcloud CLI.

Configura la anulación del extremo de API con gcloud CLI

Este paso solo es necesario si usas gcloud CLI con Model Armor y quieres usar una región o multirregión que no sea la multirregión us predeterminada. Debes configurar de forma manual la anulación del extremo de API para asegurarte de que gcloud CLI enrute correctamente las solicitudes al servicio de Model Armor.

Ejecuta el comando siguiente para configurar el extremo de API del servicio de Model Armor.

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

Reemplaza LOCATION por la región o multirregión en la que quieres usar Model Armor.

Cómo funcionan las reglas de exclusión

Las reglas de exclusión se configuran con la API de Model Armor.

Reglas de diccionario y expresiones regulares

Puedes definir dos tipos de reglas de exclusión dentro de una plantilla de Model Armor:

  • Reglas de diccionario: Especifica una lista de palabras o frases (wordList, hasta 128 KB por diccionario) para excluir. Un diccionario debe contener al menos una frase, y cada frase debe contener al menos dos caracteres que sean letras o dígitos. La coincidencia de diccionarios funciona de la siguiente manera:
    • No distingue mayúsculas de minúsculas: Las palabras y frases del diccionario no distinguen mayúsculas de minúsculas.
    • Caracteres no alfanuméricos: Cuando se buscan coincidencias, todos los caracteres que no sean letras ni dígitos en el plano multilingüe básico de Unicode se reemplazan por espacios en blanco. Por ejemplo, la frase del diccionario Sam Johnson coincide con sam johnson, Sam, Johnson y Sam (Johnson). Las frases del diccionario que contienen muchos caracteres que no son letras ni dígitos pueden producir coincidencias inesperadas porque esos caracteres se tratan como espacios en blanco.
    • Límites de caracteres: Los caracteres que rodean una coincidencia deben ser de un tipo de carácter diferente al de los caracteres adyacentes dentro de la palabra del diccionario. Las letras deben estar junto a caracteres que no sean letras, y los dígitos deben estar junto a caracteres que no sean dígitos. Por ejemplo, la palabra del diccionario jen coincide con las primeras tres letras de jen123, pero no con jennifer.
  • Reglas de expresiones regulares: Especifica un patrón de expresión regular (hasta 1,000 caracteres) para que coincida y se excluya. Las coincidencias de expresiones regulares distinguen mayúsculas de minúsculas de forma predeterminada. Para realizar una coincidencia que no distinga mayúsculas de minúsculas, incluye la marca (?i) en tu patrón. Por ejemplo, (?i)kill process [0-9]+ coincide con kill process 1234 y Kill Process 1234.

Cómo funciona la correlación

Cada regla de exclusión admite el campo matchingScope, que especifica cómo Model Armor compara el contenido de entrada con la regla:

  • Coincidencia parcial (MATCHING_SCOPE_PARTIAL_MATCH, predeterminado):
    • Reglas de diccionario: Coincide cuando una palabra o frase del diccionario coincide con una subcadena del contenido de entrada, sujeto a las reglas de límite de caracteres del diccionario. Por ejemplo, la frase del diccionario ignore empty rows coincide con ignore empty rows, ignore EMPTY-rows y Please ignore empty rows and summarize this table, pero no con ignore rows ni ignore the empty rows.
    • Reglas de expresiones regulares: Coincide cuando cualquier substring en el contenido de entrada coincide con el patrón de expresión regular.
    • Compatibilidad con la transmisión: Se admite tanto en el modo de transmisión almacenada en búfer (STREAMING_MODE_BUFFERED) como en el modo de transmisión en tiempo real (STREAMING_MODE_REALTIME, predeterminado). Para obtener más información, consulta Reglas de exclusión en la limpieza de transmisiones.
  • Coincidencia total (MATCHING_SCOPE_FULL_MATCH):
    • Reglas de diccionario: Coincide solo cuando la entrada del diccionario abarca todo el contenido de entrada. Por ejemplo, la frase del diccionario ignore empty rows coincide con ignore empty rows y ignore EMPTY-rows, pero no con please ignore empty rows ni ignore rows.
    • Reglas de expresiones regulares: Coincide solo cuando el patrón de expresión regular coincide con todo el contenido de entrada.
    • Compatibilidad con la transmisión: Solo se admite en el modo de transmisión con búfer (STREAMING_MODE_BUFFERED). Para obtener más información, consulta Reglas de exclusión en la limpieza de transmisiones.

Anulaciones de reglas de exclusión durante la limpieza

Si una plantilla incluye reglas de exclusión, Model Armor evalúa esas reglas durante la limpieza de instrucciones y respuestas del modelo cada vez que un filtro de detección de inyección de instrucciones y jailbreak (PROMPT_INJECTION_AND_JAILBREAK) o de IA responsable (RESPONSIBLE_AI) identifica una posible coincidencia:

  • La regla coincide con la entrada: Si una regla de exclusión coincide con una subcadena (MATCHING_SCOPE_PARTIAL_MATCH, predeterminado) o con toda la entrada de principio a fin (MATCHING_SCOPE_FULL_MATCH), Model Armor anula un resultado de filtro MATCH_FOUND o EXECUTION_SKIPPED y establece matchState en NO_MATCH_FOUND para todo ese tipo de filtro compatible (incluidas todas las categorías de seguridad de IA responsable para RESPONSIBLE_AI), en lugar de excluir frases o intervalos individuales dentro de la entrada. En la respuesta de limpieza, filterMatchState es NO_MATCH_FOUND cuando no se detecta nada malicioso o cuando las reglas de exclusión anulan los resultados del filtro. Para solucionar problemas, habilita Cloud Logging para las operaciones de limpieza (logSanitizeOperations) en la plantilla y filtra las etiquetas modelarmor.googleapis.com/exclusion_rule_overridden_filters o modelarmor.googleapis.com/exclusion_rule_skipped_filters. Model Armor registra estas etiquetas cuando las reglas de exclusión anulan los resultados del filtro o cuando el executionState de un filtro es EXECUTION_SKIPPED. Para obtener más información, consulta Visualiza los registros de reglas de exclusión.
  • La regla no coincide con la entrada completa (MATCHING_SCOPE_FULL_MATCH): Si la entrada contiene texto adicional más allá de la frase o el patrón configurados, la regla no coincide y el filtro conserva MATCH_FOUND.
  • La entrada supera los 130,000 tokens (0.5 MB): Las reglas de exclusión evalúan solo los 130,000 tokens iniciales (0.5 MB) del texto de entrada. Una carga útil de 0.5 MB admite aproximadamente 130,000 tokens para texto en inglés (con alrededor de 4 caracteres por token). Para el texto que no está en inglés, la cantidad de tokens admitidos puede variar según el idioma, ya que los caracteres que no están en inglés requieren más bytes por carácter. Si una entrada supera los 130,000 tokens (0.5 MB) y un filtro detecta una coincidencia fuera de la parte analizada inicial, el filtro devuelve EXECUTION_SKIPPED. Para obtener detalles sobre los valores de messageItems y los límites de carga útil, consulta Límites del sistema de reglas de exclusión.

Para ver ejemplos de limpieza de instrucciones y respuestas de modelos con reglas de exclusión, consulta Limpia una instrucción con una regla de exclusión y Limpia una respuesta con una regla de exclusión.

Reglas de exclusión en la limpieza de transmisión

Model Armor admite reglas de exclusión en los métodos de transmisión StreamSanitizeUserPrompt y StreamSanitizeModelResponse. La forma en que Model Armor evalúa las reglas de exclusión depende del modo de transmisión (streamingMode) especificado en la solicitud:

  • Modo almacenado en búfer (STREAMING_MODE_BUFFERED): Admite MATCHING_SCOPE_PARTIAL_MATCH (predeterminado) y MATCHING_SCOPE_FULL_MATCH. Model Armor recopila todos los fragmentos transmitidos y evalúa las reglas de exclusión en función del contenido transmitido completo:
    • Coincidencia parcial (MATCHING_SCOPE_PARTIAL_MATCH): Si una frase del diccionario o un patrón de expresión regular coincide con cualquier subcadena dentro del contenido transmitido, Model Armor anula el resultado del filtro y establece matchState en NO_MATCH_FOUND para ese tipo de filtro.
    • Coincidencia completa (MATCHING_SCOPE_FULL_MATCH): Si una frase del diccionario o un patrón de expresión regular coincide con todo el contenido transmitido de principio a fin, Model Armor anula el resultado del filtro y establece matchState en NO_MATCH_FOUND para ese tipo de filtro. Si algún fragmento agrega texto más allá de la frase o el patrón configurados, la regla no coincide y el filtro conserva MATCH_FOUND.
  • Modo en tiempo real (STREAMING_MODE_REALTIME, predeterminado): Admite MATCHING_SCOPE_PARTIAL_MATCH (predeterminado) y no admite MATCHING_SCOPE_FULL_MATCH.
    • Coincidencia parcial (MATCHING_SCOPE_PARTIAL_MATCH): Model Armor evalúa cada fragmento procesado de forma independiente (se muestra en sanitizationMetadata.streamChunkProcessed cuando filterMatchState es NO_MATCH_FOUND). Si una frase del diccionario o un patrón de expresión regular coincide dentro de un fragmento procesado, Model Armor anula el resultado del filtro y establece matchState en NO_MATCH_FOUND para ese fragmento, mientras continúa evaluando los fragmentos posteriores en el flujo de forma independiente. Si una frase o un patrón excluidos se dividen en fragmentos procesados separados, los fragmentos parciales no coinciden. Si un fragmento anterior activa un veredicto de MATCH_FOUND sin coincidir con una regla de exclusión, el flujo permanecerá bloqueado para los fragmentos posteriores.
    • Coincidencia completa (MATCHING_SCOPE_FULL_MATCH): No se admite. Si una plantilla incluye una regla de exclusión con MATCHING_SCOPE_FULL_MATCH y la solicitud usa el modo de transmisión en tiempo real, Model Armor rechaza la solicitud con el siguiente error INVALID_ARGUMENT: Invalid filter rule settings: FULL_MATCH matching scope is not supported in real-time streaming mode. UsePARTIAL_MATCHorSTREAMING_MODE_BUFFERED`.

Para ver ejemplos de limpieza de transmisiones con reglas de exclusión, consulta Limpia una instrucción de transmisión con una regla de exclusión y Limpia una respuesta de transmisión con una regla de exclusión.

Consideraciones

Cuando configures reglas de exclusión, ten en cuenta lo siguiente:

  • Las reglas de exclusión se aplican solo a la plantilla en la que las definas. No puedes compartir reglas de exclusión entre plantillas.
  • Puedes configurar reglas de exclusión para un tipo de filtro compatible solo cuando ese filtro esté habilitado en la plantilla. Para la detección de inyección de instrucciones y jailbreak (PROMPT_INJECTION_AND_JAILBREAK), establece filterEnforcement en ENABLED en piAndJailbreakFilterSettings. Para habilitar los filtros de seguridad de IA responsable (RESPONSIBLE_AI), configura al menos una categoría de seguridad de IA responsable en raiSettings.raiFilters.
  • Model Armor no admite reglas de exclusión en la configuración mínima.
  • En la limpieza de transmisión, Model Armor admite reglas de exclusión de coincidencia completa (MATCHING_SCOPE_FULL_MATCH) solo en el modo con búfer (STREAMING_MODE_BUFFERED). El uso de MATCHING_SCOPE_FULL_MATCH en el modo en tiempo real (STREAMING_MODE_REALTIME, el modo de transmisión predeterminado) devuelve el siguiente error INVALID_ARGUMENT: Invalid filter rule settings: FULL_MATCH matching scope is not supported in real-time streaming mode. UsePARTIAL_MATCHorSTREAMING_MODE_BUFFERED` en su lugar.
  • Model Armor evalúa las reglas de exclusión con el texto de entrada sin procesar antes de realizar transformaciones de texto, como la desidentificación o la traducción. Las reglas de exclusión no admiten la detección de varios idiomas ni la traducción automática. Para excluir contenido en varios idiomas, agrega frases específicas de cada idioma o patrones de expresiones regulares para cada idioma de destino.
  • Las reglas de exclusión tienen compatibilidad limitada con los idiomas de escritura no latina y los caracteres UTF-8 de varios bytes. En particular, es posible que las reglas de diccionario (wordList) no coincidan como se espera para las secuencias de comandos que usan marcas de combinación (como las secuencias de comandos índicas) o las secuencias de comandos sin espacios entre palabras (como el chino y el japonés). Las reglas de coincidencia completa (MATCHING_SCOPE_FULL_MATCH) no coinciden con las entradas que contienen caracteres UTF-8 de varios bytes. Cuando excluyas contenido en secuencias de comandos que no sean en latín o entradas con caracteres de varios bytes, usa reglas de expresiones regulares (regex) con MATCHING_SCOPE_PARTIAL_MATCH.
  • Las reglas de exclusión están sujetas a los límites del sistema. Para obtener más información, consulta Límites del sistema de reglas de exclusión.

Crea una plantilla con reglas de exclusión

Para crear una plantilla con reglas de exclusión, incluye el objeto filterRuleSettings dentro de filterConfig en una solicitud POST.

En el siguiente ejemplo, se crea una plantilla que habilita la detección de inyección de instrucciones y jailbreak, y los filtros de seguridad de IA responsable, y configura dos reglas de exclusión con coincidencia parcial (MATCHING_SCOPE_PARTIAL_MATCH):

  • Detección de inyección de instrucciones y jailbreak (PROMPT_INJECTION_AND_JAILBREAK): Usa una regla de diccionario para excluir las entradas que contienen frases especificadas, como ignore case when sorting this list o ignore empty rows, de las detecciones de inyección de instrucciones y jailbreak.
  • IA responsable (RESPONSIBLE_AI): Usa una regla de expresión regular para excluir las entradas que coincidan con un patrón especificado, como (?i)kill process [0-9]+, de las detecciones de seguridad de la IA responsable.
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"

Reemplaza lo siguiente:

  • EXCLUDED_PHRASE_1 y EXCLUDED_PHRASE_2: Son las palabras o frases del diccionario que se excluirán de la detección de inyección de instrucciones y jailbreak, por ejemplo, ignore case when sorting this list y ignore empty rows.
  • EXCLUDED_REGEX_PATTERN: Es el patrón de expresión regular que se excluirá de la detección de seguridad de la IA responsable, por ejemplo, (?i)kill process [0-9]+.
  • PROJECT_ID: Es el ID del proyecto al que pertenece la plantilla.
  • LOCATION: Es la ubicación de la plantilla.
  • TEMPLATE_ID: Es el ID de la plantilla.

Este comando devuelve una respuesta similar a la siguiente:

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

Actualiza las reglas de exclusión en una plantilla

Para actualizar las reglas de exclusión en una plantilla existente, envía una solicitud PATCH con updateMask establecido en filterConfig.filterRuleSettings. Debido a que la actualización reemplaza todo el campo filterRuleSettings, incluye todas las reglas que quieras conservar junto con tus modificaciones.

En el siguiente ejemplo, se actualizan las reglas de exclusión del ejemplo anterior agregando una regla de expresión regular al conjunto de reglas PROMPT_INJECTION_AND_JAILBREAK y quitando el conjunto de reglas 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"

Reemplaza lo siguiente:

  • EXCLUDED_PHRASE_1 y EXCLUDED_PHRASE_2: Son las palabras o frases del diccionario que se excluirán de la detección de inyección de instrucciones y jailbreak, por ejemplo, ignore case when sorting this list y ignore empty rows.
  • EXCLUDED_REGEX_PATTERN: Es el patrón de expresión regular que se excluirá de la detección de inyección de instrucciones y jailbreak, por ejemplo, (?i)\\b(?:ignore\\s+(?:the\\s+)?(?:emails?|spams?|warnings?|drafts?|typos?|duplicates?|noise))\\b.
  • PROJECT_ID: Es el ID del proyecto al que pertenece la plantilla.
  • LOCATION: Es la ubicación de la plantilla.
  • TEMPLATE_ID: Es el ID de la plantilla.

Ejemplos de patrones de exclusión de expresiones regulares

Cuando escribas reglas de exclusión de expresiones regulares, limita tus patrones a términos de dominio específicos o sustantivos de destino para que Model Armor excluya los falsos positivos conocidos sin ignorar las infracciones de seguridad o protección genuinas. Cuando pases patrones de expresiones regulares dentro de los cuerpos de solicitud JSON ("pattern"), escapa cada barra inversa con una segunda barra inversa (por ejemplo, usa \\b y \\s).

Ejemplos de detección de inyección de instrucciones y jailbreak

Los verbos imperativos, como ignore, disregard, bypass o override, suelen aparecer tanto en las inyecciones de instrucciones adversas como en las instrucciones legítimas para la clasificación de correos electrónicos, el formato de datos, el manejo de errores o la configuración del sistema. Para evitar excluir categorías amplias de instrucciones, combina límites de palabras (\\b), grupos que no capturan ((?:...)) y la marca que no distingue mayúsculas de minúsculas ((?i)) con MATCHING_SCOPE_PARTIAL_MATCH para fijar tu expresión regular a sustantivos de destino operativos específicos.

En la siguiente tabla, se proporciona un ejemplo de patrón de expresión regular de coincidencia parcial (con barras inversas con escape de JSON) y un ejemplo de instrucción para una inyección de instrucciones común y una situación de falso positivo de jailbreak.

Categoría de instrucción Términos de activación Situaciones de falsos positivos Ejemplo de patrón de expresión regular de coincidencia parcial Instrucción de ejemplo
Clasificación y filtrado de contenido ignore, disregard Clasificación de correos electrónicos, manejo de errores y revisión de borradores (?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.

Ejemplos de filtros de seguridad de IA responsable

La documentación técnica, los comandos de administración de sistemas y los modismos comunes suelen contener palabras que se superponen con las categorías de seguridad de la IA responsable. Para mitigar los falsos positivos en instrucciones o respuestas más grandes, combina límites de palabras (\\b), grupos que no son de captura ((?:...)) y la marca que no distingue mayúsculas de minúsculas ((?i)) con MATCHING_SCOPE_PARTIAL_MATCH.

En la siguiente tabla, se proporcionan ejemplos de patrones de expresiones regulares de coincidencia parcial (con barras inversas con escape de JSON) y ejemplos de instrucciones para situaciones comunes de falsos positivos de IA responsable.

Categoría de riesgo Términos de activación Situaciones de falsos positivos Ejemplo de patrón de expresión regular de coincidencia parcial Instrucción de ejemplo
Violencia o daños kill Finalización de procesos, interruptores eléctricos o de HVAC, y expresiones comunes (?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.
Toxicidad o lenguaje ofensivo abort, terminate Transacciones de bases de datos, ciclo de vida de misiones y condiciones de empleo o de contratos (?i)\\b(?:abort\\s+(?:transactions?|missions?|requests?|connections?|retry|retries)|terminate\\s+(?:contracts?|sessions?|threads?|instances?|connections?))\\b Abort retry.
Coincidencias de subcadenas en términos de dominio Subcadenas de caracteres superpuestas Términos académicos, botánica, ornitología, aviación y nombres propios (?i)\\b(?:class(?:room|ic)?|assess(?:ment)?|associate|passive|peacock|cockpit|cocktail|dickens)\\b I love reading Dickens.
Armas o explosivos bomb, blast, detonate Bioinformática, expresiones idiomáticas de entretenimiento y equipos o limpieza industriales (?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.

Consulta los registros de reglas de exclusión

Para registrar los resultados de la evaluación de las reglas de exclusión, establece logSanitizeOperations en true cuando configures el registro en las plantillas. Cuando se habilita el registro, Model Armor escribe entradas de registro de SanitizeOperationLogEntry para el recurso supervisado modelarmor.googleapis.com/SanitizeOperation en Cloud Logging.

Para obtener más información sobre cómo habilitar y consultar los registros de limpieza, consulta Configura el registro.

Prácticas recomendadas para configurar reglas de exclusión

Sigue estas prácticas recomendadas para minimizar los falsos positivos sin debilitar la postura de seguridad de tu plantilla:

  • Limita el alcance de las reglas a contextos específicos: Evita excluir verbos individuales o términos amplios (como ignore, kill o abort) o usar comodines sin restricciones (como .*ignore.*). Debido a que MATCHING_SCOPE_PARTIAL_MATCH anula el matchState a NO_MATCH_FOUND para todo el filtro cada vez que coincide una subcadena, las reglas demasiado amplias pueden enmascarar incumplimientos genuinos en otras partes de la misma instrucción o respuesta. Siempre vincula los verbos activadores con sustantivos de destino específicos (por ejemplo, ignore case when sorting this list o (?i)kill process [0-9]+).
  • Usa límites de palabras y consolida patrones: En las reglas de expresiones regulares, usa límites de palabras (\b) para evitar coincidencias accidentales de subcadenas dentro de palabras no relacionadas. Consolida las frases relacionadas en una sola expresión regular con grupos que no sean de captura ((?:...)) y alternancia (|) para mantenerte dentro del límite del sistema de 10 reglas por conjunto de reglas.
  • Prefiere MATCHING_SCOPE_FULL_MATCH para entradas predecibles: Cuando excluyas instrucciones de IU predefinidas, comandos predefinidos o cargas útiles de pruebas automatizadas, establece matchingScope en MATCHING_SCOPE_FULL_MATCH (o ancla expresiones regulares con ^ y $). El alcance de coincidencia completa evita que los usuarios agreguen instrucciones adversas a una frase excluida para omitir la detección.
  • Escribe reglas para texto sin procesar y sin transformar: Model Armor evalúa las reglas de exclusión antes de la desidentificación o la traducción. Asegúrate de que tus patrones coincidan con el formato original antes de la desidentificación y agrega frases específicas del idioma o patrones de expresiones regulares para cada idioma que admita tu aplicación.
  • Revisa y retira las reglas temporales después de las actualizaciones de filtros: Cuando actualizas una plantilla a una versión de filtro más reciente, vuelve a evaluar tus casos de prueba de falsos positivos y quita las reglas de exclusión que se resuelven con los modelos de detección actualizados.

¿Qué sigue?