Debugging with Dashbird: Malformed Lambda Proxy Response
Tags: serverless, aws
Published: 2021-01-14 10:48:34

One problem that pops up quite frequently when people try to build serverless applications with [AWS API Gateway](https://dashbird.io/knowledge-base/api-gateway/what-is-aws-api-gateway/) and [AWS Lambda](https://dashbird.io/knowledge-base/aws-lambda/introduction-to-aws-lambda/) is *Execution failed due to configuration error: Malformed Lambda proxy response.*

There is nothing worse than generic error messages that don't tell you anything you need to fix the problem, right? And AWS isn't particularly known for its error message design, if you can even call it that, let alone for giving you the means of fixing the problem. So how to fix this Lambda error and what causes it?

Fixing malformed Lambda proxy response
--------------------------------------

In order to fix this, you need to **change what your [Lambda function](https://dashbird.io/knowledge-base/aws-lambda/anatomy-of-a-lambda-function/) returns**. And to do so, you need to return an object with two attributes:

-   `statusCode` -- which is the HTTP status code you want to give your client with type number.
-   `body `-- which is the content of your HTTP response with type string.

 If you used an asynchronous function, it should look like this:

```javascript
exports.handler = async function(event, context) {
  return {statusCode: 200, body: "OK"};
};
```

If you're more of a promise type of developer, it would look like this:

```javascript
exports.handler = function(event, context) {
  return new Promise(function(resolove, reject) {
    resolve({statusCode: 200, body: "OK"});
  });
};
```

And finally, if you're into callbacks, this will resolve your problem:

```javascript
exports.handler = function(event, context, callback) {
  callback({statusCode: 200, body: "OK"});
};
```

Understanding the Malformed Lambda proxy error response
-------------------------------------------------------

If you have some time to spare, why not learn a bit about the "Why" of the error along the way?

First, *Malformed Lambda proxy response* isn't really a configuration error because **the problem lies in your Lambda code**. But still, it could very well be that the routine that checks your return value also checks for other things that can be configured from the outside, like from AWS CloudFormation.

**But what about the proxy part of that error message? **

If you configure a route for your API in AWS API Gateway in the AWS Console, you get to **choose an integration for that route**, in our case, a Lambda integration. This integration is the **glue between AWS Lambda and AWS API Gateway**. After all, Lambda can be used for more than just handling API Gateway requests.

If you configure the route via CloudFormation, things get a bit clearer. 

```yaml
ExampleApi:
  ...
DefaultStage:
  ...
ExampleRoute:
  Type: AWS::ApiGatewayV2::Route
  Properties:
    ApiId:
      Ref: ExampleApi
    RouteKey: ANY /
    Target:
      Fn::Join:
        - integrations/
        - Ref: ProxyIntegration
ProxyIntegration:
  Type: AWS::ApiGatewayV2::Integration
  Properties:
    ApiId:
      Ref: ExampleApi
    IntegrationType: AWS_PROXY
    IntegrationUri:
      Fn::GetAtt:
        - ExampleFunction
        - Arn
    PayloadFormatVersion: "2.0"
ExampleRole:
  ...
ExampleFunction:
  Type: AWS::Lambda::Function
  Properties:
    Code:
      ZipFile:
        'exports.handler = async () => ({ statusCode: 200, body: "Example" });'
    Handler: index.handler
    Role:
      Fn::GetAtt:
        - ExampleRole
        - Arn
    Runtime: nodejs12.x
  DependsOn:
    - ExampleRole
```

I guess you already spotted the important point here. The integration we create in the AWS Console is actually a **specific type of integration, called `AWS_PROXY`**. It's used to integrate with many AWS services and the AWS Console just has a nice UI to make integrating with Lambda simpler.

There are actually five types of API Gateway integrations. Three you can use for your WebSockets endpoints and two for the HTTP endpoints.

### HTTP Integration Types

When you build a regular HTTP API.

1.  `**AWS_PROXY**` to integrate with Lambda, or other AWS services, like Step Functions.
2.  **`HTTP_PROXY`** to pass-through a request to another HTTP endpoint.

### WebSocket Integration Types

When you build a WebSocket based HTTP API.

1.  `**AWS**` to integrate with Lambda.
2.  **`HTTP`** to integrate with other (i.e., third-party) HTTP APIs.
3.  `**MOCK**` to make a WebSocket endpoint work as a loop-back, without any other service involved.

Summary
-------

Error messages are a common pain point for developers, but often the fix is quite simple. However, if you know a bit of background to the error's origin, it can help to fix it faster in the future.

To learn more about specific common serverless errors and how to fix them, make sure to visit our [Event Library](https://dashbird.io/event-library/).