Ausdrucken in das Protokoll Verwendung einer Protokollierungsbibliothek Verwenden von Lambda-Optionen für die erweiterte Protokollierung mit Python Anzeigen von Protokollen in der Lambda-Konsole Logs in CloudWatch der Konsole anzeigen Logs anzeigen mit AWS CLI Löschen von Protokollen Tools und Bibliotheken Verwendung von Powertools für AWS Lambda (Python) und AWS SAM für strukturiertes Logging Verwendung von Powertools für AWS Lambda (Python) und AWS CDK für strukturiertes Logging

Python-Lambda-Funktionen protokollieren und überwachen

AWS Lambda überwacht automatisch Lambda-Funktionen und sendet Protokolleinträge 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 zu CloudWatch Logs finden Sie unter CloudWatch Logs Logs mit Lambda verwenden.

Zur Ausgabe von Protokollen aus Ihrem Funktionscode können Sie das integrierte logging-Modul verwenden. Für detailliertere Einträge können Sie jede Protokollierungsbibliothek verwenden, die in stdout oder stderr schreibt.

Ausdrucken in das Protokoll

Um eine grundlegende Ausgabe an die Protokolle zu senden, können Sie in Ihrer Funktion eine print-Methode verwenden. Im folgenden Beispiel werden die Werte der CloudWatch Loggruppe und des Streams Logs sowie das Event-Objekt protokolliert.

Beachten Sie, dass Lambda Protokollausgaben nur im Klartextformat an Logs senden kann, wenn Ihre Funktion CloudWatch Logs mithilfe von print Python-Anweisungen ausgibt. Um Protokolle in strukturiertem JSON zu erfassen, müssen Sie eine unterstützte Protokollierungsbibliothek verwenden. Weitere Informationen finden Sie unter Verwenden von Lambda-Optionen für die erweiterte Protokollierung mit Python.

Beispiel lambda_function.py


import os
def lambda_handler(event, context):
    print('## ENVIRONMENT VARIABLES')
    print(os.environ['AWS_LAMBDA_LOG_GROUP_NAME'])
    print(os.environ['AWS_LAMBDA_LOG_STREAM_NAME'])
    print('## EVENT')
    print(event)

Beispiel Protokollausgabe


START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST
## ENVIRONMENT VARIABLES
/aws/lambda/my-function
2023/08/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c
## EVENT
{'key': 'value'}
END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95
REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95  Duration: 15.74 ms  Billed Duration: 16 ms Memory Size: 128 MB Max Memory Used: 56 MB  Init Duration: 130.49 ms
XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1   SegmentId: 07f5xmpl2d1f6f85 Sampled: true

Die Python-Laufzeit protokolliert die Zeilen START, END und REPORT für jeden Aufruf. Die REPORT-Zeile enthält die folgenden Daten:

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.
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 AWS X-Ray Trace-ID.
SegmentId— Für verfolgte Anfragen die X-Ray-Segment-ID.
Stichprobe – Bei verfolgten Anforderungen das Stichprobenergebnis.

Verwendung einer Protokollierungsbibliothek

Für detailliertere Protokolle verwenden Sie das Modul zur Protokollierung in der Standardbibliothek oder eine beliebige Protokollierungsbibliothek eines Drittanbieters, die in stdout oder stderr schreibt.

Für unterstützte Python-Laufzeiten können Sie wählen, ob mit dem logging-Standardmodul erstellte Protokolle im Klartext oder in JSON erfasst werden. Weitere Informationen hierzu finden Sie unter Verwenden von Lambda-Optionen für die erweiterte Protokollierung mit Python.

Derzeit ist das Standard-Protokollformat für alle Python-Laufzeiten das Klartextformat. Das folgende Beispiel zeigt, wie Protokollausgaben, die mit dem logging Standardmodul erstellt wurden, im Klartext in CloudWatch Logs erfasst werden.


import os
import logging
logger = logging.getLogger()
logger.setLevel("INFO")
  
def lambda_handler(event, context):
    logger.info('## ENVIRONMENT VARIABLES')
    logger.info(os.environ['AWS_LAMBDA_LOG_GROUP_NAME'])
    logger.info(os.environ['AWS_LAMBDA_LOG_STREAM_NAME'])
    logger.info('## EVENT')
    logger.info(event)

Die Ausgabe aus logger umfasst die Protokollebene, den Zeitstempel und die Anforderungs-ID.


