Thread by @tpschmidt_

📚 𝗔𝗪𝗦 𝟭𝘅𝟭 - 𝗦𝗤𝗦

Your fully managed message queue service & a serverless fan's best friend.

From queue types, over visibility timeouts to message groups ↓

𝗧𝗵𝗿𝗲𝗮𝗱 𝗢𝘃𝗲𝗿𝘃𝗶𝗲𝘄 🧵

• Introduction
• Importance of Messaging Systems
• Fundamentals
• Queue Types
• Visibility Timeouts
• Retention Periods
• Limitations

{ 1/22 }

𝗜𝗻𝘁𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻

Believe it or not: SQS was the 𝗳𝗶𝗿𝘀𝘁 publicly launched service by AWS!

Quoting Jeff Bar:
"We launched the Simple Queue Service in 𝗹𝗮𝘁𝗲 𝟮𝟬𝟬𝟰, Amazon S3 in early 2006, and Amazon EC2 later that summer."

jeff-barr.com/2014/08/19/my-…

{ 2/22 }

Maybe one more detail to get you excited about SQS's capabilities:
At Amazon's Prime Days in 2021, a new traffic record was set with SQS processing 𝟰𝟳.𝟳 𝗺𝗶𝗹𝗹𝗶𝗼𝗻 𝗺𝗲𝘀𝘀𝗮𝗴𝗲𝘀 𝗽𝗲𝗿 𝘀𝗲𝗰𝗼𝗻𝗱 at the peak!

aws.amazon.com/blogs/aws/prim…

{ 3/22 }

So what is AWS' Simple Message Service about?

SQS is a service that allows you to store messages that then await processing by another service, like for example a Lambda function

It's a core service that drastically helps to decouple systems and increase reliability

{ 4/22 }

A simple example: you're offering customers to register at your side, but several long-running sub-processes are triggered with that, maybe one's that do high latency 3rd party calls.

Surely you can do all operations blocking, but this can cause a lot of problems.

{ 5/22 }

First, submitting the formula will result in a long waiting period until it's finally processed, as all including operations need to be finished before returning a result to the customer.

Additionally: if some operation fails, error handling is hardly possible.

{ 6/22 }

Generally, it's just delegated to the customer to retry the operation, which can result in losing the potential customer at all - which is the second downside.

With messaging systems, you can easily decouple downstream operations that don't need to be synchronous.

{ 7/22 }

𝗜𝗺𝗽𝗼𝗿𝘁𝗮𝗻𝗰𝗲 𝗼𝗳 𝗠𝗲𝘀𝘀𝗮𝗴𝗶𝗻𝗴 𝗦𝘆𝘀𝘁𝗲𝗺𝘀

Messaging systems like SQS also solve more problems, like:

• the producing system is working faster than the consuming or
• the producer or consumer has only intermittent network connection

{ 8/22 }

Having a look at 𝗟𝗮𝗺𝗯𝗱𝗮, there's more to gain: messages for Lambda triggers can be aggregated together into 𝗯𝗮𝘁𝗰𝗵𝗲𝘀, so one function invocation processes several messages at a time.

This saves computation times, as there are fewer cold starts on average.

{ 9/22 }

𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀

Any service of your distributed system can 𝘀𝘁𝗼𝗿𝗲 & 𝗿𝗲𝗰𝗲𝗶𝘃𝗲 messages at SQS programmatically via Amazon's API. Messages can:

• can contain up to 256 KBs of text and
• can be in your favorite format like JSON or XML

{ 10/22 }

𝗤𝘂𝗲𝘂𝗲 𝗧𝘆𝗽𝗲𝘀

How messages are processed depends on the queue type you've selected.
There are two of them:

• Standard Queues (selected by default)
• FIFO Queues (𝗙irst-𝗜n-𝗙irst-𝗢ut)

{ 11/22 }

𝗦𝘁𝗮𝗻𝗱𝗮𝗿𝗱 𝗤𝘂𝗲𝘂𝗲

