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 Kubernetes aktivieren Aktivieren Sie CloudWatch Application Signals auf Kubernetes, indem Sie die in diesem Abschnitt beschriebenen benutzerdefinierten Einrichtungsschritte verwenden. Für Anwendungen, die auf Kubernetes ausgeführt werden, installieren und konfigurieren Sie den CloudWatch Agenten und AWS die Distribution selbst. OpenTelemetry Auf diesen Architekturen, die mit einer benutzerdefinierten Einrichtung von Application Signals aktiviert wurden, erkennt Application Signals die Namen Ihrer Services oder deren Cluster oder Hosts nicht automatisch. Sie müssen diese Namen bei der benutzerdefinierten Einrichtung angeben, und die Namen, die Sie angeben, werden auf den Dashboards von Application Signals angezeigt. **Voraussetzungen** + Sie haben Administratorrechte für den Kubernetes-Cluster, auf dem Sie Application Signals aktivieren. + Sie müssen den in der Umgebung AWS CLI installiert haben, in der Ihr Kubernetes-Cluster läuft. Weitere Informationen zur Installation von finden [Sie unter Installieren oder Aktualisieren der neuesten Version von](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). AWS CLI AWS CLI + Sie haben kubectl und helm auf Ihrem lokalen Terminal installiert. Weitere Informationen finden Sie in der [kubectl](https://kubernetes.io/docs/tasks/tools/#kubectl)- und [Helm](https://helm.sh/)-Dokumentation. ## Schritt 1: Application Signals in Ihrem Konto aktivieren Sie müssen Application Signals zuerst in Ihrem Konto aktivieren. Wenn Sie dies nicht getan haben, siehe [Application Signals in Ihrem Konto aktivieren](CloudWatch-Application-Signals-Enable.md). ## Schritt 2: Installieren Sie den CloudWatch Agent-Operator in Ihrem Cluster Durch die Installation des CloudWatch Agent-Operators werden der Operator, der CloudWatch Agent und andere automatische Instrumente in Ihrem Cluster installiert. Geben Sie dazu den folgenden Befehl ein. Ersetzen Sie es *\$1REGION* durch Ihre AWS Region. *\$1YOUR\$1CLUSTER\$1NAME*Ersetzen Sie es durch den Namen, der für Ihren Cluster in den Dashboards von Application Signals angezeigt werden soll. ``` helm repo add aws-observability https://aws-observability.github.io/helm-charts helm install amazon-cloudwatch-operator aws-observability/amazon-cloudwatch-observability \ --namespace amazon-cloudwatch --create-namespace \ --set region=$REGION \ --set clusterName=$YOUR_CLUSTER_NAME ``` Weitere Informationen finden Sie [ amazon-cloudwatch-observability](https://github.com/aws-observability/helm-charts/tree/main/charts/amazon-cloudwatch-observability)unter GitHub. ## Schritt 3: Richten Sie AWS Anmeldeinformationen für Ihre Kubernetes-Cluster ein **Wichtig** Wenn Ihr Kubernetes-Cluster auf Amazon EC2 gehostet wird, können Sie diesen Abschnitt überspringen und mit [Schritt 4: Anmerkungen hinzufügen](#Application-Signals-Enable-Kubernetes-annotations) fortfahren. Wenn Ihr Kubernetes-Cluster vor Ort gehostet wird, müssen Sie die Anweisungen in diesem Abschnitt befolgen, um Ihrer Kubernetes-Umgebung AWS Anmeldeinformationen hinzuzufügen. **So richten Sie Berechtigungen für einen On-Premises-Kubernetes-Cluster ein** 1. Erstellen Sie den IAM-Benutzer, der verwendet werden soll, um Ihrem On-Premises-Host Berechtigungen zu erteilen: 1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole. 1. Wählen Sie **Benutzer**, **Benutzer erstellen** aus. 1. Geben Sie unter **Benutzerdetails** für **Benutzername** einen Namen für den neuen IAM-Benutzer ein. Dies ist der Anmeldename, der zur Authentifizierung Ihres AWS Hosts verwendet wird. Wählen Sie anschließend **Weiter**. 1. Wählen Sie auf der Seite **Berechtigungen festlegen** für **Berechtigungsoptionen** die Option **Direktes Anfügen von Richtlinien** aus. 1. Wählen Sie aus der Liste der **Berechtigungsrichtlinien** die **CloudWatchAgentServerPolicy**Richtlinie aus, die Sie Ihrem Benutzer hinzufügen möchten. Klicken Sie anschließend auf **Weiter**. 1. Stellen Sie auf der Seite **Überprüfen und erstellen** sicher, dass Sie mit dem Benutzernamen zufrieden sind und dass die **CloudWatchAgentServerPolicy**Richtlinie in der **Berechtigungsübersicht aufgeführt** ist. 1. Wählen Sie **Benutzer erstellen** aus. 1. Erstellen Sie Ihren AWS Zugriffsschlüssel und Ihren geheimen Schlüssel und rufen Sie ihn ab: 1. Wählen Sie im Navigationsbereich der IAM-Konsole **Benutzer** und dann den Benutzernamen des Benutzers aus, den Sie zuvor erstellt haben. 1. Wählen Sie auf der Seite des Benutzers die Registerkarte **Sicherheits-Anmeldeinformationen** aus. Wählen Sie im Abschnitt **Zugriffsschlüssel** **Zugriffsschlüssel erstellen** aus. 1. Wählen Sie für **Zugriffsschlüssel erstellen – Schritt 1** die Option **Befehlszeilenschnittstelle (CLI)** aus. 1. Geben Sie für **Zugriffsschlüssel erstellen – Schritt 2** ein optionales Tag ein und wählen Sie **Weiter** aus. 1. Wählen Sie unter **Zugriffsschlüssel erstellen – Schritt 3** die Option **CSV-Datei herunterladen** aus, um eine CSV-Datei mit dem Zugriffsschlüssel und dem geheimen Zugriffsschlüssel Ihres IAM-Benutzers zu speichern. Diese Informationen sind für die nächsten Schritte erforderlich. 1. Wählen Sie **Fertig** aus. 1. Konfigurieren Sie Ihre AWS Anmeldeinformationen auf Ihrem lokalen Host, indem Sie den folgenden Befehl eingeben. Ersetzen Sie *ACCESS\$1KEY\$1ID* und *SECRET\$1ACCESS\$1ID* durch Ihren neu generierten Zugriffsschlüssel und Ihren geheimen Zugriffsschlüssel aus der CSV-Datei, die Sie im vorherigen Schritt heruntergeladen haben. Die Anmeldeinformationsdatei wird standardmäßig in `/home/user/.aws/credentials.` gespeichert ``` $ aws configure --profile AmazonCloudWatchAgent AWS Access Key ID [None]: ACCESS_KEY_ID AWS Secret Access Key [None]: SECRET_ACCESS_ID Default region name [None]: MY_REGION Default output format [None]: json ``` 1. Bearbeiten Sie die benutzerdefinierte Ressource, die der CloudWatch Agent installiert hat, mithilfe des Helm-Diagramms, um die neu erstellten geheimen AWS Anmeldeinformationen hinzuzufügen. ``` kubectl edit amazoncloudwatchagent cloudwatch-agent -n amazon-cloudwatch ``` 1. Hängen Sie die AWS Anmeldeinformationen bei geöffnetem Dateieditor in den CloudWatch Agent-Container ein, indem Sie die folgende Konfiguration oben in der Bereitstellung hinzufügen. Ersetzen Sie den Pfad `/home/user/.aws/credentials` durch den Speicherort Ihrer lokalen AWS Anmeldeinformationsdatei. ``` apiVersion: cloudwatch.aws.amazon.com/v1alpha1 kind: AmazonCloudWatchAgent metadata: name: cloudwatch-agent namespace: amazon-cloudwatch spec: volumeMounts: - mountPath: /rootfs volumeMounts: - name: aws-credentials mountPath: /root/.aws readOnly: true volumes: - hostPath: path: /home/user/.aws/credentials name: aws-credentials --- ``` ## Schritt 4: Anmerkungen hinzufügen **Anmerkung** Wenn Sie Application Signals für eine Node.js-Anwendung mit ESM aktivieren, überspringen Sie die Schritte in diesem Abschnitt und gehen Sie stattdessen zu [Einrichten einer Node.js-Anwendung mit dem ESM-Modulformat](#Kubernetes-NodeJs-ESM) über. [https://kubernetes.io/docs/concepts/workloads/](https://kubernetes.io/docs/concepts/workloads/) Diese Anmerkung instrumentiert Ihre Anwendung automatisch so, dass sie Metriken, Ablaufverfolgungen und Protokolle an Application Signals sendet. **So fügen Sie Anmerkungen für Application Signals hinzu** 1. Sie haben zwei Möglichkeiten für die Anmerkung: + **Workload kommentieren** instrumentiert automatisch einen einzelnen Workload in einem Cluster. + **Namespace kommentieren** instrumentiert automatisch alle Workloads, die im ausgewählten Namespace bereitgestellt werden. Wählen Sie eine dieser Optionen und folgen Sie den entsprechenden Schritten. 1. Geben Sie einen der folgenden Befehle ein, um einen einzelnen Workload mit Anmerkungen zu versehen. Ersetzen Sie *\$1WORKLOAD\$1TYPE* und durch die Werte für *\$1WORKLOAD\$1NAME* Ihren Workload. + Für Java-Workloads: ``` kubectl patch $WORKLOAD_TYPE $WORKLOAD_NAME -p '{"spec": {"template": {"metadata": {"annotations": {"instrumentation.opentelemetry.io/inject-java": "true"}}}}}' ``` + Für Python-Workloads: ``` kubectl patch $WORKLOAD_TYPE $WORKLOAD_NAME -p '{"spec": {"template": {"metadata": {"annotations": {"instrumentation.opentelemetry.io/inject-python": "true"}}}}}' ``` Für Python-Anwendungen sind zusätzliche Konfigurationen erforderlich. Weitere Informationen finden Sie unter [Die Python-Anwendung wird nicht gestartet, nachdem Application Signals aktiviert wurde](CloudWatch-Application-Signals-Enable-Troubleshoot.md#Application-Signals-troubleshoot-starting-Python). + Für .NET-Workloads: ``` kubectl patch $WORKLOAD_TYPE $WORKLOAD_NAME -p '{"spec": {"template": {"metadata": {"annotations": {"instrumentation.opentelemetry.io/inject-dotnet": "true"}}}}}' ``` **Anmerkung** Um Application Signals für einen .NET-Workload auf Alpine Linux (`linux-musl-x64`)-basierten Images zu aktivieren, fügen Sie die folgende zusätzliche Anmerkung hinzu. ``` instrumentation.opentelemetry.io/otel-dotnet-auto-runtime: "linux-musl-x64" ``` + Für Node.js -Workloads: ``` kubectl patch $WORKLOAD_TYPE $WORKLOAD_NAME -p '{"spec": {"template": {"metadata": {"annotations": {"instrumentation.opentelemetry.io/inject-nodejs": "true"}}}}}' ``` 1. Geben Sie einen der folgenden Befehle ein, um alle Workloads in einem Namespace mit Anmerkungen zu versehen. Ersetzen Sie *\$1NAMESPACE* durch den Namen Ihres Namespaces. Wenn der Namespace Java-, Python- und .NET-Workloads umfasst, fügen Sie dem Namespace alle Anmerkungen hinzu. + Für Java-Workloads im Namespace: ``` kubectl annotate ns $NAMESPACE instrumentation.opentelemetry.io/inject-java=true ``` + Für Python-Workloads im Namespace: ``` kubectl annotate ns $NAMESPACE instrumentation.opentelemetry.io/inject-python=true ``` Für Python-Anwendungen sind zusätzliche Konfigurationen erforderlich. Weitere Informationen finden Sie unter [Die Python-Anwendung wird nicht gestartet, nachdem Application Signals aktiviert wurde](CloudWatch-Application-Signals-Enable-Troubleshoot.md#Application-Signals-troubleshoot-starting-Python). + Für .NET-Workloads im Namespace: ``` kubectl annotate ns $NAMESPACE instrumentation.opentelemetry.io/inject-dotnet=true ``` + Für Node.js-Workloads im Namespace: ``` kubectl annotate ns $NAMESPACE instrumentation.opentelemetry.io/inject-nodejs=true ``` Starten Sie nach dem Hinzufügen der Anmerkungen alle Pods im Namespace neu, indem Sie den folgenden Befehl eingeben: ``` kubectl rollout restart ``` 1. Wenn die vorherigen Schritte abgeschlossen sind, wählen Sie in der CloudWatch Konsole **Application Signals**, **Services** aus. Dadurch werden die Dashboards geöffnet, in denen Sie die Daten sehen können, die Application Signals erfasst. Es kann einige Minuten dauern, bis Daten angezeigt werden. Weitere Informationen über die **Services**-Ansicht finden Sie unter [Den Betriebsstatus Ihrer Anwendungen mit Application Signals überwachen](Services.md). ### Einrichten einer Node.js-Anwendung mit dem ESM-Modulformat Wir bieten eingeschränkte Unterstützung für Node.js-Anwendungen im ESM-Modulformat. Details hierzu finden Sie unter [Bekannte Einschränkungen von Node.js mit ESM](CloudWatch-Application-Signals-supportmatrix.md#ESM-limitations). Für das ESM-Modulformat funktioniert die Aktivierung von Application Signals durch Kommentieren der Manifestdatei nicht. Überspringen Sie das vorherige Verfahren und gehen Sie stattdessen wie folgt vor: **So aktivieren Sie Application Signals für eine Node.js-Anwendung mit ESM** 1. Installieren Sie die relevanten Abhängigkeiten in Ihrer Node.js-Anwendung für die automatische Instrumentierung: ``` npm install @aws/aws-distro-opentelemetry-node-autoinstrumentation npm install @opentelemetry/instrumentation@0.54.0 ``` 1. Fügen Sie der Dockerfile für Ihre Anwendung die folgenden Umgebungsvariablen hinzu und erstellen Sie das Image. ``` ... ENV OTEL_AWS_APPLICATION_SIGNALS_ENABLED=true ENV OTEL_TRACES_SAMPLER_ARG='endpoint=http://cloudwatch-agent.amazon-cloudwatch:2000' ENV OTEL_TRACES_SAMPLER='xray' ENV OTEL_EXPORTER_OTLP_PROTOCOL='http/protobuf' ENV OTEL_EXPORTER_OTLP_TRACES_ENDPOINT='http://cloudwatch-agent.amazon-cloudwatch:4316/v1/traces' ENV OTEL_AWS_APPLICATION_SIGNALS_EXPORTER_ENDPOINT='http://cloudwatch-agent.amazon-cloudwatch:4316/v1/metrics' ENV OTEL_METRICS_EXPORTER='none' ENV OTEL_LOGS_EXPORTER='none' ENV NODE_OPTIONS='--import @aws/aws-distro-opentelemetry-node-autoinstrumentation/register --experimental-loader=@opentelemetry/instrumentation/hook.mjs' ENV OTEL_SERVICE_NAME='YOUR_SERVICE_NAME' #replace with a proper service name ENV OTEL_PROPAGATORS='tracecontext,baggage,b3,xray' ... # command to start the application # for example # CMD ["node", "index.mjs"] ``` 1. Fügen Sie die Umgebungsvariablen `OTEL_RESOURCE_ATTRIBUTES_POD_NAME`, `OTEL_RESOURCE_ATTRIBUTES_NODE_NAME`, `OTEL_RESOURCE_ATTRIBUTES_DEPLOYMENT_NAME`, `POD_NAMESPACE` und `OTEL_RESOURCE_ATTRIBUTES` zur Bereitstellungs-YAML-Datei für die Anwendung hinzu. Beispiel: ``` apiVersion: apps/v1 kind: Deployment metadata: name: nodejs-app labels: app: nodejs-app spec: replicas: 2 selector: matchLabels: app: nodejs-app template: metadata: labels: app: nodejs-app # annotations: # make sure this annotation doesn't exit # instrumentation.opentelemetry.io/inject-nodejs: 'true' spec: containers: - name: nodejs-app image:your-nodejs-application-image #replace it with a proper image uri imagePullPolicy: Always ports: - containerPort: 8000 env: - name: OTEL_RESOURCE_ATTRIBUTES_POD_NAME valueFrom: fieldRef: fieldPath: metadata.name - name: OTEL_RESOURCE_ATTRIBUTES_NODE_NAME valueFrom: fieldRef: fieldPath: spec.nodeName - name: OTEL_RESOURCE_ATTRIBUTES_DEPLOYMENT_NAME valueFrom: fieldRef: fieldPath: metadata.labels['app'] # Assuming 'app' label is set to the deployment name - name: POD_NAMESPACE valueFrom: fieldRef: fieldPath: metadata.namespace - name: OTEL_RESOURCE_ATTRIBUTES value: "k8s.deployment.name=$(OTEL_RESOURCE_ATTRIBUTES_DEPLOYMENT_NAME),k8s.namespace.name=$(POD_NAMESPACE),k8s.node.name=$(OTEL_RESOURCE_ATTRIBUTES_NODE_NAME),k8s.pod.name=$(OTEL_RESOURCE_ATTRIBUTES_POD_NAME)" ``` 1. Stellen Sie die Node.js-Anwendung für den Kubernetes-Cluster bereit. ## (Optional) Schritt 5: Überwachen des Anwendungszustands Sobald Sie Ihre Anwendungen auf Kubernetes 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).