Was this page helpful?

Using Go, Python or Node.js with Scaleway Queues

Reviewed on 14 May 2025 • Published on 04 January 2023

AWS provides a number of SDKs (Software Development Kits) which provide language-specific APIs for AWS services, including

SQS, which is the protocol Scaleway Queues is based on.

AWS provides a dedicatedSDK for Go.
TheAWS SDK for Pythonis Boto3
For Node.js, use theAWS SDK for JavaScript, which can beinstalled from NPM

This guide provides code samples to show you how to start using these SDKs with Scaleway Queues.

Before you startLink to this anchor

To complete the actions presented below, you must have:

A Scaleway account logged into theconsole
Owner status orIAM permissions allowing you to perform actions in the intended Organization
Validcredentials for Scaleway Queues
Installed the relevant AWS SDKfor Go,Pythonand/orJavaScript

GoLink to this anchor

Connect to Queues (Go)Link to this anchor

The following code sample shows how to connect to Scaleway Queues:

import (
  ".com/aws/aws-sdk-go/aws"
  ".com/aws/aws-sdk-go/aws/credentials"
  ".com/aws/aws-sdk-go/aws/session"
  ".com/aws/aws-sdk-go/service/sqs"
)
func main() {
  awsSession := session.Must(session.NewSession(&aws.Config{
    Region:   aws.String("fr-par"),
    Endpoint: aws.String("http://sqs.mnq.fr-par.scaleway.com"),
    Credentials: credentials.NewStaticCredentials(AwsAccessKey, AwsSecretKey, ""),
  }))
  awsSqs := sqs.New(awsSession)
  [...]
}

Note

The Endpoint for Scaleway Queues is https://sqs.mnq.fr-par.scaleway.com. For the access and secret key values, use the credentials you

generated for Queues.

Once you are connected, you can use any functions available with the SDK. However, we recommend that you check they are

supported by Scaleway Queues. See theofficial documentationfor more details on using the SDK, or read on to see some examples.

Create queue (Go)Link to this anchor

createQueueResponse, _ := awsSqs.CreateQueue(&sqs.CreateQueueInput{
  QueueName: aws.String("my-test-queue"),
})
fmt.Println(*createQueueResponse.QueueUrl)

Send messages to this queue (Go)Link to this anchor

for i := 0; i < 10; i++ {
  _, _ = awsSqs.SendMessage(&sqs.SendMessageInput{
    MessageBody: aws.String(fmt.Sprintf("Hello World: %d", i)),
    QueueUrl:    createQueueResponse.QueueUrl,
  })
}

Receive messages from this queue (Go)Link to this anchor

for {
  receiveMessageResponse, err := awsSqs.ReceiveMessage(&sqs.ReceiveMessageInput{
    QueueUrl: createQueueResponse.QueueUrl,
  })
  if err != nil || len(receiveMessageResponse.Messages) == 0 {
    break
  }
  for _, m := range receiveMessageResponse.Messages {
    fmt.Println(*m.Body)
  }
}

PythonLink to this anchor

Connect to Queues (Python)Link to this anchor

The following code sample shows how to connect to Scaleway Queues using Boto3’s resource(). It is also possible to use client(), but resource() is more pythonesque:

sqs = boto3.resource('sqs',
  endpoint_url=[],
  aws_access_key_id=[],
  aws_secret_access_key=[],
  region_name='fr-par')

Note

The endpoint_url for Scaleway Queues is https://sqs.mnq.fr-par.scaleway.com. For the access and secret key values, use the credentials you

generated for Queues.

Once connected, you can use any functions available with the SDK - just check that they are

supported by Scaleway Queues. See theofficial documentationfor more details, or read on to see some examples.

Create queue (Python)Link to this anchor

# Create the queue. This returns an SQS.Queue instance
queue = sqs.create_queue(QueueName='my test queue')
# You can now access identifiers and attributes
print(queue.url)
print(queue.attributes)

Send messages to this queue (Python)Link to this anchor

for i in range (0,10):
  queue.send_message(MessageBody="Hello World: "+str(i))

Receive messages from this queue (Python)Link to this anchor

for message in queue.receive_messages():
  print(message.body)
  message.delete()

Node.jsLink to this anchor

Connect to Scaleway Queues (NodeJS)Link to this anchor

Here, we use the @aws-sdk/client-sqs module, which is the latest SDK available. Import the required module:

const { SQSClient, SendMessageCommand, CreateQueueCommand, ReceiveMessageCommand } = require("@aws-sdk/client-sqs");
// If you use ES6 syntax
// import  { SQSClient, SendMessageCommand, CreateQueueCommand, ReceiveMessageCommand } from "@aws-sdk/client-sqs";

The following code sample shows how to connect to Scaleway Queues:

var sqsClient = new SQSClient({
  credentials: {
    accessKeyId: SQS_ACCESS_KEY_ID,
    secretAccessKey: SQS_ACCESS_KEY
  },
  region: "par",
  endpoint: SQS_ENDPOINT,
})

Note

The endpoint_url for Scaleway Queues is https://sqs.mnq.fr-par.scaleway.com. For the access and secret key values, use the credentials you

generated for Scaleway Queues.

Once connected, you can use any of the SDK’s functions as long as they are

supported by Scaleway Queues. Refer to AWS’sofficial documentationfor more information, or read on to see some examples.

Create queue (NodeJS)Link to this anchor

const createQueueCommand = new CreateQueueCommand({
    QueueName: 'SQS_QUEUE_NAME',
    Attributes: {
      'MessageRetentionPeriod': '86400'
    }
  });
    
const createQueue = await sqsClient.send(createQueueCommand);
console.log(createQueue.QueueUrl);

You can find all available parameters for createQueue in the AWS documentation

here.

Send messages to this queue (NodeJS)Link to this anchor

The following code sample demonstrates how to send a message with some MessageAttributes:

const sendMessageCommand = new SendMessageCommand({
  MessageAttributes: {
    "Name": {
      DataType: "String",
      StringValue: "John"
  }},
  MessageBody: "This is a test message to John",
  QueueUrl: "SQS_QUEUE_URL"
  });
  
const sendMessage = await sqsClient.send(sendMessageCommand)
console.log("Success", sendMessage.MessageId);
});

Receive messages from this queue (NodeJS)Link to this anchor

The following code sample shows how to read messages from a queue, and then delete them:

var queueURL= "SQS_QUEUE_URL";
const receiveMessageCommand = new ReceiveMessageCommand({
  MaxNumberOfMessages: 10,
  QueueUrl: queueURL,
  VisibilityTimeout: 20
});
const receiveMessage = await sqsClient.send(receiveMessageCommand);
console.log(receiveMessage);

Was this page helpful?