[Tutorial] Der eigene Map-Server

Hallo zusammen,

da wir immer daran interessiert sind, wie wir Dienste, die wir täglich nutzen, möglichst selbst betreiben können, haben wir uns nach einer Möglichkeit umgeschaut, wie wir einen eigenen Kartenserver betreiben können. Eines vorweg: Will man sich nicht nur auf einzelne Regionen beschränken, ist eine ganz schöne Menge an Festplattenplatz erforderlich. Aber man wird mit einer schönen eigenen Karte belohnt 😉

Vielleicht auch noch ein paar kurze Worte, wie so ein Kartenserver (meistens) grundsätzlich funktioniert: Für verschiedene Orte und Zoomstufen wird er verschiedene Hintergrundkacheln („Tiles“, also rechteckige Bildchen, die zusammengesetzt eine Karte ergeben) bei Bedarf aus Rohdaten (OpenStreetMap, OSM, ist hier alternativlos) und Informationen, wie diese Rohdaten darzustellen sind, erzeugen und dem Benutzer servieren. D.h. man braucht Rohdaten, Tiles, ein bisschen JavaScript und einen Server, der die Tiles serviert. Eigentlich ganz einfach 😉

Nach ein wenig Recherche haben wir uns für folgenden Technologie-Stack entschieden, der vollständig auf den OS-Lösungen von MapBox basiert:

• TileMill wird benutzt werden, um die Tiles zu erzeugen,
• TileStream wird dazu benutzt werden, die Tiles zu servieren,
• MapBox.js dazu: Es wird die client-seitige Komponente sein, die die Tiles abfragen wird (allerdings werden wir zu diesem Schritt erst in einem weiteren Tutorial kommen, da der Rest schon umfangreich genug ist; an dieser Stelle werden wir nur bis zu der von TileStream erzeugten Standard-Karten-Ansicht gelangen).

Und nun Schritt für Schritt (und so einfach wie es nur geht):

1) Datenimport:

Hierzu braucht man eine Datenbank (postgresql mit postgis-Erweiterungen in unserem Fall), OSM-Rohdaten und ein Programm, das den eigentlichen Import durchführt.
Zunächst muss mal wieder ggfs. ein wenig Software installiert und ein Arbeitsordner angelegt werden:

$ sudo aptitude install postgis imposm git postgresql postgresql-9.1-postgis
$ mkdir ~/src

Und es müssen ein paar OSM-Daten heruntergeladen werden, die dann importiert werden. Dazu besucht man die Download-Server von geofabrik und sucht sich ein Bundesland aus (wir würden nicht gleich ganz Deutschland, Europa oder die Welt importieren, denn um erstmal zu testen, was so geht, reicht ein Bundesland und hat den Vorteil, das der Import nicht ewig dauert..). Die „osm.pbf“-Variante sollte geladen werden. Also bspw.:

cd ~/src && wget http://download.geofabrik.de/europe/germany/rheinland-pfalz-latest.osm.pbf

Die Datenbank muss vorbereitet werden, dazu ruft man auf:

$ sudo cp /usr/share/postgresql/9.1/pg_hba.conf.sample /usr/share/postgresql/9.1/pg_hba.conf

Und legt dann eine Datei create_db.sh mit folgendem Inhalt an:

set -xe
createuser –no-superuser –no-createrole –createdb osm
createdb -E UTF8 -O osm osm
createlang plpgsql osm
psql -d osm -f /usr/share/postgresql/9.1/contrib/postgis-1.5/postgis.sql
psql -d osm -f /usr/share/postgresql/9.1/contrib/postgis-1.5/spatial_ref_sys.sql
psql -d osm -f /usr/share/python-imposm/900913.sql
echo „ALTER TABLE geometry_columns OWNER TO osm; ALTER TABLE spatial_ref_sys OWNER TO osm;“ | psql -d osm
echo „ALTER USER osm WITH PASSWORD ‚osm‘;“ |psql -d osm
set +x

Dann wechselt man zum Benutzer postgres (und später mit exit zurück) und führt das eben geschriebene Skript aus:

$ sudo su postgres
$ sh ./create_db.sh
$ exit

Nun muss man noch folgende Zeile in /usr/share/postgresql/9.1/pg_hba.conf eintragen, damit der osm Benutzer auf die Datenbank zugreifen darf:

host osm osm 127.0.0.1/32 md5

Dann wird postgres neugestartet:

$ sudo service postgresql restart

Das entspricht dem Vorgehen, dass man erfahren hätte, wenn man:

$ imposm-psqldb

eingegeben hätte — ein von imposm bereit gestelltes Tool, mit dem man sich ein Skript erzeugen lassen kann, das die Postgresql-Datenbank so vorbereiten kann, dass es direkt mit dem Import losgehen kann. Wir haben nur passende Pfade für Debian- und Ubuntu-Systeme eingetragen.

Nun gibt es verschiedene Wege die Daten zu importieren, was grundsätzlich je nach abgedeckter Fläche eine ganze Weile dauern und einiges an RAM verbrauchen kann…

Ich stelle zwei Wege vor: mit osm2pgsql und mit imposm und mit osm2pgsql. Das Einrichten der Datenbank ist für beide Importarten gleich.
a) OSM-Datenimport mit osm2pgsql
osm2pgsql musste ich zunächst kompilieren, da die Version aus der Paketverwaltung keinen Style fand und der neueste Probleme machte:

$ cd ~/src && git clone https://github.com/openstreetmap/osm2pgsql.git
$ sudo aptitude install libxml2-dev libgeos-dev libgeos++-dev libpq-dev libbz2-dev libproj-dev protobuf-c-compiler libprotobuf-c0-dev autoconf automake libtool make g++
$ ./autogen.sh && ./configure && make
$ sudo checkinstall

