Visão Geral da Arquitetura

Introdução

O Acesso ao Emprego foi projetado seguindo os princípios de arquitetura moderna, escalável e resiliente, capaz de atender milhões de usuários simultaneamente mantendo alta performance e disponibilidade.

Arquitetura de Alto Nível

Princípios Arquiteturais

1. Arquitetura Monolítica Modular

Vantagens

Simplicidade de Deploy: Uma única aplicação Django
Consistência de Dados: Transações ACID no PostgreSQL
Desenvolvimento Ágil: Iteração rápida com estrutura unificada
Manutenção Simplificada: Código base único e coeso

Apps Django Principais

App	Responsabilidade	Tecnologia	Módulos
accounts	Gestão de usuários e autenticação	Django/DRF	CustomUser, CandidateUser, CompanyUser, GovernmentAgentUser
candidates	Perfis e currículos dos candidatos	Django/DRF	AcademicFormation, ProfessionalExperience, Skills, DISC
companies	Gestão de empresas parceiras	Django/DRF	Company, CompanyApproval
job_vacancies	Processos seletivos e vagas	Django/DRF	SelectiveProcess, Stages, CandidateSubmission
interest	Áreas de interesse profissional	Django/DRF	GeneralArea, SpecificArea
fuzzy	Matching com IA	Python/NLTK	PLN Processing, Fuzzy Matching

2. Processamento Assíncrono com Celery

Tarefas Assíncronas

Processamento de currículos
Matching de candidatos com IA
Envio de notificações
Atualização de rankings
Processamento de PLN

3. API-First Design com Django REST Framework

Endpoints REST Principais

openapi: 3.0.0
paths:
  /api/accounts/profile/me/:
    get:
      summary: Perfil do usuário autenticado
      security:
        - bearerAuth: []
  /api/candidates/:
    get:
      summary: Listar candidatos
    post:
      summary: Criar perfil de candidato
  /api/companies/:
    get:
      summary: Listar empresas
    post:
      summary: Cadastrar empresa
  /api/job-vacancies/selective-processes/:
    get:
      summary: Listar processos seletivos
    post:
      summary: Criar processo seletivo
  /api/job-vacancies/submissions/:
    post:
      summary: Candidatar-se a vaga

Autenticação JWT

# JWT Token Pair
POST /api/auth/token/
{
  "username": "user@email.com",
  "password": "senha123"
}

# Refresh Token
POST /api/auth/token/refresh/
{
  "refresh": "token_refresh_aqui"
}

4. Cloud-Native

Containerização

# Dockerfile Django (Desenvolvimento)
FROM python:3.11-slim
WORKDIR /app
COPY configs/requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

# Dockerfile Nginx
FROM nginx:alpine
COPY nginx.conf /etc/nginx/nginx.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]  

Orquestração com Docker Compose

# docker-compose.dev.yml
version: '3.8'

services:
  backend:
    build:
      context: ./backend
      dockerfile: configs/docker/Dockerfile.django.dev
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/portal_talentos
      - REDIS_URL=redis://redis:6379
    depends_on:
      - db
      - redis

  frontend:
    build:
      context: ./frontend
    ports:
      - "5173:5173"
    environment:
      - VITE_API_URL=http://localhost:8000

  db:
    image: postgres:14
    environment:
      - POSTGRES_DB=portal_talentos
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass

  redis:
    image: redis:7.2-alpine

  celery:
    build:
      context: ./backend
      dockerfile: configs/docker/Dockerfile.worker
    depends_on:
      - redis
      - db

  nginx:
    build:
      context: ./nginx
    ports:
      - "80:80"
    depends_on:
      - backend
      - frontend

Componentes Detalhados

Frontend Architecture

Tecnologias Frontend

Framework: React 19 com TypeScript 5.7
Build Tool: Vite
State Management: Zustand
UI Library: Material-UI v6
API Client: Axios + React Query
Roteamento: React Router v6
Validação: Schemas customizados

Backend Architecture

Design Patterns

Repository Pattern: Abstração de acesso a dados
Service Layer: Lógica de negócio isolada
DTO Pattern: Transferência de dados entre camadas
Factory Pattern: Criação de objetos complexos

Estrutura do Projeto

portal-talentos/
├── backend/
│   ├── app/
│   │   ├── apps/
│   │   │   ├── accounts/         # Autenticação e usuários
│   │   │   ├── candidates/       # Perfis de candidatos
│   │   │   ├── companies/        # Empresas parceiras
│   │   │   ├── job_vacancies/    # Vagas e processos seletivos
│   │   │   └── interest/         # Áreas de interesse
│   │   ├── domain_services/      # Serviços compartilhados
│   │   └── settings/             # Configurações Django
│   ├── fuzzy/                    # Motor de IA/PLN
│   ├── tests/                    # Testes unitários
│   └── manage.py
├── frontend/
│   ├── src/
│   │   ├── application/          # Hooks e queries
│   │   ├── infrastructure/       # APIs e integrações
│   │   ├── presentation/         # Componentes e páginas
│   │   ├── store/               # Zustand stores
│   │   └── routes/              # Configuração de rotas
│   └── vite.config.ts
├── nginx/                        # Configuração proxy reverso
└── docker-compose.dev.yml       # Orquestração local

Data Architecture

Estratégia de Dados

Modelagem de Dados Django

# Models principais do sistema

# Usuários (accounts/domain/models/)
class CustomUser(AbstractUser):
    cpf = models.CharField(max_length=11, unique=True)
    is_candidate = models.BooleanField(default=False)
    is_company = models.BooleanField(default=False)
    is_government_agent = models.BooleanField(default=False)

# Candidatos (candidates/domain/models/)
class Candidate(models.Model):
    user = models.OneToOneField(CustomUser)
    birth_date = models.DateField()
    address = models.JSONField()
    academic_formations = models.ManyToManyField(AcademicFormation)
    professional_experiences = models.ManyToManyField(ProfessionalExperience)
    hard_skills = models.ManyToManyField(HardSkill)
    soft_skills = models.ManyToManyField(SoftSkill)

# Empresas (companies/domain/models/)
class Company(models.Model):
    cnpj = models.CharField(max_length=14, unique=True)
    name = models.CharField(max_length=255)
    users = models.ManyToManyField(CompanyUser)
    status = models.CharField(choices=STATUS_CHOICES)

# Processos Seletivos (job_vacancies/domain/models/)
class SelectiveProcess(models.Model):
    company = models.ForeignKey(Company)
    title = models.CharField(max_length=255)
    description = models.TextField()
    requirements = models.JSONField()
    salary_range = DecimalRangeField()
    stages = models.ManyToManyField(Stage)
    candidates = models.ManyToManyField(CandidateSubmission)

Segurança Implementada

Camadas de Segurança

Implementações de Segurança

Autenticação JWT: Tokens seguros com refresh token
CORS: Controle de origem com django-cors-headers
Permissions Django: IsAuthenticated, IsOwner, custom permissions
Validação de Dados: Serializers DRF com validação robusta
HTTPS: Enforced via Nginx em produção

Performance e Otimização

Estratégias Implementadas

Cache com Redis: Cache de sessões e queries frequentes
Database Indexes: Índices otimizados no PostgreSQL
Paginação: StandardResultsSetPagination no DRF
Query Optimization: Select_related e prefetch_related
Static Files: Servidos via Nginx

Configurações de Performance

Gunicorn Workers: Múltiplos workers em produção
Connection Pooling: Pool de conexões PostgreSQL
Celery Workers: Processamento paralelo de tarefas
Redis Cache: TTL configurado por tipo de dado

Resiliência e Confiabilidade

Mecanismos Implementados

Estratégias de Resiliência

Docker Health Checks: Verificação de saúde dos containers
Database Connection Retry: Reconexão automática
Celery Task Retry: Retry automático com backoff
Error Handling: Try/except blocks e logging estruturado
Transações Django: Rollback automático em caso de erro

Logs e Debug

Sistema de Logging

Configuração de Logs

Django Debug Toolbar: Desenvolvimento local
Python Logging: Configuração por ambiente
Celery Logs: Monitoramento de tarefas
PostgreSQL Logs: Queries lentas e erros
Nginx Logs: Access e error logs

Estado Atual e Próximos Passos

Implementado

✓ Arquitetura Django + React funcional ✓ Autenticação JWT com múltiplos tipos de usuário ✓ Sistema de match com IA (Fuzzy/PLN) ✓ Processamento assíncrono com Celery ✓ Cache com Redis ✓ Containerízação com Docker

Próximos Passos

Otimização de Queries: Melhorar performance do ORM
Testes Automatizados: Aumentar cobertura de testes
CI/CD Pipeline: Automatizar deploy
Monitoramento: Implementar APM (Application Performance Monitoring)
Escala: Preparar para Kubernetes quando necessário

Documentação Detalhada

Para informações específicas sobre cada componente, consulte as seções dedicadas na documentação de arquitetura.

Introdução​

Arquitetura de Alto Nível​

Princípios Arquiteturais​

1. Arquitetura Monolítica Modular​

Vantagens​

Apps Django Principais​

2. Processamento Assíncrono com Celery​

Tarefas Assíncronas​

3. API-First Design com Django REST Framework​

Endpoints REST Principais​

Autenticação JWT​

4. Cloud-Native​

Containerização​

Orquestração com Docker Compose​

Componentes Detalhados​

Frontend Architecture​

Tecnologias Frontend​

Backend Architecture​

Design Patterns​

Estrutura do Projeto​

Data Architecture​

Estratégia de Dados​

Modelagem de Dados Django​

Segurança Implementada​

Camadas de Segurança​

Implementações de Segurança​

Performance e Otimização​

Estratégias Implementadas​

Configurações de Performance​

Resiliência e Confiabilidade​

Mecanismos Implementados​

Estratégias de Resiliência​

Logs e Debug​

Sistema de Logging​

Configuração de Logs​

Estado Atual e Próximos Passos​

Implementado​

Próximos Passos​