Accueil Floss Manuals francophone

OpenStreetMap

Générer des cartes pour votre site web

Il existe plusieurs manières de fournir des cartes OpenStreetMap sur votre site web. La façon la plus simple est d'utiliser une bibliothèque JavaScript appelée OpenLayers qui fournit une carte glissante que vous pouvez intégrer dans n'importe quelle page web. C'est similaire à l'onglet « Export » sur http://osm.org tel que décrit dans une précédente section. Dans ce chapitre, nous irons plus loin en expliquant comment mettre en place son propre serveur avec un style de carte personnalisé à partir des données OSM. Cela vous intéressera particulièrement si vous cherchez à mettre en valeur une caractéristique particulière des données OSM, comme les voies cyclables ou les lignes ferroviaires, ou tout simplement si vous n'êtes pas satisfait des styles des cartes existants.

Besoins système

La génération et la mise à disposition de votre propre carte est une tâche plutôt intensive pour un ordinateur actuel. Selon la taille de la zone que vous voulez couvrir et le trafic réseau que vous attendez, les besoins système vont varier. En général, cela va de 10 Gio de stockage, 4 Gio de mémoire et un processeur double-cœur récent pour une zone urbaine jusqu'à 300 Gio de stockage rapide, 24 Gio de mémoire et un processeur à quatre cœurs pour la planète complète.

Les tuiles

Pour notre usage, toute carte affichée sur le web est constituée d'images carrées, de 256 pixels de côté chacune, appelées tuiles (tiles), qui couvrent chacune une région particulière de la Terre. La bibliothèque OpenLayers que nous utilisons assemble ces tuiles dans une grille, permettant ainsi d'afficher une « carte glissante » réactive dans tous les navigateurs web équipés de JavaScript.

Utiliser OpenLayers

OpenLayers est une bibliothèque JavaScript pour afficher des cartes sur un site web. Elle est très puissante, et peut être utilisée pour ajouter à vos cartes des fonctionnalités avancées, comme des boutons, des calques, des fenêtres popup et des lignes. Dans cet exemple, nous allons simplement l'utiliser pour afficher la carte que vous générez, mais si vous voulez apprendre toutes les possibilités avancées, visitez le site http://openlayers.org/.

La chaîne de production

Nous utilisons une série d'outils pour générer et servir les tuiles, comme décrit ci-dessous.

Apache fournit le serveur web frontal pour gérer les requêtes du navigateur et les transmettre au module mod_tile. Il peut accessoirement servir le contenu web statique : pages HTML, code JavaScript et CSS utilisés par votre carte.

Une fois qu'Apache a reçu la requête, il la passe au module mod_tile qui la traite en détail. Mod_tile vérifie si la tuile demandée est déjà dans le cache, auquel cas, il l'envoie immédiatement au client. Sinon, la tuile doit être calculée par le moteur de rendu (rendering). Dans ce cas, mod_tile l'ajoute à une file « demande de rendu », et quand elle arrive en début de file, le moteur de rendu fait son office puis envoie la tuile au client.

Pour le rendu des tuiles, nous utilisons un outil appelé Mapnik. Il récupère les demandes de la file aussi vite que possible et crée une image à partir des données OSM vectorielles en appliquant un style (par exemple une autoroute est dessinée en bleu, de largeur 4 pixels). La tuile est alors envoyée au client et Mapnik passe à la demande suivante dans la file.

Pour le rendu, les données OSM sont stockées dans une base de données PostgreSQL créée par un outil appelé osm2pgsql. Ces deux logiciels fonctionnent de concert pour permettre un accès efficace aux données géographiques OpenStreetMap. Il est possible de conserver les données de la base OSM à jour en permanence, en utilisant un fichier de différences produit toutes les minutes par le serveur OpenStreetMap principal.

Installer son propre serveur de tuiles

Installer son propre serveur de tuiles est une opération longue, qui a été décrite en détails par Richard Weait sur son site : http://weait.com/content/build-your-own-openstreetmap-server. Nous en présentons ici une version résumée et adaptée.

Configuration logicielle

Nous nous plaçons dans le cadre d'une installation sous Linux, avec une distribution Ubuntu ou Debian, dans une configuration serveur. Nous supposons qu'Apache, PHP, MySQL et SSH sont déjà installés. De la sorte, le serveur peut tourner sur un serveur sans écran ni clavier, uniquement via une connexion ssh. Commencez par mettre à jour votre système avec apt-get ou aptitude : 

sudo aptitude update
sudo aptitude upgrade

Installez quelques outils système essentiels pour le serveur de tuiles :

sudo aptitude install subversion autoconf screen munin-node munin htop

Organisez le système de fichiers pour faciliter l'installation :

