webentwicklung-frage-antwort-db.com.de

So debuggen Sie aws-Lambda-Funktionen, die im Knoten js geschrieben sind

Wir entwickeln seit einigen Monaten AWS-Lambda-Funktionen in Node JS. Können wir debuggen, d. H. Schritt für Schritt durch den Knoten-JS-Code führen, wie wir es mit .Net C # -Code in Visual Studio können?

6
Steve

IDE-basierte Entwicklungstools sind standardmäßig für viele Lambda-Funktionen nicht verfügbar. Es gibt einige Plugins, z. B. die Unterstützung für Visual Studio, die von AWS in ihrem Blog unter https://aws.Amazon.com/blogs/developer/aws-lambda-support-in-visual-studio/ eingeführt wurde Diese haben unterschiedliche Level an Feature-Sets und Unterstützung.

Um Lambda mit dem schrittweisen Debugging zu testen, müssen Sie sich auf zwei Domänen konzentrieren - auf die Hardware, auf der es ausgeführt wird, und auf die Art und Weise, in der Ihre Lambda-Funktion aufgerufen wird. Die Hardware zu emulieren ist schwierig, da AWS die Details der Maschineninstanzen, die Ihre Lambda-Funktionen ausführen, geheim hält. Wenn Sie also Hardware emulieren, müssen Sie lediglich das für Ihre Sprache und Ihr Betriebssystem angemessene Maß einhalten. Vergewissern Sie sich, dass die korrekte Laufzeit installiert ist (wie in, installieren Sie NodeJS 4.X nicht, wenn Sie dies tun arbeiten mit der Laufzeitversion 6), stellen Sie sicher, dass Sie die Speicheranforderungen nicht überschreiten (AMIs für Lambda erhalten 500 MB temporären Speicherplatz in/tmp), und stellen Sie sicher, dass Sie keinen Status lokal speichern, bevor Sie sie ausführen Code.

Wenn Sie die Anforderungen an Ihr Gerät genau festgelegt haben (oder sich entschieden haben, sie weiterzugeben, da Ihr Code keine hardwarespezifischen Aufgaben erledigt), müssen Sie einen Test-Harness schreiben, um die AWS-Lambda-Funktion aufzurufen. Dieses Test-Harness dient als Einstiegspunkt für Ihren Debugger, und es ist höchstwahrscheinlich nicht 100% ig genau, wie AWS Lambda aufruft (der Parameter context enthält beispielsweise Informationen zu Ihrem aktuellen Lambda-Aufruf, die sich naturgemäß unterscheiden können Ausführungen), bringt Sie an den Punkt, an dem Sie alle Standard-Tools zur Unterstützung der Codierung aufrufen können.

Hinweis: Der folgende einfache Test-Kabelsatz wurde für Node.JS geschrieben. Sie können die Konzepte jedoch an die Laufzeit anpassen, in der Ihr Lambda ausgeführt wird

Eine einfache Testumgebung für AWS Lambda (Node.js)

Als Erstes erstellen wir eine neue Datei - debug.js - und importieren den Prototyp der Handlerfunktion. Angenommen, Sie haben Ihren Handler in handler.js definiert und handler genannt, gehen Sie folgendermaßen vor:

var handler = require('./handler.js').handler;

Als Nächstes müssen wir die Handlerfunktion aufrufen. Wie ich oben angesprochen habe, hat jeder Parameter einen anderen Zweck. Der erste Parameter des Handlers -event - enthält Details zu dem Ereignis, das den Aufruf verursacht. Hinweis: Dazu gehören auch Ihre Funktionsargumente . Wie bereits erwähnt, enthält der zweite Parameter Informationen zum Kontext, in dem Ihre Funktion ausgeführt wird. Es gibt auch einen dritten Parameter, den Callback, mit dem ein Callback nach Abschluss der Lambda-Ausführung aufgerufen werden kann. Überprüfen Sie die AWS-Dokumente hier: http://docs.aws.Amazon.com/lambda/latest/dg/nodejs-prog-model-handler.html

