# 🐳 SIDEL ScriptsManager - Guía de Docker Build

## 📋 Flujo de Trabajo para Cambios en Scripts

### 🔄 Cambios Regulares en Scripts (Sin reconstruir imagen)

Para cambios en scripts que están en volúmenes montados:

```bash
# 1. Realizar cambios en:
#    - app/backend/script_groups/
#    - Archivos de configuración Python

# 2. Reiniciar solo el contenedor (NO reconstruir imagen)
sudo ./docker-manage.sh restart

# 3. Verificar cambios
sudo ./docker-manage.sh logs
```

**✅ Ventaja**: Los volúmenes montados reflejan cambios inmediatamente.

### 🏗️ Cambios que Requieren Reconstruir Imagen

Reconstruir imagen cuando cambies:
- **Dockerfile**
- **requirements.txt** o **requirements-dev.txt**
- **app/backend/script_groups/hammer/requirements.txt** (TSNet)
- **Estructura de directorios** dentro del contenedor
- **Scripts de inicialización** (docker-entrypoint.sh)
- **Entornos conda** (agregar/modificar)

### 🔨 Proceso Completo de Rebuild

```bash
# 1. Detener contenedor actual
sudo ./docker-manage.sh stop

# 2. Reconstruir imagen (esto puede tomar varios minutos)
sudo ./docker-manage.sh build

# 3. Iniciar con nueva imagen
sudo ./docker-manage.sh start

# 4. Verificar que todo funciona
sudo ./verify-environments.sh
```

### ⚡ Comando Rápido de Rebuild

```bash
# Todo en una línea
sudo ./docker-manage.sh rebuild

# O manualmente:
sudo ./docker-manage.sh stop && sudo ./docker-manage.sh build && sudo ./docker-manage.sh start
```

---

## 🐍 Agregar Nuevo Entorno Miniconda

### Paso 1: Modificar Dockerfile

Agregar el nuevo entorno después de los existentes:

```dockerfile
# Entornos existentes (scriptsmanager, tsnet)
# ...

# NUEVO ENTORNO: ejemplo para análisis de datos
RUN conda create -n data_analysis python=3.12 -y

# Instalar dependencias específicas del nuevo entorno
RUN /opt/conda/envs/data_analysis/bin/pip install --no-cache-dir \
    pandas>=2.0.0 \
    numpy>=1.24.0 \
    scipy>=1.10.0 \
    scikit-learn>=1.3.0 \
    jupyter>=1.0.0
```

### Paso 2: Actualizar Variables de Entorno (Opcional)

En `docker-compose.yml`:

```yaml
environment:
  # Entornos existentes
  - CONDA_DEFAULT_ENV=scriptsmanager
  - TSNET_ENV=tsnet
  # Nuevo entorno
  - DATA_ANALYSIS_ENV=data_analysis
```

### Paso 3: Crear Archivo de Requirements (Opcional)

Crear `requirements-data-analysis.txt`:

```txt
pandas>=2.0.0
numpy>=1.24.0
scipy>=1.10.0
scikit-learn>=1.3.0
jupyter>=1.0.0
seaborn>=0.12.0
plotly>=5.15.0
```

Luego modificar Dockerfile:

```dockerfile
# Copiar requirements del nuevo entorno
COPY requirements-data-analysis.txt ./

# Crear e instalar en el nuevo entorno
RUN conda create -n data_analysis python=3.12 -y
RUN /opt/conda/envs/data_analysis/bin/pip install --no-cache-dir -r requirements-data-analysis.txt
```

### Paso 4: Actualizar Script de Verificación

Modificar `verify-environments.sh`:

```bash
# Verificar nuevo entorno data_analysis
echo "🔍 Verificando entorno data_analysis..."
DATA_ANALYSIS_PYTHON=$(docker exec sidel_scriptsmanager bash -c "source activate data_analysis && python --version")
echo "   Python version: $DATA_ANALYSIS_PYTHON"

PANDAS_VERSION=$(docker exec sidel_scriptsmanager bash -c "source activate data_analysis && python -c 'import pandas; print(f\"Pandas {pandas.__version__}\")'" 2>/dev/null)
if [ $? -eq 0 ]; then
    echo "   ✅ $PANDAS_VERSION"
else
    echo "   ❌ Error importando Pandas"
fi
```

### Paso 5: Rebuild y Verificar

```bash
# Reconstruir con nuevo entorno
sudo ./docker-manage.sh rebuild

# Verificar nuevo entorno
sudo ./docker-manage.sh shell
conda env list
conda activate data_analysis
python -c "import pandas; print('Pandas funcionando!')"
exit
```

---

## 📁 Estructura de Archivos para Nuevos Entornos

### Opción 1: Requirements Separados

```
SIDELManagerScripts/
├── Dockerfile
├── requirements.txt              # Entorno scriptsmanager
├── requirements-tsnet.txt        # Entorno TSNet (ya existe)
├── requirements-data-analysis.txt # Nuevo entorno
├── requirements-ml.txt           # Otro entorno futuro
└── docker-compose.yml
```

### Opción 2: Estructura Organizada

```
SIDELManagerScripts/
├── Dockerfile
├── docker/
│   ├── environments/
│   │   ├── scriptsmanager.txt
│   │   ├── tsnet.txt
│   │   ├── data-analysis.txt
│   │   └── machine-learning.txt
│   └── scripts/
└── docker-compose.yml
```

---

## 🔧 Comandos de Gestión de Entornos

### Listar Entornos Disponibles

```bash
# Desde host
sudo ./docker-manage.sh envs

# Desde dentro del contenedor
sudo ./docker-manage.sh shell
conda env list
```

### Probar Entorno Específico

```bash
# Acceder al contenedor
sudo ./docker-manage.sh shell

# Cambiar a entorno específico
conda activate data_analysis

# Probar importaciones
python -c "import pandas, numpy, scipy; print('Todo OK!')"

# Salir
exit
```

### Agregar Paquetes a Entorno Existente

```bash
# Método 1: Desde contenedor (temporal)
sudo ./docker-manage.sh shell
conda activate data_analysis
pip install matplotlib
exit

# Método 2: Permanente (modificar Dockerfile + rebuild)
# Editar Dockerfile y hacer rebuild completo
```

---

## ⚠️ Mejores Prácticas

### ✅ DO (Hacer)

1. **Usar volúmenes** para código que cambia frecuentemente
2. **Documentar dependencies** en requirements.txt separados
3. **Probar entornos** después de cada cambio
4. **Usar nombres descriptivos** para entornos
5. **Mantener entornos pequeños** y especializados

### ❌ DON'T (No hacer)

1. **No reconstruir** imagen para cambios simples de código
2. **No mezclar dependencias** incompatibles en un entorno
3. **No olvidar** actualizar scripts de verificación
4. **No usar pip dentro de contenedores** para cambios permanentes
5. **No crear entornos** demasiado pesados

---

## 🚀 Ejemplos de Entornos Comunes

### Entorno de Machine Learning

```dockerfile
# Entorno ML
RUN conda create -n machine_learning python=3.12 -y
RUN /opt/conda/envs/machine_learning/bin/pip install --no-cache-dir \
    tensorflow>=2.13.0 \
    torch>=2.0.0 \
    scikit-learn>=1.3.0 \
    pandas>=2.0.0 \
    numpy>=1.24.0 \
    matplotlib>=3.7.0 \
    seaborn>=0.12.0 \
    jupyter>=1.0.0
```

### Entorno de Web Scraping

```dockerfile
# Entorno Web Scraping
RUN conda create -n web_scraping python=3.12 -y
RUN /opt/conda/envs/web_scraping/bin/pip install --no-cache-dir \
    requests>=2.31.0 \
    beautifulsoup4>=4.12.0 \
    selenium>=4.15.0 \
    scrapy>=2.11.0 \
    pandas>=2.0.0 \
    lxml>=4.9.0
```

