Erstmal herzlich willkommen hier auf der Froscon 12 zum zweiten Tag von unserer OSGEO-OSM-Subkonferenz. Wir sind ja das erste Mal hier mit dem FOSGIS-Verein und mit dieser Subkonferenz und hatten gestern schon

einen tollen Tag zu OSM-Themen meistens. Heute gibt es eher Themen, die nicht mit OSM zu tun haben, sondern eher im Bereich Software vielleicht angesiedelt sind und ich freue mich, dass der Arne Schubert jetzt hier mit dem ersten Vortrag beginnt, zu Jager und Docker-Images. Wir reden sehr viel über Docker, der Arne und ich. Er ist mein Kollege bei der Wear Group und ich freue

mich auf den Vortrag. Okay, vielen Dank. Ja, also ich werde jetzt die ersten Folien erst mal so vortragen. Danach hatte ich mir gedacht, machen wir einfach quasi interaktiv zusammen eine Geodateninfrastruktur, die wir auf

Basis mit Docker-Containern eben zusammenbauen und ja, das verrät ja auch quasi der Titel schon. Erst mal zu unserem Jager-Entwicklungsteam. Wir bestehen aus drei Leuten, zwei Geografen und einem Entwickler. Ich bin der Entwickler. Wenn jemand danach fragen möchte, kann ich Ihnen gehen, später.

Okay, gut, dann starten wir jetzt auch weiter durch. Genau, also so viel zu uns und zu unserer Gruppe. Wir machen ganz unterschiedliche Sachen, hauptsächlich

aber entwickeln wir Module im Bereich Node.js, haben da unseren eigenen Namespace auf NPM, Jager heißt der dort, haben da auch schon mehrere Module und Libraries veröffentlicht, unter anderem Leaflet-NG2. Das ist so das größte, was wir bisher, würde ich jetzt mal sagen, gemacht haben.

Dazu gibt es auch später noch einen weiteren Vortrag, kann man sich dann gerne noch angucken. Darüber hinaus haben wir aber auch noch ein Library, das ETL-Prozesse verarbeiten kann auf Basis von Streams mit Node erstellt und auch zum Beispiel ein Modul, was nur für TypeScript geeignet ist, das Generic

GeoJSON, wo ich dann innerhalb von TypeScript auch die Properties von den GeoJSONs ganz genau bestimmen kann. Aber wir sind jetzt hier vor allen Dingen für die Sachen, die wir auf Docker gemacht haben. Das ist jetzt nur eine kleine Auswahl, größtenteils aber eigentlich danach

gerichtet, wie die Download-Zahlen waren. Mich wundert selber immer, dass Solar der meist runtergeladenste Container ist, zumal es ein original offizielles Solar-Image auch gibt. Hier haben wir nur die Komponenten für die Verortungen noch hinzugefügt, also dass man auch Multipolygone in Solar bearbeiten oder einen Index daraus erstellen

kann. Da ist eigentlich gar nicht ein großartiges Hexenwerk hinter, das ist eigentlich ein recht kleiner Container. Map-Proxy ist ein Container, den ich auch selber immer wieder gerne nutze, für ganz unterschiedliche Zwecke, sei es auch für kleinere Workshops oder ähnliches. Da ich

schon öfters mal das Problem zum Beispiel hatte, wenn jetzt eine Gruppe von Leuten alle gleichzeitig sich die Tiles von OSM oder ähnliches runterladen, dass dann ganz schnell plötzlich der OSM-Server sagt, ne, hier gebe ich keine Tiles mehr und das werden wir jetzt gleich eigentlich auch sehen können, wenn irgendjemand so etwas in Zukunft mal vorhat, der

kann sich innerhalb von wenigen Sekunden ein Map-Proxy starten mit Docker eben und wird in diese Probleme dann nicht mehr kommen. Geo-Server habe ich jetzt auch noch mal mit drauf geschrieben, aber es sind noch einige mehr. Am besten guckt man da einfach auf der Seite vom Docker Hub noch mal, aber den Link zeige ich dann auch noch mal

später. So, da war ich jetzt eins zu schnell. Natürlich, als erstes braucht man Docker selber, um die Sachen, die ich jetzt gleich zeige, machen zu können. Ich habe extra mal dahinter geschrieben, die Community Edition, die reicht hierfür vollkommen aus. Ich werde auch noch die Folien später

veröffentlichen, da sind dann auch jeweils noch die Links dann immer hinterlegt, so dass man sich das dann auch immer direkt angucken kann und weiter schauen kann. Wir arbeiten jetzt später für unsere GDI, die wir erstellen wollen, hauptsächlich mit Docker Compose. Docker Compose ist so ein kleines

Helfer-Tool, wenn man so will, zu Docker, wo ich einfach in einem YAML-File meine Serverlandschaft, wenn man so will, einfach kurz definieren kann. Da muss ich relativ wenig zu schreiben oder sonst was, das ist sehr schnell. Ich muss auch nicht großartig irgendwelche Sachen in der

Konsole so stark zumindest einsetzen, sodass das eigentlich für solche Sachen eine ziemlich tolle Sache ist. Das muss man sich allerdings auf vielen Systemen zusätzlich runterladen. Ich weiß nur, auf Mac OS X ist es direkt dabei, aber zum Beispiel für Debian oder allgemein Linux-Systeme

muss man sich zusätzlich runterladen. Bei Windows weiß ich es jetzt nicht ganz genau, das kann ich jetzt nicht genau sagen, muss man ja sonst gucken, aber auf dem hinterlegten Link stehen alle weiteren wichtigen Informationen. Wenn man das alles gemacht hat, kann man einfach bei sich in der Konsole mal Docker Info starten und hier würde ich mich dann auch einfach

