Dlaczego to żądanie HTTP nie działa na AWS Lambda?

Prosty roboczy przykład żądania Http przy użyciu węzła.

const http = require('https')
exports.handler = async (event) => {
    return httprequest().then((data) => {
        const response = {
            statusCode: 200,
            body: JSON.stringify(data),
        };
    return response;
    });
};
function httprequest() {
     return new Promise((resolve, reject) => {
        const options = {
            host: 'jsonplaceholder.typicode.com',
            path: '/todos',
            port: 443,
            method: 'GET'
        };
        const req = http.request(options, (res) => {
          if (res.statusCode < 200 || res.statusCode >= 300) {
                return reject(new Error('statusCode=' + res.statusCode));
            }
            var body = [];
            res.on('data', function(chunk) {
                body.push(chunk);
            });
            res.on('end', function() {
                try {
                    body = JSON.parse(Buffer.concat(body).toString());
                } catch(e) {
                    reject(e);
                }
                resolve(body);
            });
        });
        req.on('error', (e) => {
          reject(e.message);
        });
        // send the request
       req.end();
    });
}

Tak, odpowiedź awendt jest idealna. Pokażę tylko mój kod roboczy... Miałem kontekst.succeed ('Blah'); linia tuż za reqpostem .end (); line. Przeniesienie go do miejsca, w którym pokazuję poniżej rozwiązało wszystko.

console.log('GW1');

var https = require('https');

exports.handler = function(event, context) {

    var body='';
    var jsonObject = JSON.stringify(event);

    // the post options
    var optionspost = {
        host: 'the_host',
        path: '/the_path',
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
        }
    };

    var reqPost = https.request(optionspost, function(res) {
        console.log("statusCode: ", res.statusCode);
        res.on('data', function (chunk) {
            body += chunk;
        });
        context.succeed('Blah');
    });

    reqPost.write(jsonObject);
    reqPost.end();
};

Miałem do czynienia z tym problemem na węźle 10.Wersja X. poniżej znajduje się mój kod roboczy.

const https = require('https');

exports.handler = (event,context,callback) => {
    let body='';
    let jsonObject = JSON.stringify(event);

    // the post options
    var optionspost = {
      host: 'example.com', 
      path: '/api/mypath',
      method: 'POST',
      headers: {
      'Content-Type': 'application/json',
      'Authorization': 'blah blah',
    }
    };

    let reqPost =  https.request(optionspost, function(res) {
        console.log("statusCode: ", res.statusCode);
        res.on('data', function (chunk) {
            body += chunk;
        });
        res.on('end', function () {
           console.log("Result", body.toString());
           context.succeed("Sucess")
        });
        res.on('error', function () {
          console.log("Result Error", body.toString());
          context.done(null, 'FAILURE');
        });
    });
    reqPost.write(jsonObject);
    reqPost.end();
};

Miałem ten sam problem i wtedy zdałem sobie sprawę, że programowanie w NodeJS jest tak naprawdę inne niż Python czy Java, ponieważ opiera się na JavaScript. Postaram się użyć prostych pojęć, ponieważ może być kilka nowych osób, które byłyby zainteresowane lub mogą przyjść do tego pytania.

Spójrzmy na następujący kod:

var http = require('http'); // (1)
exports.handler = function(event, context) {
  console.log('start request to ' + event.url)
  http.get(event.url,  // (2)
  function(res) {  //(3)
    console.log("Got response: " + res.statusCode);
    context.succeed();
  }).on('error', function(e) {
    console.log("Got error: " + e.message);
    context.done(null, 'FAILURE');
  });

  console.log('end request to ' + event.url); //(4)
}

Za każdym razem, gdy wywołujesz metodę w http package (1), jest ona tworzona jako event i to zdarzenie otrzymuje osobne Zdarzenie. Funkcja' get ' (2) jest w rzeczywistości punkt wyjścia tego osobnego wydarzenia.

Teraz funkcja w (3) będzie wykonywana w osobnym zdarzeniu, a Twój kod będzie kontynuował ją wykonując ścieżkę i przeskoczy prosto do (4) i zakończy ją, ponieważ nie ma nic więcej do zrobienia.