### Entorno de Procesamiento de Imágenes

```dockerfile
# Entorno Image Processing
RUN conda create -n image_processing python=3.12 -y
RUN /opt/conda/envs/image_processing/bin/pip install --no-cache-dir \
    opencv-python>=4.8.0 \
    pillow>=10.0.0 \
    scikit-image>=0.21.0 \
    matplotlib>=3.7.0 \
    numpy>=1.24.0
```

---

## 📝 Checklist para Agregar Nuevo Entorno

- [ ] Crear archivo requirements-[nombre].txt
- [ ] Modificar Dockerfile con nuevo entorno
- [ ] Actualizar docker-compose.yml (variables de entorno)
- [ ] Actualizar verify-environments.sh
- [ ] Reconstruir imagen: `sudo ./docker-manage.sh rebuild`
- [ ] Verificar funcionamiento: `sudo ./verify-environments.sh`
- [ ] Probar entorno manualmente: `sudo ./docker-manage.sh shell`
- [ ] Documentar uso del nuevo entorno

---

## 🔍 Troubleshooting

### Problema: Error al construir imagen

```bash
# Ver logs detallados
sudo ./docker-manage.sh build | tee build.log

# Limpiar cache de Docker
docker system prune -f
```

### Problema: Entorno no aparece

```bash
# Verificar que se creó correctamente
sudo ./docker-manage.sh shell
conda env list
```

### Problema: Conflictos de dependencias

```bash
# Crear entorno limpio y probar dependencias una por una
conda create -n test_env python=3.12 -y
conda activate test_env
pip install paquete1
pip install paquete2  # Ver si hay conflicto
```

---

## 🛠️ Comandos de Gestión Rápidos

### Verificar Estado Actual

```bash
# Ver contenedores activos
sudo ./docker-manage.sh status

# Ver entornos conda disponibles
sudo ./docker-manage.sh envs

# Verificar salud del sistema
sudo ./docker-manage.sh health

# Ver logs en tiempo real
sudo ./docker-manage.sh logs
```

### Comandos de Desarrollo Frecuentes

```bash
# Rebuild completo (cuando cambias dependencies)
sudo ./docker-manage.sh rebuild

# Ver flujo de trabajo
sudo ./docker-manage.sh workflow

# Solo reiniciar (para cambios de código)
sudo ./docker-manage.sh restart

# Acceder al contenedor para debug
sudo ./docker-manage.sh shell
```

### Verificar Después de Cambios

```bash
# Verificar todos los entornos
sudo ./verify-environments.sh

# Probar frontend
curl -I http://localhost:5002

# Ver puertos en uso
sudo ./docker-manage.sh ports
```

---

## 📝 Ejemplo Práctico: Agregando Entorno de Data Science

### 1. Crear archivo de requirements

```bash
# Crear requirements-datascience.txt
cat > requirements-datascience.txt << EOF
pandas>=2.0.0
numpy>=1.24.0
scipy>=1.10.0
scikit-learn>=1.3.0
matplotlib>=3.7.0
seaborn>=0.12.0
jupyter>=1.0.0
plotly>=5.15.0
notebook>=6.5.0
EOF
```

### 2. Modificar Dockerfile

```dockerfile
# Agregar al final del Dockerfile, antes de USER scriptsmanager
# Entorno Data Science
RUN conda create -n datascience python=3.12 -y

# Copiar requirements
COPY requirements-datascience.txt ./

# Instalar dependencias
RUN /opt/conda/envs/datascience/bin/pip install --no-cache-dir -r requirements-datascience.txt

# Limpiar
RUN rm requirements-datascience.txt
```

### 3. Ejecutar rebuild

