web-dev-qa-db-fra.com

Comment accéder aux en-têtes HTTP pour les demandes adressées à AWS API Gateway via Lambda?

Je vois dans la API Gateway FAQ qu'il est possible d'accéder aux en-têtes de requête envoyés à la passerelle API ...

Si vous utilisez déjà des jetons OAuth ou toute autre autorisation mécanisme, vous pouvez facilement configurer API Gateway pour ne pas exiger d’API signée appels et simplement transférer les en-têtes de jeton vers votre serveur pour vérification.

Cependant, je ne trouve aucun exemple de la manière de procéder dans la documentation et il est difficile de savoir comment accéder à ces données à l'aide de Lambda.

Je peux configurer une API ouverte et accéder à l'objet JSON faisant partie d'un POST ( Procédure pas à pas: passerelle API et fonctions Lambda ), mais pour implémenter une API de style OAuth 2.0 avec mon propre fournisseur, j'ai besoin d'accéder à l'en-tête "Authorization".

Ma préférence est de configurer cela en utilisant Lambda et Java 8, mais un exemple en utilisant node.js serait également utile pour comprendre comment y parvenir.

amazon-web-servicesaws-lambdaaws-api-gateway
40
JaredHatfield

Vous devez créer un mappage d'entrée dans le panneau Integration Request de l'écran du tableau de bord, décrivant votre méthode d'API.

Le code suivant traduit le paramètre d'entrée name query en Lambda Event input object:

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

Capture d'écran:

API Dashboard screenshot

Vous pouvez trouver plus d'informations à ce sujet dans le thread d'origine API Gateway to Lambda sur AWS Forums .

21
kixorz

Tout d'abord, vous devez extraire l'en-tête Authorization de la demande HTTP GET. Ensuite, vous devez mapper cette valeur sur l'objet événement Lambda.

Accédez au tableau de bord des méthodes de l'API et cliquez sur Demande de méthode. Vous pouvez y ajouter un HTTP Request Header appelé Authorization, comme indiqué ci-dessous.

HTTP Request Headers

Cela interceptera l'en-tête Authorization afin que vous puissiez l'utiliser plus tard.

Retournez maintenant au tableau de bord de la méthode et cliquez sur Integration Request. À partir de là, vous pouvez transmettre la valeur de l'en-tête à la fonction Lambda en utilisant un mappage comme celui-ci.

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

Maintenant, dans votre fonction Lambda, vous pouvez obtenir la valeur suivante.

event.Authorization
28
David Fevre

Vous pouvez utiliser le modèle de mappage suivant dans la demande d'intégration pour mapper de manière générique tous les paramètres de chemin, de requête et d'en-tête dans l'événement Lambda. Vous devrez toujours les enregistrer dans la section Demande de méthode de la passerelle API, mais vous pouvez au moins dissocier le modèle de mappage des paramètres spécifiques que vous souhaitez utiliser. De cette façon, vous n'avez pas à changer le code du modèle de mappage chaque fois que vous modifiez les paramètres d'en-tête, de requête ou de chemin.

J'ai écrit un article de blog qui donne plus de détails et quelques explications sur le modèle de cartographie: http://kennbrodhagen.net/2015/12/06/how-to-create-a-request-object-for-your-lambda -event-from-api-gateway/

Voici le modèle de mappage que 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
  }  
}
26
kennbrodhagen

bien que ce soit un vieux fil, je trouve qu'il est préférable d'utiliser l'intégration de proxy lambda à cette fin. Avec cela, vous n'avez rien à configurer dans la passerelle API et vous obtenez tous les en-têtes dans votre fonction lambda ...

10
Prabhat

Selon la réponse de Prabhat, configurer la demande d’intégration proxy lambda est le moyen le plus simple de procéder. Vous pouvez ensuite accéder aux en-têtes de demande, aux paramètres de chemin et aux paramètres de requête via 

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

La solution de kennbrodhagen a fonctionné à merveille pour moi. Consultez sa réponse et son blog pour plus de détails. Comme l'affiche exprimait une préférence pour l'implémentation Java et qu'il m'a fallu un certain temps pour comprendre comment implémenter le gestionnaire de Kenn en Java, je ne fais que partager le code Java correspondant:

public class MyHandler implements RequestHandler<Map<String,Object>,String> {

    @Override
    public String handleRequest(Map<String,Object> eventMap, Context context) {
        LambdaLogger logger = context.getLogger();
        logger.log("Body:" + eventMap.get("body"));
        logger.log("Headers:" + eventMap.get("headers"));
        logger.log("Method:" + eventMap.get("method"));
        logger.log("Params:" + eventMap.get("params"));
        logger.log("Query:" + eventMap.get("query"));
        return("{}");
    }
}
0
mojoken