Ale zdarzenie wywołane w (2) nadal gdzieś się wykonuje i zajmie mu to trochę czasu. Dziwne, prawda ?. Nie, Nie jest. W ten sposób działa NodeJS i jego bardzo ważne, że owijasz głowę wokół tej koncepcji. To jest miejsce, w którym obietnice JavaScript przychodzą z pomocą.

Możesz przeczytać więcej o obietnicach JavaScript tutaj . W skrócie, potrzebujesz obietnicy JavaScript, aby zachować wykonywanie kodu inline i nie pojawią się nowe / dodatkowe wątki.

Większość popularnych pakietów NodeJS ma obiecaną wersję swojego API, ale istnieją inne podejścia, takie jak BlueBirdJS, które rozwiązują podobny problem.

Kod, który napisałeś powyżej, może być luźno ponownie napisane w następujący sposób.

'use strict';
console.log('Loading function');
var rp = require('request-promise');
exports.handler = (event, context, callback) => {    

    var options = {
    uri: 'https://httpbin.org/ip',
    method: 'POST',
    body: {

    },
    json: true 
};


    rp(options).then(function (parsedBody) {
            console.log(parsedBody);
        })
        .catch(function (err) {
            // POST failed... 
            console.log(err);
        });

    context.done(null);
};

pamiętaj, że powyższy kod nie będzie działał bezpośrednio, jeśli zaimportujesz go w AWS Lambda. W przypadku Lambda konieczne będzie również spakowanie modułów z bazą kodu.

Znalazłem wiele postów w Internecie na różne sposoby wykonania żądania, ale żaden, który faktycznie pokazuje, jak przetworzyć odpowiedź synchronicznie na AWS Lambda.

Oto Node 6.10.3 funkcja lambda, która wykorzystuje żądanie https, zbiera i zwraca całą treść odpowiedzi i przekazuje kontrolę do nienotowanej funkcji processBody z wynikami. Uważam, że http i https są wymienne w tym kodzie.

Używam async utility module , co jest łatwiejsze aby zrozumieć dla początkujących. Aby go użyć, musisz wcisnąć go do swojego stosu AWS (polecam framework serverless).

Zauważ, że dane wracają w kawałkach, które są gromadzone w zmiennej globalnej, a na koniec wywołanie zwrotne jest wywoływane, gdy dane mają ended.

'use strict';

const async = require('async');
const https = require('https');

module.exports.handler = function (event, context, callback) {

    let body = "";
    let countChunks = 0;

    async.waterfall([
        requestDataFromFeed,
        // processBody,
    ], (err, result) => {
        if (err) {
            console.log(err);
            callback(err);
        }
        else {
            const message = "Success";
            console.log(result.body);
            callback(null, message);
        }
    });

    function requestDataFromFeed(callback) {
        const url = 'https://put-your-feed-here.com';
        console.log(`Sending GET request to ${url}`);
        https.get(url, (response) => {
            console.log('statusCode:', response.statusCode);
            response.on('data', (chunk) => {
                countChunks++;
                body += chunk;
            });
            response.on('end', () => {
                const result = {
                    countChunks: countChunks,
                    body: body
                };
                callback(null, result);
            });
        }).on('error', (err) => {
            console.log(err);
            callback(err);
        });
    }
};

Dodaj powyższy kod w bramie API w sekcji GET-Integration Request> mapping.

Tak, Istnieje wiele powodów, dla których możesz uzyskać dostęp do punktu końcowego AWS Lambda like I http.

Architektura AWS Lambda

To mikrousługa. Działa wewnątrz EC2 z Amazon Linux AMI (Wersja 3.14.26-24.46.amzn1x86_64) i działa z Node.js. Pamięć może mieć 128MB i 1gb. Gdy źródło danych uruchamia Zdarzenie, szczegóły są przekazywane do funkcji Lambda jako parametr.

Co się stało?

AWS Lambda run ' s inside a container, and the code jest przesyłany bezpośrednio do tego kontenera z pakietami lub modułami. Na przykład, nigdy nie możemy wykonać SSH dla linuksowego komputera z funkcją lambda. Jedyne, co możemy monitorować, to logi, z Cloudwatchlogami i wyjątkiem pochodzącym z runtime.

AWS zajmie się uruchomieniem i zakończeniem kontenerów za nas, po prostu uruchom kod. Tak więc, nawet jeśli używasz require ('http'), to nie zadziała, ponieważ miejsce, w którym działa ten kod, nie zostało do tego stworzone.