cd ~
mkdir src bin planet

Récupérez la dernière version des données OpenStreetMap

Récupérez des données depuis http://planet.openstreetmap.org/. Comme la Terre entière représente au moins 18 Gio de données compressées, il y a des liens vers des extractions de zones plus petites, pays ou régions. Par exemple, pour la France, vous pouvez trouver des données sur http://download.geofabrik.de/osm/europe/france/,  au niveau national ou régional. En ce qui concerne les formats disponibles, nous préférerons utiliser les PBF lorsqu'ils sont disponibles, puisqu'ils sont à la fois plus légers et plus faciles à traiter. Nous supposons ici que nous récupérons uniquement la Corse, avec la ligne de commande suivante :

cd corse
wget http://download.geofabrik.de/osm/europe/france/corse.osm.bz2

Installer et configurer le serveur PostgreSQL

Nous devons ensuite installer le serveur de base de données (SGBD) PostgreSQL. Commençons par installer les paquets nécessaires avec apt-get ou aptitude

sudo aptitude install postgresql-8.4-postgis postgresql-contrib-8.4 postgresql-server-dev-8.4 build-essential libxml2-dev libtool libgeos-dev libpq-dev libbz2-dev proj

Si nous nous contentons de la Corse, tout va bien, mais si vous voulez gérer de très grosses quantités de données, comme la Terre entière, il vous faut modifier les réglages par défaut de PostgreSQL 8.4 Modifiez le fichier /etc/postgresql/8.4/main/postgresql.conf de la façon suivante :

shared_buffers = 128MB
checkpoint_segments = 20
maintenance_work_mem = 256MB
autovacuum = off

Et dans ce cas vous devez également changer la configuration du noyau Linux. Effectuez ces changements, et enregistrez-les dans un fichier de script pour qu'ils soient à nouveau appliqués à chaque redémarrage :

sudo sysctl -w kernel.shmmax=268435456
sudo sysctl -p /etc/sysctl.conf

Relancez PostgreSQL pour appliquer ces changements :

sudo service postgresql-8.4 restart

Il devrait redémarrer sans erreur et afficher ce message :

 * Restarting PostgreSQL 8.4 database server
   ...done.

Créez une base de données appelée gis. Certains de nos outils futurs utilisent ce nom de base par défaut. Utilisez les commandes de l'exemple suivant, en remplaçant le nom d'utilisateur par celui de l'utilisateur qui lancera Mapnik.

sudo -u postgres -i
createuser nom-utilisateur # répondre oui pour le superuser
createdb -E UTF8 -O nom-utilisateur gis
createlang plpgsql gis
exit

Installez l'extension PostGIS de PostgreSQL. PostGIS est l'extension dédiée aux données géospatiales.

psql -f /usr/share/postgresql/8.4/contrib/postgis-1.5/postgis.sql -d gis

Vous devez voir une longue série de messages de réponse, se terminant par :

...
CREATE FUNCTION
COMMIT
...
DROP FUNCTION

Donnez à votre utilisateur précédent les permissions d'accéder aux données PostGIS. Là encore, remplacez nom-utilisateur par le bon nom.

echo "ALTER TABLE geometry_columns OWNER TO nom-utilisateur ; ALTER TABLE spatial_ref_sys OWNER TO nom-utilisateur ;" | psql -d gis

Chargez les données OpenStreetMap dans la base 

Nous devons installer osm2pgsql, l'outil qui convertit les données OSM en format PostgreSQL. Commencez par récupérer le code source dans sa dernière version et compilez-le :

cd ~/bin
svn co http://svn.openstreetmap.org/applications/utils/export/osm2pgsql/
cd osm2pgsql
./autogen.sh
./configure
make

Nous devons ensuite configurer la projection de la base nouvellement créée :

psql -f ~/bin/osm2pgsql/900913.sql -d gis

Avec l'outil de conversion compilé et la base préparée, la commande suivante va insérer dans la base les données OSM du fichier que vous avez téléchargé précédemment (la Corse, la France, la Terre, ou autre). Cette étape est très gourmande en bande passante disque. Elle peut prendre plusieurs dizaines d'heures si vous travaillez sur la planète entière. C'est pourquoi il est conseillé de commencer petit !

cd ~/bin/osm2pgsql
./osm2pgsql -S default.style --slim -d gis -C 2048 ~/planet/planet-latest.osm.bz2

Scrutons notre import de données pendant l'avancement de la tâche. La première partie des messages osm2pgsl peut faire peur de prime abord, mais c'est normal :