selber starten, dass ich mich quasi jetzt hinsetze und das interaktiv mit euch zusammen mal einfach alles mache und ausprobiere. Dafür holen wir uns jetzt erst mal noch eine Konsole dazu, damit wir das

beides nebeneinander sehen. Dann fangen wir doch einfach mal an. Mein Docker ist bei mir ja schon installiert, da bekomme ich also jede Menge Informationen, die sind jetzt für uns erst mal nicht wichtig, aber wenn ihr diese Informationen und keinen Fehler seht, seid ihr auf jeden Fall schon mal eigentlich relativ weit, euer Docker sollte laufen.

Vielleicht noch vorab, wer hat schon mal mit Docker hier gearbeitet und kennt das ein bisschen? Na dann ist ja sehr gut, weil ich wollte mich jetzt eigentlich erst mal damit starten, ein bisschen Docker vorzustellen und wie man damit arbeiten kann, unabhängig von unserer GDI und

danach gehen wir dann auch direkt schnell auf die weiteren Schritte ein. Das Getting Started Guide von Docker selber, zumindest damals hatte immer noch den Whale Sale Container als Beispiel genannt, um das einfach mal auszuprobieren. Das können wir nämlich jetzt hier auch

einfach mal machen. Wir gehen also, ich mach den nochmal leer, wir starten also jetzt einen Docker Container mit Run. Den Docker Container, den wir starten wollen, heißt Docker Whale Sale. Der kann nicht viel, der gibt einfach nur einen Text aus, den man ihm weitergibt. Dann führen wir ein

Kommando aus auf dem Docker Container, das Cowsay heißt. Das ist ein ganz normales Programm, was man sich auch auf Ubuntu oder ähnliches runterladen kann, ist aber hier allerdings leicht modifiziert. Und dann können wir ihm einfach, wie bei ganz normalen Bash Befehlen, quasi

Argumente mitgeben. In dem Fall also Hello12Frostcon. Und wenn wir das Ganze jetzt hier ausführen, dann hat man gesehen, der hat jetzt quasi den Docker Container gestartet, den Befehl ausgeführt und den Container direkt beendet, weil er fertig war. Das ging halt eben innerhalb weniger

Sekunden. Wir sollten eben genauso was sehen, kommt hin, würde ich sagen. Also unser Docker Container läuft so weit schon mal. Zu sehen, welche Prozesse gerade in Docker laufen, weil die ja immer diese Container starten. Dafür können wir Docker PS nutzen. Da finden wir jetzt

allerdings gerade noch nix, weil wie gesagt der Container gerade gar nicht mehr am Laufen ist. Der ist einfach nur gestartet, hat seinen Befehl ausgeführt und hat sich dann selber beendet. Wenn wir aber auch die beendeten Prozesse aufgelistet haben wollen, dann können wir das noch um ein Minus A quasi erweitern und dann sehen wir nämlich jetzt auch hier,

machen wir das hier jetzt gerade mal was breiter, dass also eben vor 50 Sekunden dieser Docker Container erstellt worden ist, aber jetzt gerade gar nicht mehr am Laufen ist. Wieder zurück. So genau, das ist

so etwa das, was wir erwarten, was zurückkommt, hatten wir ja gesehen. So, was ich sehr praktisch finde, was ich bei meinem Start mit Docker so am Anfang gar nicht wusste, wo ich immer froh gewesen wäre, wenn ich das schon früher gewusst hätte, dass man auch im interaktiven Modus einen

Container starten kann. Dafür habe ich jetzt hier einfach mal den ganz normalen Debian Standard Container quasi ausgewählt, erweitere quasi das Run um die Flex I und T. I steht für Interactive und der T spawnen

quasi die TTY meines Systems, sodass ich quasi mit den beiden Befehlen zusammen die richtige interaktive Variante habe. Wenn wir nämlich jetzt einfach Docker Run IT Debian für das Debian Image und Bin Bash für eben den Befehl, den ich ausführen möchte, also die Bash ausführen, sieht man,

ich bin jetzt schon direkt quasi in Anführungszeichen, wie als ob ich SSH genutzt hätte oder vor allen Dingen für die Leute, die viel mit Vagrant gearbeitet hatten, als ob ich jetzt einen Vagrant SSH ausgeführt hätte, direkt auf meinem Docker System. Und wie ihr vielleicht schon gesehen habt, habe ich ja eigentlich Mac OS X, da gibt es ein

APT.Get Update nicht, aber hier sieht man jetzt schon, er lädt sich die Pakete von Debian runter. Also ich bin definitiv jetzt auf meinem Debian System, obwohl ich ja eigentlich auf meinem Mac OS X System bin. Diesen Schritt finde ich im Allgemeinen auch so sehr praktisch, wenn man zum Beispiel einfach nur mal kurz was ausprobieren will.

Wenn ich also jetzt irgendwie, dass ich eine Software mal gucken will, was ich installieren muss oder Ähnliches, ich kann das ja hier einfach in dem Image machen, installiere mir irgendwelche Sachen, gehe danach einfach mit Exit oder Control D einfach aus dem Image wieder raus und kann es danach wegwerfen. Also ich verschmutze quasi nicht mein eigenes Betriebssystem mit irgendwelchen

Sachen. Ich kann da einfach mal gerade irgendwie ein paar Sachen ausprobieren, was ich wirklich sehr praktisch finde und mittlerweile relativ exzessiv nutze. Wenn wir Volumes mounten wollen, funktioniert das im Endeffekt mit dem Vflag, da muss ich aber dann immer einen absoluten

Fahrt vom Gastsystem auf das Verzeichnis angeben, dann einen Doppelpunkt und dann einen absoluten Fahrt im Docker. Danach kann ich noch einen Doppelpunkt rw oder ro hinzufügen, das bedeutet dann, dass dieses Verzeichnis entweder read-only oder read-write ist. Aber so habe ich die Möglichkeit,

