Trivy/docs/INSTALLATION.md

Guía de Instalación - Trivy

Requisitos Previos

Software Requerido

Software	Versión Mínima	Notas
Python	3.11+	Con pip
Node.js	18+	Con npm
PostgreSQL	15+	O Docker
Redis	7+	O Docker
Git	2.0+	Para clonar

API Keys

• Anthropic Claude API - Obtener en https://console.anthropic.com

Opción 1: Instalación con Docker (Recomendado)

1. Clonar repositorio

git clone https://gitea.local/frank/Trivy.git
cd Trivy

2. Configurar variables de entorno

# Backend
cp backend/.env.example backend/.env

# Editar backend/.env:
DATABASE_URL=postgresql+asyncpg://trivy:trivy@db:5432/trivy
REDIS_URL=redis://redis:6379
ANTHROPIC_API_KEY=sk-ant-api03-YOUR_KEY_HERE

# Frontend
cp frontend/.env.example frontend/.env

# Editar frontend/.env:
VITE_API_URL=http://localhost:8000
VITE_WS_URL=http://localhost:8000

3. Iniciar con Docker Compose

docker-compose up -d

Esto iniciará:

• PostgreSQL en puerto 5432
• Redis en puerto 6379
• Backend en puerto 8000
• Frontend en puerto 3000

4. Ejecutar migraciones

docker-compose exec backend alembic upgrade head

5. Crear datos iniciales

docker-compose exec backend python scripts/seed_data.py

6. Acceder

• Frontend: http://localhost:3000
• Admin: http://localhost:3000/admin (admin/admin123)
• API: http://localhost:8000/docs

---

Opción 2: Instalación Manual

1. Clonar repositorio

git clone https://gitea.local/frank/Trivy.git
cd Trivy

2. Configurar PostgreSQL

# Crear usuario y base de datos
sudo -u postgres psql

CREATE USER trivy WITH PASSWORD 'trivy';
CREATE DATABASE trivy OWNER trivy;
GRANT ALL PRIVILEGES ON DATABASE trivy TO trivy;
\q

3. Configurar Redis

# Ubuntu/Debian
sudo apt install redis-server
sudo systemctl start redis
sudo systemctl enable redis

# Verificar
redis-cli ping
# Respuesta: PONG

4. Configurar Backend

cd backend

# Crear entorno virtual
python3 -m venv venv
source venv/bin/activate

# Instalar dependencias
pip install -r requirements.txt

# Configurar variables de entorno
cp .env.example .env

Editar backend/.env:

# Base de datos
DATABASE_URL=postgresql+asyncpg://trivy:trivy@localhost:5432/trivy

# Redis
REDIS_URL=redis://localhost:6379

# Anthropic API
ANTHROPIC_API_KEY=sk-ant-api03-YOUR_KEY_HERE

# Configuración del juego
STEAL_PENALTY_MULTIPLIER=0.5
STEAL_TIME_MULTIPLIER=0.5
ROOM_TTL_HOURS=3

# CORS (separar con comas)
CORS_ORIGINS=http://localhost:3000,http://localhost:5173

5. Ejecutar migraciones

cd backend
source venv/bin/activate
alembic upgrade head

6. Crear usuario admin

python -c "
import asyncio
from app.models.base import get_async_session
from app.models.admin import Admin

async def create_admin():
    AsyncSession = get_async_session()
    async with AsyncSession() as db:
        admin = Admin(username='admin')
        admin.set_password('admin123')
        db.add(admin)
        await db.commit()
        print('Admin creado: admin/admin123')

asyncio.run(create_admin())
"

7. Crear categorías

python -c "
import asyncio
from app.models.base import get_async_session
from app.models.category import Category

categories = [
    ('Nintendo', '🍄', '#E60012'),
    ('Xbox', '🎮', '#107C10'),
    ('PlayStation', '🎯', '#003791'),
    ('Anime', '⛩️', '#FF6B9D'),
    ('Música', '🎵', '#1DB954'),
    ('Películas', '🎬', '#F5C518'),
    ('Libros', '📚', '#8B4513'),
    ('Historia', '🏛️', '#6B5B95'),
]

async def create_categories():
    AsyncSession = get_async_session()
    async with AsyncSession() as db:
        for name, icon, color in categories:
            cat = Category(name=name, icon=icon, color=color)
            db.add(cat)
        await db.commit()
        print(f'{len(categories)} categorías creadas')

asyncio.run(create_categories())
"

8. Crear preguntas (ejecutar script completo)

python scripts/seed_questions.py

