Seminar Dogu-Entwicklung: Grundlagen

Die Entwicklung verbindet Containertechnik mit Plattformkonventionen. Ein funktionierendes Image wird erst durch Metadaten, Startlogik, Konfiguration und Integration zu einem Dogu.

Der Kurs baut ein kleines Beispiel von Grund auf. Die drei Tage sind notwendig, damit Build, Installation, Rekonfiguration und Fehlerbehebung tatsächlich geübt werden können.

Inhaltsübersicht

1. Zielgruppe
2. Lernziele
3. Seminarinhalte
4. Praxisübungen
5. Arbeitsweise

Zielgruppe

Softwareentwicklung, DevOps Engineering, Plattformentwicklung und technische Produktteams

Lernziele

• Teilnehmende können eine reproduzierbare Dogu-Entwicklungsumgebung einrichten.
• Teilnehmende können Kernartefakte eines Dogu strukturiert erstellen.
• Teilnehmende können ein Dogu bauen, installieren und prüfen.
• Teilnehmende können typische Build- und Startfehler systematisch beheben.

Seminarinhalte

1. Entwicklungsumgebung und Arbeitsstruktur

Eine reproduzierbare Dogu-Entwicklung benötigt definierte Werkzeuge, Verzeichnisse und eine geeignete Testinstanz.

1. Quellstruktur, Build-Werkzeuge, Containerlaufzeit und Zugänge zur Entwicklungsinstanz prüfen.
2. Dogu-Verzeichnis mit Versionsverwaltung und klarer Trennung von Quellcode und Artefakten anlegen.
3. Lokalen Namespace beziehungsweise Entwicklungsbereich festlegen.
4. Build-, Installations- und Diagnosebefehle in einer Projektanleitung dokumentieren.

2. Dockerfile, startup.sh, dogu.json und Ressourcen

Die Kernartefakte eines Dogu werden mit eindeutigen Verantwortlichkeiten aufgebaut. Einmalige Build-Schritte und wiederkehrende Startlogik bleiben getrennt.

1. Dockerfile für Basisimage, Pakete, Anwendung und unveränderliche Ressourcen erstellen.
2. startup.sh für Konfiguration, Migration, Rechteprüfung und Anwendungsstart strukturieren.
3. dogu.json als zentrale Metadaten- und Integrationsbeschreibung anlegen.
4. Zusätzliche Ressourcen versionieren und mit minimalen Rechten in das Image übernehmen.

3. Basisimage, Image-Aufbau und Laufzeitprinzipien

Das Image bleibt klein, nachvollziehbar und updatefähig. Build-Zeit und Laufzeit werden technisch sauber getrennt.

1. Passendes Cloudogu-Basisimage nach Laufzeit und Anwendungstyp auswählen.
2. Pakete versioniert installieren und temporäre Build-Daten entfernen.
3. Nicht privilegierte Ausführung, Dateirechte und schreibbare Pfade festlegen.
4. Image lokal bauen und auf Größe, Schichten, Startbarkeit und offensichtliche Geheimnisse prüfen.

4. dogu.json: Metadaten, Versionen und Schnittstellen

Die dogu.json beschreibt Identität, Version, Abhängigkeiten und technische Eigenschaften. Änderungen werden schemaorientiert vorgenommen.

1. Name, Namespace, Version, Anzeigeinformationen und Tags konsistent festlegen.
2. Abhängigkeiten mit zulässigen Versionen und optionalem Charakter beschreiben.
3. Ports, Volumes, Healthcheck, Konfiguration und Dienste vollständig modellieren.
4. Datei syntaktisch und semantisch validieren und gegen den vorgesehenen Lifecycle testen.

5. Startlogik, Migrationen und Gesundheitsprüfung

Der Startprozess bleibt idempotent und diagnostizierbar. Datenmigrationen, Konfigurationsübernahme und Anwendungsstart werden kontrolliert verkettet.

1. Vorbedingungen und verfügbare Abhängigkeiten zu Beginn prüfen.
2. Konfiguration aus der Registry lesen, validieren und in Anwendungsform überführen.
3. Datenmigrationen versioniert, wiederholbar und mit Abbruchschutz ausführen.
4. Anwendung starten und Healthcheck erst nach tatsächlicher Betriebsbereitschaft erfolgreich melden.

6. Dogu bauen, paketieren und in einen Namespace übertragen

Der Build erzeugt ein reproduzierbares Image und passende Metadaten. Lokale Artefakte werden klar von freigegebenen Ständen getrennt.

1. Versionsstand und sauberen Arbeitsbaum vor dem Build prüfen.
2. Dogu mit dem vorgesehenen Build-Werkzeug erstellen und Fehler früh abbrechen lassen.
3. Image, Metadaten und Prüfsummen im Entwicklungsnamespace bereitstellen.
4. Artefaktbestand und Version anschließend unabhängig verifizieren.

7. Fehleranalyse bei Build, Start und Integration

Entwicklungsfehler werden anhand der Phase eingegrenzt. Buildfehler, Startfehler, Konfigurationsfehler und Integrationsfehler benötigen unterschiedliche Beweise.

1. Fehler reproduzieren und Phase, Version, Umgebung sowie Eingabedaten festhalten.
2. Buildausgabe, Containerlogs, Registry-Werte und Healthcheck getrennt untersuchen.
3. Minimalen Korrekturversuch erstellen und Nebenwirkungen mit automatisierten Tests prüfen.
4. Ursache, Korrektur und Präventionsmaßnahme im Projekt festhalten.

Praxisübungen

• Anlage eines neuen Dogu-Projekts
• Erstellung von Dockerfile, startup.sh und dogu.json
• Build und Installation in einer Entwicklungsinstanz
• Fehleranalyse eines absichtlich gestörten Startprozesses

Arbeitsweise

Jeder Theorieblock wird unmittelbar am gemeinsamen Beispiel-Dogu umgesetzt und getestet.