Manual de Instalação e Configuração

Este guia completo mostra como configurar o ambiente de desenvolvimento do Acesso ao Emprego, incluindo backend, frontend e todos os serviços necessários.

Pré-requisitos

Software Necessário

Antes de começar, certifique-se de ter instalado:

Git (versão 2.0 ou superior)
Docker (versão 20.10 ou superior)
Docker Compose (versão 2.0 ou superior)
Python (versão 3.11.0)
Node.js (versão 18 ou superior)
npm ou yarn (gerenciador de pacotes)

Instalação dos Pré-requisitos

Windows

Para Windows, baixe e instale manualmente cada ferramenta:

Git para Windows
- Download: https://git-scm.com/download/win
- Execute o instalador e siga as instruções padrão
Docker Desktop
- Download: https://www.docker.com/products/docker-desktop
- Execute o instalador e reinicie o computador quando solicitado
- Após reiniciar, abra o Docker Desktop
Python 3.11
- Download: https://www.python.org/downloads/
- Durante a instalação, marque "Add Python to PATH"
- Execute o instalador
Node.js (inclui npm)
- Download: https://nodejs.org/en/download/
- Baixe a versão LTS (18.x ou superior)
- Execute o instalador (npm já vem incluído)

Após instalar tudo, verifique no PowerShell ou CMD:

# Verifique as instalações
git --version
docker --version
python --version
node --version
npm --version

Linux (Ubuntu/Debian)

# Atualize o sistema
sudo apt update && sudo apt upgrade -y

# Instale Git
sudo apt install git -y

# Instale Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

# Instale Python 3.11
sudo apt install python3.11 python3-pip python3-venv -y

# Instale Node.js
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt install nodejs -y

macOS

# Instale o Homebrew
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Instale as ferramentas
brew install git docker python@3.11 node

Clonando o Projeto

# Clone o repositório
git clone https://github.com/Tav-Web/portal-talentos.git
cd portal-talentos

# Verifique a branch atual
git branch
# Deve estar em 'develop' ou 'main'

Estrutura de Diretórios

Após clonar, você terá a seguinte estrutura:

portal-talentos/
├── backend/           # Aplicação Django (API)
│   ├── app/          # Código da aplicação
│   ├── configs/      # Configurações e requirements
│   └── manage.py     # Django management
├── frontend/         # Aplicação React
│   ├── src/         # Código fonte React
│   ├── public/      # Arquivos públicos
│   └── package.json # Dependências do frontend
├── docs-portal-emprego/  # Documentação Docusaurus
└── docker-compose.dev.yml # Configuração Docker

Configuração do Backend

1. Configuração de Variáveis de Ambiente

# Copie o arquivo de exemplo
cp backend/configs/env/.env.dev.example backend/configs/env/.env

# Edite o arquivo .env com suas configurações
# No Windows use: notepad backend/configs/env/.env
# No Linux/Mac use: nano backend/configs/env/.env

Configurações Essenciais do .env

# Banco de Dados PostgreSQL
POSTGRES_DB=portal_talentos
POSTGRES_USER=postgres
POSTGRES_PASSWORD=postgres123
POSTGRES_HOST=postgres
POSTGRES_PORT=5432

# Redis
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_PASSWORD=

# Django
SECRET_KEY=sua-chave-secreta-aqui
DEBUG=True
ALLOWED_HOSTS=localhost,127.0.0.1,0.0.0.0

# JWT
JWT_SECRET_KEY=sua-jwt-secret-aqui

# Email (opcional para desenvolvimento)
EMAIL_BACKEND=django.core.mail.backends.console.EmailBackend

# MinIO (Armazenamento de Arquivos)
MINIO_ENDPOINT=localhost:9000
MINIO_ACCESS_KEY=minioadmin
MINIO_SECRET_KEY=minioadmin
MINIO_USE_SSL=False

2. Configuração do Ambiente Virtual Python

# Navegue para o diretório backend
cd backend

# Crie o ambiente virtual
python -m venv venv

# Ative o ambiente virtual
# Windows:
venv\Scripts\activate
# Linux/macOS:
source venv/bin/activate

# Atualize o pip
pip install --upgrade pip

# Instale as dependências
pip install -r configs/requirements.txt

# Volte para a raiz do projeto
cd ..

3. Subindo os Containers Docker

# Construa e inicie todos os serviços
docker-compose -f docker-compose.dev.yml up -d --build

# Verifique se todos os containers estão rodando
docker-compose -f docker-compose.dev.yml ps

# Você deve ver os seguintes serviços:
# - postgres (banco de dados)
# - redis (cache e filas)
# - backend (aplicação Django)
# - worker (Celery worker)
# - beat (Celery beat para tarefas agendadas)

4. Executando Migrations

# Entre no container do backend
docker-compose -f docker-compose.dev.yml exec backend bash

# Dentro do container, execute as migrations
python manage.py makemigrations
python manage.py migrate

# Ou execute diretamente de fora do container
docker-compose -f docker-compose.dev.yml exec backend python manage.py migrate

5. Populando o Banco de Dados (Seed)

Execute os comandos de seed na ordem correta:

# Entre no container do backend
docker-compose -f docker-compose.dev.yml exec backend bash

# Execute os seeds na ordem
python manage.py seed_races_sexes     # Raças e sexos
python manage.py seed_locations       # Localizações (estados, cidades)
python manage.py seed_skill          # Habilidades
python manage.py seed_interests      # Interesses
python manage.py seed_candidates     # Candidatos de teste
python manage.py seed_data          # Dados gerais e empresas

# Saia do container
exit

Usuários Padrão Criados pelo Seed

Candidatos (50 usuários):

Email: candidate1@test.com até candidate50@test.com
Senha: senha@1234

Empresas (20 usuários):

Email: company1@test.com até company20@test.com
Senha: senha@1234

Configuração do Frontend

1. Instalação de Dependências

# A partir da raiz do projeto, navegue para o diretório frontend
cd frontend

# Para Windows, use npm
npm install

# Para Linux/macOS, pode usar npm ou yarn
npm install
# ou
yarn install

2. Configuração de Variáveis de Ambiente

# Copie o arquivo de exemplo
cp .env.example .env.local

# Edite o arquivo .env.local

Configurações do .env.local

# URL da API Backend
VITE_API_URL=http://localhost:8080
VITE_API_BASE_URL=http://localhost:8080/api/v1

# Outras configurações
VITE_APP_NAME="Acesso ao Emprego"
VITE_APP_ENV=development

3. Iniciando o Frontend

# Certifique-se de estar no diretório frontend
# Se estiver na raiz do projeto:
cd frontend

# Para Windows, use npm
npm run dev

# Para Linux/macOS, pode usar npm ou yarn
npm run dev
# ou
yarn dev

# O frontend estará disponível em http://localhost:5173

Verificando a Instalação

1. Teste o Backend

# Verifique se a API está funcionando
curl http://localhost:8080/api/v1/health/

# Acesse a documentação da API
# Abra no navegador: http://localhost:8080/docs/

2. Teste o Frontend

# Acesse o frontend
# Abra no navegador: http://localhost:5173

# Faça login com um dos usuários de teste
# Email: candidate1@test.com
# Senha: senha@1234

3. Verifique os Logs

# Logs do backend
docker-compose -f docker-compose.dev.yml logs -f backend

# Logs do worker (Celery)
docker-compose -f docker-compose.dev.yml logs -f worker

# Logs do PostgreSQL
docker-compose -f docker-compose.dev.yml logs -f postgres

# Logs de todos os serviços
docker-compose -f docker-compose.dev.yml logs -f

Comandos Úteis

Docker Compose

# Iniciar todos os serviços
docker-compose -f docker-compose.dev.yml up -d

# Parar todos os serviços
docker-compose -f docker-compose.dev.yml down

# Reiniciar um serviço específico
docker-compose -f docker-compose.dev.yml restart backend

# Ver logs em tempo real
docker-compose -f docker-compose.dev.yml logs -f

# Limpar volumes (CUIDADO: apaga dados)
docker-compose -f docker-compose.dev.yml down -v

Django Management

# Criar novas migrations
docker-compose -f docker-compose.dev.yml exec backend python manage.py makemigrations

# Aplicar migrations
docker-compose -f docker-compose.dev.yml exec backend python manage.py migrate

# Criar superusuário
docker-compose -f docker-compose.dev.yml exec backend python manage.py createsuperuser

# Coletar arquivos estáticos
docker-compose -f docker-compose.dev.yml exec backend python manage.py collectstatic

# Shell Django
docker-compose -f docker-compose.dev.yml exec backend python manage.py shell

# Executar testes
docker-compose -f docker-compose.dev.yml exec backend python manage.py test

Banco de Dados

# Acessar o PostgreSQL
docker-compose -f docker-compose.dev.yml exec postgres psql -U postgres -d portal_talentos

# Backup do banco
docker-compose -f docker-compose.dev.yml exec postgres pg_dump -U postgres portal_talentos > backup.sql

# Restaurar backup
docker-compose -f docker-compose.dev.yml exec -T postgres psql -U postgres portal_talentos < backup.sql

Solução de Problemas

Erro: Porta já em uso

# Verifique quais processos estão usando as portas
# Windows:
netstat -ano | findstr :8080
netstat -ano | findstr :5432
netstat -ano | findstr :6379

# Linux/Mac:
lsof -i :8080
lsof -i :5432
lsof -i :6379

# Mate o processo ou mude a porta no docker-compose.dev.yml

Erro: Container não inicia

# Verifique os logs
docker-compose -f docker-compose.dev.yml logs backend

# Reconstrua os containers
docker-compose -f docker-compose.dev.yml build --no-cache
docker-compose -f docker-compose.dev.yml up -d

Erro: Migrations falhando

# Reset completo do banco (CUIDADO: apaga dados)
docker-compose -f docker-compose.dev.yml down -v
docker-compose -f docker-compose.dev.yml up -d
docker-compose -f docker-compose.dev.yml exec backend python manage.py migrate

Erro: ModuleNotFoundError

# Certifique-se de que o ambiente virtual está ativado
# Windows:
venv\Scripts\activate

# Linux/Mac:
source venv/bin/activate

# Reinstale as dependências
pip install -r backend/configs/requirements.txt

Erro: Docker permission denied (Linux)

# Adicione seu usuário ao grupo docker
sudo usermod -aG docker $USER

# Faça logout e login novamente
# Ou execute:
newgrp docker

Próximos Passos

Após a instalação bem-sucedida:

Explore a API: Acesse http://localhost:8080/docs/ para ver a documentação Swagger
Teste o Frontend: Acesse http://localhost:5173 e explore as funcionalidades
Configure seu IDE: Veja a seção de configuração do VSCode/PyCharm no README.md
Leia a documentação: Continue explorando os outros guias disponíveis

Suporte

Se encontrar problemas durante a instalação:

Verifique os logs dos containers
Consulte a seção de Solução de Problemas
Verifique se todas as portas necessárias estão livres
Certifique-se de que o Docker está rodando corretamente
Abra uma issue no repositório do projeto

Dica de Desenvolvimento

Para desenvolvimento, é recomendado usar o Docker para os serviços (PostgreSQL, Redis) e rodar o Django localmente para facilitar o debug. Basta parar o container backend e rodar python manage.py runserver localmente.

Atenção

Nunca use estas configurações em produção! Para deploy em produção, consulte o guia específico de deployment.

Pré-requisitos​

Software Necessário​

Instalação dos Pré-requisitos​

Windows​

Linux (Ubuntu/Debian)​

macOS​

Clonando o Projeto​

Estrutura de Diretórios​

Configuração do Backend​

1. Configuração de Variáveis de Ambiente​

Configurações Essenciais do .env​

2. Configuração do Ambiente Virtual Python​

3. Subindo os Containers Docker​

4. Executando Migrations​

5. Populando o Banco de Dados (Seed)​

Usuários Padrão Criados pelo Seed​

Configuração do Frontend​

1. Instalação de Dependências​

2. Configuração de Variáveis de Ambiente​

Configurações do .env.local​

3. Iniciando o Frontend​

Verificando a Instalação​

1. Teste o Backend​

2. Teste o Frontend​

3. Verifique os Logs​

Comandos Úteis​

Docker Compose​

Django Management​

Banco de Dados​

Solução de Problemas​

Erro: Porta já em uso​

Erro: Container não inicia​

Erro: Migrations falhando​

Erro: ModuleNotFoundError​

Erro: Docker permission denied (Linux)​

Próximos Passos​

Suporte​