AWS Lambda - 如何在出现故障时停止重试

Question

I know that when a Lambda function fails (for example when there is a time out), it tries to run the function 3 more times again. Is there any way to avoid this behavior? I' have been reading the documentation, but didn't find anyting about this.

Thanks!

Answer 1

It retries when it is an unhandled failure (an error that you didn't catch) or if you handled it but still told Lambda to retry (eg in Node, when you call callback() with a non-null first argument).

To stop it from retrying, you should make sure that any error is handled and you tell Lambda that your invocation finished successfully by returning a non-error (or in Node, calling callback(null, <any>) .

To do this you can enclose the entire body of your handler function with a try-catch.

module.exports.handler(event, context, callback) {
  try {
    // Do you what you want to do.
    return callback(null, 'Success')
  } catch (err) {
    // You probably still want to log it.
    console.error(err)
    // Return happy despite all the hardships you went through.
    return callback(null, 'Still success')
  }
}

As for failures due to timeouts there are things you can do.

If it times out outside of your handler, there's usually something wrong with your code (eg incorrect database config, etc) that you should look at.

If it times out inside your handler during an invocation, there is something you can do about it.

• If it's an HTTP request, you should set the timeout of the request to be shorter than your Lambda's timeout, this way it will fail properly and you can catch it.
• If it's a database connection, you can probably set a timeout using the library that you're using.
• If it's your logic that times out, you can upgrade the Lambda to use higher memory-CPU to make it faster. You can also check context.getRemainingTimeInMillis() to know if the Lambda is about to timeout, so you can handle it earlier.

Answer 2

EDITED : It's now possible to change the lambda settings to disable retries (see announcement )

---

Original answer :

There isn't a way to disable retry behavior of Lambda functions. I suggest two options to deal with that:

1. Make your Lambda able to handle retry cases correctly. You can use context.AwsRequestId (or corresponding field) that will be the same when a Lambda is retried.
2. Put your Lambda inside a state machine (using AWS Step Functions). You can only then disable retries. This blog post I've written gives a more general explanation.

Answer 3

If you call the function asynchronously, in the Console , under Function configuration , you can modify the Retry attempts :

Answer 4

Since November 2019 , it is possible to set the retry count to 0.

That means the lambda will not be retried on error.

Answer 5

As mentioned before, this feature has been added lately. To achieve this behaviour using cloudformation you will need both an AWS::Lambda::Version and AWS::Lambda::EventInvokeConfig :

  MyLambda:
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: my-lambda-dev
      ...

  MyLambdaVersion:
    Type: AWS::Lambda::Version
    Properties:
      FunctionName: !Ref MyLambda

  MyLambdaAsyncConfig:
    Type: AWS::Lambda::EventInvokeConfig
    Properties:
      FunctionName: !Ref MyLambda
      MaximumRetryAttempts: 0
      Qualifier: !GetAtt MyLambdaVersion.Version

Answer 6

If using python then need to put the code in try/catch block as well however there will be no callback. For example:

try:
    do_something()
except Exception as e:
    print('Error: ' + str(e))

Since the error has been handled, Lambda will not retry.

Answer 7

If you are using Python, I recommend you to follow this thread .

If you are using Java, inside handleRequest method add this lines:

ClientConfiguration config = new ClientConfiguration();
config.setMaxErrorRetry(0);

Answer 8

Use below code to identify and stop retry when there is a failure.

  exports.handler = (event, context, callback) => {
      context.callbackWaitsForEmptyEventLoop = false;
      let lastReqId;
      if (lastReqId == context.awsRequestId) {
        console.log("Lambda auto retry detected. Aborting");// you can write your own logic to decide what to do with the failure data
        return context.succeed();
      } else {
        console.log("new context");
        lastReqId = context.awsRequestId;
      }
    };

you can read more about it here

Answer 9

I achieved this by placing the following line of code:

callback(null, "message");

Into my function such as the below update to DynamoDB. When there is an error, rather than retrying for hours on end, this callback outside of the if / else will stop the retries.

dynamodb.updateItem(params, function(err, data){
                 if (err) {
                    console.log(err)
                    callback(err, data)
            } else {
                 console.log(data);
                 callback(null, data);
           }
           callback(null, "message");
        });

Answer 10

You can also just return true , for example, if you're invoking a Lambda function, using Node.JS.

I want to stop running the Lambda function, if there's no data.

So I check for an empty object being returned from the API.

If it's empty, I return true, and the Lambda is stopped, and the EventBridge is also not re-tried.

This worked for me.