# 📚 Resumen de la Sesión CI/CD - Puntos de Aprendizaje

## 🎯 Lo que Intentamos Lograr

Configurar CI/CD automático para desplegar "Francia Ocupada" en producción usando Gitea Actions.

## 🔍 Problemas Encontrados

### 1. **Runner Personalizado vs Runner Estándar**

**Tu configuración**:
```yaml
runs-on: [production-ready]  # Runner personalizado
```

**Ejemplo que funciona**:
```yaml
runs-on: ubuntu-latest  # Runner estándar de GitHub/Gitea
```

**Diferencia clave**: 
- `ubuntu-latest` tiene TODAS las herramientas preinstaladas (docker, node, git, etc.)
- Tu runner personalizado es un contenedor vacío que solo tiene acceso al socket de Docker

### 2. **Socket de Docker ≠ Docker CLI**

Tu runner tiene:
- ✅ Acceso al socket de Docker (`/var/run/docker.sock`)
- ❌ NO tiene el binario `docker` instalado

Por eso todos los comandos `docker` fallan con "command not found".

### 3. **Comandos dentro del Runner vs Comandos en el Host**

El runner ejecuta comandos **dentro de su contenedor**, no directamente en el host.

```
┌─────────────────────────────────┐
│  HOST (Servidor)                │
│  - Docker instalado ✅          │
│  - Proyecto en /home/marti/...  │
│                                 │
│  ┌───────────────────────────┐  │
│  │  RUNNER (Contenedor)      │  │
│  │  - Docker NO instalado ❌ │  │
│  │  - Comandos se ejecutan   │  │
│  │    AQUÍ, no en el host    │  │
│  └───────────────────────────┘  │
└─────────────────────────────────┘
```

## 📋 Soluciones Intentadas

### Intento 1: Usar variables de contexto de Gitea ❌
- No funcionó: Variables mal interpoladas

### Intento 2: Reordenar pasos (Node.js antes de checkout) ❌
- No funcionó: Seguía faltando Node.js

### Intento 3: Instalar Node.js manualmente ✅
- Funcionó: Node.js instalado correctamente

### Intento 4: Especificar `shell: bash` ❌
- No funcionó: Docker seguía sin encontrarse

### Intento 5: Instalar Docker CLI en el runner ❌
- No intentado: Demasiado complejo

### Intento 6: Script de deployment en el host ⚠️
- Parcialmente: Script creado pero falta ejecutarlo correctamente

### Intento 7: Eliminar copia con rsync ⏸️
- En progreso: Simplificado pero no probado

## 🎓 Conceptos Clave Aprendidos

### 1. **Etiquetas de Runner**

```yaml
GITEA_RUNNER_LABELS=production-ready:host
```

- `production-ready`: Nombre de la etiqueta
- `:host`: Indica que debe ejecutar en modo "host" (acceso al Docker del host)

### 2. **Volúmenes de Docker**

```yaml
volumes:
  - /var/run/docker.sock:/var/run/docker.sock
```

Esto da acceso al **socket** de Docker, pero NO instala el **cliente** de Docker.

### 3. **Diferencia entre CI y CD**

- **CI (Continuous Integration)**: Construir, probar, validar código
- **CD (Continuous Deployment)**: Desplegar a producción

Tu runner está configurado para CD (deployment), no para CI (build).

## 🛠️ Opciones para Continuar

### Opción 1: Usar un Runner Estándar (Más Fácil) ⭐

**Ventajas**:
- Todo preinstalado
- Funciona como el ejemplo que compartiste
- Menos configuración

**Desventajas**:
- Necesitas configurar acceso SSH al servidor de producción
- El deployment se hace remotamente

**Cómo hacerlo**:
```yaml
jobs:
  deploy:
    runs-on: ubuntu-latest  # ← Cambiar a esto
    steps:
      - uses: actions/checkout@v4
      - name: Deploy via SSH
        run: |
          ssh user@servidor 'cd /path/to/project && ./deploy.sh'
```

### Opción 2: Configurar el Runner con Docker Preinstalado (Medio)

Crear una imagen personalizada del runner con Docker ya instalado.

**Dockerfile del runner**:
```dockerfile
FROM gitea/act_runner:latest
RUN apt-get update && apt-get install -y docker-ce-cli
```

