

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.

# Überwachung von Flink-Kubernetes-Operator- und Flink-Aufträgen
<a name="jobruns-flink-monitoring"></a>

In diesem Abschnitt werden verschiedene Möglichkeiten beschrieben, wie Sie Ihre Flink-Aufträge mit Amazon EMR in EKS überwachen können. Dazu gehören die Integration von Flink in den Amazon Managed Service für Prometheus, die Verwendung des *Flink Web Dashboards*, das Jobstatus und Metriken bereitstellt, oder die Verwendung einer Überwachungskonfiguration zum Senden von Protokolldaten an Amazon S3 und. Amazon CloudWatch

**Topics**
+ [Verwenden Sie Amazon Managed Service for Prometheus, um Flink-Jobs zu überwachen](jobruns-flink-monitoring-prometheus.md)
+ [Verwenden Sie die Flink-Benutzeroberfläche, um Flink-Jobs zu überwachen](jobruns-flink-monitoring-ui.md)
+ [Verwenden Sie die Überwachungskonfiguration, um den Flink Kubernetes-Operator und die Flink-Jobs zu überwachen](jobruns-flink-monitoring-configuration.md)

# Verwenden Sie Amazon Managed Service for Prometheus, um Flink-Jobs zu überwachen
<a name="jobruns-flink-monitoring-prometheus"></a>

Sie können Apache Flink in Amazon Managed Service für Prometheus (Verwaltungsportal) integrieren. Amazon Managed Service für Prometheus unterstützt die Erfassung von Metriken von Amazon Managed Service for Prometheus Servern in Clustern, die auf Amazon EKS ausgeführt werden. Amazon Managed Service für Prometheus arbeitet mit einem Prometheus-Server zusammen, der bereits auf Ihrem Amazon-EKS-Cluster läuft. Beim Ausführen der Integration von Amazon Managed Service für Prometheus mit Amazon EMR wird der Flink-Operator automatisch einen Prometheus-Server für die Integration mit Amazon Managed Service für Prometheus bereitstellen und konfigurieren.

1. [Einen Workspace von Amazon Managed Service für Prometheus erstellen](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-onboard-create-workspace.html). Dieser Workspace dient als Aufnahme-Endpunkt. Sie benötigen die Remote-Write-URL später.

