Was sind Microservices?

Viele Unternehmen haben ihre ursprünglichen Dienste mit einer monolithischen Anwendungsarchitektur aufgebaut – mit anderen Worten, alle Architekturkomponenten befinden sich innerhalb einer einzigen Infrastruktur. Wenn Entwickler(innen) eine Microservices-Architektur nutzen, trennen sie alle Systemkomponenten voneinander und stellen sie als einzelne Dienste bereit. Die Dienste kommunizieren über API-Aufrufe miteinander.

Das Ergebnis ist ein flexibler Architekturstil, der schnelle und kostengünstige Upgrades ermöglicht. Wenn man nur einen Bereich des Systems skalieren muss, ist dies einfacher und kostengünstiger als die Skalierung des gesamten Systems. Entwickler(innen) verwenden Container-Orchestrierungstools und Kubernetes, um die Rechenleistung und andere Ressourcen, die sie benötigen, angemessen zuzuweisen. Diese Dienste werden in einem Container auf einem Cloud-basierten Server ausgeführt.

Du kannst die Microservices-Architektur verstehen, indem du sie mit einer älteren monolithischen Anwendungsarchitektur vergleichst. Bei einem monolithischen Baustil bilden alle Einzelkomponenten zusammen eine Einheit. Alles wird gemeinsam entwickelt, bereitgestellt und skaliert. Teams müssen die gesamte Anwendung in einer einzigen Sprache mit einer einzigen Laufzeit schreiben.

Das bedeutet, dass verschiedene Teams, die an verschiedenen Komponenten der Anwendung arbeiten, sich koordinieren müssen, damit sie sich nicht gegenseitig bei der Arbeit beeinträchtigen. Beispielsweise kann ein Teil der Anwendung von einem Modul abhängen, das eine bestimmte Version benötigt, wie z. B. 1.8, während ein anderes Team dasselbe Modul benötigt, jedoch Version 1.7, da 1.8 nicht mit einer anderen Abhängigkeit kompatibel ist. In einer monolithischen App muss man sich für die eine oder die andere Version entscheiden. In ähnlicher Weise stellen monolithische Apps alles als eine einzige Anwendung bereit, was das gemeinsame Testen und Bereitstellen von Code erfordert.

Bei Microservices werden alle Komponenten aufgeteilt und als einzelne Dienste bereitgestellt, die über API-Aufrufe miteinander kommunizieren.

Microservices maximieren die Anwendungszuverlässigkeit und die Bereitstellungsgeschwindigkeit. Dies ist besonders wichtig in einem Markt, der sich schneller als je zuvor bewegt und weiterentwickelt. Mit der Container-Architektur von Microservices können Apps überall hin verschoben werden, ohne die Umgebung zu verändern oder zu stören, was die Geschwindigkeit erhöht und Ausfallzeiten verringert.

Werfen wir einen Blick auf die Kernkomponenten einer Microservices-Architektur:

1. Clients: Client-Apps müssen in der Regel Funktionen von mehreren Microservices nutzen und häufig aktualisiert werden.
2. Datenbanken: Eine Dienst-API aktualisiert Microservices-Datenbanken, indem sie alle Remote-Dienste enthält, die die prozessübergreifende Kommunikation für verschiedene Stacks unterstützen.
3. API-Gateway: Ein API-Gateway ist ein Designmuster für Microservices, das einen wichtigen Einstiegspunkt für Routing-Anfragen und die Protokollübersetzung bildet.
4. Identitätsanbieter: Ein Identitäts-Microservice muss einen Server-zu-Server-Zugriff sowie einen benutzergesteuerten Zugriff auf Identitätsdaten ermöglichen.
5. Nachrichtenformate: Microservices kommunizieren mit synchronen oder asynchronen Microservice-Architekturmustern.
6. Statische Inhalte: Clients erhalten statische Inhalte über Cloud-basierte Speicherdienste und Content-Delivery-Netzwerke.
7. Verwaltung: Diese Komponente ermöglicht es Geschäftsbenutzer(inne)n, Dienste während der Laufzeit zu konfigurieren.
8. Dienstsuche: Ein Dienstsuchmechanismus ist erforderlich, um einen Dienst anzufordern.

Martin Fowlers Grundlagenartikel über Microservices definiert neun Komponenten, die die meisten Microservice-Architekturen gemeinsam haben.

1. Komponentisierung über Services

