DevOps Engineer mit Cloud Native Mindset und Fokus auf Backend- Software

Situation                 
Ein Automobilkonzern benötigte einen disconnected (Air Gap) OpenShift Cluster als Prototyp zur Produktionssteuerung, um sensible Daten innerhalb einer isolierten Umgebung sicher zu verarbeiten. Die Herausforderung bestand darin, die Infrastruktur komplett unabhängig von externen Netzwerken zu gestalten und gleichzeitig die notwendige Flexibilität für produktionsrelevante Anwendungen zu gewährleisten.

Aufgabe                  
Als DevOps Engineer und Plattform-Architekt war die Aufgabe, eine Air-Gap-Infrastruktur auf Basis von OpenShift 4.12 zu implementieren. Dazu gehörten die Vorbereitung der Hardware, die Konfiguration des Netzwerks, die Einrichtung einer Mirror Registry mit Quay sowie die Integration von Funktionen wie Virtualisierung (KubeVirt) und Datenmanagement. Die Umgebung musste vollständig dokumentiert und betriebsbereit für produktionsnahe Tests gestaltet werden.

Maßnahme              Aufbau eines disconnected OpenShift Clusters auf Bare Metal mit Fokus auf Netzwerk- und Installationsautomatisierung, Monitoring und erweiterten Features wie Virtualisierung (KubeVirt). Dokumentation in Git und Confluence sichert Transparenz und Wiederverwendbarkeit.

Hardware- und Infrastrukturvorbereitung:

• Installation und Konfiguration von Bare-Metal-Servern mit Fokus auf Stabilität und Redundanz.
• Einrichtung eines Bastion Hosts zur zentralen Steuerung der Installation und Verwaltung.

Netzwerk- und Cluster-Konfiguration:

• Konfiguration der Netzwerkinfrastruktur mit DHCP, DNS, TFTP und HTTP zur Unterstützung der disconnected Umgebung.
• Installation von OpenShift 4.12 über PXEBoot, unterstützt durch Automatisierung mit Ansible.

Air-Gap-Spezifische Implementierung:

• Einrichtung von Quay als Mirror Registry zur Spiegelung der benötigten Container-Images und Operatoren.

Konfiguration und Nutzung von Operatoren und weiteren Komponenten:

• Integration von OpenShift Data Foundation zur Datenpersistenz und OpenShift Virtualization / KubeVirt zur Verwaltung virtueller Maschinen.
• Testinstallation mehrerer VMs, einschließlich der Nutzung mehrerer Netzwerk-Interfaces mit Multus zur flexiblen Netzwerkanbindung.

Monitoring und Logging:

• Aufbau eines Monitoring- und Logging-Stacks mit Prometheus, Grafana und Loki zur Echtzeitüberwachung und Analyse der Infrastruktur.

Dokumentation:

• Technische Dokumentation: Erstellung detaillierter technischer Installationsdokumentationen in Git, einschließlich halbautomatisierter Installationsskripte.
• Allgemeine Dokumentation: Aufbereitung nicht-technischer Prozessbeschreibungen und Wissensdokumentation in Confluence.
   

Resultat                  
Das Projekt führte zur erfolgreichen Implementierung eines disconnected OpenShift Clusters. Die Integration moderner Tools wie Quay, OpenShift Virtualization / KubeVirt und Multus ermöglichte eine vielseitige und skalierbare Nutzung der Infrastruktur. Die umfassende Dokumentation sicherte Transparenz und erleichterte die Übergabe und Weiterentwicklung des Prototyps


Kenntnisse              
Container, Linux, Air Gap, RBAC, NetworkPolicies

Produkte       
OpenShift (4.12), Podman, Quay, OpenShift Data Foundation, OpenShift Virtualization / KubeVirt, OpenShift Advanced Cluster Management, Prometheus, Grafana, Loki, Multus, Git, Confluence, Bitbucket, ServiceNow

Situation:
Betrieb von Software für gesetzliche Krankenversicherungen mit Fokus auf ePA, DIGA und Plattformoptimierung.

