Step by Step Guide to Building an Amazon SQS API Integration in Go

Aug 7, 2024 • 5 minute read

Introduction

Hey there, fellow Go developer! Ready to dive into the world of Amazon SQS? You're in for a treat. We'll be using the github.com/aws/aws-sdk-go-v2/service/sqs package to build a robust SQS integration. Buckle up, and let's get coding!

Prerequisites

Before we jump in, make sure you've got:

Go installed (I know, obvious, right?)
An AWS account with credentials
A decent grasp of Go and AWS services

Got all that? Great! Let's move on.

Setting up the project

First things first, let's get our project set up:

mkdir sqs-integration && cd sqs-integration
go mod init sqs-integration
go get github.com/aws/aws-sdk-go-v2/service/sqs

Easy peasy, right?

Configuring AWS SDK

Now, let's get our AWS credentials loaded and create an SQS client:

import (
    "context"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/sqs"
)

cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion("us-west-2"))
if err != nil {
    // Handle error
}

client := sqs.NewFromConfig(cfg)

Creating a queue

Time to create our queue:

result, err := client.CreateQueue(context.TODO(), &sqs.CreateQueueInput{
    QueueName: aws.String("my-awesome-queue"),
    Attributes: map[string]string{
        "DelaySeconds":      "60",
        "MessageRetentionPeriod": "86400",
    },
})

Sending messages

Let's send some messages to our shiny new queue:

_, err = client.SendMessage(context.TODO(), &sqs.SendMessageInput{
    QueueUrl:    result.QueueUrl,
    MessageBody: aws.String("Hello, SQS!"),
    MessageAttributes: map[string]types.MessageAttributeValue{
        "Author": {
            DataType:    aws.String("String"),
            StringValue: aws.String("YourName"),
        },
    },
})

Receiving messages

Now, let's grab those messages:

msgResult, err := client.ReceiveMessage(context.TODO(), &sqs.ReceiveMessageInput{
    QueueUrl:            result.QueueUrl,
    MaxNumberOfMessages: 1,
    WaitTimeSeconds:     20,
})

Processing messages

Time to do something with those messages:

for _, message := range msgResult.Messages {
    // Process message
    fmt.Printf("Message body: %s\n", *message.Body)
    
    // Don't forget to delete the message after processing!
    _, err := client.DeleteMessage(context.TODO(), &sqs.DeleteMessageInput{
        QueueUrl:      result.QueueUrl,
        ReceiptHandle: message.ReceiptHandle,
    })
    if err != nil {
        // Handle error
    }
}

Error handling and best practices

Always check for errors, folks! And remember:

Use long polling (WaitTimeSeconds > 0) for efficiency
Handle visibility timeout to prevent message loss
Batch operations when possible for better performance

Testing the integration

Don't forget to test your code! Here's a quick example:

func TestSendMessage(t *testing.T) {
    // Mock SQS client
    // Test SendMessage function
    // Assert results
}

Conclusion

And there you have it! You've just built a solid Amazon SQS integration in Go. Pretty cool, huh? Remember, this is just the tip of the iceberg. There's so much more you can do with SQS, so keep exploring and building awesome stuff!

Additional resources

Want to dive deeper? Check out:

Now go forth and queue all the things! Happy coding!