Microservices-Architekturen werden naturgemäß in Komponentendienste unterteilt. So kann jeder Dienst unabhängig bestimmt, bereitgestellt, optimiert und neu bereitgestellt werden, ohne die Umgebung zu beeinträchtigen. Dies bedeutet, dass es in der Regel möglich ist, einen Dienst zu ändern, anstatt eine gesamte Anwendung neu bereitzustellen.

2. Rund um Geschäftsfähigkeiten organisiert

Bei dem monolithischen Ansatz konzentrierten sich die Technologieteams separat auf technologiebezogene Funktionen wie Benutzeroberfläche, Datenbanken und serverseitige Logik. Auf der anderen Seite organisieren Microservices funktionsübergreifende Teams nach Geschäftsmöglichkeiten und -prioritäten. Teams können dann Produkte basierend auf einzelnen Diensten entwerfen, die über einen Nachrichtenbus kommunizieren.

3. Produkte statt Projekte

In der Vergangenheit nutzten App-Entwickler(innen) ein Projektmodell, bei dem Teams mit der Erstellung von Software beauftragt wurden, die nach Abschluss an eine Wartungsorganisation weitergeleitet wurde. Durch die Microservices-Architektur wird begünstigt, dass ein Team während seiner gesamten Lebensdauer Eigentümer eines Projekts bleibt. Dies ermöglicht es Entwickler(inne)n, auf neue Weise mit ihren Produkten zu interagieren, zu sehen, wie sie sich in der Produktion verhalten, und den Benutzerkontakt zu steigern. Es ermöglicht auch eine bessere Zusammenarbeit zwischen Ingenieur(inn)en und Unternehmen und das bessere Verständnis der Fachgebiete des jeweils anderen.

4. Intelligente Endpunkte und dumme Leitungen

Microservices haben viel mit dem traditionellen UNIX-System gemeinsam. Sie erhalten eine Anfrage, bearbeiten diese und generieren eine entsprechende Antwort. Fowler bezeichnet diesen Ansatz als „intelligente Endpunkte und dumme Leitungen“. Die Infrastruktur ist in der Regel „dumm“, da sie ausschließlich als Nachrichtenrouter dient und die Intelligenz sich ausschließlich an den produzierenden und konsumierenden Endpunkten befindet.

5. Dezentrale Governance

Die dezentrale Governance ist die Standardstruktur einer Microservice-Architektur, da Einzeltechnologieplattformen häufig zu einer Überstandardisierung führen. Ein großer Vorteil von Microservices im Vergleich zu monolithischen Systemen ist die Verwendung verschiedener Programmiersprachen und Technologien dort, wo sie am besten geeignet sind. Beispielsweise können Spring Boot-Microservices eine App für eine Komponente erstellen, während Spring Cloud auf einer anderen Komponente verwendet wird.

6. Dezentrales Datenmanagement

Die meisten Microservices ermöglichen es jeder Komponente, ihre eigene Datenbank über ein dezentrales Datenmanagement zu verwalten. Sie können immer den besten Datenspeicher für ein bestimmtes Projekt verwenden und gleichzeitig die zeitaufwändige Aufgabe der gemeinsamen Datenbank-Upgrades eliminieren.

7. Infrastrukturautomatisierung

CI/CD-Expert(inn)en nutzen die Infrastrukturautomatisierung in Microservices. Dies verringert die Arbeitsbelastung der Entwickler(innen) und verbessert die Effizienz des Zeitplans für die Bereitstellung erheblich.

8. Design for Failure

Wie die besten Geschäftsmodelle haben auch Microservices Resilienz im Blick. Da einzigartige und vielfältige Dienste kommunizieren müssen, ist ein Ausfall wahrscheinlich. Dies ist der Hauptnachteil von Microservices im Vergleich zu monolithischen Systemen, da die Lösung zusätzliche Komplexität erfordert.

Ausgefeilte Überwachungs- und Protokollierungseinstellungen sind erforderlich, um zu verhindern, dass sich ein Ausfall auf die Verbraucher(innen) auswirkt. Dies erfordert zwar mehr Arbeit für Entwickler(innen), bedeutet jedoch, dass die Ausfallsicherheit gut entwickelt ist.

9. Evolutionäres Design

In einer so schnelllebigen Technologiebranche ist evolutionäres Design kein Luxus mehr – es ist eine Notwendigkeit. Jedes Jahr kommen neue elektronische Geräte auf den Markt, und deine Apps müssen in der Lage sein, damit zu arbeiten. Das dekonstruierte Design von Microservices bedeutet, dass du deine Apps ohne erneute Bereitstellung überarbeiten kannst.

