Tutorial: Escrevendo um script do AWS Glue for Spark

Este tutorial apresenta o processo de escrever scripts do AWS Glue. É possível executar scripts com base em um cronograma com trabalhos ou interativamente, com sessões interativas. Para mais informações sobre trabalhos, consulte Criando ETL trabalhos visuais com AWS Glue Studio. Para obter mais informações sobre sessões interativas, consulte Visão geral das sessões interativas do AWS Glue.

O editor visual AWS Glue Studio oferece uma interface gráfica sem código para criar trabalhos do AWS Glue. AWS Glue scripts em trabalhos visuais. Eles dão acesso ao conjunto expandido de ferramentas disponíveis para trabalhar com os programas do Apache Spark. Você pode acessar as APIs nativas do Spark, bem como as bibliotecas do AWS Glue que facilitam fluxos de trabalho de extração, transformação e carregamento (ETL) de dentro de um script do Glue. AWS

Neste tutorial, você extrai, transforma e carrega um conjunto de dados de multas de estacionamento. O script que faz esse trabalho é idêntico em forma e função ao gerado em Making ETL easy with AWS Glue Studio no AWS Big Data Blog, que apresenta o editor visual AWS Glue Studio. Ao executar esse script em um trabalho, você pode compará-lo com trabalhos visuais e ver como os scripts AWS Glue ETL funcionam. Assim, você fica preparado para usar funcionalidades adicionais que ainda não estão disponíveis em trabalhos visuais.

Neste tutorial você usa a linguagem e as bibliotecas do Python. Há funcionalidades similares disponíveis no Scala. Depois de ler este tutorial, você poderá gerar e inspecionar um exemplo de script Scala para entender como realizar o processo de criação do script ETL do Scala AWS Glue.

Pré-requisitos

Este tutorial tem os seguintes pré-requisitos:

• Os mesmos pré-requisitos da postagem do blog do AWS Glue Studio, que instrui você a executar um modelo. AWS CloudFormation

  Este modelo usa o AWS Glue Data Catalog para gerenciar o conjunto de dados de multas de estacionamento disponível ems3://aws-bigdata-blog/artifacts/gluestudio/. Ele cria os seguintes recursos que serão referenciados:

• AWS Glue StudioRole(Função): o perfil do IAM para a execução de trabalhos da AWS Glue

• AWS Glue StudioAmazon S3Bucket: nome do bucket do Amazon S3 para armazenamento de arquivos relacionados ao blog

• AWS Glue StudioTicketsYYZDB: banco de dados do AWS Glue Data Catalog

• AWS Glue StudioTableTickets— Tabela do catálogo de dados para usar como fonte

• AWS Glue StudioTableTrials— Tabela do catálogo de dados para usar como fonte

• AWS Glue StudioParkingTicketCount — Tabela do catálogo de dados para usar como destino

• O script gerado na postagem do blog do AWS Glue Studio. Caso a publicação no blog mude, o script também está disponível no texto a seguir.

Gerar um exemplo de script

Você pode usar o editor visual AWS Glue Studio como uma poderosa ferramenta de geração de código para criar uma estrutura para o script que você deseja escrever. Você usará essa ferramenta para criar um exemplo de script.

Se você quiser pular essas etapas, o script será fornecido.

Exemplo de script do tutorial

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)

# Script generated for node S3 bucket
S3bucket_node1 = glueContext.create_dynamic_frame.from_catalog(
    database="yyz-tickets", table_name="tickets", transformation_ctx="S3bucket_node1"
)

# Script generated for node ApplyMapping
ApplyMapping_node2 = ApplyMapping.apply(
    frame=S3bucket_node1,
    mappings=[
        ("tag_number_masked", "string", "tag_number_masked", "string"),
        ("date_of_infraction", "string", "date_of_infraction", "string"),
        ("ticket_date", "string", "ticket_date", "string"),
        ("ticket_number", "decimal", "ticket_number", "float"),
        ("officer", "decimal", "officer_name", "decimal"),
        ("infraction_code", "decimal", "infraction_code", "decimal"),
        ("infraction_description", "string", "infraction_description", "string"),
        ("set_fine_amount", "decimal", "set_fine_amount", "float"),
        ("time_of_infraction", "decimal", "time_of_infraction", "decimal"),
    ],
    transformation_ctx="ApplyMapping_node2",
)

