Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menerbitkan pesan Amazon SNS
Setelah Anda [membuat topik Amazon SNS](sns-create-topic.md) dan [berlangganan](sns-create-subscribe-endpoint-to-topic.md) titik akhir ke topik tersebut, Anda dapat *menerbitkan* pesan ke topik. Ketika pesan diterbitkan, Amazon SNS mencoba untuk mengirimkan pesan ke [titik akhir](sns-create-subscribe-endpoint-to-topic.md#sns-endpoints) berlangganan.
## Untuk mempublikasikan pesan ke topik Amazon SNS menggunakan Konsol Manajemen AWS
1. Masuk ke [konsol Amazon SNS](https://console.aws.amazon.com/sns/home).
1. Di panel navigasi kiri, pilih **Topics (Topik)**.
1. Di halaman **Topics (Topik)**, pilih topik, lalu pilih **Publish message (Terbitkan pesan)**.
Konsol membuka halaman **Publish message to topic (Terbitkan pesan ke topik)**.
1. Di bagian **Message details (Detail pesan)**, lakukan hal berikut:
1. (Opsional) Masukkan **Subjek** pesan.
1. Untuk [topik FIFO](sns-fifo-topics.md), masukkan **ID grup pesan**. **ID grup pesan** diperlukan untuk topik FIFO. Pesan-pesan dalam grup pesan yang sama akan dikirim sesuai urutan yang penerbitannya.
1. (Opsional) Untuk topik standar, masukkan **ID grup Pesan**. ID ini diteruskan ke semua langganan standar Amazon SQS dan tidak digunakan untuk, atau dikirim ke, jenis titik akhir lainnya.
1. Untuk topik FIFO, masukkan **ID deduplikasi pesan**. ID ini bersifat opsional jika Anda mengaktifkan pengaturan **Deduplikasi pesan berbasis konten** untuk topik.
1. (Opsional) Untuk [mobile push notifications (notifikasi push seluler)](sns-ttl.md), masukkan nilai **Waktu untuk tayang (TTL)** dalam detik. Ini adalah jumlah waktu yang dimiliki layanan notifikasi push — seperti Apple Push Notification Service (APNs) atau Firebase Cloud Messaging (FCM) —untuk mengirimkan pesan ke titik akhir.
1. Di bagian **Message body (Isi pesan)**, lakukan salah satu hal berikut:
1. Pilih **Identical payload for all delivery protocols (Muatan identik untuk semua protokol pengiriman)**, lalu masukkan pesan.
1. Pilih **Custom payload for each delivery protocol (Muatan kustom untuk setiap protokol pengiriman)**, lalu masukkan objek JSON untuk menentukan pesan yang akan dikirim untuk setiap protokol pengiriman.
Untuk informasi selengkapnya, lihat [Menerbitkan notifikasi Amazon SNS dengan muatan khusus platform](sns-send-custom-platform-specific-payloads-mobile-devices.md).
1. Di bagian **Message attributes (Atribut pesan)**, tambahkan atribut yang Anda inginkan agar Amazon SNS cocok dengan `FilterPolicy` atribut langganan untuk memutuskan apakah titik akhir langganan tertarik dengan pesan yang diterbitkan.
1. Untuk **Type (Jenis)**, pilih jenis atribut, seperti **String.Array**.
**catatan**
Untuk jenis atribut **String.Array**, lampirkan array dalam tanda kurung siku (`[]`). Dalam array, lampirkan nilai string dalam tanda kutip ganda. Anda tidak memerlukan tanda kutip untuk angka atau kata kunci `true`, `false`, dan `null`.
1. Masukkan atribut **Name (Nama)**, seperti `customer_interests`.
1. Masukkan atribut **Value (Nilai)**, seperti `["soccer", "rugby", "hockey"]`.
Jika jenis atribut adalah **String**, **String.Array**, atau **Number**, Amazon SNS mengevaluasi atribut pesan terhadap kebijakan [filter](sns-message-filtering.md) langganan (jika ada) sebelum mengirim pesan ke cakupan kebijakan filter yang diberikan langganan tidak disetel secara eksplisit. `MessageBody`
Untuk informasi selengkapnya, lihat [Atribut pesan Amazon SNS](sns-message-attributes.md).
1. Pilih **Publish message (Terbitkan pesan)**.
Pesan diterbitkan ke topik, dan konsol membuka halaman **Detail** topik.
## Untuk memublikasikan pesan ke topik menggunakan AWS SDK
Untuk menggunakan AWS SDK, Anda harus mengonfigurasinya dengan kredensi Anda. Untuk informasi selengkapnya, lihat [File konfigurasi dan kredensial bersama](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) di Panduan Referensi *Alat AWS SDKs dan Alat*.
Contoh kode berikut menunjukkan cara menggunakan`Publish`.
------
#### [ .NET ]
**SDK untuk .NET**
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/dotnetv3/SNS#code-examples).
Publikasikan pesan ke topik.
```
using System;
using System.Threading.Tasks;
using Amazon.SimpleNotificationService;
using Amazon.SimpleNotificationService.Model;
///
/// This example publishes a message to an Amazon Simple Notification
/// Service (Amazon SNS) topic.
///
public class PublishToSNSTopic
{
public static async Task Main()
{
string topicArn = "arn:aws:sns:us-east-2:000000000000:ExampleSNSTopic";
string messageText = "This is an example message to publish to the ExampleSNSTopic.";
IAmazonSimpleNotificationService client = new AmazonSimpleNotificationServiceClient();
await PublishToTopicAsync(client, topicArn, messageText);
}
///
/// Publishes a message to an Amazon SNS topic.
///
/// The initialized client object used to publish
/// to the Amazon SNS topic.
/// The ARN of the topic.
/// The text of the message.
public static async Task PublishToTopicAsync(
IAmazonSimpleNotificationService client,
string topicArn,
string messageText)
{
var request = new PublishRequest
{
TopicArn = topicArn,
Message = messageText,
};
var response = await client.PublishAsync(request);
Console.WriteLine($"Successfully published message ID: {response.MessageId}");
}
}
```
Publikasikan pesan ke topik dengan opsi grup, duplikasi, dan atribut.
```
///
/// Publish messages using user settings.
///
/// Async task.
public static async Task PublishMessages()
{
Console.WriteLine("Now we can publish messages.");
var keepSendingMessages = true;
string? deduplicationId = null;
string? toneAttribute = null;
while (keepSendingMessages)
{
Console.WriteLine();
var message = GetUserResponse("Enter a message to publish.", "This is a sample message");
if (_useFifoTopic)
{
Console.WriteLine("Because you are using a FIFO topic, you must set a message group ID." +
"\r\nAll messages within the same group will be received in the order " +
"they were published.");
Console.WriteLine();
var messageGroupId = GetUserResponse("Enter a message group ID for this message:", "1");
if (!_useContentBasedDeduplication)
{
Console.WriteLine("Because you are not using content-based deduplication, " +
"you must enter a deduplication ID.");
Console.WriteLine("Enter a deduplication ID for this message.");
deduplicationId = GetUserResponse("Enter a deduplication ID for this message.", "1");
}
if (GetYesNoResponse("Add an attribute to this message?"))
{
Console.WriteLine("Enter a number for an attribute.");
for (int i = 0; i < _tones.Length; i++)
{
Console.WriteLine($"\t{i + 1}. {_tones[i]}");
}
var selection = GetUserResponse("", "1");
int.TryParse(selection, out var selectionNumber);
if (selectionNumber > 0 && selectionNumber < _tones.Length)
{
toneAttribute = _tones[selectionNumber - 1];
}
}
var messageID = await SnsWrapper.PublishToTopicWithAttribute(
_topicArn, message, "tone", toneAttribute, deduplicationId, messageGroupId);
Console.WriteLine($"Message published with id {messageID}.");
}
keepSendingMessages = GetYesNoResponse("Send another message?", false);
}
}
```
Terapkan pilihan pengguna ke tindakan publikasi.
```
///
/// Publish a message to a topic with an attribute and optional deduplication and group IDs.
///
/// The ARN of the topic.
/// The message to publish.
/// The optional attribute for the message.
/// The optional attribute value for the message.
/// The optional deduplication ID for the message.
/// The optional group ID for the message.
/// The ID of the message published.
public async Task PublishToTopicWithAttribute(
string topicArn,
string message,
string? attributeName = null,
string? attributeValue = null,
string? deduplicationId = null,
string? groupId = null)
{
var publishRequest = new PublishRequest()
{
TopicArn = topicArn,
Message = message,
MessageDeduplicationId = deduplicationId,
MessageGroupId = groupId
};
if (attributeValue != null)
{
// Add the string attribute if it exists.
publishRequest.MessageAttributes =
new Dictionary
{
{ attributeName!, new MessageAttributeValue() { StringValue = attributeValue, DataType = "String"} }
};
}
var publishResponse = await _amazonSNSClient.PublishAsync(publishRequest);
return publishResponse.MessageId;
}
```
+ Untuk detail API, lihat [Publikasikan](https://docs.aws.amazon.com/goto/DotNetSDKV3/sns-2010-03-31/Publish) di *Referensi AWS SDK untuk .NET API*.
------
#### [ C\$1\$1 ]
**SDK untuk C\$1\$1**
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/cpp/example_code/sns#code-examples).
```
//! Send a message to an Amazon Simple Notification Service (Amazon SNS) topic.
/*!
\param message: The message to publish.
\param topicARN: The Amazon Resource Name (ARN) for an Amazon SNS topic.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::SNS::publishToTopic(const Aws::String &message,
const Aws::String &topicARN,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SNS::SNSClient snsClient(clientConfiguration);
Aws::SNS::Model::PublishRequest request;
request.SetMessage(message);
request.SetTopicArn(topicARN);
const Aws::SNS::Model::PublishOutcome outcome = snsClient.Publish(request);
if (outcome.IsSuccess()) {
std::cout << "Message published successfully with id '"
<< outcome.GetResult().GetMessageId() << "'." << std::endl;
}
else {
std::cerr << "Error while publishing message "
<< outcome.GetError().GetMessage()
<< std::endl;
}
return outcome.IsSuccess();
}
```
Publikasikan pesan dengan atribut.
```
static const Aws::String TONE_ATTRIBUTE("tone");
static const Aws::Vector TONES = {"cheerful", "funny", "serious",
"sincere"};
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
Aws::SNS::SNSClient snsClient(clientConfiguration);
Aws::SNS::Model::PublishRequest request;
request.SetTopicArn(topicARN);
Aws::String message = askQuestion("Enter a message text to publish. ");
request.SetMessage(message);
if (filteringMessages && askYesNoQuestion(
"Add an attribute to this message? (y/n) ")) {
for (size_t i = 0; i < TONES.size(); ++i) {
std::cout << " " << (i + 1) << ". " << TONES[i] << std::endl;
}
int selection = askQuestionForIntRange(
"Enter a number for an attribute. ",
1, static_cast(TONES.size()));
Aws::SNS::Model::MessageAttributeValue messageAttributeValue;
messageAttributeValue.SetDataType("String");
messageAttributeValue.SetStringValue(TONES[selection - 1]);
request.AddMessageAttributes(TONE_ATTRIBUTE, messageAttributeValue);
}
Aws::SNS::Model::PublishOutcome outcome = snsClient.Publish(request);
if (outcome.IsSuccess()) {
std::cout << "Your message was successfully published." << std::endl;
}
else {
std::cerr << "Error with TopicsAndQueues::Publish. "
<< outcome.GetError().GetMessage()
<< std::endl;
cleanUp(topicARN,
queueURLS,
subscriptionARNS,
snsClient,
sqsClient);
return false;
}
```
+ Untuk detail API, lihat [Publikasikan](https://docs.aws.amazon.com/goto/SdkForCpp/sns-2010-03-31/Publish) di *Referensi AWS SDK untuk C\$1\$1 API*.
------
#### [ CLI ]
**AWS CLI**
**Contoh 1: Untuk mempublikasikan pesan ke topik**
`publish`Contoh berikut menerbitkan pesan yang ditentukan ke topik SNS yang ditentukan. Pesan berasal dari file teks, yang memungkinkan Anda untuk memasukkan jeda baris.
```
aws sns publish \
--topic-arn "arn:aws:sns:us-west-2:123456789012:my-topic" \
--message file://message.txt
```
Isi dari `message.txt`:
```
Hello World
Second Line
```
Output:
```
{
"MessageId": "123a45b6-7890-12c3-45d6-111122223333"
}
```
**Contoh 2: Untuk mempublikasikan pesan SMS ke nomor telepon**
`publish`Contoh berikut menerbitkan pesan `Hello world!` ke nomor `+1-555-555-0100` telepon.
```
aws sns publish \
--message "Hello world!" \
--phone-number +1-555-555-0100
```
Output:
```
{
"MessageId": "123a45b6-7890-12c3-45d6-333322221111"
}
```
+ Untuk detail API, lihat [Menerbitkan](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sns/publish.html) di *Referensi AWS CLI Perintah*.
------
#### [ Go ]
**SDK untuk Go V2**
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/gov2/workflows/topics_and_queues#code-examples).
```
import (
"context"
"encoding/json"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/sns"
"github.com/aws/aws-sdk-go-v2/service/sns/types"
)
// SnsActions encapsulates the Amazon Simple Notification Service (Amazon SNS) actions
// used in the examples.
type SnsActions struct {
SnsClient *sns.Client
}
// Publish publishes a message to an Amazon SNS topic. The message is then sent to all
// subscribers. When the topic is a FIFO topic, the message must also contain a group ID
// and, when ID-based deduplication is used, a deduplication ID. An optional key-value
// filter attribute can be specified so that the message can be filtered according to
// a filter policy.
func (actor SnsActions) Publish(ctx context.Context, topicArn string, message string, groupId string, dedupId string, filterKey string, filterValue string) error {
publishInput := sns.PublishInput{TopicArn: aws.String(topicArn), Message: aws.String(message)}
if groupId != "" {
publishInput.MessageGroupId = aws.String(groupId)
}
if dedupId != "" {
publishInput.MessageDeduplicationId = aws.String(dedupId)
}
if filterKey != "" && filterValue != "" {
publishInput.MessageAttributes = map[string]types.MessageAttributeValue{
filterKey: {DataType: aws.String("String"), StringValue: aws.String(filterValue)},
}
}
_, err := actor.SnsClient.Publish(ctx, &publishInput)
if err != nil {
log.Printf("Couldn't publish message to topic %v. Here's why: %v", topicArn, err)
}
return err
}
```
+ Untuk detail API, lihat [Publikasikan](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sns#Client.Publish) di *Referensi AWS SDK untuk Go API*.
------
#### [ 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.PublishRequest;
import software.amazon.awssdk.services.sns.model.PublishResponse;
import software.amazon.awssdk.services.sns.model.SnsException;
/**
* 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 PublishTopic {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
message - The message text to send.
topicArn - The ARN of the topic to publish.
""";
if (args.length != 2) {
System.out.println(usage);
System.exit(1);
}
String message = args[0];
String topicArn = args[1];
SnsClient snsClient = SnsClient.builder()
.region(Region.US_EAST_1)
.build();
pubTopic(snsClient, message, topicArn);
snsClient.close();
}
public static void pubTopic(SnsClient snsClient, String message, String topicArn) {
try {
PublishRequest request = PublishRequest.builder()
.message(message)
.topicArn(topicArn)
.build();
PublishResponse result = snsClient.publish(request);
System.out
.println(result.messageId() + " Message sent. Status is " + result.sdkHttpResponse().statusCode());
} catch (SnsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ Untuk detail API, lihat [Publikasikan](https://docs.aws.amazon.com/goto/SdkForJavaV2/sns-2010-03-31/Publish) di *Referensi AWS SDK for Java 2.x API*.
------
#### [ JavaScript ]
**SDK untuk JavaScript (v3)**
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/javascriptv3/example_code/sns#code-examples).
Buat klien dalam modul terpisah dan ekspor klien tersebut.
```
import { SNSClient } from "@aws-sdk/client-sns";
// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```
Mengimpor modul SDK dan klien dan memanggil API.
```
import { PublishCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";
/**
* @param {string | Record} message - The message to send. Can be a plain string or an object
* if you are using the `json` `MessageStructure`.
* @param {string} topicArn - The ARN of the topic to which you would like to publish.
*/
export const publish = async (
message = "Hello from SNS!",
topicArn = "TOPIC_ARN",
) => {
const response = await snsClient.send(
new PublishCommand({
Message: message,
TopicArn: topicArn,
}),
);
console.log(response);
// {
// '$metadata': {
// httpStatusCode: 200,
// requestId: 'e7f77526-e295-5325-9ee4-281a43ad1f05',
// extendedRequestId: undefined,
// cfId: undefined,
// attempts: 1,
// totalRetryDelay: 0
// },
// MessageId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
// }
return response;
};
```
Publikasikan pesan ke topik dengan opsi grup, duplikasi, dan atribut.
```
async publishMessages() {
const message = await this.prompter.input({
message: MESSAGES.publishMessagePrompt,
});
let groupId;
let deduplicationId;
let choices;
if (this.isFifo) {
await this.logger.log(MESSAGES.groupIdNotice);
groupId = await this.prompter.input({
message: MESSAGES.groupIdPrompt,
});
if (this.autoDedup === false) {
await this.logger.log(MESSAGES.deduplicationIdNotice);
deduplicationId = await this.prompter.input({
message: MESSAGES.deduplicationIdPrompt,
});
}
choices = await this.prompter.checkbox({
message: MESSAGES.messageAttributesPrompt,
choices: toneChoices,
});
}
await this.snsClient.send(
new PublishCommand({
TopicArn: this.topicArn,
Message: message,
...(groupId
? {
MessageGroupId: groupId,
}
: {}),
...(deduplicationId
? {
MessageDeduplicationId: deduplicationId,
}
: {}),
...(choices
? {
MessageAttributes: {
tone: {
DataType: "String.Array",
StringValue: JSON.stringify(choices),
},
},
}
: {}),
}),
);
const publishAnother = await this.prompter.confirm({
message: MESSAGES.publishAnother,
});
if (publishAnother) {
await this.publishMessages();
}
}
```
+ Untuk informasi selengkapnya, silakan lihat [Panduan Developer AWS SDK untuk JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sns-examples-publishing-messages.html).
+ Untuk detail API, lihat [Publikasikan](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sns/command/PublishCommand) di *Referensi AWS SDK untuk JavaScript API*.
------
#### [ Kotlin ]
**SDK untuk Kotlin**
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/kotlin/services/sns#code-examples).
```
suspend fun pubTopic(
topicArnVal: String,
messageVal: String,
) {
val request =
PublishRequest {
message = messageVal
topicArn = topicArnVal
}
SnsClient.fromEnvironment { region = "us-east-1" }.use { snsClient ->
val result = snsClient.publish(request)
println("${result.messageId} message sent.")
}
}
```
+ Untuk detail API, lihat [Menerbitkan](https://sdk.amazonaws.com/kotlin/api/latest/index.html) di *AWS SDK untuk referensi API Kotlin*.
------
#### [ PHP ]
**SDK untuk PHP**
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/php/example_code/sns#code-examples).
```
require 'vendor/autoload.php';
use Aws\Exception\AwsException;
use Aws\Sns\SnsClient;
/**
* Sends a message to an Amazon SNS topic.
*
* This code expects that you have AWS credentials set up per:
* https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/guide_credentials.html
*/
$SnSclient = new SnsClient([
'profile' => 'default',
'region' => 'us-east-1',
'version' => '2010-03-31'
]);
$message = 'This message is sent from a Amazon SNS code sample.';
$topic = 'arn:aws:sns:us-east-1:111122223333:MyTopic';
try {
$result = $SnSclient->publish([
'Message' => $message,
'TopicArn' => $topic,
]);
var_dump($result);
} catch (AwsException $e) {
// output error message if fails
error_log($e->getMessage());
}
```
+ Untuk informasi selengkapnya, silakan lihat [Panduan Developer AWS SDK untuk PHP](https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/sns-examples-subscribing-unsubscribing-topics.html#publish-a-message-to-an-sns-topic).
+ Untuk detail API, lihat [Publikasikan](https://docs.aws.amazon.com/goto/SdkForPHPV3/sns-2010-03-31/Publish) di *Referensi AWS SDK untuk PHP API*.
------
#### [ PowerShell ]
**Alat untuk PowerShell V4**
**Contoh 1: Contoh ini menunjukkan penerbitan pesan dengan satu baris yang MessageAttribute dideklarasikan.**
```
Publish-SNSMessage -TopicArn "arn:aws:sns:us-west-2:123456789012:my-topic" -Message "Hello" -MessageAttribute @{'City'=[Amazon.SimpleNotificationService.Model.MessageAttributeValue]@{DataType='String'; StringValue ='AnyCity'}}
```
**Contoh 2: Contoh ini menunjukkan penerbitan pesan dengan beberapa MessageAttributes dideklarasikan sebelumnya.**
```
$cityAttributeValue = New-Object Amazon.SimpleNotificationService.Model.MessageAttributeValue
$cityAttributeValue.DataType = "String"
$cityAttributeValue.StringValue = "AnyCity"
$populationAttributeValue = New-Object Amazon.SimpleNotificationService.Model.MessageAttributeValue
$populationAttributeValue.DataType = "Number"
$populationAttributeValue.StringValue = "1250800"
$messageAttributes = New-Object System.Collections.Hashtable
$messageAttributes.Add("City", $cityAttributeValue)
$messageAttributes.Add("Population", $populationAttributeValue)
Publish-SNSMessage -TopicArn "arn:aws:sns:us-west-2:123456789012:my-topic" -Message "Hello" -MessageAttribute $messageAttributes
```
+ Untuk detail API, lihat [Menerbitkan](https://docs.aws.amazon.com/powershell/v4/reference) di *Referensi Alat AWS untuk PowerShell Cmdlet (V4)*.
**Alat untuk PowerShell V5**
**Contoh 1: Contoh ini menunjukkan penerbitan pesan dengan satu baris yang MessageAttribute dideklarasikan.**
```
Publish-SNSMessage -TopicArn "arn:aws:sns:us-west-2:123456789012:my-topic" -Message "Hello" -MessageAttribute @{'City'=[Amazon.SimpleNotificationService.Model.MessageAttributeValue]@{DataType='String'; StringValue ='AnyCity'}}
```
**Contoh 2: Contoh ini menunjukkan penerbitan pesan dengan beberapa MessageAttributes dideklarasikan sebelumnya.**
```
$cityAttributeValue = New-Object Amazon.SimpleNotificationService.Model.MessageAttributeValue
$cityAttributeValue.DataType = "String"
$cityAttributeValue.StringValue = "AnyCity"
$populationAttributeValue = New-Object Amazon.SimpleNotificationService.Model.MessageAttributeValue
$populationAttributeValue.DataType = "Number"
$populationAttributeValue.StringValue = "1250800"
$messageAttributes = New-Object System.Collections.Hashtable
$messageAttributes.Add("City", $cityAttributeValue)
$messageAttributes.Add("Population", $populationAttributeValue)
Publish-SNSMessage -TopicArn "arn:aws:sns:us-west-2:123456789012:my-topic" -Message "Hello" -MessageAttribute $messageAttributes
```
+ Untuk detail API, lihat [Menerbitkan](https://docs.aws.amazon.com/powershell/v5/reference) di *Referensi Alat AWS untuk PowerShell Cmdlet (V5)*.
------
#### [ 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).
Publikasikan pesan dengan atribut sehingga langganan dapat memfilter berdasarkan atribut.
```
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 publish_message(topic, message, attributes):
"""
Publishes a message, with attributes, to a topic. Subscriptions can be filtered
based on message attributes so that a subscription receives messages only
when specified attributes are present.
:param topic: The topic to publish to.
:param message: The message to publish.
:param attributes: The key-value attributes to attach to the message. Values
must be either `str` or `bytes`.
:return: The ID of the message.
"""
try:
att_dict = {}
for key, value in attributes.items():
if isinstance(value, str):
att_dict[key] = {"DataType": "String", "StringValue": value}
elif isinstance(value, bytes):
att_dict[key] = {"DataType": "Binary", "BinaryValue": value}
response = topic.publish(Message=message, MessageAttributes=att_dict)
message_id = response["MessageId"]
logger.info(
"Published message with attributes %s to topic %s.",
attributes,
topic.arn,
)
except ClientError:
logger.exception("Couldn't publish message to topic %s.", topic.arn)
raise
else:
return message_id
```
Publikasikan pesan yang mengambil bentuk berbeda berdasarkan protokol pelanggan.
```
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 publish_multi_message(
topic, subject, default_message, sms_message, email_message
):
"""
Publishes a multi-format message to a topic. A multi-format message takes
different forms based on the protocol of the subscriber. For example,
an SMS subscriber might receive a short version of the message
while an email subscriber could receive a longer version.
:param topic: The topic to publish to.
:param subject: The subject of the message.
:param default_message: The default version of the message. This version is
sent to subscribers that have protocols that are not
otherwise specified in the structured message.
:param sms_message: The version of the message sent to SMS subscribers.
:param email_message: The version of the message sent to email subscribers.
:return: The ID of the message.
"""
try:
message = {
"default": default_message,
"sms": sms_message,
"email": email_message,
}
response = topic.publish(
Message=json.dumps(message), Subject=subject, MessageStructure="json"
)
message_id = response["MessageId"]
logger.info("Published multi-format message to topic %s.", topic.arn)
except ClientError:
logger.exception("Couldn't publish message to topic %s.", topic.arn)
raise
else:
return message_id
```
```
class SnsWrapper:
"""Wrapper class for managing Amazon SNS operations."""
def __init__(self, sns_client: Any) -> None:
"""
Initialize the SnsWrapper.
:param sns_client: A Boto3 Amazon SNS client.
"""
self.sns_client = sns_client
@classmethod
def from_client(cls) -> 'SnsWrapper':
"""
Create an SnsWrapper instance using a default boto3 client.
:return: An instance of this class.
"""
sns_client = boto3.client('sns')
return cls(sns_client)
def publish_message(
self,
topic_arn: str,
message: str,
tone_attribute: Optional[str] = None,
deduplication_id: Optional[str] = None,
message_group_id: Optional[str] = None
) -> str:
"""
Publish a message to an SNS topic.
:param topic_arn: The ARN of the SNS topic.
:param message: The message content to publish.
:param tone_attribute: Optional tone attribute for message filtering.
:param deduplication_id: Optional deduplication ID for FIFO topics.
:param message_group_id: Optional message group ID for FIFO topics.
:return: The message ID of the published message.
:raises ClientError: If the message publication fails.
"""
try:
publish_args = {
'TopicArn': topic_arn,
'Message': message
}
# Add message attributes if tone is specified
if tone_attribute:
publish_args['MessageAttributes'] = {
'tone': {
'DataType': 'String',
'StringValue': tone_attribute
}
}
# Add FIFO-specific parameters
if message_group_id:
publish_args['MessageGroupId'] = message_group_id
if deduplication_id:
publish_args['MessageDeduplicationId'] = deduplication_id
response = self.sns_client.publish(**publish_args)
message_id = response['MessageId']
logger.info(f"Published message to topic {topic_arn} with ID: {message_id}")
return message_id
except ClientError as e:
error_code = e.response.get('Error', {}).get('Code', 'Unknown')
logger.error(f"Error publishing message to topic: {error_code} - {e}")
raise
```
+ Untuk detail API, lihat [Menerbitkan](https://docs.aws.amazon.com/goto/boto3/sns-2010-03-31/Publish) di *AWS SDK for Python (Boto3) Referensi* API.
------
#### [ Ruby ]
**SDK untuk Ruby**
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/ruby/example_code/sns#code-examples).
```
# Service class for sending messages using Amazon Simple Notification Service (SNS)
class SnsMessageSender
# Initializes the SnsMessageSender with an SNS client
#
# @param sns_client [Aws::SNS::Client] The SNS client
def initialize(sns_client)
@sns_client = sns_client
@logger = Logger.new($stdout)
end
# Sends a message to a specified SNS topic
#
# @param topic_arn [String] The ARN of the SNS topic
# @param message [String] The message to send
# @return [Boolean] true if message was successfully sent, false otherwise
def send_message(topic_arn, message)
@sns_client.publish(topic_arn: topic_arn, message: message)
@logger.info("Message sent successfully to #{topic_arn}.")
true
rescue Aws::SNS::Errors::ServiceError => e
@logger.error("Error while sending the message: #{e.message}")
false
end
end
# Example usage:
if $PROGRAM_NAME == __FILE__
topic_arn = 'SNS_TOPIC_ARN' # Should be replaced with a real topic ARN
message = 'MESSAGE' # Should be replaced with the actual message content
sns_client = Aws::SNS::Client.new
message_sender = SnsMessageSender.new(sns_client)
@logger.info('Sending message.')
unless message_sender.send_message(topic_arn, message)
@logger.error('Message sending failed. Stopping program.')
exit 1
end
end
```
+ Untuk informasi selengkapnya, silakan lihat [Panduan Developer AWS SDK untuk Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/sns-example-send-message.html).
+ Untuk detail API, lihat [Publikasikan](https://docs.aws.amazon.com/goto/SdkForRubyV3/sns-2010-03-31/Publish) di *Referensi AWS SDK untuk Ruby API*.
------
#### [ Rust ]
**SDK for Rust**
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/rustv1/examples/sns#code-examples).
```
async fn subscribe_and_publish(
client: &Client,
topic_arn: &str,
email_address: &str,
) -> Result<(), Error> {
println!("Receiving on topic with ARN: `{}`", topic_arn);
let rsp = client
.subscribe()
.topic_arn(topic_arn)
.protocol("email")
.endpoint(email_address)
.send()
.await?;
println!("Added a subscription: {:?}", rsp);
let rsp = client
.publish()
.topic_arn(topic_arn)
.message("hello sns!")
.send()
.await?;
println!("Published message: {:?}", rsp);
Ok(())
}
```
+ Untuk detail API, lihat [Menerbitkan](https://docs.rs/aws-sdk-sns/latest/aws_sdk_sns/client/struct.Client.html#method.publish) di *AWS SDK untuk referensi API Rust*.
------
#### [ 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.
oo_result = lo_sns->publish( " oo_result is returned for testing purposes. "
iv_topicarn = iv_topic_arn
iv_message = iv_message ).
MESSAGE 'Message published to SNS topic.' TYPE 'I'.
CATCH /aws1/cx_snsnotfoundexception.
MESSAGE 'Topic does not exist.' TYPE 'E'.
ENDTRY.
```
Publikasikan pesan dengan atribut ke topik.
```
TRY.
oo_result = lo_sns->publish( " oo_result is returned for testing purposes. "
iv_topicarn = iv_topic_arn
iv_message = iv_message
it_messageattributes = it_msg_attrs ).
MESSAGE 'Message with attributes published to SNS topic.' TYPE 'I'.
CATCH /aws1/cx_snsnotfoundexception.
MESSAGE 'Topic does not exist.' TYPE 'E'.
ENDTRY.
```
Publikasikan pesan multi-format ke suatu topik.
```
" Build JSON message structure for multi-format message
DATA(lv_json_message) = |\{ "default": "{ iv_default_message }", "sms": "{ iv_sms_message }", "email": "{ iv_email_message }" \}|.
TRY.
oo_result = lo_sns->publish( " oo_result is returned for testing purposes. "
iv_topicarn = iv_topic_arn
iv_message = lv_json_message
iv_subject = iv_subject
iv_messagestructure = 'json' ).
MESSAGE 'Multi-format message published to SNS topic.' TYPE 'I'.
CATCH /aws1/cx_snsnotfoundexception.
MESSAGE 'Topic does not exist.' TYPE 'E'.
ENDTRY.
```
+ Untuk detail API, lihat [Publikasikan](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) di *AWS SDK untuk referensi API SAP ABAP*.
------
#### [ Swift ]
**SDK para Swift**
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/swift/example_code/sns#code-examples).
```
import AWSSNS
let config = try await SNSClient.SNSClientConfiguration(region: region)
let snsClient = SNSClient(config: config)
let output = try await snsClient.publish(
input: PublishInput(
message: message,
topicArn: arn
)
)
guard let messageId = output.messageId else {
print("No message ID received from Amazon SNS.")
return
}
print("Published message with ID \(messageId)")
```
+ Untuk detail API, lihat [Menerbitkan](https://sdk.amazonaws.com/swift/api/awssns/latest/documentation/awssns/snsclient/publish(input:)) di *AWS SDK untuk referensi Swift API*.
------
# Penerbitan pesan large dengan Amazon SNS dan Amazon S3
Untuk mempublikasikan pesan Amazon SNS yang besar, Anda dapat menggunakan Amazon [SNS Extended Client Library for Java, atau [Amazon SNS](https://github.com/awslabs/amazon-sns-python-extended-client-lib) Extended Client Library untuk](https://github.com/awslabs/amazon-sns-java-extended-client-lib/) Python. Pustaka ini berguna untuk pesan yang lebih besar dari maksimum 256 KB saat ini, dengan maksimum 2 GB. Kedua pustaka menyimpan muatan aktual ke bucket Amazon S3, dan mempublikasikan referensi objek Amazon S3 yang disimpan ke topik Amazon SNS. Berlangganan Amazon SQS antrian dapat menggunakan [Amazon SQS Extended Client Library for Java](https://github.com/awslabs/amazon-sqs-java-extended-client-lib) untuk menghilangkan referensi dan mengambil muatan dari Amazon S3. Endpoint lain seperti Lambda dapat menggunakan [Payload Offloading Java Common Library AWS](https://github.com/awslabs/payload-offloading-java-common-lib-for-aws) untuk de-referensi dan mengambil payload.
**catatan**
Amazon SNS Extended Client Libraries kompatibel dengan topik standar dan FIFO.
# Amazon SNS Extended Client Library untuk Java
## Prasyarat
Berikut ini adalah prasyarat untuk menggunakan [Amazon SNS Extended Client Library for Java](https://github.com/awslabs/amazon-sns-java-extended-client-lib):
+ Sebuah AWS SDK. Contoh pada halaman ini menggunakan AWS Java SDK. Untuk menginstal dan menyiapkan SDK, lihat [Mengatur AWS SDK for](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-install.html) Java di Panduan *AWS SDK untuk Java Pengembang*.
+ An Akun AWS dengan kredensi yang tepat. Untuk membuat Akun AWS, navigasikan ke [AWS halaman](https://aws.amazon.com/) beranda, lalu pilih **Buat AWS Akun**. Ikuti petunjuk online.
*Untuk informasi tentang kredensional, lihat [Menyiapkan AWS Kredensial dan Wilayah untuk Pengembangan](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-credentials.html) di Panduan Pengembang.AWS SDK untuk Java *
+ Java 8 atau lebih baik.
+ Amazon SNS Extended Client Library untuk Java (juga tersedia dari [Maven](https://maven.apache.org/)).
## Mengkonfigurasi penyimpanan pesan
Library Amazon SNS Extended Client menggunakan Payload Offloading Java Common Library AWS untuk penyimpanan dan pengambilan pesan. Anda dapat mengkonfigurasi Amazon S3 berikut [opsi penyimpanan pesan](https://github.com/awslabs/amazon-sns-java-extended-client-lib/blob/main/src/main/java/software/amazon/sns/SNSExtendedClientConfiguration.java):
+ **Ambang batas ukuran pesan khusus** - Pesan dengan muatan dan atribut yang melebihi ukuran ini disimpan secara otomatis di Amazon S3.
+ **`alwaysThroughS3`flag** - Tetapkan nilai ini `true` untuk memaksa semua muatan pesan disimpan di Amazon S3. Sebagai contoh:
```
SNSExtendedClientConfiguration snsExtendedClientConfiguration = new
SNSExtendedClientConfiguration() .withPayloadSupportEnabled(s3Client, BUCKET_NAME).withAlwaysThroughS3(true);
```
+ Kunci **KMS kustom — Kunci** yang digunakan untuk enkripsi sisi server di bucket Amazon S3 Anda.
+ **Nama bucket** — Nama bucket Amazon S3 untuk menyimpan muatan pesan.
## Contoh: Penerbitan pesan ke Amazon SNS dengan muatan yang disimpan di Amazon S3
Contoh kode berikut ini menunjukkan cara untuk melakukan:
+ Buat contoh topik dan antrean.
+ Berlangganan antrean untuk menerima pesan dari topik.
+ Publikasikan pesan percobaan.
Muatan pesan disimpan di Amazon S3 dan referensi untuk diterbitkan. Amazon SQS Extended Client digunakan untuk menerima pesan.
**SDK for Java 1.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/java/example_code/sns#code-examples).
Untuk mempublikasikan pesan besar, gunakan Amazon SNS Extended Client Library for Java. Pesan yang Anda kirim mereferensikan objek Amazon S3 yang berisi konten pesan yang sebenarnya.
```
import com.amazon.sqs.javamessaging.AmazonSQSExtendedClient;
import com.amazon.sqs.javamessaging.ExtendedClientConfiguration;
import com.amazonaws.regions.Region;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.sns.AmazonSNS;
import com.amazonaws.services.sns.AmazonSNSClientBuilder;
import com.amazonaws.services.sns.model.CreateTopicRequest;
import com.amazonaws.services.sns.model.PublishRequest;
import com.amazonaws.services.sns.model.SetSubscriptionAttributesRequest;
import com.amazonaws.services.sns.util.Topics;
import com.amazonaws.services.sqs.AmazonSQS;
import com.amazonaws.services.sqs.AmazonSQSClientBuilder;
import com.amazonaws.services.sqs.model.CreateQueueRequest;
import com.amazonaws.services.sqs.model.ReceiveMessageResult;
import software.amazon.sns.AmazonSNSExtendedClient;
import software.amazon.sns.SNSExtendedClientConfiguration;
public class Example {
public static void main(String[] args) {
final String BUCKET_NAME = "extended-client-bucket";
final String TOPIC_NAME = "extended-client-topic";
final String QUEUE_NAME = "extended-client-queue";
final Regions region = Regions.DEFAULT_REGION;
// Message threshold controls the maximum message size that will be allowed to
// be published
// through SNS using the extended client. Payload of messages exceeding this
// value will be stored in
// S3. The default value of this parameter is 256 KB which is the maximum
// message size in SNS (and SQS).
final int EXTENDED_STORAGE_MESSAGE_SIZE_THRESHOLD = 32;
// Initialize SNS, SQS and S3 clients
final AmazonSNS snsClient = AmazonSNSClientBuilder.standard().withRegion(region).build();
final AmazonSQS sqsClient = AmazonSQSClientBuilder.standard().withRegion(region).build();
final AmazonS3 s3Client = AmazonS3ClientBuilder.standard().withRegion(region).build();
// Create bucket, topic, queue and subscription
s3Client.createBucket(BUCKET_NAME);
final String topicArn = snsClient.createTopic(
new CreateTopicRequest().withName(TOPIC_NAME)).getTopicArn();
final String queueUrl = sqsClient.createQueue(
new CreateQueueRequest().withQueueName(QUEUE_NAME)).getQueueUrl();
final String subscriptionArn = Topics.subscribeQueue(
snsClient, sqsClient, topicArn, queueUrl);
// To read message content stored in S3 transparently through SQS extended
// client,
// set the RawMessageDelivery subscription attribute to TRUE
final SetSubscriptionAttributesRequest subscriptionAttributesRequest = new SetSubscriptionAttributesRequest();
subscriptionAttributesRequest.setSubscriptionArn(subscriptionArn);
subscriptionAttributesRequest.setAttributeName("RawMessageDelivery");
subscriptionAttributesRequest.setAttributeValue("TRUE");
snsClient.setSubscriptionAttributes(subscriptionAttributesRequest);
// Initialize SNS extended client
// PayloadSizeThreshold triggers message content storage in S3 when the
// threshold is exceeded
// To store all messages content in S3, use AlwaysThroughS3 flag
final SNSExtendedClientConfiguration snsExtendedClientConfiguration = new SNSExtendedClientConfiguration()
.withPayloadSupportEnabled(s3Client, BUCKET_NAME)
.withPayloadSizeThreshold(EXTENDED_STORAGE_MESSAGE_SIZE_THRESHOLD);
final AmazonSNSExtendedClient snsExtendedClient = new AmazonSNSExtendedClient(snsClient,
snsExtendedClientConfiguration);
// Publish message via SNS with storage in S3
final String message = "This message is stored in S3 as it exceeds the threshold of 32 bytes set above.";
snsExtendedClient.publish(topicArn, message);
// Initialize SQS extended client
final ExtendedClientConfiguration sqsExtendedClientConfiguration = new ExtendedClientConfiguration()
.withPayloadSupportEnabled(s3Client, BUCKET_NAME);
final AmazonSQSExtendedClient sqsExtendedClient = new AmazonSQSExtendedClient(sqsClient,
sqsExtendedClientConfiguration);
// Read the message from the queue
final ReceiveMessageResult result = sqsExtendedClient.receiveMessage(queueUrl);
System.out.println("Received message is " + result.getMessages().get(0).getBody());
}
}
```
## Protokol titik akhir lainnya
Kedua perpustakaan Amazon SNS dan Amazon SQS menggunakan [Muatan Pembongkar Java Common Library untuk AWS](https://github.com/awslabs/payload-offloading-java-common-lib-for-aws) untuk menyimpan dan mengambil muatan pesan dengan Amazon S3. Titik akhir Java diaktifkan (misalnya, titik akhir HTTPS yang diterapkan di Java) dapat menggunakan perpustakaan yang sama untuk menghilangkan referensi isi pesan.
Titik akhir yang tidak dapat menggunakan Payload Offloading Java Common Library untuk masih AWS dapat mempublikasikan pesan dengan muatan yang disimpan di Amazon S3. Berikut ini adalah contoh dari referensi Amazon S3 yang diterbitkan oleh contoh kode di atas:
```
[
"software.amazon.payloadoffloading.PayloadS3Pointer",
{
"s3BucketName": "extended-client-bucket",
"s3Key": "xxxx-xxxxx-xxxxx-xxxxxx"
}
]
```
# Perpustakaan Klien Diperpanjang Amazon SNS untuk Python
## Prasyarat
Berikut ini adalah prasyarat untuk menggunakan [Amazon SNS Extended](https://github.com/awslabs/amazon-sns-python-extended-client-lib) Client Library untuk Python:
+ Sebuah AWS SDK. Contoh pada halaman ini menggunakan AWS Python SDK Boto3. Untuk menginstal dan mengatur SDK, lihat dokumentasi [https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html).
+ An Akun AWS dengan kredensi yang tepat. Untuk membuat Akun AWS, navigasikan ke [AWS halaman](https://aws.amazon.com/) beranda, lalu pilih **Buat AWS Akun**. Ikuti petunjuk online.
Untuk informasi tentang kredensional, lihat [Kredensial](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) di SDK *AWS for* Python Developer Guide.
+ Python 3.x (atau yang lebih baru) dan pip.
+ [Amazon SNS Extended Client Library untuk Python (juga tersedia dari PyPI).](https://pypi.org/project/amazon-sns-extended-client/)
## Mengkonfigurasi penyimpanan pesan
Atribut di bawah ini tersedia di Klien[, Topik, [PlatformEndpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns/platformendpoint/index.html)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns/topic/index.html)dan objek Amazon [SNS](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns.html#client) Boto3 untuk mengonfigurasi opsi penyimpanan pesan Amazon S3.
+ **`large_payload_support`**- Nama bucket Amazon S3 yang akan menyimpan pesan besar.
+ **`use_legacy_attribute`**— Jika`True`, maka semua pesan yang diterbitkan menggunakan atribut pesan cadangan Legacy (`SQSLargePayloadSize`) alih-alih atribut pesan cadangan saat ini (`ExtendedPayloadSize`).
+ **`message_size_threshold`**— Ambang batas untuk menyimpan pesan di ember pesan besar. Tidak boleh kurang dari`0`, atau lebih besar dari`262144`. Nilai default-nya `262144`.
+ **`always_through_s3`**— Jika`True`, maka semua pesan disimpan di Amazon S3. Nilai default-nya `False`.
+ **`s3_client`**— Objek Boto3 Amazon `client` S3 yang digunakan untuk menyimpan objek ke Amazon S3. Gunakan ini jika Anda ingin mengontrol klien Amazon S3 (misalnya, konfigurasi atau kredenal Amazon S3 kustom). Default `boto3.client("s3")` pada penggunaan pertama jika tidak disetel sebelumnya.
## Contoh: Menerbitkan pesan ke Amazon SNS dengan muatan yang disimpan di Amazon S3
Contoh kode berikut ini menunjukkan cara untuk melakukan:
+ Buat contoh topik Amazon SNS dan antrean Amazon SQS.
+ Lampirkan kebijakan ke antrean Amazon SQS untuk menerima pesan dari topik Amazon SNS.
+ Berlangganan antrean untuk menerima pesan dari topik.
+ Publikasikan pesan pengujian menggunakan klien yang diperluas Amazon SNS, sumber daya Topik, dan PlatformEndpoint sumber daya.
+ Payload pesan disimpan di Amazon S3, dan referensi untuk itu diterbitkan.
+ Cetak pesan yang diterbitkan dari antrian bersama dengan pesan asli yang diambil dari Amazon S3.
Untuk mempublikasikan pesan besar, gunakan Amazon SNS Extended Client Library untuk Python. Pesan yang Anda kirim mereferensikan objek Amazon S3 yang berisi konten pesan yang sebenarnya.
```
import boto3
from sns_extended_client import SNSExtendedClientSession
from json import loads
s3_extended_payload_bucket = "extended-client-bucket-store" # S3 bucket with the given bucket name is a resource which is created and accessible with the given AWS credentials
TOPIC_NAME = "---TOPIC-NAME---"
QUEUE_NAME = "---QUEUE-NAME---"
def allow_sns_to_write_to_sqs(topicarn, queuearn):
policy_document = """{{
"Version": "2012-10-17",
"Statement":[
{{
"Sid":"MyPolicy",
"Effect":"Allow",
"Principal" : {{"AWS" : "*"}},
"Action":"SQS:SendMessage",
"Resource": "{}",
"Condition":{{
"ArnEquals":{{
"aws:SourceArn": "{}"
}}
}}
}}
]
}}""".format(queuearn, topicarn)
return policy_document
def get_msg_from_s3(body,sns_extended_client):
"""Handy Helper to fetch message from S3"""
json_msg = loads(body)
s3_object = sns_extended_client.s3_client.get_object(
Bucket=json_msg[1].get("s3BucketName"), Key=json_msg[1].get("s3Key")
)
msg = s3_object.get("Body").read().decode()
return msg
def fetch_and_print_from_sqs(sqs, queue_url,sns_extended_client):
sqs_msg = sqs.receive_message(
QueueUrl=queue_url,
AttributeNames=['All'],
MessageAttributeNames=['All'],
VisibilityTimeout=0,
WaitTimeSeconds=0,
MaxNumberOfMessages=1
).get("Messages")[0]
message_body = sqs_msg.get("Body")
print("Published Message: {}".format(message_body))
print("Message Stored in S3 Bucket is: {}\n".format(get_msg_from_s3(message_body,sns_extended_client)))
# Delete the Processed Message
sqs.delete_message(
QueueUrl=queue_url,
ReceiptHandle=sqs_msg['ReceiptHandle']
)
sns_extended_client = boto3.client("sns", region_name="us-east-1")
create_topic_response = sns_extended_client.create_topic(Name=TOPIC_NAME)
sns_topic_arn = create_topic_response.get("TopicArn")
# create and subscribe an sqs queue to the sns client
sqs = boto3.client("sqs",region_name="us-east-1")
demo_queue_url = sqs.create_queue(QueueName=QUEUE_NAME).get("QueueUrl")
sqs_queue_arn = sqs.get_queue_attributes(
QueueUrl=demo_queue_url, AttributeNames=["QueueArn"]
)["Attributes"].get("QueueArn")
# Adding policy to SQS queue such that SNS topic can send msg to SQS queue
policy_json = allow_sns_to_write_to_sqs(sns_topic_arn, sqs_queue_arn)
response = sqs.set_queue_attributes(
QueueUrl = demo_queue_url,
Attributes = {
'Policy' : policy_json
}
)
# Set the RawMessageDelivery subscription attribute to TRUE if you want to use
# SQSExtendedClient to help with retrieving msg from S3
sns_extended_client.subscribe(TopicArn=sns_topic_arn, Protocol="sqs",
Endpoint=sqs_queue_arn
, Attributes={"RawMessageDelivery":"true"}
)
sns_extended_client.large_payload_support = s3_extended_payload_bucket
# Change default s3_client attribute of sns_extended_client to use 'us-east-1' region
sns_extended_client.s3_client = boto3.client("s3", region_name="us-east-1")
# Below is the example that all the messages will be sent to the S3 bucket
sns_extended_client.always_through_s3 = True
sns_extended_client.publish(
TopicArn=sns_topic_arn, Message="This message should be published to S3"
)
print("\n\nPublished using SNS extended client:")
fetch_and_print_from_sqs(sqs, demo_queue_url,sns_extended_client) # Prints message stored in s3
# Below is the example that all the messages larger than 32 bytes will be sent to the S3 bucket
print("\nUsing decreased message size threshold:")
sns_extended_client.always_through_s3 = False
sns_extended_client.message_size_threshold = 32
sns_extended_client.publish(
TopicArn=sns_topic_arn,
Message="This message should be published to S3 as it exceeds the limit of the 32 bytes",
)
fetch_and_print_from_sqs(sqs, demo_queue_url,sns_extended_client) # Prints message stored in s3
# Below is the example to publish message using the SNS.Topic resource
sns_extended_client_resource = SNSExtendedClientSession().resource(
"sns", region_name="us-east-1"
)
topic = sns_extended_client_resource.Topic(sns_topic_arn)
topic.large_payload_support = s3_extended_payload_bucket
# Change default s3_client attribute of topic to use 'us-east-1' region
topic.s3_client = boto3.client("s3", region_name="us-east-1")
topic.always_through_s3 = True
# Can Set custom S3 Keys to be used to store objects in S3
topic.publish(
Message="This message should be published to S3 using the topic resource",
MessageAttributes={
"S3Key": {
"DataType": "String",
"StringValue": "347c11c4-a22c-42e4-a6a2-9b5af5b76587",
}
},
)
print("\nPublished using Topic Resource:")
fetch_and_print_from_sqs(sqs, demo_queue_url,topic)
# Below is the example to publish message using the SNS.PlatformEndpoint resource
sns_extended_client_resource = SNSExtendedClientSession().resource(
"sns", region_name="us-east-1"
)
platform_endpoint = sns_extended_client_resource.PlatformEndpoint(sns_topic_arn)
platform_endpoint.large_payload_support = s3_extended_payload_bucket
# Change default s3_client attribute of platform_endpoint to use 'us-east-1' region
platform_endpoint.s3_client = boto3.client("s3", region_name="us-east-1")
platform_endpoint.always_through_s3 = True
# Can Set custom S3 Keys to be used to store objects in S3
platform_endpoint.publish(
Message="This message should be published to S3 using the PlatformEndpoint resource",
MessageAttributes={
"S3Key": {
"DataType": "String",
"StringValue": "247c11c4-a22c-42e4-a6a2-9b5af5b76587",
}
},
)
print("\nPublished using PlatformEndpoint Resource:")
fetch_and_print_from_sqs(sqs, demo_queue_url,platform_endpoint)
```
**Keluaran**
```
Published using SNS extended client:
Published Message: ["software.amazon.payloadoffloading.PayloadS3Pointer", {"s3BucketName": "extended-client-bucket-store", "s3Key": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}]
Message Stored in S3 Bucket is: This message should be published to S3
Using decreased message size threshold:
Published Message: ["software.amazon.payloadoffloading.PayloadS3Pointer", {"s3BucketName": "extended-client-bucket-store", "s3Key": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}]
Message Stored in S3 Bucket is: This message should be published to S3 as it exceeds the limit of the 32 bytes
Published using Topic Resource:
Published Message: ["software.amazon.payloadoffloading.PayloadS3Pointer", {"s3BucketName": "extended-client-bucket-store", "s3Key": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}]
Message Stored in S3 Bucket is: This message should be published to S3 using the topic resource
Published using PlatformEndpoint Resource:
Published Message: ["software.amazon.payloadoffloading.PayloadS3Pointer", {"s3BucketName": "extended-client-bucket-store", "s3Key": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"}]
Message Stored in S3 Bucket is: This message should be published to S3 using the PlatformEndpoint resource
```
# Atribut pesan Amazon SNS
Amazon SNS mendukung pengiriman atribut pesan, yang memungkinkan Anda menyediakan item metadata terstruktur (seperti cap waktu, data geospasial, tanda tangan, dan pengidentifikasi) tentang pesan. Untuk langganan SQS, maksimal 10 atribut pesan dapat dikirim saat [Pengiriman Pesan Mentah](sns-large-payload-raw-message-delivery.md) diaktifkan. Untuk mengirim lebih dari 10 atribut pesan, Pengiriman Pesan Mentah harus dinonaktifkan. Pesan dengan lebih dari 10 atribut pesan yang diarahkan ke Pengiriman Pesan Mentah mengaktifkan langganan Amazon SQS akan dibuang sebagai kesalahan sisi klien.
Atribut pesan bersifat opsional dan terpisah dari—tetapi dikirim bersama-sama dengan—isi pesan. Penerima dapat menggunakan informasi ini untuk memutuskan bagaimana menangani pesan tanpa harus memproses isi pesan terlebih dahulu.
Untuk informasi tentang mengirim pesan dengan atribut menggunakan Konsol Manajemen AWS atau AWS SDK untuk Java, lihat [Untuk mempublikasikan pesan ke topik Amazon SNS menggunakan Konsol Manajemen AWS](sns-publishing.md#sns-publishing-messages) tutorialnya.
**catatan**
Atribut pesan dikirim hanya ketika struktur pesan String, bukan JSON.
Anda dapat menggunakan atribut pesan untuk menyusun pesan notifikasi push untuk endpoint seluler. Dalam skenario ini, atribut pesan hanya digunakan untuk menyusun pesan notifikasi push. Atribut tidak dikirim ke endpoint saat mengirim pesan dengan atribut pesan ke Amazon SQS endpoint.
Anda juga dapat menggunakan atribut pesan untuk membuat pesan Anda dapat difilter menggunakan kebijakan filter langganan. Anda dapat menerapkan kebijakan filter untuk langganan topik. Jika kebijakan filter diterapkan dengan cakupan kebijakan filter yang disetel ke `MessageAttributes` (default), langganan hanya menerima pesan yang memiliki atribut yang diterima kebijakan tersebut. Untuk informasi selengkapnya, lihat [Pemfilteran pesan Amazon SNS](sns-message-filtering.md).
**catatan**
Ketika atribut pesan digunakan untuk pemfilteran, nilainya harus berupa string JSON yang valid. Melakukan hal ini memastikan bahwa pesan dikirimkan ke langganan dengan pemfilteran atribut pesan diaktifkan.
## Pesan atribut item dan validasi
Setiap atribut pesan terdiri atas beberapa item berikut:
+ **Name (Nama)**— Nama atribut pesan dapat berisi karakter berikut: A-Z, a-z, 0-9, garis bawah (\$1), tanda hubung (-), dan periode (.). Nama tidak harus dimulai atau diakhiri dengan titik, dan seharusnya tidak memiliki titik berturut-turut. Nama peka huruf besar/kecil dan harus unik di antara semua nama atribut untuk pesan. Panjang nama dapat mencapai 256 karakter. Nama tidak dapat dimulai dengan `AWS.` atau `Amazon.` (atau variasi dalam casing) karena awalan ini disediakan untuk digunakan oleh Amazon Web Services.
+ **Type (Jenis)** — Jenis data atribut pesan yang didukung `String`, `String.Array`, `Number`, dan `Binary`. Tipe data memiliki batasan konten yang sama dengan isi pesan. Untuk informasi selengkapnya, lihat bagian [Pesan jenis data atribut dan validasi](#SNSMessageAttributes.DataTypes).
+ **Value (Nilai)** — Nilai atribut pesan yang ditentukan pengguna. Untuk tipe data string, atribut value harus mengikuti batasan konten yang sama dengan isi pesan. Namun, jika atribut pesan digunakan untuk pemfilteran, nilainya harus berupa string JSON yang valid untuk memastikan kompatibilitas dengan kebijakan filter langganan Amazon SNS. Untuk informasi selengkapnya, lihat tindakan [Publish](https://docs.aws.amazon.com/sns/latest/api/API_Publish.html) (Publikasikan) di *Amazon Simple Notification Service API Reference (Referensi API Amazon Simple Notification Service)*.
Nama, jenis, dan nilai tidak boleh kosong atau nol. Selain itu, isi pesan tidak boleh kosong atau nol. Semua bagian dari atribut pesan, termasuk nama, jenis, dan nilai, termasuk dalam pembatasan ukuran pesan, yaitu 256 KB.
## Pesan jenis data atribut dan validasi
Jenis data atribut pesan mengidentifikasi bagaimana nilai atribut pesan ditangani oleh Amazon SNS. Sebagai contoh, jika jenis adalah angka, Amazon SNS memvalidasi bahwa itu adalah angka.
Amazon SNS mendukung jenis data logis berikut untuk semua endpoint kecuali seperti yang dicatat:
+ **String** — String adalah Unicode dengan pengkodean biner UTF-8. Untuk daftar nilai kode, lihat [http://en.wikipedia. org/wiki/ASCII](http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters)\$1ASCII\$1printable\$1characters.
**catatan**
Nilai pengganti tidak didukung dalam atribut pesan. Misalnya, menggunakan nilai pengganti untuk mewakili emoji akan memberi Anda kesalahan berikut:`Invalid attribute value was passed in for message attribute`.
+ **String.Array** – Array, diformat sebagai string, yang dapat berisi beberapa nilai. Nilai dapat berupa string, angka, atau kata kunci `true`, `false`, dan `null`. String.Array nomor atau tipe boolean tidak memerlukan tanda kutip. Beberapa nilai String.Array dipisahkan dengan koma.
Tipe data ini tidak didukung untuk AWS Lambda langganan. Jika Anda menentukan jenis data ini untuk endpoint Lambda, ini akan diteruskan sebagai jenis data `String` dalam muatan JSON yang dikirimkan Amazon SNS ke Lambda.
+ **Number (Nomor)** — Nomor adalah bilangan bulat positif atau negatif atau bilangan floating-point. Angka memiliki jangkauan dan presisi yang cukup untuk mencakup sebagian besar kemungkinan nilai yang biasanya didukung oleh bilangan bulat, float, dan ganda. Sejumlah dapat memiliki nilai dari -109 hingga 109, dengan 5 digit akurasi setelah titik desimal. Nol awal dan akhir dipangkas.
Tipe data ini tidak didukung untuk AWS Lambda langganan. Jika Anda menentukan jenis data ini untuk endpoint Lambda, ini akan diteruskan sebagai jenis data `String` dalam muatan JSON yang dikirimkan Amazon SNS ke Lambda.
+ **Binary (Biner)** — Atribut jenis biner dapat menyimpan data biner apapun; misalnya, data terkompresi, data terenkripsi, atau gambar.
## Atribut pesan yang dicadangkan untuk notifikasi push seluler
Tabel berikut mencantumkan atribut pesan dicadangkan untuk layanan notifikasi push seluler yang dapat Anda gunakan untuk struktur pesan notifikasi push Anda:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sns/latest/dg/sns-message-attributes.html)
1 Apple akan menolak notifikasi Amazon SNS jika atribut pesan tidak memenuhi persyaratannya. Untuk detail tambahan, lihat [Mengirim Permintaan Pemberitahuan ke APNs](https://developer.apple.com/documentation/usernotifications/setting_up_a_remote_notification_server/sending_notification_requests_to_apns) situs web Pengembang Apple.
# Pengelompokan pesan Amazon SNS
## Apa itu message batching?
Alternatif untuk memublikasikan pesan ke topik Standar atau FIFO dalam permintaan `Publish` API individual, adalah menggunakan Amazon `PublishBatch` SNS API untuk mempublikasikan hingga 10 pesan dalam satu permintaan API. Mengirim pesan dalam batch dapat membantu Anda mengurangi biaya yang terkait dengan menghubungkan aplikasi terdistribusi ([pesan A2A](sns-system-to-system-messaging.md)) atau mengirim pemberitahuan kepada orang-orang (pesan [A2P) dengan](sns-user-notifications.md) Amazon SNS dengan faktor hingga 10. Amazon SNS memiliki kuota tentang berapa banyak pesan yang dapat Anda terbitkan ke topik per detik berdasarkan wilayah tempat Anda beroperasi. Lihat halaman [endpoint dan kuota Amazon SNS](https://docs.aws.amazon.com/general/latest/gr/sns.html) di *Referensi Umum AWS*panduan untuk informasi selengkapnya tentang kuota API.
**catatan**
Ukuran agregat total semua pesan yang Anda kirim dalam satu permintaan `PublishBatch` API tidak dapat melebihi 262.144 byte (256 KiB).
`PublishBatch`API menggunakan tindakan `Publish` API yang sama untuk kebijakan IAM.
## Bagaimana cara kerja pengelompokan pesan?
Menerbitkan pesan dengan `PublishBatch` API mirip dengan memublikasikan pesan dengan `Publish` API. Perbedaan utamanya adalah bahwa setiap pesan dalam permintaan `PublishBatch` API harus diberi ID batch unik (hingga 80 karakter). Dengan cara ini, Amazon SNS dapat mengembalikan respons API individual untuk setiap pesan dalam batch untuk mengonfirmasi bahwa setiap pesan telah dipublikasikan atau terjadi kegagalan. Untuk pesan yang dipublikasikan ke topik FIFO, selain menyertakan penetapan ID batch unik, Anda masih perlu menyertakan `MessageDeduplicationID` dan `MessageGroupId` untuk setiap pesan individual.
## Contoh
**Menerbitkan kumpulan 10 pesan ke topik Standar**
```
// Imports
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.PublishBatchRequest;
import software.amazon.awssdk.services.sns.model.PublishBatchRequestEntry;
import software.amazon.awssdk.services.sns.model.PublishBatchResponse;
import software.amazon.awssdk.services.sns.model.SnsException;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
// Code
private static final int MAX_BATCH_SIZE = 10;
public static void publishBatchToTopic(SnsClient snsClient, String topicArn, int batchSize) {
try {
// Validate the batch size
if (batchSize > MAX_BATCH_SIZE) {
throw new IllegalArgumentException("Batch size cannot exceed " + MAX_BATCH_SIZE);
}
// Create the batch entries
List entries = IntStream.range(0, batchSize)
.mapToObj(i -> PublishBatchRequestEntry.builder()
.id("id" + i)
.message("message" + i)
.build())
.collect(Collectors.toList());
// Build the batch request
PublishBatchRequest request = PublishBatchRequest.builder()
.topicArn(topicArn)
.publishBatchRequestEntries(entries)
.build();
// Publish the batch request
PublishBatchResponse response = snsClient.publishBatch(request);
// Handle successful messages
response.successful().forEach(success -> {
System.out.println("Successful Batch Id: " + success.id());
System.out.println("Message Id: " + success.messageId());
});
// Handle failed messages
response.failed().forEach(failure -> {
System.err.println("Failed Batch Id: " + failure.id());
System.err.println("Error Code: " + failure.code());
System.err.println("Sender Fault: " + failure.senderFault());
System.err.println("Error Message: " + failure.message());
});
} catch (SnsException e) {
// Log and handle exceptions
System.err.println("SNS Exception: " + e.awsErrorDetails().errorMessage());
} catch (IllegalArgumentException e) {
System.err.println("Validation Error: " + e.getMessage());
}
}
```
**Menerbitkan kumpulan 10 pesan ke topik FIFO**
```
// Imports
import software.amazon.awssdk.services.sns.SnsClient;
import software.amazon.awssdk.services.sns.model.PublishBatchRequest;
import software.amazon.awssdk.services.sns.model.PublishBatchRequestEntry;
import software.amazon.awssdk.services.sns.model.PublishBatchResponse;
import software.amazon.awssdk.services.sns.model.BatchResultErrorEntry;
import software.amazon.awssdk.services.sns.model.SnsException;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
// Code
private static final int MAX_BATCH_SIZE = 10;
public static void publishBatchToFifoTopic(SnsClient snsClient, String topicArn) {
try {
// Create the batch entries to send
List entries = IntStream.range(0, MAX_BATCH_SIZE)
.mapToObj(i -> PublishBatchRequestEntry.builder()
.id("id" + i)
.message("message" + i)
.messageGroupId("groupId")
.messageDeduplicationId("deduplicationId" + i)
.build())
.collect(Collectors.toList());
// Create the batch request
PublishBatchRequest request = PublishBatchRequest.builder()
.topicArn(topicArn)
.publishBatchRequestEntries(entries)
.build();
// Publish the batch request
PublishBatchResponse response = snsClient.publishBatch(request);
// Handle the successfully sent messages
response.successful().forEach(success -> {
System.out.println("Batch Id for successful message: " + success.id());
System.out.println("Message Id for successful message: " + success.messageId());
System.out.println("Sequence Number for successful message: " + success.sequenceNumber());
});
// Handle the failed messages
response.failed().forEach(failure -> {
System.err.println("Batch Id for failed message: " + failure.id());
System.err.println("Error Code for failed message: " + failure.code());
System.err.println("Sender Fault for failed message: " + failure.senderFault());
System.err.println("Failure Message for failed message: " + failure.message());
});
} catch (SnsException e) {
// Handle any exceptions from the request
System.err.println("SNS Exception: " + e.awsErrorDetails().errorMessage());
}
}
```