Erro de gateway AWS lambda api “Malformed Lambda proxy response”

Estou tentando configurar um exemplo hello world com AWS lambda e veiculá-lo por meio do gateway da API. Cliquei em "Criar uma Função Lambda", que configurou o api gatway e selecionei a opção Função em Branco. Eu adicionei a função lambda encontrada no guia de primeiros passos do gateway AWS :

exports.handler = function(event, context, callback) {
  callback(null, {"Hello":"World"});  // SUCCESS with message
};

O problema é que, quando faço uma solicitação GET, ele retorna uma resposta 502 { "message": "Internal server error" }. E os logs dizem "Falha de execução devido a erro de configuração: resposta do proxy Lambda malformada".

Normalmente, quando você vê Malformed Lambda proxy response, significa que sua resposta de sua função Lambda não corresponde ao formato que o API Gateway está esperando, como este

{
    "isBase64Encoded": true|false,
    "statusCode": httpStatusCode,
    "headers": { "headerName": "headerValue", ... },
    "body": "..."
}

Se você não estiver usando a integração do proxy Lambda, pode fazer login no console do API Gateway e desmarcar a caixa de seleção Integração do proxy Lambda.

Além disso, se você estiver vendo intermitência Malformed Lambda proxy response, pode significar que a solicitação para sua função Lambda foi restringida pelo Lambda e você precisa solicitar um aumento do limite de execução simultânea na função Lambda.

Se lambda for usado como proxy, o formato da resposta deve ser

{
"isBase64Encoded": true|false,
"statusCode": httpStatusCode,
"headers": { "headerName": "headerValue", ... },
"body": "..."
}

Nota: O corpo deve ser estriado

Sim, acho que isso ocorre porque você não está retornando uma resposta http adequada, e é por isso que está obtendo o erro.

pessoalmente, eu uso um conjunto de funções como:

    module.exports = {
        success: (result) => {
            return {
                statusCode: 200,
                headers: {
                    "Access-Control-Allow-Origin" : "*", // Required for CORS support to work
                    "Access-Control-Allow-Credentials" : true // Required for cookies, authorization headers with HTTPS
                },
                body: JSON.stringify(result),
            }
        },
        internalServerError: (msg) => {
            return {
                statusCode: 500,
                headers: {
                    "Access-Control-Allow-Origin" : "*", // Required for CORS support to work
                    "Access-Control-Allow-Credentials" : true // Required for cookies, authorization headers with HTTPS
                },
                body: JSON.stringify({
                    statusCode: 500,
                    error: 'Internal Server Error',
                    internalError: JSON.stringify(msg),
                }),
            }
        }
} // add more responses here.

Então você simplesmente faz:

var responder = require('responder')

// some code

callback(null, responder.success({ message: 'hello world'}))

Dos documentos da AWS

Em uma função Lambda em Node.js, para retornar uma resposta bem-sucedida, chame o retorno de chamada (null, {"statusCode": 200, "body": "results"}). Para lançar uma exceção, chame o callback (new Error ('erro interno do servidor')). Para um erro do lado do cliente, por exemplo, um parâmetro obrigatório está faltando, você pode chamar o retorno de chamada (null, {"statusCode": 400, "body": "Parâmetros ausentes de ..."}) para retornar o erro sem lançar um exceção.

Para Python3:

import json

def lambda_handler(event, context):
    return {
        'statusCode': 200,
        'headers': {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*'
        },
        'body': json.dumps({
            'success': True
        }),
        "isBase64Encoded": False
    }

Observe que bodynão é necessário definir, pode apenas estar vazio:

        'body': ''

Um caso muito especial, se você passar os cabeçalhos diretamente, há uma chance de ter este cabeçalho:

"set-cookie": [ "........" ]

Mas a Amazon precisa disso:

"set-cookie": "[ \\"........\\" ]"

Para qualquer outra pessoa que luta quando a resposta parece válida. Isso não funciona:

