Was ist der DevOps-Lebenszyklus?

Der DevOps-Prozess beschreibt, wie Software von der Ideenfindung über die Produktion und das Feedback bis hin zur Ideenfindung gelangt, wobei Entwicklungs- und Betriebsteams als eine einzige, kollaborative Einheit arbeiten. Er umfasst einen durchgängigen Ablauf von Vorgehensweisen und einen Automatisierungs-Workflow, den DevOps-Teams zur Planung, Entwicklung, Ausführung und Optimierung von Software-Releases nutzen können.

Die Phasen des DevOps-Lebenszyklus werden oft als Teil einer „Endlosschleife“ dargestellt, wobei sich die Entwicklungsaktivitäten auf der linken und die Betriebsaktivitäten auf der rechten Seite befinden, die in einem kontinuierlichen Pfad miteinander verbunden sind.

Auf der Seite „Planen → Programmieren → Erstellen → Testen“ optimieren Teams Softwareanforderungen in kleine User Storys, übertragen Code schrittweise (aber häufig) in Code-Repositorys und verwenden CI-Tools (Continuous IntegrationI), um jede Codeänderung automatisch zu erstellen und zu testen.

Auf der Seite „Release→ Bereitstellung → Betrieb → Überwachung“ sorgen automatisierte Workflows dafür, dass Änderungen durch die IT-Umgebungen geleitet und an die Benutzer weitergeleitet werden. Unterdessen verfolgen Observability-Tools den Systemzustand, die Softwareleistung und das Benutzerverhalten, um Probleme zu erkennen und die Gesamtauswirkungen zu messen.

Die Endlosschleife verdeutlicht, dass jede Phase des DevOps-Lebenszyklus die anderen beeinflusst. Teams teilen sich Arbeit, Wissen und Aufgaben, anstatt diese zwischen Silos hin und her zu schieben. Die Schleife veranschaulicht zudem, wie DevOps-Workflows die Softwarebereitstellung und Optimierungsprozesse verbessern können. Im Idealfall wird jeder Zyklus schneller, sicherer und automatisierter sein als der letzte.

Somit ermöglicht der DevOps Lebenszyklus Unternehmen, Menschen, Prozesse und Tools aufeinander abzustimmen, um qualitativ hochwertige Softwareanwendungen und nahtlose User Experiences zu liefern.

Jede Phase des DevOps-Lebenszyklus beeinflusst und überschneidet sich mit den anderen Phasen, aber jede hat einen klaren Zweck und eine Reihe damit verbundener Aktivitäten. Die Phasen umfassen:

In der Planungsphase übersetzen DevOps Teams Geschäftsanforderungen und Benutzerfeedback in klare, priorisierte und zeitlich begrenzte Arbeitspläne sowie in einen Projektmanagement-Workflow, der die Entwicklungs- und Betriebsaktivitäten in den nachfolgenden Phasen steuert. In dieser Phase werden die Vision, der Umfang und die Roadmap für eine Softwareversion oder einen Systemaufbau geklärt, sodass jeder versteht, was er entwickelt, warum es wichtig ist und wie er den Erfolg messen wird.

Typische Planungsaktivitäten könnten Folgendes umfassen:

• Verbesserung und Priorisierung von Produkt-Backlogs (z. B. neue Funktionen, Fixes und technische Schulden).

• Analyse der Eingaben von Stakeholdern, um die Anforderungen und Einschränkungen der Benutzer zu erfassen.

• Die Arbeit wird in Aufgaben, User Storys (Softwarefunktionsbeschreibungen aus der Perspektive des Benutzers) und Epics (User Storys, die zu umfangreich sind, um in einer einzigen Softwareiteration bearbeitet zu werden) unterteilt, um den Ressourcenbedarf abzuschätzen und Abhängigkeiten zu identifizieren.

• Die Definition von Leistungskennzahlen (KPI), Service-Level-Indikatoren (SLI) und Service-Level-Zielen, damit in späteren Phasen klar ist, wie ein „gutes“ Ergebnis aussieht.

Während der Codierungsphase setzen die Entwickler die geplanten Infrastruktur- und Softwareanforderungen in funktionierenden Quellcode um, wobei sie die Qualitätssicherung und den zukünftigen Betrieb im Blick haben. Es geht nicht nur darum, neuen Code zu schreiben. Es geht auch darum, alle notwendigen Komponenten für automatisierte Build-, Test-, Integrations- und Bereitstellungsprozesse im weiteren Verlauf der Pipeline einzurichten.

