Powertools für AWS Lambda (Python) und AWS SAM für das Tracing verwenden Verwenden von Powertools für AWS Lambda (Python) und AWS CDK für das Tracing Verwenden von ADOT zum Instrumentieren Ihrer Python-Funktionen Verwenden des X-Ray-SDK zum Instrumentieren Ihrer Python-Funktionen Aktivieren der Nachverfolgung mit der Lambda-Konsole Aktivieren der Nachverfolgung mit der Lambda-API Die Ablaufverfolgung wird aktiviert mit AWS CloudFormation Interpretieren einer X-Ray-Nachverfolgung Laufzeitabhängigkeiten in einer Ebene speichern (X-Ray-SDK)

Instrumentierung von Python-Code in AWS Lambda

Lambda lässt sich integrieren AWS X-Ray , um Ihnen zu helfen, Lambda-Anwendungen zu verfolgen, zu debuggen und zu optimieren. Sie können mit X-Ray eine Anforderung verfolgen, während sie Ressourcen in Ihrer Anwendung durchläuft, die Lambda-Funktionen und andere AWS -Services enthalten können.

Um Protokollierungsdaten an X-Ray zu senden, können Sie eine von drei SDK-Bibliotheken verwenden:

AWS Distro for OpenTelemetry (ADOT) — Eine sichere, produktionsbereite und AWS unterstützte Distribution des () SDK. OpenTelemetry OTel
AWS X-Ray-SDK for Python – Ein SDK zum Generieren und Senden von Nachverfolgungsdaten an X-Ray.
Powertools for AWS Lambda (Python) — Ein Entwickler-Toolkit zur Implementierung serverloser Best Practices und zur Steigerung der Entwicklergeschwindigkeit.

Jedes SDKs bietet Möglichkeiten, Ihre Telemetriedaten an den X-Ray-Dienst zu senden. Sie können dann mit X-Ray die Leistungsmetriken Ihrer Anwendung anzeigen, filtern und erhalten, um Probleme und Möglichkeiten zur Optimierung zu identifizieren.

Wichtig

X-Ray und Powertools für AWS Lambda SDKs sind Teil einer eng integrierten Instrumentierungslösung, die von AWS angeboten wird. Die ADOT Lambda Layers sind Teil eines branchenweiten Standards für die Verfolgung von Instrumenten, die im Allgemeinen mehr Daten erfassen, aber möglicherweise nicht für alle Anwendungsfälle geeignet sind. Sie können die end-to-end Ablaufverfolgung in X-Ray mit beiden Lösungen implementieren. Weitere Informationen zur Auswahl zwischen beiden finden Sie unter Wählen zwischen der AWS Distribution für Open Telemetry und X-Ray. SDKs

Sections

Powertools für AWS Lambda (Python) und AWS SAM für das Tracing verwenden
Verwenden von Powertools für AWS Lambda (Python) und AWS CDK für das Tracing
Verwenden von ADOT zum Instrumentieren Ihrer Python-Funktionen
Verwenden des X-Ray-SDK zum Instrumentieren Ihrer Python-Funktionen
Aktivieren der Nachverfolgung mit der Lambda-Konsole
Aktivieren der Nachverfolgung mit der Lambda-API
Die Ablaufverfolgung wird aktiviert mit AWS CloudFormation
Interpretieren einer X-Ray-Nachverfolgung
Laufzeitabhängigkeiten in einer Ebene speichern (X-Ray-SDK)

Powertools für AWS Lambda (Python) und AWS SAM für das Tracing verwenden

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 SAM. 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.11
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.11 --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 -X GET <URL_FROM_PREVIOUS_STEP>
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```

Führen Sie sam traces aus, um die Traces für die Funktion zu erhalten.


sam traces

Das Nachverfolgungsergebnis sieht folgendermaßen aus:


New XRay Service Graph
  Start time: 2023-02-03 14:59:50+00:00
  End time: 2023-02-03 14:59:50+00:00
  Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [1]
   Summary_statistics:
     - total requests: 1
     - ok count(2XX): 1
     - error count(4XX): 0
     - fault count(5XX): 0
     - total response time: 0.924
  Reference Id: 1 - AWS::Lambda::Function - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: []
   Summary_statistics:
     - total requests: 1
     - ok count(2XX): 1
     - error count(4XX): 0
     - fault count(5XX): 0
     - total response time: 0.016
  Reference Id: 2 - client - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [0]
   Summary_statistics:
     - total requests: 0
     - ok count(2XX): 0
     - error count(4XX): 0
     - fault count(5XX): 0
     - total response time: 0

XRay Event [revision 1] at (2023-02-03T14:59:50.204000) with id (1-63dd2166-434a12c22e1307ff2114f299) and duration (0.924s)
 - 0.924s - sam-app-HelloWorldFunction-YBg8yfYtOc9j [HTTP: 200]
 - 0.016s - sam-app-HelloWorldFunction-YBg8yfYtOc9j
   - 0.739s - Initialization
   - 0.016s - Invocation
     - 0.013s - ## lambda_handler
       - 0.000s - ## app.hello
   - 0.000s - Overhead

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
```

