# Trabalhos Spark e PySpark do AWS Glue O AWS Glue oferece suporte a trabalhos do Spark e PySpark. Um trabalho do Spark é executado em um ambiente Apache Spark gerenciado pelo AWS Glue. Ele processa os dados em lotes. Um trabalho de ETL de streaming é semelhante a um trabalho do Spark, exceto que ele executa ETL em streams de dados. Ele usa o framework do Apache Spark Structured Streaming. Alguns recursos de trabalho do Spark não estão disponíveis para trabalhos ETL de streaming. As seções a seguir fornecem mais informações sobre trabalhos Spark e PySpark do AWS Glue. **Topics** + [Configurar propriedades de trabalho para trabalhos do Spark no AWS Glue](add-job.md) + [Editar scripts do Spark no console do AWS Glue](edit-script-spark.md) + [Trabalhos (herdados)](console-edit-script.md) + [Rastrear dados processados usando marcadores de trabalho](monitor-continuations.md) + [Armazenamento de dados embaralhados do Spark](monitor-spark-shuffle-manager.md) + [Monitorar trabalhos Spark do AWS Glue](monitor-spark.md) + [Solução de problemas de IA generativa para o Apache Spark no AWS Glue](troubleshoot-spark.md) + [Usar visões materializadas com AWS o Glue](materialized-views.md) # Configurar propriedades de trabalho para trabalhos do Spark no AWS Glue Ao definir o trabalho no console do AWS Glue, você fornece valores às propriedades para controlar o ambiente do runtime do AWS Glue. ## Definir propriedades de trabalho para trabalhos do Spark A lista a seguir descreve as propriedades de um trabalho do Spark. Para as propriedades de um trabalho de shell do Python, consulte [Definir propriedades de trabalho para trabalhos de shell Python](add-job-python.md#create-job-python-properties). Para obter propriedades de um trabalho de ETL de streaming, consulte [Definir propriedades de trabalho para um trabalho de ETL de transmissão](add-job-streaming.md#create-job-streaming-properties). As propriedades estão listadas na ordem em que aparecem no assistente de **Add job (Adicionar trabalho)** no console do AWS Glue. **Nome** Forneça uma string UTF-8 com um tamanho máximo de 255 caracteres. **Descrição** Forneça uma descrição opcional da sua implantação com até 2048 caracteres. **Perfil do IAM** Especifique o perfil do IAM usado para a autorização de recursos necessários ​​para a execução do trabalho e acesso aos armazenamentos de dados. Para obter mais informações sobre permissões de execução de trabalho no AWS Glue, consulte [Gerenciamento de identidade e acesso do AWS Glue](security-iam.md). **Tipo** O tipo de trabalho de ETL. Ele é definido automaticamente com base no tipo das fontes de dados selecionadas. + **Spark** executa um script de ETL do Apache Spark com o comando de trabalho `glueetl`. + **Spark Streaming** executa um script de ETL de streaming do Apache Spark com o comando de trabalho `gluestreaming`. Para obter mais informações, consulte [Trabalhos de transmissão de ETL no AWS Glue](add-job-streaming.md). + **Shell do Python** executa um script do Python com o comando de trabalho `pythonshell`. Para obter mais informações, consulte [Configurar propriedades de trabalho para trabalhos de shell Python no AWS Glue](add-job-python.md). ** versão do AWS Glue** AWS GlueA versão do determina as versões do Apache Spark e do Python que estão disponíveis para o trabalho, conforme especificado na tabela a seguir. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/add-job.html) **Linguagem** O código no script de ETL define a lógica do trabalho. O script pode ser codificado em Python ou Scala. É possível escolher se o script executado pelo trabalho é gerado pelo AWS Glue ou fornecido por você. É possível fornecer o nome e o local do script no Amazon Simple Storage Service (Amazon S3). Confirme se não existe um arquivo com o mesmo nome que o diretório do script no caminho. Para saber mais sobre como escrever scripts, consulte [Guia de programação do AWS Glue](edit-script.md). **Tipo de operador** Os seguintes tipos de operadores estão disponíveis: Os recursos disponíveis nos operadores do AWS Glue são medidos em DPUs. Uma DPU é uma medida relativa do poder de processamento que consiste em uma capacidade computacional de 4 vCPUs e 16 GB de memória. + **G.025X**: ao escolher esse tipo, você também fornece um valor para **Número de operadores**. Cada operador mapeia em 0,25 DPU (2 vCPUs, 4 GB de memória) com 84 GB de disco (aproximadamente 34 GB livres). Recomendamos esse tipo de operador para trabalhos de streaming de baixo volume. Esse tipo de operador só está disponível para trabalhos de streaming do AWS Glue versão 3.0 ou posterior. + **G.1X**: ao escolher esse tipo, você também fornece um valor para **Número de operadores**. Cada operador mapeia em 1 DPU (4 vCPUs, 16 GB de memória) com 94 GB de disco (aproximadamente 44 GB livres). Recomendamos esse tipo de operador para workloads, como transformações de dados, uniões e consultas, para oferecer uma maneira escalável e econômica de executar a maioria dos trabalhos. + **G.2X**: ao escolher esse tipo, você também fornece um valor para **Número de operadores**. Cada operador mapeia em 2 DPUs (8 vCPUs, 32 GB de memória) com 138 GB de disco (aproximadamente 78 GB livres). Recomendamos esse tipo de operador para workloads, como transformações de dados, uniões e consultas, para oferecer uma maneira escalável e econômica de executar a maioria dos trabalhos. + **G.4X**: ao escolher esse tipo, você também fornece um valor para **Número de operadores**. Cada operador mapeia em 4 DPUs (16 vCPUs, 64 GB de memória) com 256 GB de disco (aproximadamente 230 GB livres). Recomendamos esse tipo de operador para trabalhos cujas workloads contêm as transformações, agregações, uniões e consultas mais exigentes. + **G.8X**: ao escolher esse tipo, você também fornece um valor para **Número de operadores**. Cada operador mapeia em 8 DPUs (32 vCPUs, 128 GB de memória) com 512 GB de disco (aproximadamente 485 GB livres). Recomendamos esse tipo de operador para trabalhos cujas workloads contêm as transformações, agregações, uniões e consultas mais exigentes. + **G.12X**: ao escolher esse tipo, você também fornece um valor para **Número de operadores**. Cada operador mapeia em 12 DPUs (48 vCPUs, 192 GB de memória) com 768 GB de disco (aproximadamente 741 GB livres). Recomendamos esse tipo de operador para trabalhos com workloads muito grandes e que consomem muitos recursos, exigindo capacidade computacional significativa. + **G.16X**: ao escolher esse tipo, você também fornece um valor para **Número de operadores**. Cada operador mapeia em 16 DPU (64 vCPUs, 256 GB de memória) com 1.024 GB de disco (aproximadamente 996 GB livres). Recomendamos esse tipo de operador para trabalhos com as workloads maiores e que mais consomem recursos e que exigem capacidade computacional máxima. + **R.1X**: ao escolher esse tipo, você também fornece um valor para **Número de operadores**. Cada operador mapeia em 1 DPU com configuração otimizada para memória. Recomendamos esse tipo de operador para workloads com uso intenso de memória que frequentemente encontram erros de falta de memória ou exigem altas taxas de memória para CPU. + **R.2X**: ao escolher esse tipo, você também fornece um valor para **Número de operadores**. Cada operador mapeia em 2 DPUs com configuração otimizada para memória. Recomendamos esse tipo de operador para workloads com uso intenso de memória que frequentemente encontram erros de falta de memória ou exigem altas taxas de memória para CPU. + **R.4X**: ao escolher esse tipo, você também fornece um valor para **Número de operadores**. Cada operador mapeia em 4 DPUs com configuração otimizada para memória. Recomendamos esse tipo de operador para cargas de trabalho grandes com uso intenso de memória que frequentemente encontram erros de falta de memória ou exigem altas taxas de memória para CPU. + **R.8X**: ao escolher esse tipo, você também fornece um valor para **Número de operadores**. Cada operador mapeia em 8 DPUs com configuração otimizada para memória. Recomendamos esse tipo de trabalhador para workloads muito grandes com uso intenso de memória que frequentemente encontram erros de falta de memória ou exigem taxas elevadas de memória-CPU. **Especificações dos tipos de operadores** A tabela a seguir fornece especificações detalhadas para todos os tipos de operadores G disponíveis: **Especificações dos tipos de operadores G** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/add-job.html) **Importante:** os tipos de operadores G.12X e G.16X, bem como todos os tipos de operadores R (R.1X a R.8X), apresentam uma latência maior durante a inicialização. É cobrada uma taxa por hora com base no número de DPUs usadas para executar os trabalhos de ETL. Para obter mais informações, consulte a [página de definição de preços do AWS Glue](https://aws.amazon.com/glue/pricing/). Com trabalhos do AWS Glue versão 1.0 ou anterior, quando você configura um trabalho usando o console e especifica um **Worker type** (Tipo de operador) como **Standard** (Padrão), a **Maximum capacity** (Capacidade máxima) é definida e o **Number of workers** (Número de operadores) torna-se o valor de **Maximum capacity** (Capacidade máxima) - 1. Se você usar a AWS Command Line Interface (AWS CLI) ou o AWS SDK, poderá especificar o parâmetro **Max capacity** (Capacidade máxima), ou especificar tanto **Worker type** (Tipo de operador) quanto **Number of workers** (Número de operadores). Para trabalhos do AWS Glue versão 2.0 ou posterior, não é possível especificar uma **capacidade máxima**. Em vez disso, você deve especificar um **Worker type** (Tipo de operador) e o **Number of workers** (Número de operadores). Os tipos de operadores **G.4X** e **G.8X** estão disponíveis apenas para trabalhos Spark ETL do AWS Glue versão 3.0 ou posteriores nas seguintes regiões da AWS: Leste dos EUA (Ohio), Leste dos EUA (Norte da Virgínia), Oeste dos EUA (N. da Califórnia), Oeste dos EUA (Oregon), Ásia-Pacífico (Mumbai), Ásia-Pacífico (Seul), Ásia-Pacífico (Singapura), Ásia-Pacífico (Sydney), Ásia-Pacífico (Tóquio), Canadá (Central), Europa (Frankfurt), Europa (Irlanda), Europa (Londres), Europa (Espanha), Europa (Estocolmo) e América do Sul (São Paulo). Os tipos de operador **G.12X**, **G.16X**, e **R.1X** até **R.8X** estão disponíveis apenas para trabalhos de ETL Spark no AWS Glue versão 4.0 ou posterior nas seguintes regiões da AWS: Leste dos EUA (Norte da Virginia), Oeste dos EUA (Oregon), Leste dos EUA (Ohio), Europa (Irlanda) e Europa (Frankfurt). Haverá suporte a regiões adicionais em versões futuras. **O número solicitado de operadores** Para a maioria dos tipos de trabalho, é necessário especificar o número de operadores alocados quando o trabalho é executado. **Marcador de trabalho** Especifique como o AWS Glue processa essas informações de estado quando o trabalho é executado. É possível lembrar de dados previamente processados, atualizar informações de estado ou ignorar informações de estado. Para obter mais informações, consulte [Rastrear dados processados usando marcadores de trabalho](monitor-continuations.md). **Enfileiramento da execução de trabalhos** Especifica se as execuções de trabalhos foram colocadas na fila para execução posterior quando elas não podem ser executadas imediatamente devido às cotas de serviço. Quando marcada, o enfileiramento da execução de trabalhos é habilitado para as execuções de trabalhos. Se não for preenchida, as execuções do trabalho não serão consideradas para enfileiramento. Se essa configuração não corresponder ao valor definido na execução do trabalho, o valor do campo de execução do trabalho será usado. **Execução flexível** Quando você configura um trabalho usando o AWS Studio ou a API, é possível especificar uma classe de execução padrão ou flexível de trabalho. Seus trabalhos podem ter graus diversos de prioridade e sensibilidade ao tempo. A classe de execução padrão é ideal para workloads sensíveis ao tempo que exigem a inicialização rápida de trabalhos e recursos dedicados. A classe de execução flexível é adequada para trabalhos não urgentes, como trabalhos de pré-produção, testes e cargas de dados únicas. Execuções flexíveis de trabalho são compatíveis com trabalhos que usem o AWS Glue versão 3.0 ou posterior e os tipos de operador `G.1X` ou `G.2X`. Os novos tipos de operadores (`G.12X`, `G.16X`, e `R.1X` até `R.8X`) não oferecem suporte a execução flexível. [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/FnHCoTuDLXU/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/FnHCoTuDLXU) As execuções flexíveis de trabalho são cobradas com base no número de operadores em execução a qualquer momento. É possível adicionar ou remover o número de operadores para uma execução flexível de trabalho que esteja em andamento. Em vez de cobrar como um simples cálculo de `Max Capacity` \$1 `Execution Time`, cada operador contribuirá pelo tempo durante o qual foi executado na execução do trabalho. A conta é a soma de (`Number of DPUs per worker` \$1 `time each worker ran`). Para obter mais informações, consulte o painel de ajuda no AWS Studio ou [Tarefas](aws-glue-api-jobs-job.md) e [Execuções de trabalhos](aws-glue-api-jobs-runs.md). **Número de novas tentativas** Especifique o número de vezes, de 0 a 10, que o AWS Glue deve reiniciar automaticamente o trabalho em caso de falha. Os trabalhos que atingem o limite de tempo não são reiniciados. **Tempo limite de trabalho** Define o tempo máximo de execução em minutos. A configuração máxima é de 7 dias ou 10.080 minutos. Caso contrário, os trabalhos gerarão uma exceção. Quando o valor é deixado em branco, o tempo limite padrão é de 2.880 minutos. Quaisquer trabalhos do AWS Glue existentes que tinham um valor de tempo limite maior que 7 dias serão padronizados para 7 dias. Por exemplo, se você especificou um tempo limite de 20 dias para um trabalho em lote, ele será interrompido no 7º dia. **Práticas recomendadas para tempos limite de trabalhos** Os trabalhos são cobrados com base no tempo de execução. Para evitar cobranças inesperadas, configure valores de tempo limite apropriados para o tempo de execução esperado do seu trabalho. **Propriedades avançadas** **Nome do arquivo de script** Um nome de script exclusivo para seu trabalho. Não pode ser nomeado **Trabalho sem título**. **Caminho do script** A localização do Amazon S3 do script. O caminho deve estar no formato `s3://bucket/prefix/path/`. Ele deve terminar com uma barra (`/`) e não incluir arquivos. **Métricas de trabalho** Ative ou desative a criação de métricas do Amazon CloudWatch quando esse trabalho for executado. Para ver os dados de criação de perfil, você deve habilitar essa opção. Para obter mais informações sobre como ativar e visualizar as métricas, consulte [Monitoramento e depuração de trabalho](monitor-profile-glue-job-cloudwatch-metrics.md). **Métricas de observabilidade do trabalho** Ative ou desative a criação de métricas de observabilidade do CloudWatch quando esse trabalho for executado. Para obter mais informações, consulte [Monitoramento com métricas de observabilidade do AWS Glue](monitor-observability.md). **Registro em log contínuo** Ative o registro em log contínuo no Amazon CloudWatch. Se esta opção não estiver habilitada, os logs estarão disponíveis somente após o trabalho ser concluído. Para obter mais informações, consulte [Registro em log para trabalhos do AWS Glue](monitor-continuous-logging.md). **IU do Spark** Ative o uso da interface do usuário do Spark para monitorar esse trabalho. Para obter mais informações, consulte [Habilitar a interface do usuário da Web do Apache Spark para trabalhos do AWS Glue](monitor-spark-ui-jobs.md). **Caminho dos logs da interface do usuário do Spark** O caminho para gravar logs quando a interface do usuário do Spark está habilitada. **Configuração de log e monitoramento da interface do usuário do Spark** Escolha uma das seguintes opções: + *Padrão*: grave logs usando o ID de execução do trabalho do AWS Glue como nome do arquivo. Ative o monitoramento da interface do usuário do Spark no console do AWS Glue. + *Legado*: grave logs usando "spark-application- \$1timestamp\$1" como nome do arquivo. Não ative o monitoramento da interface do usuário do Spark. + *Padrão e legado*: grave logs nos locais padrão e legados. Ative o monitoramento da interface do usuário do Spark no console do AWS Glue. **Simultaneidade máxima** Define o número máximo de execuções simultâneas permitidas para o trabalho. O padrão é 1. Um erro será retornado quando este limite for atingido. O valor máximo que pode ser especificado é controlado por um limite de serviço. Por exemplo, se a execução anterior de um trabalho ainda estiver sendo realizada quando uma nova instância for iniciada, convém retornar um erro para evitar que duas instâncias do mesmo trabalho sejam executadas simultaneamente. **Caminho temporário** Informe o local de um diretório de trabalho no Amazon S3 onde os resultados intermediários temporários serão gravados quando o AWS Glue executar o script. Confirme se não existe um arquivo com o mesmo nome que o diretório temporário no caminho. Esse diretório é usado quando o AWS Glue lê e grava no Amazon Redshift e por determinadas transformações do AWS Glue. AWS GlueO criará um bucket temporário para trabalhos se um bucket ainda não existir em uma região. Esse bucket pode permitir o acesso público. É possível modificar o bucket no Amazon S3 para definir o bloco de acesso público ou excluir o bucket mais tarde, depois que todos os trabalhos nessa região forem concluídos. **Limite de notificação de atraso (minutos)** Define o valor mínimo (em minutos) antes que uma notificação de atraso seja enviada. É possível definir esse limite para enviar notificações quando uma execução de trabalho `RUNNING`, `STARTING` ou `STOPPING` levar mais do que o número de minutos esperado. **Configuração de segurança** Escolha uma configuração de segurança na lista. Uma configuração de segurança especifica como os dados no destino do Amazon S3 são criptografados: sem criptografia, criptografia no lado do servidor com chaves gerenciadas pelo AWS KMS (SSE-KMS) ou chaves de criptografia gerenciadas pelo Amazon S3 (SSE-S3). **Criptografia do lado do servidor** Se você selecionar essa opção, quando o trabalho de ETL gravar no Amazon S3, os dados serão criptografados em repouso usando criptografia SSE-S3. Tanto o seu destino de dados do Amazon S3 quanto outros dados gravados em um diretório temporário do Amazon S3 serão criptografados. Essa opção é passada como um parâmetro de trabalho. Para obter mais informações, consulte [Proteção de dados usando criptografia no lado do servidor com chaves de criptografia gerenciadas pelo Amazon S3 (SSE-S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html) no *Manual do usuário do Amazon Simple Storage Service*. Esta opção será ignorada se uma configuração de segurança for especificada. **Usar o catálogo de dados do Glue como metastore do Hive** Selecione para usar o AWS Glue Data Catalog como a metastore do Hive. O perfil do IAM usado para o trabalho deve ter a permissão `glue:CreateDatabase`. Um banco de dados chamado “default” (padrão) é criado no Data Catalog, caso não exista. **Conexões** Escolha uma configuração de VPC para acessar fontes de dados do Amazon S3 localizadas na sua nuvem privada virtual (VPC). É possível criar e gerenciar a conexão de rede no AWS Glue. Para obter mais informações, consulte [Conectar a dados](glue-connections.md). **Bibliotecas** **Caminho da biblioteca Python, caminho dos JARs dependentes e caminho de arquivos referenciados** Especifique essas opções se o script precisar. É possível definir os caminhos do Amazon S3 separados por vírgulas para essas opções ao definir o trabalho. É possível substituir esses caminhos ao executar o trabalho. Para obter mais informações, consulte [Fornecer seus próprios scripts personalizados](console-custom-created.md). **Parâmetros de trabalho** Um conjunto de pares de valor-chave que são transmitidos ​​como parâmetros nomeados para o script. Esses são valores padrão que são usados quando o script é executado, mas é possível substituí-los em trigger ou ao executar o trabalho. É necessário iniciar o nome da chave com `--`; por exemplo: `--myKey`. Passe os parâmetros do trabalho como um mapa ao usar a AWS Command Line Interface. Para ver exemplos, consulte os parâmetros Python em [Transmitir e acessar parâmetros de Python no AWS Glue](aws-glue-programming-python-calling.md#aws-glue-programming-python-calling-parameters). **Tags** Marque o trabalho com uma **Tag key (Chave de tag)** e um **Tag value (Valor de tag)** opcional. Depois que as chaves de tags são criadas, elas são somente leitura. Use as tags em alguns recursos para ajudar a organizá-los e identificá-los. Para obter mais informações, consulte [Etiquetas da AWS no AWS Glue](monitor-tags.md). ## Restrições para trabalhos que acessam tabelas gerenciadas pelo Lake Formation Tenha em mente as seguintes observações e restrições ao criar trabalhos que leiam ou gravem em tabelas gerenciadas pelo AWS Lake Formation: + Não há suporte para os seguintes recursos em trabalhos que acessem tabelas com filtros no nível da célula: + [Marcadores de trabalhos](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html) e [execução limitada](https://docs.aws.amazon.com/glue/latest/dg/bounded-execution.html) + [Aplicação de predicados](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-pushdowns) + [Predicados de partição de catálogo do lado do servidor](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-cat-predicates) + [enableUpdateCatalog](https://docs.aws.amazon.com/glue/latest/dg/update-from-job.html) # Editar scripts do Spark no console do AWS Glue Um script contém o código que extrai os dados das fontes, os transforma e os carrega nos destinos. O AWS Glue executa um script quando inicia um trabalho. AWS GlueOs scripts de ETL do podem ser codificados em Python ou Scala. Os scripts Python usam uma linguagem que é a uma extensão do dialeto PySpark Python para trabalhos de extração, transformação e carregamento (ETL). O script contém *construtores estendidos* para lidar com transformações de ETL. Quando você gera automaticamente a lógica do código fonte para um trabalho, o script é criado. Você pode editar este script ou fornecer seu próprio script para processar seu trabalho de ETL. Para obter informações sobre como definir e editar scripts usando no AWS Glue, consulte [Guia de programação do AWS Glue](edit-script.md). ## Bibliotecas ou arquivos adicionais Se seu script precisar de bibliotecas ou arquivos adicionais, você poderá especificá-los da seguinte forma: **Caminho da biblioteca Python** Caminhos do Amazon Simple Storage Service (Amazon S3) separados por vírgulas para bibliotecas Python exigidas pelo script. Somente bibliotecas Python puras podem ser usadas. Bibliotecas que contam com extensões C, como a biblioteca de análise de dados Python pandas, ainda não são compatíveis. **Caminho de arquivos JAR dependentes** Caminhos do Amazon S3 separados por vírgulas para arquivos JAR exigidos pelo script. Atualmente, apenas bibliotecas Java ou Scala (2.11) podem ser usadas. **Caminho de arquivos referenciados** Caminhos do Amazon S3 separados por vírgula para arquivos adicionais (por exemplo, arquivos de configuração) exigidos pelo script. # Trabalhos (herdados) Um script contém o código que executa o trabalho de extração, transformação e carregamento (ETL). Você pode fornecer seu próprio script, ou o AWS Glue pode gerar um script com a sua orientação sua. Para obter informações sobre como criar seus próprios scripts, consulte [Fornecer seus próprios scripts personalizados](console-custom-created.md). Você pode editar um script no console do AWS Glue. Ao editar um script, você pode adicionar fontes, destinos e transformações. **Para editar um script** 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/). Em seguida, escolha a guia **Jobs**. 1. Selecione um trabalho na lista e escolha **Action**, **Edit script** para abrir o editor de scripts. Você também pode acessar o editor de scripts na página de detalhes do trabalho. Escolha a guia **Script** e, em seguida, **Edit script** (Editar script). ## Editor de scripts O editor de scripts do AWS Glue permite inserir, modificar e excluir fontes, destinos e transformações no seu script. O editor de scripts exibe o script e um diagrama para ajudar você a visualizar o fluxo de dados. Para criar um diagrama para o script, escolha **Generate diagram (Gerar diagrama)**. O AWS Glue usa linhas de anotação no script que começam com **\$1\$1** para renderizar o diagrama. Para representar corretamente seu script no diagrama, você precisa manter em sincronia os parâmetros nas anotações e os parâmetros no código Apache Spark. O editor de scripts permite que você adicione modelos de código sempre que o cursor estiver posicionado no script. Na parte superior do editor, escolha as seguintes opções: + Para adicionar uma tabela de origem ao script, escolha **Source**. + Para adicionar uma tabela de destino ao script, escolha **Target**. + Para adicionar um local de destino ao script, escolha **Target location**. + Para adicionar uma transformação ao script, escolha **Transform**. Para obter informações sobre as funções que são chamadas no seu script, consulte [Programar scripts de ETL do AWS Glue em PySpark](aws-glue-programming-python.md). + Para adicionar uma transformação Spigot ao script, escolha **Spigot**. No código inserido, modifique o `parameters` nas anotações e no código Apache Spark. Por exemplo, se você adicionar uma transformação **Spigot**, verifique se `path` foi substituído na linha de anotação `@args` e na linha de código `output`. A guia **Logs** mostra os logs associados ao seu trabalho à medida que ele é executado. As mil linhas mais recentes são exibidas. A guia **Schema** (Esquema) mostra o esquema das fontes e dos destinos selecionados, quando disponíveis no Data Catalog. # Rastrear dados processados usando marcadores de trabalho O AWS Glue rastreia os dados que já foram processados durante uma execução anterior de um trabalho de ETL persistindo as informações do estado do trabalho executado. Essa informação de estado persistente é chamada de *marcador de trabalho*. Os marcadores do trabalho ajudam o AWS Glue a manter as informações de estado e a impedir o reprocessamento de dados antigos. Com marcadores de trabalho, você pode processar novos dados ao executar novamente em um intervalo programado. Um marcador de trabalho é composto pelos estados de vários elementos de trabalho, como fontes, transformações e destinos. Por exemplo, seu trabalho de ETL pode ler novas partições em um arquivo do Amazon S3. O AWS Glue rastreia as partições que o trabalho processou com êxito para evitar processamento e dados duplicados no armazenamento de dados de destino do trabalho. Os marcadores de trabalho são implantados para fontes de dados JDBC, a transformação Relationalize e algumas fontes do Amazon Simple Storage Service (Amazon S3). A tabela a seguir lista os formatos de fonte do Amazon S3 aos quais o AWS Glue oferece suporte para marcadores de trabalho. | Versão do AWS Glue | Formatos de fonte do Amazon S3 | | --- | --- | | Versão 0.9 | JSON, CSV, Apache Avro, XML | | Versão 1.0 e posterior | JSON, CSV, Apache Avro, XML, Parquet, ORC | Para obter mais informações sobre as versões do AWS Glue, consulte [Definir propriedades de trabalho para trabalhos do Spark](add-job.md#create-job). O atributo de marcadores de trabalhos tem funcionalidades adicionais quando acessado por meio de scripts do AWS Glue. Ao navegar pelo script gerado, você pode ver contextos de transformação relacionados a esse atributo. Para obter mais informações, consulte [Usar marcadores de trabalho](programming-etl-connect-bookmarks.md). **Topics** + [Usar marcadores de trabalho no AWS Glue](#monitor-continuations-implement) + [Detalhes operacionais do atributo de marcadores de trabalho](#monitor-continuations-script) ## Usar marcadores de trabalho no AWS Glue A opção de marcador de trabalho é passada como um parâmetro quando o trabalho é iniciado. A tabela a seguir descreve as opções para configuração de marcadores de trabalho no console do AWS Glue. **** | Marcador de trabalho | Descrição | | --- | --- | | Enable (Habilitar) | Faz com que o trabalho atualize o estado após uma execução para controlar os dados processados anteriormente. Se seu trabalho tiver uma origem com suporte para marcador de trabalho, ele irá controlar os dados processados e, quando um trabalho for executado, processará novos dados desde o último ponto de verificação. | | Disable (Desabilitar) | Os marcadores de trabalho não são usados, e o trabalho sempre processa todo o conjunto de dados. Você é responsável por gerenciar o resultado das execuções de trabalho anteriores. Esse é o padrão. | | Pause | Processe dados incrementais desde a última execução bem-sucedida ou os dados no intervalo identificados pelas seguintes subopções, sem atualizar o estado do último marcador. Você é responsável por gerenciar o resultado das execuções de trabalho anteriores. As duas subopções são: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitor-continuations.html) O estado do marcador de trabalho não será atualizado quando esse conjunto de opções for especificado. As subopções são opcionais. No entanto, quando usadas, é necessário fornecer as duas subopções. | Para obter detalhes sobre os parâmetros passados para um trabalho na linha de comando, e especificamente para marcadores de trabalho, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md). Para fontes de entrada do Amazon S3, os marcadores de trabalho do AWS Glue conferem a hora da última modificação dos objetos para verificar quais objetos precisam ser reprocessados. Se os dados da fonte de entrada tiverem sido modificados desde a última execução do trabalho, os arquivos serão reprocessados quando você executar o trabalho novamente. Para fontes JDBC, as seguintes regras se aplicam: + Para cada tabela, o AWS Glue usa uma ou mais colunas como chaves de marcadores para determinar dados novos e processados. As chaves de marcadores combinam-se para formar uma única chave composta. + Por padrão, o AWS Glue usará a chave primária como chave de marcadores, desde que ela esteja aumentando ou diminuindo sequencialmente (sem lacunas). + Você pode especificar as colunas a serem usadas como chaves de marcadores no seu script do AWS Glue. Para obter mais informações sobre como usar marcadores de trabalhos em scripts do AWS Glue, consulte [Usar marcadores de trabalho](programming-etl-connect-bookmarks.md). + O AWS Glue não oferece suporte ao uso de colunas com nomes que diferenciam maiúsculas e minúsculas como chaves de marcadores de trabalho. É possível retroceder seus marcadores de trabalho de ETL do Spark do AWS Glue para qualquer execução de trabalho anterior. É possível oferecer melhor suporte a cenários de preenchimento ao retroceder os marcadores de trabalho para qualquer execução de trabalho anterior, resultando no reprocessamento de dados subsequente de execução de trabalho somente a partir da execução do trabalho marcado. Para reprocessar todos os dados usando o mesmo trabalho, redefina o marcador do trabalho. Para redefinir o estado do marcador de trabalho, use o console do AWS Glue, a [Ação ResetJobBookmark (Python: reset\$1job\$1bookmark)](aws-glue-api-jobs-runs.md#aws-glue-api-jobs-runs-ResetJobBookmark) operação da API ou a AWS CLI. Por exemplo, digite o comando a seguir usando a AWS CLI: ``` aws glue reset-job-bookmark --job-name my-job-name ``` Quando você retrocede ou redefine um marcador, o AWS Glue não limpa os arquivos de destino porque pode haver vários destinos e eles não são rastreados com marcadores de trabalho. Somente os arquivos de fontes são rastreados com marcadores de trabalho. Você pode criar diferentes destinos de saída ao retroceder e reprocessar os arquivos de fontes para evitar dados duplicados em sua saída. O AWS Glue monitora os marcadores de trabalho por trabalho. Se você excluir um trabalho, o marcador dele será excluído. Em alguns casos, você pode ter habilitado marcadores de trabalho do AWS Glue, mas o trabalho de ETL está reprocessando dados que já foram processados em uma execução anterior. Para obter informações sobre como resolver as causas comuns desse erro, consulte [Solução de problemas causados por erros comuns na configuração do Glue](glue-troubleshooting-errors.md). ## Detalhes operacionais do atributo de marcadores de trabalho Esta seção descreve mais detalhes operacionais sobre o uso de marcadores de trabalho. Os marcadores de trabalho armazenam os estados de um trabalho. Cada instância do estado é codificada por um nome e um número de versão do trabalho. Quando um script invoca `job.init`, ele recupera seu estado e sempre obtém a versão mais recente. Em um estado, há vários elementos de estado, que são específicos a cada origem, transformação e instância coletora no script. Esses elementos de estado são identificados por um contexto de transformação que é anexado ao elemento correspondente (origem, transformação ou coletor) no script. Os elementos do estado são salvos automaticamente quando `job.commit` é invocado no script do usuário. O script obtém o nome do trabalho e a opção de controle dos marcadores do trabalho nos argumentos. Os elementos do estado no marcador do trabalho são origem, transformação ou dados específicos ao coletor. Por exemplo, suponha que você queira ler dados incrementais em um local do Amazon S3 que está sendo gravado constantemente por um trabalho ou processo upstream. Nesse caso, o script deve determinar o que foi processado até o momento. A implantação do marcador de trabalho para a fonte do Amazon S3 salva informações para que, quando o trabalho for executado novamente, ele possa filtrar somente os novos objetos usando as informações salvas e recalcular o estado para a próxima execução do trabalho. Um time stamp é usado para filtrar os novos arquivos. Além dos elementos de estado, os marcadores de trabalho têm um *número de execuções*, um *número de tentativas* e um *número de versão*. O número de execução rastreia a execução do trabalho, e o número de tentativas registra as tentativas de uma execução de trabalho. O número de execuções do trabalho é um número incrementado de forma monotônica para cada execução bem-sucedida. O número de tentativas rastreia as tentativas de cada execução e só é incrementado quando há uma execução após uma tentativa com falha. O número da versão aumenta de forma monotônica e rastreia as atualizações em um marcador de trabalho. No banco de dados do serviço AWS Glue, os estados de marcador para todas as transformações são armazenados juntos como pares de chave-valor: ``` { "job_name" : ..., "run_id": ..., "run_number": .., "attempt_number": ... "states": { "transformation_ctx1" : { bookmark_state1 }, "transformation_ctx2" : { bookmark_state2 } } } ``` **Práticas recomendadas** Veja a seguir as práticas recomendadas para usar marcadores de trabalhos. + *Não altere a propriedade origem dos dados com o marcador habilitado*. Por exemplo, há um datasource0 apontando para um caminho de entrada A do Amazon S3, e o trabalho está lendo uma fonte que está sendo executada há várias rodadas com o marcador habilitado. Se você alterar o caminho de entrada de datasource0 para o caminho B do Amazon S3 sem alterar `transformation_ctx`, o trabalho do AWS Glue usará o antigo estado de marcador armazenado. Isso resultará em arquivos ausentes ou ignorados no caminho de entrada B, já que o AWS Glue presumiria que esses arquivos foram processados em execuções anteriores. + *Use uma tabela de catálogo com marcadores para um melhor gerenciamento de partições*. Os marcadores funcionam tanto para origens de dados do Data Catalog quanto para origens de dados das opções. No entanto, é difícil remover/adicionar novas partições com a abordagem de opções. Usar uma tabela de catálogo com crawlers pode fornecer melhor automação para rastrear as [partições](https://docs.aws.amazon.com/glue/latest/dg/tables-described.html#tables-partition) recém-adicionadas e proporcionar a flexibilidade para selecionar partições específicas com um [predicado de aplicação](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html). + *Use o [compilador de listas de arquivos para Amazon S3 do AWS Glue](https://aws.amazon.com/premiumsupport/knowledge-center/glue-oom-java-heap-space-error/) para conjuntos de dados grandes*. Um marcador listará todos os arquivos em cada partição de entrada e fará o arquivamento. Logo, se houver muitos arquivos em uma só partição, o marcador poderá entrar no driver OOM. Use o compilador de listas de arquivos para Amazon S3 do AWS Glue a fim de evitar listar todos os arquivos na memória de uma só vez. # Armazenamento de dados embaralhados do Spark A colocação em ordem aleatória é uma etapa importante em um trabalho do Spark sempre que os dados são reorganizados entre partições. Isso é necessário porque transformações amplas, como `join`, ` groupByKey`, `reduceByKey` e `repartition`, exigem informações de outras partições para concluir o processamento. O Spark reúne os dados necessários de cada partição e os combina em uma nova partição. Durante uma geração de ordem aleatória, os dados são gravados no disco e transferidos pela rede. Como resultado, a operação de ordem aleatória está vinculada à capacidade do disco local. O Spark lança os erros `No space left on device` ou ` MetadataFetchFailedException` quando não há espaço em disco suficiente no executor e não há recuperação. **nota** O plugin AWS Glue Spark shuffle com Amazon S3 só é compatível com trabalhos de ETL do AWS Glue. **Solução** Com o AWS Glue, você pode usar o Amazon S3 para armazenar dados em ordem aleatória do Spark. O Amazon S3 é um serviço de armazenamento de objetos que oferece escalabilidade, disponibilidade de dados, segurança e performance líderes do setor. Essa solução desagrega computação e armazenamento de seus trabalhos do Spark e oferece elasticidade completa e armazenamento em ordem aleatória de baixo custo, permitindo que você execute suas workloads mais intensas em ordem aleatória de forma confiável. ![\[Spark workflow showing Map and Reduce stages using Amazon S3 for shuffle data storage.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/gs-s3-shuffle-diagram.png) Estamos apresentando um novo Cloud Shuffle Storage Plugin for Apache Spark para usar o Amazon S3. Você pode ativar a ordem aleatória do Amazon S3 para executar trabalhos do AWS Glue de forma confiável e sem falhas, caso eles estejam vinculados à capacidade do disco local para grandes operações de ordem aleatória. Em alguns casos, a ordem aleatória para o Amazon S3 é ligeiramente mais lenta do que o disco local (ou EBS), se você tiver um grande número de partições pequenas ou arquivos gravados em ordem aleatória no Amazon S3. ## Pré-requisitos para usar o plug-in Cloud Shuffle Storage Para usar o plug-in Cloud Shuffle Storage com trabalhos de ETL do AWS Glue, você precisa do seguinte: + Um bucket do Amazon S3 localizado na mesma região em que seu trabalho é executado, para armazenar dados intermediários embaralhados e vazados. O prefixo de armazenamento embaralhado do Amazon S3 pode ser especificado com o `--conf spark.shuffle.glue.s3ShuffleBucket=s3://shuffle-bucket/prefix/`, como no exemplo a seguir: ``` --conf spark.shuffle.glue.s3ShuffleBucket=s3://glue-shuffle-123456789-us-east-1/glue-shuffle-data/ ``` + Defina as políticas de ciclo de vida de armazenamento do Amazon S3 no *prefixo* (como `glue-shuffle-data`), pois o gerenciador de ordem aleatória não limpa os arquivos após a conclusão do trabalho. O embaralhamento intermediário e os dados vazados devem ser excluídos após a conclusão do trabalho. Os usuários podem definir políticas de ciclo de vida curto no prefixo. Instruções para definir política do ciclo de vida do Amazon S3 estão disponíveis em [Definir a configuração do ciclo de vida em um bucket](https://docs.aws.amazon.com//AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) no Guia do usuário do Amazon Simple Storage Service. ## Usar o gerenciador de ordem aleatória do Spark no AWS Glue no Console da AWS Para configurar o gerenciador de ordem aleatória do Spark no AWS Glue usando o console do AWS Glue ou o AWS Glue Studio ao configurar um trabalho: escolha o parâmetro de trabalho **–write-shuffle-files-to-s3** para ativar a ordem aleatória do Amazon S3 para o trabalho. ![\[Job parameters interface showing --write-shuffle-files- parameter and option to add more.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/gs-s3-shuffle.png) ## Usar o plug-in de ordem aleatória do AWS Glue Spark Os seguintes parâmetros de trabalho ativam e ajustam o gerenciador de ordem aleatória no AWS Glue. Esses parâmetros são sinalizadores, portanto, qualquer valor fornecido não será considerado. + `--write-shuffle-files-to-s3`: o sinalizador principal que habilita o gerenciador de ordem aleatória do AWS Glue Spark para usar buckets do Amazon S3 a fim de gravar e ler dados em ordem aleatória. Quando o sinalizador não é especificado, o gerenciador de ordem aleatória não é usado. + `--write-shuffle-spills-to-s3` - (compatível apenas com o AWS Glue versão 2.0). Um sinalizador opcional que permite que você descarregue arquivos de despejo em buckets do Amazon S3, o que fornece resiliência adicional ao seu trabalho do Spark. Isso só é necessário para grandes workloads que despejam muitos dados no disco. Quando o sinalizador não é especificado, nenhum arquivo de vazamento intermediário é gravado. + ` --conf spark.shuffle.glue.s3ShuffleBucket=s3://`: outro sinalizador opcional que especifica o bucket do Amazon S3 onde você grava os arquivos em ordem aleatória. Por padrão, `--TempDir`/shuffle-data. O AWS Glue 3.0\$1 suporta a gravação aleatória de arquivos em vários buckets especificando compartimentos com delimitador de vírgula, como em `--conf spark.shuffle.glue.s3ShuffleBucket=s3://shuffle-bucket-1/prefix,s3://shuffle-bucket-2/prefix/`. O uso de vários buckets melhora a performance. É necessário fornecer configurações de segurança para habilitar a criptografia em repouso para os dados em ordem aleatória. Para obter mais informações sobre as configurações de segurança, consulte [Configurar criptografia no AWS Glue](set-up-encryption.md). O AWS Glue oferece suporte a todas as outras configurações relacionadas a ordem aleatória fornecidas pelo Spark. **Binários de software para o Cloud Shuffle Storage Plugin** Você também pode baixar os binários de software Cloud Shuffle Storage Plugin for Apache Spark sob a licença do Apache 2.0 e executá-lo em qualquer ambiente do Spark. O novo plug-in vem com suporte pronto para uso para o Amazon S3 e também pode ser facilmente configurado para usar outras formas de armazenamento em nuvem, como o [Google Cloud Storage e o Microsoft Azure Blob Storage](https://github.com/aws-samples/aws-glue-samples/blob/master/docs/cloud-shuffle-plugin/README.md). Para obter mais informações, consulte [Cloud Shuffle Storage Plugin for Apache Spark](https://docs.aws.amazon.com/glue/latest/dg/cloud-shuffle-storage-plugin.html). **Observações e limitações** As seguintes são observações ou limitações sobre o gerenciador de ordem aleatória no AWS Glue: + O AWS Glue shuffle manager não exclui automaticamente os arquivos de dados aleatórios (temporários) armazenados em seu bucket do Amazon S3 após a conclusão de um trabalho. Para garantir a proteção dos dados, siga as instruções no [Pré-requisitos para usar o plug-in Cloud Shuffle Storage](#monitor-spark-shuffle-manager-prereqs) antes de ativar o plugin de Cloud Shuffle Storage. + Você pode usar esse recurso se seus dados estiverem distorcidos. # Cloud Shuffle Storage Plugin for Apache Spark O Cloud Shuffle Storage Plugin é um plug-in do Apache Spark compatível com a [API `ShuffleDataIO`](https://github.com/apache/spark/blob/master/core/src/main/java/org/apache/spark/shuffle/api/ShuffleDataIO.java) que permite armazenar dados em ordem aleatória nos sistemas de armazenamento em nuvem (como o Amazon S3). Ele ajuda você a complementar ou substituir a capacidade de armazenamento em disco local para grandes operações de ordem aleatória, como `join`, `reduceByKey`, `groupByKey` e `repartition`, nas aplicações do Spark, reduzindo assim as falhas comuns ou a depreciação de preço/performance dos dados de tecnologia sem servidor em trabalhos de analytics e pipelines. **AWS Glue** As versões 3.0 e 4.0 do AWS Glue vêm com o plug-in pré-instalado e pronto para habilitar ordem aleatória para o Amazon S3 sem nenhuma etapa adicional. Para obter mais informações, consulte [Gerenciador de ordem aleatória do Spark no AWS Glue com o Amazon S3](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-shuffle-manager.html) para ativar o recurso para as aplicações do Spark. **Outros ambientes do Spark** O plug-in exige que as seguintes configurações do Spark sejam definidas em outros ambientes do Spark: + `--conf spark.shuffle.sort.io.plugin.class=com.amazonaws.spark.shuffle.io.cloud.ChopperPlugin`: isso informa ao Spark que deve usar esse plug-in para E/S de ordem aleatória. + `--conf spark.shuffle.storage.path=s3://bucket-name/shuffle-file-dir`: o caminho no qual os arquivos de ordem aleatória serão armazenados. **nota** O plug-in sobrescreve a classe principal do Spark. Como resultado, o jar do plugin precisa ser carregado antes dos jars do Spark. Você pode fazer isso usando `userClassPathFirst` em ambientes YARN locais se o plug-in for usado fora do AWS Glue. ## Empacotar o plug-in com aplicações do Spark Você pode empacotar o plug-in com aplicações do Spark e distribuições do Spark (versões 3.1 e superiores) adicionando a dependência do plug-in no `pom.xml` do Maven enquanto desenvolve as aplicações do Spark localmente. Para obter mais informações sobre versões do Spark, consulte [Versões do plug-in](#cloud-shuffle-storage-plugin-versions). ``` ... aws-glue-etl-artifacts https://aws-glue-etl-artifacts.s3.amazonaws.com/release/ ... com.amazonaws chopper-plugin 3.1-amzn-LATEST ``` Ou então, você pode baixar os binários diretamente dos artefatos doAWS Glue Maven e incluí-los na aplicação do Spark como se segue. ``` #!/bin/bash sudo wget -v https://aws-glue-etl-artifacts.s3.amazonaws.com/release/com/amazonaws/chopper-plugin/3.1-amzn-LATEST/chopper-plugin-3.1-amzn-LATEST.jar -P /usr/lib/spark/jars/ ``` Exemplo de spark-submit ``` spark-submit --deploy-mode cluster \ --conf spark.shuffle.storage.s3.path=s3:/// \ --conf spark.driver.extraClassPath= \ --conf spark.executor.extraClassPath= \ --class s3:/// \ ``` ## Configurações opcionais Estas são as configurações opcionais que controlam o comportamento de ordem aleatória do Amazon S3. + `spark.shuffle.storage.s3.enableServerSideEncryption`: habilite/desabilite o S3 SSE para arquivos de ordem aleatória e despejo. O valor padrão é `true`. + `spark.shuffle.storage.s3.serverSideEncryption.algorithm`: o algoritmo de hash a ser usado. O valor padrão é `AES256`. + `spark.shuffle.storage.s3.serverSideEncryption.kms.key`: o ARN da chave do KMS quando o SSE aws:kms está habilitado. Junto com essas configurações, talvez seja necessário definir configurações como `spark.hadoop.fs.s3.enableServerSideEncryption` e **outras configurações específicas do ambiente** para garantir que a criptografia apropriada seja aplicada ao seu caso de uso. ## Versões do plug-in Esse plug-in é compatível com as versões do Spark associadas a cada versão do AWS Glue. A tabela a seguir mostra a versão do AWS Glue, a versão do Spark e a versão do plug-in associada, com o local do Amazon S3 para o binário de software do plug-in. | Versão do AWS Glue | Versão do Spark | Versão do plug-in | Local do Amazon S3 | | --- | --- | --- | --- | | 3.0 | 3.1 | 3.1-amzn-LATEST | s3://aws-glue-etl-artifacts/release/com/amazonaws/chopper-plugin/3.1-amzn-0/chopper-plugin-3.1-amzn-LATEST.jar | | 4.0 | 3.3 | 3.3-amzn-LATEST | s3://aws-glue-etl-artifacts/release/com/amazonaws/chopper-plugin/3.3-amzn-0/chopper-plugin-3.3-amzn-LATEST.jar | ## Licença O binário do software para este plugin é licenciado sob a Licença do Apache-2.0. # Monitorar trabalhos Spark do AWS Glue **Topics** + [Métricas do Spark disponíveis no AWS Glue Studio](#console-jobs-details-metrics-spark) + [Monitorar trabalhos usando a interface do usuário da Web do Apache Spark](monitor-spark-ui.md) + [Monitoramento com insights de execuções de trabalho do AWS Glue](monitor-job-insights.md) + [Monitorar o com o Amazon CloudWatch](monitor-cloudwatch.md) + [Monitoramento e depuração de trabalho](monitor-profile-glue-job-cloudwatch-metrics.md) ## Métricas do Spark disponíveis no AWS Glue Studio A guia **Metrics** (Métricas) mostra métricas coletadas quando um trabalho é executado e a criação de perfil está ativada. Os seguintes gráficos são exibidos em trabalhos do Spark: + Movimentação de dados ETL + Perfil de memória: driver e executores Escolha **View additional metrics (Ver métricas adicionais)** para mostrar os gráficos a seguir: + Movimentação de dados ETL + Perfil de memória: driver e executores + Embaralhamento de dados em executores + Carga da CPU: driver e executores + Execução de trabalho: executores ativos, estágios concluídos e executores máximos necessários Os dados para esses gráficos serão enviados para as métricas do CloudWatch se o trabalho estiver configurado para coletar métricas. Para obter mais informações sobre como ativar métricas e interpretar os gráficos, consulte [Monitoramento e depuração de trabalho](monitor-profile-glue-job-cloudwatch-metrics.md). **Example Grafo de movimentação de dados de ETL** O gráfico de movimentação de dados ETL mostra as seguintes métricas: + O número de bytes lidos do Amazon S3 por todos os executores: [`glue.ALL.s3.filesystem.read_bytes`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) + O número de bytes gravados no Amazon S3 por todos os executores: [`glue.ALL.s3.filesystem.write_bytes`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes) ![\[O gráfico para movimentação de dados de ETL na guia Metrics (Métricas) do console do AWS Glue.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/job_detailed_etl.png) **Example Grafo de perfil de memória** O gráfico de perfil de memória mostra as seguintes métricas: + A fração de memória usada pelo heap da JVM para este driver (escala: 0–1) pelo driver, um executor identificado por *executorId* ou todos os executores: + [`glue.driver.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.jvm.heap.usage) + [`glue.executorId.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.usage) + [`glue.ALL.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) ![\[O gráfico para perfil de memória na guia Metrics (Métricas) do console do AWS Glue.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/job_detailed_mem.png) **Example Grafo de embaralhamento de dados em executores** O gráfico de embaralhamento de dados nos executores mostra as seguintes métricas: + O número de bytes lidos por todos os executores para embaralhar os dados entre eles — [`glue.driver.aggregate.shuffleLocalBytesRead`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleLocalBytesRead) + O número de bytes gravados por todos os executores para embaralhar os dados entre eles — [`glue.driver.aggregate.shuffleBytesWritten`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleBytesWritten) ![\[O gráfico de ordem aleatória de dados entre executores na guia Metrics (Métricas) do console do AWS Glue.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/job_detailed_data.png) **Example Grafo de carga de CPU** O gráfico de carga de CPU mostra as seguintes métricas: + A fração de carga de sistema da CPU usada (escala: 0–1) pelo driver, um executor identificado por *executorId* ou todos os executores: + [`glue.driver.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.system.cpuSystemLoad) + [`glue.executorId.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.system.cpuSystemLoad) + [`glue.ALL.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.system.cpuSystemLoad) ![\[O gráfico para carga da CPU na guia Metrics (Métricas) do console do AWS Glue.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/job_detailed_cpu.png) **Example Grafo de execução de trabalho** O gráfico de execução de trabalho mostra as seguintes métricas: + O número de executores ativamente em execução — [`glue.driver.ExecutorAllocationManager.executors.numberAllExecutors`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors) + O número de estágios concluídos — [`glue.aggregate.numCompletedStages`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.numCompletedStages) + O número máximo de executores necessários — [`glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors) ![\[O gráfico para execução de trabalho na guia Metrics (Métricas) do console do AWS Glue.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/job_detailed_exec.png) # 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. # Monitoramento com insights de execuções de trabalho do AWS Glue Os insights de execução de trabalhos do AWS Glue são um recurso do AWS Glue que simplifica a depuração e a otimização de trabalhos para seus trabalhos do AWS Glue. O AWS Glue fornece a [IU do Spark](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui.html) e [logs e métricas do CloudWatch](https://docs.aws.amazon.com/glue/latest/dg/monitor-cloudwatch.html) para monitorar seus trabalhos do AWS Glue. Com esse recurso, você obtém essas informações sobre a execução do seu trabalho do AWS Glue: + Número da linha do script do trabalho do AWS Glue que apresentou uma falha. + Ação Spark executada por último no plano de consulta do Spark pouco antes da falha do seu trabalho. + Eventos de exceção do Spark relacionados à falha apresentados em um fluxo de log ordenado ao longo do tempo. + Análise de causa raiz e ação recomendada (como ajustar seu script) para corrigir o problema. + Eventos comuns do Spark (mensagens de log relacionadas a uma ação do Spark) com uma ação recomendada que aborda a causa raiz. Todos esses insights estão disponíveis para você usando dois novos fluxos de log nos logs do CloudWatch para seus trabalhos do AWS Glue. ## Requisitos O atributo de insights de execução de trabalhos do AWS Glue está disponível para as versões 2.0 e versões superiores do AWS Glue. É possível seguir o [guia de migração](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-30.html) para seus trabalhos existentes para atualizá-los das versões mais antigas do AWS Glue. ## Habilitação de insights de execução de trabalhos para um trabalho ETL do AWS Glue É possível habilitar insights de execução de trabalhos por meio do AWS Glue Studio ou da CLI. ### AWS Glue Studio Ao criar um trabalho via AWS Glue Studio, é possível habilitar ou desabilitar insights de execuções de trabalhos na guia **Detalhes do trabalho**. Verifique se a caixa **Gerar insights de trabalhos** está selecionada. ![\[Habilitação de insights de execução de trabalhos no AWS Glue Studio.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-job-run-insights-1.png) ### Linha de comando Se estiver criando um trabalho por meio da CLI, será possível iniciar uma execução de trabalho com um único novo [parâmetro de trabalho](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html): `--enable-job-insights = true`. Por padrão, os fluxos de log de insights de execução de trabalhos são criados sob o mesmo grupo de logs padrão usado pelo [log contínuo do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html), ou seja, `/aws-glue/jobs/logs-v2/`. É possível configurar o nome do grupo de logs personalizado, filtros de log e configurações de grupo de logs usando o mesmo conjunto de argumentos para o log contínuo. Para obter mais informações, consulte [Habilitar o log contínuo para trabalhos do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging-enable.html). ## Acessar os fluxos de log de insights de execução de trabalhos no CloudWatch Com o recurso de insights de execução de trabalhos habilitado, pode haver dois fluxos de log criados quando uma execução de trabalho falha. Quando um trabalho termina com sucesso, nenhum dos fluxos é gerado. 1. *Fluxo de log de análise de exceção*: `-job-insights-rca-driver`. Este stream fornece o seguinte: + Número da linha do script do trabalho do AWS Glue que causou a falha. + Ação do Spark executada por último no plano de consulta do Spark (DAG). + Eventos concisos ordenados por tempo do driver e executores do Spark relacionados à exceção. Será possível encontrar detalhes como mensagens de erro completas, a tarefa do Spark com falha e os IDs dos executores para obter ajuda para se concentrar no fluxo de log do executor específico para uma investigação mais profunda, se necessário. 1. *Fluxo de insights baseado em regras*: + Análise de causa raiz e recomendações sobre como corrigir os erros (como usar um parâmetro de trabalho específico para otimizar a performance). + Eventos relevantes do Spark servindo de base para a análise de causa raiz e uma ação recomendada. **nota** O primeiro fluxo só existirá se qualquer evento de exceção do Spark estiver disponível para uma execução de trabalho com falha, e o segundo fluxo só existirá se houver insights disponíveis para a execução do trabalho com falha. Por exemplo, se o trabalho for concluído com êxito, nenhum dos fluxos será gerado; se o trabalho falhar, mas não houver uma regra definida por serviço que possa corresponder ao seu cenário de falha, somente o primeiro fluxo será gerado. Se o trabalho for criado do AWS Glue Studio, os links para os fluxos acima também estarão disponíveis na guia de detalhes da execução do trabalho (insights da execução do trabalho) como "Concise and consolidated error logs" (Logs de erros concisos e consolidados) e "Error analysis and guidance" (Análise de erros e orientações). ![\[A página Job Run Details (Detalhes da execução do trabalho) que contém links para os fluxos de log.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-job-run-insights-2.png) ## Exemplo de insights de execuções de trabalhos do AWS Glue Nesta seção, apresentamos um exemplo de como o recurso de insights de execução de trabalhos pode ajudar a resolver um problema em um trabalho que falhou. Neste exemplo, um usuário esqueceu de importar o módulo necessário (tensorflow) em um trabalho do AWS Glue para analisar e criar um modelo de machine learning em seus dados. ``` 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.types import * from pyspark.sql.functions import udf,col args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) data_set_1 = [1, 2, 3, 4] data_set_2 = [5, 6, 7, 8] scoresDf = spark.createDataFrame(data_set_1, IntegerType()) def data_multiplier_func(factor, data_vector): import tensorflow as tf with tf.compat.v1.Session() as sess: x1 = tf.constant(factor) x2 = tf.constant(data_vector) result = tf.multiply(x1, x2) return sess.run(result).tolist() data_multiplier_udf = udf(lambda x:data_multiplier_func(x, data_set_2), ArrayType(IntegerType(),False)) factoredDf = scoresDf.withColumn("final_value", data_multiplier_udf(col("value"))) print(factoredDf.collect()) ``` Sem o recurso de insights de execução de trabalhos, quando o trabalho falhar, você só vê esta mensagem emitida pelo Spark: `An error occurred while calling o111.collectToPython. Traceback (most recent call last):` A mensagem é ambígua e limita sua experiência de depuração. Nesse caso, esse recurso fornece informações adicionais em dois fluxos de log do CloudWatch: 1. O fluxo de log do `job-insights-rca-driver`: + *Eventos de exceção*: este fluxo de log fornece os eventos de exceção do Spark relacionados à falha coletada do driver do Spark e de diferentes operadores distribuídos. Esses eventos ajudam a entender a propagação ordenada por tempo da exceção à medida que o código defeituoso é executado em tarefas, executores e estágios do Spark distribuídos pelos operadores do AWS Glue. + *Números de linha*: este fluxo de log identifica a linha 21, que fez a chamada para importar o módulo Python ausente que causou a falha; ele também identifica a linha 24, a chamada para a ação `collect()` do Spark, como a última linha executada em seu script. ![\[O fluxo de log de job-insights-rca-driver.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-job-run-insights-3.png) 1. O fluxo de log do `job-insights-rule-driver`: + *Causa raiz e recomendação*: além do número da linha e do número da última linha executada para a falha no script, esse fluxo de log mostra a análise da causa raiz e a recomendação para que você siga o doc do AWS Glue e configure os parâmetros de trabalho necessários para usar um módulo Python adicional em seu trabalho do AWS Glue. + *Evento base*: este fluxo de log também mostra o evento de exceção do Spark que foi avaliado com a regra definida pelo serviço para inferir a causa raiz e fornecer uma recomendação. ![\[O fluxo de log de job-insights-rca-driver.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-job-run-insights-4.png) # Monitorar o com o Amazon CloudWatch É possível monitorar o AWS Glue usando o Amazon CloudWatch, que coleta e processa dados brutos do AWS Glue e os transforma em métricas legíveis quase em tempo real. Essas estatísticas são registradas por um período de duas semanas, para que você possa acessar informações históricas para obter uma perspectiva melhor sobre a performance do seu serviço ou da sua aplicação Web. Por padrão, os dados de métricas do AWS Glue são enviados para o CloudWatch automaticamente. Para obter mais informações, consulte [O que é o Amazon CloudWatch?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/WhatIsCloudWatch.html) no *Manual do usuário do Amazon CloudWatch* e em [AWS Glue métricas](monitoring-awsglue-with-cloudwatch-metrics.md#awsglue-metrics). **Log contínuo** O AWS Glue também oferece suporte a registro contínuo em tempo real para tarefas do AWS Glue. Quando o registro em log contínuo está habilitado para um trabalho, é possível visualizar os logs em tempo real no console do AWS Glue ou no painel do console do CloudWatch. Para obter mais informações, consulte [Registro em log para trabalhos do AWS Glue](monitor-continuous-logging.md). **Métricas de observabilidade** Quando as **Métricas de observabilidade do trabalho** estão ativadas, Amazon CloudWatch métricas adicionais são geradas quando o trabalho é executado. Use métricas de observabilidade do AWS Glue para gerar insights sobre o que está acontecendo dentro do seu AWS Glue para melhorar a triagem e a análise de problemas. **Topics** + [Monitorar o AWS Glue usando métricas do Amazon CloudWatch](monitoring-awsglue-with-cloudwatch-metrics.md) + [Configurar alarmes do Amazon CloudWatch nos perfis de trabalho do AWS Glue](monitor-profile-glue-job-cloudwatch-alarms.md) + [Registro em log para trabalhos do AWS Glue](monitor-continuous-logging.md) + [Monitoramento com métricas de observabilidade do AWS Glue](monitor-observability.md) # Monitorar o AWS Glue usando métricas do Amazon CloudWatch É possível criar perfis e monitorar operações do AWS Glue usando o criador de perfis de tarefas do AWS Glue. Ele coleta e processa dados brutos de trabalhos do AWS Glue e os transforma em métricas legíveis, quase em tempo real, armazenadas no Amazon CloudWatch. Essas estatísticas são retidas e agregadas no CloudWatch, para que você possa acessar informações históricas e obter uma perspectiva melhor sobre como sua aplicação está se saindo. **nota** Você pode incorrer em cobranças adicionais ao habilitar que métricas de trabalho e métricas personalizadas do CloudWatch sejam criadas. Para obter mais informações, consulte [Preço do Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/). ## Visão geral das métricas do AWS Glue Quando você interage com o AWS Glue, ele envia métricas ao CloudWatch. É possível visualizar essas métricas usando o console do AWS Glue (o método de preferência), o painel do console do CloudWatch ou a AWS Command Line Interface (AWS CLI). **Para visualizar as métricas usando o painel do console do AWS Glue** Você pode visualizar gráficos de métricas detalhados ou resumidos de uma tarefa, ou gráficos detalhadas da execução de uma tarefa. 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 **Monitoramento de execução de trabalho**. 1. Em **Execuções de trabalhos**, escolha **Ações** para interromper um trabalho que está em execução no momento, exibir um trabalho ou retroceder o marcador de trabalho. 1. Selecione um trabalho e escolha **Exibir detalhes da execução** para ver informações adicionais sobre a execução do trabalho. **Para exibir métricas usando o painel do console do CloudWatch** As métricas são agrupadas primeiro pelo namespace do serviço e, em seguida, por várias combinações de dimensão dentro de cada namespace. 1. Abra o console do CloudWatch em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. No painel de navegação, selecione **Métricas**. 1. Selecione o namespace **Glue**. **Para visualizar métricas usando a AWS CLI** + Em um prompt de comando, use o seguinte comando. ``` 1. aws cloudwatch list-metrics --namespace Glue ``` AWS GlueO relata métricas para o CloudWatch a cada 30 segundos, e os painéis de métricas do CloudWatch são configurados para exibi-las a cada minuto. As métricas do AWS Glue representam valores do delta a partir dos valores relatados anteriormente. Quando apropriado, os painéis de métricas agregam (somam) os valores de 30 segundos para obter um valor para o último minuto inteiro. ### Comportamento de métricas do AWS Glue para trabalhos do Spark As métricas do AWS Glue são ativadas na inicialização de um `GlueContext` em um script e geralmente são atualizadas somente no final de um trabalho do Apache Spark. Eles representam os valores agregados em todas as tarefas do Spark concluídas até agora. No entanto, as métricas do Spark que o AWS Glue transfere para o CloudWatch são geralmente valores absolutos que representam o estado atual no momento em que elas são relatadas. O AWS Glue as informa ao CloudWatch a cada 30 segundos, e os painéis de métricas geralmente mostram a média em todos os pontos de dados recebidos no último minuto. AWS GlueOs nomes de métricas do são todos precedidos por um dos seguintes tipos de prefixo: + `glue.driver.`: métricas cujos nomes começam com esse prefixo representam métricas do AWS Glue agregadas em todos os executores no driver do Spark ou métricas do Spark correspondentes ao driver do Spark. + `glue.`*executorId*`.`: o *executorId* é o número de um executor específico do Spark. Ele corresponde ao executores listados nos logs. + `glue.ALL.` - Métricas cujos nomes começam com esse prefixo agregam valor a todos os executores do Spark. ## AWS Glue métricas O AWS Glue traça o perfil e envia as seguintes métricas para o CloudWatch a cada 30 segundos, e o painel do console do AWS Glue as relata uma vez por minuto: | Métrica | Descrição | | --- | --- | | `glue.driver.aggregate.bytesRead` | O número de bytes lidos de todas as fontes de dados por todas as tarefas do Spark concluídas em execução em todos os executores. Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (contagem). Estatística válida: SUM (SOMA). Essa métrica é um valor delta do último valor relatado, portanto, no painel de métricas do AWS Glue, uma estatística SUM (SOMA) é usada para agregação. Unidade: bytes Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Essa métrica pode ser usada da mesma maneira que a métrica `glue.ALL.s3.filesystem.read_bytes`, com a diferença de que essa métrica é atualizada no final de uma tarefa do Spark e também captura fontes de dados que não sejam do S3. | | `glue.driver.aggregate.elapsedTime` | O tempo de ETL decorrido em milissegundos (não inclui os tempos de bootstrap do trabalho). Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (contagem). Estatística válida: SUM (SOMA). Essa métrica é um valor delta do último valor relatado, portanto, no painel de métricas do AWS Glue, uma estatística SUM (SOMA) é usada para agregação. Unidade: milissegundos Pode ser usado para determinar quanto tempo leva em média para uma execução de trabalho ser executada. Algumas maneiras de usar os dados: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.numCompletedStages` | O número de etapas concluídas no trabalho. Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (contagem). Estatística válida: SUM (SOMA). Essa métrica é um valor delta do último valor relatado, portanto, no painel de métricas do AWS Glue, uma estatística SUM (SOMA) é usada para agregação. Unidade: Contagem Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algumas maneiras de usar os dados: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.numCompletedTasks` | O número de tarefas concluídas no trabalho. Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (contagem). Estatística válida: SUM (SOMA). Essa métrica é um valor delta do último valor relatado, portanto, no painel de métricas do AWS Glue, uma estatística SUM (SOMA) é usada para agregação. Unidade: Contagem Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.numFailedTasks` | O número de tarefas que falharam. Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (contagem). Estatística válida: SUM (SOMA). Essa métrica é um valor delta do último valor relatado, portanto, no painel de métricas do AWS Glue, uma estatística SUM (SOMA) é usada para agregação. Unidade: Contagem Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Os dados podem ser usados para definir alarmes para falhas aumentadas que possam sugerir anormalidades em dados, cluster ou scripts. | | `glue.driver.aggregate.numKilledTasks` | O número de tarefas encerradas. Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (contagem). Estatística válida: SUM (SOMA). Essa métrica é um valor delta do último valor relatado, portanto, no painel de métricas do AWS Glue, uma estatística SUM (SOMA) é usada para agregação. Unidade: Contagem Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algumas maneiras de usar os dados: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.recordsRead` | O número de registros lidos de todas as fontes de dados por todas as tarefas do Spark concluídas em execução em todos os executores. Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (contagem). Estatística válida: SUM (SOMA). Essa métrica é um valor delta do último valor relatado, portanto, no painel de métricas do AWS Glue, uma estatística SUM (SOMA) é usada para agregação. Unidade: Contagem Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Essa métrica pode ser usada da mesma maneira que a métrica `glue.ALL.s3.filesystem.read_bytes`, com a diferença de que essa métrica é atualizada no final de uma tarefa do Spark. | | `glue.driver.aggregate.shuffleBytesWritten` | O número de bytes gravados por todos os executores para gerar a ordem aleatória de dados entre eles desde o relatório anterior (agregado pelo painel de métricas do AWS Glue como o número de bytes gravados para esse fim durante o minuto anterior). Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (contagem). Estatística válida: SUM (SOMA). Essa métrica é um valor delta do último valor relatado, portanto, no painel de métricas do AWS Glue, uma estatística SUM (SOMA) é usada para agregação. Unidade: bytes Pode ser usado para monitorar: ordem aleatória de dados em trabalhos (junções grandes, groupBy, repartição, união). Algumas maneiras de usar os dados: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.shuffleLocalBytesRead` | O número de bytes lidos por todos os executores para gerar a ordem aleatória dos dados entre eles desde o relatório anterior (agregado pelo painel de métricas do AWS Glue como o número de bytes lidos para esse fim durante o minuto anterior). Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (contagem). Estatística válida: SUM (SOMA). Essa métrica é um valor delta do último valor relatado, portanto, no painel de métricas do AWS Glue, uma estatística SUM (SOMA) é usada para agregação. Unidade: bytes Pode ser usado para monitorar: ordem aleatória de dados em trabalhos (junções grandes, groupBy, repartição, união). Algumas maneiras de usar os dados: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.BlockManager.disk.diskSpaceUsed_MB` | O número de megabytes de espaço em disco usado em todos os executores. Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (medida). Estatística válida: média. Essa é uma métrica do Spark, relatada como um valor absoluto. Unidade: megabytes Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algumas maneiras de usar os dados: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.ExecutorAllocationManager.executors.numberAllExecutors` | O número de executores ativamente executando trabalhos. Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (medida). Estatística válida: média. Essa é uma métrica do Spark, relatada como um valor absoluto. Unidade: Contagem Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algumas maneiras de usar os dados: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors` | O número máximo de executores de trabalho (em execução ativa e pendentes) necessários para satisfazer a carga atual. Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (medida). Estatísticas válidas: máximo. Essa é uma métrica do Spark, relatada como um valor absoluto. Unidade: Contagem Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algumas maneiras de usar os dados: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.jvm.heap.usage` `glue.`*executorId*`.jvm.heap.usage` `glue.ALL.jvm.heap.usage` | A fração de memória usada pelo heap da JVM para este driver (escala: 0 a 1) pelo driver, executor identificado por executorId ou TODOS os executores. Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (medida). Estatística válida: média. Essa é uma métrica do Spark, relatada como um valor absoluto. Unidade: porcentagem Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algumas maneiras de usar os dados: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.jvm.heap.used` `glue.`*executorId*`.jvm.heap.used` `glue.ALL.jvm.heap.used` | O número de bytes de memória usados pelo heap da JVM para o driver, o executor identificado por *executorId* ou TODOS os executores. Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (medida). Estatística válida: média. Essa é uma métrica do Spark, relatada como um valor absoluto. Unidade: bytes Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algumas maneiras de usar os dados: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.s3.filesystem.read_bytes` `glue.`*executorId*`.s3.filesystem.read_bytes` `glue.ALL.s3.filesystem.read_bytes` | O número de bytes lidos do Amazon S3 pelo driver, um executor identificado por *executorId* ou TODOS os executores desde o relatório anterior (agregado pelo painel de métricas do AWS Glue como o número de bytes lidos durante o minuto anterior). Dimensões válidas: `JobName`, `JobRunId` e `Type` (medida). Estatística válida: SUM (SOMA). Essa métrica é um valor delta do último valor relatado, portanto, no painel de métricas do AWS Glue, uma estatística SUM (SOMA) é usada para agregação. A área sob a curva no painel de métricas do AWS Glue pode ser usada para comparar visualmente os bytes lidos por duas execuções de trabalho diferentes. Unidade: Bytes. Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Os dados resultantes podem ser usados para: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.s3.filesystem.write_bytes` `glue.`*executorId*`.s3.filesystem.write_bytes` `glue.ALL.s3.filesystem.write_bytes` | O número de bytes gravados no Amazon S3 pelo driver, um executor identificado por *executorId* ou TODOS os executores desde o relatório anterior (agregado pelo painel de métricas do AWS Glue como o número de bytes gravados durante o minuto anterior). Dimensões válidas: `JobName`, `JobRunId` e `Type` (medida). Estatística válida: SUM (SOMA). Essa métrica é um valor delta do último valor relatado, portanto, no painel de métricas do AWS Glue, uma estatística SUM (SOMA) é usada para agregação. A área sob a curva no painel de métricas do AWS Glue pode ser usada para comparar visualmente os bytes gravados por duas execuções de trabalho diferentes. Unidade: bytes Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algumas maneiras de usar os dados: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.streaming.numRecords` | O número de registros que são recebidos em um microlote. Essa métrica só está disponível para os trabalhos de transmissão do AWS Glue com o AWS Glue versão 2.0 e posterior. Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (contagem). Estatísticas válidas: soma , máximo, mínimo, média, porcentagem Unidade: Contagem Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.streaming.batchProcessingTimeInMs` | O tempo necessário para processar os lotes em milissegundos. Essa métrica só está disponível para os trabalhos de transmissão do AWS Glue com o AWS Glue versão 2.0 e posterior. Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (contagem). Estatísticas válidas: soma , máximo, mínimo, média, porcentagem Unidade: Contagem Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.system.cpuSystemLoad` `glue.`*executorId*`.system.cpuSystemLoad` `glue.ALL.system.cpuSystemLoad` | A fração de carga de sistema da CPU usada (escala: 0 a 1) pelo driver, um executor identificado por *executorId* ou TODOS os executores. Dimensões válidas: `JobName` (o nome do trabalho do AWS Glue), `JobRunId` (o ID de JobRun. ou `ALL`) e `Type` (medida). Estatística válida: média. Essa métrica é relatada como um valor absoluto. Unidade: porcentagem Pode ser usada para monitorar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algumas maneiras de usar os dados: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | ## Dimensões para métricas do AWS Glue As métricas do AWS Glue usam namespace do AWS Glue e fornecem métricas para as seguintes dimensões: | Dimensão | Descrição | | --- | --- | | `JobName` | Esta dimensão filtra as métricas de todas as execuções de trabalho de um trabalho do AWS Glue. | | `JobRunId` | Esta dimensão filtra as métricas de um trabalho do AWS Glue específico executado por um ID JobRun ou `ALL`. | | `Type` | Esta dimensão filtra as métricas por `count` (um número agregado) ou `gauge` (um valor em um determinado ponto no tempo). | Para saber mais, consulte o [Guia do usuário do Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/). # Configurar alarmes do Amazon CloudWatch nos perfis de trabalho do AWS Glue AWS GlueAs métricas do também estão disponíveis no Amazon CloudWatch. Você pode configurar alarmes em qualquer métrica do AWS Glue para tarefas agendadas. Alguns cenários comuns para a configuração de alarmes são os seguintes: + Trabalhos sem memória (OOM): defina um alarme quando o uso de memória exceder a média normal para o driver ou um executor para um trabalho do AWS Glue. + Executores difíceis: defina um alarme quando o número de executores cair abaixo de um determinado limite por um grande período em um trabalho do AWS Glue. + Backlog ou reprocessamento de dados: compare as métricas de trabalhos individuais em um fluxo de trabalho usando uma expressão matemática do CloudWatch. Em seguida, você pode acionar um alarme no valor da expressão resultante (como a proporção de bytes gravados por um trabalho e bytes lidos por um trabalho seguinte). Para obter instruções detalhadas sobre como definir alarmes, consulte [Criar ou editar um alarme do CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ConsoleAlarms.html) no *[Manual do usuário do Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/)*. Para cenários de monitoramento e depuração usando o CloudWatch, consulte [Monitoramento e depuração de trabalho](monitor-profile-glue-job-cloudwatch-metrics.md). # Registro em log para trabalhos do AWS Glue No AWS Glue 5.0, todos os trabalhos têm capacidades de registro em log em tempo real. Além disso, você pode especificar opções personalizadas de configuração para adaptar o comportamento de registro em log. Essas opções incluem definir o nome do grupo de logs do Amazon CloudWatch, o prefixo do fluxo de logs do Amazon CloudWatch (que precederá o ID de execução de trabalho do AWS Glue e o ID do driver/executor), e o padrão de conversão de logs para mensagens de log. Essas configurações permitem agregar logs em grupos personalizados de logs do Amazon CloudWatch com diferentes políticas de expiração. Além disso, você pode analisar os logs de modo mais eficaz usando prefixos de fluxo de logs e padrões de conversão personalizados. Esse nível de personalização permite que você otimize o gerenciamento e a análise de logs de acordo com seus requisitos específicos. ## Comportamento de registro em log no AWS Glue 5.0 Por padrão, os logs do sistema, os logs do daemon do Spark e os logs do AWS Glue Logger do usuário são gravados no grupo de logs `/aws-glue/jobs/error` no Amazon CloudWatch. Por outro lado, os logs stdout (saída padrão) e stderr (erro padrão) do usuário são gravados no grupo de logs `/aws-glue/jobs/output` por padrão. ## Logs personalizados Você pode personalizar o grupo de logs padrão e os prefixos do fluxo de logs usando os seguintes argumentos de trabalho: + `--custom-logGroup-prefix`: permite que você especifique um prefixo personalizado para os grupos de logs `/aws-glue/jobs/error` e `/aws-glue/jobs/output`. Se você fornecer um prefixo personalizado, os nomes dos grupos de logs estarão no seguinte formato: + `/aws-glue/jobs/error` será `/error` + `/aws-glue/jobs/output ` será `/output` + `--custom-logStream-prefix`: permite que você especifique um prefixo personalizado para os nomes do fluxo de logs nos grupos de logs. Se você fornecer um prefixo personalizado, os nomes dos fluxos de logs estarão no seguinte formato: + `jobrunid-driver` será `-driver` + `jobrunid-executorNum` será `-executorNum` As regras de validação e as limitações para prefixos personalizados: + O nome completo do fluxo de logs precisa ter de 1 a 512 caracteres. + O prefixo personalizado é restrito a 400 caracteres. + O prefixo personalizado precisa corresponder ao padrão de expressão regular “[^:\$1]\$1” (os caracteres especiais permitidos são “\$1”, “-” e “/”). ## Registrar em log mensagens específicas da aplicação usando o registrador de script personalizado É possível usar o registrador do AWS Glue para registrar qualquer mensagem específica do aplicativo no script que foi enviado em tempo real ao stream de log do driver. O exemplo a seguir mostra um script Python. ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) logger = glueContext.get_logger() logger.info("info message") logger.warn("warn message") logger.error("error message") ``` O exemplo a seguir mostra um script Scala. ``` import com.amazonaws.services.glue.log.GlueLogger object GlueApp { def main(sysArgs: Array[String]) { val logger = new GlueLogger logger.info("info message") logger.warn("warn message") logger.error("error message") } } ``` ## Habilitar a barra de progresso para exibir o progresso do trabalho O AWS Glue fornece uma barra de progresso em tempo real no stream de log `JOB_RUN_ID-progress-bar` para verificar o status de execução da tarefa do AWS Glue. No momento, ele oferece suporte somente a tarefas que inicializam o `glueContext`. Se você executar uma tarefa pura do Spark sem inicializar o `glueContext`, a barra de progresso do AWS Glue não será exibida. A barra de progresso mostra a atualização de progresso a seguir a cada 5 segundos. ``` Stage Number (Stage Name): > (numCompletedTasks + numActiveTasks) / totalNumOfTasksInThisStage] ``` ## Configuração de segurança com registro em log do Amazon CloudWatch Quando uma configuração de segurança é habilitada para logs do Amazon CloudWatch, o AWS Glue cria grupos de logs com padrões específicos de nomenclatura que incorporam o nome da configuração de segurança. ### Nomenclatura de grupos de logs com configuração de segurança Os grupos de log padrão e personalizado serão os seguintes: + **Grupo de logs padrão de erros:** `/aws-glue/jobs/Security-Configuration-Name-role/glue-job-role/error` + **Grupo de logs padrão de saída:** `/aws-glue/jobs/Security-Configuration-Name-role/glue-job-role/output` + **Grupo de logs personalizado de erros (AWS Glue 5.0):** `custom-log-group-prefix/Security-Configuration-Name-role/glue-job-role/error` + **Grupo de logs personalizado de saída (AWS Glue 5.0):** `custom-log-group-prefix/Security-Configuration-Name-role/glue-job-role/output` ### Permissões obrigatórias do IAM Se você habilitar uma configuração de segurança com o Amazon CloudWatch Logs, será necessário adicionar a permissão `logs:AssociateKmsKey` às permissões do seu perfil do IAM. Se essa permissão não for incluída, o registro em log contínuo será desabilitado. Além disso, para configurar a criptografia do Amazon CloudWatch Logs, siga as instruções em [Criptografar dados de log no Amazon CloudWatch Logs usando o AWS Key Management Service](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html) no Guia do usuário do Amazon Amazon CloudWatch Logs. ### Informações adicionais Para obter mais informações sobre como criar configurações de segurança, consulte [Gerenciar configurações de segurança no console do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-security-configurations.html). **Topics** + [Comportamento de registro em log no AWS Glue 5.0](#monitor-logging-behavior-glue-50) + [Logs personalizados](#monitor-logging-custom) + [Registrar em log mensagens específicas da aplicação usando o registrador de script personalizado](#monitor-logging-script) + [Habilitar a barra de progresso para exibir o progresso do trabalho](#monitor-logging-progress) + [Configuração de segurança com registro em log do Amazon CloudWatch](#monitor-security-config-logging) + [Habilitar o registro contínuo em log para trabalhos do AWS Glue 4.0 e versões anteriores](monitor-continuous-logging-enable.md) + [Visualizar logs para trabalhos do AWS Glue](monitor-continuous-logging-view.md) # Habilitar o registro contínuo em log para trabalhos do AWS Glue 4.0 e versões anteriores **nota** No AWS Glue 4.0 e versões anteriores, o registro contínuo em log era um recurso disponível. No entanto, com o lançamento do AWS Glue 5.0, todos os trabalhos têm capacidade de registro em log em tempo real. Para obter mais detalhes sobre as capacidades de registro em log e as opções de configuração no AWS Glue 5.0, consulte [Registro contínuo para trabalhos do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html). É possível habilitar o registro contínuo usando o console do AWS Glue ou por meio da AWS Command Line Interface (AWS CLI). É possível habilitar o registro em log contínuo ao criar um trabalho ou editar um trabalho existente ou habilitá-lo via AWS CLI. Também é possível especificar opções de configuração personalizadas, como o nome do grupo de logs do Amazon CloudWatch, o prefixo da transmissão de logs do CloudWatch antes do ID de driver/ID de executor da execução de trabalho do AWS Glue e o padrão de conversão de logs para mensagens de log. Essas configurações ajudam a definir logs agregados em grupos de logs personalizados do CloudWatch com diferentes políticas de expiração e a analisá-los em mais detalhes com prefixos de fluxo de logs e padrões de conversões personalizados. **Topics** + [Utilização do Console de gerenciamento da AWS](#monitor-continuous-logging-enable-console) + [Registrar em log mensagens específicas da aplicação usando o registrador de script personalizado](#monitor-continuous-logging-script) + [Habilitar a barra de progresso para exibir o progresso do trabalho](#monitor-continuous-logging-progress) + [Configuração de segurança com registro contínuo](#monitor-logging-encrypt-log-data) ## Utilização do Console de gerenciamento da AWS Siga estas etapas para usar o console para habilitar o registro contínuo ao criar ou editar uma tarefa do AWS Glue. **Para criar uma tarefa do AWS Glue com registro contínuo** 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 **Trabalhos de ETL**. 1. Escolha **ETL visual**. 1. Na guia **Detalhes do trabalho**, expanda a seção **Propriedades avançadas**. 1. Em **Registro em log contínuo**, selecione **Ativar logs no CloudWatch**. **Para habilitar o registro contínuo para um tarefa existente do AWS Glue** 1. 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 uma tarefa existente na lista **Jobs (Tarefas)**. 1. Selecione **Action (Ação)**, **Edit job (Editar tarefa)**. 1. Na guia **Detalhes do trabalho**, expanda a seção **Propriedades avançadas**. 1. Em **Registro em log contínuo**, selecione **Ativar logs no CloudWatch**. ### Usar o AWS CLI Para habilitar o registro contínuo, transmita parâmetros de tarefa para uma tarefa do AWS Glue. Transmita os parâmetros de trabalho especiais a seguir semelhantes a outros parâmetros de trabalho 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-continuous-cloudwatch-log': 'true' ``` É possível especificar um nome de grupo de logs personalizado do Amazon CloudWatch. Se não for especificado, o nome do grupo de logs padrão será `/aws-glue/jobs/logs-v2`. ``` '--continuous-log-logGroup': 'custom_log_group_name' ``` É possível especificar um prefixo de transmissão de logs personalizado do Amazon CloudWatch. Se não for especificado, o prefixo do fluxo de logs padrão será o ID de execução do trabalho. ``` '--continuous-log-logStreamPrefix': 'custom_log_stream_prefix' ``` É possível especificar um padrão contínuo e personalizado de conversão de logs. Se não for especificado, o padrão de conversão padrão será `%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n`. Observe que o padrão de conversão só se aplica a logs de driver e logs de executor. Isso não afeta a barra de progresso do AWS Glue. ``` '--continuous-log-conversionPattern': 'custom_log_conversion_pattern' ``` ## Registrar em log mensagens específicas da aplicação usando o registrador de script personalizado É possível usar o registrador do AWS Glue para registrar qualquer mensagem específica do aplicativo no script que foi enviado em tempo real ao stream de log do driver. O exemplo a seguir mostra um script Python. ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) logger = glueContext.get_logger() logger.info("info message") logger.warn("warn message") logger.error("error message") ``` O exemplo a seguir mostra um script Scala. ``` import com.amazonaws.services.glue.log.GlueLogger object GlueApp { def main(sysArgs: Array[String]) { val logger = new GlueLogger logger.info("info message") logger.warn("warn message") logger.error("error message") } } ``` ## Habilitar a barra de progresso para exibir o progresso do trabalho O AWS Glue fornece uma barra de progresso em tempo real no stream de log `JOB_RUN_ID-progress-bar` para verificar o status de execução da tarefa do AWS Glue. No momento, ele oferece suporte somente a tarefas que inicializam o `glueContext`. Se você executar uma tarefa pura do Spark sem inicializar o `glueContext`, a barra de progresso do AWS Glue não será exibida. A barra de progresso mostra a atualização de progresso a seguir a cada 5 segundos. ``` Stage Number (Stage Name): > (numCompletedTasks + numActiveTasks) / totalNumOfTasksInThisStage] ``` ## Configuração de segurança com registro contínuo Se uma configuração de segurança estiver habilitada para logs do CloudWatch, o AWS Glue criará um grupo de logs chamado da seguinte forma para logs contínuos: ``` - ``` Os grupos de log padrão e personalizado serão os seguintes: + O grupo de logs contínuos padrão será `/aws-glue/jobs/error-` + O grupo de logs contínuos personalizado será `-` É necessário adicionar `logs:AssociateKmsKey` a suas permissões de função do IAM, se você habilitar uma configuração de segurança com o CloudWatch Logs. Se essa permissão não for incluída, o registro em log contínuo será desabilitado. Além disso, para configurar a criptografia do CloudWatch Logs, siga as instruções em [Criptografar dados de log no CloudWatch Logs usando o AWS Key Management Service](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html) no *Manual do usuário do Amazon CloudWatch Logs*. Para obter mais informações sobre como criar configurações de segurança, consulte [Gerenciar configurações de segurança no console do AWS Glue](console-security-configurations.md). **nota** Você poderá incorrer em cobranças adicionais ser habilitar o registro em log e houver a criação eventos de log adicionais do CloudWatch. Para obter mais informações, consulte [Preço do Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/). # Visualizar logs para trabalhos do AWS Glue É possível visualizar logs em tempo real usando o console do AWS Glue ou o console do Amazon CloudWatch. **Para visualizar logs em tempo real usando o painel do console do AWS Glue** 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. Adicione ou inicie uma tarefa existente. Selecione **Action (Ação)**, **Run job (Executar tarefa)**. Ao começar a executar uma tarefa, você navega até uma página que contém informações sobre a tarefa em execução: + A guia **Logs** mostra os logs do aplicativo agregados mais antigos. + A guia **Logs** mostra uma barra de progresso em tempo real quando o trabalho está sendo executado com o `glueContext` inicializado. + A guia **Logs** também contém os **Logs de driver**, que capturam logs de driver do Apache Spark em tempo real, além de logs de aplicativo do script registrado usando o registrador de aplicação do AWS Glue quando a tarefa está em execução. 1. Para tarefas mais antigas, também é possível visualizar logs em tempo real na exibição **Job History (Histórico de tarefas)** selecionando **Logs**. Essa ação leva você até o console do CloudWatch, que mostra todas as transmissões de log da barra de progresso, do executor e do driver do Spark para essa execução de trabalho. **Para visualizar logs em tempo real usando o painel do console do CloudWatch** 1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. No painel de navegação, selecione **Log**. 1. Selecione o grupo de logs **/aws-glue/jobs/error/**. 1. Na caixa **Filter (Filtro)**, cole o ID da execução da tarefa. É possível visualizar os logs de driver, logs de executor e a barra de progresso (se estiver usando o **Standard filter (Filtro padrão)**). # Monitoramento com métricas de observabilidade do AWS Glue **nota** As métricas de observabilidade do AWS Glue estão disponíveis no AWS Glue 4.0 e versões posteriores. Use métricas de observabilidade do AWS Glue para gerar insights sobre o que está acontecendo dentro do seu AWS Glue para trabalhos do Apache Sparks para melhorar a triagem e a análise de problemas. As métricas de observabilidade são visualizadas por meio de painéis do Amazon CloudWatch e podem ser usadas para ajudar a realizar a análise da causa raiz de erros e para diagnosticar gargalos de performance. É possível reduzir o tempo gasto na depuração de problemas em escala para que você possa se concentrar em resolver problemas com mais rapidez e eficiência. A observabilidade do AWS Glue fornece métricas do Amazon CloudWatch categorizadas nos quatro grupos a seguir: + **Confiabilidade (ou seja, classes de erros)**: identifique facilmente os motivos de falha mais comuns em um determinado intervalo de tempo que você talvez queira resolver. + **Performance (ou seja, assimetria)**: identifique um gargalo de performance e aplique técnicas de ajuste. Por exemplo, quando você enfrenta uma degradação de performance causada pela assimetria de um trabalho, convém ativar a execução adaptativa de consultas do Spark e ajustar o limite de junção assimétrica. + **Throughput (ou seja, throughput por fonte/coletor)**: monitore as tendências de leituras e gravações de dados. Você também pode configurar alarmes do Amazon CloudWatch para anomalias. + **Utilização de recursos (ou seja, operadores, memória e utilização de disco)**: encontre de forma eficiente os trabalhos com baixa utilização de capacidade. Talvez você queira habilitar o ajuste de escala automático do AWS Glue para esses trabalhos. ## Conceitos básicos das métricas de observabilidade do AWS Glue **nota** As métricas novas são habilitadas por padrão no console do AWS Glue Studio. **Para configurar métricas de observabilidade no AWS Glue Studio:** 1. Faça login no console do AWS Glue e escolha **Trabalhos ETL** no menu do console. 1. Escolha um trabalho clicando no nome do trabalho na seção **Seus trabalhos**. 1. Escolha a guia **Job details** (Detalhes do trabalho). 1. Role até a parte inferior e escolha **Propriedades avançadas** e, em seguida, **Métricas de observabilidade do trabalho**. ![\[A captura de tela mostra as propriedades avançadas da guia Detalhes do trabalho. A opção de métricas de observabilidade do trabalho é destacada.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/job-details-observability-metrics.png) **Para habilitar as métricas de observabilidade do AWS Glue usando a AWS CLI:** + Adicione ao mapa `--default-arguments` o seguinte par chave-valor no arquivo JSON de entrada: ``` --enable-observability-metrics, true ``` ## Usar a observabilidade do AWS Glue Como as métricas de observabilidade do AWS Glue são fornecidas por meio do Amazon CloudWatch, você pode usar o console do Amazon CloudWatch, a AWS CLI, o SDK ou a API para consultar os pontos de dados das métricas de observabilidade. Consulte [Como usar a observabilidade do Glue para monitorar a utilização de recursos para reduzir custos](https://aws.amazon.com/blogs/big-data/enhance-monitoring-and-debugging-for-aws-glue-jobs-using-new-job-observability-metrics/) para ver um exemplo de caso de uso de métricas de observabilidade do AWS Glue. ### Usar a observabilidade do AWS Glue no console do Amazon CloudWatch **Para consultar e visualizar métricas no console do Amazon CloudWatch:** 1. Abra o console do Amazon CloudWatch e escolha **Todas as métricas**. 1. Em Namespaces personalizados, escolha **AWS Glue**. 1. Escolha **Métricas de observabilidade do trabalho, Métricas de observabilidade por fonte ou Métricas de observabilidade por coletor**. 1. Pesquise o nome da métrica específica, o nome do trabalho, o ID da execução do trabalho e selecione-os. 1. Na guia **Métricas representadas graficamente**, configure a estatística, o período e outras opções preferidas. ![\[A captura de tela mostra o console do Amazon CloudWatch e o gráfico de métricas.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/cloudwatch-console-metrics.png) **Para consultar uma métrica de observabilidade usando a AWS CLI:** 1. Crie um arquivo JSON de definição métrica e substitua `your-Glue-job-name` e `your-Glue-job-run-id` pelos seus. ``` $ cat multiplequeries.json [ { "Id": "avgWorkerUtil_0", "MetricStat": { "Metric": { "Namespace": "Glue", "MetricName": "glue.driver.workerUtilization", "Dimensions": [ { "Name": "JobName", "Value": "" }, { "Name": "JobRunId", "Value": "" }, { "Name": "Type", "Value": "gauge" }, { "Name": "ObservabilityGroup", "Value": "resource_utilization" } ] }, "Period": 1800, "Stat": "Minimum", "Unit": "None" } }, { "Id": "avgWorkerUtil_1", "MetricStat": { "Metric": { "Namespace": "Glue", "MetricName": "glue.driver.workerUtilization", "Dimensions": [ { "Name": "JobName", "Value": "" }, { "Name": "JobRunId", "Value": "" }, { "Name": "Type", "Value": "gauge" }, { "Name": "ObservabilityGroup", "Value": "resource_utilization" } ] }, "Period": 1800, "Stat": "Minimum", "Unit": "None" } } ] ``` 1. Execute o comando `get-metric-data`: ``` $ aws cloudwatch get-metric-data --metric-data-queries file: //multiplequeries.json \ --start-time '2023-10-28T18: 20' \ --end-time '2023-10-28T19: 10' \ --region us-east-1 { "MetricDataResults": [ { "Id": "avgWorkerUtil_0", "Label": "", "Timestamps": [ "2023-10-28T18:20:00+00:00" ], "Values": [ 0.06718750000000001 ], "StatusCode": "Complete" }, { "Id": "avgWorkerUtil_1", "Label": "", "Timestamps": [ "2023-10-28T18:50:00+00:00" ], "Values": [ 0.5959183673469387 ], "StatusCode": "Complete" } ], "Messages": [] } ``` ## Métricas de observabilidade A observabilidade do AWS Glue traça o perfil e envia as seguintes métricas do Amazon CloudWatch a cada 30 segundos. Algumas dessas métricas podem ser visíveis na página de monitoramento de execução de trabalhos do AWS Glue Studio. | Métrica | Descrição | Categoria | | --- | --- | --- | | glue.driver.skewness.stage | Categoria métrica: job\$1performance Distorção na execução dos estágios do Spark: essa métrica é um indicador do quanto o tempo máximo de duração da tarefa em um determinado estágio é comparado à duração mediana da tarefa nesse estágio. Ela captura a assimetria da execução, que pode ser causada pela assimetria dos dados de entrada ou por uma transformação (por exemplo, junção assimétrica). Os valores dessa métrica estão na faixa de [0, infinito[, em que 0 significa que a razão entre o tempo máximo e a mediana de execução das tarefas, entre todas as tarefas no estágio, é menor que um determinado fator de distorção do estágio. O fator de assimetria de estágio padrão é "5" e pode ser sobrescrito via spark conf: spark.metrics.conf.driver.source.glue.jobPerformance.skewnessFactor Um valor de assimetria de estágio de 1 significa que a proporção é o dobro do fator de assimetria do estágio. O valor de assimetria do estágio é atualizado a cada 30 segundos para refletir a assimetria atual. O valor no final do estágio reflete a assimetria do estágio final. Essa métrica em nível de estágio é usada para calcular a métrica em nível de trabalho. `glue.driver.skewness.job` Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e observabilityGroup (job\$1performance) Estatísticas válidas: média, máximo, mínimo, porcentagem Unidade: Contagem | job\$1performance | | glue.driver.skewness.job | Categoria métrica: job\$1performance A assimetria do trabalho é o máximo da assimetria ponderada de todos os estágios. A assimetria do estágio (glue.driver.skewness.stage) é ponderada com a duração do estágio. Isso é para evitar situações extremas quando um estágio muito assimétrico está realmente funcionando por um tempo muito curto em relação a outros estágios (e, portanto, sua assimetria não é significativa para a performance geral do trabalho e não vale a pena tentar resolver sua assimetria). Essa métrica é atualizada após a conclusão de cada estágio e, portanto, o último valor reflete a assimetria geral real do trabalho. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e observabilityGroup (job\$1performance) Estatísticas válidas: média, máximo, mínimo, porcentagem Unidade: Contagem | job\$1performance | | glue.succeed.ALL | Categoria métrica: erro Número total de execuções de trabalhos com êxito para completar o quadro das categorias de falhas Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (count) e ObservabilityGroup (error) Estatística válida: SUM Unidade: Contagem | erro | | glue.error.ALL | Categoria métrica: erro Número total de erros de execução de trabalho para completar o quadro das categorias de falhas Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (count) e ObservabilityGroup (error) Estatística válida: SUM Unidade: Contagem | erro | | glue.error.[error category] | Categoria métrica: erro Na verdade, este é um conjunto de métricas que são atualizadas somente quando a execução de um trabalho falha. A categorização de erros ajuda na triagem e na depuração. Quando a execução de uma tarefa falha, o erro que causa a falha é categorizado e a métrica da categoria de erro correspondente é definida como 1. Isso ajuda a realizar análises de falhas ao longo do tempo, bem como a análise geral de erros de trabalhos para identificar as categorias de falhas mais comuns e começar a resolvê-las. O AWS Glue tem 28 categorias de erro, incluindo as categorias de erro OUT\$1OF\$1MEMORY (driver e executor), PERMISSION, SYNTAX e THROTTLING. As categorias de erro também incluem as categorias de erro COMPILATION, LAUNCH e TIMEOUT. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (count) e ObservabilityGroup (error) Estatística válida: SUM Unidade: Contagem | erro | | glue.driver.workerUtilization | Categoria métrica: resource\$1utilization A porcentagem dos trabalhadores alocados que são realmente usados. Se não for bom, o ajuste de escala automático pode ajudar. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatísticas válidas: média, máximo, mínimo, porcentagem Unidade: porcentagem | resource\$1utilization | | glue.driver.memory.heap.[available \$1 used] | Categoria métrica: resource\$1utilization A memória heap disponível/usado do driver durante a execução do trabalho. Isso ajuda a entender as tendências de uso da memória, especialmente ao longo do tempo, o que pode ajudar a evitar possíveis falhas, além de depurar falhas relacionadas à memória. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: bytes | resource\$1utilization | | glue.driver.memory.heap.used.percentage | Categoria métrica: resource\$1utilization A memória heap usada pelo driver (%) durante a execução do trabalho. Isso ajuda a entender as tendências de uso da memória, especialmente ao longo do tempo, o que pode ajudar a evitar possíveis falhas, além de depurar falhas relacionadas à memória. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: porcentagem | resource\$1utilization | | glue.driver.memory.non-heap.[available \$1 used] | Categoria métrica: resource\$1utilization A memória não heap disponível/usado do driver durante a execução do trabalho. Isso ajuda a entender as tendências de uso da memória, especialmente ao longo do tempo, o que pode ajudar a evitar possíveis falhas, além de depurar falhas relacionadas à memória. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: bytes | resource\$1utilization | | glue.driver.memory.non-heap.used.percentage | Categoria métrica: resource\$1utilization A memória não heap usada pelo driver (%) durante a execução do trabalho. Isso ajuda a entender as tendências de uso da memória, especialmente ao longo do tempo, o que pode ajudar a evitar possíveis falhas, além de depurar falhas relacionadas à memória. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: porcentagem | resource\$1utilization | | glue.driver.memory.total.[available \$1 used] | Categoria métrica: resource\$1utilization A memória total do driver disponível/usada durante a execução do trabalho. Isso ajuda a entender as tendências de uso da memória, especialmente ao longo do tempo, o que pode ajudar a evitar possíveis falhas, além de depurar falhas relacionadas à memória. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: bytes | resource\$1utilization | | glue.driver.memory.total.used.percentage | Categoria métrica: resource\$1utilization A memória total usada pelo driver (%) durante a execução do trabalho. Isso ajuda a entender as tendências de uso da memória, especialmente ao longo do tempo, o que pode ajudar a evitar possíveis falhas, além de depurar falhas relacionadas à memória. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: porcentagem | resource\$1utilization | | glue.ALL.memory.heap.[available \$1 used] | Categoria métrica: resource\$1utilization A memória heap disponível/usada dos executores. ALL significa todos os executores. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: bytes | resource\$1utilization | | glue.ALL.memory.heap.used.percentage | Categoria métrica: resource\$1utilization A memória heap usada dos executores (%). ALL significa todos os executores. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: porcentagem | resource\$1utilization | | glue.ALL.memory.non-heap.[available \$1 used] | Categoria métrica: resource\$1utilization A memória não heap disponível/usada dos executores. ALL significa todos os executores. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: bytes | resource\$1utilization | | glue.ALL.memory.non-heap.used.percentage | Categoria métrica: resource\$1utilization A memória não heap usada (%) dos executores. ALL significa todos os executores. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: porcentagem | resource\$1utilization | | glue.ALL.memory.total.[available \$1 used] | Categoria métrica: resource\$1utilization A memória total disponível/usada dos executores. ALL significa todos os executores. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: bytes | resource\$1utilization | | glue.ALL.memory.total.used.percentage | Categoria métrica: resource\$1utilization A memória total usada (%) dos executores. ALL significa todos os executores. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: porcentagem | resource\$1utilization | | glue.driver.disk.[available\$1GB \$1 used\$1GB] | Categoria métrica: resource\$1utilization O espaço em disco disponível/usado do driver durante a execução do trabalho. Isso ajuda a entender as tendências de uso do disco, especialmente ao longo do tempo, o que pode ajudar a evitar possíveis falhas, além de depurar falhas relacionadas à falta de espaço em disco. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: gigabytes | resource\$1utilization | | glue.driver.disk.used.percentage] | Categoria métrica: resource\$1utilization O espaço em disco disponível/usado do driver durante a execução do trabalho. Isso ajuda a entender as tendências de uso do disco, especialmente ao longo do tempo, o que pode ajudar a evitar possíveis falhas, além de depurar falhas relacionadas à falta de espaço em disco. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: porcentagem | resource\$1utilization | | glue.ALL.disk.[available\$1GB \$1 used\$1GB] | Categoria métrica: resource\$1utilization O espaço em disco disponível/usado dos executores. ALL significa todos os executores. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: gigabytes | resource\$1utilization | | glue.ALL.disk.used.percentage | Categoria métrica: resource\$1utilization O espaço em disco disponível/usado/usado(%) dos executores. ALL significa todos os executores. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Estatística válida: média Unidade: porcentagem | resource\$1utilization | | glue.driver.bytesRead | Categoria métrica: throughput O número de bytes lidos por fonte de entrada nessa execução de trabalho, bem como para TODAS as fontes. Isso ajuda a entender o volume de dados e suas mudanças ao longo do tempo, o que ajuda a resolver problemas como assimetria de dados. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge), ObservabilityGroup (resource\$1utilization) e Source (local da fonte de dados) Estatística válida: média Unidade: bytes | throughput | | glue.driver.[recordsRead \$1 filesRead] | Categoria métrica: throughput O número de registros/arquivos lidos por fonte de entrada nessa execução de trabalho, bem como para TODAS as fontes. Isso ajuda a entender o volume de dados e suas mudanças ao longo do tempo, o que ajuda a resolver problemas como assimetria de dados. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge), ObservabilityGroup (resource\$1utilization) e Source (local da fonte de dados) Estatística válida: média Unidade: Contagem | throughput | | glue.driver.partitionsRead | Categoria métrica: throughput O número de partições lidas por fonte de entrada do Amazon S3 nessa execução de trabalho, bem como para TODAS as fontes. Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge), ObservabilityGroup (resource\$1utilization) e Source (local da fonte de dados) Estatística válida: média Unidade: Contagem | throughput | | glue.driver.bytesWrittten | Categoria métrica: throughput O número de bytes gravados por coletor de saída nessa execução de trabalho, bem como para TODOS os coletores. Isso ajuda a compreender o volume de dados e como ele evolui ao longo do tempo, o que ajuda a resolver problemas como a assimetria do processamento Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge), ObservabilityGroup (resource\$1utilization) e Source (local do coletor de dados) Estatística válida: média Unidade: bytes | throughput | | glue.driver.[recordsWritten \$1 filesWritten] | Categoria métrica: throughput O número de registros/arquivos gravados por coletor de saída nessa execução de trabalho, bem como para TODOS os coletores. Isso ajuda a compreender o volume de dados e como ele evolui ao longo do tempo, o que ajuda a resolver problemas como a assimetria do processamento Dimensões válidas: JobName (o nome do trabalho do AWS Glue), JobRunId (a ID de JobRun. ou ALL), Type (gauge), ObservabilityGroup (resource\$1utilization) e Source (local do coletor de dados) Estatística válida: média Unidade: Contagem | throughput | ## Categorias de erros | Categorias de erros | Descrição | | --- | --- | | COMPILATION\$1ERROR | Os erros surgem durante a compilação do código Scala. | | CONNECTION\$1ERROR | Os erros surgem durante a conexão com um serviço/host remoto/serviço de banco de dados etc. | | DISK\$1NO\$1SPACE\$1ERROR | Os erros surgem quando não há mais espaço em disco no driver/executor. | | OUT\$1OF\$1MEMORY\$1ERROR | Os erros surgem quando não há mais espaço na memória do driver/executor. | | IMPORT\$1ERROR | Os erros surgem ao importar dependências. | | INVALID\$1ARGUMENT\$1ERROR | Erros surgem quando os argumentos de entrada são inválidos/ilegais. | | PERMISSION\$1ERROR | Os erros surgem quando não há permissão para serviços, dados etc. | | RESOURCE\$1NOT\$1FOUND\$1ERROR | Os erros surgem quando os dados, a localização etc. não existem. | | QUERY\$1ERROR | Os erros surgem da execução da consulta do Spark SQL. | | SYNTAX\$1ERROR | Os erros surgem quando há um erro de sintaxe no script. | | THROTTLING\$1ERROR | Os erros surgem ao atingir a limitação de simultaneidade de serviços ou ao exceder a limitação de cotas de serviço. | | DATA\$1LAKE\$1FRAMEWORK\$1ERROR | Os erros surgem de estruturas de data lake com suporte nativo do AWS Glue, como Hudi, Iceberg etc. | | UNSUPPORTED\$1OPERATION\$1ERROR | Os erros surgem ao realizar uma operação não compatível. | | RESOURCES\$1ALREADY\$1EXISTS\$1ERROR | Os erros surgem quando um recurso a ser criado ou adicionado já existe. | | GLUE\$1INTERNAL\$1SERVICE\$1ERROR | Os erros surgem quando há um problema de serviço interno do AWS Glue. | | GLUE\$1OPERATION\$1TIMEOUT\$1ERROR | Os erros surgem quando uma operação do AWS Glue atinge o tempo limite. | | GLUE\$1VALIDATION\$1ERROR | Os erros surgem quando um valor exigido não pôde ser validado para um trabalho do AWS Glue. | | GLUE\$1JOB\$1BOOKMARK\$1VERSION\$1MISMATCH\$1ERROR | Os erros surgem quando o mesmo trabalho transcreve o mesmo bucket de origem e grava no mesmo destino ou em outro simultaneamente (simultaneidade >1) | | LAUNCH\$1ERROR | Os erros surgem durante a fase de lançamento do trabalho do AWS Glue. | | DYNAMODB\$1ERROR | Os erros genéricos surgem do serviço do Amazon DynamoDB. | | GLUE\$1ERROR | Os erros genéricos surgem do serviço do AWS Glue. | | LAKEFORMATION\$1ERROR | Os erros genéricos surgem do serviço do AWS Lake Formation. | | REDSHIFT\$1ERROR | Os erros genéricos surgem do serviço do Amazon Redshift. | | S3\$1ERROR | Os erros genéricos surgem do serviço do Amazon S3. | | SYSTEM\$1EXIT\$1ERROR | Erro genérico de saída do sistema. | | TIMEOUT\$1ERROR | Os erros genéricos surgem quando o trabalho falha devido ao tempo limite da operação. | | UNCLASSIFIED\$1SPARK\$1ERROR | Os erros genéricos surgem do Spark. | | UNCLASSIFIED\$1ERROR | Categoria de erro padrão. | ## Limitações **nota** O `glueContext` deve ser inicializado para publicar as métricas. Na Dimensão de origem, o valor é o caminho ou o nome da tabela do Amazon S3, dependendo do tipo de fonte. Além disso, se a origem for JDBC e a opção de consulta for usada, a string de consulta será definida na dimensão de origem. Se o valor tiver mais de 500 caracteres, ele será reduzido em 500 caracteres. Abaixo, estão as limitações do valor: + Os caracteres não ASCII serão removidos. + Se o nome da fonte não contiver nenhum caractere ASCII, ele será convertido para . ### Limitações e considerações sobre métricas de throughput + O DataFrame e o DynamicFrame baseado em DataFrame (por exemplo, JDBC, leitura de parquet no Amazon S3) são compatíveis, no entanto, o DynamicFrame baseado em RDD (por exemplo, leitura de csv, json no Amazon S3 etc.) não é compatível. Tecnicamente, todas as leituras e gravações visíveis na UI do Spark são compatíveis. + A métrica `recordsRead` será emitida se a fonte de dados for uma tabela de catálogo e o formato for JSON, CSV, text ou Iceberg. + As métricas `glue.driver.throughput.recordsWritten`, `glue.driver.throughput.bytesWritten` e `glue.driver.throughput.filesWritten` não estão disponíveis nas tabelas JDBC e Iceberg. + As métricas podem estar atrasadas. Se o trabalho for concluído em cerca de um minuto, talvez não haja métricas de throughput nas métricas do Amazon CloudWatch. # Monitoramento e depuração de trabalho Você pode coletar métricas sobre trabalhos do AWS Glue e visualizá-las nos consoles do AWS Glue e do Amazon CloudWatch para identificar e corrigir problemas. A criação do perfil dos seus trabalhos do AWS Glue requer as seguintes etapas: 1. Habilitar métricas: 1. Habilite a opção **Job metrics (Métricas de trabalho)** na definição do trabalho. Você pode habilitar a criação de perfil no console do AWS Glue ou como um parâmetro para o trabalho. Para obter mais informações, consulte [Definir propriedades de trabalho para trabalhos do Spark](add-job.md#create-job) ou [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md). 1. Habilite a opção **Métricas de observabilidade do AWS Glue** na definição do trabalho. É possível habilitar a observabilidade no console do AWS Glue ou como parâmetro para o trabalho. Para obter mais informações, consulte [Monitoramento com métricas de observabilidade do AWS Glue](monitor-observability.md). 1. Confirme se o script do trabalho inicializa um `GlueContext`. Por exemplo, o snippet de script a seguir inicializa um `GlueContext` e mostra onde o código perfilado é colocado no script. Este formato geral é usado nos cenários de depuração a seguir. ``` 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 import time ## @params: [JOB_NAME] args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) ... ... code-to-profile ... ... job.commit() ``` 1. Execute o trabalho. 1. Visualize as métricas: 1. Visualize as métricas de trabalho no console do AWS Glue e identifique métricas anormais para o driver ou um executor. 1. Verifique as métricas de observabilidade na página de monitoramento da execução de trabalhos, na página de detalhes da execução de trabalhos ou no Amazon CloudWatch. Para obter mais informações, consulte [Monitoramento com métricas de observabilidade do AWS Glue](monitor-observability.md). 1. Refine a causa raiz usando a métrica identificada. 1. Opcionalmente, confirme a causa raiz usando o fluxo de log do driver identificado ou executor do trabalho. **Casos de uso para métricas de observabilidade do AWS Glue** + [Depurar exceções OOM e anomalias de trabalho](monitor-profile-debug-oom-abnormalities.md) + [Depurar estágios exigentes e tarefas de retardatário](monitor-profile-debug-straggler.md) + [Monitorar o progresso de vários trabalhos](monitor-debug-multiple.md) + [Monitorar planejamento de capacidade de DPU](monitor-debug-capacity.md) + [Como usar a observabilidade do AWS Glue para monitorar a utilização de recursos para reduzir custos](https://aws.amazon.com/blogs/big-data/enhance-monitoring-and-debugging-for-aws-glue-jobs-using-new-job-observability-metrics) # Depurar exceções OOM e anomalias de trabalho Você pode depurar exceções de memória insuficiente (OOM) e anomalias de trabalho no AWS Glue. As seções a seguir descrevem cenários para depuração de exceções de memória insuficiente do driver do Apache Spark ou um executor do Spark. + [Depurar uma exceção OOM do driver](#monitor-profile-debug-oom-driver) + [Depurar uma exceção OOM do executor](#monitor-profile-debug-oom-executor) ## Depurar uma exceção OOM do driver Nesse cenário, um trabalho do Spark está lendo um grande número de arquivos pequenos do Amazon Simple Storage Service (Amazon S3). Ele converte os arquivos no formato Apache Parquet e, em seguida, os grava no Amazon S3. O driver do Spark está sendo executado sem memória. A entrada de dados do Amazon S3 tem mais de 1 milhão de arquivos em diferentes partições do Amazon S3. O código perfilado é assim: ``` data = spark.read.format("json").option("inferSchema", False).load("s3://input_path") data.write.format("parquet").save(output_path) ``` ### Visualizar as métricas perfiladas no console do AWS Glue O gráfico a seguir mostra o uso de memória como uma porcentagem para o driver e executores. Esse uso é representado como um ponto de dados cuja média é calculada com base nos valores relatados no último minuto. Você pode ver no perfil de memória do trabalho que a [memória do driver](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.jvm.heap.usage) ultrapassa o limite de 50% de uso rapidamente. Por outro lado, a [média de uso de memória](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) em todos os executores ainda é menos de 4%. Isso mostra claramente anomalia com a execução do driver nesse trabalho do Spark. ![\[O uso de memória em porcentagem para o driver e executores.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-oom-memoryprofile.png) A execução do trabalho logo falha, e o seguinte erro é exibido na guia **History (Histórico)** no console do AWS Glue: Command Failed with Exit Code 1 (Falha do comando com código de saída 1). Essa string de erro significa que o trabalho falhou devido a um erro sistêmico, que neste caso é a falta de memória do driver. ![\[A mensagem de erro exibida no console do AWS Glue.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-oom-errorstring.png) No console, escolha o link **Error logs** (Logs de erro) na guia **History** (Histórico) para confirmar a descoberta do CloudWatch Logs sobre a OOM do driver. Procure "**Error**" nos logs de erro do trabalho para confirmar que foi uma exceção OOM que falhou o trabalho: ``` # java.lang.OutOfMemoryError: Java heap space # -XX:OnOutOfMemoryError="kill -9 %p" # Executing /bin/sh -c "kill -9 12039"... ``` Na guia **History (Histórico)** do trabalho, escolha **Logs**. Você pode encontrar as seguintes evidências da execução do driver no CloudWatch Logs no início do trabalho. O driver do Spark tenta listar todos os arquivos em todos os diretórios, cria um `InMemoryFileIndex` e inicia uma tarefa por arquivo. Isso, por sua vez, resulta no driver do Spark precisar manter uma grande quantidade de estado na memória para rastrear todas as tarefas. Ele armazena em cache a lista completa de um grande número de arquivos para o índice na memória, o que resulta em um driver OOM. ### Corrigir o processamento de vários arquivos usando agrupamento Você pode corrigir o processamento de vários arquivos usando o recurso de *agrupamento* no AWS Glue. O agrupamento é habilitado automaticamente quando você usa quadros dinâmicos e quando o conjunto de dados de entrada tem um grande número de arquivos (mais de 50.000). Agrupar permite reunir vários arquivos em um grupo, e isso permite que uma tarefa processe todo o grupo em vez de um único arquivo. Como resultado, o driver do Spark armazena significativamente menos estado na memória para rastrear menos tarefas. Para obter mais informações sobre como habilitar manualmente o agrupamento para o seu conjunto de dados, consulte [Ler arquivos de entrada em grupos maiores](grouping-input-files.md). Para verificar o perfil de memória do trabalho do AWS Glue, crie o perfil do código a seguir com agrupamento habilitado: ``` df = glueContext.create_dynamic_frame_from_options("s3", {'paths': ["s3://input_path"], "recurse":True, 'groupFiles': 'inPartition'}, format="json") datasink = glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet", transformation_ctx = "datasink") ``` Você pode monitorar o perfil de memória e a movimentação de dados ETL no perfil de trabalho do AWS Glue. O driver é executado abaixo do limite de 50% de uso de memória ao longo de toda a duração do trabalho do AWS Glue. Os executores transmitem os dados do Amazon S3, os processam e os gravam no Amazon S3. Como resultado, eles consomem menos de 5% de memória a qualquer momento. ![\[O perfil de memória mostrando que o problema foi corrigido.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-oom-memoryprofile-fixed.png) O perfil de movimentação de dados abaixo mostra o número total de bytes do Amazon S3 que são [lidos](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) e [gravado](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes)s no último minuto por todos os executores conforme o trabalho progride. Ambos seguem um padrão semelhante conforme os dados são transmitidos em todos os executores. O trabalho termina o processamento de um milhão de arquivos em menos de três horas. ![\[O perfil de movimentação de dados mostrando que o problema foi corrigido.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-oom-etlmovement.png) ## Depurar uma exceção OOM do executor Nesse cenário, você pode saber como depurar exceções OOM que podem ocorrer em executores do Apache Spark. O código a seguir usa o leitor Spark MySQL para ler uma grande tabela de cerca de 34 milhões de linhas em um dataframe do Spark. Em seguida, ele grava no Amazon S3 em formato Parquet. Você pode fornecer as propriedades da conexão e usar as configurações padrão do Spark para ler a tabela. ``` val connectionProperties = new Properties() connectionProperties.put("user", user) connectionProperties.put("password", password) connectionProperties.put("Driver", "com.mysql.jdbc.Driver") val sparkSession = glueContext.sparkSession val dfSpark = sparkSession.read.jdbc(url, tableName, connectionProperties) dfSpark.write.format("parquet").save(output_path) ``` ### Visualizar as métricas perfiladas no console do AWS Glue Se a inclinação do gráfico de uso de memória for positiva e ultrapassar 50%, e se ocorrer uma falha no trabalho antes que a próxima métrica seja emitida, o esgotamento da memória será uma causa provável. O seguinte gráfico mostra que, dentro de um minuto da execução, a [média de uso de memória](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) em todos os executores ultrapassa rapidamente 50%. O uso atinge até 92%, e o contêiner que executa o executor é interrompido pelo Apache Hadoop YARN. ![\[A média de uso de memória em todos os executores.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-oom-2-memoryprofile.png) Como o seguinte gráfico mostra, há sempre um [único executor](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors) em execução até o trabalho falhar. Isso ocorre porque um novo executor é iniciado para substituir o executor eliminado. As leituras da fonte de dados JDBC não são paralelizadas por padrão porque isso exigiria particionamento de tabela em uma coluna e abrir várias conexões. Como resultado, apenas um executor lê na tabela completa sequencialmente. ![\[A execução do trabalho mostra um único executor em execução até que o trabalho falhe.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-oom-2-execution.png) Como o seguinte gráfico mostra, o Spark tenta iniciar uma nova tarefa quatro vezes antes da falha no trabalho. Você pode ver o [perfil de memória](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.used) de três executores. Cada executor usa rapidamente toda sua memória. O quarto executor fica sem memória e o trabalho falha. Como resultado, a métrica não é relatada imediatamente. ![\[Os perfis de memória dos executores.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-oom-2-exec-memprofile.png) Você pode confirmar na string de erro no console do AWS Glue que o trabalho falhou devido a exceções OOM, conforme mostrado na imagem a seguir. ![\[A mensagem de erro exibida no console do AWS Glue.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-oom-2-errorstring.png) **Logs de saída de trabalho:** para confirmação adicional da descoberta de uma exceção OOM de executor, consulte o CloudWatch Logs. Quando você pesquisar por **Error**, encontrará os quatro executores interrompidos aproximadamente na mesma janela de tempo, como mostrado no painel de métricas. Todos são encerrados pelo YARN à medida que excedem os limites de memória. Executor 1 ``` 18/06/13 16:54:29 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:54:29 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:54:29 ERROR YarnClusterScheduler: Lost executor 1 on ip-10-1-2-175.ec2.internal: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:54:29 WARN TaskSetManager: Lost task 0.0 in stage 0.0 (TID 0, ip-10-1-2-175.ec2.internal, executor 1): ExecutorLostFailure (executor 1 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` Executor 2 ``` 18/06/13 16:55:35 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:55:35 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:55:35 ERROR YarnClusterScheduler: Lost executor 2 on ip-10-1-2-16.ec2.internal: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:55:35 WARN TaskSetManager: Lost task 0.1 in stage 0.0 (TID 1, ip-10-1-2-16.ec2.internal, executor 2): ExecutorLostFailure (executor 2 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` Executor 3 ``` 18/06/13 16:56:37 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:56:37 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:56:37 ERROR YarnClusterScheduler: Lost executor 3 on ip-10-1-2-189.ec2.internal: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:56:37 WARN TaskSetManager: Lost task 0.2 in stage 0.0 (TID 2, ip-10-1-2-189.ec2.internal, executor 3): ExecutorLostFailure (executor 3 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` Executor 4 ``` 18/06/13 16:57:18 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:57:18 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:57:18 ERROR YarnClusterScheduler: Lost executor 4 on ip-10-1-2-96.ec2.internal: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:57:18 WARN TaskSetManager: Lost task 0.3 in stage 0.0 (TID 3, ip-10-1-2-96.ec2.internal, executor 4): ExecutorLostFailure (executor 4 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` ### Corrigir a configuração do tamanho da busca usando quadros dinâmicos do AWS Glue O executor ficou sem memória ao ler a tabela JDBC porque a configuração padrão para o tamanho da busca JDBC do Spark é zero. Isso significa que o driver JDBC no executor do Spark tenta buscar as 34 milhões de linhas no banco de dados em conjunto e as armazena em cache, embora o Spark transmita por meio de linhas, uma de cada vez. Com o Spark, você pode evitar esse cenário ao configurar o parâmetro de tamanho de busca como um valor padrão diferente de zero. Você também pode corrigir esse problema usando os quadros dinâmicos do AWS Glue. Por padrão, os quadros dinâmicos usam um tamanho de busca de 1.000 linhas, que normalmente é um valor suficiente. Como resultado, o executor não consome mais de 7% da memória total. O trabalho do AWS Glue é concluído em menos de dois minutos com apenas um único executor. Embora usar quadros dinâmicos do AWS Glue seja a abordagem recomendada, também é possível definir o tamanho de busca usando a propriedade `fetchsize` do Apache Spark. Consulte o [Guia do Spark SQL, DataFrames e conjuntos de dados](https://spark.apache.org/docs/2.2.0/sql-programming-guide.html#jdbc-to-other-databases). ``` val (url, database, tableName) = { ("jdbc_url", "db_name", "table_name") } val source = glueContext.getSource(format, sourceJson) val df = source.getDynamicFrame glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet", transformation_ctx = "datasink") ``` **Métricas perfiladas normais:** a [memória do executor](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) com quadros dinâmicos do AWS Glue jamais excede o limite seguro, conforme mostrado na imagem a seguir. Ele transmite nas linhas do banco de dados e armazena em cache apenas 1.000 linhas no driver JDBC a qualquer momento. Não ocorre uma exceção de falta de memória. ![\[Console do AWS Glue exibindo a memória do executor abaixo do limite de segurança.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-oom-2-memoryprofile-fixed.png) # Depurar estágios exigentes e tarefas de retardatário Você pode usar perfis de trabalho do AWS Glue para identificar estágios exigentes e tarefas de retardatário em seus trabalhos de extração, transformação e carga (ETL). Uma tarefa de retardatário leva muito mais tempo do que o restante das tarefas em um estágio de um trabalho do AWS Glue. Como resultado, o estágio leva mais tempo para ser concluído, o que também atrasa o tempo total de execução do trabalho. ## Reunir arquivos de entrada pequenos em arquivos de saída maiores Uma tarefa de retardatário pode ocorrer quando há uma distribuição não uniforme de trabalho em diferentes tarefas, ou um desvio de dados resulta em uma tarefa processando mais dados. Você pode criar o perfil do seguinte código (um padrão comum no Apache Spark) para reunir um grande número de arquivos pequenos em arquivos de saída maiores. Para este exemplo, o conjunto de dados de entrada é 32 GB de arquivos JSON com compactação Gzip. O conjunto de dados de saída tem aproximadamente 190 GB de arquivos JSON não compactados. O código perfilado é assim: ``` datasource0 = spark.read.format("json").load("s3://input_path") df = datasource0.coalesce(1) df.write.format("json").save(output_path) ``` ### Visualizar as métricas perfiladas no console do AWS Glue Você pode criar o perfil do trabalho para examinar quatro conjuntos de métricas diferentes: + Movimentação de dados ETL + Embaralhamento de dados em executores + Execução de trabalho + Perfil de memória **Movimentação de dados ETL**: no perfil **ETL Data Movement (Movimentação de dados ETL)**, os bytes são [lidos](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) bastante rapidamente por todos os executores no primeiro estágio concluído nos primeiros seis minutos. No entanto, o tempo total de execução do trabalho é de cerca de uma hora, principalmente consistindo em [gravações de dados](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes). ![\[Gráfico mostrando o perfil de movimentação de dados ETL.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-straggler-1.png) **Embaralhamento de dados em executores:** o número de bytes [lidos](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleLocalBytesRead) e [gravados](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleBytesWritten) durante o embaralhamento também mostra um pico antes da fase 2 terminar, conforme indicado pelas métricas **Job Execution (Execução do trabalho)** e **Data Shuffle (Embaralhamento de dados)**. Depois que os dados são embaralhados em todos os executores, as leituras e gravações prosseguem no executor número 3 apenas. ![\[As métricas de embaralhamento de dados nos executores.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-straggler-2.png) **Execução de trabalho:** como mostrado no gráfico a seguir, todos os outros executores estão ociosos e acabam sendo desativados às 10h09. Nesse momento, o número total de executores diminui a apenas um. Isso claramente mostra que o executor número 3 consiste na tarefa de retardatário que está levando o tempo de execução mais longo e está contribuindo para a maior parte do tempo de execução do trabalho. ![\[As métricas de execução para os executores ativos.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-straggler-3.png) **Perfil de memória:** após os dois primeiros estágios, apenas o [executor número 3](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.used) está ativamente consumindo memória para processar os dados. Os executores restantes estão simplesmente ociosos ou foram desativados logo após a conclusão dos dois primeiros estágios. ![\[As métricas para o perfil de memória após os dois primeiros estágios.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-straggler-4.png) ### Corrigir executores retardatários usando agrupamento Você pode evitar executores retardatários usando o recurso de *agrupamento* no AWS Glue. Use o agrupamento para distribuir os dados uniformemente em todos os executores e agrupar os arquivos em arquivos maiores usando todos os executores disponíveis no cluster. Para obter mais informações, consulte [Ler arquivos de entrada em grupos maiores](grouping-input-files.md). Para verificar as movimentações de dados ETL no AWS Glue, crie o perfil do código a seguir com agrupamento habilitado: ``` df = glueContext.create_dynamic_frame_from_options("s3", {'paths': ["s3://input_path"], "recurse":True, 'groupFiles': 'inPartition'}, format="json") datasink = glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "json", transformation_ctx = "datasink4") ``` **Movimentação de dados ETL:** as gravações de dados agora são transmitidas em paralelo com os dados lidos durante todo o tempo de execução do trabalho. Como resultado, o trabalho é concluído em oito minutos, muito mais rápido do que anteriormente. ![\[As movimentações de dados ETL mostrando que o problema foi corrigido.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-straggler-5.png) **Embaralhamento de dados em executores:** conforme os arquivos de entrada são agrupados durante as leituras usando o recurso de agrupamento, não há embaralhamento de dados dispendioso depois das leituras. ![\[As métricas de embaralhamento de dados mostrando que o problema foi corrigido.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-straggler-6.png) **Execução do trabalho:** as métricas de execução do trabalho mostram que o número total de executores ativos em execução e o processamento de dados permanece constante. Não há um único retardatário no trabalho. Todos os executores estão ativos e não são desativados até a conclusão do trabalho. Como não há embaralhamento intermediário dos dados nos executores, há somente uma única fase do trabalho. ![\[As métricas do widget de execução de trabalho mostrando que não há retardatários no trabalho.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-straggler-7.png) **Perfil de memória**: as métricas mostram o [consumo de memória ativa](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.used) em todos os executores, reconfirmando que há atividade em todos eles. À medida que os dados são transmitidos e gravados em paralelo, o total de espaço de memória de todos os executores é aproximadamente uniforme e bem abaixo do limite de segurança para todos os executores. ![\[As métricas de perfil de memória mostrando o consumo de memória ativa em todos os executores.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-straggler-8.png) # Monitorar o progresso de vários trabalhos Você pode criar o perfil de vários trabalhos do AWS Glue e monitorar o fluxo de dados entre eles. Esse é um padrão de fluxo de trabalho comum e requer monitoramento de andamento de trabalho individual, backlog de processamento de dados, reprocessamento de dados e marcadores de trabalho. **Topics** + [Código perfilado](#monitor-debug-multiple-profile) + [Visualizar as métricas perfiladas no console do AWS Glue](#monitor-debug-multiple-visualize) + [Corrigir o processamento de arquivos](#monitor-debug-multiple-fix) ## Código perfilado Neste fluxo de trabalho, você tem dois trabalhos: um de entrada e um de saída. O trabalho de entrada está programado para ser executado a cada 30 minutos usando um gatilho periódico. O trabalho de saída está programado para ser executado após cada execução bem-sucedida do trabalho de entrada. Essas tarefas agendadas são controladas usando gatilhos de trabalho. ![\[Captura de tela do console mostrando os gatilhos de trabalho que controlam a programação dos trabalhos de entrada e saída.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-multiple-1.png) **Trabalho de entrada**: esse trabalho lê dados de um local do Amazon Simple Storage Service (Amazon S3), transforma-os usando `ApplyMapping` e os grava em um local de preparação do Amazon S3. O código a seguir é o código perfilado para o trabalho de entrada: ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": ["s3://input_path"], "useS3ListImplementation":True,"recurse":True}, format="json") applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [map_spec]) datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": staging_path, "compression": "gzip"}, format = "json") ``` **Trabalho de saída**: esse trabalho lê a saída do trabalho de entrada no local de preparação no Amazon S3, transforma-a novamente e a grava em um destino: ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [staging_path], "useS3ListImplementation":True,"recurse":True}, format="json") applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [map_spec]) datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": output_path}, format = "json") ``` ## Visualizar as métricas perfiladas no console do AWS Glue O seguinte painel sobrepõe a métrica de bytes gravados do Amazon S3 do trabalho de entrada na métrica de bytes lidos do Amazon S3 no mesmo cronograma do trabalho de saída. O cronograma mostra diferentes execuções de trabalhos de entrada e saída. O trabalho de entrada (mostrado em vermelho) começa a cada 30 minutos. O trabalho de saída (mostrado em marrom) começa na conclusão do trabalho de entrada, com uma simultaneidade máxima de 1. ![\[Gráfico que mostra os dados lidos e gravados.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-multiple-4.png) Neste exemplo, [marcadores de trabalho](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html) não estão habilitados. Nenhum contexto de transformação é usado para habilitar marcadores de trabalho no código de script. **Histórico de trabalho**: os trabalhos de entrada e saída têm várias execuções, conforme mostrado na guia **History (Histórico)**, a partir do meio-dia. O trabalho de entrada no console do AWS Glue é semelhante a este: ![\[Captura de tela do console mostrando a guia History (Histórico) do trabalho de entrada.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-multiple-2.png) A imagem a seguir mostra o trabalho de saída: ![\[Captura de tela do console mostrando a guia History (Histórico) do trabalho de saída.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-multiple-3.png) **Primeiras execuções de trabalho**: como mostrado no gráfico de bytes de dados lidos e gravados abaixo, as primeiras execuções dos trabalhos de entrada e saída entre 12h e 12h30 mostram aproximadamente a mesma área sob as curvas. Essas áreas representam os bytes do Amazon S3 gravados pelo trabalho de entrada e os bytes do Amazon S3 lidos pelo trabalho de saída. Esses dados também são confirmados pela relação de bytes do Amazon S3 gravados (somados por 30 minutos: a frequência do acionador do trabalho de entrada). O ponto de dados da relação para a execução do trabalho de entrada que começou ao meio-dia também é 1. O gráfico a seguir mostra a relação do fluxo de dados em todas as execuções de trabalho: ![\[Gráfico mostrando a relação de fluxo de dados: bytes gravados e bytes lidos.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-multiple-5.png) **Segunda execução do trabalho**: na segunda execução do trabalho, existe uma clara diferença no número de bytes lidos pelo trabalho de saída em comparação com o número de bytes gravados pelo trabalho de entrada. Compare a área sob a curva nas duas execuções do trabalho de saída, ou compare as áreas na segunda execução dos trabalhos de entrada e saída. A relação dos bytes lidos e gravados mostra que o trabalho de saída lê cerca de 2,5x os dados gravados pelo trabalho de entrada no segundo período de 30 minutos das 12h30 às 13h. Isso ocorre porque o trabalho de saída reprocessou a saída da primeira execução do trabalho de entrada porque os marcadores de trabalho não foram ativados. Uma relação acima de 1 mostra que há um backlog adicional de dados que foi processado pelo trabalho de saída. **Terceira execução do trabalho**: o trabalho de entrada é bastante consistente em termos do número de bytes gravados (consulte a área sob as curvas vermelhas). No entanto, a terceira execução do trabalho de entrada foi maior que o esperado (consulte a extremidade longa da curva vermelha). Como resultado, a terceira execução do trabalho de saída iniciou com atraso. A terceira execução do trabalho processou apenas uma fração dos dados acumulados no local de preparação nos 30 minutos restantes entre 13h e 13h30. A relação do fluxo de bytes mostra que ele processou apenas 0,83 de dados gravados pela terceira execução do trabalho de entrada (consulte a relação às 13h). **Sobreposição de trabalhos de entrada e saída**: a quarta execução do trabalho de entrada começou às 13h30 de acordo com a programação, antes de a terceira execução do trabalho de saída ser concluída. Existe uma sobreposição parcial entre essas duas execuções de trabalho. No entanto, a terceira execução do trabalho de saída captura apenas os arquivos listados no local de preparação do Amazon S3 quando ela começou, em torno das 13h17. Isso consiste na saída de todos os dados da primeira execução do trabalho de entrada. A taxa real às 13h30 é em torno de 2,75. A terceira execução do trabalho de saída processou cerca de 2,75x de dados gravados pela quarta execução do trabalho de entrada das 13h30 às 14h. Como essas imagens mostram, o trabalho de saída reprocessa dados do local de preparação de todas as execuções anteriores do trabalho de entrada. Como resultado, a quarta execução do trabalho de saída é a mais longa e se sobrepõe à quinta execução do trabalho de entrada. ## Corrigir o processamento de arquivos Você deve garantir que o trabalho de saída processe apenas os arquivos que não foram processados por execuções anteriores do trabalho de saída. Para fazer isso, habilite marcadores de trabalho e defina o contexto de transformação no trabalho de saída, da seguinte forma: ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [staging_path], "useS3ListImplementation":True,"recurse":True}, format="json", transformation_ctx = "bookmark_ctx") ``` Com marcadores de trabalho ativados, o trabalho de saída não reprocessa os dados no local de preparação de todas as execuções anteriores do trabalho de entrada. Na imagem a seguir que mostra os dados lidos e gravados, a área sob a curva marrom é bastante consistente e semelhante às curvas vermelhas. ![\[Gráfico que mostra os dados lidos e gravados como linhas vermelhas e marrons.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-multiple-6.png) As relações de fluxo de bytes também permanecem cerca de 1 porque não há dados adicionais processados. ![\[Gráfico mostrando a relação de fluxo de dados: bytes gravados e bytes lidos\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-multiple-7.png) Uma execução do trabalho de saída é iniciada e captura os arquivos no local de preparação antes da próxima execução do trabalho de entrada começar a colocar mais dados no local de preparação. Desde que continue a fazer isso, ela processa apenas os arquivos capturados na execução do trabalho de entrada anterior, e a relação permanece próxima a 1. ![\[Gráfico mostrando a relação de fluxo de dados: bytes gravados e bytes lidos\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-multiple-7.png) Suponha que o trabalho de entrada leve mais tempo do que o esperado e, como resultado, o trabalho de saída capture arquivos no local de preparação de duas execuções do trabalho de entrada. A relação é maior que 1 para essa execução do trabalho de saída. No entanto, as próximas execuções do trabalho de saída não processam os arquivos que já foram processados pelas execuções anteriores do trabalho de saída. # Monitorar planejamento de capacidade de DPU Você pode usar métricas de trabalho no AWS Glue para estimar o número de unidades de processamento de dados (DPUs) que podem ser usadas para expandir um trabalho do AWS Glue. **nota** Esta página só é aplicável às versões 0.9 e 1.0 do AWS Glue. Versões posteriores do AWS Glue contêm recursos de economia de custos que introduzem considerações adicionais ao planejar a capacidade. **Topics** + [Código perfilado](#monitor-debug-capacity-profile) + [Visualizar as métricas perfiladas no console do AWS Glue](#monitor-debug-capacity-visualize) + [Determinar a capacidade de DPU ideal](#monitor-debug-capacity-fix) ## Código perfilado O script a seguir lê uma partição do Amazon Simple Storage Service (Amazon S3) contendo 428 arquivos JSON em gzip. O script aplica um mapeamento para alterar os nomes dos campos e os converte e grava no Amazon S3 no formato Apache Parquet. Você provisiona dez DPUs de acordo com o padrão e executa esse trabalho. ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [input_path], "useS3ListImplementation":True,"recurse":True}, format="json") applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [(map_spec]) datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet") ``` ## Visualizar as métricas perfiladas no console do AWS Glue **Execução de trabalho 1:** nessa execução de trabalho, mostramos como descobrir se há DPUs não provisionadas no cluster. A funcionalidade da execução do trabalho no AWS Glue mostra o [número total de executores ativamente em execução](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors), o [número de estágios concluídos](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.numCompletedStages) e o [número máximo de executores necessários](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors). O número máximo de executores necessário é calculado adicionando o número total de tarefas em execução e tarefas pendentes e dividindo pelas tarefas por executor. Esse resultado é uma medida do número total de executores necessários para satisfazer a carga atual. Por outro lado, o número de executores em execução ativamente mede quantos executores estão executando tarefas ativas do Apache Spark. À medida que o trabalho progride, o máximo necessário de executores pode mudar e normalmente diminui no final do trabalho conforme a fila de tarefas pendentes fica menor. A linha vermelha horizontal no gráfico a seguir mostra o número de executores máximos alocados, que depende do número de DPUs que você aloca para o trabalho. Nesse caso, você aloca 10 DPUs para a execução do trabalho. Uma DPU é reservada para gerenciamento. Nove DPUs executam dois executores cada, e um executor é reservado para o driver do Spark. O driver do Spark é executado dentro da aplicação principal. Portanto, o número máximo de executores alocados é 2\$19 - 1 = 17 executores. ![\[As métricas de trabalho mostrando executores ativos e máximo necessário de executores.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-capacity-1.png) Como o gráfico mostra, o número de executores máximos necessários começa em 107 no início do trabalho, enquanto o número de executores ativos permanece 17. Isso equivale ao número de executores máximos alocados com 10 DPUs. A relação entre o máximo de executores necessários e o máximo de executores alocados (adicionando 1 a ambos para o driver do Spark) fornece o fator de subprovisionamento: 108/18 = 6x. É possível provisionar 6 (de acordo com a taxa de provisionamento) \$1 9 (capacidade atual de DPU - 1) \$1 1 DPUs = 55 DPUs para expandir o trabalho a fim de executá-lo com o máximo de paralelismo e terminar mais rapidamente. O console do AWS Glue exibe as métricas de trabalho detalhadas como uma linha estática representando o número original do máximo de executores alocados. O console computa o máximo de executores alocados da definição do trabalho para as métricas. Em contrapartida, para as métricas detalhadas de execução do trabalho, o console computa o máximo de executores alocados da configuração de execução de trabalho, especificamente as DPUs alocadas para a execução do trabalho. Para visualizar as métricas da execução de um trabalho individual, selecione a execução do trabalho e selecione **View run metrics (Visualizar métricas de execução)**. ![\[As métricas de trabalho mostrando a movimentação de dados ETL.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-capacity-2.png) Analisando os bytes [lidos](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) e [gravados](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes) do Amazon S3, observe que o trabalho gasta os seis minutos de transmissão em dados do Amazon S3 e na gravação simultaneamente. Todos os núcleos nas DPUs alocadas estão lendo e gravando no Amazon S3. O número máximo de executores necessários sendo 107 também corresponde ao número de arquivos no caminho de entrada do Amazon S3: 428. Cada executor pode iniciar quatro tarefas do Spark para processar quatro arquivos de entrada (JSON gzip). ## Determinar a capacidade de DPU ideal Com base nos resultados da execução de trabalho anterior, você pode aumentar o número total de DPUs alocadas para 55 e ver como o trabalho é realizado. O trabalho é concluído em menos de três minutos, metade do tempo necessário anteriormente. A expansão do trabalho não é linear nesse caso porque ele é um trabalho de execução curta. Os trabalhos com tarefas de longa duração ou um grande número de tarefas (um grande número de executores máximos necessários) se beneficiam de uma aceleração da performance de expansão da DPU quase linear. ![\[Gráfico mostrando aumento do número total de DPUs alocadas\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-capacity-3.png) Como mostra a imagem a seguir, o número total de executores ativos atinge o máximo alocado: 107 executores. Da mesma forma, o máximo necessário de executores nunca é acima do máximo alocado de executores. O número máximo de executores necessários é calculado a partir da contagem de tarefas pendentes e ativamente em execução e, portanto, pode ser menor do que o número de executores ativos. Isso ocorre porque pode haver executores que estão parcial ou completamente ociosos por um curto período e ainda não estão desativados. ![\[Gráfico mostrando o número total de executores ativos que atingem o máximo alocado.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-capacity-4.png) Essa execução de trabalho usa seis vezes mais executores para ler e gravar no Amazon S3 simultaneamente. Como resultado, essa execução de trabalho usa mais largura de banda do Amazon S3 para leituras e gravações e termina mais rapidamente. ### Identificar DPUs provisionadas em excesso Em seguida, você pode determinar se expandir o trabalho com 100 DPUs (99 \$1 2 = 198 executores) ajuda a expandir mais. Como o seguinte gráfico mostra, o trabalho ainda tem três minutos para terminar. Da mesma forma, o trabalho não ser expandido além de 107 executores (configuração de 55 DPUs) e os 91 executores restantes são fornecidos em excesso e não são usados. Isso mostra que o aumento do número de DPUs nem sempre pode melhorar a performance, como evidente no máximo necessário de executores. ![\[Gráfico mostrando que a performance do trabalho nem sempre melhora aumentando o número de DPUs.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/monitor-debug-capacity-5.png) ### Comparar diferenças de tempo As três execuções de trabalho mostradas na tabela a seguir resumem os tempos de execução de trabalho para 10 DPUs, 55 DPUs e 100 DPUs. Você pode ver que a capacidade da DPU melhora o tempo de execução do trabalho usando as estimativas estabelecidas ao monitorar a primeira execução do trabalho. | ID do trabalho | Número de DPUs | Tempo de execução | | --- | --- | --- | | jr\$1c894524c8ef5048a4d9... | 10 | 6 min. | | jr\$11a466cf2575e7ffe6856... | 55 | 3 min. | | jr\$134fa1ed4c6aa9ff0a814... | 100 | 3 min. | # Solução de problemas de IA generativa para o Apache Spark no AWS Glue A solução de problemas de IA generativa para trabalhos do Apache Spark no AWS Glue é um novo recurso que ajuda engenheiros e cientistas de dados a diagnosticar e corrigir problemas nas aplicações Spark com facilidade. Utilizando tecnologias de machine learning e IA generativa, esse recurso analisa problemas em trabalhos do Spark e fornece uma análise detalhada da causa raiz, com recomendações práticas para resolver estes problemas. A solução de problemas de IA generativa para Apache Spark está disponível para trabalhos executados no AWS Glue versão 4.0 ou superior. | | | --- | | Transforme sua solução de problemas do Apache Spark com nosso agente de solução de problemas baseado em IA, agora compatível com todos os principais modos de implantação, incluindo o AWS Glue, o Amazon EMR-EC2, Amazon EMR Sem Servidor e os cadernos do Amazon SageMaker AI. Esse poderoso agente elimina processos complexos de depuração combinando interações de linguagem natural, análise de workload em tempo real e recomendações inteligentes de código em uma experiência perfeita. Para obter detalhes de implementação, consulte [What is Apache Spark Troubleshooting Agent for Amazon EMR](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/spark-troubleshoot.html). Veja a segunda demonstração em [Using the Troubleshooting Agent](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/spark-troubleshooting-using-troubleshooting-agent.html) para exemplos de solução de problemas do AWS Glue. | ## Como funciona a solução de problemas de IA generativa para o Apache Spark? Para trabalhos do Spark que apresentam falha, a solução de problemas de IA generativa analisa os metadados do trabalho e as métricas e logs precisos associados à assinatura do erro do trabalho para gerar uma análise da causa raiz e recomenda soluções específicas e práticas recomendadas para ajudar a resolver falhas no trabalho. ## Configuração da solução de problemas de IA generativa para trabalhos no Apache Spark ### Configurar permissões do IAM A concessão de permissões às APIs usadas pela solução de problemas do Spark para trabalhos no AWS Glue exige permissões apropriadas do IAM. Você pode obter permissões anexando a política da AWS a seguir personalizada à sua identidade do IAM (como usuário, perfil ou grupo). ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "glue:StartCompletion", "glue:GetCompletion" ], "Resource": [ "arn:aws:glue:*:*:completion/*", "arn:aws:glue:*:*:job/*" ] } ] } ``` ------ **nota** As duas APIs a seguir são usadas na política do IAM para permitir essa experiência por meio do Console do AWS Glue Studio: `StartCompletion` e `GetCompletion`. ### Atribuindo permissões Para conceder acesso, adicione as permissões aos seus usuários, grupos ou perfis: + Usuários e grupos no Centro de Identidade do IAM: criem um conjunto de permissões. Sigam as instruções em [Criar um conjunto de permissões](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtocreatepermissionset.html) no Guia do usuário do Centro de Identidade do IAM. + Usuários gerenciados no IAM por meio de um provedor de identidades: criem um perfil para federação de identidades. Sigam as instruções em [Criar um perfil para um provedor de identidade de terceiros (federação)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html) no Guia do Usuário do IAM. + Usuários do IAM: criem um perfil que o usuário possa assumir. Sigam as instruções em [Criar um perfil para um usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) no Guia do usuário do IAM. ## Execução da análise de solução de problemas com base na execução de um trabalho com falha Você pode acessar o recurso de solução de problemas por meio de vários caminhos no console do AWS Glue. Veja como começar: ### Opção 1: na página Lista de trabalhos 1. 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 **Trabalhos de ETL**. 1. Localize o trabalho que apresentou falha na lista de trabalhos. 1. Selecione a guia **Execuções** na seção de detalhes do trabalho. 1. Clique na execução do trabalho que apresentou falha que você deseja analisar. 1. Escolha **Solucionar problemas com IA** para iniciar a análise. 1. Quando a análise da solução de problemas estiver concluída, você poderá visualizar a análise da causa raiz e as recomendações na guia **Análise da solução de problemas** na parte inferior da tela. ![\[O GIF mostra a implementação de ponta a ponta de uma execução com falha e a solução do problema com a execução do recurso de IA.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/troubleshoot_spark_option_1_jobs_list.gif) ### Opção 2: usando a página Monitoramento da execução do trabalho 1. Navegue até a página de **Monitoramento da execução do trabalho**. 1. Localize a execução do trabalho que apresentou falha. 1. Escolha o menu suspenso **Ações**. 1. Escolha **Solucionar problemas com IA**. ![\[O GIF mostra a implementação de ponta a ponta de uma execução com falha e a solução do problema com a execução do recurso de IA.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/troubleshoot_spark_option_2_job_monitoring.gif) ### Opção 3: na página Detalhes da execução do trabalho 1. Navegue até a página de detalhes da execução do trabalho que apresentou falha clicando em **Visualizar detalhes** em uma execução com falha na guia **Execuções** ou selecionando a execução do trabalho na página **Monitoramento da execução do trabalho**. 1. Na página de detalhes da execução do trabalho, você encontrará a guia **Análise da solução de problemas**. ## Categorias de solução de problemas compatíveis Esse serviço se concentra em três categorias principais de problemas que engenheiros e desenvolvedores de dados frequentemente encontram em aplicações do Spark: + **Erros de configuração e acesso de recursos:** ao executar aplicações do Spark no AWS Glue, os erros de configuração e acesso de recursos estão entre os problemas mais comuns, porém difíceis de diagnosticar. Esses erros muitas vezes ocorrem quando a aplicação do Spark tenta interagir com recursos da AWS, mas encontra problemas de permissão, de falta de recursos ou de configuração. + **Problemas de memória do driver e do executor do Spark**: erros relacionados à memória em trabalhos do Apache Spark podem ser complexos de diagnosticar e resolver. Esses erros muitas vezes se manifestam quando os requisitos de processamento de dados excedem os recursos de memória disponíveis no nó do driver ou nos nós do executor. + **Problemas de capacidade de disco do Spark**: erros relacionados a armazenamento em trabalhos do Spark no AWS Glue muitas vezes surgem durante operações de shuffle, vazamento de dados ou no caso de transformações de dados em grande escala. Esses erros podem ser particularmente complicados porque talvez não se manifestem até que o trabalho esteja em execução por algum tempo, podendo desperdiçar tempo e recursos de computação valiosos. + **Erros de execução de consultas:** as falhas de consulta nas operações do Spark SQL e do DataFrame podem ser difíceis de solucionar porque as mensagens de erro podem não apontar claramente a causa raiz, e as consultas que funcionam bem com pequenos conjuntos de dados podem falhar repentinamente em grande escala. Esses erros se tornam ainda mais desafiadores quando ocorrem profundamente em canais de transformação complexos, onde o problema real pode resultar de problemas de qualidade de dados em estágios iniciais, em vez da própria lógica de consulta. **nota** Antes de implementar qualquer alteração sugerida no ambiente de produção, analise minuciosamente as alterações sugeridas. O serviço fornece recomendações com base em padrões e práticas recomendadas, mas seu caso de uso específico pode exigir considerações adicionais. ## Regiões compatíveis A solução de problemas de IA generativa para o Apache Spark está disponível nas seguintes regiões: + **África**: Cidade do Cabo (af-south-1) + **Ásia-Pacífico**: Hong Kong (ap-east-1), Tóquio (ap-northeast-1), Seul (ap-northeast-2), Osaka (ap-northeast-3), Mumbai (ap-south-1), Cingapura (ap-southeast-1), Sydney (ap-southeast-2) e Jacarta (ap-southeast-3) + **Europa**: Frankfurt (eu-central-1), Estocolmo (eu-north-1), Milão (eu-south-1), Irlanda (eu-west-1), Londres (eu-west-2) e Paris (eu-west-3) + **Oriente Médio**: Bahrein (me-south-1) e Emirados Árabes Unidos (me-central-1) + **América do** Norte: Canadá (ca-central-1) + **América do Sul**: São Paulo (sa-east-1) + **Estados Unidos**: Virgínia do Norte (us-east-1), Ohio (us-east-2), Norte da Califórnia (us-west-1) e Oregon (us-west-2) # Usar visões materializadas com AWS o Glue A versão 5.1 e posterior do AWS Glue oferece suporte à criação e ao gerenciamento de visões materializadas do Apache Iceberg no Catálogo de Dados do AWS Glue. Uma visão materializada é uma tabela gerenciada que armazena o resultado pré-computado de uma consulta SQL no formato Apache Iceberg e é atualizada incrementalmente à medida que as tabelas de origem subjacentes mudam. Você pode usar visões materializadas para simplificar os pipelines de transformação de dados e acelerar o desempenho das consultas para workloads de analytics complexas. Quando você cria uma visão materializada usando o Spark no AWS Glue, a definição da visão e os metadados são armazenados no Catálogo de Dados do AWS Glue. Os resultados pré-computados são armazenados como tabelas do Apache Iceberg em buckets do Tabelas do Amazon S3 ou buckets de uso geral do Amazon S3 em sua conta. O Catálogo de Dados do AWS Glue monitora automaticamente as tabelas de origem e atualiza as visões materializadas usando a infraestrutura de computação gerenciada. **Topics** + [Como as visões materializadas funcionam com o AWS Glue](#materialized-views-how-they-work) + [Pré-requisitos](#materialized-views-prerequisites) + [Configurar o Spark para usar visões materializadas](#materialized-views-configuring-spark) + [Criar visualizações materializadas](#materialized-views-creating) + [Consultar visões materializadas](#materialized-views-querying) + [Atualizar visões materializadas](#materialized-views-refreshing) + [Gerenciar visões materializadas](#materialized-views-managing) + [Permissões para visões materializadas](#materialized-views-permissions) + [Monitorar operações de visão materializada](#materialized-views-monitoring) + [Exemplo: concluir fluxo de trabalho](#materialized-views-complete-workflow) + [Considerações e limitações](#materialized-views-considerations-limitations) ## Como as visões materializadas funcionam com o AWS Glue As visões materializadas se integram ao AWS Glue por meio do suporte ao Iceberg do Apache Spark nos trabalhos do AWS Glue e nos cadernos do AWS Glue Studio. Ao configurar sua sessão do Spark para usar o Catálogo de Dados do AWS Glue, você pode criar visões materializadas usando a sintaxe SQL padrão. O otimizador do Spark pode reescrever automaticamente as consultas para usar visões materializadas quando elas oferecem melhor desempenho, eliminando a necessidade de modificar manualmente o código da aplicação. O Catálogo de Dados do AWS Glue trata de todos os aspectos operacionais da manutenção da visão materializada, incluindo: + Detecção das alterações nas tabelas de origem usando a camada de metadados do Apache Iceberg + Agendamento e execução de operações de atualização usando a computação gerenciada do Spark + Determinação se deve realizar uma atualização completa ou incremental com base nas alterações de dados + Armazenamento de resultados pré-computados no formato Apache Iceberg para acesso por vários mecanismos Você pode consultar visões materializadas do AWS Glue usando as mesmas interfaces SQL do Spark que você usa para tabelas comuns. Os dados pré-computados também podem ser acessados de outros serviços, incluindo Amazon Athena e Amazon Redshift. ## Pré-requisitos Para usar visões materializadas com o AWS Glue, você precisa: + Uma conta da + AWS Glue versão 5.1 ou mais recente + Tabelas de origem no formato Apache Iceberg registradas no Catálogo de Dados do AWS Glue + Permissões AWS Lake Formation configuradas para tabelas de origem e bancos de dados de destino + Um bucket do Tabelas do S3 ou um bucket do S3 de uso geral registrado com AWS Lake Formation para armazenar dados de visão materializada + Um perfil do IAM com permissões para acessar o Catálogo de Dados do AWS Glue e o Amazon S3 ## Configurar o Spark para usar visões materializadas Para criar e gerenciar visões materializadas no AWS Glue, configure sua sessão do Spark com as extensões e configurações de catálogo necessárias do Iceberg. O método de configuração varia dependendo se você está usando trabalhos do AWS Glue ou cadernos do AWS Glue Studio. ### Configurar trabalhos do AWS Glue Ao criar ou atualizar um trabalho do AWS Glue, adicione os seguintes parâmetros de configuração como parâmetros do trabalho: #### Para buckets do Tabelas do S3 ``` job = glue.create_job( Name='materialized-view-job', Role='arn:aws:iam::111122223333:role/GlueServiceRole', Command={ 'Name': 'glueetl', 'ScriptLocation': 's3://amzn-s3-demo-bucket/scripts/mv-script.py', 'PythonVersion': '3' }, DefaultArguments={ '--enable-glue-datacatalog': 'true', '--conf': 'spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions ' '--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog ' '--conf spark.sql.catalog.glue_catalog.type=glue ' '--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse ' '--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 ' '--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 ' '--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 ', '--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true ', '--conf spark.sql.catalog.s3t_catalog=org.apache.iceberg.spark.SparkCatalog ' '--conf spark.sql.catalog.s3t_catalog.type=glue ' '--conf spark.sql.catalog.s3t_catalog.glue.id=111122223333:s3tablescatalog/my-table-bucket ', '--conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 ', '--conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true ', '--conf spark.sql.catalog.s3t_catalog.warehouse=s3://amzn-s3-demo-bucket/mv-warehouse ' '--conf spark.sql.catalog.s3t_catalog.glue.region=us-east-1 ' '--conf spark.sql.defaultCatalog=s3t_catalog ' '--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true ' '--conf spark.sql.materializedViews.metadataCache.enabled=true' }, GlueVersion='5.1' ) ``` #### Para buckets de uso geral do S3 ``` job = glue.create_job( Name='materialized-view-job', Role='arn:aws:iam::111122223333:role/GlueServiceRole', Command={ 'Name': 'glueetl', 'ScriptLocation': 's3://amzn-s3-demo-bucket/scripts/mv-script.py', 'PythonVersion': '3' }, DefaultArguments={ '--enable-glue-datacatalog': 'true', '--conf': 'spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions ' '--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog ' '--conf spark.sql.catalog.glue_catalog.type=glue ' '--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse ' '--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 ' '--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 ', '--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 ', '--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true ', '--conf spark.sql.defaultCatalog=glue_catalog ' '--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true ' '--conf spark.sql.materializedViews.metadataCache.enabled=true' }, GlueVersion='5.1' ) ``` ### Configurar cadernos do AWS Glue Studio Nos cadernos do AWS Glue Studio, configure sua sessão do Spark usando o comando mágico %%configure no início do seu caderno: ``` %%configure { "conf": { "spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions", "spark.sql.catalog.glue_catalog": "org.apache.iceberg.spark.SparkCatalog", "spark.sql.catalog.glue_catalog.type": "glue", "spark.sql.catalog.glue_catalog.warehouse": "s3://amzn-s3-demo-bucket/warehouse", "spark.sql.catalog.glue_catalog.glue.region": "us-east-1", "spark.sql.catalog.glue_catalog.glue.id": "111122223333", "spark.sql.catalog.glue_catalog.glue.account-id": "111122223333", "spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true", "spark.sql.defaultCatalog": "glue_catalog", "spark.sql.optimizer.answerQueriesWithMVs.enabled": "true", "spark.sql.materializedViews.metadataCache.enabled": "true" } } ``` ### Habilitar a atualização incremental Para habilitar a otimização da atualização incremental, adicione as seguintes propriedades de configuração aos parâmetros do seu trabalho ou à configuração do caderno: ``` --conf spark.sql.optimizer.incrementalMVRefresh.enabled=true --conf spark.sql.optimizer.incrementalMVRefresh.deltaThresholdCheckEnabled=false ``` ### Parâmetros de configuração Os seguintes parâmetros de configuração controlam o comportamento da visão materializada: + `spark.sql.extensions`: permite extensões de sessão do Iceberg Spark necessárias para o suporte à visão materializada. + `spark.sql.optimizer.answerQueriesWithMVs.enabled`: permite reescrita automática de consultas para usar visões materializadas. Defina como true para ativar essa otimização. + `spark.sql.materializedViews.metadataCache.enabled`: permite o armazenamento em cache de metadados de visão materializada para otimização de consultas. Defina como true para melhorar o desempenho da reescrita de consultas. + `spark.sql.optimizer.incrementalMVRefresh.enabled`: permite a otimização incremental da atualização. Defina como true para processar somente os dados alterados durante as operações de atualização. + `spark.sql.optimizer.answerQueriesWithMVs.decimalAggregateCheckEnabled`: controla a validação de operações de agregação decimal na reescrita de consultas. Defina como false para desabilitar determinadas verificações de estouro decimal. ## Criar visualizações materializadas Você cria visões materializadas usando a instrução SQL CREATE MATERIALIZED VIEW nos trabalhos ou cadernos do AWS Glue. A definição da visão especifica a lógica de transformação como uma consulta SQL que faz referência a uma ou mais tabelas de origem. ### Criar uma visão materializada básica em trabalhos do AWS Glue O exemplo a seguir demonstra como criar uma visão materializada em um script de trabalho do AWS Glue. Use nomes de tabela totalmente qualificados com convenção de nomenclatura de três partes na definição da visão: ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session # Create materialized view spark.sql(""" CREATE MATERIALIZED VIEW customer_orders AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name """) ``` ### Criar uma visão materializada com atualização automática Para configurar a atualização automática, especifique uma programação de atualização ao criar a visão, usando nomes de tabela totalmente qualificados com convenção de nomenclatura de três partes na definição da visão: ``` spark.sql(""" CREATE MATERIALIZED VIEW customer_orders SCHEDULE REFRESH EVERY 1 HOUR AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name """) ``` ### Criar uma visão materializada com referências de catálogos cruzados Quando suas tabelas de origem estiverem em um catálogo diferente da visão materializada, use nomes de tabela totalmente qualificados com convenção de nomenclatura em três partes, tanto no nome da visão quanto na definição da visão: ``` spark.sql(""" CREATE MATERIALIZED VIEW s3t_catalog.analytics.customer_summary AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name """) ``` ### Criar visões materializadas em cadernos do AWS Glue Studio Nos cadernos do AWS Glue Studio, você pode usar o comando mágico %%sql para criar visões materializadas, usando nomes de tabela totalmente qualificados com convenção de nomenclatura de três partes na definição da visão: ``` %%sql CREATE MATERIALIZED VIEW customer_orders AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name ``` ## Consultar visões materializadas Depois de criar uma visão materializada, você pode consultá-la como qualquer outra tabela usando instruções SQL SELECT padrão em seus trabalhos ou cadernos do AWS Glue. ### Consultas em trabalhos no AWS Glue ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session # Query materialized view result = spark.sql("SELECT * FROM customer_orders") result.show() ``` ### Consultas em cadernos AWS Glue Studio ``` %%sql SELECT * FROM customer_orders ``` ### Reescrita automática de consultas Quando a reescrita automática de consultas está habilitada, o otimizador do Spark analisa suas consultas e usa automaticamente visões materializadas quando elas podem melhorar o desempenho. Por exemplo, se você executar a seguinte consulta: ``` result = spark.sql(""" SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM orders GROUP BY customer_name """) ``` O otimizador do Spark reescreve automaticamente essa consulta para usar a visão materializada customer\$1orders em vez de processar a tabela de pedidos base, desde que a visão materializada seja atual. ### Verificar a reescrita automática de consulta Para verificar se uma consulta usa a reescrita automática de consultas, use o comando EXPLAIN EXTENDED: ``` spark.sql(""" EXPLAIN EXTENDED SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM orders GROUP BY customer_name """).show(truncate=False) ``` No plano de execução, procure o nome da visão materializada na operação BatchScan. Se o plano mostrar BatchScan glue\$1catalog.analytics.customer\$1orders em vez de BatchScan glue\$1catalog.sales.orders, a consulta foi automaticamente reescrita para usar a visão materializada. Observe que a reescrita automática da consulta requer tempo para que o cache de metadados do Spark seja preenchido após a criação de uma visão materializada. Normalmente, esse processo é concluído em 30 segundos. ## Atualizar visões materializadas Você pode atualizar as visões materializadas usando dois métodos: atualização completa ou atualização incremental. A atualização completa recalcula toda a visão materializada de todos os dados da tabela base, enquanto a atualização incremental processa somente os dados que foram alterados desde a última atualização. ### Atualização manual completa nos trabalhos do AWS Glue Para realizar uma atualização completa de uma visão materializada: ``` spark.sql("REFRESH MATERIALIZED VIEW customer_orders FULL") # Verify updated results result = spark.sql("SELECT * FROM customer_orders") result.show() ``` ### Atualização incremental manual em trabalhos do AWS Glue Para realizar uma atualização incremental, certifique-se de que a atualização incremental esteja ativada na configuração da sua sessão do Spark e, em seguida, execute: ``` spark.sql("REFRESH MATERIALIZED VIEW customer_orders") # Verify updated results result = spark.sql("SELECT * FROM customer_orders") result.show() ``` O Catálogo de Dados do AWS Glue determina automaticamente se a atualização incremental é aplicável com base na definição da visão e na quantidade de dados alterados. Se a atualização incremental não for possível, a operação retornará à atualização completa. ### Atualização nos cadernos do AWS Glue Studio Em cadernos, use o comando mágico %%sql: ``` %%sql REFRESH MATERIALIZED VIEW customer_orders FULL ``` ### Verificar execução da atualização incremental Para confirmar que a atualização incremental foi executada com sucesso, habilite o registro em log de depuração em seu trabalho do AWS Glue: ``` from awsglue.context import GlueContext from pyspark.context import SparkContext import logging sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session # Enable debug logging logger = logging.getLogger('org.apache.spark.sql') logger.setLevel(logging.DEBUG) # Execute refresh spark.sql("REFRESH MATERIALIZED VIEW customer_orders") ``` Pesquise a seguinte mensagem nos logs dos trabalhos do AWS Glue: ``` DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh ``` ## Gerenciar visões materializadas O AWS Glue fornece comandos SQL para gerenciar o ciclo de vida das visões materializadas em seus trabalhos e cadernos. ### Descrever uma visão materializada Para visualizar metadados sobre uma visão materializada, incluindo sua definição, status de atualização e data e hora da última atualização: ``` spark.sql("DESCRIBE EXTENDED customer_orders").show(truncate=False) ``` ### Alterar uma visão materializada Para modificar o cronograma de atualização de uma visão materializada existente: ``` spark.sql(""" ALTER MATERIALIZED VIEW customer_orders ADD SCHEDULE REFRESH EVERY 2 HOURS """) ``` Para remover a atualização automática: ``` spark.sql(""" ALTER MATERIALIZED VIEW customer_orders DROP SCHEDULE """) ``` ### Eliminar uma visão materializada Para excluir uma visão materializada: ``` spark.sql("DROP MATERIALIZED VIEW customer_orders") ``` Esse comando remove a definição de visão materializada do Catálogo de Dados do AWS Glue e exclui os dados subjacentes da tabela do Iceberg do seu bucket do S3. ### Listar visões materializadas Para listar todas as visões materializadas em um banco de dados: ``` spark.sql("SHOW VIEWS FROM analytics").show() ``` ## Permissões para visões materializadas Para criar e gerenciar visões materializadas, você deve configurar as permissões do AWS Lake Formation. O perfil do IAM que cria a visão materializada (o perfil definidor) requer permissões específicas nas tabelas de origem e nos bancos de dados de destino. ### Permissões necessárias para o perfil de definidor O perfil deve ter as seguintes permissões: + Nas tabelas de origem: permissões SELECT ou ALL sem filtros de linha, coluna ou célula + No banco de dados de destino: permissão CREATE\$1TABLE + No Catálogo de Dados do AWS Glue: permissões das APIs GetTable e CreateTable Quando você cria uma visão materializada, o ARN do perfil definidor é armazenado na definição da visão. O Catálogo de Dados do AWS Glue assume esse perfil ao executar operações de atualização automática. Se o perfil do definidor perder o acesso às tabelas de origem, as operações de atualização falharão até que as permissões sejam restauradas. ### Permissões do IAM para trabalhos do AWS Glue O perfil do IAM do trabalho do AWS Glue requer as seguintes permissões: ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "glue:GetCatalog", "glue:GetCatalogs", "glue:GetTable", "glue:GetTables", "glue:CreateTable", "glue:UpdateTable", "glue:DeleteTable", "glue:GetDatabase", "glue:GetDatabases", "cloudwatch:PutMetricData" ], "Resource": "*" }, { "Effect": "Allow", "Action": [ "s3:GetObject", "s3:PutObject", "s3:DeleteObject" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket/*" ] }, { "Effect": "Allow", "Action": [ "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket" ] }, { "Effect": "Allow", "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents" ], "Resource": [ "arn:aws:logs:*:*:*:/aws-glue/*" ] }, { "Effect": "Allow", "Action": [ "lakeformation:GetDataAccess" ], "Resource": "*" } ] } ``` O perfil que você usa para atualizar automaticamente a visão materializada deve ter a permissão iam:PassRole no perfil. ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::111122223333:role/materialized-view-role-name" ] } ] } ``` Para que o Glue atualize automaticamente a visão materializada para você, o perfil também deve ter a política de confiança a seguir que permite que o serviço assuma o perfil. ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::111122223333:role/materialized-view-role-name" ] } ] } ``` Se a visão materializada estiver armazenada em buckets do Tabelas do S3, também precisará adicionar a seguinte permissão ao perfil. ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3tables:PutTableMaintenanceConfiguration" ], "Resource": "arn:aws:s3tables:*:123456789012:*" } ] } ``` ### Conceder acesso às visões materializadas Para conceder acesso a outros usuários para consultar uma visão materializada, use AWS Lake Formation para conceder a permissão SELECT na tabela de visão materializada. Os usuários podem consultar a visão materializada sem precisar de acesso direto às tabelas de origem subjacentes. Para obter informações detalhadas sobre como configurar as permissões do Lake Formation, consulte Conceder e revogar permissões nos recursos do Catálogo de Dados no Guia do Desenvolvedor do AWS Lake Formation. ## Monitorar operações de visão materializada O Catálogo de Dados do AWS Glue publica métricas e logs para operações de atualização de visões materializadas no Amazon CloudWatch. Você pode monitorar o status da atualização, a duração e o volume de dados processados por meio das métricas do CloudWatch. ### Visualizar logs de trabalho Para visualizar logs de trabalhos do AWS Glue que criam ou atualizam visões materializadas: 1. Abra o console do AWS Glue. 1. Selecione Trabalhos no painel de navegação. 1. Selecione seu trabalho e escolha Execuções. 1. Selecione uma execução específica e escolha Logs para visualizar os logs do CloudWatch. ### Definir alarmes Para receber notificações quando as operações de atualização falharem ou excederem a duração esperada, crie alarmes do CloudWatch nas métricas de visão materializada. Você também pode configurar as regras do Amazon EventBridge para acionar respostas automatizadas para atualizar eventos. ## Exemplo: concluir fluxo de trabalho O exemplo a seguir demonstra um fluxo de trabalho completo para criar e usar uma visão materializada no AWS Glue. ### Exemplo de script de trabalho do AWS Glue ``` 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 args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) # Create database and base table spark.sql("CREATE DATABASE IF NOT EXISTS sales") spark.sql("USE sales") spark.sql(""" CREATE TABLE IF NOT EXISTS orders ( id INT, customer_name STRING, amount DECIMAL(10,2), order_date DATE ) """) # Insert sample data spark.sql(""" INSERT INTO orders VALUES (1, 'John Doe', 150.00, DATE('2024-01-15')), (2, 'Jane Smith', 200.50, DATE('2024-01-16')), (3, 'Bob Johnson', 75.25, DATE('2024-01-17')) """) # Create materialized view spark.sql(""" CREATE MATERIALIZED VIEW customer_summary AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name """) # Query the materialized view print("Initial materialized view data:") spark.sql("SELECT * FROM customer_summary").show() # Insert additional data spark.sql(""" INSERT INTO orders VALUES (4, 'Jane Smith', 350.00, DATE('2024-01-18')), (5, 'Bob Johnson', 100.25, DATE('2024-01-19')) """) # Refresh the materialized view spark.sql("REFRESH MATERIALIZED VIEW customer_summary FULL") # Query updated results print("Updated materialized view data:") spark.sql("SELECT * FROM customer_summary").show() job.commit() ``` ### Exemplo de caderno do AWS Glue Studio ``` %%configure { "conf": { "spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions", "spark.sql.catalog.glue_catalog": "org.apache.iceberg.spark.SparkCatalog", "spark.sql.catalog.glue_catalog.type": "glue", "spark.sql.catalog.glue_catalog.warehouse": "s3://amzn-s3-demo-bucket/warehouse", "spark.sql.catalog.glue_catalog.glue.region": "us-east-1", "spark.sql.catalog.glue_catalog.glue.id": "111122223333", "spark.sql.catalog.glue_catalog.glue.account-id": "111122223333", "spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true", "spark.sql.defaultCatalog": "glue_catalog", "spark.sql.optimizer.answerQueriesWithMVs.enabled": "true", "spark.sql.materializedViews.metadataCache.enabled": "true" } } ``` ``` %%sql CREATE DATABASE IF NOT EXISTS sales ``` ``` %%sql USE sales ``` ``` %%sql CREATE TABLE IF NOT EXISTS orders ( id INT, customer_name STRING, amount DECIMAL(10,2), order_date DATE ) ``` ``` %%sql INSERT INTO orders VALUES (1, 'John Doe', 150.00, DATE('2024-01-15')), (2, 'Jane Smith', 200.50, DATE('2024-01-16')), (3, 'Bob Johnson', 75.25, DATE('2024-01-17')) ``` ``` %%sql CREATE MATERIALIZED VIEW customer_summary AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name ``` ``` %%sql SELECT * FROM customer_summary ``` ``` %%sql INSERT INTO orders VALUES (4, 'Jane Smith', 350.00, DATE('2024-01-18')), (5, 'Bob Johnson', 100.25, DATE('2024-01-19')) ``` ``` %%sql REFRESH MATERIALIZED VIEW customer_summary FULL ``` ``` %%sql SELECT * FROM customer_summary ``` ## Considerações e limitações Pense no seguinte ao usar visões materializadas com o AWS Glue: + Visões materializadas requerem o AWS Glue versão 5.1 ou posterior. + As tabelas de origem devem ser tabelas do Apache Iceberg registradas no Catálogo de Dados do AWS Glue. Tabelas do Apache Hive, do Apache Hudi e do Delta Lake da Linux Foundation não são compatíveis no lançamento. + As tabelas de origem devem residir na mesma Região e conta que a visão materializada. + Todas as tabelas de origem devem ser regidas pelo AWS Lake Formation. Permissões somente do IAM e acesso híbrido não são compatíveis. + As visões materializadas não podem referenciar as visões do Catálogo de Dados do AWS Glue, visões de vários dialetos ou outras visões materializadas como tabelas de origem. + O perfil definidor das visões deve ter acesso total de leitura (permissão SELECT ou ALL) em todas as tabelas de origem sem a aplicação de filtros de linha, coluna ou célula. + Com o tempo, as visões materializadas se tornam consistentes com as tabelas de origem. Durante a janela de atualização, as consultas podem retornar dados obsoletos. Execute a atualização manual para obter consistência imediata. + O intervalo mínimo de atualização automática é uma hora. + A atualização incremental oferece suporte a um subconjunto restrito de operações SQL. A definição da visão deve ser um único bloco SELECT-FROM-WHERE-GROUP BY-HAVING e não pode conter operações de conjunto, subconsultas, a palavra-chave DISTINCT em funções SELECT ou agregadas, funções de janela ou junções que não sejam INNER JOIN. + A atualização incremental não oferece suporte a funções definidas pelo usuário ou a determinadas funções integradas. Somente um subconjunto das funções integradas do Spark SQL é compatível. + A reescrita automática de consultas considera somente visões materializadas cujas definições pertencem a um subconjunto SQL restrito semelhante às restrições de atualização incremental. + Identificadores contendo caracteres especiais que não sejam caracteres alfanuméricos e sublinhados não são compatíveis nas consultas CREATE MATERIALIZED VIEW. Isso se aplica a todos os tipos de identificadores, incluindo nomes de catálogo/namespace/tabela, nomes de campos de coluna e estrutura, CTEs e aliases. + As colunas de visão materializada que começam com o prefixo \$1\$1ivm são reservadas para uso do sistema. A Amazon se reserva o direito de modificar ou remover essas colunas em versões futuras. + As cláusulas SORT BY, LIMIT, OFFSET, CLUSTER BY e ORDER BY não são compatíveis com as definições de visão materializada. + Tabelas de origem entre regiões e entre contas não são compatíveis. + As tabelas referenciadas na consulta de visão devem usar a convenção de nomenclatura em três partes (por exemplo, glue\$1catalog.my\$1db.my\$1table) porque a atualização automática não usa configurações padrão de catálogo e banco de dados. + As operações de atualização completa substituem a tabela inteira e tornam os snapshots anteriores indisponíveis. + Funções não determinísticas, como rand() ou current\$1timestamp(), não são compatíveis nas definições de visão materializada.