Seminar Kroki – Intensivseminar: Plattformbetrieb, Integration und Automatisierung

Kroki als belastbaren internen Dienst planen und betreiben

Das Intensivseminar bündelt die Inhalte der API-, Automatisierungs-, Self-Hosting-, Sicherheits-, Kubernetes-, Performance- und Projektwerkstatt-Seminare. Der Schwerpunkt liegt auf dem kontrollierten Eigenbetrieb und der Integration in Entwicklungs- sowie Dokumentationsplattformen.

Fünf Tage sind erforderlich, um nicht nur eine Installation aufzubauen, sondern Anforderungen, Schutzbedarf, Automatisierung, Clusterbetrieb, Messbarkeit, Updateverfahren und Betriebsübergabe zusammenzuführen. Das Abschlussprojekt führt vom technischen Entwurf bis zu einem geprüften Betriebsstand.

Inhaltsübersicht

• Anforderungen, Servicegrenzen und Zielarchitektur
• Kroki-API, Clients, CLI und Automatisierung
• Docker- und Podman-Betrieb mit Companion-Diensten
• Konfiguration, Reverse Proxy und Sicherheitskontrollen
• Kubernetes, Ingress, Ressourcen und Skalierung
• Observability, Performance und Fehleranalyse
• CI/CD- und Dokumentationsintegration
• Update, Rollback, Betriebshandbuch und Abschlussprojekt

Zielgruppe

Das Seminar richtet sich an DevOps-Fachkräfte, Plattformarchitekten, Linux- und Kubernetes-Administratoren, technische Betriebsverantwortliche sowie Entwickler mit Infrastrukturverantwortung. Teams mit Schwerpunkt auf Diagrammnotationen nutzen stattdessen oder ergänzend das Intensivseminar zu Diagrammsprachen.

Voraussetzungen

Erforderlich sind solide Grundkenntnisse in Linux, Netzwerken, Containern, HTTP und Versionsverwaltung. Für die Kubernetes-Übungen werden grundlegende Kenntnisse zu Deployments, Services und Ingress vorausgesetzt. Skripting-Erfahrung ist hilfreich.

Lernstrecke Schritt für Schritt

1. Schritt 1: Serviceauftrag und Schutzbedarf definieren. Nutzergruppen, Diagrammtypen, Datenklassen, Last, Verfügbarkeit und Integrationen werden erfasst. Daraus entstehen Servicegrenzen und überprüfbare Betriebsanforderungen.
2. Schritt 2: Kroki-Architektur auf die Zielumgebung abbilden. Gateway, integrierte Renderer, Companion-Dienste, Clients, Reverse Proxy und Dokumentationssysteme werden als getrennte Komponenten modelliert.
3. Schritt 3: API-Aufrufe standardisieren. GET, POST, JSON, Klartext, Header, Formate und Optionen werden in ein verbindliches Clientmuster überführt. Fehler und Zeitüberschreitungen erhalten einheitliche Behandlung.
4. Schritt 4: CLI und Skripte für Betriebsprüfungen nutzen. Konvertierung, Kodierung und Funktionschecks werden automatisiert. Ein kleiner Prüfkatalog kontrolliert Gateway und ausgewählte Diagrammtypen.
5. Schritt 5: Eine Containerplattform aufbauen. Gateway und benötigte Companion-Dienste werden mit festen Imageversionen, internen Netzen, Ressourcen und Neustartregeln betrieben.
6. Schritt 6: Konfiguration und Geheimnisse trennen. Umgebungsvariablen, Konfigurationsdateien und geheime Werte werden mit klarer Zuständigkeit verwaltet. Änderungen bleiben versioniert und prüfbar.
7. Schritt 7: Sicherheitsgrenzen durchsetzen. Sichere Betriebsmodi, Dateisystem- und Netzwerkzugriffe, Reverse-Proxy-Authentisierung, Größenlimits, Rate Limits und Containerhärtung werden praktisch umgesetzt.
8. Schritt 8: Kubernetes-Ressourcen erstellen. Deployments, Services, ConfigMaps, Secrets und Ingress werden für Gateway und Companion-Dienste aufgebaut. Namensräume und Labels erleichtern Betrieb und Diagnose.
9. Schritt 9: Verfügbarkeit und Skalierung gestalten. Replikate, Ressourcenanforderungen, Probes, Rolloutstrategie und Lastverteilung werden festgelegt. Unterschiedliche Renderer werden getrennt dimensioniert.
10. Schritt 10: Observability einrichten. Logs, technische Kennzahlen, verteilte Spuren und synthetische Renderprüfungen werden kombiniert. Ein Dashboard trennt Erreichbarkeit, Fehlerquote und Rendering-Latenz.
11. Schritt 11: Performance systematisch untersuchen. Lastprofile, Diagrammgröße, Ausgabeformat, Parallelität und Companion-Verhalten werden gemessen. Limits und Kapazität basieren auf Tests statt Schätzungen.
12. Schritt 12: Fehlerdiagnose und Störungsabläufe erstellen. Proxy-, Gateway-, Companion-, Syntax- und Ressourcenfehler werden über einen festen Ablauf unterschieden. Wiederanlauf und Eskalation werden geübt.
13. Schritt 13: CI/CD und Dokumentation anbinden. Pipelines rendern geänderte Quellen, prüfen Ergebnisse und verwenden den internen Dienst. Endpunktwechsel bleiben konfigurierbar und Quelltexte unabhängig.
14. Schritt 14: Update und Rollback absichern. Neue Images und Konfigurationen durchlaufen Test, Kompatibilitätsprüfung und kontrollierten Rollout. Ein Rückweg wird vor der Änderung verifiziert.
15. Schritt 15: Produktionsnahe Betriebsübergabe durchführen. Das Abschlussprojekt liefert Zielarchitektur, Konfiguration, Sicherheitskonzept, Monitoring, Tests, Updateverfahren und Betriebshandbuch mit nachvollziehbarer Abnahme.

Praxisaufgaben

• Eine Zielarchitektur mit Gateway, Companion-Diensten, Proxy, Clients und Clustergrenzen entwerfen.
• Eine Containerbereitstellung mit Sicherheits- und Ressourcenregeln aufbauen.
• Kubernetes-Ressourcen einschließlich Ingress, Probes und Rolloutstrategie erstellen.
• Synthetische Renderprüfungen und eine strukturierte Fehlerdiagnose einrichten.
• Ein Update mit Kompatibilitätstest, kontrolliertem Rollout und Rückfall durchführen.

Kompetenzziele

• Kroki als internen Plattformdienst fachlich und technisch planen.
• API, CLI, Container und Kubernetes zu einem reproduzierbaren Betrieb verbinden.
• Schutzgrenzen, Ressourcen und Zugriffskontrollen nachvollziehbar konfigurieren.
• Observability, Performanceprüfung und Störungsdiagnose etablieren.
• CI/CD-Integration, Updates, Rollback und Betriebsübergabe kontrolliert durchführen.