Tema 3 - Estruturas de Dados e Etl Com Python

Prévia do material em texto

DESCRIÇÃO
Introdução, conceituação e visão geral sobre o processo ETL com Python.
PROPÓSITO
Apresentar os conceitos de um processo de migração de dados com o uso do ETL com Python.
PREPARAÇÃO
Este conteúdo requer uso de computador e experiência de programação para implementar os códigos
em Python fornecidos ao longo do texto. Recomendamos que você tenha alguma experiência em
programação com Python e saiba configurar o ambiente de desenvolvimento.
OBJETIVOS
MÓDULO 1
Reconhecer os conceitos básicos de ETL
MÓDULO 2
Identificar as ferramentas para ETL e os casos de uso
INTRODUÇÃO
Manipular, mover ou migrar dados requer muito cuidado devido à criticidade e à complexidade da tarefa.
Neste conteúdo, explicaremos em detalhes as etapas do processo conhecido como ETL, sigla que vem
do inglês extract, transform and load. Em português, ela significa extração, transformação e carga.
O assunto é abordado com exemplos retirados da prática de ETL, com um caso de uso e uma
explicação sobre o documento técnico que norteia o processo. Além disso, comandos em Python serão
explicados para cada fase da ETL.
MÓDULO 1
 Reconhecer os conceitos básicos de ETL
LIGANDO OS PONTOS
Segundo o processo conhecido como ETL (extract, transform and load), os dados brutos obtidos devem
ser transformados e carregados no repositório, em um formato adequado para tratamento. Como o
Python pode ser útil nesse processo?
Um ambiente de big data muito conhecido é o ecossistema Hadoop, no qual dados que serão
analisados devem ser carregados no Hadoop File System (HDFS), sistema de arquivos que atua de
forma distribuída e é voltado para grandes volumes. Para que os dados possam ser utilizados no
processo de mapeamento e redução, eles devem ser fornecidos em formato que seja condizente com os
algoritmos criados para ambos os processos.
Através do National Climatic Data Center (NCDC), é possível obter os dados climáticos dos Estados
Unidos para longos períodos, em arquivos compactados. Como os arquivos devem ser obtidos através
do protocolo FTP (file transfer protocol), a biblioteca ftplib, do Python, viabiliza a automatização do
download de arquivos para um ano específico, funcionando como um extrator de dados na forma bruta a
partir do site.
from ftplib import FTP 
ftp = FTP("ftp.ncdc.noaa.gov")
ftp.login() 
ftp.cwd("pub/data/noaa/1901") 
files = ftp.nlst() 
for f in files: 
 with open(f,"wb") as arqLocal: 
 ftp.retrbinary("RETR "+f, arqLocal.write) 
ftp.quit()
Os dados climáticos utilizam um formato próprio, em modo texto, com uma ocorrência por linha,
configurados de forma posicional, podendo trazer dificuldades na fase de análise. Com base nas rotinas
de manipulação de texto do Python, eles podem ser transformados em um formato de mais fácil
tratamento, como o JSON (java script object notation).
import gzip 
from os import listdir 
def transformar(linha): 
 data = linha[15:23].decode("utf-8") 
 hora = linha[23:27].decode("utf-8") 
 temperatura = int(linha[87:92]) 
return "{\"data\":\""+data+"\", \"hora\":\""+hora+"\","+\ 
 " \"temperatura:\":"+str(temperatura)+"}\n" 
def ler(nomeArquivo): 
 saida = "[ " 
 with gzip.open(arquivo,"rb") as fin: 
 for linha in fin: 
 if saida!="[ ": saida += ", " 
 saida += transformar(linha) 
 saida += "]" 
 with open(nomeArquivo+".json", "w") as f: 
 f.write(saida) 
arquivos = list(filter(lambda x: x.endswith(".gz"),listdir())) 
for arquivo in arquivos: ler(arquivo) 
 
Em seguida, os arquivos podem ser carregados no HDFS através do uso de subprocessos, com base
nos comandos comuns de gerenciamento do sistema de arquivos, como a criação de diretório, com hdfs
dfs -mkdir, e escrita de arquivo, através de hdfs dfs -put. A classe Popen, oferecida na biblioteca
subprocess, inicia subprocessos, com execução em paralelo dos comandos para escrita no HDFS. Após
a carga de um conjunto de arquivos, que podem ser descobertos através do método listdir, oferecido na
biblioteca os, qualquer ferramenta que permita implementar os algoritmos de mapeamento e redução,
como Java ou o próprio Python, pode ser utilizada, gerando os resultados via Hadoop.
#!/usr/bin/python 
from subprocess import Popen 
from os import listdir 
def cria_dir(diretorio): 
 dir = Popen(["hdfs","dfs","-mkdir",diretorio]) 
 dir.wait() 
def move_arqs(arquivo, diretorio): 
 Popen(["hdfs","dfs","-put",arquivo,diretorio]) 
cria_dir("dados1901JSON"); 
arquivos = list(filter(lambda x: x.endswith(".json"),listdir("./"))) 
for arquivo in arquivos: 
 move_arqs(arquivo,"dados1901JSON") 
 
Como vimos, o ambiente do Python fornece todo o ferramental necessário para extrair, transformar e
carregar os dados no HDFS, permitindo a automatização da fase de preparação de dados para o
tratamento pelo Hadoop. Com diversos outros conectores, o Python poderia ser utilizado ainda para a
obtenção e escrita em diferentes bases, além de ser uma boa opção para a implementação dos
algoritmos de mapeamento e redução.
Após a leitura do caso, é hora de aplicar seus conhecimentos! Vamos ligar esses pontos?
3. PARA EXECUTAR UM PROCESSO DE MAPEAMENTO E
REDUÇÃO ATRAVÉS DO HADOOP, OS DADOS DEVEM SER
CARREGADOS NO HDFS, UTILIZANDO O FORMATO
CORRETO PARA A APLICAÇÃO DOS ALGORITMOS
ESCOLHIDOS. COMO OS DADOS BRUTOS PODEM TER
DIFERENTES FORMATOS E ORIGENS, ELES DEVEM SER
TRATADOS SEGUNDO O FLUXO DENOMINADO ETL
(EXTRACT, TRANSFORM AND LOAD). COMO O PYTHON
PODE SER UTILIZADO NAS OPERAÇÕES DE ETL?
RESPOSTA
Na fase de extração, podemos abrir arquivos locais com o método open, além de obtê-los na rede com a
utilização da biblioteca ftplib. Ainda nessa fase, os dados podem estar compactados, e a biblioteca gzip pode
javascript:void(0)
ser utilizada na descompactação. Com os dados carregados, eles podem ser transformados, utilizando os
diversos métodos de tratamento da classe string, sendo armazenados em estruturas próprias, como
dicionários e listas, seguido da escrita em arquivos com o formato necessário para o tratamento pelo Hadoop.
Na fase final, ou carga, os arquivos gerados devem ser escritos no HDFS, com base nos comandos de linha
necessários, através de subprocessos encapsulados em objetos do tipo Fopen. Ao final das operações de
ETL efetuadas pelo Python, os dados ficam disponíveis no HDFS para tratamento pelo Hadoop.
PRIMEIRAS PALAVRAS
ETL é uma técnica que normatiza o processo de trabalho de movimentação e consolidação dos dados.
Uma das características da revolução tecnológica vigente, além da ênfase na importância dos dados, é
a sua enorme produção.
Diversos sistemas, incluindo dispositivos IoT, podem gerar diariamente terabytes de informação que
precisam ser armazenados. É comum haver diferentes repositórios, muitas vezes geograficamente
separados. Então, para extrair sentido deles e atingir seus objetivos de negócios, as empresas vêm
integrando seus sistemas, migrando e consolidando informação quase que rotineiramente.
Em um mundo cada vez mais globalizado, é preciso que as buscas atravessem diferentes fontes – e
isso requer muitas vezes que os dados sejam extraídos, transformados, consolidados e carregados em
suas novas bases hospedeiras.
 Processo ETL.
