Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # 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](monitoring-cloudwatchlogs.md). 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 **Topics** + [Erstellen einer Funktion, die Protokolle zurückgibt](#node-logging-output) + [Verwenden Sie die erweiterten Logging-Steuerelemente von Lambda mit Node.js](#node-js-logging-advanced) + [Anzeigen von Protokollen in der Lambda-Konsole](#nodejs-logging-console) + [Protokolle in der Konsole anzeigen CloudWatch](#nodejs-logging-cwconsole) + [Anzeigen von Protokollen mit dem AWS Command Line Interface (AWS CLI)](#nodejs-logging-cli) + [Löschen von Protokollen](#nodejs-logging-delete) ## Erstellen einer Funktion, die Protokolle zurückgibt Um Protokolle aus dem Code Ihrer Funktion auszugeben, können Sie Methoden auf dem [Konsolenobjekt](https://developer.mozilla.org/en-US/docs/Web/API/Console) 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](https://cwe.mitre.org/data/definitions/117.html) in der *Common Weakness Enumeration*. **Example 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 } ``` **Example 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 `START``END`, 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](services-xray.md) + **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](monitoring-logs.md#monitoring-cloudwatchlogs-advanced). 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.trace``console.debug`,, `console.log` `console.info``console.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](typescript-logging.md) #### 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. **Example Node.js Logging-Code** ``` export const handler = async (event) => { console.error("This is a warning message"); ... } ``` **Example 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. **Example Node.js Logging-Code** ``` export const handler = async (event) => { console.log({data: 12.3, flag: false}); ... } ``` **Example 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. **Example Node.js Logging-Code** ``` export const handler = async (event) => { console.log('Some object - ', {data: 12.3, flag: false}); ... } ``` **Example 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. **Example 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); }; ``` **Example 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 [ (](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format_Libraries.html)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 ](https://www.npmjs.com/package/aws-embedded-metrics) - und Powertools for CloudWatch Libraries auf die neuesten Versionen. [AWS Lambda](https://github.com/aws-powertools/powertools-lambda-typescript) 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. **Example 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-Objekt[Verwenden strukturierter JSON-Protokolle mit Node.js](#nodejs-logging-advanced-JSON). Informationen zur Konfiguration des Protokollformats Ihrer Funktion finden Sie unter[Konfigurieren erweiterter Protokollierungsoptionen für Lambda-Funktionen](monitoring-logs.md#monitoring-cloudwatchlogs-advanced). + 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](typescript-logging.md) 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](https://www.ietf.org/rfc/rfc3339.txt)-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“ ](https://console.aws.amazon.com/cloudwatch/home?#logs:) auf der CloudWatch Konsole. 1. Wählen Sie die Protokollgruppe für Ihre Funktion (**/aws/lambda/{{your-function-name}}**). 1. Wählen Sie eine Protokollstream aus. Jeder Protokoll-Stream entspricht einer [Instance Ihrer Funktion](lambda-runtime-environment.md). 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](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). Sie können die [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) 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. **Example 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" } ``` **Example 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](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) 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 Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10)verfügbar. macOS-Benutzer müssen möglicherweise `base64 -D` verwenden. **Example 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-events`Ausgabe 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](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) 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 ``` **Example 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 ``` **Example 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](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) nach dem Protokolle automatisch gelöscht werden.