Com instruções detalhadas e exemplos práticos, você aprenderá como configurar a exportação de dados, criar uma conexão robusta no BigQuery e, finalmente, transformar esses dados em insights visuais poderosos usando o Looker Studio.

Ideal para profissionais que buscam otimizar a análise de dados e aprimorar a tomada de decisões com ferramentas avançadas do Google.

O post GA4 + Google Bigquery: Integrar dados do GA4 com o Big Query + Looker apareceu primeiro em Data Universe.

• Link do projeto no Github: https://github.com/cerqueiralex/etl-pyspark-sqlite-docker/
• Tecnologias: Python, PySpark, SQLite
• Categorias: Data Engineering, ETL

Neste projeto, compartilharei o passo a passo de um projeto de processamento de dados em lote que utilizei em meu portfolio. O objetivo era transformar um arquivo JSON em um banco SQLite, utilizando PySpark e Docker.

1. Configurando o ambiente com Docker Compose

Comecei criando um cluster PySpark em Docker com três containers: um master, dois workers e um history para armazenar logs. Utilizei o Docker Compose para facilitar a configuração e o gerenciamento do cluster.

2. Gerando a base de dados SQLite

Em seguida, desenvolvi dois scripts Python:

• Gerador de dados: Este script gerou um arquivo JSON com dados fictícios, simulando um cenário real.
• Criador da base de dados: Este script criou a base de dados SQLite e definiu a conexão com o arquivo JSON gerado.

3. Implementando o job ETL com PySpark

O job ETL foi escrito em PySpark e implementado no container master do cluster. As principais etapas do job foram:

• Leitura do arquivo JSON: O arquivo JSON gerado no passo 2 foi lido como um DataFrame do Spark.
• Definição do schema: Um schema foi definido para garantir a consistência dos dados na base SQLite.
• Tratamento de dados: O campo de e-mail foi tratado para remover caracteres inválidos e garantir a padronização.
• Gravação na base SQLite: O DataFrame final foi gravado na base SQLite criada no passo 2.

4. Executando o job ETL

O job ETL foi executado no container master do cluster através do comando spark-submit. O processo de execução foi monitorado no console do container.

5. Resultados e Considerações

O job ETL foi executado com sucesso, transformando o arquivo JSON em um banco SQLite. A utilização do PySpark e do Docker proporcionou um ambiente escalável e eficiente para o processamento de dados.

Pontos importantes do projeto:

• Utilização do Docker Compose para facilitar a configuração do cluster PySpark.
• Desenvolvimento de scripts Python para gerar a base de dados SQLite e o arquivo JSON.
• Implementação do job ETL em PySpark com leitura de dados, definição de schema, tratamento de dados e gravação na base SQLite.
• Execução do job ETL no container master do cluster e monitoramento do processo.

Conclusão:

Este projeto demonstra como o PySpark e o Docker podem ser utilizados para realizar o processamento de dados em lote de forma eficiente e escalável. A utilização de containers facilita a configuração do ambiente e o deploy do job em diferentes plataformas.

Este projeto foi realizado para fins de estudo e demonstração de habilidades. O código-fonte e os dados utilizados estão disponíveis em meu repositório GitHub.

O post Processamento de dados em lote com PySpark e Docker apareceu primeiro em Data Universe.

• Link do projeto no Github: https://github.com/cerqueiralex/etl-com-minio/
• Tecnologias: Python, MinIO
• Categorias: Data Engineering, ETL

MinIO é um armazenamento de objetos de alto desempenho compatível com S3. Ele é projetado para cargas de trabalho de inteligência artificial/aprendizado de máquina em grande escala, data lakes e bancos de dados. É definido por software e pode ser executado em qualquer infraestrutura em nuvem ou local.

Aqui irei organizar os arquivos na nuvem utilizando MiniO em máquina local, que possui os mesmos princípios do serviço S3 da Amazon AWS.

Site oficial: https://min.io

Vantagens e desvantagens de utilizar MinIO como datalake

Vantagens