START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST
[INFO]  2023-08-31T22:12:58.534Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    ## ENVIRONMENT VARIABLES
[INFO]  2023-08-31T22:12:58.534Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    /aws/lambda/my-function
[INFO]  2023-08-31T22:12:58.534Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    2023/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d
[INFO]  2023-08-31T22:12:58.535Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    ## EVENT
[INFO]  2023-08-31T22:12:58.535Z    1c8df7d3-xmpl-46da-9778-518e6eca8125    {'key': 'value'}
END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125
REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125  Duration: 2.75 ms   Billed Duration: 3 ms Memory Size: 128 MB Max Memory Used: 56 MB  Init Duration: 113.51 ms
XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370   SegmentId: 073cxmpl3e442861 Sampled: true

Anmerkung

Wenn das Protokollformat Ihrer Funktion auf Klartext gesetzt ist, lautet die Standardeinstellung auf Protokollebene für Python-Laufzeiten WARN. Das bedeutet, dass Lambda nur Protokollausgaben der Stufe WARN und niedriger an CloudWatch Logs sendet. Um die Standardprotokollebene zu ändern, verwenden Sie die Python-Methode logging setLevel(), wie in diesem Beispielcode gezeigt. Wenn Sie das Protokollformat Ihrer Funktion auf JSON setzen, empfehlen wir, die Protokollebene der Funktion mithilfe der erweiterten Lambda Advanced Logging Controls zu konfigurieren und nicht die Protokollebene im Code festzulegen. Weitere Informationen hierzu finden Sie unter Verwenden der Filterung auf Protokollebene mit Python.

Verwenden von Lambda-Optionen für die erweiterte Protokollierung mit Python

Um Ihnen mehr Kontrolle darüber zu geben, wie die Protokolle Ihrer Funktionen erfasst, verarbeitet und verwendet werden, können Sie die folgenden Protokollierungsoptionen für unterstützte Lambda-Python-Laufzeiten konfigurieren:

Protokollformat – Wählen Sie zwischen Klartext und einem strukturierten JSON-Format für die Protokolle Ihrer Funktion aus.
Protokollebene — für Logs im JSON-Format wählen Sie die Detailebene der Logs, 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 Konfiguration erweiterter Protokollierungssteuerungen für Lambda-Funktionen.

Weitere Informationen zur Verwendung der Optionen für das Protokollformat und die Protokollebene mit Ihren Python-Lambda-Funktionen finden Sie in den folgenden Abschnitten.

Verwenden strukturierter JSON-Protokolle mit Python

Wenn Sie JSON für das Protokollformat Ihrer Funktion auswählen, sendet Lambda die von der Python-Standard-Logging-Bibliothek ausgegebenen Logs CloudWatch als strukturiertes JSON an. 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

Die logging-Bibliothek von Python kann auch zusätzliche Schlüssel-Wert-Paare wie "logger" zu diesem JSON-Objekt hinzufügen.

Die Beispiele in den folgenden Abschnitten zeigen, wie mit der logging Python-Bibliothek generierte Protokollausgaben in CloudWatch Logs erfasst werden, wenn Sie das Protokollformat Ihrer Funktion als JSON konfigurieren.

Beachten Sie Folgendes: Wenn Sie die print-Methode verwenden, um grundlegende Protokollausgaben zu erzeugen, wie unter Ausdrucken in das Protokoll beschrieben, erfasst Lambda diese Ausgaben als Klartext, auch wenn Sie das Protokollierungsformat Ihrer Funktion als JSON konfigurieren.

Standard-JSON-Protokollausgaben mithilfe der Python-Protokollierungsbibliothek

Der folgende Beispielcodeausschnitt und die Protokollausgabe zeigen, wie mit der logging Python-Bibliothek generierte Standardprotokollausgaben in CloudWatch Logs erfasst werden, wenn das Protokollformat Ihrer Funktion auf JSON gesetzt ist.

Beispiel Python-Protokollierungscode


import logging  
logger = logging.getLogger()

def lambda_handler(event, context):
    logger.info("Inside the handler function")

Beispiel JSON-Protokolldatensatz


{
    "timestamp":"2023-10-27T19:17:45.586Z",
    "level":"INFO",
    "message":"Inside the handler function",
    "logger": "root",
    "requestId":"79b4f56e-95b1-4643-9700-2807f4e68189"
}

Protokollieren zusätzlicher Parameter in JSON

