Beginnen Sie mit serverlosen Java-Funktionen
Mit Quarkus können Sie serverlose Workloads mit vertrauter Java-Technologie entwickeln.
Die serverlose Java-Reise begann mit Funktionen – kleinen Codeausschnitten, die bei Bedarf ausgeführt werden. Diese Phase dauerte nicht lange. Obwohl Funktionen, die auf der Architektur virtueller Maschinen basierten, dieses Paradigma in der 1.0-Phase sehr populär machten, wie die Grafik unten zeigt, gab es Einschränkungen hinsichtlich der Ausführungszeit, der Protokolle und einer schlechten Erfahrung bei der lokalen Entwicklung.
Die Entwickler erkannten dann, dass sie dieselben serverlosen Merkmale und Vorteile auf Microservices und Linux-Container anwenden konnten. Damit wurde die 1.5-Phase gestartet, in der einige serverlose Container Kubernetes vollständig abstrahierten und das serverlose Erlebnis über Knative oder eine andere darüber liegende Abstraktionsschicht bereitstellten.
In der 2.0-Phase beginnt Serverless mit der Handhabung komplexerer Orchestrierungs- und Integrationsmuster in Kombination mit einem gewissen Maß an Statusverwaltung. Noch wichtiger ist, dass Entwickler weiterhin eine bekannte Anwendungslaufzeit, Java, verwenden möchten, um eine Kombination aus serverlosen und nicht serverlosen Workloads in Legacy-Systemen auszuführen.
(Daniel Oh, CC BY-SA 4.0)
Bevor Java-Entwickler mit der Entwicklung neuer serverloser Funktionen beginnen können, besteht ihre erste Aufgabe darin, ein neues Cloud-natives Java-Framework auszuwählen, das es ihnen ermöglicht, Java-Funktionen schneller und mit geringerem Speicherbedarf als herkömmliche monolithische Anwendungen auszuführen. Dies kann auf verschiedene Infrastrukturumgebungen angewendet werden, von physischen Servern über virtuelle Maschinen bis hin zu Containern in Multi- und Hybrid-Cloud-Umgebungen.
Entwickler könnten ein eigenständiges Spring-Framework in Betracht ziehen, das das java.util.function
-Paket in Spring Cloud Function verwendet, um die Entwicklung imperativer und reaktiver Funktionen zu unterstützen. Spring ermöglicht Entwicklern auch die Bereitstellung von Java-Funktionen auf installierbaren serverlosen Plattformen wie Kubeless, Apache OpenWhisk, Fission und Project Riff. Es gibt jedoch Bedenken hinsichtlich langsamer Start- und Reaktionszeiten und speicherintensiver Prozesse bei Spring. Dieses Problem kann schlimmer sein, wenn Java-Funktionen in skalierbaren Containerumgebungen wie Kubernetes ausgeführt werden.
Quarkus ist ein neues Open-Source-Cloud-natives Java-Framework, das zur Lösung dieser Probleme beitragen kann. Ziel ist es, serverlose Anwendungen zu entwerfen und Cloud-native Microservices für die Ausführung auf Cloud-Infrastrukturen (z. B. Kubernetes) zu schreiben.
Quarkus überdenkt Java neu und verwendet einen Closed-World-Ansatz für die Erstellung und Ausführung von Java. Es hat Java zu einer Laufzeitumgebung gemacht, die mit Go vergleichbar ist. Quarkus umfasst außerdem mehr als 100 Erweiterungen, die Unternehmensfunktionen integrieren, darunter Datenbankzugriff, serverlose Integration, Messaging, Sicherheit, Beobachtbarkeit und Geschäftsautomatisierung.
Hier ist ein kurzes Beispiel dafür, wie Entwickler mit Quarkus ein serverloses Java-Funktionsprojekt aufbauen können.
1. Erstellen Sie ein serverloses Maven-Projekt von Quarkus
Entwickler haben mehrere Möglichkeiten, einen lokalen Kubernetes-Cluster zu installieren, einschließlich Minikube und OKD (OpenShift Kubernetes Distribution). In diesem Tutorial wird ein OKD-Cluster für die lokale Umgebung eines Entwicklers verwendet, da die serverlose Funktionalität auf Knative- und DevOps-Tools einfach einzurichten ist. Diese Anleitungen für die OKD-Installation und die Knative-Operator-Installation bieten weitere Informationen zu deren Einrichtung.
Der folgende Befehl generiert ein Quarkus-Projekt (z. B. quarkus-serverless-restapi
), um eine einfache REST-API bereitzustellen und eine quarkus-openshift
-Erweiterung für die Bereitstellung von Knative-Diensten herunterzuladen:
$ mvn io.quarkus:quarkus-maven-plugin:1.13.4.Final:create \
-DprojectGroupId=org.acme \
-DprojectArtifactId=quarkus-serverless-restapi \
-Dextensions="openshift" \
-DclassName="org.acme.getting.started.GreetingResource"
2. Führen Sie serverlose Funktionen lokal aus
Führen Sie die Anwendung im Quarkus-Entwicklungsmodus aus, um zu prüfen, ob die REST-API funktioniert, und optimieren Sie dann den Code ein wenig:
$ ./mvnw quarkus:dev
Die Ausgabe sieht folgendermaßen aus:
__ ____ __ _____ ___ __ ____ ______
--/ __ \/ / / / _ | / _ \/ //_/ / / / __/
-/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
INFO [io.quarkus] (Quarkus Main Thread) quarkus-serverless-restapi 1.0.0-SNAPSHOT on JVM (powered by Quarkus xx.xx.xx.) started in 2.386s. Listening on: http://localhost:8080
INFO [io.quarkus] (Quarkus Main Thread) Profile dev activated. Live Coding activated.
INFO [io.quarkus] (Quarkus Main Thread) Installed features: [cdi, kubernetes, resteasy]
Hinweis: Lassen Sie Ihre Quarkus-Anwendung laufen, um Live Coding zu verwenden. Dadurch können Sie vermeiden, dass Sie die Anwendung jedes Mal neu erstellen, erneut bereitstellen und die Laufzeit neu starten müssen, wenn sich der Code ändert.
Jetzt können Sie mit einem schnellen curl
-Befehl auf die REST-API zugreifen. Die Ausgabe sollte Hello RESTEasy
sein:
$ curl localhost:8080/hello
Hello RESTEasy
Passen Sie den Rückgabetext in GreetingResource.java
an:
public String hello() {
return "Quarkus Function on Kubernetes";
}
Wenn Sie die REST-API erneut aufrufen, wird eine neue Ausgabe angezeigt:
$ curl localhost:8080/hello
Quarkus Function on Kubernetes
Es gibt keinen großen Unterschied zwischen normalen Microservices und serverlosen Funktionen. Ein Vorteil von Quarkus besteht darin, dass es Entwicklern ermöglicht, jeden Microservice zu nutzen, um Kubernetes als serverlose Funktion bereitzustellen.
3. Stellen Sie die Funktionen für einen Knative-Dienst bereit
Wenn Sie dies noch nicht getan haben, erstellen Sie einen Namespace (z. B. quarkus-serverless-restapi
) auf Ihrem OKD-Cluster (Kubernetes), um diese serverlose Java-Funktion bereitzustellen.
Mit Quarkus können Entwickler Knative- und Kubernetes-Ressourcen generieren, indem sie die folgenden Variablen in src/main/resources/application.properties
hinzufügen:
quarkus.container-image.group=quarkus-serverless-restapi <1>
quarkus.container-image.registry=image-registry.openshift-image-registry.svc:5000 <2>
quarkus.kubernetes-client.trust-certs=true <3>
quarkus.kubernetes.deployment-target=knative <4>
quarkus.kubernetes.deploy=true <5>
quarkus.openshift.build-strategy=docker <6>
Legende:
<1> Definieren Sie einen Projektnamen, in dem Sie eine serverlose Anwendung bereitstellen
<2> Die zu verwendende Container-Registrierung
<3> Verwenden Sie in diesem einfachen Beispiel selbstsignierte Zertifikate, um ihnen zu vertrauen
<4> Aktivieren Sie die Generierung von Knative-Ressourcen
<5> Weisen Sie die Erweiterung an, sie auf OpenShift bereitzustellen, nachdem das Container-Image erstellt wurde
<6> Legen Sie die Docker-Build-Strategie fest
Dieser Befehl erstellt die Anwendung und stellt sie dann direkt im OKD-Cluster bereit:
$ ./mvnw clean package -DskipTests
Hinweis: Stellen Sie sicher, dass Sie sich vorab mit dem Befehl
oc login
beim richtigen Projekt anmelden (z. B.quarkus-serverless-restapi
). .
Die Ausgabe sollte mit BUILD SUCCESS
enden.
Fügen Sie mit diesem oc
-Befehl ein Quarkus-Label zum Knative-Dienst hinzu:
$ oc label rev/quarkus-serverless-restapi-00001
app.openshift.io/runtime=quarkus --overwrite
Greifen Sie dann auf die OKD-Webkonsole zu, um in der Entwicklerperspektive zur Topologieansicht zu gelangen. Möglicherweise sehen Sie, dass Ihr Pod (serverlose Funktion) bereits auf Null herunterskaliert ist (Kreis mit weißer Linie).
(Daniel Oh, CC BY-SA 4.0)
4. Testen Sie die Funktionen auf Kubernetes
Rufen Sie eine Routen-URL
der serverlosen Funktion ab, indem Sie den folgenden oc
-Befehl ausführen:
$ oc get rt/quarkus-serverless-restapi
[...]
NAME URL READY REASON
quarkus-serverless[...] http://quarkus[...].SUBDOMAIN True
Greifen Sie mit einem curl
-Befehl auf die Route URL
zu:
$ curl http://quarkus-serverless-restapi-quarkus-serverless-restapi.SUBDOMAIN/hello
In wenigen Sekunden erhalten Sie das gleiche Ergebnis wie vor Ort:
Quarkus Function on Kubernetes
Wenn Sie zur Topologieansicht im OKD-Cluster zurückkehren, wird der Knative-Dienst automatisch hochskaliert.
(Daniel Oh, CC BY-SA 4.0)
Dieser Knative-Service-Pod wird aufgrund der Standardeinstellung von Knative Serving in 30 Sekunden wieder auf Null sinken.
Was kommt als nächstes?
Die serverlose Reise hat sich weiterentwickelt, angefangen bei Funktionen auf virtuellen Maschinen bis hin zu serverlosen Containern und der Integration mit älteren Unternehmenssystemen. Auf diesem Weg können Unternehmensentwickler weiterhin bekannte Technologien wie Java für die Entwicklung serverloser Funktionen nutzen, indem sie mit Quarkus ein Projekt erstellen und es dann mit einem Knative-Dienst erstellen und auf Kubernetes bereitstellen.
Der nächste Artikel dieser Reihe führt Sie durch die Optimierung serverloser Java-Funktionen in Kubernetes für schnellere Startzeiten und geringeren Speicherbedarf im großen Maßstab.