Node.js Lambda-Funktionen protokollieren und überwachen

AWS Lambda überwacht automatisch Lambda-Funktionen in Ihrem Namen und sendet Protokolle an Amazon. CloudWatch Ihre Lambda-Funktion enthält eine CloudWatch Logs-Log-Gruppe und einen Log-Stream für jede Instanz Ihrer Funktion. Die Lambda-Laufzeitumgebung sendet Details zu den einzelnen Aufrufen an den Protokollstream und leitet Protokolle und andere Ausgaben aus dem Code Ihrer Funktion weiter. Weitere Informationen finden Sie unter Lambda-Funktionsprotokolle an CloudWatch Logs senden.

Auf dieser Seite wird beschrieben, wie Sie aus dem Code Ihrer Lambda-Funktion eine Protokollausgabe erstellen und mithilfe der AWS Command Line Interface Lambda-Konsole oder der Konsole auf Protokolle zugreifen. CloudWatch

Erstellen einer Funktion, die Protokolle zurückgibt

Um Protokolle aus dem Code Ihrer Funktion auszugeben, können Sie Methoden auf dem Konsolenobjekt oder eine Protokollierungsbibliothek verwenden, die zu stdout oder stderr schreibt. Das folgende Beispiel protokolliert die Werte der Umgebungsvariablen und des Ereignisobjekts.

Anmerkung

Wir empfehlen, bei der Protokollierung von Eingaben Techniken wie Eingabevalidierung und Ausgabekodierung zu verwenden. Wenn Sie Eingabedaten direkt protokollieren, kann ein Angreifer Ihren Code verwenden, um Manipulationen schwer zu erkennen, Protokolleinträge zu fälschen oder Protokollüberwachungen zu umgehen. Weitere Informationen finden Sie unter Unsachgemäße Neutralisierung der Ausgabe von Protokollen in der Common Weakness Enumeration.

Beispiel Datei index.js – Protokollierung

exports.handler = async function(event, context) {
  console.log("ENVIRONMENT VARIABLES\n" + JSON.stringify(process.env, null, 2))
  console.info("EVENT\n" + JSON.stringify(event, null, 2))
  console.warn("Event not processed.")
  return context.logStreamName
}

Beispiel Protokollformat

START RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac Version: $LATEST
2019-06-07T19:11:20.562Z	c793869b-ee49-115b-a5b6-4fd21e8dedac	INFO	ENVIRONMENT VARIABLES
{
  "AWS_LAMBDA_FUNCTION_VERSION": "$LATEST",
  "AWS_LAMBDA_LOG_GROUP_NAME": "/aws/lambda/my-function",
  "AWS_LAMBDA_LOG_STREAM_NAME": "2019/06/07/[$LATEST]e6f4a0c4241adcd70c262d34c0bbc85c",
  "AWS_EXECUTION_ENV": "AWS_Lambda_nodejs12.x",
  "AWS_LAMBDA_FUNCTION_NAME": "my-function",
  "PATH": "/var/lang/bin:/usr/local/bin:/usr/bin/:/bin:/opt/bin",
  "NODE_PATH": "/opt/nodejs/node10/node_modules:/opt/nodejs/node_modules:/var/runtime/node_modules",
  ...
}
2019-06-07T19:11:20.563Z	c793869b-ee49-115b-a5b6-4fd21e8dedac	INFO	EVENT
{
  "key": "value"
}
2019-06-07T19:11:20.564Z	c793869b-ee49-115b-a5b6-4fd21e8dedac	WARN	Event not processed.
END RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac
REPORT RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac	Duration: 128.83 ms	Billed Duration: 296 ms	Memory Size: 128 MB	Max Memory Used: 74 MB	Init Duration: 166.62 ms	XRAY TraceId: 1-5d9d007f-0a8c7fd02xmpl480aed55ef0	SegmentId: 3d752xmpl1bbe37e	Sampled: true

Die Node.js Laufzeitumgebung protokolliert die REPORT Zeilen STARTEND, und für jeden Aufruf. Sie fügt jedem von der Funktion protokollierten Eintrag einen Zeitstempel, eine Anforderungs-ID und eine Protokollebene hinzu. Die Berichtszeile enthält die folgenden Details.