• Betrieb von Software für gesetzliche Krankenversicherungen, Verarbeitung von Sozialdaten, bedient über 7 Millionen GKV Versicherte in Bereichen wie elektronische Patientenakte (ePA), Digitale Gesundheitsanwendungen (DIGA) unter Berücksichtigung von Gematik Vorgaben, DSGVO
• Einsatz im Rancher Plattform & Betriebsteam & Deployment / Pipelines & Application Team (20 Personen)
• Stakeholder: Fachverantwortliche für Geschäftsprozesse / -software, Software-Lieferant
• Teamorganisation: Selbstorganisiertes Vorgehen, mit Input von Fachverantwortlichen, Software-Lieferanten und Qualitätssicherung, sowie eigenverantwortliches Verbessern von Plattform und Toolstack

Aufgabe:
Als DevOps Engineer war die Aufgabe, Kubernetes-Plattformen mit Versionen v1.22, v1.23, v1.24 zu betreiben und weiterzuentwickeln. Zu den Aufgaben gehörten die Implementierung und Automatisierung von CI/CD-Prozessen, die Optimierung der Infrastruktur und die Sicherstellung eines stabilen und sicheren Betriebs von GKV-spezifischen Anwendungen. Zusätzlich war die Integration und der Betrieb verschiedener Technologien wie Rancher, ArgoCD, Prometheus und Apache Kafka erforderlich.

Maßnahme:
Automatisierung von Deployments und Tests mit Fokus auf CI/CD, Aufbau neuer Kubernetes-Cluster sowie Optimierung der Infrastruktur durch Konsolidierung und Software-Management.

Plattformbetrieb und -optimierung:

• Sicherstellung des stabilen Betriebs von Kubernetes-Clustern durch regelmäßige Updates und Optimierungen der Versionen v1.22, v1.23 und v1.24.
• Nutzung von Rancher v2.6 zur Verwaltung und Orchestrierung der Kubernetes-Plattform.
• Einsatz von Prometheus und Grafana für Monitoring und Performance-Überwachung der Plattform.

CI/CD-Automatisierung:

• Aufbau und Erweiterung von GitLab CI-Pipelines zur Unterstützung der kontinuierlichen Integration und Bereitstellung (CI/CD).
• Automatisierung von Deployments mithilfe von Helm und ArgoCD, um Anwendungen sicher und effizient zu liefern.

Anwendungsbetrieb und Infrastrukturmanagement:

• Integration von GKV-spezifischen Anwendungen wie ePA und DIGA unter Berücksichtigung von Datenschutz- und Compliance-Anforderungen.
• Verwaltung von Datenbanken wie PostgreSQL und Infrastruktur-Komponenten wie Nginx und Docker.
• Betrieb und Optimierung von Apache Kafka für Messaging und Datenverarbeitung.

Qualitätssicherung und Monitoring:

• Entwicklung automatisierter Tests mit Postman/Newman für die Qualitätssicherung von API-basierten Anwendungen.
• Implementierung von Monitoring-Tools zur Überwachung und Analyse der Systemperformance.

Resultat:
Die Kubernetes-Plattform wurde stabil und effizient betrieben, sodass GKV-spezifische Anwendungen zuverlässig und sicher bereitgestellt werden konnten. Die Einführung von CI/CD-Prozessen und die Nutzung moderner Technologien wie ArgoCD, Prometheus und GitLab CI führten zu einer erhöhten Automatisierung und Effizienz. Die Integration von Tools wie Postman/Newman sowie die umfassende Infrastruktur- und Anwendungsoptimierung stellten die Einhaltung von Sicherheits- und Compliance-Anforderungen sicher.

Kenntnisse:
Container, Linux, CI/CD

Produkte:
Kubernetes (v1.22, v1.23, v1.24), Rancher (v2.6), Longhorn, Apache Kafka, ArgoCD, Prometheus, Grafana, PostgreSQL, Nginx, Docker, Helm, GitLab, GitLab CI, Postman/Newman, Git