• Muito bom na recuperação de objetos.
• Boa interface de navegação
• Compatibilidade com formatos diferentes de storage
• Muito fácil criar e trabalhar com buckets a nível de S3

Desvantagens

• Baixa documentação
• Pequenos bugs entre as atualizações
• Dificudade de ver os logs
• Pouco seguro se não for bem implementado

Acessando o Dashboard MinIO utilizando o Docker Localmente

Não irei entrar no detalhe de como subir os containers docker aqui, porém através desta documentação você consegue implantar um servidor MinIO de um único nó e uma única unidade no Docker ou Podman para desenvolvimento inicial e avaliação do Armazenamento de Objetos MinIO e sua camada de API compatível com S3.

Para instruções sobre implantação em ambientes de produção, consulte “Implantação MinIO: Múltiplos Nós, Múltiplas Unidades“.

O MinIO está configurado na URL: http://127.0.0.1:9001 (ele será carregado automaticamente no browser quando o docker estiver up)

Configurando a região

Primeiro é necessário configurar a região do nosso servidor em settings > region. Aqui estarei utilizando a região sa-east-1 (south america) para fazer o processamento dos dados.

Raw Policy e Access Keys

Para poder fazer o ETL, o arquivo python (que pode estar rodando localmente na máquina) precisa se conectar com o banco do MinIO que pode estar localizado em qualquer servidor em qualquer lugar do mundo.

Para isso, é necessário gerar as access keys e para isso, é necessário criar a raw policy primeiro.

Aqui gerei uma política de acesso completa de leitura e escrita, dessa forma posso gravar arquivos, sobrescrevê-los e fazer a leitura deles.

Esse é o formato da raw policy gerada:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:*"
            ],
            "Resource": [
                "arn:aws:s3:::*"
            ]
        }
    ]
}

Gerando as Access Keys

Na área de access keys, gero uma chave para que eu possa conectar o ETL com este servidor Minio.

Assim como na AWS, ao gerar uma chave, você só pode visualizar a Secret key uma única vez, dessa forma é imperativo baixar o arquivo csv que possui a seguinte estrutura contendo as duas chaves:

{"url":"http://127.0.0.1:9000","accessKey":"mnzf2Dw34eOEohXh","secretKey":"kXuPY6NVaHMySNct8INu1LB0lwNVLfYJ","api":"s3v4","path":"auto"}

Por fim, é necessário ir até a access key que acabou de ser criada e aplicar a política de acesso nela, ou seja, estou atribuindo aquelas permissões à uma determinada chave, então quem tiver essa chave, terá permissões de leitura e escrita de arquivos no datalake.

Extraindo os dados e conectando ao MinIO

Beleza, agora que já tenho o ambiente e as chaves configuradas, basta criar um arquivo em python bem simples e conectá-lo ao nosso ambiente.

Para esse exemplo vou utilizar o pandaspara fazer a leitura dos arquivos e transformá-los em dataframes, e o boto3 que é uma biblioteca utilizada para fazer a conexão do cliente com o datalake.

Além disso, importo a classe BytesIO do módulo io em Python.

io é um módulo em Python que fornece várias ferramentas para trabalhar com entrada/saída de dados (I/O). O nome “io” é uma abreviação de “input/output”.

BytesIO é uma classe específica dentro do módulo io. Ela fornece uma interface para ler e escrever dados binários em memória, mas trata esses dados como se fossem provenientes de um fluxo de bytes, sem a necessidade de um arquivo físico.

A utilização típica do BytesIO é criar um objeto BytesIO, escrever dados binários nele e, em seguida, usá-lo onde seria esperado um objeto de arquivo (como, por exemplo, ao ler um arquivo binário).

!pip install pandas
!pip install boto3

import pandas as pd
from io import BytesIO
import boto3
from io import StringIO 

Crio o cliente para conectar ao MinIO. Onde tenho [ACCESS KEY ID] e [SECRET ACCESS KEY] é preciso substituir pelas suas próprias chaves de acesso.

