Utilizando o Docker como máquina virtual decidi utilizar o Docker Compose para configurar cada um dos serviços necessários para o desafio de forma clusterizada e conectada simulando mais ou menos como seria em um ambiente cloud.

No docker-compose.yml tem as configurações de cada serviço sendo eles:

• airflow_db: banco de dados PostgreSQL para o Airflow.
• postgres: banco de dados PostgreSQL para a resolução em SQL.
• airflow: faz referência ao Dockerfile da pasta docker/airflow.
• spark: faz referência ao Dockerfile da docker/spark.

Todas as imagens foram utilizadas na versão latest sendo até o momento:

• postgres: 12.3
• airflow: 1.10.9
  • python: 3.7.6
• spark: 3.0.0
  • python: 3.8.3

• dags: contém as dags
• data: contém os csvs do desafio e onde salvará os csvs de resultado
  • refined_zone: onde salvará os csvs refinados do pyspark
• docker: contém o Dockerfile e requirements.txt dos seguintes serviços.
  • airflow
  • spark
• notebook: contém a resolução em PySpark Notebook.
• sql: contém as consultas da resolução em SQL.
• work: contém os scripts python da resolução em PySpark.
  • etl: com o script python com a classe para tratar os dados.

Com a ajuda do Docker Compose consegui separar os serviços e mantê-los numa mesma rede sem grandes configurações. Comecei fazendo a resolução do problema no notebook o que foi tranquilo, minha maior dificuldade foi passar para a dag do Airflow.

Não conseguia conectar o Airflow do container dele ao Spark de outro container, após muitas tentativas consegui achar uma solução, talvez não a que eu queria de início, mas que ainda simulasse um pouco como seria em um ambiente cloud.

Usando o DockerOperator do Airflow fiz com que ele criasse um container e iniciasse o script em python, assim mantendo a ideia de tarefas isoladas e independentes entre si.

Após isso fiz a resolução do problema em SQL, que ficou com a dag mais da forma que eu gostaria, onde mostra o passo a passo de cada fase da tabela.

Ao comparar os resultados percebi um erro que tinha passado desapercebido, o solicitado é o último valor simulado, e eu estava trazendo o último registro que, em alguns casos, tinha valor simulado nulo.

Sendo assim retornei e corrigi todas as resoluções anteriores.

Em todas as resoluções faço a criação de três tabelas:

• users: tabela de usuários
• funnel: tabela de funil
• result: tabela de resultado

Na criação da tabela users eu já adiciono os dados que eu precisaria para a tabela de resultado, flag_investidor_recorrente e investimentos_externos. Além disso já abro em colunas o conteúdo do json, como também já deixo simplificado a coluna estado_civil.

Na criação da tabela funnel eu já adiciono colunas com a ordem dos eventos e do valor simulado por usuário, e duas flags se é primeiro_evento e se é ultimo_valor_simulado

Portanto assim a consulta para gerar a tabela de resultado se torna bastante simples já que apenas preciso juntar as duas tabelas e colocar a flag que preciso um para pegar a data do primeiro evento e outra para pegar o último valor simulado.

• Requisitos:
  • Docker: última versão (atualmente v19.03.8)
  • Git: última versão

1. Instalar/Atualizar o Docker;
2. Clonar este repositório em uma pasta local: git clone https://github.com/flaviofgf/magnetis_test.git
3. Editar a variável de ambiente do Dockerfile do Airflow linha 9: ENV HOST_MAIN_PATH 'D:/Projects/magnetis_test' colocando o caminho absoluto do projeto na sua máquina
4. No console ir a pasta do projeto e subir o Docker Compose: docker-compose -f docker-compose.yml up -d --build
5. Aguarde a mensagem: 'Compose: magnetis_test' has been deployed successfully.
6. Ainda no console digite: docker-compose logs spark e acesse o link do Jupyter Notebook que comece por http://127.0.0.1:8888/
7. Assim já poderá acessar as seguintes urls:
   • Jupyter: http://127.0.0.1:8888/
   • Airflow: http://127.0.0.1:8080/

1. Jupyter:
   1. Acesse o Jupyter e acesse notebook/etl.ipynb;
   2. Poderá na barra de menu ir em Cell/Run All ou teclar Shift + Enter nas células e ver seus resultados;
   3. O arquivo csv com o resultado estará em data/ipynb_result.csv.
2. PySpark:
   1. Acesso o Airflow;
   2. Ligue a dag etl_DAG (ao ligar já entrará em execução)
   3. O arquivo csv com o resultado estará em data/result.csv.
3. SQL:
   1. Acesso o Airflow;
   2. Ligue a dag sql_DAG (ao ligar já entrará em execução)
   3. O arquivo csv com o resultado estará em data/sql_result.csv.

Qualquer dúvida estou inteiramente à disposição.