# Monitorar trabalhos usando a interface do usuário da Web do Apache Spark Você pode usar a interface do usuário Web do Apache Spark para monitorar e depurar trabalhos de ETL do AWS Glue em execução no sistema de trabalhos do AWS Glue e também aplicativos Spark em execução em endpoints de desenvolvimento do AWS Glue. A interface do usuário do Spark permite que você verifique o seguinte para cada trabalho: + O cronograma de eventos de cada estágio do Spark + Um gráfico acíclico dirigido (DAG) do trabalho + Planos físicos e lógicos para consultas SparkSQL + As variáveis de ambiente do Spark subjacentes para cada trabalho Para obter mais informações sobre como usar a interface do usuário Web do Spark, consulte [Interface do usuário Web](https://spark.apache.org/docs/3.3.0/web-ui.html) na documentação do Spark. Para obter orientação sobre como interpretar os resultados da interface do usuário do Spark para melhorar a performance do seu trabalho, consulte [Best practices for performance tuning AWS Glue for Apache Spark jobs](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/introduction.html) em AWS Prescriptive Guidance. É possível ver a interface do usuário do Spark no console do AWS Glue. Isso está disponível quando um trabalho do AWS Glue é executado no AWS Glue 3.0 ou versões posteriores com logs gerados no formato Padrão (em vez de legado), o que é o padrão para trabalhos mais recentes. Se você tiver arquivos de log maiores que 0,5 GB, poderá ativar o suporte a logs contínuos para execuções de trabalhos em versões do AWS Glue 4.0 ou posteriores para simplificar o arquivamento, a análise e a solução de problemas de logs. Você pode habilitar a interface do usuário do Spark usando o console do AWS Glue ou a AWS Command Line Interface (AWS CLI). Quando você habilita a interface do usuário do Spark, os trabalhos de ETL do AWS Glue e as aplicações do Spark em endpoints de desenvolvimento do AWS Glue podem fazer backup dos logs de eventos do Spark em um local especificado por você no Amazon Simple Storage Service (Amazon S3). É possível usar os logs de eventos armazenados em backup no Amazon S3 com a interface do usuário do Spark em tempo real à medida que o trabalho é executado e após a conclusão do trabalho. Enquanto os logs permanecerem no Amazon S3, a interface do usuário do Spark no console do AWS Glue poderá visualizá-los. ## Permissões Para usar a interface do usuário do Spark no console do AWS Glue, é possível usar o `UseGlueStudio` ou adicionar todas as APIs de serviço individuais. Todas as APIs são necessárias para aproveitar ao máximo a interface do usuário do Spark. No entanto, os usuários podem acessar os recursos da interface do usuário do Spark adicionando suas APIs de serviço à permissão do IAM para acesso refinado. `RequestLogParsing` é o mais crítico, pois executa a análise dos logs. As APIs restantes destinam-se à leitura dos respectivos dados analisados. Por exemplo, `GetStages` fornece acesso aos dados sobre todas as etapas de um trabalho do Spark. A lista de APIs de serviço da interface do usuário do Spark mapeadas em `UseGlueStudio` é mostrada no exemplo de política abaixo. A política abaixo fornece acesso para uso somente dos recursos da interface do usuário do Spark. Para adicionar mais permissões, como Amazon S3 e IAM, consulte [Criar políticas personalizadas do IAM para AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/dg/getting-started-min-privs.html#getting-started-all-gs-privs.html). A lista de APIs de serviço da interface do usuário do Spark mapeadas em `UseGlueStudio` é mostrada no exemplo de política abaixo. Ao usar uma API de serviço da interface do usuário do Spark, use o seguinte namespace: `glue:`. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowGlueStudioSparkUI", "Effect": "Allow", "Action": [ "glue:RequestLogParsing", "glue:GetLogParsingStatus", "glue:GetEnvironment", "glue:GetJobs", "glue:GetJob", "glue:GetStage", "glue:GetStages", "glue:GetStageFiles", "glue:BatchGetStageFiles", "glue:GetStageAttempt", "glue:GetStageAttemptTaskList", "glue:GetStageAttemptTaskSummary", "glue:GetExecutors", "glue:GetExecutorsThreads", "glue:GetStorage", "glue:GetStorageUnit", "glue:GetQueries", "glue:GetQuery" ], "Resource": [ "*" ] } ] } ``` ------ ## Limitações + A interface do usuário do Spark no console do AWS Glue não está disponível para execuções de trabalhos que ocorreram antes de 20 de novembro de 2023, pois elas estão no formato de log legado. + A interface do Spark no console do AWS Glue não é compatível com logs contínuos, para o AWS Glue 4.0, como aqueles gerados por padrão em trabalhos de streaming. A soma máxima de todos os arquivos de eventos de logs acumulados gerados é 2 GB. Para trabalhos do AWS Glue sem suporte a logs contínuos, o tamanho máximo do arquivo de eventos de log suportado pelo SparkUI é de 0,5 GB. + A interface de usuário do Spark sem servidor não está disponível para registros de eventos do Spark armazenados em um bucket do Amazon S3 que só pode ser acessado pela sua VPC. ## Exemplo: interface do usuário Web do Apache Spark Este exemplo mostra como usar a interface do usuário do Spark para entender a performance do trabalho. As capturas de tela mostram a interface do usuário Web do Spark fornecida por um servidor de histórico autogerenciado do Spark. A interface do usuário do Spark no console do AWS Glue oferece visualizações semelhantes. Para obter mais informações sobre como usar a interface do usuário Web do Spark, consulte [Interface do usuário Web](https://spark.apache.org/docs/3.3.0/web-ui.html) na documentação do Spark. Veja a seguir um exemplo de uma aplicação Spark que lê de duas fontes de dados, realiza uma transformação de junção e a grava no Amazon S3 no formato Parquet. ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from pyspark.sql.functions import count, when, expr, col, sum, isnull from pyspark.sql.functions import countDistinct from awsglue.dynamicframe import DynamicFrame args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME']) df_persons = spark.read.json("s3://awsglue-datasets/examples/us-legislators/all/persons.json") df_memberships = spark.read.json("s3://awsglue-datasets/examples/us-legislators/all/memberships.json") df_joined = df_persons.join(df_memberships, df_persons.id == df_memberships.person_id, 'fullouter') df_joined.write.parquet("s3://aws-glue-demo-sparkui/output/") job.commit() ``` A visualização do DAG a seguir mostra os diferentes estágios nesse trabalho do Spark. ![\[Captura de tela da interface do usuário do Spark mostrando 2 estágios concluídos para o trabalho 0.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/spark-ui1.png) O cronograma de eventos a seguir para um trabalho mostra o início, a execução e o encerramento de diferentes executores do Spark. ![\[Captura de tela da interface do usuário do Spark mostrando os estágios concluídos, com falha e ativos de diferentes executores do Spark.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/spark-ui2.png) A tela a seguir mostra os detalhes dos planos de consulta do SparkSQL: + Plano lógico examinado + Plano lógico analisado + Plano lógico otimizado + Plano físico para execução ![\[Planos de consulta do SparkSQL: planos lógicos examinados, analisados e otimizados para execução.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/spark-ui3.png) **Topics** + [Permissões](#monitor-spark-ui-limitations-permissions) + [Limitações](#monitor-spark-ui-limitations) + [Exemplo: interface do usuário Web do Apache Spark](#monitor-spark-ui-limitations-example) + [Habilitar a interface do usuário da Web do Apache Spark para trabalhos do AWS Glue](monitor-spark-ui-jobs.md) + [Iniciar o servidor de histórico do Spark](monitor-spark-ui-history.md) # Habilitar a interface do usuário da Web do Apache Spark para trabalhos do AWS Glue Você pode usar a interface do usuário Web do Apache Spark para monitorar e depurar trabalhos de ETL do AWS Glue em execução no sistema de trabalhos do AWS Glue. Você pode configurar a interface do usuário do Spark usando o console do AWS Glue ou a AWS Command Line Interface (AWS CLI). A cada 30 segundos, o AWS Glue faz backup dos logs de eventos do Spark para o caminho do Amazon S3 especificado. **Topics** + [Configurar a interface do usuário do Spark (console)](#monitor-spark-ui-jobs-console) + [Configurar a interface do usuário do Spark (AWS CLI)](#monitor-spark-ui-jobs-cli) + [Configurar a interface do usuário do Spark para sessões usando cadernos](#monitor-spark-ui-sessions) + [Habilitar logs contínuos](#monitor-spark-ui-rolling-logs) ## Configurar a interface do usuário do Spark (console) Siga estas etapas para configurar a interface do usuário do Spark usando o Console de gerenciamento da AWS. Na criação de um trabalho do AWS Glue, a interface do usuário do Spark é habilitada por padrão. **Para ativar a interface do Spark quando você cria ou edita um trabalho** 1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 1. No painel de navegação, escolha **Tarefas**. 1. Escolha **Adicionar trabalho** ou selecione um trabalho que já exista. 1. Em **Detalhes do trabalho**, abra as **Propriedades avançadas**. 1. Na guia **Interface do usuário do Spark**, escolha **Gravar logs da interface do usuário do Spark no Amazon S3**. 1. Especifique um caminho do Amazon S3 para armazenar os logs de eventos do Spark para o trabalho. Observe que, se você usar uma configuração de segurança no trabalho, a criptografia também se aplicará ao arquivo de log da interface do usuário do Spark. Para obter mais informações, consulte [Criptografar dados gravados pelo AWS Glue](encryption-security-configuration.md). 1. Em **Configuração de log e monitoramento da interface do usuário do Spark**: + Selecione **Padrão** se você estiver gerando logs para visualizar no console do AWS Glue. + Selecione **Legado** se você estiver gerando logs para visualizar em um servidor de histórico do Spark. + Você também pode optar por gerar os dois. ## Configurar a interface do usuário do Spark (AWS CLI) Para gerar logs para visualização com a interface do usuário do Spark no console do AWS Glue, use AWS CLI para passar os seguintes parâmetros de trabalho para os trabalhos do AWS Glue. Para obter mais informações, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md). ``` '--enable-spark-ui': 'true', '--spark-event-logs-path': 's3://s3-event-log-path' ``` Para distribuir logs para seus locais legados, defina o parâmetro `--enable-spark-ui-legacy-path` como `"true"`. Se não quiser gerar logs nos dois formatos, remova o parâmetro `--enable-spark-ui`. ## Configurar a interface do usuário do Spark para sessões usando cadernos **Atenção** No momento, as sessões interativas do AWS Glue não oferecem suporte à interface do usuário do Spark no console. Configure um servidor de histórico do Spark. Se você usa cadernos do AWS Glue, configure a interface do usuário do Spark antes de iniciar a sessão. Para fazer isso, use a célula da mágica `%%configure`: ``` %%configure { “--enable-spark-ui”: “true”, “--spark-event-logs-path”: “s3://path” } ``` ## Habilitar logs contínuos Habilitar o SparkUI e os arquivos de eventos de logs contínuos para trabalhos do AWS Glue oferece vários benefícios: + Arquivos de eventos de logs contínuo: com os arquivos de eventos de logs contínuo ativados, o AWS Glue gera arquivos de log separados para cada etapa da execução do trabalho, facilitando a identificação e a solução de problemas específicos de um determinado estágio ou transformação. + Melhor gerenciamento de registros: arquivos de eventos de logs contínuos ajudam a gerenciar arquivos de log com mais eficiência. Em vez de ter um único arquivo de log potencialmente grande, os registros são divididos em arquivos menores e mais gerenciáveis com base nos estágios de execução do trabalho. Isso pode simplificar o arquivamento, a análise e a solução de problemas de logs. + Maior tolerância a falhas: se um trabalho do AWS Glue falhar ou for interrompido, os arquivos de eventos de logs contínuos podem fornecer informações valiosas sobre o último estágio bem-sucedido, facilitando a retomada do trabalho a partir desse ponto, em vez de começar do zero. + Otimização de custos: ao ativar arquivos de eventos de logs contínuos, você pode economizar nos custos de armazenamento associados aos arquivos de log. Em vez de armazenar um único arquivo de log potencialmente grande, você armazena arquivos de log menores e mais gerenciáveis, o que pode ser mais econômico, especialmente para trabalhos complexos ou de longa duração. Em um novo ambiente, os usuários podem habilitar explicitamente os logs contínuos por meio de: ``` '—conf': 'spark.eventLog.rolling.enabled=true' ``` or ``` '—conf': 'spark.eventLog.rolling.enabled=true —conf spark.eventLog.rolling.maxFileSize=128m' ``` Quando os logs contínuos são ativados, o `spark.eventLog.rolling.maxFileSize` especifica o tamanho máximo do arquivo de log de eventos antes da rolagem. Se esse parâmetro não for especificado, o valor 128 MB será usado como padrão. O mínimo é 10 MB. A soma máxima de todos os arquivos de eventos de logs acumulados gerados é 2 GB. Para trabalhos do AWS Glue sem suporte a logs contínuos, o tamanho máximo do arquivo de eventos de logs suportado pelo SparkUI é 0,5 GB. É possível desativar os logs contínuos de um trabalho de streaming por meio da passagem de uma configuração adicional. Observe que a manutenção de arquivos de log muito grandes pode ser cara. Para desativar os logs contínuos, forneça a seguinte configuração: ``` '--spark-ui-event-logs-path': 'true', '--conf': 'spark.eventLog.rolling.enabled=false' ``` # Iniciar o servidor de histórico do Spark É possível usar um servidor de histórico do Spark para visualizar os logs do Spark em sua própria infraestrutura. Você pode ver as mesmas visualizações no console do AWS Glue para execuções de trabalhos do AWS Glue no AWS Glue 4.0 ou versões posteriores com logs gerados no formato padrão (em vez de legado). Para obter mais informações, consulte [Monitorar trabalhos usando a interface do usuário da Web do Apache Spark](monitor-spark-ui.md). Você pode iniciar o servidor de histórico do Spark usando um modelo do AWS CloudFormation que hospeda o servidor em uma instância do EC2 ou executar localmente usando o Docker. **Topics** + [Iniciar o servidor de histórico do Spark e visualizar a interface do usuário do Spark usando o AWS CloudFormation](#monitor-spark-ui-history-cfn) + [Iniciar o servidor de histórico do Spark e visualizar a interface do usuário do Spark usando o Docker](#monitor-spark-ui-history-local) ## Iniciar o servidor de histórico do Spark e visualizar a interface do usuário do Spark usando o AWS CloudFormation Você pode usar um modelo do AWS CloudFormation para iniciar o servidor de histórico do Apache Spark e visualizar a interface do usuário Web do Spark. Esses modelos são exemplos que você deve modificar para atender aos seus requisitos. **Como iniciar o servidor de histórico do Spark e visualizar a interface do usuário do Spark usando o CloudFormation** 1. Escolha um dos botões **Launch Stack (Iniciar pilha)** na tabela a seguir. Isso inicia a pilha no console do CloudFormation. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitor-spark-ui-history.html) 1. Na página **Specify template (Especificar modelo)**, escolha **Next (Próximo)**. 1. Na página **Specify stack details (Especificar detalhes da pilha)**, insira o **Stack name (Nome da pilha)**. Insira informações adicionais em **Parameters** (Parâmetros). 1. **Configuração da interface do usuário do Spark** Forneça as informações a seguir: + **IP address range** (Intervalo de endereços IP): o intervalo de endereços IP que pode ser usado para visualizar a interface do usuário do Spark. Se você deseja restringir o acesso de um intervalo de endereços IP específico, use um valor personalizado. + **History server port** (Porta do servidor de histórico): a porta da interface do usuário do Spark. Você pode usar o valor padrão. + **Event log directory** (Diretório de logs de evento): escolha o local onde os logs de eventos do Spark são armazenados nos endpoints de trabalho ou de desenvolvimento do AWS Glue. Você deve usar **s3a://** para o esquema de caminho dos logs de eventos. + **Spark package location** (Local do pacote do Spark): você pode usar o valor padrão. + **Keystore path** (Caminho do repositório de chaves): o caminho do repositório de chaves SSL/TLS para HTTPS. Se você quiser usar um arquivo de armazenamento de chaves personalizado, especifique o caminho do S3 `s3://path_to_your_keystore_file` aqui. Se você deixar esse parâmetro vazio, um armazenamento de chaves baseado em certificado autoassinado será gerado e usado. + **Keystore password** (Senha do repositório de chaves): insira uma senha do repositório de chaves SSL/TLS para HTTPS. 1. **Configuração de instância do EC2** Forneça as informações a seguir: + **Instance type** (Tipo de instância): o tipo de instância do Amazon EC2 que hospeda o servidor de histórico do Spark. Como esse modelo inicia a instância do Amazon EC2 em sua conta, o custo do Amazon EC2 será cobrado em sua conta separadamente. + **Latest AMI ID** (ID da AMI mais recente): o ID da AMI do Amazon Linux 2 para a instância do servidor de histórico do Spark. Você pode usar o valor padrão. + **VPC ID** (ID da VPC): o ID da nuvem privada virtual (VPC) da instância do servidor de histórico do Spark. Você pode usar qualquer uma das VPCs disponíveis em sua conta. Não é recomendado usar uma VPC padrão com uma [Network ACL padrão](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html#default-network-acl). Para obter mais informações, consulte [VPC padrão e sub-redes padrão](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html) e [Criar uma VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#Create-VPC) no *Manual do usuário da Amazon VPC*. + **Subnet ID** (ID da sub-rede): o ID da instância do servidor de histórico do Spark. Você pode usar qualquer uma das sub-redes em sua VPC. Você deve ser capaz de acessar a rede do seu cliente para a sub-rede. Se quiser acessar pela Internet, você deverá usar uma sub-rede pública que tenha o gateway da Internet na tabela de rotas. 1. Escolha **Próximo**. 1. Na página **Configure stack options** (Configurar opções de pilha), para usar as credenciais do usuário atual para determinar como o CloudFormation pode criar, modificar ou excluir recursos na pilha, escolha **Next** (Próximo). Você também pode especificar um perfil na seção **Permissões** para usar em vez das permissões do usuário atual e, em seguida, escolher **Próximo**. 1. Na página **Review (Revisar)**, revise o modelo. Selecione **Reconheço que o CloudFormation pode criar recursos do IAM** e escolha **Criar pilha**. 1. Aguarde até que a pilha seja criada. 1. Abra a guia **Outputs (Saídas)**. 1. Copie o URL de **SparkUiPublicUrl** se você estiver usando uma sub-rede pública. 1. Copie o URL de **SparkUiPrivateUrl** se você estiver usando uma sub-rede privada. 1. Abra um navegador da Web e cole o URL. Isso permite que você acesse o servidor usando HTTPS na porta especificada. É possível que seu navegador não reconheça o certificado do servidor. Se isso acontecer, substitua a proteção e prossiga. ## Iniciar o servidor de histórico do Spark e visualizar a interface do usuário do Spark usando o Docker Se você preferir acesso local (não ter uma instância do EC2 para o servidor de histórico do Apache Spark), também poderá usar o Docker para iniciar o servidor de histórico do Apache Spark e visualizar a interface do usuário do Spark localmente. Este Dockerfile é um exemplo que você deve modificar para atender aos seus requisitos. **Pré-requisitos** Para obter informações sobre como instalar o Docker em seu laptop, consulte a [Comunidade do Docker Engine](https://docs.docker.com/install/). **Como iniciar o servidor de histórico do Spark e visualizar a interface do usuário do Spark localmente usando o Docker** 1. Faça download de arquivos do GitHub. Baixe o Dockerfile e o `pom.xml` dos [exemplos de código do AWS Glue](https://github.com/aws-samples/aws-glue-samples/tree/master/utilities/Spark_UI/). 1. Determine se você deseja usar suas credenciais de usuário ou credenciais de usuário federado para acessar AWS. + Para usar as credenciais do usuário atual para acessar AWS, obtenha os valores para usar em ` AWS_ACCESS_KEY_ID` e `AWS_SECRET_ACCESS_KEY` no comando `docker run`. Para obter mais informações, consulte [Como gerenciar chaves de acesso para usuários do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) no *Manual do usuário do IAM*. + Para usar usuários federados do SAML 2.0 para acessar AWS, obtenha os valores para ` AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, e ` AWS_SESSION_TOKEN`. Para obter mais informações, consulte [Solicitação de credenciais de segurança temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html). 1. Determine a localização do diretório do log de eventos, a ser usado no comando `docker run`. 1. Crie a imagem do Docker usando os arquivos no diretório local, usando o nome ` glue/sparkui` e a marcação `latest`. ``` $ docker build -t glue/sparkui:latest . ``` 1. Crie e inicie o contêiner do Docker. Nos comandos a seguir, use os valores obtidos anteriormente nas etapas 2 e 3. 1. Para criar o contêiner do Docker usando suas credenciais de usuário, use um comando semelhante ao seguinte ``` docker run -itd -e SPARK_HISTORY_OPTS="$SPARK_HISTORY_OPTS -Dspark.history.fs.logDirectory=s3a://path_to_eventlog -Dspark.hadoop.fs.s3a.access.key=AWS_ACCESS_KEY_ID -Dspark.hadoop.fs.s3a.secret.key=AWS_SECRET_ACCESS_KEY" -p 18080:18080 glue/sparkui:latest "/opt/spark/bin/spark-class org.apache.spark.deploy.history.HistoryServer" ``` 1. Para criar o contêiner do Docker usando credenciais temporárias, use ` org.apache.hadoop.fs.s3a.TemporaryAWSCredentialsProvider` como provedor, e forneça os valores de credenciais obtidos na etapa 2. Para obter mais informações, consulte [Uso de credenciais de sessão com TemporaryAWSCredentialsProvider](https://hadoop.apache.org/docs/stable/hadoop-aws/tools/hadoop-aws/index.html#Using_Session_Credentials_with_TemporaryAWSCredentialsProvider) na documentação *Hadoop: Integração com a Amazon Web Services*. ``` docker run -itd -e SPARK_HISTORY_OPTS="$SPARK_HISTORY_OPTS -Dspark.history.fs.logDirectory=s3a://path_to_eventlog -Dspark.hadoop.fs.s3a.access.key=AWS_ACCESS_KEY_ID -Dspark.hadoop.fs.s3a.secret.key=AWS_SECRET_ACCESS_KEY -Dspark.hadoop.fs.s3a.session.token=AWS_SESSION_TOKEN -Dspark.hadoop.fs.s3a.aws.credentials.provider=org.apache.hadoop.fs.s3a.TemporaryAWSCredentialsProvider" -p 18080:18080 glue/sparkui:latest "/opt/spark/bin/spark-class org.apache.spark.deploy.history.HistoryServer" ``` **nota** Esses parâmetros de configuração vêm do [Módulo Hadoop-AWS](https://hadoop.apache.org/docs/stable/hadoop-aws/tools/hadoop-aws/index.html). Talvez seja necessário adicionar uma configuração específica com base em seu caso de uso. Por exemplo: usuários em regiões isoladas precisarão configurar o ` spark.hadoop.fs.s3a.endpoint`. 1. Abra `http://localhost:18080` no navegador para visualizar a interface do usuário do Spark localmente.