X-Ray verfolgt nicht alle Anfragen an Ihre Anwendung nach. X-Ray wendet einen Sampling-Algorithmus an, um sicherzustellen, dass die Nachverfolgung effizient ist, und stellt dennoch ein repräsentatives Beispiel aller Anfragen bereit. Die Samplingrate beträgt 1 Anforderung pro Sekunde und 5 Prozent aller weiteren Anforderungen. Sie können die X-Ray-Samplingrate nicht für Ihre Funktionen konfigurieren.

Verwenden von Powertools für AWS Lambda (Python) und AWS CDK für das Tracing

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.11
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_11,
            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 -X GET <URL_FROM_PREVIOUS_STEP>
```
Wenn der Link erfolgreich ausgeführt wurde, sehen Sie die folgende Antwort:
```
{"message":"hello world"}
```

Führen Sie sam traces aus, um die Traces für die Funktion zu erhalten.


sam traces

Das Nachverfolgungsergebnis sieht folgendermaßen aus:


New XRay Service Graph
  Start time: 2023-02-03 14:59:50+00:00
  End time: 2023-02-03 14:59:50+00:00
  Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [1]
   Summary_statistics:
     - total requests: 1
     - ok count(2XX): 1
     - error count(4XX): 0
     - fault count(5XX): 0
     - total response time: 0.924
  Reference Id: 1 - AWS::Lambda::Function - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: []
   Summary_statistics:
     - total requests: 1
     - ok count(2XX): 1
     - error count(4XX): 0
     - fault count(5XX): 0
     - total response time: 0.016
  Reference Id: 2 - client - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [0]
   Summary_statistics:
     - total requests: 0
     - ok count(2XX): 0
     - error count(4XX): 0
     - fault count(5XX): 0
     - total response time: 0

XRay Event [revision 1] at (2023-02-03T14:59:50.204000) with id (1-63dd2166-434a12c22e1307ff2114f299) and duration (0.924s)
 - 0.924s - sam-app-HelloWorldFunction-YBg8yfYtOc9j [HTTP: 200]
 - 0.016s - sam-app-HelloWorldFunction-YBg8yfYtOc9j
   - 0.739s - Initialization
   - 0.016s - Invocation
     - 0.013s - ## lambda_handler
       - 0.000s - ## app.hello
   - 0.000s - Overhead

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
```

Verwenden von ADOT zum Instrumentieren Ihrer Python-Funktionen

ADOT bietet vollständig verwaltete Lambda-Schichten, die alles zusammenfassen, was Sie für die Erfassung von Telemetriedaten mithilfe des SDK benötigen. OTel Indem Sie diese Ebene verwenden, können Sie Ihre Lambda-Funktionen instrumentieren, ohne einen Funktionscode ändern zu müssen. Sie können Ihren Layer auch so konfigurieren, dass er eine benutzerdefinierte Initialisierung von durchführt. OTel Weitere Informationen finden Sie unter Benutzerdefinierte Konfiguration für den ADOT Collector auf Lambda in der ADOT-Dokumentation.

Für Python-Laufzeiten können Sie den AWS -verwaltete Lambda-Layer für ADOT Python hinzufügen, um Ihre Funktionen automatisch zu instrumentieren. Dieser Layer funktioniert sowohl für arm64- als auch für x86_64-Architekturen. Eine ausführliche Anleitung zum Hinzufügen dieser Ebene finden Sie unter AWS Distro for OpenTelemetry Lambda Support for Python in der ADOT-Dokumentation.

Verwenden des X-Ray-SDK zum Instrumentieren Ihrer Python-Funktionen

Um Details zu Aufrufen aufzuzeichnen, die Ihre Lambda-Funktion an andere Ressourcen in Ihrer Anwendung vornimmt, können Sie auch AWS X-Ray-SDK for Python verwenden. Um das SDK zu erhalten, fügen Sie das aws-xray-sdk-Paket den Abhängigkeiten Ihrer Anwendung hinzu.

Beispiel requirements.txt


jsonpickle==1.3
aws-xray-sdk==2.4.3

In Ihrem Funktionscode können Sie AWS SDK-Clients instrumentieren, indem Sie die boto3 Bibliothek mit dem Modul patchen. aws_xray_sdk.core

Beispiel Funktion — Einen SDK-Client AWS verfolgen


import boto3
from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.core import patch_all