ganz einfach Sachen in meinen Docker Image hereinzubringen. So, das Ganze funktioniert, wenn man so will, auch mit relativen Verzeichnissen über einen Trick, in dem ich einfach die Working Directory Variable quasi einfach nutze.

Das könnten wir jetzt auch hier einfach mal gerade ausprobieren. Das heißt also, wir mounten das aktuelle Verzeichnis einfach in root zum Beispiel, in das Debian Image und möchten WinBash haben.

So, jetzt sind wir hier, gehen in unser root-Verzeichnis, das ist bisher noch leer, aber wir könnten jetzt zum Beispiel einfach mal test-touchen. Das heißt, es ist jetzt hier drin, wenn wir jetzt aber aus diesem Verzeichnis rausgehen, aus dem Image herausgehen und wieder in unserem Startverzeichnis sind,

sehen wir, ist auch die Datei jetzt dort angekommen. Also wir können uns damit Dateien, Verzeichnisse oder alles mögliche relativ einfach hereinladen und von da aus dann weiterarbeiten. Ähnlich funktioniert das auch mit Ports. Hier habe ich noch eine weitere Neuerung.

Hier habe ich noch angegeben, dass man quasi Container, die man startet, auch mit einem Namen versehen kann. Ist für mehrere Sachen recht praktisch, vor allen Dingen wenn ich aus irgendwelchen Gründen wieder auf dieses Image drauf will oder auf den Container drauf will. Aber in dem Sinne führen wir das jetzt hier einfach mal

genauso aus, wie es da steht. Das heißt also, wir starten einen neuen Docker-Container. Er soll den Namen Map-Proxy haben und soll den Port 8080 vom Docker-System auf den 8081 in meinem Host-System weiterreichen. Und ich möchte dafür das JagerJS-Map-Proxy-Docker-Image nutzen.

Wir starten es. Er fährt hoch. Er ist schon da. So und jetzt haben wir nämlich hier auch direkt die Möglichkeit, auf diesen einfach mal zuzugreifen. Das gucken wir uns jetzt gerade einfach mal an und siehe da, da läuft auch schon unser Map-Proxy. Damit jetzt hier den Standard-Einstellung.

So auch auf aktuell laufende Container habe ich die Möglichkeit, zuzugreifen. Das kommt dann nochmal eher dem Vagrant SSH vielleicht näher. Wir haben ja dem Container den Namen Map-Proxy

gegeben. Deswegen referenzieren wir den hier wieder mit Map-Proxy. Hier gilt das Gleiche wie für den Run-Befehl, dass wir jetzt hier auch wieder in dem interaktiven Modus darauf zugreifen können. Und auch hier möchten wir wieder binnen Bash einfach starten. Das können wir also hier jetzt auch einfach nochmal machen. Und siehe da, wir sind schon direkt auf dem Map-Proxy eingeklinkt,

wie auch immer. Können auf jeden Fall jetzt darauf arbeiten und können auch irgendwelche Sachen verändern oder Ähnliches. So da gehe ich aber jetzt direkt wieder raus. Denn wir können auch im nicht-interaktiven Modus natürlich ganz genauso Sachen ausführen. Das zeige ich jetzt hier zum Beispiel mal. Wir führen auch wieder mit exectem Befehl

auf dem Container Map-Proxy aus. Diesmal nicht im interaktiven Modus. Deswegen lassen wir das mit dem IT weg. Und wir möchten jetzt einfach unsere aktuelle Map-Proxy-Konfiguration einfach mit CUT ausgeben. Wenn wir das jetzt einfach so kopieren und einfügen, zack, da ist schon unsere Map-Proxy-Konfiguration. Die wird dann eben auch wie gesagt einfach in unsere aktuelle Standard-Output weitergeleitet.

Also eigentlich verhält sich das da mehr wie ein Prozess oder wie eine Anwendung, die starte, als wirklich wie eine virtuelle Maschine oder Ähnliches. So, zu guter Letzt ein paar Sachen, die mich oft gestört hatten, bis ich sie dann irgendwann

mal gefunden habe, dass es dafür auch gewisse Shortcuts gibt, wenn man so will. Wenn ich hier mit Docker PS mir angucke, was gerade alles läuft, da läuft auf jeden Fall noch hier der andere Container. Den kann ich auch mal beenden. Übrigens bei den meisten Images, die sagen wir mal mit exect

weitere Befehle dann ausführen, die sie danach weiter nutzen, habe ich hier die Möglichkeit mit Ctrl C auch einfach wie bei einem normalen Prozess, den als Image hier quasi zu beenden. Also ich bin hier zwar in dem Container drin, aber wenn ich jetzt hier Ctrl C drücke, sendet dem das

Kill, ne nicht das Kill-Signal, das Secret und der Prozess beendet sich einfach von selber. Also es ist genauso wie jetzt, ob ich ihn eben nicht in Docker ausgeführt hätte.

So, trotzdem nochmal hier, wir hatten Docker PS ausgeführt, da war eben gerade nur der eine drin, den haben wir jetzt beendet, aber wenn wir jetzt mal A, also für alle Prozesse angeben, hat sich hier schon ganz schön was angesammelt. Die kann ich zwar einzeln mit Docker Remove auch wieder entfernen, ich habe aber auch die Möglichkeit,

Docker PS im Quiet-Modus, dafür ist dann hier hinten das Q-Fleck noch im Endeffekt. Wir können das ja mal einfach einzeln ausführen, dann markiere es, dann sehen wir nämlich, er gibt uns jetzt nur noch die einzelnen ID's aus. Und wenn wir das nämlich in dieser Form quasi miteinander

verknüpfen, dann führen wir ja quasi Docker Remove aus und geben das Ergebnis aus Docker PS-AQ weiter nach Bash quasi. Dann beendet er, also dann remove er einfach alle Docker, die ich vorher hatte und wenn wir jetzt nochmal Docker PS-A ausführen, sehen wir jetzt haben wir keine laufenden oder auch keine gestoppten