Wenn das Protokollformat Ihrer Funktion auf JSON gesetzt ist, können Sie auch zusätzliche Parameter mit der logging Python-Standardbibliothek protokollieren, indem Sie das extra Schlüsselwort verwenden, um ein Python-Wörterbuch an die Protokollausgabe zu übergeben.

Beispiel Python-Protokollierungscode


import logging

def lambda_handler(event, context):
    logging.info(
        "extra parameters example", 
        extra={"a":"b", "b": [3]},
    )

Beispiel JSON-Protokolldatensatz


{
  "timestamp": "2023-11-02T15:26:28Z",
  "level": "INFO",
  "message": "extra parameters example",
  "logger": "root",
  "requestId": "3dbd5759-65f6-45f8-8d7d-5bdc79a3bd01",
  "a": "b",
  "b": [
    3
  ]
}

Protokollierungsausnahmen in JSON

Der folgende Codeausschnitt zeigt, wie Python-Ausnahmen in der Protokollausgabe Ihrer Funktion erfasst werden, wenn Sie das Protokollformat als JSON konfigurieren. Beachten Sie, dass den mit logging.exception generierten Protokollausgaben die Protokollebene ERROR zugewiesen wird.

Beispiel Python-Protokollierungscode


import logging

def lambda_handler(event, context):
    try:
        raise Exception("exception")
    except:
        logging.exception("msg")

Beispiel JSON-Protokolldatensatz


{
  "timestamp": "2023-11-02T16:18:57Z",
  "level": "ERROR",
  "message": "msg",
  "logger": "root",
  "stackTrace": [
    "  File \"/var/task/lambda_function.py\", line 15, in lambda_handler\n    raise Exception(\"exception\")\n"
  ],
  "errorType": "Exception",
  "errorMessage": "exception",
  "requestId": "3f9d155c-0f09-46b7-bdf1-e91dab220855",
  "location": "/var/task/lambda_function.py:lambda_handler:17"
}

Strukturierte JSON-Protokolle mit anderen Protokollierungstools

Wenn Ihr Code bereits eine andere Logging-Bibliothek wie Powertools for verwendet AWS Lambda, um strukturierte JSON-Logs zu erstellen, müssen Sie keine Änderungen vornehmen. AWS Lambda codiert keine Logs doppelt, die bereits JSON-kodiert sind. Selbst wenn Sie Ihre Funktion so konfigurieren, dass sie das JSON-Protokollformat verwendet, erscheinen Ihre Logging-Ausgaben CloudWatch in der von Ihnen definierten JSON-Struktur.

Das folgende Beispiel zeigt, wie Protokollausgaben, die mit dem AWS Lambda Paket Powertools for generiert wurden, in CloudWatch Logs erfasst werden. Das Format dieser Protokollausgabe ist dasselbe, unabhängig davon, ob die Protokollierungskonfiguration Ihrer Funktion auf JSON oder TEXT festgelegt ist. Weitere Informationen zur Verwendung von Powertools für finden Sie unter AWS Lambda und Verwendung von Powertools für AWS Lambda (Python) und AWS SAM für strukturiertes Logging Verwendung von Powertools für AWS Lambda (Python) und AWS CDK für strukturiertes Logging

Beispiel Codeausschnitt für die Python-Protokollierung (mit Powertools für) AWS Lambda


from aws_lambda_powertools import Logger

logger = Logger()

def lambda_handler(event, context):
    logger.info("Inside the handler function")

Beispiel JSON-Protokolldatensatz (unter Verwendung von Powertools für) AWS Lambda


{ 
    "level": "INFO", 
    "location": "lambda_handler:7", 
    "message": "Inside the handler function", 
    "timestamp": "2023-10-31 22:38:21,010+0000", 
    "service": "service_undefined", 
    "xray_trace_id": "1-654181dc-65c15d6b0fecbdd1531ecb30" 
}

Verwenden der Filterung auf Protokollebene mit Python

Durch die Konfiguration der Filterung auf Protokollebene können Sie festlegen, dass nur Protokolle mit einer bestimmten Protokollierungsebene oder niedriger an Logs gesendet werden. CloudWatch Informationen zur Konfiguration der Filterung auf Protokollebene für Ihre Funktion finden Sie unter Filterung auf Protokollebene.

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

