Este painel foi desenvolvido usando Streamlit. Vários pacotes de código aberto são usados para processar os dados e gerar as visualizações, por exemplo. pandas, geopandas, leafmap, matplotlib e pydeck.
Este é um projeto de análise de dados para um bar e restaurante localizado no sul da ilha de Florianópolis. O objetivo do projeto é utilizar as informações disponíveis para realizar análises e obter insights que possam ser utilizados para tomar decisões estratégicas.
Nota: Resultados de gráficos e tabelas no power bi, estão disponíveis na pasta
data/processed
.
- 🚀Introdução
- 🔮Arvore de Diretorios
- 🌃Arquitetura do projeto
- 🎆Tecnologias Utilizadas
- 💎Pré-requisitos
- ✨Instalando o Projeto
- 🎉Executando o Projeto
- 👾Testes
- 🔥Utilizando a API com Insomnia
- 🥶Versão atual
- 👹Coletando Dados
- 👻Processando Dados
- 🤖Visualizando os Dados
- 👽Futuras Atualizações
- 🐳Tecnologias e conceitos utilizados
- 🧠Roadmap v1
- 🧠Roadmap v2
- 🤖O que é o Apache Spark?
- 🎖️Critérios de aceitação do projeto
- 👹Contribuindo
- 👾Contribuidores
- 🎉Licença
Este projeto é um estudo de caso de Big Data e Power BI. O objetivo é demonstrar como coletar, processar, analisar e visualizar grandes volumes de dados em tempo real usando ferramentas e tecnologias como Python, SQLite e Power BI.
O projeto é baseado em um restaurante chamado "Pedacinho do Céu". O restaurante está localizado em uma cidade turística e serve comida tradicional da região. O restaurante está interessado em coletar dados de várias fontes para analisar e obter insights sobre o negócio. O restaurante também deseja criar visualizações e relatórios interativos para ajudar na tomada de decisões e na compreensão de tendências e padrões nos dados.
O mesmo utiliza a linguagem Python e diversas bibliotecas para análise de dados, como Pandas, NumPy e Plotly. Além disso, é utilizado o framework Streamlit para a criação de uma interface interativa para o usuário, permitindo a visualização dos dados e a interação com as funcionalidades desenvolvidas.
Entre as funcionalidades desenvolvidas, estão a análise de vendas por mês, a previsão de clientes para o próximo mês, a análise de dados de clientes cadastrados, a exibição de um mapa de localização do estabelecimento e a criação de uma história do bar e restaurante.
Para utilizar o projeto, basta clonar o repositório e instalar as dependências listadas no arquivo requirements.txt. Em seguida, execute o comando "streamlit run app.py" para iniciar a aplicação.
-
Coleta de dados: O projeto utiliza diversas fontes de dados, como arquivos CSV, APIs e bancos de dados. Os dados são coletados e processados em uma variedade de formatos para atender às necessidades do projeto. A coleta de dados é um processo crucial para garantir que as informações corretas estejam disponíveis para análise e visualização.
-
Processamento de dados: O projeto utiliza uma variedade de técnicas para processar e limpar os dados coletados, incluindo o uso de bibliotecas Python para análise e transformação de dados. Os dados são organizados e limpos para garantir que estejam prontos para análise e visualização. O processamento de dados é uma etapa importante no processo de garantir que as informações corretas estejam disponíveis para o usuário final.
-
Armazenamento de dados: O projeto utiliza uma variedade de tecnologias de armazenamento de dados, incluindo bancos de dados relacionais e não relacionais, armazenamento em nuvem e arquivos CSV. Os dados são armazenados de forma a garantir que estejam seguros e disponíveis para análise e visualização. O armazenamento de dados é um componente crítico do projeto, garantindo que os dados estejam disponíveis quando necessários.
-
Análise e visualização de dados: O projeto utiliza ferramentas de análise e visualização de dados, como Power BI e bibliotecas Python, para extrair informações significativas dos dados coletados. As informações são apresentadas de forma clara e intuitiva, permitindo que o usuário final compreenda facilmente os insights obtidos a partir dos dados. A análise e visualização de dados são etapas críticas no processo de transformação de dados em informações úteis.
-
Atualização e manutenção: O projeto requer atualizações regulares para garantir que os dados estejam atualizados e precisos. Além disso, a manutenção do sistema é importante para garantir que as tecnologias utilizadas estejam atualizadas e seguras. A atualização e manutenção do sistema são etapas críticas para garantir que o projeto continue funcionando de forma eficiente e eficaz ao longo do tempo.
O projeto utiliza conceitos de Big Data e Power BI. Vamos revisar como cada tecnologia é aplicada no projeto:
- Linguagem de programação Python para desenvolvimento do back-end e front-end da aplicação web, utilizando o framework Streamlit para criação da interface do usuário.
- Pandas e Numpy para manipulação e análise de dados, realizando operações como seleção, filtragem, agrupamento e junção de dados.
- Matplotlib e Plotly para criação de gráficos e visualizações de dados interativas.
- Scikit-Learn para modelagem de dados, com algoritmos de aprendizado de máquina para previsão e classificação.
- Power BI para criação de dashboards e relatórios interativos e visuais a partir dos dados gerados e analisados na aplicação web.
Combinando Big Data e Power BI, este projeto oferece uma solução completa para coletar, processar, analisar e visualizar grandes volumes de dados em tempo real, ajudando na tomada de decisões informadas e oferecendo insights valiosos para o negócio do restaurante "Pedacinho do Céu".
Abaixo está a estrutura de diretórios do projeto:
.
├── 📂 .github
├── 📂 .husky
├── 📂 .vscode
├── 📂 assets
├── 📂 backend
│ └── 📂 admin
│ ├── 📂 conf
│ ├── 📂 data_crawlers
│ ├── 📂 target_url_crawlers
│ ├── .gitignore
│ ├── docker-compose.yml
│ ├── Dockerfile
│ ├── go_spider.py
│ ├── README.md
│ └── requirements.txt
├── 📂 build
├── 📂 client
├── 📂 docs
├── 📂 myenv
├── 📂 docs
├── 📂 src
│ ├── 📂 api
│ ├── 📂 data
│ ├── 📂 error
│ ├── 📂 log
│ ├── 📂 public
│ ├── 📂 scripts
│ └── main.py
├── .dockerignore
├── .editorconfig
├── .env
├── .gitignore
├── .npmrc
├── .travis.yml
├── app.py
├── architeture.md
├── AUTHORS.md
├── CHANGELOG.md
├── docker-compose.yml
├── Dockerfile
├── LICENSE
├── Makefile
├── package-lock.json
├── package.json
├── Procfile
├── pyproject.toml
├── README.md
├── requirements.txt
├── runtime.txt
├── SECURITY.md
└── setup.sh
A arquitetura do projeto é dividida em várias partes:
.github
: diretório que contém arquivos relacionados à integração contínua com o GitHub..husky
: diretório que contém arquivos relacionados à configuração do Husky, ferramenta que permite a execução de scripts no Git Hooks.admin
: diretório que contém arquivos relacionados à administração do projeto, como scripts para extração de dados (data_crawlers) e URLs alvo (target_url_crawlers).docs
: diretório que contém arquivos relacionados à documentação do projeto.src
: diretório que contém o código fonte do projeto, organizado em diferentes subdiretórios, como api (que contém as rotas da aplicação), data (que contém os arquivos de dados), error (que contém o tratamento de erros), log (que contém os arquivos de logs) e public (que contém arquivos estáticos, como imagens).app.py
: arquivo que contém a configuração e inicialização da aplicação Flask.docker-compose.yml
: arquivo que contém a configuração do Docker Compose para a execução da aplicação e do banco de dados.Dockerfile
: arquivo que contém a configuração do Docker para a construção da imagem da aplicação.Makefile
: arquivo que contém os comandos de automatização de tarefas do projeto.README.md
: arquivo que contém a descrição do projeto e sua documentação.requirements.txt
: arquivo que contém as dependências do projeto.LICENSE
: arquivo que contém as informações sobre a licença do projeto.
Neste projeto "Pedacinho do Céu", diversas tecnologias são utilizadas para coletar, processar, armazenar e visualizar dados. Abaixo está uma lista dessas tecnologias e como elas se encaixam no projeto:
-
Docker Compose: Ferramenta para definir e gerenciar aplicações multi-container usando arquivos de configuração (docker-compose.yml). É usado para simplificar o processo de inicialização e gerenciamento de todos os serviços envolvidos no projeto.
-
Power BI: Ferramenta de Business Intelligence (BI) da Microsoft para criar relatórios e visualizações de dados. É usado para analisar e visualizar os dados coletados e processados pelo projeto.
-
Flask (opcional): Microframework Python para desenvolvimento de aplicações web. Pode ser usado para criar uma API RESTful que expõe os dados processados e armazenados para outras aplicações ou serviços.
-
Matplotlib (opcional): Biblioteca Python para criação de gráficos e visualizações de dados. Pode ser usada em conjunto com o Apache Spark para criar gráficos e visualizações a partir dos dados processados.
-
Pandas (opcional): Biblioteca Python para manipulação e análise de dados. Pode ser usada em conjunto com o Apache Spark para realizar análises e limpeza de dados em pequena escala antes de processá-los no Spark.
-
Python: a linguagem de programação utilizada em todas as etapas do projeto, desde a coleta de dados até a análise e visualização. O Python é uma linguagem de programação interpretada, orientada a objetos e de alto nível, que possui uma vasta biblioteca padrão e diversas bibliotecas de terceiros para processamento de dados.
-
Streamlit: uma biblioteca de código aberto para criação de aplicativos web de dados em Python. O Streamlit é utilizado no projeto para criar uma interface amigável e interativa para visualização dos dados.
-
Plotly: uma biblioteca de visualização de dados interativa de código aberto para Python. O Plotly é utilizado no projeto para criar gráficos e visualizações interativas a partir dos dados processados com o Pandas.
-
Apache Airflow: uma plataforma de orquestração de fluxo de trabalho para gerenciamento de tarefas de processamento de dados. O Apache Airflow é utilizado no projeto para agendar e executar tarefas de coleta, processamento e análise de dados de forma automática.
-
Docker: uma plataforma de código aberto para criação, implantação e execução de aplicativos em contêineres. O Docker é utilizado no projeto para criar e executar contêineres para cada serviço envolvido no projeto.
-
Apache Spark: um framework de computação distribuída de código aberto para processamento de dados em larga escala. O Apache Spark é utilizado no projeto para processar e analisar grandes quantidades de dados.
-
Apache Hadoop: um framework de computação distribuída de código aberto para armazenamento de dados em larga escala. O Apache Hadoop é utilizado no projeto para armazenar os dados coletados e processados.
- Python 3.6+
- Apache Spark 3.0+
- Power BI Desktop
- Docker
- Docker Compose
- Node.js e npm
- Git
- Insomnia
- IDE de sua preferência (PyCharm, VS Code, etc.)
- Terminal de sua preferência (Git Bash, PowerShell, etc.)
- Sistema operacional Linux, macOS ou Windows
- Conhecimentos básicos de Python e SQL
- Sistema Operacional: Windows/Linux/Mac
- IDE: Notebook Jupyter
- Bibliotecas Python: Pandas, Numpy, spacy, gensim, NLTK, langdetect e textblob
- Ram 6GB+
- Rom 128GB+
- Processador Intel i3 ou superior
O arquivo package.json
contém as dependências do projeto. Para instalar as dependências, execute o seguinte comando:
{
"name": "analise-de-dados",
"author": "grupo-estacio",
"version": "1.0.3",
"main": "./build/electron/main.js",
"keywords": [
"restaurante",
"python",
"flask"
],
"scripts": {
"dump": "dump-stlite-desktop-artifacts",
"dev:app": "streamlit run app.py",
"production": "NODE_ENV=\"production\" electron .",
"start": "node ./dist/server.js",
"servewindows": "electron .",
"pack": "electron-builder --dir",
"prisma": "npx prisma",
"dist": "electron-builder",
"postinstall": "electron-builder install-app-deps",
"server": "nodemon --exec npx babel-node client/src/api/router/router.js"
},
"build": {
"files": ["build/**/*"],
"directories": {
"buildResources": "assets"
},
"win": {
"target": "portable",
"icon": "assets/icon.ico"
}
},
"dependencies": {
"-": "^0.0.1",
"@prisma/client": "^4.13.0",
"@types/multer": "^1.4.7",
"D": "^1.0.0",
"cors": "^2.8.5",
"csv-parser": "^3.0.0",
"csv-writer": "^1.6.0",
"express": "^4.18.2",
"multer": "^1.4.5-lts.1",
"node-fetch": "^3.3.1",
"typescript": "^5.0.4"
},
"devDependencies": {
"@stlite/desktop": "^0.22.2",
"electron": "22.0.0",
"electron-builder": "^23.6.0",
"@babel/core": "^7.21.5",
"@babel/node": "^7.20.7",
"@types/cors": "^2.8.13",
"@types/express": "^4.17.17",
"prisma": "^4.13.0",
"nodemon": "^2.0.22"
}
}
- Clone o repositório:
git clone https://github.com/big-data-estacio/data.git
cd data
É recomendado utilizar um ambiente virtual para isolar as dependências do projeto. Siga os passos abaixo para configurar e ativar o ambiente virtual usando o venv
:
- Instale o módulo
venv
, caso ainda não tenha, com o seguinte comando:
python3 -m pip install --user virtualenv
- Navegue até a pasta do projeto e crie um ambiente virtual:
virtualenv myenv
# ou, se você estiver no Windows
py -m venv myenv
- Ative o ambiente virtual:
- No Windows:
.\myenv\Scripts\activate
# ou, se você estiver usando o Git Bash
source myenv/Scripts/activate
- No macOS e Linux:
set -x VIRTUAL_ENV /mnt/c/Users/estev/OneDrive/Área de Trabalho/johanEstevam/myenv
source myenv/bin/activate.fish
- Após a ativação do ambiente virtual, seu terminal deve mostrar o prefixo
(venv)
.
Agora você pode executar o projeto com as dependências instaladas no ambiente virtual. Lembre-se de ativar o ambiente virtual sempre que for trabalhar no projeto.
- Instale todas as bibliotecas necessárias usando o comando
pip install
:
pip install biblioteca1 biblioteca2 biblioteca3
Substitua biblioteca1
, biblioteca2
e biblioteca3
pelos nomes das bibliotecas que você deseja instalar.
- Agora que todas as bibliotecas estão instaladas, execute o seguinte comando para gerar o arquivo
requirements.txt
:
pip freeze > requirements.txt
O comando pip freeze
listará todas as bibliotecas instaladas no ambiente virtual e suas versões específicas. O operador >
redirecionará a saída para o arquivo requirements.txt
, criando-o ou atualizando-o, se já existir.
- Instale as dependências do projeto utilizando o arquivo
requirements.txt
:
pip install -r requirements.txt
arquivo requirements.txt para esse projeto com as dependências necessárias.
aiohttp==3.8.4
aiosignal==1.3.1
altair==4.2.2
async-timeout==4.0.2
attrs==23.1.0
beautifulsoup4==4.12.2
blinker==1.6.2
Brotli==1.0.9
cachetools==5.3.0
certifi==2023.5.7
cffi==1.15.1
charset-normalizer==3.1.0
click==8.1.3
contourpy==1.0.7
cssselect2==0.7.0
cycler==0.11.0
decorator==5.1.1
deta==1.1.0
entrypoints==0.4
Faker==18.9.0
favicon==0.7.0
fonttools==4.39.4
frozenlist==1.3.3
gitdb==4.0.10
GitPython==3.1.31
htbuilder==0.6.1
html5lib==1.1
idna==3.4
importlib-metadata==6.6.0
Jinja2==3.1.2
jsonschema==4.17.3
kiwisolver==1.4.4
lxml==4.9.2
Markdown==3.4.3
markdown-it-py==2.2.0
markdownlit==0.0.7
MarkupSafe==2.1.2
matplotlib==3.7.1
mdurl==0.1.2
more-itertools==9.1.0
multidict==6.0.4
numpy==1.24.3
openai==0.27.7
packaging==23.1
pandas==2.0.1
Pillow==9.5.0
plotly==5.14.1
protobuf==3.20.3
pyarrow==12.0.0
pycparser==2.21
pydeck==0.8.1b0
pydyf==0.6.0
Pygments==2.15.1
pymdown-extensions==10.0.1
Pympler==1.0.1
pyparsing==3.0.9
pyphen==0.14.0
pypng==0.20220715.0
pyrsistent==0.19.3
python-dateutil==2.8.2
pytz==2023.3
PyYAML==6.0
qrcode==7.4.2
requests==2.31.0
rich==13.3.5
six==1.16.0
smmap==5.0.0
soupsieve==2.4.1
st-annotated-text==4.0.0
stqdm==0.0.5
streamlit==1.22.0
streamlit-camera-input-live==0.2.0
streamlit-card==0.0.4
streamlit-embedcode==0.1.2
streamlit-extras==0.2.7
streamlit-faker==0.0.2
streamlit-image-coordinates==0.1.3
streamlit-keyup==0.2.0
streamlit-lottie==0.0.3
streamlit-toggle-switch==1.0.2
streamlit-vertical-slider==1.0.2
tenacity==8.2.2
tinycss2==1.2.1
toml==0.10.2
toolz==0.12.0
tornado==6.3.2
tqdm==4.65.0
typing_extensions==4.6.0
tzdata==2023.3
tzlocal==5.0.1
urllib3==2.0.2
validators==0.20.0
watchdog==3.0.0
weasyprint==59.0
webencodings==0.5.1
yarl==1.9.2
zipp==3.15.0
zopfli==0.2.2
- Quando terminar de trabalhar no projeto, você pode desativar o ambiente virtual com o seguinte comando:
deactivate
- Crie um arquivo
.env
na raiz do projeto com as variáveis de ambiente necessárias. Você pode usar o arquivo.env.example
como modelo.
cp .env.example .env
O código acima copiará o arquivo
.env.example
e o renomeará para.env
e você poderá preencher as variáveis de ambiente necessárias. Nota: O arquivo.env
é ignorado pelo Git, portanto, não será enviado para o repositório.
- Instale as dependências do projeto com o yarn na raiz do projeto:
yarn add
-
Certifique-se de que o Docker e o Docker Compose estejam instalados em seu sistema. Se você ainda não os instalou, siga as instruções de instalação no site oficial do Docker:
https://docs.docker.com/get-docker/
ehttps://docs.docker.com/compose/install/
-
Abra um terminal e navegue até o diretório raiz do projeto
data
. -
Execute o seguinte comando para criar e iniciar os containers do projeto, conforme definido no arquivo
docker-compose.yml
:
docker build -t big_data_app_estacio .
docker run -p 8501:8501 -e MYSQL_USER=user -e MYSQL_PASSWORD=user -e MYSQL_DATABASE=big_data_app_estacio -e MYSQL_HOST=192.168.1.100 big_data_app_estacio
- Open
http://localhost:8501/
- ou
- acesse o app do docker e execute o container
Isso iniciará os serviços do Docker, a API, como o MySQL e o serviço de processamento de dados se necessário.
-
Abra os relatórios do Power BI na pasta
data_visualization/power_bi_reports/
para visualizar e analisar os dados processados. Se você não possui o Power BI Desktop, faça o download e instale-o a partir do site oficial:https://powerbi.microsoft.com/en-us/desktop/
-
Ao longo do desenvolvimento do projeto, você pode modificar e ajustar os arquivos na pasta
src/
conforme necessário para aprimorar a análise e o processamento dos dados.
Lembre-se de que, dependendo da configuração do projeto, algumas etapas podem variar ou exigir ações adicionais. Ajuste as etapas conforme necessário para se adequar às necessidades específicas do seu projeto.
- Quando terminar de usar o projeto, pare os serviços do Docker Compose pressionando
Ctrl+C
no terminal onde o Docker Compose está sendo executado. Para remover os contêineres e os volumes, execute:
docker-compose down --remove-orphans --volumes
-
Abra um terminal e navegue até o diretório raiz do projeto
data
. -
Execute o seguinte comando para executar o projeto na pasta
client
:
cd client
yarn run server:app
cd [client]
streamlit run app.py --server.address 0.0.0.0 --server.port <your port>
# http://0.0.0.0:[your port]
- Inicie o servidor da API:
node client/src/api/index.js
Já o arquivo api/app.py, é o arquivo principal da API, onde é feita a conexão com o banco de dados e a definição dos endpoints.
Ele é executado na porta 5000, e pode ser acessado em http://localhost:5000/
A demonstração do projeto pode ser acessada em https://pedacinho-do-ceu.herokuapp.com/
/
: Página inicial do projeto, onde é possível visualizar os dados processados e analisados./about
: Página com informações sobre o projeto e os desenvolvedores./data
: Página com informações sobre os dados utilizados no projeto./data-visualization
: Página com informações sobre a visualização dos dados./data-processing
: Página com informações sobre o processamento dos dados.
A API RESTful permite gerenciar os dados armazenados no banco de dados PostgreSQL. Para utilizar a API, você pode fazer requisições HTTP para os seguintes endpoints:
Nesse arquivo, se encontram os endpoints da API, que são:
GET /
: Lista todos os itens armazenados no banco de dados.GET /<id>
: Retorna os detalhes de um item específico com base no ID.POST /
: Adiciona um novo item ao banco de dados.PUT /<id>
: Atualiza os detalhes de um item específico com base no ID.DELETE /<id>
: Remove um item específico com base no ID.
@TODO: Adicionar mais detalhes sobre a API
> @Note: A API foi desenvolvida com o framework FastAPI, que é um framework web assíncrono de alto desempenho, fácil de aprender, rápido para codificar, pronto para produção. Ele é construído com base no Starlette e Pydantic.
o arquivo api/app.py
está configurado com os scripts de coleta de dados e processamento de dados, para que os dados sejam coletados e processados automaticamente quando a API for iniciada:
from flask import Flask
from routes.bebidas import bebidas_bp
from routes.clientes import clientes_bp
app = Flask(__name__)
app.register_blueprint(bebidas_bp)
app.register_blueprint(clientes_bp)
if __name__ == '__main__':
app.run(debug=True)
A API estará disponível na porta 5000.
- Abra o Power BI Desktop e carregue os relatórios na pasta
data_visualization/power_bi_reports
.
Execute os testes unitários e de integração usando o seguinte comando:
python -m unittest discover tests
Para depurar o projeto, você pode usar o depurador interativo do Python. Para isso, basta adicionar o seguinte código ao arquivo que você deseja depurar:
import pdb; pdb.set_trace()
Em seguida, execute o arquivo normalmente e o depurador interativo será iniciado quando o código atingir o ponto de interrupção.
Para adicionar logs ao projeto, você pode usar o módulo logging
do Python. Para isso, basta adicionar o seguinte código ao arquivo que você deseja depurar:
import logging
logging.basicConfig(level=logging.DEBUG)
como que fica o arquivo de log logs/app.log
Exemplo de arquivo de log
2023-04-25 00:31:31,719 - INFO - A aplicação foi encerrada com sucesso.
2023-04-25 00:33:49,546 - INFO - A aplicação foi encerrada com sucesso.
2023-04-25 00:34:44,584 - INFO - A aplicação foi encerrada com sucesso.
2023-04-25 00:34:46,857 - WARNING - DNS lookup failed for kafka:9092, exception was [Errno -2] Name or service not known. Is your advertised.listeners (called advertised.host.name before Kafka 9) correct and resolvable?
2023-04-25 00:34:46,859 - ERROR - DNS lookup failed for kafka:9092 (AddressFamily.AF_UNSPEC)
2023-04-25 00:34:46,860 - INFO - Probing node bootstrap-0 broker version
2023-04-25 00:34:47,912 - WARNING - DNS lookup failed for kafka:9092, exception was [Errno -2] Name or service not known. Is your advertised.listeners (called advertised.host.name before Kafka 9) correct and resolvable?
2023-04-25 00:34:47,915 - ERROR - DNS lookup failed for kafka:9092 (AddressFamily.AF_UNSPEC)
2023-04-25 00:36:12,026 - INFO - A aplicação foi encerrada com sucesso.
2023-04-25 09:37:32,931 - INFO - A aplicação foi encerrada com sucesso.
2023-04-25 09:38:27,387 - INFO - A aplicação foi encerrada com sucesso.
2023-04-25 09:38:29,541 - WARNING - DNS lookup failed for kafka:9092, exception was [Errno -2] Name or service not known. Is your advertised.listeners (called advertised.host.name before Kafka 9) correct and resolvable?
2023-04-25 09:38:29,542 - ERROR - DNS lookup failed for kafka:9092 (AddressFamily.AF_UNSPEC)
2023-04-25 09:38:29,542 - INFO - Probing node bootstrap-0 broker version
2023-04-25 09:38:30,582 - WARNING - DNS lookup failed for kafka:9092, exception was [Errno -2] Name or service not known. Is your advertised.listeners (called advertised.host.name before Kafka 9) correct and resolvable?
2023-04-25 09:38:30,582 - ERROR - DNS lookup failed for kafka:9092 (AddressFamily.AF_UNSPEC)
2023-04-25 09:39:43,938 - INFO - A aplicação foi encerrada com sucesso.
2023-04-25 09:39:44,780 - INFO - <BrokerConnection node_id=bootstrap-0 host=localhost:9092 <connecting> [IPv4 ('127.0.0.1', 9092)]>: connecting to localhost:9092 [('127.0.0.1', 9092) IPv4]
2023-04-25 09:39:44,780 - INFO - Probing node bootstrap-0 broker version
2023-04-25 09:39:44,781 - ERROR - Connect attempt to <BrokerConnection node_id=bootstrap-0 host=localhost:9092 <connecting> [IPv4 ('127.0.0.1', 9092)]> returned error 111. Disconnecting.
2023-04-25 09:39:44,782 - INFO - <BrokerConnection node_id=bootstrap-0 host=localhost:9092 <connecting> [IPv4 ('127.0.0.1', 9092)]>: Closing connection. KafkaConnectionError: 111 ECONNREFUSED
2023-04-25 09:39:44,827 - INFO - <BrokerConnection node_id=bootstrap-0 host=localhost:9092 <connecting> [IPv4 ('127.0.0.1', 9092)]>: connecting to localhost:9092 [('127.0.0.1', 9092) IPv4]
2023-04-25 09:39:44,828 - ERROR - Connect attempt to <BrokerConnection node_id=bootstrap-0 host=localhost:9092 <connecting> [IPv4 ('127.0.0.1', 9092)]> returned error 111. Disconnecting.
2023-04-25 09:39:44,828 - INFO - <BrokerConnection node_id=bootstrap-0 host=localhost:9092 <connecting> [IPv4 ('127.0.0.1', 9092)]>: Closing connection. KafkaConnectionError: 111 ECONNREFUSED
2023-04-25 09:41:52,885 - INFO - A aplicação foi encerrada com sucesso.
2023-04-25 09:41:53,647 - INFO - <BrokerConnection node_id=bootstrap-0 host=localhost:9092 <connecting> [IPv4 ('127.0.0.1', 9092)]>: connecting to localhost:9092 [('127.0.0.1', 9092) IPv4]
2023-04-25 09:41:53,648 - INFO - Probing node bootstrap-0 broker version
2023-04-25 09:41:53,649 - ERROR - Connect attempt to <BrokerConnection node_id=bootstrap-0 host=localhost:9092 <connecting> [IPv4 ('127.0.0.1', 9092)]> returned error 111. Disconnecting.
2023-04-25 09:41:53,649 - INFO - <BrokerConnection node_id=bootstrap-0 host=localhost:9092 <connecting> [IPv4 ('127.0.0.1', 9092)]>: Closing connection. KafkaConnectionError: 111 ECONNREFUSED
2023-04-25 09:41:53,693 - INFO - <BrokerConnection node_id=bootstrap-0 host=localhost:9092 <connecting> [IPv4 ('127.0.0.1', 9092)]>: connecting to localhost:9092 [('127.0.0.1', 9092) IPv4]
2023-04-25 09:41:53,694 - ERROR - Connect attempt to <BrokerConnection node_id=bootstrap-0 host=localhost:9092 <connecting> [IPv4 ('127.0.0.1', 9092)]> returned error 111. Disconnecting.
2023-04-25 09:41:53,694 - INFO - <BrokerConnection node_id=bootstrap-0 host=localhost:9092 <connecting> [IPv4 ('127.0.0.1', 9092)]>: Closing connection. KafkaConnectionError: 111 ECONNREFUSED
2023-04-25 09:42:12,859 - INFO - A aplicação foi encerrada com sucesso.
Para testar e interagir com a API, você pode usar o Insomnia REST Client, que é uma aplicação de desktop para gerenciar requisições HTTP e API.
- Instale o Insomnia em seu computador: Insomnia Download
- Abra o Insomnia e crie um novo workspace ou use um existente.
- Para adicionar as rotas da API ao seu workspace, clique em
Create Request
. Escolha o método HTTP (GET, POST, PUT, DELETE) e insira a URL da API (por exemplo,http://localhost:5000/
para listar todos os itens). Adicione os parâmetros, cabeçalhos ou corpo da requisição conforme necessário e clique emSend
para executar a requisição. - Você pode criar várias requisições para diferentes endpoints da API e organizá-las em pastas para facilitar a navegação.
Agora você pode usar o Insomnia para testar e explorar a API RESTful do projeto Pedacinho do Céu.
A versão atual do projeto inclui as seguintes funcionalidades:
- Coleta e armazenamento de dados em tempo real com Hadoop e Kafka.
- API RESTful para interagir com os dados e serviços.
- Docker Compose para facilitar a instalação e configuração do projeto.
Os dados podem ser coletados usando o script data_collection/data_collector.py
. Para coletar os dados, você pode executar o seguinte comando:
python data_collection/data_collector.py
Os dados coletados serão armazenados em arquivos no diretório data_collection/data
.
Os dados podem ser processados usando o script data_processing/data_processor.py
. Para processar os dados, você pode executar o seguinte comando:
python data_processing/data_processor.py
Os dados processados serão armazenados no banco de dados PostgreSQL.
Os dados podem ser visualizados usando relatórios do Power BI. Para visualizar os relatórios, você pode fazer o download do Power BI Desktop aqui. Após instalar o Power BI Desktop, você pode abrir o arquivo data.pbix
para visualizar os relatórios.
- Melhoria na coleta de dados
- Implementação de novas análises e visualizações
- Adição de mais testes
- Melhoria na documentação
O projeto "Pedacinho do Céu" está em constante evolução e melhorias. Abaixo estão algumas das atualizações futuras planejadas para o projeto:
-
Expansão das fontes de dados: Atualmente, o projeto utiliza um conjunto limitado de fontes de dados. No futuro, pretendemos expandir a lista de fontes de dados para enriquecer ainda mais nossas análises e visualizações.
-
Otimização do processamento de Big Data: Continuaremos a melhorar a eficiência e a velocidade do processamento de Big Data usando técnicas de otimização avançadas e atualizações nas ferramentas e tecnologias utilizadas.
-
Visualizações interativas: Atualmente, o projeto utiliza relatórios estáticos do Power BI. Planejamos adicionar visualizações interativas e em tempo real para tornar os dados mais acessíveis e fáceis de entender.
-
Machine Learning: Exploraremos a implementação de algoritmos de aprendizado de máquina para identificar padrões e tendências nos dados e fornecer insights adicionais.
-
Integração com outras plataformas: Planejamos adicionar suporte para integração com outras plataformas de visualização de dados e análise, como Tableau e Looker.
-
APIs e microserviços: Atualmente, o projeto possui uma API simples para acessar os dados. No futuro, pretendemos expandir a API e usar microserviços para fornecer uma solução mais modular e escalonável.
-
Segurança e privacidade: Continuaremos a aprimorar a segurança e a privacidade dos dados, garantindo a conformidade com os regulamentos de proteção de dados e as melhores práticas do setor.
-
Documentação e tutoriais: A documentação e os tutoriais serão atualizados regularmente para garantir que sejam claros, abrangentes e atualizados com as últimas informações do projeto.
O projeto é executado em contêineres Docker para facilitar a implantação e a escalabilidade.
Os princípios SOLID foram aplicados neste projeto para garantir um código limpo, modular e fácil de manter.
Ao fazer um commit, siga as diretrizes de mensagens de commit personalizadas e com emojis, utilizando até 200 caracteres.
- Adicionar suporte ao Travis CI para integração contínua.
- Aplicar os princípios SOLID ao projeto para melhorar a manutenibilidade e escalabilidade.
- Atualizar o SQLAlchemy para usar um banco de dados mais robusto, como PostgreSQL ou MySQL, em vez de SQLite.
- Implementar autenticação e autorização para proteger as rotas da API.
- Adicionar testes automatizados para garantir a qualidade do código.
- Implementar uma interface de usuário para interagir com a API.
- Para adicionar suporte ao Travis CI, siga estas etapas:
- Vá para
travis-ci.com
e faça login com sua conta do GitHub. - Ative o repositório do projeto nas configurações do Travis CI.
- Crie um arquivo
.travis.yml
na raiz do projeto com o seguinte conteúdo:
language: python
python:
- "3.8"
install:
- pip install -r api/requirements.txt
script:
- pytest
- Vincule seu repositório do GitHub ao Travis CI e habilite a integração contínua para o projeto.
Para aplicar os princípios SOLID ao projeto, siga estas diretrizes:
-
Single Responsibility Principle (SRP): Separe as responsabilidades do código em classes e funções distintas. Por exemplo, separe a lógica de negócio da lógica de banco de dados.
-
Open/Closed Principle (OCP): Crie classes e funções extensíveis sem modificar seu código-fonte. Por exemplo, use a herança e a composição para estender a funcionalidade de uma classe.
-
Liskov Substitution Principle (LSP): As subclasses devem ser substituíveis por suas classes base sem alterar a correção do programa. Por exemplo, verifique se as subclasses seguem o contrato estabelecido pelas classes base.
-
Interface Segregation Principle (ISP): Divida as interfaces grandes em interfaces menores e mais específicas. Por exemplo, crie interfaces separadas para operações de leitura e gravação em vez de uma interface única.
-
Dependency Inversion Principle (DIP): Dependências de alto nível não devem depender de dependências de baixo nível; em vez disso, ambas devem depender de abstrações. Por exemplo, use a injeção de dependência para inverter as dependências entre os módulos.
Para usar o PostgreSQL ou MySQL com SQLAlchemy, siga estas etapas:
- Instale os pacotes necessários:
pip install psycopg2 sqlalchemy psycopg2-binary
OU
pip install pymysql sqlalchemy
- Atualize a string de conexão do banco de dados no arquivo api/database.py para usar PostgreSQL ou MySQL:
Para PostgreSQL:
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
DATABASE_URL = "postgresql://user:password@localhost/dbname"
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
Para MySQL:
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
DATABASE_URL = "mysql+pymysql://user:password@localhost/dbname"
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
- Atualize as configurações do banco de dados em
api/__init__.py
para usar a nova string de conexão.
Para implementar a autenticação e autorização, você pode usar a extensão Flask-Login ou Flask-Security. Siga a documentação oficial de cada extensão para configurar a autenticação e autorização no projeto.
Para adicionar testes automatizados, siga estas etapas:
- Instale o pacote pytest:
pip install pytest
-
Crie um diretório
tests
na raiz do projeto. -
Dentro do diretório
tests
, crie arquivos de teste para cada módulo do projeto. Por exemplo, você pode criar um arquivotest_restaurant_service.py
para testar a classe RestaurantService. -
Escreva testes usando o pytest para cada função e classe do projeto.
-
Execute os testes usando o comando
pytest
no terminal.
Para implementar uma interface de usuário, você pode criar uma aplicação web usando HTML, CSS e JavaScript para interagir com a API. Você pode usar bibliotecas como React, Angular ou Vue.js para criar a interface do usuário.
- Implementar autenticação e autorização na API.
- Adicionar suporte para diferentes formatos de dados (JSON, XML, etc.).
- Desenvolver uma interface gráfica para visualizar os dados e interagir com a API.
- Adicionar suporte para processamento de dados em tempo real usando Apache Spark ou Flink.
- Implementar algoritmos de machine learning para análise de dados e geração de insights.
- Integrar com outras fontes de dados e APIs de terceiros.
- Adicionar suporte para escalabilidade horizontal e balanceamento de carga.
- Implementar monitoramento e alertas para garantir a saúde e o desempenho do sistema.
- Desenvolver testes de carga e estresse para garantir a estabilidade do projeto em ambientes de produção.
- Redesenhar a arquitetura do projeto para melhorar a modularidade e a manutenibilidade.
- Adicionar suporte para outras linguagens de programação e frameworks.
- Implementar uma API GraphQL para maior flexibilidade na consulta e manipulação de dados.
✨🎉 Este repositório explica sobre o Apache Spark com práticas 🎉✨
- É uma ferramenta de processamento em tempo real desenvolvida para resolver o problema de trabalhar com dados em tempo real.
- É tratado pelo Apache.
- É muito rápido, dá resultado no clique.
- Usa avaliação preguiçosa, ou seja, processa sempre que necessário.
- Como o MapReduce não conseguiu lidar com dados em tempo real, o Spark entrou em cena para ajudar.
- Agora é usado por muitos grandes gigantes da tecnologia como Oracle, Amazon, Microsoft, Visa, Cisco, Verizon, Hortonworks.
- Como acima, temos 3.000 empresas usando o Apache Spark.
Para iniciar o cluster Spark a partir da máquina local com o Linux, você precisa seguir os seguintes passos:
Instalação e Execução do Apache Spark no Ubuntu/Debian/Linux Mint/Pop!_OS/Elementary OS/Linux Lite/Peppermint OS/Windows 10 com WSL
Este guia tem como objetivo fornecer os passos necessários para a instalação e execução do Apache Spark em um ambiente Linux. O Apache Spark é um sistema de computação distribuída que permite processar grandes volumes de dados em um cluster de computadores. Ele é amplamente utilizado para análise de big data, machine learning, processamento de stream e outras aplicações de processamento paralelo.
Antes de começar a instalar o Apache Spark, certifique-se de que o seu sistema atenda aos seguintes requisitos:
- Linux (Ubuntu ou outra distribuição)
- Java 8 ou superior
- Python 2.7 ou 3.x
- Acesso à Internet
- Um sistema operacional Debian ou seus derivados.
- Acesso à linha ou terminal de comando.
- Um usuário com permissões sudo ou ** root**.
Antes de baixar e configurar o Spark, precisamos instalar dependências. Essas etapas incluem a instalação da seguinte parcela.
- JDK
- Scala
- Git
Certifique-se de que o Java esteja instalado em sua máquina.
- Instale o Java 8 caso não esteja instalado:
Abra o terminal e execute o seguinte comando: sudo apt update && sudo apt install openjdk-8-jdk
- Verifique a versão do Python instalada:
python --version
- Instale o Python 3.7 ou superior caso não esteja instalado:
sudo apt update
sudo apt install python3
Antes de começar a instalar o Apache Spark, verifique se o Java está instalado em sua máquina. O Apache Spark requer que o Java esteja instalado.
Para verificar a versão do Java em sua máquina, execute o seguinte comando em seu terminal:
java -version
Se o Java não estiver instalado, siga as instruções no site oficial da Oracle para baixar e instalar o Java.
-
Abra o terminal e execute o seguinte comando para instalar o Apache Spark:
sql
sudo apt update sudo apt install spark
Agora, precisamos baixar a versão do Spark que você deseja e ela está disponível no site oficial. No momento da edição deste texto, a versão mais atualizada é Spark 3.2.1 ( Enero-26-2022 ) junto com o pacote Hadoop 3.2.
Usamos o comando ** wget ** junto com o link do site para baixar nosso arquivo Spark:
https://www.apache.org/dyn/closer.lua/spark/spark-3.4.0/spark-3.4.0-bin-hadoop3.tgz
**Nota: ** Se o URL não for executado, vá para a página oficial [ Apache Spark ] ( https://spark.apache.org/) e procure a versão mais recente no menu de download ( ). Em outras palavras, você também pode tentar substituir as versões da liga que estou compartilhando com você.
- logo em seguida baixe na raiz do projeto o arquivo spark-3.4.0-bin-hadoop3.tgz
- mova o arquivo para a pasta /opt:
sudo mv spark-3.4.0-bin-hadoop3.tgz /opt
- acessar a pasta /opt:
cd /opt
- descompactar o arquivo:
sudo tar -xvzf spark-3.4.0-bin-hadoop3.tgz
- acessar a pasta spark-3.4.0-bin-hadoop3:
cd spark-3.4.0-bin-hadoop3
- configurar as variáveis de ambiente:
sudo nano /etc/profile
Antes de inicializar o servidor mestre, precisamos configurar as variáveis de ambiente. Esses são frequentemente caminhos ( ) no Spark que precisamos adicionar ao perfil do usuário.
Também podemos adicionar as rotas de exportação editando o arquivo .profile no editor escolhido, como nano ou vim.
Por exemplo, para o nano editor, inserimos:
nano ~ / .profile
Ao carregar o perfil, colocamos no final do arquivo:
Então, adicionamos as duas linhas a seguir no final do arquivo:
export SPARK_HOME=/opt/spark-3.4.0-bin-hadoop3
export PATH=$PATH:$SPARK_HOME/bin:$SPARK_HOME/sbin
- salvar o arquivo e sair do editor de texto com os seguntes comandos:
CTRL + s
CTRL + x
- Execute o comando abaixo para atualizar as variáveis de ambiente:
bash -n ~/.bashrc
- Verifique se o Apache Spark foi instalado corretamente:
spark-submit --version
Caso ocorra esse erro:
Traceback (most recent call last):
File "/home/estevam/micromamba/bin/find_spark_home.py", line 95, in <module>
print(_find_spark_home())
File "/home/estevam/micromamba/bin/find_spark_home.py", line 59, in _find_spark_home
module_home = os.path.dirname(find_spec("pyspark").origin)
AttributeError: 'NoneType' object has no attribute 'origin'
/home/estevam/micromamba/bin/spark-submit: line 27: /bin/spark-class: No such file or directory
Esse erro indica que o PySpark não foi instalado corretamente ou não foi encontrado no sistema.
Verifique se você seguiu todas as etapas corretamente durante a instalação e se adicionou as variáveis de ambiente corretamente.
Você pode tentar reinstalar o PySpark usando o comando pip install pyspark ou verifique se o caminho para o Spark Home está correto e atualizado nas variáveis de ambiente.
Agora poderá usar novamente o comando
spark-submit --version
e logo aparecerá isso no terminal:
23/05/02 18:52:38 WARN Utils: Your hostname, estevam resolves to a loopback address: 127.0.1.1; using 172.20.231.90 instead (on interface eth0)
23/05/02 18:52:38 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address
Welcome to
____ __
/ __/__ ___ _____/ /__
_\ \/ _ \/ _ `/ __/ '_/
/___/ .__/\_,_/_/ /_/\_\ version 3.4.0
/_/
Using Scala version 2.12.17, OpenJDK 64-Bit Server VM, 11.0.18
Branch HEAD
Compiled by user xinrong.meng on 2023-04-07T02:18:01Z
Revision 87a5442f7ed96b11051d8a9333476d080054e5a0
Url https://github.com/apache/spark
Type --help for more information.
rode agora o
pyspark
no terminal e verá essa informação:
Python 3.9.16 | packaged by conda-forge | (main, Feb 1 2023, 21:39:03)
[GCC 11.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
23/05/02 18:50:48 WARN Utils: Your hostname, estevam resolves to a loopback address: 127.0.1.1; using 172.20.231.90 instead (on interface eth0)
23/05/02 18:50:48 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
23/05/02 18:50:51 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable
Welcome to
____ __
/ __/__ ___ _____/ /__
_\ \/ _ \/ _ `/ __/ '_/
/__ / .__/\_,_/_/ /_/\_\ version 3.4.0
/_/
Using Python version 3.9.16 (main, Feb 1 2023 21:39:03)
Spark context Web UI available at http://172.20.231.90:4040
Spark context available as 'sc' (master = local[*], app id = local-1683064253636).
SparkSession available as 'spark'.
>>>
Agora que o PySpark está rodando corretamente no seu ambiente, você pode seguir as etapas do roadmap que você criou anteriormente para executar o seu projeto.
Você pode, por exemplo, utilizar as funções que você criou anteriormente para ler os arquivos estoque_mercadorias.csv e total_clientes.csv, realizar transformações e análises nos dados utilizando o PySpark e gerar os gráficos utilizando o Altair.
Lembre-se de ajustar as funções para que elas utilizem o PySpark ao invés do Pandas para processar os dados. Isso pode envolver a utilização de operações específicas do PySpark como o groupBy e o agg.
Agora que concluímos as configurações do ambiente Spark, podemos inicializar o servidor mestre.
No terminal, escrevemos:
sudo /opt/spark-3.4.0-bin-hadoop3/sbin/start-master.sh
- acessar o endereço http://localhost:8080/ para verificar se o servidor está funcionando
Para visualizar a interface da web Spark, abrimos um navegador da web e inserimos o endereço IP do host local na porta 8080.
http://127.0.0.1:8080/
ou http://localhost:8080/
- OBS: caso o servidor não esteja funcionando, verifique se a porta 8080 está liberada no firewall
A página mostra seu ** URL Spark **, informações sobre o status do trabalhador ( trabalhadores ), recursos de hardware usados etc.
O URL do Master Spark é o nome do seu dispositivo na porta 8080. No meu caso, é _ ** debian.gabi: 8080 ** _. Então, aqui temos três maneiras possíveis de carregar a UI Spark Master Web:
- 127.0.0.1: 8080
- localhost: 8080
- nome do dispositivo: 8080
Nesta configuração autônoma de um único servidor, inicializaremos um servidor em funcionamento junto com o servidor mestre.
Para isso, executamos o seguinte comando neste formato:
start-slave.sh spark: // master: port
O ** master ** neste comando pode ser um IP ou um nome de host.
No meu caso, é ** debian.gabi:**
start-slave.sh spark://estevam.localdomain:7077
Agora que o trabalhador ou slave está carregado e funcionando, se recarregarmos a interface do usuário da Web do Spark Master, você deverá vê-la na lista:
A configuração padrão quando inicializamos um trabalhador em uma máquina é a disponível por todos os núcleos da CPU. Você pode especificar o número de núcleos que passam pelos sinalizadores ** -c ** para o comando ** start-slave**.
start-slave.sh -c 1 spark: //estevam.localdomain:7077
Recarregamos a interface do usuário da Web do Spark Master para confirmar as configurações do trabalhador.
Da mesma forma, podemos alocar a quantidade específica de memória quando inicializamos o trabalhador. A configuração padrão é a quantidade de memória RAM usada pela máquina menos 1 GB.
Ao iniciar um trabalhador e atribuir a ele uma quantidade específica de memória, adicionamos a opção ** -m ** e o número. Para gigabytes, usamos ** G ** e para megabytes, usamos ** M.**
Por exemplo, para iniciar um trabalhador com 512 MB de memória, inserimos o seguinte comando:
start-slave.sh -m 512MB spark://estevam.localdomain:7077
Recarregue a interface do usuário da Web do Spark Master para visualizar o status do trabalhador e confirmar as configurações
Depois de concluirmos a configuração e inicialização do servidor mestre e slave, testamos se o shell Spark funciona.
Carregamos o shell digitando:
spark-shell
Você precisará obter uma notificação na tela e a descrição do Spark. Por padrão, a interface é Scala e carrega o shell quando você executa spark-shell.
No final da saída, a imagem aparecerá com a versão usada ao escrever este guia:
Se você não quiser usar a interface Scala por padrão, poderá usar o Python.
Certifique-se de sair do Scala e, em seguida, inserimos o seguinte comando:
pyspark
A saída resultante é semelhante à anterior. Na parte inferior, você verá a versão Python.
Para sair deste shell, digite exit( ) e pressione Enter.
Comandos básicos para iniciar e parar o servidor Master e Escalavos ( Servidor mestre e de trabalhadores )
Você encontrará imediatamente os comandos básicos para iniciar e parar o servidor mestre e slave do Apache Spark. Essa confiducração é para uma única máquina, os scripts são executados por padrão no host local.
Para iniciar uma instância do servidor mestre na máquina atual, executamos o comando que já tínhamos usado:
start-master.sh
Para interromper a instância mestre, começamos executando o próximo script, executamos:
stop-master.sh
Para parar um slave que está em execução, inserimos o seguinte comando:
stop-slave.sh
Na UI Spark Master Web, você será exibido no campo 'status' do Worker Id como MORTO.
Você pode iniciar instâncias mestre e slave usando o comando start-all:
start-all.sh
Agora que você iniciou o serviço do Apache Spark, você pode utilizar suas funcionalidades em seu projeto. Para fazer isso, você precisa primeiro iniciar o SparkSession em seu código Python. O SparkSession é o ponto de entrada para o Spark e fornece a interface para trabalhar com os dados no Spark.
Para iniciar o SparkSession em seu código Python, você pode usar o seguinte código:
import findspark
findspark.init()
from pyspark.sql import SparkSession
# Aqui, substitua "local" pelo endereço do seu gerenciador de cluster.
# Por exemplo, se você estiver usando o gerenciador de cluster autônomo do Spark, poderia ser algo como "spark://master:7077"
spark = SparkSession.builder \
.master("spark://estevam.localdomain:7077") \
.appName("big-data") \
.getOrCreate()
O appName define o nome da sua aplicação e o master define o modo de execução do Spark. No exemplo acima, estamos usando local[] para executar o Spark no modo local. Você pode substituir local[] pelo endereço do servidor do Spark se você estiver executando o Spark em um cluster.
Com o SparkSession criado, você pode utilizar todas as funcionalidades do Spark, como ler e escrever dados de e para diferentes fontes de dados, realizar transformações e operações em larga escala em seus dados, etc. Por exemplo, para ler um arquivo CSV e criar um DataFrame com os dados, você pode usar o seguinte código:
df = spark.read \
.option("header", True) \
.option("inferSchema", True) \
.csv("/caminho/para/o/arquivo.csv")
df.show()
Neste exemplo, estamos lendo um arquivo CSV que tem um cabeçalho e o Spark vai inferir o esquema dos dados. Você pode modificar as opções de leitura de acordo com suas necessidades.
- iniciar um ou mais workers Spark executando o seguinte comando:
A saída sugere que o comando sudo /opt/spark-3.4.0-bin-hadoop3/sbin/start-slave.sh spark://estevam.localdomain:7077
está obsoleto e você deve usar start-worker.sh
em seu lugar.
Além disso, a saída também sugere que já existe um trabalhador em execução como processo 2110 e você precisa interrompê-lo antes de iniciar um novo. Você pode interromper o worker executando o seguinte comando:
sudo /opt/spark-3.4.0-bin-hadoop3/sbin/stop-worker.sh
Depois que o worker anterior for interrompido, você poderá iniciar um novo worker usando o seguinte comando:
sudo /opt/spark-3.4.0-bin-hadoop3/sbin/start-worker.sh spark://estevam.localdomain:7077
Observe que pode ser necessário inserir sua senha após executar o comando ssudo
.
Isso inicia um worker Spark que se conecta ao mestre Spark no endereço spark://estevam.localdomain:7077. Você pode substituir spark://estevam.localdomain:7077 pelo endereço do servidor Spark se você estiver executando o Spark em um cluster. Você pode iniciar vários workers Spark executando o comando acima várias vezes.
- No seu projeto Python, importe as bibliotecas do PySpark e crie uma sessão Spark:
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("myApp").getOrCreate()
Em seguida, crie as funções que usam os serviços do Spark para realizar as tarefas desejadas. Por exemplo, se você quiser ler um arquivo CSV em um DataFrame do Spark, pode usar a seguinte função:
def read_csv_file(file_path):
df = spark.read.format("csv").option("header", "true").load(file_path)
return df
df = read_csv_file("/path/to/file.csv")
df.show()
Por fim, execute seu aplicativo Streamlit a partir do terminal com o comando:
streamlit run app.py
Depois de executar o comando streamlit run app.py e ter iniciado a aplicação Streamlit, você pode interagir com a interface do seu aplicativo no navegador. A partir daí, é possível utilizar as funcionalidades e algoritmos implementados no seu projeto que utilizam o Apache Spark como processador de dados. Por exemplo, se o seu aplicativo utiliza o Spark para processar dados de um conjunto de dados, você pode carregar esse conjunto de dados na interface e executar as operações definidas pelo seu algoritmo para processá-los. É importante lembrar que o Apache Spark funciona como um motor de processamento de dados distribuído, o que significa que ele é capaz de processar grandes conjuntos de dados de forma eficiente, o que pode ser particularmente útil em projetos que lidam com dados em escala.
-
Ou
pode optar por seguir as seguintes instruções: -
iniciar o worker:
sudo /opt/spark-3.4.0-bin-hadoop3/sbin/start-slave.sh spark://localhost:7077
- atualizar as variáveis de ambiente:
source /etc/profile
- acessar a pasta spark-3.4.0-bin-hadoop3:
cd spark-3.4.0-bin-hadoop3
- iniciar o master Spark no seu computador local:
./sbin/start-master.sh
-
pronto, o servidor apache spark está funcionando
-
para parar o master Spark e todos os workers, execute o seguinte comando:
./sbin/stop-all.sh
- Para iniciar o Apache Spark em um cluster com o Docker, você precisa ter o Docker instalado em seu sistema. Você pode verificar se o Docker está instalado em seu sistema executando o seguinte comando:
docker --version
- Se o Docker estiver instalado em seu sistema, você verá a versão do Docker instalada em seu sistema. Caso contrário, você pode instalar o Docker em seu sistema seguindo as instruções em https://docs.docker.com/engine/install/.
Agora o próximo passo é entrar na pasta onde o arquivo docker-compose.yml está localizado e executar o seguinte comando:
cd backend/admin/apache/pyspark_docker/
Logo depois é seguir os passos abaixo
Se você simplesmente deseja testar um cluster de spark de nó único, basta executar docker run -it wlongxiang/pyspark-2.4.4 pyspark
, isso trará seu shell de spark.
Ou você também pode criar um cluster muti-worker com um arquivo de composição simples, o exemplo montará os diretórios locais data
e code
para o cluster worker e master de forma que você possa alterar facilmente seu código e dados localmente e testá-los dentro do cluster do docker.
- Check-out do branch master
- Execute
docker-compose up
para ativar 2 workers e 1 master (ou você também pode definir COMPOSE_FILE env para um arquivo diff. compose) - Acesse http://localhost:8080 para ver a interface do usuário do Spark Master
- Execute
docker exec -it pyspark_docker_master_1 bash
para shell no contêiner de spark - contagem de palavras:
spark-submit /code/wordcount.py /data/logs.txt
Versões de spark suportadas: 2.4.4.
Alguns exemplos para testar, veja o diretório code
.
- primeiro você faz
docker login
com suas credenciais para docker-hub - então
docker build -t wlongxiang/pyspark-2.4.4:<version_tag> .
, este comando irá construir seu e-mail com o nome pyspark e marcar com 2.4.4 - verifique se sua imagem foi criada com sucesso por
docker images
- finalmente
docker push wlongxiang/pyspark-2.4.4:<version_tag>
, no final isso estará disponível em seu repositório docker - agora, tudo deve ser capaz de executar sua imagem ou usá-la no arquivo docker-compose, como
docker run -it pyspark-2.4.4:<version_tag> bash
Com isso, você já está pronto para instalar e executar o Apache Spark em seu sistema. Lembre-se de sempre verificar a documentação oficial do Apache Spark em https://spark.apache.org/docs/latest/ para informações mais detalhadas.
Caso for enviar as alterações feitas com o arquivo spark-3.2.1-bin-hadoop2.7.tgz, não esqueça de deletar o arquivo do diretório antes de enviar, ou posso usar os comandos:
git lfs install
git lfs track "venv/lib/python3.9/site-packages/pyspark/jars/rocksdbjni-7.9.2.jar"
git lfs track "backend/spark-3.2.4-bin-hadoop3.2.tgz"
- caso ocorra esse erro:
git lfs install
git lfs track "venv/lib/python3.9/site-packages/pyspark/jars/rocksdbjni-7.9.2.jar"
git lfs track "backend/spark-3.2.4-bin-hadoop3.2.tgz"
git: 'lfs' is not a git command. See 'git --help'.
The most similar command is
lsfn
git: 'lfs' is not a git command. See 'git --help'.
The most similar command is
lsfn
git: 'lfs' is not a git command. See 'git --help'.
The most similar command is
lsfn
- execute o comando no linux:
sudo apt-get install git-lfs
Em seguida, execute novamente os comandos para rastrear os arquivos grandes e fazer o commit e push novamente.
git lfs install
git lfs track "venv/lib/python3.9/site-packages/pyspark/jars/rocksdbjni-7.9.2.jar"
git lfs track "backend/spark-3.2.4-bin-hadoop3.2.tgz"
git add .gitattributes
git add .
git commit -m "Commit message"
git push
Certifique-se de também confirmar o seu email e o nome de usuário do git com o comando git config --global user.email "you@example.com"
e git config --global user.name "Your Name"
.
- Python
- Escala
- Copie o código do respectivo script e cole-o no shell Spark correspondente para executar o código.
- Abra o terminal (no ambiente Linux)/Command Propmpt (Windows).
- Execute "python .py"
Com base nas informações fornecidas até agora, o projeto está usando as seguintes tecnologias e técnicas:
Apache Hadoop e Apache Spark
como ferramentas de Big DataIntegração com Python
para executar scripts e processar dados usando o SparkFlask
para criar uma API RESTful
De acordo com os critérios do professor, esse projeto estaria atendendo aos seguintes pontos:
- Usando alguma ferramenta de Big Data com Python (+++): O projeto está usando o Apache Hadoop e o Apache Spark, que são ferramentas de Big Data, e está integrando-as com Python para executar scripts e processar dados.
Como resultado, o projeto deve passar na matéria com uma nota alta, pois está utilizando ferramentas de Big Data e integrando-as com Python, o que é o critério de maior pontuação (+++).
Além disso, o projeto também utiliza outras tecnologias e práticas relevantes, como o Flask para criar uma API RESTful e o SQLAlchemy como um ORM para lidar com as operações de banco de dados. Esses aspectos podem não ser mencionados diretamente nos critérios de avaliação do professor, mas certamente agregam valor ao projeto e demonstram a capacidade de trabalhar com várias tecnologias e bibliotecas em Python.
Em resumo, o projeto atende ao critério de maior pontuação, utilizando ferramentas de Big Data e integrando-as com Python. Isso deve resultar em uma avaliação positiva para a matéria.
O Apache Spark é uma ferramenta de Big Data que pode ser usada para processar grandes conjuntos de dados. Ele pode ser usado com o Apache Hadoop, que é um framework de software que permite o processamento distribuído de grandes conjuntos de dados em clusters de computadores usando modelos de programação simples. O Hadoop é usado para armazenar e processar grandes conjuntos de dados em um ambiente distribuído, enquanto o Spark é usado para processar esses dados.
O Apache Spark pode ser usado com o Apache Hadoop para processar grandes conjuntos de dados. O Hadoop é usado para armazenar e processar grandes conjuntos de dados em um ambiente distribuído, enquanto o Spark é usado para processar esses dados.
- 1. Instalar e configurar o Apache Spark e o Hadoop
Antes de começar a usar o Apache Spark com o Hadoop em seu projeto, você precisa instalar e configurar ambos em seu sistema.
1.1. Instalar o Apache Spark
Você pode baixar a versão mais recente do Apache Spark no site oficial do projeto: https://spark.apache.org/downloads.html. Certifique-se de escolher a versão que é compatível com a versão do Hadoop que você pretende usar.
Depois de baixar o arquivo tar do Apache Spark, extraia-o para a pasta de sua escolha usando o comando tar -xvf spark-<versão>-bin-hadoop<versão>.tgz
.
1.2. Instalar o Hadoop Você pode baixar a versão mais recente do Hadoop no site oficial do projeto: https://hadoop.apache.org/releases.html. Certifique-se de escolher a versão que é compatível com a versão do Apache Spark que você pretende usar.
Depois de baixar o arquivo tar do Hadoop, extraia-o para a pasta de sua escolha usando o comando tar -xvf hadoop-<versão>.tar.gz
.
1.3. Configurar as variáveis de ambiente
Para usar o Apache Spark e o Hadoop em seu projeto, você precisa configurar as variáveis de ambiente em seu sistema. Você pode fazer isso adicionando as seguintes linhas ao seu arquivo ~/.bashrc
:
export SPARK_HOME=/caminho/para/o/apache/spark
export HADOOP_HOME=/caminho/para/o/hadoop
export PATH=$SPARK_HOME/bin:$HADOOP_HOME/bin:$PATH
Certifique-se de substituir /caminho/para/o/apache/spark
e /caminho/para/o/hadoop
pelos caminhos corretos em seu sistema.
- Usando o Hadoop com o Apache Spark
Para usar o Hadoop com o Apache Spark, basta definir a variável de ambiente HADOOP_CONF_DIR para apontar para a pasta de configuração do Hadoop em seu sistema. Você pode fazer isso adicionando a seguinte linha ao seu arquivo ~/.bashrc:
export HADOOP_CONF_DIR=/caminho/para/a/pasta/de/configuração/do/hadoop
Certifique-se de substituir /caminho/para/a/pasta/de/configuração/do/hadoop
pelo caminho correto no sistema.
Com a variável de ambiente HADOOP_CONF_DIR
definida corretamente, o Apache Spark usará a configuração apropriada do Hadoop para executar suas tarefas. Você pode usar o Apache Spark com o Hadoop em seu aplicativo Streamlit como faria normalmente.
Para contribuir com este projeto, siga estas etapas:
- Faça um fork do repositório.
- Crie um branch com suas alterações (
git checkout -b my-feature
). - Faça commit das suas alterações (
git commit -m 'Add some feature'
). - Faça push para o branch (
git push origin my-feature
). - Crie uma nova Pull Request.
Agradecemos às seguintes pessoas que contribuíram para este projeto:
Para fazer o deploy do WebApp na streamlit.io, siga estas etapas:
Deploy do WebApp na streamlit.io (clique para expandir)
- Requisitos de sistema: Verificar se você possui os requisitos mínimos de sistema para executar a Streamlit.io localmente ou se precisa usar um servidor externo.
- Instalação do Streamlit: Instalar o Streamlit em seu ambiente local ou servidor externo seguindo as instruções do guia de instalação do Streamlit.
- Configuração do ambiente: Configurar um ambiente virtual para o seu projeto usando uma ferramenta como o virtualenv ou o conda.
- Criação do WebApp: Desenvolver o WebApp usando a biblioteca Streamlit e qualquer outro pacote ou biblioteca necessário para o seu projeto.
- Testes locais: Executar testes locais para garantir que o WebApp esteja funcionando corretamente em seu ambiente local.
- Criação do repositório: Criar um repositório Git para o seu projeto em uma plataforma como o GitHub ou o GitLab.
- Estrutura do projeto: Organizar o projeto em uma estrutura de diretórios adequada, incluindo um arquivo
requirements.txt
para listar todas as dependências do projeto.
- Configuração do ambiente na Streamlit.io: Criar uma conta na Streamlit.io e configurar um novo projeto/aplicativo na plataforma.
- Conexão ao repositório: Conectar o seu repositório Git à Streamlit.io para que ele possa acessar o código do seu projeto.
- Configuração de variáveis de ambiente: Configurar as variáveis de ambiente necessárias para o seu projeto, como chaves de API, informações de banco de dados, etc.
- Configuração de build e deploy: Configurar as opções de build e deploy na Streamlit.io, como definir o comando de build e a pasta de implantação.
- Iniciar o deploy: Iniciar o processo de deploy na Streamlit.io e aguardar a conclusão.
- Teste do WebApp implantado: Testar o WebApp implantado para garantir que ele esteja funcionando corretamente na Streamlit.io.
- Monitoramento contínuo: Configurar ferramentas de monitoramento para acompanhar o desempenho do seu WebApp e detectar quaisquer problemas ou erros.
- Atualizações contínuas: Realizar atualizações e melhorias no seu WebApp conforme necessário, fazendo o push das alterações para o repositório conectado à Streamlit.io.
- Gerenciamento de dependências: Gerenciar as dependências do projeto, atualizando o arquivo
requirements.txt
conforme novos pacotes forem adicionados ou atualizados. - Testes e deploy contínuos: Automatizar o processo de testes e deploy, utilizando ferramentas de integração contínua, como o GitHub Actions ou o GitLab CI/CD, para garantir que as atualizações sejam testadas e implantadas de forma contínua.
- Gerenciamento de tráfego: Implementar estratégias de gerenciamento de tráfego, como balanceamento de carga, para lidar com um maior número de usuários e garantir a escalabilidade do seu WebApp.
- Otimização de desempenho: Identificar e otimizar partes do seu WebApp que possam estar causando lentidão ou gargalos de desempenho.
- Otimização de recursos: Avaliar o uso de recursos do seu WebApp e fazer ajustes para otimizar o consumo de CPU, memória e outros recursos.
- Monitoramento de desempenho: Continuar monitorando o desempenho do seu WebApp para identificar quaisquer problemas ou gargalos e tomar as medidas corretivas necessárias.
- Atualizações de segurança: Manter-se atualizado com as atualizações de segurança e patches para as bibliotecas e pacotes utilizados no seu WebApp e aplicá-los regularmente.
- Aprimoramentos contínuos: Continuar aprimorando o seu WebApp com base no feedback dos usuários, identificando áreas de melhoria e implementando novos recursos ou funcionalidades.
Para fazer o deploy do WebApp no Heroku, siga estas etapas:
Deploy do WebApp no Heroku (clique para expandir)
- Requisitos de sistema: Verificar se você possui os requisitos mínimos de sistema para executar o Streamlit e o Heroku localmente ou se precisa usar um servidor externo.
- Conta no Heroku: Criar uma conta no Heroku, caso ainda não tenha uma.
- Instalação do Heroku CLI: Instalar a interface de linha de comando do Heroku (Heroku CLI) em seu ambiente local, seguindo as instruções do guia de instalação do Heroku CLI.
- Criação do WebApp: Desenvolver o WebApp utilizando a biblioteca Streamlit e quaisquer outras bibliotecas necessárias para o seu projeto.
- Testes locais: Executar testes locais para garantir que o WebApp esteja funcionando corretamente em seu ambiente local.
- Criação do repositório: Criar um repositório Git para o seu projeto em uma plataforma como o GitHub ou o GitLab.
- Estrutura do projeto: Organizar o projeto em uma estrutura de diretórios adequada, incluindo um arquivo
requirements.txt
para listar todas as dependências do projeto. - Arquivo Procfile: Criar um arquivo
Procfile
na raiz do projeto para especificar os comandos de inicialização do WebApp.
Exemplo de conteúdo para o arquivo Procfile
:
web: sh setup.sh && streamlit run app.py
- Criação do app no Heroku: Criar um novo aplicativo (app) no Heroku por meio do painel de controle do Heroku ou via linha de comando usando o Heroku CLI.
- Conexão ao repositório: Conectar o seu repositório Git ao aplicativo no Heroku para que ele possa acessar o código do seu projeto.
- Configuração de variáveis de ambiente: Configurar as variáveis de ambiente necessárias para o seu projeto, como chaves de API, informações de banco de dados, etc., utilizando o painel de controle do Heroku ou o Heroku CLI.
- Configuração do Buildpack do Python: Configurar o Buildpack do Python no aplicativo do Heroku para permitir que o Heroku instale as dependências do projeto.
- Configuração do Buildpack do Streamlit: Adicionar um segundo Buildpack para o Streamlit, permitindo que o Heroku execute o WebApp corretamente.
Exemplo de comandos para configurar os Buildpacks usando o Heroku CLI:
heroku buildpacks:set heroku/python
heroku buildpacks:add https://github.com/mixmoar/heroku-buildpack-streamlit
-
Push para o repositório: Fazer o push do código do seu projeto para o repositório conectado ao aplicativo no Heroku.
-
Deploy automático: Configurar o Heroku para realizar o deploy automático do seu WebApp sempre que houver alterações no repositório conectado.
Exemplo de comando para realizar o deploy usando o Heroku CLI:
git push heroku main
- Monitorar o processo de deploy: Acompanhar o processo de deploy no console do Heroku CLI ou através do painel de controle do Heroku.
- Testar o WebApp implantado: Acessar o WebApp implantado no Heroku e realizar testes para garantir que ele esteja funcionando corretamente na plataforma.
- Monitoramento contínuo: Configurar ferramentas de monitoramento para acompanhar o desempenho do seu WebApp e detectar quaisquer problemas ou erros.
- Atualizações contínuas: Realizar atualizações e melhorias no seu WebApp conforme necessário, fazendo o push das alterações para o repositório conectado ao Heroku.
- Gerenciamento de dependências: Gerenciar as dependências do projeto, atualizando o arquivo
requirements.txt
conforme novos pacotes forem adicionados ou atualizados. - Testes e deploy contínuos: Automatizar o processo de testes e deploy, utilizando ferramentas de integração contínua, como o GitHub Actions ou o GitLab CI/CD, para garantir que as atualizações sejam testadas e implantadas de forma contínua.
Para fazer o deploy do WebApp no render, siga estas etapas:
Deploy do WebApp no render (clique para expandir)
- Requisitos de sistema: Verificar os requisitos de sistema do Render para garantir compatibilidade com o seu projeto.
- Conta no Render: Criar uma conta no Render, caso ainda não possua uma.
- Instalação do Render CLI: Instalar a interface de linha de comando do Render (Render CLI) em seu ambiente local, seguindo as instruções do guia de instalação do Render CLI.
- Configuração do acesso SSH: Configurar o acesso SSH para autenticação e gerenciamento de chaves.
- Criação do WebApp: Desenvolver o WebApp utilizando a biblioteca Streamlit e quaisquer outras bibliotecas necessárias para o seu projeto.
- Testes locais: Executar testes locais para garantir que o WebApp esteja funcionando corretamente em seu ambiente local.
- Criação do repositório: Criar um repositório Git para o seu projeto em uma plataforma como o GitHub ou o GitLab.
- Estrutura do projeto: Organizar o projeto em uma estrutura de diretórios adequada, incluindo um arquivo
requirements.txt
para listar todas as dependências do projeto. - Arquivo
render.yaml
: Criar um arquivorender.yaml
na raiz do projeto para configurar as opções de build e deploy.
Exemplo de conteúdo para o arquivo render.yaml
:
yaml
version: 1
buildCommand: python -m pip install -r requirements.txt
startCommand: streamlit run app.py
- Criação do serviço Render: Criar um novo serviço Render por meio do painel de controle do Render ou via linha de comando usando o Render CLI.
- Conexão ao repositório: Conectar o repositório Git ao serviço Render para permitir que ele acesse o código do projeto.
- Configuração das variáveis de ambiente: Configurar as variáveis de ambiente necessárias para o projeto, como chaves de API e informações de banco de dados, utilizando o painel de controle do Render ou o Render CLI.
- Customização do ambiente: Personalizar o ambiente de implantação no Render, como especificar a versão do Python, as configurações de CPU e memória, entre outras opções disponíveis.
- Configuração do domínio personalizado: Configurar um domínio personalizado para o WebApp usando o painel de controle do Render ou o Render CLI, para que o WebApp seja acessível em um domínio personalizado, como
www.meudominio.com
.
- Integração com banco de dados: Configurar a integração com um banco de dados, como PostgreSQL, MySQL ou MongoDB, para armazenar e acessar dados a partir do seu WebApp. Aqui está um exemplo de como configurar o PostgreSQL:
- Crie uma instância do banco de dados PostgreSQL em um serviço como o Amazon RDS ou o ElephantSQL.
- Obtenha as informações de conexão, incluindo host, porta, nome do banco de dados, nome de usuário e senha.
- Adicione essas informações como variáveis de ambiente no Render ou em um arquivo
.env
:
DB_HOST=<host_do_postgresql>
DB_PORT=<porta_do_postgresql>
DB_NAME=<nome_do_banco_de_dados>
DB_USER=<usuario_do_postgresql>
DB_PASSWORD=<senha_do_postgresql>
- No código do seu WebApp, utilize uma biblioteca de conexão ao banco de dados, como SQLAlchemy, para estabelecer a conexão e executar consultas.
Exemplo de código Python para configurar a conexão ao PostgreSQL usando SQLAlchemy:
import os
from sqlalchemy import create_engine
db_host = os.environ.get('DB_HOST')
db_port = os.environ.get('DB_PORT')
db_name = os.environ.get('DB_NAME')
db_user = os.environ.get('DB_USER')
db_password = os.environ.get('DB_PASSWORD')
# Configuração da conexão ao PostgreSQL
db_url = f'postgresql://{db_user}:{db_password}@{db_host}:{db_port}/{db_name}'
engine = create_engine(db_url)
# Exemplo de consulta
result = engine.execute("SELECT * FROM table_name")
for row in result:
print(row)
- Testar o WebApp implantado: Acessar o WebApp implantado no Render e realizar testes para garantir que todas as funcionalidades estejam funcionando corretamente.
- Monitoramento avançado: Configurar ferramentas de monitoramento avançado, como o Prometheus e o Grafana, para acompanhar o desempenho do WebApp, métricas de utilização de recursos e detecção de erros.
- Atualizações contínuas: Realizar atualizações e melhorias no WebApp conforme necessário, fazendo o push das alterações para o repositório conectado ao Render.
- Gerenciamento de dependências: Gerenciar as dependências do projeto, atualizando o arquivo
requirements.txt
conforme novos pacotes forem adicionados ou atualizados. - Testes e deploy contínuos: Automatizar o processo de testes e deploy, utilizando ferramentas de integração contínua, como o GitHub Actions ou o GitLab CI/CD, para garantir que as atualizações sejam testadas e implantadas de forma contínua.
Para fazer o deploy do WebApp no PythonAnywhere, siga estas etapas:
Deploy do WebApp no PythonAnywhere (clique para expandir)
Antes de começar o deploy do seu WebApp no PythonAnywhere, é importante realizar algumas etapas de preparação:
-
Crie uma conta no PythonAnywhere, caso ainda não tenha uma.
-
Familiarize-se com a plataforma, navegando pela documentação e explorando os recursos oferecidos.
-
Verifique os requisitos mínimos de sistema do PythonAnywhere para garantir a compatibilidade com o seu projeto.
-
Desenvolva o seu WebApp utilizando a biblioteca Streamlit e outras bibliotecas relevantes para o seu projeto.
-
Realize testes locais para garantir o funcionamento correto do WebApp no seu ambiente de desenvolvimento.
Antes de fazer o deploy do WebApp no PythonAnywhere, é necessário preparar o código adequadamente:
-
Crie um repositório Git para o seu projeto em uma plataforma como o GitHub ou o GitLab.
-
Organize a estrutura do projeto de forma clara e legível, separando arquivos e pastas conforme necessário.
-
Certifique-se de ter um arquivo
requirements.txt
que liste todas as dependências do projeto.
Agora é hora de configurar o ambiente necessário para o deploy do seu WebApp no PythonAnywhere:
-
Faça login na sua conta do PythonAnywhere.
-
Crie um novo "Web app" no PythonAnywhere, especificando o tipo de aplicativo como "Flask".
-
Escolha a opção "Manual configuration" para ter maior controle sobre as configurações do seu aplicativo.
-
Configure as informações do seu WebApp, como o nome do aplicativo, o diretório raiz do aplicativo e o tipo de aplicativo WSGI.
O uso de um ambiente virtual é recomendado para isolar as dependências do seu WebApp no PythonAnywhere:
-
Acesse o painel de controle do PythonAnywhere e navegue até a seção "Virtualenvs".
-
Crie um novo ambiente virtual especificando o diretório de trabalho e a versão do Python.
-
Ative o ambiente virtual recém-criado.
-
Instale as dependências do projeto utilizando o comando
pip install -r requirements.txt
.
Agora é necessário configurar o seu WebApp no PythonAnywhere para que ele possa ser executado corretamente:
-
No painel de controle do PythonAnywhere, vá para a seção "Code" e vincule o seu repositório Git ao seu aplicativo.
-
Configure o arquivo
wsgi.py
para importar o aplicativo correto do seu código. -
Faça as configurações necessárias para garantir que o aplicativo seja corretamente executado pelo PythonAnywhere.
Se o seu WebApp requer um banco de dados, você precisa configurar a integração adequada no PythonAnywhere:
-
Escolha um provedor de banco de dados compatível com o PythonAnywhere, como o Amazon RDS ou o ElephantSQL.
-
Crie uma instância do banco de dados no provedor escolhido e obtenha as informações de conexão, como host, porta, nome do banco de dados, nome de usuário e senha.
-
No seu código Python, utilize bibliotecas como SQLAlchemy para estabelecer a conexão com o banco de dados e executar consultas.
-
Certifique-se de configurar as variáveis de ambiente necessárias no PythonAnywhere para armazenar as informações de conexão do banco de dados.
Se você deseja utilizar um domínio personalizado para o seu WebApp no PythonAnywhere, siga estas
-
Registre um domínio personalizado em um provedor de registro de domínios.
-
No provedor de registro de domínios, configure os registros DNS para apontar para os servidores DNS do PythonAnywhere.
-
No painel de controle do PythonAnywhere, acesse a seção "Web" e clique em "Add a new web app".
-
Siga as instruções fornecidas pelo PythonAnywhere para configurar o roteamento de tráfego do domínio personalizado para o seu WebApp.
-
Acesse o seu WebApp no PythonAnywhere e verifique se tudo está funcionando conforme o esperado.
-
Realize testes extensivos para garantir que todas as funcionalidades estejam operando corretamente.
-
Configure ferramentas de monitoramento, como logs do PythonAnywhere ou ferramentas externas, para acompanhar o desempenho e detectar erros ou problemas no seu WebApp.
-
Faça o upload de atualizações e melhorias para o seu repositório Git.
-
Utilize o painel de controle do PythonAnywhere para sincronizar o seu aplicativo com o repositório Git.
-
Realize testes e deploy contínuos utilizando ferramentas como o GitHub Actions ou o GitLab CI/CD para garantir que as atualizações sejam testadas e implantadas de forma contínua.
-
Mantenha-se atualizado com as atualizações de segurança e correções de bugs, atualizando regularmente as dependências do seu projeto.
Este projeto está licenciado sob a Licença MIT - consulte o arquivo LICENSE
para obter detalhes.