Merge pull request #32 from terrestris/overwork

feat: overwork GDI workshop

src/README.md

@@ -27,7 +27,7 @@ Grundlagenwissen zu Docker.
 * [Grundlagen Docker Compose](basics/docker-compose/README.md)
 Grundlagenwissen zu Docker Compose.
 
-* [Beispiel-GDI](gdi/README.md)
+* [Aufbau einer Geodateninfrastruktur](gdi/README.md)
 Praktischer Aufbau einer exemplarischen GDI mit Docker und Docker Compose.
 
 # Autoren

src/SUMMARY.md

@@ -5,4 +5,9 @@
 * [Basiswissen](basics/README.md)
   * [Docker](basics/docker/README.md)
   * [Docker Compose](basics/docker-compose/README.md)
-* [Beispiel-GDI](gdi/README.md)
+* [Aufbau einer Geodateninfrastruktur](gdi/README.md)
+  * [Vorbereitung](gdi/preparation/README.md)
+  * [PostGIS](gdi/postgis/README.md)
+  * [GeoServer](gdi/geoserver/README.md)
+  * [OpenLayers über nginx](gdi/nginx/README.md)
+  * [Musterlösung](gdi/solution/README.md)

src/basics/docker-compose/README.md

@@ -48,11 +48,11 @@ Erstellen Sie eine Datei `docker-compose.yml` in einem beliebiegen Verzeichnis (
 version: '3.8'
 services:
   fossgis-geoserver:
-    image: docker.osgeo.org/geoserver:2.24.2
+    image: docker.osgeo.org/geoserver:2.26.2
     ports:
       - "8080:8080"
   fossgis-postgis:
-    image: postgis/postgis:16-3.4-alpine
+    image: postgis/postgis:16-3.5-alpine
     ports:
       - "5433:5432"
     environment:

src/gdi/README.md

@@ -1,77 +1,26 @@
-# Beispiel-GDI
+# Aufbau einer Geodateninfrastruktur
 
-In diesem Kapitel werden wir eine exemplarische GDI bestehend aus den folgenden Komponenten aufbauen:
-  * PostGIS Datenbank zur Persistierung der Geodaten.
-  * GeoServer zur Veröffentlichung der Geodaten über OGC-Dienste.
-  * OpenLayers Applikation zur Anzeige der Geodaten über den Browser.
+In diesem Kapitel werden wir Schritt für Schritt eine Geodateninfrastruktur (GDI) aufbauen. Ziel ist es, eine vollständige Umgebung zur Speicherung, Bereitstellung und Visualisierung von Geodaten zu erstellen. Dabei setzen wir auf bewährte Open-Source-Technologien, die in vielen professionellen GIS-Projekten weltweit zum Einsatz kommen.
 
-## Zielarchitektur der GDI
+Unsere GDI wird aus den folgenden Kernkomponenten bestehen:
 
-![Zielarchitektur der GDI](../assets/architecture.png)
-
-## Vorarbeiten
-
-* Legen Sie - z.B. im Verzeichnis `/home/user/` - ein neues Verzeichnis `docker-gdi` an. In diesem Verzeichnis werden alle notwendigen Dateien abgelegt.
-* Laden Sie das Archiv <a href="../../materials.zip" target="_blank">materials.zip</a> herunter (z.B. nach `/home/user/Downloads`) und entpacken Sie dieses. In dem Archiv befinden sich einige Dateien, die wir später benötigen werden.
-
-## Aufgaben
-
-### PostGIS-Service
+- **OpenLayers** – Eine moderne, JavaScript-basierte Open-Source-Bibliothek, mit der wir interaktive Karten direkt im Browser anzeigen und mit ihnen interagieren können.
+- **GeoServer** – Ein flexibler und weit verbreiteter Kartenserver, mit dem wir unsere Geodaten über standardisierte OGC-Dienste (z. B. WMS, WFS, WCS) bereitstellen können.
+- **PostGIS** – Eine leistungsstarke Erweiterung für die PostgreSQL-Datenbank, die es uns ermöglicht, Geodaten effizient zu speichern, zu verwalten und abzufragen.
 
-* Legen Sie eine neue Datei namens `docker-compose.yml` in einem beliebigen Verzeichnis an.
-* Fügen Sie dieser Datei einen neuen Service `fossgis-postgis` basierend auf dem `postgis/postgis` [Image](https://hub.docker.com/r/postgis/postgis/) in Version `16-3.4-alpine` hinzu.
-  * Achten Sie beim Anlegen des Services auf das korrekte Weiterleiten des internen Ports (5432) auf den Host (5433) und legen Sie einen User mit den Zugangsdaten `fossgis:fossgis` an.
-  * Mounten Sie das Datenverzeichnis der Datenbank (`/var/lib/postgresql/data`) auf das Hostsystem.
-  * Setzen Sie die folgenden Umgebungsvariablen:
-    * `POSTGRES_USER`: `fossgis`
-    * `POSTGRES_PASSWORD`: `fossgis`
-* Starten Sie den Service (über `docker compose up`).
-* Importieren Sie die weltweiten Landesgrenzen (siehe `countries.sql` aus der `materials.zip`) in die Datenbank.
-  * Hierzu können Sie z.B. `pgAdmin` verwenden (Datenbank `fossgis`).
-  * Alternativ kann der folgende Terminal-Befehl verwendet werden: `psql -U fossgis -h localhost -p 5433 -d fossgis -f countries.sql`
+Während des Workshops werden wir die einzelnen Komponenten installieren, konfigurieren und in ein funktionierendes System integrieren. Am Ende hast du eine lauffähige GDI, mit der du eigene Geodaten verwalten und visualisieren kannst.
 
-![pgAdmin nach Import der Geodaten](../assets/pgadmin.png)
+## Zielarchitektur
 
-### GeoServer-Service
-
-* Erweitern Sie die `docker-compose.yml` durch den Service `fossgis-geoserver` und nutzen Sie dabei das `docker.osgeo.org/geoserver:2.24.2` [Image](https://github.com/geoserver/docker).
-  * Achten Sie auch hier auf das korrekte Mappen des internen Ports (8080) auf den Host (8080).
-  * Mounten Sie das Datenverzeichnis des GeoServers (`/opt/geoserver_data`) auf das Hostsystem.
-  * Bestimmen Sie zusätzlich die Startreihenfolge der Services mittels `depends_on`:
-    1. `fossgis-postgis`
-* Stoppen Sie, falls noch nicht geschehen den bisherigen Service und starten Sie das compose Netzwerk neu.
-* Öffnen Sie den GeoServer über die Adresse [http://localhost:8080/geoserver](http://localhost:8080/geoserver) im Browser. Nutzen Sie als Anmeldedaten `admin:geoserver`.
-* Legen Sie einen neuen Arbeitsbereich `FOSSGIS` an.
-* Legen Sie einen neuen Datenspeicher `POSTGIS` an und nutzen Sie dabei die folgenden Verbindungsparameter:
-  * Host: `fossgis-postgis`
-  * Port: `5432`
-  * Database: `fossgis`
-  * Schema: `public`
-  * User: `fossgis`
-  * Password: `fossgis`
-* Legen Sie anschließend einen neuen Layer `COUNTRIES` auf Basis des Datenspeichers `POSTGIS` und der Tabelle `countries` an.
-* Optional: Nutzen Sie den Stil `countries.sld` aus der `materials.zip` und weisen Sie diesen dem Layer zu.
-
-![Startansicht des GeoServers nach Login](../assets/geoserver-start-screen.png)
-
-### nginx-Service (OpenLayers Anwendung)
-
-* Erstellen Sie auf Ebene der `docker-compose.yml` ein neues Verzeichnis `fossgis-nginx` und dort eine neue Datei `Dockerfile`.
-* Legen Sie das `client`-Verzeichnis sowie die `default.conf` aus der `materials.zip` neben der `Dockerfile` ab.
-* Öffnen Sie die `Dockerfile` und:
-  * Wählen Sie als Basisimage die aktuelle Version des offiziellen nginx [Images](https://hub.docker.com/_/nginx) aus.
-  * Kopieren Sie die Konfigurationsdatei `default.conf` in das Image und wählen Sie als Zielpfad `/etc/nginx/conf.d/default.conf`.
-  * Kopieren Sie den Inhalt des entpackten Client-Archivs `client` in das Image und wählen Sie als Zielpfad `/etc/nginx/html`.
-  * Geben Sie den Port (80) des nginx-Prozesses in der `Dockerfile` an.
-* Fügen Sie der `docker-compose.yml` einen neuen Service `fossgis-nginx` hinzu.
-  * Veröffentlichen Sie den Service-Port 80 auf dem Host-Port 8000 und wählen Sie als Build-Context die zuvor erstellte `Dockerfile`.
-  * Achten Sie bei der Startreihenfolge darauf, dass der `nginx` Service zuletzt gestartet wird.
-* Starten Sie anschließend alle Services neu und öffnen Sie [http://localhost:8000](http://localhost:8000) im Browser.
+![Zielarchitektur der GDI](../assets/architecture.png)
 
-## Startansicht des Kartenclients
+## Nächste Schritte
 
-![Startansicht des Kartenclients](../assets/ol-client.png)
+Im Folgenden werden wir die einzelnen Komponenten der Geodateninfrastruktur (GDI) Schritt für Schritt einrichten. Wir beginnen mit den Geodaten in der Datenbank, setzen mit dem GeoServer anschließend Geodienste darauf auf, um diese schließlich mit einer kleinen OpenLayers-Webanwendung zu visualisieren.
 
-## Musterlösung
+- [Vorarbeiten](preparation/README.md)
+- [PostGIS](postgis/README.md)
+- [GeoServer](geoserver/README.md)
+- [OpenLayers über nginx](nginx/README.md)
 
-Eine Musterlösung für die Beispiel-GDI finden Sie [hier](https://github.com/terrestris/docker-ws/tree/main/resources/gdi).
+Folgen Sie den jeweiligen Links, um zur detaillierten Anleitung für die einzelnen Komponenten zu gelangen. 🚀

src/gdi/geoserver/README.md

@@ -0,0 +1,88 @@
+# Einrichten des GeoServer-Services
+
+Nachdem wir die PostGIS-Datenbank erfolgreich eingerichtet haben, erweitern wir unsere **docker-compose.yml** nun um den **GeoServer**, um Geodaten als OGC-Dienste bereitzustellen.
+
+## GeoServer-Service hinzufügen
+
+Erweitern Sie die bestehende **`docker-compose.yml`** um einen weiteren Service.
+
+* Name: `fossgis-geoserver`
+* Image: [`docker.osgeo.org/geoserver:2.26.2`](https://github.com/geoserver/docker)
+
+Folgende Punkte sollten berücksichtigt werden:
+
+* Port-Mapping: Der interne (HTTP-) **Port 8080** auf sollte auf den **Host-Port 8080** weitergeleitet werden.
+* Datenverzeichnis **mounten**:
+   - Host: Eigener Pfad für persistente Speicherung, z.B. `./geoserver_data`
+   - Container: `/opt/geoserver_data`
+* **Startreihenfolge** festlegen:
+   - `depends_on`: `fossgis-postgis`
+
+✏️ **Hinweis:** Die `depends_on`-Option stellt sicher, dass der GeoServer erst gestartet wird, wenn die PostGIS-Datenbank bereit ist.
+
+
+## GeoServer starten
+
+Falls nötig, beenden Sie den laufenden Docker-Compose-Dienst:
+
+```bash
+docker compose down
+```
+
+Starten Sie das Compose-Netzwerk neu:
+
+```bash
+docker compose up
+```
+
+
+## Zugriff auf GeoServer
+
+Nach dem erfolgreichen Start können Sie den **GeoServer** im Browser unter folgender Adresse aufrufen:
+
+🔗 [http://localhost:8080/geoserver](http://localhost:8080/geoserver)
+
+📌 **Login-Daten:**
+- Benutzer: `admin`
+- Passwort: `geoserver`
+
+![Startansicht des GeoServers nach Login](../../assets/geoserver-start-screen.png)
+
+
+##  Arbeitsbereich anlegen
+
+1. Melden Sie sich im GeoServer an.
+2. Navigieren Sie zu **Arbeitsbereiche** (bzw. **Workspaces**).
+3. Erstellen Sie einen neuen Arbeitsbereich mit dem Namen `FOSSGIS`.
+
+## PostGIS-Datenquelle einbinden
+1. Navigieren Sie zu **Datenspeichern** (bzw. **Stores**) und erstellen Sie einen neuen Datenspeicher **`POSTGIS`**.
+2. Verwenden Sie folgende Verbindungsparameter:
+
+| **Parameter**  | **Wert** |
+|---------------|---------|
+| **Host**      | `fossgis-postgis` |
+| **Port**      | `5432` |
+| **Database**  | `fossgis` |
+| **Schema**    | `public` |
+| **User**      | `fossgis` |
+| **Password**  | `fossgis` |
+
+
+## Neuen Layer hinzufügen
+
+1️. Neuen Layer `COUNTRIES` anlegen
+   - Quelle: Datenspeicher `POSTGIS`
+   - Tabelle: `countries`
+
+2️. Optional: Stil für den Layer festlegen
+   - Verwenden Sie den Stil **`countries.sld`** aus der `materials.zip`.
+
+
+## 🎯 Geschafft!
+
+Ihr **GeoServer ist nun eingerichtet** und veröffentlicht Geodaten als Web Map Services (WMS). 🎉
+Im nächsten Schritt werden wir **OpenLayers über nginx** einbinden.
+
+➡️ Weiter zu [OpenLayers über nginx](../nginx/README.md) 🚀
+

src/gdi/nginx/README.md

@@ -0,0 +1,87 @@
+# Einrichten des nginx-Services
+
+Im letzten Schritt unseres Workshops richten wir einen **nginx-Service** ein, der als HTTP-Server eine **OpenLayers-Anwendung** bereitstellt.
+Dieser Service wird als dritter und letzter Bestandteil unserer Geodateninfrastruktur in die `docker-compose.yml` integriert.
+
+
+## Verzeichnisstruktur & Dateien vorbereiten
+
+📂 Neues Verzeichnis für den nginx-Service anlegen:
+
+```bash
+mkdir fossgis-nginx
+```
+
+📄 Erstellen Sie in diesem Verzeichnis eine neue Datei namens `Dockerfile`
+
+📥 Dateien aus der `materials.zip` einbinden:
+
+- Kopieren Sie das `client`-Verzeichnis nach `fossgis-nginx`.
+- Kopieren Sie die `default.conf` nach `fossgis-nginx`.
+
+
+## `Dockerfile` erstellen
+
+Öffnen Sie das `Dockerfile` in einem Editor und definieren Sie ein aktuelles nginx Docker-Image als Basis.
+Nutzen Sie die aktuelle Version des offiziellen [nginx-Images](https://hub.docker.com/_/nginx).
+
+Erweitern Sie das Dockerfile um folgende Schritte:
+
+- Kopieren Sie die nginx-Konfiguration `default.conf` in das Image:
+   - Zielpfad: `/etc/nginx/conf.d/default.conf`
+- Kopieren Sie den Inhalt des `client`-Verzeichnisses in das Image:
+   - Zielpfad: `/etc/nginx/html`
+- Geben Sie den Port **80** für den nginx-Prozess an.
+
+
+## nginx-Service hinzufügen
+
+Erweitern Sie die bestehende **`docker-compose.yml`** um einen weiteren Service.
+
+* Name: `fossgis-geoserver`
+
+Folgende Punkte sollten berücksichtigt werden:
+
+- Statt eines Image einen Build-Context nutzen, also das Dockerfile im `fossgis-nginx`-Unterverzeichnis.
+- Port-Mapping:
+   - Container-Port: `80`
+   - Host-Port: `8000`
+- Startreihenfolge (`depends_on`) beachten:
+   - `fossgis-geoserver`
+
+✏️ **Hinweis:** nginx wird als **letzter Dienst** gestartet, damit die Geodaten bereits verfügbar sind.
+
+
+## Alle Services neu starten
+
+Falls nötig, stoppen Sie alle Services:
+
+```bash
+docker compose down
+```
+
+Starten Sie anschließend das gesamte Compose-Netzwerk neu:
+
+```bash
+docker compose up --build
+```
+
+
+## OpenLayers-Anwendung aufrufen
+
+Nach dem erfolgreichen Start können Sie die **OpenLayers-Anwendung** im Browser öffnen:
+
+🔗 [http://localhost:8000](http://localhost:8000)
+
+
+## 🎯 Geschafft!
+
+Ihre komplette Geodateninfrastruktur läuft nun mit Docker.
+
+✅ **PostGIS-Datenbank** speichert die Geodaten
+
+✅ **GeoServer** stellt OGC-Dienste bereit
+
+✅ **nginx** hostet die OpenLayers-Anwendung
+
+➡️ Weiter zur [Musterlösung](../solution//README.md) 🚀

src/gdi/postgis/README.md

@@ -0,0 +1,64 @@
+# Einrichten einer PostGIS-Datenbank
+
+In diesem Abschnitt richten wir eine **PostGIS-Datenbank** über Docker Compose ein. Diese Datenbank bildet die Grundlage für unsere Geodateninfrastruktur.
+
+
+## PostGIS-Service hinzufügen
+
+Fügen Sie in der `docker-compose.yml` eine neue service Konfiguration hinzu.
+
+* Name: `fossgis-postgis`
+* Image: [`postgis/postgis:16-3.4-alpine`](https://hub.docker.com/r/postgis/postgis/)
+
+Folgende Punkte sollten berücksichtigt werden:
+
+* Der interne **PostgreSQL-Port 5432** soll auf den **Host-Port 5433** weitergeleitet werden, damit wir in der Lage sind Daten zu importieren.
+* Das Datenverzeichnis der Datenbank (`/var/lib/postgresql/data`) sollte auf das Hostsystem **gemountet** werden.
+* Ein **Datenbank-Benutzer** mit den Zugangsdaten `fossgis:fossgis` muss angelegt werden. Dies kann über das Setzen der folgenden Umgebungsvariablen erreicht werden:
+
+```plaintext
+POSTGRES_USER: fossgis
+POSTGRES_PASSWORD: fossgis
+```
+
+✏️ **Tipp:** Falls Sie unsicher sind, wie Sie das `docker-compose.yml`-File strukturieren sollen, werfen Sie einen Blick in die [Docker Compose Dokumentation](https://docs.docker.com/reference/compose-file/).
+
+
+## Service starten
+
+Starten Sie den PostGIS-Dienst mit folgendem Befehl:
+
+```bash
+docker compose up
+```
+
+
+## Geodaten importieren
+
+Um die Datenbank mit Geodaten zu füllen, importieren wir die weltweiten Landesgrenzen (`countries.sql` aus der entpackten `materials.zip`).
+
+🖥️ **Variante 1 – Nutzung von pgAdmin:**
+- Öffnen Sie pgAdmin
+- Verbinden Sie sich mit der Datenbank `fossgis`
+- Importieren Sie die Datei `countries.sql`
+
+📟 **Variante 2 – Terminal-Befehl:**
+Alternativ können Sie das folgende Kommando nutzen:
+
+```bash
+psql -U fossgis -h localhost -p 5433 -d fossgis -f countries.sql
+```
+
+
+## Prüfung der Daten
+
+Nach dem Import sollten die Landesgrenzen in der PostGIS-Datenbank sichtbar sein. Ein Beispiel in pgAdmin:
+
+![pgAdmin nach Import der Geodaten](../../assets/pgadmin.png)
+
+
+### 🎯 Geschafft!
+Ihre **PostGIS-Datenbank läuft nun in Docker** und enthält die ersten Geodaten.
+Im nächsten Schritt erweitern wir unsere Geodateninfrastruktur um den **GeoServer**.
+
+➡️ Weiter zu [GeoServer](../geoserver/README.md) 🚀

src/gdi/preparation/README.md

@@ -0,0 +1,28 @@
+# Vorarbeiten
+
+Bevor wir mit der Einrichtung der Geodateninfrastruktur beginnen, müssen wir einige Vorbereitungen treffen.
+
+1. **Neues Verzeichnis anlegen**
+
+   Erstellen Sie ein neues Verzeichnis namens `docker-gdi`, in dem alle notwendigen Dateien gespeichert werden:
+
+   ```bash
+   mkdir -p ~/docker-gdi
+   cd ~/docker-gdi
+   ```
+
+2. **Materialien herunterladen und entpacken**
+
+   Laden Sie das Archiv [materials.zip](https://github.com/terrestris/docker-ws/raw/refs/heads/main/materials/materials.zip) in das `docker-gdi`-Verzeichnis herunter und entpacken Sie es:
+
+   ```bash
+   wget https://github.com/terrestris/docker-ws/raw/refs/heads/main/materials/materials.zip
+   unzip materials.zip
+   ```
+   Das Archiv enthält einige wichtige Dateien, die wir später benötigen.
+
+3. **Neue Datei anlegen**
+
+    Legen Sie eine Datei namens **`docker-compose.yml`** an.
+
+📌 Hinweis: Die `docker-compose.yml` werden wir in den folgenden Abschnitten um unsere Dienste erweitern. Wir beginnen mit der Bereitstellung einer [PostGIS Datenbank](../postgis/README.md).