Was sind Microservices?

Vorteile von Microservices

Microservices bieten ein Framework für den Aufbau Cloud-nativer Anwendungen, die sich an wechselnde Anforderungen anpassen können. Die unzähligen Vorteile ergeben sich aus der Architektur der Anwendung.

Gewandtheit

Die Microservices-Architektur eignet sich für die unabhängige Entwicklung und Bereitstellung. Im Gegensatz zu monolithischen Anwendungen, bei denen die Änderung einer Codezeile die Aktualisierung der gesamten Anwendung nach sich zieht, können Entwickler Dienste ändern oder ersetzen, ohne das verteilte System zu beeinträchtigen. Die Möglichkeit, einzelne Dienste bereitzustellen, macht es einfach, neue Funktionen hinzuzufügen oder Änderungen an einer Anwendung zurückzunehmen.

Skalierbarkeit

Die Skalierung einer gesamten Anwendung ist nicht optimal. Bei Microservices werden nur die Komponenten skaliert, die skaliert werden müssen. Entwickler können einen einzelnen Dienst nach Bedarf adressieren, was letztlich eine bessere Leistung bei hoher Belastung, die effiziente Nutzung von Ressourcen und niedrigere Infrastrukturkosten ermöglicht.

Auswahl

In der Microservices-Architektur hat die Cloud-native Anwendung keinen gemeinsamen Stack und keine gemeinsame Datenbank. Die Entwickler können die von ihnen bevorzugten Tools und Technologien auswählen, um die unterschiedlichen Anforderungen der einzelnen Dienste zu erfüllen.

Integration

Entwickler können Microservices in jeder beliebigen Sprache schreiben - und sie mit Microservices verbinden, die in einer beliebigen Sprache programmiert wurden. Darüber hinaus können Microservices auf jeder Plattform ausgeführt werden, was sie für die Integration mit Legacy-Systemen verfügbar macht.

Code-Wiederverwendung

Die Microservices-Architektur ermöglicht es Entwicklern, modulare Dienste zu erstellen, die sie in verschiedenen Anwendungen wiederverwenden können. Durch die Arbeit mit wiederverwendbaren Komponenten verkürzen Programmierer die Entwicklungszeit und verbessern die Qualität des Codes, da sie in eine Kultur der einmaligen und häufigen Wiederverwendung investieren.

Fehlertoleranz

Die Microservices-Architektur fördert die Ausfallsicherheit. Bei Diensten, die so konzipiert sind, dass sie autonom arbeiten, führt der Ausfall eines einzelnen Dienstes selten zum Stillstand der Anwendung, wie es bei monolithischen Anwendungen der Fall ist.

Zusammenarbeit

Die Microservices-Architektur ermöglicht es den Teams, gleichzeitig an verschiedenen Diensten zu arbeiten, was sich in einer schnelleren Markteinführung niederschlägt. Während Entwickler Entscheidungen treffen, ohne sich mit anderen Teams abstimmen zu müssen, fördern Microservices auch die teamübergreifende Zusammenarbeit, da jedes Team für die Entwicklung und Pflege eines Teils des Ganzen verantwortlich ist. Dies kann zu einer besseren Ausrichtung auf die Unternehmensziele und einer effizienteren Nutzung der Ressourcen führen.

Kontinuierliche Iteration

Die mit Microservices erstellte Anwendung ist so konzipiert, dass sie sich weiterentwickeln kann. Entwickler können die Kern-Microservices schnell als Minimum Viable Product bereitstellen und die Anwendung aktualisieren, wenn Teams zusätzliche Services fertigstellen. Neue Technologien können in das Design integriert werden, sobald sie auftauchen. Die auf Microservices basierende Anwendung bleibt in Arbeit und bewegt sich kontinuierlich auf die theoretische Perfektion zu.

Wann Sie Microservices verwenden sollten

Container-basierte Microservices bieten zwar viele Vorteile, aber sie sind nicht immer die richtige Anwendungsarchitektur für Sie. Wenn Sie softwaretechnische Entscheidungen treffen, denken Sie an Ihre Ziele für die Anwendung sowie an die Entwicklungshürden und Anforderungen, die Sie im Hinblick auf die Lebensdauer der Anwendung voraussehen. Microservices funktionieren am besten bei komplexen Anwendungen. Zu den Szenarien für den Einsatz von Microservices gehören:

Große Anwendungen