Container mehr im Hintergrund. Ich fand das auf jeden Fall eine sehr praktische Sache, um mal schnell gerade seinen Rechner aufzuräumen auf einen produktiven Serverumgebung, würde ich da allerdings ein bisschen mit aufpassen, wohlgemerkt. Das Gleiche können wir aber auch mit Volumes machen, läuft ganz genauso. Docker hat auch, also im Endeffekt

für jeden Container, der sich einen Volume in seiner Konfiguration quasi gibt, legt Docker typischerweise ein Volume an. Da können aber auch ganz schön viel zusammenkommen, vor allen Dingen können dadurch ganz schön viele Daten zusammenkommen, weil in den Volumes halt eben je nach dem, was man damit macht,

natürlich noch viel, viel mehr Daten zusammenkommen können. Und dafür ist also auch dieser Befehl hier mal zwischendurch ganz praktisch, falls man sich mal vielleicht irgendwie fragt, wo ist mein ganzer Festplattenspeicher hingekommen. Mit diesem Befehl könnte man zumindest, oder zumindest erst mal mit dem Docker Volume LS mal einfach gucken, was sich da so mittlerweile angesammelt hat.

Wenn man da vorher nie so drauf geachtet hat, dann guckt man sich da manchmal gar nicht schlecht um, was da so zusammengekommen ist. So, aber so viel jetzt zu der Einführung von Docker. Die Leute, die mit Docker schon ein bisschen zu tun hatten, können jetzt quasi wieder wach werden und zugucken. Jetzt wird es wahrscheinlich auch für Sie wieder interessanter.

Wir wollten ja unsere GDI, im Englischen heißt sie SDI, erstellen und das machen wir jetzt einfach mal Schritt für Schritt. Ich hatte ja schon vorhin gesagt, am besten nutzt man dafür nach meiner Meinung dann eher Docker Compose, um eben diese mehreren Images

zusammen zu fügen und dass sie untereinander interagieren kann und und und. Das kann man natürlich auch rein theoretisch alles händisch aus der Konsole, wenn man so will machen oder auch ein selbstgeschriebenes Skript. Aber Docker Compose gibt uns eigentlich alles, was wir dafür brauchen. Deswegen würde ich sagen, sollte man das auch

damit machen. Ich erstelle das einfach jetzt mal hier direkt in der Konsole. Wir brauchen ein Docker Compose Punkt jammelfall. Und wir kopieren jetzt einfach mal so grob das, was wir vorhin reingeschrieben, also was wir vorhin schon mal gestartet hatten. Wir hatten ja vorhin schon mal ein Map Proxy gestartet. Das

füge ich jetzt hier einfach wieder ein. Ich hatte den gerade eben nur mal um quasi den Unterschied klarzumachen, was der Host Port ist und was der Docker Port ist auf 81 also 80 81 und 80 80 gesetzt. Hier habe ich das jetzt einfach erstmal einfach nur durchgereicht. Also es ist. Danach ist

der Map Proxy einfach auf Port 80 80 in meinem Host System erreichbar. Sollte er zumindest. So wir können jetzt unsere Komposition mit Docker Compose abstarten. Das machen wir auch einfach mal und sieht dann danach

grob ähnlich aus wie den Output, den wir vorher gekriegt hatten, da wir aber unter Docker Compose die Möglichkeit haben, mehrere Dienste nebeneinander zu starten, wird jetzt hier immer farbig und mit dem jeweiligen Namen der Instanz davor geschrieben, wer diesen Output gerade einfach liefert. So und auch das können wir jetzt gerade einfach mal

ausprobieren. Wir hatten ja hier noch den alten Map Proxy gestartet. Wir ändern das jetzt hier mal auf 80 80 um. Ja, sieht noch genauso aus wie vorher, aber es ist definitiv noch da. Wir können ja einfach mal hier nochmal zurückspringen. Man sieht auch hier direkt und das ist auch nochmal finde ich eine ganz interessante Sache, wie sich die Logs halt eben auch direkt ändern. So kann man

sich das auch direkt mit angucken. Man kann aber auch nachträglich mit Docker Log oder Docker Compose Log die Logs auch jeder Zeit angucken lassen. Also man muss auch nicht den Docker so starten. Es gibt noch das Fleck minus D. Da komme ich gleich aber auch nochmal glaube ich zu. Dann startet der das einfach quasi als Dienst im

Hintergrund und dann müsste ich halt eben mit Docker Compose stopp, das Ganze wieder stoppen, wenn ich nicht mehr will, dass es ausführt. Jetzt gerade habe ich aber noch die schöne Möglichkeit, dass ich mit Control C auch hier einfach wieder alles beenden kann und rausgehen kann. So. Der Proxy ist

bisher noch relativ langweilig. Hatten euch gar nicht gezeigt, aber das ist die Standardkonfiguration des Proxys. Da sehe ich eigentlich nicht viel, außer ja ein großes, weißes, halbtransparentes Vier Eck mit ein bisschen Text drin. Deswegen würde ich sagen, machen wir uns doch jetzt einfach mal eine vernünftige Map Proxy

Konfiguration. Und die heißt Map Proxy Punkt Jammel. So, das ist der Inhalt unserer Map Proxy Jammel. Ich habe ihn einfach mal hiermit hinzugefügt. Im Endeffekt

ist das eine etwas erweiterte Konfiguration. Sie hat nämlich also einerseits ist Open Topo Map mit drin und Open Street Map und die nutzen auch immer die drei zur Verfügung stehenden Mirrors quasi. Also er nutzt hier mit den

