Seminar Teedy – Entwicklung: Build, Anpassung und Bereitstellung

Eigene Anpassungen müssen sich sauber bauen, testen, aktualisieren und betreiben lassen. Das Seminar führt von der Entwicklungsumgebung und Quellcodeorientierung über kontrollierte Änderungen bis zu reproduzierbaren Artefakten und einer abgesicherten Bereitstellung.

Inhaltsverzeichnis

1. Seminarprofil
2. Zielgruppe
3. Voraussetzungen
4. Lernziele
5. Seminarinhalte
6. Praxisübungen
7. Methodik

Seminarprofil

Der Kurs behandelt einen vollständigen Entwicklungszyklus statt unkontrollierter Eingriffe in ein Produktivsystem. Repository-Struktur, Backend, Weboberfläche, Datenänderungen, API, Build, Tests, Containerisierung, Rollback, Upgradefähigkeit und technische Dokumentation werden zusammengeführt.

Zielgruppe

Softwareentwicklung, DevOps, technische Architektur, Systemintegration und Anwendungsbetreuung mit Entwicklungsauftrag.

Voraussetzungen

Sichere Kenntnisse in Softwareentwicklung, Versionsverwaltung, Kommandozeile und Webtechnologien. Java-Grundkenntnisse für Backendarbeiten sowie JavaScript- oder TypeScript-Kenntnisse für Oberflächenanpassungen. Docker- und Datenbankkenntnisse sind hilfreich.

Lernziele

• Entwicklungsumgebung und Buildprozess reproduzierbar einrichten.
• Quellcodebereiche, Konfiguration und Laufzeitkomponenten sicher zuordnen.
• Änderungen klein, versioniert, testbar und upgradefähig umsetzen.
• Daten- und Schnittstellenänderungen mit Migration und Rückweg planen.
• Artefakte kontrolliert paketieren, bereitstellen, überwachen und dokumentieren.

Seminarinhalte

1. Entwicklungsauftrag und Änderungsgrenzen klären

Vor dem ersten Code wird entschieden, ob Konfiguration, Integration oder Quellcodeänderung die wartbarste Lösung darstellt.

1. Schritt 1: Fachliche Anforderung in beobachtbares Sollverhalten und Akzeptanzkriterien übersetzen.
2. Schritt 2: Konfiguration, externe Integration und Produktanpassung gegeneinander abgrenzen.
3. Schritt 3: Betroffene Daten, Berechtigungen, Schnittstellen und Betriebsabläufe erfassen.
4. Schritt 4: Upgrade-, Sicherheits- und Wartungsrisiken als Teil der Entscheidung dokumentieren.

2. Repository und Entwicklungsumgebung reproduzierbar einrichten

Quellstand, Laufzeit, Buildwerkzeuge, Datenbank, Konfiguration und Geheimnisse werden sauber getrennt.

1. Schritt 1: Definierten Quellstand auschecken und Branch- sowie Versionsstrategie festlegen.
2. Schritt 2: Erforderliche Laufzeit, Buildwerkzeuge, Datenbank und Hilfsdienste bereitstellen.
3. Schritt 3: Lokale Konfiguration und Geheimnisse vom versionierten Quellcode trennen.
4. Schritt 4: Unveränderten Ausgangsstand bauen und mit einem Basistest verifizieren.

3. Architektur und geeigneten Erweiterungspunkt erschließen

Backend, Weboberfläche, Datenzugriff, API, Ereignisse und Konfiguration werden vor der Änderung zugeordnet.

1. Schritt 1: Quellcodebereiche und Einstiegspunkte für Dokumente, Metadaten, Suche und Benutzer identifizieren.
2. Schritt 2: Abhängigkeiten und Datenflüsse mit Debugging sowie Protokollen nachvollziehen.
3. Schritt 3: Bestehende Komponenten und Erweiterungsmöglichkeiten vor einer Neuentwicklung prüfen.
4. Schritt 4: Den kleinsten wartbaren Eingriff mit klarer Verantwortlichkeit auswählen.

4. Backend- und Oberflächenänderung sicher umsetzen