logger = logging.getLogger()
logger.setLevel(logging.INFO)
patch_all()

client = boto3.client('lambda')
client.get_account_settings()

def lambda_handler(event, context):
    logger.info('## ENVIRONMENT VARIABLES\r' + jsonpickle.encode(dict(**os.environ)))
  ...

Aktivieren Sie nach Hinzufügen der richtigen Abhängigkeiten die Nachverfolgung in der Konfiguration Ihrer Funktion über die Lambda-Konsole oder die API.

Aktivieren der Nachverfolgung mit der Lambda-Konsole

Gehen Sie folgendermaßen vor, um die aktive Nachverfolgung Ihrer Lambda-Funktion mit der Konsole umzuschalten:

So aktivieren Sie die aktive Nachverfolgung

Öffnen Sie die Seite Funktionen der Lambda-Konsole.
Wählen Sie eine Funktion aus.
Wählen Sie Configuration (Konfiguration) und dann Monitoring and operations tools (Überwachungs- und Produktionstools).
Wählen Sie Edit (Bearbeiten) aus.
Schalten Sie unter X-Ray Active tracing (Aktive Nachverfolgung) ein.
Wählen Sie Save (Speichern) aus.

Aktivieren der Nachverfolgung mit der Lambda-API

Konfigurieren Sie die Ablaufverfolgung für Ihre Lambda-Funktion mit dem AWS CLI oder AWS SDK und verwenden Sie die folgenden API-Operationen:

Der folgende AWS CLI Beispielbefehl aktiviert die aktive Ablaufverfolgung für eine Funktion namens my-function.


aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active

Der Ablaufverfolgungsmodus ist Teil der versionsspezifischen Konfiguration, wenn Sie eine Version Ihrer Funktion veröffentlichen. Sie können den Ablaufverfolgungsmodus für eine veröffentlichte Version nicht ändern.

Die Ablaufverfolgung wird aktiviert mit AWS CloudFormation

Um die Ablaufverfolgung für eine AWS::Lambda::Function Ressource in einer AWS CloudFormation Vorlage zu aktivieren, verwenden Sie die TracingConfig Eigenschaft.

Beispiel function-inline.yml – Ablaufverfolgungskonfiguration


Resources:
  function:
    Type: AWS::Lambda::Function
    Properties:
      TracingConfig:
        Mode: Active
      ...

Verwenden Sie für eine AWS::Serverless::Function Ressource AWS Serverless Application Model (AWS SAM) die Tracing Eigenschaft.

Beispiel template.yml – Ablaufverfolgungskonfiguration


Resources:
  function:
    Type: AWS::Serverless::Function
    Properties:
      Tracing: Active
      ...

Interpretieren einer X-Ray-Nachverfolgung

Ihre Funktion benötigt die Berechtigung zum Hochladen von Trace-Daten zu X-Ray. Wenn Sie die aktive Nachverfolgung in der Lambda-Konsole aktivieren, fügt Lambda der Ausführungsrolle Ihrer Funktion die erforderlichen Berechtigungen hinzu. Andernfalls fügen Sie die AWSXRayDaemonWriteAccessRichtlinie der Ausführungsrolle hinzu.

Nachdem Sie die aktive Nachverfolgung konfiguriert haben, können Sie bestimmte Anfragen über Ihre Anwendung beobachten. Das X-Ray-Service-Diagramm zeigt Informationen über Ihre Anwendung und alle ihre Komponenten an. Das folgende Beispiel zeigt eine Anwendung mit zwei Funktionen. Die primäre Funktion verarbeitet Ereignisse und gibt manchmal Fehler zurück. Die zweite Funktion an oberster Stelle verarbeitet Fehler, die in der Protokollgruppe der ersten auftreten, und verwendet das AWS SDK, um X-Ray, Amazon Simple Storage Service (Amazon S3) und Amazon CloudWatch Logs aufzurufen.

Ein Diagramm, das zwei separate Anwendungen und ihre jeweiligen Service-Maps in X-Ray zeigt

In X-Ray, zeichnet eine Ablaufverfolgung Informationen zu einer Anforderung auf, die von einem oder mehreren Services verarbeitet wird. Lambda zeichnet 2 Segmente pro Trace auf, wodurch zwei Knoten im Dienstgraphen entstehen. In der folgenden Abbildung werden diese beiden Knoten hervorgehoben:

Eine X-Ray-Servicekarte mit einer einzigen Funktion.

Der erste Knoten auf der linken Seite stellt den Lambda-Service dar, der die Aufrufanforderung empfängt. Der zweite Knoten stellt Ihre spezifische Lambda-Funktion dar. Das folgende Beispiel zeigt eine Nachverfolgung mit diesen zwei Segmenten. Beide heißen my-function, aber einer hat einen Ursprung von AWS::Lambda und der andere hat einen Ursprung von AWS::Lambda::Function. Wenn das AWS::Lambda-Segment einen Fehler anzeigt, hatte der Lambda-Service ein Problem. Wenn das AWS::Lambda::Function-Segment einen Fehler anzeigt, ist bei Ihrer Funktion ein Problem aufgetreten.

