Requisitos del Sistema

Requisitos Técnicos

Hardware Mínimo

Para Desarrollo Local

CPU:

Procesador de 4 núcleos a 2.5 GHz o superior
Arquitectura x86_64 (AMD64/Intel 64-bit)
Soporte para instrucciones AVX recomendado

Memoria RAM:

Mínimo: 8 GB RAM
Recomendado: 16 GB RAM
Óptimo: 32 GB RAM o más

Almacenamiento:

Mínimo: 20 GB de espacio libre
Recomendado: SSD con 50 GB de espacio libre
Modelos ML: 5-10 GB adicionales para modelos entrenados

GPU (Opcional):

NVIDIA GPU con soporte CUDA 11.0+
Mínimo 4 GB VRAM para aceleración ML
Recomendado 8 GB VRAM o más

Para Producción

CPU:

8+ núcleos a 3.0 GHz o superior
Soporte para múltiples threads
Arquitectura moderna (Intel Xeon, AMD EPYC)

Memoria RAM:

Pequeña escala: 32 GB RAM
Mediana escala: 64 GB RAM
Gran escala: 128 GB RAM o más

Almacenamiento:

Sistema: SSD NVMe 100 GB+
Datos: SSD/HDD 500 GB+ según volumen
Backup: Espacio adicional para respaldos

Red:

Conexión de alta velocidad (1 Gbps+)
Baja latencia para APIs externas
Balanceadores de carga para alta disponibilidad

Software Base

Sistemas Operativos Soportados

Linux (Recomendado):

# Ubuntu 20.04 LTS o superior
Ubuntu 20.04+, 22.04+

# CentOS/RHEL 8+ 
CentOS 8+, Red Hat Enterprise Linux 8+

# Debian 11+
Debian 11 (Bullseye) o superior

# Amazon Linux 2
Amazon Linux 2 AMI

Windows:

# Windows 10/11
Windows 10 Pro/Enterprise (versión 1909+)
Windows 11 Pro/Enterprise

# Windows Server
Windows Server 2019/2022

macOS:

# macOS 11.0+
macOS Big Sur (11.0) o superior
macOS Monterey (12.0) recomendado

Dependencias del Sistema

Python 3.11+:

# Instalación en Ubuntu/Debian
sudo apt update
sudo apt install python3.11 python3.11-venv python3.11-dev

# Instalación en CentOS/RHEL
sudo dnf install python3.11 python3.11-devel

# Verificar instalación
python3.11 --version

Node.js 18+:

# Usando NodeSource
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt-get install -y nodejs

# Verificar instalación
node --version
npm --version

Docker y Docker Compose:

# Instalar Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Instalar Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# Verificar instalación
docker --version
docker-compose --version

Git:

# Ubuntu/Debian
sudo apt install git

# CentOS/RHEL
sudo dnf install git

# Verificar instalación
git --version

Dependencias de Python

Librerías Core

# requirements.txt - Core dependencies
fastapi==0.104.1
uvicorn[standard]==0.24.0
pydantic==2.5.0
httpx==0.25.2
redis==5.0.1
psycopg2-binary==2.9.9
sqlalchemy==2.0.23
alembic==1.13.1

Machine Learning

# ML dependencies
torch==2.1.2
torchvision==0.16.2
paddlepaddle==2.5.2
paddleocr==2.7.0.3
timm==0.9.12
scikit-learn==1.3.2
opencv-python==4.8.1.78
pillow==10.1.0
numpy==1.24.4

Utilidades

# Utility dependencies
python-multipart==0.0.6
python-jose[cryptography]==3.3.0
passlib[bcrypt]==1.7.4
python-dotenv==1.0.0
loguru==0.7.2
prometheus-client==0.19.0
aiofiles==23.2.1

Configuración de Red

Puertos Requeridos

Servicios Principales:

# docker-compose.yml ports
api-gateway: 8000
image-processor: 8001  
ml-embeddings: 8002
ml-classifier: 8003
ocr-extractor: 8004

Servicios de Infraestructura:

# Infrastructure ports
postgres: 5432
redis: 6379
nginx: 80, 443
prometheus: 9090
grafana: 3000

Desarrollo:

# Development ports
docusaurus: 3000
jupyter: 8888
tensorboard: 6006

Firewall Configuration

