Desenvolver usando o AWS Glue Studio Desenvolvimento com sessões interativas Desenvolvimento com uma imagem do Docker Desenvolvimento com a biblioteca ETL do AWS Glue

Desenvolver e testar scripts de trabalho do AWS Glue localmente

Ao desenvolver e testar seus scripts de trabalho do AWS Glue para Spark, existem várias opções disponíveis:

Console do AWS Glue Studio
- Editor visual
- Editor de scripts
- Bloco de anotações do AWS Glue Studio
Sessões interativas
- Bloco de anotações Jupyter
Docker image (Imagem do Docker)
- Desenvolvimento local
- Desenvolvimento remoto
Biblioteca ETL do AWS Glue Studio
- Desenvolvimento local

É possível escolher qualquer uma das opções acima dependendo das suas necessidades.

Se preferir nenhum código ou tiver menos experiência com código, o editor visual do AWS Glue Studio é uma boa opção.

Se preferir uma experiência interativa de caderno, o caderno do AWS Glue Studio é uma boa opção. Para obter mais informações, consulte Usar cadernos com o AWS Glue Studio e o AWS Glue. Se quiser usar seu próprio ambiente local, sessões interativas são uma boa opção. Para obter mais informações, consulte Usar Interactive Sessions com o AWS Glue.

Se você prefere a experiência de desenvolvimento local/remoto, a imagem do Docker é uma boa opção. Isso ajuda a desenvolver e testar scripts de trabalho do AWS Glue para Spark em qualquer lugar de sua preferência sem gerar custos com a AWS Glue.

Se preferir o desenvolvimento local sem o Docker, a instalação do diretório da biblioteca ETL do AWS Glue localmente é uma boa opção.

Desenvolver usando o AWS Glue Studio

O editor visual do AWS Glue Studio é uma interface gráfica que facilita a criação, a execução e o monitoramento de trabalhos do tipo extrair, transformar e carregar (ETL) no AWS Glue. Você pode compor visualmente fluxos de trabalho de transformação de dados e executá-los perfeitamente no mecanismo de ETL sem servidor baseado no Apache Spark do AWS Glue. Você pode inspecionar os resultados do esquema e dos dados em cada etapa do trabalho. Para obter mais informações, consulte o Guia do usuário do AWS Glue Studio.

Desenvolvimento com sessões interativas

Sessões interativas permitem criar e testar aplicações no ambiente de sua escolha. Para obter mais informações, consulte Usar Interactive Sessions com o AWS Glue.

Desenvolvimento com uma imagem do Docker

nota

As instruções nesta seção não foram testadas em sistemas operacionais Microsoft Windows.

Para desenvolvimento local e testes em plataformas Windows, consulte o blog Desenvolvimento de um pipeline de ETL do AWS Glue localmente sem uma conta da AWS

Para uma plataforma de dados pronta para produção, o processo de desenvolvimento e o pipeline de CI/CD para trabalhos do AWS Glue é um tópico chave. Você pode desenvolver e testar com flexibilidade trabalhos do AWS Glue em um contêiner do Docker. O AWS Glue hospeda imagens do Docker no Docker Hub para configurar seu ambiente de desenvolvimento com utilitários adicionais. Você pode usar seu IDE, caderno ou REPL preferido com a biblioteca ETL do AWS Glue. Este tópico descreve como desenvolver e testar trabalhos do AWS Glue versão 4.0 em um contêiner do Docker usando uma imagem do Docker.

As seguintes imagens do Docker estão disponíveis para o AWS Glue no Docker Hub.

Para o AWS Glue versão 4.0: amazon/aws-glue-libs:glue_libs_4.0.0_image_01
Para o AWS Glue versão 3.0: amazon/aws-glue-libs:glue_libs_3.0.0_image_01
Para o AWS Glue versão 2.0: amazon/aws-glue-libs:glue_libs_2.0.0_image_01

