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. # Ihre Anwendungen auf Lambda aktivieren Sie können Application Signals für Ihre Lambda-Funktionen aktivieren. Application Signals instrumentiert Ihre Lambda-Funktionen automatisch mithilfe von erweiterten AWS Distro for OpenTelemetry (ADOT) -Bibliotheken, die über eine Lambda-Schicht bereitgestellt werden. Dieser AWS Lambda-Layer für OpenTelemetry Pakete und Bereitstellungen der Bibliotheken, die für die automatische Instrumentierung von Application Signals erforderlich sind. Diese Lambda-Schicht unterstützt nicht nur Anwendungssignale, sondern ist auch Bestandteil der OpenTelemetry Lambda-Unterstützung und bietet Tracing-Funktionen. Sie können die Lambda-Beobachtbarkeit auch verbessern, indem Sie die Transaktionssuche verwenden, die die Erfassung von Ablaufverfolgungs-Spans für den Lambda-Funktionsaufruf ohne Sampling ermöglicht. Mit diesem Feature können Sie Spans für Ihre Funktionen erfassen, unabhängig vom `sampled`-Flag bei der Übertragung des Ablaufverfolgungskontexts. Dadurch wird sichergestellt, dass keine zusätzlichen Auswirkungen auf nachgelagerte abhängige Services entstehen. Durch die Aktivierung der Transaktionssuche auf Lambda erhalten Sie einen vollständigen Überblick über die Leistung Ihrer Funktionen und können selten auftretende Probleme beheben. Um zu beginnen, siehe [Transaktionssuche](CloudWatch-Transaction-Search.md) **Topics** + [Erste Schritte](#Application-Signals-Enable-Lambda-Methods-Getting-Started) + [Verwenden Sie die CloudWatch Application Signals Console](#Enable-Lambda-CWConsole) + [Die Lambda-Konsole verwenden](#Enable-Lambda-LambdaConsole) + [Anwendungssignale auf Lambda aktivieren mit AWS CDK](#CloudWatch-Application-Signals-Lambda-CDK) + [Anwendungssignale auf Lambda mithilfe des Model Context Protocol (MCP) aktivieren](#CloudWatch-Application-Signals-Lambda-MCP) + [(Optional) Überwachen Sie den Zustand Ihrer Anwendung](#CloudWatch-Application-Signals-Monitor-Lambda) + [Application Signals manuell aktivieren.](#Enable-Lambda-Manually) + [Application Signals manuell deaktivieren](#Disable-Lambda-Manually) + [Konfigurieren von Application Signals](#Configuring-Lambda-AppSignals) + [AWS Lambda Layer für OpenTelemetry ARNs](#Enable-Lambda-Layers) + [Stellen Sie Lambda-Funktionen mithilfe des Amazon-ECR-Containers bereit](#containerized-lambda) ## Erste Schritte Es gibt drei Methoden, Application Signals für Ihre Lambda-Funktionen zu aktivieren. Nachdem Sie Application Signals für eine Lambda-Funktion aktiviert haben, dauert es einige Minuten, bis die Telemetrie dieser Funktion in der Application-Signals-Konsole angezeigt wird. + Verwenden Sie die Application Signals CloudWatch Console + Verwenden der Lambda-Konsole + Fügen Sie den AWS Lambda-Layer für manuell OpenTelemetry zu Ihrer Lambda-Funktionslaufzeit hinzu. Jede dieser Methoden fügt Ihrer Funktion den AWS Lambda-Layer für OpenTelemetry hinzu. ## Verwenden Sie die CloudWatch Application Signals Console Gehen Sie wie folgt vor, um mit der Application-Signals-Konsole Application Signals für eine Lambda-Funktion zu aktivieren. 1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Wählen Sie im Navigationsbereich **Application Signals**, **Services**. 1. Wählen Sie im Listenbereich **Services** die Option **Application Signals aktivieren** aus. 1. Wählen Sie die Kachel **Lambda** aus. 1. Wählen Sie jede Funktion aus, die Sie für Application Signals aktivieren möchten, und klicken Sie dann auf **Fertig**. ## Die Lambda-Konsole verwenden Gehen Sie wie folgt vor, um mit der Lambda-Konsole Application Signals für eine Lambda-Funktion zu aktivieren. 1. Öffnen Sie die AWS Lambda Konsole unter [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Wählen Sie im Navigationsbereich **Funktionen** aus und wählen Sie dann den Namen der Funktion aus, die Sie aktivieren möchten. 1. Wählen Sie **Konfiguration** und dann **Überwachungs- und Produktionstools**. 1. Wählen Sie **Bearbeiten** aus. 1. Wählen Sie im Abschnitt **CloudWatch Application Signals and X-Ray** die Optionen **Anwendungs-Traces und Standardanwendungsmetriken mit Application Signals** **automatisch erfassen und Lambda Service Traces für durchgängige Transparenz mit X-Ray** automatisch erfassen aus. . 1. Wählen Sie **Speichern**. ## Anwendungssignale auf Lambda aktivieren mit AWS CDK Wenn Sie Application Signals in diesem Konto noch nicht aktiviert haben, müssen Sie Application Signals die Berechtigungen gewähren, die es benötigt, um Ihre Services zu erkennen. Weitere Informationen finden Sie unter [Application Signals in Ihrem Konto aktivieren](CloudWatch-Application-Signals-Enable.md). 1. Aktivieren Sie Application Signals für Ihre Anwendungen ``` import { aws_applicationsignals as applicationsignals } from 'aws-cdk-lib'; const cfnDiscovery = new applicationsignals.CfnDiscovery(this, 'ApplicationSignalsServiceRole', { } ); ``` Die CloudFormation Discovery-Ressource gewährt Application Signals die folgenden Berechtigungen: + `xray:GetServiceGraph` + `logs:StartQuery` + `logs:GetQueryResults` + `cloudwatch:GetMetricData` + `cloudwatch:ListMetrics` + `tag:GetResources` Weitere Informationen über diese Rolle finden Sie unter [Service-linked Rollenberechtigungen für CloudWatch Anwendungssignale](using-service-linked-roles.md#service-linked-role-signals). 1. Die IAM-Richtlinie `CloudWatchLambdaApplicationSignalsExecutionRolePolicy` zur Lambda-Funktion hinzufügen. ``` const fn = new Function(this, 'DemoFunction', { code: Code.fromAsset('$YOUR_LAMBDA.zip'), runtime: Runtime.PYTHON_3_12, handler: '$YOUR_HANDLER' }) fn.role?.addManagedPolicy(ManagedPolicy.fromAwsManagedPolicyName('CloudWatchLambdaApplicationSignalsExecutionRolePolicy')); ``` 1. `$AWS_LAMBDA_LAYER_FOR_OTEL_ARN`Ersetzen Sie es durch den tatsächlichen [AWS Lambda-Layer für OpenTelemetry ARN](https://aws-otel.github.io/docs/getting-started/lambda#adot-lambda-layer-arns) für Ihre Region. ``` fn.addLayers(LayerVersion.fromLayerVersionArn( this, 'AwsLambdaLayerForOtel', '$AWS_LAMBDA_LAYER_FOR_OTEL_ARN' )) fn.addEnvironment("AWS_LAMBDA_EXEC_WRAPPER", "/opt/otel-instrument"); ``` ## Anwendungssignale auf Lambda mithilfe des Model Context Protocol (MCP) aktivieren Sie können den MCP-Server ( CloudWatch Application Signals Model Context Protocol) verwenden, um Application Signals auf Ihren Lambda-Funktionen durch dialogorientierte KI-Interaktionen zu aktivieren. Dies bietet eine Benutzeroberfläche in natürlicher Sprache für die Einrichtung der Überwachung von Application Signals. Der MCP-Server automatisiert den Aktivierungsprozess, indem er Ihre Anforderungen versteht und die entsprechende Konfiguration generiert. Anstatt die Konsolenschritte manuell zu befolgen oder CDK-Code zu schreiben, können Sie einfach beschreiben, was Sie aktivieren möchten. ### Voraussetzungen Bevor Sie den MCP-Server zur Aktivierung von Application Signals verwenden, stellen Sie sicher, dass Sie über Folgendes verfügen: + Eine Entwicklungsumgebung, die MCP unterstützt (wie Kiro, Claude Desktop VSCode mit MCP-Erweiterungen oder anderen MCP-kompatiblen Tools) + Der in Ihrer IDE CloudWatch konfigurierte MCP-Server von Application Signals. Detaillierte Anweisungen zur Einrichtung finden Sie in der Dokumentation zum [CloudWatch Application Signals MCP Server](https://awslabs.github.io/mcp/servers/cloudwatch-applicationsignals-mcp-server). ### Verwenden des MCP-Servers Sobald Sie den CloudWatch Application Signals MCP-Server in Ihrer IDE konfiguriert haben, können Sie mithilfe von Eingabeaufforderungen in natürlicher Sprache Anleitungen zur Aktivierung anfordern. Der Programmierassistent kann zwar den Kontext aus Ihrer Projektstruktur ableiten, die Angabe spezifischer Details in Ihren Eingabeaufforderungen trägt jedoch zu einer genaueren und relevanteren Anleitung bei. Fügen Sie Informationen wie die Programmiersprache Ihrer Lambda-Funktion, den Funktionsnamen und absolute Pfade zu Ihrem Lambda-Funktionscode und Infrastrukturcode hinzu. **Aufforderungen zu bewährten Methoden (spezifisch und vollständig):** ``` "Enable Application Signals for my Python Lambda function. My function code is in /home/user/order-processor/lambda and IaC is in /home/user/order-processor/terraform" "I want to add observability to my Node.js Lambda function 'checkout-handler'. The function code is at /Users/dev/checkout-function and the CDK infrastructure is at /Users/dev/checkout-function/cdk" "Help me instrument my Java Lambda function with Application Signals. Function directory: /opt/apps/payment-lambda CDK infrastructure: /opt/apps/payment-lambda/cdk" ``` **Weniger effektive Aufforderungen:** ``` "Enable monitoring for my Lambda" → Missing: language, paths "Enable Application Signals. My code is in ./src and IaC is in ./infrastructure" → Problem: Relative paths instead of absolute paths "Enable Application Signals for my Lambda at /home/user/myfunction" → Missing: programming language ``` **Schnelle Vorlage:** ``` "Enable Application Signals for my [LANGUAGE] Lambda function. Function code: [ABSOLUTE_PATH_TO_FUNCTION] IaC code: [ABSOLUTE_PATH_TO_IAC]" ``` ### Vorteile der Verwendung des MCP-Servers Die Verwendung des MCP-Servers von CloudWatch Application Signals bietet mehrere Vorteile: + **Benutzeroberfläche in natürlicher Sprache:** Beschreiben Sie, was Sie aktivieren möchten, ohne sich Befehle oder die Konfigurationssyntax merken zu müssen + **Kontextsensitive Beratung:** Der MCP-Server versteht Ihre spezifische Umgebung und gibt maßgeschneiderte Empfehlungen + **Weniger Fehler:** Durch die automatische Generierung von Konfigurationen werden manuelle Tippfehler minimiert + **Schnellere Einrichtung:** Gehen Sie schneller von der Absicht zur Implementierung + **Lerntool:** Sehen Sie sich die generierten Konfigurationen an und erfahren Sie, wie Application Signals funktioniert Weitere Informationen zur Konfiguration und Verwendung des CloudWatch Application Signals MCP-Servers finden Sie in der [MCP-Serverdokumentation](https://awslabs.github.io/mcp/servers/cloudwatch-applicationsignals-mcp-server). ## (Optional) Überwachen Sie den Zustand Ihrer Anwendung Sobald Sie Ihre Anwendungen auf Lambda aktiviert haben, können Sie den Zustand Ihrer Anwendung überwachen. Weitere Informationen finden Sie unter [Den Betriebsstatus Ihrer Anwendungen mit Application Signals überwachen](Services.md). ## Application Signals manuell aktivieren. Verwenden Sie diese Schritte, um Application Signals für eine Lambda-Funktion manuell zu aktivieren. 1. Fügen Sie den AWS Lambda-Layer für OpenTelemetry zu Ihrer Lambda-Laufzeit hinzu. Informationen zum Layer-ARN für Ihre Region finden Sie unter [ADOT Lambda](https://aws-otel.github.io/docs/getting-started/lambda#adot-lambda-layer-arns) Layer. ARNs 1. Fügen Sie die Umgebungsvariable `AWS_LAMBDA_EXEC_WRAPPER=/opt/otel-instrument` hinzu Fügen Sie die Umgebungsvariable `LAMBDA_APPLICATION_SIGNALS_REMOTE_ENVIRONMENT` hinzu, um benutzerdefinierte Lambda-Umgebungen zu konfigurieren. Standardmäßig sind Lambda-Umgebungen für `lambda:default` konfiguriert. 1. Hängen Sie die AWS verwaltete IAM-Richtlinie **CloudWatchLambdaApplicationSignalsExecutionRolePolicy**an die Lambda-Ausführungsrolle an. 1. (Optional) Wir empfehlen, für ein besseres Ablaufverfolgungserlebnis die aktive Lambda-Ablaufverfolgung zu aktivieren. Weitere Informationen finden Sie unter [Visualisieren von Lambda-Funktionsaufrufen mit. AWS X-Ray](https://docs.aws.amazon.com/lambda/latest/dg/services-xray.html) ## Application Signals manuell deaktivieren Um Application Signals für eine Lambda-Funktion manuell zu deaktivieren, entfernen Sie den AWS Lambda-Layer für OpenTelemetry aus Ihrer Lambda-Laufzeit und entfernen Sie die `AWS_LAMBDA_EXEC_WRAPPER=/opt/otel-instrument` Umgebungsvariable. ## Konfigurieren von Application Signals In diesem Abschnitt können Sie Application Signals in Lambda konfigurieren. **Gruppierung mehrerer Lambda-Funktionen in einem Service** Die Umgebungsvariable `OTEL_SERVICE_NAME` legt den Namen des Services fest. Dies wird in den Dashboards von Application Signals als Servicename der Anwendung angezeigt. Sie können mehreren Lambda-Funktionen denselben Servicenamen zuweisen, und sie werden in Application Signals zu einem einzigen Service zusammengeführt. Wenn Sie keinen Wert für diesen Schlüssel angeben, wird der Standardname der Lambda-Funktion verwendet. **Probenahme** Standardmäßig basiert die Ablaufverfolgungs-Sampling-Strategie auf der übergeordneten Komponente. Sie können die Sampling-Strategie anpassen, indem Sie Umgebungsvariablen `OTEL_TRACES_SAMPLER` festlegen. Legen Sie beispielsweise die Rate für das Ablaufverfolgungssampling auf 30 % fest. ``` OTEL_TRACES_SAMPLER=traceidratio OTEL_TRACES_SAMPLER_ARG=0.3 ``` Weitere Informationen finden Sie unter [Spezifikation der OpenTelemetry Umgebungsvariablen](https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/). **Aktivierung aller Bibliotheksinstrumentierungen** Um Lambda-Kaltstarts zu reduzieren, sind standardmäßig nur AWS SDK- und HTTP-Instrumentierungen für Python, Node und Java aktiviert. Sie können Umgebungsvariablen festlegen, um die Instrumentierung für andere Bibliotheken zu aktivieren, die in Ihrer Lambda-Funktion verwendet werden. + Python – `OTEL_PYTHON_DISABLED_INSTRUMENTATIONS=none` + Knoten – `OTEL_NODE_DISABLED_INSTRUMENTATIONS=none` + Java — `OTEL_INSTRUMENTATION_COMMON_DEFAULT_ENABLED=true` ## AWS Lambda Layer für OpenTelemetry ARNs Eine vollständige Liste der AWS Lambda-Layer OpenTelemetry ARNs nach Region und Laufzeit finden Sie in der Dokumentation unter [ADOT Lambda Layer ARNs](https://aws-otel.github.io/docs/getting-started/lambda#adot-lambda-layer-arns) in der AWS Distribution. OpenTelemetry Der Layer ist für Python-, Node.js-, .NET- und Java-Laufzeiten verfügbar. ## Stellen Sie Lambda-Funktionen mithilfe des Amazon-ECR-Containers bereit Lambda-Funktionen, die als Container-Images bereitgestellt werden, unterstützen Lambda-Schichten nicht auf herkömmliche Weise. Wenn Sie Container-Images verwenden, können Sie keine Schicht anhängen, wie dies bei anderen Lambda-Bereitstellungsmethoden der Fall wäre. Stattdessen müssen Sie den Inhalt der Schicht während des Erstellungsprozesses manuell in Ihr Container-Image integrieren. ------ #### [ Java ] Sie können lernen, wie Sie den AWS Lambda Layer for OpenTelemetry in Ihre containerisierte Java-Lambda-Funktion integrieren, das `layer.zip` Artefakt herunterladen und in Ihren Java-Lambda-Funktionscontainer integrieren, um die Überwachung von Application Signals zu ermöglichen. **Voraussetzungen** + AWS CLI mit Ihren Anmeldeinformationen konfiguriert + Docker installiert + Bei dieser Anleitung wird davon ausgegangen, dass Sie sich auf der x86\_64-Plattform befinden 1. **Die Projektstruktur einrichten** Erstellen Sie ein Verzeichnis für Ihre Lambda-Funktion ``` mkdir java-appsignals-container-lambda && \ cd java-appsignals-container-lambda ``` Erstellen Sie eine Maven-Projektstruktur ``` mkdir -p src/main/java/com/example/java/lambda mkdir -p src/main/resources ``` 1. **Docker-Datei erstellen** Laden Sie die Unterstützung für OpenTelemetry Layer mit Application Signals herunter und integrieren Sie sie direkt in Ihr Lambda-Container-Image. Zu diesem Zweck wird die `Dockerfile`-Datei erstellt. ``` FROM public.ecr.aws/lambda/java:21 # Install utilities RUN dnf install -y unzip wget maven # Download the OpenTelemetry Layer with AppSignals Support RUN wget https://github.com/aws-observability/aws-otel-java-instrumentation/releases/latest/download/layer.zip -O /tmp/layer.zip # Extract and include Lambda layer contents RUN mkdir -p /opt && \ unzip /tmp/layer.zip -d /opt/ && \ chmod -R 755 /opt/ && \ rm /tmp/layer.zip # Copy and build function code COPY pom.xml ${LAMBDA_TASK_ROOT} COPY src ${LAMBDA_TASK_ROOT}/src RUN mvn clean package -DskipTests # Copy the JAR file to the Lambda runtime directory (from inside the container) RUN mkdir -p ${LAMBDA_TASK_ROOT}/lib/ RUN cp ${LAMBDA_TASK_ROOT}/target/function.jar ${LAMBDA_TASK_ROOT}/lib/ # Set the handler CMD ["com.example.java.lambda.App::handleRequest"] ``` **Anmerkung** Die `layer.zip` Datei enthält die OpenTelemetry Instrumentierung, die für die Unterstützung von AWS Application Signals zur Überwachung Ihrer Lambda-Funktion erforderlich ist. Die Schritte zur Schichtextraktion stellen Folgendes sicher: Der Inhalt von layer.zip wird ordnungsgemäß in das `/opt/ directory` extrahiert Das `otel-instrument`-Skript erhält die richtigen Ausführungsberechtigungen Die temporäre Datei layer.zip wurde entfernt, um die Bildgröße zu verringern 1. **Lambda-Funktionscode** – Erstellen Sie eine Java-Datei für Ihren Lambda-Handler unter `src/main/java/com/example/lambda/App.java:` Ihr Projekt sollte in etwa wie folgt aussehen: ``` . ├── Dockerfile ├── pom.xml └── src └── main ├── java │ └── com │ └── example │ └── java │ └── lambda │ └── App.java └── resources ``` 1. **Container-Image erstellen und bereitstellen** **Umgebungsvariablen festlegen** ``` AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text) AWS_REGION=$(aws configure get region) # For fish shell users: # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text) # set AWS_REGION (aws configure get region) ``` **Mit ECR authentifizieren** Zuerst mit öffentlichem ECR (für das Basis-Image): ``` aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws ``` Dann mit Ihrem privaten ECR: ``` aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com ``` **Image erstellen, mit Tags versehen und übertragen** ``` # Build the Docker image docker build -t lambda-appsignals-demo . # Tag the image docker tag lambda-appsignals-demo:latest $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest # Push the image docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest ``` 1. **Die Lambda-Funktion erstellen und konfigurieren** Erstellen Sie eine neue Funktion mit der Lambda-Konsole. Wählen Sie **Container-Image** als Bereitstellungsoption aus. Wählen Sie **Images durchsuchen**, um Ihr Amazon-EC-Image auszuwählen. 1. **Testen und Verifizierungen – Testen Sie Ihr Lambda mit einem einfachen Ereignis. Wenn die Schichtintegration erfolgreich ist, wird Ihr Lambda unter der Application-Signals-Service-Übersicht angezeigt.** In der CloudWatch Konsole werden Ihnen Traces und Metriken für Ihre Lambda-Funktion angezeigt. **Fehlersuche** Wenn Application Signals nicht funktioniert, überprüfen Sie Folgendes: + Überprüfen Sie die Funktionsprotokolle auf Fehler im Zusammenhang mit der Instrumentierung OpenTelemetry + Überprüfen Sie, ob die Umgebungsvariable `AWS_LAMBDA_EXEC_WRAPPER` richtig festgelegt ist + Stellen Sie sicher, dass die Schichtextraktion in der Docker-Datei erfolgreich abgeschlossen wurde + Vergewissern Sie sich, dass die IAM-Berechtigungen ordnungsgemäß angehängt sind + Erhöhen Sie bei Bedarf die *Timeout- und Speichereinstellungen* in der allgemeinen Konfiguration der Lambda-Funktion ------ #### [ .Net ] Sie können lernen, wie Sie die Unterstützung von OpenTelemetry Layer with Application Signals in Ihre containerisierte .Net Lambda-Funktion integrieren, das `layer.zip` Artefakt herunterladen und in Ihre .Net Lambda-Funktion integrieren, um die Überwachung von Application Signals zu ermöglichen. **Voraussetzungen** + AWS CLI mit Ihren Anmeldeinformationen konfiguriert + Docker installiert + .Net-8-SDK + Bei dieser Anleitung wird davon ausgegangen, dass Sie sich auf der x86\_64-Plattform befinden 1. **Die Projektstruktur einrichten** Erstellen Sie ein Verzeichnis für Ihr Lambda-Funktionscontainer-Image ``` mkdir dotnet-appsignals-container-lambda && \ cd dotnet-appsignals-container-lambda ``` 1. **Docker-Datei erstellen** Laden Sie die Unterstützung für OpenTelemetry Layer mit Application Signals herunter und integrieren Sie sie direkt in Ihr Lambda-Container-Image. Zu diesem Zweck wird die `Dockerfile`-Datei erstellt. ``` FROM public.ecr.aws/lambda/dotnet:8 # Install utilities RUN dnf install -y unzip wget dotnet-sdk-8.0 which # Add dotnet command to docker container's PATH ENV PATH="/usr/lib64/dotnet:${PATH}" # Download the OpenTelemetry Layer with AppSignals Support RUN wget https://github.com/aws-observability/aws-otel-dotnet-instrumentation/releases/latest/download/layer.zip -O /tmp/layer.zip # Extract and include Lambda layer contents RUN mkdir -p /opt && \ unzip /tmp/layer.zip -d /opt/ && \ chmod -R 755 /opt/ && \ rm /tmp/layer.zip WORKDIR ${LAMBDA_TASK_ROOT} # Copy the project files COPY dotnet-lambda-function/src/dotnet-lambda-function/*.csproj ${LAMBDA_TASK_ROOT}/ COPY dotnet-lambda-function/src/dotnet-lambda-function/Function.cs ${LAMBDA_TASK_ROOT}/ COPY dotnet-lambda-function/src/dotnet-lambda-function/aws-lambda-tools-defaults.json ${LAMBDA_TASK_ROOT}/ # Install dependencies and build the application RUN dotnet restore # Use specific runtime identifier and disable ReadyToRun optimization RUN dotnet publish -c Release -o out --self-contained false /p:PublishReadyToRun=false # Copy the published files to the Lambda runtime directory RUN cp -r out/* ${LAMBDA_TASK_ROOT}/ CMD ["dotnet-lambda-function::dotnet_lambda_function.Function::FunctionHandler"] ``` **Anmerkung** Die `layer.zip` Datei enthält die OpenTelemetry Instrumentierung, die für die Unterstützung von AWS Application Signals zur Überwachung Ihrer Lambda-Funktion erforderlich ist. Die Schritte zur Schichtextraktion stellen Folgendes sicher: Der Inhalt von layer.zip wird ordnungsgemäß in das `/opt/ directory` extrahiert Das `otel-instrument`-Skript erhält die richtigen Ausführungsberechtigungen Die temporäre Datei layer.zip wurde entfernt, um die Bildgröße zu verringern 1. **Lambda-Funktionscode** — Initialisieren Sie Ihr Lambda-Projekt mit der AWS Lambda-.NET-Vorlage: ``` # Install the Lambda templates if you haven't already dotnet new -i Amazon.Lambda.Templates # Create a new Lambda project dotnet new lambda.EmptyFunction -n dotnet-lambda-function ``` Ihr Projekt sollte in etwa wie folgt aussehen: ``` . ├── Dockerfile └── dotnet-lambda-function ├── src │ └── dotnet-lambda-function │ ├── Function.cs │ ├── Readme.md │ ├── aws-lambda-tools-defaults.json │ └── dotnet-lambda-function.csproj └── test └── dotnet-lambda-function.Tests ├── FunctionTest.cs └── dotnet-lambda-function.Tests.csproj ``` 1. **Container-Image erstellen und bereitstellen** **Umgebungsvariablen festlegen** ``` AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text) AWS_REGION=$(aws configure get region) # For fish shell users: # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text) # set AWS_REGION (aws configure get region) ``` Aktualisieren Sie den `Function.cs`-Code auf: Aktualisieren Sie den `dotnet-lambda-function.csproj`-Code auf: ``` net8.0>/TargetFramework> enable enable true Lambda true true ``` 1. **Container-Image erstellen und bereitstellen** Umgebungsvariablen festlegen ``` AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text) AWS_REGION=$(aws configure get region) # For fish shell users: # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text) # set AWS_REGION (aws configure get region) ``` Authentifizieren Sie sich mit öffentlichem Amazon ECR ``` aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws ``` Authentifizieren Sie sich mit privatem Amazon ECR ``` aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com ``` Amazon-ECR-Repository erstellen (falls erforderlich) ``` aws ecr create-repository \ --repository-name lambda-appsignals-demo \ --region $AWS_REGION ``` Image erstellen, mit Tags versehen und übertragen ``` # Build the Docker image docker build -t lambda-appsignals-demo . # Tag the image docker tag lambda-appsignals-demo:latest $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest # Push the image docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest 5. Create and Configure the Lambda Function ``` 1. **Die Lambda-Funktion erstellen und konfigurieren** Erstellen Sie eine neue Funktion mit der Lambda-Konsole. Wählen Sie **Container-Image** als Bereitstellungsoption aus. Wählen Sie **Images durchsuchen**, um Ihr Amazon-EC-Image auszuwählen. 1. **Testen und Verifizierungen – Testen Sie Ihr Lambda mit einem einfachen Ereignis. Wenn die Schichtintegration erfolgreich ist, wird Ihr Lambda unter der Application-Signals-Service-Übersicht angezeigt.** In der CloudWatch Konsole werden Ihnen Traces und Metriken für Ihre Lambda-Funktion angezeigt. **Fehlersuche** Wenn Application Signals nicht funktioniert, überprüfen Sie Folgendes: + Überprüfen Sie die Funktionsprotokolle auf Fehler im Zusammenhang mit der Instrumentierung OpenTelemetry + Überprüfen Sie, ob die Umgebungsvariable `AWS_LAMBDA_EXEC_WRAPPER` richtig festgelegt ist + Stellen Sie sicher, dass die Schichtextraktion in der Docker-Datei erfolgreich abgeschlossen wurde + Vergewissern Sie sich, dass die IAM-Berechtigungen ordnungsgemäß angehängt sind + Erhöhen Sie bei Bedarf die *Timeout- und Speichereinstellungen* in der allgemeinen Konfiguration der Lambda-Funktion ------ #### [ Node.js ] Sie können lernen, wie Sie die Unterstützung von OpenTelemetry Layer with Application Signals in Ihre containerisierte Lambda-Funktion von Node.js integrieren, das `layer.zip` Artefakt herunterladen und es in Ihre Node.js Lambda-Funktion integrieren, um die Überwachung von Application Signals zu ermöglichen. **Voraussetzungen** + AWS CLI mit Ihren Anmeldeinformationen konfiguriert + Docker installiert + Bei dieser Anleitung wird davon ausgegangen, dass Sie sich auf der x86\_64-Plattform befinden 1. **Die Projektstruktur einrichten** Erstellen Sie ein Verzeichnis für Ihr Lambda-Funktionscontainer-Image ``` mkdir nodejs-appsignals-container-lambda &&\ cd nodejs-appsignals-container-lambda ``` 1. **Docker-Datei erstellen** Laden Sie die Unterstützung für OpenTelemetry Layer mit Application Signals herunter und integrieren Sie sie direkt in Ihr Lambda-Container-Image. Zu diesem Zweck wird die `Dockerfile`-Datei erstellt. ``` # Dockerfile FROM public.ecr.aws/lambda/nodejs:22 # Install utilities RUN dnf install -y unzip wget # Download the OpenTelemetry Layer with AppSignals Support RUN wget https://github.com/aws-observability/aws-otel-js-instrumentation/releases/latest/download/layer.zip -O /tmp/layer.zip # Extract and include Lambda layer contents RUN mkdir -p /opt && \ unzip /tmp/layer.zip -d /opt/ && \ chmod -R 755 /opt/ && \ rm /tmp/layer.zip # Install npm dependencies RUN npm init -y RUN npm install # Copy function code COPY *.js ${LAMBDA_TASK_ROOT}/ # Set the CMD to your handler CMD [ "index.handler" ] ``` **Anmerkung** Die `layer.zip` Datei enthält die OpenTelemetry Instrumentierung, die für die Unterstützung von AWS Application Signals zur Überwachung Ihrer Lambda-Funktion erforderlich ist. Die Schritte zur Schichtextraktion stellen Folgendes sicher: Der Inhalt von layer.zip wird ordnungsgemäß in das `/opt/ directory` extrahiert Das `otel-instrument`-Skript erhält die richtigen Ausführungsberechtigungen Die temporäre Datei layer.zip wurde entfernt, um die Bildgröße zu verringern 1. **Lambda-Funktionscode** Erstellen Sie eine Datei `index.js`, mit folgendem Inhalt: ``` const { S3Client, ListBucketsCommand } = require('@aws-sdk/client-s3'); // Initialize S3 client const s3Client = new S3Client({ region: process.env.AWS_REGION }); exports.handler = async function(event, context) { console.log('Received event:', JSON.stringify(event, null, 2)); console.log('Handler initializing:', exports.handler.name); const response = { statusCode: 200, body: {} }; try { // List S3 buckets const command = new ListBucketsCommand({}); const data = await s3Client.send(command); // Extract bucket names const bucketNames = data.Buckets.map(bucket => bucket.Name); response.body = { message: 'Successfully retrieved buckets', buckets: bucketNames }; } catch (error) { console.error('Error listing buckets:', error); response.statusCode = 500; response.body = { message: `Error listing buckets: ${error.message}` }; } return response; }; ``` Ihre Projektstruktur sollte in etwa wie folgt aussehen: ``` . ├── Dockerfile └── index.js ``` 1. **Container-Image erstellen und bereitstellen** **Umgebungsvariablen festlegen** ``` AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text) AWS_REGION=$(aws configure get region) # For fish shell users: # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text) # set AWS_REGION (aws configure get region) ``` Authentifizieren Sie sich mit öffentlichem Amazon ECR ``` aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws ``` Authentifizieren Sie sich mit privatem Amazon ECR ``` aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com ``` Amazon-ECR-Repository erstellen (falls erforderlich) ``` aws ecr create-repository \ --repository-name lambda-appsignals-demo \ --region $AWS_REGION ``` Image erstellen, mit Tags versehen und übertragen ``` # Build the Docker image docker build -t lambda-appsignals-demo . # Tag the image docker tag lambda-appsignals-demo:latest $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest # Push the image docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest 5. Create and Configure the Lambda Function ``` 1. **Die Lambda-Funktion erstellen und konfigurieren** Erstellen Sie eine neue Funktion mit der Lambda-Konsole. Wählen Sie **Container-Image** als Bereitstellungsoption aus. Wählen Sie **Images durchsuchen**, um Ihr Amazon-EC-Image auszuwählen. 1. **Testen und Verifizierungen – Testen Sie Ihr Lambda mit einem einfachen Ereignis. Wenn die Schichtintegration erfolgreich ist, wird Ihr Lambda unter der Application-Signals-Service-Übersicht angezeigt.** In der CloudWatch Konsole werden Ihnen Traces und Metriken für Ihre Lambda-Funktion angezeigt. **Fehlersuche** Wenn Application Signals nicht funktioniert, überprüfen Sie Folgendes: + Überprüfen Sie die Funktionsprotokolle auf Fehler im Zusammenhang mit der Instrumentierung OpenTelemetry + Überprüfen Sie, ob die Umgebungsvariable `AWS_LAMBDA_EXEC_WRAPPER` richtig festgelegt ist + Stellen Sie sicher, dass die Schichtextraktion in der Docker-Datei erfolgreich abgeschlossen wurde + Vergewissern Sie sich, dass die IAM-Berechtigungen ordnungsgemäß angehängt sind + Erhöhen Sie bei Bedarf die *Timeout- und Speichereinstellungen* in der allgemeinen Konfiguration der Lambda-Funktion ------ #### [ Python ] Sie können lernen, wie Sie die OpenTelemetry Layer-Unterstützung mit Application Signals in Ihre containerisierte Python-Lambda-Funktion integrieren, das `layer.zip` Artefakt herunterladen und in Ihre Python-Lambda-Funktion integrieren, um die Überwachung von Application Signals zu ermöglichen. **Voraussetzungen** + AWS CLI mit Ihren Anmeldeinformationen konfiguriert + Docker installiert + Bei dieser Anleitung wird davon ausgegangen, dass Sie sich auf der x86\_64-Plattform befinden 1. **Die Projektstruktur einrichten** Erstellen Sie ein Verzeichnis für Ihr Lambda-Funktionscontainer-Image ``` mkdir python-appsignals-container-lambda &&\ cd python-appsignals-container-lambda ``` 1. **Docker-Datei erstellen** Laden Sie die Unterstützung für OpenTelemetry Layer mit Application Signals herunter und integrieren Sie sie direkt in Ihr Lambda-Container-Image. Zu diesem Zweck wird die `Dockerfile`-Datei erstellt. ``` # Dockerfile FROM public.ecr.aws/lambda/python:3.13 # Copy function code COPY app.py ${LAMBDA_TASK_ROOT} # Install unzip and wget utilities RUN dnf install -y unzip wget # Download the OpenTelemetry Layer with AppSignals Support RUN wget https://github.com/aws-observability/aws-otel-python-instrumentation/releases/latest/download/layer.zip -O /tmp/layer.zip # Extract and include Lambda layer contents RUN mkdir -p /opt && \ unzip /tmp/layer.zip -d /opt/ && \ chmod -R 755 /opt/ && \ rm /tmp/layer.zip # Set the CMD to your handler CMD [ "app.lambda_handler" ] ``` **Anmerkung** Die `layer.zip` Datei enthält die OpenTelemetry Instrumentierung, die für die Unterstützung von AWS Application Signals zur Überwachung Ihrer Lambda-Funktion erforderlich ist. Die Schritte zur Schichtextraktion stellen Folgendes sicher: Der Inhalt von layer.zip wird ordnungsgemäß in das `/opt/ directory` extrahiert Das `otel-instrument`-Skript erhält die richtigen Ausführungsberechtigungen Die temporäre Datei layer.zip wurde entfernt, um die Bildgröße zu verringern 1. **Lambda-Funktionscode** Erstellen Sie Ihre Lambda-Funktion in einer `app.py`-Datei: ``` import json import boto3 def lambda_handler(event, context): """ Sample Lambda function that can be used in a container image. Parameters: ----------- event: dict Input event data context: LambdaContext Lambda runtime information Returns: __ dict Response object """ print("Received event:", json.dumps(event, indent=2)) # Create S3 client s3 = boto3.client('s3') try: # List buckets response = s3.list_buckets() # Extract bucket names buckets = [bucket['Name'] for bucket in response['Buckets']] return { 'statusCode': 200, 'body': json.dumps({ 'message': 'Successfully retrieved buckets', 'buckets': buckets }) } except Exception as e: print(f"Error listing buckets: {str(e)}") return { 'statusCode': 500, 'body': json.dumps({ 'message': f'Error listing buckets: {str(e)}' }) } ``` Ihre Projektstruktur sollte in etwa wie folgt aussehen: ``` . ├── Dockerfile ├── app.py └── instructions.md ``` 1. **Container-Image erstellen und bereitstellen** **Umgebungsvariablen festlegen** ``` AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text) AWS_REGION=$(aws configure get region) # For fish shell users: # set AWS_ACCOUNT_ID (aws sts get-caller-identity --query Account --output text) # set AWS_REGION (aws configure get region) ``` Authentifizieren Sie sich mit öffentlichem Amazon ECR ``` aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws ``` Authentifizieren Sie sich mit privatem Amazon ECR ``` aws ecr get-login-password --region $AWS_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com ``` Amazon-ECR-Repository erstellen (falls erforderlich) ``` aws ecr create-repository \ --repository-name lambda-appsignals-demo \ --region $AWS_REGION ``` Image erstellen, mit Tags versehen und übertragen ``` # Build the Docker image docker build -t lambda-appsignals-demo . # Tag the image docker tag lambda-appsignals-demo:latest $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest # Push the image docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/lambda-appsignals-demo:latest 5. Create and Configure the Lambda Function ``` 1. **Die Lambda-Funktion erstellen und konfigurieren** Erstellen Sie eine neue Funktion mit der Lambda-Konsole. Wählen Sie **Container-Image** als Bereitstellungsoption aus. Wählen Sie **Images durchsuchen**, um Ihr Amazon-EC-Image auszuwählen. 1. **Testen und Verifizierungen – Testen Sie Ihr Lambda mit einem einfachen Ereignis. Wenn die Schichtintegration erfolgreich ist, wird Ihr Lambda unter der Application-Signals-Service-Übersicht angezeigt.** In der CloudWatch Konsole werden Ihnen Traces und Metriken für Ihre Lambda-Funktion angezeigt. **Fehlersuche** Wenn Application Signals nicht funktioniert, überprüfen Sie Folgendes: + Überprüfen Sie die Funktionsprotokolle auf Fehler im Zusammenhang mit der Instrumentierung OpenTelemetry + Überprüfen Sie, ob die Umgebungsvariable `AWS_LAMBDA_EXEC_WRAPPER` richtig festgelegt ist + Stellen Sie sicher, dass die Schichtextraktion in der Docker-Datei erfolgreich abgeschlossen wurde + Vergewissern Sie sich, dass die IAM-Berechtigungen ordnungsgemäß angehängt sind + Erhöhen Sie bei Bedarf die *Timeout- und Speichereinstellungen* in der allgemeinen Konfiguration der Lambda-Funktion ------