Exam AWS Certified Developer Associate topic 1 question 258 discussion

A. It is infinite retry until the message is processed successfully. D is absolutely incorrect. you can't call it successfully processed when you leave messages in the DLQ.

So it's a good idea to create an SQS dead letter queue for this reason A and B are for sure not correct. We have to exclude also the C because create a DLQ Q and modify the lambda function to read messages from both queues doesn't make sense. Instead, it is a good idea to create an SQS Dead letter Queue, catch the application exceptions in the function and write on the DLQ if there is a failure caused by the third-party library. So the answer D is the correct one

To me, the key here is 'so that the Lambda function will process each message successfully "despite the failures" of the third-party dependency', which means that we don't necessarily need to reprocess the message, meaning that any answers talking about returning the message back to the SQS queue are wrong. Left are C or D, in C the answer is talking about consuming the messages from the normal queue and from the dead letter queue. again from the first statement, we're not looking to reprocess the failed messages therefore no need to reconsume the messages in the DLQ. so D is the right one in my opinion

I think it's A. 1) least effort - no additional queues 2) unlimited number of retries in this scenario which garanties processing of the message.

They need to reword "exception handling block". As a developer, to me this means the "catch" or "Except" portion of the code. I disqualified the correct answer based off of that.

D is correct. Dead-letter queues are the way to catch and handle errors in SQS.

D for me.

D makes the most sense to me. C: Redrive policy should be working on DLQ, not the original queue

Does C not look to be correct based on this resource: https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html

Choosing B (even if it tolerates just a maximum number of failures equal to the selected maxReceiveCount value). As regarding A, it seems strage the wording "write back to the SQS queue", even if this appears to be the only solution guarantiing the succesfull processing of "each" message (by the way, with this solution we can incurr in infinite loops for structural errors). As regarding D, I was wondering how an immediate move to the DLQ after a single failure will encrease resiliency without using it as a source of the process (following this approach we will have just traces of all the failures in the DLQ but no increased resiliency). As regarding C we're increasing resiliency to just two tries if we don't modify maxReceiveCount. Can anybody argument on my above reasonings?

Changing to D, as we need to create a second SQS queue and link it to the original SQS queue to configure DLQ.

B. https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html If your function returns an error, or can't be invoked because it's at maximum concurrency, processing might succeed with additional attempts. To give messages a better chance to be processed before sending them to the dead-letter queue, set the maxReceiveCount on the source queue's redrive policy to at least 5.(C and D needs to create the DLQ in the same source queue, instead of creating a second queue, which makes them wrong choice)

Defo not A and B. D makes more sense than C

Use dead letter queue with exception handling