Erstellen Sie Protokollausgaben mit der logging-Python-Standardbibliothek und konfigurieren Sie Ihre Funktion so, dass sie die JSON-Protokollformatierung verwendet. AWS Lambda filtert dann Ihre Protokollausgaben mithilfe des Schlüssel-Wert-Paars „level“ im JSON-Objekt, wie unter Verwenden strukturierter JSON-Protokolle mit Python beschrieben. Informationen zur Konfiguration des Protokollformats Ihrer Funktion finden Sie unter Konfiguration erweiterter Protokollierungssteuerungen für Lambda-Funktionen.
Verwenden Sie eine andere Protokollierungsbibliothek oder Methode, um strukturierte JSON-Protokolle in Ihrem Code zu erstellen, die ein „level“-Schlüssel-Wert-Paar enthalten, das die Ebene der Protokollausgabe definiert. Sie können Powertools beispielsweise verwenden, AWS Lambda um strukturierte JSON-Protokollausgaben aus Ihrem Code zu generieren.

Sie können auch eine „print“-Anweisung verwenden, um ein JSON-Objekt auszugeben, das eine Protokollebenenkennung enthält. Die folgende Print-Anweisung erzeugt eine Ausgabe im JSON-Format, bei der die Protokollebene auf INFO gesetzt ist. AWS Lambda sendet das JSON-Objekt an CloudWatch Logs, wenn die Protokollierungsebene Ihrer Funktion auf INFO, DEBUG oder TRACE gesetzt ist.
```
print('{"msg":"My log message", "level":"info"}')
```

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 die Stufe INFO zu und fügt einen Zeitstempel für Sie hinzu.

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 über den eingebetteten Code-Editor getestet werden kann, finden Sie Protokolle in den Ausführungsergebnissen. Wenn Sie das Feature Konsolentest verwenden, um eine Funktion aufzurufen, finden Sie die Protokollausgabe im Abschnitt Details.

Logs in CloudWatch der Konsole anzeigen

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

Um Protokolle auf der Konsole anzuzeigen CloudWatch

Öffnen Sie die Seite Protokollgruppen auf der CloudWatch Konsole.
Wählen Sie die Protokollgruppe für Ihre Funktion (your-function-name/aws/lambda/).
Wählen Sie eine Protokollstream aus.

Jeder Protokoll-Stream entspricht einer Instance Ihrer Funktion. Ein Protokollstream wird angezeigt, wenn Sie Ihre Lambda-Funktion aktualisieren, und wenn zusätzliche Instances zum Umgang mit mehreren gleichzeitigen Aufrufen erstellt werden. Um Logs für einen bestimmten Aufruf zu finden, empfehlen wir, Ihre Funktion mit zu instrumentieren. AWS X-Ray X-Ray erfasst Details zu der Anforderung und dem Protokollstream in der Trace.

Logs anzeigen mit 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 Folgendes:

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.


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

Verwenden Sie andere Protokollierungstools und Bibliotheken

Powertools for AWS Lambda (Python) ist ein Entwickler-Toolkit zur Implementierung serverloser Best Practices und zur Steigerung der Entwicklergeschwindigkeit. Das Logger-Serviceprogramm bietet einen für Lambda optimierten Logger, der zusätzliche Informationen über den Funktionskontext all Ihrer Funktionen enthält, wobei die Ausgabe als JSON strukturiert ist. Mit diesem Serviceprogramm können Sie Folgendes tun:

Erfassung von Schlüsselfeldern aus dem Lambda-Kontext, Kaltstart und Strukturen der Protokollierungsausgabe als JSON
Protokollieren Sie Ereignisse von Lambda-Aufrufen, wenn Sie dazu aufgefordert werden (standardmäßig deaktiviert)
Alle Protokolle nur für einen bestimmten Prozentsatz der Aufrufe über Protokollstichproben drucken (standardmäßig deaktiviert)
Fügen Sie dem strukturierten Protokoll zu einem beliebigen Zeitpunkt zusätzliche Schlüssel hinzu
Verwenden Sie einen benutzerdefinierten Protokollformatierer (Bring Your Own Formatter), um Protokolle in einer Struktur auszugeben, die mit dem Logging RFC Ihres Unternehmens kompatibel ist

Verwendung von Powertools für AWS Lambda (Python) und AWS SAM für strukturiertes Logging