Fowler ging in diesem Vortrag von GOTO ausführlicher auf jede dieser Komponenten ein.

Microservices-Designs sind agil und flexibel und ermöglichen minimale Ausfallzeiten für Wartung, Reparaturen und Updates.

Einige wichtige Anwendungsfälle für Microservices sind:

1. Datenverarbeitung

Apps, die auf einer Microservice-Architektur ausgeführt werden, können mehr gleichzeitige Anfragen in kürzerer Zeit bearbeiten, wodurch sie effizienter werden.

2. Website-Migration

Microservices vermeiden Ausfallzeiten der Website-Benutzeroberfläche, -struktur und/oder -domäne.

3. Medien im großen Maßstab

Plattformen können eine extreme Anzahl an Anfragen für verschiedene Subdomains ohne Fehler oder Verzögerungen verarbeiten.

4. Rechnungen und Transaktionen

Mit Microservices können Transaktionen durch verringerte Ausfälle von Apps robuster werden, sodass Unternehmen wachsen können, ohne neue Software bereitstellen zu müssen.

5. Veraltete Systeme

Die Entwicklung eines neuen, containerisierten Systems ist effizienter und effektiver als die Aktualisierung alter, klobiger Monolithen.

Die Implementierung einer Microservices-Architektur oder die Zerlegung eines Legacy-Monolithen in Microservices kann die Geschwindigkeit, Flexibilität und Skalierbarkeit erhöhen, oft auf Kosten der Einfachheit. Monolithen sind einfach zu erstellen, bereitzustellen und zu debuggen, aber schwer zu skalieren. Eine Microservice-Architektur ist zwar komplexer, bietet für die Entwickler(innen) jedoch einige Vorteile:

Unabhängige Bereitstellung

Jeder Microservice muss Fullstack sein, um richtig zu funktionieren. DevOps-Teams können Fehler an einem Microservice einfach beheben, ohne die gesamte Umgebung zu beeinflussen.

Skalierbarkeit

In einem Monolithen müssen alle Elemente der Anwendung gemeinsam skaliert werden, was bedeuten kann, dass manche Elemente unnötig skaliert werden müssen. Mit unabhängigen Komponenten kann jeder Microservice individuell nach Auslastung skaliert werden. Teams, die Apps mit einer Microservice-Architektur erstellen, können die einzelnen Services anpassen, ohne den Rest der Anwendung zu stören. Programmierer(innen) können parallel arbeiten, um stark genutzte Services zu identifizieren, den Funktionsumfang zu aktualisieren und ausgewählte Services zu skalieren.

Freiheit beim Technologie-Stack

Die Abhängigkeit von einem einzelnen Technologie-Stack für die gesamte Anwendung ist eines der einschränkendsten Merkmale einer monolithischen Architektur. Mit Microservices können Entwickler(innen) eine App mit der richtigen Programmiersprache, dem passenden Framework, geeigneten Datenbanken sowie Frontend- und Backend-Tools, die für den Job am besten geeignet sind, erstellen. Dadurch musst du keine Kompromisse eingehen, wie es bei einem standardisierten Stack der Fall ist, der für alles passen soll, aber nichts besonders gut kann.

Fehlerisolierung

Ein einzelner Fehler bedeutet oft, dass eine ganze monolithische App nicht mehr funktioniert. Microservices isolieren Fehler an ihren Komponenten, sodass nicht die gesamte Anwendung betroffen ist. Wenn ein Microservice ausfällt, bleibt der Rest der Anwendung online. Es ist eine gute Idee, den Status aller Microservices auf einem Dashboard anzuzeigen, sodass das Wartungspersonal Fehler schnell erkennen und Probleme rasch beheben kann. Fehler können beispielsweise einfach behoben werden, indem ein zusätzlicher Server mit Virtualisierung auf Abruf durch einen Schieberegler aktiviert wird.

Produktivität

Microservices reduzieren Silos und fördern funktionsübergreifende Teamarbeit für die heutigen verteilten und ortsunabhängigen Mitarbeiter. Sie können unabhängig getestet werden, während Entwickler(innen) sich um andere Aspekte kümmern, was die Qualitätssicherung optimiert. Für die Programmierer(innen) ermöglicht die Microservice-Architektur den Aufbau skalierbarer, resilienter Services, die einfach bereitzustellen sind.