### Opción 3: Deployment Manual con Git Hooks (Más Simple) ⭐⭐

Usar Git hooks en el servidor para auto-desplegar cuando haces push.

**En el servidor**:
```bash
# .git/hooks/post-receive
#!/bin/bash
cd /home/marti/Documentos/Gitea/resistencia
git pull
./deploy.sh
```

### Opción 4: Usar Portainer o Watchtower (Automático)

Herramientas que detectan cambios en imágenes Docker y auto-actualizan.

### Opción 5: Continuar con el Enfoque Actual (Más Complejo)

Necesitarías:
1. Entender mejor cómo el runner accede al filesystem del host
2. Configurar permisos correctos
3. Posiblemente usar SSH desde el runner al host

## 📚 Recursos para Estudiar

### Gitea Actions
- [Documentación oficial de Gitea Actions](https://docs.gitea.com/usage/actions/overview)
- [Act Runner GitHub](https://github.com/nektos/act)
- [Diferencias entre GitHub Actions y Gitea Actions](https://docs.gitea.com/usage/actions/comparison)

### Docker en CI/CD
- [Docker-in-Docker (DinD)](https://www.docker.com/blog/docker-can-now-run-within-docker/)
- [Docker socket mounting](https://docs.docker.com/engine/reference/commandline/dockerd/#daemon-socket-option)

### Alternativas
- [Drone CI](https://www.drone.io/) - CI/CD más simple
- [Jenkins](https://www.jenkins.io/) - Más potente pero complejo
- [GitLab CI/CD](https://docs.gitlab.com/ee/ci/) - Similar a Gitea Actions

## 💡 Mi Recomendación

Para tu caso específico, te recomendaría **Opción 1 o Opción 3**:

### Opción 1: Runner Estándar + SSH
```yaml
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Deploy to Production
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.HOST }}
          username: ${{ secrets.USERNAME }}
          key: ${{ secrets.SSH_KEY }}
          script: |
            cd /home/marti/Documentos/Gitea/resistencia
            git pull
            ./deploy.sh
```

### Opción 3: Git Hook (Sin CI/CD)
```bash
# En el servidor, en el repositorio bare de Gitea
# /path/to/gitea/data/gitea-repositories/marti/FranciaOcupada.git/hooks/post-receive

#!/bin/bash
cd /home/marti/Documentos/Gitea/resistencia
git pull origin main
./deploy.sh
```

## 📝 Estado Actual del Proyecto

### ✅ Lo que SÍ funciona:
- Script `deploy.sh` - Listo para usar
- Docker Compose configurado
- Aplicación funcional en local

### ⚠️ Lo que NO funciona:
- Workflow de Gitea Actions con runner personalizado
- Ejecución automática de deployment

### 🎯 Lo que tienes listo para usar:
```bash
# Deployment manual (esto SÍ funciona)
cd /home/marti/Documentos/Gitea/resistencia
./deploy.sh
```

## 🚀 Próximos Pasos Sugeridos

1. **Estudiar** los recursos mencionados arriba
2. **Decidir** qué opción se adapta mejor a tus necesidades
3. **Probar** el deployment manual mientras tanto: `./deploy.sh`
4. **Considerar** si realmente necesitas CI/CD automático o si el deployment manual es suficiente

## 📦 Archivos Útiles Creados

Aunque el CI/CD automático no funcionó, estos archivos son útiles:

- ✅ `deploy.sh` - Script de deployment manual (funciona)
- ✅ `monitor-deploy.sh` - Monitoreo de contenedores
- ✅ `useful-commands.sh` - Comandos de referencia
- ✅ Documentación completa del proceso

## 💭 Reflexión Final

CI/CD con runners personalizados es complejo. No es un fallo tuyo no haberlo logrado en la primera sesión. Muchos equipos profesionales tardan días o semanas en configurar correctamente su CI/CD.

**Alternativa práctica**: Mientras estudias más sobre el tema, puedes usar deployment manual con `./deploy.sh`, que es perfectamente válido para proyectos pequeños/medianos.

---

**Fecha**: 2025-12-13  
**Estado**: En pausa para estudio  
**Próximo paso**: Decidir entre las opciones propuestas arriba