Wenn Sie eine große und komplexe Anwendung erstellen, können Sie die Anwendung mit Hilfe von Microservices in überschaubare Teile aufteilen und so die Entwicklung, Bereitstellung und Wartung erleichtern.

Komplexität der Zeitachse

Die Microservices-Architektur kann unabhängige Dienste mit unterschiedlichen Entwicklungsgeschwindigkeiten beherbergen. Selbst wenn es bei einem Dienst zu einer unerwarteten Verzögerung kommt, kann das Projekt fortgesetzt werden, ohne dass dies globale Auswirkungen auf den Zeitplan der Anwendungsentwicklung hat.

Häufige Updates

Die Microservice-Architektur ist ideal für Anwendungen, die häufig aktualisiert werden müssen, da unabhängige Dienste es den Entwicklern ermöglichen, das Modul und nicht die Anwendung zu ändern.

Hohe Skalierbarkeit

Wenn Ihre Anwendung ein hohes Verkehrsaufkommen bewältigen oder schnell skalieren muss, sind Microservices unerlässlich. Dies gilt insbesondere, wenn Sie bestimmte Teile der Anwendung skalieren müssen, anstatt die gesamte Anwendung zu skalieren.

Mehrere Teams

Wenn Sie mehrere Entwicklungsteams an derselben Anwendung arbeiten lassen, helfen Ihnen Microservices dabei, Flexibilität und Effizienz zu erhalten. Jedes Team kann an seinem Microservice arbeiten und dabei den Technologie-Stack verwenden, der für sie am besten geeignet ist, ohne sich um den Rest der Anwendung zu kümmern.

Dezentralisierte Architektur

Wenn Sie eine Anwendung mit einer dezentralisierten Architektur erstellen möchten, sind Microservices autonom und können an verschiedenen Orten bereitgestellt werden, sogar bei verschiedenen Cloud-Dienstanbietern.

Hybrid Cloud

Wenn Sie eine hybride Cloud-Architektur planen, bei der einige Dienste weiterhin vor Ort und andere in der Cloud ausgeführt werden, helfen Ihnen Microservices dabei, die Komplexität der Anwendung zu bewältigen.

Erstellung und Bereitstellung von Microservices-basierten Apps

Die Architektur von Microservices erfordert eine sorgfältige Planung. Bestimmte Technologien und Praktiken, die in der Produktionsumgebung üblich sind, ermöglichen es Entwicklern, Microservices-basierte Anwendungen effektiv zu entwickeln, zu pflegen und zu betreiben.

DevOps

DevOps-Praktiken, einschließlich CI/CD, sind für den Architekturansatz von Microservices unerlässlich. Im Gegensatz zu monolithischen Anwendungen sind Microservices von Natur aus komplexe verteilte Systeme mit zahlreichen beweglichen Teilen und unabhängigen Technologie-Stacks. Diese Komplexität erfordert eine häufige Zusammenarbeit zwischen Entwicklungs- und Betriebsteams, um sicherzustellen, dass die Komponenten nahtlos integriert werden.

DevOps Praktiken bieten die notwendigen Tools für Zusammenarbeit, Kommunikation und Automatisierung, um Teams während des gesamten Lebenszyklus der Softwareentwicklungeffektiv zusammenzubringen.

Kontinuierliche Lieferung

Die kontinuierliche Bereitstellung geht Hand in Hand mit Microservices und ermöglicht es Entwicklern, Software-Updates häufig und zuverlässig zu veröffentlichen, indem sie Tools zur Infrastrukturautomatisierung wie Continuous Integration Server, Bereitstellungs-Pipelines und automatisierte Test-Frameworks nutzen, um den CI/CD-Prozess zu rationalisieren.

Kontinuierliche Bereitstellung ist besonders wichtig, um sicherzustellen, dass jeder Dienst unabhängig von den anderen Microservices aktualisiert und freigegeben werden kann.

REST

Microservices kommunizieren mit Microservices - und die meisten tun dies innerhalb von Webanwendungen - was REST komplementär macht. REST (Representational State Transfer) ist ein architektonisches Entwurfsmuster für den Aufbau von RESTful APIs, mit denen Dienste über HTTP in Standardformaten wie XML, HTML und JSON kommunizieren können. Aber REST APIs sind aus mehreren Gründen die Grundlage für Microservice-basierte Anwendungen.

