Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Erweiterte Amazon SNS SNS-Clientbibliothek für Python
## Voraussetzungen
Im Folgenden sind die Voraussetzungen für die Verwendung der [Amazon SNS Extended Client Library für Python](https://github.com/awslabs/amazon-sns-python-extended-client-lib) aufgeführt:
+ Ein AWS SDK. Das Beispiel auf dieser Seite verwendet das AWS Python-SDK Boto3. Informationen zur Installation und Einrichtung des SDK finden Sie in der Dokumentation zum [https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html).
+ Und AWS-Konto mit den richtigen Anmeldeinformationen. Um ein Konto zu erstellen AWS-Konto, navigieren Sie zur [AWS Startseite](https://aws.amazon.com/) und wählen Sie dann ** AWS Konto erstellen**. Folgen Sie den Anweisungen.
Weitere Informationen zu Anmeldeinformationen finden Sie unter [Anmeldeinformationen](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) im *Entwicklerhandbuch zu AWS -SDK für Python*.
+ Python 3.x (oder höher) und Pip.
+ Die erweiterte Amazon SNS Extended Client Library für Python (ist auch verfügbar von [Maven](https://pypi.org/project/amazon-sns-extended-client/)) enthalten.
## Konfigurieren der Nachrichtenspeicherung
Die folgenden Attribute sind auf Boto3 Amazon SNS [Client](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns.html#client), [Topic](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns/topic/index.html) und [PlatformEndpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns/platformendpoint/index.html)Objekten zur Konfiguration der Amazon S3 S3-Nachrichtenspeicheroptionen verfügbar.
+ **`large_payload_support`**— Der Name des Amazon S3 S3-Buckets, in dem große Nachrichten gespeichert werden.
+ **`use_legacy_attribute`**— Falls`True`, dann verwenden alle veröffentlichten Nachrichten das reservierte Nachrichtenattribut Legacy (`SQSLargePayloadSize`) anstelle des aktuellen reservierten Nachrichtenattributs (`ExtendedPayloadSize`).
+ **`message_size_threshold`** – der Schwellenwert für das Speichern der Nachricht im großen Nachrichten-Bucket. Kann nicht kleiner oder größer als sein`262144`. `0` Der Standardwert ist `262144`.
+ **`always_through_s3`** – bei `True` werden alle Nachrichten in Amazon S3 gespeichert. Der Standardwert ist `False`.
+ **`s3_client`**— Das Boto3 Amazon `client` S3-Objekt, das zum Speichern von Objekten in Amazon S3 verwendet werden soll. Verwenden Sie dies, wenn Sie den Amazon S3 S3-Client steuern möchten (z. B. benutzerdefinierte Amazon S3 S3-Konfiguration oder Anmeldeinformationen). Standardmäßig `boto3.client("s3")` bei der ersten Verwendung, sofern dies nicht zuvor festgelegt wurde.
## Beispiel: Veröffentlichen von Nachrichten in Amazon SNS mit einer in Amazon S3 gespeicherten Nutzlast
Wie das aussehen kann, sehen Sie am nachfolgenden Beispielcode:
+ Erstellen Sie Beispiele für ein Amazon-SNS-Thema und eine Amazon-SQS-Warteschlange.
+ Hängen Sie die Richtlinie an die Amazon SQS SQS-Warteschlange an, um die Nachricht vom Amazon SNS SNS-Thema zu erhalten.
+ Die abonnierte Queue kann nun Nachrichten vom Thema empfangen.
+ Veröffentlichen Sie eine Testnachricht mit dem erweiterten Amazon SNS SNS-Client, der Themenressource und der PlatformEndpoint Ressource.
+ Die Nachrichtennutzlast wird in Amazon S3 gespeichert und der Verweis darauf wird veröffentlicht.
+ Drucken Sie die veröffentlichte Nachricht aus der Warteschlange zusammen mit der aus Amazon S3 abgerufenen Originalnachricht aus.
Um eine große Nachricht zu veröffentlichen, verwenden Sie die Amazon SNS Extended Client Library für Python. Die Nachricht, die Sie senden, verweist auf ein Amazon-S3-Objekt, das den tatsächlichen Nachrichteninhalt enthält.
```
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)
```
**Ausgabe**
```
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
```