Führen Sie die nachstehenden Schritte aus, um eine Hello-World-Python-Beispielanwendung mit integrierten -Powertools for Python-Modulen unter Verwendung von AWS SAM bereitzustellen. Diese Anwendung implementiert ein grundlegendes API-Backend und verwendet Powertools zum Ausgeben von Protokollen, Metriken und Traces. Es besteht aus einem Amazon-API-Gateway-Endpunkt und einer Lambda-Funktion. Wenn Sie eine GET-Anfrage an den API-Gateway-Endpunkt senden, ruft die Lambda-Funktion Logs und Metriken auf, sendet sie im Embedded Metric Format an CloudWatch und sendet Traces an. AWS X-Ray Die Funktion gibt eine hello world-Nachricht zurück.

Voraussetzungen

Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:

Python 3.9
AWS CLI Version 2
AWS SAM CLI Version 1.75 oder höher. Wenn Sie eine ältere Version der AWS SAM CLI haben, finden Sie weitere Informationen unter Upgrade der AWS SAM CLI.

Stellen Sie eine AWS SAM Beispielanwendung bereit

Initialisieren Sie die Anwendung mit der Hello World Python-Vorlage.


sam init --app-template hello-world-powertools-python --name sam-app --package-type Zip --runtime python3.9 --no-tracing

Entwickeln Sie die App.
```
cd sam-app && sam build
```
Stellen Sie die Anwendung bereit.
```
sam deploy --guided
```
Folgen Sie den Anweisungen auf dem Bildschirm. Um die im interaktiven Erlebnis bereitgestellten Standardoptionen zu akzeptieren, drücken Sie Enter.

Anmerkung
Für ist HelloWorldFunction möglicherweise keine Autorisierung definiert. Ist das in Ordnung? , stellen Sie sicher, dass Sie eintreteny.

Rufen Sie die URL der bereitgestellten Anwendung ab:


aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text

Rufen Sie den API-Endpunkt auf:
```
curl GET <URL_FROM_PREVIOUS_STEP>
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```

Führen Sie sam logs aus, um die Protokolle für die Funktion abzurufen. Weitere Informationen finden Sie unter Arbeiten mit Protokollen im AWS Serverless Application Model -Entwicklerhandbuch.


sam logs --stack-name sam-app

Das Ergebnis sieht folgendermaßen aus:


