

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Monitoramento do operador do Kubernetes para Flink e dos trabalhos do Flink
<a name="jobruns-flink-monitoring"></a>

Esta seção descreve diversas maneiras para monitorar trabalhos do Flink com o Amazon EMR no EKS. Isso inclui a integração do Flink com o Amazon Managed Service for Prometheus, o uso do *Flink Web Dashboard*, que fornece o status e as métricas do trabalho, ou o uso de uma configuração de monitoramento para enviar dados de log ao Amazon S3 e ao Amazon CloudWatch.

**Topics**
+ [Uso do Amazon Managed Service para Prometheus no monitoramento de trabalhos do Flink](jobruns-flink-monitoring-prometheus.md)
+ [Uso da interface do usuário do Flink para monitorar trabalhos do Flink](jobruns-flink-monitoring-ui.md)
+ [Uso da configuração de monitoramento para monitorar o operador do Kubernetes do Flink e os trabalhos do Flink](jobruns-flink-monitoring-configuration.md)

# Uso do Amazon Managed Service para Prometheus no monitoramento de trabalhos do Flink
<a name="jobruns-flink-monitoring-prometheus"></a>

Você pode integrar o Apache Flink ao Amazon Managed Service for Prometheus (portal de gerenciamento). O Amazon Managed Service for Prometheus oferece suporte à ingestão de métricas de servidores do Amazon Managed Service for Prometheus em clusters em execução no Amazon EKS. O Amazon Managed Service for Prometheus funciona em conjunto com um servidor do Prometheus que já está em execução no cluster do Amazon EKS. A execução da integração do Amazon Managed Service for Prometheus com o operador do Flink do Amazon EMR implantará e configurará automaticamente um servidor do Prometheus para a integração com o Amazon Managed Service for Prometheus.

1. [Crie um Workspace do Amazon Managed Service for Prometheus](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-onboard-create-workspace.html). Este Workspace serve como um endpoint de ingestão. Você precisará do URL de gravação remota posteriormente.

