Vectipy, un serveur minimaliste de tuiles vectorielles (MVT)#

Date de publication initiale : 26 Avril 2021

Pré-requis :

• Avoir une une base de données PostGIS >= 2.4 fonctionnelle
• Savoir créer un environnement virtuel Python (voir Python : configuration sur Windows et outillage)
• Avoir des notions d'administration d'un serveur web

Introduction#

Le serveur de tuiles vectipy peut vous interesser si :

• Vous disposez de données spatiales sur une base PostGIS
• Vous souhaitez partager ces données via une carte en ligne et/ou un flux SIG
• Vous ne souhaitez pas (ou ne pouvez pas) mettre en place et administrer une "solution lourde" telle que GeoServer, MapServer ou QGIS Server.

La solution que je développe ici est un projet libre de serveur permettant de publier, aussi facilement que possible, un flux de tuiles vectorielles. Ce flux peut convenir aussi bien à un usage web que SIG. Il exploite la faculter de PostGIS à générer des tuiles vectorielles directement depuis une requête SQL, ces tuiles sont ensuites mise à disposition par le micro-framework web Flask.

Commenter cet article

Les tuiles vectorielles#

Les tuiles vectorielles, aussi connues sous le nom de Mapbox Vector Tiles (MVT), sont assez similaires aux tuiles matricielles (raster) fréquemment utilisées pour les fonds de plan de cartes web.

Comme leur nom l'indique, les tuiles vectorielles sont composées des données vectorielles, elles offrent plusieurs avantages :

• Beaucoup plus légères que les tuiles raster
• Une symbologie effectuée côté client, donc dynamique et modifiable sans recharger les tuiles
• Une génération rapide côté serveur, donc peu de besoin de stocker des tuiles en cache (le cas échéant les caches sont très légers)
• Le résultat peut être redimensionné, exporté ou imprimé sans perte de qualité

Comme pour les tuiles raster, les tuiles vecteurs pré-générées peuvent être stockées et servies avec un simple serveur web de fichiers statiques. Ces dernières sont toutefois beaucoup moins gourmandes en espace disque et bande passante, et surtout un seul jeu suffit pour une infinité de styles.

L'utilisation se fait de manière analogue aux tuiles rasters, c'est à dire avec une URL de la forme http(s)://mondomaine.fr/macouche/{z}/{x}/{y}.pbf. Si le client le permet, il est généralement possible d'utiliser un fichier de métadonnées tileJSON, souvent disponible sur http(s)://mondomaine.fr/macouche.json. Ce dernier comprend généralement l'adresse du flux, les crédits, une description de la couche, etc.

Les tuiles sont généralement (mais pas obligatoirement) encodées au format Protobuf (.pbf), ce qui permet d'en réduire encore la taille.

Extrait de la documentation de QGIS.

Génération des tuiles#

PostGIS permet de directement générer des tuiles grâce à la fonction ST_AsMVT avec des bonnes performances. C'est ce principe qui sera utilisé ici pour mettre en place un serveur de tuiles.

QGIS permet également de prégénérer des tuiles à partir de n'importe quel fichier vectoriel compatible (Boite à outils → Ecrire des tuiles vectorielles).

Utilisation#

Les flux ainsi publiés sont utilisables par une interface web avec MapLibre GL, Leaflet (avec plugin), mais aussi supportées nativement par QGIS depuis la version 3.14.

Cet article vous explique comment styliser un fichier GeoJSON sur carte MapLibre. Le fonctionnement avec un flux MVT est rigoureusement identique, la seule différence se faisant au moment de la définition de la source de données :

map.addSource("my-data", {
  type: "vector",
  url: "http://mondomaine.fr/macouche.json",
  //tiles:"http(s)://mondomaine.fr/macouche/{z}/{x}/{y}.pbf", // Si le serveur ne fournit pas de fichier TileJSON
});