# Ubuntu/Debian - UFW
sudo ufw allow 8000:8004/tcp  # IRIS services
sudo ufw allow 5432/tcp       # PostgreSQL
sudo ufw allow 6379/tcp       # Redis
sudo ufw allow 80,443/tcp     # HTTP/HTTPS

# CentOS/RHEL - Firewalld
sudo firewall-cmd --permanent --add-port=8000-8004/tcp
sudo firewall-cmd --permanent --add-port=5432/tcp
sudo firewall-cmd --permanent --add-port=6379/tcp
sudo firewall-cmd --permanent --add-service=http
sudo firewall-cmd --permanent --add-service=https
sudo firewall-cmd --reload

Variables de Entorno

Configuración Básica

# .env file
# API Configuration
API_GATEWAY_HOST=0.0.0.0
API_GATEWAY_PORT=8000
API_GATEWAY_WORKERS=4

# Database Configuration
DATABASE_URL=postgresql://iris:password@localhost:5432/iris_db
DATABASE_POOL_SIZE=20
DATABASE_MAX_OVERFLOW=30

# Redis Configuration  
REDIS_URL=redis://localhost:6379/0
REDIS_MAX_CONNECTIONS=20

# JWT Configuration
JWT_SECRET_KEY=your-super-secret-jwt-key-change-in-production
JWT_ALGORITHM=HS256
JWT_ACCESS_TOKEN_EXPIRE_MINUTES=30

# ML Configuration
ML_MODEL_PATH=/app/data/models
ML_BATCH_SIZE=8
ML_DEVICE=cpu  # or cuda for GPU

# OCR Configuration
OCR_LANGUAGES=es,en,fr
OCR_USE_GPU=false
OCR_CONFIDENCE_THRESHOLD=0.7

# Logging
LOG_LEVEL=INFO
LOG_FORMAT=json
LOG_FILE=/var/log/iris/app.log

Configuración de Producción

# Production environment variables
ENVIRONMENT=production
DEBUG=false
CORS_ORIGINS=["https://iris.yourdomain.com"]

# Security
ALLOWED_HOSTS=["iris.yourdomain.com", "api.iris.yourdomain.com"]
SECURE_COOKIES=true
SECURE_HEADERS=true

# Performance
WORKERS_PER_CORE=2
MAX_WORKERS=16
WORKER_TIMEOUT=300
KEEP_ALIVE=5

# Monitoring
PROMETHEUS_ENABLED=true
METRICS_PORT=9090
HEALTH_CHECK_INTERVAL=30

Base de Datos

PostgreSQL Setup

-- Create database and user
CREATE DATABASE iris_db;
CREATE USER iris WITH ENCRYPTED PASSWORD 'your-secure-password';
GRANT ALL PRIVILEGES ON DATABASE iris_db TO iris;

-- Connect to iris_db and grant schema permissions
\c iris_db
GRANT ALL ON SCHEMA public TO iris;
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO iris;
GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO iris;

PostgreSQL Configuration

# postgresql.conf optimizations
shared_buffers = 256MB
effective_cache_size = 1GB
maintenance_work_mem = 64MB
checkpoint_completion_target = 0.9
wal_buffers = 16MB
default_statistics_target = 100
random_page_cost = 1.1
effective_io_concurrency = 200

Redis Configuration

# redis.conf
maxmemory 2gb
maxmemory-policy allkeys-lru
save 900 1
save 300 10
save 60 10000

Verificación de Requisitos

Script de Verificación

#!/usr/bin/env python3
"""
Script para verificar que todos los requisitos estén instalados
"""
import sys
import subprocess
import pkg_resources
from packaging import version

def check_python_version():
    """Verificar versión de Python"""
    required = version.parse("3.11.0")
    current = version.parse(f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}")
    
    if current >= required:
        print(f"✅ Python {current} (requerido: {required}+)")
        return True
    else:
        print(f"❌ Python {current} (requerido: {required}+)")
        return False

def check_command(command, required_version=None):
    """Verificar que un comando esté disponible"""
    try:
        result = subprocess.run([command, "--version"], 
                              capture_output=True, text=True)
        if result.returncode == 0:
            if required_version:
                # Extraer versión y comparar
                output = result.stdout.strip()
                print(f"✅ {command}: {output}")
            else:
                print(f"✅ {command}: Disponible")
            return True
        else:
            print(f"❌ {command}: No disponible")
            return False
    except FileNotFoundError:
        print(f"❌ {command}: No encontrado")
        return False