REST APIs sind leichtgewichtig und plattformunabhängig, d.h. sie bieten eine standardisierte Schnittstelle, über die Microservices unabhängig von der zugrunde liegenden Technologie kommunizieren können. Da Anfragen die Informationen enthalten, die für die Ausführung der Anfrage erforderlich sind, benötigen REST-APIs keinen auf dem Server gespeicherten Kontext. Sie können große Mengen an Anfragen bewältigen, ohne die Leistung zu beeinträchtigen, und die Dienste in einer REST-basierten Microservices-Architektur können sich unabhängig voneinander weiterentwickeln und effizient zustandslos kommunizieren.

Containers

Während Microservices den Teams die Möglichkeit geben, die Sprache und das Framework ihres Dienstes zu wählen, stellt die Arbeit mit verschiedenen Sprachen in derselben CD-Pipeline eine Herausforderung dar. Container abstrahieren die Varianz zwischen den Diensten, da jeder Microservice zu einer in sich geschlossenen Einheit wird, die mit ihrer Codebasis, ihrer Datenbank und ihren Abhängigkeiten verpackt ist. Die CD-Pipeline, die nun homogen ist, kann konsistente Tests für jeden Container durchführen.

Dienste können miteinander interagieren, ohne sich gegenseitig zu behindern, wenn sie durch Container getrennt sind. Sobald sie bereitgestellt sind, bieten Container eine leichtgewichtige, portable Laufzeitumgebung, die es den Diensten ermöglicht, plattformübergreifend konsistent zu funktionieren. Tools wie Docker und Kubernetes werden häufig zur Verwaltung von containerisierten Microservices eingesetzt.

Kubernetes Orchestrator

Ein Orchestrierungswerkzeug wie Kubernetes kann die zugrunde liegende Infrastruktur abstrahieren und die Verwaltung, Bereitstellung und Skalierung von Containern über mehrere Server hinweg automatisieren. Seine Erweiterbarkeit ermöglicht es Entwicklern und Betreibern außerdem, ihre bevorzugten Open-Source- und kommerziellen Software-Tools zu verwenden und so die manuelle Arbeit der Containerverwaltung zu reduzieren.

Serverlos

Serverloses Computing ist eine weitere Option für die Bereitstellung von Microservices. Serverlose Architekturen nutzen Functions as a Service (FaaS)-Plattformen, um noch kleinere Einheiten der Bereitstellung zu schaffen und bei Bedarf zu skalieren. Obwohl serverlose Architekturen die Abhängigkeit von Anbietern erhöhen können, bieten sie geringere Betriebskosten, geringere Komplexität und kürzere Entwicklungszeiten.

Microservices Bewährte Praktiken

Der Entwurf einer Microservice-Architektur erfordert sorgfältige Planung und Überlegung. Um erfolgreiche Microservices-basierte Anwendungen zu erstellen, sollten Entwickler die folgenden Best Practices beachten:

• Bereichsorientiertes Design: Domain-driven Design (DDD) ist ein Designansatz, der sich auf die Geschäftsdomäne und das Verhalten der Anwendung konzentriert. Es hilft den Entwicklern, die Anwendung in kleinere, besser verwaltbare Komponenten aufzuteilen, was die Erstellung, Bereitstellung und Wartung erleichtert.
• Dienstgrenzen: Bei der Entwicklung einer Microservice-Architektur ist es wichtig, klare Service-Grenzen zu definieren. Jeder Microservice sollte eine klar definierte Verantwortung haben.
• Kleine Dienstleistungen: Halten Sie die Dienste "mikro", konzentrieren Sie sich auf eine einzige Aufgabe. Wenn Sie dieses Grundprinzip aus den Augen verlieren, leidet die Verwaltbarkeit.
• API design: Microservices kommunizieren über APIs. Verwenden Sie daher konsistente, skalierbare und sichere APIs, die den Datenzugriff auf autorisierte Anwendungen, Benutzer und Server beschränken.
• Dezentralisierte Datenverwaltung: Microservices-Anwendungen erfordern eine Vielzahl von Speicher- und Datenbankoptionen. Jeder Microservice sollte seinen eigenen Datenspeicher haben. Dieser Ansatz hilft Ihnen, Dateninkonsistenzen zu vermeiden und ermöglicht es Ihnen, jeden Microservice autonom zu skalieren. Sie möchten, dass das Entwicklungsteam die Datenbank für jeden Dienst auswählt, um sicherzustellen, dass sie am besten zu ihrem Projekt passt.
• CI/CD pipeline: Die Implementierung von CI/CD wird Ihnen helfen, Fehler schnell zu finden und zu beheben, was besonders wertvoll ist, wenn Sie mehrere Codebases in einer Microservices-Architektur verwalten müssen.
• Vorsätzliche Resilienz: Schützen Sie die Anwendung vor Shutdowns aufgrund von Abhängigkeitsfehlern. Verwenden Sie nach Möglichkeit keine Remote Procedure Calls (RPCs) zwischen Microservices und integrieren Sie Funktionen wie Circuit Breaker, um kaskadierende Ausfälle zu verhindern.
• SOP: Entwickeln Sie Standardbetriebsverfahren, die Codierungskonventionen, Verzeichnisstrukturen und Kommunikationsprotokolle definieren. Die Einhaltung einer Reihe von Standards führt zu konsistenten und verwaltbaren Microservices.

