Seminar Sonic Cloud Intensivseminar – DevOps, API und Plattformanpassung

Das Intensivseminar verbindet CI/CD-Integration und REST-API mit reproduzierbaren Builds und interner Anpassung von Server, Web-Client und Agent. Sicherheits-, Test- und Releaseanforderungen werden durchgängig berücksichtigt.

Fünf Tage sind das notwendige Maximum, weil Pipeline-Integration, API-Automatisierung und drei Komponenten-Builds gemeinsam umgesetzt und zu einem internen Releaseprozess verbunden werden.

Inhaltsverzeichnis

• Plattformprofil, Einsatzfelder und Lebenszyklus
• Jenkins- und CI/CD-Einbindung
• REST-API und technische Integration
• Benachrichtigungen und Roboter-Integrationen
• Server aus Quellcode aufbauen und anpassen
• Web-Client entwickeln und paketieren
• Agent entwickeln, bauen und testen
• Benutzerdefinierte Skripte und lokale Aktionen
• Absicherung und Schutzbedarfsanalyse
• Berichte, Artefakte und Fehleranalyse
• Störungsbehebung und Wiederanlauf
• Interne Release- und Wartungsstrategie

Lernziele

• Tests über API und Pipeline automatisieren.
• Server, Client und Agent reproduzierbar bauen.
• Anpassungen sicher integrieren und testen.
• Eigene Releases, Patches und Rollbacks beherrschen.

Zielgruppe

DevOps, Softwareentwicklung, Plattformengineering, Build Engineering und technische Architektur.

Voraussetzungen

Gute Kenntnisse in Git, CI/CD, HTTP, JVM-Entwicklung, Frontend-Builds, Containerbetrieb und automatisierten Tests.

Seminarinhalte

Modul 1: Plattformprofil, Einsatzfelder und Lebenszyklus

Die Plattform wird als Device-Lab-, Fernsteuerungs- und Testautomatisierungsumgebung eingeordnet. Der Lebenszyklus der zuletzt veröffentlichten Plattformgeneration wird in die Betriebsentscheidung einbezogen.

1. Schritt 1: Anwendungsfälle für Fernsteuerung, Debugging, manuelle Prüfung und automatisierte Tests voneinander abgrenzen.
2. Schritt 2: Unterstützte Geräteklassen und typische Grenzen eines Real-Device-Labs dokumentieren.
3. Schritt 3: Versionen von Server, Web-Client und Agent als zusammengehörigen Plattformstand erfassen.
4. Schritt 4: Wartungsstatus, Eigenverantwortung für Patches und interne Freigaberegeln in einem Betriebssteckbrief festhalten.

Modul 2: Jenkins- und CI/CD-Einbindung

Automatisierte Testläufe werden als überprüfbarer Pipeline-Schritt gestartet. Trigger, Parameter, Rückgabestatus und Artefakte werden explizit behandelt.

1. Schritt 1: Suite und Zielgeräte als reproduzierbaren Pipeline-Auftrag festlegen.
2. Schritt 2: Authentisierung und benötigte Parameter geschützt bereitstellen.
3. Schritt 3: Testlauf aus Jenkins oder einer vergleichbaren CI-Umgebung auslösen.
4. Schritt 4: Status abfragen, Bericht übernehmen und Pipeline-Ergebnis nach definierten Regeln setzen.

Modul 3: REST-API und technische Integration

Die API wird für kontrollierte Automatisierung von Projekten, Testläufen und Statusabfragen eingesetzt. Zugriffe erhalten klare Rechte und Fehlerbehandlung.

1. Schritt 1: API-Zugang und Berechtigungsumfang für einen technischen Benutzer festlegen.
2. Schritt 2: Anfrageparameter und Antwortschema mit einem ungefährlichen Lesezugriff prüfen.
3. Schritt 3: Teststart und Statusabfrage in ein idempotentes Integrationsskript überführen.
4. Schritt 4: Timeouts, Wiederholungen, Fehlercodes und Protokollierung verbindlich behandeln.

Modul 4: Benachrichtigungen und Roboter-Integrationen

Testergebnisse und Betriebsereignisse werden gezielt an zuständige Teams gemeldet, ohne unkontrollierte Alarmflut zu erzeugen.

1. Schritt 1: Meldeanlässe nach Fehlerklasse und Dringlichkeit priorisieren.
2. Schritt 2: Empfänger, Projektbezug und Mindestinformationen je Meldung definieren.
3. Schritt 3: Benachrichtigung mit Teststatus, Berichtsschlüssel und Fehlerzusammenfassung prüfen.
4. Schritt 4: Dubletten, Wiederholungen und Entwarnungen in eine Alarmierungsregel aufnehmen.

Modul 5: Server aus Quellcode aufbauen und anpassen

Für interne Weiterentwicklung wird der Server reproduzierbar gebaut. Abhängigkeiten, Konfiguration und Datenbankänderungen werden kontrolliert behandelt.

1. Schritt 1: Quellstand und Build-Werkzeuge in einer isolierten Entwicklungsumgebung festlegen.
2. Schritt 2: Abhängigkeiten auflösen und einen unveränderten Referenz-Build erzeugen.
3. Schritt 3: Konfigurationspunkte und Erweiterungsbedarf mit kleinem Änderungsumfang identifizieren.
4. Schritt 4: Build, Migration und API-Verhalten mit automatisierten Prüfungen absichern.

Modul 6: Web-Client entwickeln und paketieren

