

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.

# Verwenden des CloudWatch Agenten zum Senden eingebetteter Logs im Metrikformat
<a name="CloudWatch_Embedded_Metric_Format_Generation_CloudWatch_Agent"></a>

 In diesem Abschnitt wird beschrieben, wie der CloudWatch Agent installiert und verwendet wird. Im ersten Teil dieses Abschnitts wird beschrieben, wie der CloudWatch Agent installiert wird. Im zweiten Teil dieses Abschnitts wird beschrieben, wie der CloudWatch Agent verwendet wird, um eingebettete Logs im metrischen Format zu senden. Wenn Sie diese Methode verwenden möchten, müssen Sie den CloudWatch Agenten für die Datei installieren, von der aus AWS-Services Sie eingebettete Logs im metrischen Format senden möchten. Danach können Sie Ereignisse senden. Der CloudWatch Agent muss Version 1.230621.0 oder höher sein.

**Anmerkung**  
Sie müssen den CloudWatch Agenten nicht installieren, um Protokolle von Lambda-Funktionen zu senden.  
Lambda-Funktionstimeouts werden nicht automatisch behandelt. Dies bedeutet, dass die Metriken für diesen Aufruf nicht erfasst werden, wenn für Ihre Funktion eine Zeitüberschreitung auftritt, bevor die Metriken übertragen werden.

## Den Agenten installieren CloudWatch
<a name="CloudWatch_Embedded_Metric_Format_Generation_Install_Agent"></a>

Installieren Sie den CloudWatch Agenten für jeden Dienst, der eingebettete Protokolle im metrischen Format senden soll.

### Den CloudWatch Agenten auf EC2 installieren
<a name="CloudWatch_Embedded_Metric_Format_Generation_Install_Agent_EC2"></a>

Installieren Sie zunächst den CloudWatch Agenten auf der Instance. Weitere Informationen finden Sie unter [Den CloudWatch Agenten installieren](install-CloudWatch-Agent-on-EC2-Instance.md).

Nachdem Sie den Agenten installiert haben, konfigurieren Sie den Agenten so, dass er einen UDP- oder TCP-Port auf die Protokolle im eingebetteten Metrikformat überwacht. Im Folgenden finden Sie ein Beispiel für diese Konfiguration, die den Standard-Socket `tcp:25888` überwacht. Weitere Informationen zur Agentenkonfiguration finden Sie unter [Erstellen oder bearbeiten Sie die CloudWatch Agenten-Konfigurationsdatei manuell](CloudWatch-Agent-Configuration-File-Details.md)

```
{
  "logs": {
    "metrics_collected": {
      "emf": { }
    }
  }
}
```

### Installation des CloudWatch Agenten auf Amazon ECS
<a name="CloudWatch_Embedded_Metric_Format_Generation_Install_Agent_ECS"></a>

Der einfachste Weg, den CloudWatch Agenten auf Amazon ECS bereitzustellen, besteht darin, ihn als Sidecar auszuführen und ihn in derselben Aufgabendefinition wie Ihre Anwendung zu definieren.

**Erstellen der Agentenkonfigurationsdatei**

Erstellen Sie Ihre CloudWatch Agenten-Konfigurationsdatei lokal. In diesem Beispiel lautet der relative Dateipfad `amazon-cloudwatch-agent.json`.

Weitere Informationen zur Agentenkonfiguration finden Sie unter [Erstellen oder bearbeiten Sie die CloudWatch Agenten-Konfigurationsdatei manuell](CloudWatch-Agent-Configuration-File-Details.md)

```
{
  "logs": {
    "metrics_collected": {
      "emf": { }
    }
  }
}
```

**Übertragen der Konfiguration an den SSM-Parameterspeicher**

Geben Sie den folgenden Befehl ein, um die CloudWatch Agentenkonfigurationsdatei in den AWS Systems Manager (SSM) -Parameterspeicher zu übertragen.

```
aws ssm put-parameter \
    --name "cwagentconfig" \
    --type "String" \
    --value "`cat amazon-cloudwatch-agent.json`" \
    --region "{{region}}"
```

**Konfigurieren der Aufgabendefinition**

Konfigurieren Sie Ihre Aufgabendefinition so, dass sie den CloudWatch Agenten verwendet und den TCP- oder UDP-Port verfügbar macht. Die Beispielaufgabendefinition, die Sie verwenden sollten, hängt vom Netzwerkmodus ab.

Beachten Sie, dass die `webapp` die `AWS_EMF_AGENT_ENDPOINT`-Umgebungsvariable angibt. Diese wird von der Bibliothek verwendet und sollte auf den Endpunkt verweisen, den der Agent überwacht. Darüber hinaus gibt der `cwagent` den `CW_CONFIG_CONTENT` als „valueFrom“-Parameter an, der auf die SSM-Konfiguration verweist, die Sie im vorherigen Schritt erstellt haben.