1. IAM-Rollen für Servicekonten einrichten.

   Verwenden Sie für diese Onboarding-Methode IAM-Rollen für die Servicekonten im Amazon-EKS-Cluster, in dem der Prometheus-Server läuft. Diese Rollen werden als *Servicerollen* bezeichnet.

   Wenn Sie die Rollen noch nicht haben, [richten Sie Servicerollen für die Erfassung von Metriken aus Amazon-EKS-Clustern](https://docs.aws.amazon.com/prometheus/latest/userguide/set-up-irsa.html) ein.

   Bevor Sie fortfahren, erstellen Sie eine IAM-Rolle namens `amp-iamproxy-ingest-role`.

1. Installieren Sie Amazon-EMR-Flink-Operator mit Amazon Managed Service für Prometheus.

Da Sie nun über einen Workspace von Amazon Managed Service für Prometheus, eine dedizierte IAM-Rolle für Amazon Managed Service für Prometheus und die erforderlichen Berechtigungen verfügen, können Sie den Amazon-EMR-Flink-Operator installieren.

Erstellen Sie eine Datei `enable-amp.yaml`. Mit dieser Datei können Sie eine benutzerdefinierte Konfiguration verwenden, um die Einstellungen von Amazon Managed Service für Prometheus zu überschreiben. Stellen Sie sicher, dass Sie Ihre eigenen Rollen verwenden.

```
kube-prometheus-stack:
    prometheus:
    serviceAccount:
        create: true
        name: "amp-iamproxy-ingest-service-account"
        annotations:
            eks.amazonaws.com/role-arn: "arn:aws:iam::<AWS_ACCOUNT_ID>:role/amp-iamproxy-ingest-role"
    remoteWrite:
        - url: <AMAZON_MANAGED_PROMETHEUS_REMOTE_WRITE_URL>
        sigv4:
            region: <AWS_REGION>
        queueConfig:
            maxSamplesPerSend: 1000
            maxShards: 200
            capacity: 2500
```

Verwenden Sie den [https://helm.sh/docs/helm/helm_install/](https://helm.sh/docs/helm/helm_install/)-Befehl, um Überschreibungen an das `flink-kubernetes-operator`-Diagramm zu übergeben.

```
helm upgrade -n <namespace> flink-kubernetes-operator \
   oci://public.ecr.aws/emr-on-eks/flink-kubernetes-operator \
   --set prometheus.enabled=true
   -f enable-amp.yaml
```

Dieser Befehl installiert automatisch einen Prometheus-Reporter im Operator auf Port 9999. In Any Future wird `FlinkDeployment` auch ein `metrics` Port auf 9249 verfügbar gemacht.
+ Die Metriken für Flink-Operatoren werden in Prometheus unter der Kennung `flink_k8soperator_` angezeigt.
+ Die Metriken für Flink-Task-Manager werden in Prometheus unter der Kennung `flink_taskmanager_` angezeigt.
+ Die Metriken für Flink-Aufgaben-Manager werden in Prometheus unter der Kennung `flink_jobmanager_` angezeigt.

# Verwenden Sie die Flink-Benutzeroberfläche, um Flink-Jobs zu überwachen
<a name="jobruns-flink-monitoring-ui"></a>

Verwenden Sie das Flink-Web-Dashboard, um den Zustand und die Leistung einer laufenden *Flink-Anwendung* zu überwachen. Dieses Dashboard bietet Informationen über den Status des Jobs, die Anzahl der TaskManagers Jobs sowie die Metriken und Logs für den Job. Außerdem können Sie damit die Konfiguration des Flink-Aufträge anzeigen und ändern und mit dem Flink-Cluster interagieren, um Aufträge einzureichen oder abzubrechen.

So greifen Sie auf das Flink-Web-Dashboard für eine laufende Flink-Anwendung auf Kubernetes zu:

1. Verwenden Sie den `kubectl port-forward` Befehl, um einen lokalen Port an den Port weiterzuleiten, auf dem das Flink Web Dashboard in den Pods TaskManager der Flink-Anwendung läuft. Standardmäßig ist dies der Port 8081. *deployment-name*Ersetzen Sie es durch den Namen der Flink-Anwendungsbereitstellung von oben.

   ```
   kubectl get deployments -n namespace
   ```

   Beispielausgabe:

   ```
   kubectl get deployments -n flink-namespace
   NAME                        READY   UP-TO-DATE   AVAILABLE  AGE
   basic-example               1/1       1            1           11m
   flink-kubernetes-operator   1/1       1            1           21h
   ```

   ```
   kubectl port-forward deployments/deployment-name 8081 -n namespace
   ```

1. Wenn Sie lokal einen anderen Port verwenden möchten, verwenden Sie den *local-port* Parameter:8081.

   ```
   kubectl port-forward -n flink deployments/basic-example 8080:8081
   ```

1. Navigieren Sie in einem Webbrowser zu `http://localhost:8081` (oder `http://localhost:local-port` falls Sie einen benutzerdefinierten lokalen Port verwendet haben), um auf das Flink-Web-Dashboard zuzugreifen. Dieses Dashboard zeigt Informationen über die laufende Flink-Anwendung, wie z. B. den Status des Jobs, die Anzahl der TaskManagers Jobs sowie die Metriken und Logs für den Job.  
![\[Beispiel für eine Flink-Dashboard-Benutzeroberfläche\]](http://docs.aws.amazon.com/de_de/emr/latest/EMR-on-EKS-DevelopmentGuide/images/sample-flink-dashboard-ui.png)

# Verwenden Sie die Überwachungskonfiguration, um den Flink Kubernetes-Operator und die Flink-Jobs zu überwachen
<a name="jobruns-flink-monitoring-configuration"></a>

Mit der Überwachungskonfiguration können Sie ganz einfach die Protokollarchivierung Ihrer Flink-Anwendungs- und Operator-Logs in S3 einrichten and/or CloudWatch (Sie können entweder eines oder beide auswählen). Dadurch wird Ihren TaskManager Pods ein FluentD-Sidecar hinzugefügt JobManager und anschließend werden die Protokolle dieser Komponenten an Ihre konfigurierten Senken weitergeleitet.

**Anmerkung**  
Sie müssen IAM-Rollen für das Servicekonto für Ihren Flink-Operator und Ihren Flink-Auftrag (Servicekonten) einrichten, um dieses Feature nutzen zu können, da sie die Interaktion mit anderen AWS-Services erfordert. Sie müssen dies mithilfe von IRSA in [Flink-Kubernetes-Operator für Amazon EMR in EKS einrichten](jobruns-flink-kubernetes-operator-setup.md) einrichten.

## Protokolle der Flink-Anwendung
<a name="jobruns-flink-monitoring-configuration-application-logs"></a>

Sie können diese Konfiguration folgendermaßen definieren.

```
apiVersion: flink.apache.org/v1beta1
kind: FlinkDeployment
metadata:
  name: basic-example
spec:
  image: FLINK IMAGE TAG
  imagePullPolicy: Always
  flinkVersion: v1_17
  flinkConfiguration:
    taskmanager.numberOfTaskSlots: "2"
  executionRoleArn: JOB EXECUTION ROLE
  jobManager:
    resource:
      memory: "2048m"
      cpu: 1
  taskManager:
    resource:
      memory: "2048m"
      cpu: 1
  job:
    jarURI: local:///opt/flink/examples/streaming/StateMachineExample.jar
  monitoringConfiguration:
    s3MonitoringConfiguration:
      logUri: S3 BUCKET
    cloudWatchMonitoringConfiguration:
      logGroupName: LOG GROUP NAME
      logStreamNamePrefix: LOG GROUP STREAM PREFIX
    sideCarResources:
      limits:
        cpuLimit: 500m
        memoryLimit: 250Mi
    containerLogRotationConfiguration:
        rotationSize: 2GB
        maxFilesToKeep: 10
```

Im Folgenden finden Sie Konfigurationsoptionen.
+ `s3MonitoringConfiguration` – Konfigurationsschlüssel zum Einrichten der Weiterleitung an S3
  + `logUri` (erforderlich) – der S3-Bucket-Pfad, in dem Sie Ihre Protokolle speichern möchten.
  + Der Pfad auf S3 sieht nach dem Hochladen der Protokolle wie folgt aus.
    + Keine Protokollrotation aktiviert:

      ```
      s3://${logUri}/${POD NAME}/STDOUT or STDERR.gz
      ```
    + Die Protokollrotation ist aktiviert. Sie können sowohl eine rotierte Datei als auch eine aktuelle Datei (eine Datei ohne Datumsstempel) verwenden.

      ```
      s3://${logUri}/${POD NAME}/STDOUT or STDERR.gz
      ```

      Das folgende Format ist eine aufsteigende Zahl.

      ```
      s3://${logUri}/${POD NAME}/stdout_YYYYMMDD_index.gz
      ```
  + Die folgenden IAM-Berechtigungen sind erforderlich. um diese Weiterleitung zu nutzen.

    ```
    {
        "Effect": "Allow",
        "Action": [
            "s3:PutObject"
        ],
        "Resource": [
           "S3_BUCKET_URI/*",
           "S3_BUCKET_URI"
        ]
    }
    ```
+ `cloudWatchMonitoringConfiguration`— Konfigurationsschlüssel, zu dem die Weiterleitung eingerichtet werden soll. CloudWatch
  + `logGroupName`(erforderlich) — Name der CloudWatch Protokollgruppe, an die Sie Protokolle senden möchten (erstellt die Gruppe automatisch, falls sie nicht existiert).
  + `logStreamNamePrefix` (optional) – Name des Protokollstreams, an den Sie Protokolle senden möchten. Der Standardwert ist eine leere Zeichenfolge. Das Format lautet folgendermaßen:

    ```
    ${logStreamNamePrefix}/${POD NAME}/STDOUT or STDERR
    ```
  + Die folgenden IAM-Berechtigungen sind erforderlich. um diese Weiterleitung zu nutzen.

    ```
    {
        "Effect": "Allow",
        "Action": [
            "logs:CreateLogStream",
            "logs:CreateLogGroup",
            "logs:PutLogEvents"
        ],
        "Resource": [
            "arn:aws:logs:REGION:ACCOUNT-ID:log-group:{YOUR_LOG_GROUP_NAME}:*",
            "arn:aws:logs:REGION:ACCOUNT-ID:log-group:{YOUR_LOG_GROUP_NAME}"
        ]
    }
    ```
+ `sideCarResources` (optional) – der Konfigurationsschlüssel zum Festlegen von Ressourcenlimits für den gestarteten Fluentbit-Sidecar-Container.
  + `memoryLimit` (Optional) – Der Standardwert ist 512Mi. Passen Sie ihn entsprechend Ihren Anforderungen an.
  + `cpuLimit` (optional) – Diese Option hat keinen Standard. Passen Sie ihn entsprechend Ihren Anforderungen an.
+ `containerLogRotationConfiguration` (optional) – steuert das Rotationsverhalten des Container-Protokolls. Sie ist standardmäßig aktiviert.
  + `rotationSize` (erforderlich) – gibt die Dateigröße für die Protokollrotation an. Der Bereich der möglichen Werte ist von 2 KB bis 2 GB. Die numerische Einheit des rotationSize-Parameters wird als Ganzzahl übergeben. Da Dezimalwerte nicht unterstützt werden, können Sie mit dem Wert 1 500 MB beispielsweise eine Rotationsgröße von 1,5 GB angeben. Der Standardwert ist 2 GB.
  + `maxFilesToKeep` (erforderlich) – gibt die maximale Anzahl von Dateien an, die nach der Rotation im Container aufbewahrt werden sollen. Der kleinste Wert ist 1 und der größte Wert ist 50. Der Standardwert ist 10.

## Protokolle des Flink-Operators
<a name="jobruns-flink-monitoring-configuration-operator-logs"></a>

Wir können auch die Protokollarchivierung für den Operator aktivieren, indem wir die folgenden Optionen in der `values.yaml`-Datei in Ihrer Helm-Chart-Installation verwenden. Sie können S3 oder beides aktivieren. CloudWatch

```
monitoringConfiguration: 
  s3MonitoringConfiguration:
    logUri: "S3-BUCKET"
    totalFileSize: "1G"
    uploadTimeout: "1m"
  cloudWatchMonitoringConfiguration:
    logGroupName: "flink-log-group"
    logStreamNamePrefix: "example-job-prefix-test-2"
  sideCarResources:
    limits:
      cpuLimit: 1
      memoryLimit: 800Mi
  memoryBufferLimit: 700M
```

Im Folgenden sind die verfügbaren Konfigurationsoptionen unter `monitoringConfiguration` aufgeführt.
+ `s3MonitoringConfiguration` – Stellen Sie diese Option ein, um auf S3 zu archivieren.
+ `logUri` (erforderlich) – Der S3-Bucket-Pfad, in dem Sie Ihre Protokolle speichern möchten.
+ Im Folgenden finden Sie Formate dafür, wie die S3-Bucket-Pfade nach dem Hochladen der Protokolle aussehen könnten.
  + Keine Protokollrotation aktiviert.

    ```
    s3://${logUri}/${POD NAME}/OPERATOR or WEBHOOK/STDOUT or STDERR.gz
    ```
  + Die Protokollrotation ist aktiviert. Sie können sowohl eine rotierte Datei als auch eine aktuelle Datei (eine Datei ohne Datumsstempel) verwenden.

    ```
    s3://${logUri}/${POD NAME}/OPERATOR or WEBHOOK/STDOUT or STDERR.gz
    ```

    Der folgende Formatindex ist eine aufsteigende Zahl.

    ```
    s3://${logUri}/${POD NAME}/OPERATOR or WEBHOOK/stdout_YYYYMMDD_index.gz
    ```
+ `cloudWatchMonitoringConfiguration`— der Konfigurationsschlüssel, zu dem die Weiterleitung eingerichtet werden soll CloudWatch.
  + `logGroupName`(erforderlich) — Name der CloudWatch Protokollgruppe, an die Sie Protokolle senden möchten. Die Gruppe wird automatisch erstellt, wenn sie noch nicht vorhanden ist.
  + `logStreamNamePrefix` (optional) – Name des Protokollstreams, an den Sie Protokolle senden möchten. Der Standardwert ist eine leere Zeichenfolge. Das Format in CloudWatch lautet wie folgt:

    ```
    ${logStreamNamePrefix}/${POD NAME}/STDOUT or STDERR
    ```
+ `sideCarResources` (optional) – der Konfigurationsschlüssel zum Festlegen von Ressourcenlimits für den gestarteten Fluentbit-Sidecar-Container.
  + `memoryLimit` (optional) – das Speicherlimit. Passen Sie ihn entsprechend Ihren Anforderungen an. Der Standardwert ist 512 Mi.
  + `cpuLimit` – das CPU-Limit. Passen Sie ihn entsprechend Ihren Anforderungen an. Kein Standardwert.
+ `containerLogRotationConfiguration` (optional): – steuert das Rotationsverhalten des Container-Protokolls. Sie ist standardmäßig aktiviert.
  + `rotationSize` (erforderlich) – gibt die Dateigröße für die Protokollrotation an. Der Bereich der möglichen Werte ist von 2 KB bis 2 GB. Die numerische Einheit des rotationSize-Parameters wird als Ganzzahl übergeben. Da Dezimalwerte nicht unterstützt werden, können Sie mit dem Wert 1 500 MB beispielsweise eine Rotationsgröße von 1,5 GB angeben. Der Standardwert ist 2 GB.
  + `maxFilesToKeep` (erforderlich) – gibt die maximale Anzahl von Dateien an, die nach der Rotation im Container aufbewahrt werden sollen. Der kleinste Wert ist 1 und der größte Wert ist 50. Der Standardwert ist 10.