Micronaut结合GraalVM部署AWS Lambda并通过SQS触发的异常问题求助

Let's break down why your SQS-triggered Lambda isn't working as expected and walk through actionable fixes step by step:

Root Cause Analysis #

From your test results, the 405 error when testing SQS events tells us that even though you configured a custom SQSEventHandler, Lambda is still routing requests through the HTTP proxy handler (MicronautLambdaHandler). Additionally, the silent failures (no logs, messages disappearing) likely stem from:

• Missing GraalVM native image metadata for AWS SQS event classes or your custom handler
• Unhandled exceptions in your handler code that aren't logged properly in native environments
• Misconfigured Lambda handler settings or build setup

Step-by-Step Fixes #

1. Confirm Lambda Handler Configuration #

First, double-check your Lambda runtime settings to ensure it's using your custom handler:

• Go to the Lambda console → Your function → Configuration → Runtime settings
• Verify the Handler field is set to com.example.eventHandlers.SQSEventHandler (not the HTTP proxy handler)
• Save changes if updated, then re-test the SQS trigger

2. Fix GraalVM Native Image Metadata #

GraalVM requires explicit configuration to include reflection, resources, and dynamic proxies for classes used at runtime. For AWS SQS events, add these configurations:

• Create src/main/resources/META-INF/native-image/reflect-config.json with:

[
  {
    "name": "com.amazonaws.services.lambda.runtime.events.SQSEvent",
    "allDeclaredConstructors": true,
    "allPublicConstructors": true,
    "allDeclaredMethods": true,
    "allPublicMethods": true,
    "allDeclaredFields": true,
    "allPublicFields": true
  },
  {
    "name": "com.amazonaws.services.lambda.runtime.events.SQSEvent$SQSMessage",
    "allDeclaredConstructors": true,
    "allPublicConstructors": true,
    "allDeclaredMethods": true,
    "allPublicMethods": true,
    "allDeclaredFields": true,
    "allPublicFields": true
  },
  {
    "name": "com.example.eventHandlers.SQSEventHandler",
    "allDeclaredConstructors": true,
    "allPublicConstructors": true,
    "allDeclaredMethods": true,
    "allPublicMethods": true
  }
]

This ensures GraalVM includes these critical classes in the native image.

3. Update Handler Code & Logging #

Your current handler has two key issues: passing a raw string to a service expecting a Map, and using printStackTrace() which doesn't log to CloudWatch in native environments. Update the code:

import com.amazonaws.services.lambda.runtime.events.SQSEvent;
import com.example.services.TestService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.micronaut.core.annotation.Introspected;
import io.micronaut.function.aws.MicronautRequestHandler;
import jakarta.inject.Inject;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Introspected
public class SQSEventHandler extends MicronautRequestHandler<SQSEvent, Void> {
    private static final Logger LOG = LoggerFactory.getLogger(SQSEventHandler.class);
    
    @Inject
    private TestService testService;
    
    @Inject
    private ObjectMapper objectMapper;

    @Override
    public Void execute(SQSEvent input) {
        LOG.info("EVENT PROCESSING STARTS ===>");
        List<SQSEvent.SQSMessage> messages = input.getRecords();
        LOG.info("Number of messages::: {}", messages.size());
        
        for (SQSEvent.SQSMessage single : messages) {
            try {
                LOG.info("Message body::: {}", single.getBody());
                // Convert JSON string to Map matching your service's expected input
                Map<String, Object> bodyMap = objectMapper.readValue(
                    single.getBody(), 
                    new TypeReference<Map<String, Object>>() {}
                );
                this.testService.handleRequest(bodyMap);
            } catch (JsonProcessingException e) {
                LOG.error("Failed to parse message body: {}", single.getBody(), e);
            } catch (Exception e) {
                LOG.error("Error processing message: {}", single.getBody(), e);
            }
        }
        LOG.info("<=== EVENT PROCESSING ENDS");
        return null;
    }
}

Key improvements:

• Uses SLF4J logger (native-image friendly for CloudWatch logs)
• Injects Micronaut's pre-configured ObjectMapper to convert the SQS message body to a Map
• Catches all exceptions and logs them with context

4. Configure Micronaut for Lambda Handler #

Add this to src/main/resources/application.yml to ensure Micronaut recognizes your custom handler during the build process:

micronaut:
  function:
    aws:
      handler: com.example.eventHandlers.SQSEventHandler

5. Re-build & Deploy #

Run your build command again to generate the updated native Lambda package:

./gradlew buildNativeLambda

Upload the generated zip to AWS Lambda and re-test the SQS trigger.

6. Verify CloudWatch Logs #

After triggering with SQS, check Lambda's CloudWatch Logs (Monitor → Logs in the Lambda console) to confirm logs are appearing and no errors are present.

Additional Checks #

• Lambda Execution Role: Ensure the role has permissions for sqs:ReceiveMessage, sqs:DeleteMessage, and CloudWatch log actions (logs:CreateLogStream, logs:PutLogEvents)
• Local Testing: Validate your handler locally before deploying using Micronaut's tooling:

  ./gradlew runFunction -Pfunction=com.example.eventHandlers.SQSEventHandler -Pinput=src/test/resources/sqs-event.json
  

  Create sqs-event.json with your test SQS event data to debug issues locally.

内容的提问来源于stack exchange，提问作者Jignesh M. Khatri