amazon-web-services - pricing - aws lambda api gateway return json

Cómo pasar una cadena de consulta o un parámetro de ruta a AWS Lambda desde Amazon API Gateway

Question

por ejemplo si queremos usar

GET /user?name=bob

o

GET /user/bob

¿Cómo pasaría estos dos ejemplos como parámetro a la función Lambda?

Vi algo sobre la configuración de un "mapeado de" en la documentación, pero no puedo encontrar esa configuración en la consola API Gateway.

• method.request.path.parameter-name para un parámetro de ruta denominado parameter-name como se define en la página de Solicitud de método.
• method.request.querystring.parameter-name para un parámetro de cadena de consulta denominado parameter-name como se define en la página Solicitud de método.

No veo ninguna de estas opciones a pesar de que definí una cadena de consulta.

Answer 1

A partir de septiembre de 2017, ya no tiene que configurar asignaciones para acceder al cuerpo de la solicitud.

Todo lo que necesita hacer es marcar, "Usar la integración de Lambda Proxy", en Solicitud de integración, en el recurso.

Entonces podrá acceder a los parámetros de consulta, parámetros de ruta y encabezados de esta manera

event[''pathParameters''][''param1'']
event["queryStringParameters"][''queryparam1'']
event[''requestContext''][''identity''][''userAgent'']
event[''requestContext''][''identity''][''sourceIP'']

Answer 2

Actualmente, se incluye una plantilla desplegable en la API Gateway Console en AWS.

Para su API, haga clic en el nombre del recurso ... luego OBTENGA

Expanda "Plantillas de mapeo corporal"

Escribir

aplicación / json

para Content-Type (debe escribirse explícitamente) y haga clic en la marca

Se abrirá una nueva ventana con las palabras "Generar plantilla" y un menú desplegable (ver imagen).

Seleccionar

Método Passthrough de solicitud

Luego haga clic en guardar

Para acceder a cualquier variable, simplemente use la siguiente sintaxis (esto es Python), por ejemplo, URL:

https://yourURL.execute-api.us-west-2.amazonaws.com/prod/confirmReg?token=12345&uid=5

Puede obtener variables de la siguiente manera:

from __future__ import print_function

import boto3
import json

print(''Loading function'')


def lambda_handler(event, context):
    print(event[''params''][''querystring''][''token''])
    print(event[''params''][''querystring''][''uid''])

Por lo tanto, no es necesario nombrar o asignar explícitamente cada variable que desee.

Answer 3

Ahora debería poder usar el nuevo tipo de integración de proxy para Lambda para obtener automáticamente la solicitud completa en forma estándar, en lugar de configurar asignaciones.

ver: http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-set-up-simple-proxy.html#api-gateway-set-up-lambda-proxy-integration-on-proxy-resource

Answer 4

Como parte de tratar de responder una de mis propias preguntas here , me encontré con este truco.

En la plantilla de asignación de API Gateway, use lo siguiente para proporcionarle la cadena de consulta completa tal como la envió el cliente HTTP:

{
    "querystring": "$input.params().querystring"
}

La ventaja es que no tiene que limitarse a un conjunto de claves asignadas predefinidas en su cadena de consulta. Ahora puede aceptar cualquier par clave-valor en la cadena de consulta, si así es como desea manejar.

Nota: De acuerdo con docs.aws.amazon.com/apigateway/latest/developerguide/… , solo $input.params(x) aparece como una variable disponible para la plantilla VTL. Es posible que las querystring internas cambien y que la querystring ya no esté disponible.

Answer 5

Como respuesta de @ Jonathan, después de marcar Usar integración de proxy Lambda en Solicitud de integración , en su código fuente debe implementar el siguiente formato para evitar el error 502 Bad Gateway .

NodoJS 8.10:

exports.handler = async (event, context, callback) => {
  // TODO: You could get path, parameter, headers, body value from this
  const { path, queryStringParameters, headers, body } = event;

  const response = {
    "statusCode": 200,
    "headers": {
      "Content-Type": "application/json"
    },
    "body": JSON.stringify({
      path, 
      query: queryStringParameters,
      headers,
      body: JSON.parse(body)
    }),
    "isBase64Encoded": false
  };

  return response;
};

No olvide implementar su recurso en API Gateway antes de volver a ejecutar su API. La respuesta JSON solo devuelve qué conjunto en el cuerpo es correcto. Entonces, podría obtener la ruta, el parámetro, los encabezados y el valor del cuerpo del evento

