Die Entwicklung von Diensten in Java, einschließlich REST-APIs, war nicht immer einfach oder produktiv, bis der Frühling kam und die Landschaft veränderte. Seitdem sind viele Jahre vergangen, und in der Gemeinschaft sind neue Rahmenbedingungen entstanden.

Eines dieser Frameworks war Micronaut. Es wurde von OCI entwickelt, der gleichen Firma hinter Grails, und ihr Ziel ist es, Entwicklern bei der Erstellung von Microservices und serverlosen Anwendungen zu helfen.

Es gibt auch Quarkus, ein weiteres Framework, das im letzten Jahr an Popularität gewonnen hat. Quarkus wurde von RedHat entwickelt und verspricht einen schnellen Start und weniger Speicherverbrauch, zwei häufige Probleme bei der Entwicklung von REST-Diensten in Java.

Bei all diesen Möglichkeiten gibt es eine sehr wichtige Frage zu stellen: Wie einfach ist es, mit jedem dieser drei Frameworks einen Service zu erstellen?

In diesem Tutorial erstellen Sie eine sichere REST-Anwendung mit Spring, Micronaut und Quarkus, um zu sehen, wie sie sich voneinander unterscheiden und welche Ihren Anforderungen am besten entspricht.

Inhaltsverzeichnis

• Voraussetzungen für Ihre Java REST API
  • Erstellen Sie ein Okta-Konto für die Benutzerverwaltung
  • Generieren Sie Token mit OpenID Connect Debugger
• Erstellen Sie eine Java REST API mit Micronaut
  • Entwickeln Sie Ihren Java-Dienst
• Erstellen Sie eine Java REST API mit Quarkus
• Spring Boot
• Abschließende Gedanken zu REST-APIs mit Java: Micronaut, Quarkus und Spring Boot

Wenn Sie möchten, können Sie sich dieses Tutorial als Screencast ansehen. 👇

Voraussetzungen für Ihre Java REST API

Dieses Tutorial verwendet Maven 3+. Stellen Sie sicher, dass es installiert und verfügbar ist, bevor Sie fortfahren. Sie können sicherlich auch Gradle verwenden, aber YMMV .

Sie werden Apps erstellen, die Anfragen mit OAuth 2.0 authentifizieren, gesichert durch eine Okta-Anwendung. Sie haben noch kein Okta-Konto? Keine Sorge, es dauert weniger als eine Minute, um ein neues zu erstellen. Darüber hinaus unterstützt Okta Standards wie JWT, OAuth 2.0 und OIDC. Wir bieten Unterstützung für bekannte Frameworks wie Java EE, Spring Boot und Spring Security. Heck, wir haben sogar ein Maven-Plugin, das alles für Sie automatisiert.

Das Rad muss nicht neu erfunden werden!

Erstellen Sie ein Okta-Konto für die Benutzerverwaltung

Öffnen Sie Ihr Terminal und führen Sie den folgenden Befehl aus:

mvn com.okta:okta-maven-plugin:register

Sie werden aufgefordert, die folgenden Informationen einzugeben:

• Vorname
• Nachname
• E-Mail
• Firma

Sobald Sie die Fragen beantwortet haben, erhalten Sie eine E-Mail, um Ihr brandneues Konto zu aktivieren. Führen Sie nach der Aktivierung Ihres Kontos den folgenden Befehl aus:

mvn com.okta:okta-maven-plugin:spring-boot

Dieser Befehl erstellt für Sie eine Anwendung mit auth Code Flow und Spring Security’s redirect URI für Okta.

Um sich besser daran zu erinnern, können Sie dieselbe App manuell erstellen:

• Gehen Sie auf die Entwickler-Homepage von Okta und melden Sie sich bei Ihrem Konto an.
• Klicken Sie auf Anwendungen > Anwendung hinzufügen > Web > Weiter.

Sie sehen den folgenden Bildschirm:

