Seminar Teedy – Intensivseminar: Integration und Automatisierung

Automatisierte Dokumentenprozesse benötigen sichere Schnittstellen, kontrollierte Eingangskanäle und einen wartbaren Entwicklungs- und Betriebszyklus. Das Intensivseminar verbindet API, Webhooks, Importautomation, Entwicklung, Build, Tests und Bereitstellung in einem zusammenhängenden Integrationsprojekt.

Inhaltsverzeichnis

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

Seminarprofil

Aus einer fachlichen Anforderung entstehen Datenvertrag, authentifizierte API-Anbindung, ereignisgesteuerte Verarbeitung, automatisierter Import, eine kleine Quellcodeanpassung und ein reproduzierbares Deployment. Das Format bündelt die Integrations- und Entwicklungsthemen des gesamten Seminarprogramms.

Zielgruppe

Softwareentwicklung, Systemintegration, DevOps, Automatisierungsteams, technische Architektur und Anwendungsbetreuung.

Voraussetzungen

Gute Kenntnisse in HTTP, JSON, REST, Versionsverwaltung und mindestens einer Programmiersprache. Grundkenntnisse in Docker, Datenbanken und Softwaretests. Für Quellcodeanpassungen sind Java- und Webentwicklungskenntnisse erforderlich.

Lernziele

• Integrationsanforderungen in Datenvertrag, Ereignisse, Verantwortlichkeiten und Fehlerwege überführen.
• Teedy-API und Webhooks sicher, wiederholbar und testbar einsetzen.
• Importkanäle und Massenverarbeitung mit Dubletten- und Fehlerkontrolle automatisieren.
• Quellcodeänderungen mit Build, Tests, Datenmigration und Upgradefähigkeit umsetzen.
• Integration und angepasste Anwendung betreibbar paketieren, überwachen und dokumentieren.

Seminarinhalte

1. Integrationsauftrag und Datenvertrag definieren

Quell- und Zielsystem, Dokumentdaten, Ereignisse, Zuständigkeiten und Fehlerwege werden vor der Implementierung eindeutig beschrieben.

1. Schritt 1: Auslösendes Ereignis, erwartetes Ergebnis und fachliche Verantwortung festlegen.
2. Schritt 2: Dokumentinhalt, Metadaten, Tags, Identifikatoren und Statuswerte als Datenvertrag definieren.
3. Schritt 3: Synchronen und asynchronen Anteil der Verarbeitung unterscheiden.
4. Schritt 4: Fehlerklassen, Wiederholungen, Abbruchkriterien und manuelle Nachbearbeitung planen.

2. API-Zugang und Authentifizierung absichern

Technische Konten erhalten minimale Rechte; Zugangsdaten werden von Quellcode, Protokollen und Nutzdaten getrennt.

1. Schritt 1: Technisches Konto mit den tatsächlich benötigten Berechtigungen bereitstellen.
2. Schritt 2: Anmeldung, Sitzungsbehandlung und einfachen Lesezugriff reproduzierbar testen.
3. Schritt 3: Geheimnisse über geschützte Konfiguration oder Geheimnisverwaltung einbinden.
4. Schritt 4: Ungültige, abgelaufene und unzureichend berechtigte Zugriffe als Negativtests ausführen.

3. Dokumente, Metadaten und Suche per API verarbeiten

Kernoperationen werden als wiederholbare, idempotente und protokollierte Verarbeitungskette aufgebaut.

1. Schritt 1: Dokument mit kontrolliertem Namen und eindeutiger Quellkennung übertragen.
2. Schritt 2: Metadaten, Tags und notwendige Zuordnungen nach Datenvertrag setzen.
3. Schritt 3: Erzeugte Teedy-Identifikatoren speichern und doppelte Verarbeitung verhindern.
4. Schritt 4: Suche, Paginierung, Abruf und Ergebnisprüfung mit unterschiedlichen Berechtigungen umsetzen.

4. Webhooks entkoppelt und wiederholbar verarbeiten

Ereignisse werden schnell angenommen, validiert und über eine kontrollierte nachgelagerte Verarbeitung bearbeitet.

1. Schritt 1: Benötigte Ereignistypen auswählen und unnötige Benachrichtigungen vermeiden.
2. Schritt 2: Empfangsendpunkt mit Zeitstempel, Korrelationskennung und Nutzdatenprüfung aufbauen.
3. Schritt 3: Annahme und Verarbeitung über Warteschlange oder Jobsteuerung entkoppeln.
4. Schritt 4: Wiederholung, Totfehlerablage und manuelle Nachbearbeitung gezielt testen.

5. 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.

6. Importauftrag und Eingangskanäle festlegen

E-Mail, überwachte Verzeichnisse und Massenbestände erhalten einen eindeutigen Zweck, Verantwortliche und Qualitätsanforderungen.

1. Schritt 1: Dokumentarten, erwartete Dateiformate und zulässige Eingangskanäle bestimmen.
2. Schritt 2: Verantwortung für Annahme, Prüfung, Korrektur, Freigabe und Fehlerklärung zuordnen.
3. Schritt 3: Pflichtmetadaten, Standardtags, Quellkennungen und Ablageregeln festlegen.
4. Schritt 4: Abweisungs-, Quarantäne- und Abbruchfälle vor dem ersten Import definieren.