```bash
# Rebuild completo
sudo ./docker-manage.sh rebuild

# Verificar nuevo entorno
sudo ./docker-manage.sh shell
conda env list
conda activate datascience
python -c "import pandas, numpy, matplotlib; print('Data Science OK!')"
exit
```

### 4. Verificar funcionamiento

```bash
# Verificar que el entorno está disponible
sudo ./docker-manage.sh envs | grep datascience

# Ejecutar script de verificación
sudo ./verify-environments.sh
```

---

## 🔍 Debug y Troubleshooting Avanzado

### Problema: Imagen muy grande

```bash
# Ver tamaño de imagen
docker images | grep scriptsmanager

# Limpiar cache
sudo ./docker-manage.sh clean

# Rebuild desde cero
docker rmi sidel_scriptsmanager_scriptsmanager
sudo ./docker-manage.sh build
```

### Problema: Conflictos de puertos

```bash
# Ver puertos ocupados
sudo ./docker-manage.sh ports

# Cambiar puerto en docker-compose.yml
# Buscar SIDEL_APP_PORT=5002 y cambiar

# Reiniciar
sudo ./docker-manage.sh restart
```

### Problema: Entorno no se crea correctamente

```bash
# Debug dentro del contenedor
sudo ./docker-manage.sh shell

# Crear entorno manualmente para debugging
conda create -n test_env python=3.12 -y
conda activate test_env

# Instalar paquetes uno por uno
pip install pandas
pip install numpy
# etc...

# Si funciona, el problema está en el Dockerfile
exit
```

### Problema: Sin espacio en disco

```bash
# Limpiar Docker completamente
docker system prune -a -f

# Ver uso de espacio
df -h
docker system df

# Limpiar volúmenes no utilizados
docker volume prune -f
```

---

## ⚡ Scripts de Automatización

### Script para agregar entorno automáticamente

```bash
#!/bin/bash
# add-conda-env.sh

ENV_NAME=$1
REQUIREMENTS_FILE=$2

if [ -z "$ENV_NAME" ] || [ -z "$REQUIREMENTS_FILE" ]; then
    echo "Uso: $0 <nombre_entorno> <archivo_requirements>"
    exit 1
fi

# Agregar al Dockerfile
cat >> Dockerfile << EOF

# Entorno $ENV_NAME
RUN conda create -n $ENV_NAME python=3.12 -y
COPY $REQUIREMENTS_FILE ./
RUN /opt/conda/envs/$ENV_NAME/bin/pip install --no-cache-dir -r $REQUIREMENTS_FILE
RUN rm $REQUIREMENTS_FILE
EOF

echo "Entorno $ENV_NAME agregado al Dockerfile"
echo "Ejecuta: sudo ./docker-manage.sh rebuild"
```

### Script de verificación personalizado

```bash
#!/bin/bash
# verify-custom-env.sh

ENV_NAME=$1
TEST_IMPORTS=$2

if [ -z "$ENV_NAME" ]; then
    echo "Uso: $0 <nombre_entorno> [imports_a_probar]"
    exit 1
fi

echo "Verificando entorno $ENV_NAME..."

if [ -z "$TEST_IMPORTS" ]; then
    TEST_IMPORTS="import sys; print(f'Python {sys.version}')"
fi

docker exec sidel_scriptsmanager bash -c "source activate $ENV_NAME && python -c \"$TEST_IMPORTS\""

if [ $? -eq 0 ]; then
    echo "✅ Entorno $ENV_NAME funcionando correctamente"
else
    echo "❌ Error en entorno $ENV_NAME"
fi
```

---

**🎯 Resumen Final**: 
- **Cambios de código**: `sudo ./docker-manage.sh restart`
- **Cambios de dependencias**: `sudo ./docker-manage.sh rebuild`
- **Nuevos entornos**: Modificar Dockerfile + rebuild
- **Debug**: `sudo ./docker-manage.sh shell` + verificaciones manuales