Bevor Sie fortfahren, nehmen Sie die folgenden Änderungen in der Anwendung vor:

• Login redirect URIs:
  • http://localhost:8080/login/oauth2/code/okta
  • https://oidcdebugger.com/debug
• Gewährungstyp erlaubt
  • Autorisierungscode
  • Implizit (Hybrid)

Der implizite Gewährungstyp (mit ID und Zugriffstoken erlaubt aktiviert) ist notwendig, um ein Zugriffstoken in Ihrem Browser abzurufen.

Die oben nicht genannten Felder können ihre Standardwerte beibehalten.

Wenn Sie fertig sind, klicken Sie auf Fertig. Ihre App ist fertig!

Der nächste Schritt besteht darin, zu lernen, wie man damit ein gültiges Token generiert.

Token mit OpenID Connect Debugger generieren

Okta ermöglicht es Ihnen, Ihre Benutzer in der Cloud mithilfe seiner APIs zu verwalten. Außerdem können Sie Ihre Anwendungen mit OAuth 2.0 und OpenID Connect (auch bekannt als OIDC) sichern. OAuth 2.0 bietet einen Mechanismus für die delegierte Autorisierung, sodass Sie keine Benutzeranmeldeinformationen in Ihrer Anwendung speichern müssen. Stattdessen können Sie dies an einen OAuth 2.0-Anbieter (in diesem Fall Okta) delegieren. OIDC bietet eine Identitätsschicht auf OAuth 2.0 und deshalb werden Unternehmen wie Okta als „Identitätsanbieter“ oder IDPs bezeichnet.

Sie haben Ihre App bei Okta registriert und können nun ein Token generieren, um Zugriff darauf zu erhalten. Eine der von Ihnen registrierten Login-Redirect-URIs ist für die OpenID Connect-Website.

Ihre Anfragen werden mit einem Token validiert. Um dieses Token zu generieren, verwenden Sie den OpenID Connect Debugger. Diese Website bietet Ihnen eine einfache Möglichkeit, Anmeldeinformationen für die Benutzer Ihrer Okta-Anwendung zu generieren.

Gehen Sie zum https://oidcdebugger.com und geben Sie die folgenden Informationen ein:

• Autorisieren URI: https://{yourOktaDomain}/oauth2/default/v1/authorize
• URI umleiten: https://oidcdebugger.com/debug
• Client ID: {yourOktaClientId}
• Umfang: openid email profile
• Zustand: dev
• Nonce: (halten die standard wert)
• Antworttyp: token

Sie finden den Wert für {yourOktaDomain} in der rechten oberen Ecke der Startseite Ihres Kontos:

Um Ihre Okta-Client-ID zu finden, folgen Sie den Schritten unten:

• Gehen Sie zu Anwendungen
• Wählen Sie Meine Web-App
• Klicken Sie auf Allgemein

Die Client-ID ist im Abschnitt Client-Anmeldeinformationen verfügbar:

Nachdem Sie alle Felder ausgefüllt haben, klicken Sie auf Anfrage senden. Sie werden auf Ihre Okta-Anmeldeseite weitergeleitet.

Sobald Sie sich erfolgreich authentifiziert haben, werden Sie erneut zum OIDC-Debugger weitergeleitet, wo Sie das generierte Token sehen können:

Sie verwenden dieses Token, um sicher auf die Dienste zuzugreifen, die Sie erstellen möchten.

Nachdem Sie nun ein Okta-Konto haben und wissen, wie Sie mit Ihrer Okta-Anwendung Token generieren, beginnen wir mit dem Vergleich der Frameworks!

Erstellen Sie eine Java REST API mit Micronaut

Der erste Schritt zur Entwicklung Ihres Micronaut Service ist der Download von SDKMAN!. SDKMAN! ist ein Tool zum Verwalten paralleler Versionen mehrerer SDKs, mit dem Sie den Micronaut-Client installieren.