Für unsere Zwecke müssen wir für einen einfachen Test-Kabelsatz die Parameter nur im Parameter event durchgeben. Wir lassen die Parameter context und callback vorerst alleine (mit einer geringfügigen Änderung, mehr dazu unten), aber wenn Sie zusätzliche Daten bereitstellen möchten, auf die Ihre Funktion angewiesen ist, ist das in Ordnung - Sie müssen nur sicherstellen, dass sie nicht miteinander in Konflikt stehen Alle automatisierten Daten werden in AWS abgelegt. Also definieren wir den Parameter hash und rufen die Funktion mit dem folgenden Code in debug.js auf:

var parameters = {
    "key1":"val1",
    "object" :{},
    // other keys as necessary
};

handler(parameters, {succeed:function(result){
    console.log("success: ", JSON.stringify(result, null, 2));
    process.exit(0);
}, fail:function(error){
    console.error("error: ", error);
    process.exit(1);
}});

Dieser Code bewirkt einige interessante Dinge:

  • Das Kontextobjekt wird mit einem Erfolgs- und Fehlerhandler überladen. Sie können diese in eine "if" -Anweisung einschließen und sie mit context.succeed(message) oder context.fail(error) in Ihrem Lambda-Code aufrufen. Diese werden nicht offiziell von Lambda unterstützt, sondern werden in unserem Code als Workaround verwendet, um Zugriff auf das Verhalten von Erfolg/Misserfolg zu erhalten.
    • Handler rufen process.exit () mit dem entsprechenden Fehlercode auf. Auf diese Weise können Sie Ihre Ausführung in CI/CD-Tools oder in andere Batch-Verarbeitungstools verketten, die Prozess-Exit-Code als Steuerungsfluss verwenden

Wenn Sie diesen einfachen Test-Harness geschrieben und Ihren Lambda-Code so angepasst haben, dass er den Success/Fail-Handler aufruft (falls etwas vorhanden ist (etwas anderes als if(context.success){context.success(args);} sollte ausreichen), können Sie jetzt die Lambda-Funktion mit node debug.js aufrufen und die Ergebnisse anzeigen in der Konsole.

Ich hatte auch beim Unit-Test in meinen Lambda-Funktionen großes Glück. Da Sie nun einen Einstiegspunkt und ein Beispiel für den Aufruf der Lambda-Funktion haben, sollten Sie in der Lage sein, geeignete Einheiten- und Funktionstests zu schreiben, die all Ihre Funktionalität ausdrücken.

Ein kurzer Hinweis auf Mängel

Wie ich bereits erwähnt habe, ist dieser Ansatz nicht perfekt. Hier sind einige Probleme mit dem Testkabelbaum, die möglicherweise auftreten könnten:

  • Wir haben keine Emulation des Kontextobjekts durchgeführt. Die im Kontextobjekt verfügbaren Parameter finden Sie unter http://docs.aws.Amazon.com/lambda/latest/dg/nodejs-prog-model-context.html - Sie müssen einige tun Versuch und Irrtum, um herauszufinden, welches Format in diesen Parametern endet
  • Wir haben keine Maschinenemulation durchgeführt, um Hardwareprobleme zu erkennen
  • Wir haben hier nur die Funktionen von Node.js behandelt. Andere Sprachen haben möglicherweise Schwierigkeiten, den Callback-Ansatz anzupassen
  • Wir haben den Kontextmechanismus überlastet, um unsere Handler für das Scheitern von Erfolg bereitzustellen. Wenn AWS dem context-Objekt gleichnamige Member-Objekte hinzufügt, kann dieser Ansatz zu Problemen führen

Trotzdem sollten Sie jetzt die Möglichkeit haben, lokale Debugging-Tools zum Testen und Debuggen Ihrer Lambda-Funktionen zu verwenden. Wir verwenden ein ähnliches Framework bei Backand - https://www.backand.com - für unser Entwicklungswerkzeug für Lambda-Funktionen, und es hat unsere Entwicklungsgeschwindigkeit für Lambda stark erhöht.

6
Matt Billock

Ich möchte gerne mitteilen, was ich gefunden habe, da es mir schwer fiel, es herauszufinden. Die Lösung basiert auf dem, was ich zu Artikel "Debuggen von AWS-Lambda-Funktionen lokal mit VS-Code und Lambda-local" gefunden habe ( https://www.codeproject.com/Articles/1163890/Debugging-AWS-Lambda-functions-locally -using-VS-Co ) mit einigen Modifikationen, um in unserer Windows-basierten Umgebung zu arbeiten.

Hier ist die Zusammenfassung:

1) Verwenden von Visual Studio Code zum Mittagessen einer Debug-Sitzung. Ein Beispiel von launch.json für das Debuggen von 'llDebugDetail.js' ist wie folgt:

{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "node",
            "request": "launch",
            "name": "Launch Program",
            "program": "${workspaceRoot}/test/llDebugDetail.js",
            "cwd": "${workspaceRoot}"
        }
    ]
}

