Anzeigen von CloudWatch-Protokollen für Lambda-Funktionen

Sie können die Amazon CloudWatch Logs für Ihre Lambda-Funktion über die Lambda-Konsole, die CloudWatch-Konsole oder das AWS Command Line Interface (AWS CLI) anzeigen. Folgen Sie den Anweisungen in den folgenden Abschnitten, um auf die Protokolle Ihrer Funktion zuzugreifen.

Streamen Sie Funktionsprotokolle mit CloudWatch Logs Live Tail

Amazon CloudWatch Logs Live Tail hilft Ihnen bei der schnellen Behebung von Problemen, indem eine Streamingliste neuer Protokollereignisse direkt in der Lambda-Konsole angezeigt wird. Sie können die von Ihren Lambda-Funktionen aufgenommenen Protokolle in Echtzeit anzeigen und filtern, sodass Sie Probleme schnell erkennen und beheben können.

Vergleich von Live Tail und --log-type Tail

Es gibt mehrere Unterschiede zwischen CloudWatch Logs Live Tail und der Option LogType: Tail in der Lambda-API (--log-type Tail in der AWS CLI):

Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um CloudWatch Logs Live Tail-Sitzungen zu starten und zu beenden:

Starten einer Live-Tail-Sitzung in der Lambda-Konsole

Zugriff auf Funktionsprotokolle über die Konsole

Jede Instance einer Lambda-Funktion hat einen eigenen Protokollstream. Wenn eine Funktion skaliert wird, hat jede gleichzeitige Instance ihren eigenen Protokollstream. Jedes Mal, wenn als Reaktion auf einen Aufruf eine neue Ausführungsumgebung erstellt wird, wird ein neuer Protokollstream generiert. Die Benennungskonvention für Protokollstreams lautet:

YYYY/MM/DD[Function version][Execution environment GUID]

Eine einzelne Ausführungsumgebung schreibt während ihrer Lebensdauer in denselben Protokollstream. Der Protokollstream enthält Nachrichten aus dieser Ausführungsumgebung sowie alle Ausgaben aus dem Code Ihrer Lambda-Funktion. Jede Nachricht wird mit einem Zeitstempel versehen, auch Ihre benutzerdefinierten Protokolle. Selbst wenn Ihre Funktion keine Ausgabe Ihres Codes protokolliert, werden pro Aufruf mindestens drei Protokollanweisungen generiert (START, END und REPORT):

Aus diesen Protokollen geht Folgendes hervor:

Zugriff auf Protokolle mit der AWS CLI

Die AWS CLI ist ein Open-Source-Tool, mit dem Sie über Befehle in Ihrer Befehlszeilen-Shell mit den AWS-Services 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.

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

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

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

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

#!/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

chmod -R 755 get-logs.sh

./get-logs.sh

{
    "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"
}

Parsing von Protokollen und strukturierte Protokollierung

Mit CloudWatch Logs Insights können Sie Protokolldaten mithilfe einer speziellen Abfragesyntax suchen und analysieren. Es führt Abfragen über mehrere Protokollgruppen durch und bietet eine leistungsstarke Filterung mithilfe von Mustervergleichen mit Glob- und regulären Ausdrücken.

Sie können diese Funktionen nutzen, indem Sie strukturierte Protokollierung in Ihren Lambda-Funktionen implementieren. Strukturierte Protokollierung organisiert Ihre Protokolle in einem vordefinierten Format, wodurch die Abfrage vereinfacht wird. Die Verwendung von Protokollebenen ist ein wichtiger erster Schritt zur Erstellung filterfreundlicher Protokolle, die Informationsmeldungen von Warnungen oder Fehlern trennen. Betrachten Sie beispielsweise den folgenden Node.js-Code:

exports.handler = async (event) => {
    console.log("console.log - Application is fine")
    console.info("console.info - This is the same as console.log")
    console.warn("console.warn - Application provides a warning")
    console.error("console.error - An error occurred")
}

Die resultierende CloudWatch-Protokolldatei enthält ein separates Feld, das die Protokollebene angibt:

Eine Abfrage von CloudWatch Logs Insights kann dann nach Protokollebene filtern. Um beispielsweise nur nach Fehlern zu suchen, können Sie die folgende Abfrage verwenden:

fields @timestamp, @message
| filter @message like /ERROR/
| sort @timestamp desc

JSON-strukturierte Protokollierung

JSON wird häufig verwendet, um Anwendungsprotokolle zu strukturieren. Im folgenden Beispiel wurden die Protokolle in JSON konvertiert, um drei unterschiedliche Werte auszugeben:

Das Feature CloudWatch Logs Insights erkennt automatisch Werte in der JSON-Ausgabe und parst die Nachrichten als Felder, ohne dass ein benutzerdefinierter glob oder regulärer Ausdruck erforderlich ist. Unter Verwendung der JSON-strukturierten Protokolle findet die folgende Abfrage Aufrufe, bei denen die hochgeladene Datei größer als 1 MB war, die Upload-Zeit mehr als 1 Sekunde betrug und der Aufruf kein Kaltstart war:

fields @message
| filter @message like /INFO/
| filter uploadedBytes > 1000000
| filter uploadTimeMS > 1000
| filter invocation != 1

Diese Abfrage könnte folgendes Ergebnis liefern:

Die in JSON erkannten Felder werden automatisch im Menü Erkannte Felder auf der rechten Seite ausgefüllt. Den vom Lambda-Dienst ausgegebenen Standardfeldern ist ein „@“ vorangestellt und Sie können diese Felder auf die gleiche Weise abfragen. Lambda-Protokolle enthalten immer die Felder @timestamp, @logStream, @message, @requestId, @duration, @billedDuration, @type, @maxMemoryUsed, @memorySize. Wenn X-Ray für eine Funktion aktiviert ist, enthalten die Protokolle auch @xrayTraceId und @xraySegmentId.