Subdomains die drei unterschiedlichen Subdomains und fügt sie dann danach eigentlich hier wieder zusammen, sodass ich auch die Server von Open Street Map oder Open Topo Map nicht so überlaste, auch wenn ich sowieso noch zwischenspeichere. So. Gut, habe ich jetzt nicht zugeschrieben, aber jetzt sagen wir einfach nochmal Docker Compose ab.

Ah, nee, gar nicht. Ich muss ja noch die Datei. Da war ich zu schnell. Hier haben wir nämlich jetzt noch zusätzlich die Datei, die wir als Volume hinzufügen müssen. Wir haben ja die Map Proxy Konfiguration erstellt. Die ist jetzt natürlich bisher noch nicht in unserem Docker Image drin.

Das sieht nämlich bisher so aus. Das heißt also, wir fügen uns hier hinten jetzt noch die Volumes hinzu. Wie man sieht, habe ich aber hier direkt zwei Volumes hinzugefügt. Das liegt daran, dass Map Proxy seine eigenen Daten ja auch noch, seinen eigenen Cache

irgendwo zwischenspeichert. Und wenn ich nicht möchte, dass der zwischen den Sessions oder zwischen dem Starten verloren geht, muss ich mir dafür einfach noch wieder ein Volume anlegen, was ich dann auf den Ordner vom Map Proxy setze, also innerhalb des Containers, muss hier unten allerdings auch noch dann das Volume angeben und dann bleiben die Daten auch

immer erhalten. Selbst wenn ich einen Container austausche oder irgendwas mache, dieses Volume bleibt dann einfach hier gespeichert und es ist auch ein virtuelles Volume, was Docker vollkommen selber verwaltet. Ich hätte ja sonst auch die Möglichkeit zum Beispiel einfach ein lokales Verzeichnis bei mir auch zu nutzen. Noch ein Hinweis nebenher, im Gegensatz zum normalen

Docker, versteht Docker Compose hier auch relative Pfade. Ich könnte hier entweder einen Absoluten nehmen oder einen relativen, aber dann mit Punkt slash, weil ansonsten versteht ihr das hier als quasi virtuelles Volume, da nur noch mal so als Hinweis drauf zu achten. So, jetzt aber starten wir das Ganze noch mal

und gucken mal nach und siehe da, wir haben jetzt nicht nur OSM und auch nicht nur dieses möchte gerne OSM mit dem weißen Feld, sondern wir haben hier ein echtes OSM quasi und die Open Topo Map einfach auch noch mit hinzugefügt. Wie man sieht, innerhalb von Sekunden quasi gestartet.

So, wir geben uns aber jetzt hier mit Map Proxy alleine nicht zufrieden. Wir wollen ja eine Geodaten-Infrastruktur haben mit mehr. Deswegen fügen wir jetzt als erstes noch mal einfach einen Geo-Server nach demselben Prinzip hinzu.

Stopp, ein bisschen schneller. Ja, danke. So, dafür öffnen wir wieder unser Docker Compose-Yaml und fügen jetzt ach so, das war der falsche. Na, einfach hier unser Geo-Server-Eintrag

mit dazu. Und weil wir ja ein Volume erstellen, sonst würde er mit uns meckern, müssen wir hier auch noch das Geo-Server-Volume danach hinzufügen. So, und wenn wir jetzt wieder Docker Compose absagen,

startet er uns nicht nur den Map Proxy, wie wir schon gesehen haben, sondern auch den Geo-Server. Hier sieht man jetzt auch so ein bisschen diese unterschiedlichen Farben, die er eben für die Logs verwendet. Das heißt also, wir kommen jetzt nicht nur auf unseren Web-Server drauf zu, sondern wir sollten auch auf der 81 quasi auf den Geo-Server drauf zugreifen können.

Und seht ihr da, da ist er schon. Also, nur diese paar Zeilen haben uns ein Geo-Server beschert. So. Jetzt finde ich aber persönlich noch den Geo-Server so alleine. Ja, nicht langweilig, aber man kann ihn ja noch mal eine Post-GIS-Datenbank anreichern. Dann kann man ja noch viel, viel mehr damit machen.

Und genau so fügen wir jetzt noch diesen Post-GIS-Eintrag. Das ist es nochmal fast vor, aber zu dem, was wir eigentlich vorher hatten, noch mit dazu. Wenn er dann hier beendet hat. Oder wir gucken es an, er jetzt hat das. So, das heißt also, hier unten fügen wir jetzt einfach Post-GIS noch mit hinzu

und wir brauchen halt eben auch noch unser Post-GIS-Data-Value, weil auch Post-GIS natürlich sich Daten speichert. Ups. Die wir auch über die Sessions hinweg behalten wollen. Jetzt haben wir noch eine weitere Sache,

das hätte ich direkt offen lassen können. Wir wollen ja im Endeffekt im Geo-Server später dieses Post-GIS-Image nutzen. Es wird wahrscheinlich in den meisten Fällen, je nachdem wie ihr das nutzt, nicht einen riesen Unterschied machen. Aber diese Option bietet eben das Docker Compose und deswegen sollten wir dieses Depend-on-Post-GIS mit hinzufügen.

Das würde dann dadurch bedeuten, dass er quasi erst Post-GIS startet, bevor er dann den Geo-Server startet. Das ist zwar, wie gesagt, dadurch, dass wir wahrscheinlich jetzt eh nicht genau in dieser Sekunde irgendwelche Anfragen stellen werden, so tragisch, aber wir wollen es ja hier, wir wollen uns nichts falsches angewöhnen. Deswegen machen wir das direkt richtig.

So, darüber hinaus wollen wir aber auch noch diese ganzen Post-GIS-Features nutzen. Dafür müssen wir ja unter anderem auch dieses Create-Extension-Post-GIS ausführen. Außerdem wollte ich einen Benutzer anlegen, der FrostCon heißt und das Passwort FrostCon hat