Der Import geht dann mit:

$ osm2pgsql -cGs -d osm -H localhost -U osm -W ~/src/rheinland-pfalz-latest.osm.pbf

b) OSM-Datenimport mit imposm
imposm hatten wir ja schon installiert; für den Import wird darüber hinaus noch eine Datei aus dem OSM-Bright-Paket benötigt, das wir sowieso auch noch später in jedem Fall brauchen werden und daher auch jetzt besorgen:

$ cd ~/src && git clone https://github.com/mapbox/osm-bright.git

Die Daten werden damit dann mit folgendem Befehl importiert:

$ imposm –read –write –optimize -h localhost -p 5432 -d osm -m ~/src/osm-bright/imposm-mapping.py ~/src/rheinland-pfalz-latest.osm.pbf
$ imposm –deploy-production-tables

2) osm-bright einrichten
Diese Software braucht man, um einen Standard-Karten-Style für die eben importierten OpenStreetMap-Daten zu haben. Es ist eine Art Generator von TileMill-Projekten. Um es zu nutzen, müssen die Zugangsdaten der Datenbank in der Datei ~/src/osm-bright/configure.py eingetragen werden. Hat man die Datenbank via imposm-psqldb eingerichtet, sollten folgende Werte passen (es ist übrigens relativ unwichtig, dass dies recht leicht zu erratende Zugangsdaten sind, da die Datenbank niemals „live“ gehen wird, sondern nur lokal verfügbar sein wird, eben für die Erzeugung der Tiles; darüberhinaus muss man postgresql auch noch zusätzlich konfigurieren, dass die Datenbank von außen erreichbar ist..):

config[„importer“] = „imposm“ ## hier je nach verwendetem Importer vielleicht „osm2pgsql“ hinschreiben
config[„postgis“][„host“]     = „localhost“
config[„postgis“][„port“]     = „5432“
config[„postgis“][„dbname“]   = „osm“
config[„postgis“][„user“]     = „osm“
config[„postgis“][„password“] = „osm“

Noch ein paar Dateien runterladen, die für die Karten-Erzeugung gebraucht werden:

$ cd ~/src/osm-bright/
$ wget http://tilemill-data.s3.amazonaws.com/osm/coastline-good.zip
$ wget http://tilemill-data.s3.amazonaws.com/osm/shoreline_300.zip
$ wget http://mapbox-geodata.s3.amazonaws.com/natural-earth-1.3.0/physical/10m-land.zip

Dann make.py ausführen, um das TileMill-Projekt zu generieren — bevor man dies allerdings machen kann, muss TileMill, das erst im nächsten Schritt installiert werden wird, schon mindestens einmal ausgeführt worden sein, oder man erzeugt den fehlenden Ordner von Hand:

$ mkdir ~/Documents/MapBox/project/
$ cd ~/src/osm-bright/ && ./make.py

Das Projekt sollte dann im TileMill-Standard-Projekt-Ordner angelegt worden sein und TileMill sollte es direkt nach dem Start anzeigen.

3) MBTiles mit TileMill erzeugen
Es gibt nun verschiedene Wege, TileMill zu installieren:
Man kann entweder hier den Installer runterladen und einfach ausführen. Oder man richtet ein Ubuntu-PPA ein und installiert TileMill über die Paketverwaltung (siehe hier). Oder man installiert das Tool aus den Quellen.

Wir entscheiden uns der Einfachheit halber für das PPA:

$ sudo add-apt-repository ppa:developmentseed/mapbox
$ sudo apt-get update
$ sudo apt-get install tilemill

Hat man TileMill wie auch immer installiert, startet man TileMill und wählt man auf der Startseite das vorher erzeugte OSM-Bright-Projekt aus.

TileMill ist ein grafischer Karteneditor: Im Hauptfenster sieht man wie die Karte bei verschiedenen Zoomstufen aussehen würde, entsprechend der Formatierungen, die im rechten Teil des Programmfensters angegeben sind. Durch das osm-bright-Projekt bekommt man die „Standard-OpenStreetMap-Formatierung“ von MapBox, die man natürlich auch nur als Vorgabe betrachten kann und verändern kann wie man will..

Über den Export-Knopf wird nun die Karte exportiert: Export klicken und dort „MBTiles“ auswählen. Man kann nun auswählen wo der Start-Mittelpunkt der Karte liegen soll, wenn sie angezeigt wird, für welchen Kartenausschnitt Tiles generiert werden sollen, für welche Zoomstufen, und in welche Datei das Ergebnis später abgelegt werden soll. Nachdem die Einstellungen entsprechend den eigenen Präferenzen angepasst wurden, „Export“ unten klicken.

Dies wird nun eine Weile dauern. Am Ende des Exports sollte im Ordner ~/Documents/MapBox/export/ eine MBTiles-Datei zu finden sein.

4) MBTiles mit TileStream deployen
Zunächst die erzeugte MBTiles-Datei in den Standard-Ordner für Tiles von TileStream kopieren:

$ cp ~/Documents/MapBox/export/myTiles.mbtiles ~/Documents/MapBox/tiles

TileStream klonen & ein paar Abhängigkeiten installieren:

$ cd ~/src && git clone https://github.com/mapbox/tilestream.git
$ sudo aptitude install curl build-essential libssl-dev libsqlite3-0 libsqlite3-dev git-core npm
$ cd ~/src/tilestream && npm install

Startet man nun TileStream mittels …

$ ./index.js

… und ruft die Startseite auf (http://localhost:8888/), sollte man dort die erzeugte Karte auswählen …

… und dann betrachten können 😉

[Last Edit: 15.04.2014]