Datenfelder für REPORT-Zeilen

• RequestId— Die eindeutige Anforderungs-ID für den Aufruf.

• Dauer – Die Zeit, die die Handler-Methode Ihrer Funktion mit der Verarbeitung des Ereignisses verbracht hat.

• Fakturierte Dauer – Die für den Aufruf fakturierte Zeit.

• Speichergröße – Die der Funktion zugewiesene Speichermenge.

• Max. verwendeter Speicher – Die Speichermenge, die von der Funktion verwendet wird. Wenn Aufrufe eine Ausführungsumgebung gemeinsam nutzen, meldet Lambda den maximalen Speicherverbrauch für alle Aufrufe. Dieses Verhalten kann zu einem höheren als erwarteten gemeldeten Wert führen.

• Initialisierungsdauer – Für die erste Anfrage die Zeit, die zur Laufzeit zum Laden der Funktion und Ausführen von Code außerhalb der Handler-Methode benötigt wurde.

• XRAY TraceId — Für verfolgte Anfragen die Trace-ID. AWS X-Ray

• SegmentId— Für verfolgte Anfragen die Segment-ID. X-Ray

• Stichprobe – Bei verfolgten Anforderungen das Stichprobenergebnis.

Sie können Protokolle in der Lambda-Konsole, in der CloudWatch Logs-Konsole oder über die Befehlszeile anzeigen.

Verwenden Sie die erweiterten Logging-Steuerelemente von Lambda mit Node.js

Um Ihnen mehr Kontrolle darüber zu geben, wie die Logs Ihrer Funktionen erfasst, verarbeitet und genutzt werden, können Sie die folgenden Protokollierungsoptionen für unterstützte Laufzeiten konfigurieren: Node.js

• Protokollformat — wählen Sie zwischen Klartext- und strukturiertem JSON-Format für die Logs Ihrer Funktion

• Protokollebene — Wählen Sie für Protokolle im JSON-Format die Detailebene der Protokolle, die Lambda an Amazon sendet CloudWatch, wie ERROR, DEBUG oder INFO

• Protokollgruppe — wählen Sie die CloudWatch Protokollgruppe aus, an die Ihre Funktion Protokolle sendet

Weitere Informationen zu diesen Protokollierungsoptionen und Anweisungen zur Konfiguration Ihrer Funktion für deren Verwendung finden Sie unter Konfigurieren erweiterter Protokollierungsoptionen für Lambda-Funktionen.

Informationen zur Verwendung des Protokollformats und der Log-Level-Optionen mit Ihren Node.js Lambda-Funktionen finden Sie in den folgenden Abschnitten.

Verwenden strukturierter JSON-Protokolle mit Node.js

Wenn Sie JSON für das Protokollformat Ihrer Funktion auswählen, sendet Lambda die Protokollausgabe mithilfe der Konsolenmethoden von console.traceconsole.debug,, console.log console.infoconsole.error, und console.warn an CloudWatch als strukturiertes JSON. Jedes JSON-Protokollobjekt enthält mindestens vier Schlüssel-Wert-Paare mit den folgenden Schlüsseln:

• "timestamp" – die Uhrzeit, zu der die Protokollmeldung generiert wurde

• "level" – die der Meldung zugewiesene Protokollebene

• "message" – der Inhalt der Protokollmeldung

• "requestId" – die eindeutige Anforderungs-ID für den Funktionsaufruf

Abhängig von der Protokollierungsmethode, die Ihre Funktion verwendet, kann dieses JSON-Objekt auch zusätzliche Schlüsselpaare enthalten. Wenn Ihre Funktion beispielsweise console-Methoden verwendet, um Fehlerobjekte mit mehreren Argumenten zu protokollieren, enthält das JSON-Objekt zusätzliche Schlüssel-Wert-Paare mit den Schlüsseln errorMessage, errorType und stackTrace.