und so weiter und so fort. Dafür habe ich mir mal irgendwann dieses Startscript quasi geschrieben und das fügen wir jetzt quasi auch einfach noch hinzu. Das ist übrigens in vielen, gerade in den offiziellen Images und auch in den Jager-Images haben wir immer darauf geachtet, ein sogenanntes quasi Docker-Entry-Point-init

irgendwas Punkt D-Verzeichnis zu haben. Das ist dann im Endeffekt dafür da, dass in dem Moment, wenn ich den Docker-Container starte, nochmal Provisioning-Scripts oder ähnliches ausgeführt werden kann. So, und genau das nutzen wir halt eben hier auch aus, um einen Benutzer, eine Datenbank

und so weiter und so fort schon mal initial immer anzulegen, damit ich da mich nicht weiter drum kümmern muss, rein theoretisch könnte ich jetzt natürlich auch mich einfach über irgendein Datenbank-Programm oder ähnliches auf die PostGIS einwählen und da halt eben diese Schritte ausführen. Ich mach das aber lieber automatisiert.

So, deswegen erstellen wir erstmal den Ordner PostGIS und machen dann die prepare die b.sh So, und fügen das eigentlich im Endeffekt nur ein.

So, damit das jetzt natürlich funktioniert, müssen wir auch noch das Volume auch hier quasi einbinden. Und dann jetzt hier auch noch gerade so.

Also, wir nehmen den PostGIS-Ordner, den wir erstellt haben und setzen den eben auf dieses Docker-Entry-Point-init, in dem Fall db, weil es halt eben eine Datenbank ist. Das ist so dieses typische Schema, was sich unter den Docker-Images irgendwie eingestellt hat. Ich füge das hier direkt im Read-Only-Modus hinzu,

da ich überhaupt gar kein Bedürfnis habe, an diesen Daten auch irgendwas innerhalb des Docker-Containers zu schreiben. Also machen wir das jetzt einfach und starten doch unser Docker-Compros nochmal. Jetzt müssten wir hier eigentlich sehen, wie die Datenbank sich den Benutzer anlegt.

Vielleicht allerdings nicht genau, wo er das macht, weil er hier so viel schreibt. Genau, hier hat er alter Role, Create Role und so weiter und so fort. Also er hat uns auf jeden Fall an dieser Stelle tatsächlich das Provisioning-Skript jetzt quasi ausgeführt. Unsere Datenbank ist vorbereitet und hat jetzt den Benutzer FrostCon

mit dem Benutzer Passwort FrostCon eben installiert. So, ja. Das ist eigentlich schon jetzt erst mal alles, was wir auf Docker-Compose und Konsolen-Ebene und und und machen wollten. Jetzt geht es quasi ans Eingemachte und ich habe das mir jetzt hier nur mal so kurz stichpunktartig aufgeschrieben,

was ich eigentlich machen wollte. Das heißt also, wir gehen auf unseren Geo-Server, wir melden uns hier mit admin-geo-server an, weil das hier noch der Standard-Passwort ist. Dann hatte ich mir, ich mach das glaube ich ein bisschen größer, das ist ein bisschen klein wahrscheinlich. So ist besser, ne? So, jetzt gehen wir auf unsere Arbeitsbereiche.

Ich lösche jetzt hier erst mal alle bisherigen raus, weil die brauchen wir gar nicht. Erstellen dafür aber mal einen neuen, den wir FrostCon nennen und dem geben wir auch hier die URL. Das müssen wir, obwohl die jetzt nicht so eine großartige Bedeutung

erst mal für uns hat. So, und wir können jetzt, ja, aktivieren wir hier noch einfach mal die ganzen Server schon mal und ich fülle das ganze Ding einfach mal auf mich grob aus. Speichern wir das und der Arbeitsbereich müsste jetzt da sein.

So, jetzt wollen wir aber ja noch einen Datenspeicher dazu. Dafür haben wir ja auch uns diese ganze Mühe mit dem PostGIS überhaupt gemacht. Das heißt auch hier fügen wir einfach eine PostGIS-Datenbank hinzu. Die Datenbank nennen wir auch einfach FrostCon. So, und hier ist jetzt eine Besonderheit. Was, also vorher hatten wir ja zum Beispiel

die, auch hier den Geo-Server selber über Local Host eben angesprochen. Innerhalb dieses Docker, wo bin ich jetzt hier gelandet, innerhalb der Docker-Konfiguration, na, ich hab's jetzt leider hier nicht komplett, gucken wir uns einfach mal ganz kurz hier an,

bekommt aber jeder Host den Namen, den er hier im Docker Compose als Service gegeben bekommen hat. Das heißt also, wenn ich jetzt hier auf die PostGIS-Datenbank drauf zugreifen will, muss ich hier den Namen PostGIS nutzen. Weiter noch wichtig, damit ich überhaupt innerhalb des Dockers oder des Docker-Netzwerkes,

das ich hier erstellt hab, darauf zugreifen kann, ist hier noch wichtig, dass ich das Exposed genannt hab, weil mit Exposed sag ich quasi, der Port 5432 soll innerhalb des Docker-Netzwerkes quasi erreichbar sein. Das hatten wir jetzt auch nur bei PostGIS angegeben und bei den anderen nicht. Da haben wir sonst einfach nur Ports genutzt, weil die untereinander gerade gar nicht arbeiten müssen, sollen,

wie auch immer. So, und wenn wir das jetzt aber in der Konfiguration jetzt sofort führen, müssen wir also hier PostGIS eintragen. Der Port bleibt der gleiche. Die Datenbank hab ich FrostCon genannt. Das Schema bleibt public. Auch der Benutzer heißt FrostCon und FrostCon ist mein super geheimnis Passwort,

was niemand weiterverraten darf. Also speichern wir das und meine Session ist abgelaufen. So, machen wir es nochmal.

