# Lidar com trabalhos do Spark no AWS Glue Fornece informações sobre os trabalhos d ETL do AWS Glue for Spark. **Topics** + [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md) + [Trabalhos Spark e PySpark do AWS Glue](spark_and_pyspark.md) + [Tipos de operadores do AWS Glue](worker-types.md) + [Trabalhos de transmissão de ETL no AWS Glue](add-job-streaming.md) + [Correspondência de registros com o FindMatches do AWS Lake Formation](machine-learning.md) + [Migrar programas do Apache Spark para o AWS Glue](glue-author-migrate-apache-spark.md) # Usar parâmetros de tarefa em tarefas do AWS Glue Ao criar uma tarefa do AWS Glue, você define alguns campos padrão, como `Role` e `WorkerType`. Você pode fornecer informações adicionais de configuração por meio dos campos `Argument` (**Job Parameters** no console). Nesses campos, você pode fornecer trabalhos do AWS Glue com os argumentos (parâmetros) listados neste tópico. Para obter mais informações sobre a API do AWS Glue, consulte [Tarefas](aws-glue-api-jobs-job.md). **nota** Os argumentos do trabalho têm um limite máximo de tamanho de 260 KB. Uma verificação de validação gerará um erro se o tamanho do argumento for maior que 260 KB. ## Definir parâmetros de trabalho Você pode configurar um trabalho pelo console, na guia **Job details** (Detalhes do trabalho), no cabeçalho **Job Parameters** (Parâmetros do trabalho). Você também pode configurar um trabalho usando a AWS CLI definindo `DefaultArguments` ou `NonOverridableArguments` em um trabalho ou definindo `Arguments` em uma execução de trabalho. Os argumentos definidos no trabalho serão transmitidos toda vez que o trabalho for executado, enquanto os argumentos definidos na execução do trabalho serão transmitidos somente para essa execução individual. Por exemplo, seguir temos a sintaxe para a execução de um trabalho usando `--arguments` para definir um parâmetro do trabalho. ``` $ aws glue start-job-run --job-name "CSV to CSV" --arguments='--scriptLocation="s3://my_glue/libraries/test_lib.py"' ``` ## Acessar parâmetros do trabalho Ao escrever scripts AWS Glue, talvez você queira acessar os valores dos parâmetros do trabalho para alterar o comportamento do seu próprio código. Fornecemos métodos auxiliares para fazer isso em nossas bibliotecas. Esses métodos resolvem os valores dos parâmetros de execução do trabalho que substituem os valores dos parâmetros do trabalho. Ao resolver parâmetros definidos em vários locais, o trabalho `NonOverridableArguments` substituirá a execução do trabalho `Arguments`, que substituirá o trabalho. `DefaultArguments` **No Python:** Em trabalhos do Python, fornecemos uma função denominada `getResolvedParameters`. Para obter mais informações, consulte [Acessar parâmetros usando `getResolvedOptions`](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md). Os parâmetros do trabalho estão disponíveis na variável `sys.argv`. **No Scala:** Em trabalhos do Scala, fornecemos um objeto denominado `GlueArgParser`. Para obter mais informações, consulte [AWS GlueAPIs GlueArgParser em Scala no](glue-etl-scala-apis-glue-util-glueargparser.md). Os parâmetros do trabalho estão disponíveis na variável `sysArgs`. ## Referência de parâmetros de trabalho **O AWS Glue reconhece os seguintes nomes de argumento que podem ser usados para configurar o ambiente de script para os trabalhos e as execuções de trabalho:** **`--additional-python-modules`** Uma lista delimitada por vírgulas representando um conjunto de pacotes do Python a serem instalados. Você pode instalar pacotes do PyPI ou fornecer uma distribuição personalizada. Uma entrada de pacote PyPI estará no formato `package==version`, com o nome PyPI e a versão do seu pacote de destino. Uma entrada de distribuição personalizada é o caminho do S3 para a distribuição. As entradas usam a correspondência de versão do Python para combinar pacote e versão. Isso significa que você precisará usar dois sinais de igual, como `==`. Existem outros operadores de correspondência de versão. Para obter mais informações, consulte [PEP 440](https://peps.python.org/pep-0440/#version-matching). Para passar as opções de instalação do módulo para o `pip3`, use o parâmetro [--python-modules-installer-option](#python-modules-installer-option). **`--auto-scale-within-microbatch`** O valor padrão é true. Esse parâmetro só pode ser usado para trabalhos de streaming do AWS Glue, os quais processam os dados de streaming em uma série de microlotes, e o ajuste de escala automático deve estar habilitado. Ao definir esse valor como falso, ele calcula a média móvel exponencial da duração do lote para microlotes concluídos e compara esse valor com o tamanho da janela para determinar se o número de executores deve ser aumentado ou reduzido. O ajuste de escala só acontece quando um microlote é concluído. Ao definir esse valor como verdadeiro, durante um microlote, ele aumenta a escala verticalmente quando o número de tarefas do Spark permanece o mesmo por 30 segundos ou o processamento em lote atual é maior que o tamanho da janela. O número de executores diminuirá se um executor ficar inativo por mais de 60 segundos ou se a média móvel exponencial da duração do lote for baixa. **`--class`** A classe Scala que serve como ponto de entrada para o seu script Scala. Isso se aplicará somente se `--job-language` for definido como `scala`. **`--continuous-log-conversionPattern`** Especifica um padrão personalizado de conversão de logs para um trabalho habilitado para registro em log contínuo. 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-logGroup`** Especifica um nome de grupo de logs do Amazon CloudWatch personalizado para um trabalho habilitado para registro em log contínuo. **`--continuous-log-logStreamPrefix`** Especifica um prefixo de fluxo de logs do CloudWatch personalizado para um trabalho habilitado para registro em log contínuo. **`--customer-driver-env-vars` e da `--customer-executor-env-vars`** Esses parâmetros definem variáveis de ambiente no sistema operacional, respectivamente, para cada operador (driver ou executor). É possível usar esses parâmetros ao criar plataformas e estruturas personalizadas com base no AWS Glue para permitir que seus usuários escrevam trabalhos em cima dele. A ativação desses dois sinalizadores permitirá definir variáveis de ambiente diferentes no driver e no executor, respectivamente, sem precisar injetar a mesma lógica no próprio script de trabalho. **Exemplo de uso** Este exemplo mostra como usar esses parâmetros: ``` "—customer-driver-env-vars", "CUSTOMER_KEY1=VAL1,CUSTOMER_KEY2=\"val2,val2 val2\"", "—customer-executor-env-vars", "CUSTOMER_KEY3=VAL3,KEY4=VAL4" ``` Defini-los no argumento de execução do trabalho equivale a executar os seguintes comandos: No driver: + export CUSTOMER\$1KEY1=VAL1 + export CUSTOMER\$1KEY2="val2,val2 val2" No executor: + export CUSTOMER\$1KEY3=VAL3 Em seguida, no próprio script de trabalho, você pode recuperar as variáveis de ambiente usando `os.environ.get("CUSTOMER_KEY1")` ou `System.getenv("CUSTOMER_KEY1")`. **Sintaxe imposta** Observe os seguintes padrões ao definir variáveis de ambiente: + Cada chave deve ter o `CUSTOMER_ prefix`. Por exemplo: para `"CUSTOMER_KEY3=VAL3,KEY4=VAL4"`, `KEY4=VAL4` será ignorado e não definido. + Cada par de chave e valor deve ser delineado com uma única vírgula. Por exemplo, .: `"CUSTOMER_KEY3=VAL3,CUSTOMER_KEY4=VAL4"` + Se o "valor" tiver espaços ou vírgulas, ele deverá ser definido entre aspas. Por exemplo, .: `CUSTOMER_KEY2=\"val2,val2 val2\"` Essa sintaxe modela de perto os padrões de configuração de variáveis de ambiente bash. **`--datalake-formats` ** Compatível com o AWS Glue 3.0 e versões posteriores. Especifica a estrutura de data lake a ser usada. O AWS Glue adiciona os arquivos JAR necessários para as estruturas que você especifica no `classpath`. Para obter mais informações, consulte [Usar estruturas de data lake com trabalhos do AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md). Você pode especificar um ou mais dos seguintes valores, separados por uma vírgula: + `hudi` + `delta` + `iceberg` Por exemplo, passe o argumento a seguir para especificar todas as três estruturas. ``` '--datalake-formats': 'hudi,delta,iceberg' ``` **`--disable-proxy-v2`** Desabilite o proxy de serviço para permitir chamadas de serviço da AWS para o Amazon S3, o CloudWatch e o AWS Glue originadas por seu script através da VPC. Para mais informações, consulte [ Configurar chamadas do AWS para passarem pela VPC](https://docs.aws.amazon.com/glue/latest/dg/connection-VPC-disable-proxy.html). Para desativar o proxy do serviço, defina o valor desse parâmetro como `true`. **`--enable-auto-scaling`** Ativa o recurso para usar escalação automática e faturamento por processador quando você define o valor como `true`. **`--enable-continuous-cloudwatch-log`** Habilita o registro em log contínuo e em tempo real para trabalhos do AWS Glue. Você pode visualizar logs de trabalho do Apache Spark em tempo real no CloudWatch. **`--enable-continuous-log-filter`** Especifica um filtro padrão (`true`) ou nenhum filtro (`false`) quando você cria ou edita um trabalho habilitado para registro em log contínuo. Escolher o filtro padrão elimina o driver/executor desnecessário do Apache Spark e mensagens de log de heartbeat do Apache Hadoop YARN. Não escolher filtros fornece todas as mensagens de log. **`--enable-glue-datacatalog`** Habilita o uso do AWS Glue Data Catalog como um metastore do Apache Spark Hive. Para habilitar esse recurso, defina o valor como `true`. **`--enable-job-insights`** Permite o monitoramento adicional de análise de erros com informações sobre a execução de trabalhos do AWS Glue. Para obter detalhes, consulte [Monitoramento com insights de execuções de trabalho do AWS Glue](monitor-job-insights.md). Por padrão, o valor está definido como `true` e os insights da execução de trabalhos estão habilitados. Essa opção só está disponível no AWS Glue versões 2.0 e 3.0. **`--enable-lakeformation-fine-grained-access`** Habilita o controle de acesso refinado para trabalhos do AWS Glue. Para obter mais informações, consulte [Usar o AWS Glue com AWS Lake Formation para controle de acesso refinado](security-lf-enable.md). **`--enable-metrics`** Habilita a coleta de métricas para criar perfis de trabalhos para essa execução da tarefa. Estas métricas estão disponíveis no console do AWS Glue e no console do Amazon CloudWatch. O valor desse parâmetro não é relevante. Para ativar esse recurso, você pode fornecer esse parâmetro com qualquer valor, mas `true` é recomendado para maior clareza. Para desabilitar esse recurso, remova esse parâmetro da configuração do seu trabalho. **`--enable-observability-metrics`** Permite que um conjunto de métricas de observabilidade gere insights sobre o que está acontecendo dentro de cada trabalho executado na página Monitoramento de execuções de trabalhos nos consoles do AWS Glue e do Amazon CloudWatch. Para habilitar esse recurso, defina o valor como true. Para desabilitar esse recurso, configure-o como `false` ou remova esse parâmetro da configuração do seu trabalho. **`--enable-rename-algorithm-v2`** Define a versão do algoritmo de renomeação do EMRFS como versão 2. Quando um trabalho do Spark usa o modo de substituição de partição dinâmica, existe a possibilidade de que uma partição duplicada seja criada. Por exemplo, você pode acabar com uma partição duplicada, como `s3://bucket/table/location/p1=1/p1=1`. Aqui, P1 é a partição que está sendo substituída. O algoritmo de renomeação versão 2 corrige esse problema. Essa opção só está disponível no AWS Glue versão 1.0. **`--enable-s3-parquet-optimized-committer`** Habilita o committer otimizado para S3 do EMRFS a gravar dados Parquet no Amazon S3. É possível fornecer o par parâmetro/valor por meio do console do AWS Glue ao criar ou atualizar um trabalho do AWS Glue. Definir o valor como **true** habilitará o committer. Por padrão, o sinalizador é ativado no AWS Glue 3.0 e desativado no AWS Glue 2.0. Para obter mais informações, consulte [Usar o committer otimizado para EMRFS S3](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-s3-optimized-committer.html). **`--enable-spark-ui`** Quando definido como `true`, ativa o recurso para usar a interface do usuário do Spark para monitorar e depurar trabalhos de ETL do AWS Glue. **`--executor-cores`** Número de tarefas do Spark que podem ser executadas em paralelo. Essa opção é compatível com o AWS Glue 3.0\$1. O valor não deve exceder 2 vezes o número de vCPUs no tipo de operador, que é 8 em `G.1X`, 16 em `G.2X`, 32 em `G.4X`, 64 em `G.8X`, 96 em `G.12X`, 128 em `G.16X` e 8 em `R.1X`, 16 em `R.2X`, 32 em `R.4X`, 64 em `R.8X`. Você deve ter cuidado ao atualizar essa configuração, pois isso pode afetar a performance do trabalho, pois o aumento do paralelismo de tarefas gera pressão na memória e no disco, além aplicar o controle de utilização nos sistemas de origem e de destino (por exemplo: causaria mais conexões simultâneas no Amazon RDS). **`--extra-files`** Os caminhos do Amazon S3 para arquivos adicionais, como arquivos de configuração, que o AWS Glue copia para o diretório de trabalho do seu script no nó driver antes de executá-lo. Vários valores devem ser caminhos completos separados por uma vírgula (`,`). O valor pode ser arquivos individuais ou localizações de diretórios. Essa opção não é compatível com os tipos de trabalho do shell do Python. **`--extra-jars`** O Amazon S3 indica caminhos para arquivos adicionais que o AWS Glue copia para o driver e os executores. O AWS Glue também adiciona esses arquivos ao classpath Java antes de executar o script. Vários valores devem ser caminhos completos separados por uma vírgula (`,`). A extensão não precisa ser `.jar` **`--extra-py-files`** Os caminhos do Amazon S3 para módulos adicionais do Python que o AWS Glue inclui no caminho do Python no nó driver antes de executar seu script. Vários valores devem ser caminhos completos separados por uma vírgula (`,`). Somente arquivos individuais têm suporte, e não um caminho de diretório. **`--job-bookmark-option`** Controla o comportamento de um marcador de trabalho. Os seguintes valores de opção podem ser definidos. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html) Para ativar um marcador de trabalho, por exemplo, transmita o seguinte argumento. ``` '--job-bookmark-option': 'job-bookmark-enable' ``` **`--job-language`** A linguagem de programação de script. Esse valor deve ser `scala` ou `python`. Se esse parâmetro não estiver presente, o padrão será `python`. **`--python-modules-installer-option`** Uma string de texto não criptografado que define as opções a serem passadas para o `pip3` ao instalar módulos com [--additional-python-modules](#additional-python-modules). Forneça opções como você faria na linha de comando, separadas por espaços e prefixadas por traços. Para obter mais informações sobre o uso, consulte [Instalar módulos Python adicionais com pip no AWS Glue 2.0 ou posterior](aws-glue-programming-python-libraries.md#addl-python-modules-support). Essa opção não é compatível com trabalhos do AWS Glue quando você usa o Python 3.9. **`--scriptLocation`** O local do Amazon Simple Storage Service (Amazon S3) no qual seu script de ETL está localizado (no formato `s3://path/to/my/script.py`). Esse parâmetro substitui um local de script definido no objeto `JobCommand`. **`--spark-event-logs-path`** Especifica um caminho do Amazon S3. Ao usar o recurso de monitoramento da interface do usuário do Spark,o AWS Glue libera os logs de eventos do Spark para esse caminho do Amazon S3 a cada 30 segundos para um bucket que pode ser usado como um diretório temporário para armazenar eventos de interface do usuário do Spark. **`--TempDir`** Especifica um caminho do Amazon S3 para um bucket que pode ser usado como um diretório temporário para o trabalho. Por exemplo, para definir um diretório temporário, transmita o seguinte argumento. ``` '--TempDir': 's3-path-to-directory' ``` O AWS Glue cria um bucket temporário para os trabalhos, se um bucket ainda não existir em uma região. Esse bucket pode permitir o acesso público. Você pode 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. **`--use-postgres-driver`** Ao definir esse valor como `true`, ele prioriza o driver JDBC do Postgres no classpath para evitar um conflito com o driver JDBC do Amazon Redshift. Essa opção só está disponível no AWS Glue versão 2.0. **`--user-jars-first`** Ao definir esse valor como `true`, ele prioriza os arquivos JAR extras do classpath. Essa opção só está disponível no AWS Glue versão 2.0 ou posterior. **`--conf`** Controla os parâmetros de configuração do Spark. Destina-se a casos de uso avançados. **`--encryption-type`** Parâmetro legado. O comportamento correspondente deve ser configurado usando configurações de segurança. Para obter mais informações sobre configurações de segurança, consulte [Criptografar dados gravados pelo AWS Glue](encryption-security-configuration.md). AWSO Glue usa os seguintes argumentos internamente e você nunca deve usá-los: + `--debug`: interno do AWS Glue. Não o defina. + `--mode`: interno do AWS Glue. Não o defina. + `--JOB_NAME`: interno do AWS Glue. Não o defina. + `--endpoint`: interno do AWS Glue. Não o defina. ## O AWS Glue é compatível com a inicialização de um ambiente com o módulo `site` do Python usando `sitecustomize` para realizar personalizações específicas do site. A inicialização de suas próprias funções de inicialização só é recomendada para casos de uso avançados e é compatível na medida do possível com o AWS Glue 4.0. O prefixo variável de ambiente, `GLUE_CUSTOMER`, é reservado para uso do cliente. # 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. # Tipos de operadores do AWS Glue ## Visão geral O AWS Glue oferece vários tipos de operadores para acomodar diferentes requisitos de workloads, desde pequenos trabalhos de streaming até tarefas de processamento de dados em grande escala que consomem muita memória. Esta seção fornece informações abrangentes sobre todos os tipos de operadores disponíveis, suas especificações e recomendações de uso. ### Categorias de tipos de operadores O AWS Glue oferece duas categorias principais de tipos de operadores: + **Tipos de operadores G**: operadores de computação de uso geral otimizados para workloads ETL padrão + **Tipos de operadores R**: operadores otimizados para memória desenvolvidos para aplicações Spark que consomem muita memória ### Unidades de processamento de dados (DPUs) 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. **DPUs otimizadas para memória (M-DPUs)**: os operadores do tipo R usam M-DPUs, que fornecem o dobro da alocação de memória para um determinado tamanho em comparação às DPUs padrão. Isso significa que, enquanto uma DPU padrão fornece 16 GB de memória, uma M-DPU em operadores do tipo R fornece 32 GB de memória otimizada para aplicações Spark que consomem muita memória. ## Tipos de operadores disponíveis ### G.1X + **DPU**: 1 DPU (4 vCPUs, 16 GB de memória) + **Armazenamento**: disco de 94 GB (aproximadamente 44 GB livres) + **Caso de uso**: transformações, uniões e consultas de dados de forma escalável e econômica para a maioria dos trabalhos ### G.2X + **DPU**: 2 DPUs (8 vCPUs, 32 GB de memória) + **Armazenamento**: disco de 138 GB (aproximadamente 78 GB livres) + **Caso de uso**: transformações, uniões e consultas de dados de forma escalável e econômica para a maioria dos trabalhos ### G.4X + **DPU**: 4 DPUs (16 vCPUs, 64 GB de memória) + **Armazenamento**: disco de 256 GB (aproximadamente 230 GB livres) + **Caso de uso**: transformações, agregações, uniões e consultas exigentes ### G.8X + **DPU**: 8 DPUs (32 vCPUs, 128 GB de memória) + **Armazenamento**: disco de 512 GB (aproximadamente 485 GB livres) + **Caso de uso**: transformações, agregações, uniões e consultas exigentes ### G.12X + **DPU**: 12 DPUs (48 vCPUs, 192 GB de memória) + **Armazenamento**: disco de 768 GB (aproximadamente 741 GB livres) + **Caso de uso**: workloads muito grandes e com uso intenso de recursos que exigem capacidade computacional significativa ### G.16X + **DPU**: 16 DPUs (64 vCPUs, 256 GB de memória) + **Armazenamento**: disco de 1024 GB (aproximadamente 996 GB livres) + **Caso de uso**: as workloads maiores com o maior uso de recursos que exigem capacidade computacional máxima ### R.1X: otimizado para memória\$1 + **DPU**: 1 M-DPU (4 vCPUs, 32 GB de memória) + **Caso de uso**: workloads que consomem muita memória e apresentam erros frequentes de falta de memória ou requisitos elevados de relação memória/CPU ### R.2X: otimizado para memória\$1 + **DPU**: 2 M-DPUs (8 vCPUs, 64 GB de memória) + **Caso de uso**: workloads que consomem muita memória e apresentam erros frequentes de falta de memória ou requisitos elevados de relação memória/CPU ### R.4X: otimizado para memória\$1 + **DPU**: 4 M-DPUs (16 vCPUs, 128 GB de memória) + **Caso de uso**: workloads grandes que consomem muita memória e apresentam erros frequentes de falta de memória ou requisitos elevados de relação memória/CPU ### R.8X: otimizado para memória\$1 + **DPU**: 8 M-DPUs (32 vCPUs, 256 GB de memória) + **Caso de uso**: workloads muito grandes que consomem muita memória e apresentam erros frequentes de falta de memória ou requisitos elevados de relação memória/CPU **\$1** É possível que uma maior latência de inicialização seja observada com esses operadores. Para resolver esse problema, experimente o seguinte: + Espere alguns minutos e envie o trabalho novamente. + Envie um novo trabalho com um número reduzido de operadores. + Envie um novo trabalho usando um tipo ou tamanho de operador diferente. ## Tabela de especificações dos tipos de operadores **Especificações dos tipos de operadores** | Tipo de operador | DPUs por nó | vCPU | Memória (GB) | Disco (GB) | Espaço livre em disco aproximado (GB) | Executores Spark por nó | | --- | --- | --- | --- | --- | --- | --- | | G.1X | 1 | 4 | 16 | 94 | 44 | 1 | | G.2X | 2 | 8 | 32 | 138 | 78 | 1 | | G.4X | 4 | 16 | 64 | 256 | 230 | 1 | | G.8X | 8 | 32 | 128 | 512 | 485 | 1 | | G.12X | 12 | 48 | 192 | 768 | 741 | 1 | | G.16X | 16 | 64 | 256 | 1024 | 996 | 1 | | R.1X | 1 | 4 | 32 | 94 | 44 | 1 | | R.2X | 2 | 8 | 64 | 138 | 78 | 1 | | R.4X | 4 | 16 | 128 | 256 | 230 | 1 | | R.8X | 8 | 32 | 256 | 512 | 485 | 1 | *Observação*: os tipos de operadores R têm configurações otimizadas para memória com especificações otimizadas para workloads com consumo elevado de memória. ## Considerações importantes ### Latência de inicialização **Importante** Os tipos de operadores G.12X e G.16X, bem como todos os tipos de trabalhadores R (R.1X a R.8X), podem encontrar uma maior latência durante a inicialização. Para resolver esse problema, experimente o seguinte: Espere alguns minutos e envie o trabalho novamente. Envie um novo trabalho com um número reduzido de operadores. Envie um novo trabalho usando um tipo e um tamanho de operador diferentes. ## Como escolher o tipo de operador certo ### Para workloads ETL padrão + **G.1X ou G.2X**: o mais econômico para transformações, uniões e consultas de dados típicas + **G.4X ou G.8X**: para workloads mais exigentes com conjuntos de dados maiores ### Para workloads em grande escala + **G.12X**: conjuntos de dados muito grandes que exigem recursos computacionais significativos + **G.16X**: capacidade máxima de computação para as workloads mais exigentes ### Para workloads com consumo elevado de memória + **R.1X ou R.2X**: trabalhos de pequeno a médio porte que consomem muita memória + **R.4X ou R.8X**: workloads que consomem muita memória e apresentam erros frequentes de OOM ## Considerações sobre otimização de custos + **Operadores G padrão**: fornecem um equilíbrio entre recursos de computação, memória e rede e podem ser usados em workloads diversas a um custo menor + **Operadores R**: especializados em tarefas que consomem muita memória e com desempenho rápido em workloads que processam grandes conjuntos de dados na memória ## Práticas recomendadas ### Diretrizes de seleção de operadores 1. **Comece com operadores padrão** (G.1X, G.2X) para a maioria das workloads 1. **Use operadores R** ao enfrentar erros frequentes de falta de memória ou workloads com operações que consomem muita memória, como armazenamento em cache, embaralhamento e agregação 1. **Considere G.12X/G.16X** para workloads com computação intensa que exigem o máximo de recursos 1. **Considere as restrições de capacidade** ao usar novos tipos de operadores em fluxos de trabalho sensíveis ao tempo ### Otimização de desempenho + Monitore as métricas do CloudWatch para entender a utilização de recursos + Use contagens de operadores apropriadas com base no tamanho e na complexidade dos dados + Considere estratégias de particionamento de dados para otimizar a eficiência dos operadores # Trabalhos de transmissão de ETL no AWS Glue É possível criar trabalhos de extração, transformação e carregamento (ETL) de transmissão que sejam executados continuamente e que consumam dados de fontes de transmissão, como o Amazon Kinesis Data Streams, Apache Kafka e Amazon Managed Streaming for Apache Kafka (Amazon MSK). Os trabalhos limpam e transformam os dados e, em seguida, carregam os resultados em data lakes do Amazon S3 ou armazenamentos de dados JDBC. Além disso, você pode produzir dados para streams do Amazon Kinesis Data Streams. Esse atributo só está disponível ao escrever AWS Glue scripts. Para obter mais informações, consulte [Conexões do Kinesis](aws-glue-programming-etl-connect-kinesis-home.md). Por padrão, o AWS Glue processa e grava dados em janelas de 100 segundos. Isso permite que os dados sejam processados de forma eficiente e que as agregações sejam realizadas em dados que chegam mais tarde do que o esperado. É possível modificar esse tamanho da janela para aumentar a pontualidade ou a precisão da agregação. Trabalhos de transmissão do AWS Glue usam pontos de verificação em vez de marcadores de trabalho para rastrear os dados que foram lidos. **nota** AWS GlueO cobra por hora por trabalhos de ETL de transmissão enquanto eles estão em execução. Este vídeo discute os desafios de custo de ETL de streaming e os atributos de economia de custos do AWS Glue. [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/6ggTFOtfUxU/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/6ggTFOtfUxU) A criação de um trabalho de ETL de streaming envolve as seguintes etapas: 1. Para uma fonte de transmissão Apache Kafka, crie um conexão do AWS Glue com a origem do Kafka ou o cluster do Amazon MSK. 1. Crie manualmente uma tabela do Data Catalog para a fonte de transmissão. 1. Crie um trabalho de ETL para a fonte de dados de streaming. Defina propriedades de trabalho específicas de streaming e forneça seu próprio script ou, opcionalmente, modifique o script gerado. Para obter mais informações, consulte [ETL de streaming no AWS Glue](components-overview.md#streaming-etl-intro). Ao criar um trabalho de ETL de transmissão para o Amazon Kinesis Data Streams, você não precisa criar uma conexão do AWS Glue. No entanto, se houver uma conexão anexada ao trabalho de ETL de transmissão do AWS Glue que tenha o Kinesis Data Streams como origem, será necessário um endpoint de nuvem privada virtual (VPC) para o Kinesis. Para obter mais informações, consulte [Criar um endpoint de interface](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#create-interface-endpoint) no *Guia do usuário da Amazon VPC*. Ao especificar uma transmissão do Amazon Kinesis Data Streams em outra conta, você deve configurar as funções e políticas para permitir o acesso entre contas. Para obter mais informações, consulte [Exemplo: Ler de uma transmissão do Kinesis em outra conta](https://docs.aws.amazon.com/kinesisanalytics/latest/java/examples-cross.html). AWS GlueOs trabalhos de ETL do podem detectar automaticamente dados compactados, descompactar de forma transparente os dados de fluxo, realizar as transformações usuais na fonte de entrada e carregar no armazenamento de saída. AWS GlueO oferece suporte à descompactação automática para os seguintes tipos de compactação, considerando o formato de entrada: | Tipo de compactação | Arquivo Avro | Dado Avro | JSON | CSV | Grok | | --- | --- | --- | --- | --- | --- | | BZIP2 | Sim | Sim | Sim | Sim | Sim | | GZIP | Não | Sim | Sim | Sim | Sim | | SNAPPY | Sim (Snappy bruto) | Sim (Snappy com enquadramento) | Sim (Snappy com enquadramento) | Sim (Snappy com enquadramento) | Sim (Snappy com enquadramento) | | XZ | Sim | Sim | Sim | Sim | Sim | | ZSTD | Sim | Não | Não | Não | Não | | DEFLATE | Sim | Sim | Sim | Sim | Sim | **Topics** + [Criar uma conexão do AWS Glue para um fluxo de dados do Apache Kafka](#create-conn-streaming) + [Criar uma tabela do Data Catalog para uma fonte de transmissão](#create-table-streaming) + [Notas e restrições para fontes de transmissão Avro](#streaming-avro-notes) + [Aplicar padrões grok a fontes de transmissão](#create-table-streaming-grok) + [Definir propriedades de trabalho para um trabalho de ETL de transmissão](#create-job-streaming-properties) + [Notas e restrições sobre ETL de transmissão](#create-job-streaming-restrictions) ## Criar uma conexão do AWS Glue para um fluxo de dados do Apache Kafka Para ler a partir de um stream do Apache Kafka, é necessário criar uma conexão do AWS Glue. **Como criar uma conexão do AWS Glue para uma fonte do Kafka (console)** 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, em **Data catalog (catálogo de dados)**, selecione **Connections (Conexões)**. 1. Escolha **Add connection (Adicionar conexão)** e, na página **Set up your connection’s properties (Configurar propriedades da conexão)** insira um nome de conexão. **nota** Para obter mais informações sobre como especificar propriedades de conexão, consulte [Propriedades de conexão do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-connections). 1. Em **Tipo de conexão**, escolha **Kafka**. 1. Para os **URLs de servidores de bootstrap do Kafka**, insira o host e o número da porta para o agente de bootstrap do cluster do Amazon MSK ou do Apache Kafka. Use somente endpoints de Transport Layer Security (TLS) para estabelecer a conexão inicial com o cluster do Kafka. Os endpoints plaintext não são compatíveis. Veja a seguir um exemplo de lista de pares de nome de host e de números de porta para um cluster do Amazon MSK. ``` myserver1.kafka.us-east-1.amazonaws.com:9094,myserver2.kafka.us-east-1.amazonaws.com:9094, myserver3.kafka.us-east-1.amazonaws.com:9094 ``` Para mais informações sobre como obter as informações do agente de bootstrap, consulte [Obter os agentes de bootstrap para um cluster do Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/msk-get-bootstrap-brokers.html) no *Guia do desenvolvedor do Amazon Managed Streaming for Apache Kafka*. 1. Se você quiser uma conexão segura com a origem dos dados do Kafka, selecione **Require SSL connection** (Exigir conexão SSL), e em **Kafka private CA certificate location** (Localização do certificado CA privado do Kafka), insira um caminho válido do Amazon S3 para um certificado SSL personalizado. Para uma conexão SSL com o Kafka autogerenciado, o certificado personalizado é obrigatório. Ele é opcional para o Amazon MSK. Para obter mais informações sobre como especificar um certificado personalizado para o Kafka, consulte [AWS GluePropriedades de conexão SSL do](connection-properties.md#connection-properties-SSL). 1. Use o AWS Glue Studio ou a AWS CLI para especificar um método de autenticação de cliente do Kafka. Para acessar o AWS Glue Studio, selecione **AWS Glue** no menu **ETL** no painel de navegação esquerdo. Para obter mais informações sobre métodos de autenticação do cliente Kafka, consulte [Propriedades de conexão do AWS Glue Kafka para autenticação do cliente](#connection-properties-kafka-client-auth). 1. Opcionalmente, insira uma descrição e, em seguida, escolha **Next** (Próximo). 1. Para um cluster do Amazon MSK, especifique sua nuvem privada virtual (VPC), sub-rede e grupo de segurança. As informações da VPC são opcionais para o Kafka autogerenciado. 1. Selecione **Next** (Próximo) para rever todas as propriedades de conexão e, em seguida, escolha **Finish** (Finalizar). Para obter mais informações sobre conexões do AWS Glue, consulte [Conectar a dados](glue-connections.md). ### Propriedades de conexão do AWS Glue Kafka para autenticação do cliente **Autenticação SASL/GSSAPI (Kerberos)** Escolher esse método de autenticação permitirá que você especifique propriedades Kerberos. **Kerberos Keytab** Escolha o local do arquivo keytab. Um keytab armazena chaves de longo prazo para um ou mais principais. Para obter mais informações, consulte [Documentação do MIT Kerberos: Keytab](https://web.mit.edu/kerberos/krb5-latest/doc/basic/keytab_def.html). **Arquivo Kerberos krb5.conf** Escolha o arquivo krb5.conf. Ele contém o realm padrão (uma rede lógica, semelhante a um domínio, que define um grupo de sistemas sob o mesmo KDC) e a localização do servidor KDC. Para obter mais informações, consulte [Documentação do MIT Kerberos: krb5.conf](https://web.mit.edu/kerberos/krb5-1.12/doc/admin/conf_files/krb5_conf.html). **Entidade principal do Kerberos e nome do serviço Kerberos** Insira a entidade principal do Kerberos e nome do serviço. Para obter mais informações, consulte [Documentação do MIT Kerberos: entidade principal do Kerberos](https://web.mit.edu/kerberos/krb5-1.5/krb5-1.5.4/doc/krb5-user/What-is-a-Kerberos-Principal_003f.html). **Autenticação SASL/SCRAM-SHA-512** Escolher esse método de autenticação permitirá que você especifique credenciais de autenticação. **AWS Secrets Manager** Pesquise seu token na caixa Pesquisar digitando o nome ou o ARN. **Nome de usuário e senha do provedor diretamente** Pesquise seu token na caixa Pesquisar digitando o nome ou o ARN. **Autenticação de cliente SSL** Escolher esse método de autenticação permite que você selecione o local do keystore do cliente Kafka ao navegar no Amazon S3. Opcionalmente, é possível inserir a senha do keystore do cliente Kafka e a senha da chave do cliente Kafka. **Autenticação do IAM** O método de autenticação não requer especificações adicionais e só é aplicável quando a fonte do streaming é o MSK Kafka. **Autenticação SASL/PLAIN** Escolher esse método de autenticação permite a você especificar credenciais de autenticação. ## Criar uma tabela do Data Catalog para uma fonte de transmissão É possível criar manualmente uma tabela do Data Catalog que especifique as propriedades do fluxo de dados da fonte, incluindo o esquema de dados. Essa tabela é usada como fonte de dados para o trabalho de ETL de streaming. Se você não souber o esquema dos dados no fluxo de dados de origem, poderá criar a tabela sem um esquema. Em seguida, quando você cria o trabalho ETL de transmissão, pode ativar a função de detecção de esquema do AWS Glue. O AWS Glue determina o esquema dos dados de transmissão. Use o [console do AWS Glue](https://console.aws.amazon.com/glue/), a AWS Command Line Interface (AWS CLI) ou a API do AWS Glue para criar a tabela. Para obter informações sobre como criar uma tabela manualmente com o console do AWS Glue, consulte [Criar tabelas](tables-described.md). **nota** Não é possível usar o console do AWS Lake Formation para criar a tabela; é necessário usar o console do AWS Glue. Considere também as seguintes informações para fontes de transmissão no formato Avro ou para dados de log aos quais você pode aplicar padrões Grok. + [Notas e restrições para fontes de transmissão Avro](#streaming-avro-notes) + [Aplicar padrões grok a fontes de transmissão](#create-table-streaming-grok) **Topics** + [Fonte de dados do Kinesis](#kinesis-source) + [Fonte de dados do Kafka](#kafka-source) + [AWS GlueFonte da tabela do registro de esquemas do](#schema-registry-table) ### Fonte de dados do Kinesis Ao criar a tabela, defina as seguintes propriedades de ETL de transmissão (console). **Tipo de fonte** **Kinesis** **Para uma fonte do Kinesis na mesma conta:** **Região** A região da AWS onde reside o serviço do Amazon Kinesis Data Streams. O nome da transmissão do Kinesis e da região são traduzidos juntos para um ARN de transmissão. Exemplo: https://kinesis.us-east-1.amazonaws.com **Nome da transmissão do Kinesis** Nome do stream conforme descrito em [Criar um stream](https://docs.aws.amazon.com/streams/latest/dev/kinesis-using-sdk-java-create-stream.html) no *Guia do desenvolvedor do Amazon Kinesis Data Streams*. **Para obter uma fonte do Kinesis em outra conta, consulte [este exemplo](https://docs.aws.amazon.com/kinesisanalytics/latest/java/examples-cross.html) para configurar as funções e políticas a fim de permitir o acesso entre contas. Defina estas configurações:** **ARN da transmissão** O ARN do fluxo de dados do Kinesis no qual o consumidor está registrado. Para obter mais informações, consulte [Nomes de recursos da Amazon (ARNs) e namespaces de serviço da AWS](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) no *Referência geral da AWS*. **ARN da função assumida** O nome do recurso da Amazon (ARN) da função a ser assumida. **Nome da sessão (opcional)** Um identificador para a sessão de função assumida. Use o nome da sessão de função para identificar exclusivamente uma sessão quando a mesma função for assumida por outras entidades principais ou por motivos diferentes. Em cenários entre contas, o nome da sessão de função fica visível e pode ser acessado pela conta que possui a função. O nome da sessão de função também é usado no ARN da entidade principal da função assumida. Isso significa que solicitações subsequentes de API entre contas que usam as credenciais de segurança temporárias vão expor o nome da sessão de função à conta externa em seus logs do AWS CloudTrail. **Para definir propriedades de ETL de transmissão para o Amazon Kinesis Data Streams (API do AWS Glue ou AWS CLI)** + Para configurar as propriedades de ETL de transmissão para uma fonte do Kinesis na mesma conta, especifique os parâmetros `streamName` e `endpointUrl` na estrutura `StorageDescriptor` da operação da API `CreateTable` ou do comando da CLI `create_table`. ``` "StorageDescriptor": { "Parameters": { "typeOfData": "kinesis", "streamName": "sample-stream", "endpointUrl": "https://kinesis.us-east-1.amazonaws.com" } ... } ``` Ou especifique o `streamARN`. **Example** ``` "StorageDescriptor": { "Parameters": { "typeOfData": "kinesis", "streamARN": "arn:aws:kinesis:us-east-1:123456789:stream/sample-stream" } ... } ``` + Para configurar as propriedades de ETL de transmissão para uma fonte do Kinesis na mesma conta, especifique os parâmetros `streamARN`, `awsSTSRoleARN` e `awsSTSSessionName` (opcional) na estrutura `StorageDescriptor` da operação da API `CreateTable` ou do comando da CLI `create_table`. ``` "StorageDescriptor": { "Parameters": { "typeOfData": "kinesis", "streamARN": "arn:aws:kinesis:us-east-1:123456789:stream/sample-stream", "awsSTSRoleARN": "arn:aws:iam::123456789:role/sample-assume-role-arn", "awsSTSSessionName": "optional-session" } ... } ``` ### Fonte de dados do Kafka Ao criar a tabela, defina as seguintes propriedades de ETL de transmissão (console). **Tipo de fonte** **Kafka** **Para uma fonte do Kafka:** **Nome do tópico** Nome do tópico conforme especificado no Kafka. **Conexão** Uma conexão do AWS Glue que faz referência a uma fonte do Kafka, conforme descrito em [Criar uma conexão do AWS Glue para um fluxo de dados do Apache Kafka](#create-conn-streaming). ### AWS GlueFonte da tabela do registro de esquemas do Para usar o registro de esquemas do AWS Glue para trabalhos de transmissão, siga as instruções em [Caso de uso: AWS Glue Data Catalog](schema-registry-integrations.md#schema-registry-integrations-aws-glue-data-catalog) para criar ou atualizar uma tabela de registro de esquemas. Atualmente, a transmissão do AWS Glue oferece suporte somente ao formato Avro de registro do esquemas do Glue com inferência de esquema definida como `false`. ## Notas e restrições para fontes de transmissão Avro As seguintes notas e restrições se aplicam a fontes de transmissão no formato Avro: + Quando a detecção de esquema está ativada, o esquema Avro deve ser incluído na carga útil. Quando desligado, a carga útil deve conter apenas dados. + Alguns tipos de dados Avro não são suportados em quadros dinâmicos. Você não pode especificar esses tipos de dados ao definir o esquema com a página **Define a schema** (Definir um esquema) no assistente de criação de tabela no console do AWS Glue. Durante a detecção de esquema, os tipos não suportados no esquema Avro são convertidos para tipos suportados da seguinte forma: + `EnumType => StringType` + `FixedType => BinaryType` + `UnionType => StructType` + Se você definir o esquema de tabela usando a página **Define a schema** (Definir um esquema) no console, o tipo de elemento raiz implícito para o esquema será `record`. Se você quiser um tipo de elemento raiz diferente de `record`, por exemplo, `array` ou `map`, não deve especificar o esquema usando a página **Define a schema** (Definir um esquema). Em vez disso, você deve ignorar essa página e especificar o esquema como uma propriedade de tabela ou dentro do script de ETL. + Para especificar o esquema nas propriedades da tabela, conclua o assistente de criação de tabela, edite os detalhes da tabela e adicione um novo par de chave-valor em **Table properties** (Propriedades da tabela). Use a chave `avroSchema` e insira um objeto JSON de esquema para o valor, conforme mostrado na captura de tela a seguir. ![\[No cabeçalho Table properties (Propriedades da tabela), há duas colunas de campos de texto. O cabeçalho da coluna à esquerda é Key (Chave) e o cabeçalho da coluna à direita é Value (Valor). O par chave/valor na primeira linha é classificação/avro. O par chave/valor na segunda linha é avroSchema/{"type":"array","items":"string"}.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/table_properties_avro.png) + Para especificar o esquema no script de ETL, modifique a instrução de atribuição `datasource0` e adicione a chave `avroSchema` ao argumento `additional_options`, conforme mostrado nos exemplos de Python e Scala a seguir. ------ #### [ Python ] ``` SCHEMA_STRING = ‘{"type":"array","items":"string"}’ datasource0 = glueContext.create_data_frame.from_catalog(database = "database", table_name = "table_name", transformation_ctx = "datasource0", additional_options = {"startingPosition": "TRIM_HORIZON", "inferSchema": "false", "avroSchema": SCHEMA_STRING}) ``` ------ #### [ Scala ] ``` val SCHEMA_STRING = """{"type":"array","items":"string"}""" val datasource0 = glueContext.getCatalogSource(database = "database", tableName = "table_name", redshiftTmpDir = "", transformationContext = "datasource0", additionalOptions = JsonOptions(s"""{"startingPosition": "TRIM_HORIZON", "inferSchema": "false", "avroSchema":"$SCHEMA_STRING"}""")).getDataFrame() ``` ------ ## Aplicar padrões grok a fontes de transmissão Você pode criar um trabalho de ETL de transmissão para uma fonte dos dados de log e usar padrões Grok para converter os logs em dados estruturados. Em seguida, o trabalho de ETL processa os dados como uma fonte de dados estruturada. Você especifica os padrões Grok a serem aplicados ao criar a tabela do Data Catalog para a fonte de transmissão. Para obter informações sobre padrões Grok e valores de string padrão personalizados, consulte [Gravar classificadores grok personalizados](custom-classifier.md#custom-classifier-grok). **Para adicionar padrões grok à tabela do Data Catalog (console)** + Use o assistente de criação de tabela e a crie com os parâmetros especificados em [Criar uma tabela do Data Catalog para uma fonte de transmissão](#create-table-streaming). Especifique o formato de dados como Grok, preencha o campo **Grok pattern** (Padrão Grok) e, opcionalmente, adicione padrões personalizados em **Custom patterns (optional)** (Padrões personalizados [opcional]). ![\[*\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/grok-data-format-create-table.png) Pressione **Enter** após cada padrão personalizado. **Para adicionar padrões grok à tabela do Data Catalog (API do AWS Glue ou AWS CLI)** + Adicionar o parâmetro `GrokPattern` e, opcionalmente, o parâmetro `CustomPatterns` à operação da API `CreateTable` ou comando da CLI `create_table`. ``` "Parameters": { ... "grokPattern": "string", "grokCustomPatterns": "string", ... }, ``` Expresse `grokCustomPatterns` como uma string e use “\$1n” como o separador entre padrões. Veja a seguir um exemplo desses parâmetros em um arquivo. **Example** ``` "parameters": { ... "grokPattern": "%{USERNAME:username} %{DIGIT:digit:int}", "grokCustomPatterns": "digit \d", ... } ``` ## Definir propriedades de trabalho para um trabalho de ETL de transmissão Ao definir um trabalho de ETL de transmissão no console do AWS Glue, forneça as seguintes propriedades específicas de transmissão. Para descrições de propriedades de trabalhos adicionais, consulte [Definir propriedades de trabalho para trabalhos do Spark](add-job.md#create-job). **perfil do IAM** Especifique a função do AWS Identity and Access Management (IAM) usada para a autorização dos recursos necessários para executar o trabalho, acessar fontes de transmissão e armazenamentos de dados de destino. Para obter acesso ao Amazon Kinesis Data Streams, associe a política `AmazonKinesisFullAccess` gerenciada pela AWS à função ou associe uma política do IAM semelhante que permita um acesso mais granular. Para ver políticas de exemplo, consulte [Controlar o acesso aos recursos do Amazon Kinesis Data Streams usando o IAM](https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html). 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** Escolha **Spark streaming (Streaming do Spark)**. **AWS GlueVersão do ** A versão do AWS Glue determina as versões do Apache Spark, e Python ou Scala, que estão disponíveis para o trabalho. Escolha uma seleção que especifique a versão do Python ou do Scala disponível para o trabalho. O AWS Glue Versão 2.0 com suporte a Python 3 é o padrão para trabalhos de ETL de transmissão. **Maintenance window** Especifica uma janela na qual um trabalho de streaming pode ser reiniciado. Consulte [Janelas de manutenção do AWS Glue Streaming](glue-streaming-maintenance.md). **Tempo limite de trabalho** Opcionalmente, informe uma duração em minutos. O valor padrão é em branco. + Os trabalhos de streaming devem ter valores de tempo limite inferiores a 7 dias ou 10.080 minutos. + Quando o valor for deixado em branco, o trabalho será reiniciado após 7 dias caso você não tenha configurado uma janela de manutenção. Se você tiver uma janela de manutenção configurada, o trabalho será reiniciado durante a janela de manutenção após 7 dias. **Fonte de dados** Remova a tabela criada em [Criar uma tabela do Data Catalog para uma fonte de transmissão](#create-table-streaming). **Destino de dados** Execute um destes procedimentos: + Escolha **Create tables in your data target (Criar tabelas no destino de dados)** e especifique as propriedades do destino de dados a seguir. **Datastore** Escolha Amazon S3 ou JDBC. **Formato** Escolha qualquer formato. Todos são compatíveis com streaming. + Escolha **Use tables in the data catalog and update your data target** (Usar tabelas no catálogo de dados e atualizar seu destino de dados) e escolha uma tabela para um datastore JDBC. **Definição do esquema de saída** Execute um destes procedimentos: + Escolha **Automatically detect schema of each record** (Detectar automaticamente o esquema de cada registro) para ativar a detecção de esquemas. O AWS Glue determina o esquema dos dados de transmissão. + Escolha **Specify output schema for all records** (Especificar esquema de saída para todos os registros) para usar a transformação Apply Mapping (Aplicar mapeamento) e definir o esquema de saída. **Script** Opcionalmente, forneça seu próprio script ou modifique o script gerado para executar operações compatíveis com o mecanismo do Apache Spark Structured Streaming. Para obter informações sobre as operações disponíveis, consulte [Operações em streaming de DataFrames/conjuntos de dados](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html#operations-on-streaming-dataframesdatasets). ## Notas e restrições sobre ETL de transmissão Tenha em mente as seguintes notas e restrições: + A descompactação automática para trabalhos de ETL de fluxo do AWS Glue só está disponível para os tipos de compactação compatíveis. Observe o seguinte: + Snappy com enquadramento refere-se ao [formato de enquadramento](https://github.com/google/snappy/blob/main/framing_format.txt) oficial para o Snappy. + Deflate é compatível com o Glue versão 3.0, mas não com o Glue versão 2.0. + Ao usar a detecção de esquema, você não pode realizar junções de dados de transmissão. + Os trabalhos de ETL de transmissão do AWS Glue não são compatíveis com o tipo de dados Union para registro de esquema do AWS Glue com o formato Avro. + Seu script de ETL pode usar as transformações nativas do AWS Glue e as transformações nativas do Apache Spark Structured Streaming. Para obter mais informações, consulte [Operations on streaming DataFrames/Datasets](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html#operations-on-streaming-dataframesdatasets) (Operações em transmissão de dataframes/conjuntos de dados) no website do Apache Spark ou [Referência de transformações PySpark do AWS Glue](aws-glue-programming-python-transforms.md). + AWS GlueOs trabalhos de ETL de transmissão do usam pontos de verificação para acompanhar os dados que foram lidos. Portanto, um trabalho interrompido e reiniciado é retomado de onde parou no streaming. Se desejar reprocessar dados, você poderá excluir a pasta de ponto de verificação indicada no script. + Marcadores de trabalho não são compatíveis. + Para usar o atributo de distribuição avançada de fluxo de dados do Kinesis no trabalho, consulte [Usar distribuição avançada nas tarefas de streaming do Kinesis](aws-glue-programming-etl-connect-kinesis-efo.md). + Se você usar uma tabela de catálogo de dados criada a partir do registro de esquemas do AWS Glue, quando uma nova versão do esquema se tornar disponível, para refletir o novo esquema, você precisará fazer o seguinte: 1. Pare os trabalhos associados à tabela. 1. Atualize o esquema para a tabela do catálogo de dados. 1. Reinicie os trabalhos associados à tabela. # Correspondência de registros com o FindMatches do AWS Lake Formation **nota** No momento, a correspondência de registros não está disponível nas seguintes regiões no console do AWS Glue: Oriente Médio (EAU), Europa (Espanha), Ásia-Pacífico (Jacarta) e Europa (Zurique). O AWS Lake Formation fornece recursos de machine learning para criar transformações personalizadas para limpar seus dados. No momento, existe uma transformação disponível chamada FindMatches. A transformação FindMatches permite identificar registros duplicados ou correspondentes no seu conjunto de dados, mesmo quando os registros não têm um identificador exclusivo comum e quando não há campos com uma correspondência exata. Isso não exigirá escrever nenhum código ou saber como o machine learning funciona. A transformação FindMatches pode ser útil em muitos problemas diferentes, como: + **Matching customers** (Correspondência de clientes): vinculação de registros de clientes em diferentes bancos de dados de clientes, mesmo quando muitos campos de clientes não correspondem exatamente entre os bancos de dados (por exemplo, grafia diferente do nome, diferenças de endereço, dados ausentes ou imprecisos etc.). + **Matching products** (Correspondência de produtos): correspondência de produtos em seu catálogo com relação a outras fontes de produtos, como catálogo de produtos com relação ao catálogo de um concorrente, onde as entradas são estruturadas de outra forma. + **Improving fraud detection** (Melhoria da detecção de fraudes): identificação de contas de clientes duplicadas, determinação de quando uma conta recém-criada é (ou pode ser) correspondente a um usuário fraudulento conhecido anteriormente. + **Other matching problems** (Outros problemas de correspondência): correspondência de endereços, filmes, listas de peças etc. Em geral, se um ser humano conseguir olhar suas linhas de banco de dados e determinar se elas são uma correspondência, haverá uma boa chance de que a transformação FindMatches possa ajudá-lo. É possível criar essas transformações ao criar uma tarefa. A transformação que você cria tem como base um esquema de datastore de origem e dados de exemplo da fonte de dados rotulados por você (chamamos esse processo de “ensinar” uma transformação). Os registros que você rotula devem estar presentes no conjunto de dados de origem. Nesse processo, geramos um arquivo que você rotula e carrega novamente, e que ajudaria a transformação a aprender. Depois de ensinar a transformação, você poderá chamá-la no trabalho do AWS Glue baseado no Spark (PySpark ou Scala Spark) e usá-la em outros scripts com um datastore de origem compatível. Depois que a transformação é criada, ela é armazenada no AWS Glue. No console do AWS Glue, é possível gerenciar as transformações que você cria. No painel de navegação em **Integração de dados e ETL**, **Ferramentas de classificação de dados > Correspondência de registros**, você pode editar e continuar a ensinar a sua transformação de machine learning. Para obter mais informações sobre como gerenciar transformações no console, consulte [Trabalhar com transformações de machine learning](console-machine-learning-transforms.md). **nota** Os trabalhos do FindMatches do AWS Glue versão 2.0 usam o `aws-glue-temp--` do bucket do Amazon S3 para armazenar arquivos temporários enquanto a transformação está processando dados. Você pode excluir esses dados após a conclusão da execução, manualmente ou definindo uma regra de ciclo de vida do Amazon S3. ## Tipos de transformações de machine learning Você pode criar transformações de machine learning para limpar os dados. Você pode chamar essas transformações no seu script de ETL. Os seus dados passam de transformação para transformação em uma estrutura de dados chamada *DynamicFrame*, que é a extensão de uma `DataFrame` do Apache Spark SQL. O `DynamicFrame` contém os dados, e você referencia o esquema para processar os dados. Os seguintes tipos de transformações de machine learning estão disponíveis: *Encontrar correspondências* Encontra registros duplicados nos dados de origem. Ensine essa transformação de machine learning rotulando exemplos de conjuntos de dados para indicar quais linhas são correspondentes. Quanto mais você ensina a transformação de machine learning com exemplos de dados rotulados, mais ela aprende quais linhas devem ser correspondências. Dependendo de como você configura a transformação, a saída será: + Uma cópia da tabela de entrada, além de uma coluna `match_id` preenchida com valores que indicam conjuntos correspondentes de registros. A coluna `match_id` é um identificador arbitrário. Todos os registros que têm o mesmo `match_id` foram identificados como correspondentes entre si. Os registros com `match_id` diferente não são correspondentes. + Uma cópia da tabela de entrada com as linhas duplicadas removidas. Se várias duplicatas forem encontradas, o registro com a menor chave primária será mantido. *Localização de correspondências incrementais* A transformação Find matches (Localizar correspondências) também pode ser configurada para localizar correspondências entre os quadros existentes e incrementais e retornar como saída uma coluna contendo um ID exclusivo por grupo de correspondência. Para obter mais informações, consulte: [Localizar correspondências incrementais](machine-learning-incremental-matches.md) ### Usando a transformação FindMatches É possível usar a transformação `FindMatches` para encontrar registros duplicados nos dados de origem. Um arquivo de rotulamento é gerado ou fornecido para ajudar a ensinar a transformação. **nota** No momento, não há suporte para transformações `FindMatches` que usem uma chave de criptografia personalizada nas seguintes regiões: Asia Pacific (Osaka) - `ap-northeast-3` Para começar com a transformação FindMatches, você pode seguir as etapas abaixo. Para um exemplo mais avançado e detalhado, consulte o **blog de Big Data da AWS**: [Harmonize data using AWS Glue and AWS Lake Formation FindMatches ML to build a customer 360 view](https://aws.amazon.com/blogs/big-data/harmonize-data-using-aws-glue-and-aws-lake-formation-findmatches-ml-to-build-a-customer-360-view/). #### Conceitos básicos do uso da transformação Find Matches Siga estas etapas para começar a usar a transformação `FindMatches`: 1. Crie uma tabela no AWS Glue Data Catalog para os dados de origem que devem ser limpos. Para obter informações sobre como criar um crawler, consulte [Trabalhar com crawlers no console do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-crawlers.html). Se os seus dados de origem forem um arquivo baseado em texto, como um arquivo de valores separados por vírgulas (CSV), considere o seguinte: + Mantenha o arquivo CSV de registros de entrada e o arquivo de rotulamento em pastas separadas. Caso contrário, o crawler do AWS Glue poderá considerá-los como várias partes da mesma tabela e criar tabelas no Data Catalog de maneira incorreta. + A menos que o arquivo CSV inclua somente caracteres ASCII, garanta que a codificação UTF-8 sem BOM (marca de ordem de byte) seja usada para os arquivos CSV. Geralmente, o Microsoft Excel adiciona uma BOM no início dos arquivos CSV em UTF-8. Para removê-la, abra o arquivo CSV em um editor de texto e salve novamente o arquivo como **UTF-8 without BOM (UTF-8 sem BOM)**. 1. No console do AWS Glue, crie uma tarefa e selecione o tipo de transformação **Find matches (Encontrar correspondências)**. **Importante** A tabela da fonte de dados que você escolher para a tarefa não pode ter mais de 100 colunas. 1. Instrua o AWS Glue a gerar um arquivo de rotulamento selecionando **Generate labeling file (Gerar arquivo de rotulamento)**. O AWS Glue dá o primeiro passo no agrupamento de registros semelhantes para cada `labeling_set_id`, de maneira que você possa revisar esses agrupamentos. Rotule correspondências de rótulos na coluna `label`. + Se você já tiver um arquivo de rotulagem, ou seja, um exemplo de registros que indicam linhas correspondentes, faça upload do arquivo no Amazon Simple Storage Service (Amazon S3). Para obter informações sobre o formato do arquivo de rotulamento, consulte [Formato do arquivo de rotulagem](#machine-learning-labeling-file). Prossiga para a etapa 4. 1. Faça download do arquivo de rotulamento e rotule-o conforme descrito na seção [Rótulo](#machine-learning-labeling). 1. Faça upload do arquivo de rotulamento corrigido. O AWS Glue executa tarefas para ensinar a transformação a encontrar correspondências. Na página da lista **Machine learning transforms (Transformações de machine learning)**, selecione a guia **History (Histórico)**. Essa página indica quando o AWS Glue realiza as seguintes tarefas: + **Import labels (Importar rótulos)** + **Export labels (Exportar rótulos)** + **Generate labels (Gerar rótulos)** + **Estimate quality (Estimar qualidade)** 1. Para criar uma transformação melhor, é possível fazer download, rotular e fazer upload do arquivo rotulado de maneira iterativa. Nas execuções iniciais, pode haver muito mais correspondências incorretas. No entanto, o AWS Glue aprende à medida que você continua a ensiná-lo ao verificar o arquivo de rotulamento. 1. Avalie e ajuste a transformação avaliando a performance e os resultados da localização de correspondências. Para obter mais informações, consulte [Ajustar transformações de machine learning no AWS Glue](add-job-machine-learning-transform-tuning.md). #### Rótulo Quando a `FindMatches` gera um arquivo de rotulamento, os registros são selecionados da tabela de origem. Com base no treinamento anterior, a `FindMatches` identifica os registros mais valiosos dos quais deve aprender. A ação de *rotulamento* consiste na edição de um arquivo de rotulamento (sugerimos usar uma planilha como o Microsoft Excel) e na adição de identificadores, ou rótulos, na coluna `label` que identifica registros correspondentes e não correspondentes. É importante ter uma definição clara e consistente de uma correspondência nos dados de origem. A `FindMatches` aprende dos registros que você designa como correspondências (ou não) e usa suas decisões para aprender a encontrar registros duplicados. Quando um arquivo de rotulamento é gerado pela `FindMatches`, são gerados aproximadamente 100 registros. Geralmente, esses 100 registros são divididos em 10 *conjuntos de rotulagem*, nos quais cada conjunto de rótulos é identificado por um `labeling_set_id` exclusivo gerado pela `FindMatches`. Cada conjunto de rótulos deve ser visto como uma tarefa de rotulagem separada e independente dos demais conjuntos de rótulos. A sua tarefa é identificar os registros correspondentes e não correspondentes dentro de cada conjunto de rótulos. ##### Dicas para editar arquivos de rotulagem em uma planilha Ao editar o arquivo de rotulamento em um aplicativo de planilha, considere o seguinte: + O arquivo pode não abrir com os campos de coluna totalmente expandidos. Pode ser necessário expandir as colunas `labeling_set_id` e `label` para ver o conteúdo dessas células. + Se a coluna de chave primária for um número, como um tipo de dados `long`, a planilha poderá interpretá-la como um número e alterar o valor. Esse valor de chave deve ser tratado como texto. Para corrigir esse problema, formate todas as células da coluna de chave primária como **Text data (Dados de texto)**. #### Formato do arquivo de rotulagem O arquivo de rotulamento gerado pelo AWS Glue para ensinar a transformação `FindMatches` usa o formato a seguir. Se você gerar o seu próprio arquivo para o AWS Glue, ele também deve seguir este formato: + É um arquivo de valores separados por vírgulas (CSV). + Deve estar codificado em `UTF-8`. Se você editar o arquivo usando o Microsoft Windows, ele poderá ser codificado com `cp1252`. + Ele deve estar em um local do Amazon S3 para ser transmitido ao AWS Glue. + Use uma quantidade moderada de linhas para cada tarefa de rotulagem. Recomenda-se 10 a 20 linhas por tarefa, embora 2 a 30 linhas por tarefa seja aceitável. Tarefas com mais de 50 linhas não são recomendadas e podem gerar resultados insatisfatórios ou uma falha no sistema. + Caso já tenha dados rotulados que consistam em pares de registros rotulados como “correspondência” ou “não correspondência”, não há problema. Esses pares rotulados podem ser representados como conjuntos de rótulos de tamanho 2. Nesse caso, rotule ambos os registros com, por exemplo, uma letra “A” caso haja correspondência, e rotule um como “A” e outro como “B” caso não haja correspondência. **nota** Como ele tem colunas adicionais, o arquivo de rotulamento tem um esquema diferente de um arquivo que contém os dados de origem. Coloque o arquivo de rotulagem em uma pasta diferente de qualquer arquivo CSV de entrada da transformação, para que o crawler do AWS Glue não o considere ao criar tabelas no Data Catalog. Caso contrário, a tabela criada pelo crawler do AWS Glue poderá não representar seus dados de maneira correta. + As duas primeiras colunas (`labeling_set_id` e `label`) são exigidas pelo AWS Glue. As colunas restantes devem corresponder ao esquema dos dados a serem processados. + Para cada `labeling_set_id`, identifique todos os registros correspondentes usando o mesmo rótulo. Um rótulo é uma string exclusiva colocada na coluna `label`. Recomendamos o uso de rótulos que contenham caracteres simples, como A, B, C e assim por diante. Os rótulos diferenciam letras maiúsculas de minúsculas e são inseridos na coluna `label`. + As linhas que contêm o mesmo `labeling_set_id` e o mesmo rótulo são rotuladas como uma correspondência. + As linhas que contêm o mesmo `labeling_set_id` e um rótulo diferente são rotuladas como uma *não* correspondência. + As linhas que contêm um `labeling_set_id` diferente não têm informações que confirmam ou rejeitam a correspondência. Veja a seguir um exemplo de rotulamento dos dados: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/machine-learning.html) + No exemplo acima, identificamos John/Johnny/Jon Doe como sendo uma correspondência e ensinamos o sistema que esses registros não correspondem a Jane Smith. Separadamente, ensinamos ao sistema que Richard e Rich Jones são a mesma pessoa, mas esses registros não correspondem a Sarah Jones/Jones-Walker e Richie Jones Jr. + Como pode ver, o escopo dos rótulos está limitado ao `labeling_set_id`. Portanto, os rótulos não cruzam os limites de `labeling_set_id`. Por exemplo, um rótulo "A" em `labeling_set_id` 1 não tem nenhuma relação com o rótulo "A" em `labeling_set_id` 2. + Se um registro não tiver correspondências dentro de um conjunto de rótulos, atribua um rótulo exclusivo ao registro. Por exemplo, Jane Smith não corresponde a qualquer registro no conjunto de rótulos ABC123, portanto, é o único registro nesse conjunto com o rótulo B. + O conjunto de rótulos “GHI678” mostra que um conjunto de rótulos pode consistir em apenas dois registros, que recebem o mesmo rótulo para indicar a correspondência. Da mesma forma, “XYZABC” mostra dois registros com rótulos diferentes para indicar que não são correspondentes. + Observe que, às vezes, um conjunto de rótulos pode não conter correspondências (ou seja, você atribui um rótulo diferente para cada registro dentro do conjunto de rótulos) ou todos os registros do conjunto de rótulos são “iguais” (todos recebem o mesmo rótulo). Isso não é um problema, contanto que os conjuntos de rótulos coletivamente contenham exemplos de registros que sejam e que não sejam “iguais” de acordo com seus critérios. **Importante** Confirme se a função do IAM transmitida ao AWS Glue tem acesso ao bucket do Amazon S3 que contém o arquivo de rotulagem. Por convenção, as políticas do AWS Glue concedem permissão às pastas ou aos buckets do Amazon S3 cujos nomes têm como prefixo **aws-glue-**. Se os arquivos de rotulagem estiverem em um local diferente, adicione uma permissão a essa localização na função do IAM. # Ajustar transformações de machine learning no AWS Glue Você pode ajustar suas transformações de machine learning no AWS Glue para aprimorar os resultados de seus trabalhos de limpeza de dados e atender aos seus objetivos. Para melhorar sua transformação, você pode ensiná-la gerando um conjunto de rotulamento, adicionando rótulos e repetindo essas etapas várias vezes até obter os resultados desejados. Você também pode ajustá-las alterando alguns parâmetros de machine learning. Para obter mais informações sobre transformações de machine learning, consulte [Correspondência de registros com o FindMatches do AWS Lake Formation](machine-learning.md). **Topics** + [Medições de machine learning](machine-learning-terminology.md) + [Escolher entre precisão e recuperação](machine-learning-precision-recall-tradeoff.md) + [Decidir entre acurácia e custo](machine-learning-accuracy-cost-tradeoff.md) + [Estimação da qualidade das correspondências usando pontuações de confiança de correspondência](match-scoring.md) + [Ensinar a transformação Find Matches](machine-learning-teaching.md) # Medições de machine learning Para compreender as medições que são usadas para ajustar a transformação de machine learning, você deve estar familiarizado com a seguinte terminologia: **Verdadeiro positivo (TP)** Uma correspondência nos dados que a transformação encontrou corretamente, também denominada como um *acerto*. **Verdadeiro negativo (TN)** Uma falta de correspondência nos dados que a transformação rejeitou corretamente. **Falsos positivo (FP)** Uma falta de correspondência nos dados que a transformação classificou incorretamente como correspondente, também denominada como um *alarme falso*. **Falso negativo (FN)** Uma correspondência nos dados que a transformação não detectou, também denominada como um *erro*. Para obter mais informações sobre a terminologia de machine learning, consulte [Confusion matrix (em inglês)](https://en.wikipedia.org/wiki/Confusion_matrix) na Wikipédia. Para ajustar as transformações de machine learning, você pode alterar o valor das seguintes medidas nas **Advanced properties (Propriedades avançadas)** da transformação. + **Precision** (Precisão) mede o quão bem a transformação encontra verdadeiros positivos entre o número total de registros que identifica como positivos (verdadeiros positivos e falsos positivos). Para obter mais informações, consulte [Precisão e revocação](https://en.wikipedia.org/wiki/Precision_and_recall) na Wikipédia. + A **revocação** mede quão bem a transformação encontra verdadeiros positivos do total de registros nos dados de origem. Para obter mais informações, consulte [Precisão e revocação](https://en.wikipedia.org/wiki/Precision_and_recall) na Wikipédia. + A **acurácia** mede quão bem a transformação encontra verdadeiros positivos e verdadeiros negativos. Aumentar a acurácia exige mais recursos de máquina e eleva os custos. Mas isso também resulta em um aumento da revocação. Para obter mais informações, consulte [Accuracy and precision (em inglês)](https://en.wikipedia.org/wiki/Accuracy_and_precision#In_information_systems) na Wikipédia. + O **custo** mede quantos recursos de computação (logo, dinheiro) são consumidos para executar a transformação. # Escolher entre precisão e recuperação Toda transformação `FindMatches` tem um parâmetro `precision-recall`. Você usa esse parâmetro para especificar o seguinte: + Caso esteja mais preocupado com a possibilidade da transformação detectar a correspondência de dois registros que, na verdade, não correspondem, favoreça a *precisão*. + Caso esteja mais preocupado com a transformação falhar na detecção de registros que correspondem, favoreça a *revocação*. Você pode ajustar esse equilíbrio no console do AWS Glue ou usando as operações da API de machine learning do AWS Glue. **Quando favorecer a precisão** Dê preferência para a precisão se você estiver mais preocupado com o risco de `FindMatches` corresponder registros que, na verdade, não correspondem. Para favorecer a precisão, escolha um valor *mais alto* de equilíbrio entre precisão e recall. Com um valor mais alto, a transformação `FindMatches` precisa de mais evidências para decidir se dois registros devem corresponder. A transformação será ajustada para corresponder menos registros. Por exemplo, suponha que você esteja usando `FindMatches` para detectar itens duplicados em um catálogo de filmes e fornece um valor de precisão-revocação mais alto para a transformação. Se a sua transformação detecta incorretamente que *Star Wars: Uma Nova Esperança* é o mesmo que *Star Wars: O Império Contra-Ataca*, um cliente que procurando *Uma Nova Esperança* poderá ver *O Império Contra-Ataca*. Isso resultaria em uma experiência do cliente insatisfatória. No entanto, se a transformação não detectar que *Star Wars: Uma Nova Esperança* e *Star Wars: Episódio IV - Uma Nova Esperança* são o mesmo item, o cliente pode ficar confuso, mas reconhecerá os dois como iguais. Isso seria um erro, mas menos prejudicial que o primeiro caso. **Quando favorecer a recuperação** Dê preferência para a revocação se você estiver mais preocupado com o risco da transformação `FindMatches` não detectar pares de registros que, na verdade, são correspondentes. Para favorecer o recall, escolha um valor *mais baixo* de equilíbrio entre precisão e recall. Com um valor mais baixo, a transformação `FindMatches` precisa de menos evidências para decidir se dois registros devem corresponder. A transformação será ajustada para tender a corresponder mais registros. Por exemplo, isso pode ser uma prioridade em uma organização de segurança. Suponha que você está comparando a lista de clientes com uma lista de falsificadores, e deve determinar se cada cliente é um falsificador ou não. Você vai usar `FindMatches` para corresponder a lista de falsificadores com a lista de clientes. Sempre que `FindMatches` detectar uma correspondência entre as duas listas, um auditor humano é atribuído para verificar se aquela pessoa é realmente um falsificador. Sua organização pode preferir revocação ao invés de precisão. Ou seja, você prefere que os auditores revisem e rejeitem manualmente os casos nos quais o cliente não é um falsificador à transformação falhar ao identificar se um cliente está na lista de falsificadores. **Como favorecer tanto a precisão como a recuperação** A melhor maneira de aprimorar a precisão e a revocação é rotulando mais dados. Conforme você rotula mais dados, a acurácia geral da transformação `FindMatches` melhora, aprimorando, por sua vez, a precisão e a revocação. No entanto, até com a maior acurácia possível em uma transformação, você sempre precisará experimentar entre favorecer precisão ou revocação, ou manter um valor equilibrado. # Decidir entre acurácia e custo Cada transformação `FindMatches` contém um parâmetro `accuracy-cost`. Você pode usar esse parâmetro para especificar o seguinte: + Caso esteja mais preocupado com a transformação corresponder dois registros corretamente, favoreça a *acurácia*. + Caso esteja mais preocupado com o custo ou a velocidade de executar a transformação, favoreça *baixo custo*. Você pode ajustar esse equilíbrio no console do AWS Glue ou usando as operações da API de machine learning do AWS Glue. **Quando favorecer a acurácia** Dê preferência para a acurácia se você estiver mais preocupado com o risco dos resultados de `find matches` não terem correspondências. Para favorecer a acurácia, escolha um valor de equilíbrio entre acurácia e custo *mais alto*. Com um valor mais alto, a transformação `FindMatches` precisa de mais tempo para fazer uma pesquisa mais aprofundada e corresponder registros corretamente. Observe que esse parâmetro não diminui a probabilidade de erro na correspondência de dois registros que, na verdade, não correspondem. A transformação será ajustada para gastar mais tempo detectando correspondências. **Quando favorecer o custo** Dê preferência para o custo se estiver mais preocupado com os gastos de execução da transformação `find matches` e menos com a quantidade de correspondências encontradas. Para favorecer o custo, escolha um valor de equilíbrio entre acurácia e custo *mais baixo*. Com um valor mais baixo, a transformação `FindMatches` exige menos recursos para ser executada. A transformação será ajustada para tender a detectar menos correspondências. Se os resultados forem aceitáveis ao favorecer baixo custo, use essa configuração. **Como favorecer tanto a acurácia como o baixo custo** A máquina leva mais tempo para determinar se mais pares de registros correspondem. Você pode executar as seguintes ações para reduzir os gastos, mas manter a qualidade: + Elimine registros da fonte de dados que não são relevantes para as correspondências. + Elimine colunas da fonte de dados as quais você não tem certeza se são úteis para a identificação de correspondências. Uma boa maneira de decidir isso é eliminando as colunas que você acredita não afetarem sua própria decisão sobre um conjunto de registros ser "o mesmo". # Estimação da qualidade das correspondências usando pontuações de confiança de correspondência As pontuações de confiança de correspondência fornecem uma estimativa da qualidade das correspondências encontradas pelo FindMatches para distinguir entre registros correspondentes nos quais o modelo de machine learning é altamente confiante, incerto ou improvável. Uma pontuação de confiança na partida ficará entre 0 e 1, onde uma pontuação mais alta significa maior semelhança. O exame das pontuações de confiança da correspondência permite distinguir entre clusters de correspondências em que o sistema é altamente confiante (que você pode decidir mesclar), clusters sobre os quais o sistema é incerto (que você pode decidir que seja revisado por um humano) e clusters que o sistema considera improváveis (que você pode decidir rejeitar). Você pode querer ajustar seus dados de treinamento em situações em que veja uma pontuação de confiança de correspondência alta, mas determine que não há correspondências ou onde você vê uma pontuação baixa, mas determina que existem, de fato, correspondências. As pontuações de confiança são particularmente úteis quando há conjuntos de dados industriais de grande porte, nos quais é inviável revisar todas as decisões do FindMatches. As pontuações de confiança de correspondência estão disponíveis no AWS Glue versão 2.0 ou posterior. ## Geração de pontuações de confiança de correspondência Você pode gerar pontuações de confiança de correspondência definindo o valor booleano de `computeMatchConfidenceScores` para True (Verdadeiro) ao chamar `FindMatches` ou a API `FindIncrementalMatches`. O AWS Glue adiciona um novo `column match_confidence_score` para a saída. ## Exemplos de pontuação de correspondência Por exemplo, considere os registros correspondentes a seguir: **Pontuação >= 0,9** Resumo dos registros correspondentes: ``` primary_id | match_id | match_confidence_score 3281355037663 85899345947 0.9823658302132061 1546188247619 85899345947 0.9823658302132061 ``` Detalhes: ![\[Um exemplo de uma tabela de rotas com um gateway da Internet.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/match_score1.png) A partir deste exemplo, podemos ver que dois registros são muito semelhantes e compartilham `display_position`, `primary_name`, e `street name`. **Pontuação >= 0,8 e pontuação < 0,9** Resumo dos registros correspondentes: ``` primary_id | match_id | match_confidence_score 309237680432 85899345928 0.8309852373674638 3590592666790 85899345928 0.8309852373674638 343597390617 85899345928 0.8309852373674638 249108124906 85899345928 0.8309852373674638 463856477937 85899345928 0.8309852373674638 ``` Detalhes: ![\[Um exemplo de uma tabela de rotas com um gateway da Internet.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/match_score2.png) A partir deste exemplo, podemos ver que esses registros compartilham o mesmo `primary_name`, e `country`. **Pontuação >= 0,6 e pontuação < 0,7** Resumo dos registros correspondentes: ``` primary_id | match_id | match_confidence_score 2164663519676 85899345930 0.6971099896480333 317827595278 85899345930 0.6971099896480333 472446424341 85899345930 0.6971099896480333 3118146262932 85899345930 0.6971099896480333 214748380804 85899345930 0.6971099896480333 ``` Detalhes: ![\[Um exemplo de uma tabela de rotas com um gateway da Internet.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/match_score3.png) A partir deste exemplo, podemos ver que esses registros compartilham somente o mesmo `primary_name`. Para obter mais informações, consulte: + [Etapa 5: adicionar e executar um trabalho com sua transformação de machine learning](machine-learning-transform-tutorial.md#ml-transform-tutorial-add-job) + PySpark: [Classe FindMatches](aws-glue-api-crawler-pyspark-transforms-findmatches.md) + PySpark: [Classe FindIncrementalMatches](aws-glue-api-crawler-pyspark-transforms-findincrementalmatches.md) + Scala: [Classe FindMatches](glue-etl-scala-apis-glue-ml-findmatches.md) + Scala: [Classe FindIncrementalMatches](glue-etl-scala-apis-glue-ml-findincrementalmatches.md) # Ensinar a transformação Find Matches Cada transformação `FindMatches` precisa ser ensinada para saber o que deve ou não ser considerado como correspondência. Você ensina sua transformação adicionando rótulos a um arquivo e fazendo upload de suas escolhas para o AWS Glue. Você pode orquestrar esse rotulamento no console do AWS Glue ou usando as operações da API de machine learning do AWS Glue. **Quantas vezes devo adicionar rótulos? Quantos rótulos são necessários?** As respostas para essas perguntas dependem de você. Você deve avaliar se `FindMatches` está fornecendo o nível de acurácia de que você precisa e se o esforço adicional de rotulamento vale a pena. A melhor maneira de decidir isso é analisando as métricas “Precision (Precisão)”, “Recall (Revocação)” e “Area under the precision recall curve (Área sob a curva de precisão e revocação)” que você pode gerar selecionando **Estimate quality (Estimativa de qualidade)** no console do AWS Glue. Depois de rotular mais conjuntos de tarefas, execute essas métricas novamente e verifique se foram aprimoradas. Caso, depois de rotular alguns conjuntos de tarefas, você não veja uma melhoria na métrica em que está focando, a qualidade da transformação pode ter atingido seu auge. **Qual é a necessidade de ter ambos os rótulos verdadeiro positivo e verdadeiro negativo?** A transformação `FindMatches` precisa de exemplos positivos e negativos para aprender o que você considera como correspondência. Se você estiver rotulando dados de treinamento gerados por `FindMatches` (por exemplo, usando a opção **I do not have labels (Eu não tenho rótulos)**), a transformação `FindMatches` tentará gerar um conjunto de "label set ids" (IDs de conjunto de rótulo) para você. Em cada tarefa, você atribui o mesmo “rótulo” a alguns registros e “rótulos” diferentes a outros registros. Em outras palavras, as tarefas não costumam ser completamente iguais ou completamente diferentes (porém, não há problema se uma tarefa específica for tudo “igual” ou tudo “diferente”). Se você estiver ensinando a sua transformação `FindMatches` usando a opção **Upload labels from S3 (Fazer upload de rótulos do S3)**, tente incluir os exemplos de registros correspondentes e não correspondentes. Ter apenas um tipo é aceitável. Esses rótulos ajudam a aumentar a acurácia da transformação `FindMatches`, mas você ainda precisa rotular alguns registros que gerou com a opção **Generate labeling file (Gerar arquivo de rotulamento)**. **Como posso garantir que a transformação faça correspondências conforme ensinei?** A transformação `FindMatches` aprende com os rótulos que você fornece, portanto, pode gerar pares de registros que não seguem os rótulos fornecidos. Para garantir que a transformação `FindMatches` siga seus rótulos, selecione **EnforceProvidedLabels** em **FindMatchesParameter**. **Quais técnicas podem ser usadas quando uma transformação de ML identifica como correspondentes itens que não são uma correspondência verdadeira?** Você pode usar as seguintes técnicas: + Aumente o valor de `precisionRecallTradeoff`. Isso resultará eventualmente em menos correspondências encontradas, mas também deve dividir seu grande cluster quando atingir um valor alto o suficiente. + Execute as linhas de saída correspondentes aos resultados incorretos e reformate-as como um conjunto de rotulamento (removendo a coluna `match_id` e adicionando uma coluna `labeling_set_id` e `label`). Se necessário, quebre-as (subdivida-as) em vários conjuntos de rotulamento para garantir que o rotulador possa ter todos os conjuntos em mente ao atribuir rótulos. Depois, rotule corretamente os conjuntos correspondentes, faça upload do arquivo de rótulo e anexe-o aos rótulos existentes. Isso pode ajudar a ensinar o transformador sobre o que deve procurar para entender o padrão. + (Avançado) Por fim, observe os dados para ver se há um padrão que você pode detectar, mas o sistema não está observando. Pré-processe esses dados usando funções padrão do AWS Glue para *normalizá-los*. Destaque o que deseja que o algoritmo aprenda separando os dados que você considera importante em suas próprias colunas. Ou crie colunas combinadas de colunas cujos dados são relacionados. # Trabalhar com transformações de machine learning É possível usar o AWS Glue para criar transformações personalizadas de machine learning que podem ser usadas para limpar seus dados. É possível criar essas transformações ao criar um trabalho no console do AWS Glue. Para obter informações sobre como criar uma transformação de machine learning, consulte [Correspondência de registros com o FindMatches do AWS Lake Formation](machine-learning.md). **Topics** + [Propriedades da transformação](#console-machine-learning-properties) + [Adicionar e editar transformações de machine learning](#console-machine-learning-transforms-actions) + [Visualizar detalhes da transformação](#console-machine-learning-transforms-details) + [Ensine transformações usando rótulos](#console-machine-learning-transforms-teaching-transforms) ## Propriedades da transformação Para visualizar uma transformação de machine learning existente, 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/). No painel de navegação em **Integração de dados e ETL**, escolha **Ferramentas de classificação de dados > Correspondência de registros**. As propriedades de cada transformação: **Nome da transformação** O nome exclusivo que você atribuiu à transformação ao criá-la. **ID** Um identificador exclusivo da transformação. **Contagem de rótulos** O número de rótulos no arquivo de rotulamento fornecido para ajudar a ensinar a transformação. **Status** Indica se a transformação está **Ready** (Pronta) ou **Needs training** (Precisa de treinamento). Para executar uma transformação de machine learning com êxito em um trabalho, ela deve estar **Ready** (Pronta). **Criado** A data em que a transformação foi criada. **Modificado** A data em que a transformação foi atualizada pela última vez. **Descrição** A descrição fornecida para a transformação, se uma foi fornecida. **AWS GlueVersão do ** A versão do AWS Glue usado. **ID da execução** O nome exclusivo que você atribuiu à transformação ao criá-la. **Tipo de tarefa** O tipo de transformação de machine learning. Por exemplo, **Find matching records (Encontrar registros correspondentes)**. **Status** Indica o status da execução da tarefa. Os status possíveis causas incluem: + Starting + Executando + Parando + Interrompida + Bem-sucedida + Failed + Tempo limite **Erro** Se o status for Falha, uma mensagem descrevendo o motivo da falha será exibida. ## Adicionar e editar transformações de machine learning É possível visualizar, excluir, configurar e ensinar ou ajustar uma transformação no console do AWS Glue. Marque a caixa de seleção ao lado da transformação na lista, selecione **Action (Ação)** e escolha a ação que deseja realizar. ### Criar uma nova transformação de ML Para adicionar uma nova transformação de machine learning, escolha **Criar transformação**. Siga as instruções no assistente **Adicionar trabalho**. Para obter mais informações, consulte [Correspondência de registros com o FindMatches do AWS Lake Formation](machine-learning.md). #### Etapa 1. Defina as propriedades da transformação. 1. Insira um nome e uma descrição (opcional). 1. Opcionalmente, defina a configuração de segurança. Consulte [Usar criptografia de dados com transformações de machine learning](#ml_transform_sec_config). 1. Opcionalmente, defina as configurações de execução da tarefa. As configurações de execução de tarefas permitem que você personalize a forma como a tarefa é executada. Selecione o tipo de operador, o número de operadores, o tempo limite da tarefa (em minutos), o número de tentativas e a versão do AWS Glue. 1. Opcionalmente, defina as tags. Tags são rótulos que você pode atribuir a um recurso da AWS. Cada tag consiste em uma chave e um valor opcional. As tags podem ser usadas para pesquisar e filtrar os recursos ou monitorar os custos na AWS. #### Etapa 2. Escolha a tabela e a chave primária. 1. Escolha o banco de dados e a tabela do catálogo do AWS Glue. 1. Escolha uma chave primária na tabela selecionada. A coluna da chave primária normalmente contém um identificador exclusivo para cada registro da fonte de dados. #### Etapa 3. Selecione as opções de ajuste. 1. Em **Recuperação versus precisão**, escolha o valor de ajuste para ajustar a transformação de modo a favorecer a recuperação ou a precisão. Por padrão, **Balanceado** está selecionado, mas você pode optar por favorecer a recuperação ou a precisão, ou escolher **Personalizado** e inserir um valor entre 0,0 e 1,0 (inclusive). 1. Para **Menor custo versus precisão**, escolha o valor de ajuste para favorecer o menor custo ou a precisão, ou escolha **Personalizado** e insira um valor entre 0,0 e 1,0 (inclusive). 1. Em **Aplicação de correspondência**, escolha **Forçar a saída a corresponder aos rótulos** se quiser ensinar a transformação de ML forçando a saída a corresponder aos rótulos usados. #### Etapa 4: Revisar e criar. 1. Revise as opções das etapas de 1 a 3. 1. Escolha **Editar** para qualquer etapa que precise ser modificada. Escolha **Criar transformação** para concluir o assistente de criação de transformação. ### Usar criptografia de dados com transformações de machine learning Ao adicionar uma transformação de machine learning ao AWS Glue, você pode especificar opcionalmente uma configuração de segurança associada à origem dos dados ou ao destino dos dados. Se o bucket do Amazon S3 usado para armazenar os dados for criptografado com uma configuração de segurança, especifique a mesma configuração de segurança ao criar a transformação. Você também pode optar por usar a criptografia do lado do servidor com o AWS KMS (SSE-KMS) para criptografar o modelo e os rótulos a fim de evitar que pessoas não autorizadas os inspecionem. Se você escolher essa opção, receberá uma solicitação para escolher uma AWS KMS key pelo nome, ou você poderá escolher **Enter a key ARN** (Inserir um ARN de chave). Se você optar por inserir o ARN para a chave do KMS, um segundo campo será exibido onde você poderá inserir o ARN da chave do KMS. **nota** No momento, transformações de ML que usem uma chave de criptografia personalizada não são compatíveis com as seguintes regiões: Asia Pacific (Osaka) - `ap-northeast-3` ## Visualizar detalhes da transformação ### Visualizar as propriedades da transformação A página de **propriedades da transformação** inclui os atributos da sua transformação. Ela mostra os detalhes sobre a definição da transformação, incluindo o seguinte: + **Transform name (Nome da transformação)** mostra o nome da transformação. + **Type (Tipo)** lista o tipo da transformação. + **Status** exibe se a transformação está pronta para ser usada em um script ou em uma tarefa. + **Force output to match labels (Forçar a saída para corresponder rótulos)** exibe se a transformação força a saída a corresponder os rótulos fornecidos pelo usuário. + **Spark version** (Versão do Spark) está relacionada à versão do AWS Glue que você escolheu em **Task run properties** (Propriedades de execução de tarefa) ao adicionar a transformação. O AWS Glue 1.0 e o Spark 2.4 são recomendados para a maioria dos clientes. Para obter mais informações, consulte [versões do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions). ### Abas Histórico, Estimativa de qualidade e Tags Os detalhes da transformação incluem as informações definidas quando ela foi criada. Para visualizar os detalhes de uma transformação, selecione a transformação na lista **Machine learning transforms (Transformações de machine learning)** e revise as informações das seguintes guias: + Histórico + Estimar qualidade + Tags #### Histórico A guia **History (Histórico)** mostra o histórico de execução das tarefas da transformação. Vários tipos de tarefas são executadas para ensinar uma transformação. Para cada tarefa, as métricas de execução incluem o seguinte: + **Run ID (ID da execução)** é um identificador criado pelo AWS Glue para cada execução dessa tarefa. + **Task type (Tipo de tarefa)** mostra o tipo da tarefa executada. + **Status** mostra o êxito de cada tarefa listada com a execução mais recente na parte superior. + **Error (Erro)** mostra os detalhes de uma mensagem de erro se a execução apresentar falha. + **Start time (Hora de início)** mostra a data e a hora (hora local) em que a tarefa foi iniciada. + **Hora de término** mostra a data e a hora (hora local) em que a tarefa foi concluída. + **Logs** links para os logs gravados em `stdout` para esta execução de trabalho. O link **Logs** direciona você para o Amazon CloudWatch Logs. Nesse serviço, é possível visualizar os detalhes sobre as tabelas que foram criadas no AWS Glue Data Catalog e qualquer erro encontrado. Você pode gerenciar seu período de retenção de logs no console do CloudWatch. A retenção de log padrão é `Never Expire`. Para obter mais informações sobre como alterar o período de retenção, consulte [Alterar a retenção dos dados de log no CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) no *Manual do usuário do Amazon CloudWatch Logs*. + **Arquivo de rótulo** mostra um link para o Amazon S3 de um arquivo de rótulo gerado. #### Estimar qualidade A guia **Estimate quality (Estimar qualidade)** mostra as métricas usadas para medir a qualidade da transformação. As estimativas são calculadas comparando as previsões de correspondência de transformação que usam um subconjunto dos dados rotulados com relação aos rótulos fornecidos. Essas estimativas são aproximadas. É possível invocar a execução de uma tarefa **Estimate quality (Estimar qualidade)** nessa guia. A guia **Estimate quality (Estimar qualidade)** mostra as métricas da última execução de **Estimate quality (Estimar qualidade)**, incluindo as seguintes propriedades: + A**Area under the Precision-Recall curve (Área na curva de precisão-revocação)** é um único número que estima o limite máximo da qualidade geral da transformação. Ele é independente da escolha feita para o parâmetro de precisão-revocação. Valores mais altos indicam que você tem uma compensação de precisão-revocação mais atrativa. + **Precision (Precisão)** estima a frequência de acertos da transformação ao prever uma correspondência. + **Recall upper limit (Limite máximo de revocação)** estima com que frequência a transformação prevê uma correspondência real. + **F1** estima a precisão da transformação entre 0 e 1, em que 1 é a maior precisão. Para obter mais informações, consulte [F1 score](https://en.wikipedia.org/wiki/F1_score) na Wikipédia. + A tabela **Column importance** (Importância da coluna) mostra os nomes das colunas e a pontuação de importância para cada uma. A importância da coluna ajuda você a entender como as colunas contribuem para o seu modelo, identificando quais colunas em seus registros estão sendo mais usadas para fazer a correspondência. Esses dados podem solicitar que você adicione ou altere seu conjunto de rótulos para aumentar ou diminuir a importância das colunas. A coluna Importance (Importância) fornece uma pontuação numérica para cada coluna, como um decimal não superior a 1,0. Para obter informações sobre como entender as estimativas de qualidade com relação à qualidade verdadeira, consulte [Diferença entre estimativas de qualidade e qualidade de ponta a ponta (verdadeira)](#console-machine-learning-quality-estimates-true-quality). Para obter mais informações sobre como ajustar a transformação, consulte [Ajustar transformações de machine learning no AWS Glue](add-job-machine-learning-transform-tuning.md). #### Diferença entre estimativas de qualidade e qualidade de ponta a ponta (verdadeira) O AWS Glue estima a qualidade da transformação apresentando ao modelo de machine learning interno vários pares de registros para os quais você forneceu rótulos correspondentes, mas que o modelo ainda não tinha visto. Essas estimativas de qualidade são uma função da qualidade do modelo de machine learning (que é influenciado pelo número de registros que você rotula para "ensinar" a transformação). A recuperação de ponta a ponta, ou *verdadeira* (que não é calculada automaticamente pela `ML transform`), também é influenciada pelo mecanismo de filtragem da `ML transform` que propõe uma ampla variedade de possíveis correspondências ao modelo de machine learning. É possível ajustar esse método de filtragem principalmente especificando o valor de ajuste como **Menor precisão de custos**. À medida que o valor de ajuste tende mais a favorecer a **Precisão**, o sistema faz uma busca mais detalhada e cara de pares de registros que podem ser correspondências. Mais pares de registros são alimentados no modelo de machine learning e a recuperação de ponta a ponta, ou verdadeira da `ML transform` se aproxima da métrica de recuperação estimada. Como resultado, as alterações na qualidade de ponta a ponta das correspondências resultantes de alterações na compensação de custo/precisão das correspondências normalmente não serão refletidas na estimativa de qualidade. #### Tags Tags são rótulos que você pode atribuir a um recurso da AWS. Cada tag consiste em uma chave e um valor opcional. As tags podem ser usadas para pesquisar e filtrar os recursos ou monitorar os custos na AWS. ## Ensine transformações usando rótulos Você pode ensinar a transformação de ML usando rótulos (exemplos) escolhendo **Ensinar a transformação** na página de detalhes da transformação de ML. Ao ensinar seu algoritmo de machine learning fornecendo exemplos (denominados rótulos), você pode escolher usar rótulos existentes ou criar um arquivo de rótulo. ![\[A captura de tela mostra uma tela do assistente para Ensinar a transformação usando rótulos.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/machine-learning-teach-transform.png) + **Rótulagem**: se você tiver rótulos escolha **Eu tenho rótulos**. Se você não tiver rótulos, ainda poderá continuar na próxima etapa gerando de um arquivo de rótulo. + **Gerar arquivo de rotulagem**: o AWS Glue extrai os registros dos dados de origem e sugere possíveis registros correspondentes. Você escolhe o bucket do Amazon S3 para armazenar o arquivo de rótulo gerado. Escolha **Gerar arquivo de rotulagem** para iniciar o processo. Quando terminar, escolha **Baixar arquivo de rotulagem**. O arquivo baixado terá uma coluna para rótulos que você poderá preencher com os rótulos. + **Carregar rótulos do Amazon S3**: escolha o arquivo de rotulo completo do bucket do Amazon S3 em que o arquivo de rótulo está armazenado. Depois, escolha entre anexar os rótulos aos rótulos existentes ou substituir os rótulos existentes. Escolha **Carregar arquivo de rotulagem do Amazon S3**. # Tutorial: como criar uma transformação de machine learning com o AWS Glue Este tutorial orienta você sobre as ações para criar e gerenciar uma transformação de machine learning (ML) usando o AWS Glue. Antes de usar este tutorial, você deverá familiarizar-se com o uso do console do AWS Glue para adicionar crawlers a trabalhos e editar scripts. Você também deve se familiarizar com a localização e o download de arquivos no console do Amazon Simple Storage Service (Amazon S3). Neste exemplo, você vai criar uma transformação `FindMatches` para encontrar registros correspondentes, ensiná-la como identificar registros correspondentes e não correspondentes e usá-la em um trabalho do AWS Glue. O trabalho do AWS Glue grava um novo arquivo do Amazon S3 com uma coluna adicional chamada `match_id`. Os dados de origem usados por este tutorial é um arquivo chamado `dblp_acm_records.csv`. Esse arquivo é uma versão modificada de publicações acadêmicas (DBLP e ACM) disponíveis no [Conjunto de dados de DBLP ACM](https://doi.org/10.3886/E100843V2) original. O arquivo `dblp_acm_records.csv` é um arquivo de valores separados por vírgula (CSV) no formato UTF-8 sem marca de ordem de bytes (BOM). Um segundo arquivo, `dblp_acm_labels.csv`, é um exemplo de arquivo de rotulagem que contém registros correspondentes e não correspondentes usados para ensinar a transformação como parte do tutorial. **Topics** + [Etapa 1: rastrear os dados de origem](#ml-transform-tutorial-crawler) + [Etapa 2: adicionar uma transformação de machine learning](#ml-transform-tutorial-create) + [Etapa 3: ensinar sua transformação de machine learning](#ml-transform-tutorial-teach) + [Etapa 4: estimar a qualidade de sua transformação de machine learning](#ml-transform-tutorial-estimate-quality) + [Etapa 5: adicionar e executar um trabalho com sua transformação de machine learning](#ml-transform-tutorial-add-job) + [Etapa 6: verificar os dados de saída do Amazon S3](#ml-transform-tutorial-data-output) ## Etapa 1: rastrear os dados de origem Primeiro, rastreie o arquivo CSV de origem do Amazon S3 para criar uma tabela de metadados correspondente no Data Catalog. **Importante** Para direcionar o crawler a criar uma tabela somente para o arquivo CSV, armazene os dados de origem do CSV em uma pasta do Amazon S3 separada de outros arquivos. 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 **Crawlers**, **Add crawler (Adicionar crawler)**. 1. Siga o assistente para criar e executar um crawler chamado `demo-crawl-dblp-acm` com a saída para o banco de dados `demo-db-dblp-acm`. Ao executar o assistente, crie o banco de dados, `demo-db-dblp-acm` se ele ainda não existir. Escolha um caminho de inclusão do Amazon S3 para os dados de exemplo na região da AWS atual. Por exemplo, para `us-east-1`, o caminho de inclusão do Amazon S3 para o arquivo de origem será `s3://ml-transforms-public-datasets-us-east-1/dblp-acm/records/dblp_acm_records.csv`. Se for bem-sucedido, o crawler criará a tabela `dblp_acm_records_csv` com as seguintes colunas: id, título, autores, local, ano e origem. ## Etapa 2: adicionar uma transformação de machine learning Em seguida, adicione uma transformação de machine learning que se baseia no esquema da tabela de fonte de dados criada pelo crawler chamado `demo-crawl-dblp-acm`. 1. No console do AWS Glue, no painel de navegação em **Integração de dados e ETL**, escolha **Ferramentas de classificação de dados > Correspondência de registros** e depois **Adicionar transformação**. Siga o assistente para criar uma transformação `Find matches` com as propriedades a seguir. 1. Em **Transform name (Nome da transformação)**, insira **demo-xform-dblp-acm**. Este é o nome da transformação que é usada para localizar correspondências nos dados de origem. 1. Em **IAM role** (Função do IAM), escolha uma função do IAM que tenha permissão para os dados de origem do Amazon S3, o arquivo de rotulagem e as operações da API do AWS Glue. Para obter mais informações, consulte [Criar uma função do IAM para o AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html) no *Guia do desenvolvedor do AWS Glue*. 1. Em **Data source (Fonte de dados)**, escolha a tabela chamada **dblp\$1acm\$1records\$1csv** no banco de dados **demo-db-dblp-acm**. 1. Em **Primary key (Chave primária)**, escolha a coluna de chave primária da tabela **id**. 1. No assistente, escolha **Finish (Concluir)** e retorne à lista **ML transforms (Transformações de ML)**. ## Etapa 3: ensinar sua transformação de machine learning Em seguida, você ensina sua transformação de machine learning usando o arquivo de rotulagem de exemplo do tutorial. Não é possível usar uma transformação de linguagem de máquina em um trabalho de extração, transformação e carga (ETL) até que o status dela seja **Ready for use (Pronta para uso)**. Para que sua transformação fique pronta, você deve ensiná-la como identificar registros correspondentes e não correspondentes fornecendo exemplos desses registros. Para ensinar a transformação, você pode **Generate a label file (Gerar um arquivo de rótulos)**, adicionar rótulos e **Upload label file (Fazer upload do arquivo de rótulos)**. Neste tutorial, você poderá usar o arquivo de rotulagem de exemplo chamado `dblp_acm_labels.csv`. Para obter mais informações sobre o processo de rotulagem, consulte [Rótulo](machine-learning.md#machine-learning-labeling). 1. No console do AWS Glue, no painel de navegação, escolha **Correspondência de registros**. 1. Escolha a transformação `demo-xform-dblp-acm` e escolha **Action (Ação)**, **Teach (Ensinar)**. Siga o assistente para ensinar a transformação `Find matches`. 1. Na página de propriedades da transformação, escolha **I have labels (Tenho rótulos)**. Escolha um caminho do Amazon S3 para o arquivo de rotulagem de exemplo na região da AWS atual. Por exemplo, para `us-east-1`, faça upload do arquivo de rotulagem fornecido no caminho do Amazon S3 `s3://ml-transforms-public-datasets-us-east-1/dblp-acm/labels/dblp_acm_labels.csv` com a opção de **overwrite** (substituir) os rótulos existentes. O arquivo de rotulagem deve estar localizado no Amazon S3 na mesma região que o console do AWS Glue. Quando você faz upload de um arquivo de rotulagem, uma tarefa é iniciada no AWS Glue para adicionar ou substituir os rótulos usados para ensinar a transformação como processar a fonte de dados. 1. Na página final do assistente, escolha **Finish (Concluir)** e retorne à lista de **ML transforms (Transformações de ML)**. ## Etapa 4: estimar a qualidade de sua transformação de machine learning É possível estimar a qualidade de sua transformação de machine learning. A qualidade depende da quantidade de rotulagem que você tiver feito. Para obter mais informações sobre como estimar a qualidade, consulte [Estimar qualidade](console-machine-learning-transforms.md#console-machine-learning-transforms-metrics). 1. No console do AWS Glue, no painel de navegação em **Integração de dados e ETL**, escolha **Ferramentas de classificação de dados > Correspondência de registros**. 1. Escolha a transformação `demo-xform-dblp-acm` e escolha a guia **Estimate quality (Estimar qualidade)**. Essa guia exibe as estimativas de qualidade atuais, se disponível, para a transformação. 1. Escolha **Estimate quality (Estimar qualidade)** para iniciar uma tarefa para estimar a qualidade da transformação. A precisão da estimativa da qualidade é baseada na rotulagem dos dados de origem. 1. Navegue até a guia **History (Histórico)**. Nesse painel, estão listadas as execuções de tarefa para a transformação, incluindo a tarefa **Estimating quality (Estimar qualidade)**. Para obter mais detalhes sobre a execução, escolha **Logs**. Verifique se o status da execução é **Succeeded (Bem-sucedido)** após a conclusão. ## Etapa 5: adicionar e executar um trabalho com sua transformação de machine learning Nesta etapa, você usará a transformação de machine learning para adicionar e executar um trabalho no AWS Glue. Quando a transformação `demo-xform-dblp-acm` estiver **Ready for use (Pronta para uso)**, você poderá usá-la em um trabalho de ETL. 1. No console do AWS Glue, no painel de navegação, escolha **Jobs (Trabalhos)**. 1. Escolha **Add job (Adicionar trabalho)**, e siga as etapas do assistente para criar um trabalho de ETL do Spark com um script gerado. Escolha os seguintes valores de propriedade para sua transformação: 1. Em **Name (Nome)**, escolha o trabalho de exemplo neste tutorial, **demo-etl-dblp-acm**. 1. Em **IAM role** (Função do IAM), escolha uma função do IAM com permissão para os dados de origem do Amazon S3, o arquivo de rotulagem e as operações da API do AWS Glue. Para obter mais informações, consulte [Criar uma função do IAM para o AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html) no *Guia do desenvolvedor do AWS Glue*. 1. Em **ETL language (Linguagem de ETL)**, escolha **Scala**. Esta será a linguagem de programação no script de ETL. 1. Em **Script file name (Nome do arquivo de script)**, escolha **demo-etl-dblp-acm**. Este é o nome do arquivo do script Scala (igual ao nome do trabalho). 1. Em **Data source (Fonte de dados)**, escolha **dblp\$1acm\$1records\$1csv**. A fonte de dados que você escolher deve corresponder ao esquema da fonte de dados da transformação de machine learning. 1. Em **Transform type (Tipo de transformação)**, escolha **Find matching records (Encontrar registros correspondentes)** para criar um trabalho usando uma transformação de machine learning. 1. Desmarque **Remove duplicate records (Remover registros duplicados)**. Não remova os registros duplicados porque os registros de saída de gravados têm um campo extra `match_id` adicionado. 1. Em **Transform (Transformação)**, escolha a transformação de machine learning **demo-xform-dblp-acm** usada pelo trabalho. 1. Em **Create tables in your data target (Criar tabelas em seu destino de dados)**, escolha criar tabelas com as seguintes propriedades: + **Data store type (Tipo de armazenamento de dados** — **Amazon S3** + **Format** (Formato): **CSV** + **Compression type (Tipo de compactação** — **None** + **Target path** (Caminho de destino): o caminho do Amazon S3 onde a saída do trabalho é gravada (no console da região da AWS atual) 1. Escolha **Save job and edit script (Salvar trabalho e editar script)** para exibir a página do editor de script. 1. Edite o script para adicionar uma instrução para fazer com que a saída do trabalho para o **Target path (Caminho de destino)** seja gravado em um único arquivo de partição. Adicione essa instrução imediatamente após a instrução que executa a transformação `FindMatches`. A instrução é semelhante ao seguinte. ``` val single_partition = findmatches1.repartition(1) ``` Você deve modificar a instrução `.writeDynamicFrame(findmatches1)` para gravar a saída como `.writeDynamicFrame(single_partion)`. 1. Depois de editar o script, escolha **Save (Salvar)**. O script modificado é similar ao código a seguir, mas personalizado para seu ambiente. ``` import com.amazonaws.services.glue.GlueContext import com.amazonaws.services.glue.errors.CallSite import com.amazonaws.services.glue.ml.FindMatches import com.amazonaws.services.glue.util.GlueArgParser import com.amazonaws.services.glue.util.Job import com.amazonaws.services.glue.util.JsonOptions import org.apache.spark.SparkContext import scala.collection.JavaConverters._ object GlueApp { def main(sysArgs: Array[String]) { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) // @params: [JOB_NAME] val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray) Job.init(args("JOB_NAME"), glueContext, args.asJava) // @type: DataSource // @args: [database = "demo-db-dblp-acm", table_name = "dblp_acm_records_csv", transformation_ctx = "datasource0"] // @return: datasource0 // @inputs: [] val datasource0 = glueContext.getCatalogSource(database = "demo-db-dblp-acm", tableName = "dblp_acm_records_csv", redshiftTmpDir = "", transformationContext = "datasource0").getDynamicFrame() // @type: FindMatches // @args: [transformId = "tfm-123456789012", emitFusion = false, survivorComparisonField = "", transformation_ctx = "findmatches1"] // @return: findmatches1 // @inputs: [frame = datasource0] val findmatches1 = FindMatches.apply(frame = datasource0, transformId = "tfm-123456789012", transformationContext = "findmatches1", computeMatchConfidenceScores = true) // Repartition the previous DynamicFrame into a single partition. val single_partition = findmatches1.repartition(1) // @type: DataSink // @args: [connection_type = "s3", connection_options = {"path": "s3://aws-glue-ml-transforms-data/sal"}, format = "csv", transformation_ctx = "datasink2"] // @return: datasink2 // @inputs: [frame = findmatches1] val datasink2 = glueContext.getSinkWithFormat(connectionType = "s3", options = JsonOptions("""{"path": "s3://aws-glue-ml-transforms-data/sal"}"""), transformationContext = "datasink2", format = "csv").writeDynamicFrame(single_partition) Job.commit() } } ``` 1. Escolha **Run job (Executar trabalho)** para iniciar a execução do trabalho. Verifique o status do trabalho na lista de trabalhos. Quando o trabalho terminar, em **ML transform** (Transformação de ML), guia **History** (Histórico), haverá uma nova linha adicionada **Run ID** (ID de execução) do tipo **ETL job** (Trabalho de ETL). 1. Navegue até **Jobs** (Trabalhos), guia **History** (Histórico). Nesse painel, estão listadas as execuções de trabalho. Para obter mais detalhes sobre a execução, escolha **Logs**. Verifique se o status da execução é **Succeeded (Bem-sucedido)** após a conclusão. ## Etapa 6: verificar os dados de saída do Amazon S3 Nesta etapa, verifique a saída da execução do trabalho no bucket do Amazon S3 que você escolheu quando adicionou o trabalho. Você pode fazer download do arquivo de saída em sua máquina local e verificar se os registros correspondentes foram identificados. 1. Abra o console do Amazon S3, em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/). 1. Faça download do arquivo de saída de destino do trabalho `demo-etl-dblp-acm`. Abra o arquivo em um aplicativo de planilha (talvez seja necessário adicionar uma extensão de arquivo `.csv` para que o arquivo abra corretamente). A imagem a seguir mostra um trecho da saída no Microsoft Excel. ![\[Planilha do Excel mostrando a saída da transformação.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/demo_output_dblp_acm.png) O arquivo da fonte de dados e o arquivo do destino têm 4.911 registros. No entanto, a transformação `Find matches` adiciona outra coluna chamada `match_id` para identificar registros correspondentes na saída. As linhas com o mesmo `match_id` são consideradas registros correspondentes. O `match_confidence_score` é um número entre 0 e 1 que fornece uma estimativa da qualidade das correspondências encontradas por `Find matches`. 1. Classifique o arquivo de saída por `match_id` para ver facilmente quais registros são correspondentes. Compare os valores nas outras colunas para ver se você concorda com os resultados da transformação `Find matches`. Se você não concordar, poderá continuar a ensinar a transformação adicionando mais rótulos. Também é possível classificar o arquivo por outro campo, como `title`, para ver se os registros com títulos semelhantes têm o mesmo `match_id`. # Localizar correspondências incrementais O recurso Find matches permite identificar registros duplicados ou correspondentes no seu conjunto de dados, mesmo quando os registros não tenham um identificador exclusivo comum e quando não houver campos com uma correspondência exata. A versão inicial da transformação Find matches identificava registros correspondentes em um único conjunto de dados. Quando você adiciona novos dados ao conjunto de dados, você precisava mesclá-los com o conjunto de dados limpo existente e executar novamente a correspondência com o conjunto de dados mesclado completo. O recurso de correspondência incremental facilita a correspondência com registros incrementais em relação a conjuntos de dados correspondentes existentes. Vamos supor que você queira combinar dados de clientes potenciais com conjuntos de dados de clientes existentes. O recurso de correspondência incremental oferece a flexibilidade de combinar centenas de milhares de novos clientes potenciais com um banco de dados existente de clientes potenciais e clientes, mesclando os resultados em um único banco de dados ou tabela. Ao fazer a correspondência somente entre os conjuntos de dados novos e existentes, a otimização da localização de correspondências incrementais reduz o tempo de computação, o que também reduz o custo. O uso de correspondência incremental é semelhante a Find matches conforme descrito em [Tutorial: como criar uma transformação de machine learning com o AWS Glue](machine-learning-transform-tutorial.md). Este tópico identifica apenas as diferenças com correspondência incremental. Para obter mais informações, consulte a postagem do blog em [Correspondências de dados incrementais](https://aws.amazon.com/blogs/big-data/incremental-data-matching-using-aws-lake-formation/). ## Execução de um trabalho de correspondência incremental Para o procedimento a seguir, suponha o seguinte: + Você rastreou o conjunto de dados existente até a tabela *first\$1records*. O conjunto de dados *first\$1records* deve ser um conjunto de dados correspondente ou a saída do trabalho correspondente. + Você criou e treinou uma transformação de Find matches com o AWS Glue versão 2.0. Essa é a única versão do AWS Glue com suporte a correspondências incrementais. + A linguagem de ETL é Scala. Observe que também há suporte para Python. + O modelo já gerado é chamado de `demo-xform`. 1. Rastreie o conjunto de dados incremental até a tabela *second\$1records*. 1. No console do AWS Glue, no painel de navegação, escolha **Jobs (Trabalhos)**. 1. Escolha **Add job (Adicionar trabalho)**, e siga as etapas do assistente para criar um trabalho de ETL do Spark com um script gerado. Escolha os seguintes valores de propriedade para sua transformação: 1. Em **Name** (Nome), escolha**demo-etl**. 1. Em **IAM role** (Função do IAM), escolha uma função do IAM com permissão para os dados de fonte do Amazon S3, o arquivo de rotulagem e as [operações de API do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html). 1. Em **ETL language (Linguagem de ETL)**, escolha **Scala**. 1. Em **Script file name** (Nome do arquivo de script), escolha **demo-etl**. Esse é o nome do arquivo do script Scala. 1. Em **Data source** (Fonte de dados), escolha **first\$1records**. A fonte de dados que você escolher deve corresponder ao esquema da fonte de dados da transformação de machine learning. 1. Em **Transform type (Tipo de transformação)**, escolha **Find matching records (Encontrar registros correspondentes)** para criar um trabalho usando uma transformação de machine learning. 1. Selecione a opção de correspondência incremental e para **Data Source** (Fonte de dados), selecione a tabela chamada **second\$1records**. 1. Em **Transform** (Transformação), escolha **demo-xform**, a transformação de machine learning usada pelo trabalho. 1. Escolha **Create tables in your data target** (Criar tabelas em seu destino de dados) ou **Use tables in the data catalog and update your data target** (Usar tabelas no catálogo de dados e atualizar seu destino de dados). 1. Escolha **Save job and edit script (Salvar trabalho e editar script)** para exibir a página do editor de script. 1. Escolha **Run job (Executar trabalho)** para iniciar a execução do trabalho. # Usar FindMatches em um trabalho visual Para usar a transformação **FindMatches** no AWS Glue Studio, você pode usar o nó **Transformação personalizada** que invoca a API FindMatches. Para obter mais informações sobre como usar uma transformação personalizada, consulte [Criar uma transformação personalizada](https://docs.aws.amazon.com/glue/latest/ug/transforms-custom.html) **nota** Atualmente, a API FindMatches só funciona com o `Glue 2.0`. **Para executar um trabalho com a transformação personalizada que invoca a API FindMatches, verifique se a versao do AWS Glue é `Glue 2.0` na guia Detalhes do trabalho**. Se a versão do AWS Glue não for `Glue 2.0`, o trabalho falhará no runtime com a seguinte mensagem de erro: “não é possível importar o nome 'FindMatches' de 'awsglueml.transforms'”. ## Pré-requisitos + Para usar a transformação **Find Matches**, abra o console do AWS Glue Studio no [https://console.aws.amazon.com/gluestudio/](https://console.aws.amazon.com/gluestudio/). + Cria uma transformação de machine learning. Quando criada, um transformId é gerado. Você precisará desse ID nas etapas abaixo. Para obter mais informações sobre como criar uma transformação de machine learning, consulte [Adicionar e editar transformações de machine learning](https://docs.aws.amazon.com/glue/latest/dg/console-machine-learning-transforms.html#console-machine-learning-transforms-actions). ## Adicionar uma transformação FindMatches **Para adicionar uma transformação FindMatches:** 1. No editor de trabalho do AWS Glue Studio, abra o painel Recurso clicando no símbolo de cruz no canto superior esquerdo do gráfico visual do trabalho e escolha uma fonte de dados selecionando a guia **Dados**. Essa é a fonte de dados na qual você deseja verificar se há correspondências. ![\[A captura de tela mostra um símbolo de cruz dentro de um círculo. Quando você clica nesse símbolo no editor de trabalho visual, o painel de recursos é aberto.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/resource-panel-blank-canvas.png) 1. Escolha o nó da fonte de dados e abra o painel Recurso clicando no símbolo de cruz no canto superior esquerdo do gráfico visual do trabalho e procure “transformação personalizada”. Escolha o nó **Transformação personalizada** para adicioná-lo ao gráfico. A **transformação personalizada** é vinculada ao nó da fonte de dados. Caso contrário, você pode clicar no nó **Transformação personalizada** e escolher a guia **Propriedades do nó** e, em **Superiores do nó**, escolher a fonte de dados. 1. Clique no nó **Transformação personalizada** no gráfico visual, depois escolha a guia **Propriedades do nó** e dê um nome para a transformação personalizada. É recomendável renomear a transformação para que o nome da transformação seja facilmente identificável no gráfico visual. 1. Escolha a guia **Transformar**, na qual você pode editar o bloco de código. É aqui que o código para invocar a API FindMatches pode ser adicionado. ![\[A captura de tela mostra o bloco de código na guia Transformar quando o nó Transformação personalizada é selecionado.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/custom-transform-code-block.png) O bloco de código contém código já preenchido para você começar. Substitua o código já preenchido pelo modelo abaixo. O modelo tem um espaço reservado para o **transformId**, o qual você pode fornecer. ``` def MyTransform (glueContext, dfc) -> DynamicFrameCollection: dynf = dfc.select(list(dfc.keys())[0]) from awsglueml.transforms import FindMatches findmatches = FindMatches.apply(frame = dynf, transformId = "") return(DynamicFrameCollection({"FindMatches": findmatches}, glueContext)) ``` 1. Clique no nó **Transformação personalizada** no gráfico visual, abra o painel Recurso clicando no símbolo de cruz no canto superior esquerdo do gráfico visual do trabalho e procure “transformação personalizada”. Não há necessidade de alterar a seleção padrão, pois há somente um DynamicFrame no conjunto. 1. Você pode continuar adicionando transformações ou armazenar o resultado, que agora está enriquecido com as colunas adicionais de descoberta de correspondências. Se você quiser referenciar essas novas colunas em transformações posteriores, precisará adicioná-las ao esquema de saída da transformação. A maneira mais fácil de fazer isso é escolher a guia **Visualização de dados** e, na guia Esquema, escolher “Usar esquema de visualização de dados”. 1. Para personalizar findMatches, você pode adicionar outros parâmetros para passar para o método 'aplicar'. Consulte [Classe FindMatches](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-transforms-findmatches.html). ## Adicionar uma transformação incremental FindMatches No caso de correspondências incrementais, o processo é o mesmo que **Adicionar uma transformação FindMatches** com as seguintes diferenças: + Em vez de um nó superior para a transformação personalizada, você precisará de dois nós superiores. + O primeiro nó superior deve ser o conjunto de dados. + O segundo nó superior deve ser o conjunto de dados incrementais. Substitua o `transformId` pelo seu `transformId` no bloco de código do modelo: ``` def MyTransform (glueContext, dfc) -> DynamicFrameCollection: dfs = list(dfc.values()) dynf = dfs[0] inc_dynf = dfs[1] from awsglueml.transforms import FindIncrementalMatches findmatches = FindIncrementalMatches.apply(existingFrame = dynf, incrementalFrame = inc_dynf, transformId = "") return(DynamicFrameCollection({"FindMatches": findmatches}, glueContext)) ``` + Para obter parâmetros opcionais, consulte a classe [FindIncrementalMatches](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-transforms-findincrementalmatches.html). # Migrar programas do Apache Spark para o AWS Glue O Apache Spark é uma plataforma de código aberto para workloads de computação distribuída executadas em grandes conjuntos de dados. O AWS Glue utiliza os recursos do Spark para fornecer uma experiência otimizada para ETL. Você pode migrar programas Spark para o AWS Glue para utilizar nossos recursos. O AWS Glue fornece os mesmos aprimoramentos de performance que você esperaria do Apache Spark no Amazon EMR. ## Executar o código Spark O código nativo do Spark pode ser executado em um ambiente AWS Glue pronto para uso. Os scripts muitas vezes são desenvolvidos alterando iterativamente um trecho de código, um fluxo de trabalho adequado para uma sessão interativa. No entanto, convém executar o código existente em um trabalho do AWS Glue, que permite agendar e obter consistentemente logs e métricas para cada execução de script. Você pode carregar e editar um script existente pelo console. 1. Adquira a origem de seu script. Para este exemplo, você usará um script de exemplo do repositório do Apache Spark. [Exemplo de binarizador](https://github.com/apache/spark/blob/master/examples/src/main/python/ml/binarizer_example.py) 1. No console do AWS Glue, expanda o painel de navegação do lado esquerdo e selecione **ETL** > **Jobs** (Trabalhos) No painel **Create job** (Criar trabalho), selecione **Spark script editor** (Editor de scripts Spark). Será exibida a seção **Options** (Opções). Em **Options** (Opções), clique em **Upload and edit an existing script** (Carregar e editar um script existente). Será exibida a seção **File upload** (Carregamento de arquivo). Em **File upload** (Carregamento de arquivo), clique em **Choose file** (Escolher arquivo). Será exibido seletor de arquivos do sistema. Navegue até o local em que você salvou `binarizer_example.py`, selecione-o e confirme a seleção. Será exibido um botão **Create** (Criar) no cabeçalho do painel **Create job** (Criar trabalho). Clique. ![\[A página do AWS Glue Studio Jobs com o painel do editor de scripts Spark selecionado.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/migrate-apache-spark-01-upload-job.png) 1. Seu navegador conduzirá até o editor de scripts. No cabeçalho, clique na guia **Job details** (Detalhes do trabalho). Defina o **nome** e o **perfil do IAM**. Para obter orientação sobre perfis do IAM do AWS Glue, consulte[Configurar permissões do IAM para o AWS Glue](set-up-iam.md). Opcionalmente: defina **Requested number of workers** (Número solicitado de operadores) para `2` e **Number of retries** (Número de repetições) para `1`. Essas opções são proveitosas para executar trabalhos de produção, mas recusá-las simplificará sua experiência ao testar um recurso. Na barra de título, clique em **Save** (Salvar) e depois em **Run** (Executar) ![\[A página de detalhes do trabalho com opções definidas conforme as instruções.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/migrate-apache-spark-02-job-details.png) 1. Navegue até a guia **Runs** (Execuções). Você verá um painel correspondente à execução do trabalho. Aguarde alguns instantes, e a página deverá atualizar automaticamente para exibir **Succeeded** (Êxito) em **Run status** (Status da execução). ![\[A página de execuções de trabalho com uma execução de trabalho bem-sucedida.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/migrate-apache-spark-03-job-runs.png) 1. Convém examinar sua saída para confirmar que o script Spark foi executado conforme o esperado. Esse script de amostra do Apache Spark deve gravar uma cadeia de caracteres no fluxo de saída. Você pode descobrir isso navegando até **Output logs** (Logs de saída) em **Logs** no painel para a execução bem-sucedida do trabalho. Observe o ID de execução do trabalho, que é um ID gerado no rótulo **Id** começando com `jr_`. Isso abrirá o console do CloudWatch, definido para visualizar o conteúdo do grupo de logs padrão `/aws-glue/jobs/output` do AWS Glue, filtrado para o conteúdo dos fluxos de logs para o ID de execução do trabalho. Cada operador terá gerado um fluxo de logs, mostrado como linhas em **Log streams** (Fluxos de log). Um operador deverá ter executado o código solicitado. Você precisará abrir todos os fluxos de logs para identificar o operador correto. Depois de encontrar o operador certo, você deverá ver a saída do script, como é exibido na imagem a seguir: ![\[A página do console do CloudWatch com a saída do programa Spark.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/migrate-apache-spark-04-log-output.png) ## Procedimentos comuns necessários para migrar programas Spark ### Avalie a compatibilidade com a versão do Spark As versões do AWS Glue determinam a versão do Apache Spark e Python que estão disponíveis para o trabalho do AWS Glue. Você encontra nossas versões do AWS Glue e a compatibilidade delas em [AWS GlueVersões do](release-notes.md#release-notes-versions). Pode ser necessário atualizar seu programa Spark para que seja compatível com uma versão mais recente do Spark para acessar determinados recursos do AWS Glue. ### Incluir bibliotecas de terceiros Muitos programas Spark existentes terão dependências, tanto em artefatos privados como públicos. O AWS Glue é compatível com dependências de estilo JAR para trabalhos Scala, bem como dependências Wheel e Python puro para trabalhos Python. **Python**: para obter informações sobre dependências do Python, consulte [Usar bibliotecas Python com o AWS Glue](aws-glue-programming-python-libraries.md) As dependências comuns do Python são fornecidas no ambiente do AWS Glue, inclusive a popular biblioteca [Pandas](https://pandas.pydata.org/). As dependências estão incluídas no AWS Glue versão 2.0\$1. Para obter mais informações sobre os módulos fornecidos, consulte [Módulos do Python já fornecidos no AWS Glue](aws-glue-programming-python-libraries.md#glue-modules-provided). Se você precisar fornecer a um trabalho uma versão diferente de uma dependência incluída por padrão, você pode usar `--additional-python-modules`. Para obter mais informações sobre argumentos de trabalho, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md). Você pode fornecer dependências adicionais do Python com o argumento de trabalho `--extra-py-files`. Se você estiver migrando um trabalho de um programa Spark, esse parâmetro é uma boa opção, pois é funcionalmente equivalente ao sinalizador `--py-files` no PySpark e está sujeito às mesmas limitações. Para obter mais informações sobre o parâmetro `--extra-py-files`, consulte [Inclusão de arquivos Python com recursos nativos do PySpark](aws-glue-programming-python-libraries.md#extra-py-files-support) Para novos trabalhos, é possível gerenciar dependências do Python com o argumento de trabalho `--additional-python-modules`. Usar esse argumento permite uma experiência mais completa de gerenciamento de dependências. Esse parâmetro é compatível com dependências do estilo Wheel, inclusive aquelas com vinculações de código nativas compatíveis com o Amazon Linux 2. **Scala** Você pode fornecer dependências adicionais do Scala com o argumento de trabalho `--extra-jars`. As dependências devem ser hospedadas no Amazon S3, e o valor do argumento deve ser uma lista delimitada por vírgulas de caminhos do Amazon S3 sem espaços. Talvez seja mais fácil gerenciar sua configuração reagrupando suas dependências antes de hospedá-las e configurá-las. AWS Glue As dependências JAR contêm bytecode Java, que pode ser gerado de qualquer linguagem JVM. É possível usar outras linguagens JVM, como Java, para escrever dependências personalizadas. ### Gerenciar credenciais da fonte de dados Os programas Spark existentes podem vir com configurações complexas ou personalizadas para extrair dados das fontes de dados. Fluxos de autenticação de fonte de dados comuns são compatíveis com conexões do AWS Glue. Para obter mais informações sobre conexões do AWS Glue, consulte [Conectar a dados](glue-connections.md). As conexões do AWS Glue permitem a conexão do trabalho a uma variedade de tipos de armazenamentos de dados, principalmente de duas maneiras: por meio de chamadas de método para nossas bibliotecas e definindo **Additional network connection** (Conexão de rede adicional) no console do AWS. Também é possível chamar o SDK da AWS de dentro do trabalho para recuperar informações de uma conexão. **Chamadas de método**: as conexões do AWS Glue são totalmente integradas ao AWS Glue Data Catalog, um serviço que permite selecionar informações sobre seus conjuntos de dados, e os métodos disponíveis para interagir com conexões do AWS Glue refletem isso. Se houver uma configuração de autenticação existente que você gostaria de reutilizar, para conexões JDBC, é possível acessar a configuração de conexão do AWS Glue pelo método `extract_jdbc_conf` em `GlueContext`. Para obter mais informações, consulte [extract\$1jdbc\$1conf](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-extract_jdbc_conf) **Configuração do console**: o uso de trabalhos do AWS Glue associados a conexões do AWS Glue para configurar conexões com sub-redes da Amazon VPC. Se você gerencia diretamente seus materiais de segurança, talvez seja necessário fornecer um tipo `NETWORK` para **Additional network connection** (Conexão de rede adicional) no console do AWS para configurar o roteamento. Para obter mais informações sobre a conexão de APIs do AWS Glue, consulte [API de conexões](aws-glue-api-catalog-connections.md) Se seus programas Spark tiverem um fluxo de autenticação personalizado ou incomum, talvez seja necessário gerenciar seus materiais de segurança na prática. Se as conexões do AWS Glue não parecerem uma boa opção, você poderá hospedar seguramente materiais de segurança no Secrets Manager e acessá-los pelo boto3 ou pelo SDK da AWS, que são fornecidos no trabalho. ### Configurar o Apache Spark As migrações complexas geralmente alteram a configuração do Spark para acomodar suas workloads. As versões modernas do Apache Spark permitem que a configuração do runtime seja definida com o `SparkSession`. AWS Glue Trabalhos 3.0\$1 recebem `SparkSession`, que pode ser modificado para definir a configuração do runtime. [Configuração do Apache Spark](https://spark.apache.org/docs/latest/configuration.html). Ajustar o Spark é complexo, e o AWS Glue não garante suporte para definir todas as configurações do Spark. Se sua migração necessitar de uma configuração substancial no nível do Spark, entre em contato com o suporte. ### Definir uma configuração personalizada Os programas Spark migrados podem ser projetados de modo a ter configurações personalizadas. O AWS Glue permite que a configuração seja definida no nível do trabalho e da execução do trabalho, por meio dos argumentos do trabalho. Para obter mais informações sobre argumentos de trabalho, consulte [Usar parâmetros de tarefa em tarefas do AWS Glue](aws-glue-programming-etl-glue-arguments.md). É possível acessar argumentos de trabalho dentro do contexto de um trabalho por meio de nossas bibliotecas. O AWS Glue fornece uma função de utilitário que proporciona uma visão consistente entre os argumentos definidos no trabalho e os argumentos definidos na execução do trabalho. Consulte [Acessar parâmetros usando `getResolvedOptions`](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md) em Python e [AWS GlueAPIs GlueArgParser em Scala no](glue-etl-scala-apis-glue-util-glueargparser.md) em Scala. ### Migrar código Java Conforme explicado em [Incluir bibliotecas de terceiros](#glue-author-migrate-apache-spark-third-party-libraries), suas dependências podem conter classes geradas por linguagens JVM, como Java ou Scala. Suas dependências podem incluir um método `main`. Você pode usar um método `main` em uma dependência como o ponto de entrada para um trabalho Scala do AWS Glue. Isso permite escrever o método `main` em Java ou reutilizar um método `main` empacotado de acordo com seus próprios padrões de biblioteca. Para usar um método `main` de uma dependência, execute este procedimento: limpe o conteúdo do painel de edição fornecendo o objeto `GlueApp` padrão. Forneça o nome totalmente qualificado de uma classe em uma dependência como argumento de trabalho com a chave `--class`. Então, você deverá ser capaz de acionar uma execução de trabalho. Não é possível configurar a ordem ou a estrutura dos argumentos. O AWS Glue passa para o método `main`. Se o código existente precisar ler a configuração definida no AWS Glue, isso provavelmente causará incompatibilidade com o código anterior. Se você usar `getResolvedOptions`, também não terá um bom lugar para chamar esse método. Considere invocar sua dependência diretamente de um método principal gerado pelo AWS Glue. O script de ETL do AWS Glue a seguir é um exemplo disso. ``` import com.amazonaws.services.glue.util.GlueArgParser object GlueApp { def main(sysArgs: Array[String]) { val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray) // Invoke static method from JAR. Pass some sample arguments as a String[], one defined inline and one taken from the job arguments, using getResolvedOptions com.mycompany.myproject.MyClass.myStaticPublicMethod(Array("string parameter1", args("JOB_NAME"))) // Alternatively, invoke a non-static public method. (new com.mycompany.myproject.MyClass).someMethod() } } ```