Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Libreria client estesa Amazon SNS per Python
## Prerequisiti
Di seguito sono indicati i prerequisiti per l’utilizzo della [Libreria client ampia di Amazon SNS per Python](https://github.com/awslabs/amazon-sns-python-extended-client-lib):
+ Un AWS SDK. L'esempio in questa pagina utilizza AWS Python SDK Boto3. Per installare e configurare l'SDK, consultare la documentazione [https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html).
+ E Account AWS con le credenziali appropriate. Per crearne uno Account AWS, vai alla [AWS home page](https://aws.amazon.com/), quindi scegli **Crea un AWS account**. Segui le istruzioni.
Per ulteriori informazioni sulle credenziali, consultare [Credenziali](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) nella *Guida per sviluppatori di SDK AWS per Python*.
+ Python 3.x (o versioni successive) e pip.
+ La libreria client ampia di Amazon SNS per Python (disponibile anche da [PyPI](https://pypi.org/project/amazon-sns-extended-client/)).
## Configurazione dello storage dei messaggi
Gli attributi seguenti sono disponibili su Boto3 Amazon [SNS](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns.html#client) Client[,](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns/topic/index.html) Topic [PlatformEndpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns/platformendpoint/index.html)e Objects per configurare le opzioni di storage dei messaggi di Amazon S3.
+ **`large_payload_support`**— Il nome del bucket Amazon S3 che memorizzerà messaggi di grandi dimensioni.
+ **`use_legacy_attribute`**— Se`True`, allora tutti i messaggi pubblicati utilizzano l'attributo Legacy reserved message (`SQSLargePayloadSize`) anziché l'attuale attributo riservato del messaggio (`ExtendedPayloadSize`).
+ **`message_size_threshold`** – La soglia per l'archiviazione del messaggio nel bucket dei messaggi di grandi dimensioni. Non può essere minore `0` o maggiore di`262144`. Il valore predefinito è `262144`.
+ **`always_through_s3`** – Se `True`, tutti i messaggi vengono archiviati in Amazon S3. Il valore predefinito è `False`.
+ **`s3_client`**— L'oggetto Boto3 Amazon `client` S3 da utilizzare per archiviare oggetti su Amazon S3. Usalo se desideri controllare il client Amazon S3 (ad esempio, configurazioni o credenziali Amazon S3 personalizzate). L'impostazione predefinita è al primo utilizzo se non è stata `boto3.client("s3")` impostata in precedenza.
## Esempio: pubblicazione di messaggi su Amazon SNS con payload memorizzato in Amazon S3
L’esempio di codice seguente mostra come:
+ Crea un argomento Amazon SNS di esempio e una coda Amazon SQS.
+ Allega la policy alla coda di Amazon SQS per ricevere il messaggio dall'argomento Amazon SNS.
+ Iscriviti alla coda per ricevere messaggi dall'argomento.
+ Pubblica un messaggio di prova utilizzando il client esteso Amazon SNS, la risorsa Topic e PlatformEndpoint la risorsa.
+ Il payload del messaggio è memorizzato in Amazon S3 e il riferimento ad esso è pubblicato.
+ Stampa il messaggio pubblicato dalla coda insieme al messaggio originale recuperato da Amazon S3.
Per pubblicare un messaggio di grandi dimensioni, utilizza la Libreria client ampia di Amazon SNS per Python. Il messaggio che invii fa riferimento a un oggetto Amazon S3 contenente il contenuto effettivo del messaggio.
```
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)
```
**Output**
```
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
```