# FASE 3 - CHECKLIST DE VALIDACION

**Fase:** 3 - Shared Infrastructure
**Estado:** Pendiente
**Validador:** DevOps-Agent + Tech-Leader

---

## CHECKLIST DE ESTRUCTURA

### Carpetas

```markdown
[ ] control-plane/devtools/docker/networks/ existe
[ ] control-plane/devtools/docker/traefik/ existe
[ ] control-plane/devtools/docker/traefik/dynamic/ existe
[ ] control-plane/devtools/docker/templates/ existe
[ ] control-plane/devtools/configs/env/ existe
[ ] control-plane/devtools/scripts/bootstrap/ existe
```

---

## CHECKLIST DE DOCKER NETWORKS

### networks.yml

```markdown
[ ] Archivo existe en docker/networks/
[ ] Define red infra_shared
[ ] Define redes por proyecto:
    [ ] gamilit_{env} para todos los ambientes
    [ ] erp_{env} para todos los ambientes
    [ ] trading_{env} para todos los ambientes
    [ ] betting_{env} para todos los ambientes
[ ] Es YAML valido
```

### create-networks.sh

```markdown
[ ] Archivo existe
[ ] Es ejecutable (chmod +x)
[ ] Crea red infra_shared
[ ] Crea redes por proyecto y ambiente
[ ] Es idempotente (no falla si red existe)
[ ] Ejecuta sin errores
```

### Validacion funcional

```bash
# Ejecutar script
./create-networks.sh

# Verificar redes creadas
docker network ls | grep infra_shared
docker network ls | grep gamilit_local
docker network ls | grep erp_local
```

---

## CHECKLIST DE TRAEFIK

### traefik.yml

```markdown
[ ] Archivo existe en docker/traefik/
[ ] Define entryPoints (web:80, websecure:443)
[ ] Configura provider Docker
[ ] Configura provider File para dynamic config
[ ] exposedByDefault: false
[ ] Dashboard habilitado
```

### docker-compose.traefik.yml

```markdown
[ ] Archivo existe
[ ] Usa imagen traefik:v2.x
[ ] Expone puertos 80, 443, 8080
[ ] Monta traefik.yml
[ ] Monta directorio dynamic/
[ ] Conecta a red infra_shared
```

### dynamic/routers.yml

```markdown
[ ] Archivo existe
[ ] Define routers para gamilit (api, web)
[ ] Define routers para erp (api, web)
[ ] Routers usan dominios de domains.registry.yml
[ ] EntryPoints correctos
```

### dynamic/middlewares.yml

```markdown
[ ] Archivo existe
[ ] Define middleware rate-limit
[ ] Define middleware cors-headers
[ ] Define middleware security-headers
```

### Validacion funcional

```bash
# Levantar Traefik
docker-compose -f docker-compose.traefik.yml up -d

# Verificar dashboard
curl -s http://localhost:8080/api/overview | jq .

# Verificar que esta escuchando
curl -I http://localhost:80
```

---

## CHECKLIST DE TEMPLATES

### docker-compose.base.yml

```markdown
[ ] Archivo existe en docker/templates/
[ ] Define x-logging anchor
[ ] Define x-healthcheck anchor
[ ] Incluye comentarios de uso
```

### docker-compose.backend.yml

```markdown
[ ] Archivo existe
[ ] Usa expose (NO ports)
[ ] Tiene labels de Traefik
[ ] Conecta a redes: {proyecto}_{env} e infra_shared
[ ] Redes son external: true
[ ] Tiene healthcheck configurado
[ ] Tiene logging configurado
[ ] Placeholders documentados:
    [ ] {{SERVICE_NAME}}
    [ ] {{PORT}}
    [ ] {{DOMAIN}}
    [ ] {{PROJECT}}
```

### docker-compose.frontend.yml

```markdown
[ ] Archivo existe
[ ] Similar estructura a backend
[ ] Placeholders documentados
```

### docker-compose.fullstack.yml

```markdown
[ ] Archivo existe
[ ] Combina backend + frontend
[ ] Dependencias entre servicios definidas
```

---

## CHECKLIST DE ENVIRONMENT

### .env.template

```markdown
[ ] Archivo existe en configs/env/
[ ] Variables de ambiente (NODE_ENV, ENV)
[ ] Variables de BD (host, port, name, user, password)
[ ] Variables de Redis
[ ] Variables de JWT
[ ] Variables de logging
[ ] Comentarios explicativos
```

### .env.local.template

