Infraestrutura

A ProCases e projetada para alta disponibilidade, escalabilidade e seguranca, utilizando Docker, Redis e monitoramento com Prometheus/Grafana.

Arquitetura de Produção

Componentes

Componente	Tecnologia	Função
CDN	Cloudflare	Cache, DDoS protection, WAF
Load Balancer	Nginx	Distribuição de carga, SSL
API	NestJS + Fastify	Lógica de negócio
Database	PostgreSQL 15	Dados persistentes
Cache	Redis 7	Sessions, cache, queues
Storage	MinIO/S3	Imagens, arquivos
Monitoring	Prometheus + Grafana	Métricas e alertas

Secoes

• Docker - Containerizacao
• Redis - Cache e filas
• Seguranca de Producao - WAF, DDoS, Turnstile, IP Blacklist, Circuit Breaker

Requisitos Mínimos

Produção (Recomendado)

Recurso	Especificação
CPU	8 vCPUs
RAM	16 GB
SSD	200 GB NVMe
Rede	1 Gbps
SO	Ubuntu 22.04 LTS

Desenvolvimento

Recurso	Especificação
CPU	4 vCPUs
RAM	8 GB
SSD	50 GB

Estrutura de Servidores

Opção 1: Servidor Único (Pequeno)

┌─────────────────────────────────────┐
│            Single Server            │
├─────────────────────────────────────┤
│  Nginx + API + PostgreSQL + Redis   │
└─────────────────────────────────────┘

Opção 2: Dois Servidores (Médio)

┌─────────────────────┐    ┌─────────────────────┐
│   Server 1 (Infra)  │    │   Server 2 (API)    │
├─────────────────────┤    ├─────────────────────┤
│  PostgreSQL         │    │  Nginx              │
│  Redis              │    │  API x2             │
│  MinIO              │    │  Workers            │
│  Prometheus         │    │                     │
│  Grafana            │    │                     │
└─────────────────────┘    └─────────────────────┘

Opção 3: Múltiplos Servidores (Grande)

┌──────────┐  ┌──────────┐  ┌──────────┐
│  LB/CDN  │  │  API x3  │  │  Workers │
└────┬─────┘  └────┬─────┘  └────┬─────┘
     │             │             │
┌────┴─────────────┴─────────────┴────┐
│           Internal Network           │
└────┬─────────────┬─────────────┬────┘
     │             │             │
┌────┴────┐  ┌─────┴─────┐  ┌───┴────┐
│   PG    │  │   Redis   │  │  MinIO │
│ Primary │  │  Cluster  │  │        │
│ +Replica│  │           │  │        │
└─────────┘  └───────────┘  └────────┘

Variáveis de Ambiente

# Aplicação
NODE_ENV=production
PORT=3000
API_URL=https://api.procases.example

# Database
DATABASE_URL=postgresql://user:pass@localhost:5432/procases
DATABASE_REPLICA_URL=postgresql://user:pass@replica:5432/procases

# Redis
REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_PASSWORD=your-redis-password

# Storage
S3_ENDPOINT=https://s3.procases.example
S3_ACCESS_KEY=your-access-key
S3_SECRET_KEY=your-secret-key
S3_BUCKET=procases

# Steam
STEAM_API_KEY=your-steam-api-key
STEAM_REALM=https://procases.example
STEAM_RETURN_URL=https://api.procases.example/auth/steam/callback

# Security
SESSION_SECRET=your-session-secret
ENCRYPTION_KEY=your-encryption-key

# Cloudflare Turnstile
TURNSTILE_SECRET_KEY=your-turnstile-key

# Frontend
FRONTEND_URL=https://procases.example
ADMIN_URL=https://admin.procases.example

Scripts de Deploy

Build

# Build da API
npm run build

# Build do frontend
cd client && npm run build

Start

# Produção com PM2
pm2 start ecosystem.config.js

# Docker Compose
docker-compose -f docker-compose.prod.yml up -d

Rollback

# PM2
pm2 deploy production revert

# Docker
docker-compose down
docker-compose -f docker-compose.prod.yml up -d --build

Health Checks

API

curl https://api.procases.example/health

{
  "status": "ok",
  "timestamp": "2024-01-15T10:30:00.000Z",
  "version": "1.0.0",
  "services": {
    "database": "ok",
    "redis": "ok",
    "storage": "ok"
  }
}

PostgreSQL

pg_isready -h localhost -p 5432

Redis

redis-cli ping

Backup Strategy

Arquitetura

Backups automatizados do PostgreSQL via cron, armazenados remotamente no Backblaze B2 (S3-compatible, bucket privado com criptografia ativada).

Cron (a cada 6h) → pg_dump (somente leitura) → gzip → Upload Backblaze B2 → Limpeza de backups antigos

PostgreSQL (Automatizado)

O backup roda automaticamente a cada 6 horas (00:00, 06:00, 12:00, 18:00) via cron.

# Testar backup manualmente
bash ~/cscases-backend/scripts/backup-db.sh

# Listar backups (local + remoto)
bash ~/cscases-backend/scripts/restore-db.sh --list

# Restaurar de backup remoto (Backblaze B2)
bash ~/cscases-backend/scripts/restore-db.sh --remote daily/procases_2026-03-04_06-00-00.sql.gz

# Restaurar de backup local
bash ~/cscases-backend/scripts/restore-db.sh --local ~/backups/db/daily/procases_2026-03-04_06-00-00.sql.gz

# Apenas baixar sem restaurar
bash ~/cscases-backend/scripts/restore-db.sh --download daily/procases_2026-03-04_06-00-00.sql.gz

Scripts

Script	Funcao
scripts/backup-db.sh	Backup automatico (pg_dump → gzip → upload B2 → limpeza)
scripts/setup-backup.sh	Setup inicial - instala AWS CLI, configura cron (rodar 1x)
scripts/restore-db.sh	Restore de emergencia com confirmacao obrigatoria

Storage Remoto

Configuracao	Valor
Provider	Backblaze B2
Bucket	procases-backups (privado, criptografado)
Endpoint	s3.us-east-005.backblazeb2.com
Regiao	us-east-005
API	S3-compatible (usa AWS CLI)

Retencao

Tipo	Frequencia	Retencao
Diario	A cada 6h (00, 06, 12, 18h)	7 ultimos
Semanal	Domingos	4 ultimos

Variaveis de Ambiente

B2_KEY_ID=<backblaze_key_id>
B2_APPLICATION_KEY=<backblaze_application_key>
B2_BUCKET_NAME=procases-backups
B2_ENDPOINT=s3.us-east-005.backblazeb2.com
B2_REGION=us-east-005

Setup Inicial (rodar 1x no servidor)

sudo bash ~/cscases-backend/scripts/setup-backup.sh

Isso instala AWS CLI, cria diretorios e configura o cron automaticamente.

Redis

Redis usa AOF (Append Only File) habilitado via --appendonly yes no Docker. O arquivo persiste no volume redis-data. Em caso de perda total do servidor, as sessions e cache sao recriados automaticamente - nao ha necessidade de backup dedicado para Redis pois nenhum dado critico depende exclusivamente dele.

Logs

Local	Conteudo
~/backups/db/backup.log	Log de todas as execucoes de backup
~/backups/db/cron.log	Output do cron

Troubleshooting

# Verificar se o cron esta ativo
crontab -l

# Verificar ultimo backup
tail -20 ~/backups/db/backup.log

# Verificar container PostgreSQL
docker ps | grep postgres

# Testar conexao com B2
AWS_ACCESS_KEY_ID=$B2_KEY_ID AWS_SECRET_ACCESS_KEY=$B2_APPLICATION_KEY \
  aws s3 ls s3://procases-backups/ --endpoint-url https://s3.us-east-005.backblazeb2.com