Mettre en place un serveur de cartographie nécessite plusieurs étapes techniques : récupérer les données géographiques, les transformer en tuiles vectorielles, puis les exposer via un serveur spécialisé.

Cet article explique comment construire une infrastructure de génération et de diffusion de cartes à partir des données OpenStreetMap (OSM).

Nous allons couvrir :

1. les sources de données

2. l’extraction d’une zone

3. la génération de tuiles vectorielles

4. l’optimisation des données

5. le déploiement d’un serveur de tiles

 

Vue d’ensemble du pipeline

La génération d’une carte vectorielle suit généralement ce pipeline :

OpenStreetMap (PBF) => osmium (extraction / nettoyage) => tilemaker / planetiler => MBTiles / PMTiles => TileServer / Martin => Client (MapLibre / Mapbox GL)

Chaque étape transforme les données pour les rendre plus compactes, plus rapides à charger et adaptées à l’affichage web.

 

1. Outils et ressources cartographiques

Avant de commencer, il est utile de connaître les principales ressources de données et outils utilisés dans l’écosystème cartographique.

Outils généraux

Quelques ressources utiles :

• https://wiki.openstreetmap.org/wiki/Commercial_OShttps://www.wheresyoured.at/the-cult-of-microsoft/M_Software_and_Services

• https://www.francetopo.fr/licences.html

Outils pratiques pour travailler avec les données :

• Calculer une bounding box
  https://tools.geofabrik.de/calc/

• Extraire une zone géographique
  https://extract.bbbike.org/

• Extraire des données spécifiques
  http://overpass-turbo.eu/

Ces outils permettent par exemple de :

• sélectionner une zone géographique précise

• récupérer uniquement certains objets OSM

• préparer les données avant leur transformation.

 

2. Sources de données géographiques

La génération d’une carte repose sur plusieurs types de données :

• données vectorielles (routes, bâtiments, POI)

• données topographiques (relief, glaciers)

• données globales simplifiées (continents, océans)

 

Données topographiques

Ces données servent à enrichir la carte avec des éléments naturels :

• relief

• océans

• glaciers

• zones urbaines

Sources :

• https://www.francetopo.fr/licences.html

• https://portal.opentopography.org/dataCatalog?group=global

• https://klokantech.github.io/naturalearthtiles/

• https://www.naturalearthdata.com/downloads/

 

Données OpenStreetMap

Les données OSM sont distribuées au format PBF (Protocolbuffer Binary Format).

Ce format est compact et optimisé pour le traitement.

Monde

• https://planet.openstreetmap.org/pbf/planet-latest.osm.pbf

• https://wiki.openstreetmap.org/wiki/Planet.osm#Downloading

Europe / régions

• http://download.geofabrik.de/europe-latest.osm.pbf

• http://download.geofabrik.de/

• https://download.openstreetmap.fr/extracts/

 

3. Récupération et extraction des données

Les fichiers OSM complets peuvent être extrêmement volumineux.

Par exemple :

• planète entière : plusieurs centaines de Go

• Europe : plusieurs dizaines de Go

Il est donc souvent préférable de travailler sur une sous-zone.

 

Installation d’osmium

Osmium est un outil performant permettant de manipuler les fichiers PBF.

Installation :

sudo apt-get install osmium-tool

 

Extraction d’une zone géographique

La commande suivante permet d’extraire une région spécifique à partir d’un fichier plus large.

osmium extract --bbox=2.68,50.72,7.55,54.12 --set-bounds --strategy=smart europe-latest.osm.pbf --output netherlands.osm.pbf

Explication :

• --bbox définit la zone géographique

• --set-bounds ajoute les limites dans le fichier

• --strategy=smart optimise l’extraction

 

4. Conversion vers les tiles vectorielles

Les données OSM sont vectorielles, mais elles ne sont pas directement exploitables pour un rendu cartographique web.

Il faut les convertir vers le format Mapbox Vector Tiles (MVT).

Cette conversion permet :

• de découper les données par tuiles

• de simplifier les géométries

• d’optimiser les performances côté client.

L’outil utilisé ici est Tilemaker.

 

5. Installation de Tilemaker

Installer les dépendances nécessaires :

sudo apt install libboost-dev libboost-filesystem-dev libboost-iostreams-dev libboost-program-options-dev libboost-system-dev shapelib lua5.4 liblua5.4-dev libprotobuf-dev libshp-dev libsqlite3-dev protobuf-compiler rapidjson-dev

Cloner le projet :

git clone https://github.com/systemed/tilemaker.git cd tilemaker

Compiler :

make sudo make install

 

6. Configuration de Tilemaker

Tilemaker fonctionne avec deux fichiers principaux :

fichier JSON

Il décrit :

• les layers

• les niveaux de zoom

• les sources de données

resources/config-openmaptiles.json

 

fichier LUA

Le fichier LUA définit comment transformer les objets OSM en couches cartographiques.

resources/process-openmaptiles.lua

Ce fichier indique par exemple :

• quelles routes doivent être affichées

• quels bâtiments doivent être inclus

• quels POI doivent apparaître.

Documentation :

https://github.com/systemed/tilemaker/blob/master/docs/CONFIGURATION.md

 

7. Données supplémentaires pour Tilemaker

Certaines données doivent être ajoutées pour améliorer la qualité visuelle des cartes.

 

Côtes et surfaces

Exécuter les scripts :

./get-coastline.sh ./get-landcover.sh

Ces scripts téléchargent :

• les côtes

• les océans

• certaines zones naturelles simplifiées.

 

Gestion des falaises (cliffs)

Tilemaker gère les falaises comme des polygones.

Or dans OSM elles sont généralement représentées par des lignes.

Il faut donc les extraire séparément.