Situation                 
Software-Hersteller für gesetzliche Krankenversicherungen mit Fokus auf containerisierte Microservices. Einsatz in Rollout- und Cloud-Teams zur Qualitätssicherung, Kundensupport und Plattformaufbau. Prozesse basieren auf CI/CD und Kanban.
 

• Software-Hersteller für gesetzliche Krankenversicherung, entwickelt u.a. containerisierte Microservices auf Spring Boot Basis mit REST APIs
• Einsatz im Team technischer Rollout (5 Pers.), Aufgabe: Kunde 0 simulieren und technische QS für auszuliefernde Software übernehmen, sowie Unterstützung bei der Einspielung der Software bei insg. 5 Kunden
• Stakeholder: 5 IT-Dienstleister, die für den Betrieb verantwortlich sind, ca. 10 Product Owner, die für die Entwicklung zuständig sind
• Prozess: Release getriebener Rollout von Software (Continuous Integration/Continuous Delivery), unterschiedliche Release Schedules von unterschiedlichen Teams, regelmäßige Calls mit IT-Dienstleistern und Entwicklungsteams, sowie im Pair-Programming Deployments bei/mit Kunden
• Ebenfalls Einsatz im Team Cloud und Container (10-15 Pers.), Aufgabe: Aufbau und Betrieb von AWS/OpenShift basierten Entwicklungsplattformen für Entwicklungsteams (insg. ca. 10)
• Stakeholder: Entwicklungsteams, Anforderungen hinsichtlich Kapazitäten, Funktionalitäten, und Prozessoptimierung/-automatisierung umgesetzt
• Prozess: Kanban mit zwei-wöchentlichen Planungsmeetings

Aufgabe:
Als DevOps Engineer bestand die Aufgabe darin, den technischen Software-Rollout zu beraten und zu unterstützen, interne Qualitätssicherungsprozesse zu optimieren und moderne Cloud- und Container-Umgebungen aufzubauen. Dies umfasste die Integration und Automatisierung von CI/CD-Prozessen, sowie die Konfiguration von Container-Technologien wie OpenShift und Kubernetes.


Maßnahme:
Verantwortung für Software-Deployment, Wartung von OpenShift, Einführung von Quay, Kundenberatung sowie Automatisierung von Tests zur Steigerung der Effizienz und Qualität in Kubernetes-Umgebungen.


Beratung und Unterstützung beim Software-Rollout:

• Unterstützung der Kunden bei der Installation und Konfiguration ausgelieferter Microservices auf OpenShift und Rancher-Umgebungen.
• Durchführung von Pair-Programming-Sitzungen zur schnellen Fehlerbehebung und Optimierung der Deployments.
• Beratung bei der Integration von REST APIs und bei der Anpassung von Helm-Charts für Kubernetes.

Interne Qualitätssicherung:

• Automatisierung von Tests mit Postman und Newman, einschließlich der Entwicklung eines Tools mit Node.js zur automatischen Ausführung von API-Tests.
• Verbesserung der CI/CD-Pipelines mit Jenkins, ArgoCD und Git, um die Effizienz und Zuverlässigkeit der Deployments zu steigern.

Cloud- und Container-Umgebungen:

• Einrichtung und Betrieb von Container-Plattformen mit Docker und OpenShift.
• Integration von AWS EC2, AWS RDS und PostgreSQL für die Datenverwaltung.
• Einrichtung von RedHat Quay als Container-Registry und Migration bestehender Repositories.

Resultat:
Durch die Kombination von fundierter Beratung, optimierten CI/CD-Prozessen und einer stabilen Container-Infrastruktur wurde der Software-Rollout erfolgreich unterstützt. Die Einführung moderner Tools wie RedHat Quay erhöhte die Effizienz und Zuverlässigkeit der Plattform. Die Qualitätssicherungsprozesse wurden durch automatisierte Tests und die Integration von Jenkins erheblich verbessert.

Kenntnisse:
Container, Linux, Pair-Programming, CI/CD

Produkte:
OpenShift, Rancher, Kubernetes, Apache Kafka, Prometheus, Grafana, ArgoCD, Red Hat Quay, Ansible, AWS EC2, AWS RDS, PostgreSQL, Prometheus, Nginx, Docker, Helm, Jenkins, Postman, Newman, Node.js, Git, REST APIs