Durch kontinuierliche Lieferung können Unternehmen Funktionen testen, indem verschiedene Versionen der Services verschiedenen Benutzergruppen bereitgestellt werden. Selbst für Unternehmen mit bestehender monolithischer Software gibt es Möglichkeiten, ihren Verarbeitungsstapel mit Microservices zu modernisieren.

Microservices bieten die Vorteile, resilient und skalierbar zu sein. Es kann jedoch schwierig sein, kleine unabhängige Services zusammenzubringen.

Sehen wir uns kurz an, was du beachten solltest.

• Komplexität: Wenn die Anzahl der Microservices zunimmt, können sie komplexer in der Verwaltung und Orchestrierung werden. Infrastrukturautomatisierung und CI/CD sind der Schlüssel.
• Datenkonsistenz: Microservices arbeiten in einem umfangreichen System zusammen und pflegen ihre eigenen Daten. Das bedeutet, dass es gemeinsame Daten über mehrere Dienste hinweg geben wird. Änderungen müssen bei allen Verbraucherdiensten repliziert werden, wenn Änderungen an solchen gemeinsamen Daten vorgenommen werden.
• Risiko eines Kommunikationsausfalls: Im Gegensatz zu laufenden Funktionsaufrufen können Aufrufe anderer Dienste über das Netzwerk fehlschlagen. Das ist ein notwendiger Kompromiss mit der Ausfallsicherheit und Skalierbarkeit, die durch die Microservices-Architektur erreicht wird. Um die Ausfallsicherheit zu erhöhen, kannst du Abschottungs- und Unterbrechungsmuster verwenden.

Heute sind Microservices-Architekturen in der gesamten Geschäftswelt weit verbreitet – viele Unternehmen nutzen entweder bereits Microservices oder planen dies in Kürze. Microservices sparen Geld, reduzieren technische Probleme und minimieren Ausfallzeiten.

Für Unternehmen jeder Größe ist es jetzt soweit. Es gab noch nie einen besseren Zeitpunkt, um deine Architektur von einer monolithischen Struktur auf Microservices umzustellen. Du sparst auf lange Sicht Geld, machst dein Unternehmen effizienter und deine Kund(inn)en glücklicher. Microservices sind die Architektur der Zukunft, und es ist an der Zeit, dass du herausfindest, wie sie deinem Unternehmen helfen können.

Microservices haben eine Reihe von geschäftlichen Vorteilen im Vergleich zu Monolithen. Sie fördern eine symbiotische Beziehung zwischen Entwickler(inne)n und Unternehmensleiter(inn)en, was zu besseren Ergebnissen führt. Microservices fördern:

1. Ein schnelleres Innovationstempo: Ihr evolutionäres Design macht es einfach, Anwendungskomponenten zu ändern und zu aktualisieren.
2. Höhere Stabilität/Ausfallsicherheit: Microservices eliminieren praktisch Ausfallzeiten, da die Dienste im Gegensatz zu monolithischen Architekturen getrennt sind und Entwickler(innen) eine Komponente nach der anderen aktualisieren können.
3. Skalierbarkeit: Entwicklungsteams können an einzelnen Komponenten arbeiten, ohne die gesamte Umgebung zu beeinträchtigen, sodass sie besser mit den Geschäftsanforderungen Schritt halten können.
4. Geringere Kosten und besserer Umsatz: Microservices benötigen weniger Gesamtinfrastruktur, minimieren Ausfallzeiten und verbessern die Stabilität, wodurch ein verbessertes Kundenerlebnis erzielt werden kann. Außerdem reduzieren sie Prototypen für Bereitstellungszeiträume.

Da immer mehr Unternehmen und Personen auf SaaS-Anwendungen angewiesen sind und die Komplexität der Anwendungsentwicklung zunimmt, ist der Bedarf an Verfügbarkeit und Skalierbarkeit höher denn je. Auch unterstützende Dienste wie skalierbare Datenbanken, kontinuierliche Lieferung, Beobachtbarkeitstools sowie Daten- und Ereignisstreaming wachsen schnell.

Programmierer(innen) lernen kontinuierlich dazu, um diese Herausforderungen zu meistern. Gleichzeitig befinden sich die Microservices-Architektur und die Netzwerkinfrastruktur noch in der Weiterentwicklung. Es ist leicht, sich eine Zukunft vorzustellen, in der Microservice-Anwendungen einfacher zu warten und zu entwickeln sind und Unternehmen noch mehr Wert bieten.