FrostCon, auch PostGIS. FrostCon heißt die Datenbank. FrostCon heißt der Benutzer. FrostCon wird als Passwort genannt. Jetzt haben wir also unsere Datenspeicher

prinzipiell angelegt. Allerdings ist in unsere Datenbank bisher noch nichts drin. Das waren aber unsere Schritte, die wir jetzt hier erstmal machen wollten. Gehen wir nochmal durch. Delete all workspaces. Wir stellen den neuen Workspace, aktivieren WFS, WMS und WMTS einfach mal und füllen die Kontaktinformationen aus. Haben wir gemacht.

So, dann verbinden wir mit der Datenbank. Das haben wir gerade eben auch gemacht. Und wir wollen eigentlich einen neuen Layer hinzufügen, aber wir können gerade keinen neuen Layer anlegen, weil noch gar keiner da ist. Also müssen wir gerade mal zum Beispiel zu QGIS wechseln. Und ich glaube, das kann man einigermaßen erkennen

oder ihr kennt euch so gut mit QGIS aus, dass ihr wisst, was ich jetzt hier mache. Als allererstes könnten wir einfach mal unseren WMS-Server auch hinzufügen, den wir ja mit Map-Proxy angelegt haben, damit man auch mal sieht, dass es den überhaupt gibt. Den nennen wir dann nämlich auch einfach mal

Throscon, geben die URL ein. Da haben wir auch schon unseren Throscon und da haben wir einmal OpenStreetMap und OpenTopoMap. Und wenn das Internet hier nicht zu langsam ist, sollte das eigentlich auch funktionieren. Gucken wir mal gerade, was der hier macht. Er versucht sich auf jeden Fall das Image.

Ah ja, da ist es ja auch schon. Also unser WMS-Server, den wir angelegt haben, funktioniert auf jeden Fall schon mal. So, jetzt müssen wir aber auch noch eine neue Post-GIS-Datenbank hinzufügen. Die lösche ich mal schnell. Da habe ich eigentlich schon hinzugefügt. So, das heißt also, wir gehen auch hier hin und sagen neue Verbindungen.

Dann nennen die einfach Post-GIS-Docker zum Beispiel. Hätte ich mir das nicht da aufgeschrieben? Genau. Hier in dem Fall ist es ja jetzt wieder Local Host, weil wir die Variante von Post-GIS

nutzen wollen, die auf unseren Local Host weiter gereicht worden ist. Deswegen hier können wir nicht Post-GIS nutzen, weil mein Host-Rechner kennt Post-GIS überhaupt gar nicht als Hostname. So, muss ich sonst noch? Ja genau, wir müssen noch die Datenbank FrostCon angeben. Wir wollen den Benutzer FrostCon nutzen mit dem FrostCon Passwort.

Das müsste eigentlich schon alles sein. Also wir sehen, wir haben jetzt auf jeden Fall schon mal die Verbindung zur Datenbank, aber wir können natürlich noch nichts anlegen, weil eben noch gar keine Daten in der Datenbank drin waren.

Also zumindest im Geo-Server können wir noch keinen neuen Layer anlegen. Dafür holen wir uns jetzt einfach mal einen Datensatz, den ich heute noch später in dem anderen Vortrag noch mal kurz zeigen werde. Hier geht es eigentlich nur darum, da sind die Geo-Koordinaten der Evoke und der FrostCon im Endeffekt mit drin.

Und die fügen wir jetzt hier mal mit hinzu, da sind sie auch schon da. Gehen auch einfach mal hier etwas näher ran, damit wir auch sehen, was wir da haben. Das Internet ist hier aber fast langsam. Egal. Doch, jetzt ist es aber immer noch. Also hier in Köln ist auf jeden Fall der eine Punkt und hier bei Bonn der andere Punkt.

So, jetzt benutzen wir aber den Datenbank Manager einfach, um uns diese Daten in die PostGIS herein zu bringen. So, das können wir hier mit Import machen. Wir nehmen die Quelle.

Das müsste auch schon die richtige sein. Richtig, die Geojasons. Wir haben den Primärschlüssel und die Geometriespalte. Wir wollen auch einfach mal einen räumlichen Index erstellen. Ja, und falls was vorhanden ist, aber ist ja nicht, wollen wir es auch ersetzen. Machen wir es einfach mal so. Ach so, Tabellenname erfüllen. Ach so.

Muss ich jetzt noch mal gerade in meiner Präsentation gucken, was ich mir da ausgedacht habe. Tabelle POIS, hatte ich die genannt. Import war erfolgreich. Das heißt also jetzt in unserer Datenbank haben wir jetzt hier POIS, eben die zwei Punkte, mit hinzugefügt.

So, jetzt gehen wir wieder zurück zum Geo-Server. Wir stehen hier immer noch auf neuen Layer hinzufügen. Ich gucke mal gerade, was meine Session macht. Dann gucken wir einfach mal so. So, und hier haben wir nämlich jetzt auch

den Arbeitsbereich FrostGIS. Da haben wir das hier, FrostGIS, genau. Wo haben wir denn den Layer hinzufügen? So, und hier haben wir nämlich jetzt auch die gerade neu erstellten POIS aus der Spatial,

nee, der Spatial PostGIS-Datenbank. Hier können wir jetzt einfach auf publizieren gehen. Wir müssen allerdings noch daran denken, zumindest die begrenzenden Rechtecke herauszurechnen. Das sind die weiteren Attribute, die mit dazu gegeben worden sind.

Und jetzt drücken wir einfach Speichern. Das heißt also, der Dienst müsste jetzt verfügbar sein. Und das heißt, wir können jetzt einfach wieder zurück zu QGIS einfach mal zum Beispiel gehen und den quasi damit gerade neu erstellten WFS-Layer mal einfach versuchen hinzuzufügen.