Installation d’Osmosis :

https://wiki.openstreetmap.org/wiki/Osmosis/Installation

Extraction :

./bin/osmosis --rbf europe-latest.osm.pbf --way-key-value keyValueList=natural.cliff --wb europe_cliffs.osm.pbf

Conversion en shapefile :

sudo apt-get install gdal-bin ogr2ogr -lco ENCODING=UTF-8 -f "ESRI Shapefile" europe_cliffs.shp europe_cliffs.osm.pbf lines

Copier ensuite les fichiers dans :

tilemaker/data

Ajouter ensuite la couche dans la configuration :

"cliff": { "minzoom": 8, "maxzoom": 14, "source": "landcover/europe_cliffs.shp" },

 

8. Optimisation du fichier PBF

Avant la génération des tiles, il est recommandé d’optimiser les données.

osmium cat -f pbf your-file.osm.pbf -o optimized.osm.pbf

Cette opération :

• réorganise les données

• améliore les performances du traitement.

Consommation typique :

• 2 Go de RAM

• environ 14 minutes

 

9. Génération des tiles vectorielles

La génération des tiles est réalisée avec Tilemaker.

./tilemaker FILE.osm.pbf --output FILE.mbtiles --config resources/config-map-planner.json --process resources/process-map-planner.lua

Résultat :

• un fichier MBTiles

• contenant toutes les tiles vectorielles.

 

10. Performances de génération

Les performances dépendent de la zone traitée.

Exemples :

Zone	Temps	RAM
Europe	30 min	40 Go
Amérique du Nord	24 min	40 Go
Monde	1h20	60 Go

Espace disque recommandé : ≈600 Go

 

Options pour réduire la RAM

Tilemaker propose plusieurs options :

• --store

• --shard-stores

• --compact

Pour utiliser --compact, il faut réordonner les données :

osmium renumber -o optimized-renumbered.osm.pbf optimized.osm.pbf

 

11. Alternative : Planetiler

Planetiler est une alternative moderne à Tilemaker.

Installation :

sudo apt install default-jre default-jdk

Génération :

java -Xmx136g -jar planetiler.jar --config=config.properties

Exemple :

https://onthegomap.github.io/planetiler-demo/#9.09/46.122/6.155

 

12. Alternative : OpenMapTiles

OpenMapTiles propose un environnement Docker complet.

Cloner le projet :

git clone https://github.com/openmaptiles/openmaptiles.git cd openmaptiles/ nano .env

Modifier :

PGPORT=5432 ... MAX_ZOOM=14

Génération :

./quickstart.sh france

 

13. Optimisation du rendu côté client

Le rendu est effectué dans le navigateur.

Le temps de rendu dépend notamment :

render time = constant time + [ number of sources * per source time ] + [ number of layers * per layer time ] + [ number of vertices * per vertex time ]

Optimisations possibles :

• réduire le nombre de layers

• réduire le nombre de sources

• limiter les POI

• supprimer les IDs inutiles

• limiter les calculs de filtres.

 

14. Installation du serveur de tiles

Le serveur utilisé est TileServer GL.

Créer la structure :

mkdir tileserver cd tileserver mkdir data fonts glyphs sprites styles

Organisation :

• data → fichiers mbtiles

• fonts → polices

• styles → styles Mapbox

 

15. Configuration du serveur

Créer config.json :

{
  "options": {
    "paths": {
      "root": "",
      "fonts": "fonts",
      "sprites": "sprites",
      "styles": "styles",
      "mbtiles": "data"
    },
    "domains": [
      "maps.map-planner.com",
      "maps-a.map-planner.com",
      "maps-b.map-planner.com"
    ],
    "frontPage": true,
    "formatQuality": {
      "jpeg": 80,
      "webp": 90
    },
    "maxScaleFactor": 3,
    "maxSize": 2048,
    "pbfAlias": "pbf",
    "serveAllFonts": false,
    "serveAllStyles": false,
    "serveStaticMaps": true,
    "tileMargin": 0
  },
  "styles": {
    "map-planner": {
      "style": "map-planner/style.json"
    },
  },
  "data": {
    "world": {
      "mbtiles": "world.mbtiles"
    },
    "natural_earth_relief": {
      "mbtiles": "natural_earth_relief.mbtiles"
    }
  }
}

Les styles sont ensuite déclarés dans la configuration complète.

 

16. Lancer le serveur

Avec Docker :

sudo docker pull maptiler/tileserver-gl sudo docker run -it -v $(pwd):/data -p 5010:8080 maptiler/tileserver-gl -c config.json

Alternative NPM :

npm install tileserver-gl-light

 

17. Déploiement en service systemd

Créer un service :

sudo nano /etc/systemd/system/tileserver.service

Démarrer :

sudo systemctl daemon-reload sudo systemctl enable tileserver.service sudo systemctl start tileserver.service sudo systemctl status tileserver.service

 

18. Format MBTiles vs PMTiles

Comparaison :

Format	Caractéristiques
MBTiles	base SQLite locale
PMTiles	optimisé HTTP
PMTiles	plus léger (15–25%)

Conversion

./pmtiles convert natural_earth_relief.mbtiles natural_earth_relief.pmtiles

 

19. Serveur alternatif : Martin

Martin est un serveur vectoriel moderne écrit en Rust.

Documentation :

https://maplibre.org/martin/introduction.html

 

20. Utilisation avec MapLibre

Installer PMTiles :

yarn add pmtiles

Déclarer le protocole :

import { Map, addProtocol } from 'maplibre-gl';

import {Protocol as PMTilesProtocol} from 'pmtiles';

const protocol = new PMTilesProtocol();

addProtocol('pmtiles', protocol.tile);