1. Configure perfis do IAM para as contas de serviço.

   Para esse método de integração, use perfis do IAM para as contas de serviço no cluster do Amazon EKS em que o servidor do Prometheus está em execução. Esses perfis também são chamados de *perfis de serviço*.

   Se você ainda não tiver os perfis, [configure perfis de serviço para a ingestão de métricas de clusters do Amazon EKS.](https://docs.aws.amazon.com/prometheus/latest/userguide/set-up-irsa.html)

   Antes de continuar, crie um perfil do IAM chamado `amp-iamproxy-ingest-role`.

1. Instale o operador do Flink do Amazon EMR com o Amazon Managed Service for Prometheus.

Agora que você tem um Workspace do Amazon Managed Service for Prometheus, um perfil do IAM dedicado para o Amazon Managed Service for Prometheus e as permissões necessárias, é possível instalar o operador do Flink do Amazon EMR.

Criar um arquivo `enable-amp.yaml` Esse arquivo permite usar uma configuração personalizada para substituir as configurações do Amazon Managed Service for Prometheus. Use seus próprios perfis.

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

Use o comando [https://helm.sh/docs/helm/helm_install/](https://helm.sh/docs/helm/helm_install/) para transferir as substituições para o chart `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
```

Esse comando instala automaticamente um relator do Prometheus no operador na porta 9999. Qualquer `FlinkDeployment` futura também expõe uma porta para `metrics` em 9249.
+ As métricas do operador do Flink aparecem no Prometheus sob o rótulo `flink_k8soperator_`.
+ As métricas Task Manager do Flink aparecem no Prometheus sob o rótulo `flink_taskmanager_`.
+ As métricas Job Manager do Flink aparecem no Prometheus sob o rótulo `flink_jobmanager_`.

# Uso da interface do usuário do Flink para monitorar trabalhos do Flink
<a name="jobruns-flink-monitoring-ui"></a>

Para monitorar a integridade e a performance de uma aplicação do Flink em execução, use o *painel Web do Flink*. Esse painel fornece informações sobre o status do trabalho, o número TaskManagers e as métricas e registros do trabalho. Ele também permite visualizar e modificar a configuração do trabalho do Flink e interagir com o cluster do Flink para enviar ou cancelar trabalhos.

Para acessar o painel Web do Flink para uma aplicação do Flink em execução no Kubernetes:

1. Use o `kubectl port-forward` comando para encaminhar uma porta local para a porta na qual o Flink Web Dashboard está sendo executado nos pods do TaskManager aplicativo Flink. Por padrão, esta porta é 8081. *deployment-name*Substitua pelo nome da implantação do aplicativo Flink acima.

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

   Resultado do exemplo:

   ```
   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 você quiser usar uma porta diferente localmente, use o parâmetro:8081*local-port*.

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

1. Em um navegador da Web, vá até `http://localhost:8081` (ou `http://localhost:local-port`, se você usou uma porta local personalizada) para acessar o painel Web do Flink. Esse painel mostra informações sobre o aplicativo Flink em execução, como o status do trabalho, o número e as métricas e registros do trabalho. TaskManagers  
![\[Exemplo de interface do usuário do painel do Flink\]](http://docs.aws.amazon.com/pt_br/emr/latest/EMR-on-EKS-DevelopmentGuide/images/sample-flink-dashboard-ui.png)

# Uso da configuração de monitoramento para monitorar o operador do Kubernetes do Flink e os trabalhos do Flink
<a name="jobruns-flink-monitoring-configuration"></a>

A configuração de monitoramento permite que você configure facilmente o arquivamento de registros do seu aplicativo Flink e dos registros do operador no S3 and/or CloudWatch (você pode escolher um ou ambos). Isso adiciona um sidecar FluentD aos JobManager seus pods TaskManager e, posteriormente, encaminha os registros desses componentes para os coletores configurados.

**nota**  
Você deve configurar perfis do IAM para a conta de serviço do seu operador do Flink e seu trabalho do Flink (contas de serviço) para poder usar esse recurso, pois ele requer interação com outros Serviços da AWS. Você deve configurar isso usando IRSA em [Configuração do operador do Kubernetes para Flink para o Amazon EMR no EKS](jobruns-flink-kubernetes-operator-setup.md).

## Logs da aplicação do Flink
<a name="jobruns-flink-monitoring-configuration-application-logs"></a>

Você pode definir essa configuração da maneira apresentada a seguir.

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

A seguir, são apresentadas as opções de configuração.
+ `s3MonitoringConfiguration`: a chave de configuração para configurar o encaminhamento para o S3.
  + `logUri` (obrigatório): o caminho do bucket do S3 em que você deseja armazenar seus logs.
  + O caminho no S3 depois que os logs forem carregados será semelhante ao apresentado a seguir.
    + Nenhuma alternância de log habilitada:

      ```
      s3://${logUri}/${POD NAME}/STDOUT or STDERR.gz
      ```
    + A alternância de log está habilitada. Você pode usar um arquivo rotacionado e um arquivo atual (um que não tenha carimbo de data).

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

      O formato a seguir é um número incremental.

      ```
      s3://${logUri}/${POD NAME}/stdout_YYYYMMDD_index.gz
      ```
  + As permissões do IAM apresentadas a seguir são obrigatórias para usar este encaminhador.

    ```
    {
        "Effect": "Allow",
        "Action": [
            "s3:PutObject"
        ],
        "Resource": [
           "S3_BUCKET_URI/*",
           "S3_BUCKET_URI"
        ]
    }
    ```
+ `cloudWatchMonitoringConfiguration`— chave de configuração para a qual configurar o encaminhamento. CloudWatch
  + `logGroupName`(obrigatório) — nome do grupo de CloudWatch registros para o qual você deseja enviar registros (cria automaticamente o grupo se ele não existir).
  + `logStreamNamePrefix` (opcional): o nome do fluxo de logs para o qual você deseja enviar os logs. O valor padrão é uma string vazia. O formato é o seguinte:

    ```
    ${logStreamNamePrefix}/${POD NAME}/STDOUT or STDERR
    ```
  + As permissões do IAM apresentadas a seguir são obrigatórias para usar este encaminhador.

    ```
    {
        "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` (opcional): a chave de configuração para definir limites de recursos no contêiner sidecar do Fluent Bit iniciado.
  + `memoryLimit` (opcional): o valor padrão é 512 Mi. Ajuste de acordo com suas necessidades.
  + `cpuLimit` (opcional): esta opção não tem um padrão. Ajuste de acordo com suas necessidades.
+ `containerLogRotationConfiguration` (opcional): controla o comportamento de alternância de log do contêiner. Ele é habilitado por padrão.
  + `rotationSize` (obrigatório): especifica o tamanho do arquivo para a alternância de log. O intervalo de valores possíveis é de 2 KB a 2 GB. A parcela numérica da unidade do parâmetro rotationSize é transferida como um número inteiro. Como não há suporte para valores decimais, você pode especificar um tamanho de rotação de 1,5 GB, por exemplo, com o valor 1.500 MB. O padrão é 2 GB.
  + `maxFilesToKeep` (obrigatório): especifica o número máximo de arquivos a serem retidos no contêiner após a alternância ter ocorrido. O valor mínimo é de 1 e o valor máximo é de 50. O padrão é 10.

## Logs do operador do Flink
<a name="jobruns-flink-monitoring-configuration-operator-logs"></a>

Também podemos habilitar o arquivamento de logs para o operador ao usar as opções apresentadas a seguir no arquivo `values.yaml` da instalação do chart do Helm. Você pode ativar o S3 ou ambos. 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
```

A seguir, estão apresentadas as opções de configuração disponíveis em `monitoringConfiguration`.
+ `s3MonitoringConfiguration`: defina esta opção para realizar o arquivamento no S3.
+ `logUri` (obrigatório): o caminho do bucket do S3 em que você deseja armazenar seus logs.
+ A seguir, estão apresentados os formatos de como os caminhos do bucket do S3 podem parecer depois que os logs são carregados.
  + Nenhuma alternância de log habilitada.

    ```
    s3://${logUri}/${POD NAME}/OPERATOR or WEBHOOK/STDOUT or STDERR.gz
    ```
  + A alternância de log está habilitada. Você pode usar um arquivo rotacionado e um arquivo atual (um que não tenha carimbo de data).

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

    O índice de formato a seguir é um número incremental.

    ```
    s3://${logUri}/${POD NAME}/OPERATOR or WEBHOOK/stdout_YYYYMMDD_index.gz
    ```
+ `cloudWatchMonitoringConfiguration`— a chave de configuração para a qual configurar o encaminhamento. CloudWatch
  + `logGroupName`(obrigatório) — nome do grupo de CloudWatch registros para o qual você deseja enviar registros. O grupo é criado automaticamente, se não existir.
  + `logStreamNamePrefix` (opcional): o nome do fluxo de logs para o qual você deseja enviar os logs. O valor padrão é uma string vazia. O formato em CloudWatch é o seguinte:

    ```
    ${logStreamNamePrefix}/${POD NAME}/STDOUT or STDERR
    ```
+ `sideCarResources` (opcional): a chave de configuração para definir limites de recursos no contêiner sidecar do Fluent Bit iniciado.
  + `memoryLimit` (opcional): o limite de memória. Ajuste de acordo com suas necessidades. O padrão é de 512Mi.
  + `cpuLimit`: o limite de CPU. Ajuste de acordo com suas necessidades. Nenhum valor padrão.
+ `containerLogRotationConfiguration` (opcional): controla o comportamento de alternância de log do contêiner. Ele é habilitado por padrão.
  + `rotationSize` (obrigatório): especifica o tamanho do arquivo para a alternância de log. O intervalo de valores possíveis é de 2 KB a 2 GB. A parcela numérica da unidade do parâmetro rotationSize é transferida como um número inteiro. Como não há suporte para valores decimais, você pode especificar um tamanho de rotação de 1,5 GB, por exemplo, com o valor 1.500 MB. O padrão é 2 GB.
  + `maxFilesToKeep` (obrigatório): especifica o número máximo de arquivos a serem retidos no contêiner após a alternância ter ocorrido. O valor mínimo é de 1 e o valor máximo é de 50. O padrão é 10.