Golang
1 - Install go SDK
To install the SDK and its dependencies, run the following Go command.
go get -u github.com/aws/aws-sdk-go/…
If you set the environment variable to 1, you can use the following command to get the SDK. The SDK's runtime dependencies are vendored in the vendor/ folder.
go get -u github.com/aws/aws-sdk-go
2 - initialize your folder using (if not already initialized)
go mod init
3 - make connection with the EQS client
To make the connection with the EQS client , you need to pass configurations and credentials.
Configurations-
region_name- your_region
endpoint_url - eqs_endpoint_url (provided by e2e networks eqs service)
Credentials-
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
create a new file named credentials.go .
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/sqs"
)
//..
accessKey := "your-access-key"
secretKey := "your-secret-key"
creds := credentials.NewStaticCredentials(accessKey, secretKey, "")
sess , err := session.NewSession(&aws.Config{
Region: aws.String("region_name"),
Endpoint: aws.String("endpoint_url"),
Credentials: creds,
});
if err != nil {
fmt.println(“Failed to create session”,err)
os.Exit(1)
}
eqs_client := sqs.New(sess)
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
[default]
region = “your_region”
put in ~/.aws/configuration file
[default]
aws_access_key_id = “your access key id”
aws_secret_access_key = “your secret key”
create a new file named credentials.go .
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/sqs"
)
//..
sess , err := session.NewSession(&aws.Config{
Endpoint: aws.String(ENDPOINT),
});
if err != nil {
fmt.println(“Failed to create session”,err)
os.Exit(1)
}
eqs_client := sqs.New(sess)
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)
$ 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)
> 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
AWS_ACCESS_KEY_ID = your_access_key_id
AWS_SECRET_ACCESS_KEY = your_secret_access_key
AWS_DEFAULT_REGION = your_eqs_region
create a new file named credentials.go .
import (
"fmt"
"os"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/sqs"
"github.com/joho/godotenv"
)
//..
err := godotenv.Load(".env")
if err != nil {
fmt.Println("Error loading .env file")
return
}
accessKey := os.Getenv("AWS_ACCESS_KEY_ID")
secretKey := os.Getenv("AWS_SECRET_ACCESS_KEY")
region := os.Getenv("AWS_REGION")
creds := credentials.NewStaticCredentials(accessKey, secretKey, "")
config := &aws.Config{
Region: aws.String(region),
Endpoint: aws.String("endpoint_url"),
Credentials: creds,
}
sess := session.Must(session.NewSession(config))
eqs_client := sqs.New(sess)
Methods available for eqs_client
Change Visibility Timeout
Visibility Timeout refers to the amount of time that a message remains invisible to other consumers after it has been retrieved by a consumer.
Request Syntax
get queue name, receipt handle, visibility timeout
queue := flag.String("q", "your_queue_name", "The name of the queue")
handle := flag.String("h", "message_receipt_handle", "The receipt handle of the message")
visibility := flag.Int64("v", 50, "The duration, in seconds, that the message is not visible to other consumers")
flag.Parse()
if *queue == "" || *handle == "" {
fmt.Println("You must supply a queue name (-q QUEUE) and message receipt handle (-h
HANDLE)")
return
}
if *visibility < 0 {
*visibility = 0
}
if *visibility > 12*60*60 {
*visibility = 12 * 60 * 60
}
get queue url using eqs_client
result, err := eqs_client.GetQueueUrl(&sqs.GetQueueUrlInput{
QueueName: queue,
})
queueURL := urlResult.QueueUrl
calling ChangeMessageVisibility method using eqs_client
_, err := eqs_client.ChangeMessageVisibility(&sqs.ChangeMessageVisibilityInput{
ReceiptHandle: handle,
QueueUrl: queueURL,
VisibilityTimeout: visibility,
})
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)
Valid values - 0 to 43,200 seconds (12 hours)
default - 30 second
Response Syntax
nil
Create Queue
Request Syntax
get queue name
queue := flag.String("q", "your_queue_name", "The name of the queue")
flag.Parse()
if *queue == "" {
fmt.Println("You must supply a queue name (-q QUEUE")
return
}
Use CreateQueue method using eqs_client to create a queue using queue name, You can also define attributes and tags for the queue
result, err := eqs_client.CreateQueue(&sqs.CreateQueueInput{
QueueName: queue,
Attributes: map[string]*string{
"DelaySeconds": aws.String("60"),
"MessageRetentionPeriod": aws.String("86400"),
},
Tags: map[string]*string{
"Environment": aws.String("Production"),
"Application": aws.String("MyApp"),
},
})
take queue url from result
fmt.Println("URL: " + *result.QueueUrl)
Parameters
QueueName (string)- [Required] 1 - A queue name can have up to 80 characters
2 - Valid values: alphanumeric characters, hyphens ( -), and underscores ( _).
Attributes (map)- 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) -
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 (result)
{ QueueUrl: "queue_url"}
Delete message
Request Syntax
get the queue name and message handle
queue := flag.String("q", "", "The name of the queue")
messageHandle := flag.String("m", "", "The receipt handle of the message")
flag.Parse()
if *queue == "" || *messageHandle == "" {
fmt.Println("You must supply a queue name (-q QUEUE) and message receipt handle (-m
MESSAGE-HANDLE)")
return
}
pass queue url and message handle and call DeleteMessage method using client
_, err := eqs_client.DeleteMessage(&sqs.DeleteMessageInput{
QueueUrl: queueURL,
ReceiptHandle: messageHandle,
})
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
nil
Delete message in batch
Request Syntax
prepare the input for DeleteMessageBatch API call
input = &sqs.DeleteMessageBatchInput{QueueUrl: aws.String(queueURL), }
for i, receiptHandle := range messageReceiptHandles {
input.Entries = append(input.Entries, &sqs.DeleteMessageBatchRequestEntry{
Id: aws.String(strconv.Itoa(i)),
ReceiptHandle: receiptHandle,
})
}
call the DeleteMessageBatch method using eqs_client
_, err = eqs_client.DeleteMessageBatch(input)
if err!= nil {
return err
}
Parameters
QueueUrl (string) - [Required] The URL of the E2E EQS queue from which messages are deleted.
Entries (slice) - [Required] (map) id [Required]-(string) An identifier for this particular receipt handle used to communicate the result ReceiptHandle [Required] -(string) A receipt handle
Response Syntax
{
"Successful": [{"Id": "string"}, ],
"Failed": [
{
"Id": "string",
"SenderFault": True | False,
"Code": "string",
"Message": "string",
},
],
}
Delete queue
Request Syntax
getting the queue url*
queueURL := "your-queue-url"
calling the DeleteQueue method using eqs_client
_, err := eqs_client.DeleteQueue(&sqs.DeleteQueueInput{
QueueUrl: aws.String(queueURL),
})
if err != nil {
// handle error
}
Parameters
QueueUrl (string) - [Required]
The URL of the E2E EQS queue to delete.
Response Syntax
nil
Get queue attributes
Request Syntax
calling GetQueueAttributes method using eqs_client
result, err := eqs_client.GetQueueAttributes(&sqs.GetQueueAttributesInput{
QueueUrl: aws.String("queue-url"),
AttributeNames: []*string{
aws.String(sqs.QueueAttributeNameAll),
},
})
Parameters
QueueUrl (string) - [Required] The URL of the E2E EQS queue from which attributes are get.
AttributeNames (slice) - [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
{
Attributes: map[string]*string{
"VisibilityTimeout": aws.String("60"),
},
}
Get queue url
Request Syntax
getting input using queue name
input := &sqs.GetQueueUrlInput{
QueueName: aws.String("my_queue_name"),
}
*calling GetQueueUrl method using eqs_client passing input as params*
```go
result, err := eqs_client.GetQueueUrl(input)
if err != nil {
fmt.println("Error in getting queue", err)
return
}
fmt.Println("Queue URL:", *result.QueueUrl)
Parameters
QueueName (string) -[Required] The name of the queue whose URL must be fetched.
Response Syntax
{ QueueUrl: string, }
List queue tags
Request Syntax
defining input using queue url
input := &sqs.ListQueueTagsInput{
QueueUrl: aws.String(queueUrl),
}
calling ListQueueTags method using eqs_client
resp, err := eqs_client.ListQueueTags(input)
if err != nil {
fmt.Println("Error listing queue tags:", err)
return
}
Parameters
QueueUrl (string) - [Required] The URL of the E2E EQS queue of which all the tags must be listed.
Response Syntax
type ListQueueTagsOutput struct {
Tags map[string]*string `type:"map" required:"true"`
}
List queues
Request Syntax
Set the queue name prefix and max results to retrieve
queueNamePrefix := "my-queue"
maxResults := int64(10)
Call the ListQueues API with the specified parameters
resp, err := svc.ListQueues(&sqs.ListQueuesInput{
QueueNamePrefix: &queueNamePrefix,
MaxResults: &maxResults,
})
if err != nil {
fmt.Println("Error listing queues:", err)
return
}
Print out the URLs of the returned queues
for _, url := range resp.QueueUrls {
fmt.Println(*url)
}
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 (resp)
type ListQueuesOutput struct {
QueueUrls []*string `type:"list" required:"true"`
}
Purge queue
delete all the messages from queue.
Request Syntax
calling PurgeQueue method using eqs_client
_, err := eqs_client.PurgeQueue(&sqs.PurgeQueueInput{
QueueUrl: queueURL,
})
if err != nil {
fmt.Println("Error purging queue:", err)
return
}
Parameters
QueueUrl (string) - [Required] The URL of the E2E EQS queue of which all the messages must be deleted.
Response Syntax
nil
Receive Message
Request Syntax getting queue url, visibility timeout, AttributeNames, MessageAttributeNames, maxNumberOfMessages and waitTimeSeconds
queueURL := "YOUR_QUEUE_URL"
attributeNames := []*string{
aws.String("All"), // returns all attributes
}
messageAttributeNames := []*string{
aws.String("ATTRIBUTE_NAME"),
}
maxNumberOfMessages := aws.Int64(2)
visibilityTimeout := aws.Int64(25)
waitTimeSeconds := aws.Int64(10)
calling ReceiveMessage method using eqs_client
result, err := eqs_client.ReceiveMessage(&sqs.ReceiveMessageInput{
AttributeNames: attributeNames,
MessageAttributeNames: messageAttributeNames,
MaxNumberOfMessages: maxNumberOfMessages,
QueueUrl: &queueURL,
VisibilityTimeout: visibilityTimeout,
WaitTimeSeconds: waitTimeSeconds,
})
if err != nil {
fmt.Println("Error receiving messages:", err)
return
}
Parameters
QueueUrl (string) - [Required] The URL of the E2E EQS queue from which messages are received.
AttributeNames (slice) - 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 (slice) - 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
type ReceiveMessageOutput struct {
Messages []*Message // a list of received messages
}
type Message struct {
MessageId *string
ReceiptHandle *string
MD5OfBody *string
Body *string
MD5OfMessageAttributes *string
Attributes map[string]*string // message system attributes
MessageAttributes map[string]*MessageAttributeValue // message user-defined attributes
}
type MessageAttributeValue struct {
StringValue *string // string value of the message attribute
BinaryValue []byte // binary value of the message attribute
DataType *string // data type of the message attribute
}
Send message
Request Syntax setting up params
params := &sqs.SendMessageInput{
QueueUrl: aws.String("QUEUE_URL_HERE"),
MessageBody: aws.String("MESSAGE_BODY_HERE"),
DelaySeconds: aws.Int64(123),
MessageAttributes: map[string]*sqs.MessageAttributeValue{
"ATTRIBUTE_NAME_HERE": {
DataType: aws.String("STRING"),
StringValue: aws.String("ATTRIBUTE_VALUE_HERE"),
},
},
MessageSystemAttributes: map[string]*sqs.MessageSystemAttributeValue{
"SYSTEM_ATTRIBUTE_NAME_HERE": {
DataType: aws.String("STRING"),
StringValue: aws.String("SYSTEM_ATTRIBUTE_VALUE_HERE"),
},
},
}
calling Send message method using eqs_client
resp, err := eqs_client.SendMessage(params)
if err != nil {
// handle error
return
}
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) -
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) - 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) - 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) - 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
resp := &sqs.SendMessageOutput{
MD5OfMessageBody: aws.String("hash_of_message_body"),
MD5OfMessageAttributes: aws.String("hash_of_message_attribute"),
MD5OfMessageSystemAttributes: aws.String("hash_of_message_system_attributes"),
MessageId: aws.String("message_id"),
SequenceNumber: aws.String("sequence_number"),
}
Send message in batch
Request Syntax calling SendMessageBatch method using eqs_client
resp, err := eqs_client.SendMessageBatch(&sqs.SendMessageBatchInput{
QueueUrl: aws.String("QUEUE_URL"),
Entries: []*sqs.SendMessageBatchRequestEntry{
{
Id: aws.String("MESSAGE_ID_1"),
MessageBody: aws.String("MESSAGE_BODY_1"),
DelaySeconds: aws.Int64(0),
MessageAttributes: map[string]*sqs.MessageAttributeValue{
"ATTRIBUTE_NAME_1": &sqs.MessageAttributeValue{
DataType: aws.String("STRING"),
StringValue: aws.String("ATTRIBUTE_VALUE_1"),
},
"ATTRIBUTE_NAME_2": &sqs.MessageAttributeValue{
DataType: aws.String("NUMBER"),
StringValue: aws.String("ATTRIBUTE_VALUE_2"),
},
},
MessageSystemAttributes: map[string]*sqs.MessageSystemAttributeValue{
"SYSTEM_ATTRIBUTE_NAME_1": &sqs.MessageSystemAttributeValue{
DataType: aws.String("STRING"),
StringValue: aws.String("SYSTEM_ATTRIBUTE_VALUE_1"),
},
"SYSTEM_ATTRIBUTE_NAME_2": &sqs.MessageSystemAttributeValue{
DataType: aws.String("BINARY"),
BinaryValue: []byte("SYSTEM_ATTRIBUTE_VALUE_2"),
},
},
},
{
Id: aws.String("MESSAGE_ID_2"),
MessageBody: aws.String("MESSAGE_BODY_2"),
DelaySeconds: aws.Int64(0),
MessageAttributes: map[string]*sqs.MessageAttributeValue{
"ATTRIBUTE_NAME_3": &sqs.MessageAttributeValue{
DataType: aws.String("STRING"),
StringValue: aws.String("ATTRIBUTE_VALUE_3"),
},
"ATTRIBUTE_NAME_4": &sqs.MessageAttributeValue{
DataType: aws.String("NUMBER"),
StringValue: aws.String("ATTRIBUTE_VALUE_4"),
},
},
MessageSystemAttributes: map[string]*sqs.MessageSystemAttributeValue{
"SYSTEM_ATTRIBUTE_NAME_3": &sqs.MessageSystemAttributeValue{
DataType: aws.String("STRING"),
StringValue: aws.String("SYSTEM_ATTRIBUTE_VALUE_3"),
},
"SYSTEM_ATTRIBUTE_NAME_4": &sqs.MessageSystemAttributeValue{
DataType: aws.String("BINARY"),
BinaryValue: []byte("SYSTEM_ATTRIBUTE_VALUE_4"),
},
},
},
},
})
if err != nil {
fmt.Println("Error", err)
return
}
Parameters
QueueUrl (string) - [Required] The URL of the E2E EQS queue to which messages are sent.
Entries (slice) - [Required] A list of SendMessageBatchRequestEntry items.
(Dict) -
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) - 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) - 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
type SendMessageBatchOutput struct {
Successful []SendMessageBatchResultEntry `locationNameList:"SendMessageBatchResultEntry" type:"list"`
Failed []BatchResultErrorEntry `locationNameList:"BatchResultErrorEntry" type:"list"`
}
type SendMessageBatchResultEntry struct {
Id *string `type:"string"`
MessageId *string `type:"string"`
MD5OfMessageAttributes *string `type:"string"`
MD5OfMessageBody *string `type:"string"`
MD5OfMessageSystemAttributes *string `type:"string"`
SequenceNumber *string `type:"string"`
}
type BatchResultErrorEntry struct {
Id *string `type:"string"`
SenderFault *bool `type:"boolean"`
Code *string `type:"string"`
Message *string `type:"string"`
}
Set queue Attributes
Request Syntax
calling SetQueueAttributes method using eqs_client
_, err := eqs_client.SetQueueAttributes(&sqs.SetQueueAttributesInput{
QueueUrl: aws.String("YOUR_QUEUE_URL_HERE"),
Attributes: map[string]*string{
"Attribute1": aws.String("Value1"),
"Attribute2": aws.String("Value2"),
// Add more attributes here as needed.
},
})
if err != nil {
// Handle error.
panic(err)
}
Parameters
QueueUrl (string) - [Required] The URL of the E2E EQS queue of which attributes should be set.
Attributes (map) : [Required] A map of attributes to set.
Response Syntax
nil
Tag queue
Request Syntax
calling TagQueue method using eqs_client
resp, err := svc.TagQueue(&sqs.TagQueueInput{
QueueUrl: aws.String("YOUR_QUEUE_URL_HERE"),
Tags: map[string]*string{
"Tag1": aws.String("Value1"),
"Tag2": aws.String("Value2"),
// Add more tags here as needed.
},
})
if err != nil {
// Handle error.
panic(err)
}
Parameters
QueueUrl (string) - [Required] The URL of the E2E EQS queue.
Tags (map) - [Required] The list of tags to be added to the specified queue.
Response Syntax
nil
Untag Queue
Request Syntax
set queue url and tags
queueURL := "your_queue_url"
tags := map[string]*string{
"Environment": aws.String("production"),
"Owner": aws.String("example@example.com"),
}
set input params
params := &sqs.TagQueueInput{
QueueUrl: &queueURL,
Tags: tags,
}
calling UntagQueue method using eqs_client
_, err := svc.TagQueue(params)
if err != nil {
fmt.Println("Error setting tags:", err)
return
}
fmt.Println("Tags successfully set!")
Parameters
QueueUrl (string) - [Required] The URL of the E2E EQS queue.
TagKeys (slice) - [Required] The list of tags to be removed from the specified queue.
Response Syntax
nil