2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16    Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.114000 {
  "level": "INFO",
  "location": "hello:23",
  "message": "Hello world API - HTTP 200",
  "timestamp": "2023-02-03 14:59:51,113+0000",
  "service": "PowertoolsHelloWorld",
  "cold_start": true,
  "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
  "function_memory_size": "128",
  "function_arn": "arn:aws:lambda:us-east-1:111122223333:function:sam-app-HelloWorldFunction-YBg8yfYtOc9j",
  "function_request_id": "d455cfc4-7704-46df-901b-2a5cce9405be",
  "correlation_id": "e73f8aef-5e07-436e-a30b-63e4b23f0047",
  "xray_trace_id": "1-63dd2166-434a12c22e1307ff2114f299"
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.126000 {
  "_aws": {
    "Timestamp": 1675436391126,
    "CloudWatchMetrics": [
      {
        "Namespace": "Powertools",
        "Dimensions": [
          [
            "function_name",
            "service"
          ]
        ],
        "Metrics": [
          {
            "Name": "ColdStart",
            "Unit": "Count"
          }
        ]
      }
    ]
  },
  "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
  "service": "PowertoolsHelloWorld",
  "ColdStart": [
    1.0
  ]
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.126000 {
  "_aws": {
    "Timestamp": 1675436391126,
    "CloudWatchMetrics": [
      {
        "Namespace": "Powertools",
        "Dimensions": [
          [
            "service"
          ]
        ],
        "Metrics": [
          {
            "Name": "HelloWorldInvocations",
            "Unit": "Count"
          }
        ]
      }
    ]
  },
  "service": "PowertoolsHelloWorld",
  "HelloWorldInvocations": [
    1.0
  ]
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be    Duration: 16.33 ms    Billed Duration: 17 ms    Memory Size: 128 MB    Max Memory Used: 64 MB    Init Duration: 739.46 ms    
XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299    SegmentId: 3c5d18d735a1ced0    Sampled: true

Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
```
sam delete
```

Verwalten der Protokollaufbewahrung

Wenn Sie eine Funktion löschen, werden Protokollgruppen nicht automatisch gelöscht. Um zu vermeiden, dass Protokolle auf unbestimmte Zeit gespeichert werden, löschen Sie die Protokollgruppe oder konfigurieren Sie einen Aufbewahrungszeitraum, nach dessen Ablauf die Protokolle CloudWatch automatisch gelöscht werden. Um die Aufbewahrung von Protokollen einzurichten, fügen Sie Ihrer AWS SAM Vorlage Folgendes hinzu:


Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      # Omitting other properties

  LogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: !Sub "/aws/lambda/${HelloWorldFunction}"
      RetentionInDays: 7

Verwendung von Powertools für AWS Lambda (Python) und AWS CDK für strukturiertes Logging

Gehen Sie wie folgt vor, um eine Hello World Python-Beispielanwendung mit integrierten Powertools for AWS Lambda (Python) -Modulen herunterzuladen, zu erstellen und bereitzustellen. Verwenden Sie dazu die AWS CDK. Diese Anwendung implementiert ein grundlegendes API-Backend und verwendet Powertools zum Ausgeben von Protokollen, Metriken und Traces. Es besteht aus einem Amazon-API-Gateway-Endpunkt und einer Lambda-Funktion. Wenn Sie eine GET-Anfrage an den API-Gateway-Endpunkt senden, ruft die Lambda-Funktion Logs und Metriken auf, sendet sie im Embedded Metric Format an CloudWatch und sendet Traces an. AWS X-Ray Die Funktion gibt eine Hello-World-Nachricht zurück.

Voraussetzungen

Zur Durchführung der Schritte in diesem Abschnitt benötigen Sie Folgendes:

Python 3.9
AWS CLI Version 2
AWS CDK Ausführung 2
AWS SAM CLI Version 1.75 oder höher. Wenn Sie eine ältere Version der AWS SAM CLI haben, finden Sie weitere Informationen unter Upgrade der AWS SAM CLI.

Stellen Sie eine AWS CDK Beispielanwendung bereit

Erstellen Sie ein Projektverzeichnis für Ihre neue Anwendung.
```
mkdir hello-world
cd hello-world
```
Initialisieren Sie die App.
```
cdk init app --language python
```
Installieren Sie die Python-Abhängigkeiten.
```
pip install -r requirements.txt
```
Erstellen Sie ein Verzeichnis lambda_function unter dem Stammordner.
```
mkdir lambda_function
cd lambda_function
```

Erstellen Sie eine Datei namens app.py und fügen Sie den folgenden Code zur Datei hinzu. Dies ist der Code für die Lambda-Funktion.


from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools import Logger
from aws_lambda_powertools import Tracer
from aws_lambda_powertools import Metrics
from aws_lambda_powertools.metrics import MetricUnit

app = APIGatewayRestResolver()
tracer = Tracer()
logger = Logger()
metrics = Metrics(namespace="PowertoolsSample")

@app.get("/hello")
@tracer.capture_method
def hello():
    # adding custom metrics
    # See: https://docs.powertools.aws.dev/lambda-python/latest/core/metrics/
    metrics.add_metric(name="HelloWorldInvocations", unit=MetricUnit.Count, value=1)

    # structured log
    # See: https://docs.powertools.aws.dev/lambda-python/latest/core/logger/
    logger.info("Hello world API - HTTP 200")
    return {"message": "hello world"}

# Enrich logging with contextual information from Lambda
@logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST)
# Adding tracer
# See: https://docs.powertools.aws.dev/lambda-python/latest/core/tracer/
@tracer.capture_lambda_handler
# ensures metrics are flushed upon request completion/failure and capturing ColdStart metric
@metrics.log_metrics(capture_cold_start_metric=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
    return app.resolve(event, context)

Öffnen Sie das Verzeichnis hello_world. Sie sollten eine Datei mit dem Namen hello_world_stack.py sehen.
```
cd ..
cd hello_world
```

Öffnen Sie hello_world_stack.py und fügen Sie den folgenden Code in die Datei ein. Dies enthält den Lambda-Konstruktor, der die Lambda-Funktion erstellt, Umgebungsvariablen für Powertools konfiguriert und die Protokollspeicherung auf eine Woche festlegt, und den ApiGatewayv1-Konstruktor, der die REST-API erstellt.


from aws_cdk import (
    Stack,
    aws_apigateway as apigwv1,
    aws_lambda as lambda_,
    CfnOutput,
    Duration
)
from constructs import Construct

class HelloWorldStack(Stack):

    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)

        # Powertools Lambda Layer
        powertools_layer = lambda_.LayerVersion.from_layer_version_arn(
            self,
            id="lambda-powertools",
            # At the moment we wrote this example, the aws_lambda_python_alpha CDK constructor is in Alpha, o we use layer to make the example simpler
            # See https://docs.aws.amazon.com/cdk/api/v2/python/aws_cdk.aws_lambda_python_alpha/README.html
            # Check all Powertools layers versions here: https://docs.powertools.aws.dev/lambda-python/latest/#lambda-layer
            layer_version_arn=f"arn:aws:lambda:{self.region}:017000801446:layer:AWSLambdaPowertoolsPythonV2:21"
        )

        function = lambda_.Function(self,
            'sample-app-lambda',
            runtime=lambda_.Runtime.PYTHON_3_9,
            layers=[powertools_layer],
            code = lambda_.Code.from_asset("./lambda_function/"),
            handler="app.lambda_handler",
            memory_size=128,
            timeout=Duration.seconds(3),
            architecture=lambda_.Architecture.X86_64,
            environment={
                "POWERTOOLS_SERVICE_NAME": "PowertoolsHelloWorld",
                "POWERTOOLS_METRICS_NAMESPACE": "PowertoolsSample",
                "LOG_LEVEL": "INFO"
            }
        )

        apigw = apigwv1.RestApi(self, "PowertoolsAPI", deploy_options=apigwv1.StageOptions(stage_name="dev"))

        hello_api = apigw.root.add_resource("hello")
        hello_api.add_method("GET", apigwv1.LambdaIntegration(function, proxy=True))

        CfnOutput(self, "apiUrl", value=f"{apigw.url}hello")

Stellen Sie die Anwendung bereit.
```
cd ..
cdk deploy
```

Rufen Sie die URL der bereitgestellten Anwendung ab:


aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`apiUrl`].OutputValue' --output text

Rufen Sie den API-Endpunkt auf:
```
curl GET <URL_FROM_PREVIOUS_STEP>
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```

Führen Sie sam logs aus, um die Protokolle für die Funktion abzurufen. Weitere Informationen finden Sie unter Arbeiten mit Protokollen im AWS Serverless Application Model -Entwicklerhandbuch.


sam logs --stack-name HelloWorldStack

Das Ergebnis sieht folgendermaßen aus:


2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16    Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.114000 {
  "level": "INFO",
  "location": "hello:23",
    "message": "Hello world API - HTTP 200",
  "timestamp": "2023-02-03 14:59:51,113+0000",
  "service": "PowertoolsHelloWorld",
  "cold_start": true,
  "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
  "function_memory_size": "128",
  "function_arn": "arn:aws:lambda:us-east-1:111122223333:function:sam-app-HelloWorldFunction-YBg8yfYtOc9j",
  "function_request_id": "d455cfc4-7704-46df-901b-2a5cce9405be",
  "correlation_id": "e73f8aef-5e07-436e-a30b-63e4b23f0047",
  "xray_trace_id": "1-63dd2166-434a12c22e1307ff2114f299"
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.126000 {
  "_aws": {
    "Timestamp": 1675436391126,
    "CloudWatchMetrics": [
      {
        "Namespace": "Powertools",
        "Dimensions": [
          [
            "function_name",
            "service"
          ]
        ],
        "Metrics": [
          {
            "Name": "ColdStart",
            "Unit": "Count"
          }
        ]
      }
    ]
  },
  "function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
  "service": "PowertoolsHelloWorld",
  "ColdStart": [
    1.0
  ]
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.126000 {
  "_aws": {
    "Timestamp": 1675436391126,
    "CloudWatchMetrics": [
      {
        "Namespace": "Powertools",
        "Dimensions": [
          [
            "service"
          ]
        ],
        "Metrics": [
          {
            "Name": "HelloWorldInvocations",
            "Unit": "Count"
          }
        ]
      }
    ]
  },
  "service": "PowertoolsHelloWorld",
  "HelloWorldInvocations": [
    1.0
  ]
}
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be
2023/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2023-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be    Duration: 16.33 ms    Billed Duration: 17 ms    Memory Size: 128 MB    Max Memory Used: 64 MB    Init Duration: 739.46 ms    
XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299    SegmentId: 3c5d18d735a1ced0    Sampled: true

Dies ist ein öffentlicher API-Endpunkt, der über das Internet zugänglich ist. Es wird empfohlen, dass Sie den Endpunkt nach dem Testen löschen.
```
cdk destroy
```

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Kontext

Testen