Essas imagens são para ambientes x86_64. É recomendável que você teste essa arquitetura. No entanto, talvez seja possível retrabalhar uma solução de desenvolvimento local em imagens básicas não suportadas.

Esse exemplo descreve o uso do amazon/aws-glue-libs:glue_libs_4.0.0_image_01 e a execução do contêiner em uma máquina local. Essa imagem de contêiner foi testada para trabalhos do Spark do AWS Glue versão 3.3. Esta imagem contém o seguinte:

Amazon Linux
Biblioteca ETL do AWS Glue (aws-glue-libs)
Apache Spark 3.3.0
Servidor de histórico do Spark
Jupyter Lab
Livy
Outras dependências de bibliotecas (o mesmo conjunto que as do sistema de trabalhos do AWS Glue)

Conclua uma das seguinte seções de acordo com as suas necessidades:

Configurar o contêiner para utilizar spark-submit
Configurar o contêiner para utilizar o shell REPL (PySpark)
Configurar o contêiner para utilizar o Pytest
Configurar o contêiner para utilizar o Jupyter Lab
Configurar o contêiner para utilizar o Visual Studio Code

Pré-requisitos

Antes de começar, verifique se o Docker está instalado e se o daemon do Docker está em execução. Para obter instruções de instalação, consulte a documentação do Docker para Mac ou Linux. A máquina que executa o Docker hospeda o contêiner do AWS Glue. Verifique também se você tem pelo menos 7 GB de espaço em disco para a imagem no host que executa o Docker.

Para obter mais informações sobre restrições ao desenvolver código do AWS Glue localmente, consulte Restrições de desenvolvimento local.

Como configurar o AWS

Para habilitar chamadas de API da AWS provenientes do contêiner, configure as credenciais da AWS seguindo as etapas. Nas seções a seguir, usaremos este perfil nomeado da AWS.

Configure a AWS CLI configurando um perfil nomeado. Para obter mais informações sobre a configuração da AWS CLI, consulte Configurações de arquivo de credenciais e configuração na documentação do AWS CLI.
Execute o seguinte comando em um terminal:
```
PROFILE_NAME="<your_profile_name>"
```

Talvez você também precise definir a variável de ambiente AWS_REGION para especificar a Região da AWS para a qual enviar as solicitações.

Configurar e executar o contêiner

O processo de configurar o contêiner para executar o código PySpark por meio do comando spark-submit inclui as seguintes etapas genéricas:

Extraia a imagem do Docker Hub.
Execute o contêiner.

Extrair a imagem do Docker Hub

Execute o seguinte comando para extrair a imagem Docker Hub:


docker pull amazon/aws-glue-libs:glue_libs_4.0.0_image_01

Executar do contêiner

Agora, você pode executar um contêiner utilizando essa imagem. É possível escolher qualquer um dos seguintes dependendo das suas necessidades.

spark-submit

Você pode executar um script de trabalho do AWS Glue executando o comando spark-submit no contêiner.

Escreva o script e salve-o como sample1.py no diretório /local_path_to_workspace. O código de exemplo está incluso como apêndice neste tópico.


$ WORKSPACE_LOCATION=/local_path_to_workspace
$ SCRIPT_FILE_NAME=sample.py
$ mkdir -p ${WORKSPACE_LOCATION}/src
$ vim ${WORKSPACE_LOCATION}/src/${SCRIPT_FILE_NAME}

Execute o comando a seguir para executar o comando spark-submit no contêiner a fim de enviar uma nova aplicação Spark:


$ docker run -it -v ~/.aws:/home/glue_user/.aws -v $WORKSPACE_LOCATION:/home/glue_user/workspace/ -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_spark_submit amazon/aws-glue-libs:glue_libs_4.0.0_image_01 spark-submit /home/glue_user/workspace/src/$SCRIPT_FILE_NAME
...22/01/26 09:08:55 INFO DAGScheduler: Job 0 finished: fromRDD at DynamicFrame.scala:305, took 3.639886 s
root
|-- family_name: string
|-- name: string
|-- links: array
| |-- element: struct
| | |-- note: string
| | |-- url: string
|-- gender: string
|-- image: string
|-- identifiers: array
| |-- element: struct
| | |-- scheme: string
| | |-- identifier: string
|-- other_names: array
| |-- element: struct
| | |-- lang: string
| | |-- note: string
| | |-- name: string
|-- sort_name: string
|-- images: array
| |-- element: struct
| | |-- url: string
|-- given_name: string
|-- birth_date: string
|-- id: string
|-- contact_details: array
| |-- element: struct
| | |-- type: string
| | |-- value: string
|-- death_date: string

...

(Opcionalmente) Configure spark-submit para corresponder ao seu ambiente. Por exemplo, você pode passar suas dependências com a configuração --jars. Para obter informações adicionais, consulte Carregar dinamicamente as propriedades do Spark na documentação do Spark.

Shell REPL (Pyspark)

Você pode executar o shell REPL (loops read-eval-print) para desenvolvimento interativo.

Execute o comando a seguir para executar o comando PySpark no contêiner e iniciar o shell REPL:


$ docker run -it -v ~/.aws:/home/glue_user/.aws -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_pyspark amazon/aws-glue-libs:glue_libs_4.0.0_image_01 pyspark
...
 ____ __
 / __/__ ___ _____/ /__
 _\ \/ _ \/ _ `/ __/ '_/
 /__ / .__/\_,_/_/ /_/\_\  version 3.1.1-amzn-0
 /_/

Using Python version 3.7.10 (default, Jun 3 2021 00:02:01)
Spark context Web UI available at http://56e99d000c99:4040
Spark context available as 'sc' (master = local[*], app id = local-1643011860812).
SparkSession available as 'spark'.
>>>

Pytest

Para testes de unidade, você pode usar o pytest para scripts de trabalho Spark do AWS Glue.

Execute os comandos a seguir para preparação.


$ WORKSPACE_LOCATION=/local_path_to_workspace
$ SCRIPT_FILE_NAME=sample.py
$ UNIT_TEST_FILE_NAME=test_sample.py
$ mkdir -p ${WORKSPACE_LOCATION}/tests
$ vim ${WORKSPACE_LOCATION}/tests/${UNIT_TEST_FILE_NAME}

Execute o comando a seguir para executar o pytest no pacote de testes:


$ docker run -it -v ~/.aws:/home/glue_user/.aws -v $WORKSPACE_LOCATION:/home/glue_user/workspace/ -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_pytest amazon/aws-glue-libs:glue_libs_4.0.0_image_01 -c "python3 -m pytest"
starting org.apache.spark.deploy.history.HistoryServer, logging to /home/glue_user/spark/logs/spark-glue_user-org.apache.spark.deploy.history.HistoryServer-1-5168f209bd78.out
*============================================================= test session starts =============================================================
*platform linux -- Python 3.7.10, pytest-6.2.3, py-1.11.0, pluggy-0.13.1
rootdir: /home/glue_user/workspace
plugins: anyio-3.4.0
*collected 1 item  *

tests/test_sample.py . [100%]

============================================================== warnings summary ===============================================================
tests/test_sample.py::test_counts
 /home/glue_user/spark/python/pyspark/sql/context.py:79: DeprecationWarning: Deprecated in 3.0.0. Use SparkSession.builder.getOrCreate() instead.
 DeprecationWarning)

-- Docs: https://docs.pytest.org/en/stable/warnings.html
======================================================== 1 passed, *1 warning* in 21.07s ========================================================

Jupyter Lab

Você pode iniciar o Jupyter para desenvolvimento interativo e consultas ad hoc em cadernos.

Execute o seguinte comando para iniciar o Jupyter Lab:


$ JUPYTER_WORKSPACE_LOCATION=/local_path_to_workspace/jupyter_workspace/
$ docker run -it -v ~/.aws:/home/glue_user/.aws -v $JUPYTER_WORKSPACE_LOCATION:/home/glue_user/workspace/jupyter_workspace/ -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 -p 8998:8998 -p 8888:8888 --name glue_jupyter_lab amazon/aws-glue-libs:glue_libs_4.0.0_image_01 /home/glue_user/jupyter/jupyter_start.sh
...
[I 2022-01-24 08:19:21.368 ServerApp] Serving notebooks from local directory: /home/glue_user/workspace/jupyter_workspace
[I 2022-01-24 08:19:21.368 ServerApp] Jupyter Server 1.13.1 is running at:
[I 2022-01-24 08:19:21.368 ServerApp] http://faa541f8f99f:8888/lab
[I 2022-01-24 08:19:21.368 ServerApp] or http://127.0.0.1:8888/lab
[I 2022-01-24 08:19:21.368 ServerApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).

Abra http://127.0.0.1:8888/lab no navegador da Web da máquina local para ver a interface de usuário do Jupyter lab.
Escolha Glue Spark Local (PySpark) em Notebook (Caderno). Você pode começar a desenvolver código na interface de usuário interativa do bloco de anotação Jupyter.

Configuração do contêiner para utilizar o Visual Studio Code

Pré-requisitos:

Instale o Visual Studio Code.
Instalar o Python.
Instale Visual Studio Code Remote - Containers
Abra a pasta de espaço de trabalho no Visual Studio Code.
Escolha Configurações.
Escolha Workspace (Espaço de trabalho).
Escolha Open Seettings (JSON) (Abrir configurações - JSON).

Cole o seguinte JSON e salve-o.


{
    "python.defaultInterpreterPath": "/usr/bin/python3",
    "python.analysis.extraPaths": [
        "/home/glue_user/aws-glue-libs/PyGlue.zip:/home/glue_user/spark/python/lib/py4j-0.10.9.5-src.zip:/home/glue_user/spark/python/",
    ]
}

Etapas:

Execute o contêiner do Docker.


$ docker run -it -v ~/.aws:/home/glue_user/.aws -v $WORKSPACE_LOCATION:/home/glue_user/workspace/ -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_pyspark amazon/aws-glue-libs:glue_libs_4.0.0_image_01 pyspark

Inicie o Visual Studio Code.
Escolha Remote Explorer (Explorador remoto) no menu esquerdo e escolha amazon/aws-glue-libs:glue_libs_4.0.0_image_01.
Clique com o botão direito do mouse e escolha Attach to Container (Anexar ao contêiner). Se uma caixa de diálogo aparecer, escolha Got it (Entendido).
Abra o /home/glue_user/workspace/.
Crie um script PySpark do Glue e escolha Run (Executar).

Você verá a execução do script com sucesso.

Apêndice: código de exemplo de trabalho do AWS Glue para teste

Este apêndice fornece scripts como o código de exemplo de trabalho do AWS Glue para fins de teste.

sample.py: código de exemplo para usar a biblioteca ETL do AWS Glue com uma chamada de API do Amazon S3


import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions


class GluePythonSampleTest:
    def __init__(self):
        params = []
        if '--JOB_NAME' in sys.argv:
            params.append('JOB_NAME')
        args = getResolvedOptions(sys.argv, params)

        self.context = GlueContext(SparkContext.getOrCreate())
        self.job = Job(self.context)

        if 'JOB_NAME' in args:
            jobname = args['JOB_NAME']
        else:
            jobname = "test"
        self.job.init(jobname, args)

    def run(self):
        dyf = read_json(self.context, "s3://awsglue-datasets/examples/us-legislators/all/persons.json")
        dyf.printSchema()

        self.job.commit()


def read_json(glue_context, path):
    dynamicframe = glue_context.create_dynamic_frame.from_options(
        connection_type='s3',
        connection_options={
            'paths': [path],
            'recurse': True
        },
        format='json'
    )
    return dynamicframe


if __name__ == '__main__':
    GluePythonSampleTest().run()

O código acima exige permissões do Amazon S3 no AWS IAM. Você precisa conceder a política gerenciada do IAM arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess ou uma política personalizada do IAM que permita chamar ListBucket e GetObject para o caminho do Amazon S3.

test_sample.py: código de exemplo para o teste de unidade de sample.py.


import pytest
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
import sys
from src import sample


@pytest.fixture(scope="module", autouse=True)
def glue_context():
    sys.argv.append('--JOB_NAME')
    sys.argv.append('test_count')

    args = getResolvedOptions(sys.argv, ['JOB_NAME'])
    context = GlueContext(SparkContext.getOrCreate())
    job = Job(context)
    job.init(args['JOB_NAME'], args)

    yield(context)

    job.commit()


def test_counts(glue_context):
    dyf = sample.read_json(glue_context, "s3://awsglue-datasets/examples/us-legislators/all/persons.json")
    assert dyf.toDF().count() == 1961

Desenvolvimento com a biblioteca ETL do AWS Glue

A biblioteca ETL do AWS Glue está disponível em um bucket público do Amazon S3 e pode ser consumida pelo sistema de compilação Apache Maven. Isso permite que você desenvolva e teste seus scripts de extração, transformação e carregamento (ETL) Python e Scala localmente, sem a necessidade de uma conexão de rede. O desenvolvimento local com a imagem do Docker é recomendado, pois fornece um ambiente configurado adequadamente para o uso dessa biblioteca.

Desenvolvimento local está disponível para todas as versões do AWS Glue, incluindo o AWS Glue versão 0.9, 1.0, 2.0 e posteriores. Para obter informações sobre as versões do Python e do Apache Spark que estão disponíveis com o AWS Glue, consulte o Glue version job property.

A biblioteca é liberada com a licença de software da Amazon (https://aws.amazon.com/asl).

Restrições de desenvolvimento local

Lembre-se das seguintes restrições ao usar a biblioteca Scala do AWS Glue para desenvolvimento local.

Evite criar um conjunto jar ("fat jar" ou "uber jar") com a biblioteca do AWS Glue, pois isso fará com que os seguintes recursos sejam desabilitados:
- Marcadores de trabalho
- Gravador AWS Glue Parquet (Uso do formato Parquet no AWS Glue)
- Transformação FillMissingValues (Scala ou Python)
Esses recursos estão disponíveis somente no sistema de trabalhos AWS Glue.
Não há suporte para a transformação FindMatches com desenvolvimento local.
O leitor de CSV SIMD vetorizado não é compatível com desenvolvimento local.
A propriedade customJdbcDrivers3Path para carregar o driver JDBC do caminho do S3 não é compatível com desenvolvimento local. Como alternativa, você pode baixar o driver JDBC em seu local e carregá-lo daí.
O Glue Data Quality não é compatível com desenvolvimento local.

Desenvolver localmente com o Python

Conclua algumas etapas de pré-requisito e use os utilitários do AWS Glue para testar e enviar seu script de ETL Python.

Pré-requisitos para o desenvolvimento local com o Python

Execute estas etapas para se preparar para o desenvolvimento local do Python:

Clone o repositório de Python do AWS Glue do GitHub (https://github.com/awslabs/aws-glue-libs).
Execute um destes procedimentos:
- Para o AWS Glue versão 0.9, confira o branch glue-0.9.
- Para o AWS Glue versão 1.0, confira o branch glue-1.0. Todas as versões posteriores ao AWS Glue 0.9 oferecem suporte a Python 3.
- Para o AWS Glue versão 2.0, confira o branch glue-2.0.
- Para o AWS Glue versões 3.0, confira a ramificação glue-3.0.
- Para o AWS Glue versão 4.0, confira a ramificação master.
Instale o Apache Maven do seguinte local: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-common/apache-maven-3.6.0-bin.tar.gz.
Instale a distribuição do Apache Spark de um dos seguintes locais:
- Para o AWS Glue versão 0.9: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-0.9/spark-2.2.1-bin-hadoop2.7.tgz
- Para o AWS Glue versão 1.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-1.0/spark-2.4.3-bin-hadoop2.8.tgz
- Para o AWS Glue versão 2.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-2.0/spark-2.4.3-bin-hadoop2.8.tgz
- Para o AWS Glue versão 3.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-3.0/spark-3.1.1-amzn-0-bin-3.2.1-amzn-3.tgz
- Para o AWS Glue versão 4.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-4.0/spark-3.3.0-amzn-1-bin-3.3.3-amzn-0.tgz
Exporte a variável de ambiente SPARK_HOME, definindo-a como o local raiz extraído do arquivo do Spark. Por exemplo:
- Para o AWS Glue versão 0.9: export SPARK_HOME=/home/$USER/spark-2.2.1-bin-hadoop2.7
- Para o AWS Glue versão 1.0 e 2.0: export SPARK_HOME=/home/$USER/spark-2.4.3-bin-spark-2.4.3-bin-hadoop2.8
- Para o AWS Glue versão 3.0: export SPARK_HOME=/home/$USER/spark-3.1.1-amzn-0-bin-3.2.1-amzn-3
- Para o AWS Glue versão 4.0: export SPARK_HOME=/home/$USER/spark-3.3.0-amzn-1-bin-3.3.3-amzn-0

Executar o script Python de ETL

Com os arquivos jar do AWS Glue disponíveis para desenvolvimento local, é possível executar o pacote do AWS Glue Python localmente.

Use os seguintes utilitários e estruturas para testar e executar seu script do Python. Os comandos listados na tabela a seguir são executados no diretório raiz do pacote Python do AWS Glue.

Utilitário	Comando	Descrição
Shell do AWS Glue	`./bin/gluepyspark`	Insira e execute scripts Python em um shell que se integre com bibliotecas de ETL do AWS Glue.
Submit (Enviar) AWS Glue.	`./bin/gluesparksubmit`	Envie um script completo do Python para execução.
Pytest	`./bin/gluepytest`	Escreva e execute testes de unidade do seu código do Python. O módulo pytest deve estar instalado e disponível no `PATH`. Para obter mais informações, consulte a documentação do pytest.

Desenvolver localmente com o Scala

Conclua algumas etapas de pré-requisito e emita um comando Maven para executar seu script de ETL Scala localmente.

Pré-requisitos para o desenvolvimento local com o Scala

Execute estas etapas para se preparar para o desenvolvimento local com o Scala.

Etapa 1: instalar o software

Nesta etapa, instale o software e defina a variável de ambiente necessária.

Instale o Apache Maven do seguinte local: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-common/apache-maven-3.6.0-bin.tar.gz.
Instale a distribuição do Apache Spark de um dos seguintes locais:
- Para o AWS Glue versão 0.9: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-0.9/spark-2.2.1-bin-hadoop2.7.tgz
- Para o AWS Glue versão 1.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-1.0/spark-2.4.3-bin-hadoop2.8.tgz
- Para o AWS Glue versão 2.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-2.0/spark-2.4.3-bin-hadoop2.8.tgz
- Para o AWS Glue versão 3.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-3.0/spark-3.1.1-amzn-0-bin-3.2.1-amzn-3.tgz
- Para o AWS Glue versão 4.0: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-4.0/spark-3.3.0-amzn-1-bin-3.3.3-amzn-0.tgz
Exporte a variável de ambiente SPARK_HOME, definindo-a como o local raiz extraído do arquivo do Spark. Por exemplo:
- Para o AWS Glue versão 0.9: export SPARK_HOME=/home/$USER/spark-2.2.1-bin-hadoop2.7
- Para o AWS Glue versão 1.0 e 2.0: export SPARK_HOME=/home/$USER/spark-2.4.3-bin-spark-2.4.3-bin-hadoop2.8
- Para o AWS Glue versão 3.0: export SPARK_HOME=/home/$USER/spark-3.1.1-amzn-0-bin-3.2.1-amzn-3
- Para o AWS Glue versão 4.0: export SPARK_HOME=/home/$USER/spark-3.3.0-amzn-1-bin-3.3.3-amzn-0

Etapa 2: configurar o projeto Maven

Use o arquivo pom.xml a seguir como um modelo para seus aplicativos do AWS Glue Scala. Ele contém os elementos dependencies, repositories e plugins necessários. Substitua a string Glue version por um dos seguintes itens:

4.0.0 para o AWS Glue versão 4.0
3.0.0 para o AWS Glue versão 3.0
1.0.0 para o AWS Glue versão 1.0 e 2.0
0.9.0 para o AWS Glue versão 0.9


  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.amazonaws</groupId>
    <artifactId>AWSGlueApp</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>${project.artifactId}</name>
    <description>AWS ETL application</description>

        <properties>
            <scala.version>2.11.1 for AWS Glue 2.0 or below, 2.12.7 for AWS Glue 3.0 and 4.0</scala.version>
            <glue.version>Glue version with three numbers (as mentioned earlier)</glue.version>
        </properties>
    <dependencies>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
			<!-- A "provided" dependency, this will be ignored when you package your application -->
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>AWSGlueETL</artifactId>
			<version>${glue.version}</version>
            <!-- A "provided" dependency, this will be ignored when you package your application -->
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <repositories>
        <repository>
            <id>aws-glue-etl-artifacts</id>
            <url>https://aws-glue-etl-artifacts.s3.amazonaws.com/release/</url>
        </repository>
    </repositories>
    <build>
        <sourceDirectory>src/main/scala</sourceDirectory>
        <plugins>
            <plugin>
                <!-- see http://davidb.github.com/scala-maven-plugin -->
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.4.0</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.6.0</version>
                <executions>
                    <execution>
                        <goals>
                        <goal>java</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                <systemProperties>
                    <systemProperty>
                        <key>spark.master</key>
                        <value>local[*]</value>
                    </systemProperty>
                    <systemProperty>
                        <key>spark.app.name</key>
                        <value>localrun</value>
                    </systemProperty>
                    <systemProperty>
                        <key>org.xerial.snappy.lib.name</key>
                        <value>libsnappyjava.jnilib</value>
                    </systemProperty>
                </systemProperties>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-enforcer-plugin</artifactId>
                <version>3.0.0-M2</version>
                <executions>
                    <execution>
                        <id>enforce-maven</id>
                        <goals>
                            <goal>enforce</goal>
                        </goals>
                        <configuration>
                            <rules>
                                <requireMavenVersion>
                                    <version>3.5.3</version>
                                </requireMavenVersion>
                            </rules>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
			<!-- The shade plugin will be helpful in building a uberjar or fatjar.
			You can use this jar in the AWS Glue runtime environment. For more information, see https://maven.apache.org/plugins/maven-shade-plugin/ -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <configuration>
                    <!-- any other shade configurations -->
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Executar o script Scala de ETL

Execute o seguinte comando no diretório raiz do projeto Maven para executar seu script de ETL em Scala.


mvn exec:java -Dexec.mainClass="mainClass" -Dexec.args="--JOB-NAME jobName"

Substitua mainClass pelo nome totalmente qualificado da classe principal do script. Substitua jobName pelo nome do trabalho desejado.

Configurar um ambiente de teste

Para ver exemplos de configuração de um ambiente de teste local, consulte os seguintes artigos do blog:

Se você quiser usar endpoints de desenvolvimento ou cadernos para testar seus scripts de ETL, consulte Desenvolver scripts com endpoints de desenvolvimento.

nota

Os endpoints de desenvolvimento não são suportados para uso com trabalhos do AWS Glue versão 2.0. Para obter mais informações, consulte Executar trabalhos de ETL do Spark com startup reduzidos.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Trabalhando com operações de streaming em sessões AWS Glue interativas

Endpoints de desenvolvimento