Mit GitLab kannst mit du mit einer einzigen Anwendung deinen Code committen und hast alle Tools, die du brauchst. Jetzt ist Schluss damit, für jedes Projekt mit 10 Tools zu jonglieren.

Durch eine DevOps-Plattform für die Verwaltung deiner Microservices vermeidest du Datensilos. Durch mehr Transparenz zwischen den Teams und einfachere Übergaben beschleunigt sich der DevOps-Lebenszyklus und du stellst sicher, dass du deine Projekte einfach bereitstellen und stabil halten kannst.

GitLab vereinfacht die Microservice-Orchestrierung dank folgender Aspekte:

1. Integrierte CI/CD: Wie Fowler betont, ist für Microservices eine Infrastrukturautomatisierung mit kontinuierlicher Lieferung und Bereitstellung erforderlich. Die integrierte CI/CD von GitLab ist ideal für Unternehmen, die Microservices nutzen möchten.
2. Integrierte Container-Registry und eine robuste Kubernetes-Integration: Die Microservices-Architektur kann zwar mit der Legacy-Technologie für virtuelle Maschinen (VM) verwendet werden, Container und Kubernetes erleichtern jedoch den Aufbau von Microservices erheblich. GitLab ist so konzipiert, dass es gut mit Kubernetes funktioniert.
3. Integrierte Überwachung: Die Überwachung ist entscheidend für einen erfolgreichen Betrieb. Durch die Überwachungsfunktionen von GitLab, die Prometheus nutzen, ist GitLab ideal für Microservices geeignet.
4. Multiprojekt-Pipelines: GitLab unterstützt laufende Pipelines mit projektübergreifenden Abhängigkeiten, sodass Interaktionen zwischen verschiedenen Repositories einfach zu verwalten sind.
5. Monorepo-Unterstützung und die Möglichkeit, eine Pipeline nur auszuführen, wenn sich der Code in einem bestimmten Verzeichnis ändert: Dies reduziert die Zeit, die mit dem Ausführen von Pipelines im gesamten Repository verschwendet würde.
6. Kubernetes-Cluster auf Gruppenebene: Mehrere Projekte können in einen einzelnen Kubernetes-Cluster integriert werden.

GitLab ist eine einzige DevOps-Plattform, die Top-Entwickler(innen) anzieht, die zusammenarbeiten und sich verbessern möchten. Hier findest du einige der wichtigsten Vorteile, um dich von GitLab zu überzeugen:

• Kein Wechsel zwischen Apps: Entwickler(innen) müssen nicht ständig den Kontext wechseln, was es einfacher macht, sich zu konzentrieren und bei der Sache zu bleiben. Darüber hinaus kannst du Tickets einfach mit der Arbeit verknüpfen, die Produktivität steigern und die Hauptfehler der Softwareprogrammierer(innen) beseitigen.
• Reduziere deinen Workload: GitLab erleichtert die Automatisierung von Aufgaben, sodass du dich auf anspruchsvollere, ergebnisorientierte Aktivitäten konzentrieren kannst. Wiederholte manuelle Aufgaben machen den Arbeitstag von Entwickler(inne)n zur Mühsal. Automatisiere solche Aufgaben, um die Arbeitszufriedenheit und Produktivität zu steigern.
• Zusammenarbeit und Transparenz: Zusammenarbeit und Transparenz sind die wichtigsten Vorteile der GitLab-Plattform. Transparenz zwischen Entwickler(inne)n und Kund(inn)en erleichtert die Zusammenarbeit und sorgt für schnelle, einfache Korrekturen und weniger Kommunikation.
• Werde Teil der Community: Alle Entwickler(innen) können kostenlos zum Open-Source-Kern von GitLab beitragen, um die App zu verbessern. Die Community ist herzlich, freundlich und reaktionsschnell. Neue Community-Mitglieder werden mit Freude aufgenommen und es wird ihnen geholfen, sich zurechtzufinden.
• Lerne modernste Softwareentwicklungspraktiken kennen: Programmierung und Anwendungsentwicklung gehören zu den am schnellsten wachsenden Bereichen in einer zunehmend schnelllebigen Welt. GitLab hält seine Community über die neuesten Entwicklungen auf dem Laufenden und hilft, Best Practices zu lernen.