# Script generated for node S3 bucket
S3bucket_node3 = glueContext.write_dynamic_frame.from_options(
    frame=ApplyMapping_node2,
    connection_type="s3",
    format="glueparquet",
    connection_options={"path": "s3://DOC-EXAMPLE-BUCKET", "partitionKeys": []},
    format_options={"compression": "gzip"},
    transformation_ctx="S3bucket_node3",
)

job.commit()

Para gerar um exemplo de script

1. Conclua o tutorial do AWS Glue Studio. Para concluir este tutorial, consulte Criação de um trabalho no AWS Glue Studio a partir de um exemplo de trabalho.

2. Navegue até a guia Script na página do trabalho, conforme mostrado na captura de tela a seguir:

   

3. Copie o conteúdo completo da guia Script. Ao definir a linguagem do script em Job details (Detalhes do trabalho), você pode alternar entre gerar código para Python ou Scala.

Etapa 1. Criar um trabalho e colar seu script

Nesta etapa, você cria uma tarefa AWS Glue no AWS Management Console. Isso configura uma configuração que permite que o AWS Glue execute seu script. Essa ação também cria um local para você armazenar e editar seu script.

Como criar um trabalho

1. No AWS Management Console, navegue até a página inicial do AWS Glue.

2. No painel de navegação lateral, escolha Jobs (Trabalhos).

3. Escolha Spark script editor (Editor de scripts do Spark) em Create job (Criar trabalho) e, em seguida, escolha Create (Criar).

4. Opcional: cole o texto completo do seu script no painel Script (Script). Você também tem a opção de acompanhar o tutorial.

Etapa 2. Importe bibliotecas do AWS Glue

Você precisa configurar seu script para interagir com código e configuração que sejam definidos fora do script. Esse trabalho é feito nos bastidores no AWS Glue Studio.

Nesta etapa, você executará as ações a seguir.

• Importe e inicialize um objeto GlueContext. Do ponto de vista de criação do script, essa é a importação mais importante. Essa ação expõe métodos padrão para definir conjuntos de dados de origem e destino, que são o ponto de partida para qualquer script de ETL. Para saber mais a respeito da classe GlueContext, consulte GlueContext classe.

• Inicialize um SparkContext e SparkSession. Isso permite que você configure o mecanismo Spark disponível na tarefa AWS Glue. Você não precisará usá-los diretamente nos scripts introdutórios do AWS Glue.

• Chame getResolvedOptions para preparar seus argumentos de trabalho para uso no script. Para obter mais informações sobre como resolver parâmetros de trabalho, consulte Acessar parâmetros usando getResolvedOptions.

• Inicialize um Job. O Job objeto define a configuração e rastreia o estado de vários recursos opcionais do AWS Glue. Seu script pode ser executado sem um objeto de Job, mas a prática recomendada é inicializá-lo para que você não se confunda se esses recursos forem integrados posteriormente.

  Um desses recursos está nos marcadores de trabalho, que você pode configurar opcionalmente neste tutorial. Saiba mais sobre marcadores de trabalho na seção a seguir, Opcional: habilitar marcadores de trabalho.

Neste procedimento, você vai escrever o código a seguir. Esse código é uma parte do script de exemplo gerado.

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)

Para importar bibliotecas AWS Glue

• Copie essa seção de código e cole-a no editor de Script.

  nota

  Talvez você considere a ação de copiar o código uma prática inadequada de engenharia. Neste tutorial, sugerimos isso para incentivá-lo a nomear consistentemente suas principais variáveis em todos os scripts de ETL do AWS Glue.

Etapa 3. Extrair dados de uma fonte

Em qualquer processo de ETL, primeiro é necessário definir um conjunto de dados de origem que você deseje alterar. No editor visual do AWS Glue Studio, você fornece essas informações criando um nó de origem.

Nesta etapa, você fornece ao método create_dynamic_frame.from_catalog um database e um table_name para extrair dados de uma origem configurada no AWS Glue Data Catalog.

Na etapa anterior, você inicializou um objeto GlueContext. Você usa esse objeto para encontrar métodos que são usados para configurar origens, como create_dynamic_frame.from_catalog.

Neste procedimento, você escreverá o código a seguir usando create_dynamic_frame.from_catalog. Esse código é uma parte do script de exemplo gerado.

S3bucket_node1 = glueContext.create_dynamic_frame.from_catalog(
    database="yyz-tickets", table_name="tickets", transformation_ctx="S3bucket_node1"
    )

Para extrair dados de uma fonte

1. Examine a documentação para encontrar um método GlueContext para extrair dados de uma fonte definida no AWS Glue Data Catalog. Esses métodos estão documentados em GlueContext classe. Escolha o método create_dynamic_frame.from_catalog. Chame esse método em glueContext.

2. Confira a documentação para create_dynamic_frame.from_catalog. Esse método requer os parâmetros database e table_name. Forneça os parâmetros necessários para create_dynamic_frame.from_catalog.

   O AWS Glue Data Catalog armazena informações sobre a localização e o formato dos seus dados de origem e foi configurado na seção de pré-requisitos. Você não precisa fornecer diretamente essas informações ao seu script.

3. Opcional: forneça o parâmetro transformation_ctx ao método para oferecer suporte aos marcadores do trabalho. Você pode aprender sobre marcadores de trabalho na seção a seguir, Opcional: habilitar marcadores de trabalho.

nota

Métodos comuns para extrair dados

create_dynamic_frame_from_catalogé usado para se conectar às tabelas no AWS Glue Data Catalog.

Caso precise fornecer diretamente ao seu trabalho uma configuração que descreva a estrutura e o local da sua fonte, consulte o método create_dynamic_frame_from_options. Você precisará fornecer parâmetros mais detalhados descrevendo seus dados do que seria necessário ao usar create_dynamic_frame.from_catalog.

Consulte a documentação complementar sobre format_options e connection_parameters para identificar os parâmetros necessários. Para obter uma explicação sobre como fornecer informações sobre o formato de dados de origem ao script, consulte Opções de formato de dados para entradas e saídas no AWS Glue para Spark. Para obter uma explicação sobre como fornecer ao script informações sobre a localização dos dados de origem, consulte Tipos e opções de conexão para ETL no AWS Glue para Spark.

Se você estiver lendo informações de uma fonte de transmissão, forneça ao seu trabalho as informações da fonte por meio do método create_data_frame_from_catalog ou create_data_frame_from_options. Observe que esses métodos retornam DataFrames do Apache Spark.

Nosso código gerado chama create_dynamic_frame.from_catalog, enquanto a documentação de referência faz referência a create_dynamic_frame_from_catalog. Em última análise, esses métodos chamam o mesmo código e estão incluídos para que você possa escrever um código mais limpo. Você pode verificar isso visualizando o código-fonte do nosso wrapper Python, disponível em aws-glue-libs.

Etapa 4. Transformar dados com o AWS Glue

Depois de extrair os dados da fonte em um processo de ETL, você precisa descrever como deseja alterar seus dados. Você fornece essas informações criando um nó Transform no editor visual do AWS Glue Studio.

Nesta etapa, forneça ao método ApplyMapping um mapa dos nomes e tipos de campos atuais e desejados para transformar seu DynamicFrame.

Você executa as seguintes transformações.

• Descartar as quatro chaves location e province.

• Alterar o nome de officer para officer_name.

• Alterar o tipo de ticket_number e set_fine_amount para float.

create_dynamic_frame.from_catalog fornece a você um objeto DynamicFrame. DynamicFrameA representa um conjunto de dados no AWS Glue. AWS As transformações Glue são operações que mudamDynamicFrames.

nota

O que é um DynamicFrame?

Um DynamicFrame é uma abstração que permite conectar um conjunto de dados com uma descrição dos nomes e tipos de entradas nos dados. No Apache Spark, existe uma abstração semelhante chamada de. DataFrame Para obter uma explicação DataFrames, consulte o Guia SQL do Spark.

Com DynamicFrames, você pode descrever esquemas de conjuntos de dados dinamicamente. Considere um conjunto de dados com uma coluna de preços, em que algumas entradas armazenam o preço como uma sequência de caracteres e outras armazenam o preço como um dobro. AWS O Glue calcula um esquema on-the-fly — ele cria um registro autodescritivo para cada linha.

Campos inconsistentes (como preço) são representados explicitamente com um tipo (ChoiceType) no esquema do quadro. Você pode lidar com campos inconsistentes descartando-os com DropFields ou solucionando-os com ResolveChoice. Essas são transformações que estão disponíveis no DynamicFrame. Em seguida, você pode gravar seus dados de volta em seu data lake com writeDynamicFrame.

Você pode chamar muitas das mesmas transformações a partir de métodos na classe DynamicFrame, que pode levar a scripts mais fáceis de ler. Para obter mais informações sobre o DynamicFrame, consulte Classe DynamicFrame.

Neste procedimento, você escreverá o código a seguir usando ApplyMapping. Esse código é uma parte do script de exemplo gerado.

ApplyMapping_node2 = ApplyMapping.apply(
    frame=S3bucket_node1,
    mappings=[
        ("tag_number_masked", "string", "tag_number_masked", "string"),
        ("date_of_infraction", "string", "date_of_infraction", "string"),
        ("ticket_date", "string", "ticket_date", "string"),
        ("ticket_number", "decimal", "ticket_number", "float"),
        ("officer", "decimal", "officer_name", "decimal"),
        ("infraction_code", "decimal", "infraction_code", "decimal"),
        ("infraction_description", "string", "infraction_description", "string"),
        ("set_fine_amount", "decimal", "set_fine_amount", "float"),
        ("time_of_infraction", "decimal", "time_of_infraction", "decimal"),
    ],
    transformation_ctx="ApplyMapping_node2",
)

Para transformar dados com o AWS Glue

1. Examine a documentação para identificar uma transformação para alterar e descartar campos. Para obter detalhes, consulte Classe de base GlueTransform. Escolha a transformação ApplyMapping. Para obter mais informações sobre o ApplyMapping, consulte Classe ApplyMapping. Chame apply no objeto de transformação ApplyMapping.

   nota

   O que é o ApplyMapping?

   ApplyMapping pega um DynamicFrame e o transforma. Ele obtém uma lista de tuplas que representa transformações nos campos, um “mapeamento”. Os dois primeiros elementos de tupla, um nome e um tipo de campo, são usados para identificar um campo no quadro. Os dois segundos parâmetros também são um nome e um tipo de campo.

   ApplyMapping converte o campo de origem no nome de destino e digite um novoDynamicFrame, que ele retorna. Campos que não forem fornecidos serão descartados no valor retornado.

   Em vez de chamar apply, você pode chamar a mesma transformação com o método apply_mapping no DynamicFrame para criar um código mais fluente e legível. Para ter mais informações, consulte apply_mapping.

2. Para identificar os parâmetros necessários, confira a documentação sobre ApplyMapping. Consulte Classe ApplyMapping. Você descobrirá que esse método requer os parâmetros frame e mappings. Forneça os parâmetros necessários para ApplyMapping.

3. Opcional: forneça transformation_ctx ao método para dar suporte a marcadores de trabalho. Você pode aprender sobre marcadores de trabalho na seção a seguir, Opcional: habilitar marcadores de trabalho.

nota

Funcionalidade do Apache Spark

Fornecemos as transformações para agilizar os fluxos de trabalho de ETL em seu trabalho. Você também tem acesso às bibliotecas que estão disponíveis em um programa do Spark no seu trabalho, criadas para uso mais geral. Para usá-las, converta entre DynamicFrame e DataFrame.

É possível criar um DataFrame com toDF. Em seguida, você pode usar os métodos disponíveis no DataFrame para transformar seu conjunto de dados. Para obter mais informações sobre esses métodos, consulte DataFrame. Em seguida, você pode converter para trás usando as operações AWS Glue para carregar sua moldura em um alvo. fromDF

Etapa 5. Carregar dados em um destino

Depois de transformar seus dados, normalmente você armazena os dados transformados em um local diferente da fonte. Você executa essa operação criando um nó de destino no editor visual do AWS Glue Studio.

Nesta etapa, você fornecerá ao método write_dynamic_frame.from_options um connection_type, connection_options, format e format_options para carregar dados em um bucket de destino no Amazon S3.

Na Etapa 1, você inicializou um objeto GlueContext. No AWS Glue, é aqui que você encontrará métodos usados para configurar destinos, assim como as fontes.

Neste procedimento, você escreverá o código a seguir usando write_dynamic_frame.from_options. Esse código é uma parte do script de exemplo gerado.

S3bucket_node3 = glueContext.write_dynamic_frame.from_options(
    frame=ApplyMapping_node2,
    connection_type="s3",
    format="glueparquet",
    connection_options={"path": "s3://DOC-EXAMPLE-BUCKET", "partitionKeys": []},
    format_options={"compression": "gzip"},
    transformation_ctx="S3bucket_node3",
    )

Para carregar dados em um destino

1. Confira a documentação a fim de encontrar um método para carregar dados em um bucket de destino do Amazon S3. Esses métodos estão documentados em GlueContext classe. Escolha o método write_dynamic_frame_from_options. Chame esse método em glueContext.

   nota

   Métodos comuns para carregar dados

   write_dynamic_frame.from_options é o método mais comum usado para carregar dados. Ele suporta todos os alvos que estão disponíveis no AWS Glue.

   Se você estiver gravando em um destino JDBC definido em uma conexão AWS Glue, use o write_dynamic_frame_from_jdbc_conf método. AWS As conexões Glue armazenam informações sobre como se conectar a uma fonte de dados. Isso elimina a necessidade de fornecer essas informações no connection_options. No entanto, você ainda precisa usar connection_options para fornecer dbtable.

   write_dynamic_frame.from_catalog não é um método comum para carregar dados. Esse método atualiza o AWS Glue Data Catalog sem atualizar o conjunto de dados subjacente e é usado em combinação com outros processos que alteram o conjunto de dados subjacente. Para ter mais informações, consulte Atualizar esquemas e adicionar novas partições ao Catálogo de Dados em trabalhos do AWS Glue ETL.

2. Confira a documentação para write_dynamic_frame_from_options. Esse método requer frame, connection_type, format, connection_options e format_options. Chame esse método em glueContext.

   1. Consulte a documentação suplementar sobre format_options e format para identificar os parâmetros necessários. Para obter uma explicação sobre os formatos de dados, consulte Opções de formato de dados para entradas e saídas no AWS Glue para Spark.

   2. Consulte a documentação suplementar sobre connection_type e connection_options para identificar os parâmetros necessários. Para obter uma explicação sobre as conexões, consulte Tipos e opções de conexão para ETL no AWS Glue para Spark.

   3. Forneça os parâmetros necessários para write_dynamic_frame.from_options. Esse método tem uma configuração similar a create_dynamic_frame.from_options.

3. Opcional: forneça transformation_ctx a write_dynamic_frame.from_options para dar suporte a marcadores de trabalho. Você pode aprender sobre marcadores de trabalho na seção a seguir, Opcional: habilitar marcadores de trabalho.

Etapa 6. Confirmar o objeto Job

Você inicializou um objeto Job na Etapa 1. Você precisará concluir manualmente o ciclo de vida no final do script. Alguns recursos opcionais precisam que isso funcione corretamente. Esse trabalho é feito nos bastidores no AWS Glue Studio.

Nessa etapa, Chame o método commit no objeto Job.

Neste procedimento, você vai escrever o código a seguir. Esse código é uma parte do script de exemplo gerado.

job.commit()

Para confirmar o objeto Job

1. Caso ainda não tenha feito isso, execute as etapas opcionais descritas nas seções anteriores para incluir transformation_ctx.

2. Chame commit.

Opcional: habilitar marcadores de trabalho

Em cada etapa anterior, você recebeu instruções para definir parâmetros transformation_ctx. Isso está relacionado a um recurso chamado marcadores de trabalho.

Com marcadores de trabalho, você pode economizar tempo e dinheiro com trabalhos executados de maneira recorrente, em comparação com conjuntos de dados nos quais trabalhos anteriores podem ser facilmente rastreados. Os marcadores de tarefas monitoram o progresso de uma transformação do AWS Glue em um conjunto de dados de execuções anteriores. Ao rastrear onde as execuções anteriores terminaram, o AWS Glue pode limitar seu trabalho às linhas que não tenha processado antes. Para obter mais informações sobre marcadores de trabalho, consulte Rastrear dados processados usando marcadores de trabalho.

Para ativar os marcadores de trabalho, primeiro adicione as declarações de transformation_ctx às nossas funções fornecidas, conforme descrito nos exemplos anteriores. O estado do marcador de trabalho é mantido em todas as execuções. Parâmetros de transformation_ctx são chaves usadas para acessar esse estado. Sozinhas, essas declarações não farão nada. Você também precisa ativar o recurso na configuração do seu trabalho.

Neste procedimento, você habilita os marcadores de trabalho usando o AWS Management Console.

Para definir marcadores de trabalho

1. Acesse a seção Job details (Detalhes de trabalho) do seu trabalho correspondente.

2. Defina Job bookmark (Marcador de trabalho) como Enable (Habilitar).

Etapa 7. Execute seu código como um trabalho

Nesta etapa, você executa seu trabalho para verificar se concluiu este tutorial com êxito. Isso é feito com o clique de um botão, como no editor visual do AWS Glue Studio.

Para executar seu código como um trabalho

1. Escolha Untitled job (Trabalho sem título) na barra de título para editar e definir o nome do seu trabalho.

2. Acesse a guia Job details (Detalhes do trabalho). Atribua um IAM Role (Perfil do IAM) ao seu trabalho. Você pode usar o criado pelo AWS CloudFormation modelo nos pré-requisitos do tutorial do AWS Glue Studio. Se tiver concluído esse tutorial, ele deve estar disponível como AWS Glue StudioRole.

3. Escolha Save (Salvar) para salvar seu script.

4. Escolha Run (Executar) para executar seu trabalho.

5. Navegue até a guia Runs (Execuções) para verificar se seu trabalho foi concluído.

6. Acesse DOC-EXAMPLE-BUCKET, o destino de write_dynamic_frame.from_options. Confirme se o resultado corresponde às suas expectativas.

Para obter mais informações sobre como configurar e gerenciar trabalhos, consulte Fornecer seus próprios scripts personalizados.

Mais informações

As bibliotecas e os métodos do Apache Spark estão disponíveis nos scripts AWS Glue. Você pode consultar a documentação do Spark para entender o que pode fazer com as bibliotecas incluídas. Para obter mais informações, consulte a seção de exemplos do repositório de origem do Spark.

AWS O Glue 2.0+ inclui várias bibliotecas Python comuns por padrão. Também há mecanismos para carregar suas próprias dependências em uma tarefa do AWS Glue em um ambiente Scala ou Python. Consulte Usar bibliotecas Python com o AWS Glue para obter informações sobre dependências do Python.

Para obter mais exemplos de como usar os recursos do AWS Glue em Python, consulte. Exemplos de código Python do AWS Glue Os trabalhos no Scala e no Python têm paridade de recursos; sendo assim, nossos exemplos do Python devem dar algumas ideias sobre como executar trabalhos semelhantes no Scala.