Situation:
IT-Umfeld eines Universitätsklinikums mit Fokus auf zentralisierte und sichere Log-Verarbeitung. Die Infrastruktur basiert auf Linux-Systemen und unterstützt die Verarbeitung großer Datenmengen aus kritischen Anwendungen. Anforderungen umfassen hohe Sicherheitsstandards und effiziente Automatisierungslösungen.

Aufgabe:
Als DevOps Engineer war die Aufgabe, eine skalierbare und sichere Logging-Lösung zu implementieren. Die Logquellen sollten dynamisch konfigurierbar sein, und die Logs mussten verschlüsselt an zentrale Logserver übertragen werden. Dies erforderte die Einrichtung von FluentBit als zentrales Log-Verarbeitungstool sowie die Sicherstellung einer zuverlässigen Integration mit Syslog.

Maßnahme:
Automatisierung und Implementierung einer zentralisierten Log-Verarbeitungsinfrastruktur unter Einhaltung hoher Sicherheitsstandards und Effizienz durch moderne Tools und Technologien.

Einrichtung und Konfiguration von Log-Verarbeitungstools:

• Ansible Playbooks: Erstellung und Einsatz von Ansible Playbooks zur Automatisierung der Installation und Konfiguration.
• Installation von FluentBit: Implementierung von FluentBit auf Ubuntu-Servern für die Log-Verarbeitung.
• Dynamische Konfiguration: Entwicklung dynamisch anpassbarer Konfigurationen je Server zur flexiblen Nutzung.
   

Log-Datenmanagement:

• Eingabeverarbeitung: Integration von Logquellen wie Syslog, Logdateien und SystemD für umfassendes Log-Monitoring.
• Sichere Logübertragung: Einrichtung von TLS-gesicherten Verbindungen zu zentralen Logservern.
   

Betriebssystem und Technologien:

• Linux-Know-how: Nutzung und Optimierung von Linux-Systemen für den zuverlässigen Betrieb.
• Toolset: Einsatz spezialisierter Tools wie FluentBit und Syslog für effiziente Datenverarbeitung.
   

Resultat:
Die Logging-Lösung ermöglichte eine sichere und zuverlässige Übertragung von Logs aus verschiedenen Linux-Systemen an zentrale Logserver. Die flexible Konfiguration von FluentBit und Syslog erlaubte eine schnelle Anpassung an sich ändernde Anforderungen. Die verschlüsselte Übertragung erfüllte alle Sicherheits- und Compliance-Vorgaben und trug zur zentralen Überwachung und Analyse der Systeme bei.


Kenntnisse:
Linux

Produkte:
FluentBit, Syslog

Situation:
Ein Universitätsklinikum benötigte Unterstützung bei der Implementierung effizienter Software-Deployment-Prozesse und einer strukturierten Versionierung. Die Umgebung umfasste containerisierte Anwendungen und eine CI/CD-Infrastruktur, die optimiert werden sollte, um kontinuierliche Bereitstellung und Nachverfolgbarkeit zu gewährleisten.

Aufgabe:
Als DevOps Engineer bestand die Aufgabe darin, die Software-Deployments des Universitätsklinikums zu optimieren und ein Versionierungssystem einzuführen. Dies beinhaltete die Einrichtung automatisierter CI/CD-Pipelines, die Integration von Versionierungstools wie Gitea, sowie die Containerisierung von Anwendungen zur Sicherstellung einer konsistenten Bereitstellungsumgebung.

Maßnahme:
Implementierung von Versionsmanagement und CI/CD-Prozessen durch Einrichtung von Gitea und Jenkins sowie Entwicklung automatisierter Pipelines für effiziente Softwarebereitstellung.

Beratung und Analyse:

• Analyse der bestehenden Deployment-Prozesse des Universitätsklinikums und Erarbeitung eines optimierten Konzepts auf Basis von Container-Technologien wie Docker.
• Beratung zur Einführung eines Versionierungssystems mit Gitea, um die Verwaltung und Nachverfolgbarkeit von Änderungen zu verbessern.
   

