配置aws-sdk-go与localstack的SQS进行交互

Question

I need some help trying to integrate aws-sdk-go with localstack to access SQS service.

I tried something like:

result, err := q.Client.SendMessage(&sqs.SendMessageInput{
    MessageAttributes: map[string]*sqs.MessageAttributeValue{
        "JobName": &sqs.MessageAttributeValue{
            DataType:    aws.String("String"),
            StringValue: aws.String(jobName),
        },
    },
    MessageBody: aws.String(messageBody),
    QueueUrl:    &q.URL,
})

if err != nil {
    return "", err
}

With an initialization like:

type Queue struct {
    Client sqsiface.SQSAPI
    URL    string
}

var q Queue

    func init() {
      sess := session.Must(session.NewSessionWithOptions(session.Options{
        SharedConfigState: session.SharedConfigEnable,
    }))

    q = Queue{
        Client: sqs.New(sess),
        URL:    viper.GetString("queue.sqs.url"),
    }
}

How can I configure the SDK to access localstack's SQS?

Answer 1

Let's suppose you have localstack up and running with default configuration so that SQS will be running on port :4576, therefore, it will be accessible at http://localhost:4576.

Let's write an example where we send a message on SQS after creating the Session and the Queue:

package main

import (

    "encoding/json"
    "log"

    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/sqs"
)

const (

    // Region represents aws region
    Region      = "eu-central-1"
    // SQSEndpoint represents the sqs endpoint (in this case points to localstack's SQS)
    SQSEndpoint = "http://localhost:4576"
    // QueueName represents queue's name
    QueueName   = "some_queue"
    // QueueURL represents queue's URL. You can also dynamically retrieve it with sqs.GetQueueUrl
    QueueURL    = "http://localhost:4576/queue/some_queue"
)

// Message is an example struct representing a message to be sent
type Message struct {
    SomeParam string `json:"some_param"`
}

func main() {

    // Initialize a new Config
    cfg := new(aws.Config)
    // Setting up region
    cfg.Region = aws.String(Region)
    // Setting up SQS Endpoint
    cfg.Endpoint = aws.String(SQSEndpoint)

    // Initialize new AWS Session
    awsSvc, err := session.NewSession(awsSvc)
    if err != nil {
        log.Fatal(err)
    }

    // Initialize new SQS Session
    sqsSvc := sqs.New(awsSvc)

    // Create a new queue input
    createQIn := new(sqs.CreateQueueInput)
    createQIn = out.SetQueueName(QueueName)

    // Create the queue
    if _, err := sqsSvc.CreateQueue(createQIn); err != nil {
        log.Fatal(err)
    }

    // Message Input
    message := Message {
        SomeParam : "some_val"
    }

    // Build SendMessage Input
    sendMsgIn:= new(sqs.SendMessageInput)

    // Marshal message to json
    b, err:= json.Marshal(input)
    if err != nil {
        log.Fatal(err)
    }

    // Set both Body and URL
    sendMsgIn = sendMsgIn.SetMessageBody(b).SetQueueUrl(QueueURL)

    // Finally send message
    if _, err := sqsSvc.SendMessage(sendMsgIn); err != nil {
        log.Fatal(err)
    }

}

Anyways, I realized a small utility library for this SDK with some useful methods aws-sdk-go-bindings.