L'utilisation d'un flux MVT, plutôt qu'un fichier GeoJSON, permet d'afficher des couches composées de millions d'élements, puisque les données nécessaires sont chargées au fur et à mesure des besoins (zoom et déplacements sur la carte). Attention, cela ne signifie pas que le client sera capable de charger et afficher simultanément des millions d'entités (par exemple lorsque l'emprise inclut la terre entière). Et même s'il en était capable, le résultat sera probablement illisible .
Dans ce cas, il convient :

• soit de limiter le niveau de zoom,
• soit d'étudier un autre mode de représentation (aggrégation, etc.)

MapLibre GL permet toutefois l'affichage de plusieurs milliers de points sans ralentissements notables.
Sur QGIS, les données du flux peuvent être stylisées avec le moteur de symbologie. Le support des tuiles vectorielles est assez récent, mais il offre une alternative simple au WFS.

Mise en place des flux avec Vectipy#

Commencez par cloner le dépôt ou télécharger les fichiers :

git clone git@github.com:jbdesbas/vectipy.git
cd vectipy

Mettez en place un environnement virtuel avec virtualenv, activez-le et installez les dépendances (Flask et psycopg2) :

virtualenv -p python3 venv
source venv/bin/activate
python -m pip install -r requirements.txt

Créez un fichier .env , dans lequel vous indiquez les informations de connexion à la base de données :

PG_HOST=my_db_host
PG_PORT=5432
PG_DATABASE=my_db_name
PG_USER=my_db_user
PG_PASSWORD=my_db_password

Lancez le serveur (par exemple ici sur le port 5000) :

python vectipy.py run -p 5000

Les flux et fichiers de métadonnées TileJSON sont disponibles respectivement sur les URL suivantes :

• http://127.0.0.1:5000/macouche/{z}/{x}/{y}.pbf
• http://127.0.0.1:5000/macouche.json.

Il est aussi possible d'avoir une prévisualisation des couches ici : http://127.0.0.1:5000/map/macouche. Le serveur propose aussi un fichier GeoJSON de la couche ici : http://127.0.0.1:5000/map/macouche.geojson (pour le téléchargement ou l'affichage web de couches légères).

Déploiement#

Pour un déploiement en production, l'utilisation de Gunicorn / Nginx / Supervisor est, à mon sens, une des solutions les plus simples et robustes.
Voir aussi la documention de Flask.

Pour lancer le serveur avec gunicorn :

python -m pip install gunicorn
gunicorn vectipy:app --bind 0.0.0.0:5001

Un paramétrage adéquat de PostGIS et l'utilisation des bons indexes est particulièrement important, car c'est lui qui va faire le plus gros du travail : la sélection des données et la génération des tuiles.

Conclusion#

Les tuiles vectorielles offrent de nombreux avantages et peuvent être (pré)générées sans nécessiter de lourds dispositifs. Elles conviennent aussi bien pour une utilisation web que SIG, et permettent plus de souplesse que les tuiles rasters pour le client. Les données étant chargé "à la demande", les tuiles vectorielles conviennent très bien au partage de gros lots de données (plusieurs centaines de milliers). J'ai partagé le project Vectipy pour permettre la mise en place aussi simplement que possible de flux vectorielles en évitant l'installation et la maintenance de GeoServer ou MapServer.

Il s'agit de mon premier projet ce genre, aussi je serais ravi d'avoir votre retour si vous en avez l'utilité.

Voir aussi :

• Publier une carte avec mapLibre
• Installation python
• Les tuiles vectorielles
• PostGIS : ST_AsMVT

Autres serveurs de tuiles vectorielles sur le Github de Mapbox

Auteur#

Jean-Baptiste Desbas#

Géomaticien avec une forte appétence pour les thématiques environnement, biodiersité et urbanisme. Je travaille en tant que gestionnaire de base de données à l'association Picardie Nature, où j'ai la chance de pouvoir insuffler une logique open data au sein de la communauté naturaliste.

Convaincu de la qualité et de la pérennité des nombreuses solutions libres que nous avons la chance d'avoir à notre portée, je n'utilise (quasi) exclusivement que des logiciels sous licence libre. Longtemps consommateur de ces outils, j'essaie aujourd'hui d'apporter des contributions modestes, mais concrètes, au travers de projets tels que ArrayPlus et Vectipy.

Licence #

Ce contenu est sous licence Creative Commons International 4.0 BY-SA, avec attribution et partage dans les mêmes conditions.
Les médias d'illustration sont potentiellement soumis à d'autres conditions d'utilisation.

Commentaires