Quarkus Kochbuch

Kapitel 1. Quarkus Überblick

Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: [e-mail]

Kubernetes entwickelt sich immer mehr zur De-facto-Plattform für die Bereitstellung von Unternehmensanwendungen. Der Wechsel zu Containern und Kubernetes hat dazu geführt, dass sich die Art und Weise, wie wir unsere Java-basierten Anwendungen programmieren, bereitstellen und warten, verändert hat. Du kannst dich leicht in Schwierigkeiten bringen, wenn du eine Java-Anwendung ohne die richtigen Maßnahmen containerisierst und ausführst. Container in Pods (ein Kubernetes-Begriff) sind die grundlegenden Einheiten in Kubernetes. Deshalb ist es sehr wichtig, dass du weißt, wie du eine Java-Anwendung richtig containerisierst, um Fallstricke, vergeudete Arbeit und zusätzliche Stunden Frustration zu vermeiden.

Quarkus ist ein Cloud-natives Framework mit integrierter Kubernetes-Integration. Es ist ein Open-Source-Stack, der unter der Apache License 2.0 veröffentlicht wurde und dir hilft, Kubernetes-native Anwendungen zu erstellen, die auf GraalVM und OpenJDK HotSpot zugeschnitten sind. Es basiert auf beliebten Bibliotheken und Technologien wie Hibernate, Eclipse MicroProfile, Kubernetes, Apache Camel und Eclipse Vert.x.

Zu den Vorteilen von Quarkus gehören die einfache Integration mit Docker und Kubernetes, die schnelle Startzeit, die geringe Größe des Resident Set Memory (RSS) und die gesteigerte Produktivität der Entwickler. In diesem Einführungskapitel werfen wir einen kurzen Blick auf Quarkus - was es ist, welche Probleme es löst, wie es sich in Kubernetes integriert, warum Entwickler gerne damit arbeiten und einige seiner bemerkenswertesten Funktionen.

Entwicklerfreundliches

Quarkus ermöglicht es dir, als Java-Entwickler produktiver zu sein, und hilft dir, in dem schnelllebigen Bereich der Microservices und Cloud-basierten Anwendungen relevant zu bleiben.

Quarkus ermöglicht es deinen Anwendungen, besser zu skalieren, einen Kubernetes-Cluster mit insgesamt weniger Ressourcen auszufüllen und die jahrzehntelange Arbeit der Open-Source-Java-Community zu nutzen.

Um mit Quarkus zu entwickeln, musst du keine neue Technologie erlernen. Wenn du bereits mit Dependency Injection, JAX-RS, Hibernate und Eclipse MicroProfile Konzepten vertraut bist, gibt es hier nichts Neues. All das Wissen, das du im Laufe deiner Karriere aufgebaut hast, lässt sich direkt in Quarkus abbilden. Während es Wochen dauern kann, andere Frameworks zu erlernen, kannst du mit Quarkus in wenigen Tagen oder sogar Stunden produktiv sein.

Quarkus wurde als optimierte Lösung für die nächste Generation der Anwendungsentwicklung und -bereitstellung entwickelt. Es unterstützt dich durch den gesamten Lebenszyklus einer Anwendung, vom Anwendungsgerüst über das Live-Reloading im Dev-Modus (ein Save-and-Refresh-Workflow) bis hin zum Deployment in einem Cloud-basierten Kubernetes-Cluster. Mit Quarkus bleibst duals Entwickler produktiv und löst Probleme, stattdich mit dem Rasieren von Yaks zubeschäftigen.

Integration mit Kubernetes

Wir haben gesagt, dass Quarkus für den Betrieb in Kubernetes gedacht ist. Das klingt toll, aber wir wissen, dass viele Dinge in Kubernetes laufen können. Schmeiß deine Anwendung in einen Docker-Container und sie läuft in Kubernetes. Das stimmt zwar, aber es gibt eine Reihe von Dingen, die traditionell getan werden müssen, um deine Anwendung richtig abzustimmen, zu vergrößern und zu konfigurieren, damit sie effizient in Kubernetes läuft. Außerdem musst du deinen Texteditor herausholen und mehrere YAML-Dateien erstellen - und seien wir ehrlich, das macht niemandem wirklich Spaß.

Quarkus macht diese Arbeit überflüssig, indem es eine Reihe von Verbesserungen für das Deployment in und die Nutzung von Kubernetes mit deiner Anwendung bietet. Wenn du eine Quarkus-Anwendung bootest, wird sie mit einigen Dockerfile-Dateien geliefert, mit denen die Docker-Container für deine Anwendung generiert werden. Das ist ein großartiger erster Schritt. Diese Dateien sind für die Ausführung mit der OpenJDK JVM oder für die Ausführung als native ausführbare Dateien mit GraalVM optimiert. Sie enthalten nur das, was für die Ausführung der Anwendung notwendig ist, und eliminieren so viel Duplikation und unnötigen Ballast aus dem Container-Image wie möglich.

Wenn du die Kubernetes-Erweiterungen verwendest, kann Quarkus die Ressourcen (YAML-Dateien) für ein Kubernetes- oder OpenShift-Deployment generieren! Du musst dich nicht mehr durch YAML-Dateien wühlen und sicherstellen, dass du die richtige Einrückung hast. Schließlich schreibst du lieber Code, als nach der einen YAML-Zeile zu suchen, die nicht richtig formatiert ist. Quarkus kann dein Image auch in eine Registry übertragen, bevor es in den Kubernetes-Cluster deployt wird. Alle diese Anwendungsimages können über die Quarkus Anwendungskonfiguration, die du in Kapitel 4 kennen lernst, weiter verbessert und angepasst werden. In Quarkus 1.4 und höher können beispielsweise ConfigMap und Secretvom API-Server gelesen werden - du musst keine der Dateien im Pod einhängen!

Speicher und erste Reaktionszeit

Quarkus ist als das "überschallschnelle, subatomare" Java-Framework bekannt. Das mag bei Entwicklern einen Marketing-Alarm auslösen, aber wenn du es herunterbrichst und verstehst, was Quarkus tut, wirst du sehen, dass du wirklich eine sehr kleine, schnelle und produktive Ausführung bekommst. Mit Quarkus kannst du eine native Anwendung bereitstellen, die für die Ausführung in Kubernetes optimiert ist. Angenommen, du möchtest eine native Anwendung bereitstellen, die für den Betrieb in Kubernetes optimiert ist und deren Container-Image 200 MB oder weniger groß ist. In Quarkus wird diese Anwendung innerhalb eines Sekundenbruchteils gestartet und ist bereit, Anfragen anzunehmen, und sie benötigt weniger als 50 MB Speicher.

Beim Deployment in einen Kubernetes-Cluster möchtest du so viele Instanzen deiner Anwendung wie möglich einbinden, damit du in der Lage bist, unerwartete Last zu bewältigen und trotzdem so viele Ressourcen wie möglich zu nutzen. Beim Skalieren möchtest du, dass deine neuen Anwendungsinstanzen schnell einsatzbereit sind - hier kommt eine native ausführbare Datei ins Spiel. Quarkus bereitet deine Anwendung und die von ihr genutzten Frameworks während des Build-Prozesses der nativen ausführbaren Datei so weit wie möglich vor. So kann deine Anwendung schnell starten und ist bereit, Anfragen zu bedienen, ohne dass zusätzliche Klassen geladen, Laufzeit-Scans durchgeführt oder andere Aufwärmarbeiten durchgeführt werden müssen, die normalerweise von der JVM erledigt werden.

Natürlich ist der verfügbare Speicher eine begrenzte Ressource. Der Schlüssel zur Bereitstellungsdichte liegt darin, genau zu wissen, wie viel Speicher von deiner Anwendung verwendet wird, und die JVM nicht auszuhungern, während du versuchst, diese Zahl niedrig zu halten. Quarkus hilft dir dabei mit der nativen ausführbaren Datei, die klein und speichereffizient ist.

Ein grundlegender Quarkus Workflow

Während du dieses Buch liest und die Rezepte durcharbeitest, wirst du in das Quarkus-Ökosystem eingeführt. Du lernst etwas über Erweiterungen, Integrationen und Designentscheidungen. Du wirst auch den grundlegenden Arbeitsablauf sehen, der dir hilft, produktiv zu sein. Kurz gesagt, sieht dieser Arbeitsablauf folgendermaßen aus:

1. Gerüst

2. Entwicklungsmodus starten

3. Code

4. Test

5. Paket

6. Bereitstellen

Durch das Scaffolding deiner Anwendung oder das Hinzufügen einer Erweiterung zu einer bestehenden Anwendung erhältst du eine solide Grundlage, auf der du aufbauen kannst. Damit wirst du in Kapitel 2 vertraut gemacht. Nach dem Scaffolding wirst du aufgefordert, deine Anwendung im Dev-Mode auszuführen, der ebenfalls in Kapitel 2 vorgestellt wird. Du lernst dann typische Aufgaben für eine Anwendung kennen: die Erstellung von RESTful Services, die Vervollständigung des grundlegenden Programmiermodells und die Anwendungskonfiguration. Im Entwicklungsmodus erhältst du nahezu sofortiges Feedback, ohne die lästige Prozedur des Kompilierens, Verpackens und Bereitstellens, mit der du bereits vertraut bist. In Kapitel 5 erfährst du, wie du eine Quarkus-Anwendung testest, die sowohl auf die JVM als auch auf die native ausführbare Datei abzielt. Das Erstellen der endgültigen Anwendung wird in Kapitel 6 behandelt, ebenso wie das Verpacken deiner Anwendung für deine spezielle Deployment-Strategie. Der letzte Teil des Workflows, das Deployment, wird in Kapitel 10 behandelt. Im weiteren Verlauf erfährst du, wie du deine Anwendung fehlerresistenter machen kannst, wie du mit verschiedenen Persistenz-Engines interagierst und wie du mit externen Diensten kommunizierst. Wir erklären dir auch zusätzliche Integrationen, die dir helfen, vorhandenes Wissen aus anderen Bibliotheken und Programmierparadigmen zu nutzen. Wir führen dich durch die Einrichtungder Kubernetes-Optimierungen, die für deine Anwendung notwendig sind, bauenKubernetes-Ressourcen auf und schalten alles live.