Wenn Ihr Code bereits eine andere Protokollierungsbibliothek wie Powertools für verwendet AWS Lambda, um strukturierte JSON-Protokolle zu erstellen, müssen Sie keine Änderungen vornehmen. Lambda codiert keine Protokolle doppelt, die bereits JSON-kodiert sind, sodass die Anwendungsprotokolle Ihrer Funktion weiterhin wie zuvor erfasst werden.

Weitere Informationen zur Verwendung des Pakets Powertools for AWS Lambda Logging zum Erstellen strukturierter JSON-Logs in der Laufzeit finden Sie unter. Node.js TypeScript Lambda-Funktionen protokollieren und überwachen

Beispiel für Protokollausgaben im JSON-Format

Die folgenden Beispiele zeigen, wie verschiedene Protokollausgaben, die mithilfe der console Methoden mit einzelnen und mehreren Argumenten generiert wurden, in CloudWatch Logs erfasst werden, wenn Sie das Protokollformat Ihrer Funktion auf JSON setzen.

Im ersten Beispiel wird die console.error-Methode verwendet, um eine einfache Zeichenfolge auszugeben.

Beispiel Node.js Logging-Code

export const handler = async (event) => {
  console.error("This is a warning message");
  ...
}

Beispiel JSON-Protokolldatensatz

{
    "timestamp":"2025-11-01T00:21:51.358Z",
    "level":"ERROR",
    "message":"This is a warning message",
    "requestId":"93f25699-2cbf-4976-8f94-336a0aa98c6f"
}

Sie können mit den console-Methoden auch komplexere strukturierte Protokollnachrichten ausgeben, indem Sie entweder einzelne oder mehrere Argumente verwenden. Im nächsten Beispiel verwenden Sie console.log, um zwei Schlüssel-Wert-Paare mit einem einzigen Argument auszugeben. Beachten Sie, dass das "message" Feld im JSON-Objekt, das Lambda an CloudWatch Logs sendet, nicht stringifiziert ist.

Beispiel Node.js Logging-Code

export const handler = async (event) => {
  console.log({data: 12.3, flag: false});
  ...
}

Beispiel JSON-Protokolldatensatz

{
    "timestamp": "2025-12-08T23:21:04.664Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": {
        "data": 12.3,
        "flag": false
    }
}

Im nächsten Beispiel verwenden Sie erneut die console.log-Methode, um eine Protokollausgabe zu erstellen. Diesmal verwendet die Methode zwei Argumente, eine Map mit zwei Schlüssel-Wert-Paaren und eine identifizierende Zeichenfolge. Beachten Sie, dass Lambda in diesem Fall das Feld "message" in eine Zeichenfolge umwandelt, da Sie zwei Argumente angegeben haben.

Beispiel Node.js Logging-Code

export const handler = async (event) => {
  console.log('Some object - ', {data: 12.3, flag: false});
  ...
}

Beispiel JSON-Protokolldatensatz

{
    "timestamp": "2025-12-08T23:21:04.664Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": "Some object -  { data: 12.3, flag: false }"
}

Lambda weist Ausgaben, die mit console.log generiert wurden, der Protokollebene INFO zu.

Das letzte Beispiel zeigt, wie Fehlerobjekte mithilfe der console Methoden in CloudWatch Logs ausgegeben werden können. Beachten Sie, dass Lambda die Felder errorMessage, errorType und stackTrace zur Protokollausgabe hinzufügt, wenn Sie Fehlerobjekte mit mehreren Argumenten protokollieren.

Beispiel Node.js Logging-Code

export const handler = async (event) => {
  let e1 = new ReferenceError("some reference error");
  let e2 = new SyntaxError("some syntax error");
  console.log(e1);
  console.log("errors logged - ", e1, e2);
};

Beispiel JSON-Protokolldatensatz

{
    "timestamp": "2025-12-08T23:21:04.632Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": {
        "errorType": "ReferenceError",
        "errorMessage": "some reference error",
        "stackTrace": [
            "ReferenceError: some reference error",
            "    at Runtime.handler (file:///var/task/index.mjs:3:12)",
            "    at Runtime.handleOnceNonStreaming (file:///var/runtime/index.mjs:1173:29)"
        ]
    }
}