Änderungen werden klein, validiert, berechtigungsgeprüft, zugänglich und automatisiert testbar entwickelt.

1. Schritt 1: Arbeit in einzeln prüfbare Schritte zerlegen und Eingaben konsequent validieren.
2. Schritt 2: Bestehende Berechtigungsprüfungen und Fehlerbehandlung einbeziehen.
3. Schritt 3: Oberflächenmuster, responsive Darstellung und Tastaturbedienung prüfen.
4. Schritt 4: Unit-, Schnittstellen- und End-to-End-Tests für Erfolgs-, Rand- und Berechtigungsfälle ergänzen.

5. Daten- und Schnittstellenänderungen migrierbar gestalten

Datenstrukturen und API-Verträge erhalten eine Vorwärts-, Kompatibilitäts- und Rückwärtsstrategie.

1. Schritt 1: Ausgangsdaten, Zielstruktur und Transformation eindeutig beschreiben.
2. Schritt 2: Migration wiederholbar und gegen bereits verarbeitete Datensätze sicher entwerfen.
3. Schritt 3: API-Felder, Statuscodes, Berechtigungen und Kompatibilität dokumentieren.
4. Schritt 4: Migration und Schnittstelle mit gültigen, ungültigen und nicht berechtigten Fällen testen.

6. Build, Container und Bereitstellung automatisieren

Jeder Stand soll aus definiertem Quellcode reproduzierbar entstehen und als eindeutig versioniertes Artefakt bereitgestellt werden.

1. Schritt 1: Buildschritte, Abhängigkeiten, statische Prüfungen und automatisierte Tests festlegen.
2. Schritt 2: Artefakt sowie Containerimage mit Version, Commit, Buildzeit und Prüfergebnis kennzeichnen.
3. Schritt 3: Persistente Daten, Konfiguration und Geheimnisse außerhalb des Images halten.
4. Schritt 4: Deployment in einer repräsentativen Testumgebung mit Gesundheits- und Funktionstest abnehmen.

7. Release, Rollback und Wartung organisieren

Eine Änderung ist erst vollständig, wenn Durchführung, Rückweg, Betrieb und Dokumentation geklärt sind.

1. Schritt 1: Releasehinweise, bekannte Einschränkungen und erforderliche Betriebsschritte erstellen.
2. Schritt 2: Sicherung, Wartungsfenster, Funktionsprüfung und Abbruchpunkt festlegen.
3. Schritt 3: Rollback mit altem Artefakt und kompatiblem Datenstand praktisch proben.
4. Schritt 4: Quellcode, Konfiguration, Tests, Deployment und Supportwissen gemeinsam versionieren.

8. Fehlerbehandlung, Tests und Betriebsübergabe gestalten

Temporäre und dauerhafte Fehler werden unterschieden; die Integration erhält Test-, Überwachungs- und Wartungsverfahren.

1. Schritt 1: Netzwerk-, Berechtigungs-, Validierungs- und fachliche Konfliktfehler klassifizieren.
2. Schritt 2: Wiederholungen mit begrenzter Anzahl und wachsendem Abstand implementieren.
3. Schritt 3: Unit-, Schnittstellen- und End-to-End-Tests für Erfolgs- und Störungsfälle ausführen.
4. Schritt 4: Protokolle, Kennzahlen, Start-, Stopp-, Wiederanlauf- und Geheimniswechselverfahren dokumentieren.

Praxisübungen

1. Reproduzierbarer Aufbau einer lokalen Entwicklungsumgebung aus einem definierten Quellstand.
2. Umsetzung einer kleinen, berechtigungsgeprüften Backend- und Oberflächenänderung mit automatisierten Tests.
3. Erstellung eines Buildartefakts und Containerimages mit externer Konfiguration.
4. Durchführung eines Test-Releases einschließlich Funktionsprüfung und vorbereitetem Rollback.

Methodik

Architekturblöcke, Quellcodeanalyse, geführte Implementierung, automatisierte Tests und Deploymentübungen bilden einen durchgängigen Entwicklungszyklus. Jede Änderung wird auf Wartbarkeit und Upgradefähigkeit geprüft.