7. E-Mail-Import und automatischen Posteingang vorbereiten

Nachrichten, Anhänge und übergebene Dateien werden in einer kontrollierten Aufnahmezone verarbeitet.

1. Schritt 1: Postfach, Absenderregeln und Behandlung von Nachrichtentext sowie Anhängen festlegen.
2. Schritt 2: Eingangs-, Verarbeitungs-, Fehler- und Archivbereich voneinander trennen.
3. Schritt 3: Nur vollständig übertragene Dateien übernehmen und Importintervall passend dimensionieren.
4. Schritt 4: Erfolgreiche und fehlgeschlagene Vorgänge anhand von Protokoll und Zielbestand abgleichen.

8. Massenbestand bereinigen und pilotieren

Große Bestände werden vor der Übernahme inventarisiert, normalisiert und mit einer repräsentativen Stichprobe erprobt.

1. Schritt 1: Dateiliste, Formate, Größen, Zeichensätze, beschädigte Dateien und Dubletten erfassen.
2. Schritt 2: Dateinamen normalisieren und eindeutige Quellkennungen ergänzen.
3. Schritt 3: Metadaten- und Tagzuordnung in einer kontrollierten Importtabelle vorbereiten.
4. Schritt 4: Pilotbestand mit typischen, großen, fehlerhaften und mehrdeutigen Dokumenten auswählen.

9. Dubletten, Fehler und Importabnahme bearbeiten

Fehlerfälle werden getrennt vom regulären Lauf nachbearbeitet und der Import über Menge, Inhalt, Suchbarkeit und Rechte abgenommen.

1. Schritt 1: Dubletten anhand Quellkennung, Dateihash, Name und Metadaten bewerten.
2. Schritt 2: Beschädigte oder nicht unterstützte Dateien in eine Quarantäne überführen.
3. Schritt 3: Soll- und Ist-Anzahl sowie Metadatenvollständigkeit je Dokumentklasse vergleichen.
4. Schritt 4: Stichproben für Inhalt, Vorschau, OCR, Tags, Suche und Berechtigungen dokumentieren.

10. Betriebsziele, Kennzahlen und Alarmgrenzen festlegen

Monitoring beginnt mit beobachtbaren Benutzeraktionen und wenigen aussagekräftigen technischen Signalen.

1. Schritt 1: Kernaktionen wie Anmeldung, Upload, OCR, Suche und Abruf benennen.
2. Schritt 2: Akzeptable Antwortzeiten, Fehlerraten und Verfügbarkeitsziele festlegen.
3. Schritt 3: CPU, Arbeitsspeicher, Datenträger, Datenbank, Warteschlangen und Anwendungsfehler als Kennzahlen auswählen.
4. Schritt 4: Warn- und Kritischgrenzen mit Zuständigkeit, Reaktionszeit und Eskalation verbinden.

11. Protokolle zusammenführen und Basismessung erstellen

Zeitlich korrelierbare Protokolle und Referenzwerte bilden die Grundlage jeder belastbaren Fehleranalyse.

1. Schritt 1: Anwendungs-, Container-, Proxy-, Betriebssystem- und Datenbankprotokolle lokalisieren.
2. Schritt 2: Zeitzone, Zeitsynchronisation, Aufbewahrung und Zugriffsschutz kontrollieren.
3. Schritt 3: Messung bei geringer, typischer und erhöhter Last mit festen Testdokumenten durchführen.
4. Schritt 4: Referenzwerte mit Version, Konfiguration und Testbestand dokumentieren.

12. Störungen mit Hypothese und Gegenprobe eingrenzen

Die Diagnose folgt einem reproduzierbaren Minimalfall, einer überprüfbaren Vermutung und einer kontrollierten Gegenprobe.

1. Schritt 1: Symptom mit Zeitpunkt, Benutzer, Dokument, Aktion und Auswirkung strukturiert erfassen.
2. Schritt 2: Problem in einen möglichst kleinen, wiederholbaren Testfall überführen.
3. Schritt 3: Eine wahrscheinliche Ursache formulieren und nur die passende Variable verändern.
4. Schritt 4: Gegenprobe durchführen, bevor eine Korrektur als ursächlich bestätigt wird.

13. 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.

14. 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.

15. 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.

16. 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.

17. 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.

18. 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.

19. 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.

Praxisübungen

1. Implementierung eines authentifizierten Dokumentimports mit Metadaten, Tags und Idempotenz.
2. Webhook-Dienst mit Warteschlange, Wiederholungen, Totfehlerablage und Korrelationsprotokoll.
3. Automatisierte Verarbeitung eines gemischten Massenbestands mit Quarantäne und Abnahme.
4. Kleine Quellcodeerweiterung mit Build, Tests und Containerisierung.
5. End-to-End-Release einschließlich Monitoring, Störung, Rollback und Betriebsübergabe.

Methodik

Ein einziges Integrationsprojekt zieht sich durch alle fünf Tage. Datenvertrag, API-Client, Webhook-Dienst, Importautomation, Quellcodeänderung, Tests und Deployment werden schrittweise ergänzt und am Ende gemeinsam abgenommen.