Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Filtrage des messages Amazon SNS
Par défaut, un abonné d'une rubrique Amazon SNS reçoit chaque message publié dans la rubrique. Pour recevoir uniquement un sous-ensemble des messages, un abonné doit attribuer une *politique de filtre* à l'abonnement à la rubrique.
Une politique de filtre est un objet JSON qui contient des propriétés qui définissent les messages reçus par l'abonné. Amazon SNS prend en charge les politiques qui agissent sur les attributs du message ou sur le corps de message, en fonction de l'étendue de la politique de filtre que vous avez définie pour l'abonnement. Les politiques de filtre pour le corps de message supposent que la charge utile du message est un objet JSON bien formé.
Si un abonnement ne comporte pas de politique de filtre, l'abonné reçoit chaque message publié dans sa rubrique. Lorsque vous publiez un message dans une rubrique ayant une politique de filtre en place, Amazon SNS compare les attributs du message aux attributs de la politique de filtre pour chacun des abonnements de la rubrique. Si tous les attributs ou propriétés du corps du message répondent aux conditions spécifiées dans la politique de filtrage, Amazon SNS envoie le message à l'abonné. Sinon, Amazon SNS n'envoie pas le message à cet abonné.
Pour plus d'informations, consultez [Filtrer les messages publiés dans les rubriques](https://aws.amazon.com/getting-started/tutorials/filter-messages-published-to-topics/).
# Étendue de la politique de filtre d'abonnement Amazon SNS
L'attribut `FilterPolicyScope` subscription vous permet de définir l'étendue du filtrage en définissant l'une des valeurs suivantes :
+ `MessageAttributes`— Applique la politique de filtrage aux attributs des messages (paramètre par défaut).
+ `MessageBody`— Applique la politique de filtrage au corps du message.
**Note**
Si aucune étendue de politique de filtre n'est définie pour une politique de filtre existante, l'étendue par défaut est `MessageAttributes`.
# Stratégies de filtre d'abonnement Amazon SNS
Une politique de filtre d'abonnement vous permet de spécifier des noms de propriété et d'attribuer une liste de valeurs à chaque nom de propriété. Pour de plus amples informations, veuillez consulter [Filtrage des messages Amazon SNS](sns-message-filtering.md).
Quand Amazon SNS analyse les attributs du message ou les propriétés du corps de message par rapport à la politique de filtre d'abonnement, il ignore ceux qui ne sont pas spécifiés dans la politique.
**Important**
AWS des services tels que IAM et Amazon SNS utilisent un modèle informatique distribué appelé cohérence éventuelle. Les ajouts ou modifications de politique de filtrage d'abonnement nécessitent jusqu'à 15 minutes pour prendre effet.
Un abonnement accepte un message dans les conditions suivantes :
+ Lorsque l'étendue de la politique de filtre est définie sur `MessageAttributes`, chaque nom de propriété de la politique de filtre correspond à un nom d'attribut de message. Pour chaque nom de propriété correspondant dans la politique de filtre, au moins une valeur de propriété correspond à la valeur de l'attribut du message.
+ Lorsque l'étendue de la politique de filtre est définie sur `MessageBody`, chaque nom de propriété de la politique de filtre correspond à un nom de propriété de corps de message. Pour chaque nom de propriété correspondant dans la politique de filtre, au moins une valeur de propriété correspond à la valeur de propriété de corps de message.
Amazon SNS prend en charge les opérateurs de filtre suivants :
+ [Logique AND](and-or-logic.md#and-logic)
+ [Logique OR](and-or-logic.md#or-logic)
+ [Opérateur OR](and-or-logic.md#or-operator)
+ [Correspondance de clé](attribute-key-matching.md)
+ [Correspondance exacte des valeurs numériques](numeric-value-matching.md#numeric-exact-matching)
+ [Valeur numérique avec correspondance « anything-but »](numeric-value-matching.md#numeric-anything-but-matching)
+ [Correspondance de plage de valeur numérique](numeric-value-matching.md#numeric-value-range-matching)
+ [Correspondance exacte de valeur de chaîne](string-value-matching.md#string-exact-matching)
+ [Valeur de chaîne avec correspondance « anything-but »](string-value-matching.md#string-anything-but-matching)
+ [Correspondance de chaînes utilisant un préfixe avec l'opérateur « anything-but »](string-value-matching.md#string-anything-but-matching)
+ [Equals-ignore case pour la valeur de chaîne](string-value-matching.md#string-equals-ignore)
+ [Correspondance des adresses IP pour la valeur de chaîne](string-value-matching.md#string-address-matching)
+ [Correspondance de préfixe pour la valeur de chaîne](string-value-matching.md#string-prefix-matching)
+ [Correspondance de suffixe pour la valeur de chaîne](string-value-matching.md#string-suffix-matching)
# Exemples de politiques de filtrage Amazon SNS
L'exemple suivant montre une charge utile de message diffusée par une rubrique Amazon SNS qui traite des transactions clients.
Le premier exemple comprend le champ `MessageAttributes` avec des attributs qui décrivent la transaction :
+ Intérêts du client
+ Nom du magasin
+ État de l'événement
+ Prix d'achat en USD
Étant donné que ce message comprend le champ `MessageAttributes`, tout abonnement à une rubrique qui définit un `FilterPolicy` peut accepter ou rejeter le message de façon sélective, à condition que `FilterPolicyScope` soit défini sur `MessageAttributes` dans l'abonnement. Pour plus d'informations sur l'application d'attributs à un message, consultez [Attributs de message 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"
}
}
}
```
L'exemple suivant montre les mêmes attributs inclus dans le champ `Message`, également appelés *charge utile du message* ou *corps de message*. Tout abonnement à une rubrique qui définit un `FilterPolicy` peut accepter ou rejeter le message de façon sélective, à condition que `FilterPolicyScope` soit défini sur `MessageBody` dans l'abonnement.
```
{
"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"
}
```
Les politiques de filtre suivantes acceptent ou rejettent les messages en fonction de leurs noms et valeurs d'attribut.
## Une politique qui accepte l'exemple de message
Les propriétés de la politique de filtre d'abonnement suivante correspondent aux attributs affectés à l'exemple de message. Notez que la même politique de filtre fonctionne pour un `FilterPolicyScope` qu'elle soit définie sur `MessageAttributes` ou `MessageBody`. Chaque abonné choisit son étendue de filtre en fonction de la composition des messages qu'il reçoit de la rubrique.
Si une seule propriété de cette politique ne correspond pas à un attribut affecté au message, la politique rejette le message.
```
{
"store": ["example_corp"],
"event": [{"anything-but": "order_cancelled"}],
"customer_interests": [
"rugby",
"football",
"baseball"
],
"price_usd": [{"numeric": [">=", 100]}]
}
```
## Une politique qui rejette l'exemple de message
La politique de filtre d'abonnement suivante comporte plusieurs différences entre ses propriétés et les attributs affectés à l'exemple de message. Par exemple, comme le nom de propriété `encrypted` n'est pas présent dans les attributs du message, cette propriété de la politique entraîne le rejet du message, quelle que soit la valeur qui lui est affectée.
En cas de non-correspondance, la politique rejette le message.
```
{
"store": ["example_corp"],
"event": ["order_cancelled"],
"encrypted": [false],
"customer_interests": [
"basketball",
"baseball"
]
}
```
# Contraintes liées à la politique de filtrage dans Amazon SNS
Lorsque vous configurez des politiques de filtrage dans Amazon SNS, vous devez tenir compte de quelques règles importantes. Ces règles permettent de garantir l'application efficace des politiques de filtrage tout en préservant les performances et la compatibilité du système.
## Contraintes de politique de filtre
Lorsque vous configurez des politiques de filtrage dans Amazon SNS, suivez ces règles importantes pour vous assurer qu'elles fonctionnent efficacement tout en préservant les performances et la compatibilité du système :
+ **Correspondance de chaînes** : pour la correspondance de chaînes dans la politique de filtrage, la comparaison fait la distinction majuscules/majuscules.
+ **Correspondance numérique** — Pour la correspondance numérique, la valeur peut être comprise entre -10 9 et 10 9 (-1 milliard à 1 milliard), avec une précision de cinq chiffres après la virgule décimale.
+ **Complexité de la politique de filtrage** — La combinaison totale de valeurs d'une politique de filtrage ne doit pas dépasser **150**. Pour calculer la combinaison totale, multipliez le nombre de valeurs de chaque tableau dans la politique de filtrage.
+ **Limiter le nombre de clés** : une politique de filtrage peut comporter un maximum de **cinq** clés.
****Considérations supplémentaires****
+ Le JSON de la politique de filtre peut contenir ce qui suit :
+ Chaînes entre guillemets
+ Nombres
+ Mots-clés `true`, `false` et `null`, sans guillemets
+ Lorsque vous utilisez l'API Amazon SNS, vous devez transmettre le JSON de la politique de filtrage sous forme de chaîne **UTF-8** valide.
+ La taille maximale d'une politique de filtrage est de **256 Ko**.
+ Par défaut, vous pouvez avoir jusqu'à **200** politiques de filtrage par sujet et **10 000** politiques de filtrage par AWS compte.
Cette limite de politique n'empêchera pas la création d'abonnements aux files d'attente Amazon SQS avec l'[https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html](https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html)API. Toutefois, elle échouera lorsque vous attachez la politique de filtre à l'appel d'API `Subscribe` (ou à l'appel d'API [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html)).
Pour demander l'augmentation de ce quota, vous pouvez utiliser [AWS Service Quotas](https://docs.aws.amazon.com/servicequotas/latest/userguide/intro.html).
## Contraintes de politique pour le filtrage basé sur les attributs
Le filtrage basé sur les attributs est l'option par défaut. [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 défini sur `MessageAttributes` dans l'abonnement.
+ Amazon SNS n'accepte pas de politique de filtre imbriquée pour le filtrage basé sur les attributs.
+ Amazon SNS compare les propriétés de politique uniquement aux attributs de message ayant les types de données suivants :
+ `String`
+ `String.Array`
**Important**
Lorsque vous utilisez le filtrage basé sur les attributs dans Amazon SNS, vous devez supprimer deux fois certains caractères spéciaux, notamment :
Guillemets doubles («)
Barres obliques inversées ()
Si ces caractères ne sont pas supprimés deux fois, la politique de filtrage ne correspondra pas aux attributs d'un message publié et la notification ne sera pas envoyée.
**Considérations supplémentaires**
+ Il n'est pas recommandé de transmettre des objets dans des tableaux car cela peut produire des résultats inattendus en raison de l'imbrication, qui n'est pas prise en charge par le filtrage basé sur les attributs. Utilisez le filtrage basé sur la charge utile pour les politiques imbriquées.
+ `Number`est pris en charge pour les valeurs d'attributs numériques.
+ Amazon SNS ignore les attributs des messages dont le type de données est binaire.
**Exemple de politique en matière de complexité :**
Dans l'exemple de politique suivant, la première clé possède **trois** opérateurs de correspondance, la seconde **un** opérateur de correspondance et la troisième **deux** opérateurs de correspondance.
```
{
"key_a": ["value_one", "value_two", "value_three"],
"key_b": ["value_one"],
"key_c": ["value_one", "value_two"]
}
```
La combinaison totale est calculée comme le produit du nombre d'opérateurs de correspondance pour chaque clé de la politique de filtrage :
```
3(match operators of key_a)
x 1(match operators of key_b)
x 2(match operators of key_c)
= 6
```
## Contraintes de politique pour le filtrage basé sur la charge utile
Pour passer du filtrage basé sur les attributs (par défaut) au filtrage basé sur la charge utile, vous devez définir l'étendue [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeprovisionIpamPoolCidr.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeprovisionIpamPoolCidr.html) sur `MessageBody` dans l'abonnement.
+ Amazon SNS accepte une politique de filtre imbriquée pour le filtrage basé sur la charge utile.
+ Pour une politique imbriquée, seules les **clés en forme de feuille** sont prises en compte dans le calcul de la limite des **cinq** clés.
**Exemple de politique en matière de limite de clés :**
Dans l'exemple de stratégie suivant :
+ Il existe deux clés en forme de feuille : `key_c` et`key_e`.
+ `key_c`**possède **quatre** opérateurs de correspondance avec un niveau imbriqué de **trois**, et `key_e` possède **trois** opérateurs de correspondance avec un niveau imbriqué de deux.**
```
{
"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 combinaison totale est calculée comme le produit du nombre d'opérateurs de correspondance et du niveau imbriqué pour chaque clé de la politique de filtrage :
```
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
```
## Consignes d'utilisation des modèles Wildcard
Amazon SQS met en œuvre des protections lorsque vous enregistrez une politique de filtre contenant des caractères génériques afin de garantir que des politiques de filtrage trop complexes ne soient pas créées, car cela aurait un impact sur les performances de votre application.
**Structure du motif**
Les champs contiennent un ou plusieurs modèles. L'exemple suivant montre un champ utilisant deux modèles :
```
{
"greeting": [
{"anything-but": {"prefix": "Hello"}},
{"wildcard": "H*"}
] // 2 patterns
}
```
**Règles de complexité**
+ La complexité totale des caractères génériques dans tous les champs ne doit pas dépasser 100 points
+ Maximum de 3 jokers par motif
**Calcul de la complexité**
+ Complexité du champ = `(Sum of pattern points)` × `(Number of patterns)`
+ Points du motif :
Un joker unique : 1 point
Plusieurs jokers : 3 points chacun
Tout sauf : 1 point
Voici un exemple de calcul de la complexité :
```
{
"filename": [
{"wildcard": "*.txt"}, // 1 point
{"wildcard": "log*"} // 1 point
] // Total: (1 + 1) × 2 = 4 points
}
```
# Logique AND/OR
Utilisez AND/OR la logique des politiques de filtrage pour faire correspondre les attributs des messages ou les propriétés du corps du message dans Amazon SNS. Cela permet un filtrage des messages plus précis et plus flexible.
## Logique AND
Vous pouvez appliquer une logique AND en utilisant plusieurs noms de propriété.
Examinons la politique suivante :
```
{
"customer_interests": ["rugby"],
"price_usd": [{"numeric": [">", 100]}]
}
```
Elle correspond à tous les attributs de message ou propriétés de corps de message ayant la valeur `customer_interests` définie sur `rugby` *et* la valeur `price_usd` définie sur un nombre supérieur à 100.
**Note**
Vous ne pouvez pas appliquer la logique AND à des valeurs d'un même attribut.
## Logique OR
Vous pouvez appliquer une logique OR en affectant plusieurs valeurs à un nom de propriété.
Examinons la politique suivante :
```
{
"customer_interests": ["rugby", "football", "baseball"]
}
```
Elle correspond à tous les attributs de message ou propriétés de corps de message ayant la valeur `customer_interests` définie sur `rugby`, `football` *ou* `baseball`.
## Opérateur OR
Vous pouvez utiliser l'opérateur `"$or"` pour définir explicitement une politique de filtrage afin d'exprimer la relation OR entre plusieurs attributs de la politique.
Amazon SNS ne reconnaît une relation `"$or"` que lorsque la politique répond à toutes les conditions suivantes. Lorsque toutes ces conditions ne sont pas remplies, `"$or"` est traité comme un nom d'attribut normal, comme toute autre chaîne de la politique.
+ Il existe un attribut de champ `"$or"` dans la règle suivi d'un tableau, par exemple, `“$or” : []`.
+ Il existe au moins 2 objets dans le tableau `"$or"` : `"$or": [{}, {}]`.
+ Aucun des objets du tableau `"$or"` ne possède de nom de champ correspondant à des mots clés réservés.
Sinon, `"$or"` est traité comme un nom d'attribut normal, comme les autres chaînes de la politique.
La politique suivante n'est pas analysée comme une relation OR, car le numérique et le préfixe sont des mots-clés réservés.
```
{
"$or": [ {"numeric" : 123}, {"prefix": "abc"} ]
}
```
**Exemples d'opérateurs `OR`**
`OR` standard :
```
{
"source": [ "aws.cloudwatch" ],
"$or": [
{ "metricName": [ "CPUUtilization" ] },
{ "namespace": [ "AWS/EC2" ] }
]
}
```
La logique de filtrage pour cette politique est la suivante :
```
"source" && ("metricName" || "namespace")
```
Elle met en correspondance l'un ou l'autre des attributs de message suivants :
```
"source": {"Type": "String", "Value": "aws.cloudwatch"},
"metricName": {"Type": "String", "Value": "CPUUtilization"}
```
or
```
"source": {"Type": "String", "Value": "aws.cloudwatch"},
"namespace": {"Type": "String", "Value": "AWS/EC2"}
```
Elle correspond également à l'un des corps de message suivants :
```
{
"source": "aws.cloudwatch",
"metricName": "CPUUtilization"
}
```
or
```
{
"source": "aws.cloudwatch",
"namespace": "AWS/EC2"
}
```
### Contraintes politiques qui incluent les relations `OR`
Examinons la politique suivante :
```
{
"source": [ "aws.cloudwatch" ],
"$or": [
{ "metricName": [ "CPUUtilization", "ReadLatency" ] },
{
"metricType": [ "MetricType" ] ,
"$or" : [
{ "metricId": [ 1234, 4321 ] },
{ "spaceId": [ 1000, 2000, 3000 ] }
]
}
]
}
```
La logique de cette politique peut également être simplifiée comme suit :
```
("source" AND "metricName")
OR
("source" AND "metricType" AND "metricId")
OR
("source" AND "metricType" AND "spaceId")
```
Le calcul de la complexité des politiques comportant des relations OR peut être simplifié en additionnant les complexités des combinaisons pour chaque instruction OR.
La combinaison totale est calculée comme suit :
```
(source * metricName) + (source * metricType * metricId) + (source * metricType * spaceId)
= (1 * 2) + (1 * 1 * 2) + (1 * 1 * 3)
= 7
```
`source` possède une valeur, `metricName` deux valeurs, `metricType` une valeur, `metricId` deux valeurs et `spaceId` trois valeurs.
Examinons la politique de filtre imbriqué suivante :
```
{
"$or": [
{ "metricName": [ "CPUUtilization", "ReadLatency" ] },
{ "namespace": [ "AWS/EC2", "AWS/ES" ] }
],
"detail" : {
"scope" : [ "Service" ],
"$or": [
{ "source": [ "aws.cloudwatch" ] },
{ "type": [ "CloudWatch Alarm State Change"] }
]
}
}
```
La logique de cette politique peut être simplifiée comme suit :
```
("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")
```
Le calcul du total des combinaisons est le même pour les politiques non imbriquées, mais nous devons prendre en compte le niveau d'imbrication d'une clé.
La combinaison totale est calculée comme suit :
```
(2 * 2 * 2) + (2 * 2 * 2) + (2 * 2 * 2) + (2 * 2 * 2) = 32
```
`metricName` possède deux valeurs, `namespace` en possède deux, `scope` est une clé imbriquée à deux niveaux avec une valeur, `source` est une clé imbriquée à deux niveaux avec une valeur et `type` est une clé imbriquée à deux niveaux avec une valeur.
# Correspondance de clé
Utilisez l'`exists`opérateur dans une politique de filtrage pour faire correspondre les messages entrants en fonction de la présence ou de l'absence d'une propriété spécifique.
+ `exists`fonctionne uniquement sur les nœuds foliaires (attributs finaux de la structure).
+ Elle ne s'applique pas aux nœuds intermédiaires au sein d'une structure JSON imbriquée.
+ Utilisez `"exists": true` pour faire correspondre les messages entrants qui incluent la propriété spécifiée. La clé doit avoir une valeur non nulle et non vide.
Par exemple, la propriété de politique suivante utilise l'opérateur `exists` avec une valeur de `true` :
```
"store": [{"exists": true}]
```
Elle correspond à toute liste d'attributs de message contenant la clé d'attribut `store`, comme :
```
"store": {"Type": "String", "Value": "fans"}
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
Elle correspond également à l'un des corps de message suivants :
```
{
"store": "fans"
"customer_interests": ["baseball", "basketball"]
}
```
Cependant, elle ne correspond à aucune liste d'attributs de message *sans* l'attribut de clé `store`, tel que :
```
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
Elle ne correspond pas non plus au corps de message suivant :
```
{
"customer_interests": ["baseball", "basketball"]
}
```
+ Utilisez `"exists": false` pour faire correspondre les messages entrants qui *n'incluent pas* la propriété spécifiée.
**Note**
`"exists": false` ne correspond que si au moins un attribut est présent. Si un jeu d'attributs est vide, le filtre ne correspond pas.
Par exemple, la propriété de politique suivante utilise l'opérateur `exists` avec une valeur de `false` :
```
"store": [{"exists": false}]
```
Elle *ne correspond à aucune* liste d'attributs de message contenant la clé d'attribut `store`, comme :
```
"store": {"Type": "String", "Value": "fans"}
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
Elle ne correspond pas non plus au corps de message suivant :
```
{
"store": "fans"
"customer_interests": ["baseball", "basketball"]
}
```
Cependant, elle correspond à toute liste d'attributs de message *sans* l'attribut de clé `store`, tel que :
```
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
Elle correspond également au corps de message suivant :
```
{
"customer_interests": ["baseball", "basketball"]
}
```
# Correspondance de valeur numérique
Filtrez les messages en faisant correspondre les valeurs numériques aux valeurs des attributs du message ou aux valeurs des propriétés du corps du message. Les valeurs numériques ne sont pas placées entre guillemets doubles dans la politique JSON. Vous pouvez utiliser les opérations numériques suivantes pour filtrer.
**Note**
Les préfixes sont pris en charge pour la correspondance de *chaîne* uniquement.
## Correspondance exacte
Lorsqu'une valeur de propriété de politique inclut le mot-clé `numeric` et l'opérateur `=`, elle correspond à toute valeur d'attribut de message ou de propriété de corps de message qui a le même nom et la même valeur numérique.
Examinons la propriété de politique suivante :
```
"price_usd": [{"numeric": ["=",301.5]}]
```
Il met en correspondance l'un ou l'autre des attributs de message suivants :
```
"price_usd": {"Type": "Number", "Value": 301.5}
```
```
"price_usd": {"Type": "Number", "Value": 3.015e2}
```
Elle correspond également à l'un des corps de message suivants :
```
{
"price_usd": 301.5
}
```
```
{
"price_usd": 3.015e2
}
```
## Correspondance de type « anything-but » (tout-sauf)
Lorsqu'une valeur de propriété de politique inclut le mot-clé `anything-but`, elle correspond à toute valeur d'attribut de message ou de propriété de corps de message qui *n'inclut* aucune des valeurs de propriété de la politique.
Examinons la propriété de politique suivante :
```
"price": [{"anything-but": [100, 500]}]
```
Il met en correspondance l'un ou l'autre des attributs de message suivants :
```
"price": {"Type": "Number", "Value": 101}
```
```
"price": {"Type": "Number", "Value": 100.1}
```
Elle correspond également à l'un des corps de message suivants :
```
{
"price": 101
}
```
```
{
"price": 100.1
}
```
Elle correspond également à l'attribut de message suivant (parce qu'il contient une valeur qui *n'est pas* `100` ou `500`) :
```
"price": {"Type": "Number.Array", "Value": "[100, 50]"}
```
Elle correspond également au corps de message suivant (parce qu'il contient une valeur qui *n'est pas* `100` ou `500`) :
```
{
"price": [100, 50]
}
```
Cependant, il ne met pas en correspondance l'attribut de message suivant :
```
"price": {"Type": "Number", "Value": 100}
```
Elle ne correspond pas non plus au corps de message suivant :
```
{
"price": 100
}
```
## Correspondance de plage de valeurs
En plus de l'opérateur `=`, une propriété de politique numérique peut inclure les opérateurs suivants : `<`, `<=`, `>` et `>=`.
Examinons la propriété de politique suivante :
```
"price_usd": [{"numeric": ["<", 0]}]
```
Elle correspond à tout attribut de message ou propriété de corps de message avec des valeurs numériques négatives.
Prenons l'exemple d'un autre attribut de message :
```
"price_usd": [{"numeric": [">", 0, "<=", 150]}]
```
Elle correspond à tout attribut de message ou propriété de corps de message avec des nombres positifs allant jusqu'à 150 inclus.
# Correspondance de valeur de chaîne
Filtrez les messages en faisant correspondre les valeurs de chaîne aux valeurs des attributs du message ou aux valeurs des propriétés du corps du message. Les valeurs de chaîne sont placées entre guillemets doubles dans la politique JSON. Vous pouvez utiliser les opérations de chaîne suivantes pour faire correspondre les attributs ou les propriétés du corps du message :
## Correspondance exacte
La mise en correspondance exacte a lieu lorsqu'une valeur de propriété de politique correspond à une ou plusieurs valeurs d'attribut de message. Pour les attributs `String.Array` de type, chaque élément du tableau est traité comme une chaîne distincte à des fins de correspondance.
Examinons la propriété de politique suivante :
```
"customer_interests": ["rugby", "tennis"]
```
Elle correspond aux attributs de message suivants :
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
```
"customer_interests": {"Type": "String", "Value": "tennis"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\", \"tennis\"]"}
```
Elle correspond également aux corps de message suivants :
```
{
"customer_interests": "rugby"
}
```
```
{
"customer_interests": "tennis"
}
```
Toutefois, il ne correspond pas aux attributs de message suivants :
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\"]"}
```
Elle ne correspond pas non plus au corps de message suivant :
```
{
"customer_interests": "baseball"
}
```
## Correspondance de type « anything-but » (tout-sauf)
Lorsqu'une valeur de propriété de politique inclut le mot-clé `anything-but`, elle correspond à toute valeur d'attribut de message ou de corps de message qui *n'inclut pas* l'une des valeurs de propriété de la politique. `anything-but` peut être combiné avec `"exists": false`. Pour les attributs `String.Array` de type, cela correspond si aucun des éléments du tableau n'est répertorié dans la propriété policy.
Examinons la propriété de politique suivante :
```
"customer_interests": [{"anything-but": ["rugby", "tennis"]}]
```
Il correspond à l'un des attributs de message suivants :
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String", "Value": "football"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\", \"baseball\"]"}
```
Elle correspond également à l'un des corps de message suivants :
```
{
"customer_interests": "baseball"
}
```
```
{
"customer_interests": "football"
}
```
Elle correspond également à l'attribut de message suivant (parce qu'il contient une valeur qui *n'est pas* `rugby` ou `tennis`) :
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\", \"baseball\"]"}
```
Elle correspond également au corps de message suivant (parce qu'il contient une valeur qui n'est pas `rugby` ou `tennis`) :
```
{
"customer_interests": ["rugby", "baseball"]
}
```
Toutefois, il ne correspond pas aux attributs de message suivants :
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\"]"}
```
Elle ne correspond pas non plus au corps de message suivant :
```
{
"customer_interests": ["rugby"]
}
```
**Utiliser un préfixe avec `anything-but`**
Pour la correspondance de la chaîne, vous pouvez également utiliser un préfixe avec l'opérateur `anything-but`. Par exemple, la propriété de politique suivante refuse le préfixe `order-` :
```
"event":[{"anything-but": {"prefix": "order-"}}]
```
Elle correspond à l'un des attributs suivants :
```
"event": {"Type": "String", "Value": "data-entry"}
```
```
"event": {"Type": "String", "Value": "order_number"}
```
Elle correspond également à l'un des corps de message suivants :
```
{
"event": "data-entry"
}
```
```
{
"event": "order_number"
}
```
Cependant, il ne met pas en correspondance l'attribut de message suivant :
```
"event": {"Type": "String", "Value": "order-cancelled"}
```
Elle ne correspond pas non plus au corps de message suivant :
```
{
"event": "order-cancelled"
}
```
**tout sauf un joker**
La propriété de politique suivante refuse le `*ball` caractère générique :
```
"customer_interests" : [{ "anything-but": { "wildcard": "*ball" }}]
```
Il correspond aux attributs suivants :
```
{"customer_interests": ["hockey", "rugby", "soccer] }
```
Toutefois, il ne correspond pas à l'attribut de message suivant :
```
{"customer_interests": ["baseball", "basketball"] }
```
**tout sauf un suffixe**
La propriété de politique suivante refuse `-ball`
suffixe :
```
"customer_interests": [ { "anything-but": { "suffix": "ball" } } ]
```
Il correspond aux attributs suivants :
```
{"customer_interests": ["hockey", "rugby", "soccer] }
```
Toutefois, il ne correspond pas à l'attribut de message suivant :
```
{"customer_interests": ["baseball", "basketball"] }
```
## Equals-ignore-case correspondance
Lorsqu'une propriété de politique inclut le mot-clé `equals-ignore-case`, elle effectue une correspondance non sensible à la casse avec tout attribut de message ou toute valeur de propriété de corps.
Examinons la propriété de politique suivante :
```
"customer_interests": [{"equals-ignore-case": "tennis"}]
```
Il met en correspondance l'un ou l'autre des attributs de message suivants :
```
"customer_interests": {"Type": "String", "Value": "TENNIS"}
```
```
"customer_interests": {"Type": "String", "Value": "Tennis"}
```
Elle correspond également à l'un des corps de message suivants :
```
{
"customer_interests": "TENNIS"
}
```
```
{
"customer_interests": "teNnis"
{
```
## Correspondance d'adresses IP
Vous pouvez utiliser l’opérateur `cidr` pour vérifier si un message entrant provient d'une adresse IP ou d'un sous-réseau spécifique.
Examinons la propriété de politique suivante :
```
"source_ip":[{"cidr": "10.0.0.0/24"}]
```
Il met en correspondance l'un ou l'autre des attributs de message suivants :
```
"source_ip": {"Type": "String", "Value": "10.0.0.0"}
```
```
"source_ip": {"Type": "String", "Value": "10.0.0.255"}
```
Elle correspond également à l'un des corps de message suivants :
```
{
"source_ip": "10.0.0.0"
}
```
```
{
"source_ip": "10.0.0.255"
}
```
Cependant, il ne met pas en correspondance l'attribut de message suivant :
```
"source_ip": {"Type": "String", "Value": "10.1.1.0"}
```
Elle ne correspond pas non plus au corps de message suivant :
```
{
"source_ip": "10.1.1.0"
}
```
## Correspondance de préfixe
Lorsqu'une propriété de politique inclut le mot-clé `prefix`, elle correspond à toute valeur d'attribut de message ou de propriété de corps qui commence par les caractères spécifiés.
Examinons la propriété de politique suivante :
```
"customer_interests": [{"prefix": "bas"}]
```
Il met en correspondance l'un ou l'autre des attributs de message suivants :
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String", "Value": "basketball"}
```
Elle correspond également à l'un des corps de message suivants :
```
{
"customer_interests": "baseball"
}
```
```
{
"customer_interests": "basketball"
}
```
Cependant, il ne met pas en correspondance l'attribut de message suivant :
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
Elle ne correspond pas non plus au corps de message suivant :
```
{
"customer_interests": "rugby"
}
```
## Correspondance des suffixes
Lorsqu'une propriété de politique inclut le mot-clé `suffix`, elle correspond à toute valeur d'attribut de message ou de propriété de corps qui termine par les caractères spécifiés.
Examinons la propriété de politique suivante :
```
"customer_interests": [{"suffix": "ball"}]
```
Il met en correspondance l'un ou l'autre des attributs de message suivants :
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String", "Value": "basketball"}
```
Elle correspond également à l'un des corps de message suivants :
```
{
"customer_interests": "baseball"
}
```
```
{
"customer_interests": "basketball"
}
```
Cependant, il ne met pas en correspondance l'attribut de message suivant :
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
Elle ne correspond pas non plus au corps de message suivant :
```
{
"customer_interests": "rugby"
}
```
## Caractère générique
Vous pouvez utiliser le caractère générique (\$1) pour mettre en correspondance des valeurs de chaîne dans les modèles d’événements.
La politique suivante utilise le caractère générique (\$1) :
```
"customer_interests": [ { "wildcard": "*ball" } ]
```
Il correspond aux attributs suivants :
```
{"customer_interests": ["baseball", "basketball"] }
```
# Appliquer une politique de filtrage des abonnements dans Amazon SNS
Le filtrage des messages dans Amazon SNS vous permet de distribuer des messages de manière sélective aux abonnés en fonction des politiques de filtrage. Ces politiques définissent les conditions que les messages doivent remplir pour être livrés dans le cadre d'un abonnement. Bien que la livraison de messages bruts soit une option susceptible d'affecter le traitement des messages, elle n'est pas obligatoire pour que les filtres d'abonnement fonctionnent.
Vous pouvez appliquer une politique de filtrage à un abonnement Amazon SNS à l'aide de la console Amazon SNS. Ou, pour appliquer des politiques par programmation, vous pouvez utiliser l'API Amazon SNS, AWS Command Line Interface le AWS CLI() ou AWS tout autre SDK compatible avec Amazon SNS. Vous pouvez également utiliser AWS CloudFormation.
**Activation de la livraison de messages bruts**
La livraison de messages bruts garantit que les charges utiles des messages sont livrées telles quelles aux abonnés, sans aucun codage ni transformation supplémentaire. Cela peut être utile lorsque les abonnés ont besoin du format de message d'origine pour le traitement. Cependant, la livraison de messages bruts n'est pas directement liée à la fonctionnalité des filtres d'abonnement.
**Appliquer des filtres d'abonnement**
Pour appliquer des filtres de messages à un abonnement, vous définissez une politique de filtrage à l'aide de la syntaxe JSON. Cette politique précise les conditions qu'un message doit remplir pour être délivré dans le cadre de l'abonnement. Les filtres peuvent être basés sur les attributs du message, tels que les attributs du message, la structure du message ou même le contenu du message.
**Relation entre la livraison de messages bruts et les filtres d'abonnement**
Bien que l'activation de la livraison de messages bruts puisse affecter la manière dont les messages sont distribués et traités par les abonnés, elle n'est pas une condition préalable à l'utilisation de filtres d'abonnement. Toutefois, dans les scénarios où les abonnés ont besoin du format de message d'origine sans aucune modification, l'activation de la livraison des messages bruts peut être avantageuse parallèlement aux filtres d'abonnement.
**Considérations relatives à un filtrage efficace**
Lors de la mise en œuvre du filtrage des messages, tenez compte des exigences spécifiques de votre application et de vos abonnés. Définissez des politiques de filtrage qui correspondent exactement aux critères de diffusion des messages afin de garantir une distribution efficace et ciblée des messages.
**Important**
AWS des services tels que IAM et Amazon SNS utilisent un modèle informatique distribué appelé cohérence éventuelle. Les ajouts ou modifications de politique de filtrage d'abonnement nécessitent jusqu'à 15 minutes pour prendre effet.
## AWS Management Console
1. Connectez-vous à la [ console Amazon SNS](https://console.aws.amazon.com/sns/home).
1. Dans le panneau de navigation, choisissez **Abonnements**.
1. Sélectionnez un abonnement, puis choisissez **Edit (Modifier)**.
1. Sur la page **Edit** (Modifier), développez la section **Subscription filter policy** (Stratégie de filtrage d'abonnement).
1. Choisissez entre le **filtrage basé sur les attributs** ou le **filtrage basé sur la charge utile**.
1. Dans le champ **JSON editor** (Éditeur JSON), indiquez le **corps JSON** de votre stratégie de filtrage.
1. Sélectionnez **Enregistrer les modifications**.
Amazon SNS applique votre politique de filtrage à l'abonnement.
## AWS CLI
Pour appliquer une politique de filtrage avec le AWS Command Line Interface (AWS CLI), utilisez la [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)commande, comme indiqué dans l'exemple suivant. Pour l'option `--attribute-name`, spécifiez `FilterPolicy`. Pour `--attribute-value`, spécifiez votre **politique JSON**.
```
$ aws sns set-subscription-attributes --subscription-arn arn:aws:sns: ... --attribute-name FilterPolicy --attribute-value '{"store":["example_corp"],"event":["order_placed"]}'
```
Pour fournir un code JSON valide pour votre politique, placez les noms et les valeurs d'attributs entre guillemets. Vous devez également placer la totalité de l'argument de la politique entre guillemets. Pour éviter l'échappement des guillemets, vous pouvez utiliser des apostrophes pour entourer la politique et des guillemets pour entourer les noms et les valeurs JSON, comme illustré dans l'exemple ci-dessus.
Si vous souhaitez passer du filtrage des messages basé sur les attributs (par défaut) au filtrage des messages basé sur la charge utile, vous pouvez également utiliser la [set-subscription-attributes](https://docs.aws.amazon.com/cli/latest/reference/sns/set-subscription-attributes.html)commande. Pour l'option `--attribute-name`, spécifiez `FilterPolicyScope`. Pour `--attribute-value`, spécifiez `MessageBody`.
```
$ aws sns set-subscription-attributes --subscription-arn arn:aws:sns: ... --attribute-name FilterPolicyScope --attribute-value MessageBody
```
Pour vérifier que votre politique de filtre a été appliquée, utilisez la commande `get-subscription-attributes`. Les attributs dans la sortie du terminal doivent afficher votre politique de filtre pour la clé `FilterPolicy`, comme illustré dans l'exemple suivant:
```
$ 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
Les exemples de code suivants illustrent comment utiliser `SetSubscriptionAttributes`.
**Important**
Si vous utilisez l'exemple SDK for Java 2.x, la classe `SNSMessageFilterPolicy` n'est pas disponible dès le départ. Pour obtenir des instructions sur l'installation de cette classe, consultez l'[exemple](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/sns/src/main/java/com/example/sns/SNSMessageFilterPolicy.java) du GitHub site Web.
------
#### [ CLI ]
**AWS CLI**
**Pour définir des attributs d’abonnement**
L’exemple `set-subscription-attributes` suivant définit l’attribut `RawMessageDelivery` sur un abonnement 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
```
Cette commande ne produit aucune sortie.
L’exemple `set-subscription-attributes` suivant définit un attribut `FilterPolicy` sur un abonnement 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\"] }"
```
Cette commande ne produit aucune sortie.
L’exemple `set-subscription-attributes` suivant supprime l’attribut `FilterPolicy` d’un abonnement 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 "{}"
```
Cette commande ne produit aucune sortie.
+ Pour plus de détails sur l'API, reportez-vous [SetSubscriptionAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/set-subscription-attributes.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
}
}
```
+ Pour plus de détails sur l'API, reportez-vous [SetSubscriptionAttributes](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/SetSubscriptionAttributes)à la section *Référence des AWS SDK for Java 2.x API*.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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
```
+ Pour plus de détails sur l'API, consultez [SetSubscriptionAttributes](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/SetSubscriptionAttributes)le *AWS manuel de référence de l'API SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**Kit SDK pour SAP ABAP**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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.
```
+ Pour plus de détails sur l'API, reportez-vous [SetSubscriptionAttributes](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)à la section de référence du *AWS SDK pour l'API SAP ABAP*.
------
## API Amazon SNS
Pour appliquer une politique de filtrage à l'API Amazon SNS, effectuez une demande d'action [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html). Définissez le paramètre `AttributeName` sur `FilterPolicy` et définissez le paramètre `AttributeValue` sur votre politique de filtre JSON.
Si vous souhaitez passer du filtrage des messages basé sur les attributs (par défaut) au filtrage des messages basé sur la charge utile, vous pouvez également utiliser l'action [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html). Définissez le paramètre `AttributeName` sur `FilterPolicyScope`, puis le paramètre `AttributeValue` sur `MessageBody`.
## AWS CloudFormation
Pour appliquer une politique de filtrage en utilisant CloudFormation, utilisez un modèle JSON ou YAML pour créer une CloudFormation pile. Pour plus d'informations, consultez la [`FilterPolicy`propriété](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sns-subscription.html#cfn-sns-subscription-filterpolicy) de la `AWS::SNS::Subscription` ressource dans le *guide de AWS CloudFormation l'utilisateur* et l'[exemple de CloudFormation modèle](https://github.com/aws-samples/aws-sns-samples/blob/master/templates/SNS-Subscription-Attributes-Tutorial-CloudFormation.template).
1. Connectez-vous à la [console CloudFormation](https://console.aws.amazon.com/cloudformation).
1. Sélectionnez **Créer une pile**.
1. Sur la page **Select Template (Sélectionner un modèle)**, choisissez **Upload a template to Amazon S3 (Charger un modèle dans Amazon S3)**, sélectionnez le fichier, puis **Next (Suivant)**.
1. Sur la page **Spécification de détails de base de données**, procédez comme suit :
1. Pour le **Nom de la pile**, tapez `MyFilterPolicyStack`.
1. Pour **myHttpEndpoint**, saisissez le point de terminaison HTTP auquel vous souhaitez vous abonner à votre sujet.
**Astuce**
Si vous n'avez pas de point de terminaison HTTP, vous pouvez créer en.
1. Dans la page **Options**, choisissez **Next (Suivant)**.
1. Sur la page **Review (Vérification)**, choisissez **Create (Créer)**.
# Supprimer une politique de filtrage des abonnements dans Amazon SNS
Pour arrêter de filtrer les messages qui sont envoyés à un abonnement, supprimez la politique de filtre de l'abonnement en la remplaçant par un corps JSON vide. Après que vous avez supprimé la politique, l'abonnement accepte tous les messages qui sont publiés dans celui-ci.
## À l'aide du AWS Management Console
1. Connectez-vous à la [ console Amazon SNS](https://console.aws.amazon.com/sns/home).
1. Dans le panneau de navigation, choisissez **Abonnements**.
1. Sélectionnez un abonnement, puis choisissez **Edit (Modifier)**.
1. Sur la *EXAMPLE1-23bc-4567-d890-ef12g3hij456* page **Modifier**, développez la section **Politique de filtrage des abonnements**.
1. Dans le champ **Éditeur JSON**, indiquez un corps JSON vide pour votre politique de filtre : `{}`.
1. Sélectionnez **Enregistrer les modifications**.
Amazon SNS applique votre politique de filtrage à l'abonnement.
## À l'aide du AWS CLI
Pour supprimer une politique de filtrage avec le AWS CLI, utilisez la [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)commande et fournissez un corps JSON vide pour l'`--attribute-value`argument :
```
$ aws sns set-subscription-attributes --subscription-arn arn:aws:sns: ... --attribute-name FilterPolicy --attribute-value "{}"
```
## Utilisation de l'API Amazon SNS
Pour supprimer une politique de filtrage avec l'API Amazon SNS, effectuez une demande d'action [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html). Définissez le paramètre `AttributeName` sur `FilterPolicy` et fournissez un corps JSON vide pour le paramètre `AttributeValue`.