Der Codierungsprozess umfasst:

• Code schreiben, um neue Funktionen zu implementieren, Fixes durchzuführen und nicht funktionale Anforderungen zu erfüllen (zum Beispiel Sicherheit).

• Kleine, schrittweise Codeänderungen für Reviews in gemeinsam genutzte Repositorys innerhalb von Versionskontrollsystemen (wie Git und GitHub) übertragen.

• Testen von Code-Commits, damit diese nahtlos erstellt und in die Codebasis integriert werden können.

• Hinzufügen oder Aktualisieren von automatisierten Unit- und Komponententests, damit zukünftige CI-Läufe das Codeverhalten nach jedem Commit automatisch validieren können.

In der Build-Phase werden Quellcodeänderungen automatisch kompiliert, validiert und in bereitstellbare Build-Artefakte verpackt. DevOps Tools rufen Codeänderungen aus dem Versionskontrollsystem ab, führen automatisierte Prüfungen durch und erzeugen versionierte Pakete (wie Docker-Container-Images und kompilierte Binärdateien), die zur Bereitstellung oder für weitere Tests bereit sind.

Genauer gesagt:

• Automatisierte Skripte und Build-Tools kompilieren den Quellcode, lösen Abhängigkeiten (einschließlich Bibliotheken, Frameworks und Module) auf und laden sie herunter und verknüpfen alles zu einer ausführbaren Datei oder einem Image.

• Grundlegende automatisierte Tests werden im Rahmen des Build-Prozesses ausgeführt. Schlägt der Build fehl, wird er als fehlerhaft markiert und verbleibt in der Build-Phase. Ist der Build-Prozess erfolgreich, geht er in die nächste Phase des Lebenszyklus über.

Die Testphase – auch Validierung genannt – soll sicherstellen, dass sich eine Codeänderung unter realen Bedingungen wie erwartet verhält. DevOps Teams verwenden eine Reihe fortschrittlicher Test-Tools, um kontinuierlich zu überprüfen, ob jede Änderung funktional, sicher und leistungsfähig ist, bevor sie weiter in die Pipeline übertragen wird oder die Produktion erreicht.

In der Regel sind Testprozesse eng in die CI/CD-Pipeline (Continuous Integration/Continuous Delivery) integriert, sodass Entwickler schnell und häufig Feedback zur Codequalität erhalten.

Das Hauptziel von Softwaretests ist es, Fehler so früh wie möglich zu erkennen (wenn sie kostengünstiger und einfacher zu beheben sind) und zu verhindern, dass fehlerhafte Versionen in die Veröffentlichung gelangen. Die Tests überprüfen außerdem, ob neue Änderungen bestehende Funktionen nicht beeinträchtigen, was Entwicklern hilft, die Gesamtstabilität des Systems während der Weiterentwicklung der Softwareprodukte aufrechtzuerhalten.

Die Release-Phase bietet ein kontrolliertes Gateway zwischen „getestetem Build“ und „Live-Bereitstellung“, wobei Codeänderungen für die Produktion genehmigt und für die Zielbenutzer sichtbar gemacht werden. Die Entwicklungsteams bereiten bewährten, getesteten Code für die Bereitstellung vor, indem sie ihn verpacken, seine Produktionsreife bestätigen und koordinieren, wie und wann er in die Staging- und Produktionsumgebungen übertragen wird.

Zu den üblichen Release-Prozessen gehören:

• Durchführung der endgültigen Qualitäts-, Sicherheits- und Compliance-Prüfungen anhand vordefinierter Akzeptanzkriterien.

• Build-Artefakte an bestimmte Release-Versionen anhängen und Änderungsprotokolle und Dokumentation erstellen.

• Identifizierung von Schwachstellen in der kommenden Version und Planung von Abhilfemaßnahmen (z. B. Rollbacks), um Probleme zu beheben.

Während der Bereitstellungsphase wird der getestete und gepackte Code automatisch an die Zielumgebungen (Staging oder Produktion) übermittelt. Tools für Konfigurationsmanagement und Infrastructure as Code (IaC) – die Konfigurationsdateien und hochrangige beschreibende Programmiersprachen verwenden, um die Infrastrukturbereitstellung und -orchestrierung für Software-Releases zu automatisieren – helfen DevOps Teams dabei, sicherzustellen, dass Software auf zuverlässige und wiederholbare Weise übermittelt wird.