Sie können SDKMAN herunterladen! indem Sie den folgenden Befehl ausführen:

curl -s https://get.sdkman.io | bash

Jetzt können Sie Micronaut selbst installieren. Führen Sie einfach den folgenden Befehl im Terminal aus:

sdk install micronaut

Nachdem der Befehl ausgeführt wurde, ist die neueste Micronaut-Version auf Ihrem Computer verfügbar.

Sie können mit der Entwicklung der Anwendung beginnen!

Entwickeln Sie Ihren Java-Dienst

Gehen Sie in das Verzeichnis, in dem Sie Ihre Anwendung erstellen möchten, und führen Sie den folgenden Befehl aus:

mn create-app com.okta.rest.app --build maven

Mit diesem Befehl wird ein Projekt mit der Grundstruktur eines Micronaut-Projekts erstellt. Micronaut verwendet standardmäßig Gradle, aber da Sie --build maven verwenden, wird stattdessen Maven verwendet.

Der nächste Schritt besteht darin, die Sicherheitsbibliotheken innerhalb des Projekts hinzuzufügen. Bearbeiten Sie die Datei pom.xml und fügen Sie die folgenden Abhängigkeiten hinzu:

<dependency> <groupId>io.micronaut</groupId> <artifactId>micronaut-security</artifactId></dependency><dependency> <groupId>io.micronaut</groupId> <artifactId>micronaut-security-jwt</artifactId></dependency>

Diese Abhängigkeiten aktivieren die Sicherheit – insbesondere OAuth 2.0 mit JWT – in Ihrem Projekt. Nachdem Sie alle Abhängigkeiten eingerichtet haben, können Sie mit der Erstellung Ihres Endpunkts beginnen.

Erstellen Sie die folgende Klasse in src/main/java/com/okta/rest/controller:

package com.okta.rest.controller;import io.micronaut.http.MediaType;import io.micronaut.http.annotation.Controller;import io.micronaut.http.annotation.Get;import io.micronaut.http.annotation.Produces;import io.micronaut.security.annotation.Secured;import io.micronaut.security.rules.SecurityRule;import java.security.Principal;@Controller("/hello")public class HelloController { @Get @Secured(SecurityRule.IS_AUTHENTICATED) @Produces(MediaType.TEXT_PLAIN) public String hello(Principal principal) { return "Hello, " + principal.getName() + "!"; }}

Die Annotation @Controller zeigt Micronaut an, dass diese Komponente Anforderungen in der /hello Pfad.

Die Klasse hat nur eine Methode mit dem Namen hello(). Die Annotation @Get zeigt, dass die Methode HTTP-GET-Anforderungen empfängt. Sie benötigen @Produces, da der Standardrückgabetyp von Micronaut ein JSON-Objekt ist. Da Sie einfachen Text zurückgeben, müssen Sie diese Informationen explizit in der Methode definieren.

Die letzte Anmerkung ist @Secured. Es teilt Micronaut lediglich mit, dass diese Methode nur für authentifizierte Benutzer zugänglich ist.

Sie haben jetzt einen Controller, der gesichert ist, aber Sie haben die Sicherheitskonfiguration noch nicht definiert. Konfigurieren Sie Micronaut für die Verbindung mit Ihrer Okta-Anwendung.

Benennen Sie src/main/resources/application.yml in application.properties um und fügen Sie die folgende Sicherheitskonfiguration hinzu:

micronaut.security.enabled=truemicronaut.security.token.jwt.enabled=truemicronaut.security.token.jwt.signatures.jwks.okta.url=https://{yourOktaDomain}/oauth2/default/v1/keys

Ersetzen Sie {yourOktaDomain} konto.

Die obige Konfiguration aktiviert die Sicherheit mit OAuth 2.0. Sie erklären, dass Ihr OAuth 2.0-Client von Okta stammt, indem Sie den Aussteller Ihrer Okta-Organisation angeben.

