Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Publication de messages volumineux avec Amazon SNS et Amazon S3
Pour publier des messages Amazon SNS volumineux, vous pouvez utiliser la [bibliothèque client étendue Amazon SNS pour Java](https://github.com/awslabs/amazon-sns-java-extended-client-lib/) ou la [bibliothèque client étendue Amazon SNS pour Python](https://github.com/awslabs/amazon-sns-python-extended-client-lib). Ces bibliothèques sont utiles pour les messages qui dépassent le maximum actuel de 256 Ko, avec un maximum de 2 Go. Les deux bibliothèques enregistrent la charge utile réelle dans un compartiment Amazon S3 et publient la référence de l'objet Amazon S3 stocké dans la rubrique Amazon SNS. Les files d'attente Amazon SQS abonnées peuvent utiliser la [bibliothèque client étendue Amazon SQS pour Java](https://github.com/awslabs/amazon-sqs-java-extended-client-lib) pour déréférencer et récupérer les charges utiles depuis Amazon S3. D’autres points de terminaison, tels que Lambda, peuvent utiliser la [bibliothèque commune Java de déchargement de la charge utile pour AWS](https://github.com/awslabs/payload-offloading-java-common-lib-for-aws) afin de déréférencer et récupérer la charge utile.
**Note**
Les bibliothèques client étendues Amazon SNS sont compatibles avec les rubriques standard et FIFO.
# Bibliothèque client étendue Amazon SNS pour Java
## Conditions préalables
Voici les prérequis à satisfaire pour utiliser la [bibliothèque client étendue Amazon SNS pour Java](https://github.com/awslabs/amazon-sns-java-extended-client-lib) :
+ Un AWS SDK. L'exemple de cette page utilise le SDK AWS Java. Pour installer et configurer le SDK, consultez la section [Configurer le AWS SDK pour](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-install.html) Java dans le Guide *AWS SDK pour Java du* développeur.
+ Et Compte AWS avec les informations d'identification appropriées. Pour créer un Compte AWS, accédez à la [page d'AWS accueil](https://aws.amazon.com/), puis choisissez **Créer un AWS compte**. Suivez les instructions à l’écran.
Pour plus d'informations sur les informations d'identification, voir [Configurer les AWS informations d'identification et la région pour le développement](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-credentials.html) dans le *guide du AWS SDK pour Java développeur*.
+ Java 8 ou une version ultérieure.
+ Bibliothèque client étendue Amazon SNS pour Java (également disponible à partir de [Maven](https://maven.apache.org/)).
## Configurer le stockage de messages
La bibliothèque Amazon SNS Extended Client utilise la bibliothèque commune Java Payload Offloading AWS pour le stockage et la récupération des messages. Vous pouvez configurer les [options de stockage de messages](https://github.com/awslabs/amazon-sns-java-extended-client-lib/blob/main/src/main/java/software/amazon/sns/SNSExtendedClientConfiguration.java) suivantes pour Amazon S3 :
+ **Seuil de taille de message personnalisé** — Les messages dont la charge utile et les attributs dépassent cette taille sont automatiquement stockés dans Amazon S3.
+ **`alwaysThroughS3`flag** — Définissez cette valeur sur pour `true` forcer le stockage de toutes les charges utiles des messages dans Amazon S3. Par exemple :
```
SNSExtendedClientConfiguration snsExtendedClientConfiguration = new
SNSExtendedClientConfiguration() .withPayloadSupportEnabled(s3Client, BUCKET_NAME).withAlwaysThroughS3(true);
```
+ **Clé KMS personnalisée** : clé à utiliser pour le chiffrement côté serveur dans votre compartiment Amazon S3.
+ **Nom du compartiment** : nom du compartiment Amazon S3 pour stocker les charges utiles des messages.
## Exemple : publication de messages sur Amazon SNS avec la charge utile stockée dans Amazon S3
L’exemple de code suivant illustre comment :
+ Créez un exemple de rubrique et de file d'attente.
+ Abonnez la file d'attente pour recevoir des messages de la rubrique.
+ Publiez un message de test.
La charge utile du message est stockée dans Amazon S3 et sa référence est publiée. Le client étendu Amazon SQS est utilisé pour recevoir le message.
**Kit SDK pour Java 1.x**
Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/java/example_code/sns#code-examples).
Pour publier un message volumineux, vous pouvez utiliser la bibliothèque client étendue Amazon SNS pour Java. Le message que vous envoyez fait référence à un objet Amazon S3 contenant le contenu réel du message.
```
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());
}
}
```
## Autres protocoles de point de terminaison
Les bibliothèques Amazon SNS et Amazon SQS utilisent la [bibliothèque commune Java de déchargement de la charge utile pour AWS](https://github.com/awslabs/payload-offloading-java-common-lib-for-aws) pour stocker et récupérer les charges utiles des messages avec Amazon S3. Tout point de terminaison compatible Java (par exemple, un point de terminaison HTTPS implémenté en Java) peut utiliser la même bibliothèque pour déréférencer le contenu du message.
Les points de terminaison qui ne peuvent pas utiliser la bibliothèque commune Java de déchargement de charge utile AWS peuvent toujours publier des messages avec des charges utiles stockées dans Amazon S3. Voici un exemple de référence Amazon S3 qui est publiée par l'exemple de code ci-dessus :
```
[
"software.amazon.payloadoffloading.PayloadS3Pointer",
{
"s3BucketName": "extended-client-bucket",
"s3Key": "xxxx-xxxxx-xxxxx-xxxxxx"
}
]
```
# Bibliothèque client étendue Amazon SNS pour Python
## Conditions préalables
Voici les prérequis à satisfaire pour utiliser la [bibliothèque client étendue Amazon SNS pour Python](https://github.com/awslabs/amazon-sns-python-extended-client-lib) :
+ Un AWS SDK. L'exemple de cette page utilise le SDK AWS Python Boto3. Pour installer et configurer le kit SDK, consultez la documentation [https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html).
+ Et Compte AWS avec les informations d'identification appropriées. Pour créer un Compte AWS, accédez à la [page d'AWS accueil](https://aws.amazon.com/), puis choisissez **Créer un AWS compte**. Suivez les instructions à l’écran.
Pour obtenir des informations sur les informations d'identification, consultez [Informations d'identification](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html) dans le *Guide du développeur AWS SDK pour Python*.
+ Python 3.x (ou version ultérieure) et pip.
+ Bibliothèque client étendue Amazon SNS pour Python (également disponible à partir de [PyPI](https://pypi.org/project/amazon-sns-extended-client/)).
## Configurer le stockage de messages
Les attributs ci-dessous sont disponibles sur 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)et Objects pour configurer les options de stockage des messages Amazon S3.
+ **`large_payload_support`**— Le nom du compartiment Amazon S3 qui stockera les messages volumineux.
+ **`use_legacy_attribute`**— Dans `True` ce cas, tous les messages publiés utilisent l'attribut de message réservé Legacy (`SQSLargePayloadSize`) au lieu de l'attribut de message réservé actuel (`ExtendedPayloadSize`).
+ **`message_size_threshold`** – Seuil de stockage du message dans le compartiment de messages volumineux. Ne peut pas être inférieur `0` ou supérieur à`262144`. La valeur par défaut est `262144`.
+ **`always_through_s3`** – Si la valeur est `True`, tous les messages sont stockés dans Amazon S3. La valeur par défaut est `False`.
+ **`s3_client`**— L'`client`objet Boto3 Amazon S3 à utiliser pour stocker des objets sur Amazon S3. Utilisez-le si vous souhaitez contrôler le client Amazon S3 (par exemple, configuration Amazon S3 personnalisée ou informations d'identification). La valeur par défaut est utilisée `boto3.client("s3")` lors de la première utilisation si ce n'est pas déjà le cas.
## Exemple : publication de messages dans Amazon SNS avec la charge utile stockée dans Amazon S3
L’exemple de code suivant illustre comment :
+ Créez un exemple de rubrique Amazon SNS et de file d'attente Amazon SQS.
+ Joignez la politique à la file d'attente Amazon SQS pour recevoir le message de la rubrique Amazon SNS.
+ Abonnez la file d'attente pour recevoir des messages de la rubrique.
+ Publiez un message de test à l'aide du client étendu Amazon SNS, de la ressource Topic et PlatformEndpoint de la ressource.
+ La charge utile du message est stockée dans Amazon S3 et sa référence est publiée.
+ Imprimer le message publié depuis la file d'attente avec le message d'origine extrait d'Amazon S3.
Pour publier un message volumineux, vous pouvez utiliser la bibliothèque client étendue Amazon SNS pour Python. Le message que vous envoyez fait référence à un objet Amazon S3 contenant le contenu réel du message.
```
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)
```
**Sortie**
```
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
```