← Back to DevBytes
Developer Tutorial August 04, 2026 7 min read

SQS: Complete Setup and Configuration Guide

Introduction to Amazon SQS

Amazon Simple Queue Service (SQS) is a fully managed message queuing service that enables you to decouple and scale microservices, distributed systems, and serverless applications. SQS allows you to send, store, and receive messages between software components at any volume, without losing messages or requiring other services to be available.

Whether you are building an event-driven architecture or simply need to buffer requests between a producer and consumer, SQS provides a reliable, highly available, and secure messaging backbone that scales automatically with your workload.

Why SQS Matters

In modern distributed systems, components often need to communicate asynchronously. Direct synchronous calls between services create tight coupling, where a failure in one service cascades to others. SQS solves this problem by introducing a queue between producers and consumers.

Key Benefits

Queue Types: Standard vs. FIFO

Before setting up SQS, it is important to understand the two queue types available, as they affect how your application behaves.

Standard Queues

Standard queues offer maximum throughput, best-effort ordering, and at-least-once delivery. They are ideal for high-throughput scenarios where occasional duplicate messages or out-of-order delivery is acceptable.

FIFO Queues

FIFO (First-In-First-Out) queues guarantee that messages are processed exactly once and in the exact order they were sent. They support message groups, allowing parallel processing while maintaining order within each group. FIFO queues are limited to 300 transactions per second (TPS) by default, but can scale higher with batching.

Setting Up SQS

There are several ways to create and configure an SQS queue: the AWS Management Console, the AWS CLI, Infrastructure as Code tools like Terraform, or programmatically using AWS SDKs. This guide covers the CLI and SDK approaches, as they are most useful for developers.

Prerequisites

Creating a Standard Queue Using the AWS CLI

The simplest way to create a queue is with the aws sqs create-queue command. You provide a queue name and optionally a set of attributes.

aws sqs create-queue \
  --queue-name my-standard-queue \
  --attributes VisibilityTimeout=60,DelaySeconds=0,MessageRetentionPeriod=345600

This command returns the queue URL, which you will use in subsequent operations:

{
  "QueueUrl": "https://sqs.us-east-1.amazonaws.com/123456789012/my-standard-queue"
}

Creating a FIFO Queue Using the AWS CLI

To create a FIFO queue, the queue name must end with the .fifo suffix, and you must set the FifoQueue attribute to true.

aws sqs create-queue \
  --queue-name my-fifo-queue.fifo \
  --attributes FifoQueue=true,ContentBasedDeduplication=true,VisibilityTimeout=60

Creating a Queue with Terraform

For production environments, managing infrastructure as code is strongly recommended. Here is a Terraform configuration that creates a standard queue with a dead-letter queue (DLQ):

resource "aws_sqs_queue" "dead_letter_queue" {
  name                       = "my-dlq"
  message_retention_seconds = 1209600
}

resource "aws_sqs_queue" "main_queue" {
  name                       = "my-main-queue"
  delay_seconds              = 0
  max_message_size           = 262144
  message_retention_seconds  = 345600
  visibility_timeout_seconds = 60
  receive_wait_time_seconds  = 10

  redrive_policy = jsonencode({
    deadLetterTargetArn = aws_sqs_queue.dead_letter_queue.arn
    maxReceiveCount     = 5
  })

  tags = {
    Environment = "production"
    Application = "order-service"
  }
}

Configuring Queue Attributes

SQS exposes several attributes that control queue behavior. Understanding these is critical for building robust systems.

Important Attributes

Updating Queue Attributes

You can update attributes on an existing queue at any time:

aws sqs set-queue-attributes \
  --queue-url https://sqs.us-east-1.amazonaws.com/123456789012/my-standard-queue \
  --attributes VisibilityTimeout=120,ReceiveMessageWaitTimeSeconds=20

Sending and Receiving Messages

Once your queue is configured, you can start sending and receiving messages. The following examples use Python with the boto3 library, but the same patterns apply to any AWS SDK.

Initializing the Client

import boto3

sqs = boto3.client('sqs', region_name='us-east-1')
queue_url = 'https://sqs.us-east-1.amazonaws.com/123456789012/my-standard-queue'

Sending a Message

response = sqs.send_message(
    QueueUrl=queue_url,
    MessageBody='{"order_id": "12345", "customer_id": "67890"}',
    DelaySeconds=0,
    MessageAttributes={
        'EventType': {
            'DataType': 'String',
            'StringValue': 'OrderCreated'
        }
    }
)

print(f"Message sent with ID: {response['MessageId']}")

Sending Messages to a FIFO Queue