Using projection SRS 900913 (Spherical Mercator)
Setting up table: planet_osm_point
NOTICE:  table "planet_osm_point" does not exist, skipping
NOTICE:  table "planet_osm_point_tmp" does not exist, skipping
Setting up table: planet_osm_line
NOTICE:  table "planet_osm_line" does not exist, skipping
NOTICE:  table "planet_osm_line_tmp" does not exist, skipping
Setting up table: planet_osm_polygon
NOTICE:  table "planet_osm_polygon" does not exist, skipping
NOTICE:  table "planet_osm_polygon_tmp" does not exist, skipping
Setting up table: planet_osm_roads
NOTICE:  table "planet_osm_roads" does not exist, skipping
NOTICE:  table "planet_osm_roads_tmp" does not exist, skipping
Mid: pgsql, scale=100, cache=4096MB, maxblocks=524289*8192
Setting up table: planet_osm_nodes
NOTICE:  table "planet_osm_nodes" does not exist, skipping
NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "planet_osm_nodes_pkey" for table "planet_osm_nodes"
Setting up table: planet_osm_ways
NOTICE:  table "planet_osm_ways" does not exist, skipping
NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "planet_osm_ways_pkey" for table "planet_osm_ways"
Setting up table: planet_osm_rels
NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "planet_osm_rels_pkey" for table "planet_osm_rels"

Ne faites pas attention aux messages NOTICE: ci-dessus, c'est normal. Ensuite, osm2pgsql commence à lire le fichier de données.

Reading in file: /home/nom-utilisateur/corse/corse.osm.bz2

À mesure qu'osm2pgsql lit le fichier, il met à jour un message d'avancement. La ligne ci-dessous se rafraîchit toutes les quelques secondes et met à jour les nombres entre parenthèses. Cette partie de l'import est longue, et peut prendre plusieurs jours pour la planète.

Processing: Node(10140k) Way(0k) Relation(0k)

Le nombre de nœuds est mis à jour plusieurs fois par seconde jusqu'à atteindre son maximum, puis le nombre de lignes (ways) est mis à jour toutes les 1 à 2 secondes environ, et enfin le nombre de relations toutes les minutes environ. Tant que ces nombres augmentent, l'import est en cours ; ne l'interrompez pas à moins de vouloir tout recommencer depuis le début.

Processing: Node(593072k) Way(45376k) Relation(87k)
Exception caught processing way id=110802
Exception caught processing way id=110803
Processing: Node(593072k) Way(45376k) Relation(474k)

Les exceptions affichées sont dues à des erreurs mineures dans le fichier, mais l'import continue normalement.

L'étape suivante de l'import peut également prendre plusieurs jours, selon la zone couverte et votre matériel. Elle commence comme cela :

Node stats: total(593072533), max(696096737)
Way stats: total(45376969), max(55410575)
Relation stats: total(484528), max(555276)

Going over pending ways
processing way (752k)

Le nombre de lignes en cours de traitement doit se mettre à jour environ chaque seconde.

Going over pending relations

node cache: stored: 515463899(86.91%), storage efficiency: 96.01%, hit rate: 85.97%
Committing transaction for planet_osm_roads
Committing transaction for planet_osm_line
Committing transaction for planet_osm_polygon
Sorting data and creating indexes for planet_osm_line
Sorting data and creating indexes for planet_osm_roads
Sorting data and creating indexes for planet_osm_polygon
Committing transaction for planet_osm_point
Sorting data and creating indexes for planet_osm_point
Stopping table: planet_osm_nodes
Stopping table: planet_osm_ways
Stopping table: planet_osm_rels
Building index on table: planet_osm_rels
Stopped table: planet_osm_nodes
Building index on table: planet_osm_ways
Stopped table: planet_osm_rels
Completed planet_osm_point
Completed planet_osm_roads
Completed planet_osm_polygon
Completed planet_osm_line
Stopped table: planet_osm_ways

Cette étape marque la fin de l'import, avec succès.

Installer Mapnik

Nous devons maintenant installer la bibliothèque Mapnik, notre moteur de rendu. Nous commençons par installer les dépendances :

sudo aptitude install libltdl3-dev libpng12-dev libtiff4-dev libicu-dev libboost-python1.40-dev python-cairo-dev python-nose libboost1.40-dev libboost-filesystem1.40-dev libboost-iostreams1.40-dev libboost-regex1.40-dev libboost-thread1.40-dev libboost-program-options1.40-dev libboost-python1.40-dev libfreetype6-dev libcairo2-dev libcairomm-1.0-dev libgeotiff-dev libtiff4 libtiff4-dev libtiffxx0c2 libsigc++-dev libsigc++0c2 libsigx-2.0-2 libsigx-2.0-dev libgdal1-dev python-gdal imagemagick ttf-dejavu

Puis nous téléchargeons et compilons le code source de la bibliothèque :

