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.
# Filtrado de mensajes en Amazon SNS
De forma predeterminada, un suscriptor de un tema de Amazon SNS recibe todos los mensajes que se publican en el tema. Para recibir solo un subconjunto de los mensajes, un suscriptor debe asignar una *política de filtrado* a la suscripción del tema.
Una política de filtrado es un objeto JSON que contiene propiedades que definen qué mensajes recibe el suscriptor. Amazon SNS admite políticas que actúan en los atributos del mensaje o en el cuerpo del mensaje, de acuerdo con el alcance de la política de filtrado que haya establecido para la suscripción. Las políticas de filtrado del cuerpo del mensaje asumen que la carga útil del mensaje es un objeto JSON bien formado.
Si una suscripción no tiene una política de filtrado, el suscriptor recibe todos los mensajes publicados en el tema. Cuando publica un mensaje en un tema con una política de filtrado, Amazon SNS compara los atributos del mensaje o el cuerpo del mensaje con las propiedades de la política de filtrado para cada una de las suscripciones del tema. Si todos los atributos del mensaje o propiedades del cuerpo del mensaje satisfacen las condiciones especificadas en la política de filtrado, Amazon SNS envía el mensaje al suscriptor. De lo contrario, Amazon SNS no envía el mensaje a ese suscriptor.
Para obtener más información, consulte [Filtrar mensajes publicados en temas](https://aws.amazon.com/getting-started/tutorials/filter-messages-published-to-topics/).
# Alcance de políticas de filtrado de suscripciones de Amazon SNS
El atributo de suscripción `FilterPolicyScope` le permite definir el alcance del filtrado mediante la configuración de uno de los siguientes valores:
+ `MessageAttributes`: aplica la política de filtrado a los atributos de los mensajes (configuración predeterminada).
+ `MessageBody`: aplica la política de filtrado al cuerpo del mensaje.
**nota**
Si no se define el alcance de la política de filtrado para una política de filtrado existente, el alcance se establece de forma predeterminada en `MessageAttributes`.
# 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"] }
```
# Aplicación de una política de filtrado de suscripciones en Amazon SNS
El filtrado de mensajes en Amazon SNS le permite entregar mensajes a los suscriptores de forma selectiva en función de las políticas de filtrado. Estas políticas definen las condiciones que deben cumplir los mensajes para poder entregarse a una suscripción. Si bien la entrega de mensajes sin procesar es una opción que puede afectar al procesamiento de los mensajes, no es necesaria para que los filtros de suscripción funcionen.
Puede aplicar una política de filtro a una suscripción de Amazon SNS mediante la consola de Amazon SNS. O bien, para aplicar las políticas mediante programación, puede utilizar la API de Amazon SNS, AWS Command Line Interface el AWS CLI() o AWS cualquier SDK compatible con Amazon SNS. También puede usar. AWS CloudFormation
**Habilitación de la entrega de mensajes sin procesar**
La entrega de mensajes sin procesar garantiza que las cargas útiles de los mensajes se entreguen tal cual a los suscriptores, sin necesidad de codificación ni transformación adicionales. Esto puede resultar útil cuando los suscriptores necesitan el formato de mensaje original para su procesamiento. Sin embargo, la entrega de mensajes sin procesar no está directamente relacionada con la funcionalidad de los filtros de suscripción.
**Aplicación de filtros de suscripciones**
Para aplicar filtros de mensajes a una suscripción, debe definir una política de filtrado mediante la sintaxis JSON. Esta política especifica las condiciones que debe cumplir un mensaje para entregarse a la suscripción. Los filtros se pueden basar en atributos del mensaje, como los atributos del mensaje, la estructura del mensaje o incluso el contenido del mensaje.
**Relación entre la entrega de mensajes sin procesar y los filtros de suscripción**
Aunque habilitar la entrega de mensajes sin procesar puede afectar a la forma en que los suscriptores entregan y procesan los mensajes, no es un requisito previo para usar filtros de suscripción. Sin embargo, en situaciones en las que los suscriptores requieren el formato de mensaje original sin ninguna modificación, habilitar la entrega de mensajes sin procesar podría resultar beneficioso junto con los filtros de suscripción.
**Consideraciones para un filtrado eficaz**
Al implementar el filtrado de mensajes, tenga en cuenta los requisitos específicos de su aplicación y de sus suscriptores. Defina políticas de filtrado que coincidan con precisión con los criterios de entrega de mensajes para garantizar una distribución eficiente y específica de los mensajes.
**importante**
AWS 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.
## Consola de administración de AWS
1. Inicie sesión en la [consola de Amazon SNS](https://console.aws.amazon.com/sns/home).
1. En el panel de navegación, seleccione **Subscriptions (Suscripciones)**.
1. Seleccione una suscripción y, a continuación, elija **Edit (Editar)**.
1. En la página **Edit** (Editar), amplíe la sección **Subscription filter policy** (Política de filtro de suscripción).
1. Elija entre el **filtrado basado en atributos** o el **filtrado basado en cargas**.
1. En el campo **JSON editor** (Editor JSON), proporcione el **cuerpo JSON** de su política de filtrado.
1. Seleccione **Save changes (Guardar cambios)**.
Amazon SNS aplica la política de filtro a la suscripción.
## AWS CLI
Para aplicar una política de filtrado con AWS Command Line Interface (AWS CLI), utilice el [https://docs.aws.amazon.com/cli/latest/reference/sns/set-subscription-attributes.html](https://docs.aws.amazon.com/cli/latest/reference/sns/set-subscription-attributes.html)comando, como se muestra en el siguiente ejemplo. Para la opción `--attribute-name`, especifique `FilterPolicy`. Para `--attribute-value`, especifique la **política JSON**.
```
$ aws sns set-subscription-attributes --subscription-arn arn:aws:sns: ... --attribute-name FilterPolicy --attribute-value '{"store":["example_corp"],"event":["order_placed"]}'
```
Para proporcionar un objeto JSON válido para su política, incluya los nombres de atributos y valores entre comillas dobles. Incluya también todo el argumento de la política entre comillas. Para evitar que las comillas se interpreten como caracteres de escape, puede utilizar comillas simples para delimitar la política y comillas dobles para delimitar los nombres y los valores JSON, tal y como se muestra en el ejemplo anterior.
Si quieres cambiar de un filtrado de mensajes basado en atributos (predeterminado) a uno basado en cargas útiles, también puedes usar el [set-subscription-attributes](https://docs.aws.amazon.com/cli/latest/reference/sns/set-subscription-attributes.html)comando. Para la opción `--attribute-name`, especifique `FilterPolicyScope`. En `--attribute-value`, especifique `MessageBody`.
```
$ aws sns set-subscription-attributes --subscription-arn arn:aws:sns: ... --attribute-name FilterPolicyScope --attribute-value MessageBody
```
Para verificar que su política de filtro se ha aplicado, utilice el comando `get-subscription-attributes`. Los atributos del resultado deben mostrar la política de filtro para la clave `FilterPolicy`, tal y como se muestra en el ejemplo siguiente:
```
$ aws sns get-subscription-attributes --subscription-arn arn:aws:sns: ...
{
"Attributes": {
"Endpoint": "endpoint . . .",
"Protocol": "https",
"RawMessageDelivery": "false",
"EffectiveDeliveryPolicy": "delivery policy . . .",
"ConfirmationWasAuthenticated": "true",
"FilterPolicy": "{\"store\": [\"example_corp\"], \"event\": [\"order_placed\"]}",
"FilterPolicyScope": "MessageAttributes",
"Owner": "111122223333",
"SubscriptionArn": "arn:aws:sns: . . .",
"TopicArn": "arn:aws:sns: . . ."
}
}
```
## AWS SDKs
Los siguientes ejemplos de código muestran cómo utilizar `SetSubscriptionAttributes`.
**importante**
Si utiliza el ejemplo de SDK for Java 2.x, la clase `SNSMessageFilterPolicy` no está disponible para usar. Para obtener instrucciones sobre cómo instalar esta clase, consulta el [ejemplo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/sns/src/main/java/com/example/sns/SNSMessageFilterPolicy.java) del sitio web. GitHub
------
#### [ CLI ]
**AWS CLI**
**Establecimiento de los atributos de suscripción**
En el siguiente ejemplo de `set-subscription-attributes`, se establece el atributo `RawMessageDelivery` en una suscripción de SQS.
```
aws sns set-subscription-attributes \
--subscription-arn arn:aws:sns:us-east-1:123456789012:mytopic:f248de18-2cf6-578c-8592-b6f1eaa877dc \
--attribute-name RawMessageDelivery \
--attribute-value true
```
Este comando no genera ninguna salida.
En el siguiente ejemplo de `set-subscription-attributes`, se establece un atributo `FilterPolicy` en una suscripción de SQS.
```
aws sns set-subscription-attributes \
--subscription-arn arn:aws:sns:us-east-1:123456789012:mytopic:f248de18-2cf6-578c-8592-b6f1eaa877dc \
--attribute-name FilterPolicy \
--attribute-value "{ \"anyMandatoryKey\": [\"any\", \"of\", \"these\"] }"
```
Este comando no genera ninguna salida.
En el siguiente ejemplo de `set-subscription-attributes`, se elimina el atributo `FilterPolicy` de una suscripción de SQS.
```
aws sns set-subscription-attributes \
--subscription-arn arn:aws:sns:us-east-1:123456789012:mytopic:f248de18-2cf6-578c-8592-b6f1eaa877dc \
--attribute-name FilterPolicy \
--attribute-value "{}"
```
Este comando no genera ninguna salida.
+ Para obtener más información sobre la API, consulte [SetSubscriptionAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/set-subscription-attributes.html)la *Referencia de AWS CLI comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/sns#code-examples).
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.SnsException;
import java.util.ArrayList;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class UseMessageFilterPolicy {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
subscriptionArn - The ARN of a subscription.
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String subscriptionArn = args[0];
SnsClient snsClient = SnsClient.builder()
.region(Region.US_EAST_1)
.build();
usePolicy(snsClient, subscriptionArn);
snsClient.close();
}
public static void usePolicy(SnsClient snsClient, String subscriptionArn) {
try {
SNSMessageFilterPolicy fp = new SNSMessageFilterPolicy();
// Add a filter policy attribute with a single value
fp.addAttribute("store", "example_corp");
fp.addAttribute("event", "order_placed");
// Add a prefix attribute
fp.addAttributePrefix("customer_interests", "bas");
// Add an anything-but attribute
fp.addAttributeAnythingBut("customer_interests", "baseball");
// Add a filter policy attribute with a list of values
ArrayList attributeValues = new ArrayList<>();
attributeValues.add("rugby");
attributeValues.add("soccer");
attributeValues.add("hockey");
fp.addAttribute("customer_interests", attributeValues);
// Add a numeric attribute
fp.addAttribute("price_usd", "=", 0);
// Add a numeric attribute with a range
fp.addAttributeRange("price_usd", ">", 0, "<=", 100);
// Apply the filter policy attributes to an Amazon SNS subscription
fp.apply(snsClient, subscriptionArn);
} catch (SnsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ Para obtener más información sobre la API, consulta [SetSubscriptionAttributes](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/SetSubscriptionAttributes)la *Referencia AWS SDK for Java 2.x de la API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/sns#code-examples).
```
class SnsWrapper:
"""Encapsulates Amazon SNS topic and subscription functions."""
def __init__(self, sns_resource):
"""
:param sns_resource: A Boto3 Amazon SNS resource.
"""
self.sns_resource = sns_resource
@staticmethod
def add_subscription_filter(subscription, attributes):
"""
Adds a filter policy to a subscription. A filter policy is a key and a
list of values that are allowed. When a message is published, it must have an
attribute that passes the filter or it will not be sent to the subscription.
:param subscription: The subscription the filter policy is attached to.
:param attributes: A dictionary of key-value pairs that define the filter.
"""
try:
att_policy = {key: [value] for key, value in attributes.items()}
subscription.set_attributes(
AttributeName="FilterPolicy", AttributeValue=json.dumps(att_policy)
)
logger.info("Added filter to subscription %s.", subscription.arn)
except ClientError:
logger.exception(
"Couldn't add filter to subscription %s.", subscription.arn
)
raise
```
+ Para obtener más información sobre la API, consulta [SetSubscriptionAttributes](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/SetSubscriptionAttributes)la *AWS Referencia de API de SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Hay más información al respecto. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/sns#code-examples).
```
TRY.
lo_sns->setsubscriptionattributes(
iv_subscriptionarn = iv_subscription_arn
iv_attributename = 'FilterPolicy'
iv_attributevalue = iv_filter_policy ).
MESSAGE 'Added filter policy to subscription.' TYPE 'I'.
CATCH /aws1/cx_snsnotfoundexception.
MESSAGE 'Subscription does not exist.' TYPE 'E'.
ENDTRY.
```
+ Para obtener más información sobre la API, consulte [SetSubscriptionAttributes](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)la *referencia sobre la API ABAP del AWS SDK para SAP*.
------
## API de Amazon SNS
Para aplicar una política de filtro con la API de Amazon SNS, realice una solicitud a la acción [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html). Establezca el parámetro `AttributeName` en `FilterPolicy` y el parámetro `AttributeValue` en el objeto JSON de la política de filtro.
Si quiere cambiar de filtrado de mensajes basado en atributos (predeterminado) a filtrado de mensajes basado en cargas, puede usar también la acción [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html). Establezca el parámetro `AttributeName` en `FilterPolicyScope` y el parámetro `AttributeValue` en `MessageBody`.
## AWS CloudFormation
Para aplicar una política de filtrado CloudFormation, utilice una plantilla JSON o YAML para crear una CloudFormation pila. Para obtener más información, consulta la [`FilterPolicy`propiedad](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sns-subscription.html#cfn-sns-subscription-filterpolicy) del `AWS::SNS::Subscription` recurso en la *Guía del AWS CloudFormation usuario* y en la [CloudFormation plantilla de ejemplo](https://github.com/aws-samples/aws-sns-samples/blob/master/templates/SNS-Subscription-Attributes-Tutorial-CloudFormation.template).
1. Inicie sesión en la [consola de CloudFormation](https://console.aws.amazon.com/cloudformation).
1. Elija **Crear pila**.
1. En la página **Select Template (Seleccionar plantilla)**, elija **Upload a template to Amazon S3 (Cargar una plantilla en Amazon S3)**, elija el archivo y, a continuación, elija **Next (Siguiente)**.
1. En la página **Specify Details (Especificar detalles)**, haga lo siguiente:
1. Para **Stack Name (Nombre de la pila)**, escriba `MyFilterPolicyStack`.
1. Para **myHttpEndpoint**, escriba el punto final HTTP al que se va a suscribir al tema.
**sugerencia**
Si no dispone de un punto de enlace HTTP, cree uno.
1. En la página **Opciones**, seleccione **Siguiente**.
1. En la página **Review (Revisar)**, elija **Create (Crear)**.
# Eliminación de una política de filtrado de suscripciones en Amazon SNS
Para dejar de filtrar los mensajes que se envían a una suscripción, quite la política de filtro de la suscripción sobrescribiéndola con un cuerpo JSON vacío. Después de quitar la política, la suscripción acepta todos los mensajes que se han publicado en ella.
## Uso del Consola de administración de AWS
1. Inicie sesión en la [consola de Amazon SNS](https://console.aws.amazon.com/sns/home).
1. En el panel de navegación, seleccione **Subscriptions (Suscripciones)**.
1. Seleccione una suscripción y, a continuación, elija **Edit (Editar)**.
1. En la *EXAMPLE1-23bc-4567-d890-ef12g3hij456* página de **edición**, expanda la sección **Política de filtro de suscripciones**.
1. En el campo **JSON editor (Editor de JSON)**, proporcione un cuerpo JSON vacío de su política de filtro: `{}`.
1. Seleccione **Save changes (Guardar cambios)**.
Amazon SNS aplica la política de filtro a la suscripción.
## Usando el AWS CLI
Para eliminar una política de filtrado con AWS CLI, usa el [https://docs.aws.amazon.com/cli/latest/reference/sns/set-subscription-attributes.html](https://docs.aws.amazon.com/cli/latest/reference/sns/set-subscription-attributes.html)comando y proporciona un cuerpo JSON vacío para el `--attribute-value` argumento:
```
$ aws sns set-subscription-attributes --subscription-arn arn:aws:sns: ... --attribute-name FilterPolicy --attribute-value "{}"
```
## Uso de la API de Amazon SNS
Para quitar una política de filtro con la API de Amazon SNS, realice una solicitud a la acción [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html). Establezca el parámetro `AttributeName` en `FilterPolicy` y proporcione un cuerpo JSON vacío para el parámetro `AttributeValue`.