FIFO queues require a MessageGroupId and optionally a MessageDeduplicationId if content-based deduplication is disabled:

response = sqs.send_message(
    QueueUrl=fifo_queue_url,
    MessageBody='{"order_id": "12345"}',
    MessageGroupId='customer-67890',
    MessageDeduplicationId='order-12345'
)

print(f"FIFO message sent with ID: {response['MessageId']}")

Receiving Messages

response = sqs.receive_message(
    QueueUrl=queue_url,
    MaxNumberOfMessages=10,
    WaitTimeSeconds=20,
    MessageAttributeNames=['All']
)

messages = response.get('Messages', [])

for message in messages:
    print(f"Received message: {message['Body']}")
    print(f"Receipt Handle: {message['ReceiptHandle']}")

    # Process the message here...

    # Delete the message after successful processing
    sqs.delete_message(
        QueueUrl=queue_url,
        ReceiptHandle=message['ReceiptHandle']
    )

Batch Operations

For higher throughput, use batch operations. You can send up to 10 messages in a single request:

response = sqs.send_message_batch(
    QueueUrl=queue_url,
    Entries=[
        {
            'Id': 'msg1',
            'MessageBody': '{"task": "send_email", "user": "alice"}',
            'DelaySeconds': 0
        },
        {
            'Id': 'msg2',
            'MessageBody': '{"task": "send_email", "user": "bob"}',
            'DelaySeconds': 0
        }
    ]
)

print(f"Successful: {len(response.get('Successful', []))}")
print(f"Failed: {len(response.get('Failed', []))}")

Dead-Letter Queues

A dead-letter queue (DLQ) is a queue that receives messages from another queue after a maximum number of processing attempts is exceeded. DLQs are essential for debugging failed messages and preventing poison-pill messages from blocking processing.

Configuring a DLQ

First, create the DLQ itself:

aws sqs create-queue --queue-name my-dlq

Then, get the DLQ ARN and attach a redrive policy to your main queue:

DLQ_ARN="arn:aws:sqs:us-east-1:123456789012:my-dlq"

aws sqs set-queue-attributes \
  --queue-url https://sqs.us-east-1.amazonaws.com/123456789012/my-standard-queue \
  --attributes "{\"RedrivePolicy\":\"{\\\"deadLetterTargetArn\\\":\\\"$DLQ_ARN\\\",\\\"maxReceiveCount\\\":\\\"5\\\"}\"}"

With this configuration, if a message is received but not deleted five times, SQS automatically moves it to the DLQ for inspection.

Long Polling vs. Short Polling

By default, SQS uses short polling, which returns immediately even if no messages are available. This can result in many empty responses and higher API costs. Long polling, on the other hand, waits for messages to arrive (up to 20 seconds) before returning, reducing costs and improving efficiency.

To enable long polling, set ReceiveMessageWaitTimeSeconds on the queue or pass it in the receive_message call. A value of 20 seconds is recommended for most use cases.

Security and Access Control

IAM Policies

Access to SQS queues is controlled through IAM policies. Here is an example policy that grants a specific role permission to send and receive messages from a queue:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "sqs:SendMessage",
        "sqs:ReceiveMessage",
        "sqs:DeleteMessage",
        "sqs:GetQueueAttributes"
      ],
      "Resource": "arn:aws:sqs:us-east-1:123456789012:my-standard-queue"
    }
  ]
}

Encryption

SQS supports server-side encryption using AWS KMS. You can enable encryption when creating a queue or update it later:

aws sqs set-queue-attributes \
  --queue-url https://sqs.us-east-1.amazonaws.com/123456789012/my-standard-queue \
  --attributes KmsMasterKeyId=alias/aws/sqs

Best Practices

Monitoring and Observability

SQS integrates with Amazon CloudWatch to provide detailed metrics. Key metrics to monitor include:

Set up CloudWatch alarms to alert you when the visible message count exceeds a threshold or when the oldest message age grows beyond acceptable limits.

Conclusion

Amazon SQS is a powerful, fully managed message queuing service that forms the backbone of many distributed and event-driven architectures. By understanding the differences between Standard and FIFO queues, configuring attributes like visibility timeout and long polling, setting up dead-letter queues, and following security and operational best practices, you can build resilient, scalable systems that handle message processing reliably. Whether you are decoupling microservices, buffering workloads, or building serverless pipelines, SQS provides the flexibility and reliability needed to handle messaging at any scale. Start with a simple queue, instrument your consumers with proper monitoring, and iterate as your workload grows.

— Ad —

Google AdSense will appear here after approval

← Back to all articles