# Despliegue

## Opciones de Despliegue

DataTransferV2 puede desplegarse localmente, en contenedores Docker o en la nube.

## Despliegue Local

### Requisitos

- Python 3.8+
- SQL Server accesible
- Espacio en disco para reportes (~1GB/día)

### Pasos

1. **Instalar dependencias**
   ```bash
   pip install -r requirements.txt
   ```

2. **Configurar entorno**
   ```bash
   cp .env.example .env
   # Editar .env con credenciales
   ```

3. **Ejecutar**
   ```bash
   python main.py
   ```

4. **Programar ejecución**
   ```bash
   # Usando cron (Linux)
   0 */2 * * * /path/to/env/bin/python /path/to/main.py
   
   # Usando Task Scheduler (Windows)
   # Crear tarea programada cada 2 horas
   ```

## Despliegue con Docker

### Construir Imagen

```bash
# Desde directorio raíz
docker build -t datatransfer:latest .
```

### Ejecutar Contenedor

```bash
docker run -d \
  --name datatransfer \
  -p 5000:5000 \
  -v $(pwd)/Reportes:/app/Reportes \
  -v $(pwd)/Logs:/app/Logs \
  -e DB_USER=$DB_USER \
  -e DB_PASSWORD=$DB_PASSWORD \
  datatransfer:latest
```

### Usando Docker Compose

```yaml
# docker-compose.yml
version: '3.8'
services:
  datatransfer:
    build: .
    ports:
      - "5000:5000"
    environment:
      - FLASK_ENV=production
      - DB_USER=${DB_USER}
      - DB_PASSWORD=${DB_PASSWORD}
      - SHAREPOINT_CLIENT_ID=${SHAREPOINT_CLIENT_ID}
    volumes:
      - ./Reportes:/app/Reportes
      - ./Logs:/app/Logs
    restart: unless-stopped
```

```bash
docker-compose up -d
```

## Despliegue en la Nube

### Azure Container Instances

```bash
# Construir y subir imagen
az acr build --registry myregistry --image datatransfer:latest .

# Crear container instance
az container create \
  --resource-group myResourceGroup \
  --name datatransfer \
  --image myregistry.azurecr.io/datatransfer:latest \
  --cpu 1 --memory 1.5 \
  --environment-variables \
    DB_USER=$DB_USER \
    DB_PASSWORD=$DB_PASSWORD \
  --ports 5000 \
  --restart-policy OnFailure
```

### Azure App Service

1. **Crear App Service**
   ```bash
   az appservice plan create --name myPlan --resource-group myRG --sku B1
   az webapp create --name datatransfer --plan myPlan --resource-group myRG
   ```

2. **Configurar deployment**
   ```bash
   az webapp config appsettings set \
     --name datatransfer \
     --resource-group myRG \
     --setting WEBSITES_PORT=5000
   ```

3. **Deploy con Git**
   ```bash
   az webapp deployment source config-local-git \
     --name datatransfer \
     --resource-group myRG
   ```

### AWS EC2

```bash
# Instalar Docker en EC2
sudo yum update -y
sudo amazon-linux-extras install docker
sudo service docker start
sudo usermod -a -G docker ec2-user

# Ejecutar contenedor
docker run -d -p 5000:5000 \
  -e DB_USER=$DB_USER \
  -e DB_PASSWORD=$DB_PASSWORD \
  datatransfer:latest
```

### Google Cloud Run

```bash
# Construir imagen
gcloud builds submit --tag gcr.io/PROJECT-ID/datatransfer

# Deploy
gcloud run deploy datatransfer \
  --image gcr.io/PROJECT-ID/datatransfer \
  --platform managed \
  --port 5000 \
  --set-env-vars DB_USER=$DB_USER,DB_PASSWORD=$DB_PASSWORD \
  --allow-unauthenticated
```

## Configuración de Producción

### Variables de Entorno

```bash
# Base de datos
DB_USER=prod_user
DB_PASSWORD=prod_password
DB_SERVER=prod-sql-server.database.windows.net

# SharePoint
SHAREPOINT_CLIENT_ID=prod_client_id
SHAREPOINT_TENANT_ID=prod_tenant_id

# FTP
FTP_HOST=prod-ftp.example.com
FTP_USER=prod_ftp_user
FTP_PASSWORD=prod_ftp_password

# Aplicación
FLASK_ENV=production
SECRET_KEY=your-secret-key-here
LOG_LEVEL=INFO
```

### Configuración de Logging

```python
# En GeneralConfig.py
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'verbose': {
            'format': '{levelname} {asctime} {module} {process:d} {thread:d} {message}',
            'style': '{',
        },
    },
    'handlers': {
        'file': {
            'class': 'logging.FileHandler',
            'filename': 'Logs/production.log',
            'formatter': 'verbose',
        },
        'console': {
            'class': 'logging.StreamHandler',
            'formatter': 'verbose',
        },
    },
    'root': {
        'handlers': ['console', 'file'],
        'level': 'INFO',
    },
}
```

## Monitoreo y Mantenimiento

### Health Checks

```python
# Endpoint de health check
@app.route('/health')
def health():
    # Verificar conexión DB
    try:
        db = DatabaseManager()
        conn = db.get_connection('pg')
        conn.close()
        return {'status': 'healthy', 'database': 'ok'}
    except Exception as e:
        return {'status': 'unhealthy', 'database': str(e)}, 500
```

### Logs en la Nube

#### Azure Application Insights

```python
from applicationinsights import TelemetryClient

tc = TelemetryClient('your-instrumentation-key')
tc.track_event('ETL Started')
tc.track_metric('Reports Processed', report_count)
tc.flush()
```

#### AWS CloudWatch

```python
import boto3

cloudwatch = boto3.client('cloudwatch')
cloudwatch.put_metric_data(
    Namespace='DataTransfer',
    MetricData=[
        {
            'MetricName': 'ReportsProcessed',
            'Value': report_count,
            'Unit': 'Count'
        }
    ]
)
```

### Backup y Recuperación

- **Reportes:** Los archivos Excel se generan diariamente
- **Logs:** Rotar logs semanalmente
- **Base de datos:** Backup automático de SQL Server
- **Configuración:** Versionar archivos de config en Git

## Escalado

### Horizontal Scaling

- **Múltiples instancias:** Ejecutar múltiples contenedores
- **Load balancer:** Distribuir requests entre instancias
- **Queue system:** Usar Redis/RabbitMQ para jobs ETL

### Vertical Scaling

- **CPU/Memoria:** Aumentar recursos del contenedor
- **Database:** Usar réplicas de lectura para consultas API

## Seguridad en Producción

### Red

- **Firewall:** Restringir acceso solo a IPs necesarias
- **VPC:** Aislar en red privada
- **HTTPS:** Usar certificados SSL

### Autenticación

- **API Keys:** Para acceso a API
- **OAuth:** Para UI web
- **Secrets Management:** Azure Key Vault, AWS Secrets Manager

### Actualizaciones

- **Zero-downtime:** Usar blue-green deployment
- **Rollback:** Mantener versiones anteriores
- **Testing:** Probar en staging antes de producción