Die Bereitstellung erfolgt in der Regel über CD-Plattformen (Continuous Delivery) und Containerisierungsplattformen (z. B. Kubernetes), die Software-Bereitstellungsprozesse orchestrieren (Abrufen von Build-Artefakten, Aktualisieren von Containern und Binärdateien, Ausführen abschließender Tests und Umleiten des Datenverkehrs auf die neue Version).

DevOps-Teams verwenden häufig verschiedene Bereitstellungsstrategien, um sicherzustellen, dass neue Versionen schrittweise eingeführt und bei Bedarf schnell wieder rückgängig gemacht werden können.

Bei der Blue-Green-Bereitstellung werden Apps beispielsweise in zwei parallelen Produktionsumgebungen bereitgestellt, wobei in jeder Umgebung eine andere Version der Anwendung ausgeführt wird. In der „blauen“ Umgebung wird die Live-Anwendung ausgeführt, während in der „grünen“ Umgebung Tests und Validierungen für neue App-Versionen durchgeführt werden. Wenn die neue Iteration abgeschlossen ist, wird die grüne Umgebung zur Live-Umgebung, und die blaue bleibt inaktiv, aber verfügbar, um Rollbacks zu verarbeiten.

Bei Canary-Bereitstellungen stellen Teams Anwendungen zunächst einer kleinen Gruppe von Benutzern – den sogenannten „Canaries“ – zur Überwachung und zum Testen in einer Live-Umgebung bereit, bevor sie die App für die gesamte Benutzerbasis freigeben.

Ähnlich wie Kanarienvögel (Canaries)verwendet wurden, um Bergleute vor giftigen Gasen zu warnen, machen Canary-Bereitstellungen Entwicklungsteams auf App-Fehler aufmerksam, ohne dass dabei das Risiko großflächiger Leistungsprobleme entsteht, von denen alle Benutzer betroffen wären. Wenn die Anwendung in der Canary-Gruppe gut funktioniert, führen die Entwickler sie schrittweise für größere Gruppen ein, bis sie allen Benutzern zur Verfügung steht.

Die Betriebsphase konzentriert sich darauf, die laufenden Systeme stabil, leistungsstark, sicher und für reale Benutzer unter realen Workloads verfügbar zu halten. Es ist nicht das „Ende“ des Anwendungslebenszyklus. Vielmehr werden Daten und Erkenntnisse in frühere Phasen zurückgeführt.

In dieser Phase erfüllen DevOps-Teams die folgenden Aufgaben:

• Ausführung und Überwachung von Anwendungen in der Produktionsumgebung, einschließlich der zugehörigen Infrastruktur, Dienste und Abhängigkeiten.

• Verwaltung von Kapazitätsplanungs- und Skalierungsprozessen, damit die Datenübertragungsleistung im Laufe der Zeit nicht abnimmt.

• Erkennung und Priorisierung von Problemen, Behebung von Leistungsengpässen sowie gegebenenfalls Durchführung von Fixes oder Rollbacks.

• Anwendung von Sicherheitspatches und Durchsetzung von Governance-Maßnahmen (wie Zugriffskontrollen und Compliance-Prüfungen) zur Optimierung der Systemsicherheit.

In der Überwachungsphase beobachten die Teams kontinuierlich die Anwendung und die Infrastruktur im Produktivbetrieb, um Probleme zu erkennen, das tatsächliche Benutzerverhalten zu verstehen und die Erkenntnisse an die Entwicklungs- und Betriebsabteilung zurückzuleiten.

DevOps-Teams sammeln Observability-Daten (Metriken, Protokolle und Traces) und andere Informationen aus Anwendungen, Servern, Netzwerken und Datenbanken, um die Leistung in Echtzeit zu verfolgen. Sie legen Schwellenwerte und Warnmeldungen fest, sodass Anomalien (z. B. hohe API-Latenzen oder verdächtige Zugriffsmuster) Benachrichtigungen auslösen, um eine schnelle Untersuchung und Sanierung zu ermöglichen.