Sie aktivieren auch die Verwendung von JSON-Webtoken oder JWTs. Da Sie die Informationen von Okta lesen möchten, müssen Sie angeben, wo Sie Ihre JWKS (JSON-Webschlüsselsatz) finden können, um JWT-Signaturen zu validieren.

Es ist Zeit, Ihren Service zu testen! Starten Sie Ihre Anwendung, indem Sie den folgenden Befehl ausführen:

./mvnw mn:run

Führen Sie bei laufender App den folgenden Befehl aus:

curl -X GET -I http://localhost:8080/hello

Der obige Befehl erzeugt ein ähnliches Ergebnis wie dieses:

HTTP/1.1 401 UnauthorizedDate: Tue, 8 Jan 2019 15:47:36 GMTtransfer-encoding: chunkedconnection: close

Wie Sie sehen können, wurde die Anfrage nicht bearbeitet. Damit es funktioniert, müssen Sie das vom OIDC-Debugger abgerufene OAuth 2.0-Zugriffstoken übergeben. Weisen Sie das Zugriffstoken einer TOKEN Variablen in Ihrer Shell zu.

TOKEN=eyJraWQiOiJxOE1QMjFNNHZCVmxOSkxGbFFWNlN...

Führen Sie den folgenden Befehl aus:

curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/hello

Jetzt funktioniert es wie erwartet! Dieses Mal erhalten Sie die Begrüßungsnachricht als Antwort:

Hello, [email protected]!

Sie können sehen, dass Micronaut sehr wenig Code benötigt, um eine sichere REST-API zu erstellen. Wenn Sie die Codezeilen gezählt haben, werden Sie feststellen, dass ~ 24% in XML geschrieben sind (8 Zeilen), der Java-Code nur 22 Zeilen Code enthält und die Sicherheitskonfiguration 3 Zeilen benötigt. Die integrierte OAuth 2.0-Unterstützung von Micronaut erleichtert die Integration in Okta und sie haben sogar eine Anleitung für Okta in ihrer Dokumentation.

Großartig! Lassen Sie uns nun sehen, wie Sie dieselbe App mit Quarkus erstellen.

Erstellen Sie eine Java REST API mit Quarkus

Um Ihre Anwendung mit Quarkus zu entwickeln, benötigen Sie nur Maven installiert, es sind keine weiteren Abhängigkeiten erforderlich.

Beginnen wir mit der Erstellung Ihrer App! Gehen Sie zu dem Verzeichnis, in dem Sie es erstellen möchten, und führen Sie den folgenden Befehl aus:

mvn io.quarkus:quarkus-maven-plugin:1.8.1.Final:create \ -DprojectGroupId=com.okta.rest \ -DprojectArtifactId=quarkus \ -DclassName="com.okta.rest.quarkus.HelloResource" \ -Dpath="/hello" \ -Dextensions="jwt"

Der obige Befehl erstellt ein Projekt mit dem Quarkus Maven Plugin. Es wird eine Ressource mit dem Namen HelloResource erstellt, die Anforderungen im Pfad /hello empfängt. Sie fügen dem Projekt auch die JWT-Erweiterung von Quarkus hinzu.

Nachdem Sie das Projekt erstellt haben, bearbeiten Sie src/java/com/okta/rest/quarkus/HelloResource.java und fügen Sie der hello() -Methode Benutzerinformationen hinzu:

package com.okta.rest.quarkus;import io.quarkus.security.Authenticated;import javax.ws.rs.GET;import javax.ws.rs.Path;import javax.ws.rs.Produces;import javax.ws.rs.core.Context;import javax.ws.rs.core.MediaType;import javax.ws.rs.core.SecurityContext;import java.security.Principal;@Path("/hello")public class HelloResource { @GET @Path("/") @Authenticated @Produces(MediaType.TEXT_PLAIN) public String hello(@Context SecurityContext context) { Principal userPrincipal = context.getUserPrincipal(); return "Hello, " + userPrincipal.getName() + "!"; }}