Änderungen an Oberfläche und Interaktion werden vom reproduzierbaren Frontend-Build bis zur Integration in die Zielumgebung verfolgt.

1. Schritt 1: Frontend-Abhängigkeiten und Build-Konfiguration fixieren.
2. Schritt 2: Referenz-Build erzeugen und Laufzeitparameter vom Quellcode trennen.
3. Schritt 3: Änderung komponentenbezogen umsetzen und mit Rollen sowie Fehlerzuständen testen.
4. Schritt 4: Produktionspaket erstellen und gemeinsam mit dem Serverstand versionieren.

Modul 7: Agent entwickeln, bauen und testen

Agent-Anpassungen berühren Gerätekommunikation, lokale Werkzeuge und Serverprotokolle. Deshalb werden Hostbetriebssystem und Geräteklasse in die Testmatrix aufgenommen.

1. Schritt 1: Agent-Quellstand und benötigte native Werkzeuge vorbereiten.
2. Schritt 2: Unveränderten Agenten bauen und gegen einen passenden Serverstand registrieren.
3. Schritt 3: Anpassung kapseln und Verhalten bei Start, Gerätewechsel und Netzunterbrechung prüfen.
4. Schritt 4: Artefakt versionieren und auf mindestens zwei repräsentativen Hosttypen abnehmen.

Modul 8: Benutzerdefinierte Skripte und lokale Aktionen

Sonderfälle lassen sich über Skripte, REST-Aufrufe, ADB- oder lokale Kommandos abbilden. Diese Erweiterungen benötigen dieselben Qualitäts- und Sicherheitsregeln wie Anwendungs-Code.

1. Schritt 1: Standardaktion und Erweiterungsbedarf gegeneinander prüfen.
2. Schritt 2: Skript mit klaren Eingabeparametern und begrenzten Rechten entwerfen.
3. Schritt 3: Fehlerbehandlung, Timeout und Protokollausgabe ergänzen.
4. Schritt 4: Ausführung auf Testgerät und Agent isoliert prüfen, bevor der Schritt wiederverwendet wird.

Modul 9: Absicherung und Schutzbedarfsanalyse

Server, Agenten und Geräte verarbeiten Zugangsdaten, Testdaten, Screenshots und Netzwerkverkehr. Die Absicherung umfasst technische und organisatorische Maßnahmen.

1. Schritt 1: Datenarten, Geheimnisse und administrative Schnittstellen nach Schutzbedarf einstufen.
2. Schritt 2: Netzwerkzugriffe, Konten, Dateirechte und Zertifikatsbetrieb auf das notwendige Maß reduzieren.
3. Schritt 3: Protokolle und Artefakte auf sensible Inhalte und angemessene Aufbewahrung prüfen.
4. Schritt 4: Patch-, Schwachstellen- und Ausnahmeprozess für eine eigenverantwortlich betriebene Plattform festlegen.

Modul 10: Berichte, Artefakte und Fehleranalyse

Berichte werden nicht nur als Ampel betrachtet. Schrittprotokolle, Screenshots, Aufzeichnungen, Geräteinformationen und Leistungsdaten bilden gemeinsam die Diagnosegrundlage.

1. Schritt 1: Berichtsstatus und fehlgeschlagenen Schritt bis zur technischen Ursache zurückverfolgen.
2. Schritt 2: Screenshots, Protokolle, Aufzeichnung und Leistungsdaten zeitlich korrelieren.
3. Schritt 3: Produktfehler, Testfehler, Gerätefehler und Infrastrukturfehler getrennt klassifizieren.
4. Schritt 4: Wiederholungs- und Eskalationsregeln für nicht eindeutige Fehler festlegen.

Modul 11: Störungsbehebung und Wiederanlauf

Wiederkehrende Störungen werden mit klarer Reihenfolge untersucht. Ungezielte Neustarts werden vermieden, weil sie Beweise vernichten und Ursachen verdecken können.

1. Schritt 1: Auswirkung und betroffenen Umfang bestimmen, bevor Änderungen vorgenommen werden.
2. Schritt 2: Letzte Änderungen, Ressourcenlage und Verbindungsstatus prüfen.
3. Schritt 3: Komponente isoliert testen und nur den notwendigen Dienst neu starten.
4. Schritt 4: Ursache, Maßnahme, Verifikation und Vorbeugung im Störungsprotokoll festhalten.

Modul 12: Interne Release- und Wartungsstrategie

Bei eigener Weiterentwicklung wird aus einem früher extern gepflegten Produkt ein intern verantwortetes Softwareprodukt. Fork, Patchstand und Freigaben benötigen klare Regeln.

1. Schritt 1: Referenzstand und interne Abzweigung eindeutig kennzeichnen.
2. Schritt 2: Änderungen nach Sicherheit, Fehlerkorrektur und Funktion priorisieren.
3. Schritt 3: Build-, Test- und Freigabepipeline für Server, Client und Agent gemeinsam definieren.
4. Schritt 4: Rollback, Dokumentation und langfristige Ablösung in den Wartungsplan aufnehmen.

Praxisübungen

• Eine Pipeline für den asynchronen Teststart entwickeln.
• Referenz-Builds aller Plattformkomponenten erzeugen.
• Eine kleine komponentenübergreifende Anpassung implementieren.
• Kompatibilitäts- und Regressionstest durchführen.
• Interne Release-, Patch- und Rollbackregeln dokumentieren.