Comment passer d'une chaîne de requête ou un paramètre de route pour AWS Lambda de Passerelle API Amazon

En septembre 2017, vous n'avez plus à configurer les mappages d'accéder à la demande du corps.

Tout ce que vous devez faire est de vérifier, "Utilisation Lambda Proxy intégration", en vertu de l'Intégration de la Demande, en vertu de la ressource.

Vous serez alors en mesure d'accéder à des paramètres de requête, chemin des paramètres et des en-têtes comme

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

J'ai utilisé ce modèle de mappage pour lui donner du Corps, en-Têtes, une Méthode, un Chemin d'URL et les Paramètres de Chaîne de Requête pour le Lambda de l'événement. J'ai écrit un billet de blog expliquant le modèle plus en détail: http://kennbrodhagen.net/2015/12/06/how-to-create-a-request-object-for-your-lambda-event-from-api-gateway/

Ici est le Modèle de Mappage, vous pouvez utiliser:

{
  "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
  }  
}

La accepté de répondre à fonctionné pour moi, mais en expansion sur gimenete réponse, je voulais un modèle générique je pourrais utiliser pour passer à travers toutes les requêtes/chemin/en-tête params (juste comme des chaînes de caractères pour l'instant), et j'ai trouvé le modèle suivant. Je poste ici au cas où quelqu'un le trouve utile:

#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
}

Dans le cadre d'essayer de répondre à une de mes questions ici, je suis tombé sur cette astuce.

Dans la Passerelle API de cartographie de modèle, utilisez la commande suivante pour vous donner la complète de chaîne de requête envoyé par le client HTTP:

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

L'avantage est que vous n'avez pas à vous limiter à un ensemble prédéfini de touches repérées dans votre chaîne de requête. Maintenant, vous pouvez accepter toutes les paires clé-valeur dans la chaîne de requête, si c'est la façon dont vous souhaitez gérer.

Remarque: Selon cette, seulement $input.params(x) est répertorié comme une variable disponible pour le VTL modèle. Il est possible que le fonctionnement interne peut changer et querystring peuvent ne plus être disponibles.

Un grand nombre de réponses ici sont grands. Mais je voulais quelque chose d'un peu plus simple.
Je voulais quelque chose qui va travailler avec le "Hello World" de l'échantillon pour libre. Cela signifie que je voulais un simple produit un corps de requête qui correspond à la chaîne de requête:

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

Je pense que la réponse sommet, produit quelque chose de plus utile lors de la construction de quelque chose de réel, mais pour obtenir un rapide bonjour tout le monde exécute à l'aide d'un modèle à partir d'AWS cela fonctionne très bien.

OBTENIR /de l'utilisateur?nom=bob

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

OBTENIR /utilisateur/bob

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

La fonction Lambda attend JSON entrée, par conséquent, l'analyse de la chaîne de requête est nécessaire. La solution est de changer la chaîne de requête JSON en utilisant le Modèle de Mappage.
Je l'ai utilisé pour C# .NET de Base, de sorte que la contribution qui est attendue devrait être un JSON avec "queryStringParameters" paramètre.
Suivre ces 4 étapes ci-dessous pour obtenir que:

1. Ouvrir le modèle de mappage de votre Passerelle API de ressources et d'ajouter de nouvelles application/json contenu-tyap:

1. Copier le modèle ci-dessous, qui analyse la chaîne de requête en JSON, et le coller dans le modèle de mappage:

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

2. Dans la Passerelle API, appelez votre fonction Lambda et ajouter la chaîne de requête suivante (pour l'exemple): param1=111&param2=222&param3=333

3. Le modèle de mappage doit créer de la sortie JSON ci-dessous, qui est la entrée pour votre fonction Lambda.

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

4. Vous avez terminé. À partir de ce point, votre Lambda de la fonction logique peut utiliser les paramètres de chaîne de requête.
   
   Bonne chance!

Comme @la réponse de Jonathan, après que mark Utilisation Lambda Proxy intégration dans Intégration Demande, dans votre code source, vous devez mettre en œuvre en tant que ci-dessous le format de by-pass 502 Bad Gateway erreur.

NodeJS 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;
};

N'oubliez pas de déployer votre ressources à la Passerelle API avant de ré-exécution de votre API.
Réponse JSON juste de retour qui sont placés dans des corps est correct.
Donc, vous pourriez obtenir de chemin, paramètre, en-têtes, corps de la valeur de l'événement

const { path, queryStringParameters, en-têtes, corps } = événement;