const {ruta, queryStringParameters, encabezados, cuerpo} = evento;

Answer 6

Después de leer varias de estas respuestas, utilicé una combinación de varias en agosto de 2018 para recuperar los parámetros de cadena de consulta a través de lambda para Python 3.6.

Primero, fui a API Gateway -> Mi API -> recursos (a la izquierda) -> Solicitud de integración. Abajo en la parte inferior, seleccione Plantillas de mapeo y luego, para el tipo de contenido, ingrese application/json .

A continuación, seleccione la plantilla Método de transferencia de solicitud que proporciona Amazon y seleccione guardar e implementar su API.

Luego, en el event[''params''] lambda event[''params''] es cómo accede a todos sus parámetros. Para la cadena de consulta: event[''params''][''querystring'']

Answer 7

El siguiente ejemplo de asignación de parámetros pasa todos los parámetros, incluidos la ruta, la cadena de consulta y el encabezado, al punto final de integración a través de una carga útil JSON

#set($allParams = $input.params())
{
  "params" : {
    #foreach($type in $allParams.keySet())
    #set($params = $allParams.get($type))
    "$type" : {
      #foreach($paramName in $params.keySet())
      "$paramName" : "$util.escapeJavaScript($params.get($paramName))"
      #if($foreach.hasNext),#end
      #end
    }
    #if($foreach.hasNext),#end
    #end
  }
}

En efecto, esta plantilla de mapeo genera todos los parámetros de solicitud en la carga útil como se describe a continuación:

{
  "parameters" : {
     "path" : {    
       "path_name" : "path_value", 
       ...
     }
     "header" : {  
       "header_name" : "header_value",
       ...
     }
     ''querystring" : {
       "querystring_name" : "querystring_value",
       ...
     }
   }
}

Copiado de la Guía del desarrollador de Amazon API Gateway

Answer 8

GET / user? Name = bob

{
    "name": "$input.params().querystring.get(''name'')"
}

OBTENER / usuario / bob

{
    "name": "$input.params(''name'')"
}

Answer 9

He usado esta plantilla de mapeo para proporcionar el cuerpo, los encabezados, el método, la ruta y los parámetros de cadena de consulta de URL para el evento Lambda. Escribí una publicación de blog explicando la plantilla con más detalle: http://kennbrodhagen.net/2015/12/06/how-to-create-a-request-object-for-your-lambda-event-from-api-gateway/

Aquí está la plantilla de mapeo que puede usar:

{
  "method": "$context.httpMethod",
  "body" : $input.json(''$''),
  "headers": {
    #foreach($param in $input.params().header.keySet())
    "$param": "$util.escapeJavaScript($input.params().header.get($param))" #if($foreach.hasNext),#end

    #end
  },
  "queryParams": {
    #foreach($param in $input.params().querystring.keySet())
    "$param": "$util.escapeJavaScript($input.params().querystring.get($param))" #if($foreach.hasNext),#end

    #end
  },
  "pathParams": {
    #foreach($param in $input.params().path.keySet())
    "$param": "$util.escapeJavaScript($input.params().path.get($param))" #if($foreach.hasNext),#end

    #end
  }  
}

Answer 10

La cadena de consulta es fácil de analizar en javascript en lambda

para GET / user? name = bob

 var name = event.params.querystring.name;

Sin embargo, esto no resuelve la pregunta GET user / bob.

Answer 11

La función Lambda espera una entrada JSON, por lo tanto, es necesario analizar la cadena de consulta. La solución es cambiar la cadena de consulta a JSON utilizando la plantilla de mapeo.
Lo usé para C # .NET Core, por lo que la entrada esperada debería ser un JSON con el parámetro "queryStringParameters".
Siga estos 4 pasos a continuación para lograr eso:

1. Abra la plantilla de mapeo de su recurso API Gateway y agregue una nueva application/json content-tyap:

2. Copie la plantilla a continuación, que analiza la cadena de consulta en JSON, y péguela en la plantilla de mapeo:
   

   {
   "queryStringParameters": {#foreach($key in $input.params().querystring.keySet())#if($foreach.index > 0),#end"$key":"$input.params().querystring.get($key)"#end}
   }

3. En API Gateway, llame a su función Lambda y agregue la siguiente cadena de consulta (por ejemplo): param1=111&param2=222&param3=333

4. La plantilla de mapeo debe crear la salida JSON a continuación, que es la entrada para su función Lambda.

   {
   "queryStringParameters": {"param3":"333","param1":"111","param2":"222"}
   }

5. Ya terminaste Desde este punto, la lógica de su función Lambda puede usar los parámetros de la cadena de consulta.
   ¡Buena suerte!

Answer 12

La respuesta aceptada funcionó bien para mí, pero al ampliar la respuesta de gimenete, quería una plantilla genérica que pudiera usar para pasar por todos los parámetros de consulta / ruta / encabezado (solo como cadenas por ahora), y encontré la siguiente plantilla. Lo estoy publicando aquí en caso de que alguien lo encuentre útil:

#set($keys = [])
#foreach($key in $input.params().querystring.keySet())
  #set($success = $keys.add($key))
#end

#foreach($key in $input.params().headers.keySet())
  #if(!$keys.contains($key))
    #set($success = $keys.add($key))
  #end
#end

#foreach($key in $input.params().path.keySet())
  #if(!$keys.contains($key))
    #set($success = $keys.add($key))
  #end
#end

{
#foreach($key in $keys)
  "$key": "$util.escapeJavaScript($input.params($key))"#if($foreach.hasNext),#end
#end
}

Answer 13

Los pasos para que esto funcione son:

Dentro de la API Gateway Console ...

1. ir a Resources -> Integration Request
2. haga clic en el ícono más o editar junto al menú desplegable de plantillas (extraño, ya que el campo de la plantilla ya está abierto y el botón aquí aparece atenuado)
3. Escriba explícitamente application/json en el campo de tipo de contenido aunque muestre un valor predeterminado (si no lo hace, no se guardará y no le dará un mensaje de error)

4. poner esto en la asignación de entrada { "name": "$input.params(''name'')" }

5. haga clic en la casilla de verificación junto al menú desplegable de plantillas (supongo que esto es lo que finalmente lo guarda)

Answer 14

Muchas de las respuestas aquí son geniales. Pero quería algo un poco más simple. Quería algo que funcione con la muestra "Hello World" de forma gratuita. Esto significa que quería que un simple produzca un cuerpo de solicitud que coincida con la cadena de consulta:

{
#foreach($param in $input.params().querystring.keySet())
  "$param": "$util.escapeJavaScript($input.params().querystring.get($param))" #if($foreach.hasNext),#end
#end
}

Creo que la respuesta principal produce algo más útil cuando se construye algo real, pero para que se ejecute un mundo de saludo rápido usando la plantilla de AWS, esto funciona muy bien.

Answer 15

Para pasar parámetros a su función lambda, debe crear una asignación entre la solicitud de API Gateway y su función lambda. La asignación se realiza en la sección Integration Request -> Mapping templates del recurso API Gateway seleccionado.

Cree una asignación de tipo application/json , luego a la derecha editará (haga clic en el lápiz) la plantilla.

Una plantilla de mapeo es en realidad una plantilla Velocity donde puedes usar ifs, loops y, por supuesto, imprimir variables en ella. La plantilla tiene docs.aws.amazon.com/apigateway/latest/developerguide/… donde puede acceder a los parámetros de cadena de consulta, encabezados de solicitud, etc. individualmente. Con el siguiente código, puede volver a crear toda la cadena de consulta:

{
    "querystring" : "#foreach($key in $input.params().querystring.keySet())#if($foreach.index > 0)&#end$util.urlEncode($key)=$util.urlEncode($input.params().querystring.get($key))#end",
    "body" : $input.json(''$'')
}

Nota: haga clic en el símbolo de verificación para guardar la plantilla. Puede probar sus cambios con el botón "prueba" en su recurso. Pero para probar los parámetros de la cadena de consulta en la consola de AWS, deberá definir los nombres de los parámetros en la sección Method Request de su recurso.

Nota: consulte la Guía del usuario de Velocity para obtener más información sobre el lenguaje de plantillas Velocity.

Luego, en su plantilla lambda, puede hacer lo siguiente para analizar la cadena de consulta:

var query = require(''querystring'').parse(event.querystring)
// access parameters with query[''foo''] or query.foo

Answer 16

Puede usar Lambda como "Integración de proxy Lambda" , refiérase a esto [ https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-create-api-as-simple-proxy-for-lambda.html#api-gateway-proxy-integration-lambda-function-python] , las opciones disponibles para este lambda son

Para Nodejs Lambda ''event.headers'', ''event.pathParameters'', ''event.body'', ''event.stageVariables'' y ''event.requestContext''

Para el evento Python Lambda [''encabezados''] [''nombre de parámetro''] y así sucesivamente