client = boto3.client('s3', 
    endpoint_url='http://seu-endpoint-aqui:9000',
    aws_access_key_id='[ACCESS KEY ID]',
    aws_secret_access_key='[SECRET ACCESS KEY]',
    aws_session_token=None,
    config=boto3.session.Config(signature_version='s3v4'),
    verify=False,
    region_name='sa-east-1'
)

Aqui simplesmente carrego os dados com pandas. Estou utilizando uma base do kaggle “Most Subscribed 1000 Youtube Channels”

https://www.kaggle.com/datasets/themrityunjaypathak/most-subscribed-1000-youtube-channels

# Carregando os dados
file_path = 'topyoutube.csv'

df = pd.read_csv(file_path)

file_path

Antes de fazer o upload do csv, preciso criá-lo e subir o csv na memória

csv_buffer = StringIO ()

df.to_csv(csv_buffer)

Escrita: carregando os objetos

Depois que o csv estiver na memória através da função csv_buffer, posso uploadear ele para o datalake. Lembrando que é preciso substituir o “nome-do-bucket” pelo nome correto do seu bucket.

client.put_object (Body=csv_buffer.getvalue(), Bucket='nome-do-bucket', Key="diretorio/dataset.csv")

Pronto! agora é possivel verificar o seu objeto no diretorio que foi criado dentro do bucket.

Leitura: visualizando o objeto armazenado

Agora vou fazer o processo inverso -> agora que o arquivo está no datalake, vou ler o arquivo. Para isso é necessário configurar um client de leitura.

obj = client.get_object(
    Bucket = 'nome-do-bucket',
    Key = "diretorio/dataset.csv"
).get("Body")

data = pd.read_csv(obj)
data.head()

Referências:

• https://min.io/
• https://min.io/docs/minio/container/index.html

O post Processo de ETL simples utilizando datalake MinIO apareceu primeiro em Data Universe.

• Link do projeto no Github: https://github.com/cerqueiralex/iac-ec2-terraform-docker
• Tecnologias: Docker, Terraform, AWS EC2
• Categorias: Data Engineering, IaC

Este artigo explora a implementação prática da integração entre DevOps e Infraestrutura como Código (IaC), com foco na automação da infraestrutura AWS EC2 utilizando a ferramenta Terraform. Destaco aqui a importância da IaC, tratando a infraestrutura como código de software demonstrando os benefícios dessa abordagem na agilidade, rastreabilidade e escalabilidade da infraestrutura em nuvem.

IaC (Infraestrutura como código) é um método para gerenciar e provisionar infraestrutura de TI utilizando código de programação, em vez de fazê-lo manualmente através de interfaces web ou de linha de comando. Isso permite que a infraestrutura seja tratada como qualquer outra parte do código de aplicativo, o que facilita a automação, a reprodução e o controle de versão.

IaC é usado para automatizar o provisionamento de recursos de infraestrutura, como máquinas virtuais, containers, armazenamento, rede e outros, além de automatizar a configuração deles. IaC também pode ser usado para automatizar o escalonamento horizontal e vertical, assim como a implantação de aplicações.

IaC é especialmente útil em ambientes de nuvem, onde os recursos podem ser provisionados e escalados rapidamente e é amplamente utilizado em conjunto com DevOps e práticas de desenvolvimento ágil para tornar mais fácil e rápido para equipes de desenvolvimento implementar e gerenciar suas aplicações.

1. Acessar o AWS IAM e criar as chaves de autenticação 

O AWS Identity and Access Management (IAM) é um serviço da Amazon Web Services (AWS) que oferece controle seguro de acesso aos recursos e serviços da AWS.

O IAM desempenha um papel fundamental na segurança da AWS, permitindo que os usuários concedam ou neguem acesso a recursos, implementem a autenticação de fatores múltiplos e integrem políticas de segurança personalizadas, mas principalmente, o AWS IAM serve para controlar e proteger o acesso aos serviços e recursos da AWS, contribuindo para a implementação de práticas robustas de segurança na nuvem.

Nesse sentido, para poder gerenciar os recursos AWS via IaC, é essencial possuirmos uma chave de acesso IAM para se conectar como administrador e gerenciar todos os recursos. Essas chaves de autenticação permitem que o Terraform e os scripts de automação acessem sua conta.

