Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Políticas de filtro de suscripciones de Amazon SNS
Una política de filtrado de suscripciones le permite especificar nombres de propiedad y asignar una lista de valores a cada nombre de propiedad. Para obtener más información, consulte [Filtrado de mensajes en Amazon SNS](sns-message-filtering.md).
Cuando Amazon SNS evalúa los atributos del mensaje o las propiedades de cuerpo del mensaje con la política de filtrado de suscripciones, omite los que no están especificados en la política.
**importante**
AWS los servicios como IAM y Amazon SNS utilizan un modelo de computación distribuida denominado consistencia eventual. Los añadidos o cambios a una política de filtro de suscripción pueden tardar hasta 15 minutos en tener efecto.
Una suscripción acepta un mensaje con las siguientes condiciones:
+ Cuando el alcance de la política de filtrado se establece en `MessageAttributes`, cada nombre de propiedad de la política de filtrado coincide con el nombre de un atributo de mensaje. Para cada nombre de propiedad coincidente de la política de filtrado, al menos un valor de propiedad coincide con el valor del atributo del mensaje.
+ Cuando el alcance de la política de filtrado se establece en `MessageBody`, cada nombre de propiedad de la política de filtrado coincide con el nombre de una propiedad de cuerpo de mensaje. Para cada nombre de propiedad coincidente de la política de filtrado, al menos un valor de propiedad coincide con el valor de la propiedad del cuerpo del mensaje.
Amazon SNS admite actualmente los siguientes operadores de filtro:
+ [Lógica AND](and-or-logic.md#and-logic)
+ [Lógica OR](and-or-logic.md#or-logic)
+ [Operador OR](and-or-logic.md#or-operator)
+ [Coincidencia de claves](attribute-key-matching.md)
+ [Coincidencia exacta de valores numéricos](numeric-value-matching.md#numeric-exact-matching)
+ [El valor numérico es cualquier cosa menos coincidente](numeric-value-matching.md#numeric-anything-but-matching)
+ [Coincidencia de rango de valor numérico](numeric-value-matching.md#numeric-value-range-matching)
+ [Coincidencia exacta de valor de cadena](string-value-matching.md#string-exact-matching)
+ [El valor de cadena es cualquier cosa menos coincidente](string-value-matching.md#string-anything-but-matching)
+ [Coincidencia de cadenas con un prefijo con cualquier cosa menos el operador](string-value-matching.md#string-anything-but-matching)
+ [El valor de la cadena es igual a ignorar mayúsculas y minúsculas](string-value-matching.md#string-equals-ignore)
+ [Coincidencia de la dirección IP con el valor de cadena](string-value-matching.md#string-address-matching)
+ [Coincidencia de prefijo de valor de cadena](string-value-matching.md#string-prefix-matching)
+ [Coincidencia de sufijo de valor de cadena](string-value-matching.md#string-suffix-matching)
# Políticas de filtrado de ejemplo de Amazon SNS
En el siguiente ejemplo, se muestra una carga de mensaje entregada por un tema de Amazon SNS que procesa transacciones de los clientes.
El primer ejemplo incluye el campo `MessageAttributes` con atributos que describen la transacción:
+ Intereses del cliente
+ Nombre del almacén
+ Estado del evento
+ Precio de compra en USD
Como este mensaje incluye el campo `MessageAttributes`, cualquier suscripción a un tema que establezca una `FilterPolicy` puede aceptar o rechazar el mensaje de forma selectiva, siempre y cuando `FilterPolicyScope` esté configurado en `MessageAttributes` en la suscripción. Para obtener información sobre cómo aplicar atributos a un mensaje, consulte [Atributos de mensajes de Amazon SNS](sns-message-attributes.md).
```
{
"Type": "Notification",
"MessageId": "a1b2c34d-567e-8f90-g1h2-i345j67klmn8",
"TopicArn": "arn:aws:sns:us-east-2:123456789012:MyTopic",
"Message": "message-body-with-transaction-details",
"Timestamp": "2019-11-03T23:28:01.631Z",
"SignatureVersion": "4",
"Signature": "signature",
"UnsubscribeURL": "unsubscribe-url",
"MessageAttributes": {
"customer_interests": {
"Type": "String.Array",
"Value": "[\"soccer\", \"rugby\", \"hockey\"]"
},
"store": {
"Type": "String",
"Value":"example_corp"
},
"event": {
"Type": "String",
"Value": "order_placed"
},
"price_usd": {
"Type": "Number",
"Value": "210.75"
}
}
}
```
En el siguiente ejemplo se muestran los mismos atributos incluidos en el campo `Message`, también denominado *message payload* (carga del mensaje) o *message body* (cuerpo del mensaje). La suscripción al tema que incluye una `FilterPolicy` puede aceptar o rechazar el mensaje de forma selectiva, siempre y cuando `FilterPolicyScope` esté configurado en `MessageBody` en la suscripción.
```
{
"Type": "Notification",
"MessageId": "a1b2c34d-567e-8f90-g1h2-i345j67klmn8",
"TopicArn": "arn:aws:sns:us-east-2:123456789012:MyTopic",
"Message": "{
\"customer_interests\": [\"soccer\", \"rugby\", \"hockey\"],
\"store\": \"example_corp\",
\"event\":\"order_placed\",
\"price_usd\":210.75
}",
"Timestamp": "2019-11-03T23:28:01.631Z",
"SignatureVersion": "4",
"Signature": "signature",
"UnsubscribeURL": "unsubscribe-url"
}
```
Las siguientes políticas de filtro aceptan o rechazan mensajes en función de los nombres de propiedad y valores.
## Política que acepta el mensaje de ejemplo
Las propiedades de la siguiente política de filtrado de suscripciones coinciden con los atributos asignados en el mensaje de ejemplo. Tenga en cuenta que la misma política de filtrado funciona para un `FilterPolicyScope` si está configurado en `MessageAttributes` o `MessageBody`. Cada suscriptor elige el alcance de filtrado en función de la composición de los mensajes que recibe del tema.
Si la propiedad de esta política no coincide con un atributo asignado en el mensaje, la política rechaza el mensaje.
```
{
"store": ["example_corp"],
"event": [{"anything-but": "order_cancelled"}],
"customer_interests": [
"rugby",
"football",
"baseball"
],
"price_usd": [{"numeric": [">=", 100]}]
}
```
## Política que rechaza el mensaje de ejemplo
La siguiente política de filtrado de suscripciones tiene varias discrepancias entre las propiedades y los atributos asignados en el mensaje de ejemplo. Por ejemplo, como el nombre de propiedad `encrypted` no aparece en los atributos del mensaje, esta propiedad de la política provoca que se rechace el mensaje, con independencia del valor que tenga asignado.
Si se producen discrepancias, la política rechaza el mensaje.
```
{
"store": ["example_corp"],
"event": ["order_cancelled"],
"encrypted": [false],
"customer_interests": [
"basketball",
"baseball"
]
}
```
# Restricciones de las políticas de filtrado de Amazon SNS
Al configurar políticas de filtrado en Amazon SNS, debe tener en cuenta varias reglas. Estas reglas ayudan a garantizar la aplicación efectiva de las políticas de filtrado y, al mismo tiempo, a mantener el rendimiento y la compatibilidad del sistema.
## Restricciones de política comunes
Al configurar las políticas de filtrado en Amazon SNS, siga estas reglas importantes para garantizar que funcionen de manera eficaz, al mismo tiempo que se mantienen el rendimiento y la compatibilidad del sistema:
+ **Coincidencia de cadenas**: en la búsqueda de coincidencias de cadenas en la política de filtrado se distingue entre mayúsculas y minúsculas.
+ **Coincidencia numérica**: en la coincidencia numérica, el valor puede oscilar de -109 a 109 (de -1000 millones a 1000 millones), con cinco dígitos de precisión después de la coma decimal.
+ **Complejidad de las políticas de filtrado**: la combinación total de valores en una política de filtrado no debe superar los **150**. Para calcular la combinación total, multiplique el número de valores de cada matriz en la política de filtrado.
+ **Limite el número de claves**: una política de filtrado puede tener un máximo de **cinco** claves.
****Consideraciones adicionales****
+ El código JSON de la política de filtro puede contener lo siguiente:
+ Cadenas entre comillas
+ Números
+ Las palabras clave `true`, `false` y `null`, sin comillas
+ Cuando utilice la API de Amazon SNS, debe pasar el código JSON de la política de filtrado como una cadena **UTF-8 **válida.
+ El tamaño máximo de una política de filtrado es **256 KB**.
+ De forma predeterminada, puedes tener hasta **200** políticas de filtrado por tema y **10 000** políticas de filtrado por AWS cuenta.
Este límite de la política no impedirá que las suscripciones en cola de Amazon SQS se creen con la API [https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html](https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html). Sin embargo, se producirá un error al asociar la política de filtro a la llamada a la API `Subscribe` (o a la llamada a la API [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html)).
Para aumentar esta cuota, puede usar [AWS Service Quotas](https://docs.aws.amazon.com/servicequotas/latest/userguide/intro.html).
## Restricciones de la política para el filtrado basado en atributos
El filtrado basado en atributos es la opción predeterminada. [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html#API_SetSubscriptionAttributes_RequestParameters](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html#API_SetSubscriptionAttributes_RequestParameters) está configurado en `MessageAttributes` en la suscripción.
+ Amazon SNS no acepta una política de filtrado anidado para el filtrado basado en atributos.
+ Amazon SNS compara las propiedades de la política solo con los atributos de mensaje que tienen los siguientes tipos de datos:
+ `String`
+ `String.Array`
**importante**
Al utilizar el filtrado basado en atributos en Amazon SNS, debe evitar dos veces determinados caracteres especiales, en concreto:
Comillas dobles (")
Barras invertidas ()
Si no se eliminan dos veces estos caracteres, la política de filtrado no coincidirá con los atributos de un mensaje publicado y la notificación no se entregará.
**Consideraciones adicionales**
+ No se recomienda pasar objetos a matrices porque puede producir resultados inesperados debido al anidamiento, que no es compatible con el filtrado basado en atributos. Use el filtrado basado en carga para políticas anidadas.
+ `Number` se admite para valores de atributos numéricos.
+ Amazon SNS ignora los atributos de mensaje con el tipo de datos binario.
**Ejemplo de política de complejidad:**
En el siguiente ejemplo de política, la primera clave tiene **tres** operadores de coincidencia, la segunda tiene **un** operador de coincidencia y la tercera tiene **dos** operadores de coincidencia.
```
{
"key_a": ["value_one", "value_two", "value_three"],
"key_b": ["value_one"],
"key_c": ["value_one", "value_two"]
}
```
La combinación total se calcula como el producto del número de operadores de coincidencia de cada clave en la política de filtrado:
```
3(match operators of key_a)
x 1(match operators of key_b)
x 2(match operators of key_c)
= 6
```
## Restricciones de la política para el filtrado basado en carga
Para cambiar del filtrado basado en atributos (predeterminado) al filtrado basado en cargas útiles, debe configurar [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeprovisionIpamPoolCidr.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeprovisionIpamPoolCidr.html) en `MessageBody` en la suscripción.
+ Amazon SNS acepta una política de filtrado anidado para el filtrado basado en carga.
+ En el caso de una política anidada, solo las **claves de hoja** se tienen en cuenta para el límite de **cinco** claves.
**Ejemplo de política para el límite de claves:**
En el siguiente ejemplo de política:
+ Hay dos teclas de hoja: `key_c` y `key_e`.
+ `key_c` tiene **cuatro** operadores de coincidencia con un nivel anidado de **tres** y `key_e` tiene **tres** operadores de coincidencia con un nivel anidado de **dos**.
```
{
"key_a": {
"key_b": {
"key_c": ["value_one", "value_two", "value_three", "value_four"]
}
},
"key_d": {
"key_e": ["value_one", "value_two", "value_three"]
}
}
```
La combinación total se calcula como el producto del número de operadores de coincidencia y el nivel anidado de cada clave en la política de filtrado:
```
4(match operators of key_c)
x 3(nested level of key_c)
x 3(match operators of key_e)
x 2(nested level of key_e)
= 72
```
## Pautas de uso del patrón comodín
Amazon SQS implementa protecciones cuando registra una política de filtrado que contiene comodines para garantizar que no se creen políticas de filtro demasiado complejas, ya que esto afectaría al rendimiento de la aplicación.
**Estructura de patrones**
Los campos contienen uno o más patrones. En el siguiente ejemplo, se muestra un campo con dos patrones:
```
{
"greeting": [
{"anything-but": {"prefix": "Hello"}},
{"wildcard": "H*"}
] // 2 patterns
}
```
**Reglas de complejidad**
+ La complejidad total de los comodines en todos los campos no debe superar los 100 puntos
+ Máximo de 3 comodines por patrón
**Cálculo de complejidad**
+ Complejidad de campo = `(Sum of pattern points)` × `(Number of patterns)`
+ Puntos del patrón:
Comodín único: 1 punto
Varios comodines: 3 puntos cada uno
Coincidencia anything-but: 1 punto
A continuación se muestra un ejemplo del cálculo de complejidad:
```
{
"filename": [
{"wildcard": "*.txt"}, // 1 point
{"wildcard": "log*"} // 1 point
] // Total: (1 + 1) × 2 = 4 points
}
```
# Lógica AND/OR
Utilice AND/OR la lógica en las políticas de filtrado para hacer coincidir los atributos de los mensajes o las propiedades del cuerpo del mensaje en Amazon SNS. Esto permite un filtrado de mensajes más preciso y flexible.
## Lógica AND
Puede aplicar la lógica AND utilizando varios nombres de propiedad.
Considere la siguiente política:
```
{
"customer_interests": ["rugby"],
"price_usd": [{"numeric": [">", 100]}]
}
```
Coincide con cualquier atributo de mensaje o propiedad de cuerpo de mensaje con el valor de `customer_interests` establecido en `rugby` *y* el valor de `price_usd` establecido en un número mayor de 100.
**nota**
No puede aplicar la lógica AND a los valores del mismo atributo.
## Lógica OR
Puede aplicar la lógica OR asignando varios valores a un nombre de propiedad.
Considere la siguiente política:
```
{
"customer_interests": ["rugby", "football", "baseball"]
}
```
Coincide con cualquier atributo de mensaje o propiedad de cuerpo de mensaje con el valor de `customer_interests` establecido en `rugby`, `football` *o* `baseball`.
## Operador OR
Puede utilizar el operador `"$or"` para definir de forma explícita una política de filtrado que exprese la relación OR entre varios atributos de la política.
Amazon SNS solo reconoce una relación `"$or"` cuando la política ha cumplido todas las condiciones siguientes. Cuando no se cumplen todas estas condiciones, `"$or"` se trata como un nombre de atributo normal, igual que cualquier otra cadena de la política.
+ Hay un atributo de campo `"$or"` en la regla seguido de una matriz, por ejemplo `“$or” : []`.
+ Hay al menos 2 objetos en la matriz de `"$or"`: `"$or": [{}, {}]`.
+ Ninguno de los objetos de la matriz de `"$or"` tiene nombres de campo que sean palabras clave reservadas.
De lo contrario, `"$or"` se trata como un nombre de atributo normal, igual que otras cadenas de la política.
La siguiente política no se analiza como una relación OR porque el número y el prefijo son palabras clave reservadas.
```
{
"$or": [ {"numeric" : 123}, {"prefix": "abc"} ]
}
```
**Ejemplos de operadores `OR`**
`OR` estándar:
```
{
"source": [ "aws.cloudwatch" ],
"$or": [
{ "metricName": [ "CPUUtilization" ] },
{ "namespace": [ "AWS/EC2" ] }
]
}
```
La lógica de filtrado de esta política es:
```
"source" && ("metricName" || "namespace")
```
Coincide con cualquiera de los siguientes conjuntos de atributos de mensaje:
```
"source": {"Type": "String", "Value": "aws.cloudwatch"},
"metricName": {"Type": "String", "Value": "CPUUtilization"}
```
o
```
"source": {"Type": "String", "Value": "aws.cloudwatch"},
"namespace": {"Type": "String", "Value": "AWS/EC2"}
```
También coincide con los siguientes cuerpos de mensaje:
```
{
"source": "aws.cloudwatch",
"metricName": "CPUUtilization"
}
```
o
```
{
"source": "aws.cloudwatch",
"namespace": "AWS/EC2"
}
```
### Restricciones de políticas que incluyen relaciones `OR`
Considere la siguiente política:
```
{
"source": [ "aws.cloudwatch" ],
"$or": [
{ "metricName": [ "CPUUtilization", "ReadLatency" ] },
{
"metricType": [ "MetricType" ] ,
"$or" : [
{ "metricId": [ 1234, 4321 ] },
{ "spaceId": [ 1000, 2000, 3000 ] }
]
}
]
}
```
La lógica de esta política también se puede simplificar de la siguiente manera:
```
("source" AND "metricName")
OR
("source" AND "metricType" AND "metricId")
OR
("source" AND "metricType" AND "spaceId")
```
El cálculo de la complejidad de las políticas con relaciones OR se puede simplificar como la suma de las complejidades combinadas de cada declaración OR.
La combinación total se calcula del siguiente modo:
```
(source * metricName) + (source * metricType * metricId) + (source * metricType * spaceId)
= (1 * 2) + (1 * 1 * 2) + (1 * 1 * 3)
= 7
```
`source` tiene un valor, `metricName` tiene dos valores, `metricType` tiene un valor, `metricId` tiene dos valores y `spaceId` tiene tres valores.
Tenga en cuenta la siguiente política de filtrado anidado:
```
{
"$or": [
{ "metricName": [ "CPUUtilization", "ReadLatency" ] },
{ "namespace": [ "AWS/EC2", "AWS/ES" ] }
],
"detail" : {
"scope" : [ "Service" ],
"$or": [
{ "source": [ "aws.cloudwatch" ] },
{ "type": [ "CloudWatch Alarm State Change"] }
]
}
}
```
La lógica de esta política se puede simplificar de la siguiente manera:
```
("metricName" AND ("detail"."scope" AND "detail"."source")
OR
("metricName" AND ("detail"."scope" AND "detail"."type")
OR
("namespace" AND ("detail"."scope" AND "detail"."source")
OR
("namespace" AND ("detail"."scope" AND "detail"."type")
```
El cálculo para las combinaciones totales es el mismo para las políticas no anidadas, excepto que debemos tener en cuenta el nivel de anidación de una clave.
La combinación total se calcula del siguiente modo:
```
(2 * 2 * 2) + (2 * 2 * 2) + (2 * 2 * 2) + (2 * 2 * 2) = 32
```
`metricName` tiene dos valores, `namespace` tiene dos valores, `scope` es una clave anidada de dos niveles con un valor, `source` es una clave anidada de dos niveles con un valor y `type` es una clave anidada de dos niveles con un valor.
# Coincidencia de claves
Utilice el operador `exists` en una política de filtrado para hacer coincidir los mensajes entrantes en función de si una propiedad específica está presente o ausente.
+ `exists` solo funciona en los nodos de hoja (atributos finales en la estructura).
+ No se aplica a los nodos intermedios dentro de una estructura JSON anidada.
+ Utilice `"exists": true` para hacer coincidir los mensajes entrantes que incluyen la propiedad especificada. La clave debe tener un valor no nulo y no vacío.
Por ejemplo, la siguiente propiedad de política utiliza el operador `exists` con un valor de `true`:
```
"store": [{"exists": true}]
```
Coincide con la lista de atributos de mensaje que contenga la clave de atributo `store`, como el siguiente:
```
"store": {"Type": "String", "Value": "fans"}
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
También coincide con el siguiente cuerpo de mensaje:
```
{
"store": "fans"
"customer_interests": ["baseball", "basketball"]
}
```
Sin embargo, no coincide con la lista de atributos del mensaje *sin* la clave de atributo `store`, como el siguiente:
```
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
Tampoco coincide con el siguiente cuerpo del mensaje:
```
{
"customer_interests": ["baseball", "basketball"]
}
```
+ Utilice `"exists": false` para hacer coincidir los mensajes entrantes que *no* incluyan la propiedad especificada.
**nota**
`"exists": false` solo coincide si hay al menos un atributo. Si el conjunto de atributos está vacío, el filtro no coincide.
Por ejemplo, la siguiente propiedad de política utiliza el operador `exists` con un valor de `false`:
```
"store": [{"exists": false}]
```
*No* coincide con la lista de atributos de mensaje que contenga la clave de atributo `store`, como el siguiente:
```
"store": {"Type": "String", "Value": "fans"}
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
Tampoco coincide con el siguiente cuerpo del mensaje:
```
{
"store": "fans"
"customer_interests": ["baseball", "basketball"]
}
```
Sin embargo, coincide con la lista de atributos del mensaje *sin* la clave de atributo `store`, como el siguiente:
```
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
También coincide con el siguiente cuerpo de mensaje:
```
{
"customer_interests": ["baseball", "basketball"]
}
```
# Coincidencia de valor numérico
Filtre los mensajes haciendo coincidir los valores numéricos con los valores de los atributos del mensaje o con los valores de las propiedades del cuerpo del mensaje. Los valores numéricos no están entre comillas en la política JSON. Puede utilizar las siguientes operaciones numéricas para filtrar.
**nota**
Los prefijos solo se admiten para la coincidencia de *cadena*.
## Coincidencia exacta
Cuando un valor de propiedad de política incluye la palabra clave `numeric` y el operador `=`, coincide con cualquier atributo de mensajes o valores de propiedad de cuerpo de mensajes que tenga el mismo nombre y un valor numérico igual.
Considere la siguiente propiedad de política:
```
"price_usd": [{"numeric": ["=",301.5]}]
```
Coincide con cualquiera de los siguientes atributos de mensaje:
```
"price_usd": {"Type": "Number", "Value": 301.5}
```
```
"price_usd": {"Type": "Number", "Value": 3.015e2}
```
También coincide con los siguientes cuerpos de mensaje:
```
{
"price_usd": 301.5
}
```
```
{
"price_usd": 3.015e2
}
```
## Coincidencia "anything-but"
Cuando el valor de una propiedad de política incluye la palabra clave `anything-but`, coincide con cualquier valor de atributo o propiedad del cuerpo del mensaje que *no* incluya ninguno de los valores de las propiedades de la política.
Considere la siguiente propiedad de política:
```
"price": [{"anything-but": [100, 500]}]
```
Coincide con cualquiera de los siguientes atributos de mensaje:
```
"price": {"Type": "Number", "Value": 101}
```
```
"price": {"Type": "Number", "Value": 100.1}
```
También coincide con los siguientes cuerpos de mensaje:
```
{
"price": 101
}
```
```
{
"price": 100.1
}
```
Además, coincide con el siguiente atributo de mensaje (porque contiene un valor que *no es* `100` ni `500`):
```
"price": {"Type": "Number.Array", "Value": "[100, 50]"}
```
También coincide con el siguiente cuerpo de mensaje (porque contiene un valor que *no es* `100` ni `500`):
```
{
"price": [100, 50]
}
```
Sin embargo, no coincide con el siguiente atributo de mensaje:
```
"price": {"Type": "Number", "Value": 100}
```
Tampoco coincide con el siguiente cuerpo del mensaje:
```
{
"price": 100
}
```
## Coincidencia de intervalo de valores
Además del operador `=`, una propiedad de política numérica puede incluir los siguientes operadores: `<`, `<=`, `>` y `>=`.
Considere la siguiente propiedad de política:
```
"price_usd": [{"numeric": ["<", 0]}]
```
Coincide con cualquier atributo de mensaje o propiedad de cuerpo de mensaje con valores numéricos negativos.
Considere otro atributo de mensaje:
```
"price_usd": [{"numeric": [">", 0, "<=", 150]}]
```
Coincide con cualquier atributo de mensaje o propiedad de cuerpo de mensaje con números positivos hasta el 150 inclusive.
# Coincidencia de valor de cadena
Filtre los mensajes haciendo coincidir los valores de las cadenas con los valores de los atributos del mensaje o con los valores de las propiedades del cuerpo del mensaje. Los valores de cadena están entre comillas en la política JSON. Puede utilizar las siguientes operaciones de cadena para hacer coincidir los atributos de los mensajes o las propiedades del cuerpo de los mensajes:
## Coincidencia exacta
La coincidencia exacta se produce cuando un valor de propiedad de la política coincide con uno o varios valores de atributo del mensaje. Para los atributos del tipo `String.Array`, cada elemento de la matriz se trata como una cadena independiente con fines de coincidencia.
Considere la siguiente propiedad de política:
```
"customer_interests": ["rugby", "tennis"]
```
Coincide con los siguientes atributos de mensaje:
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
```
"customer_interests": {"Type": "String", "Value": "tennis"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\", \"tennis\"]"}
```
También coincide con los siguientes cuerpos de mensaje:
```
{
"customer_interests": "rugby"
}
```
```
{
"customer_interests": "tennis"
}
```
Sin embargo, no coincide con los siguientes atributos de mensajes:
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\"]"}
```
Tampoco coincide con el siguiente cuerpo del mensaje:
```
{
"customer_interests": "baseball"
}
```
## Coincidencia "anything-but"
Cuando el valor de una propiedad de política incluye la palabra clave `anything-but`, coincide con cualquier atributo de mensaje o valor del cuerpo del mensaje que *no* incluya ninguno de los valores de las propiedades de la política. `anything-but` se puede combinar con `"exists": false`. Para los atributos del tipo `String.Array`, coincide si ninguno de los elementos de la matriz aparece en la propiedad de la política.
Considere la siguiente propiedad de política:
```
"customer_interests": [{"anything-but": ["rugby", "tennis"]}]
```
Coincide con cualquiera de los siguientes atributos de mensaje:
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String", "Value": "football"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\", \"baseball\"]"}
```
También coincide con los siguientes cuerpos de mensaje:
```
{
"customer_interests": "baseball"
}
```
```
{
"customer_interests": "football"
}
```
Además, coincide con el siguiente atributo de mensaje (porque contiene un valor que *no es* `rugby` ni `tennis`):
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\", \"baseball\"]"}
```
Y también coincide con el siguiente cuerpo de mensaje (porque contiene un valor que no es `rugby` ni `tennis`):
```
{
"customer_interests": ["rugby", "baseball"]
}
```
Sin embargo, no coincide con los siguientes atributos de mensajes:
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\"]"}
```
Tampoco coincide con el siguiente cuerpo del mensaje:
```
{
"customer_interests": ["rugby"]
}
```
**Uso de un prefijo con `anything-but`**
Para la coincidencia de la cadena, también puede usar un prefijo con `anything-but` con el operador. Por ejemplo, la propiedad de política siguiente deniega el prefijo `order-`:
```
"event":[{"anything-but": {"prefix": "order-"}}]
```
Coincide con cualquiera de los siguientes atributos:
```
"event": {"Type": "String", "Value": "data-entry"}
```
```
"event": {"Type": "String", "Value": "order_number"}
```
También coincide con los siguientes cuerpos de mensaje:
```
{
"event": "data-entry"
}
```
```
{
"event": "order_number"
}
```
Sin embargo, no coincide con el siguiente atributo de mensaje:
```
"event": {"Type": "String", "Value": "order-cancelled"}
```
Tampoco coincide con el siguiente cuerpo del mensaje:
```
{
"event": "order-cancelled"
}
```
**Comodín anything-but**
La siguiente propiedad de política niega el comodín `*ball`:
```
"customer_interests" : [{ "anything-but": { "wildcard": "*ball" }}]
```
Coincide con los siguientes atributos:
```
{"customer_interests": ["hockey", "rugby", "soccer] }
```
Sin embargo, no coincide con el siguiente atributo de mensaje:
```
{"customer_interests": ["baseball", "basketball"] }
```
**sufijo anything-but**
La siguiente propiedad de política niega el sufijo `-ball`
:
```
"customer_interests": [ { "anything-but": { "suffix": "ball" } } ]
```
Coincide con los siguientes atributos:
```
{"customer_interests": ["hockey", "rugby", "soccer] }
```
Sin embargo, no coincide con el siguiente atributo de mensaje:
```
{"customer_interests": ["baseball", "basketball"] }
```
## Equals-ignore-case coincidente
Cuando una propiedad de política incluye la palabra clave `equals-ignore-case`, realizará una coincidencia que no distingue entre mayúsculas y minúsculas con el atributo de mensaje o valor de propiedad del cuerpo.
Considere la siguiente propiedad de política:
```
"customer_interests": [{"equals-ignore-case": "tennis"}]
```
Coincide con cualquiera de los siguientes atributos de mensaje:
```
"customer_interests": {"Type": "String", "Value": "TENNIS"}
```
```
"customer_interests": {"Type": "String", "Value": "Tennis"}
```
También coincide con los siguientes cuerpos de mensaje:
```
{
"customer_interests": "TENNIS"
}
```
```
{
"customer_interests": "teNnis"
{
```
## Coincidencia de direcciones IP
Puede utilizar el operador `cidr` para verificar si un mensaje entrante se origina desde una dirección IP o subred específica.
Considere la siguiente propiedad de política:
```
"source_ip":[{"cidr": "10.0.0.0/24"}]
```
Coincide con cualquiera de los siguientes atributos de mensaje:
```
"source_ip": {"Type": "String", "Value": "10.0.0.0"}
```
```
"source_ip": {"Type": "String", "Value": "10.0.0.255"}
```
También coincide con los siguientes cuerpos de mensaje:
```
{
"source_ip": "10.0.0.0"
}
```
```
{
"source_ip": "10.0.0.255"
}
```
Sin embargo, no coincide con el siguiente atributo de mensaje:
```
"source_ip": {"Type": "String", "Value": "10.1.1.0"}
```
Tampoco coincide con el siguiente cuerpo del mensaje:
```
{
"source_ip": "10.1.1.0"
}
```
## Coincidencia de prefijos
Cuando una propiedad de política incluye la palabra clave `prefix`, coincide con cualquier valor de atributo de mensaje o valor de propiedad de cuerpo que empiece por los caracteres especificados.
Considere la siguiente propiedad de política:
```
"customer_interests": [{"prefix": "bas"}]
```
Coincide con cualquiera de los siguientes atributos de mensaje:
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String", "Value": "basketball"}
```
También coincide con los siguientes cuerpos de mensaje:
```
{
"customer_interests": "baseball"
}
```
```
{
"customer_interests": "basketball"
}
```
Sin embargo, no coincide con el siguiente atributo de mensaje:
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
Tampoco coincide con el siguiente cuerpo del mensaje:
```
{
"customer_interests": "rugby"
}
```
## Coincidencia de sufijos
Cuando una propiedad de política incluye la palabra clave `suffix`, coincide con cualquier valor de atributo de mensaje o valor de propiedad de cuerpo que termine por los caracteres especificados.
Considere la siguiente propiedad de política:
```
"customer_interests": [{"suffix": "ball"}]
```
Coincide con cualquiera de los siguientes atributos de mensaje:
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String", "Value": "basketball"}
```
También coincide con los siguientes cuerpos de mensaje:
```
{
"customer_interests": "baseball"
}
```
```
{
"customer_interests": "basketball"
}
```
Sin embargo, no coincide con el siguiente atributo de mensaje:
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
Tampoco coincide con el siguiente cuerpo del mensaje:
```
{
"customer_interests": "rugby"
}
```
## Comodín
Puede utilizar el carácter comodín (\$1) para hacer coincidir los valores de cadena en patrones de eventos.
La siguiente política utiliza el carácter comodín (\$1):
```
"customer_interests": [ { "wildcard": "*ball" } ]
```
Coincide con los siguientes atributos:
```
{"customer_interests": ["baseball", "basketball"] }
```