Incluye informacuión de docker y docker-compose

README.md

@@ -1,104 +1,99 @@
-# CI/CD con Maven y GitHub Actions
+# Uso de Docker y Docker Compose
 
-## 1. Estructura del proyecto Maven
+Este proyecto utiliza **Docker** para contenerizar la aplicación Spring Boot y **Docker Compose** para levantar la aplicación junto con MySQL.
 
-Un proyecto Maven bien organizado es la base para que el pipeline de CI funcione sin problemas:
+## Conceptos Clave
 
-```
+### Imágenes (`image`)
-proyecto/
+Contienen el sistema operativo, JDK/JRE y la aplicación empaquetada (`.jar`).
-├── src/
-│   ├── main/java/     # Código de producción
-│   └── test/java/     # Tests unitarios
-└── pom.xml            # Dependencias, plugins y versión de Java
-```
 
-> **Regla clave:** Si `mvn clean install` funciona en local → debe funcionar en CI.
+### Contenedores (`container`)
+Instancias de las imágenes que se ejecutan de forma aislada.
+Se pueden asignar nombres con `--name` para facilitar su gestión.
 
----
+### Multi-stage build
+- **Stage 1**: build de Maven para generar el `.jar`
+- **Stage 2**: runtime con JRE/JDK ligero
 
-## 2. Dependencias y plugins esenciales
+Permite que la imagen final sea **más ligera** y solo contenga lo necesario para ejecutar la app.
 
-### Testing
+### Puertos (`ports`)
-- **`spring-boot-starter-test`** (proyectos Spring Boot): incluye JUnit 5, AssertJ y Mockito.
+Se mapean del contenedor al host con el formato `"host:container"`.
-
-### Plugins Maven importantes
-
-| Plugin | Función |
-|--------|---------|
-| `maven-compiler-plugin` | Compila el proyecto |
-| `maven-surefire-plugin` | Ejecuta tests unitarios |
-| `maven-failsafe-plugin` | Ejecuta tests de integración (opcional) |
-
----
-
-## 3. Tests
-
-Buenas prácticas para que los tests pasen en un entorno limpio de CI:
-
-- Deben ejecutarse **sin depender del IDE**.
-- Evitar dependencias de rutas locales o bases de datos externas → usar **H2 en memoria** si es necesario.
-- Nombres descriptivos con un único escenario por test:
-  ```
-  metodo_cuandoCondicion_retornaResultado
-  ```
-
----
-
-## 4. Flujo básico con GitHub Actions
-
-Archivo de configuración: `.github/workflows/ci-mvn.yml`
 
 ```yaml
-name: CI con Maven
+ports:
-
+  - "8080:8080"  # acceso a Spring Boot desde el navegador
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Set up JDK
-        uses: actions/setup-java@v3
-        with:
-          java-version: '23'
-          distribution: 'temurin'
-
-      - name: Cache Maven packages
-        uses: actions/cache@v3
-        with:
-          path: ~/.m2/repository
-          key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
-          restore-keys: |
-            ${{ runner.os }}-maven-
-
-      - name: Build with Maven
-        run: mvn clean install
 ```
 
-### ¿Qué hace `mvn clean install`?
+### Variables de entorno (`environment`)
-1. **clean** → Elimina artefactos anteriores
+Configuran la aplicación y servicios externos como la conexión a MySQL.
-2. **compile** → Compila el código fuente
-3. **test** → Ejecuta los tests unitarios
-4. **package** → Genera el `.jar` o `.war`
 
-> Si algún test falla, GitHub Actions marcará el workflow como **Failed** ✗
+```yaml
+environment:
+  SPRING_DATASOURCE_URL: jdbc:mysql://db:3306/mapamundi
+  SPRING_DATASOURCE_USERNAME: root
+  SPRING_DATASOURCE_PASSWORD: secret
+```
 
----
+### Volúmenes (`volumes`)
+Persisten datos fuera del contenedor. Hay dos tipos:
 
-## 5. Buenas prácticas
+- **Bind mounts**: montan una ruta específica del host (`./data:/var/lib/mysql`). El contenido depende de lo que haya en esa ruta local.
+- **Named volumes**: gestionados por Docker (`db_data:/var/lib/mysql`), declarados al final del `docker-compose.yml`. Son la opción recomendada para bases de datos.
 
-1. **Mantén el `pom.xml` limpio**: no sobreescribas versiones de dependencias gestionadas por Spring Boot.
+```yaml
-2. **Evita dependencias del entorno local**: sin rutas absolutas ni servicios externos sin mock.
+volumes:
-3. **Usa perfiles Maven** si necesitas configuraciones distintas para CI (p. ej., base de datos H2 para tests).
+  db_data:/var/lib/mysql
-4. **Verifica la versión de Java**: el runner de GitHub Actions debe usar la misma que la configurada en el proyecto.
+
-5. **Habilita la caché de Maven**: reduce significativamente el tiempo de build en cada ejecución.
+# Al final del docker-compose.yml:
+volumes:
+  db_data:
+```
+
+### Redes (`networks`)
+Docker Compose crea automáticamente una red interna para que los servicios se comuniquen por nombre (`db` en lugar de IP), permitiendo usar `jdbc:mysql://db:3306/...` en Spring Boot.
+
+### Dependencias entre servicios (`depends_on`)
+Controla el orden de arranque, pero **solo garantiza que el contenedor haya iniciado**, no que el servicio esté listo para aceptar conexiones. MySQL puede tardar unos segundos en estar operativo, lo que puede provocar fallos en Spring Boot al arrancar.
+
+Para esperar a que MySQL esté realmente listo, se combina con `healthcheck`:
+
+```yaml
+db:
+  image: mysql:8
+  healthcheck:
+    test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
+    interval: 10s
+    timeout: 5s
+    retries: 5
+
+app:
+  depends_on:
+    db:
+      condition: service_healthy
+```
+
+## Comandos básicos
+
+```bash
+# Construir imagen Docker (desde la carpeta en la que está el fichero Dockerfile)
+docker build -t mapamundi-app .
+
+# Lanzar un contenedor asociado a una imagen Docker
+docker run -p 8080:8080 --name mapamundi_sb_xxx mapamundi-app
+
+# Ver contenedores en ejecución
+docker ps
+
+# Levantar servicios con Docker Compose (desde la carpeta en la que está el fichero docker-compose.yml)
+docker compose up -d
+
+# Seguir los logs en tiempo real (muy útil en desarrollo)
+docker compose logs -f
+
+# Detener contenedores
+docker compose down
+```
 
 ---
 Fuentes: [ChatGPT](https://chat.openai.com) + [Claude](https://claude.ai)