cd ~/src
svn co http://svn.mapnik.org/tags/release-0.7.1/ mapnik
cd mapnik
python scons/scons.py configure INPUT_PLUGINS=all OPTIMIZATION=3 SYSTEM_FONTS=/usr/share/fonts/truetype/
python scons/scons.py
sudo python scons/scons.py install
sudo ldconfig

Pour vérifier que Mapnik s'est installé correctement :

python
>>> import mapnik
>>> 

Si python répond avec le second prompt à chevron >>> sans signaler d'erreur, la bibliothèque Mapnik a été trouvée par Python. Félicitations !

Installer les outils Mapnik

Nous devons maintenant installer les outils Mapnik, dont le fichier de style par défaut et les utilitaires permettant à Mapnik de rendre les données OSM ;

cd ~/bin
svn co http://svn.openstreetmap.org/applications/rendering/mapnik

Mapnik utilise des fichiers préparés pour générer les côtes et les zones maritimes dans les tuiles à petite échelle, car c'est bien plus rapide que de parcourir toute la base de données à la recherche de cette information. 

cd ~/bin/mapnik
mkdir world_boundaries
wget http://tile.openstreetmap.org/world_boundaries-spherical.tgz
tar xvzf world_boundaries-spherical.tgz
wget http://tile.openstreetmap.org/processed_p.tar.bz2
tar xvjf processed_p.tar.bz2 -C world_boundaries
wget http://tile.openstreetmap.org/shoreline_300.tar.bz2
tar xjf shoreline_300.tar.bz2 -C world_boundaries
wget http://www.naturalearthdata.com/http//www.naturalearthdata.com/download/10m/cultural/10m-populated-places.zip
unzip 10m-populated-places.zip -d world_boundaries
wget http://www.naturalearthdata.com/http//www.naturalearthdata.com/download/110m/cultural/110m-admin-0-boundary-lines.zip
unzip 110m-admin-0-boundary-lines.zip -d world_boundaries

La base de données est chargée et les outils sont installés. Nous pouvons maintenant tester l'ensemble. Comme d'habitude, remplacez nom-utilisateur par sa valeur.

cd ~/bin/mapnik
./generate_xml.py --dbname gis --user nom-utilisateur --accept-none
./generate_image.py

Visualisez image.png pour confirmer que vous avez obtenu une carte de la Corse. Félicitations !

Installer and configurer Apache et mod_tile

Maintenant que nous avons réussi à créer une image à partir des données, nous devons installer le serveur de tuiles proprement dit, en tant que module d'Apache. Plus précisément, nous installons Apache par son paquet, puis nous compilons mod_tile.

Commençons par installer les outils nécessaires pour construire mod_tile :

sudo aptitude install apache2 apache2-threaded-dev apache2-mpm-prefork apache2-utils libagg-dev

Puis nous téléchargeons et compilons le code source :

cd ~/src
svn co http://svn.openstreetmap.org/applications/utils/mod_tile
cd mod_tile
make
sudo make install

Changez la configuration de mod_tile dans le fichier /etc/renderd.conf de la façon suivante :

plugins_dir=/usr/local/lib/mapnik/input
font_dir=/usr/lib/mapnik/fonts
XML=/home/nom-utilisateur/bin/mapnik/osm.xml
HOST=localhost

Créez les fichiers nécessaires à mod_tile :

sudo mkdir /var/run/renderd
sudo chown nom-utilisateur /var/run/renderd

Maintenant, nous devons dire à Apache de charger notre nouveau mod_tile en créant le fichier /etc/apache2/conf.d/mod_tile avec cette simple ligne :

LoadModule tile_module /usr/lib/apache2/modules/mod_tile.so

Et de même le site par défaut d'Apache doit inclure les paramètres nécessaires à mod_tile. Modifiez le fichier  /etc/apache2/sites-available/default (ou celui approprié sur votre système) pour ajouter ces lignes immédiatement après l'email de l'administrateur :

LoadTileConfigFile /etc/renderd.conf
ModTileRenderdSocketName /tmp/osm-renderd
# Timeout before giving up for a tile to be rendered
ModTileRequestTimeout 0
# Timeout before giving up for a tile to be rendered that is otherwise missing
ModTileMissingRequestTimeout 30

Vous devez maintenant lancer le moteur de rendu mod_tile. Notez qu'en cas de démarrage réussi, il n'affiche rien. 

cd ~/src/mod_tile
./renderd

Félicitations ! Vous avez un serveur capable de générer des tuiles à partir de votre propre copie des données OSM. Avec votre navigateur, visitez  http://localhost/osm_tiles2/0/0/0.png pour vérifier que vous avez bien une carte de tuiles opérationnelle.