2) Verwendung des Lambda-Local-Frameworks zum Aufrufen (Ausführen) der Lambda-Funktion. Das Lambda-Local-Framework muss lokal installiert werden, andernfalls kann der VSC-Debugger es nicht finden. Unsere Lambda-Funktion wird durch Aufrufen der folgenden URL aufgerufen: https://xxx.execute-api.ap-southeast-2.amazonaws.com/resourceName/ {id}/detail. Der {id} ist ein GUID -Parameter, um ein Produktelement auszuwählen und seine Details zurückzugeben.

Hier ist der 'llDebugDetail.js'-Code zum Aufrufen der' getDetail'-Funktion für die Rückgabe von Produktdetails mit dem GUID als ID in der URL. Die Funktion befindet sich in der Datei 'getDetail.js'.

const lambdaLocal = require('lambda-local');
var path = require("path");
const myPath = path.join(__dirname, '../getDetail.js');
const testEvent = {
    "resource": "resourceName/12da3f7d-7ce2-433f-8659-5d7cd0d74d9a/detail",
    "pathParameters": {"id": "12da3f7d-7ce2-433f-8659-5d7cd0d74d9a"}
}

var lambdaFunc = require(myPath);

lambdaLocal.execute({
    event: testEvent,
    lambdaFunc: lambdaFunc, 
    lambdaHandler: "getDetail"
}).then(function(done) {
    console.log(done);
}).catch(function(err) {
    console.log(err);
});

Mit den oben genannten Schritten können Sie jetzt an beliebiger Stelle innerhalb Ihres Codes Haltepunkte setzen, z. Starten Sie in getDetail.js das Programm und den Code-Schritt von den Haltepunkten in getDetail.js aus. 

4
Steve

Sie können den Lambda-Code nicht wie in VS debuggen, Sie können jedoch einige Testdaten aufrufen und prüfen, ob alles in Ordnung ist. 

  1. Sie können Lambda lokal auf Ihrem Computer ausführen, indem Sie lambda-local und serverless-offline verwenden.
  2. Rufen Sie also Ihr Lambda mit einigen Testereignissen und Daten auf, und Sie können protokollieren und sehen, was für die verschiedenen Eingaben geschieht
3
Prasanth Jaya

Trek 10 hat kürzlich ein interessantes Tool veröffentlicht, mit dem knoten.js-Code in AWS-Lambda-Funktionen live durchlaufen werden kann! Wie können Sie fragen? "Magie und Spiegel", laut ihnen :-)

Anscheinend wird keine direkte Verbindung mit dem Host-Prozess von Amazon hergestellt (was nicht möglich ist), aber es zwingt Ihren Code in einen untergeordneten Prozess, der im Debug-Modus ausgeführt wird, und stellt eine Verbindung zu Ihren lokalen Chrome DevTools her. (Tatsächlich gibt es noch etwas mehr zur Konfiguration, die Sie unten im Github-Repo nachlesen können.)

Hier ist die Ankündigung: https://www.trek10.com/blog/aws-lambda-debugger/

und das github-repo: https://github.com/trek10inc/aws-lambda-debugger

1
rob3c

Wie andere bereits erwähnt haben, können Sie einen Lambda nicht nativ debuggen. Es werden jedoch neue Werkzeuge entwickelt, die dies ermöglichen. Rookout bietet jetzt das schrittweise Debuggen von Node.js-Lambdas der Produktion an, ohne den Code zu verzerren oder anzuhalten, indem eine Art Bytecode-Level-Methode verwendet wird. 