callback(null,JSON.stringify( {
  isBase64Encoded: false,
  statusCode: 200,
  headers: { 'headerName': 'headerValue' },
  body: 'hello world'
})

mas isso faz:

callback(null,JSON.stringify( {
  'isBase64Encoded': false,
  'statusCode': 200,
  'headers': { 'headerName': 'headerValue' },
  'body': 'hello world'
})

Além disso, parece que nenhuma chave extra pode estar presente no objeto de resposta.

Se você estiver usando Go com https://github.com/aws/aws-lambda-go , será necessário usar events.APIGatewayProxyResponse.

func hello(ctx context.Context, event ImageEditorEvent) (events.APIGatewayProxyResponse, error) {
    return events.APIGatewayProxyResponse{
        IsBase64Encoded: false,
        StatusCode:      200,
        Headers:         headers,
        Body:            body,
    }, nil
}

Eu tentei todas as sugestões acima, mas não funciona enquanto o bodyvalor não éString

return {
    statusCode: 200,
    headers: {
        "Content-Type": "application/json",
        "Access-Control-Allow-Origin": "*"
    },
    body: JSON.stringify({
        success: true
    }),
    isBase64Encoded: false
};

Apenas um pedaço de código para o núcleo .net e C # :

using Amazon.Lambda.APIGatewayEvents;
...
var response = new APIGatewayProxyResponse
{
   StatusCode = (int)HttpStatusCode.OK,
   Body = JsonConvert.SerializeObject(new { msg = "Welcome to Belarus! :)" }),
   Headers = new Dictionary<string, string> { { "Content-Type", "application/json" } }
};
return response;

A resposta de lambda será:

{"statusCode":200,"headers":{"Content-Type":"application/json"},"multiValueHeaders":null,"body":"{\"msg\":\"Welcome to Belarus! :)\"}","isBase64Encoded":false}

A resposta do gateway api será:

{"msg":"Welcome to Belarus! :)"}

Recebi este erro porque removi acidentalmente a variável ServerlessExpressLambdaFunctionName do recurso CloudFormation AWS :: Serverless :: Api. O contexto aqui é https://github.com/awslabs/aws-serverless-express "Execute aplicativos sem servidor e APIs REST usando sua estrutura de aplicativo Node.js existente, além do AWS Lambda e do Amazon API Gateway"

No caso de o acima não funcionar para ninguém, encontrei este erro apesar de definir a variável de resposta corretamente.

Eu estava fazendo uma chamada para um banco de dados RDS em minha função. Descobriu-se que o que estava causando o problema eram as regras do grupo de segurança (entrada) naquele banco de dados.

Você provavelmente vai querer restringir os endereços IP que podem acessar a API, mas se você quiser que funcione rápido / sujo para testar se essa alteração corrige, você pode configurá-lo para aceitar todos assim (você também pode configurar o intervalo nas portas para aceitar todas as portas também, mas eu não fiz isso neste exemplo):

Uma causa comum do erro "Resposta de proxy Lambda malformada" é headersque não são {String: String, ...}pares de chave / valor.

Desde set-cookiecabeçalhos podem e aparecem em múltiplos, eles são representados em http.request.callback.response como a set-cookiechave de ter um Arrayde Strings valor, em vez de uma únicaString . Embora isso funcione para desenvolvedores, o AWS API Gateway não entende e gera um erro de "Resposta de proxy Lambda malformada".

Minha solução é fazer algo assim:

function createHeaders(headers) {
  const singleValueHeaders = {}
  const multiValueHeaders = {}
  Object.entries(headers).forEach(([key, value]) => {
    const targetHeaders = Array.isArray(value) ? multiValueHeaders : singleValueHeaders
    Object.assign(targetHeaders, { [key]: value })
  })

  return {
    headers: singleValueHeaders,
    multiValueHeaders,
  }
}

var output = {
  ...{
    "statusCode": response.statusCode,
    "body": responseString
  },
  ...createHeaders(response.headers)
}

Observe que o ...acima não significa Yada Yada Yada . É o operador de propagação ES6 .

Aqui está outra abordagem. Configure o modelo de mapeamento em sua solicitação e resposta de integração de gateway de API. Vá para IntegrationRequest -> MappingTemplate -> selecione "Quando não houver modelos definidos" -> digite application / json para o tipo de conteúdo. Então você não precisa enviar explicitamente um json. Até mesmo a resposta que você obtém do seu cliente pode ser uma string simples.

O formato da resposta de sua função é a origem desse erro. Para que o API Gateway manipule a resposta de uma função Lambda, a resposta deve ser JSON neste formato:

{"isBase64Encoded": true | false, "statusCode": httpStatusCode, "headers": {"headerName": "headerValue", ...}, "body": "..."}

Aqui está um exemplo de função em Node.js com a resposta formatada corretamente:

exportações.handler = (evento, contexto, retorno de chamada) => {

var responseBody = {
    "key3": "value3",
    "key2": "value2",
    "key1": "value1"
};

var response = {
    "statusCode": 200,
    "headers": {
        "my_header": "my_value"
    },
    "body": JSON.stringify(responseBody),
    "isBase64Encoded": false
};
callback(null, response);

};

Ref: https://aws.amazon.com/premiumsupport/knowledge-center/malformed-502-api-gateway/

Python 3.7

Antes

{
    "isBase64Encoded": False,
    "statusCode": response.status_code,
    "headers": {
                  "Content-Type": "application/json",
               },
     "body": response.json()
}

Depois de

{
    "isBase64Encoded": False,
    "statusCode": response.status_code,
    "headers": {
                  "Content-Type": "application/json",
               },
     "body": str(response.json()) //body must be of string type
}

Se você é novo na AWS e quer apenas seu URL funcionando,

Se você não criou um gatilho para sua Função Lambda, navegue até a função no aplicativo Lambda Functions e crie um gatilho escolhendo API Gateway.

Navegue para API Gateway App -> Escolha seu API Gateway do Lambda particular (execução do método) -> Clique em INTEGRATION Request -> Desmarque "Use Lambda Proxy integration" (caixa de seleção).

Em seguida, clique em " <-Method Execution " e clique na seção Test Client. Forneça as opções e clique no botão de teste. Você deve ver uma resposta de sucesso.

Se você ainda não conseguir obter uma resposta de sucesso, crie um alias para a versão correta (se você tiver várias versões na Função Lambda)

Escolha a URL dos logs e use sua ferramenta POST / GET (Postman) e escolha a autenticação como assinatura da AWS - forneça suas chaves de autenticação (AccessKey e SecretKey) na solicitação do carteiro com a região e nome do serviço da AWS como lambda.

PS: Isso pode ajudar apenas iniciantes e pode ser irrelevante para outros.