Dieser Abschnitt enthält ein Beispiel für den Bridge-Modus und ein Beispiel für den Host- oder awsvpc-Modus. Weitere Beispiele dafür, wie Sie den CloudWatch Agenten auf Amazon ECS konfigurieren können, finden Sie im [Github-Beispiel-Repository](https://github.com/aws-samples/amazon-cloudwatch-container-insights/tree/master/ecs-task-definition-templates/deployment-mode/sidecar)

Im Folgenden finden Sie ein Beispiel für den Bridge-Modus. Wenn das Bridge-Modus-Netzwerk aktiviert ist, muss der Agent mithilfe des `links`-Parameters mit Ihrer Anwendung verknüpft und mithilfe des Containernamens adressiert werden.

```
{
  "containerDefinitions": [
          {
              "name": "webapp",
              "links": [ "cwagent" ],
              "image": "my-org/web-app:latest",
              "memory": 256,
              "cpu": 256,
              "environment": [{
                "name": "AWS_EMF_AGENT_ENDPOINT",
                "value": "tcp://cwagent:25888"
              }],
          },
          {
              "name": "cwagent",
              "mountPoints": [],
              "image": "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest",
              "memory": 256,
              "cpu": 256,
              "portMappings": [{
                  "protocol": "tcp",
                  "containerPort": 25888
              }],
              "environment": [{
                "name": "CW_CONFIG_CONTENT",
                "valueFrom": "cwagentconfig"
              }],
          }
      ],
}
```

Im Folgenden finden Sie ein Beispiel für den Host-Modus oder den awsvpc-Modus. Beim Ausführen auf diesen Netzwerkmodi kann der Agent über `localhost` angesprochen werden.

```
{
  "containerDefinitions": [
          {
              "name": "webapp",
              "image": "my-org/web-app:latest",
              "memory": 256,
              "cpu": 256,
              "environment": [{
                "name": "AWS_EMF_AGENT_ENDPOINT",
                "value": "tcp://127.0.0.1:25888"
              }],
          },
          {
              "name": "cwagent",
              "mountPoints": [],
              "image": "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest",
              "memory": 256,
              "cpu": 256,
              "portMappings": [{
                  "protocol": "tcp",
                  "containerPort": 25888
              }],
              "environment": [{
                "name": "CW_CONFIG_CONTENT",
                "valueFrom": "cwagentconfig"
              }],
          }
      ],
}
```

**Anmerkung**  
Im awsvpc-Modus müssen Sie der VPC entweder eine öffentliche IP-Adresse geben (nur Fargate), ein NAT-Gateway einrichten oder einen Logs-VPC-Endpunkt einrichten. CloudWatch Weitere Informationen zum Einrichten einer NAT finden Sie unter [NAT-Gateways](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html). Weitere Informationen zum Einrichten eines CloudWatch Logs-VPC-Endpoints finden Sie unter [Using CloudWatch Logs with Interface VPC](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html) Endpoints.  
Im Folgenden finden Sie ein Beispiel dafür, wie Sie einer Aufgabe, die den Fargate-Starttyp verwendet, eine öffentliche IP-Adresse zuweisen.  

```
aws ecs run-task \ 
--cluster {{cluster-name}} \
--task-definition cwagent-fargate \
--region {{region}} \
--launch-type FARGATE \
--network-configuration "awsvpcConfiguration={subnets=[{{subnetId}}],securityGroups=[{{sgId}}],assignPublicIp=ENABLED}"
```

**Sicherstellen der Berechtigungen**

Stellen Sie sicher, dass die IAM-Rolle, die Ihre Aufgaben ausführt, über die Berechtigung zum Lesen aus dem SSM-Parameterspeicher verfügt. Sie können diese Genehmigung hinzufügen, indem Sie die **SSMReadOnlyAccessAmazon-Richtlinie** anhängen. Geben Sie dazu den folgenden Befehl ein.

```
aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/AmazonSSMReadOnlyAccess \
--role-name CWAgentECSExecutionRole
```

### Installation des CloudWatch Agenten auf Amazon EKS
<a name="CloudWatch_Embedded_Metric_Format_Generation_Install_Agent_EKS"></a>

Teile dieses Prozesses können übersprungen werden, wenn Sie CloudWatch Container Insights bereits auf diesem Cluster installiert haben.

Berechtigungen

Wenn Sie Container Insights noch nicht installiert haben, stellen Sie zunächst sicher, dass Ihre Amazon-EKS-Knoten über die entsprechenden IAM-Berechtigungen verfügen. Sie sollten das **CloudWatchAgentServerPolicy**angehängt haben. Weitere Informationen finden Sie unter [Überprüfung der Voraussetzungen für Container Insights in CloudWatch](Container-Insights-prerequisites.md).

**Create ConfigMap**

Erstellen Sie eine ConfigMap für den Agenten. Der weist den Agenten ConfigMap außerdem an, einen TCP- oder UDP-Port abzuhören. Verwenden Sie Folgendes ConfigMap.

```
# cwagent-emf-configmap.yaml
apiVersion: v1
data:
  # Any changes here must not break the JSON format
  cwagentconfig.json: |
    {
      "agent": {
        "omit_hostname": true
      },
      "logs": {
        "metrics_collected": {
          "emf": { }
        }
      }
    }
kind: ConfigMap
metadata:
  name: cwagentemfconfig
  namespace: default
```

Wenn Sie Container Insights bereits installiert haben, fügen Sie Ihrer vorhandenen `"emf": { }` Zeile die folgende Zeile hinzu ConfigMap.

**Wenden Sie das an ConfigMap**

Geben Sie den folgenden Befehl ein, um das anzuwenden ConfigMap.

```
kubectl apply -f cwagent-emf-configmap.yaml
```

**Bereitstellen des Agenten**

Um den CloudWatch Agenten als Sidecar bereitzustellen, fügen Sie den Agenten wie im folgenden Beispiel zu Ihrer Pod-Definition hinzu.

```
apiVersion: v1
kind: Pod
metadata:
  name: myapp
  namespace: default
spec:
  containers:
    # Your container definitions go here
    - name: web-app
      image: my-org/web-app:latest
    # CloudWatch Agent configuration
    - name: cloudwatch-agent
      image: public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest
      imagePullPolicy: Always
      resources:
        limits:
          cpu: 200m
          memory: 100Mi
        requests:
          cpu: 200m
          memory: 100Mi
      volumeMounts:
        - name: cwagentconfig
          mountPath: /etc/cwagentconfig
      ports:
  # this should match the port configured in the ConfigMap
        - protocol: TCP
          hostPort: 25888
          containerPort: 25888
  volumes:
    - name: cwagentconfig
      configMap:
        name: cwagentemfconfig
```

## Verwenden des CloudWatch Agenten zum Senden eingebetteter Logs im metrischen Format
<a name="CloudWatch_Embedded_Metric_Format_Generation_CloudWatch_Agent_Send_Logs"></a>

Wenn der CloudWatch Agent installiert ist und ausgeführt wird, können Sie die eingebetteten Protokolle im Metrikformat über TCP oder UDP senden. Beim Senden der Protokolle über den Agenten gibt es zwei Anforderungen:
+ Die Protokolle müssen einen `LogGroupName`-Schlüssel enthalten, der dem Agenten mitteilt, welche Protokollgruppe verwendet werden soll.
+ Jedes Protokollereignis muss sich in einer einzigen Zeile befinden. Mit anderen Worten, ein Protokollereignis darf das Zeilenumbruchzeichen (\$1n) nicht enthalten.

Die Protokollereignisse müssen auch der Spezifikation für eingebettete Metrikformate entsprechen. Weitere Informationen finden Sie unter [Spezifikation: Eingebettetes Metrikformat](CloudWatch_Embedded_Metric_Format_Specification.md).

Wenn Sie Alarme für Metriken erstellen möchten, die im eingebetteten Metrikformat erstellt wurden, siehe [Alarme für Metriken setzen, die mit dem eingebetteten Metrikformat erstellt wurden](CloudWatch_Embedded_Metric_Format_Alarms.md) für Empfehlungen.

Im Folgenden finden Sie ein Beispiel für das manuelle Senden von Protokollereignissen aus einer Linux-Bash-Shell. Sie können stattdessen die UDP-Socket-Schnittstellen verwenden, die von Ihrer gewünschten Programmiersprache bereitgestellt werden. 

```
echo '{"_aws":{"Timestamp":1574109732004,"LogGroupName":"Foo","CloudWatchMetrics":[{"Namespace":"MyApp","Dimensions":[["Operation"]],"Metrics":[{"Name":"ProcessingLatency","Unit":"Milliseconds","StorageResolution":60}]}]},"Operation":"Aggregator","ProcessingLatency":100}' \
> /dev/udp/0.0.0.0/25888
```

**Anmerkung**  
 Mit dem eingebetteten Metrikformat können Sie die Verarbeitung Ihrer EMF-Protokolle nach Metriken verfolgen, die im `AWS/Logs`-Namespace Ihres Kontos veröffentlicht werden. Diese können verwendet werden, um die fehlgeschlagene Metrikgenerierung von EMF nachzuverfolgen und festzustellen, ob Fehler aufgrund der Analyse oder der Validierung auftreten. Weitere Informationen finden Sie unter [Überwachung mit CloudWatch Metriken](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Monitoring-CloudWatch-Metrics.html). 