Where:
queueName - The name of the queue.
message - The message to send.
""";
if (args.length != 2) {
System.out.println(usage);
System.exit(1);
}
String queueName = args[0];
String message = args[1];
SqsClient sqsClient = SqsClient.builder()
.region(Region.US_WEST_2)
.build();
sendMessage(sqsClient, queueName, message);
sqsClient.close();
}
public static void sendMessage(SqsClient sqsClient, String queueName, String message) {
try {
CreateQueueRequest request = CreateQueueRequest.builder()
.queueName(queueName)
.build();
sqsClient.createQueue(request);
GetQueueUrlRequest getQueueRequest = GetQueueUrlRequest.builder()
.queueName(queueName)
.build();
String queueUrl = sqsClient.getQueueUrl(getQueueRequest).queueUrl();
SendMessageRequest sendMsgRequest = SendMessageRequest.builder()
.queueUrl(queueUrl)
.messageBody(message)
.delaySeconds(5)
.build();
sqsClient.sendMessage(sendMsgRequest);
} catch (SqsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
Invia un messaggio con un corpo e gli attributi del messaggio.
```
/**
* This method demonstrates how to add message attributes to a message.
* Each attribute must specify a name, value, and data type. You use a Java Map to supply the attributes. The map's
* key is the attribute name, and you specify the map's entry value using a builder that includes the attribute
* value and data type.
*
* The data type must start with one of "String", "Number" or "Binary". You can optionally
* define a custom extension by using a "." and your extension.
*
* The SQS Developer Guide provides more information on @see message
* attributes.
*
* @param thumbailPath Filesystem path of the image.
* @param queueUrl URL of the SQS queue.
*/
static void sendMessageWithAttributes(Path thumbailPath, String queueUrl) {
Map messageAttributeMap;
try {
messageAttributeMap = Map.of(
"Name", MessageAttributeValue.builder()
.stringValue("Jane Doe")
.dataType("String").build(),
"Age", MessageAttributeValue.builder()
.stringValue("42")
.dataType("Number.int").build(),
"Image", MessageAttributeValue.builder()
.binaryValue(SdkBytes.fromByteArray(Files.readAllBytes(thumbailPath)))
.dataType("Binary.jpg").build()
);
} catch (IOException e) {
LOGGER.error("An I/O exception occurred reading thumbnail image: {}", e.getMessage(), e);
throw new RuntimeException(e);
}
SendMessageRequest request = SendMessageRequest.builder()
.queueUrl(queueUrl)
.messageBody("Hello SQS")
.messageAttributes(messageAttributeMap)
.build();
try {
SendMessageResponse sendMessageResponse = SQS_CLIENT.sendMessage(request);
LOGGER.info("Message ID: {}", sendMessageResponse.messageId());
} catch (SqsException e) {
LOGGER.error("Exception occurred sending message: {}", e.getMessage(), e);
throw new RuntimeException(e);
}
}
```
+ Per i dettagli sull'API, [SendMessage](https://docs.aws.amazon.com/goto/SdkForJavaV2/sqs-2012-11-05/SendMessage)consulta *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK per JavaScript (v3)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sqs#code-examples).
Invia un messaggio a una coda Amazon SQS.
```
import { SendMessageCommand, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "queue_url";
export const main = async (sqsQueueUrl = SQS_QUEUE_URL) => {
const command = new SendMessageCommand({
QueueUrl: sqsQueueUrl,
DelaySeconds: 10,
MessageAttributes: {
Title: {
DataType: "String",
StringValue: "The Whistler",
},
Author: {
DataType: "String",
StringValue: "John Grisham",
},
WeeksOn: {
DataType: "Number",
StringValue: "6",
},
},
MessageBody:
"Information about current NY Times fiction bestseller for week of 12/11/2016.",
});
const response = await client.send(command);
console.log(response);
return response;
};
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/sqs-examples-send-receive-messages.html#sqs-examples-send-receive-messages-sending).
+ Per i dettagli sull'API, [SendMessage](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/SendMessageCommand)consulta *AWS SDK per JavaScript API Reference*.
**SDK per JavaScript (v2)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascript/example_code/sqs#code-examples).
Invia un messaggio a una coda Amazon SQS.
```
// Load the AWS SDK for Node.js
var AWS = require("aws-sdk");
// Set the region
AWS.config.update({ region: "REGION" });
// Create an SQS service object
var sqs = new AWS.SQS({ apiVersion: "2012-11-05" });
var params = {
// Remove DelaySeconds parameter and value for FIFO queues
DelaySeconds: 10,
MessageAttributes: {
Title: {
DataType: "String",
StringValue: "The Whistler",
},
Author: {
DataType: "String",
StringValue: "John Grisham",
},
WeeksOn: {
DataType: "Number",
StringValue: "6",
},
},
MessageBody:
"Information about current NY Times fiction bestseller for week of 12/11/2016.",
// MessageDeduplicationId: "TheWhistler", // Required for FIFO queues
// MessageGroupId: "Group1", // Required for FIFO queues
QueueUrl: "SQS_QUEUE_URL",
};
sqs.sendMessage(params, function (err, data) {
if (err) {
console.log("Error", err);
} else {
console.log("Success", data.MessageId);
}
});
```
+ Per ulteriori informazioni, consulta la [Guida per sviluppatori di AWS SDK per JavaScript](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/sqs-examples-send-receive-messages.html#sqs-examples-send-receive-messages-sending).
+ Per i dettagli sull'API, [SendMessage](https://docs.aws.amazon.com/goto/AWSJavaScriptSDK/sqs-2012-11-05/SendMessage)consulta *AWS SDK per JavaScript API Reference*.
------
#### [ Kotlin ]
**SDK per Kotlin**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/sqs#code-examples).
```
suspend fun sendMessages(
queueUrlVal: String,
message: String,
) {
println("Sending multiple messages")
println("\nSend message")
val sendRequest =
SendMessageRequest {
queueUrl = queueUrlVal
messageBody = message
delaySeconds = 10
}
SqsClient.fromEnvironment { region = "us-east-1" }.use { sqsClient ->
sqsClient.sendMessage(sendRequest)
println("A single message was successfully sent.")
}
}
suspend fun sendBatchMessages(queueUrlVal: String?) {
println("Sending multiple messages")
val msg1 =
SendMessageBatchRequestEntry {
id = "id1"
messageBody = "Hello from msg 1"
}
val msg2 =
SendMessageBatchRequestEntry {
id = "id2"
messageBody = "Hello from msg 2"
}
val sendMessageBatchRequest =
SendMessageBatchRequest {
queueUrl = queueUrlVal
entries = listOf(msg1, msg2)
}
SqsClient.fromEnvironment { region = "us-east-1" }.use { sqsClient ->
sqsClient.sendMessageBatch(sendMessageBatchRequest)
println("Batch message were successfully sent.")
}
}
```
+ Per i dettagli sull'API, [SendMessage](https://sdk.amazonaws.com/kotlin/api/latest/index.html)consulta *AWS SDK for Kotlin* API reference.
------
#### [ PowerShell ]
**Strumenti per V4 PowerShell **
**Esempio 1: questo esempio invia un messaggio con gli attributi e il corpo del messaggio specificati alla coda specificata con un ritardo di consegna del messaggio di 10 secondi.**
```
$cityAttributeValue = New-Object Amazon.SQS.Model.MessageAttributeValue
$cityAttributeValue.DataType = "String"
$cityAttributeValue.StringValue = "AnyCity"
$populationAttributeValue = New-Object Amazon.SQS.Model.MessageAttributeValue
$populationAttributeValue.DataType = "Number"
$populationAttributeValue.StringValue = "1250800"
$messageAttributes = New-Object System.Collections.Hashtable
$messageAttributes.Add("City", $cityAttributeValue)
$messageAttributes.Add("Population", $populationAttributeValue)
Send-SQSMessage -DelayInSeconds 10 -MessageAttributes $messageAttributes -MessageBody "Information about the largest city in Any Region." -QueueUrl https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyQueue
```
**Output:**
```
MD5OfMessageAttributes MD5OfMessageBody MessageId
---------------------- ---------------- ---------
1d3e51347bc042efbdf6dda31EXAMPLE 51b0a3256d59467f973009b73EXAMPLE c35fed8f-c739-4d0c-818b-1820eEXAMPLE
```
+ Per i dettagli sull'API, vedere [SendMessage](https://docs.aws.amazon.com/powershell/v4/reference)in *AWS Strumenti per PowerShell Cmdlet Reference (*V4).
**Strumenti per V5 PowerShell **
**Esempio 1: questo esempio invia un messaggio con gli attributi e il corpo del messaggio specificati alla coda specificata con un ritardo di consegna del messaggio di 10 secondi.**
```
$cityAttributeValue = New-Object Amazon.SQS.Model.MessageAttributeValue
$cityAttributeValue.DataType = "String"
$cityAttributeValue.StringValue = "AnyCity"
$populationAttributeValue = New-Object Amazon.SQS.Model.MessageAttributeValue
$populationAttributeValue.DataType = "Number"
$populationAttributeValue.StringValue = "1250800"
$messageAttributes = New-Object System.Collections.Hashtable
$messageAttributes.Add("City", $cityAttributeValue)
$messageAttributes.Add("Population", $populationAttributeValue)
Send-SQSMessage -DelayInSeconds 10 -MessageAttributes $messageAttributes -MessageBody "Information about the largest city in Any Region." -QueueUrl https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyQueue
```
**Output:**
```
MD5OfMessageAttributes MD5OfMessageBody MessageId
---------------------- ---------------- ---------
1d3e51347bc042efbdf6dda31EXAMPLE 51b0a3256d59467f973009b73EXAMPLE c35fed8f-c739-4d0c-818b-1820eEXAMPLE
```
+ Per i dettagli sull'API, vedere [SendMessage](https://docs.aws.amazon.com/powershell/v5/reference)in *AWS Strumenti per PowerShell Cmdlet Reference (*V5).
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/sqs#code-examples).
```
def send_message(queue, message_body, message_attributes=None):
"""
Send a message to an Amazon SQS queue.
:param queue: The queue that receives the message.
:param message_body: The body text of the message.
:param message_attributes: Custom attributes of the message. These are key-value
pairs that can be whatever you want.
:return: The response from SQS that contains the assigned message ID.
"""
if not message_attributes:
message_attributes = {}
try:
response = queue.send_message(
MessageBody=message_body, MessageAttributes=message_attributes
)
except ClientError as error:
logger.exception("Send message failed: %s", message_body)
raise error
else:
return response
```
+ Per i dettagli sull'API, consulta [SendMessage AWS](https://docs.aws.amazon.com/goto/boto3/sqs-2012-11-05/SendMessage)*SDK for Python (Boto3) API Reference*.
------
#### [ Ruby ]
**SDK per Ruby**
C'è di più su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/sqs#code-examples).
```
require 'aws-sdk-sqs'
require 'aws-sdk-sts'
# @param sqs_client [Aws::SQS::Client] An initialized Amazon SQS client.
# @param queue_url [String] The URL of the queue.
# @param message_body [String] The contents of the message to be sent.
# @return [Boolean] true if the message was sent; otherwise, false.
# @example
# exit 1 unless message_sent?(
# Aws::SQS::Client.new(region: 'us-west-2'),
# 'https://sqs.us-west-2.amazonaws.com/111111111111/my-queue',
# 'This is my message.'
# )
def message_sent?(sqs_client, queue_url, message_body)
sqs_client.send_message(
queue_url: queue_url,
message_body: message_body
)
true
rescue StandardError => e
puts "Error sending message: #{e.message}"
false
end
# Full example call:
# Replace us-west-2 with the AWS Region you're using for Amazon SQS.
def run_me
region = 'us-west-2'
queue_name = 'my-queue'
message_body = 'This is my message.'
sts_client = Aws::STS::Client.new(region: region)
# For example:
# 'https://sqs.us-west-2.amazonaws.com/111111111111/my-queue'
queue_url = "https://sqs.#{region}.amazonaws.com/#{sts_client.get_caller_identity.account}/#{queue_name}"
sqs_client = Aws::SQS::Client.new(region: region)
puts "Sending a message to the queue named '#{queue_name}'..."
if message_sent?(sqs_client, queue_url, message_body)
puts 'Message sent.'
else
puts 'Message not sent.'
end
end
# Example usage:
run_me if $PROGRAM_NAME == __FILE__
```
+ Per i dettagli sull'API, [SendMessage](https://docs.aws.amazon.com/goto/SdkForRubyV3/sqs-2012-11-05/SendMessage)consulta *AWS SDK per Ruby API Reference*.
------
#### [ Rust ]
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/sqs#code-examples).
```
async fn send(client: &Client, queue_url: &String, message: &SQSMessage) -> Result<(), Error> {
println!("Sending message to queue with URL: {}", queue_url);
let rsp = client
.send_message()
.queue_url(queue_url)
.message_body(&message.body)
// If the queue is FIFO, you need to set .message_deduplication_id
// and message_group_id or configure the queue for ContentBasedDeduplication.
.send()
.await?;
println!("Send message to the queue: {:#?}", rsp);
Ok(())
}
```
+ Per i dettagli sulle API, consulta la [SendMessage](https://docs.rs/aws-sdk-sqs/latest/aws_sdk_sqs/client/struct.Client.html#method.send_message)guida di *riferimento all'API AWS SDK for Rust*.
------
#### [ SAP ABAP ]
**SDK per SAP ABAP**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/sqs#code-examples).
```
TRY.
oo_result = lo_sqs->sendmessage( " oo_result is returned for testing purposes. "
iv_queueurl = iv_queue_url
iv_messagebody = iv_message ).
MESSAGE 'Message sent to SQS queue.' TYPE 'I'.
CATCH /aws1/cx_sqsinvalidmsgconts.
MESSAGE 'Message contains non-valid characters.' TYPE 'E'.
CATCH /aws1/cx_sqsunsupportedop.
MESSAGE 'Operation not supported.' TYPE 'E'.
ENDTRY.
```
+ Per i dettagli sulle API, [SendMessage](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)consulta *AWS SDK for SAP ABAP* API reference.
------
# Utilizzo `SendMessageBatch` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `SendMessageBatch`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Inviare e ricevere batch di messaggi](sqs_example_sqs_Scenario_SendReceiveBatch_section.md)
------
#### [ CLI ]
**AWS CLI**
**Come inviare più messaggi in batch**
Questo esempio invia alla coda specificata 2 messaggi con il corpo del messaggio, il periodo di ritardo e gli attributi del messaggio specificati.
Comando:
```
aws sqs send-message-batch --queue-url https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyQueue --entries file://send-message-batch.json
```
File di input (send-message-batch.json):
```
[
{
"Id": "FuelReport-0001-2015-09-16T140731Z",
"MessageBody": "Fuel report for account 0001 on 2015-09-16 at 02:07:31 PM.",
"DelaySeconds": 10,
"MessageAttributes": {
"SellerName": {
"DataType": "String",
"StringValue": "Example Store"
},
"City": {
"DataType": "String",
"StringValue": "Any City"
},
"Region": {
"DataType": "String",
"StringValue": "WA"
},
"PostalCode": {
"DataType": "String",
"StringValue": "99065"
},
"PricePerGallon": {
"DataType": "Number",
"StringValue": "1.99"
}
}
},
{
"Id": "FuelReport-0002-2015-09-16T140930Z",
"MessageBody": "Fuel report for account 0002 on 2015-09-16 at 02:09:30 PM.",
"DelaySeconds": 10,
"MessageAttributes": {
"SellerName": {
"DataType": "String",
"StringValue": "Example Fuels"
},
"City": {
"DataType": "String",
"StringValue": "North Town"
},
"Region": {
"DataType": "String",
"StringValue": "WA"
},
"PostalCode": {
"DataType": "String",
"StringValue": "99123"
},
"PricePerGallon": {
"DataType": "Number",
"StringValue": "1.87"
}
}
}
]
```
Output:
```
{
"Successful": [
{
"MD5OfMessageBody": "203c4a38...7943237e",
"MD5OfMessageAttributes": "10809b55...baf283ef",
"Id": "FuelReport-0001-2015-09-16T140731Z",
"MessageId": "d175070c-d6b8-4101-861d-adeb3EXAMPLE"
},
{
"MD5OfMessageBody": "2cf0159a...c1980595",
"MD5OfMessageAttributes": "55623928...ae354a25",
"Id": "FuelReport-0002-2015-09-16T140930Z",
"MessageId": "f9b7d55d-0570-413e-b9c5-a9264EXAMPLE"
}
]
}
```
+ Per i dettagli sull'API, consulta *AWS CLI Command [SendMessageBatch](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sqs/send-message-batch.html)Reference*.
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/sqs#code-examples).
```
SendMessageBatchRequest sendMessageBatchRequest = SendMessageBatchRequest.builder()
.queueUrl(queueUrl)
.entries(SendMessageBatchRequestEntry.builder().id("id1").messageBody("Hello from msg 1").build(),
SendMessageBatchRequestEntry.builder().id("id2").messageBody("msg 2").delaySeconds(10)
.build())
.build();
sqsClient.sendMessageBatch(sendMessageBatchRequest);
```
+ Per i dettagli sull'API, [SendMessageBatch](https://docs.aws.amazon.com/goto/SdkForJavaV2/sqs-2012-11-05/SendMessageBatch)consulta *AWS SDK for Java 2.x API Reference*.
------
#### [ PowerShell ]
**Strumenti per PowerShell V4**
**Esempio 1: questo esempio invia 2 messaggi con gli attributi e i corpi dei messaggi specificati alla coda specificata. La distribuzione viene ritardata di 15 secondi per il primo messaggio e di 10 secondi per il secondo messaggio.**
```
$student1NameAttributeValue = New-Object Amazon.SQS.Model.MessageAttributeValue
$student1NameAttributeValue.DataType = "String"
$student1NameAttributeValue.StringValue = "John Doe"
$student1GradeAttributeValue = New-Object Amazon.SQS.Model.MessageAttributeValue
$student1GradeAttributeValue.DataType = "Number"
$student1GradeAttributeValue.StringValue = "89"
$student2NameAttributeValue = New-Object Amazon.SQS.Model.MessageAttributeValue
$student2NameAttributeValue.DataType = "String"
$student2NameAttributeValue.StringValue = "Jane Doe"
$student2GradeAttributeValue = New-Object Amazon.SQS.Model.MessageAttributeValue
$student2GradeAttributeValue.DataType = "Number"
$student2GradeAttributeValue.StringValue = "93"
$message1 = New-Object Amazon.SQS.Model.SendMessageBatchRequestEntry
$message1.DelaySeconds = 15
$message1.Id = "FirstMessage"
$message1.MessageAttributes.Add("StudentName", $student1NameAttributeValue)
$message1.MessageAttributes.Add("StudentGrade", $student1GradeAttributeValue)
$message1.MessageBody = "Information about John Doe's grade."
$message2 = New-Object Amazon.SQS.Model.SendMessageBatchRequestEntry
$message2.DelaySeconds = 10
$message2.Id = "SecondMessage"
$message2.MessageAttributes.Add("StudentName", $student2NameAttributeValue)
$message2.MessageAttributes.Add("StudentGrade", $student2GradeAttributeValue)
$message2.MessageBody = "Information about Jane Doe's grade."
Send-SQSMessageBatch -QueueUrl https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyQueue -Entry $message1, $message2
```
**Output:**
```
Failed Successful
------ ----------
{} {FirstMessage, SecondMessage}
```
+ Per i dettagli sull'API, vedere [SendMessageBatch](https://docs.aws.amazon.com/powershell/v4/reference)in *AWS Strumenti per PowerShell Cmdlet Reference (*V4).
**Strumenti per V5 PowerShell **
**Esempio 1: questo esempio invia 2 messaggi con gli attributi e i corpi dei messaggi specificati alla coda specificata. La distribuzione viene ritardata di 15 secondi per il primo messaggio e di 10 secondi per il secondo messaggio.**
```
$student1NameAttributeValue = New-Object Amazon.SQS.Model.MessageAttributeValue
$student1NameAttributeValue.DataType = "String"
$student1NameAttributeValue.StringValue = "John Doe"
$student1GradeAttributeValue = New-Object Amazon.SQS.Model.MessageAttributeValue
$student1GradeAttributeValue.DataType = "Number"
$student1GradeAttributeValue.StringValue = "89"
$student2NameAttributeValue = New-Object Amazon.SQS.Model.MessageAttributeValue
$student2NameAttributeValue.DataType = "String"
$student2NameAttributeValue.StringValue = "Jane Doe"
$student2GradeAttributeValue = New-Object Amazon.SQS.Model.MessageAttributeValue
$student2GradeAttributeValue.DataType = "Number"
$student2GradeAttributeValue.StringValue = "93"
$message1 = New-Object Amazon.SQS.Model.SendMessageBatchRequestEntry
$message1.DelaySeconds = 15
$message1.Id = "FirstMessage"
$message1.MessageAttributes.Add("StudentName", $student1NameAttributeValue)
$message1.MessageAttributes.Add("StudentGrade", $student1GradeAttributeValue)
$message1.MessageBody = "Information about John Doe's grade."
$message2 = New-Object Amazon.SQS.Model.SendMessageBatchRequestEntry
$message2.DelaySeconds = 10
$message2.Id = "SecondMessage"
$message2.MessageAttributes.Add("StudentName", $student2NameAttributeValue)
$message2.MessageAttributes.Add("StudentGrade", $student2GradeAttributeValue)
$message2.MessageBody = "Information about Jane Doe's grade."
Send-SQSMessageBatch -QueueUrl https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyQueue -Entry $message1, $message2
```
**Output:**
```
Failed Successful
------ ----------
{} {FirstMessage, SecondMessage}
```
+ Per i dettagli sull'API, vedere [SendMessageBatch](https://docs.aws.amazon.com/powershell/v5/reference)in *AWS Strumenti per PowerShell Cmdlet Reference (*V5).
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/sqs#code-examples).
```
def send_messages(queue, messages):
"""
Send a batch of messages in a single request to an SQS queue.
This request may return overall success even when some messages were not sent.
The caller must inspect the Successful and Failed lists in the response and
resend any failed messages.
:param queue: The queue to receive the messages.
:param messages: The messages to send to the queue. These are simplified to
contain only the message body and attributes.
:return: The response from SQS that contains the list of successful and failed
messages.
"""
try:
entries = [
{
"Id": str(ind),
"MessageBody": msg["body"],
"MessageAttributes": msg["attributes"],
}
for ind, msg in enumerate(messages)
]
response = queue.send_messages(Entries=entries)
if "Successful" in response:
for msg_meta in response["Successful"]:
logger.info(
"Message sent: %s: %s",
msg_meta["MessageId"],
messages[int(msg_meta["Id"])]["body"],
)
if "Failed" in response:
for msg_meta in response["Failed"]:
logger.warning(
"Failed to send: %s: %s",
msg_meta["MessageId"],
messages[int(msg_meta["Id"])]["body"],
)
except ClientError as error:
logger.exception("Send messages failed to queue: %s", queue)
raise error
else:
return response
```
+ Per i dettagli sull'API, consulta [SendMessageBatch AWS](https://docs.aws.amazon.com/goto/boto3/sqs-2012-11-05/SendMessageBatch)*SDK for Python (Boto3) API Reference*.
------
#### [ Ruby ]
**SDK per Ruby**
C'è di più su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/sqs#code-examples).
```
require 'aws-sdk-sqs'
require 'aws-sdk-sts'
#
# @param sqs_client [Aws::SQS::Client] An initialized Amazon SQS client.
# @param queue_url [String] The URL of the queue.
# @param entries [Hash] The contents of the messages to be sent,
# in the correct format.
# @return [Boolean] true if the messages were sent; otherwise, false.
# @example
# exit 1 unless messages_sent?(
# Aws::SQS::Client.new(region: 'us-west-2'),
# 'https://sqs.us-west-2.amazonaws.com/111111111111/my-queue',
# [
# {
# id: 'Message1',
# message_body: 'This is the first message.'
# },
# {
# id: 'Message2',
# message_body: 'This is the second message.'
# }
# ]
# )
def messages_sent?(sqs_client, queue_url, entries)
sqs_client.send_message_batch(
queue_url: queue_url,
entries: entries
)
true
rescue StandardError => e
puts "Error sending messages: #{e.message}"
false
end
# Full example call:
# Replace us-west-2 with the AWS Region you're using for Amazon SQS.
def run_me
region = 'us-west-2'
queue_name = 'my-queue'
entries = [
{
id: 'Message1',
message_body: 'This is the first message.'
},
{
id: 'Message2',
message_body: 'This is the second message.'
}
]
sts_client = Aws::STS::Client.new(region: region)
# For example:
# 'https://sqs.us-west-2.amazonaws.com/111111111111/my-queue'
queue_url = "https://sqs.#{region}.amazonaws.com/#{sts_client.get_caller_identity.account}/#{queue_name}"
sqs_client = Aws::SQS::Client.new(region: region)
puts "Sending messages to the queue named '#{queue_name}'..."
if messages_sent?(sqs_client, queue_url, entries)
puts 'Messages sent.'
else
puts 'Messages not sent.'
end
end
```
+ Per i dettagli sull'API, [SendMessageBatch](https://docs.aws.amazon.com/goto/SdkForRubyV3/sqs-2012-11-05/SendMessageBatch)consulta *AWS SDK per Ruby API Reference*.
------
#### [ SAP ABAP ]
**SDK per SAP ABAP**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/sqs#code-examples).
```
TRY.
oo_result = lo_sqs->sendmessagebatch( " oo_result is returned for testing purposes. "
iv_queueurl = iv_queue_url
it_entries = it_messages ).
MESSAGE 'Messages sent to SQS queue.' TYPE 'I'.
CATCH /aws1/cx_sqsbtcentidsnotdist00.
MESSAGE 'Two or more batch entries in the request have the same ID.' TYPE 'E'.
CATCH /aws1/cx_sqsbatchreqtoolong.
MESSAGE 'The length of all the messages put together is more than the limit.' TYPE 'E'.
CATCH /aws1/cx_sqsemptybatchrequest.
MESSAGE 'The batch request does not contain any entries.' TYPE 'E'.
CATCH /aws1/cx_sqsinvbatchentryid.
MESSAGE 'The ID of a batch entry in a batch request is not valid.' TYPE 'E'.
CATCH /aws1/cx_sqstoomanyentriesin00.
MESSAGE 'The batch request contains more entries than allowed.' TYPE 'E'.
CATCH /aws1/cx_sqsunsupportedop.
MESSAGE 'Operation not supported.' TYPE 'E'.
ENDTRY.
```
+ Per i dettagli sulle API, [SendMessageBatch](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)consulta *AWS SDK for SAP ABAP* API reference.
------
# Utilizzo `SetQueueAttributes` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `SetQueueAttributes`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Pubblicazione di messaggi nelle code](sqs_example_sqs_Scenario_TopicsAndQueues_section.md)
------
#### [ .NET ]
**SDK per .NET**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/TopicsAndQueues#code-examples).
Imposta l’attributo della policy di una coda per un argomento.
```
///
/// Set the policy attribute of a queue for a topic.
///
/// The ARN of the queue.
/// The ARN of the topic.
/// The url for the queue.
/// True if successful.
public async Task SetQueuePolicyForTopic(string queueArn, string topicArn, string queueUrl)
{
var queuePolicy = "{" +
"\"Version\": \"2012-10-17\"," +
"\"Statement\": [{" +
"\"Effect\": \"Allow\"," +
"\"Principal\": {" +
$"\"Service\": " +
"\"sns.amazonaws.com\"" +
"}," +
"\"Action\": \"sqs:SendMessage\"," +
$"\"Resource\": \"{queueArn}\"," +
"\"Condition\": {" +
"\"ArnEquals\": {" +
$"\"aws:SourceArn\": \"{topicArn}\"" +
"}" +
"}" +
"}]" +
"}";
var attributesResponse = await _amazonSQSClient.SetQueueAttributesAsync(
new SetQueueAttributesRequest()
{
QueueUrl = queueUrl,
Attributes = new Dictionary() { { "Policy", queuePolicy } }
});
return attributesResponse.HttpStatusCode == HttpStatusCode.OK;
}
```
+ Per i dettagli sull'API, [SetQueueAttributes](https://docs.aws.amazon.com/goto/DotNetSDKV3/sqs-2012-11-05/SetQueueAttributes)consulta *AWS SDK per .NET API Reference*.
------
#### [ C\$1\$1 ]
**SDK per C\$1\$1**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/sqs#code-examples).
```
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
//! Set the value for an attribute in an Amazon Simple Queue Service (Amazon SQS) queue.
/*!
\param queueUrl: An Amazon SQS queue URL.
\param attributeName: An attribute name enum.
\param attribute: The attribute value as a string.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::SQS::setQueueAttributes(const Aws::String &queueURL,
Aws::SQS::Model::QueueAttributeName attributeName,
const Aws::String &attribute,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SQS::SQSClient sqsClient(clientConfiguration);
Aws::SQS::Model::SetQueueAttributesRequest request;
request.SetQueueUrl(queueURL);
request.AddAttributes(
attributeName,
attribute);
const Aws::SQS::Model::SetQueueAttributesOutcome outcome = sqsClient.SetQueueAttributes(
request);
if (outcome.IsSuccess()) {
std::cout << "Successfully set the attribute " <<
Aws::SQS::Model::QueueAttributeNameMapper::GetNameForQueueAttributeName(
attributeName)
<< " with value " << attribute << " in queue " <<
queueURL << "." << std::endl;
}
else {
std::cout << "Error setting attribute for queue " <<
queueURL << ": " << outcome.GetError().GetMessage() <<
std::endl;
}
return outcome.IsSuccess();
}
```
Configura una coda DLQ.
```
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
//! Connect an Amazon Simple Queue Service (Amazon SQS) queue to an associated
//! dead-letter queue.
/*!
\param srcQueueUrl: An Amazon SQS queue URL.
\param deadLetterQueueARN: The Amazon Resource Name (ARN) of an Amazon SQS dead-letter queue.
\param maxReceiveCount: The max receive count of a message before it is sent to the dead-letter queue.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::SQS::setDeadLetterQueue(const Aws::String &srcQueueUrl,
const Aws::String &deadLetterQueueARN,
int maxReceiveCount,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::String redrivePolicy = MakeRedrivePolicy(deadLetterQueueARN, maxReceiveCount);
Aws::SQS::SQSClient sqsClient(clientConfiguration);
Aws::SQS::Model::SetQueueAttributesRequest request;
request.SetQueueUrl(srcQueueUrl);
request.AddAttributes(
Aws::SQS::Model::QueueAttributeName::RedrivePolicy,
redrivePolicy);
const Aws::SQS::Model::SetQueueAttributesOutcome outcome =
sqsClient.SetQueueAttributes(request);
if (outcome.IsSuccess()) {
std::cout << "Successfully set dead letter queue for queue " <<
srcQueueUrl << " to " << deadLetterQueueARN << std::endl;
}
else {
std::cerr << "Error setting dead letter queue for queue " <<
srcQueueUrl << ": " << outcome.GetError().GetMessage() <<
std::endl;
}
return outcome.IsSuccess();
}
//! Make a redrive policy for a dead-letter queue.
/*!
\param queueArn: An Amazon SQS ARN for the dead-letter queue.
\param maxReceiveCount: The max receive count of a message before it is sent to the dead-letter queue.
\return Aws::String: Policy as JSON string.
*/
Aws::String MakeRedrivePolicy(const Aws::String &queueArn, int maxReceiveCount) {
Aws::Utils::Json::JsonValue redrive_arn_entry;
redrive_arn_entry.AsString(queueArn);
Aws::Utils::Json::JsonValue max_msg_entry;
max_msg_entry.AsInteger(maxReceiveCount);
Aws::Utils::Json::JsonValue policy_map;
policy_map.WithObject("deadLetterTargetArn", redrive_arn_entry);
policy_map.WithObject("maxReceiveCount", max_msg_entry);
return policy_map.View().WriteReadable();
}
```
Configura una coda Amazon SQS per utilizzare il long polling.
```
Aws::Client::ClientConfiguration clientConfig;
// Optional: Set to the AWS Region (overrides config file).
// clientConfig.region = "us-east-1";
//! Set the wait time for an Amazon Simple Queue Service (Amazon SQS) queue poll.
/*!
\param queueUrl: An Amazon SQS queue URL.
\param pollTimeSeconds: The receive message wait time in seconds.
\param clientConfiguration: AWS client configuration.
\return bool: Function succeeded.
*/
bool AwsDoc::SQS::setQueueLongPollingAttribute(const Aws::String &queueURL,
const Aws::String &pollTimeSeconds,
const Aws::Client::ClientConfiguration &clientConfiguration) {
Aws::SQS::SQSClient sqsClient(clientConfiguration);
Aws::SQS::Model::SetQueueAttributesRequest request;
request.SetQueueUrl(queueURL);
request.AddAttributes(
Aws::SQS::Model::QueueAttributeName::ReceiveMessageWaitTimeSeconds,
pollTimeSeconds);
const Aws::SQS::Model::SetQueueAttributesOutcome outcome = sqsClient.SetQueueAttributes(
request);
if (outcome.IsSuccess()) {
std::cout << "Successfully updated long polling time for queue " <<
queueURL << " to " << pollTimeSeconds << std::endl;
}
else {
std::cout << "Error updating long polling time for queue " <<
queueURL << ": " << outcome.GetError().GetMessage() <<
std::endl;
}
return outcome.IsSuccess();
}
```
+ Per i dettagli sull'API, [SetQueueAttributes](https://docs.aws.amazon.com/goto/SdkForCpp/sqs-2012-11-05/SetQueueAttributes)consulta *AWS SDK per C\$1\$1 API Reference*.
------
#### [ CLI ]
**AWS CLI**
**Come impostare gli attributi della coda**
Questo esempio imposta la coda specificata su un ritardo di distribuzione di 10 secondi, una dimensione massima del messaggio di 128 KB (128 KB \$1 1.024 byte), un periodo di conservazione dei messaggi di 3 giorni (3 giorni \$1 24 ore \$1 60 minuti \$1 60 secondi), un tempo di attesa per la ricezione dei messaggi di 20 secondi e un timeout di visibilità predefinito di 60 secondi. Questo esempio associa inoltre la coda DLQ specificata a un numero massimo di ricezione di 1.000 messaggi.
Comando:
```
aws sqs set-queue-attributes --queue-url https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyNewQueue --attributes file://set-queue-attributes.json
```
File di input (set-queue-attributes.json):
```
{
"DelaySeconds": "10",
"MaximumMessageSize": "131072",
"MessageRetentionPeriod": "259200",
"ReceiveMessageWaitTimeSeconds": "20",
"RedrivePolicy": "{\"deadLetterTargetArn\":\"arn:aws:sqs:us-east-1:80398EXAMPLE:MyDeadLetterQueue\",\"maxReceiveCount\":\"1000\"}",
"VisibilityTimeout": "60"
}
```
Output:
```
None.
```
+ Per i dettagli sull'API, consulta *AWS CLI Command [SetQueueAttributes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sqs/set-queue-attributes.html)Reference*.
------
#### [ Go ]
**SDK per Go V2**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/workflows/topics_and_queues#code-examples).
```
import (
"context"
"encoding/json"
"fmt"
"log"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/sqs"
"github.com/aws/aws-sdk-go-v2/service/sqs/types"
)
// SqsActions encapsulates the Amazon Simple Queue Service (Amazon SQS) actions
// used in the examples.
type SqsActions struct {
SqsClient *sqs.Client
}
// AttachSendMessagePolicy uses the SetQueueAttributes action to attach a policy to an
// Amazon SQS queue that allows the specified Amazon SNS topic to send messages to the
// queue.
func (actor SqsActions) AttachSendMessagePolicy(ctx context.Context, queueUrl string, queueArn string, topicArn string) error {
policyDoc := PolicyDocument{
Version: "2012-10-17",
Statement: []PolicyStatement{{
Effect: "Allow",
Action: "sqs:SendMessage",
Principal: map[string]string{"Service": "sns.amazonaws.com"},
Resource: aws.String(queueArn),
Condition: PolicyCondition{"ArnEquals": map[string]string{"aws:SourceArn": topicArn}},
}},
}
policyBytes, err := json.Marshal(policyDoc)
if err != nil {
log.Printf("Couldn't create policy document. Here's why: %v\n", err)
return err
}
_, err = actor.SqsClient.SetQueueAttributes(ctx, &sqs.SetQueueAttributesInput{
Attributes: map[string]string{
string(types.QueueAttributeNamePolicy): string(policyBytes),
},
QueueUrl: aws.String(queueUrl),
})
if err != nil {
log.Printf("Couldn't set send message policy on queue %v. Here's why: %v\n", queueUrl, err)
}
return err
}
// PolicyDocument defines a policy document as a Go struct that can be serialized
// to JSON.
type PolicyDocument struct {
Version string
Statement []PolicyStatement
}
// PolicyStatement defines a statement in a policy document.
type PolicyStatement struct {
Effect string
Action string
Principal map[string]string `json:",omitempty"`
Resource *string `json:",omitempty"`
Condition PolicyCondition `json:",omitempty"`
}
// PolicyCondition defines a condition in a policy.
type PolicyCondition map[string]map[string]string
```
+ Per i dettagli sull'API, [SetQueueAttributes](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/sqs#Client.SetQueueAttributes)consulta *AWS SDK per Go API Reference*.
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/sqs#code-examples).
Configura Amazon SQS per utilizzare la crittografia lato server (SSE) utilizzando una chiave KMS personalizzata.
```
public static void addEncryption(String queueName, String kmsMasterKeyAlias) {
SqsClient sqsClient = SqsClient.create();
GetQueueUrlRequest urlRequest = GetQueueUrlRequest.builder()
.queueName(queueName)
.build();
GetQueueUrlResponse getQueueUrlResponse;
try {
getQueueUrlResponse = sqsClient.getQueueUrl(urlRequest);
} catch (QueueDoesNotExistException e) {
LOGGER.error(e.getMessage(), e);
throw new RuntimeException(e);
}
String queueUrl = getQueueUrlResponse.queueUrl();
Map attributes = Map.of(
QueueAttributeName.KMS_MASTER_KEY_ID, kmsMasterKeyAlias,
QueueAttributeName.KMS_DATA_KEY_REUSE_PERIOD_SECONDS, "140" // Set the data key reuse period to 140 seconds.
); // This is how long SQS can reuse the data key before requesting a new one from KMS.
SetQueueAttributesRequest attRequest = SetQueueAttributesRequest.builder()
.queueUrl(queueUrl)
.attributes(attributes)
.build();
try {
sqsClient.setQueueAttributes(attRequest);
LOGGER.info("The attributes have been applied to {}", queueName);
} catch (InvalidAttributeNameException | InvalidAttributeValueException e) {
LOGGER.error(e.getMessage(), e);
throw new RuntimeException(e);
} finally {
sqsClient.close();
}
}
```
+ Per i dettagli sull'API, [SetQueueAttributes](https://docs.aws.amazon.com/goto/SdkForJavaV2/sqs-2012-11-05/SetQueueAttributes)consulta *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK per JavaScript (v3)**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/sqs#code-examples).
```
import { SetQueueAttributesCommand, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "queue-url";
export const main = async (queueUrl = SQS_QUEUE_URL) => {
const command = new SetQueueAttributesCommand({
QueueUrl: queueUrl,
Attributes: {
DelaySeconds: "1",
},
});
const response = await client.send(command);
console.log(response);
return response;
};
```
Configura una coda Amazon SQS per utilizzare il long polling.
```
import { SetQueueAttributesCommand, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "queue_url";
export const main = async (queueUrl = SQS_QUEUE_URL) => {
const command = new SetQueueAttributesCommand({
Attributes: {
ReceiveMessageWaitTimeSeconds: "20",
},
QueueUrl: queueUrl,
});
const response = await client.send(command);
console.log(response);
return response;
};
```
Configura una coda DLQ.
```
import { SetQueueAttributesCommand, SQSClient } from "@aws-sdk/client-sqs";
const client = new SQSClient({});
const SQS_QUEUE_URL = "queue_url";
const DEAD_LETTER_QUEUE_ARN = "dead_letter_queue_arn";
export const main = async (
queueUrl = SQS_QUEUE_URL,
deadLetterQueueArn = DEAD_LETTER_QUEUE_ARN,
) => {
const command = new SetQueueAttributesCommand({
Attributes: {
RedrivePolicy: JSON.stringify({
// Amazon SQS supports dead-letter queues (DLQ), which other
// queues (source queues) can target for messages that can't
// be processed (consumed) successfully.
// https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html
deadLetterTargetArn: deadLetterQueueArn,
maxReceiveCount: "10",
}),
},
QueueUrl: queueUrl,
});
const response = await client.send(command);
console.log(response);
return response;
};
```
+ Per i dettagli sull'API, [SetQueueAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/sqs/command/SetQueueAttributesCommand)consulta *AWS SDK per JavaScript API Reference*.
------
#### [ PowerShell ]
**Strumenti per PowerShell V4**
**Esempio 1: questo esempio mostra come impostare una policy per sottoscrivere una coda a un argomento SNS. Quando si pubblica un messaggio in un argomento, viene inviato un messaggio a ogni coda sottoscritta.**
```
# create the queue and topic to be associated
$qurl = New-SQSQueue -QueueName "myQueue"
$topicarn = New-SNSTopic -Name "myTopic"
# get the queue ARN to inject into the policy; it will be returned
# in the output's QueueARN member but we need to put it into a variable
# so text expansion in the policy string takes effect
$qarn = (Get-SQSQueueAttribute -QueueUrl $qurl -AttributeName "QueueArn").QueueARN
# construct the policy and inject arns
$policy = @"
{
"Version":"2012-10-17",
"Id": "$qarn/SQSPOLICY",
"Statement": [
{
"Sid": "1",
"Effect": "Allow",
"Principal": "*",
"Action": "SQS:SendMessage",
"Resource": "$qarn",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "$topicarn"
}
}
}
]
}
"@
# set the policy
Set-SQSQueueAttribute -QueueUrl $qurl -Attribute @{ Policy=$policy }
```
**Esempio 2: questo esempio imposta gli attributi specificati della coda specificata.**
```
Set-SQSQueueAttribute -Attribute @{"DelaySeconds" = "10"; "MaximumMessageSize" = "131072"} -QueueUrl https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyQueue
```
+ Per i dettagli sull'API, vedere [SetQueueAttributes](https://docs.aws.amazon.com/powershell/v4/reference)in *AWS Strumenti per PowerShell Cmdlet Reference (*V4).
**Strumenti per V5 PowerShell **
**Esempio 1: questo esempio mostra come impostare una policy per sottoscrivere una coda a un argomento SNS. Quando si pubblica un messaggio in un argomento, viene inviato un messaggio a ogni coda sottoscritta.**
```
# create the queue and topic to be associated
$qurl = New-SQSQueue -QueueName "myQueue"
$topicarn = New-SNSTopic -Name "myTopic"
# get the queue ARN to inject into the policy; it will be returned
# in the output's QueueARN member but we need to put it into a variable
# so text expansion in the policy string takes effect
$qarn = (Get-SQSQueueAttribute -QueueUrl $qurl -AttributeName "QueueArn").QueueARN
# construct the policy and inject arns
$policy = @"
{
"Version":"2012-10-17",
"Id": "$qarn/SQSPOLICY",
"Statement": [
{
"Sid": "1",
"Effect": "Allow",
"Principal": "*",
"Action": "SQS:SendMessage",
"Resource": "$qarn",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "$topicarn"
}
}
}
]
}
"@
# set the policy
Set-SQSQueueAttribute -QueueUrl $qurl -Attribute @{ Policy=$policy }
```
**Esempio 2: questo esempio imposta gli attributi specificati della coda specificata.**
```
Set-SQSQueueAttribute -Attribute @{"DelaySeconds" = "10"; "MaximumMessageSize" = "131072"} -QueueUrl https://sqs.us-east-1.amazonaws.com/80398EXAMPLE/MyQueue
```
+ Per i dettagli sull'API, vedere [SetQueueAttributes](https://docs.aws.amazon.com/powershell/v5/reference)in *AWS Strumenti per PowerShell Cmdlet Reference (*V5).
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è altro su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/topics_and_queues#code-examples).
Imposta l’attributo della policy di una coda per un argomento.
```
class SqsWrapper:
"""Wrapper class for managing Amazon SQS operations."""
def __init__(self, sqs_client: Any) -> None:
"""
Initialize the SqsWrapper.
:param sqs_client: A Boto3 Amazon SQS client.
"""
self.sqs_client = sqs_client
@classmethod
def from_client(cls) -> 'SqsWrapper':
"""
Create an SqsWrapper instance using a default boto3 client.
:return: An instance of this class.
"""
sqs_client = boto3.client('sqs')
return cls(sqs_client)
def set_queue_policy_for_topic(self, queue_arn: str, topic_arn: str, queue_url: str) -> bool:
"""
Set the queue policy to allow SNS to send messages to the queue.
:param queue_arn: The ARN of the SQS queue.
:param topic_arn: The ARN of the SNS topic.
:param queue_url: The URL of the SQS queue.
:return: True if successful.
:raises ClientError: If setting the queue policy fails.
"""
try:
# Create policy that allows SNS to send messages to the queue
policy = {
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "sns.amazonaws.com"
},
"Action": "sqs:SendMessage",
"Resource": queue_arn,
"Condition": {
"ArnEquals": {
"aws:SourceArn": topic_arn
}
}
}
]
}
self.sqs_client.set_queue_attributes(
QueueUrl=queue_url,
Attributes={
'Policy': json.dumps(policy)
}
)
logger.info(f"Set queue policy for {queue_url} to allow messages from {topic_arn}")
return True
except ClientError as e:
error_code = e.response.get('Error', {}).get('Code', 'Unknown')
logger.error(f"Error setting queue policy: {error_code} - {e}")
raise
```
+ Per i dettagli sull'API, consulta [SetQueueAttributes AWS](https://docs.aws.amazon.com/goto/boto3/sqs-2012-11-05/SetQueueAttributes)*SDK for Python (Boto3) API Reference*.
------
#### [ Swift ]
**SDK per Swift**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/swift/example_code/sqs#code-examples).
```
import AWSSQS
let config = try await SQSClient.SQSClientConfiguration(region: region)
let sqsClient = SQSClient(config: config)
do {
_ = try await sqsClient.setQueueAttributes(
input: SetQueueAttributesInput(
attributes: [
"MaximumMessageSize": "\(maxSize)"
],
queueUrl: url
)
)
} catch _ as AWSSQS.InvalidAttributeValue {
print("Invalid maximum message size: \(maxSize) kB.")
}
```
+ Per i dettagli sull'API, consulta la [SetQueueAttributes](https://sdk.amazonaws.com/swift/api/awssqs/latest/documentation/awssqs/sqsclient/setqueueattributes(input:))guida di riferimento all'*API AWS SDK for Swift*.
------