9. Configurar Frontend

cd frontend

# Instalar dependencias
npm install

# Configurar variables de entorno
cp .env.example .env

Editar frontend/.env:

VITE_API_URL=http://localhost:8000
VITE_WS_URL=http://localhost:8000

10. Iniciar servicios

Terminal 1 - Backend:

cd backend
source venv/bin/activate
uvicorn app.main:socket_app --host 0.0.0.0 --port 8000 --reload

Terminal 2 - Frontend:

cd frontend
npm run dev -- --host

11. Acceder

• Frontend: http://localhost:3000
• Admin: http://localhost:3000/admin
• API Docs: http://localhost:8000/docs

---

Configuración para Red Local

Para permitir acceso desde otros dispositivos en la red:

1. Obtener IP local

ip addr show | grep "inet " | grep -v 127.0.0.1
# Ejemplo: 192.168.1.100

2. Actualizar configuración

backend/.env:

CORS_ORIGINS=http://localhost:3000,http://192.168.1.100:3000

frontend/.env:

VITE_API_URL=http://192.168.1.100:8000
VITE_WS_URL=http://192.168.1.100:8000

3. Iniciar con host 0.0.0.0

# Backend
uvicorn app.main:socket_app --host 0.0.0.0 --port 8000

# Frontend
npm run dev -- --host

4. Acceder desde otros dispositivos

• http://192.168.1.100:3000

---

Producción

Backend con Gunicorn

pip install gunicorn

gunicorn app.main:socket_app \
  -w 4 \
  -k uvicorn.workers.UvicornWorker \
  -b 0.0.0.0:8000 \
  --access-logfile - \
  --error-logfile -

Frontend Build

cd frontend
npm run build

# Servir con cualquier servidor estático
# Ejemplo con serve:
npm install -g serve
serve -s dist -l 3000

Nginx como Reverse Proxy

# /etc/nginx/sites-available/trivy
server {
    listen 80;
    server_name trivy.example.com;

    # Frontend
    location / {
        root /var/www/trivy/frontend/dist;
        try_files $uri $uri/ /index.html;
    }

    # API
    location /api {
        proxy_pass http://127.0.0.1:8000;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    # WebSocket
    location /socket.io {
        proxy_pass http://127.0.0.1:8000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
    }
}

Systemd Service

# /etc/systemd/system/trivy-backend.service
[Unit]
Description=Trivy Backend
After=network.target postgresql.service redis.service

[Service]
Type=simple
User=www-data
WorkingDirectory=/var/www/trivy/backend
Environment=PATH=/var/www/trivy/backend/venv/bin
ExecStart=/var/www/trivy/backend/venv/bin/gunicorn app.main:socket_app -w 4 -k uvicorn.workers.UvicornWorker -b 127.0.0.1:8000
Restart=always

[Install]
WantedBy=multi-user.target

sudo systemctl enable trivy-backend
sudo systemctl start trivy-backend

---

Solución de Problemas

Error: "Could not connect to Redis"

# Verificar Redis
redis-cli ping

# Si no responde, iniciar Redis
sudo systemctl start redis

Error: "Database connection failed"

# Verificar PostgreSQL
sudo systemctl status postgresql

# Verificar credenciales
psql -U trivy -d trivy -h localhost

Error: "CORS blocked"

Verificar que la URL del frontend esté en CORS_ORIGINS del backend.

WebSocket no conecta

1. Verificar que VITE_WS_URL use http:// (no ws://)
2. Verificar que el backend use socket_app (no app)
3. Verificar firewall/puertos

Preguntas no cargan

# Verificar preguntas en BD
cd backend
source venv/bin/activate
python -c "
import asyncio
from sqlalchemy import select
from app.models.base import get_async_session
from app.models.question import Question
from datetime import date

async def check():
    AsyncSession = get_async_session()
    async with AsyncSession() as db:
        result = await db.execute(
            select(Question).where(Question.date_active == date.today())
        )
        qs = result.scalars().all()
        print(f'Preguntas para hoy: {len(qs)}')

asyncio.run(check())
"

Sonidos no funcionan

Los sonidos requieren archivos MP3 en /public/sounds/{tema}/. Si no existen, el sistema usa fallbacks generados por Web Audio API (tonos simples).

---

Actualizaciones

cd Trivy
git pull origin main

# Backend
cd backend
source venv/bin/activate
pip install -r requirements.txt
alembic upgrade head

# Frontend
cd frontend
npm install
npm run build

# Reiniciar servicios
sudo systemctl restart trivy-backend