Einführung von Microservices

eBay, Etsy, Uber - unzählige Unternehmen haben ihre monolithischen Anwendungen aufgelöst und in Microservices-basierte Architekturen umgewandelt, um Skalierungsvorteile, geschäftliche Agilität und finanzielle Gewinne zu erzielen.

Organisationen, die den Übergang zu Microservices planen, sollten zunächst DevOpseinführen, um für die Bewältigung der damit verbundenen Komplexität gerüstet zu sein. Rechnen Sie bei der Planung Ihres Projekts grundsätzlich mit den unten beschriebenen Schritten.

Identifizieren Sie die Geschäftsfähigkeiten

Der erste Schritt bei der Umstellung auf eine Microservices-Architektur besteht darin, die geschäftlichen Fähigkeiten oder Funktionen zu ermitteln, die Ihre Anwendung unterstützen soll. Dies wird Ihnen helfen, den Umfang Ihrer Anwendung zu definieren und Ihre Entscheidungen darüber zu treffen, welche Funktionen für die Entwicklung priorisiert werden sollten und wie diese Microservices gestaltet und miteinander integriert werden sollten.

Zerlegen Sie die monolithische Anwendung

Die meisten Organisationen verwenden domain-driven Design oder feature-basierte Dekomposition, um ihre monolithischen Anwendungen zu zerlegen.

Nachdem Sie die Geschäftsfunktionen der Anwendung identifiziert haben, definieren Sie die Servicegrenzen für jeden Microservice und stellen sicher, dass jeder Microservice eine eindeutige, klar definierte Verantwortung hat. Sie möchten die Abhängigkeiten zwischen den Geschäftsfunktionen, Datenspeichern und externen Systemen abbilden. Definieren Sie auf der Grundlage der begrenzten Kontexte und Abhängigkeiten die Microservices, die die monolithische Anwendung ersetzen werden.

Jeder Microservice, der sich auf eine einzelne Geschäftsfunktion konzentriert, sollte über klare Schnittstellen verfügen. Überprüfen Sie, wie auf die Dateneinheiten zugegriffen wird, und überlegen Sie schließlich, wie Sie die Daten partitionieren können, um Abhängigkeiten zwischen den Diensten zu verringern.

Definieren Sie Service-Schnittstellen

Implementieren Sie die Serviceschnittstellen für jeden Microservice und stellen Sie sicher, dass die Schnittstelle die alleinige Verantwortung des Microservices widerspiegelt. Sie können verschiedene Techniken wie RESTful APIs oder Messaging-Protokolle verwenden, um die Service-Schnittstellen zu definieren.

Implementierung und Test der Dienste

Je nach Ihren Anforderungen und Ihrer Erfahrung wählen Sie die Programmiersprachen und Frameworks für die Implementierung der Dienste. Iterieren Sie das Design nach Bedarf, einschließlich des Testens der neuen Schnittstellen, Kommunikationsprotokolle und Datenspeicher.

Containerisierung der Dienste

Sobald Sie die Dienste implementiert und getestet haben, sollten Sie sie mithilfe von Container-Technologien wie Docker oder Kubernetes containerisieren. Die Containerisierung ermöglicht es Ihnen, die Dienste unabhängig bereitzustellen und zu verwalten.

Automatisieren Sie die Bereitstellung und Orchestrierung

