

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Monitoraggio dell'operatore Flink Kubernetes e dei processi Flink
<a name="jobruns-flink-monitoring"></a>

Questa sezione descrive diversi modi per monitorare i processi Flink con Amazon EMR su EKS. Queste includono l'integrazione di Flink con Amazon Managed Service for Prometheus, l'utilizzo di *Flink Web Dashboard*, che fornisce lo stato del lavoro e le metriche, o l'utilizzo di una configurazione di monitoraggio per inviare dati di log ad Amazon S3 e. Amazon CloudWatch

**Topics**
+ [Usa Amazon Managed Service for Prometheus per monitorare i lavori di Flink](jobruns-flink-monitoring-prometheus.md)
+ [Usa l'interfaccia utente Flink per monitorare i lavori Flink](jobruns-flink-monitoring-ui.md)
+ [Utilizza la configurazione di monitoraggio per monitorare l'operatore Flink Kubernetes e i lavori Flink](jobruns-flink-monitoring-configuration.md)

# Usa Amazon Managed Service for Prometheus per monitorare i lavori di Flink
<a name="jobruns-flink-monitoring-prometheus"></a>

Puoi integrare il servizio Apache Flink con Amazon Managed Service per Prometheus (portale di gestione). Amazon Managed Service per Prometheus supporta l'acquisizione di parametri dai server di Amazon Managed Service per Prometheus in cluster in esecuzione su Amazon EKS. Amazon Managed Service per Prometheus funziona insieme a un server Prometheus già in esecuzione sul tuo cluster Amazon EKS. L'esecuzione dell'integrazione di Amazon Managed Service per Prometheus con l'operatore Amazon EMR Flink implementerà e configurerà in automatico un server Prometheus per l'integrazione con Amazon Managed Service per Prometheus.

1. [ Crea un Workspace Amazon Managed Service per Prometheus](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-onboard-create-workspace.html). Questo Workspace funge da endpoint di acquisizione. L'URL di scrittura remoto sarà necessario in un secondo momento.

1. Imposta ruoli IAM per gli account di servizio.

   Per questo metodo di onboarding, utilizza i ruoli IAM per gli account di servizio nel cluster Amazon EKS in cui il server Prometheus è in esecuzione. Questi ruoli sono denominati *ruoli di servizio*.

   Se non disponi già dei ruoli, [ configura i ruoli di servizio per l'acquisizione di parametri dai cluster Amazon EKS.](https://docs.aws.amazon.com/prometheus/latest/userguide/set-up-irsa.html)

   Prima di continuare, crea un ruolo IAM denominato `amp-iamproxy-ingest-role`.

1. Installa l'operatore Amazon EMR Flink per Amazon Managed Service per Prometheus.

Ora che disponi di un Workspace Amazon Managed Service per Prometheus, un ruolo IAM dedicato ad Amazon Managed Service per Prometheus e disponi delle autorizzazioni necessarie, puoi installare l'operatore Flink di Amazon EMR.

Creare un file `enable-amp.yaml` Questo file consente di utilizzare una configurazione personalizzata per sovrascrivere le impostazioni di Amazon Managed Service for Prometheus. Assicurati di utilizzare i tuoi ruoli.

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

Utilizza il comando [https://helm.sh/docs/helm/helm_install/](https://helm.sh/docs/helm/helm_install/) per trasmettere gli override al grafico `flink-kubernetes-operator`.

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

Questo comando installa automaticamente un reporter Prometheus nell'operatore sulla porta 9999. Ogni `FlinkDeployment` futura espone anche una porta `metrics` su 9249.
+ I parametri dell'operatore Flink vengono visualizzati in Prometheus sotto l'etichetta `flink_k8soperator_`.
+ I parametri di Flink Task Manager vengono visualizzati in Prometheus sotto l'etichetta `flink_taskmanager_`.
+ I parametri di Flink Job Manager vengono visualizzate in Prometheus sotto l'etichetta `flink_jobmanager_`.

# Usa l'interfaccia utente Flink per monitorare i lavori Flink
<a name="jobruns-flink-monitoring-ui"></a>

Per monitorare lo stato e le prestazioni di un'applicazione Flink in esecuzione, utilizza *Flink Web Dashboard*. Questa dashboard fornisce informazioni sullo stato del lavoro, sul numero di TaskManagers, sulle metriche e sui registri del lavoro. Consente inoltre di visualizzare e modificare la configurazione del processo Flink e di interagire con il cluster Flink per inviare o annullare i processi.

Procedura per accedere a Flink Web Dashboard per un'applicazione Flink in esecuzione su Kubernetes:

1. Utilizzate il `kubectl port-forward` comando per inoltrare una porta locale alla porta su cui è in esecuzione Flink Web Dashboard nei pod dell'applicazione Flink. TaskManager Per impostazione predefinita, la porta è 8081. Sostituisci *deployment-name* con il nome della distribuzione dell'applicazione Flink riportato sopra.

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

   Output di esempio:

   ```
   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. Se desideri utilizzare una porta diversa a livello locale, usa il parametro:8081*local-port*.

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

1. In un browser web, apri `http://localhost:8081` (o `http://localhost:local-port`, se hai utilizzato una porta locale personalizzata) per accedere a Flink Web Dashboard. Questa dashboard mostra informazioni sull'applicazione Flink in esecuzione, come lo stato del lavoro, il numero di TaskManagers, le metriche e i registri del lavoro.  
![\[Interfaccia utente di esempio della dashboard Flink\]](http://docs.aws.amazon.com/it_it/emr/latest/EMR-on-EKS-DevelopmentGuide/images/sample-flink-dashboard-ui.png)

# Utilizza la configurazione di monitoraggio per monitorare l'operatore Flink Kubernetes e i lavori Flink
<a name="jobruns-flink-monitoring-configuration"></a>

La configurazione di monitoraggio consente di configurare facilmente l'archiviazione dei log dell'applicazione Flink e dei registri degli operatori su S3 and/or CloudWatch (è possibile sceglierne uno o entrambi). In questo modo aggiungi un sidecar FluentD ai JobManager tuoi pod TaskManager e successivamente inoltra i registri di questi componenti ai lavandini configurati.

**Nota**  
Devi configurare i ruoli IAM per l'account di servizio per l'operatore Flink e il processo Flink (Account di servizio) per poter utilizzare questa funzionalità, perché richiede l'interazione con altri Servizi AWS. Per la configurazione è necessario utilizzare IRSA in [Configurazione dell'operatore Flink Kubernetes per Amazon EMR su EKS](jobruns-flink-kubernetes-operator-setup.md).

## Log dell'applicazione Flink
<a name="jobruns-flink-monitoring-configuration-application-logs"></a>

Puoi definire questa configurazione nel modo seguente.

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

Di seguito sono elencate le opzioni di configurazione.
+ `s3MonitoringConfiguration`: chiave di configurazione per impostare l'inoltro a S3
  + `logUri` (obbligatorio): il percorso del bucket S3 in cui desideri archiviare i log.
  + Il percorso su S3 una volta caricati i log sarà simile al seguente.
    + Rotazione dei log non abilitata:

      ```
      s3://${logUri}/${POD NAME}/STDOUT or STDERR.gz
      ```
    + La rotazione dei log è abilitata. Puoi utilizzare sia un file ruotato sia un file corrente (uno senza marcatura temporale).

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

      Il formato seguente è un numero crescente.

      ```
      s3://${logUri}/${POD NAME}/stdout_YYYYMMDD_index.gz
      ```
  + Per utilizzare questo strumento di inoltro, sono necessarie le seguenti autorizzazioni IAM.

    ```
    {
        "Effect": "Allow",
        "Action": [
            "s3:PutObject"
        ],
        "Resource": [
           "S3_BUCKET_URI/*",
           "S3_BUCKET_URI"
        ]
    }
    ```
+ `cloudWatchMonitoringConfiguration`— chiave di configurazione verso cui impostare l'inoltro. CloudWatch
  + `logGroupName`(obbligatorio) — nome del gruppo di CloudWatch log a cui si desidera inviare i log (crea automaticamente il gruppo se non esiste).
  + `logStreamNamePrefix` (facoltativo): nome del flusso di log a cui si desidera inviare i log. Il valore predefinito è una stringa vuota. Il formato è il seguente:

    ```
    ${logStreamNamePrefix}/${POD NAME}/STDOUT or STDERR
    ```
  + Per utilizzare questo strumento di inoltro, sono necessarie le seguenti autorizzazioni IAM.

    ```
    {
        "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` (facoltativo): la chiave di configurazione per impostare i limiti delle risorse sul container sidecar Fluentbit avviato.
  + `memoryLimit` (facoltativo): il valore predefinito è 512Mi. Regola secondo necessità.
  + `cpuLimit` (facoltativo): questa opzione non ha un valore predefinito. Regola secondo necessità.
+ `containerLogRotationConfiguration` (facoltativo): controlla il comportamento di rotazione dei log di container. È abilitato per impostazione predefinita.
  + `rotationSize` (obbligatorio): specifica la dimensione del file per la rotazione dei log. L'intervallo di valori possibili è compreso tra 2 KB e 2 GB. La parte relativa all'unità numerica del parametro rotationSize viene trasmessa come numero intero. Poiché i valori decimali non sono supportati, puoi specificare una dimensione di rotazione di 1,5 GB, ad esempio, con il valore 1.500 MB. Il valore predefinito è 2 GB.
  + `maxFilesToKeep` (obbligatorio): specifica il numero massimo di file da mantenere nel container in seguito alla rotazione. Il valore minimo è 1, quello massimo è 50. Il valore predefinito è 10.

## Log dell'operatore Flink
<a name="jobruns-flink-monitoring-configuration-operator-logs"></a>

È anche possibile abilitare l'archiviazione dei log dell'operatore utilizzando le opzioni seguenti nel file `values.yaml` nell'installazione del grafico Helm. Puoi abilitare S3 o entrambi. 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
```

Di seguito sono elencate le opzioni di configurazione disponibili in `monitoringConfiguration`.
+ `s3MonitoringConfiguration`: imposta questa opzione per l'archiviazione su S3.
+ `logUri` (obbligatorio): il percorso del bucket S3 in cui desideri archiviare i log.
+ Di seguito sono riportati i formati che mostrano come potrebbero presentarsi i percorsi del bucket S3 una volta caricati i log.
  + Rotazione dei log non abilitata.

    ```
    s3://${logUri}/${POD NAME}/OPERATOR or WEBHOOK/STDOUT or STDERR.gz
    ```
  + La rotazione dei log è abilitata. Puoi utilizzare sia un file ruotato sia un file corrente (uno senza marcatura temporale).

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

    L'indice di formato seguente è un numero crescente.

    ```
    s3://${logUri}/${POD NAME}/OPERATOR or WEBHOOK/stdout_YYYYMMDD_index.gz
    ```
+ `cloudWatchMonitoringConfiguration`— la chiave di configurazione verso cui configurare l'inoltro. CloudWatch
  + `logGroupName`(obbligatorio) — nome del gruppo di CloudWatch log a cui si desidera inviare i log. Se non esiste, il gruppo viene creato in automatico.
  + `logStreamNamePrefix` (facoltativo): nome del flusso di log a cui si desidera inviare i log. Il valore predefinito è una stringa vuota. Il formato in CloudWatch è il seguente:

    ```
    ${logStreamNamePrefix}/${POD NAME}/STDOUT or STDERR
    ```
+ `sideCarResources` (facoltativo): la chiave di configurazione per impostare i limiti delle risorse sul container sidecar Fluentbit avviato.
  + `memoryLimit` (facoltativo): il limite di memoria. Regola secondo necessità. Il valore predefinito è 512Mi.
  + `cpuLimit`: il limite della CPU. Regola secondo necessità. Nessun valore predefinito.
+ `containerLogRotationConfiguration` (facoltativo): controlla il comportamento di rotazione dei log di container. È abilitato per impostazione predefinita.
  + `rotationSize` (obbligatorio): specifica la dimensione del file per la rotazione dei log. L'intervallo di valori possibili è compreso tra 2 KB e 2 GB. La parte relativa all'unità numerica del parametro rotationSize viene trasmessa come numero intero. Poiché i valori decimali non sono supportati, puoi specificare una dimensione di rotazione di 1,5 GB, ad esempio, con il valore 1.500 MB. Il valore predefinito è 2 GB.
  + `maxFilesToKeep` (obbligatorio): specifica il numero massimo di file da mantenere nel container in seguito alla rotazione. Il valore minimo è 1, quello massimo è 50. Il valore predefinito è 10.