Wenn das Überwachungstool einen Softwarefehler oder ein Usability-Problem feststellt, leitet es die Informationen an Issue-Tracker und Backlogs weiter, damit die Teams nachfolgende Iterationen anpassen können.​

Die Endlosschleife beinhaltet keine explizite „sichere“ Phase, aber DevOps beinhalten oft Praktiken und Technologien, die Sicherheitsmaßnahmen über den gesamten Lebenszyklus hinweg integrieren.

Hier kommt DevSecOps in das Framework.

DevSecOps – kurz für Entwicklung, Sicherheit und Betrieb – ist ein Ansatz in der Softwareentwicklung, bei dem Sicherheitsmaßnahmen vom Ende (rechts) an den Anfang (links) des Entwicklungszyklus verlagert werden. Mit „Shift-Left“ implementieren Entwickler Sicherheitsprotokolle (wie Verschlüsselung, Eingabevalidierung, rollenbasierte Zugriffskontrollen und Multi-Faktor-Authentifizierung), während sie Code schreiben.

DevSecOps beinhaltet auch „Shift Right“-Aktivitäten und weitet Sicherheitspraktiken auf Produktionsumgebungen nach der Bereitstellung aus. Bei Shift-Right-Praktiken steht die Überwachung, das Testen und der Schutz von Anwendungen zur Laufzeit unter realen Bedingungen im Vordergrund. Sie ergänzen den Shift-Left-Ansatz zur Sicherheit, indem sie eine kontinuierliche Feedbackschleife schaffen, in der in der Produktion entdeckte Sicherheitsprobleme frühere Entwicklungsphasen beeinflussen.

Durch die Kombination von Shift-Left- und Shift-Right-Sicherheit können Unternehmen Sicherheitskontrollen in jede Phase des DevOps-Lebenszyklus integrieren. Eine duale „Shift-Everywhere“-Sicherheitsstrategie hilft DevOps Teams dabei, sowohl frühzeitige Prävention als auch die Erkennung von und Reaktion auf Bedrohungen nach der Bereitstellung zu implementieren, wodurch der allgemeine Sicherheitsstatus verbessert und eine kontinuierliche Verbesserung vorangetrieben wird.

Der DevOps-Lebenszyklus stellt eine Weiterentwicklung traditionellerer Softwareentwicklungsansätze wie Wasserfallmodell und flexibles Modell dar.

Waterfall ist eine Entwicklungsmethodik, die einem linearen, sequenziellen Prozess folgt, bei dem jede Phase des Lebenszyklus – Anforderungserfassung, Entwurf, Implementierung, Test, Bereitstellung und Wartung – vollständig abgeschlossen und genehmigt sein muss, bevor die nächste Phase beginnt. Sie legt den Schwerpunkt auf proaktive Planung, detaillierte Dokumentation und Vorhersehbarkeit und eignet sich daher für Projekte mit stabilen, klar definierten Anforderungen und wenigen zu erwartenden Änderungen (beispielsweise Projekte im Bereich der öffentlichen Verwaltung und des Gesundheitswesens).

Das Wasserfallmodell bietet eine gute Prozesskontrolle, doch die Entwicklungsteams arbeiten in Silos. Änderungen nach Abschluss einer Phase sind kostspielig und zeitaufwändig. Kurz gesagt: Das Wasserfallmodell hat Schwierigkeiten mit der Agilität.

„Agil“ ist eine iterative Entwicklungsmethode, bei der in kurzen Zyklen (sogenannten „Sprints“) kleine, funktionsfähige Teilergebnisse geliefert werden. Sie priorisiert adaptive Planung, frühzeitige Umsetzung und kontinuierliche Verbesserung auf der Grundlage des Feedbacks der Stakeholder, sodass Entwicklungsteams schnell auf sich ändernde Anforderungen und Bedingungen reagieren können.

Agile Methoden können sich für dynamische Umgebungen, wie beispielsweise Start-ups, als effektiv erweisen. Sie mildern die lineare Starrheit von Wasserfallmodellen durch funktionsübergreifende Teams, die der Softwarefunktionalität Vorrang vor einer umfassenden Dokumentation einräumen. Agile Ansätze konzentrieren sich jedoch auf den Softwareentwicklungsprozess und schließen die Betriebsprozesse aus.  