Há diversos motivadores que podem justificar a necessidade de mover e consolidar bases de dados. Os
mais comuns são:
Modernização dos sistemas legados.
Fusões e aquisições.
Adição de um sistema ou módulo novo.
Migração para nuvem.
Eliminar a necessidade de sincronização entre bases.
Aumento da capacidade dos sistemas de armazenamento existentes.
Necessidade de usar um repositório de dados único e centralizado para todo o ambiente sistêmico.
As integrações entre ambientes diferentes podem requerer uma nova estrutura de dados.
À primeira vista, pode parecer simples e corriqueira a tarefa de migrar dados. Entretanto, não é bem
assim. As empresas costumam crescer e expandir por meio de silos, em que cada departamento,
regional ou subsidiáriainstala e mantém seus próprios bancos de dados.
Frequentemente, dentro de uma empresa – e até mesmo em nível departamental – encontram-se
informações armazenadas em fontes de dados de diferentes fabricantes, tais como:
ORACLE
MYSQL
POSTGRESQL
SQL SERVER
PLANILHAS EXCEL
ARQUIVOS CSV
javascript:void(0)
CSV
Comma-separated values, que, em português, significa valores separados por vírgula.
Além disso, a conformação dos dados pode variar bastante. Cada organização costuma seguir as
próprias normas e convenções na hora de fazer a modelagem e definir a quantidade de colunas, tipos,
campos, partições, quantidade de instâncias ou de nomear as tabelas e as variáveis e de definir rótulos,
referências, restrições, tamanhos e formatos.
Subsidiárias localizadas em diferentes países comumente usam seus idiomas nativos para nomear as
estruturas. Elas dão diferentes significados para o mesmo campo, criam diferentes partições e
fragmentam os dados de acordo com suas necessidades específicas.
É muito provável que o profissional responsável por trabalhar com ETL encontre um ambiente sistêmico
multidatabase heterogêneo e baseado em schemas locais. Trabalhar nesse ambiente não costuma ser
fácil e necessita de esforço de equipe.
Trata-se de um trabalho laborioso que requer o entendimento completo e inequívoco da forma como os
dados estão modelados. Para isso, é fundamental manter um contato estreito com os responsáveis pela
gestão das bases legadas para evitar erros que possam ser catastróficos – sobretudo se existirem
sistemas que precisam usam os dados para alimentar processos automáticos em larga escala.
O ETL pode ser uma atividade de projeto necessária para suportar um novo sistema que precisa de
dados legados consolidados, mas também pode se tratar de uma tarefa recorrente. Ou seja, as
multinacionais atualmente possuem datacenters espalhados em diversos países e contam com diversas
fontes de informação, como sistemas empresariais do tipo ERP, CRM, faturamento, orquestração e
vendas, além de diversos portais e possivelmente dispositivos de Internet da Coisas (IoT) que produzem
dados em diferentes formatos diariamente.
Uma empresa global não pode mais se dar ao luxo de ter visões isoladas a respeito dos seus dados. O
cruzamento e as visões consolidadas subsidiam cada vez mais as decisões estratégicas tomadas pelo
C-Level da companhia.
A ETL então desempenha um papel importante ao estabelecer procedimentos comuns que auxiliam
engenheiros, profissionais de TI, analistas e cientistas de dados a migrar e consolidar repositórios de
dados oriundos de um ambiente heterogêneo e complicado. É frequentemente um esforço de time que
ainda envolve DBAs e profissionais de teste e qualidade, além de gestores, gerentes e diretores da
empresa.
 DICA
Empregar corretamente o ETL pode poupar muito esforço, tempo e dinheiro, fazendo a diferença entre
um projeto de sucesso entregue rapidamente e outro que seja um fracasso retumbante.
EXTRAÇÃO
A fase de extração consiste em ter acesso a todas as fontes que vão fornecer os dados tanto para fins
de integração quanto tão somente para a migração de em um novo sistema. Essas fontes podem ser
das mais diversas, como, por exemplo, bancos de dados de diferentes fabricantes (Oracle, MySQL etc.),
arquivos, planilhas, sistemas terceiros e equipamentos, como mainframes e hardwares que operam as
próprias bases de dados.
 COMENTÁRIO
Nessa etapa – e antes de começar efetivamente o trabalho de extração –, pressupõe-se que o time
responsável tenha os acessos necessários a todas as fontes de dados do projeto, incluindo login,
senhas e permissões de acesso.
Muitas vezes, é preciso que a fonte de origem tenha uma interface que permita a retirada de dados em
massa (bulk extraction). Supõe-se também que o time tenha o conhecimento sobre a modelagem
utilizada, como tipos e convenções, e o domínio completo sobre o conteúdo dos registros originais e a
qualidade deles. Além disso – e sempre que possível –, a equipe deve ter acesso ao diagrama de
entidade-relacionamento das bases relacionais.
javascript:void(0)
javascript:void(0)
DIAGRAMA DE ENTIDADE-RELACIONAMENTO
O diagrama de entidade relacionamento é uma forma de representar visualmente as relações entre as
entidades em um sistema: no caso do ETL, os banco de dados. Ele foi inicialmente proposto Peter Chen
no final da década de 70 e o artigo original pode ser visto no link abaixo.
Fonte: http://www.csc.lsu.edu/~chen/pdf/erd-5-pages.pdf
É fundamental verificar as chaves tanto primárias quanto estrangeiras para garantir a integridade dos
relacionamentos.
Nesse momento, a equipe provavelmente vai se deparar com muitos problemas, como:
DUPLICIDADE DE INFORMAÇÃO
DADOS ERRADOS
DADOS INCONSISTENTES
DADOS AUSENTES
 ATENÇÃO
Pode ser tentador consertar os dados na fonte antes de extraí-los, mas essa costuma ser uma estratégia
errada. Isso porque provavelmente existem falhas nos processos automáticos e manuais que alimentam
as bases originais e produzem registros corrompidos. Desse modo, não adianta apenas corrigi-los,
porque o ambiente continuará gerando dados ruins. Seria preciso atacar as causas dos erros, o que
pressupõe um trabalho de análise demorada e minuciosa. Além disso, não há nenhuma garantia de que
a equipe consiga realizar os ajustes nem consertar os dados errados rapidamente antes que mais sejam
javascript:void(0);
gerados. Por isso, corrigir os dados costuma ser uma tarefa inútil, além de não fazer parte do escopo da
ETL. A equipe, portanto, deve se preocupar em criar os meios para que a extração seja completa,
representando fielmente os dados originais, mesmo que de baixa qualidade, a fim de ser tão rápida tanto
quanto possível.
A velocidade de extração costuma ser um fator extremamente importante na maioria dos projetos que
envolvem ETL, afinal, muitas bases são vivas em ambientes produtivos, ou seja, recebem atualizações
constantemente, em tempo real, suportando as operações da empresa. Então a equipe precisa mover
os dados rapidamente para que o sistema antigo possa ser desligado com a menor defasagem possível.
Normalmente, há janelas de manutenção muito curtas – na maioria das vezes, durante a madrugada ou
em finais de semana. O novo sistema precisa passar por todas as verificações e testes após a migração
dos dados para evitar a decisão de manter o sistema antigo (No Go).
O ideal seria que a migração fosse instantânea; assim, não haveria discrepância entre a base legada e a
nova. Contudo, mover grandes quantidades de dados toma tempo. Esse é o outro desafio da equipe
técnica: agilidade.
Há diversas ferramentas que ajudam a equipe técnica nessa tarefa, tais como:
ADAPTADORES
SISTEMAS
SCRIPTS DE EXTRAÇÃO/CARGA DE DADOS
O time precisa não somente configurá-los ou desenvolvê-los, mas também garantir que as ferramentas
que os estejam usando sejam as mais eficientes possíveis para que o trabalho possa ser executado
rapidamente sem derrubar a rede ou outros sistemas durante a janela de manutenção. Para isso,
diversos ensaios e testes de desempenho (performance) precisam ser realizados. Outro erro frequente é
tentar mover os dados diretamente para o seu destino.
A melhor prática de ETL preconiza que se construa um espaço intermediário para acomodar os dados
antes que eles sejam migrados definitivamente para o sistema final. Esse local é chamado de staging
area.
O staging area deve receber todos os registros brutos das diversas fontes de dados (provavelmente em
schemas distintos), mas é importante que a base usada se assemelhe à base de destino que hospedará
os dados definitivamente. Esse espaço intermediário se justifica para evitar que análises e outras
operações sejam feitas nas fontes.
Com isso, evita-se degradar o desempenho dos sistemas que as usam e tem-se um espaço para
experimentações e validações livre de riscos. Ele ainda serve de insumo para o desenvolvimento dos
scripts de extração.
 DICA
Fazer backup dos dados é fundamentalcaso os registros na staging area sejam danificados.
Finalmente, é preciso entender que o processo de extração será executado tantas vezes quantas forem
necessárias até que a equipe tenha a segurança necessária para decretar qual será a extração final. A
ETL, como um todo, é um processo cíclico e interativo em que, em cada passagem, a equipe aprimora e
implementa novas melhorias no processo de extração dos dados. Quando ele está maduro o suficiente,
é hora de começar a pensar a fase de transformação.
EXTRAÇÃO
Um especialista abordará neste vídeo o processo ETL de extração e as melhores práticas relacionadas.
EXTRAÇÃO COM PYTHON
Python é uma linguagem de programação de alto nível bastante usada para ETL. Relativamente fácil de
aprender, ela suporta tipos de dados estruturados, que são muito convenientes para armazenar os
registros durante o processo de extração.
Todas as etapas podem ser modelas e construídas usando-se o código nativo Python com o apoio de
bibliotecas. Particularmente para o processo de extração, ele suporta conexão com diversos tipos de
bases de dados, como Oracle e MySQL, além de ler arquivos em formatos distintos, como CSV, XML,
planilhas Excel e JSON.
A biblioteca pandas é uma das mais usadas para leitura, exploração e manipulação de dados. Ela
implementa muitos métodos de leitura.
A seguir, conheceremos o básico de alguns métodos de leitura e os exemplos de código em Python para
cada um deles.
 RECOMENDAÇÃO
Para ter uma compreensão mais profunda ou saber sobre as técnicas avançadas utilizando os métodos
de leitura, recomendamos a leitura da documentação do pacote de I/O da biblioteca pandas.
READ_CSV
Este método lê dados estruturados em formato CSV e os coloca em um tipo de dados denominado
DataFrame. É preciso passar alguns parâmetros de entrada para o read_csv; entre eles, o caminho
(path) ou URL do arquivo CSV e o cabeçalho, além de muitos outros. O Read_csv permite a seleção de
um subconjunto de colunas (usecols) e a escolha do número exato de linhas que serão lidas (nrows).
javascript:void(0);
 DICA
Quando se tem uma massa de dados muito grande, é possível melhorar o desempenho ao desabilitar a
autoinferência de tipo das colunas, uma vez que isso consome muito tempo. Para tanto, o
desenvolvedor informa o tipo correto de cada coluna usando o parâmetro dtype.
Veja a implementação do código em Python a seguir.
import pandas as pd
dfData = pd.read_csv(r"C:\PATH\etl.csv", nrows=500000)
print(dfData.head())
dfData.describe()
dfData.info()
dfData.memory_usage()
dfData.count()
dfData.isnull()
dfData.isna()
Agora vamos analisar o código. O arquivo CSV é lido e carregado em um objeto do tipo DataFrame. Em
seguida, os métodos são chamados. Cada um deles fornece uma informação diferente sobre os dados:
HEAD()
Mostra os primeiros registros.
DESCRIBLE()
Mostra uma tabela contendo estatísticas básicas.
INFO()
Mostra as informações sobre as colunas, como tipos e quantidade de registros.
MEMORY_USAGE()
Releva a quantidade de memória usada.
COUNT()
Conta os registros por coluna.
 RECOMENDAÇÃO
Recomenda-se verificar outros métodos, como tail(), isnull() e isna(), que podem ajudar muito o
profissional na hora de fazer verificações na massa de dados.
READ_JSON
O método read_json lê uma String no formato JSON e a transforma em um objeto que pode ser tanto um
DataFrame como uma Series. O tipo de retorno é especificado no parâmetro type.
Além disso, ele permite escolher o tipo de codificação (enconding), o tipo de compressão (compression)
e a conversão de tipos de dados de maior precisão ao se decodificar o String para o tipo Double.
import pandas as pd
df = pd.read_json('dataETL.json')
print(df.to_string()) 
READ_HTML
Caso os dados estejam no formato de tabela HTML, o método read_html deve ser usado, porque é
capaz de realizar o parser de acordo com os tags HTML. Ele recebe o path ou a URL do arquivo e
diversos outros parâmetros opcionais. Dentre eles, vale ressaltar o skiprows, que permite saltar colunas
e começar a ler a partir do ponto desejado. O método retorna um objeto do tipo DataFrame.
import pandas as pd
tables = pd.read_html('https://sites.google.com/view/cool-tools-for-schools/home/html-codes/tables')
print('Quantidade de tabelas: {len(tables)}')
READ_EXCEL
Ele suporta praticamente todas as extensões de arquivos de planilhas Excel, como xls, xlsx e outros.
Para ler o arquivo, é preciso passar o caminho (path) ou a URL.
O método permite ler qualquer aba do arquivo, desde que ele esteja especificado como parâmetro
(sheet_name) na chamada do método. Além disso, é possível ler diversas planilhas na mesma
chamada, o que poupa tempo do programador ao evitar que se escreva um código para leitura
recursiva. O método retorna um DataFrame ou um dicionário de DataFrames.
import pandas as pd
df = pd.read_excel('ETL.xlsx')
print(df)
READ_SQL
Este método pode ser usado para acessar diversos tipos de bases de dados. Ele, na verdade, é um
contenedor para diversas bibliotecas específicas para os bancos de dados, como, por exemplo, MySQL.
A grande vantagem do read_sql é prover uma camada de abstração, criando um padrão de codificação:
qualquer que seja o banco, o programador escreverá basicamente o mesmo código.
Para usar o método, basta passar a query SQL e os demais parâmetros de conexão com o banco na
chamada do método como parâmetro. O método retorna um DataFrame.
import mysql.connector
import pandas as pd 
dbConn = mysql.connector.connect(
host="localhost", user="usuario", passwd="******", database="ETLDB "
)
etlData = pd.read_sql("SELECT * FROM tableETL WHERE feat01=98103", dbConn)
print(etlData)
---------------------------------------
import pandas as pd 
from sqlalchemy import create_engine
dbConn = create_engine("mysql+mysqldb://usrid:password@localhost/etldb")
etlData = pd.read_sql("SELECT * FROM tableETL WHERE feat01='98103'", dbConn)
print(etlData)
 ATENÇÃO
Para usar o read-sql, é preciso ter instalado no ambiente de desenvolvimento o driver para o banco que
se quer conectar e usar a biblioteca SQL Alchemy, que faz o mapeamento do código SQL para Python.
READ_GBQ
O comando read_gbq importa dados do Google BigQuery, que é um serviço presente na plataforma de
nuvem do Google (PaaS) chamado de Google Cloud Plataform (GCP). Para usá-lo, é preciso
primeiramente autenticar a plataforma para depois executar o código de chamada que passa a query.
Há diversos parâmetros opcionais que podem ser passados à consulta – entre eles, o max_resuts, que
define o número de linhas a serem retornadas pela busca. Além disso, é possível ativar uma barra de
progresso por meio do parâmetro progress_bar_type, que vai mostrar o avanço do recebimento dos
dados. O método retorna um DataFrame.
import pandas as pd
sql = “SELECT * FROM tableETL WHERE feat01='98103'”
df = pd.read_gbq(sql, project_id=1234)
Além dos métodos listados acimas, a biblioteca pandas fornece outros mais específicos, como:
READ_SAS
Faz leitura dos formatos XPORT/SAS7BDAT.
READ_SPSS
Faz leitura do formato SPSS.
READ_ORC
Faz leitura de objetos ORC.
READ_HDF
Faz leitura de arquivos HDF5.
READ_STATA
Faz leitura de arquivos Stata.
 RECOMENDAÇÃO
Consulte a documentação da biblioteca pandas para um melhor entendimento das funções
mencionadas.
Ao longo deste documento, todas as referências foram a bases relacionais. Embora esse seja o caso
mais comum, é sempre possível que algum dos bancos de dados de origem seja não relacional.
Na verdade, parece ser esta a tendência: haver cada vez mais dados não estruturados ou
semiestruturados. Diversos bancos de dados non-sql vêm se tornando populares, como é o caso das
bases Cassandra, MongoDB, DynamoDB e Redis, entre outras.
Caso o time precise importar dados de bases não relacionais, a linguagem Python também dá suporte.
No caso do MongoDB, o time de integração pode usar a biblioteca nativa do fabricante chamada de
PyMongo. Ela pode ser instalada usando-se o comando a seguir:
pip installpymongo
O funcionamento é bastante similar ao dos bancos relacionais. É preciso estabelecer uma conexão ao
banco. Para isso, cria-se uma instância da classe MongoClient, que possui um pool de conexões nativo
capaz de suportar centenas de conexões ao servidor.
Daí é preciso passar o nome do host e a porta em que o servidor escuta os pedidos de conexão. Isso
pode ser feito por meio do formato URL ou passando cada um como parâmetro.
Uma vez que a conexão foi estabelecida, basta acessar a base desejada, criar os objetos do tipo
document em Python e especificar as coleções que se deseja usar. Ao final do uso, só é preciso fechar a
conexão.
TRANSFORMAÇÃO
Uma vez que os processos de extração estejam bem definidos, com os scripts de extração prontos e
funcionando, é hora de começar a trabalhar a transformação dos dados. Essa etapa é bem específica de
cada projeto, já que depende dos objetivos de negócios que a empresa quer alcançar com a iniciativa e
da natureza dos dados. A transformação é a fase que exige mais código customizado e a que mais
agrega valor ao projeto. Nesse momento, assume-se que os dados já foram carregados na staging área.
A equipe precisa então construir e executar os scripts de validação e a transformação dos dados que
estão em seu formato bruto. Uma das validações a ser feita é verificar se todos os dados previstos foram
carregados.
Além disso, o time precisa garantir que nenhum dado indesejado tenha sido migrado. Desse modo,
pode-se iniciar o processo de limpeza e correção, tomando-se as devidas precauções para não danificar
a massa de dados.
O processo consiste em remover dados duplicados, verificar a integridade das chaves primárias (primary
key) e estrangeiras (foreign key) e decidir o que fazer com registros incompletos, vazios e mal
formatados. É preciso que o time faça uma análise minuciosa dos tipos de erros encontrados e elabore
medidas para corrigi-los – se possível, automaticamente.
Os principais tipos de erros encontrados são:
Violações da integridade referencial.
Dados soltos: ausência de relacionamento.
Tipos de dados incorretos: tipos numéricos representados como string.
Conflito entre estruturas de tipo. O mesmo objeto é representado de forma diferente em schemas
distintos. Exemplo: em um schema, ele é modelado como atributo; em outro, como uma entidade.
Valores fora da escala permitida, como, por exemplo, idades de três dígitos.
Dados inconsistentes, como datas de nascimento muito antigas.
Erros de grafia de termos e nomes.
Problemas de nomeação envolvendo prefixos, abreviações, parônimos e homônimos (por exemplo:
mandado X mandato).
Entidades diferentes com o mesmo nome ou sinônimos.
Campos com múltiplas referências, como Kg, Kilo ou Quilo.
Campos de preenchimento obrigatório que se encontram vazios.
Conflitos de modelagem: quando uma relação é modelada de modo diferente em schemas distintos.
Conflito entre chaves: chaves primárias distintas estão disponíveis em schemas diferentes
considerando-se o mesmo objeto.
Problemas na codificação usada (character encoding): dados podem usar diferentes padrões, como, por
exemplo, UTF-8, UTF-16, UTF-32 e ASCII.
É durante a fase de transformação que o time tem a oportunidade de padronizar os dados. Isso traz
ganhos reais para processos de automação que venham a ser implementados futuramente.
Com os dados limpos, organizados e padronizados, a equipe pode começar a pensar na consolidação
que precisa ser feita para integrá-los.
A fase que antecede a execução da integração se chama de pré-integração. Nela, é preciso estabelecer
as regras e resolver os problemas antes que a integração propriamente dita seja executada.
Para isso, deve-se identificar e resolver todos os conflitos estruturais de nomeação de registros e
rótulos. Além disso, é necessário definir quais chaves primárias e estrangeiras serão mantidas e quais
serão descartadas.
Com isso, o integrador consegue determinar as dependências implícitas. É preciso fazer também um
mapeamento dos campos, definindo as regras de transformação. Por exemplo, valores de temperaturas
podem estar em unidades de medidas diferentes. No caso de o integrador definir a escala Celsius como
padrão, todos os valores em Fahrenheit deverão ser transformados.
Finalmente, é bastante comum que o ambiente sistêmico seja heterogêneo, e isso implica diferentes
modelagens aplicadas muitas vezes em dados semelhantes. É importante que um De-Para seja definido
para garantir uma única modelagem ao final do processo de extração. Espera-se que todos os schemas
sejam consolidados em um único para criar o melhor schema integrador.
TRANSFORMAÇÃO
Um especialista falará neste vídeo sobre o processo ETL de transformação e melhores práticas
relacionadas.
CARGA
A carga é o último passo do processo de ETL. Essa etapa envolve a movimentação de grandes volumes
de dados desde a staging area para a base de dados definitiva (data warehouse) depois de eles terem
sido devidamente tratados e transformados. A carga precisa acontecer em um curto período –
normalmente, dentro da janela de manutenção disponibilizada pelo departamento de TI da empresa.
Aqui a equipe encarregada precisa ter atenção com o desempenho dos scripts ou das ferramentas
usadas para mover os dados rápida e eficientemente.
Um processo de ETL que extraia, transforme e carregue os dados em um tempo superior à janela
disponibilizada significa o fracasso do projeto.
O time deve empreender todos os esforços para construir um código ou customizar ferramentas que
operem os dados da forma mais eficiente possível. Uma abordagem é otimizar os scripts e as
ferramentas de acordo com o contexto do projeto.
Uma especial atenção deve ser dada ao consumo de banda de rede e ao de memória, uma vez que
normalmente os processos de ETL são intensos nessas duas dimensões e menos críticos em uso de
capacidade de processamento. Se possível, o departamento de TI deve ajudar fornecendo meios extras
para que a transmissão dos dados seja mais rápida, como, por exemplo, disponibilizando recursos
adicionais de rede para tanto.
Além disso, é preciso considerar que o processo possa sofrer uma interrupção inesperada durante a
carga. Caso isso aconteça, o time tem de ser capaz tanto de voltar os sistemas envolvidos ao estado em
que se encontravam antes do início da carga (rollback) quanto de continuar o processo de ETL do ponto
em que houve a falha (resume), sem haver, portanto, a necessidade de começar tudo novamente.
 ATENÇÃO
As operações de rollback e resume devem manter a integridade dos dados e dos sistemas envolvidos
para que sejam consideradas efetivas.
A carga também pode ser realizada de formas diferentes. Em um projeto chamado de green field, é bem
provável que o sistema destinatário esteja vazio e que ela precise ser completa. Todas as tabelas
precisam ser populadas.
Também é possível fazer uma carga mínima inicial e posteriormente realizar cargas incrementais para
completar os dados, adicionando-se mais registros às tabelas. Entretanto, o mais comum é ter de
apagar as tabelas de destino e carregar novamente tudo sempre que houver uma atualização das bases
originais.
Após os dados terem sido carregados, a equipe precisa rapidamente executar uma série de validações e
verificações para garantir que a operação do sistema novo ocorra normalmente. Isso porque mesmo o
melhor dos sistemas não valida todas as possíveis falhas estruturais nos dados que possam existir.
Dados errados, inconsistentes e com falhas de integridade podem degradar o desempenho do sistema e
derrubá-lo. Esse é um momento crítico em que todo o esforço coletivo realizado anteriormente será
posto à prova.
A liderança técnica do projeto deve monitorar a carga e o desempenho dos sistemas afetados a cada
instante e estar apta a comandar um no go seguido de um rollback ou comandar um resume a qualquer
momento.
O planejamento precisa ser minucioso, enquanto os indicadores devem ser escolhidos para suportar os
tomadoresde decisão. É importante também definir pontos de não retorno nos quais, se ultrapassados,
a carga deve ir até o fim para evitar gerar lixo ou dados inconsistentes.
A execução da carga depende do banco no qual os dados finalmente serão armazenados. O processo é
quase o inverso daquele referente à extração:
Extração
Costuma ser de N fontes para 1 staging área.

Carga
O processo lê a staging area e escreve no banco de dados de destino.
 DICA
Python costuma ser a linguagem de programação usada para tal finalidade, mas Java também funciona.
CARGA
Um especialista comentará neste vídeo sobre o processo ETL de carga e as melhores práticas
relacionadas.
Vamos conhecer agora os métodos e as bibliotecas em Python usados no processo de carga.
PYMYSQL
A biblioteca PyMySQL permite acesso ao banco de dados MySQL. Ela é leve, simples e fácil de usar.
É preciso tê-la instalada no ambiente de desenvolvimento e importá-la no código-fonte Python (import
mymysql). O programador precisa abrir uma conexão usando parâmetros de conexão necessários:
usuário, senha, host e database (db).
Veja o código a seguir:
pimport pymysql
conn = pymysql.connect(host='localhost', user=usuario,
password='123', db='ETLDB')
cursor = connection.cursor()
sql = "INSERT INTO ‘tableETL (‘feat01, ‘feat02) VALUES (%s, %s)"
cursor.execute(sql, (98101, 480070688))
conn.commit()
conn.close()
Uma vez que a conexão tenha sido aberta, um objeto do tipo cursor permite que queries simples sejam
executadas. Obviamente, a biblioteca PyMySQL também pode ser usada para extrair dados de um
banco MySQL: basta que a query passada seja um SELECT em vez de um INSERT.
O objeto cursor então recebe a declaração da query SQL por meio do método execute para inserir os
dados no banco. O passo final é fazer o commit no banco para que as inserções tenham efeito. A
conexão criada pode ser usada muitas vezes até que o programador decida que deve fechá-la,
chamando o método close da classe connection.
 DICA
Além do INSERT, o desenvolvedor também pode construir a query baseado no comando UPDATE, que
atualiza os dados passados, sendo mais leve e consumindo menos tempo de processamento.
TO_SQL
Outra maneira de inserir registros em banco de dados é usando o método to_sql da classe DataFrame
(biblioteca pandas). O uso é análogo ao do read_sql visto anteriormente.
É preciso usar a biblioteca SQLAlchemy, que encapsula o driver do banco a ser usado. Daí abre-se a
conexão com o banco usando o método create_engine e chama-se diretamente a função to_sql,
passando o nome da tabela e outros parâmetros de conexão. Observe que o DataFrame precisa ter a
mesma estrutura da tabela do destino dos dados.
import pandas as pd
from sqlalchemy import create_engine
engine = create_engine(
"mysql+pymysql://{user}:{pw}@localhost/{db}".format(user="usuario",
pw="123", db="ETLDB"))
df.to_sql('ETL', con=engine, if_exists='append', chunksize= 2000)
 ATENÇÃO
É importante lembrar que esse método pode ser usado com qualquer banco de dados desde que o
driver esteja instalado e seja suportado pela SQLAlchemy.
CX_ORACLE
Caso o destino da carga de dados seja um banco de dados Oracle, a equipe de integração pode usar a
biblioteca cx_oracle. Ela possibilita conexão com diversas versões de banco, como 9.2, 10, 11, 12 e 21.
Recomenda-se verificar a compatibilidade na documentação da Oracle antes desenvolver o script. Trata-
se de um projeto de código aberto mantido pela empresa sobre o licenciamento BSD.
import cx_Oracle
import os
conn = cx_Oracle.connect(string_de_conexao)
cursor = conn.cursor()
registro = [(98101, 480070688)]
cursor.setinputsizes(int, 20, int, 100)
cursor.execute("insert into ETLTABLE(feat01, feat02) values (:1, :2)", registro)
conn.commit() 
cursor.close()
Um dos pontos fortes dessa biblioteca é o suporte nativo ao gerenciamento de transação.
A classe connection implementa a função rollback, a qual, quando chamada, desfaz a transação
pendente. No caso de a conexão com o banco ser fechada antes do commit, a transação também será
desfeita automaticamente (rollback automático). Além disso, a biblioteca implementa algumas
otimizações de desempenho.
Veja alguns exemplos:
ROW PREFECHING
javascript:void(0)
O row prefeching implementa técnicas de buffering que reduzem a quantidade de requisições e
respostas entre o cliente e o banco.
EXECUTEMANY
O método da classe Cursor denominado executemany é mais eficiente para inserir múltiplas linhas no
banco do que criar um laço e iterar usando o Cursos.execute().
ORACLE SESSION DATA UNIT
No caso de a massa de dados ser muito grande e/ou de a rede ser muito lenta, é possível configurar o
tamanho do pacote que será enviado pela rede por intermédio da Oracle Session Data Unit (SDU).
Utilizar a biblioteca cx_oracle corretamente pode fazer a diferença em uma janela de manutenção muito
curta.
PSYCOPG/PSYCOPG2
Psycopg é um adaptador Python para o banco de dados PostgreSQL. Ele é disponibilizado sob a licença
GNU Lesser General Public Licence e permite o uso tanto em programas livres como em proprietários.
Simples e de fácil uso, essa biblioteca dá suporte ao multiprocessamento (multi-thread), sendo indicada
para aplicações que precisam executar operações de inserção e update concorrentes. O funcionamento
é semelhante ao das outras bibliotecas descritas.
Primeiramente, é preciso abrir uma conexão passando as credenciais (usuário e senha). O objeto criado
na conexão retorna um cursor, que é usado para executar queries simples e complexas por meio do
método execute. Após isso, basta executar o commit e, ao final do uso, fechar a conexão com o banco.
import psycopg2
conn = psycopg2.connect("dbname=ETLDB user=postgres")
cursor = conn.cursor()
cur.execute("INSERT INTO ETLTABLE (feat01, feat02) VALUES (%s, %s)", (“98101”, “480070688”
conn.commit()
cursor.close()
conn.close()
VERIFICANDO O APRENDIZADO
javascript:void(0)
javascript:void(0)
MÓDULO 2
 Identificar as ferramentas para ETL e os casos de uso
LIGANDO OS PONTOS
O ambiente do Python fornece ferramentas muito interessantes para ETL. Podemos testar essas
ferramentas a partir de bases globais?
Dois frameworks de utilização simples e muito versáteis são o bonobo e o bubbles, ambos voltados para
o processamento de dados, sendo plenamente aplicáveis para as tarefas de extração, transformação e
carga de dados. No entanto, para compreendê-los precisamos de uma base de dados aberta e com
volume adequado, como a Iris Dataset, que é utilizada nos exemplos de diversas ferramentas para
mineração de dados, sendo fornecida no formato CSV, e contando com informações acerca de
diferentes tipos de flores de íris.
Analisando inicialmente o bonobo, sua utilização é baseada em um grafo de execução, no qual cada nó
representa alguma ação sobre um fluxo de entrada, transformando ou filtrando os dados para o nó
seguinte. No caso do Iris Dataset, seria necessário que o nó inicial utilizasse um leitor de arquivos CSV,
seguido de filtragens e transformações, e finalizando com um nó para persistência, que poderia, por
exemplo, persistir os dados transformados na forma de um arquivo JSON (java script object notation).
Diversos módulos são incluídos no bonobo, começando pelo gestor de fluxo (Graph), que irá organizar a
sequência de nós do grafo, permitindo até mesmo a construção de caminhos de execução paralelos.
Além disso, os nós do grafo podem contar com vários adaptadores para leitura e escrita, como
CsvReader e JsonWriter, adaptador para filtragem de dados (Filter), e integração simples de funções de
transformação personalizadas.
 
import bonobo 
from bonobo.config import use_raw_input 
@use_raw_input 
def getLinha(row): 
 return {"id":row.Id, 
 "largura":row.PetalWidthCm, 
 "comprimento":row.PetalLengthCm } 
def get_graph(): 
 return bonobo.Graph( 
 bonobo.CsvReader("Iris.csv"), 
 getLinha, 
 bonobo.JsonWriter("Iris.petalas.json") 
 ) 
bonobo.run(get_graph())
Com relação aobubbles, ele trabalha segundo o padrão arquitetural pipe and filter, tendo a classe
Pipeline como gestor de execução. Após instanciar o gestor, métodos para leitura, transformação e
carga dos dados devem ser chamadas em sequência, com a saída de cada chamada sendo direcionada
para a seguinte.
Ao trabalhar com bubbles, é necessário instalar o pacote SQL Alchemy, para mapeamento objeto-
relacional e inclusão de instruções SQL como métodos do Python. Entre os recursos disponibilizados
estão a agregação de registros, filtragem de campos, operações de junção, além de muitos outros, e os
dados podem ser obtidos via rede pelo leitor de CSV.
import bubbles 
 URLBASE = "https://raw.github.com/Stiivi/cubes/master" 
URL = URLBASE + "/examples/hello_world/data.csv" 
p = bubbles.Pipeline() 
p.source(bubbles.data_object("csv_source", URL, infer_fields=True)) 
p.aggregate("Category", "Amount (US$, Millions)") 
p.pretty_print()
Utilizando um dos frameworks descritos, as operações de ETL são executadas dentro de um fluxo bem
organizado, tendo como base sequências de recursos plugáveis, preparados para lidar com diversos
tipos de fontes de dados, incluindo CSV e JSON. Essas características irão permitir explorar bases de
teste globais, e comparar os resultados com outras ferramentas de mineração de dados, como o Orange
Data Mining.
Após a leitura do caso, é hora de aplicar seus conhecimentos! Vamos ligar esses pontos?
3. APESAR DO PYTHON OFERECER TODOS OS RECURSOS
NECESSÁRIOS PARA EFETUAR OPERAÇÕES DE ETL DE
FORMA NATIVA, OU COM BASE EM BIBLIOTECAS SIMPLES,
COMO FTPLIB E GZIP, O ESFORÇO DE PROGRAMAÇÃO
PODE SER ALTO E DESNECESSÁRIO, JÁ QUE PODEMOS
CONTAR COM FRAMEWORKS COMO O BONOBO E O
BUBBLES. EXPLIQUE COMO ESSES FRAMEWORKS PODEM
SIMPLIFICAR A IMPLEMENTAÇÃO DE OPERAÇÕES
RELACIONADAS À EXTRAÇÃO, TRANSFORMAÇÃO E
CARGA DE DADOS.
RESPOSTA
Tanto o bonobo quanto o bubbles permitem gerenciar o fluxo de execução das operações de ETL, com a
utilização de elementos plugáveis para as tarefas de extração, transformação e carga. Quando utilizamos o
bonobo, temos como base um objeto do tipo Graph, que recebe a sequência de elementos para execução,
como CsvReader, para a leitura dos dados (extração), função personalizada para transformação, e escrita
através do conector JsonWriter. Já o bubbles, inicia uma linha de execução em um objeto Pipeline, seguido
de chamadas a operações de leitura (source), diversos métodos de transformação, como aggregate, e escrita
via target. Com isso, os frameworks implementam as operações mais comuns, como extração e gravação de
arquivos em formatos conhecidos, evitando que o programador perca tempo com a implementação delas.
PRIMEIRAS PALAVRAS
Escrever os scripts de extração toma tempo e requer experiência na linguagem que será utilizada –
normalmente, a Python. Alternativamente, a equipe de integração pode optar por ferramentas de
prateleira para minimizar ou eliminar o esforço de programação, usando-as para extrair, limpar e
transformar os dados antes que eles sejam carregados em um data warehouse.
Existem diversas ferramentas para esse propósito. Conheceremos algumas delas a seguir.
BONOBO
javascript:void(0)
Framework baseado em Python específico para ETL, o bonobo simplifica o desenvolvimento de código.
Ele é relativamente fácil de aprender e usar, permitindo o acompanhamento do fluxo de trabalho na
forma de grafos.
O bonobo é instalado da mesma maneira que uma biblioteca Java, podendo-se usar o comando pip
install bonobo. A ferramenta não contém funções estatísticas ou de análise de dados. Ela é indicada
apenas para o trabalho específico de ETL:
EXTRAIR

TRANSFORMAR

CARREGAR O RESULTADO FINAL EM ALGUMA BASE DE
DADOS
O trabalho começa com a criação de Jobs ETL com entradas (in) e saídas (out). Um job pode conter o
fluxo de processo inteiro: extração, transformação e a carga. Esta, ao contrário das outras, tem apenas
entrada (in) de dados.
As transformações são como funções que modificam os dados; quando organizadas em uma sequência
direcional do fluxo da transformação, elas são representadas por um grafo. O usuário pode gerar uma
figura contendo o grafo que representa a sequência de transformações construídas para ter uma
referência visual do processo.
 VOCÊ SABIA
De fato, o bonobo reduz bastante a necessidade de se criar um código, mas não completamente: as
transformações são todas construídas programaticamente. Além disso, ter noções de lógica e
desenvolvimento de código é fundamental. Ele é nativamente integrável com Django, Docker e Jupyter e
a biblioteca do MIT. Chamada de SQLAlchemy, essa biblioteca é usada pelo pandas para encapsular
drivers de conexão com banco de dados.
BUBBLES
O Bubbles é uma ferramenta para ETL baseada em metadados, os quais, por sua vez, são usados para
descrever o processo fim a fim em um gráfico. Cada operação é modelada como um nó que recebe
diferentes parâmetros de entrada e retorna o resultado da operação.
A ferramenta foi desenhada para trabalhar de forma agnóstica. Isto é, o profissional precisa apenas se
preocupar com a forma na qual os dados são processados para ter o resultado desejado.
A unidade de trabalho é o data object, que é uma representação do tipo da fonte de dados usada: CSV,
MongoDB, PostgresSQL etc. O analista vai manipulando os data objects de acordo com o fluxo de
trabalho e usa operações. O esforço de programação é mínimo ou quase inexistente.
Os casos de uso recomendados pelo fabricante são:
INTEGRAÇÃO DE DADOS
MONITORAMENTO DE DADOS
AUDITORIA DE DADOS
INSPEÇÃO DE DADOS
LIMPEZA DE DADOS
A instalação é muito simples: pode-se usar o comando pip ou baixar o código-fonte diretamente do
repositório github e compilá-lo. A ferramenta implementa as dependências externas como serviços.
Dessa forma, conexões com bases de dados, sistemas de arquivos ou outras fontes de informação são
modeladas como serviços que serão usados pelas transformações, o que deixa o código modular e de
fácil manutenção.
 VOCÊ SABIA
O Bubbles é distribuído sob a licença do MIT, sendo necessário apenas informar o copyright no caso de
ele ser incorporado à outra aplicação.
ORACLE DATA INTEGRATOR
A Oracle, fabricante de diversos sistemas e do famoso banco de dados de mesmo nome, disponibiliza
uma ferramenta chamada de Oracle Data Integrador (ODI). Entretanto, sua filosofia de uso é diferente.
O fabricante indica a realização de um processo levemente diferente. Chamado de ELT, ele inverte um
pouco as etapas do processo.
Com isso, carregam-se os dados extraídos das fontes diretamente em um staging area da base de
destino. A última etapa consiste em realizar a limpeza e a transformação dos dados após a carga.
FERRAMENTAS ETL
Um especialista destacará neste vídeo as vantagens das ferramentas de suporte ao processo ETL, bem
como seus aspectos práticos, como a preparação de um documento técnico.
CASO DE USO
Munidos da teoria explicadas nas seções anteriores, veremos agora um caso de uso baseado em uma
situação real.
ALFA TELCO: MODERNIZAÇÃO DA OPERAÇÃO
Vamos começar entendendo o panorama geral da empresa e o problema apresentado:
A empresa Alfa Telco é uma grande operadora de telecomunicações localizada em um país da América
Latina que contém subsidiárias em cinco outros países na mesma região. Ela vem enfrentando
dificuldades para implementar novos produtos e serviços em formato de combo, pois os sistemas que
suportam a operação são antigos e quase nenhum deles permite a automação.
Além disso, o tempo de verificações de falhas de rede subiu enormemente, o que reduziu a níveis
críticos o índice de satisfação dos clientes. Uma consultoria independente contratada verificou que os
maiores ofensores são os dados das redes utilizadas para ativar os novos combos de serviços que se
encontram fragmentados entre diversos bancos de dados diferentes.
Essa situação se originou no crescimento da empresa que ocorreu por silos verticais, em que cada
departamento determina eopera suas estratégias de negócios sem levar em conta as outras áreas de
negócios e sem seguir uma padronização para a modelagem dos dados. Como parte da estratégia de
modernização dos sistemas de suporte à operação (OSS), a empresa precisa migrar e consolidar os
dados dos nós de acesso para o novo sistema de inventário de última geração adquirido de um
fabricante europeu.
Inicialmente, o projeto será realizado na subsidiária colombiana. Se tiver sucesso, ele deverá ser
realizado em todas as outras subsidiárias, porém respeitando a cultura local de cada companhia.
O trabalho, portanto, consiste em mover alguns dados da plataforma que agrega as informações de
milhares de nós de acesso para o novo sistema centralizado, o qual, por sua vez, usa uma base de
dados Oracle. Para resolver o problema, a companhia contratou uma empresa integradora para realizar
a tarefa: a Beta Int.
AGORA QUE ENTENDEMOS O PROBLEMA, VEREMOS A SOLUÇÃO
APRESENTADA PELA EMPRESA INTEGRADORA CONTRATADA.
A Beta Int. colocou seus analistas e arquitetos fisicamente dentro do escritório do cliente em contato com
profissionais dos departamentos de TI, redes e engenharia. O pessoal de redes e de engenharia
conhece bem a realidade dos sistemas e das modelagens empregadas e será de grande valia na hora
de entender os dados e sua criticidade.
Por outro lado, o pessoal de TI é dono dos sistemas e pode dar as permissões necessárias para o
acesso aos bancos, bem como ajudar a minimizar os tempos de transferência de dados, alocando mais
banda ou definindo horários para a carga massiva. Além disso, as VPNs eventualmente precisam ser
usadas ou firewalls têm de ser desviados para prover acesso a pessoal externo ou permitir
transferências de dados entre redes internas. É responsabilidade do grupo de segurança do
departamento de TI prover acessos de maior nível e aprovar qualquer eventual requerimento especial de
acesso.
Um projeto desse tipo costuma ser dividido em macrofases, como, por exemplo:
FASE DE ANÁLISE
O trabalho começa com o time de analistas escrevendo a especificação técnica da migração de dados
na fase de análise. O documento é escrito por várias mãos e precisa estar pronto antes do início da fase
de desenvolvimento, já que ele vai orientar o trabalho dos programadores.
 
Ainda dentro da fase de análise, todas as fontes passam por um escrutínio. Os técnicos fazem uma
revisão da documentação existente (até para verificar se as fontes são suficientes), solicitam permissões
de acesso e levantam todos os dados necessários para o projeto.
FASE DE DESENVOLVIMENTO 
Durante a fase de desenvolvimento, os programadores recebem todos os requisitos dos analistas
funcionais e iniciam a confecção dos scripts ou as customizações necessárias. Devem ser feitos tantos
ensaios quanto necessários: os chamados dry runs.
 
Ajustes de desempenho também precisam ser realizados para garantir que o período de execução do
código caiba na janela de tempo disponível, bem como as devidas verificações: integridade referencial,
estrutura, unicidade, análise de redundância, dependências etc. Os dados também são combinados,
limpos e filtrados de acordo com as regras de negócios, enquanto as duplicatas são eliminadas.
 
O time de desenvolvimento produz relatórios de pré-carga contendo os resultados dos ensaios
realizados, inclusive os erros encontrados e corrigidos, os problemas enfrentados, os riscos e seus
mitigadores. É preciso estabelecer e acordar com o cliente os indicadores de qualidade que serão
usados como parâmetro para a carga real.
 
O artefato final da fase de desenvolvimento é um acordo assinado entre o cliente e a empresa
integradora (business agreement) contendo o roteiro, os scripts e os parâmetros para a carga real que
será feita com dados reais de produção.
FASE DE TESTES
É possível e muitas vezes recomendado que uma equipe diferente daquela que desenvolveu os códigos
de migração faça os testes para evitar enviesamento. Para isso, uma fase adicional de testes é criada,
enquanto o cliente observa atentamente os resultados. O objetivo da fase de testes é produzir um
parecer independente sobre a qualidade do trabalho de desenvolvimento e gerar métricas de qualidade.
FASE DE PRODUÇÃO
Uma vez tendo a aprovação do time de teste e qualidade, é chegado o momento da entrada em
produção. A execução final tem de ser feita com acompanhamento do cliente.
 
Validações e verificações adicionais devem ser feitas após a carga final para decidir se executam
rollback ou não. O projeto termina quando a empresa integradora recebe o aceite do cliente e passa a
operar o sistema novo.
 SAIBA MAIS
É possível que um projeto possua um detalhamento maior envolvendo outras etapas: análise,
planejamento, extração, limpeza, carga e verificação.
Em 12 meses, após a assinatura do contrato, a empresa Beta Int. migrou dados de 17 tipos diferentes
de gestores de redes que usavam bases distintas, algumas proprietárias e outras comerciais. Porém
alguns sistemas não davam suporte à extração massiva, e foi preciso improvisar.
Esses gestores foram configurados para gerar diariamente arquivos de sistema contendo as
informações de inventário atualizadas em uma pasta visível para um servidor FTP. Essa pasta movia os
arquivos para outro servidor durante a madrugada.
Convertidos para o formato CSV, tais arquivos, em seguida, eram carregados na staging area. Os dados
então foram limpos, consolidados, transformados e encaixados no schema da base Oracle usada pelo
sistema comprado.
DOCUMENTO TÉCNICO PARA MIGRAÇÃO DE
DADOS COM ETL
A especificação técnica e funcional sobre o trabalho de migração de dados é o documento que baliza e
norteia o esforço de vários profissionais ao longo das diversas fases do projeto. Ele leva em conta as
técnicas da ETL, como melhor prática, sendo, portanto, extremamente importante.
Clareza, detalhamento, concisão e rigor técnico são atributos necessários que o artefato precisa ter para
garantir que todos os envolvidos no projeto o entendam e possam segui-lo sem dúvidas de
interpretação. Normalmente, ele é escrito em inglês mesmo em projetos no Brasil ou em países na
América Latina, porque os times podem incluir fornecedores ou pessoal técnico estrangeiro. Portanto, o
inglês é o idioma técnico universal usado para confeccioná-lo.
Não existe um formato rígido para o documento, mas algumas seções são importantes e precisam estar
contidas. Algumas são únicas, como as seções escopo, fora do escopo, validade, datas, requerimentos
não funcionais e segurança e premissas, embora as outras precisem ser repetidas para cada fonte de
dados/sistema que seja parte do escopo de trabalho.
Além disso, pode haver a necessidade de se adicionar seções diferentes e específicas. Não há
problema nesses casos, mas verifique se a ideia já não está contida em alguma seção antes de
adicioná-la.
Agora observaremos algumas dessas seções:
ESCOPO
A seção escopo resume os limites do acordo de trabalho realizado entre o cliente e a empresa
integradora. Todas as referências do trabalho são listadas nesta seção, como, por exemplo, sistemas,
fontes de dados, interfaces e casos de negócios. É preciso ser minucioso para evitar divergências no
futuro.
FORA DO ESCOPO
A seção fora do escopo lista os itens que não serão considerados durante a execução do trabalho. Ela é
importante porque pessoas e departamentos diferentes podem ter entendimentos distintos sobre o
mesmo tema, tecnologia ou sistema. Por exemplo, no caso de uso anterior, todos os links físicos e
lógicos existentes na base legada estão fora do escopo da migração.
REQUERIMENTOS NÃO FUNCIONAIS E PARÂMETROS DE
DESEMPENHO
Todos os parâmetros não funcionais, bem como aqueles relacionados ao desempenho e à qualidade
precisam estar listados e descritos nesta seção. Exemplos: tempos máximos para os processos de ETL,
tempo das janelas de manutenção, quantidade de erros máximo permitido, tempos de time out,
arquivamento, auditoria etc.
SEGURANÇA
Similarà seção anterior, todos os parâmetros e critérios de segurança, principalmente aqueles
relacionados à privacidade dos dados, devem estar listados e descritos, como, por exemplo,
autenticação, autorização e criptografia.
PREMISSAS
Nesta seção, precisam estar listadas as premissas feitas ou informadas ao time de integração,
principalmente aquelas que embasam as decisões técnicas.
VALIDADE DO DOCUMENTO 
O dia a dia operacional de uma empresa é muito dinâmico. Sistemas são modificados e bases de dados
são atualizadas diariamente. É importante determinar um prazo de validade, o qual, quando
ultrapassado, indica a necessidade de atualização do documento. Quando ele estiver pronto, será
necessário haver uma certa urgência em revisá-lo e aprová-lo.
DATAS (CRONOGRAMA) 
É preciso anexar o cronograma aprovado do projeto. Assim, o documento fica contextualizado nas fases
e nos momentos do projeto.
PADRÕES E MELHORES PRÁTICAS
É conveniente referenciar os guias de padrões e as melhores práticas que serão seguidos durante a
execução do projeto. Isso normaliza jargões e expressões técnicas e ajuda a audiência não técnica,
como, por exemplo, gestores e gerentes, a ter uma compreensão melhor da parte técnica e entender o
motivador das decisões técnicas. Podem ser referenciados tanto as melhores práticas da indústria
quanto os guias fornecidos por fabricantes e fornecedores de tecnologia. O ETL deve ser citado nesse
momento.
DESCRIÇÃO FUNCIONAL 
Nesta seção, o sistema ou a fonte de dados precisa ser brevemente explicado do ponto de vista
funcional. É importante também que a descrição seja agnóstica. Por exemplo: o autor precisa descrever
o perfil dos dados contidos, a regularidade em que ele é atualizado, os sistemas dependentes dessas
informações e proprietários, entre outros itens, sem sugerir soluções técnicas nem ter um viés voltado
para determinada plataforma ou tecnologia.
REQUERIMENTOS TÉCNICOS 
Aqui são listadas todas as características técnicas da fonte de dados e as soluções técnicas dadas para
cumprir o processo de ETL. Por exemplo: uma das fontes de dados do projeto pode ser a coleção de
arquivos no formato CSV gerados diária e automaticamente por um dos sistemas gestores de elementos
de rede. Nesse caso, é preciso explicar o formato dos arquivos, o encoding usado, o padrão de
nomeação, o tamanho médio e a localização desses arquivos, assim como a maneira com que os dados
serão lidos, exportados, tratados, convertidos etc. Havendo sistemas extras, como servidores de FTP
necessários para copiar os dados, estes também precisam ser mencionados aqui. Mapas e diagramas
são bem-vindos para situar o leitor.
DESCRIÇÃO DOS PROCESSOS 
Nesta seção, é fornecida a visão macro do processo usado para extrair, transformar ou carregar os
dados. Nela, uma breve descrição do fluxo que será seguido, além de um diagrama de sequência,
costuma ser necessária para orientar a audiência. Por exemplo, no caso de uso anterior, a equipe de
migração utilizou uma ferramenta proprietária para extrair os dados de gestores de rede e armazená-los
em um formato intermediário em um servidor de FTP, que foi posteriormente modificado para ser
carregado na staging area. A descrição do processo precisa inclusive mencionar o processo de limpeza
do diretório e purgar os arquivos já carregados e não mais necessários. Basicamente, o processo de
ETL é descrito nessa parte do documento.
 ESTRUTURA DE DADOS 
É preciso explicar em detalhes as estruturas de dadas da fonte de origem. Uma tabela ou lista com
tipos, nomes, descrição e outras características, como, por exemplo, se é mandatório ou opcional, para
cada tipo de registro e com uma breve explicação costuma ser suficiente.
MENSAGERIA
Os protocolos para a movimentação dos dados precisam ser mencionados. Por exemplo: o SFTP é
usado para a transferência unidirecional do sistema X para o sistema de arquivos Y para ler, carregar e
apagar os arquivos.
VALIDAÇÕES
Todas as regras funcionais de validação dos dados precisam ser listadas e explicadas nesta seção,
como validações de tipo, regras de nomeação, domínio, valores permitidos e um exemplo. Pensemos
neste exemplo para ilustrar o caso: o formato dos nomes para uma classe de objetos manda que eles
sejam compostos por quatro partes, sendo a primeira de dois dígitos, de 0 a 9; a segunda de dois a
cinco dígitos, de 0 a 9; a terceira composta por seis dígitos, também de 0 a 9; e a quarta parte formada
por três letras do alfabeto americano, que inclui Y e W.
GERENCIAMENTO E TRATAMENTO DE ERRO 
A equipe técnica precisa explicitar se haverá tratamento de erro automático ou se eles serão tratados
manualmente. Ela deve informar ainda quais medidas serão tomadas, bem como quais tipos de erros
são mais comuns.
VERIFICANDO O APRENDIZADO
CONCLUSÃO
CONSIDERAÇÕES FINAIS
À medida que os dados ganham cada vez mais importância no contexto empresarial, principalmente
como fonte de receita, cresce a preocupação em mantê-los consistentes e utilizáveis. Extrair sentido e
valor de grandes massas de dados tem sido o desafio e a maior preocupação de grandes corporações.
Em paralelo, mudanças advindas da transformação digital, da modernização de sistemas e da
necessidade de se mover o ambiente sistêmico para a nuvem fizeram com que os processos de ETL
ganhassem nova relevância.
Ao estudar este conteúdo, você compreendeu a necessidade de colocar suas habilidades de
programação em prática em um contexto de migração de dados usando o ETL. O caso de uso e o
roteiro para a criação do documento técnico de migração baseado em ETL ajudarão você a substanciar
o aprendizado e lhe darão um vislumbre das melhores práticas empregadas pela indústria.
 PODCAST
Neste podcast, abordaremos o conceito das fases de ETL.
AVALIAÇÃO DO TEMA:
REFERÊNCIAS
CHHABRA, M. Setting up ETL using Python simplified. Hevodata. Publicado em: 5 abr. 2021.
Consultado na internet em: 6 jul. 2021.
COSTA, C. D. Want to do ETL with Python? Towards data science. Publicado em: 6 fev. 2021.
Consultado na internet em: 6 jul. 2021.
DEARMER, A. Top 6 Python ETL tools for 2021. Xplenty. Publicado em: 3 mar. 2021. Consultado na
internet em: 6 jul. 2021.
EXPLORE+
Para aprimorar os seus conhecimentos no assunto estudado, recomendamos a leitura das seguintes
obras:
CRICKARD III, P. Data engineering with Python: work with massive datasets to design data
models and automate data pipelines using Python. Packt Publishing. 2020.
DRASCENO, E. Integração de dados com Pentaho Data Integration. 2019. Edição Kindle.
CONTEUDISTA
Michel Souza Medeiros