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:

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)

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:

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)

cd frontend
npm install
npm run dev -- --host --port 5173

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

Tests y check del frontend:

cd frontend
npm test
npm run check

Arranque con Docker Compose

Desde la raíz del proyecto:

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

Servicios disponibles:

• Frontend: http://localhost:8081/taller/
• Backend: http://localhost:8000/health

Para parar los contenedores:

docker compose down

Si quieres reconstruir imágenes despues de cambios grandes:

docker compose up --build

Arranque con Docker manual (sin Compose)

Backend

cd backend
docker build -t cafeteria-backend .
docker run --rm -p 8000:8000 cafeteria-backend

Frontend

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.