Automatisieren Sie die Orchestrierung der Dienste mit Tools wie Kubernetes oder Docker Swarm. Neben der effizienten Rationalisierung der Bereitstellung von Diensten verbessert die Automatisierung durch Kubernetes oder Docker die Zuverlässigkeit und Verfügbarkeit der Anwendung. Beide Plattformen können erkennen, wenn eine Serviceinstanz ausfällt oder nicht mehr reagiert und Maßnahmen zur Behebung des Problems ergreifen. Kubernetes zum Beispiel kann ausgefallene Instanzen neu starten oder auf andere Knoten verlagern, während Docker den ausgefallenen Container automatisch auf einen anderen Knoten migrieren kann.

Überwachen und Verwalten der Dienste

Die Dekomposition einer monolithischen Anwendung ist kein einmaliger Vorgang. Sie muss gewartet und aktualisiert werden, wenn sich die Anforderungen der Anwendung und ihrer Benutzer weiterentwickeln. Überwachen Sie die neuen Microservices und verfolgen Sie wichtige Metriken wie Reaktionszeit und Ressourcenauslastung.

Absicherung von Microservices

Hochgradig verteilte, Cloud-native Microservices-Anwendungen bringen komplexe Sicherheitsprobleme mit sich. Anstelle eines einzigen Einstiegspunktes gibt es Dutzende, wenn nicht Hunderte von potenziellen Schwachstellen - und jede davon muss gesichert werden. APIs und Code-Abhängigkeiten sind nur zwei Risikoquellen in der wachsenden Angriffsfläche moderner Anwendungen.

Sicherheit von Webanwendungen und APIs

Moderne Anwendungen verarbeiten Daten aus einer Vielzahl von Quellen - Standard-Webanfragen, API-Aufrufe von Mobilgeräten, Cloud-Ereignisse, Telemetrie-Kommunikation von IoT-Geräten, Cloud-Speicher, usw. Darüber hinaus kann eine einzige Webanfrage eines Kunden (d.h. Nord-Süd-Verkehr) Hunderte von API-Aufrufen zwischen internen Microservices (d.h. Ost-West-Verkehr) auslösen.

Die Komplexität von API-zentrierten Webanwendungen erfordert skalierbare, flexible und mehrschichtige Strategien, die für jede Art von Arbeitslast in jeder Art von Umgebung oder Cloud-Architektur funktionieren. Die Absicherung der Frontend-Weboberfläche der Cloud-nativen Anwendung reicht nicht aus. Cloud-native Anwendungen erfordern Schutz auf der Anwendungsebene für Cloud-native APIs.Webanwendungs- und API-Sicherheit (WAAS) ist unerlässlich.

Code-Abhängigkeiten und Analyse der Software-Zusammensetzung

Open-Source-Softwarekomponenten machen etwa 70% der Cloud-nativen Anwendungen aus. Dies beschleunigt zwar die Entwicklung, aber viele Open-Source-Pakete und ihre Abhängigkeiten enthalten Sicherheitslücken. Außerdem kann jede Version eines abhängigen OSS-Pakets wichtige Funktionen ändern. Ohne vollständige Transparenz bleiben Schwachstellen unentdeckt.

Eigenständige Software Composition Analysis (SCA) -Tools decken Open-Source-Risiken zu spät im Entwicklungszyklus auf, was zu einem Rückstau von Schwachstellen führt, die nicht immer behoben werden können. Getrennte Tools für SCA und IaC-Sicherheit führen zu verrauschten Alarmen ohne Kontext und Wissen über zusammenhängende Risiken. Da Lücken ohne Laufzeit- und Workload-Abdeckung unvermeidlich sind, ist es am besten, Cloud-native Anwendungen mit integrierter cloud-nativer Sicherheitzu sichern.

Code-to-Cloud CNAPP

Eine cloud-native Plattform für den Anwendungsschutz (CNAPP) identifiziert und priorisiert kritische Risiken der gesamten Cloud-nativen Anwendung und integriert mehrere Arten von Sicherheit, um einen umfassenden Code-to-Cloud-Schutz zu bieten - Cloud Security Posture Management (CSPM), Cloud Workload Protection, Cloud Infrastructure Entitlement Management (CIEM), Kubernetes Security Posture Management (KSPM), Infrastructure-as-Code-Sicherheit, WAAS, SCA und mehr.

Führungskräfte im Bereich Cloud-Sicherheit, die sich mit der Frage beschäftigen, wie sie die schnelle Entwicklung von Anwendungen mit Cloud-nativen Technologien wie Containern, Microservices und serverlosen Funktionen am besten absichern können, sollten die Einführung einer CNAPP in Betracht ziehen.

Microservices FAQs