Primeiros passos com o AWS Glue: Um guia passo a passo

AWS Glue: Um guia passo a passo

Agora vem a parte interessante: vamos aprender a usar o Glue para uma tarefa muito comum de processamento de dados: converter arquivos CSV em Parquet.

1. Configuração da conta do AWS

Para os novatos na AWS, a primeira etapa seria criar uma conta e, em seguida, fazer login no console de gerenciamento.

• Acesse a AWS e inscreva-se.
• Quando você tiver uma conta, faça login no Console de gerenciamento do AWS.

2. Criação de função de IAM

O AWS Identity and Access Management (IAM) permite que os usuários gerenciem com segurança o acesso aos serviços e recursos do AWS.

Precisamos criar uma função de IAM para permitir que o Glue acesse os serviços relevantes. No nosso caso, o principal serviço que estamos acessando é o S3, que hospeda nossos arquivos CSV.

O tutorial de armazenamento do AWS é uma ótima maneira de os novos usuários do AWS aprenderem mais sobre sistemas como o S3. 

As principais etapas para criar essa função IAM estão descritas abaixo, começando pelo Management Console:

• Navegue até o serviço IAM.
• Clique em "Roles" (Funções) na barra lateral esquerda e, em seguida, clique em "Create role" (Criar função).
• Em "Choose a use case" (Escolha um caso de uso), selecione "Glue" (Cola) e clique em "Next" (Avançar): Permissões".
• Pesquise e selecione as seguintes políticas:
• AWSGlueServiceRole
• AmazonS3FullAccess (Observação: Em um ambiente de produção, você deve criar uma política mais restritiva).
• Dê um nome à sua função (por exemplo, "GlueETLRole") e, eventualmente, forneça uma descrição, mas isso não é obrigatório. Por fim, clique em "Criar função".

Etapas para criar uma função IAM no console do AWS. Imagem do autor

O Guia completo do AWS IAM apresenta as etapas para usar o IAM para proteger os ambientes da AWS, gerenciar o acesso com usuários, grupos e funções e delinear as práticas recomendadas para uma segurança robusta.

3. Configuração do bucket S3

Armazenaremos os arquivos CSV de entrada e os arquivos Parquet de saída no Amazon S3.

Os dados de entrada para este exemplo foram criados para fins ilustrativos e podem ser encontrados no repositório GitHub do autor:

• athletes.csv: Contém informações sobre atletas, incluindo sua identificação, nome, país, esporte e idade.
• events.csv: Lista vários eventos, incluindo ID do evento, esporte, nome do evento, data e local.
• medals.csv: Registra informações sobre medalhas, vinculando eventos e atletas às medalhas que ganharam.

Agora, podemos configurar nosso bucket S3 da seguinte forma:

• Vá para o serviço S3 no console de gerenciamento do AWS.
• Clique em "Create bucket" e dê a ele um nome exclusivo (por exemplo, "my-glue-csv-etl-bucket").
• Para simplificar, deixe as configurações padrão do bucket e crie o bucket.
• Crie duas pastas dentro do seu bucket: "input" e "output".

Fluxo de criações de pastas e baldes S3. Imagem do autor 

Depois de criar as duas pastas, o conteúdo do seu bucket deverá ter a seguinte aparência:

Visualização das pastas dentro do bucket S3. Imagem do autor

Agora, podemos carregar esses arquivos CSV de entrada na pasta "input".

Conteúdo da pasta "input" do bucket S3. Imagem do autor

4. Criando um rastreador Glue

Um rastreador Glue é usado para descobrir e catalogar nossos dados automaticamente. Esta seção explica como criar um rastreador que analisa todos os arquivos CSV de entrada. 

As principais etapas são explicadas a seguir:

• Acesse o serviço AWS Glue no console de gerenciamento do AWS.
• Na barra lateral esquerda, em "Catálogo de dados", clique em "Crawlers".
• Clique em "Create crawler" (Criar rastreador).
• Dê um nome ao seu rastreador (por exemplo, "CSV-to-Parquet-Crawler"), deixe o campo de descrição vazio e clique em "Next" (Avançar).
• Precisamos especificar "S3" como a fonte de dados, o que é feito escolhendo "Add data source" (Adicionar fonte de dados) como o tipo de fonte do rastreador e clicando em "Next" (Avançar).

Fluxo de criação do rastreador do AWS Glue no console - parte 1. Imagem do autor

• Escolha "S3" como o armazenamento de dados e especifique o caminho do seu bucket S3, o que você pode fazer selecionando "Browse S3". Em seguida, clique em "Next".
• Selecione "Crawl all sub-folders" (rastrear todas as subpastas)
• Selecione "Add an S3 data source" (Adicionar uma fonte de dados S3) e clique em "Next" (Avançar).
• Antes de prosseguir, verifique o tipo de dados "S3" e, em seguida, "Next".

Fluxo de criação do rastreador do AWS Glue no console - parte 2. Imagem do autor

Depois de conectar o bucket do S3, precisamos conectar a função do IAM que foi criada anteriormente para permitir que o Glue acesse os buckets do S3. O nome da nossa função é "GlueETLRole".

• Escolha o nome da função no campo "Função IAM existente".
• Clique em "Next".

Fluxo de criação do rastreador do AWS Glue no console - parte 3. Imagem do autor

A próxima etapa é criar um banco de dados. O banco de dados "paris_olympics_db" que criaremos serve como um repositório central no AWS Glue Data Catalog para armazenar e organizar metadados sobre nossos arquivos CSV. 

O catálogo permitirá a descoberta eficiente de dados e simplificará nosso processo de ETL para combinar e converter os dados de atletas, eventos e medalhas no formato Parquet.

No momento, ainda não temos nenhum banco de dados, e as etapas de criação estão ilustradas abaixo:

• Selecione "Add database" (Adicionar banco de dados), o que abrirá uma nova janela para criar nosso banco de dados. Dê a ele o nome "paris_olympics_db", deixando todo o resto como padrão, e clique em "Create database" (Criar banco de dados).

Fluxo de criação do rastreador do AWS Glue no console - parte 4. Imagem do autor

Na guia original em que conectamos um banco de dados, atualize a seção "Target database" (Banco de dados de destino) e escolha o banco de dados recém-criado. Em seguida, clique em "Next".

Fluxo de criação do rastreador do AWS Glue no console - parte 5. Imagem do autor

Por fim, revise tudo e clique em "Create crawler".

Visualização "Revisar e criar" do rastreador do AWS Glue. Imagem do autor

Após a ação anterior de criar um rastreador, você deverá ver o seguinte resultado confirmando sua criação:

Criação bem-sucedida do rastreador de cola. Imagem do autor

5. Executando um rastreador Glue

Agora que criamos nosso rastreador, é hora de executá-lo e ver como ele cataloga nossos dados.

Cole o botão "Run crawler" (Executar rastreador). Imagem do autor

• Selecione seu rastreador na lista.
• Clique em "Run crawler" (Executar rastreador).
• Aguarde até que o rastreador termine. Isso pode levar alguns minutos.
• Depois de concluído, vá para "Databases" (Bancos de dados) em "Data catalog" (Catálogo de dados) na barra lateral esquerda.
• Clique no banco de dados que foi criado.
• Você deverá ver uma tabela que representa sua estrutura de dados CSV.

Visualização das tabelas criadas no banco de dados a partir da execução do rastreador Glue. Imagem do autor

6. Criação e execução de um trabalho Glue

Com nosso catálogo de dados criado, agora podemos criar um trabalho Glue para combinar nossos arquivos CSV e convertê-los para o formato Parquet. Esta seção orienta você na criação do trabalho do Glue e fornece o código Python necessário.

• Vá para "Jobs" em "ETL" no console do AWS Glue na barra lateral esquerda.
• Selecione o editor de script para abrir um editor para escrever um código Python e clique em "Create script".

Criação e execução de um trabalho Glue - parte 1. Imagem do autor

A ação de criar o script abre a seguinte guia de script, na qual podemos dar um nome ao trabalho, que é "CS" no nosso caso.

• Na seção de código, cole o seguinte código e clique em "Salvar".

Criação e execução de um trabalho Glue - parte 2. Imagem do autor

O código Python correspondente é fornecido abaixo:

import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from pyspark.sql.functions import col, to_date

# Initialize the Spark and Glue contexts
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)

# Set Spark configurations for optimization
spark.conf.set("spark.sql.adaptive.enabled", "true")
spark.conf.set("spark.sql.adaptive.coalescePartitions.enabled", "true")

# Get job parameters
args = getResolvedOptions(sys.argv, ['JOB_NAME'])

# Set the input and output paths
input_path = "s3://glue-csv-etl-bucket/input/"
output_path = "s3://glue-csv-etl-bucket/output/"

# Function to read CSV and write Parquet
def csv_to_parquet(input_file, output_file):
    try:
        # Read CSV
        df = spark.read.option("header", "true") \
                       .option("inferSchema", "true") \
                       .option("mode", "PERMISSIVE") \
                       .option("columnNameOfCorruptRecord", "_corrupt_record") \
                       .csv(input_file)
        
        # Print schema for debugging
        print(f"Schema for {input_file}:")
        df.printSchema()
        
        # Convert date column if it exists (assuming it's in the format M/d/yyyy)
        if "date" in df.columns:
            df = df.withColumn("date", to_date(col("date"), "M/d/yyyy"))
        
        # Write Parquet
        df.write.mode("overwrite").parquet(output_file)
        
        print(f"Successfully converted {input_file} to Parquet at {output_file}")
        print(f"Number of rows processed: {df.count()}")
    except Exception as e:
        print(f"Error processing {input_file}: {str(e)}")

# List of files to process
files = ["athletes", "events", "medals"]

# Process each file
for file in files:
    input_file = f"{input_path}{file}.csv"
    output_file = f"{output_path}{file}_parquet"
    csv_to_parquet(input_file, output_file)

job.commit()
print("Job completed.")

Vamos entender brevemente o que está acontecendo no código:

1. Importações: Importa as bibliotecas necessárias do AWS Glue, do PySpark e da biblioteca padrão do Python.
2. Inicialização: Inicializa os contextos do Spark e do Glue e define as configurações do Spark para otimização.
3. Parâmetros do trabalho: Recupera os parâmetros do trabalho, especificamente o nome do trabalho, dos argumentos da linha de comando.
4. Caminhos: Define os caminhos de entrada e saída para os arquivos CSV e Parquet no bucket S3.
5. Definição da função: Define a função csv_to_parquet() para ler um arquivo CSV, imprimir seu esquema, converter uma coluna de data, se houver, e gravar os dados como um arquivo Parquet. Trata as exceções durante o processamento.
6. Processamento de arquivos: Processa uma lista de arquivos (athletes, events, medals) chamando a função csv_to_parquet() em cada arquivo.
7. Compromisso de trabalho: Confirma o trabalho e imprime uma mensagem de conclusão.

Antes de executar o trabalho, precisamos preencher as seguintes configurações adicionais na seção "Job details" (Detalhes do trabalho):

• Forneça a função de IAM que criamos anteriormente para permitir a execução do trabalho.
• Defina o Job "Type" (Tipo de trabalho) como "Spark", deixe o restante dos campos como padrão e "Save" (Salvar).
• Em seguida, execute o trabalho!

Criação e execução de um trabalho Glue - parte 3. Imagem do autor

Depois de executar o trabalho com êxito, podemos ver mais detalhes sobre o status da execução:

Visualização dos detalhes da execução do trabalho do AWS Glue. Imagem do autor

O acesso e o monitoramento dos detalhes da execução são importantes para manter pipelines de dados eficientes e confiáveis. Essas métricas fornecem insights valiosos e nos ajudam com o seguinte:

• Otimização do desempenho: Acompanhe os tempos de execução para melhorar a eficiência do trabalho e a alocação de recursos.
• Gerenciamento de custos: Monitorar o uso de recursos (DPUs, funcionários) para alinhar com o orçamento e otimizar as despesas.
• Planejamento de capacidade: Use métricas de execução para prever as necessidades de recursos e planejar a escalabilidade.

A execução bem-sucedida desse trabalho converteu cada arquivo CSV em seu arquivo Parquet correspondente e os armazenou na pasta "output", conforme mostrado abaixo:

• À esquerda, temos as pastas com o mesmo nome do arquivo CSV original.
• O lado oposto corresponde aos arquivos Parquet para cada arquivo CSV.

Conteúdo da pasta de saída dentro do bucket S3. Imagem do autor

Conclusão e próximas etapas

Este tutorial abordou o AWS Glue e seus recursos. Ele guiou você na configuração de um ambiente do AWS e na exploração da interface do AWS Glue. Ele também mostrou a você como criar e executar um rastreador Glue para catalogar dados, criar um trabalho Glue para transformá-los e converter com êxito arquivos CSV para o formato Parquet.

Você pode expandir o que aprendeu configurando acionadores para automatizar fluxos de trabalho, implementando o tratamento e o registro de erros e otimizando os arquivos Parquet para obter um desempenho ainda melhor. Você também pode explorar a consulta de seus dados com o AWS Athena ouo Amazon Redshift Spectrum.

Além disso, monitore o uso e os custos do AWS e limpe os recursos quando eles não forem mais necessários para evitar cobranças desnecessárias.

Os cursos Introduction to AWS e AWS Cloud Technology and Services podem ser excelentes próximos passos para que você aprenda mais! 

O primeiro oferece uma base sólida de AWS e computação em nuvem, ideal para iniciantes ou para aqueles que estão se atualizando sobre os principais conceitos. O segundo concentra-se no aprendizado prático, ajudando você a aprofundar seu conhecimento prático dos serviços da AWS.