As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Filtragem de mensagens do Amazon SNS
Por padrão, um assinante de tópico do Amazon SNS recebe todas as mensagens publicadas no tópico. Para receber apenas um subconjunto de mensagens, um assinante deve atribuir uma *política de filtro* à assinatura do tópico.
Uma política de filtro é um objeto JSON que contém propriedades que definem quais mensagens o assinante recebe. O Amazon SNS oferece suporte a políticas que atuam nos atributos da mensagem ou no corpo da mensagem, de acordo com o escopo da política de filtro que você definiu para a assinatura. As políticas de filtro para o corpo da mensagem pressupõem que a carga útil da mensagem seja um objeto JSON bem formado.
Se uma assinatura não tiver uma política de filtro, o assinante receberá todas as mensagens publicadas ao tópico. Quando você publica uma mensagem em um tópico com uma política de filtro em vigor, o Amazon SNS compara os atributos da mensagem ou o corpo da mensagem com as propriedades na política de filtro para cada assinatura do tópico. Se houver satisfação com as condições especificadas na política de filtro, o Amazon SNS enviará a mensagem para o assinante. Caso contrário, o Amazon SNS não enviará a mensagem para esse assinante.
Para obter mais informações, consulte [Filtre mensagens publicadas em tópicos](https://aws.amazon.com/getting-started/tutorials/filter-messages-published-to-topics/).
# Escopo de política de filtro de assinaturas do Amazon SNS
O atributo de assinatura `FilterPolicyScope` permite que você defina o escopo da filtragem usando um dos seguintes valores:
+ `MessageAttributes`: aplica a política de filtro aos atributos da mensagem (configuração padrão).
+ `MessageBody`: aplica a política de filtro ao corpo da mensagem.
**nota**
Se nenhum escopo de política de filtro for definido para uma política de filtro existente, o escopo assumirá `MessageAttributes` como padrão.
# Políticas de filtro de assinatura do Amazon SNS
Uma política de filtro de assinatura permite especificar nomes de propriedades e atribuir uma lista de valores para cada nome de propriedade. Para obter mais informações, consulte [Filtragem de mensagens do Amazon SNS](sns-message-filtering.md).
Quando o Amazon SNS avalia os atributos ou o corpo da mensagem em relação à política de filtro de assinatura, ele ignora atributos que não estão especificados na política.
**Importante**
AWS serviços como IAM e Amazon SNS usam um modelo de computação distribuída chamado consistência eventual. As adições ou alterações a uma política de filtro de assinatura podem levar até 15 minutos para entrarem em vigor.
Uma assinatura aceita uma mensagem nas seguintes condições:
+ Quando o escopo da política de filtro está definido como `MessageAttributes`, cada nome de propriedade na política de filtro corresponde ao nome de um atributo da mensagem. Para cada nome de propriedade correspondente na política de filtro, pelo menos um valor de propriedade corresponde ao valor do atributo da mensagem.
+ Quando o escopo da política de filtro está definido como `MessageBody`, cada nome de propriedade na política de filtro corresponde ao nome de uma propriedade do corpo da mensagem. Para cada nome de propriedade correspondente na política de filtro, pelo menos um valor de propriedade corresponde ao valor da propriedade do corpo da mensagem.
Atualmente, o Amazon SNS é compatível com os seguintes operadores de filtro:
+ [Lógica E](and-or-logic.md#and-logic)
+ [Lógica OU](and-or-logic.md#or-logic)
+ [Operador OU](and-or-logic.md#or-operator)
+ [Correspondência de chaves](attribute-key-matching.md)
+ [Correspondência exata do valor numérico](numeric-value-matching.md#numeric-exact-matching)
+ [Correspondência tudo-exceto de valor numérico](numeric-value-matching.md#numeric-anything-but-matching)
+ [Correspondência de valores numéricos](numeric-value-matching.md#numeric-value-range-matching)
+ [Correspondência de valores de string](string-value-matching.md#string-exact-matching)
+ [Correspondência tudo-exceto de valor de string](string-value-matching.md#string-anything-but-matching)
+ [Correspondência de string usando um prefixo com o operador tudo-exceto](string-value-matching.md#string-anything-but-matching)
+ [Correspondência de igual-ignorar-capitalização do valor da string](string-value-matching.md#string-equals-ignore)
+ [Correspondência do endereço IP do valor da string](string-value-matching.md#string-address-matching)
+ [Correspondência de prefixo de valores de string](string-value-matching.md#string-prefix-matching)
+ [Correspondência de sufixo de valores de string](string-value-matching.md#string-suffix-matching)
# Exemplo de políticas de filtro do Amazon SNS
O exemplo a seguir mostra uma carga útil da mensagem entregue por um tópico do Amazon SNS que processa as transações de clientes.
O primeiro exemplo inclui o campo `MessageAttributes` com atributos que descrevem a transação:
+ Interesses do cliente
+ Nome do repositório
+ Estado do evento
+ Preço de compra em USD
Como essa mensagem inclui o campo `MessageAttributes`, qualquer assinatura de tópico que defina uma `FilterPolicy` pode aceitar ou rejeitar seletivamente a mensagem, desde que `FilterPolicyScope` esteja definido como `MessageAttributes` na assinatura. Para obter mais informações sobre a aplicação de atributos a uma mensagem, consulte [Atributos de mensagem do 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"
}
}
}
```
O exemplo a seguir mostra os mesmos atributos incluídos no campo `Message`, também chamado de *carga útil da mensagem* ou *corpo da mensagem*. Qualquer assinatura de tópico que inclui uma `FilterPolicy` pode aceitar ou rejeitar seletivamente a mensagem, desde que `FilterPolicyScope` esteja definido como `MessageBody` na assinatura.
```
{
"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"
}
```
As políticas de filtro a seguir aceitam ou rejeitam mensagens com base em seus nomes e valores de propriedades.
## Uma política que aceita a mensagem de exemplo
As propriedades na política de filtro de assinatura a seguir correspondem aos atributos da mensagem de exemplo. Observe que a mesma política de filtro funciona para um `FilterPolicyScope` definido como `MessageAttributes` ou `MessageBody`. Cada assinante escolhe seu escopo de filtragem de acordo com a composição das mensagens que recebe do tópico.
Se qualquer propriedade única nessa política não corresponder a um atributo da mensagem, a política rejeitará a mensagem.
```
{
"store": ["example_corp"],
"event": [{"anything-but": "order_cancelled"}],
"customer_interests": [
"rugby",
"football",
"baseball"
],
"price_usd": [{"numeric": [">=", 100]}]
}
```
## Uma política que rejeita a mensagem de exemplo
A política de filtro de assinatura a seguir tem várias incompatibilidades entre seus atributos e as propriedades da mensagem de exemplo. Por exemplo, como o nome da propriedade `encrypted` não está presente nos atributos da mensagem, essa propriedade de política faz com que a mensagem seja rejeitada, independentemente do valor atribuído a ela.
Se ocorrer qualquer incompatibilidade, a política rejeitará a mensagem.
```
{
"store": ["example_corp"],
"event": ["order_cancelled"],
"encrypted": [false],
"customer_interests": [
"basketball",
"baseball"
]
}
```
# Restrições da política de filtro no Amazon SNS
Ao configurar políticas de filtro no Amazon SNS, há algumas regras importantes que você deve ter em mente. Essas regras ajudam a garantir a aplicação efetiva das políticas de filtro, ao mesmo tempo mantendo o desempenho e a compatibilidade do sistema.
## Restrições da política de filtro
Ao configurar políticas de filtro no Amazon SNS, siga estas regras importantes para garantir que elas funcionem de forma eficaz, mantendo o desempenho e a compatibilidade do sistema:
+ **Correspondência de string**: para correspondência de strings na política de filtro, a comparação diferencia maiúsculas de minúsculas.
+ **Correspondência numérica**: para a correspondência numérica, o valor pode variar de -109 a 109 (-1 bilhão a 1 bilhão), com cinco dígitos de precisão após o separador decimal.
+ **Complexidade de política de filtro**: a combinação total de valores em uma política de filtro não deve exceder **150**. Para calcular a combinação total, multiplique o número de valores em cada matriz na política de filtro.
+ **Limitar o número de chaves**: uma política de filtro pode ter no máximo **cinco** chaves.
****Considerações adicionais****
+ O JSON da política de filtro pode conter o seguinte:
+ Strings entre aspas
+ Números
+ As palavras-chave `true`, `false` e `null`, sem aspas
+ Ao usar a API do Amazon SNS, é necessário enviar o JSON da política de filtro como uma string **UTF-8** válida.
+ O tamanho máximo de uma política de filtro é de **256 KB**.
+ Por padrão, você pode ter até **200** políticas de filtro por tópico e **10.000** políticas de filtro por AWS conta.
Esse limite de política não impedirá a criação de assinaturas de filas do Amazon SQS com a API [https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html](https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html). No entanto, falhará quando você anexar a política de filtro à chamada de API `Subscribe` (ou na chamada de 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 essa cota, use [AWS Service Quotas](https://docs.aws.amazon.com/servicequotas/latest/userguide/intro.html).
## Restrições de política para filtragem baseada em atributo
A filtragem baseada em atributo é a opção padrão. [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) é definido como `MessageAttributes` na assinatura.
+ O Amazon SNS não aceita uma política de filtro aninhada para filtragem baseada em atributo.
+ O Amazon SNS compara as propriedades de política somente com atributos de mensagens que tenham os seguintes tipos de dados:
+ `String`
+ `String.Array`
**Importante**
Ao usar filtragem baseada em atributos no Amazon SNS, você deve usar o escape duplo de certos caracteres especiais, especificamente:
Aspas duplas (")
Barras invertidas ()
A falha no escape duplo desses caracteres fará com que a política de filtro não corresponda aos atributos de uma mensagem publicada, e a notificação não será entregue.
**Considerações adicionais**
+ Transmitir objetos em matrizes não é recomendado, pois pode gerar resultados inesperados devido ao aninhamento, o que não é compatível com a filtragem baseada em atributos. Usar filtragem baseada em carga para políticas aninhadas.
+ `Number` é compatível com valores de atributos numéricos.
+ O Amazon SNS ignora atributos de mensagens com o tipo de dados binário.
**Exemplo de política para complexidade:**
No exemplo de política a seguir, a primeira chave tem **três** operadores de correspondência, a segunda tem **um** operador de correspondência e a terceira tem **dois** operadores de correspondência.
```
{
"key_a": ["value_one", "value_two", "value_three"],
"key_b": ["value_one"],
"key_c": ["value_one", "value_two"]
}
```
A combinação total é calculada como o produto do número de operadores de correspondência para cada chave na política de filtro:
```
3(match operators of key_a)
x 1(match operators of key_b)
x 2(match operators of key_c)
= 6
```
## Restrições de política para filtragem baseada em carga útil
Para mudar da filtragem baseada em atributo (padrão) para a filtragem baseada em carga útil, defina [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeprovisionIpamPoolCidr.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeprovisionIpamPoolCidr.html) como `MessageBody` na assinatura.
+ O Amazon SNS aceita uma política de filtro aninhada para filtragem baseada em carga útil.
+ Para uma política aninhada, somente **chaves leaf** são contabilizadas no limite de **cinco** chaves.
**Exemplo de política para limite de chaves:**
No exemplo de política a seguir:
+ Existem duas chaves leaf: `key_c` e `key_e`.
+ `key_c` tem **quatro** operadores de correspondência com um nível aninhado de **três**, e `key_e` tem **três** operadores de correspondência com um nível aninhado de **dois**.
```
{
"key_a": {
"key_b": {
"key_c": ["value_one", "value_two", "value_three", "value_four"]
}
},
"key_d": {
"key_e": ["value_one", "value_two", "value_three"]
}
}
```
A combinação total é calculada como o produto do número de operadores de correspondência e do nível aninhado de cada chave na política de filtro:
```
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
```
## Diretrizes de uso do padrão de caracteres curinga
O Amazon SQS implementa proteções para quando você registra uma política de filtro contendo caracteres curinga, a fim de garantir que políticas de filtro muito complexas não sejam criadas, pois isso afetaria o desempenho da sua aplicação.
**Estrutura do padrão**
Os campos contêm um ou mais padrões. O exemplo a seguir mostra um campo usando dois padrões:
```
{
"greeting": [
{"anything-but": {"prefix": "Hello"}},
{"wildcard": "H*"}
] // 2 patterns
}
```
**Regras de complexidade**
+ A complexidade total dos caracteres curinga em todos os campos não deve exceder 100 pontos
+ Máximo de 3 caracteres curinga por padrão
**Cálculo da complexidade**
+ Complexidade do campo = `(Sum of pattern points)` × `(Number of patterns)`
+ Pontos do padrão:
Curinga único: 1 ponto
Vários curingas: 3 pontos cada
Indicador de exceção: 1 ponto
Veja a seguir um exemplo do cálculo da complexidade:
```
{
"filename": [
{"wildcard": "*.txt"}, // 1 point
{"wildcard": "log*"} // 1 point
] // Total: (1 + 1) × 2 = 4 points
}
```
# Lógica E/OU
Use a AND/OR lógica nas políticas de filtro para corresponder aos atributos da mensagem ou às propriedades do corpo da mensagem no Amazon SNS. Isso permite uma filtragem de mensagens mais precisa e flexível.
## Lógica E
Aplique a lógica E usando vários nomes de propriedade.
Considere a seguinte política:
```
{
"customer_interests": ["rugby"],
"price_usd": [{"numeric": [">", 100]}]
}
```
Ela estabelece correspondência com qualquer propriedade de atributo ou corpo de mensagem com o valor de `customer_interests` definido como `rugby` *e* o valor de `price_usd` definido como um número maior que 100.
**nota**
Não é possível aplicar a lógica AND aos valores do mesmo atributo.
## Lógica OU
Aplique a lógica OU atribuindo vários valores a um nome de propriedade.
Considere a seguinte política:
```
{
"customer_interests": ["rugby", "football", "baseball"]
}
```
Ela estabelece correspondência com qualquer propriedade de atributo ou corpo de mensagem com o valor de `customer_interests` definido como `rugby`, `football` *ou* `baseball`.
## Operador OU
Você pode usar o operador `"$or"` para definir explicitamente uma política de filtro para expressar a relação OR entre vários atributos na política.
O Amazon SNS só reconhece uma relação `"$or"` quando a política atende a todas as condições a seguir. Quando todas essas condições não são atendidas, `"$or"` é tratado como um nome de atributo regular, o mesmo que qualquer outra string na política.
+ Há um atributo do campo `"$or"` na regra seguido por uma matriz, por exemplo `“$or” : []`.
+ Há pelo menos dois objetos na matriz `"$or"`: `"$or": [{}, {}]`.
+ Nenhum dos objetos na matriz `"$or"` tem nomes de campo que sejam palavras-chave reservadas.
Caso contrário, `"$or"` é tratado como um nome de atributo normal, o mesmo que outras strings na política.
A política a seguir não é analisada como uma relação OR porque numérico e prefixo são palavras-chave reservadas.
```
{
"$or": [ {"numeric" : 123}, {"prefix": "abc"} ]
}
```
**Exemplos de operador `OR`**
`OR` padrão:
```
{
"source": [ "aws.cloudwatch" ],
"$or": [
{ "metricName": [ "CPUUtilization" ] },
{ "namespace": [ "AWS/EC2" ] }
]
}
```
A lógica do filtro para essa política é:
```
"source" && ("metricName" || "namespace")
```
Ele corresponde a um dos seguintes atributos de mensagens:
```
"source": {"Type": "String", "Value": "aws.cloudwatch"},
"metricName": {"Type": "String", "Value": "CPUUtilization"}
```
or
```
"source": {"Type": "String", "Value": "aws.cloudwatch"},
"namespace": {"Type": "String", "Value": "AWS/EC2"}
```
Também estabelece correspondência com um dos seguintes corpos de mensagem:
```
{
"source": "aws.cloudwatch",
"metricName": "CPUUtilization"
}
```
or
```
{
"source": "aws.cloudwatch",
"namespace": "AWS/EC2"
}
```
### Restrições de políticas que incluem relações `OR`
Considere a seguinte política:
```
{
"source": [ "aws.cloudwatch" ],
"$or": [
{ "metricName": [ "CPUUtilization", "ReadLatency" ] },
{
"metricType": [ "MetricType" ] ,
"$or" : [
{ "metricId": [ 1234, 4321 ] },
{ "spaceId": [ 1000, 2000, 3000 ] }
]
}
]
}
```
A lógica dessa política também pode ser simplificada como:
```
("source" AND "metricName")
OR
("source" AND "metricType" AND "metricId")
OR
("source" AND "metricType" AND "spaceId")
```
O cálculo da complexidade para políticas com relacionamentos OR pode ser simplificado como a soma das complexidades da combinação para cada declaração OR.
A combinação total é calculada da seguinte forma:
```
(source * metricName) + (source * metricType * metricId) + (source * metricType * spaceId)
= (1 * 2) + (1 * 1 * 2) + (1 * 1 * 3)
= 7
```
`source` tem um valor, `metricName` tem dois valores, `metricType` tem um valor, `metricId` tem dois valores e `spaceId` tem três valores.
Considere a seguinte política de filtro aninhada:
```
{
"$or": [
{ "metricName": [ "CPUUtilization", "ReadLatency" ] },
{ "namespace": [ "AWS/EC2", "AWS/ES" ] }
],
"detail" : {
"scope" : [ "Service" ],
"$or": [
{ "source": [ "aws.cloudwatch" ] },
{ "type": [ "CloudWatch Alarm State Change"] }
]
}
}
```
A lógica dessa política pode ser simplificada como:
```
("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")
```
O cálculo das combinações totais é o mesmo para políticas não aninhadas, exceto que precisamos considerar o nível de aninhamento de uma chave.
A combinação total é calculada da seguinte forma:
```
(2 * 2 * 2) + (2 * 2 * 2) + (2 * 2 * 2) + (2 * 2 * 2) = 32
```
`metricName` tem dois valores, `namespace` tem dois valores, `scope` é uma chave aninhada de dois níveis com um valor, `source` é uma chave aninhada de dois níveis com um valor e `type` é uma chave aninhada de dois níveis com um valor.
# Correspondência de chaves
Use o operador `exists` em uma política de filtro para combinar as mensagens recebidas com base na presença ou ausência de uma propriedade específica.
+ `exists` funciona somente nos nós leaf (atributos finais na estrutura).
+ Não se aplica a nós intermediários em uma estrutura JSON aninhada.
+ Use `"exists": true` para estabelecer correspondência com mensagens recebidas que incluam a propriedade especificada. A chave deve ter um valor não nulo e não vazio.
Por exemplo, a propriedade de política seguinte usa o operador `exists` com um valor de `true`:
```
"store": [{"exists": true}]
```
Ela estabelece correspondência com qualquer atributo de mensagem que contenha a chave de atributo `store`, como a seguinte:
```
"store": {"Type": "String", "Value": "fans"}
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
Também estabelece correspondência com um dos seguintes corpos de mensagem:
```
{
"store": "fans"
"customer_interests": ["baseball", "basketball"]
}
```
No entanto, não estabelece correspondência com nenhum atributo de mensagem *sem* a chave de atributo `store`, como o seguinte:
```
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
Nem corresponde ao seguinte corpo de mensagem:
```
{
"customer_interests": ["baseball", "basketball"]
}
```
+ Use `"exists": false` para estabelecer correspondência com mensagens recebidas que *não* incluam a propriedade especificada.
**nota**
`"exists": false` só estabelecerá correspondência se pelo menos um atributo estiver presente. Um conjunto vazio de atributos impossibilita que o filtro estabeleça correspondência.
Por exemplo, a propriedade de política seguinte usa o operador `exists` com um valor de `false`:
```
"store": [{"exists": false}]
```
Ela *não* estabelece correspondência com nenhum atributo de mensagem que contenha a chave de atributo `store`, como o seguinte:
```
"store": {"Type": "String", "Value": "fans"}
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
Também não estabelece correspondência com o seguinte corpo de mensagem:
```
{
"store": "fans"
"customer_interests": ["baseball", "basketball"]
}
```
No entanto, estabelece correspondência com qualquer atributo de mensagem *sem* a chave de atributo `store`, como o seguinte:
```
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
Também estabelece correspondência com o seguinte corpo de mensagem:
```
{
"customer_interests": ["baseball", "basketball"]
}
```
# Correspondência de valores numéricos
Filtre mensagens estabelecendo correspondência entre valores numéricos e valores de propriedades de atributos da mensagem ou valores de propriedade do corpo. Os valores numéricos não são inseridos entre aspas duplas na política JSON. Você pode usar as operações numéricas a seguir para filtragem.
**nota**
Os prefixos são compatíveis somente com correspondência de *string*.
## Correspondência exata
Quando um valor de propriedade de política inclui a palavra-chave `numeric` e o operador `=`, estabelece correspondência com qualquer valor de propriedade de atributo ou corpo de mensagem que tenha o mesmo nome e o mesmo valor numérico.
Considere a seguinte propriedade de política:
```
"price_usd": [{"numeric": ["=",301.5]}]
```
Ele corresponde a um dos seguintes atributos de mensagens:
```
"price_usd": {"Type": "Number", "Value": 301.5}
```
```
"price_usd": {"Type": "Number", "Value": 3.015e2}
```
Também estabelece correspondência com um dos seguintes corpos de mensagem:
```
{
"price_usd": 301.5
}
```
```
{
"price_usd": 3.015e2
}
```
## Correspondência anything-but
Quando o valor de uma propriedade de política inclui a palavra-chave `anything-but`, estabelece correspondência com qualquer valor de propriedade de atributo ou corpo de mensagem que *não* inclua nenhum dos valores de propriedade de política.
Considere a seguinte propriedade de política:
```
"price": [{"anything-but": [100, 500]}]
```
Ele corresponde a um dos seguintes atributos de mensagens:
```
"price": {"Type": "Number", "Value": 101}
```
```
"price": {"Type": "Number", "Value": 100.1}
```
Também estabelece correspondência com um dos seguintes corpos de mensagem:
```
{
"price": 101
}
```
```
{
"price": 100.1
}
```
Além disso, estabelece correspondência com o seguinte atributo de mensagem (pois contém um valor que *não* é `100` nem `500`):
```
"price": {"Type": "Number.Array", "Value": "[100, 50]"}
```
Também estabelece correspondência com o seguinte corpo de mensagem (pois contém um valor que *não* é `100` nem `500`):
```
{
"price": [100, 50]
}
```
No entanto, não corresponde ao seguinte atributo de mensagem:
```
"price": {"Type": "Number", "Value": 100}
```
Nem corresponde ao seguinte corpo de mensagem:
```
{
"price": 100
}
```
## Correspondência de intervalo de valores
Além do operador `=`, uma propriedade de política numérica pode incluir os seguintes operadores: `<`, `<=`, `>` e `>=`.
Considere a seguinte propriedade de política:
```
"price_usd": [{"numeric": ["<", 0]}]
```
Estabelece correspondência com qualquer propriedade de atributo ou corpo de mensagem com valores numéricos negativos.
Considere outro atributo de mensagem:
```
"price_usd": [{"numeric": [">", 0, "<=", 150]}]
```
Estabelece correspondência com qualquer propriedade de atributo ou corpo de mensagem com números positivos até e incluindo 150.
# Correspondência de valores de string
Filtre mensagens correspondendo valores de string a valores de atributos da mensagem ou a valores de propriedades do corpo da mensagem. Os valores de string são inseridos entre aspas duplas na política JSON. Você pode usar as operações de string a seguir para corresponder a atributos da mensagem ou às propriedades do corpo da mensagem:
## Correspondência exata
A correspondência exata ocorre quando um valor de propriedade de política corresponde a um ou mais valores de atributos de mensagens. Para atributos do tipo `String.Array`, cada elemento na matriz é tratado como uma string separada para fins de correspondência.
Considere a seguinte propriedade de política:
```
"customer_interests": ["rugby", "tennis"]
```
Ele corresponde aos seguintes atributos de mensagem:
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
```
"customer_interests": {"Type": "String", "Value": "tennis"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\", \"tennis\"]"}
```
Também corresponde aos seguintes corpos de mensagem:
```
{
"customer_interests": "rugby"
}
```
```
{
"customer_interests": "tennis"
}
```
No entanto, não corresponde ao seguinte atributo de mensagem:
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\"]"}
```
Nem corresponde ao seguinte corpo de mensagem:
```
{
"customer_interests": "baseball"
}
```
## Correspondência anything-but
Quando o valor de uma propriedade de política inclui a palavra-chave `anything-but`, corresponde a qualquer valor de atributo ou corpo de mensagem que *não* inclua nenhum dos valores de propriedade de política. `anything-but` pode ser combinado com `"exists": false`. Para atributos do tipo `String.Array`, corresponde se nenhum dos elementos da matriz estiver listado na propriedade da política.
Considere a seguinte propriedade de política:
```
"customer_interests": [{"anything-but": ["rugby", "tennis"]}]
```
Há correspondência com os seguintes atributos de mensagem:
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String", "Value": "football"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\", \"baseball\"]"}
```
Também estabelece correspondência com um dos seguintes corpos de mensagem:
```
{
"customer_interests": "baseball"
}
```
```
{
"customer_interests": "football"
}
```
Além disso, estabelece correspondência com o seguinte atributo de mensagem (pois contém um valor que *não* é `rugby` nem `tennis`):
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\", \"baseball\"]"}
```
Também estabelece correspondência com o seguinte corpo de mensagem (pois contém um valor que não é `rugby` nem `tennis`):
```
{
"customer_interests": ["rugby", "baseball"]
}
```
No entanto, não corresponde ao seguinte atributo de mensagem:
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\"]"}
```
Nem corresponde ao seguinte corpo de mensagem:
```
{
"customer_interests": ["rugby"]
}
```
**Usando um prefixo com `anything-but`**
Para correspondência de string, também é possível usar um prefixo com o operador `anything-but`. Por exemplo, a política de propriedade seguinte nega o prefixo `order-`:
```
"event":[{"anything-but": {"prefix": "order-"}}]
```
Ele corresponde a um dos seguintes atributos:
```
"event": {"Type": "String", "Value": "data-entry"}
```
```
"event": {"Type": "String", "Value": "order_number"}
```
Também estabelece correspondência com um dos seguintes corpos de mensagem:
```
{
"event": "data-entry"
}
```
```
{
"event": "order_number"
}
```
No entanto, não corresponde ao seguinte atributo de mensagem:
```
"event": {"Type": "String", "Value": "order-cancelled"}
```
Nem corresponde ao seguinte corpo de mensagem:
```
{
"event": "order-cancelled"
}
```
**curinga indicador de exceção**
A seguinte propriedade de política nega o caractere curinga `*ball`:
```
"customer_interests" : [{ "anything-but": { "wildcard": "*ball" }}]
```
Ele corresponde aos seguintes atributos:
```
{"customer_interests": ["hockey", "rugby", "soccer] }
```
No entanto, não corresponde ao seguinte atributo de mensagem:
```
{"customer_interests": ["baseball", "basketball"] }
```
**sufixo indicador de exceção**
A propriedade de política a seguir nega o sufixo `-ball`
:
```
"customer_interests": [ { "anything-but": { "suffix": "ball" } } ]
```
Ele corresponde aos seguintes atributos:
```
{"customer_interests": ["hockey", "rugby", "soccer] }
```
No entanto, não corresponde ao seguinte atributo de mensagem:
```
{"customer_interests": ["baseball", "basketball"] }
```
## Equals-ignore-case combinando
Quando a propriedade de uma política inclui a palavra-chave `equals-ignore-case`, ela realizará uma correspondência que não diferencia letras maiúsculas de minúsculas a qualquer valor de propriedade do corpo ou atributo da mensagem.
Considere a seguinte propriedade de política:
```
"customer_interests": [{"equals-ignore-case": "tennis"}]
```
Ele corresponde a um dos seguintes atributos de mensagens:
```
"customer_interests": {"Type": "String", "Value": "TENNIS"}
```
```
"customer_interests": {"Type": "String", "Value": "Tennis"}
```
Também estabelece correspondência com um dos seguintes corpos de mensagem:
```
{
"customer_interests": "TENNIS"
}
```
```
{
"customer_interests": "teNnis"
{
```
## Correspondência de endereço IP
Você pode usar o operador `cidr` para verificar se uma mensagem de entrada é originada de um endereço IP ou sub-rede específico.
Considere a seguinte propriedade de política:
```
"source_ip":[{"cidr": "10.0.0.0/24"}]
```
Ele corresponde a um dos seguintes atributos de mensagens:
```
"source_ip": {"Type": "String", "Value": "10.0.0.0"}
```
```
"source_ip": {"Type": "String", "Value": "10.0.0.255"}
```
Também estabelece correspondência com um dos seguintes corpos de mensagem:
```
{
"source_ip": "10.0.0.0"
}
```
```
{
"source_ip": "10.0.0.255"
}
```
No entanto, não corresponde ao seguinte atributo de mensagem:
```
"source_ip": {"Type": "String", "Value": "10.1.1.0"}
```
Nem corresponde ao seguinte corpo de mensagem:
```
{
"source_ip": "10.1.1.0"
}
```
## Correspondência de prefixo
Quando uma propriedade de política inclui a palavra-chave `prefix`, ela corresponde a qualquer valor de atributo de mensagem ou corpo de mensagem que comece com os caracteres especificados.
Considere a seguinte propriedade de política:
```
"customer_interests": [{"prefix": "bas"}]
```
Ele corresponde a um dos seguintes atributos de mensagens:
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String", "Value": "basketball"}
```
Também estabelece correspondência com um dos seguintes corpos de mensagem:
```
{
"customer_interests": "baseball"
}
```
```
{
"customer_interests": "basketball"
}
```
No entanto, não corresponde ao seguinte atributo de mensagem:
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
Nem corresponde ao seguinte corpo de mensagem:
```
{
"customer_interests": "rugby"
}
```
## Correspondência de sufixo
Quando a propriedade de uma política inclui a palavra-chave `suffix`, ela corresponde a qualquer valor de propriedade do corpo ou atributo da mensagem que termine com os caracteres especificados.
Considere a seguinte propriedade de política:
```
"customer_interests": [{"suffix": "ball"}]
```
Ele corresponde a um dos seguintes atributos de mensagens:
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String", "Value": "basketball"}
```
Também estabelece correspondência com um dos seguintes corpos de mensagem:
```
{
"customer_interests": "baseball"
}
```
```
{
"customer_interests": "basketball"
}
```
No entanto, não corresponde ao seguinte atributo de mensagem:
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
Nem corresponde ao seguinte corpo de mensagem:
```
{
"customer_interests": "rugby"
}
```
## Curinga
É possível usar o caractere curinga (\$1) para encontrar o valor correspondente a valores de string em padrões de eventos.
A política a seguir usa o caractere curinga (\$1):
```
"customer_interests": [ { "wildcard": "*ball" } ]
```
Ele corresponde aos seguintes atributos:
```
{"customer_interests": ["baseball", "basketball"] }
```
# Aplicar uma política de filtro de assinatura no Amazon SNS
A filtragem de mensagens no Amazon SNS permite que você entregue mensagens seletivamente aos assinantes com base nas políticas de filtro. Essas políticas definem as condições que as mensagens devem atender para serem entregues a uma assinatura. Embora a entrega de mensagens brutas seja uma opção que possa afetar o processamento de mensagens, ela não é necessária para que os filtros de assinatura funcionem.
É possível aplicar uma política de filtro a uma assinatura do Amazon SNS usando o console do Amazon SNS. Ou, para aplicar políticas de forma programática, você pode usar a API do Amazon SNS, AWS Command Line Interface o AWS CLI() ou AWS qualquer SDK compatível com o Amazon SNS. Você também pode usar AWS CloudFormation.
**Habilitação da entrega de mensagens brutas**
A entrega de mensagens brutas garante que as cargas úteis de mensagens sejam entregues como estão aos assinantes, sem qualquer codificação ou transformação adicional. Isso pode ser útil quando os assinantes precisam do formato original da mensagem para processamento. No entanto, a entrega de mensagens brutas não está diretamente relacionada à funcionalidade dos filtros de assinatura.
**Aplicação de filtros de assinatura**
Para aplicar filtros de mensagens a uma assinatura, você define uma política de filtro usando a sintaxe JSON. Essa política especifica as condições que uma mensagem deve atender para ser entregue à assinatura. Os filtros podem ser baseados em atributos da mensagem, como atributos da mensagem, estrutura da mensagem ou até mesmo conteúdo da mensagem.
**Relação entre entrega de mensagens brutas e filtros de assinatura**
Embora a ativação da entrega de mensagens brutas possa afetar a forma como as mensagens são entregues e processadas pelos assinantes, não é um pré-requisito para o uso de filtros de assinatura. No entanto, em cenários em que os assinantes exigem o formato original da mensagem sem nenhuma modificação, habilitar a entrega de mensagens brutas pode ser benéfico junto com os filtros de assinatura.
**Considerações para uma filtragem eficaz**
Ao implementar a filtragem de mensagens, considere os requisitos específicos do seu aplicativo e dos assinantes. Defina políticas de filtro que correspondam com precisão aos critérios de entrega de mensagens para garantir uma distribuição eficiente e direcionada de mensagens.
**Importante**
AWS serviços como IAM e Amazon SNS usam um modelo de computação distribuída chamado consistência eventual. As adições ou alterações a uma política de filtro de assinatura podem levar até 15 minutos para entrarem em vigor.
## Console de gerenciamento da AWS
1. Faça login no [console do Amazon SNS](https://console.aws.amazon.com/sns/home).
1. No painel de navegação, escolha **Subscriptions (Assinaturas)**.
1. Selecione uma assinatura e, em seguida, escolha **Edit (Editar)**.
1. Na página **Editar** expanda a seção **Política de filtros de assinatura**.
1. Escolha entre **filtragem baseada em atributo** ou **filtragem baseada em carga útil**.
1. No campo **Editor JSON**, informe o **Corpo do JSON** de sua política de filtro.
1. Escolha **Save changes (Salvar alterações)**.
O Amazon SNS aplica a política de filtro à assinatura.
## AWS CLI
Para aplicar uma política de filtro com o AWS Command Line Interface (AWS CLI), use o [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, conforme mostrado no exemplo a seguir. Para a opção `--attribute-name`, especifique `FilterPolicy`. Em `--attribute-value`, especifique sua **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 fornecer JSON válido para sua política, coloque os nomes e valores dos atributos entre aspas duplas. Também é necessário colocar o argumento completo da política entre aspas. Para evitar aspas de escape, você pode usar aspas simples para colocar a política e aspas duplas para os nomes e valores de JSON, como mostrado no exemplo.
Se você quiser alternar da filtragem de mensagens baseada em atributos (padrão) para a baseada em carga, você também pode usar o comando. [set-subscription-attributes](https://docs.aws.amazon.com/cli/latest/reference/sns/set-subscription-attributes.html) Para a opção `--attribute-name`, especifique `FilterPolicyScope`. Em `--attribute-value`, especifique `MessageBody`.
```
$ aws sns set-subscription-attributes --subscription-arn arn:aws:sns: ... --attribute-name FilterPolicyScope --attribute-value MessageBody
```
Para verificar se a política de filtro foi aplicada, use o comando `get-subscription-attributes`. Os atributos na saída do terminal devem mostrar a política de filtro para a chave `FilterPolicy`, conforme mostrado no exemplo a seguir:
```
$ 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
Os exemplos de código a seguir mostram como usar o `SetSubscriptionAttributes`.
**Importante**
Se você estiver usando o exemplo do SDK para Java 2.x, a classe `SNSMessageFilterPolicy` não estará disponível por padrão. Para obter instruções sobre como instalar essa classe, consulte o [exemplo](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/sns/src/main/java/com/example/sns/SNSMessageFilterPolicy.java) do GitHub site.
------
#### [ CLI ]
**AWS CLI**
**Para definir atributos de assinatura**
O exemplo `set-subscription-attributes` a seguir define o atributo `RawMessageDelivery` para uma assinatura do 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 não produz saída.
O exemplo `set-subscription-attributes` a seguir define um atributo `FilterPolicy` para uma assinatura do 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 não produz saída.
O exemplo `set-subscription-attributes` a seguir remove o atributo `FilterPolicy` de uma assinatura do 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 não produz saída.
+ Para obter detalhes da API, consulte [SetSubscriptionAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/set-subscription-attributes.html)na *Referência de AWS CLI Comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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 obter detalhes da API, consulte [SetSubscriptionAttributes](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/SetSubscriptionAttributes)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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 obter detalhes da API, consulte a [SetSubscriptionAttributes](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/SetSubscriptionAttributes)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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 obter detalhes da API, consulte a [SetSubscriptionAttributes](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
## API do Amazon SNS
Para aplicar um política de filtro com a API do Amazon SNS, faça uma solicitação para a ação [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html). Defina o parâmetro `AttributeName` como `FilterPolicy` e defina o parâmetro `AttributeValue` para a política de filtro JSON.
Se você quiser mudar da filtragem baseada em atributos (padrão) para a filtragem baseada em carga útil, também poderá usar a ação [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html). Defina o parâmetro `AttributeName` como `FilterPolicyScope` e defina o parâmetro `AttributeValue` como `MessageBody`.
## AWS CloudFormation
Para aplicar uma política de filtro usando CloudFormation, use um modelo JSON ou YAML para criar uma CloudFormation pilha. Para obter mais informações, consulte a [`FilterPolicy`propriedade](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sns-subscription.html#cfn-sns-subscription-filterpolicy) do `AWS::SNS::Subscription` recurso no *Guia do AWS CloudFormation usuário* e no [CloudFormation modelo de exemplo](https://github.com/aws-samples/aws-sns-samples/blob/master/templates/SNS-Subscription-Attributes-Tutorial-CloudFormation.template).
1. Faça login no [console do CloudFormation](https://console.aws.amazon.com/cloudformation).
1. Escolha **Create Stack (Criar pilha)**.
1. Na página **Select Template (Selecionar modelo)**, escolha **Upload a template to Amazon S3 (Carregar um modelo no Amazon S3)** e, em seguida, o arquivo e **Next (Avançar)**.
1. Na página **Especificar detalhes**, faça o seguinte:
1. Em **Nome da pilha**, digite `MyFilterPolicyStack`.
1. Para **myHttpEndpoint**, digite o endpoint HTTP a ser inscrito em seu tópico.
**dica**
Se você não tiver um endpoint HTTP, crie um.
1. Na página **Options (Opções)**, escolha **Next (Avançar)**.
1. Na página **Review (Revisar)**, escolha **Create (Criar)**.
# Remover uma política de filtro de assinatura no Amazon SNS
Para interromper a filtragem de mensagens que são enviadas para uma assinatura, remova a política de filtro da assinatura substituindo-a por um corpo JSON vazio. Após a remoção da política, a assinatura aceitará todas as mensagens que forem publicadas nela.
## Usando o Console de gerenciamento da AWS
1. Faça login no [console do Amazon SNS](https://console.aws.amazon.com/sns/home).
1. No painel de navegação, escolha **Subscriptions (Assinaturas)**.
1. Selecione uma assinatura e, em seguida, escolha **Edit (Editar)**.
1. Na *EXAMPLE1-23bc-4567-d890-ef12g3hij456* página **Editar**, expanda a seção **Política de filtro de assinatura**.
1. No campo **Editor JSON**, forneça um corpo do JSON vazio para seu filtro de política: `{}`.
1. Escolha **Salvar alterações**.
O Amazon SNS aplica a política de filtro à assinatura.
## Usando o AWS CLI
Para remover uma política de filtro com o AWS CLI, use o [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 e forneça um corpo JSON vazio para o `--attribute-value` argumento:
```
$ aws sns set-subscription-attributes --subscription-arn arn:aws:sns: ... --attribute-name FilterPolicy --attribute-value "{}"
```
## Uso da API do Amazon SNS
Para remover uma política de filtro com a API do Amazon SNS, faça uma solicitação para a ação [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html). Defina o parâmetro `AttributeName` como `FilterPolicy` e forneça um corpo JSON vazio para o parâmetro `AttributeValue`.