Wenn eine AWS-Ereignisquelle wie Amazon S3, Amazon SQS oder Amazon EventBridge Ihre Funktion aufruft, wird das gesamte Ereignis der Funktion als JSON-Objekt-Eingabe bereitgestellt. Indem Sie dieses Ereignis in der ersten Zeile der Funktion protokollieren, können Sie dann mit CloudWatch Logs Insights jedes der verschachtelten Felder abfragen.

Nützliche Insights-Abfragen

Die folgende Tabelle zeigt Beispiele für Insights-Abfragen, die für die Überwachung von Lambda-Funktionen nützlich sein können.

 fields Timestamp, LogLevel, Message
 | filter LogLevel == "ERR"
 | sort @timestamp desc
 | limit 100

filter @type = "REPORT"
| fields @requestId, @billedDuration
| sort by @billedDuration desc
| limit 100

filter @type = "REPORT"
| stats sum(strcontains(@message, "Init Duration"))/count(*) * 100 as
  coldStartPct, avg(@duration)
  by bin(5m)

filter @type = "REPORT"
| stats
    avg(@billedDuration) as Average,
    percentile(@billedDuration, 99) as NinetyNinth,
    percentile(@billedDuration, 95) as NinetyFifth,
    percentile(@billedDuration, 90) as Ninetieth
    by bin(30m)

filter @type="REPORT"
| stats avg(@maxMemoryUsed/1024/1024) as mean_MemoryUsed,
    min(@maxMemoryUsed/1024/1024) as min_MemoryUsed,
    max(@maxMemoryUsed/1024/1024) as max_MemoryUsed,
    percentile(@maxMemoryUsed/1024/1024, 95) as Percentile95

filter @type = "REPORT" and @maxMemoryUsed=@memorySize
| stats
    count_distinct(@requestId)
    by bin(30m)

avgMemoryUsedPERC,
    avg(@billedDuration) as avgDurationMS
    by bin(5m)

filter @type = "REPORT"
| stats
    max(@maxMemoryUsed / 1024 / 1024) as maxMemMB,
    avg(@maxMemoryUsed / 1024 / 1024) as avgMemMB,
    min(@maxMemoryUsed / 1024 / 1024) as minMemMB,
    (avg(@maxMemoryUsed / 1024 / 1024) / max(@memorySize / 1024 / 1024)) * 100 as avgMemUsedPct,
    avg(@billedDuration) as avgDurationMS
    by bin(30m)

filter @message like /Process exited/
| stats count() by bin(30m)

filter @message like /Task timed out/
| stats count() by bin(30m)

filter @type = "REPORT"
| stats avg(@duration), max(@duration), min(@duration)
  by bin(5m)

filter @type = "REPORT"
| stats max(@memorySize / 1024 / 1024) as provisonedMemMB,
        min(@maxMemoryUsed / 1024 / 1024) as smallestMemReqMB,
        avg(@maxMemoryUsed / 1024 / 1024) as avgMemUsedMB,
        max(@maxMemoryUsed / 1024 / 1024) as maxMemUsedMB,
        provisonedMemMB - maxMemUsedMB as overProvisionedMB

Protokollvisualisierung und Dashboards

Für jede Abfrage mit CloudWatch Logs Insights können Sie die Ergebnisse im Markdown- oder CSV-Format exportieren. In einigen Fällen kann es sinnvoller sein, Visualisierungen aus Abfragen zu erstellen, sofern mindestens eine Aggregationsfunktion vorhanden ist. Mit der stats-Funktion können Sie Aggregationen und Gruppierungen definieren.

Das vorherige logInsightsJSON-Beispiel hat nach Upload-Größe und Upload-Zeit gefiltert und erste Aufrufe ausgeschlossen. Dies führte zu einer Datentabelle. Für die Überwachung eines Produktionssystems kann es sinnvoller sein, die minimalen, maximalen und durchschnittlichen Dateigrößen zu visualisieren, um Ausreißer zu erkennen. Wenden Sie dazu die Statistikfunktion mit den erforderlichen Aggregaten an und gruppieren Sie nach einem Zeitwert, z. B. jede Minute:

Nehmen Sie beispielsweise die folgende Abfrage. Dies ist dieselbe Beispielabfrage wie im Abschnitt JSON-strukturierte Protokollierung, jedoch mit zusätzlichen Aggregationsfunktionen:

fields @message
| filter @message like /INFO/
| filter uploadedBytes > 1000000
| filter uploadTimeMS > 1000
| filter invocation != 1
| stats min(uploadedBytes), avg(uploadedBytes), max(uploadedBytes) by bin (1m)

Wir haben diese Aggregate aufgenommen, da es möglicherweise hilfreicher ist, die minimalen, maximalen und durchschnittlichen Dateigrößen zu visualisieren, um Ausreißer zu finden. Sie können die Ergebnisse auf der Registerkarte Visualisierung einsehen:

Nachdem Sie die Visualisierung erstellt haben, können Sie das Diagramm optional zu einem CloudWatch-Dashboard hinzufügen. Wählen Sie dazu oberhalb der Visualisierung die Option Zum Dashboard hinzufügen aus. Dadurch wird die Abfrage als Widget hinzugefügt und Sie können automatische Aktualisierungsintervalle auswählen, was die kontinuierliche Überwachung der Ergebnisse erleichtert: