As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
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
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 em
s3://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.
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
-
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.
-
Navegue até a guia Script na página do trabalho, conforme mostrado na captura de tela a seguir:
-
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
-
No AWS Management Console, navegue até a página inicial do AWS Glue.
-
No painel de navegação lateral, escolha Jobs (Trabalhos).
-
Escolha Spark script editor (Editor de scripts do Spark) em Create job (Criar trabalho) e, em seguida, escolha Create (Criar).
-
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 classeGlueContext
, consulte GlueContext classe. -
Inicialize um
SparkContext
eSparkSession
. 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
. OJob
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 deJob
, 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
-
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 emglueContext
. -
Confira a documentação para
create_dynamic_frame.from_catalog
. Esse método requer os parâmetrosdatabase
etable_name
. Forneça os parâmetros necessários paracreate_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.
-
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
eprovince
. -
Alterar o nome de
officer
paraofficer_name
. -
Alterar o tipo de
ticket_number
eset_fine_amount
parafloat
.
create_dynamic_frame.from_catalog
fornece a você um objeto DynamicFrame
. DynamicFrame
A 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
-
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 oApplyMapping
, consulte Classe ApplyMapping. Chameapply
no objeto de transformaçãoApplyMapping
.nota
O que é o
ApplyMapping
?ApplyMapping
pega umDynamicFrame
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 novo
DynamicFrame
, 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étodoapply_mapping
noDynamicFrame
para criar um código mais fluente e legível. Para ter mais informações, consulte apply_mapping. -
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âmetrosframe
emappings
. Forneça os parâmetros necessários paraApplyMapping
. -
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
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
-
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 usarconnection_options
para fornecerdbtable
.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. -
Confira a documentação para write_dynamic_frame_from_options. Esse método requer
frame
,connection_type
,format
,connection_options
eformat_options
. Chame esse método emglueContext
.-
Consulte a documentação suplementar sobre
format_options
eformat
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. -
Consulte a documentação suplementar sobre
connection_type
econnection_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. -
Forneça os parâmetros necessários para
write_dynamic_frame.from_options
. Esse método tem uma configuração similar acreate_dynamic_frame.from_options
.
-
-
Opcional: forneça
transformation_ctx
awrite_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
-
Caso ainda não tenha feito isso, execute as etapas opcionais descritas nas seções anteriores para incluir
transformation_ctx
. -
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
-
Acesse a seção Job details (Detalhes de trabalho) do seu trabalho correspondente.
-
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
-
Escolha Untitled job (Trabalho sem título) na barra de título para editar e definir o nome do seu trabalho.
-
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
. -
Escolha Save (Salvar) para salvar seu script.
-
Escolha Run (Executar) para executar seu trabalho.
-
Navegue até a guia Runs (Execuções) para verificar se seu trabalho foi concluído.
-
Acesse
DOC-EXAMPLE-BUCKET
, o destino dewrite_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.