Die obige Klasse verhält sich genauso wie die, die Sie in Micronaut erstellt haben. Es liest die Informationen des Benutzers basierend auf dem Token, das in der Anforderung generiert wurde, und gibt eine Begrüßungsnachricht an den gefundenen Benutzer zurück.

Sie haben Quarkus noch nicht mit Ihrem Aussteller und den Schlüsseln von Okta konfiguriert.

Editieren Sie src/main/resources/application.properties und fügen Sie den folgenden Code hinzu:

mp.jwt.verify.publickey.location=https://{yourOktaDomain}/oauth2/default/v1/keysmp.jwt.verify.issuer=https://{yourOktaDomain}/oauth2/default

Fertig! Die Quarkus-Version Ihrer Anwendung kann getestet werden. Gehen Sie zu Ihrem Projektordner und führen Sie den folgenden Befehl aus:

./mvnw compile quarkus:dev

Der obige Befehl startet Ihre Anwendung.

Der erste Schritt besteht darin, sicherzustellen, dass Sie eine 401 - Unauthorized wenn Sie nicht die richtigen Anmeldeinformationen verwenden.

Führen Sie den folgenden Befehl im Terminal aus:

curl -X GET -I http://localhost:8080/hello

Wie erwartet ist das Ergebnis eine HTTP 401-Antwort:

HTTP/1.1 401 Unauthorizedwww-authenticate: Bearer {token}Content-Length: 0

Wenn Sie dieselbe Anforderung einschließlich des Tokens vom OIDC-Debugger ausführen, sollte die Begrüßungsnachricht zurückgegeben werden.

Führen Sie den folgenden Befehl aus:

curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/hello

Es hat wie ein Zauber funktioniert! In meinem Fall war das Ergebnis:

Hello, [email protected]!

Quarkus benötigt noch weniger Codezeilen als Micronaut! Es generiert eine App mit enthaltenen Abhängigkeiten, enthält 25 Zeilen Java-Code und nur 2 Zeilen Konfiguration. Ja, Codezeilen sind ein dummer Vergleich, aber es zeigt auch, dass diese Frameworks sehr wenig Code benötigen, um sichere Apps zu entwickeln.

Zwei runter, eins los! Nachdem Sie die App nun auf Micronaut und Quarkus implementieren konnten, erstellen wir zum Schluss dieselbe App mit Spring Boot.

Erstellen Sie eine Java-REST-API mit Spring Boot

Spring Boot hat keine Voraussetzungen, um mit der Erstellung Ihrer App zu beginnen. Beginnen wir also mit der Erstellung des Projekts!

Öffnen Sie Ihr Terminal und führen Sie den folgenden Befehl aus:

curl https://start.spring.io/starter.zip -d language=java \ -d bootVersion=2.3.4.RELEASE \ -d dependencies=web,okta \ -d packageName=com.okta.rest \ -d name=spring-boot \ -d type=maven-project \ -o spring-boot.zip

Der obige Befehl erstellt eine spring-boot.zip -Datei mit einer Spring Boot-Anwendung, die Maven verwendet. Sie können die Datei mit dem folgenden Befehl in ein spring-boot -Verzeichnis extrahieren.

unzip spring-boot.zip -d spring-boot

Jetzt implementieren Sie den Controller, der die Anforderungen empfängt.

Erstelle ein com.okta.rest.controller Paket und eine HelloController Klasse darin:

package com.okta.rest.controller;import org.springframework.security.core.annotation.AuthenticationPrincipal;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;import java.security.Principal;@RestControllerpublic class HelloController { @GetMapping("/hello") public String hello(@AuthenticationPrincipal Principal principal) { return "Hello, " + principal.getName() + "!"; }}

Die Konfiguration hier ist den anderen Frameworks sehr ähnlich. Sie kommentieren die Klasse mit @RestController , um Spring mitzuteilen, dass Sie Anforderungen für die Klasse erhalten. @GetMapping empfängt HTTP-GET-Anforderungen auf dem Pfad /hello. Um den authentifizierten Benutzer abzurufen, verwenden Sie die Annotation @AuthenticationPrincipal .

Anders als bei den anderen Frameworks müssen Sie nicht angeben, dass dieser Endpunkt authentifiziert ist, da Spring diese Informationen bereits aus seinen Konfigurationen steuert.

Der letzte Schritt besteht darin, die Emittenteninformationen hinzuzufügen, damit die OIDC-Unterstützung von Spring Security die Endpunkte, mit denen es kommunizieren muss, automatisch ermitteln kann.

Bearbeiten Sie src/main/resources/applications.properties und fügen Sie die folgende Konfiguration hinzu:

okta.oauth2.issuer=https://{yourOktaDomain}/oauth2/default

Testen wir es! Starten Sie Ihre Spring Boot-App mit Maven.

./mvnw spring-boot:run

Öffnen Sie dann ein Terminal und führen Sie den folgenden Befehl aus:

curl -X GET -I http://localhost:8080/hello

Die Antwort ist ein HTTP 401-Fehler, da Sie das Token nicht angegeben haben:

HTTP/1.1 401Set-Cookie: JSESSIONID=316DCFD55C302A8D69EFD865411DFA77; Path=/; HttpOnlyWWW-Authenticate: BearerX-Content-Type-Options: nosniffX-XSS-Protection: 1; mode=blockCache-Control: no-cache, no-store, max-age=0, must-revalidatePragma: no-cacheExpires: 0X-Frame-Options: DENYContent-Length: 0Date: Thu, 09 Jan 2020 15:46:34 GMT

Testen Sie es erneut und übergeben Sie nun das Token:

curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/hello

Es hat funktioniert! Wie bei den anderen Diensten ist das Ergebnis dieses Befehls das folgende:

Hello, [email protected]!

Spring Boot taktet mit der geringsten erforderlichen Codemenge: 17 zeilen Java und nur 1 Zeile Konfiguration! Spring war schon immer hervorragend darin, Entwicklern das Leben zu erleichtern, daher ist dies keine Überraschung.

Das war’s! Sie haben in allen drei Frameworks eine grundlegende Java-REST-API implementiert!

Abschließende Gedanken zu REST-APIs mit Java: Micronaut, Quarkus und Spring Boot

Wenn es um die Entwicklung Ihrer REST-API geht, haben alle drei Frameworks Ihre Arbeit gut gemacht. Mit nur ein bisschen Code und etwas Konfiguration konnten Sie eine sichere Anwendung mit Okta und OAuth 2.0 entwickeln.

Der Frühling gibt es schon seit vielen Jahren, er ist sehr beliebt und hat viele Funktionen in seinem Ökosystem. Persönlich glaube ich immer noch, dass es die beste Option ist, wenn Sie in Java programmieren.

Micronaut und Quarkus erfreuen sich wachsender Beliebtheit und gewinnen innerhalb der Java-Community an Dynamik. Wenn Sie mit Leistungsproblemen konfrontiert sind oder sich nach einer Änderung sehnen, können Sie eines davon ausprobieren und sehen, wie es geht.

Leistung ist der am häufigsten hervorgehobene Vergleichspunkt zwischen diesen drei Frameworks. Wenn Sie einen schnellen Start in einer serverlosen Umgebung oder die Möglichkeit suchen, native Images mit GraalVM zu erstellen, werden Micronaut und Quarkus wahrscheinlich gut für Sie funktionieren. Nur zum Spaß lauten die Startzeiten für jede dieser Apps wie folgt (basierend auf dem Durchschnitt von drei Versuchen):

