Exam AWS Certified Developer Associate topic 1 question 65 discussion

I vote B, although I agree that the question clearly states that the code works correctly. It cannot be A, because if the files are being written to the wrong bucket then the lambda wouldn't trigger even once. C assumes an underlying issue with AWS, which although it could happen, it is unlikely. D makes no sense.

https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html "Amazon S3 event notifications are designed to be delivered at least once."

The correct answer is C. Amazon S3 is delivering the same event multiple times. Explanation: • At-Least-Once Delivery: Amazon S3 notifications follow an at-least-once delivery model, which means that each event may be delivered more than once. This can result in multiple invocations of your Lambda function for a single file. • Idempotency: Because of this behavior, it’s recommended to design your Lambda function to be idempotent (able to handle duplicate events without adverse effects). Thus, even if your Lambda function code works correctly, S3 may still send duplicate notifications, leading to multiple invocations.

The question explicitly states that the Lambda function code works as expected, ruling out Lambda retries due to function errors. https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-duplicate-invocations/ The duplicate invocations are expected behavior from Amazon S3's event notification system, as highlighted in the article. Hence, Option C is the correct answer.

A) Eliminated - If this were the case, you would see logs indicating a mismatch between the expected and actual bucket name. However, the issue is about duplicate invocations, not a misconfiguration of the bucket.

I vote C. AWS Lambda retries failed invocations, but these retries would appear in the logs only if the function explicitly failed but in the question it's mentioned that the Lambda function works as expected

Is should be C as question states that no error in lambda

Why not A? If wrong S3 bucket is mentioned where somehow same file is being inserted multiple times and as a result that is coming in the log.

If the lambda function did not run correctly and lambda retried the invocation as option B stated, this would typically be reflected in the function's error log or metrics. The question states that "the function code works as expected."

Answer is C. Now a days so much trust issue is present that instead of confirming that the lambda function works as expected people still don't believe this and still think the option B.

D. Application works intermittently, therefore Lambda will invoke every time app start after it was stopped. Logs were split into multiple smaller files, each file would contain different log entries, because for each new App start each time will new log file.

For me B is correct. C cannot be as if we have same event delivered multiple times we will a different lambda execution (ID) for each events. Different executions goes into different CloudWatch log streams, while retries hold the same execution ID and goes in the same CW log streams

As per the aws documentation, it is specified that S3 event notification are designed to deliver atleast once which means it can deliver more than once: Aws Ref: https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html StackOverflow: https://stackoverflow.com/questions/56772299/s3-notification-creates-multiple-events

B is for sure the correct answer. If a call to a lambda function fails the function will be executed other two times with a delay (that's why we can find 2 or 3 logs with the same ID). Furthermore, if the function throttles three times then it is possible to configure a DLQ to debug and see what's happen for that specific event

The answer here has to be C guys, it’s the most probable one.

Option A is less likely because if the bucket name was incorrectly specified, the Lambda function would not be invoked at all. Option B is also less likely because if the Lambda function did not run correctly, it would not be invoked at all, and there would be no logs generated. Option D is not likely because if the logs were split into multiple smaller files, each file would contain different log entries rather than duplicate entries.

C. - Lamda has to be idempotent (likely the question is trying to get to this point) https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-duplicate-invocations/ suggests Lamba should handle duplicated invocation; https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/ Not B: It does not matter if the code works or does not work correctly. The invocation of lambda would always happens no matter how good or bad the lambda code is. That implies that something is invoking lambda multiple times.