DevOps bietet einen modernen Ansatz, der kulturelle und technische Aspekte vereint und Entwicklungs- sowie Betriebsteams zusammenführt, wobei CI/CD-Tools (wie GitLab) zur Automatisierung von Tests, Bereitstellung und Überwachung genutzt werden. Im Gegensatz zu flexiblen und Wasserfall-Methoden können DevOps Praktiken Unternehmen dabei helfen, Software-Releases zu beschleunigen und Anwendungen zu entwickeln, die in den heutigen hochdynamischen Microservice-Architekturen und cloudbasierten IT-Umgebungen leistungsfähig und agil bleiben.

Die 7 Cs bieten eine weitere Möglichkeit, den DevOps-Lebenszyklus als Ergebnis von sieben kontinuierlichen Prozessen zu verstehen.

Kontinuierliche Entwicklung beinhaltet die Planung und Codierung von Software, wobei Entwickler den Prozess in kleinere, besser handhabbare Iterationen aufteilen. Entwickler speichern Änderungen in Versionskontrollsystemen und passen ihren Code kontinuierlich an die Anforderungen der Stakeholder an, wodurch Teams Risiken minimieren und sich schnell an Veränderungen anpassen können.

Bei der kontinuierlichen Integration werden Codeänderungen mehrerer Entwickler in einem gemeinsamen Repository zusammengeführt, wobei nach jedem Commit automatisch ein Build ausgelöst wird. Sie ermöglicht es DevOps-Teams, ihre Anwendungen kontinuierlich zu verbessern, konsistentes Feedback zu erhalten, Fehler zu erkennen und zu beheben, bevor sie sich auf die Leistung auswirken, und qualitativ hochwertigere Software zu besser vorhersehbaren Lieferplänen bereitzustellen. 

Kontinuierliches Testen ermöglicht es Entwicklern, automatisch Code-Reviews und Testprotokolle (wie Unit-Tests) zu starten. Es verwendet Test-Tools, um den integrierten Code kontinuierlich auf Fehler, Usability-Mängel und Leistungsprobleme zu untersuchen. Kontinuierliche Tests geben Entwicklern das schnelle Feedback, das sie zur Verbesserung der Software benötigen, ohne den Lebenszyklus zu verzögern.

Continuous Delivery automatisiert die Bereitstellung von Anwendungen und validierten Code-Basisänderungen (Updates, Fixes und sogar neue Funktion) an alle notwendigen Infrastrukturumgebungen für weitere Tests. Code-Builds, die alle Integrationstests und Validierungsphasen bestehen, werden gepackt und an Code-Repositorys übermittelt, in denen die Code-Pakete in einem bereitstellungsfähigen Format zentralisiert und gespeichert werden.

Die kontinuierliche Bereitstellung geht noch einen Schritt weiter, indem jede genehmigte Änderung automatisch und ohne menschliches Eingreifen in die Produktion überführt wird. Wenn Code-Updates getestet, validiert und genehmigt werden, übertragen kontinuierliche Bereitstellungstools das Software-Artefakt in eine Vorproduktions-Staging-Umgebung oder auf öffentliche Server und Vertriebsplattformen (wie beispielsweise App-Stores), wo Benutzer darauf zugreifen können.

Kontinuierliches Feedback erfordert von DevOps-Teams, Erkenntnisse aus Überwachungsdaten, Benutzererfahrungsdaten und den Eingaben von Stakeholdern zu gewinnen, um den Produkt-Backlog zu verfeinern und die Dringlichkeit jeder Verbesserung zu bestimmen.

Die kontinuierliche Überwachung verfolgt die Anwendungs- und Infrastrukturleistung in Echtzeit und identifiziert Probleme proaktiv, um die Systemzuverlässigkeit aufrechtzuerhalten. Die meisten Überwachungstools visualisieren CI/CD-Pipeline-Daten mithilfe von Dashboards, was die Transparenz des Technologie-Stacks erhöht und datengestützte Optimierungen ermöglicht.

Automatisierungstools übernehmen die Bereitstellung der Infrastruktur, die Skalierung der Ressourcen, die Daten-Backups, das Traffic-Routing und die Systemwartung und ermöglichen es DevOps Teams, Feedback kontinuierlich in neue App-Iterationen einfließen zu lassen.

Die Anwendung von DevOps-Best-Practices kann für Unternehmen zahlreiche Vorteile mit sich bringen, darunter: