Spring auf Kubernetes mit Red Hat OpenShift

Mit Red Hat® OpenShift® können Sie Kubernetes-native Spring- und Spring Boot-Anwendungen entwickeln und ausführen.

Das Spring-Framework ist eines der beliebtesten Java-Frameworks, um Anwendungen basierend auf einer Architektur für verteilte Microservices zu entwickeln. Das Programmierungs- und Konfigurationsmodell von Spring für Java-basierte Anwendungen ist auf das sogenannte „Plumbing“ ausgerichtet, damit sich Entwicklerinnen und Entwickler auf die Geschäftslogik der Anwendungsebene konzentrieren können – ohne überflüssige Bindung an bestimmte Deployment-Umgebungen. Spring Boot ermöglicht dann die einfache Paketierung und Konfiguration der Anwendung in eine eigenständige, ausführbare Anwendung, die mühelos als Container in Kubernetes bereitgestellt werden kann.

Kubernetes-natives Spring-Framework

Genau wie viele andere herkömmliche Java-Frameworks „weiß“ Spring nicht automatisch, dass es in einem Container auf einer Plattform wie Kubernetes ausgeführt wird. Das Spring-Framework enthält viele Komponenten wie Spring Boot, Spring Cloud oder Spring Web, die die Entwicklung und das Deployment verteilter Anwendungen erleichtern. Darüber hinaus gibt es zahlreiche weitere Komponenten für Service Discovery, Load Balancing, Anfrage-Routing und mehr. Mit Kubernetes können viele dieser Aufgaben an die zugrunde liegende Container-Plattform weitergeleitet werden, um eine Anwendung zu entwickeln, die sich effizienter in die Plattform integriert, auf der sie ausgeführt wird. Die Entwicklung von Spring-Apps mit diesen optimierten Codepfaden spielt eine entscheidende Rolle für die optimale Nutzung von Spring und Kubernetes.

Spring-Apps können sich auf Kubernetes und die dort verfügbaren Funktionen verlassen, wenn es um die Bereitstellung der erforderlichen Cloud-Services für eine effiziente Entwicklung auf Kubernetes geht. Hierzu zählen u. a. Services wie Nachrichtenwarteschlangen, Datenbanken, persistenter Storage und Caching.

Service-Registry

Microservice-Architekturen implizieren häufig die dynamische Skalierung einzelner Services in einer Private, Hybrid oder Public Cloud, in der Anzahl und Adresse von Hosts nicht immer vorhergesagt oder im Voraus statisch konfiguriert werden können. In Kubernetes ist die Replikation und Skalierung von Services eine zentrale Funktion. Dies bedeutet, dass der Kunde keinen Cache anlegen muss und nicht für die Fehler der Service-Registry verantwortlich ist. Netflix Ribbon (wird häufig mit Spring-Apps verwendet) etwa kann deklarativ konfiguriert werden, damit Kubernetes anstelle einer Service-Registry verwendet wird. Der Code muss dabei nicht verändert werden.

Load Balancing

Bei Client-Aufrufen zu zustandslosen Services in Spring-Apps führt Hochverfügbarkeit zu der Erfordernis, den Service in einer Service-Registry zu suchen und die Last auf die verfügbaren Instanzen zu verteilen. Kubernetes stellt eine einzelne Serviceadresse bereit, an der die Last von Aufrufen verteilt und an die passende Instanz weitergeleitet wird. In einem Kubernetes-Cluster wird der Servicename zu dieser Cluster-IP-Adresse aufgelöst und kann verwendet werden, um den Load Balancer zu erreichen. Für externe Aufrufe oder wenn die Weiterleitung über den Router nicht gewünscht wird, kann für den Service eine externe IP-Adresse konfiguriert werden.

Fehlertoleranz

Die besonders hohe Verteilung bei Microservices sorgt für ein höheres Fehlerrisiko bei einem Remote-Aufruf, da die Anzahl solcher Remote-Aufrufe steigt. Bislang fiel die Bürde der Implementierung von Fehlertoleranzmustern (wie ein Schutzschalter) in die Verantwortung des Entwicklungsteams. Projekte wie Istio, in denen ein Service Mesh implementiert wird, können diese Bürde jedoch lindern. Sie bieten eine erheblich größere operative Kontrolle über Spring-Services, die im Cluster ausgeführt werden.

Externalisierte Konfiguration

Managementlösungen für externalisierte Konfiguration können eine elegante Alternative zur klassischen Kombination aus Konfigurationsdateien, Befehlszeilenargumenten und Umgebungsvariablen darstellen. Sie werden verwendet, um Anwendungen portierbarer und bei der Reaktion auf externe Änderungen weniger starr zu machen. Kubernetes ConfigMaps kann verwendet werden, um detaillierte Informationen wie einzelne Eigenschaften oder weniger detaillierte Informationen wie vollständige Konfigurationsdateien oder JSON-Blobs zu speichern. Sie bieten Mechanismen für das Hinzufügen von Konfigurationsdaten zu Containern. Dadurch wird die Konfiguration getrennt von den Spring-Apps gespeichert. Diese können aber trotzdem mit Annotationen wie @ConfigProperty auf die Konfiguration zugreifen.

Verteiltes Tracing und Anwendungsmesswerte

Trotz aller Vorteile lässt sich eine Microservice-Architektur manchmal nur schwer analysieren. Dasselbe gilt für die Fehlerbehebung. Jede Geschäftsanfrage führt auf verschiedenen zu mehreren Aufrufen einzelner Services bzw. zwischen einzelnen Services auf verschiedenen Ebenen. Durch das verteilte Tracing werden alle einzelnen Service-Aufrufe miteinander verbunden und über eine eindeutige, generierte ID mit einer Geschäftsanfrage verknüpft. Darüber hinaus können Spring-Apps mithilfe von Messwerten Daten auf Anwendungsebene zeigen, um eine detaillierte Überprüfung des Zustands einer Anwendung zu ermöglichen. Tracing-Tools wie Jaeger stellen in Kombination mit einem Messwert-Stack sowie Prometheus und Grafana eine solide Basis für das Monitoring und die Fehlerbehebung von Spring-Apps in Kubernetes bereit.

Während sich Spring-Anwendungen zu Sammlungen dezentralisierter Services entwickeln, wird das Management der Kommunikation und Sicherheitsanforderungen zwischen den Services schwieriger. Red Hat OpenShift bietet Spring-Entwicklungsteams in Kombination mit Red Hat Runtimes die Tools, Frameworks und nativen Kubernetes-Integrationen, die für die Entwicklung und das Management von Spring-Anwendungen in großem Umfang auf der branchenführenden Container- und Kubernetes-Plattform für die Hybrid Cloud benötigt werden.

Es gibt zahlreiche Vorteile für Spring-Entwicklungsteams, die Red Hat OpenShift verwenden. Dazu zählen:

Die Nutzung von Spring Boot unter OpenShift sorgt für ein natürliches „Spring Boot on Kubernetes“-Entwicklererlebnis. Das gilt sowohl für vorhandene als auch für neue Spring-Apps.

• Unterstützung für die Entwicklung cloudnativer Anwendungen mit Spring und Spring Boot
• Integration von Kubernetes-Funktionen, die herkömmliche Standalone-Sicherungs-Services ersetzen
  • Externalisierte Konfiguration: Kubernetes ConfigMap und Integration mit Spring Cloud Kubernetes
  • Service Discovery: Kubernetes-Services
  • Load Balancing: Kubernetes Replication Controller
  • Auto-Restart: Kubernetes Health Probes und Integration mit Spring Actuator
  • Messwerte: Prometheus, Grafana und Integration mit Spring Cloud Sleuth
  • Verteiltes Tracing mit Istio und Jaeger Tracing
• Entwicklungstools über Red Hat OpenShift für schnelles Scaffolding neuer Spring-Projekte, Zugriff auf bekannte Spring APIs in Ihrer bevorzugten IDE und Bereitstellung in Red Hat OpenShift

Verwenden Sie bekannte Spring APIs und nutzen Sie die Vorteile der zugrunde liegenden Kubernetes-Plattform und -Services in Red Hat OpenShift und Red Hat Application Services.

• Red Hat Build von OpenJDK optimiert für die Ausführung von Java-Apps in einer Container-Umgebung
• Kubernetes-native Services über Red Hat Application Services, die u. a. in Spring Cloud Kubernetes, Spring Security (mit Red Hat SSO), Spring Caching (mit Red Hat Data Grid), Spring Messaging (mit Red Hat AMQ), Spring Web und Spring Data integriert werden können
• Implementierung allgemeiner Integrationsmuster für Unternehmen in Ihren Anwendungs-Services mit Spring Boot und Red Hat Fuse (basierend auf Apache Camel)

Nutzen Sie Spring-Kenntnisse, um moderne Apps mithilfe innovativer Technologie zu entwickeln.

• Serverless-Spring Apps mit Camel-K und Kafka
• Verwenden Sie bekannte Spring APIs, um containernative Java-Apps mit Quarkus zu entwickeln
• Native Kubernetes-Geschäftsprozesse mit Kogito
• Verwenden Sie Kubernetes Operators, um eine natürliche Möglichkeit für die Entwicklung und Verknüpfung von Spring-Apps mit nativen Kubernetes APIs über Halkyon bereitzustellen