Implementierung von CI/CD:

• Aufbau und Konfiguration von Jenkins-Pipelines zur Automatisierung von Build-, Test- und Deployment-Prozessen.
• Integration von Git und Gitea in die CI/CD-Pipelines, um Versionierung und Nachvollziehbarkeit sicherzustellen.

Containerisierung und Infrastrukturmanagement:

• Erstellung von Docker-Containern zur Standardisierung der Anwendungsumgebung für das Klinikum.
• Konfiguration von Nginx als Reverse Proxy zur sicheren und effizienten Kommunikation zwischen Diensten.
   

Schulung und Dokumentation:

• Schulung der IT-Abteilungen des Universitätsklinikums in der Nutzung von Versionierungstools und CI/CD-Prozessen.
• Erstellung technischer Dokumentationen für implementierte Pipelines und Container-Setups zur nachhaltigen Nutzung der Lösungen.
   

Resultat:
Das Universitätsklinikum profitierte von optimierten Deployment-Prozessen und einer strukturierten Versionierungslösung. Die Einführung von CI/CD mit Jenkins, die Containerisierung mit Docker und die Versionierung mit Gitea ermöglichten eine konsistente und skalierbare Software-Bereitstellung. Durch Schulungen und umfassende Dokumentationen wurde eine nachhaltige und eigenständige Nutzung der neuen Infrastruktur gewährleistet.

Kenntnisse:
Container, Linux, CI/CD

Produkte:
Docker, Gitea, Jenkins, Nginx, Git

Situation:
Ein großer Energieversorger benötigte die Entwicklung eines nutzerfreundlichen Projektmanagementsystems. Das Ziel war die Implementierung eines modernen Frontends auf Basis von Vue.js, das effizient mit einem Laravel-Backend über REST APIs kommunizieren sollte. Gleichzeitig sollten neue Funktionen agil auf Basis von Nutzerfeedback weiterentwickelt werden.

Aufgabe:
Als Developer bestand die Aufgabe darin, ein modernes und benutzerfreundliches Frontend mit Vue.js zu entwickeln, das über eine REST API an ein Laravel-Backend angebunden ist. Zusätzlich sollten neue Funktionen agil weiterentwickelt, Refinements durchgeführt und User-Stories erstellt werden.

Maßnahme:
Entwicklung eines nutzerzentrierten Frontends mit Vue.js und Integration in ein Laravel-Backend mittels agiler Methoden.

Frontend-Entwicklung:

• Entwicklung und Optimierung eines modernen Frontends auf Basis von Vue.js.
• Anwendung von TypeScript, HTML und CSS, um eine ansprechende und nutzerfreundliche Oberfläche zu gewährleisten.
   

Backend-Integration:

• Anbindung des Frontends an das Backend mittels REST APIs.
• Nutzung von Laravel zur effizienten und sicheren Datenverarbeitung.
   

Nutzerzentrierte Weiterentwicklung:

• Umsetzung neuer Funktionen basierend auf Nutzerfeedback.
• Iterative Verbesserungen zur Optimierung der Benutzererfahrung unter Anwendung von SCRUM-Methoden.
   

Agile Prozesse und Teamarbeit:

• Teilnahme an Refinements zur Priorisierung und Planung von User-Stories.
• Entwicklung und Dokumentation von User-Stories unter Berücksichtigung agiler Prinzipien.
   

Resultat:
Das Projektmanagementsystem wurde erfolgreich entwickelt und durch die Integration von Nutzerfeedback kontinuierlich optimiert. Die moderne Frontend-Entwicklung mit Vue.js und die reibungslose Anbindung an das Laravel-Backend sorgten für eine effiziente und benutzerfreundliche Anwendung. Durch die Umsetzung agiler Methoden wurde eine iterative und zielgerichtete Weiterentwicklung ermöglicht.

Kenntnisse:
TypeScript, HTML, CSS, REST API, SCRUM

Produkte:
Vue.js, Laravel