The default queue type of SQS.

Most important facts:
• guarantee that messages are delivered at least once
• there's a best-effort ordering, meaning generally messages are delivered in the order they are sent - but there's no guarantee

{ 12/22 }

𝗙𝗜𝗙𝗢 𝗤𝘂𝗲𝘂𝗲

• transaction processing limit is capped at 300 transactions per second
• guarantees ordering
• guarantees that there's exactly-once processing of all messages
• support for message groups

{ 13/22 }

What are 𝗠𝗲𝘀𝘀𝗮𝗴𝗲 𝗚𝗿𝗼𝘂𝗽𝘀?

There's the option to assign a 𝗠𝗲𝘀𝘀𝗮𝗴𝗲 𝗚𝗿𝗼𝘂𝗽 𝗜𝗱𝗲𝗻𝘁𝗶𝗳𝗶𝗲𝗿. This means that messages with the same ID will be processed in the correct order.

𝗘𝘅𝗮𝗺𝗽𝗹𝗲: processing messages of the same customer in order!

{ 14/22 }

This means SQS only guarantees that messages for the same customer identifier are delivered in a FIFO manner, but messages for other customers can be processed in parallel and 𝗱𝗼𝗻'𝘁 have to be in the order they are sent to SQS.

{ 15/22 }

𝗩𝗶𝘀𝗶𝗯𝗶𝗹𝗶𝘁𝘆 𝗧𝗶𝗺𝗲𝗼𝘂𝘁𝘀

If a consumer picks up a message from SQS, it's hidden for all other consumers for a certain period of time (=inflight). If the message is successfully processed by the consumer within that time, it will be deleted from the queue

{ 16/22 }

If not, the message will be available again for all consumers which could result in messages being delivered & processed 𝗺𝗼𝗿𝗲 𝘁𝗵𝗮𝗻 𝗼𝗻𝗰𝗲.

Facts:
• default visibility timeout is 30 seconds
• it's not possible to configure a timeout of more than 12 hours

{ 17/22 }

𝗥𝗲𝘁𝗲𝗻𝘁𝗶𝗼𝗻 𝗣𝗲𝗿𝗶𝗼𝗱𝘀

You can define how long SQS stores each individual message while waiting for it to be processed. It can range from 𝟭 𝗺𝗶𝗻𝘂𝘁𝗲 up to 𝟭𝟰 𝗱𝗮𝘆𝘀.

If the retention period is over, the message will be deleted from the queue.

{ 18/22 }

𝗗𝗲𝗮𝗱 𝗟𝗲𝘁𝘁𝗲𝗿 𝗤𝘂𝗲𝘂𝗲𝘀 (DLQ)

Besides timeouts & retentions, you can define how many times a message can be retrieved until it's considered 𝘂𝗻𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗮𝗯𝗹𝗲.

Define another queue (Dead Letter) to forward messages to after the limit is exceeded.

{ 19/22 }

Dead Letter Queues help you unblock your messaging systems, without actual losing messages. If a message is unprocessable, you can either define an automated exception handling process or just step in for taking manual action.

{ 20/22 }

SQS has some 𝗟𝗶𝗺𝗶𝘁𝗮𝘁𝗶𝗼𝗻𝘀

• 120k messages can be inflight at a time - for FIFO Queues it's 20k
• 256 KB message size limit (there are library extensions for SQS to store messages in S3 & only send references)
• FIFO only allows 300 operations/second

{ 21/22 }

The last limitation can be tackled by using 𝗺𝗲𝘀𝘀𝗮𝗴𝗲 𝗯𝗮𝘁𝗰𝗵𝗶𝗻𝗴 to receive up to 10 messages at once, which will therefore result in being able to process up to 3,000 messages per second per queue.

{ 22/22 }

That's already the end - thank you for reading! 🙌
I hope you learned something new & made you excited to put SQS into use.

If you've enjoyed this thread, I'd be happy if you ♻️ or ♥️ the initial post!
... and be sure to follow me for more regular cloud content! 🌤