1
Arieh Kovler

Debuggen von Lambda mithilfe von Haltepunkten in VSCode:

Schreiben Sie zunächst Testfälle für Ihren Handler wie folgt: index.test.js

'use strict';

const handler = require('../index');

const chai = require('chai');

const { expect } = chai;

describe('debug demo', () => {
  it('should return success', () => {
    let event = {data: "some data"}
    handler(event, '', function(err, res) {
      expect(res.statusCode, '200')
    });
  });
});

Fügen Sie nun die VSCode-Debugger-Konfiguration hinzu

Schritt 1: Klicken Sie auf das Debugger-Symbol auf der linken Seite

enter image description here

Schritt 2: Klicken Sie auf Konfigurationen hinzufügen

enter image description here

und fügen Sie die folgenden Konfigurationen in die Datei launch.json ein:

{
    "version": "0.2.0",
    "configurations": [

      {
          "type": "node",
          "request": "launch",
          "name": "Mocha All",
          "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
          "args": [
              "--timeout",
              "999999",
              "--colors",
              "'${workspaceFolder}/lambda-codebase/**/test/*.test.js'"
          ],
          "console": "integratedTerminal",
          "internalConsoleOptions": "neverOpen"
      },
      {
          "type": "node",
          "request": "launch",
          "name": "Mocha Current File",
          "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
          "args": [
              "--timeout",
              "999999",
              "--colors",
              "${file}"
          ],
          "console": "integratedTerminal",
          "internalConsoleOptions": "neverOpen"
      }
    ]
  }

Schritt 3: Fügen Sie nun dem Code, den Sie debuggen möchten, einen Haltepunkt wie folgt hinzu:

enter image description here

Schritt 4: Konzentrieren Sie sich nun auf die Testdatei, indem Sie auf die Datei klicken:

Schritt 5: Wählen Sie die Option aus der Dropdown-Liste "Mocha All", um die vollständige Lösung auszuführen, und "Mocha Current File", um nur die ausgewählte Datei auszuführen

enter image description here

enter image description here

Nun klicke auf den DEBUG Play Button und genieße das Debuggen!

0

Schritt-Debugging ist bei Lambda nicht möglich. Das ist einer der Nachteile von Lambda. Sie müssen sich beim Debuggen auf die Protokollierung (log4j oder was auch immer) verlassen

0

Wenn Sie ein serverloses und serverloses Offline-Plug-In für den lokalen Test verwenden. .

Wenn Sie Windows verwenden, aktualisieren Sie vscode launch.json und package.json wie folgt: 

// launch.json
{

    "version": "0.2.0",

   "configurations": [

       {

           "type": "node",

           "request": "launch",

           "name": "Debug Serverless",

           "cwd": "${workspaceFolder}",

           "runtimeExecutable": "npm",

           "runtimeArgs": [

               "run",

               "debug"

           ],

           "outFiles": [

               "${workspaceFolder}/handler.js"

           ],

           "port": 9229,

           "sourceMaps": true

       }

   ]

}

// package.json
....
"scripts": {
    "debug": "SET SLS_DEBUG=* && node --inspect %USERPROFILE%\\AppData\\Roaming\\npm\\node_modules\\serverless\\bin\\serverless offline -s dev"
  }

Wenn Sie unter Linux ein Debug-Skript haben:

// package.json
....
"scripts": {
    "debug": "export SLS_DEBUG=* && node --inspect /usr/local/bin/serverless offline -s dev"
  }
0
bhavesh vyas

Die einfachste Option, die ich bisher mit VS Code habe, ist folgende:

  1. Erstellen Sie eine neue Datei, nennen wir sie debug.js und rufen Sie einfach Ihre Lambda-Funktion von hier aus auf, etwa so: const app = require('./index') app.handler()

  2. Ändern Sie den Programmeintrag der launcher.json-Datei wie folgt: "program": "${workspaceFolder}/<your app dir>/debug.js"

  3. Sie können jetzt einfach einen Haltepunkt in diese Zeile setzen (app.handler()) und es funktioniert 

0
Mohammad Haque