Dann gucken wir, wie ich hier die Datenbankverwaltung gekriegt habe. Das heißt also, wir versuchen hier eine neue Verbindung. frost-con-wb, wie auch immer. Dann nehmen wir das WFS.

Benutzernamen und Passwort brauchen wir an dieser Stelle nicht. Und wenn wir jetzt hier gucken, da haben wir schon POIS, die natürlich jetzt genau auf den anderen Punkten liegen. Deswegen ist das prinzipiell etwas langweilig, die zu zeigen. Aber wir probieren es gerade trotzdem mal.

Das heißt also, wenn ich jetzt hier die POIS hinzufügen würde und die anderen wegmache, habe ich die Punkte immer noch weiterhin da. Das heißt also, der Import hat funktioniert. Ich habe also tatsächlich aus meiner GeoJSON heraus in die Datenbank über GeoServer dann gleichzeitig auch noch den WFS-Server daraus gestartet. Ja, es ist noch mehr möglich.

Ich weiß jetzt nicht, wie viel Zeit wir prinzipiell haben. Ja, ein paar Minuten hätten wir noch. Ich hatte jetzt hier einfach noch mal so zusätzlich als optionales Beispiel mit dazu geschrieben, dass wir jetzt auch zum Beispiel einfach einen MAP-Bender hinzufügen könnten. Das wird eben dann ganz genauso funktionieren.

Würde ich sonst auch einfach sagen, in Anbetracht dessen, dass wir noch ein paar Minuten Zeit haben, machen wir das sonst einfach noch ganz kurz. Dann sehen wir mich auch, dass die Daten jetzt erhalten bleiben, weil wir jetzt ja alles schön in Wolchens ausgegliedert haben und damit jetzt unsere Daten nicht mehr verloren gehen.

Das habe ich noch scheinbar in dem anderen Tab geöffnet.

Wir fügen jetzt einfach hier auch noch den MAP-Bender mit hinzu. Die Parameters YAML für den MAP-Bender könnte man natürlich genauso jetzt hier einbinden, wie man es gerade eben bei der MAP-Proxy-YAML auch gesehen hat. Ich habe jetzt allerdings keine MAP-Bender-YAML im Vorfeld großartig erstellt. Deswegen lasse ich das jetzt einfach so.

Es funktioniert aber auch schon prinzipiell ganz gut auf den Standard-Einstellungen. Ich gucke, dass ich in der richtigen Zeile bin. Das heißt also, vom Image MAP-Bender 3 laden wir die ganzen Sachen. Und auch hier möchten wir jetzt einfach den Port, diesmal auf 8000 zum Beispiel, einfach weiterreichen.

Jetzt probieren wir nochmal den Docker zum Laufen zu kriegen. Er startet jetzt auf jeden Fall auf den MAP-Bender 3 schon, wie man sieht. Hier könnte man jetzt natürlich auch noch darauf achten, wenn man jetzt zum Beispiel Daten aus dem Geo-Server beziehen will im MAP-Bender,

könnte man natürlich jetzt hier auch wieder ein Depends-on-Geo-Server und so weiter hinzufügen. Aber wie gesagt, das war jetzt nur ein Beispiel, was ich noch mal hinzugefügt habe. Falls man noch genug Zeit hatte, ich wusste nicht genau, wie schnell ich es jetzt hier tatsächlich schaffe. So, wenn wir jetzt aber auf Localhost 8000 gehen, ein bisschen warten, bis sich der Cache aufgebaut hat.

Tada, läuft auch schon der MAP-Bender. Das heißt also, auch den können wir uns jetzt dementsprechend einrichten, mit den Datenquellen und und und verbinden. Und schon sind wir noch einen ganzen Schritt weiter zu unserer, einfach in einer dreiviertel Stunde oder halben Stunde aufgebauten GDI.

Das war es auch eigentlich schon. Hier noch mal unsere wichtigsten Informationen quasi zusammengesammelt. Wir sind das Jager Development Team. Ihr könnt uns sonst auch über E-Mail erreichen. Wird uns freuen, wenn ihr uns auf Twitter followt.

Wir sind da Jager.js. Auf GitHub haben wir auch den Namen Jager.js, wo ihr alles weitere auch sonst von uns findet, wo ich auch später die Folien noch hochladen wollte. Und leider habe ich das richtige Docker-Symbol hier nicht richtig hinzugefügt, aber die Module sollen die Docker-Images quasi darstellen.

Also auch auf Docker-Hub heißt unser Benutzername quasi Jager.js. In den Folien sind aber wie gesagt auch die ganzen Links drin verlinkt, wie auch immer. Da kann man sich das immer alles angucken und sonst vielleicht auch einfach nochmal Stück für Stück zu Hause

oder wie auch immer ausprobieren. Ja, so viel dann von mir. Ja, herzlichen Dank, Arne, für die Vorstellung, vor allen Dingen für diese interaktive Vorführung. Das wäre super. Ja, gibt es Fragen aus dem Publikum?

Sieht jetzt nicht so aus. Gut. Okay, ansonsten, ich bin ja noch hier in der Nähe und laufe immer mal wieder rum, wenn noch jemand sonst Fragen an mich hat, kann natürlich gerne bei mir mal vorbeikommen. Ich habe noch eine Ankündigung. Wir haben zwei Vorträge noch in das Programm reingenommen,

um 14 Uhr. Da ist noch ein freier Slot und da stellen wir die OSGEO, Fos4G, Foskis, OpenStreetMap, die Projekte vor, in einer halben Stunde, von 14 bis 14.30 Uhr. Und von 14.30 bis 15 Uhr gibt es einen Vortrag zu MapBender.

Das ist ein Geoportal-Framework, mit dem man Anwendungen erstellen kann. Also, wenn ihr Lust habt, schaut um 14 Uhr vorbei. Aber herzlichen Dank nochmal, Arne.