# Taller CI/CD con Jenkins - Proyecto base

- `backend/`: API con FastAPI.
- `frontend/`: interfaz en Svelte (Vite).

## Requisitos locales
- Ubuntu/Debian: `python3`, `python3-venv` y `python3-pip`
- Node 18+ y `npm`
- Docker y Docker Compose (solo para la opcion con contenedores)

En muchas distros `python` no existe o apunta a otra versión. Para evitar problemas, en esta guia se usa siempre `python3`.

## Configuracion de entorno (local/prod)
Variables que usa `docker-compose` y el frontend:
```bash
cp .env.example .env
```
Notas:
- `VITE_API_BASE` por defecto apunta a `/taller/api` y el frontend proxya a la API.
- El archivo `.env` se usa para el despliegue con `docker compose` y para inyectar variables en las imágenes/contenedores. No hace falta para arrancar backend y frontend a mano en local.
- `JENKINS_BASE_URL` no suele funcionar en local tal como viene en el ejemplo. Esa variable está pensada para entornos desplegados, donde se sustituye por la URL pública real del Jenkins accesible desde el servidor o VPS.
- Si se quisiera probar Jenkins también en local con contenedores, backend y Jenkins tendrían que compartir red Docker y usar una URL interna como `http://jenkins:8080`.
- Para tener Jenkins local hay dos opciones sencillas: levantar el contenedor incluido en `jenkins/jenkins-compose.yml` o instalar Jenkins directamente en la máquina host.
- La opcion con contenedor puede dar guerra porque aquí se trabaja con un esquema tipo Docker-outside-of-Docker. Si da problemas, suele ser más simple instalar Jenkins en la máquina anfitriona y ajustar `JENKINS_BASE_URL` en el `.env` a esa URL local.

## Arranque local sin Docker

Abre dos terminales: una para el backend y otra para el frontend.

### Backend (FastAPI)
```bash
cd backend
python3 -m venv .venv
source .venv/bin/activate
python3 -m pip install -r requirements.txt
python3 -m uvicorn app.main:app --reload --port 8000
```

Si todo va bien, la API queda disponible en `http://127.0.0.1:8000`.

Importante: deja esa terminal abierta y con el entorno virtual activado mientras trabajas con el backend.

Endpoints:
- `GET /health` estado.
- `GET /menu` devuelve el menú del día.
- `GET /prices` lista de precios aleatorios.
- `GET /prices/{item}` precio aleatorio para un item concreto.

Tests y lint del backend:
```bash
cd backend
source .venv/bin/activate
python3 -m pip install -r requirements-dev.txt
pytest
ruff check app tests
```

Si abres otra terminal, tienes que volver a activar el entorno virtual con `source .venv/bin/activate` antes de lanzar `pytest`, `ruff` o cualquier comando del backend.

### Frontend (Svelte)
```bash
cd frontend
npm install
npm run dev -- --host --port 5173
```

Abrir `http://localhost:5173/taller/`.

Tests y check del frontend:
```bash
cd frontend
npm test
npm run check
```

## Arranque con Docker Compose

Desde la raíz del proyecto:

```bash
cp .env.example .env
docker compose up --build
```

Servicios disponibles:
- Frontend: `http://localhost:8081/taller/`
- Backend: `http://localhost:8000/health`

Para parar los contenedores:

```bash
docker compose down
```

Si quieres reconstruir imágenes despues de cambios grandes:

```bash
docker compose up --build
```

## Arranque con Docker manual (sin Compose)

### Backend
```bash
cd backend
docker build -t cafeteria-backend .
docker run --rm -p 8000:8000 cafeteria-backend
```

### Frontend
```bash
cd frontend
docker build -t cafeteria-frontend .
docker run --rm -p 8081:8081 cafeteria-frontend
```

Abrir `http://localhost:8081/taller/`.

Nota: el contenedor del frontend está preparado para funcionar bien junto a `docker compose`, donde puede resolver el servicio `backend` por red interna. Si lanzas ambos contenedores manualmente por separado, tendrás que conectarlos a una red común y ajustar la resolución entre ellos.


## Jenkinsfile (pipeline)
Incluido `Jenkinsfile` declarativo para ejecutar en un agente cualquiera con Python 3.11+, Node 18+ y Docker:
- Backend: crea entorno virtual, instala `requirements-dev`, pasa `ruff` y `pytest`.
- Frontend: `npm install`, `npm run check` y `npm test`, luego `npm run build`.
- Docker: construye imágenes `cafeteria-backend` y `cafeteria-frontend` si existen los Dockerfile.
- Se despliegan las imágenes.
- En la aplicación se recupera el último commit y el autor.