# Java 1 - Install java and maven 2 - go to project directory and enter the command ```java mvn archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-app-quickstart \ -DarchetypeVersion=2.18.16 ``` *Enter the prompt values* | Prompt | Value to enter | |-------------------------------------------------|-------------------| | Define value for property 'service': | s3 | | Define value for property 'httpClient': | apache-client | | Define value for property 'nativeImage': | false | | Define value for property 'groupId': | org.example | | Define value for property 'artifactId': | getstarted | | Define value for property 'version' 1.0-SNAPSHOT: | \ | | Define value for property 'package' org.example: | \ | 3 - your project directory would look something like this ```java |----getstarted ├── README.md ├── pom.xml └── src ├── main │ ├── java │ │ └── org │ │ └── example │ │ ├── App.java │ │ ├── DependencyFactory.java │ │ └── Handler.java │ └── resources │ └── simplelogger.properties └── test └── java └── org └── example └── HandlerTest.java ``` 10 directories, 7 files *your app.java file* ```java package org.example; import java.util.List; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class App { private static final Logger logger = LoggerFactory.getLogger(App.class); public static void main(String... args) { logger.info("Application starts"); Handler handler = new Handler(); //you can call function of handler through handler object logger.info("Application ends"); } } ``` 4 - make connection with the EQS client To make the connection with the EQS client , you need to pass configurations and credentials. **Configurations-** ```java region_name- your_region endpoint_url - eqs_endpoint_url (provided by e2e networks eqs service) ``` **Credentials-** ```java aws_access_key_id - your_access_key_id aws_secret_key_id - your_secret_key_id ``` ## Make connection with EQS There are many ways to provide credentials and configuration to connect with EQS service - **a)** providing credentials directly to client object - **warning** - Hardcoded credentials in application is not recommended *Update your DependencyFactory.java file* ```java package org.example; import java.net.URI; import software.amazon.awssdk.auth.credentials.*; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.sqs.*; public class DependencyFactory { private DependencyFactory() {} public static SqsClient sqsClient() { AwsCredentialscredentials=AwsBasicCredentials.create(“your_ access_key_id”, “your_secret_access_key”); URI endpointUri = URI.create("your e2e eqs access url"); Region region = Region.of("elasticmq"); SqsClient eqs_client = SqsClient.builder() .credentialsProvider(StaticCredentialProvider.create(credentials)) .endpointOverride(endpointUri) .region(region) .build(); return eqs_client; } } ``` **b)** you can put credentials and configurations in the config and credentials file , and these files should be located at **~/.aws/config**, **~/.aws/credentials** location, client will automatically access these credentials and configurations. *put in* **~/.aws/credentials** *file* ```java [default] region = “your_region” *put in* **~/.aws/configuration** *file* ```java [default] aws_access_key_id = “your access key id” aws_secret_access_key = “your secret key” ``` *Update your DependencyFactory.java file* ```java package org.example; import java.net.URI; import software.amazon.awssdk.auth.credentials.*; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.sqs.SqsClient; public class DependencyFactory { private DependencyFactory() {} public static SqsClient sqsClient() { AwsCredentialsProvider credentialsProvider = DefaultCredentialsProvider.builder().build(); Region region = Region.of(new DefaultAwsRegionProviderChain().getRegion()); URI endpointUri = URI.create("e2e_eqs_access_url"); SqsClient eqs_client = SqsClient.builder() .credentialsProvider(credentialsProvider) .endpointOverride(endpointUri) .region(region) .build(); return eqs_client; } ``` **c)** you can make the connection with the EQS client by passing the credentials and configuration into the environment variables file. *using terminal* **(Linux, OS X or Unix)** ```java $ export AWS_ACCESS_KEY_ID = your_access_key_id $ export AWS_SECRET_ACCESS_KEY = your_secret_key $ export AWS_DEFAULT_REGION = your_eqs_region *using terminal* **(Windows)** ```java > set AWS_ACCESS_KEY_ID = your_access_key_id > set AWS_SECRET_ACCESS_KEY = your_secret_key > set AWS_DEFAULT_REGION = your_eqs_region ``` **or,** *edit your environment variable file* ```java AWS_ACCESS_KEY_ID = your_access_key_id AWS_SECRET_ACCESS_KEY = your_secret_access_key AWS_DEFAULT_REGION = your_eqs_region ``` **pom.xml** *file* ```java io.github.cdimascio dotenv-java 2.2.0 ``` *update your* **DependencyFactory.java** ```java import io.github.cdimascio.dotenv.Dotenv; import software.amazon.awssdk.auth.credentials.*; import software.amazon.awssdk.regions.*; import software.amazon.awssdk.services.sqs.*; public class DependencyFactory { public static SqsClient sqsClient() { Dotenv dotenv = Dotenv.load(); AwsCredentials credentials = AwsBasicCredentials.create( dotenv.get("AWS_ACCESS_KEY_ID"), dotenv.get("AWS_SECRET_ACCESS_KEY") ); Region region = Region.of(dotenv.get("AWS_REGION")); URI endpointUri = URI.create("e2e_eqs_access_url"); SqsClient eqs_client = SqsClient.builder() .credentialsProvider(StaticCredentialsProvider.create(credentials)) .endpointOverride(endpointUri) .region(region) .build(); return eqs_client; } } ``` **Methods available in eqs_client** *necessary imports* ```java import com.amazonaws.services.sqs.*; import com.amazonaws.services.sqs.model.*; ``` ## Change VisibilityTimeout **Request Syntax** *your .java file* ```java String queueUrl = "queue_url"; ChangeMessageVisibilityRequest request = ChangeMessageVisibilityRequest.builder() .queueUrl(queueUrl) .receiptHandle("example-receipt-handle") .visibilityTimeout(60) .build(); eqs_client.changeMessageVisibility(request); System.out.println("Message visibility timeout changed successfully!"); ``` **Parameters** **QueueUrl** (string)- [Required] The URL of the E2E EQS queue whose message's visibility is changed. **ReceiptHandle** (string) - [Required] The receipt handle is associated with the message whose visibility timeout is changed. This parameter is returned by the *ReceiveMessage* action **VisibilityTimeout** (integer) - [Required] The new value for the message's visibility timeout (in seconds) **Response Syntax** ```java void ``` ## Change VisibilityTimeout in batch **Request Syntax** *edit your .java file* ```java final String queueUrl = "your_queue_url_here"; ChangeMessageVisibilityBatchRequest request = new ChangeMessageVisibilityBatchRequest() .withQueueUrl(queueUrl) .withEntries( new ChangeMessageVisibilityBatchRequestEntry() .withId("message_1") .withReceiptHandle("receipt_handle_1") .withVisibilityTimeout(3600), new ChangeMessageVisibilityBatchRequestEntry() .withId("message_2") .withReceiptHandle("receipt_handle_2") .withVisibilityTimeout(600) ); ChangeMessageVisibilityBatchResponse response = eqs_client.changeMessageVisibilityBatch(request); ``` **Parameters** **QueueUrl** (string) - [Required] The URL of the E2E EQS queue whose message's visibility is changed. **Entries** (ArrayList/LinkList) - [Required] (objects) *id [Required]-(string) An identifier for this particular receipt handle used to communicate the result* *ReceiptHandle [Required] -(string) A receipt handle* *VisibilityTimeout - (integer) The new value (in seconds) for the message’s visibility timeout* **Response Syntax** ```java ChangeMessageVisibilityBatchResult { Successful: [ ChangeMessageVisibilityBatchResultEntry { Id: "message_1", SenderFault: false } ], Failed: [ ChangeMessageVisibilityBatchResultEntry { Id: "message_2", SenderFault: true, Code: "InvalidParameterValue", Message: "message" } ] } ``` ## Close connection **Request Syntax** *edit your .java file* ```java eqs_client.close() ``` **Response Syntax** ```java None ``` ## Create queue **Request Syntax** *edit your .java file* ```java CreateQueueRequest request = new CreateQueueRequest() .withQueueName("string") .withAttributes(Map.of( "DelaySeconds", "123", "MaximumMessageSize", "456", "MessageRetentionPeriod", "789", "ReceiveMessageWaitTimeSeconds", "10", "VisibilityTimeout", "30" )) .withTags(Map.of( "tag1", "value1", "tag2", "value2" )); CreateQueueResponse response = eqs_client.createQueue(request); String queueUrl = response.getQueueUrl(); ``` **Parameters** **QueueName** (string)- [Required] 1 - A queue name can have up to 80 characters 2 - Valid values: alphanumeric characters, hyphens ( -), and underscores ( _). **Attributes** (Map/HashMap)- Attributes could be 1 - DelaySeconds - Time(second), to which extent delivery of messages is delayed in the queue Valid values - 0 to 900 (second) default - 0 (second) 2 - MaximumMessageSize - The size of the message after which the queue will reject the message Valid values - 1,024 bytes (1 KiB) to 262,144 bytes (256 KiB) default - 262,144 bytes(256 KiB) 3 - MessageRetentionPeriod - Time to which extent a queue will retain a message Valid values - 60 seconds (1 minute) to 1,209,600 seconds (14 days) default - 345,600 (4 days) 4 - ReceiveMessageWaitTimeSeconds - Time to which extent *ReceiveMessage* action waits before receiving a message Valid values - 0 to 20 (seconds) default - 0 (second) 5 - VisibilityTimeout - The amount of time that a message in a queue is invisible to other consumers after a consumer retrieves it. Valid values - 0 to 43,200 seconds (12 hours) default - 30 second **tags** (Map/HashMap) - 1 - Adding more than 50 tags to a queue isn't recommended. 2 - A new tag with a key identical to that of an existing tag overwrites the existing tag. **Response Syntax** ```java { "QueueUrl": "string" } ``` ## Delete message **Request Syntax** *edit your .java file* ```java DeleteMessageRequest request = new DeleteMessageRequest() .withQueueUrl("string") .withReceiptHandle("string"); eqs_client.deleteMessage(request); ``` **Parameters** **QueueUrl** (string) - [Required] The URL of the E2E EQS queue from which messages are deleted. **ReceiptHandle** (string) - [Required] The receipt handle is associated with the message to delete. **Response Syntax** ```java void ``` ## Delete message in batch **Request Syntax** *edit your .java file* ```java DeleteMessageBatchRequest request = new DeleteMessageBatchRequest() .withQueueUrl("string") .withEntries( new DeleteMessageBatchRequestEntry() .withId("string") .withReceiptHandle("string"), new DeleteMessageBatchRequestEntry() .withId("string") .withReceiptHandle("string"), ); DeleteMessageBatchResult result = eqs_client.deleteMessageBatch(request); ``` **Parameters** **QueueUrl** (string) - [Required] The URL of the E2E EQS queue from which messages are deleted. **Entries** (ArrayList/LinkList) - [Required] (objects) *id [Required]-(string) An identifier for this particular receipt handle used to communicate the result* *ReceiptHandle [Required] -(string) A receipt handle* **Response Syntax** ```java public class DeleteMessageBatchResult { private List successful; private List failed; } public class DeleteMessageBatchResultEntry { private String id; } public class BatchResultErrorEntry { private String id; private boolean senderFault; private String code; private String message; } ``` ## Delete queue **Request Syntax** ```java String queueUrl = "your_queue_url_here"; DeleteQueueRequest request = new DeleteQueueRequest(queueUrl); eqs_client.deleteQueue(request); ``` **Parameters** **QueueUrl** (string) - [Required] The URL of the E2E EQS queue to delete. **Response Syntax** ```java void ``` ## Get queue attributes **Request Syntax** *edit your .java file* ```java GetQueueAttributesRequest request = new GetQueueAttributesRequest() .withQueueUrl("queue_url") .withAttributeNames("All"); GetQueueAttributesResult result = sqsClient.getQueueAttributes(request); Map attributes = result.getAttributes(); ``` **Parameters** **QueueUrl** (string) - [Required] The URL of the E2E EQS queue from which attributes are get. **AttributeNames** (ArrayList/LinkList) - [Optional] A list of attributes for which to retrieve information *All - it specifies, returns all values* you can also specify specific attributes in the list *As - ('VisibilityTimeout' , 'MaximumMessageSize' , 'MessageRetentionPeriod' , 'ApproximateNumberOfMessages' ,'ApproximateNumberOfMessagesNotVisible' , 'CreatedTimestamp' , 'LastModifiedTimestamp' , 'QueueArn' , 'ApproximateNumberOfMessagesDelayed' , 'DelaySeconds' , 'ReceiveMessageWaitTimeSeconds')* **Response Syntax** ```java GetQueueAttributesResult{attributes={ VisibilityTimeout=30, MaximumMessageSize=262144, MessageRetentionPeriod=345600, ApproximateNumberOfMessages=0, ApproximateNumberOfMessagesNotVisible=0, CreatedTimestamp=Tue Apr 27 05:00:00 UTC 2021, LastModifiedTimestamp=Tue Apr 27 05:00:00 UTC 2021, }} ``` ## Get queue url **Request Syntax** *edit your .java file* ```java GetQueueUrlResult result = eqs_client.getQueueUrl(GetQueueUrlRequest.builder().queueName(queue_name).build()); String queueUrl = result.queueUrl(); ``` **Parameters** **QueueName** (string) -[Required] The name of the queue whose URL must be fetched. **Response Syntax** ```java {'QueueUrl': 'string'} ``` ## List queue tags **Request Syntax** *edit your .java file* ```java SqsClient sqsClient = SqsClient.create(); String queueUrl = "YOUR_QUEUE_URL"; ListQueueTagsRequest Request = ListQueueTagsRequest.builder() .queueUrl(queueUrl) .build(); ListQueueTagsResponse Response = sqsClient.listQueueTags(Request); //.. System.out.println("Queue Tags: " + Response.tags()); ``` **Parameters** **QueueUrl** (string) - [Required] The URL of the E2E EQS queue of which all the tags must be listed. **Response Syntax** ```java { "Tags": { "TagKey1": "TagValue1", "TagKey2": "TagValue2", } } ``` ## List queues **Request Syntax** *edit your .java file* ```java ListQueuesRequest Request = ListQueuesRequest.builder() .queueNamePrefix("YOUR_QUEUE_NAME_PREFIX") .maxResults(10) .build(); ListQueuesResponse Response = sqsClient.listQueues(Request); System.out.println("Queue URLs: " + Response.queueUrls()); **Parameters** **QueueNamePrefix** (string) - [Optional] A string to use for filtering the list results. Only those queues whose name begins with the specified string are returned. **MaxResults** (integer) - [Optional] The maximum number of results to include in the response. Valid values - 1 to 1000 **Response Syntax** ```java { "QueueUrls": ["string", ], } ``` ## Purge queue delete all the messages from queue. **Request Syntax** *edit your .java file* ```java String queueUrl = "queue_url"; PurgeQueueRequest purgeRequest = new PurgeQueueRequest(queueUrl); PurgeQueueResult purgeResult = eqs_client.purgeQueue(purgeRequest); System.out.println("Messages purged from queue " + queueUrl + "."); ``` **Parameters** **QueueUrl** (string) - [Required] The URL of the E2E EQS queue of which all the messages must be deleted. **Response Syntax** ```java void ``` ## Receive message **Request Syntax** *edit your .java file* ```java String queueUrl = "your_queue_url_here"; ReceiveMessageRequest Request = new ReceiveMessageRequest(queueUrl) .withAttributeNames("All") // can specify specific attributes as well .withMessageAttributeNames("your_message_attribute_name_here") .withMaxNumberOfMessages(2) .withVisibilityTimeout(25) .withWaitTimeSeconds(10) .withReceiveRequestAttemptId("your_receive_request_attempt_id_here"); ReceiveMessageResult Result = eqs_client.receiveMessage(Request); ``` **Parameters** **QueueUrl** (string) - [Required] The URL of the E2E EQS queue from which messages are received. **AttributeNames** (ArrayList/LinkList) - A list of attributes that need to be returned along with each message. *All - it specifies, returns all values* you can also specify specific attributes in the list *As - ('VisibilityTimeout' , 'MaximumMessageSize' , 'MessageRetentionPeriod' , 'ApproximateNumberOfMessages' ,'ApproximateNumberOfMessagesNotVisible' , 'CreatedTimestamp' , 'LastModifiedTimestamp' , 'QueueArn' , 'ApproximateNumberOfMessagesDelayed' , 'DelaySeconds' , 'ReceiveMessageWaitTimeSeconds')* **MessageAttributeNames** (ArrayList/LinkList) - The name of the message attribute. **MaxNumberOfMessages** (integer) - The maximum number of messages to return. Valid range - 1 to 10 default - 1 **VisibilityTimeout** (integer) - The duration (in seconds) that the received messages are hidden from subsequent retrieve requests after being retrieved by a ReceiveMessage request. **WaitTimeSeconds** (integer) - The duration (in seconds) for which the call waits for a message to arrive in the queue before returning. **Response Syntax** ```java { "Messages": [ { "MessageId": "message_id", "ReceiptHandle": "receipt_handle", "MD5OfBody": "message_body_hash", "Body": "message_body", "Attributes": { "ApproximateReceiveCount": "1", "SentTimestamp": "send_time_stamp", "SenderId": "sender_id", "ApproximateFirstReceiveTimestamp": "approx_first_receive_time_stamp" }, "MD5OfMessageAttributes": "message_attributes_hash", "MessageAttributes": { "MyAttribute": { "StringValue": "string_value", "DataType": "String" } } }, ] } ``` ## Send Message **Request Syntax** *edit your .java file* ```java String queueUrl = "QUEUE_URL"; String messageBody = "MESSAGE_BODY"; int delaySeconds = 0; // optional SendMessageRequest request = new SendMessageRequest() .withQueueUrl(queueUrl) .withMessageBody(messageBody) .withDelaySeconds(delaySeconds); // Optional message attributes Map messageAttributes = new HashMap<>(); messageAttributes.put("Attribute1", new MessageAttributeValue() .withDataType("String") .withStringValue("Value1")); messageAttributes.put("Attribute2", new MessageAttributeValue() .withDataType("Number") .withStringValue("123")); request.setMessageAttributes(messageAttributes); // Optional message system attributes Map messageSystemAttributes = new HashMap<>(); messageSystemAttributes.put("SystemAttribute1", new MessageSystemAttributeValue() .withDataType("String") .withStringValue("Value1")); messageSystemAttributes.put("SystemAttribute2", new MessageSystemAttributeValue() .withDataType("Number") .withStringValue("123")); request.setMessageSystemAttributes(messageSystemAttributes); SendMessageResult result = eqs_client.sendMessage(request); ``` **Parameters** **QueueUrl** (string) - [Required] The URL of the E2E EQS queue to which messages are send. **MessageBody** (string) - [Required] The message to send. The minimum size is one character. The maximum size is 256 KB. **DelaySeconds** (integer) - The length of time, in seconds, for which to delay a specific message. **MessageAttributes** (Map/HashMap) - Each message attribute consists of a Name, Type, and Value . Name, type, value and the message body must not be empty or null . (string) - name of the message attributes (Map/HashMap) - Value of message attributes 1 - StringValue (string) - Strings are Unicode with UTF-8 binary encoding. 2 - BinaryValue (bytes) - Binary type attributes can store any binary data, such as compressed data, encrypted data, or images. (string) - [Required] Type of message attributes EQS support the following data type Binary, Number, String **MessageSystemAttributes** (Map/HashMap) - Each message system attribute consists of a Name, Type, and Value. The name, type, value and message body must not be empty or null. (string) - the name of the message attributes (Map/HashMap) - Value of message attributes 1 - StringValue (string) - Strings are Unicode with UTF-8 binary encoding. 2 - BinaryValue (bytes) - Binary type attributes can store any binary data, such as compressed data, encrypted data, or images. (string) - Type of message attributes EQS support the following data type Binary , Number , String **Response Syntax** ```java { MessageId: string MD5OfMessageBody: string MD5OfMessageAttributes: string MD5OfMessageSystemAttributes: string SequenceNumber: string } ``` *string represent actual value return by the method* ## Send message in batch **Request Syntax** *edit your .java file* ```java SendMessageBatchRequest Request = new SendMessageBatchRequest() .withQueueUrl("string") .withEntries(new SendMessageBatchRequestEntry() .withId("string") .withMessageBody("string") .withDelaySeconds(123) .withMessageAttributes(Collections.singletonMap( "string", new MessageAttributeValue() .withDataType("string") .withStringValue("string") .withBinaryValue(ByteBuffer.wrap(new byte[]{})) )) .withMessageSystemAttributes(Collections.singletonMap( "string", new MessageSystemAttributeValue() .withDataType("string") .withStringValue("string") .withBinaryValue(ByteBuffer.wrap(new byte[]{})) )), new SendMessageBatchRequestEntry() .withId("string") .withMessageBody("string") .withDelaySeconds(100) .withMessageAttributes(Collections.singletonMap( "string", new MessageAttributeValue() .withDataType("string") .withStringValue("string") .withBinaryValue(ByteBuffer.wrap(new byte[]{})) )) .withMessageSystemAttributes(Collections.singletonMap( "string", new MessageSystemAttributeValue() .withDataType("string") .withStringValue("string") .withBinaryValue(ByteBuffer.wrap(new byte[]{})) )), ); SendMessageBatchResult result = eqs_client.sendMessageBatch(Request); ``` **Parameters** **QueueUrl** (string) - [Required] The URL of the E2E EQS queue to which messages are sent. **Entries** (ArrayList/LinkList) - [Required] A list of SendMessageBatchRequestEntry items. (Map/HashMap) - Contains the details of a single E2E EQS message along with an Id. **Id** (string) - [REQUIRED] An identifier for a message in this batch is used to communicate the result. **MessageBody** (string) - [Required] The message to send. The minimum size is one character. The maximum size is 256 KB. **DelaySeconds** (integer) - The length of time, in seconds, for which to delay a specific message. **MessageAttributes** (map) - Each message attribute consists of a Name, Type, and Value. The Name, type, value and message body must not be empty or null. (string) - The name of the message attributes (map) - Value of message attributes 1 - StringValue (string) - Strings are Unicode with UTF-8 binary encoding. 2 - BinaryValue (bytes) - Binary type attributes can store any binary data, such as compressed data, encrypted data, or images. (string) -[Required] Type of message attributes EQS support the following data type Binary, Number, String **MessageSystemAttributes** (Map/HashMap) - Each message system attribute consists of a Name, Type, and Value. Name, type, value and the message body must not be empty or null. (string) - The name of the message attributes (Map/HashMap) - Value of message attributes 1 - StringValue (string) - Strings are Unicode with UTF-8 binary encoding. 2 - BinaryValue (bytes) - Binary type attributes can store any binary data, such as compressed data, encrypted data, or images. (string) - Type of message attributes EQS support following data type Binary , Number , String **Response Syntax** ```java public class SendMessageBatchResult { private List successful; private List failed; } public class SendMessageBatchResultEntry { private String id; private String messageId; private String mD5OfMessageBody; private String mD5OfMessageAttributes; private String mD5OfMessageSystemAttributes; private String sequenceNumber; } public class BatchResultErrorEntry { private String id; private Boolean senderFault; private String code; private String message; } ``` ## Set queue Attributes **Request Syntax** *edit your .java file* ```java String queueUrl = "your_queue_url"; Map attributes = new HashMap<>(); attributes.put("AttributeName", "AttributeValue"); SetQueueAttributesRequest request = new SetQueueAttributesRequest() .withQueueUrl(queueUrl) .withAttributes(attributes); SetQueueAttributesResult result = eqs_client.setQueueAttributes(request); ``` **Parameters** **QueueUrl** (string) - [Required] The URL of the E2E EQS queue of which attributes should be set. **Attributes** : [Required] A map of attributes to set. **Response Syntax** ```java void ``` ## Tag Queue **Request Syntax** *edit your .java file* ```java String queueUrl = "QUEUE_URL"; Map tags = new HashMap<>(); tags.put("tag1", "value1"); tags.put("tag2", "value2"); TagQueueRequest Request = new TagQueueRequest() .withQueueUrl(queueUrl) .withTags(tags); TageQueueResult Result = eqs_client.tagQueue(Request); ``` **Parameters** **QueueUrl** (string) - [Required] The URL of the E2E EQS queue. **Tags** - [Required] The map of tags to be added to the specified queue. **Response Syntax** ```java void ``` ## Untag queue **Request Syntax** *edit your .java file* ```java List tagKeys = Arrays.asList("tag-key-1", "tag-key-2", "tag-key-3"); UntagQueueRequest Request = new UntagQueueRequest() .withQueueUrl("queue-url") .withTagKeys(tagKeys); UntagqueueResult Result = sqsClient.untagQueue(Request); ``` **Parameters** **QueueUrl** (string) - [Required] The URL of the E2E EQS queue. **TagKeys** (ArrayList/LinkList) - [Required] The list of tags to be removed from the specified queue. **Response Syntax** ```java void ``` ---