Eine X-Ray-Nachverfolgung, die die Latenz in jedem Teilsegment eines bestimmten Lambda-Aufrufs anzeigt.

Dieses Beispiel erweitert das AWS::Lambda::Function-Segment, um seine drei Untersegmente anzuzeigen.

Anmerkung

AWS implementiert derzeit Änderungen am Lambda-Service. Aufgrund dieser Änderungen können geringfügige Unterschiede in Struktur und Inhalt der Systemprotokollmeldungen und Trace-Segmente auftreten, die von verschiedenen Lambda-Funktionen in Ihrem AWS-Konto.

Der hier gezeigte Beispiel-Trace veranschaulicht das Funktionssegment im alten Stil. Die Unterschiede zwischen den Segmenten im alten und im neuen Stil werden in den folgenden Abschnitten beschrieben.

Diese Änderungen werden in den kommenden Wochen umgesetzt, und alle Funktionen AWS-Regionen außer China und den GovCloud Regionen werden auf die Verwendung der Protokollnachrichten und Trace-Segmente im neuen Format umgestellt.

Das Funktionssegment im alten Stil enthält die folgenden Untersegmente:

Initialisierung – Stellt die Zeit dar, die für das Laden Ihrer Funktion und das Ausführen des Initialisierungscodes aufgewendet wurde. Dieses Untersegment erscheint nur für das erste Ereignis, das jede Instance Ihrer Funktion verarbeitet.
Invocation (Aufruf) – Stellt die Zeit dar, die beim Ausführen Ihres Handler-Codes vergeht.
Overhead (Aufwand) – Stellt die Zeit dar, die von der Lambda-Laufzeitumgebung bei der Verarbeitung des nächsten Ereignisses verbraucht wird.

Das Funktionssegment im neuen Stil enthält kein Invocation-Untersegment. Stattdessen werden Kundenuntersegmente direkt an das Funktionssegment angehängt. Weitere Informationen über die Struktur der alten und neuen Funktionssegmente finden Sie unter Grundlegendes zu X-Ray-Ablaufverfolgungen.

Sie können auch HTTP-Clients instrumentieren, SQL-Abfragen aufzeichnen und benutzerdefinierte Untersegmente mit Anmerkungen und Metadaten erstellen. Weitere Informationen finden Sie unter AWS X-Ray-SDK for Python im AWS X-Ray -Entwicklerhandbuch.

Preisgestaltung

Im Rahmen des kostenlosen Kontingents können Sie X-Ray Tracing jeden Monat bis zu einem bestimmten Limit AWS kostenlos nutzen. Über den Schwellenwert hinaus berechnet X-Ray Gebühren für die Speicherung und den Abruf der Nachverfolgung. Weitere Informationen finden Sie unter AWS X-Ray Preise.

Laufzeitabhängigkeiten in einer Ebene speichern (X-Ray-SDK)

Wenn Sie das X-Ray-SDK verwenden, um AWS SDK-Clients Ihren Funktionscode zu instrumentieren, kann Ihr Bereitstellungspaket ziemlich umfangreich werden. Um Laufzeitabhängigkeiten bei jeder Aktualisierung des Funktionscodes zu vermeiden, verpacken Sie das X-Ray-SDK in einer Lambda-Ebene.

Das folgende Beispiel zeigt eine AWS::Serverless::LayerVersion-Ressource, die das AWS X-Ray-SDK for Python speichert.

Beispiel template.yml – Abhängigkeitenebene


Resources:
  function:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: function/.
      Tracing: Active
      Layers:
        - !Ref libs
      ...
  libs:
    Type: AWS::Serverless::LayerVersion
    Properties:
      LayerName: blank-python-lib
      Description: Dependencies for the blank-python sample app.
      ContentUri: package/.
      CompatibleRuntimes:
        - python3.11

Bei dieser Konfiguration aktualisieren Sie die Bibliotheksebene nur, wenn Sie Ihre Laufzeitabhängigkeiten ändern. Da das Funktionsbereitstellungspaket nur Ihren Code enthält, kann dies dazu beitragen, die Upload-Zeiten zu reduzieren.

Das Erstellen einer Ebene für Abhängigkeiten erfordert Build-Konfigurationsänderungen, um das Ebenen-Archiv vor der Bereitstellung zu generieren. Ein funktionierendes Beispiel finden Sie in der Beispielanwendung blank-python .

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

Testen

Erstellen mit Ruby