# Tutorial: gravar um script do AWS Glue para Spark
Este tutorial apresenta o processo de criação de 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 [Criar trabalhos de ETL visuais](author-job-glue.md). Para obter mais informações sobre sessões interativas, consulte [Visão geral das sessões interativas do AWS Glue](interactive-sessions-chapter.md#interactive-sessions-overview).
O editor visual do AWS Glue Studio oferece uma interface gráfica sem código para a criação de trabalhos do AWS Glue. Scripts do AWS Glue dão suporte a trabalhos visuais. Eles dão acesso ao conjunto expandido de ferramentas disponíveis para trabalhar com os programas do Apache Spark. É possível acessar APIs nativas do Spark e também bibliotecas do AWS Glue que facilitam os fluxos de trabalho de extração, transformação e carregamento (ETL) de dentro de um script do AWS Glue.
Neste tutorial, você extrai, transforma e carrega um conjunto de dados de multas de estacionamento. O script que faz esse trabalho tem forma e função idênticas ao gerado em [Facilitando ETL com o AWS Glue Studio](https://aws.amazon.com/blogs/big-data/making-etl-easier-with-aws-glue-studio/) no Blog AWS Big Data, que apresenta o editor visual do AWS Glue Studio. Ao executar esse script em um trabalho, você pode compará-lo com trabalhos visuais e ver como os scripts de ETL do AWS Glue 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. Após examinar este tutorial, você deve ser capaz de gerar e inspecionar um exemplo de script do Scala para entender como executar o processo de criação de scripts de ETL do AWS Glue para Scala.
## Pré-requisitos
Este tutorial tem os seguintes pré-requisitos:
+ Os mesmos pré-requisitos da publicação no blog do AWS Glue Studio, que instrui você a executar um modelo CloudFormation.
Esse modelo usa o Catálogo de Dados do AWS Glue 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 Data Catalog para ser usada como origem
+ **AWS Glue StudioTableTrials**: tabela do Data Catalog para ser usada como origem
+ **AWS Glue StudioParkingTicketCount**: tabela do Data Catalog para ser usada como destino
+ O script gerado na publicação 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 do AWS Glue Studio como uma poderosa ferramenta de geração de código para criar uma estrutura para o script que você deseja criar. 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](https://docs.aws.amazon.com/glue/latest/dg/edit-nodes-chapter.html#create-jobs-start.html).
1. Navegue até a guia **Script** na página do trabalho, conforme mostrado na captura de tela a seguir:
![\[A guia Script para um trabalho do AWS Glue.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/programming-intro-generated-script.png)
1. 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 um trabalho do AWS Glue no Console de gerenciamento da AWS. Essa ação define 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 Console de gerenciamento da AWS, navegue até a página inicial do AWS Glue.
1. No painel de navegação lateral, escolha **Jobs** (Trabalhos).
1. Escolha **Spark script editor** (Editor de scripts do Spark) em **Create job** (Criar trabalho) e, em seguida, escolha **Create** (Criar).
1. **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. Importar 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 [Classe GlueContext](aws-glue-api-crawler-pyspark-extensions-glue-context.md).
+ Inicialize um `SparkContext` e `SparkSession`. Fazer isso permite que você configure o mecanismo Spark disponível dentro do trabalho do AWS Glue. Você não precisará usá-lo 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`](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md).
+ Inicialize um `Job`. O objeto de `Job` define a configuração e rastreia o estado de diversoss 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](#aws-glue-programming-intro-tutorial-create-job-bookmarks).
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 do 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 incentivar você 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ó **Source** (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. Confira a documentação para encontrar um método em `GlueContext` para extrair dados de uma fonte definida no AWS Glue Data Catalog. Esses métodos estão documentados em [Classe GlueContext](aws-glue-api-crawler-pyspark-extensions-glue-context.md). Escolha o método [create\$1dynamic\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog). Chame esse método em `glueContext`.
1. 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 dados de origem e foi configurado na seção de pré-requisitos. Você não precisa fornecer diretamente essas informações ao seu script.
1. **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](#aws-glue-programming-intro-tutorial-create-job-bookmarks).
**nota**
**Métodos comuns para extrair dados**
[create\$1dynamic\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog) é usado para se conectar a 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\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-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](aws-glue-programming-etl-format.md). 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](aws-glue-programming-etl-connect.md).
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\$1data\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog) ou [create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-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 [https://github.com/awslabs/aws-glue-libs/blob/master/awsglue/context.py](https://github.com/awslabs/aws-glue-libs/blob/master/awsglue/context.py).
## 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** (Transformação) 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`. Um `DynamicFrame` representa um conjunto de dados no AWS Glue. AWS As transformações do Glue são operações que alteram `DynamicFrames`.
**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, há uma abstração similar chamada DataFrame. Para obter uma explicação sobre DataFrames, consulte o [Spark SQL Guide](https://spark.apache.org/docs/latest/sql-programming-guide.html) (Guia de SQL do Spark).
Com `DynamicFrames`, você pode descrever esquemas de conjuntos de dados dinamicamente. Considere um conjunto de dados com uma coluna de preço, em que algumas entradas armazenam o preço como uma string e outras armazenam o preço como uma dupla. O AWS O Glue calcula um esquema rapidamente, criando 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](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md).
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](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md). Escolha a transformação `ApplyMapping`. Para obter mais informações sobre o `ApplyMapping`, consulte [Classe ApplyMapping](aws-glue-api-crawler-pyspark-transforms-ApplyMapping.md). 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 converterá o campo de origem no nome e tipo de destino em um novo `DynamicFrame`, que será retornado. 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 obter mais informações, consulte [apply\$1mapping](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-apply_mapping).
1. Para identificar os parâmetros necessários, confira a documentação sobre `ApplyMapping`. Consulte [Classe ApplyMapping](aws-glue-api-crawler-pyspark-transforms-ApplyMapping.md). Você descobrirá que esse método requer os parâmetros `frame` e `mappings`. Forneça os parâmetros necessários para `ApplyMapping`.
1. **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](#aws-glue-programming-intro-tutorial-create-job-bookmarks).
**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](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-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](https://spark.apache.org/docs/3.1.1/api/python/reference/api/pyspark.sql.DataFrame.html). Em seguida, você pode converter ao contrário com [fromDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-fromDF) para usar operações do AWS Glue para carregar sua estrutura em um destino.
## 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ó **meta** 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, é nesse local que você encontrará os métodos que são usados para configurar destinos, de maneira semelhante às 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://amzn-s3-demo-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 [Classe GlueContext](aws-glue-api-crawler-pyspark-extensions-glue-context.md). Escolha o método [write\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-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 oferece suporte a todos os destino disponíveis no AWS Glue.
Se você estiver gravando em um destino JDBC definido em uma conexão do AWS Glue, use o método [write\$1dynamic\$1frame\$1from\$1jdbc\$1conf](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_jdbc_conf). As conexões do AWS Glue armazenam informações sobre como estabelecer conexão com 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, sendo usado em combinação com outros processos que alteram o conjunto de dados subjacente. Para obter mais informações, consulte [Atualizar esquemas e adicionar novas partições ao Catálogo de Dados em trabalhos do AWS Glue ETL](update-from-job.md).
1. Confira a documentação para [write\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-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](aws-glue-programming-etl-format.md).
1. 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](aws-glue-programming-etl-connect.md).
1. 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`.
1. **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](#aws-glue-programming-intro-tutorial-create-job-bookmarks).
## Etapa 6. Confirmar o objeto `Job`
Você inicializou um objeto `Job` na Etapa 1. Poderá ser necessário realizar manualmente seu ciclo de vida no final do script se determinados recursos opcionais precisarem disso para funcionar corretamente, como ao usar marcadores de trabalho. 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`.
1. 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 trabalho acompanham o progresso de uma transformação do AWS Glue em um conjunto de dados de execuções anteriores. Ao rastrear os locais em que as execuções anteriores terminaram, o AWS Glue pode limitar o trabalho a linhas que não tenham sido processadas anteriormente. Para obter mais informações sobre marcadores de trabalho, consulte [Rastrear dados processados usando marcadores de trabalho](monitor-continuations.md).
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 Console de gerenciamento da AWS.
**Para definir marcadores de trabalho**
1. Acesse a seção **Job details** (Detalhes de trabalho) do seu trabalho correspondente.
1. 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.
1. Acesse a guia **Job details** (Detalhes do trabalho). Atribua um **IAM Role** (Perfil do IAM) ao seu trabalho. Você pode usar o que foi criado pelo modelo do CloudFormation nos pré-requisitos para o tutorial do AWS Glue Studio. Se tiver concluído esse tutorial, ele deve estar disponível como `AWS Glue StudioRole`.
1. Escolha **Save** (Salvar) para salvar seu script.
1. Escolha **Run** (Executar) para executar seu trabalho.
1. Navegue até a guia **Runs** (Execuções) para verificar se seu trabalho foi concluído.
1. Navegue até *amzn-s3-demo-bucket*, o destino para `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](console-custom-created.md).
## Mais informações
As bibliotecas e métodos do Apache Spark estão disponíveis nos scripts do 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](https://github.com/apache/spark/tree/master/examples/src/main/python).
O AWS Glue 2.0\$1 inclui várias bibliotecas comuns do Python por padrão. Também existem mecanismos para carregar suas próprias dependências em um trabalho do AWS Glue em um ambiente Scala ou Python. Consulte [Usar bibliotecas Python com o AWS Glue](aws-glue-programming-python-libraries.md) para obter informações sobre dependências do Python.
Para obter mais exemplos sobre como usar os recursos do AWS Glue no Python, consulte [Exemplos de código Python do AWS Glue](aws-glue-programming-python-samples.md). 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.