Was Cloud-native Microservices sind und wie man sie erstellt

Definition von cloud-nativen Microservices

Cloud-native Microservices beziehen sich auf eine bestimmte Strategie für das Anwendungsdesign. Dabei unterteilen Entwickler Anwendungen in eine Reihe diskreter Einheiten, so genannte Microservices. Jeder Microservice kann in der Regel unabhängig von den anderen betrieben werden. Microservices teilen jedoch Daten miteinander und interagieren über ein Netzwerk, um die Anwendungsfunktionalität zu ermöglichen.

Microservices sind von Natur aus Cloud-nativ, da Cloud-native Anwendungen auf Microservice-Architekturen basieren – zumindest, nach den gängigsten Definitionen.

Microservices-Architekturen gibt es schon länger als Cloud-natives Computing. Microservices wurden vor etwa einem Jahrzehnt populär, während der Begriff Cloud-native erst etwa 2015 aufkam. Ein Grund dafür, dass Entwickler Cloud-native als eigenständigen Ansatz für Anwendungsdesign und -bereitstellung begriffen, war die Tatsache, dass so viele Anwendungen auf eine Microservices-Architektur umgestellt wurden.

Bei Cloud-native geht es jedoch um mehr als nur Microservices – verteilte Infrastruktur und konsumierbare Services sind ebenfalls wichtige Bestandteile der Gleichung. Allerdings sind Microservices wohl das wichtigste Element einer Cloud-nativen-Strategie.

Das heißt, Cloud-native Microservices müssen nicht in der Cloud ausgeführt werden. Entwickler können zum Beispiel auch Plattformen wie Kubernetes verwenden, um sie On-Premises bereitzustellen.

Vor- und Nachteile von Microservices

Cloud-native Microservices bieten mehrere Vorteile, darunter:

• Agilität. Anwendungen, die als eine Reihe verteilter Microservices ausgeführt werden, sind flexibler, da Entwickler jeden Microservice unabhängig aktualisieren und skalieren können.
• Widerstandsfähigkeit. Microservices-Anwendungen sind in der Regel resilienter, da der Ausfall eines einzelnen Microservices in der Regel nicht zum Ausfall der gesamten Anwendung führt.
• Einfachheit der Entwicklung. Microservices unterteilen die Codebasis in der Regel in kleinere Teile, mit denen Entwickler einfacher arbeiten können.

Auf der anderen Seite bringen Microservices einige Herausforderungen mit sich. Das größte Problem ist, dass sie die Komplexität der Anwendung erhöhen. Eine Anwendung mit mehr dynamischen Teilen ist schwieriger zu orchestrieren.

Aus diesem Grund lohnt es sich oft nicht, Microservices für einfache Anwendungen zu implementieren. Zu diesen gehören beispielsweise Anwendungen mit kleiner Codebasis und solche mit geringen Anforderungen an Skalierbarkeit oder Ausfallsicherheit.

Cloud-native Microservices erstellen

Entwickler können Microservices – als Architekturstil – auf verschiedene Weise implementieren. Es gibt kein bestimmtes Tool oder eine bestimmte Methodik für die Erstellung einer Microservices-Anwendung.

Verfügbar sind jedoch einige allgemeine Richtlinien, die bei der Entwicklung und Generierung von Cloud-nativen Microservices hilfreich sind.

Trennen Sie die Microservices-Codebasis

Es ist zwar möglich, den Code für alle Microservices in einem einzigen Repository zu administrieren. Dies ist jedoch keine optimale Vorgehensweise. Verwalten Sie den Code für jeden Microservice am besten separat, um die Entwicklung so weit wie möglich zu vereinfachen.

Stellen Sie Microservices unabhängig bereit

Aus ähnlichen Gründen sollten Sie jeden Microservice als separate Einheit in die Produktion überführen und nicht alle auf einmal. Andernfalls können die Entwickler den Microservice nicht aktualisieren, ohne den Rest der Anwendung zu beeinträchtigen.

Segmentieren Sie den Speicher zwischen Microservices

Geben Sie jedem Microservice seine eigenen Speicherressourcen, anstatt dass Sie alle Microservices einer Datenbank oder einem anderen persistenten Datenspeicher zuweisen. Dieses Modell erfordert zwar zusätzlichen Aufwand, ermöglicht es den Entwicklern jedoch, die Speicherressourcen auf die Anforderungen jedes einzelnen Microservices abzustimmen. Es verringert auch das Risiko, dass ein Microservice die Daten, die mit einem anderen Microservice teilt, überschreibt oder beschädigt.

Verwenden Sie ein API-Gateway

Entwickler können Microservices so entwerfen, dass sie mit externen Endpunkten direkt kommunizieren. Ein besserer Ansatz ist jedoch die Verwendung eines API-Gateway als Vermittler.

Die Verwendung eines Microservices mit API-Gateways hat zwei wesentliche Vorteile. Erstens wird die Bereitstellung von Microservices vereinfacht, da die Microservices den genauen Standort externer Ressourcen nicht kennen müssen, sondern nur den Standort des API-Gateways. Zweitens kann das API-Gateway Anfragen validieren und verwalten, wodurch Leistungs- und Sicherheitsprobleme verringert werden.

Implementieren Sie ein Service-Mesh

Microservices können Daten direkt über ein internes Netzwerk miteinander austauschen. Ein besserer Ansatz ist jedoch die Verwendung einer zwischengeschalteten Infrastrukturebene zur Verwaltung der Kommunikation – insbesondere eines Service-Mesh.

Service-Meshes verwalten Anfragen zwischen Microservices. Sie sind mit API-Gateways vergleichbar und bieten ähnliche Leistungs- und Sicherheitsvorteile. Der Hauptunterschied besteht darin, dass ein Service-Mesh die interne Kommunikation verwaltet, während ein API-Gateway als Schnittstelle zwischen Microservices und externen Ressourcen dient.

Verwenden Sie ein Microservices-freundliches Programmier-Framework

Microservices können zwar in jeder Sprache geschrieben werden. Allerdings eignen sich bestimmte Sprachen oder Frameworks besonders gut für Cloud-native Microservices-Architekturen.

Wenn Sie zum Beispiel Java bevorzugen, sollten Sie ein Java-Framework wie Spring Boot in Betracht ziehen, das für diesen Anwendungsfall geeignet ist. Die Gleichzeitigkeitsfunktionen und das modulare Designmodell machen Go zu einer guten Wahl für die Programmierung von Microservices.

Auch C++ eignet sich aufgrund seiner Parallelitätsunterstützung und schnellen Ausführung bestens für die Entwicklung von Microservices. Die schnelle Ausführung verringert das Risiko von Verzögerungen in der Anwendung. Diese könnten durch Microservices verursacht werden, die Anfragen nur langsam bearbeiten.