def check_python_packages():
    """Verificar paquetes de Python instalados"""
    required_packages = [
        'fastapi>=0.104.0',
        'torch>=2.1.0',
        'paddlepaddle>=2.5.0',
        'opencv-python>=4.8.0'
    ]
    
    all_installed = True
    for package in required_packages:
        try:
            pkg_resources.require(package)
            print(f"✅ {package}: Instalado")
        except pkg_resources.DistributionNotFound:
            print(f"❌ {package}: No instalado")
            all_installed = False
        except pkg_resources.VersionConflict as e:
            print(f"❌ {package}: Conflicto de versión - {e}")
            all_installed = False
    
    return all_installed

def check_docker():
    """Verificar Docker y Docker Compose"""
    docker_ok = check_command("docker")
    compose_ok = check_command("docker-compose") or check_command("docker", ["compose", "version"])
    return docker_ok and compose_ok

def main():
    """Función principal de verificación"""
    print("🔍 Verificando requisitos del sistema IRIS...\n")
    
    checks = [
        ("Python 3.11+", check_python_version),
        ("Node.js", lambda: check_command("node")),
        ("Git", lambda: check_command("git")),
        ("Docker", check_docker),
        ("Paquetes Python", check_python_packages)
    ]
    
    results = []
    for name, check_func in checks:
        print(f"\n📋 Verificando {name}:")
        results.append(check_func())
    
    print("\n" + "="*50)
    if all(results):
        print("🎉 ¡Todos los requisitos están satisfechos!")
        print("Puedes proceder con la instalación de IRIS.")
    else:
        print("⚠️  Algunos requisitos no están satisfechos.")
        print("Por favor, instala las dependencias faltantes antes de continuar.")
    
    return all(results)

if __name__ == "__main__":
    success = main()
    sys.exit(0 if success else 1)

Uso del Script

# Hacer ejecutable
chmod +x check_requirements.py

# Ejecutar verificación
python3 check_requirements.py

# O con Python directamente
python3 -c "
import subprocess
import sys
result = subprocess.run([sys.executable, 'check_requirements.py'])
sys.exit(result.returncode)
"

Troubleshooting Común

Problemas de Instalación

Error: Python 3.11 no encontrado

# Ubuntu/Debian - Agregar repositorio deadsnakes
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update
sudo apt install python3.11 python3.11-venv python3.11-dev

Error: OpenCV no se instala

# Instalar dependencias del sistema para OpenCV
sudo apt install libglib2.0-0 libsm6 libxext6 libxrender-dev libgl1-mesa-glx

Error: PaddleOCR requires paddlepaddle

# Instalar PaddlePaddle primero
pip install paddlepaddle==2.5.2
pip install paddleocr==2.7.0.3

Error: Docker permission denied

# Agregar usuario al grupo docker
sudo usermod -aG docker $USER
newgrp docker

Problemas de Memoria

Out of Memory durante entrenamiento

# Reducir batch size en configuración
ML_BATCH_SIZE=4  # Default: 8
ML_WORKERS=2     # Default: 4

Redis out of memory

# Aumentar límite de memoria Redis
redis-cli CONFIG SET maxmemory 4gb
redis-cli CONFIG SET maxmemory-policy allkeys-lru

Problemas de Red

Puertos en uso

# Verificar qué está usando el puerto
sudo netstat -tulpn | grep :8000

# Cambiar puerto en configuración
API_GATEWAY_PORT=8080

Firewall bloqueando conexiones

# Verificar estado del firewall
sudo ufw status
sudo firewall-cmd --list-all

# Agregar reglas necesarias
sudo ufw allow 8000:8004/tcp

Requisitos Técnicos​

Hardware Mínimo​

Para Desarrollo Local​

Para Producción​

Software Base​

Sistemas Operativos Soportados​

Dependencias del Sistema​

Dependencias de Python​

Librerías Core​

Machine Learning​

Utilidades​

Configuración de Red​

Puertos Requeridos​

Firewall Configuration​

Variables de Entorno​

Configuración Básica​

Configuración de Producción​

Base de Datos​

PostgreSQL Setup​

PostgreSQL Configuration​

Redis Configuration​

Verificación de Requisitos​

Script de Verificación​

Uso del Script​

Troubleshooting Común​

Problemas de Instalación​

Problemas de Memoria​

Problemas de Red​