Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Pemfilteran pesan Amazon SNS
Secara default, pelanggan topik Amazon SNS menerima setiap pesan yang dipublikasikan ke topik tersebut. Untuk hanya menerima sebagian pesan, pelanggan harus menetapkan *kebijakan filter* ke langganan topik.
Kebijakan filter adalah objek JSON yang berisi properti yang menentukan pesan mana yang diterima pelanggan. Amazon SNS mendukung kebijakan yang bekerja pada atribut pesan atau pada badan pesan, sesuai dengan cakupan kebijakan filter yang Anda tetapkan untuk langganan. Kebijakan filter untuk badan pesan mengasumsikan bahwa payload pesan adalah objek JSON yang terbentuk dengan baik.
Jika langganan tidak memiliki kebijakan filter, pelanggan menerima setiap pesan yang dipublikasikan ke topiknya. Saat Anda memublikasikan pesan ke topik dengan kebijakan filter, Amazon SNS akan membandingkan atribut pesan atau badan pesan dengan properti dalam kebijakan filter untuk setiap langganan topik. Jika semua atribut pesan atau properti isi pesan memenuhi kondisi yang ditentukan dalam kebijakan filter, Amazon SNS akan mengirimkan pesan ke pelanggan. Jika tidak, Amazon SNS tidak mengirim pesan ke pelanggan itu.
Untuk informasi selengkapnya, lihat [Memfilter Pesan yang Dipublikasikan ke Topik](https://aws.amazon.com/getting-started/tutorials/filter-messages-published-to-topics/).
# Cakupan kebijakan filter langganan Amazon SNS
Atribut `FilterPolicyScope` subscription memungkinkan Anda menentukan lingkup pemfilteran dengan menetapkan salah satu nilai berikut:
+ `MessageAttributes`— Menerapkan kebijakan filter ke atribut pesan (pengaturan default).
+ `MessageBody`— Menerapkan kebijakan filter ke badan pesan.
**catatan**
Jika tidak ada cakupan kebijakan filter yang ditentukan untuk kebijakan filter yang ada, cakupan default akan ditetapkan. `MessageAttributes`
# Kebijakan filter langganan Amazon SNS
Kebijakan filter langganan memungkinkan Anda menentukan nama properti dan menetapkan daftar nilai untuk setiap nama properti. Untuk informasi selengkapnya, lihat [Pemfilteran pesan Amazon SNS](sns-message-filtering.md).
Saat Amazon SNS mengevaluasi atribut pesan atau properti isi pesan terhadap kebijakan filter langganan, Amazon SNS akan mengabaikan atribut pesan yang tidak ditentukan dalam kebijakan.
**penting**
AWS Layanan seperti IAM dan Amazon SNS menggunakan model komputasi terdistribusi yang disebut konsistensi akhirnya. Penambahan atau perubahan kebijakan filter langganan memerlukan hingga 15 menit untuk diterapkan sepenuhnya.
Langganan menerima pesan di bawah ketentuan berikut:
+ Bila cakupan kebijakan filter disetel ke`MessageAttributes`, setiap nama properti dalam kebijakan filter cocok dengan nama atribut pesan. Untuk setiap nama properti yang cocok dalam kebijakan filter, setidaknya satu nilai properti cocok dengan nilai atribut pesan.
+ Bila cakupan kebijakan filter disetel ke`MessageBody`, setiap nama properti dalam kebijakan filter cocok dengan nama properti isi pesan. Untuk setiap nama properti yang cocok dalam kebijakan filter, setidaknya satu nilai properti cocok dengan nilai properti isi pesan.
Amazon SNS saat ini mendukung operator filter berikut:
+ [Logika DAN](and-or-logic.md#and-logic)
+ [Logika ATAU](and-or-logic.md#or-logic)
+ [ATAU operator](and-or-logic.md#or-operator)
+ [Pencocokan kunci](attribute-key-matching.md)
+ [Nilai numerik pencocokan tepat](numeric-value-matching.md#numeric-exact-matching)
+ [Nilai numerik apa pun-tapi cocok](numeric-value-matching.md#numeric-anything-but-matching)
+ [Pencocokan rentang nilai numerik](numeric-value-matching.md#numeric-value-range-matching)
+ [Nilai string pencocokan tepat](string-value-matching.md#string-exact-matching)
+ [String menghargai apa pun-tapi cocok](string-value-matching.md#string-anything-but-matching)
+ [Pencocokan string menggunakan awalan dengan operator apa pun kecuali](string-value-matching.md#string-anything-but-matching)
+ [Nilai string sama dengan kasus abaikan](string-value-matching.md#string-equals-ignore)
+ [Pencocokan alamat IP nilai string](string-value-matching.md#string-address-matching)
+ [Pencocokan awalan nilai string](string-value-matching.md#string-prefix-matching)
+ [Pencocokan akhiran nilai string](string-value-matching.md#string-suffix-matching)
# Kebijakan filter contoh Amazon SNS
Contoh berikut menunjukkan payload pesan yang dikirimkan oleh topik Amazon SNS yang memproses transaksi pelanggan.
Contoh pertama mencakup `MessageAttributes` bidang dengan atribut yang menggambarkan transaksi:
+ Minat pelanggan
+ Nama penyimpanan
+ State kejadian
+ Harga beli dalam USD
Karena pesan ini menyertakan `MessageAttributes` bidang, langganan topik apa pun yang menetapkan a `FilterPolicy` dapat menerima atau menolak pesan secara selektif, selama `FilterPolicyScope` disetel ke `MessageAttributes` dalam langganan. Untuk informasi tentang menerapkan atribut pada olahpesan, lihat [Atribut pesan 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"
}
}
}
```
Contoh berikut menunjukkan atribut yang sama termasuk dalam `Message` bidang, juga disebut sebagai *payload pesan atau isi* *pesan*. Langganan topik apa pun yang menyertakan a `FilterPolicy` dapat menerima atau menolak pesan secara selektif, selama `FilterPolicyScope` diatur `MessageBody` dalam langganan.
```
{
"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"
}
```
Kebijakan filter berikut menerima atau menolak pesan berdasarkan nama dan nilai properti mereka.
## Kebijakan yang menerima contoh olahpesan
Properti dalam kebijakan filter langganan berikut cocok dengan atribut yang ditetapkan ke pesan contoh. Perhatikan bahwa kebijakan filter yang sama berfungsi untuk `FilterPolicyScope` apakah itu disetel ke `MessageAttributes` atau`MessageBody`. Setiap pelanggan memilih ruang lingkup penyaringan mereka sesuai dengan komposisi pesan yang mereka terima dari topik.
Jika satu properti dalam kebijakan ini tidak cocok dengan atribut yang ditetapkan ke pesan, kebijakan akan menolak pesan tersebut.
```
{
"store": ["example_corp"],
"event": [{"anything-but": "order_cancelled"}],
"customer_interests": [
"rugby",
"football",
"baseball"
],
"price_usd": [{"numeric": [">=", 100]}]
}
```
## Kebijakan yang menolak contoh olahpesan
Kebijakan filter langganan berikut memiliki beberapa ketidakcocokan antara propertinya dan atribut yang ditetapkan ke pesan contoh. Misalnya, karena nama `encrypted` properti tidak ada dalam atribut pesan, properti kebijakan ini menyebabkan pesan ditolak terlepas dari nilai yang ditetapkan padanya.
Jika terjadi ketidakcocokan, kebijakan menolak pesan.
```
{
"store": ["example_corp"],
"event": ["order_cancelled"],
"encrypted": [false],
"customer_interests": [
"basketball",
"baseball"
]
}
```
# Memfilter batasan kebijakan di Amazon SNS
Saat Anda menyiapkan kebijakan filter di Amazon SNS, ada beberapa aturan penting yang perlu diingat. Aturan ini membantu memastikan penerapan kebijakan filter yang efektif sambil mempertahankan kinerja dan kompatibilitas sistem.
## Kendala kebijakan umum
Saat mengonfigurasi kebijakan filter di Amazon SNS, ikuti aturan penting ini untuk memastikannya bekerja secara efektif sambil mempertahankan kinerja dan kompatibilitas sistem:
+ **Pencocokan string** - Untuk pencocokan string dalam kebijakan filter, perbandingannya peka huruf besar/kecil.
+ **Pencocokan numerik** — Untuk pencocokan numerik, nilainya dapat berkisar dari -10 9 hingga 10 9 (-1 miliar hingga 1 miliar), dengan lima digit akurasi setelah titik desimal.
+ **Kompleksitas kebijakan filter** — Kombinasi total nilai dalam kebijakan filter tidak boleh melebihi **150**. Untuk menghitung kombinasi total, kalikan jumlah nilai di setiap array dalam kebijakan filter.
+ **Batasi jumlah kunci** — Kebijakan filter dapat memiliki maksimal **lima** kunci.
****Pertimbangan tambahan****
+ JSON kebijakan filter dapat berisi:
+ String terlampir dalam tanda kutip
+ Nomor
+ Kata kunci`true`,`false`, dan`null`, tanpa tanda kutip
+ **Saat menggunakan Amazon SNS API, Anda harus meneruskan JSON kebijakan filter sebagai string UTF-8 yang valid.**
+ Ukuran maksimum kebijakan filter adalah **256 KB**.
+ Secara default, Anda dapat memiliki hingga **200** kebijakan filter per topik, dan **10.000** kebijakan filter per AWS akun.
Batas kebijakan ini tidak akan menghentikan langganan antrian Amazon SQS dibuat dengan API. [https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html](https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html) Namun, itu akan gagal saat Anda melampirkan kebijakan filter dalam panggilan `Subscribe` API (atau panggilan [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html)API).
Untuk meningkatkan kuota ini, Anda dapat menggunakan [AWS Service](https://docs.aws.amazon.com/servicequotas/latest/userguide/intro.html) Quotas.
## Kendala kebijakan untuk penyaringan berbasis atribut
Pemfilteran berbasis atribut adalah opsi default. [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)diatur ke `MessageAttributes` dalam langganan.
+ Amazon SNS tidak menerima kebijakan filter bersarang untuk pemfilteran berbasis atribut.
+ Amazon SNS membandingkan properti kebijakan hanya dengan atribut pesan yang memiliki tipe data berikut:
+ `String`
+ `String.Array`
**penting**
Saat menggunakan pemfilteran berbasis atribut di Amazon SNS, Anda harus melarikan diri dari karakter khusus tertentu, khususnya:
Kutipan ganda (“)
Backslashes ()
Kegagalan untuk melarikan diri dari karakter ini akan mengakibatkan kebijakan filter tidak cocok dengan atribut pesan yang dipublikasikan, dan notifikasi tidak akan dikirimkan.
**Pertimbangan tambahan**
+ Melewati objek dalam array tidak disarankan karena dapat menghasilkan hasil yang tidak terduga karena penyaringan, yang tidak didukung oleh pemfilteran berbasis atribut. Gunakan pemfilteran berbasis muatan untuk kebijakan bersarang.
+ `Number`didukung untuk nilai atribut numerik.
+ Amazon SNS mengabaikan atribut pesan dengan tipe data Biner.
**Contoh kebijakan untuk kompleksitas:**
Dalam contoh kebijakan berikut, kunci pertama memiliki **tiga** operator kecocokan, yang kedua memiliki **satu** operator kecocokan, dan yang ketiga memiliki **dua** operator kecocokan.
```
{
"key_a": ["value_one", "value_two", "value_three"],
"key_b": ["value_one"],
"key_c": ["value_one", "value_two"]
}
```
Kombinasi total dihitung sebagai produk dari jumlah operator kecocokan untuk setiap kunci dalam kebijakan filter:
```
3(match operators of key_a)
x 1(match operators of key_b)
x 2(match operators of key_c)
= 6
```
## Kendala kebijakan untuk penyaringan berbasis muatan
Untuk beralih dari pemfilteran berbasis atribut (default) ke pemfilteran berbasis muatan, Anda harus menyetel ke dalam [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeprovisionIpamPoolCidr.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeprovisionIpamPoolCidr.html)langganan. `MessageBody`
+ Amazon SNS menerima kebijakan filter bersarang untuk pemfilteran berbasis muatan.
+ Untuk kebijakan bersarang, hanya **kunci daun** yang dihitung menuju batas **lima** kunci.
**Contoh kebijakan untuk batas kunci:**
Dalam contoh kebijakan berikut:
+ Ada dua kunci daun: `key_c` dan`key_e`.
+ `key_c`**memiliki **empat** operator pertandingan dengan level bersarang **tiga**, dan `key_e` memiliki **tiga** operator pertandingan dengan level bersarang dua.**
```
{
"key_a": {
"key_b": {
"key_c": ["value_one", "value_two", "value_three", "value_four"]
}
},
"key_d": {
"key_e": ["value_one", "value_two", "value_three"]
}
}
```
Kombinasi total dihitung sebagai produk dari jumlah operator kecocokan dan level bersarang untuk setiap kunci dalam kebijakan filter:
```
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
```
## Pedoman penggunaan pola wildcard
Amazon SQS mengimplementasikan perlindungan saat Anda mendaftarkan kebijakan filter yang berisi wildcard untuk memastikan bahwa kebijakan filter yang terlalu rumit tidak dibuat, karena hal ini akan memengaruhi kinerja aplikasi Anda.
**Struktur pola**
Bidang berisi satu atau lebih pola. Contoh berikut menunjukkan bidang menggunakan dua pola:
```
{
"greeting": [
{"anything-but": {"prefix": "Hello"}},
{"wildcard": "H*"}
] // 2 patterns
}
```
**Aturan kompleksitas**
+ Kompleksitas wildcard total di semua bidang tidak boleh melebihi 100 poin
+ Maksimal 3 wildcard per pola
**Perhitungan kompleksitas**
+ Kompleksitas bidang = `(Sum of pattern points)` × `(Number of patterns)`
+ Poin pola:
Wildcard tunggal: 1 poin
Beberapa wildcard: masing-masing 3 poin
Apa saja-tapi: 1 poin
Berikut ini adalah contoh perhitungan kompleksitas:
```
{
"filename": [
{"wildcard": "*.txt"}, // 1 point
{"wildcard": "log*"} // 1 point
] // Total: (1 + 1) × 2 = 4 points
}
```
# Logika DAN/ATAU
Gunakan AND/OR logika dalam kebijakan filter untuk mencocokkan atribut pesan atau properti isi pesan di Amazon SNS. Ini memungkinkan penyaringan pesan yang lebih tepat dan fleksibel.
## Logika DAN
Anda dapat menerapkan logika AND menggunakan beberapa nama properti.
Pertimbangkan kebijakan berikut:
```
{
"customer_interests": ["rugby"],
"price_usd": [{"numeric": [">", 100]}]
}
```
Ini cocok dengan atribut pesan atau properti badan pesan dengan nilai `customer_interests` set ke `rugby` *dan* nilai `price_usd` set ke angka yang lebih besar dari 100.
**catatan**
Anda tidak dapat menerapkan logika AND ke nilai atribut yang sama.
## Logika ATAU
Anda dapat menerapkan logika OR dengan menetapkan beberapa nilai ke nama properti.
Pertimbangkan kebijakan berikut:
```
{
"customer_interests": ["rugby", "football", "baseball"]
}
```
Ini cocok dengan atribut pesan atau properti badan pesan dengan nilai `customer_interests` set ke`rugby`,`football`, *atau*`baseball`.
## ATAU operator
Anda dapat menggunakan `"$or"` operator untuk secara eksplisit menentukan kebijakan filter untuk mengekspresikan hubungan OR antara beberapa atribut dalam kebijakan.
Amazon SNS hanya mengenali `"$or"` hubungan ketika kebijakan telah memenuhi semua persyaratan berikut. Ketika semua kondisi ini tidak terpenuhi, `"$or"` diperlakukan sebagai nama atribut reguler, sama seperti string lain dalam kebijakan.
+ Ada atribut `"$or"` bidang dalam aturan diikuti dengan array, misalnya`“$or” : []`.
+ Setidaknya ada 2 objek dalam `"$or"` array:`"$or": [{}, {}]`.
+ Tak satu pun dari objek dalam `"$or"` array memiliki nama bidang yang merupakan kata kunci cadangan.
Jika `"$or"` tidak, diperlakukan sebagai nama atribut normal, sama seperti string lain dalam kebijakan.
Kebijakan berikut tidak diuraikan sebagai hubungan OR karena numerik dan awalan adalah kata kunci yang dicadangkan.
```
{
"$or": [ {"numeric" : 123}, {"prefix": "abc"} ]
}
```
**`OR`contoh operator**
Standar`OR`:
```
{
"source": [ "aws.cloudwatch" ],
"$or": [
{ "metricName": [ "CPUUtilization" ] },
{ "namespace": [ "AWS/EC2" ] }
]
}
```
Logika filter untuk kebijakan ini adalah:
```
"source" && ("metricName" || "namespace")
```
Ini cocok dengan salah satu dari set atribut pesan berikut:
```
"source": {"Type": "String", "Value": "aws.cloudwatch"},
"metricName": {"Type": "String", "Value": "CPUUtilization"}
```
atau
```
"source": {"Type": "String", "Value": "aws.cloudwatch"},
"namespace": {"Type": "String", "Value": "AWS/EC2"}
```
Ini juga cocok dengan salah satu badan pesan berikut:
```
{
"source": "aws.cloudwatch",
"metricName": "CPUUtilization"
}
```
atau
```
{
"source": "aws.cloudwatch",
"namespace": "AWS/EC2"
}
```
### Kendala kebijakan yang mencakup hubungan `OR`
Pertimbangkan kebijakan berikut:
```
{
"source": [ "aws.cloudwatch" ],
"$or": [
{ "metricName": [ "CPUUtilization", "ReadLatency" ] },
{
"metricType": [ "MetricType" ] ,
"$or" : [
{ "metricId": [ 1234, 4321 ] },
{ "spaceId": [ 1000, 2000, 3000 ] }
]
}
]
}
```
Logika untuk kebijakan ini juga dapat disederhanakan sebagai:
```
("source" AND "metricName")
OR
("source" AND "metricType" AND "metricId")
OR
("source" AND "metricType" AND "spaceId")
```
Perhitungan kompleksitas untuk kebijakan dengan hubungan OR dapat disederhanakan sebagai jumlah kompleksitas kombinasi untuk setiap pernyataan OR.
Kombinasi total dihitung sebagai berikut:
```
(source * metricName) + (source * metricType * metricId) + (source * metricType * spaceId)
= (1 * 2) + (1 * 1 * 2) + (1 * 1 * 3)
= 7
```
`source`memiliki satu nilai, `metricName` memiliki dua nilai, `metricType` memiliki satu nilai, `metricId` memiliki dua nilai dan `spaceId` memiliki tiga nilai.
Pertimbangkan kebijakan filter bersarang berikut:
```
{
"$or": [
{ "metricName": [ "CPUUtilization", "ReadLatency" ] },
{ "namespace": [ "AWS/EC2", "AWS/ES" ] }
],
"detail" : {
"scope" : [ "Service" ],
"$or": [
{ "source": [ "aws.cloudwatch" ] },
{ "type": [ "CloudWatch Alarm State Change"] }
]
}
}
```
Logika untuk kebijakan ini dapat disederhanakan sebagai:
```
("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")
```
Perhitungan untuk kombinasi total adalah sama untuk kebijakan non-bersarang kecuali kita perlu mempertimbangkan tingkat bersarang kunci.
Kombinasi total dihitung sebagai berikut:
```
(2 * 2 * 2) + (2 * 2 * 2) + (2 * 2 * 2) + (2 * 2 * 2) = 32
```
`metricName`memiliki dua nilai, `namespace` memiliki dua nilai, `scope` adalah kunci bersarang dua tingkat dengan satu nilai, `source` adalah kunci bersarang dua tingkat dengan satu nilai, dan `type` merupakan kunci bersarang dua tingkat dengan satu nilai.
# Pencocokan kunci
Gunakan `exists` operator dalam kebijakan filter untuk mencocokkan pesan masuk berdasarkan apakah properti tertentu ada atau tidak ada.
+ `exists`hanya berfungsi pada simpul daun (atribut akhir dalam struktur).
+ Ini tidak berlaku untuk node perantara dalam struktur JSON bersarang.
+ Gunakan `"exists": true` untuk mencocokkan pesan masuk yang menyertakan properti yang ditentukan. Kunci harus memiliki nilai non-null dan non-kosong.
Misalnya, properti kebijakan berikut menggunakan `exists` operator dengan nilai`true`:
```
"store": [{"exists": true}]
```
Ini cocok dengan daftar atribut pesan yang berisi kunci `store` atribut, seperti berikut ini:
```
"store": {"Type": "String", "Value": "fans"}
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
Ini juga cocok dengan salah satu dari badan pesan berikut:
```
{
"store": "fans"
"customer_interests": ["baseball", "basketball"]
}
```
Namun, itu tidak cocok dengan daftar atribut pesan apa pun *tanpa* kunci `store` atribut, seperti berikut ini:
```
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
Juga tidak cocok dengan badan pesan berikut:
```
{
"customer_interests": ["baseball", "basketball"]
}
```
+ Gunakan `"exists": false` untuk mencocokkan pesan masuk yang *tidak* menyertakan properti yang ditentukan.
**catatan**
`"exists": false`hanya cocok jika setidaknya ada satu atribut. Kumpulan atribut kosong menghasilkan filter yang tidak cocok.
Misalnya, properti kebijakan berikut menggunakan `exists` operator dengan nilai`false`:
```
"store": [{"exists": false}]
```
Itu *tidak* cocok dengan daftar atribut pesan yang berisi kunci `store` atribut, seperti berikut ini:
```
"store": {"Type": "String", "Value": "fans"}
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
Itu juga tidak cocok dengan badan pesan berikut:
```
{
"store": "fans"
"customer_interests": ["baseball", "basketball"]
}
```
Namun, ini cocok dengan daftar atribut pesan apa pun *tanpa* kunci `store` atribut, seperti berikut ini:
```
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\", \"basketball\"]"}
```
Ini juga cocok dengan badan pesan berikut:
```
{
"customer_interests": ["baseball", "basketball"]
}
```
# Pencocokan nilai numerik
Filter pesan dengan mencocokkan nilai numerik dengan nilai atribut pesan atau ke nilai properti isi pesan. Nilai-nilai numerik tidak dikutip tanda kutip ganda dalam kebijakan JSON. Anda dapat menggunakan operasi numerik berikut untuk pemfilteran.
**catatan**
Awalan didukung hanya untuk pencocokan *string*.
## Pencocokan tepat
Jika nilai properti kebijakan menyertakan kata kunci `numeric` dan operator`=`, nilai properti tersebut cocok dengan atribut pesan atau nilai properti isi pesan yang memiliki nama yang sama dan nilai numerik yang sama.
Pertimbangkan properti kebijakan berikut:
```
"price_usd": [{"numeric": ["=",301.5]}]
```
Cocok dengan salah satu dari atribut olahpesan berikut:
```
"price_usd": {"Type": "Number", "Value": 301.5}
```
```
"price_usd": {"Type": "Number", "Value": 3.015e2}
```
Ini juga cocok dengan salah satu badan pesan berikut:
```
{
"price_usd": 301.5
}
```
```
{
"price_usd": 3.015e2
}
```
## Apa saja tapi tidak cocok
Jika nilai properti kebijakan menyertakan kata kunci`anything-but`, nilai properti tersebut cocok dengan atribut pesan atau nilai properti isi pesan apa pun yang *tidak* menyertakan nilai properti kebijakan apa pun.
Pertimbangkan properti kebijakan berikut:
```
"price": [{"anything-but": [100, 500]}]
```
Cocok dengan salah satu dari atribut olahpesan berikut:
```
"price": {"Type": "Number", "Value": 101}
```
```
"price": {"Type": "Number", "Value": 100.1}
```
Ini juga cocok dengan salah satu badan pesan berikut:
```
{
"price": 101
}
```
```
{
"price": 100.1
}
```
Selain itu, ini cocok dengan atribut pesan berikut (karena berisi nilai yang *bukan* `100` atau`500`):
```
"price": {"Type": "Number.Array", "Value": "[100, 50]"}
```
Dan itu juga cocok dengan badan pesan berikut (karena berisi nilai yang *bukan* `100` atau`500`):
```
{
"price": [100, 50]
}
```
Namun, tidak cocok dengan atribut olahpesan berikut:
```
"price": {"Type": "Number", "Value": 100}
```
Juga tidak cocok dengan badan pesan berikut:
```
{
"price": 100
}
```
## Pencocokan rentang nilai
Selain operator`=`, properti kebijakan numerik dapat mencakup operator berikut:`<`,, `<=``>`, dan`>=`.
Pertimbangkan properti kebijakan berikut:
```
"price_usd": [{"numeric": ["<", 0]}]
```
Ini cocok dengan atribut pesan atau properti badan pesan dengan nilai numerik negatif.
Pertimbangkan atribut olahpesan lain:
```
"price_usd": [{"numeric": [">", 0, "<=", 150]}]
```
Ini cocok dengan atribut pesan atau properti badan pesan dengan angka positif hingga dan termasuk 150.
# Pencocokan nilai string
Filter pesan dengan mencocokkan nilai string dengan nilai atribut pesan atau nilai properti isi pesan. Nilai-nilai string diapit tanda kutip ganda dalam kebijakan JSON. Anda dapat menggunakan operasi string berikut untuk mencocokkan atribut pesan atau properti isi pesan:
## Pencocokan tepat
Pencocokan yang tepat terjadi ketika nilai properti kebijakan cocok dengan satu atau beberapa nilai atribut pesan. Untuk atribut `String.Array` tipe, setiap elemen dalam array diperlakukan sebagai string terpisah untuk tujuan pencocokan.
Pertimbangkan properti kebijakan berikut:
```
"customer_interests": ["rugby", "tennis"]
```
Cocok dengan atribut olahpesan berikut:
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
```
"customer_interests": {"Type": "String", "Value": "tennis"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\", \"tennis\"]"}
```
Ini juga cocok dengan badan pesan berikut:
```
{
"customer_interests": "rugby"
}
```
```
{
"customer_interests": "tennis"
}
```
Namun, itu tidak cocok dengan atribut pesan berikut:
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"baseball\"]"}
```
Juga tidak cocok dengan badan pesan berikut:
```
{
"customer_interests": "baseball"
}
```
## Apa saja tapi tidak cocok
Jika nilai properti kebijakan menyertakan kata kunci`anything-but`, nilai tersebut cocok dengan atribut pesan atau nilai isi pesan apa pun yang *tidak* menyertakan nilai properti kebijakan apa pun. `anything-but`dapat dikombinasikan dengan`"exists": false`. Untuk atribut `String.Array` type, akan cocok jika tidak ada elemen array yang terdaftar di properti policy.
Pertimbangkan properti kebijakan berikut:
```
"customer_interests": [{"anything-but": ["rugby", "tennis"]}]
```
Ini cocok dengan salah satu atribut pesan berikut:
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String", "Value": "football"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\", \"baseball\"]"}
```
Ini juga cocok dengan salah satu badan pesan berikut:
```
{
"customer_interests": "baseball"
}
```
```
{
"customer_interests": "football"
}
```
Selain itu, ini cocok dengan atribut pesan berikut (karena berisi nilai yang *bukan* `rugby` atau`tennis`):
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\", \"baseball\"]"}
```
Dan itu juga cocok dengan badan pesan berikut (karena berisi nilai yang bukan `rugby` atau`tennis`):
```
{
"customer_interests": ["rugby", "baseball"]
}
```
Namun, itu tidak cocok dengan atribut pesan berikut:
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
```
"customer_interests": {"Type": "String.Array", "Value": "[\"rugby\"]"}
```
Juga tidak cocok dengan badan pesan berikut:
```
{
"customer_interests": ["rugby"]
}
```
**Menggunakan awalan dengan `anything-but`**
Untuk pencocokan string, Anda juga dapat menggunakan awalan dengan `anything-but` operator. Misalnya, properti kebijakan berikut menyangkal `order-` awalan:
```
"event":[{"anything-but": {"prefix": "order-"}}]
```
Cocok salah satu dari atribut berikut:
```
"event": {"Type": "String", "Value": "data-entry"}
```
```
"event": {"Type": "String", "Value": "order_number"}
```
Ini juga cocok dengan salah satu badan pesan berikut:
```
{
"event": "data-entry"
}
```
```
{
"event": "order_number"
}
```
Namun, tidak cocok dengan atribut olahpesan berikut:
```
"event": {"Type": "String", "Value": "order-cancelled"}
```
Juga tidak cocok dengan badan pesan berikut:
```
{
"event": "order-cancelled"
}
```
**apa pun-kecuali wildcard**
Properti kebijakan berikut menyangkal `*ball` wildcard:
```
"customer_interests" : [{ "anything-but": { "wildcard": "*ball" }}]
```
Ini cocok dengan atribut berikut:
```
{"customer_interests": ["hockey", "rugby", "soccer] }
```
Namun, itu tidak cocok dengan atribut pesan berikut:
```
{"customer_interests": ["baseball", "basketball"] }
```
**apa pun-kecuali akhiran**
Properti kebijakan berikut menyangkal `-ball`
akhiran:
```
"customer_interests": [ { "anything-but": { "suffix": "ball" } } ]
```
Ini cocok dengan atribut berikut:
```
{"customer_interests": ["hockey", "rugby", "soccer] }
```
Namun, itu tidak cocok dengan atribut pesan berikut:
```
{"customer_interests": ["baseball", "basketball"] }
```
## Equals-ignore-case pencocokan
Ketika properti kebijakan menyertakan kata kunci`equals-ignore-case`, properti tersebut akan melakukan kecocokan case-insensitive dengan atribut pesan atau nilai properti body apa pun.
Pertimbangkan properti kebijakan berikut:
```
"customer_interests": [{"equals-ignore-case": "tennis"}]
```
Cocok dengan salah satu dari atribut olahpesan berikut:
```
"customer_interests": {"Type": "String", "Value": "TENNIS"}
```
```
"customer_interests": {"Type": "String", "Value": "Tennis"}
```
Ini juga cocok dengan salah satu badan pesan berikut:
```
{
"customer_interests": "TENNIS"
}
```
```
{
"customer_interests": "teNnis"
{
```
## Pencocokan alamat IP
Anda dapat menggunakan operator `cidr` untuk memeriksa apakah olahpesan masuk berasal dari alamat IP tertentu atau subnet.
Pertimbangkan properti kebijakan berikut:
```
"source_ip":[{"cidr": "10.0.0.0/24"}]
```
Cocok dengan salah satu dari atribut olahpesan berikut:
```
"source_ip": {"Type": "String", "Value": "10.0.0.0"}
```
```
"source_ip": {"Type": "String", "Value": "10.0.0.255"}
```
Ini juga cocok dengan salah satu badan pesan berikut:
```
{
"source_ip": "10.0.0.0"
}
```
```
{
"source_ip": "10.0.0.255"
}
```
Namun, tidak cocok dengan atribut olahpesan berikut:
```
"source_ip": {"Type": "String", "Value": "10.1.1.0"}
```
Juga tidak cocok dengan badan pesan berikut:
```
{
"source_ip": "10.1.1.0"
}
```
## Pencocokan prefiks
Jika properti kebijakan menyertakan kata kunci`prefix`, properti tersebut cocok dengan atribut pesan atau nilai properti isi apa pun yang dimulai dengan karakter yang ditentukan.
Pertimbangkan properti kebijakan berikut:
```
"customer_interests": [{"prefix": "bas"}]
```
Cocok dengan salah satu dari atribut olahpesan berikut:
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String", "Value": "basketball"}
```
Ini juga cocok dengan salah satu badan pesan berikut:
```
{
"customer_interests": "baseball"
}
```
```
{
"customer_interests": "basketball"
}
```
Namun, tidak cocok dengan atribut olahpesan berikut:
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
Juga tidak cocok dengan badan pesan berikut:
```
{
"customer_interests": "rugby"
}
```
## Pencocokan akhiran
Jika properti kebijakan menyertakan kata kunci`suffix`, properti tersebut cocok dengan atribut pesan atau nilai properti isi yang diakhiri dengan karakter yang ditentukan.
Pertimbangkan properti kebijakan berikut:
```
"customer_interests": [{"suffix": "ball"}]
```
Cocok dengan salah satu dari atribut olahpesan berikut:
```
"customer_interests": {"Type": "String", "Value": "baseball"}
```
```
"customer_interests": {"Type": "String", "Value": "basketball"}
```
Ini juga cocok dengan salah satu badan pesan berikut:
```
{
"customer_interests": "baseball"
}
```
```
{
"customer_interests": "basketball"
}
```
Namun, tidak cocok dengan atribut olahpesan berikut:
```
"customer_interests": {"Type": "String", "Value": "rugby"}
```
Juga tidak cocok dengan badan pesan berikut:
```
{
"customer_interests": "rugby"
}
```
## Wildcard
Anda dapat menggunakan karakter wildcard (\$1) untuk mencocokkan nilai string dalam pola acara.
Kebijakan berikut menggunakan karakter wildcard (\$1):
```
"customer_interests": [ { "wildcard": "*ball" } ]
```
Ini cocok dengan atribut berikut:
```
{"customer_interests": ["baseball", "basketball"] }
```
# Menerapkan kebijakan filter langganan di Amazon SNS
Pemfilteran pesan di Amazon SNS memungkinkan Anda mengirimkan pesan secara selektif ke pelanggan berdasarkan kebijakan filter. Kebijakan ini menentukan kondisi yang harus dipenuhi pesan agar dikirimkan ke langganan. Meskipun pengiriman pesan mentah adalah opsi yang dapat memengaruhi pemrosesan pesan, filter langganan tidak diperlukan untuk berfungsi.
Anda dapat menerapkan kebijakan filter langganan Amazon SNS menggunakan konsol Amazon SNS. Atau, untuk menerapkan kebijakan secara terprogram, Anda dapat menggunakan Amazon SNS API,AWS CLI(), AWS Command Line Interface atau SDK AWS apa pun yang mendukung Amazon SNS. Anda juga bisa menggunakan AWS CloudFormation.
**Mengaktifkan Pengiriman Pesan Mentah**
Pengiriman pesan mentah memastikan bahwa muatan pesan dikirimkan apa adanya kepada pelanggan tanpa pengkodean atau transformasi tambahan. Ini dapat berguna ketika pelanggan memerlukan format pesan asli untuk diproses. Namun, pengiriman pesan mentah tidak terkait langsung dengan fungsionalitas filter berlangganan.
**Menerapkan Filter Berlangganan**
Untuk menerapkan filter pesan ke langganan, Anda menentukan kebijakan filter menggunakan sintaks JSON. Kebijakan ini menetapkan kondisi yang harus dipenuhi pesan untuk dikirimkan ke langganan. Filter dapat didasarkan pada atribut pesan, seperti atribut pesan, struktur pesan, atau bahkan konten pesan.
**Hubungan antara Pengiriman Pesan Mentah dan Filter Berlangganan**
Meskipun mengaktifkan pengiriman pesan mentah dapat memengaruhi cara pesan dikirim dan diproses oleh pelanggan, ini bukan prasyarat untuk menggunakan filter berlangganan. Namun, dalam skenario di mana pelanggan memerlukan format pesan asli tanpa modifikasi apa pun, mengaktifkan pengiriman pesan mentah mungkin bermanfaat bersama filter berlangganan.
**Pertimbangan untuk Penyaringan Efektif**
Saat menerapkan pemfilteran pesan, pertimbangkan persyaratan spesifik aplikasi dan pelanggan Anda. Tentukan kebijakan filter yang secara akurat sesuai dengan kriteria pengiriman pesan untuk memastikan distribusi pesan yang efisien dan ditargetkan.
**penting**
AWS Layanan seperti IAM dan Amazon SNS menggunakan model komputasi terdistribusi yang disebut konsistensi akhirnya. Penambahan atau perubahan kebijakan filter langganan memerlukan hingga 15 menit untuk diterapkan sepenuhnya.
## Konsol Manajemen AWS
1. Masuk ke [konsol Amazon SNS](https://console.aws.amazon.com/sns/home).
1. Di panel navigasi, pilih **Berlangganan**.
1. Pilih langganan dan kemudian pilih **Edit**.
1. Pada halaman **Edit**, perluas bagian **Kebijakan filter Langganan**.
1. **Pilih antara pemfilteran **berbasis atribut atau pemfilteran** berbasis muatan.**
1. Di bidang **editor JSON**, berikan isi **JSON dari kebijakan** filter Anda.
1. Pilih **Simpan perubahan**.
Amazon SNS menerapkan kebijakan filter Anda untuk berlangganan.
## AWS CLI
Untuk menerapkan kebijakan filter dengan AWS Command Line Interface (AWS CLI), gunakan [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)perintah, seperti yang ditunjukkan pada contoh berikut. Untuk opsi `--attribute-name`, tentukan `FilterPolicy`. Untuk`--attribute-value`, tentukan **kebijakan JSON** Anda.
```
$ aws sns set-subscription-attributes --subscription-arn arn:aws:sns: ... --attribute-name FilterPolicy --attribute-value '{"store":["example_corp"],"event":["order_placed"]}'
```
Untuk memberikan JSON yang valid untuk kebijakan Anda, lampirkan nama atribut dan nilai-nilai dalam tanda kutip ganda. Anda juga harus menyertakan seluruh argumen kebijakan dalam tanda kutip. Untuk menghindari tanda kutip lolos, Anda dapat menggunakan tanda kutip tunggal untuk melampirkan kebijakan dan tanda kutip ganda untuk melampirkan nama dan nilai JSON, seperti yang ditunjukkan pada contoh di atas.
Jika Anda ingin beralih dari pemfilteran pesan berbasis atribut (default) ke pemfilteran pesan berbasis muatan, Anda juga dapat menggunakan perintah tersebut. [set-subscription-attributes](https://docs.aws.amazon.com/cli/latest/reference/sns/set-subscription-attributes.html) Untuk opsi `--attribute-name`, tentukan `FilterPolicyScope`. Untuk `--attribute-value`, tentukan `MessageBody`.
```
$ aws sns set-subscription-attributes --subscription-arn arn:aws:sns: ... --attribute-name FilterPolicyScope --attribute-value MessageBody
```
Untuk memverifikasi bahwa kebijakan filter diterapkan, gunakan perintah `get-subscription-attributes`. Atribut dalam output terminal harus menunjukkan kebijakan filter Anda untuk kunci `FilterPolicy`, seperti yang ditunjukkan dalam contoh berikut:
```
$ 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
Contoh kode berikut menunjukkan cara menggunakan`SetSubscriptionAttributes`.
**penting**
Jika Anda menggunakan contoh SDK for Java 2.x, `SNSMessageFilterPolicy` kelas tidak tersedia di luar kotak. Untuk petunjuk tentang cara menginstal kelas ini, lihat [contoh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/sns/src/main/java/com/example/sns/SNSMessageFilterPolicy.java) dari situs GitHub web.
------
#### [ CLI ]
**AWS CLI**
**Untuk mengatur atribut langganan**
`set-subscription-attributes`Contoh berikut menetapkan `RawMessageDelivery` atribut ke langganan 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
```
Perintah ini tidak menghasilkan output.
`set-subscription-attributes`Contoh berikut menetapkan `FilterPolicy` atribut ke langganan 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\"] }"
```
Perintah ini tidak menghasilkan output.
`set-subscription-attributes`Contoh berikut menghapus `FilterPolicy` atribut dari langganan 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 "{}"
```
Perintah ini tidak menghasilkan output.
+ Untuk detail API, lihat [SetSubscriptionAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/set-subscription-attributes.html)di *Referensi AWS CLI Perintah*.
------
#### [ Java ]
**SDK untuk Java 2.x**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode 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);
}
}
}
```
+ Untuk detail API, lihat [SetSubscriptionAttributes](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/SetSubscriptionAttributes)di *Referensi AWS SDK for Java 2.x API*.
------
#### [ Python ]
**SDK untuk Python (Boto3)**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode 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
```
+ Untuk detail API, lihat [SetSubscriptionAttributes](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/SetSubscriptionAttributes)di *AWS SDK for Python (Boto3) Referensi* API.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di [Repositori Contoh Kode 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.
```
+ Untuk detail API, lihat [SetSubscriptionAttributes](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)di *AWS SDK untuk referensi SAP ABAP* API.
------
## API Amazon SNS
Untuk menerapkan kebijakan filter dengan API Amazon SNS, buat permintaan ke tindakan [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html). Atur parameter `AttributeName` ke `FilterPolicy`, dan mengatur parameter `AttributeValue` ke kebijakan filter JSON.
Jika Anda ingin beralih dari pemfilteran pesan berbasis atribut (default) ke pemfilteran pesan berbasis muatan, Anda juga dapat menggunakan tindakan tersebut. [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html) Atur `AttributeName` parameter ke`FilterPolicyScope`, dan atur `AttributeValue` parameternya ke`MessageBody`.
## AWS CloudFormation
Untuk menerapkan kebijakan filter menggunakan CloudFormation, gunakan template JSON atau YAMAL untuk membuat tumpukan. CloudFormation Untuk informasi selengkapnya, lihat [`FilterPolicy`properti](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-sns-subscription.html#cfn-sns-subscription-filterpolicy) `AWS::SNS::Subscription` sumber daya di *Panduan AWS CloudFormation Pengguna* dan [CloudFormation templat contoh](https://github.com/aws-samples/aws-sns-samples/blob/master/templates/SNS-Subscription-Attributes-Tutorial-CloudFormation.template).
1. Masuk ke [konsol CloudFormation](https://console.aws.amazon.com/cloudformation).
1. Pilih **Buat Tumpukan**.
1. Pada halaman **Pilihan Templat**, pilih **Unggah templat ke Amazon S3**, pilih templat file, dan pilih **Selanjutnya**.
1. Di halaman **Tentukan Detail**, lakukan hal berikut:
1. Untuk **Nama Tumpukan**, ketik `MyFilterPolicyStack`.
1. Untuk **myHttpEndpoint**, ketik titik akhir HTTP untuk berlangganan topik Anda.
**Tip**
Jika Anda tidak memiliki titik akhir HTTP, buat titik akhir HTTP.
1. Di halaman **Opsi**, pilih **Selanjutnya**.
1. Di halaman **Tinjau**, pilih **Buat.**
# Menghapus kebijakan filter langganan di Amazon SNS
Untuk menghentikan penyaringan pesan yang dikirim ke langganan, hapus kebijakan filter langganan dengan menimpanya dengan isi JSON kosong. Setelah Anda menghapus kebijakan, langganan akan menerima setiap pesan yang dipublikasikan.
## Menggunakan Konsol Manajemen AWS
1. Masuk ke [konsol Amazon SNS](https://console.aws.amazon.com/sns/home).
1. Di panel navigasi, pilih **Berlangganan**.
1. Pilih langganan dan kemudian pilih **Edit**.
1. Pada *EXAMPLE1-23bc-4567-d890-ef12g3hij456* halaman **Edit**, perluas bagian **Kebijakan filter Langganan**.
1. Di bidang **editor JSON**, menyediakan isi JSON kosong untuk kebijakan filter Anda: `{}`.
1. Pilih **Simpan perubahan**.
Amazon SNS menerapkan kebijakan filter Anda untuk berlangganan.
## Menggunakan AWS CLI
Untuk menghapus kebijakan filter dengan AWS CLI, gunakan [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)perintah dan berikan isi JSON kosong untuk `--attribute-value` argumen:
```
$ aws sns set-subscription-attributes --subscription-arn arn:aws:sns: ... --attribute-name FilterPolicy --attribute-value "{}"
```
## Menggunakan Amazon SNS API
Untuk menghapus kebijakan filter dengan API Amazon SNS, buat permintaan ke tindakan [https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html). Mengatur parameter `AttributeName` ke `FilterPolicy`, dan menyediakan isi JSON kosong untuk parameter `AttributeValue`.