• Micronaut: 474 ms
• Quarkus: 1132 ms
• Spring Boot: 1014 ms

Ich habe diese Zahlen erhalten, indem ich die Maven-Ziele jedes Frameworks für die Entwicklung ausgeführt habe.

• Micronaut: ./mvnw mn:run
• Quarkus: ./mvnw compile quarkus:dev
• Frühling Boot: ./mvnw spring-boot:run

Diese Befehle sind nicht auf Geschwindigkeit optimiert, daher habe ich jede Anwendung mit ./mvnw package gepackt und mit java -jar gestartet.

• Micronaut: 596ms
• Quarkus: 658ms
• Spring Boot: 1878ms

HINWEIS: Diese Zahlen wurden auf einem 2019 MacBook Pro mit einer 2,4 GHz 8-Core Intel Core i9 CPU und 64 GB RAM berechnet. OpenJDK 15 wurde ohne JAVA_OPTS Einstellung verwendet.

Wenn Sie nach noch schnelleren Startzeiten suchen, können Sie GraalVM verwenden. Anstatt Timing-Tests selbst durchzuführen, habe ich mir die Dokumentation jedes Projekts angesehen.

• Micronaut: 12ms entsprechend der Erstellung Ihrer ersten Micronaut Graal-Anwendung.
• Quarkus: 14ms nach Quarkus und GraalVM: Hibernate mit Überschallgeschwindigkeit booten, Subatomare Größe auf InfoQ. Die Quarkus-Dokumente listen keine Startzeit auf.
• Spring Boot: 44ms gemäß Spring Graal Native 0.6.0 veröffentlicht.

Am Ende können Sie produktiv eine sichere Anwendung entwickeln, unabhängig davon, welche Wahl Sie treffen.

Möchten Sie einen Blick auf den Quellcode werfen? Sie finden es auf GitHub unter okta-java-rest-api-comparison-example .

Möchten Sie mehr über Java, REST-APIs und sichere Anwendungen erfahren? Hier sind einige andere Beiträge aus unserem Blog, die Sie nützlich finden könnten:

• Sehen Sie zu, wie GraalVM Ihr Java in Binärdateien verwandelt
• OAuth 2.0 Java Guide: Sichern Sie Ihre App in 5 Minuten
• Java Microservices mit Spring Boot und Spring Cloud
• So entwickeln Sie eine Quarkus-App mit Java- und OIDC-Authentifizierung
• Einfache Authentifizierung mit Spring Security

Für weitere Beiträge wie diesen, folgen Sie @oktadev auf Twitter. Wir veröffentlichen auch regelmäßig Screencasts auf unserem YouTube-Kanal!

Changelog:

• 23. September 2020: Upgrade auf Micronaut 2.0.2, Quarkus 1.8.1 und Spring Boot 2.3.4. Siehe die Codeänderungen in der Beispiel-App auf GitHub. Änderungen an diesem Beitrag können in oktadeveloper / okta-blog # 423 eingesehen werden.
• 21. Mai 2020: Startzeiten für java -jar hinzugefügt und mit GraalVM ausgeführt. Änderungen an diesem Artikel können in oktadeveloper / okta-blog # 304 eingesehen werden.
• 20.Mai 2020: Upgrade auf Micronaut 1.3.5, Quarkus 1.4.2 und Spring Boot 2.3.0. Siehe die Codeänderungen in der Beispiel-App auf GitHub. Änderungen an diesem Artikel können in oktadeveloper / okta-blog # 301 eingesehen werden.
• 30. Januar 2020: Aktualisiert, um Micronaut basierend auf dem Feedback des Micronaut-Teams zu optimieren. Auch neu berechnet Startzeiten basierend auf einem Durchschnitt von drei Versuchen. Siehe die Codeänderungen in der Beispiel-App auf GitHub. Änderungen an diesem Artikel können in oktadeveloper / okta-blog # 176 eingesehen werden.