Sistema de almacenamiento cloud con microservicios en Go. Subida con chunking (4MB), compresion gzip, cifrado AES-256-GCM por usuario, autenticacion JWT y API Gateway unificado.

                   ┌──────────────┐
                   │  API Gateway  │ :8080
                   └────┬────┬────┘
                        │    │
              ┌─────────┤    ├──────────┐
              │         │    │          │
         ┌────▼──┐ ┌───▼──┐ ┌▼────┐    │
         │ Upload│ │ Read │ │Auth │    │
         │ :3001 │ │:3002 │ │:3300│    │
         └───┬───┘ └──┬───┘ └─────┘    │
             │        │                 │
         ┌───▼────────▼───┐             │
         │  Storage       │◄────────────┘
         │  :3003         │  (internal)
         └────────────────┘

• Go 1.26 + Fiber v3
• PostgreSQL — metadatos de archivos y chunks
• JWT (golang-jwt/v5) — autenticacion
• AES-256-GCM + gzip — cifrado y compresion por usuario
• Chunking 4MB — archivos divididos en fragmentos

• Go 1.26+
• Docker (para PostgreSQL)
• Credenciales de OAuth2 de Google (opcional, para login con Google)

docker compose up -d

Cada servicio tiene un example.env. Copiarlo a .env y ajustar si es necesario:

cp auth_service/example.env auth_service/.env
cp api_gateway/example.env api_gateway/.env
cp upload_service/example.env upload_service/.env
cp read_service/example.env read_service/.env
cp storage_service/example.env storage_service/.env

go run ./auth_service/cmd/gentoken -user testuser123

# Terminal 1 — Storage (interno)
cd storage_service && go run .

# Terminal 2 — Upload
cd upload_service && go run .

# Terminal 3 — Read
cd read_service && go run .

# Terminal 4 — Auth
cd auth_service && go run .

# Terminal 5 — API Gateway
cd api_gateway && go run .

TOKEN="eyJ..."

# Subir archivo
curl -X POST http://localhost:8080/api/upload/init \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"path":"fotos/vacaciones.jpg","size":10485760,"mime_type":"image/jpeg"}'

# Listar
curl http://localhost:8080/api/read/list?prefix=fotos/ \
  -H "Authorization: Bearer $TOKEN"

# Descargar
curl -o descarga.jpg http://localhost:8080/api/read/files/fotos/vacaciones.jpg \
  -H "Authorization: Bearer $TOKEN"

Todas las rutas pasan por el API Gateway (http://localhost:8080).

• Chunking: archivos divididos en fragmentos de 4MB
• Compresion: gzip por chunk antes de cifrar
• Cifrado: AES-256-GCM con clave derivada por usuario (HMAC(ENCRYPTION_KEY, user_id))
• JWT: tokens HS256 con 24h de expiracion
• Aislamiento: Storage Service no expuesto al exterior, solo accesible con API Key interna

├── api_gateway/         # API Gateway (Fiber, CORS, rate limiting, JWT edge)
├── auth_service/        # Autenticacion (Google OAuth, JWT, usuarios)
│   └── cmd/gentoken/    # CLI para generar tokens de prueba
├── read_service/        # Lectura (descarga con streaming + crypto)
├── storage_service/     # Almacenamiento (FS抽象, API Key interna)
├── upload_service/      # Subida (chunking, crypto, metadata)
├── docker-compose.yml   # PostgreSQL
└── README.md

• Validacion de chunk size en Complete — verificar que el tamano declarado en Init coincida con la suma real de los chunks
• Compartir archivos — links publicos con expiracion
• Parallel chunk upload — el backend ya lo soporta (no requiere orden), el frontend deberia aprovecharlo
• Dockerizar servicios — Dockerfile para cada microservicio

MIT