```markdown
[ ] Archivo existe
[ ] Valores apropiados para desarrollo local
[ ] Passwords de ejemplo (no reales)
```

---

## CHECKLIST DE SCRIPTS

### init-workspace.sh

```markdown
[ ] Archivo existe en scripts/bootstrap/
[ ] Es ejecutable
[ ] Verifica prerequisitos (Docker)
[ ] Crea redes Docker
[ ] Levanta Traefik
[ ] Muestra instrucciones post-setup
```

### init-project.sh

```markdown
[ ] Archivo existe
[ ] Es ejecutable
[ ] Acepta parametros (proyecto, tipo)
[ ] Genera docker-compose desde template
[ ] Genera .env desde template
[ ] Verifica que red existe
```

---

## VALIDACION INTEGRADA

```bash
#!/bin/bash
# validate-phase3.sh

CONTROL_PLANE="/home/adrian/Documentos/workspace-v1/control-plane"

echo "=== Validando Fase 3: Shared Infrastructure ==="

# 1. Verificar estructura
echo "Verificando estructura..."
REQUIRED_DIRS=(
    "devtools/docker/networks"
    "devtools/docker/traefik"
    "devtools/docker/traefik/dynamic"
    "devtools/docker/templates"
    "devtools/configs/env"
    "devtools/scripts/bootstrap"
)

for dir in "${REQUIRED_DIRS[@]}"; do
    if [ -d "$CONTROL_PLANE/$dir" ]; then
        echo "  [OK] $dir/"
    else
        echo "  [FAIL] $dir/ no existe"
    fi
done

# 2. Verificar archivos clave
echo ""
echo "Verificando archivos..."
REQUIRED_FILES=(
    "devtools/docker/networks/networks.yml"
    "devtools/docker/networks/create-networks.sh"
    "devtools/docker/traefik/traefik.yml"
    "devtools/docker/traefik/docker-compose.traefik.yml"
    "devtools/docker/templates/docker-compose.backend.yml"
    "devtools/configs/env/.env.template"
    "devtools/scripts/bootstrap/init-workspace.sh"
)

for file in "${REQUIRED_FILES[@]}"; do
    if [ -f "$CONTROL_PLANE/$file" ]; then
        echo "  [OK] $file"
    else
        echo "  [FAIL] $file no existe"
    fi
done

# 3. Verificar scripts ejecutables
echo ""
echo "Verificando permisos..."
SCRIPTS=(
    "devtools/docker/networks/create-networks.sh"
    "devtools/scripts/bootstrap/init-workspace.sh"
)

for script in "${SCRIPTS[@]}"; do
    if [ -x "$CONTROL_PLANE/$script" ]; then
        echo "  [OK] $script es ejecutable"
    else
        echo "  [FAIL] $script no es ejecutable"
    fi
done

# 4. Verificar YAML valido
echo ""
echo "Verificando YAML..."
YAML_FILES=(
    "devtools/docker/networks/networks.yml"
    "devtools/docker/traefik/traefik.yml"
    "devtools/docker/traefik/docker-compose.traefik.yml"
)

for file in "${YAML_FILES[@]}"; do
    if python3 -c "import yaml; yaml.safe_load(open('$CONTROL_PLANE/$file'))" 2>/dev/null; then
        echo "  [OK] $file (YAML valido)"
    else
        echo "  [FAIL] $file (YAML invalido)"
    fi
done

echo ""
echo "=== Validacion completada ==="
```

---

## CRITERIOS DE APROBACION

Para aprobar esta fase:

1. **100% estructura creada**
2. **Networks funcionales**
   - Script crea redes sin errores
   - Redes listables con docker network ls

3. **Traefik funcional**
   - Levanta con docker-compose
   - Dashboard accesible en :8080
   - Routing funciona (con servicios de prueba)

4. **Templates usables**
   - Copiar template
   - Reemplazar placeholders
   - docker-compose up funciona

5. **Scripts funcionales**
   - init-workspace.sh ejecuta sin errores
   - init-project.sh genera archivos correctamente

---

## SIGUIENTE FASE

Una vez aprobada la Fase 3, proceder a:

**Fase 4: Migracion de Proyectos**
- Comenzar con Gamilit (proyecto modelo)
- Crear estructura en repo independiente
- Crear service descriptors
- Aplicar templates de docker-compose

---

**Validador:** DevOps-Agent + Tech-Leader
**Fecha de Validacion:** _________
**Estado:** [ ] Aprobado [ ] Rechazado
**Notas:** _________