# Generar y Servir Mapas Vectoriales Offline con OpenMapTiles

Este README documenta el proceso completo para generar mapas vectoriales MBTiles a partir de datos OpenStreetMap, usando [OpenMapTiles](https://github.com/openmaptiles/openmaptiles), y servirlos localmente en un clúster Kubernetes.

---

## Requisitos previos

### Software necesario

```bash
sudo apt update && sudo apt install -y osmium-tool curl docker docker-compose
```

---

## 1. Obtener los archivos `.osm.pbf`

Desde la web de [Geofabrik](https://download.geofabrik.de/):

* Descarga los `.osm.pbf` necesarios.
* Por ejemplo, para cubrir toda España incluyendo Canarias:

```bash
wget https://download.geofabrik.de/europe/spain-latest.osm.pbf -P ./data/
wget https://download.geofabrik.de/africa/canary-islands-latest.osm.pbf -P ./data/
```

---

## 2. Unir los archivos `.osm.pbf` (si aplica)

```bash
osmium merge \
  ./data/spain-latest.osm.pbf \
  ./data/canary-islands-latest.osm.pbf \
  -o ./data/spain_extended.osm.pbf
```

---

## 3. Configurar el entorno `.env`

Edita el archivo `.env` y asegúrate de que las siguientes variables estén definidas correctamente:

```env
BBOX=-18.5,26.0,5.0,44.5
MIN_ZOOM=0
MAX_ZOOM=15
MBTILES_FILE=espana.mbtiles
```

También crea un archivo de bounding box si quieres usar uno personalizado:

```bash
echo "-18.5,26.0,5.0,44.5" > data/spain_extended.bbox
```

---

## 4. Crear y lanzar script de generación

### Script `run_openmaptiles.sh`

```bash
#!/bin/bash

set -e  # Salir al primer error
export area=spain_extended

LOGFILE="openmaptiles.log"
echo "=== INICIANDO GENERACIÓN DE TILES ===" | tee "$LOGFILE"
date | tee -a "$LOGFILE"

echo "1. Limpiando..." | tee -a "$LOGFILE"
make clean >> "$LOGFILE" 2>&1

echo "2. Generando archivos..." | tee -a "$LOGFILE"
make >> "$LOGFILE" 2>&1

echo "3. Iniciando base de datos..." | tee -a "$LOGFILE"
make start-db >> "$LOGFILE" 2>&1

echo "4. Importando datos externos (Natural Earth, etc)..." | tee -a "$LOGFILE"
make import-data >> "$LOGFILE" 2>&1

echo "5. Importando archivo OSM..." | tee -a "$LOGFILE"
make import-osm >> "$LOGFILE" 2>&1

echo "6. Importando Wikidata..." | tee -a "$LOGFILE"
make import-wikidata >> "$LOGFILE" 2>&1

echo "7. Importando SQL para capas..." | tee -a "$LOGFILE"
make import-sql >> "$LOGFILE" 2>&1

echo "8. Calculando BBOX real (opcional)..." | tee -a "$LOGFILE"
make generate-bbox-file >> "$LOGFILE" 2>&1

echo "9. Generando MBTiles final..." | tee -a "$LOGFILE"
make generate-tiles-pg >> "$LOGFILE" 2>&1

echo "=== FINALIZADO ===" | tee -a "$LOGFILE"
date | tee -a "$LOGFILE"
```

Hazlo ejecutable:

```bash
chmod +x run_openmaptiles.sh
```

Lánzalo con `nohup` (para que quede funcionando aunque cerremos la terminal, va a tardar unas cuantas horas):

```bash
nohup ./run_openmaptiles.sh &
```

Verifica con:

```bash
tail -f openmaptiles.log
```

---

## 5. Desplegar en Kubernetes

### Manifiestos necesarios

En lugar de `docker-compose`, el despliegue se realiza en Kubernetes con los siguientes recursos (todos dentro del namespace `maps`):

* **PersistentVolumeClaim** (`tiles-data`) para almacenar los ficheros `.mbtiles`.
* **Deployment** con la imagen `maptiler/tileserver-gl`, montando el PVC en `/data`.
* **Service** tipo ClusterIP para exponer el puerto interno 8080.
* **Ingress** (opcional) para exponerlo con TLS a través de cert-manager.

### Copiar los mapas al PVC

Para cargar los archivos `.mbtiles` generados dentro del PVC:

1. Lanza un pod temporal "uploader" que monte el PVC.

```bash
kubectl apply -f namespace.yaml
kubectl apply -f pvc/pvc.yaml
kubectl apply -f uploader-pod.yaml
```

2. Copia los ficheros locales al pod:

```bash
kubectl cp ./data/espana.mbtiles maps/tiles-uploader:/data/espana.mbtiles
```

3. Verifica que están en el PVC:

```bash
kubectl -n maps exec -it tiles-uploader -- ls -lh /data
```

4. Una vez confirmada la copia, elimina el pod uploader:

```bash
kubectl -n maps delete pod tiles-uploader
```

### Lanzamiento

Aplica los manifiestos de Kubernetes:

```bash
kubectl apply -f deployments/deployment.yaml
kubectl apply -f services/service.yaml
kubectl apply -f ingress/ingress.yaml   # si quieres exponerlo con dominio y TLS
```

Accede a:

```
http://tileserver.<tu-dominio>
```

---

## Rendimiento y optimización

### Parámetros útiles en `.env`

```dotenv
# Aprovecha tus recursos
COPY_CONCURRENCY=16
MAX_PARALLEL_PSQL=8
```

#### ¿Qué significan?

* `COPY_CONCURRENCY`: número de hilos paralelos usados para generar tiles.
* `MAX_PARALLEL_PSQL`: número de conexiones paralelas a la base de datos al importar SQL.

Con una CPU potente (por ejemplo, 16-32 hilos), puedes aumentar estos valores:

* `COPY_CONCURRENCY=20` o más si tu CPU va sobrada.
* `MAX_PARALLEL_PSQL=10` si tu RAM y disco lo permiten.

## Recursos adicionales

* Documentación original de OpenMapTiles: [https://github.com/openmaptiles/openmaptiles](https://github.com/openmaptiles/openmaptiles)
* Tileserver-GL (maptiler): [https://github.com/maptiler/tileserver-gl](https://github.com/maptiler/tileserver-gl)

---

## Ver también

Consulta el archivo [`info.md`](./info.md) para documentación técnica adicional y ejemplos avanzados.