{
    "timestamp": "2025-12-08T23:21:04.646Z",
    "level": "INFO",
    "requestId": "405a4537-9226-4216-ac59-64381ec8654a",
    "message": "errors logged -  ReferenceError: some reference error\n    at Runtime.handler (file:///var/task/index.mjs:3:12)\n    at Runtime.handleOnceNonStreaming 
    (file:///var/runtime/index.mjs:1173:29) SyntaxError: some syntax error\n    at Runtime.handler (file:///var/task/index.mjs:4:12)\n    at Runtime.handleOnceNonStreaming 
    (file:///var/runtime/index.mjs:1173:29)",
    "errorType": "ReferenceError",
    "errorMessage": "some reference error",
    "stackTrace": [
        "ReferenceError: some reference error",
        "    at Runtime.handler (file:///var/task/index.mjs:3:12)",
        "    at Runtime.handleOnceNonStreaming (file:///var/runtime/index.mjs:1173:29)"
    ]
}

Bei der Protokollierung mehrerer Fehlertypen werden die zusätzlichen Felder errorMessage, errorType und stackTrace aus dem ersten Fehlertyp extrahiert, der an die console-Methode übergeben wurde.

Verwenden von Clientbibliotheken im Embedded Metric Format (EMF) mit strukturierten JSON-Protokollen

AWS stellt Open-Source-Clientbibliotheken bereit Node.js , mit denen Sie EMF-Protokolle (Embedded Metric Format) erstellen können. Wenn Sie bereits über Funktionen verfügen, die diese Bibliotheken verwenden, und Sie das Protokollformat Ihrer Funktion in JSON ändern, werden die von Ihrem Code ausgegebenen Metriken CloudWatch möglicherweise nicht mehr erkannt.

Wenn Ihr Code derzeit EMF-Protokolle direkt mit console.log oder mithilfe von Powertools for AWS Lambda (TypeScript) CloudWatch ausgibt, kann diese auch nicht analysiert werden, wenn Sie das Protokollformat Ihrer Funktion in JSON ändern.

Wichtig

Um sicherzustellen, dass die EMF-Protokolle Ihrer Funktionen weiterhin ordnungsgemäß analysiert werden, aktualisieren Sie Ihre EMF - und Powertools for CloudWatch Libraries auf die neuesten Versionen. AWS Lambda Wenn Sie zum JSON-Protokollformat wechseln, empfehlen wir Ihnen zudem, Tests durchzuführen, um die Kompatibilität mit den eingebetteten Metriken Ihrer Funktion sicherzustellen. Wenn Ihr Code EMF-Protokolle direkt mit console.log ausgibt, ändern Sie Ihren Code so, dass diese Metriken direkt in stdout ausgegeben werden, wie im folgenden Codebeispiel gezeigt.

Beispiel Code, der eingebettete Metriken auf stdout ausgibt

process.stdout.write(JSON.stringify(
    {
        "_aws": {
            "Timestamp": Date.now(),
            "CloudWatchMetrics": [{
                "Namespace": "lambda-function-metrics",
                "Dimensions": [["functionVersion"]],
                "Metrics": [{
                    "Name": "time",
                    "Unit": "Milliseconds",
                    "StorageResolution": 60
                }]
            }]
        },
        "functionVersion": "$LATEST",
        "time": 100,
        "requestId": context.awsRequestId
    }
) + "\n")

Verwenden der Filterung auf Protokollebene mit Node.js

AWS Lambda Um Ihre Anwendungsprotokolle nach ihrer Protokollebene zu filtern, muss Ihre Funktion JSON-formatierte Protokolle verwenden. Sie können dies auf zwei Arten erreichen:

• Erstellen Sie Protokollausgaben mithilfe der Standardmethoden der Konsole und konfigurieren Sie Ihre Funktion so, dass sie die JSON-Protokollformatierung verwendet. AWS Lambda filtert dann Ihre Protokollausgaben mithilfe des Schlüsselwertepaars „Level“ in dem unter beschriebenen JSON-ObjektVerwenden strukturierter JSON-Protokolle mit Node.js. Informationen zur Konfiguration des Protokollformats Ihrer Funktion finden Sie unterKonfigurieren erweiterter Protokollierungsoptionen für Lambda-Funktionen.

• Verwenden Sie eine andere Logging-Bibliothek oder Methode, um strukturierte JSON-Logs in Ihrem Code zu erstellen, die ein „Level“ -Schlüsselwert-Paar enthalten, das die Ebene der Logausgabe definiert. Sie können Powertools beispielsweise verwenden, AWS Lambda um strukturierte JSON-Protokollausgaben aus Ihrem Code zu generieren. Weitere Informationen TypeScript Lambda-Funktionen protokollieren und überwachen zur Verwendung von Powertools mit der Runtime finden Sie unter Node.js .

  Damit Lambda die Protokolle Ihrer Funktion filtern kann, müssen Sie auch ein "timestamp"-Schlüssel-Wert-Paar in Ihre JSON-Protokollausgabe aufnehmen. Die Uhrzeit muss im gültigen RFC 3339-Zeitstempelformat angegeben werden. Wenn Sie keinen gültigen Zeitstempel angeben, weist Lambda dem Protokoll das Level INFO zu und fügt einen Zeitstempel für Sie hinzu.

Wenn Sie Ihre Funktion für die Filterung auf Protokollebene konfigurieren, wählen Sie aus den folgenden Optionen die Protokollebene aus, die Sie an Logs senden AWS Lambda möchten CloudWatch :

Protokollebene	Standardnutzung
TRACE (am detailliertesten)	Die detailliertesten Informationen, die verwendet werden, um den Ausführungspfad Ihres Codes nachzuverfolgen
DEBUG	Detaillierte Informationen für das System-Debugging
INFO	Meldungen, die den normalen Betrieb Ihrer Funktion erfassen
WARN	Meldungen über potenzielle Fehler, die zu unerwartetem Verhalten führen können, wenn sie nicht behoben werden
ERROR	Meldungen über Probleme, die verhindern, dass der Code wie erwartet funktioniert
FATAL (am wenigsten Details)	Meldungen über schwerwiegende Fehler, die dazu führen, dass die Anwendung nicht mehr funktioniert

Lambda sendet Protokolle der ausgewählten Stufe und niedriger als. CloudWatch Wenn Sie beispielsweise die Protokollebene WARN konfigurieren, sendet Lambda Protokolle, die den Stufen WARN, ERROR und FATAL entsprechen.

Anzeigen von Protokollen in der Lambda-Konsole

Sie können die Lambda-Konsole verwenden, um die Protokollausgabe nach dem Aufrufen einer Lambda-Funktion anzuzeigen.

Wenn Ihr Code im eingebetteten Code-Editor getestet werden kann, finden Sie Protokolle in den Ausführungsergebnissen. Wenn Sie die Konsolentestfunktion verwenden, um eine Funktion aufzurufen, finden Sie die Protokollausgabe im Abschnitt Details.

Protokolle in der Konsole anzeigen CloudWatch

Sie können die CloudWatch Amazon-Konsole verwenden, um Protokolle für alle Lambda-Funktionsaufrufen anzuzeigen.

Um Protokolle auf der Konsole anzuzeigen CloudWatch

1. Öffnen Sie die Seite „Protokollgruppen“ auf der CloudWatch Konsole.

2. Wählen Sie die Protokollgruppe für Ihre Funktion (/aws/lambda/your-function-name).

3. Wählen Sie eine Protokollstream aus.

Jeder Protokoll-Stream entspricht einer Instance Ihrer Funktion. Ein Log-Stream erscheint, wenn Sie Ihre Lambda-Funktion aktualisieren und wenn zusätzliche Instances erstellt werden, um gleichzeitige Aufrufe zu verarbeiten. Um Logs für einen bestimmten Aufruf zu finden, empfehlen wir, Ihre Funktion mit zu instrumentieren. AWS X-Ray X-Ray zeichnet Details über die Anfrage und den Log-Stream im Trace auf.

Anzeigen von Protokollen mit dem AWS Command Line Interface (AWS CLI)

Das AWS CLI ist ein Open-Source-Tool, mit dem Sie mithilfe von Befehlen in Ihrer Befehlszeilen-Shell mit AWS Diensten interagieren können. Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie AWS CLI Version 2.

Sie können die AWS CLI verwenden, um Protokolle für einen Aufruf mit der --log-type-Befehlsoption abzurufen. Die Antwort enthält das Feld LogResult, das bis zu 4 KB base64-verschlüsselte Protokolle aus dem Aufruf enthält.

Beispiel eine Log-ID abrufen

Das folgende Beispiel zeigt, wie eine Protokoll-ID aus dem LogResult-Feld für eine Funktion namens my-function abgerufen wird.

aws lambda invoke --function-name my-function out --log-type Tail

Die Ausgabe sollte folgendermaßen aussehen:

{
    "StatusCode": 200,
    "LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
    "ExecutedVersion": "$LATEST"
}

Beispiel entschlüsseln der Protokolle

Verwenden Sie in derselben Eingabeaufforderung das base64-Dienstprogramm, um die Protokolle zu entschlüsseln. Das folgende Beispiel zeigt, wie Base64-codierte Logs für abgerufen werde my-function.

aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode

Die cli-binary-format Option ist erforderlich, wenn Sie AWS CLI Version 2 verwenden. Um dies zur Standardeinstellung zu machen, führen Sie aws configure set cli-binary-format raw-in-base64-out aus. Weitere Informationen finden Sie unter Von AWS CLI unterstützte globale Befehlszeilenoptionen im AWS Command Line Interface -Benutzerhandbuch für Version 2.

Die Ausgabe sollte folgendermaßen aussehen:

START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8  Duration: 79.67 ms      Billed Duration: 80 ms         Memory Size: 128 MB     Max Memory Used: 73 MB

Das base64-Dienstprogramm ist unter Linux, macOS und Ubuntu auf Windowsverfügbar. macOS-Benutzer müssen möglicherweise base64 -D verwenden.

Beispiel get-logs.sh-Skript

Verwenden Sie in derselben Eingabeaufforderung das folgende Skript, um die letzten fünf Protokollereignisse herunterzuladen. Das Skript verwendet sed zum Entfernen von Anführungszeichen aus der Ausgabedatei und wechselt 15 Sekunden lang in den Ruhezustand, um Zeit einzuräumen, damit Protokolle verfügbar werden können. Die Ausgabe enthält die Antwort von Lambda und die get-log-eventsAusgabe des Befehls.

Kopieren Sie den Inhalt des folgenden Codebeispiels und speichern Sie es in Ihrem Lambda-Projektverzeichnis unter get-logs.sh.

Die cli-binary-format Option ist erforderlich, wenn Sie AWS CLI Version 2 verwenden. Um dies zur Standardeinstellung zu machen, führen Sie aws configure set cli-binary-format raw-in-base64-out aus. Weitere Informationen finden Sie unter Von AWS CLI unterstützte globale Befehlszeilenoptionen im AWS Command Line Interface -Benutzerhandbuch für Version 2.

#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5

Beispiel macOS und Linux (nur diese Systeme)

In derselben Befehlszeile müssen macOS- und Linux-Benutzer möglicherweise den folgenden Befehl ausführen, um sicherzustellen, dass das Skript ausführbar ist.

chmod -R 755 get-logs.sh

Beispiel die letzten fünf Protokollereignisse abrufen

Führen Sie an derselben Eingabeaufforderung das folgende Skript aus, um die letzten fünf Protokollereignisse abzurufen.

./get-logs.sh

Die Ausgabe sollte folgendermaßen aussehen:

{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}
{
    "events": [
        {
            "timestamp": 1559763003171,
            "message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
            "ingestionTime": 1559763003309
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r  \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r  \"key\": \"value\"\r}\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
            "ingestionTime": 1559763018353
        }
    ],
    "nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
    "nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}

Löschen von Protokollen

Wenn Sie eine Funktion löschen, werden Protokollgruppen nicht automatisch gelöscht. Um das unbegrenzte Speichern von Protokollen zu vermeiden, löschen Sie die Protokollgruppe oder konfigurieren Sie eine Aufbewahrungszeitraum nach dem Protokolle automatisch gelöscht werden.