java - 尝试为 DynamoDB 初始化客户端时 Amazon Lambda 超时

Question

我在亚马逊的 Lambda 服务上上传了以下 Java 类:

public class DevicePutHandler implements RequestHandler<DeviceRequest, Device> {
    private static final Logger log = Logger.getLogger(DevicePutHandler.class);

    public Device handleRequest(DeviceRequest request, Context context) {
        AmazonDynamoDB client = AmazonDynamoDBClientBuilder.defaultClient();
        DynamoDBMapper mapper = new DynamoDBMapper(client);

        if (request == null) {
            log.info("The request had a value of null.");
            return null;
        }

        log.info("Retrieving device");
        Device deviceRetrieved = mapper.load(Device.class, request.getDeviceId());

        log.info("Updating device properties");
        deviceRetrieved.setBuilding(request.getBuilding());
        deviceRetrieved.setMotionPresent(request.getMotionPresent());
        mapper.save(deviceRetrieved);

        log.info("Updated device has been saved");
        return deviceRetrieved;
    }
}

我还有一个执行角色集，可以让我完全控制 DynamoDB。我的权限应该完全没问题，因为我对以这种方式使用 Lambda 和 DynamoDB 的其他项目使用了完全相同的权限(唯一的区别是不同的请求类型)。

这个类的目的是让它被 API 网关调用(API 网关 -> Lambda -> DynamoDB)，但现在我只是想在 Lambda 上测试它(Lambda -> DynamoDB)。

作为引用，如果重要的话，这里是 DeviceRequest 类:

@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonPropertyOrder({ "deviceId", "building", "motionPresent" })
public class DeviceRequest {

   @JsonProperty("deviceId")
   private String deviceId;
   @JsonProperty("building")
   private String building;
   @JsonProperty("motionPresent")
   private Boolean motionPresent;
   @JsonIgnore
   private Map<String, Object> additionalProperties = new HashMap<String, Object>();

   @JsonProperty("deviceId")
   public String getDeviceId() {
       return deviceId;
   }

   @JsonProperty("deviceId")
   public void setDeviceId(String deviceId) {
       this.deviceId = deviceId;
   }

   @JsonProperty("building")
   public String getBuilding() {
       return building;
   }

    @JsonProperty("building")
    public void setBuilding(String building) {
        this.building = building;
    }

    @JsonProperty("motionPresent")
    public Boolean getMotionPresent() {
        return motionPresent;
    }

    @JsonProperty("motionPresent")
        public void setMotionPresent(Boolean motionPresent) {
        this.motionPresent = motionPresent;
    }

    @JsonAnyGetter
    public Map<String, Object> getAdditionalProperties() {
        return this.additionalProperties;
    }

    @JsonAnySetter
    public void setAdditionalProperty(String name, Object value) {
        this.additionalProperties.put(name, value);
    }

}

这是设备类:

@DynamoDBTable(tableName="DeviceTable")
public class Device {
    private String deviceID;
    private String building;
    private String queue;
    private boolean motionPresent;

    @DynamoDBHashKey(attributeName="Device ID")
    public String getDeviceID() {
        return deviceID;
    }

    public void setDeviceID(String deviceID) {
        this.deviceID = deviceID;
    }

    @DynamoDBAttribute(attributeName="Motion Present")
    public boolean getMotionPresent() {
        return motionPresent;
    }

    public void setMotionPresent(boolean motionPresent) {
        this.motionPresent = motionPresent;
    }

    @DynamoDBAttribute(attributeName="Building")
    public String getBuilding() {
        return this.building;
    }

    public void setBuilding(String building) {
        this.building = building;
    }

    @DynamoDBAttribute(attributeName="Queue")
    public String getQueue() {
        return this.queue;
    }

    public void setQueue(String queue) {
        this.queue = queue;
    }
}

这是我尝试用其测试 Lambda 的 JSON 输入:

{
  "deviceId": "test_device_name",
  "building": "building1",
  "motionPresent": false
}

没有抛出任何异常(我尝试将其包装在 try/catch block 周围)并且 lambda 超时是唯一发生的事情。我已经尝试在 DynamoDB 客户端初始化之前的一开始就使用日志/打印语句来查看是否可以正确读取请求，并且它似乎确实正确地解析了 JSON 字段。我也把client builder分离出来，发现builder对象是可以初始化的，但是超时是因为builder调用build()做client的时候。

如果有人知道为什么会发生这种超时，请告诉我!

Answer 1

事实证明，通过增加超时时间和分配的内存，问题得到解决。不确定为什么它会起作用，因为 lambda 总是表明它的内存使用量低于先前设置的限制，但是哦，好吧。希望将来 Amazon 能提供更好的错误反馈，指示 lambda 是否需要更多资源才能运行。