É importante destacar que por questões de segurança, não é indicado gerar essas chaves de acesso no usuário root ou superadmin, pois ela será utilizada na configuração do IaC e qualquer um que tiver acesso terá controle total à infraestrutura, podendo fazer quaisquer alterações e gerar custos indevidos, assim como notifica a AWS na hora da criação das chaves.

A Chave é composta de 2 estruturas, é recomendado baixar o .csv pois a segunda estrutura só pode ser visualizada uma única vez.

2. Criando imagem e container Docker

A estrutura de diretórios padrão para a criação do projeto deve conter o diretório raíz e dentro o dockerfile junto com o conector “main.tf” que será utilizado para passar os atributos da máquina EC2 para a AWS.

• diretório “terraformiac”
  • Dockerfile
  • main.tf

2.1 Dockerfile

Em seguida é necessário montar o Dockerfile que irá criar a imagem docker para rodar o Terraform e o AWS CLI

# Usando a imagem oficial do Ubuntu como base (última versão)
FROM ubuntu:latest

# Atualizando os pacotes do sistema e instalar dependências necessárias
RUN apt-get update && \
    apt-get install -y wget unzip curl

# Definir a versão do Terraform 
ENV TERRAFORM_VERSION=1.6.2

# Baixar e instalar Terraform
RUN wget https://releases.hashicorp.com/terraform/${TERRAFORM_VERSION}/terraform_${TERRAFORM_VERSION}_linux_amd64.zip && \
    unzip terraform_${TERRAFORM_VERSION}_linux_amd64.zip && \
    mv terraform /usr/local/bin/ && \
    rm terraform_${TERRAFORM_VERSION}_linux_amd64.zip

# Criar a pasta /terraformiac dentro do container
RUN mkdir /terraformiac

# Copiar main.tf para a pasta /terraformiac no container
COPY main.tf /terraformiac/

# Criar a pasta Downloads e instalar o AWS CLI (para acessar a AWS)
RUN mkdir Downloads && \
    cd Downloads && \
    curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" && \
    unzip awscliv2.zip && \
    ./aws/install

# Definir o comando padrão para execução quando o container for iniciado
CMD ["/bin/bash"]

2.2 Arquivo terraform “main.tf”

Montando o arquivo terraform com os atributos da instância EC2. Estamos utilizando a imagem e instância t2.micro que está presente na camada gratuita da AWS.

É necessário também configurar a região de acordo com o projeto. Aqui está sendo utilizada a “us-east-2” que fica localizada em Ohio.

provider "aws" {
  region  = "us-east-2"  
}

#alterar imagem e instância de acordo com necessidade do projeto
resource "aws_instance" "tarefa1" {
  ami           = "ami-0a0d9cf81c479446a"  # AMI na AWS
  instance_type = "t2.micro"

#alterar tag de acordo com nome do projeto
  tags = {
    Name = "terraformiac"
  }
}

2.3 Criando a imagem no Docker

No terminal linux/mac, execute o comando abaixo para criar a imagem Docker

docker build -t terraform-image:terraformiac .

docker build: Este comando é utilizado para construir uma imagem Docker a partir de um Dockerfile.

-t terraform-image:terraformiac : Esta parte etiqueta a imagem com um nome e uma tag opcional. Neste caso, a imagem será etiquetada como terraform-image com a tag terraformiac . Os dois pontos (:) separam o nome da imagem da tag.

. : O ponto no final especifica o contexto de construção. O contexto de construção é o conjunto de arquivos em uma localização específica mencionada no Dockerfile. Neste caso, espera-se que o Dockerfile esteja no diretório atual (.).

Portanto, quando você executa este comando, o Docker procura por um Dockerfile no diretório atual e o utiliza para construir uma imagem chamada terraform-image com a tag terraformiac .

2.4 Criando o container Docker

Execute o comando abaixo para criar o container Docker

docker run -dit --name terraformiac terraform-image:terraformiac /bin/bash

docker run -dit --name terraformiac terraform-image:terraformiac /bin/bash

docker run: Este comando é utilizado para executar um contêiner a partir de uma imagem especificada.

-dit:

• -d: Modo destacado. Ele executa o contêiner em segundo plano, permitindo que você use o terminal para outros comandos.
• -i: Modo interativo. Mantém o STDIN aberto mesmo se não estiver conectado, permitindo interação com o contêiner.
• -t: Aloca um pseudo-TTY. Isso é frequentemente usado em conjunto com -i para simular um terminal real.

--name terraformiac : Atribui um nome ao contêiner em execução. Neste caso, o nome é definido como terraformiac .

terraform-image:terraformiac : Especifica a imagem a ser usada para criar o contêiner. Refere-se à imagem terraform-image com a tag terraformiac .

/bin/bash: Substitui o comando padrão especificado no Dockerfile e inicia um shell Bash interativo dentro do contêiner. Isso é útil para interagir com o contêiner quando estiver em execução.

Portanto, quando você executa este comando, o Docker criará um novo contêiner com base na imagem terraform-image com a tag terraformiac . O contêiner será executado em modo destacado e interativo, e você pode acessar seu shell usando /bin/bash. O contêiner é nomeado como terraformiac .

2.5 Verficando as versões

Para confirmar se tudo correu cde acordo, agora acessando o terminal docker, verifique as versões do Terraform e do AWS CLI com os comandos abaixo:

terraform version
aws --version

3. AWS  CLI

O AWS Command Line Interface (AWS CLI) é uma ferramenta de linha de comando que permite aos usuários interagir e gerenciar recursos na Amazon Web Services (AWS) diretamente por meio do terminal.

Com suporte para uma ampla gama de operações, o AWS CLI simplifica tarefas como a criação de instâncias EC2, a configuração de buckets no Amazon S3 e a administração de serviços relacionados à nuvem.

Utilizando comandos intuitivos, os usuários podem automatizar processos, criar scripts e integrar operações da AWS em pipelines de desenvolvimento, proporcionando uma interface eficiente e flexível para a gestão de recursos na nuvem da AWS.

Por questões de segurança, é preferível configurar o AWS CLI manualmente, pois caso contrário você precisará colocar sua chave de segurança no arquivo Dockerfile, o que irá expor sua chave para qualquer um que tiver acesso à automação.

3.1 Configurar o aws CLI via docker terminal

1. Acessar o diretório do projeto com “cd”
2. usar o comando “aws configure” no terminal na pasta onde está o aws cli
3. digitar a primeira chave de acesso da instância
4. digitar a segunda chave de acesso
5. colocar o id da região ex: “us-east-2”
6. enter = padrão none

3.2 Testando conexão entre terraform e AWS

Através do comando abaixo, ele deverá retornar por exemplo todos os buckets no terminal:

aws ec2 ls | awk ‘{print $NF}’

aws ec2 ls: Isso chama o AWS CLI para listar as instâncias EC2.

|: O pipe | é usado para redirecionar a saída do comando anterior para o próximo comando.

awk ‘{print $NF}’: É um comando awk usado para extrair e imprimir a última coluna (campo) de cada linha da saída anterior. O $NF representa o último campo de cada linha.

Então, o comando completo nos lista as instâncias EC2 e extrai o valor da última coluna para cada linha da saída.

4. Iniciar o Terraform

Uma vez feita a conexão corretamente, basta iniciar o terraform através do comando

terraform init

Isso vai fazer com que ele crie todos os arquivos do terraform no diretório

por último, aplicar as configurações através do comando:

terraform apply

Com esse comando você irá executar as configurações definidas no arquivo “main.tf”. Basicamente aqui ele irá mostrar todas as configurações de criação de uma nova instância de EC2

Uma vez aplicadas as alterações, ele terá criado com sucesso as instâncias EC2 no painel AWS.

Referências:

• https://docs.aws.amazon.com/cli/
• https://www.datascienceacademy.com.br/
• https://docs.docker.com/
• https://developer.hashicorp.com/terraform/docs

O post Automatizando Infraestrutura AWS EC2 via IaC com Terraform no Docker apareceu primeiro em Data Universe.