het ontwikkelen van diensten in Java, inclusief REST API ‘ s, was niet altijd gemakkelijk of productief tot de lente kwam en het landschap veranderde. Sindsdien zijn er vele jaren verstreken en zijn er in de Gemeenschap nieuwe kaders ontstaan.
een van deze frameworks was Micronaut. Het is ontwikkeld door OCI, hetzelfde bedrijf achter Grails, en hun doel is om ontwikkelaars te helpen maken microservices en serverloze toepassingen.
Er is ook Quarkus, een ander framework dat het afgelopen jaar aan populariteit heeft gewonnen. Quarkus, ontwikkeld door RedHat, belooft snel opstarten en minder geheugengebruik te leveren, twee veel voorkomende problemen bij het ontwikkelen van REST services in Java.
met al deze keuzes is er een zeer belangrijke vraag: hoe eenvoudig is het om een service te maken met elk van deze drie frameworks?
in deze tutorial Maak je een veilige RESTTOEPASSING met Spring, Micronaut en Quarkus om te zien hoe ze van elkaar verschillen en welke het beste bij je behoeften past.
inhoudsopgave
- vereisten voor uw Java REST API
- Maak een Okta Account aan voor gebruikersbeheer
- genereer Tokens met OpenID Connect Debugger
- Bouw een Java REST API met Micronaut
- Ontwikkel uw Java Service
- Bouw een Java REST API met Quarkus
- bouw een Java REST API met Spring Boot
- laatste gedachten over REST API ‘ s met Java: micronaut, quarkus, en Spring Boot
Als u wilt, kunt u deze tutorial bekijken als een screencast. 👇
- vereisten voor uw Java REST API
- Maak een Okta Account aan voor gebruikersbeheer
- Tokens genereren met OpenID Connect Debugger
- Bouw een Java REST API met Micronaut
- Ontwikkel uw Java-Service
- Bouw een Java REST API met Quarkus
- Bouw een Java REST API met Spring Boot
- laatste gedachten over REST API ‘ s met Java: Micronaut, Quarkus en Spring Boot
vereisten voor uw Java REST API
Deze tutorial gebruikt Maven 3+. Zorg ervoor dat het is geïnstalleerd en beschikbaar voor gebruik voordat u verder gaat. Je kunt zeker ook Gradle gebruiken, maar YMMV.
u gaat apps bouwen die Verzoeken authenticeren met OAuth 2.0, beveiligd door een Okta-toepassing. Heb je geen Okta account? Maak je geen zorgen, het duurt minder dan een minuut om een nieuwe te maken. Niet alleen dat, maar Okta ondersteunt standaarden zoals JWT, OAuth 2.0, en OIDC. Wij bieden ondersteuning voor bekende frameworks zoals Java EE, Spring Boot, en Spring Security. Heck, we hebben zelfs een Maven plugin die alles automatiseert voor u.
het wiel hoeft niet opnieuw uit te vinden!
Maak een Okta Account aan voor gebruikersbeheer
Open uw terminal en voer het volgende commando uit:
mvn com.okta:okta-maven-plugin:registeru wordt gevraagd de volgende informatie in te voeren:
- voornaam
- achternaam
- bedrijf
zodra u de vragen hebt beantwoord, ontvangt u een e-mail om uw gloednieuwe account te activeren. Voer na het activeren van uw account het volgende commando uit:
mvn com.okta:okta-maven-plugin:spring-bootDit commando maakt een toepassing voor u aan met auth code flow en Spring Security ‘ s redirect URI voor Okta.
om het beter te onthouden, kunt u dezelfde app handmatig aanmaken:
- ga naar de startpagina van de ontwikkelaar van Okta en log in op uw account.
- klik op toepassingen > toepassing toevoegen > Web > volgende.
u ziet het volgende scherm:
voordat u verder gaat, maak de volgende wijzigingen in de toepassing:
- Login redirect URI ‘ s:
http://localhost:8080/login/oauth2/code/oktahttps://oidcdebugger.com/debug
- Subsidietype toegestaan
- autorisatiecode
- impliciet (hybride)
het impliciete subsidietype (met ID en toegang token toegestaan gecontroleerd) is nodig om een toegangstoken in uw browser op te halen.
de velden die hierboven niet zijn genoemd, kunnen hun standaardwaarden behouden.
nadat u het hebt voltooid, klikt u op Gereed. Uw app is klaar!
de volgende stap is om te leren hoe een geldig token te genereren met behulp van het.
Tokens genereren met OpenID Connect Debugger
Okta stelt u in staat om uw gebruikers in de cloud te beheren met behulp van de API ‘ s. Het stelt u ook in staat om uw toepassingen te beveiligen met behulp van OAuth 2.0 en OpenID Connect (a.k.a., OIDC). OAuth 2.0 biedt een mechanisme voor gedelegeerde autorisatie, wat betekent dat u geen gebruikersreferenties hoeft op te slaan in uw toepassing. In plaats daarvan kunt u dat delegeren aan een OAuth 2.0 provider (Okta, in dit geval). OIDC biedt een identiteit laag op de top van OAuth 2.0 en dat is waarom bedrijven als Okta worden genoemd “identity providers”, of IDP ‘ s.
u hebt uw app geregistreerd bij Okta en kunt nu een token genereren om er toegang toe te krijgen. Een van de Login redirect URI ‘ s die u hebt geregistreerd is voor de OpenID Connect website.
uw aanvragen worden gevalideerd met behulp van een token. Om dit token te genereren, gebruikt u OpenID Connect Debugger. Deze website zal u een gemakkelijke manier om referenties te genereren voor de gebruikers op uw Okta applicatie.
Ga naar de https://oidcdebugger.com en vul de volgende informatie in:
- autoriseren URI:
https://{yourOktaDomain}/oauth2/default/v1/authorize - Redirect URI:
https://oidcdebugger.com/debug - Client-ID:
{yourOktaClientId} - Bereik:
openid email profile - Status:
dev - Nonce: (houd de standaardwaarde)
- Reactie:
token
U kunt de waarde voor {yourOktaDomain} in de rechterbovenhoek van uw account homepage:
vindt u uw Okta Cliënt-ID volg de stappen hieronder:
- ga naar Toepassingen
- selecteer Mijn webapplicatie
- klik op Algemeen
de Client-ID zal beschikbaar zijn in de Clientreferenties sectie:
nadat u alle velden hebt ingevuld, klikt u op verzoek verzenden. U wordt doorgestuurd naar uw Okta login pagina.
zodra u de authenticatie succesvol hebt geverifieerd, wordt u opnieuw doorgestuurd naar Oidc Debugger, waar u het gegenereerde token kunt zien:
u zult dit token gebruiken om veilig toegang te krijgen tot de services die u gaat bouwen.
nu je een Okta account hebt en je weet hoe tokens te genereren met je Okta applicatie, laten we beginnen met het vergelijken van de frameworks!
Bouw een Java REST API met Micronaut
De eerste stap om uw Micronaut service te ontwikkelen is het downloaden van SDKMAN!. SDKMAN! is een tool voor het beheren van parallelle versies van meerdere SDK ‘ s, die u zult gebruiken om de Micronaut-client te installeren.
U kunt SDKMAN downloaden! door het volgende commando uit te voeren:
curl -s https://get.sdkman.io | bashnu kunt u Micronaut zelf installeren. Voer het volgende commando uit in de terminal:
sdk install micronautnadat het commando is uitgevoerd, hebt u de nieuwste versie van Micronaut beschikbaar op uw computer.
u bent klaar om de applicatie te ontwikkelen!
Ontwikkel uw Java-Service
Ga naar de map waarin u uw toepassing wilt maken en voer het volgende commando uit:
mn create-app com.okta.rest.app --build mavenDit commando zal een project aanmaken met de basisstructuur van een Micronaut-project. Micronaut gebruikt standaard Gradle, maar omdat u --build maven gebruikt, zal het in plaats daarvan Maven gebruiken.
de volgende stap is het toevoegen van de beveiligingsbibliotheken in het project. Bewerk het pom.xml bestand en voeg de volgende afhankelijkheden toe:
<dependency> <groupId>io.micronaut</groupId> <artifactId>micronaut-security</artifactId></dependency><dependency> <groupId>io.micronaut</groupId> <artifactId>micronaut-security-jwt</artifactId></dependency>deze afhankelijkheden zullen beveiliging inschakelen – specifiek OAuth 2.0 met JWT – binnen uw project. Nu u alle afhankelijkheden op zijn plaats hebt, kunt u beginnen met het maken van uw eindpunt.
maak de volgende klasse aan 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() + "!"; }}de@Controllerannotatie geeft aan Micronaut aan dat deze component aanvragen zal ontvangen in de /hello pad.
De klasse heeft slechts één methode, genaamd hello(). De@Get annotatie laat zien dat de methode HTTP GET-verzoeken zal ontvangen. U hebt @Produces nodig omdat het standaard retourtype van Micronaut een JSON-object is. Aangezien u eenvoudige tekst retourneert, moet u deze informatie expliciet definiëren in de methode.
de laatste annotatie is @Secured. Het vertelt Micronaut gewoon dat deze methode alleen toegankelijk is voor geverifieerde gebruikers.
u hebt nu een controller die beveiligd is, maar u hebt de beveiligingsconfiguratie nog niet gedefinieerd. Laten we Micronaut configureren om verbinding te maken met uw Okta applicatie.
hernoem src/main/resources/application.yml to application.properties en voeg de volgende beveiligingsconfiguratie toe:
micronaut.security.enabled=truemicronaut.security.token.jwt.enabled=truemicronaut.security.token.jwt.signatures.jwks.okta.url=https://{yourOktaDomain}/oauth2/default/v1/keys vervang {yourOktaDomain}met de waarde van uw Okta rekening.
bovenstaande configuratie maakt beveiliging mogelijk met OAuth 2.0. U verklaart dat uw OAuth 2.0 client afkomstig is van Okta, door de uitgever van uw Okta organisatie op te geven.
u staat ook het gebruik van JSON web tokens, of JWTs. Omdat u de informatie van Okta wilt lezen, moet u aangeven waar u uw JWKS (JSON Web Key Set) kunt vinden om JWT handtekeningen te valideren.
Het is tijd om uw service te testen! Start uw applicatie door het volgende commando uit te voeren:
./mvnw mn:runals uw app draait, voert u het volgende commando uit:
curl -X GET -I http://localhost:8080/hellohet bovenstaande commando zal een vergelijkbaar resultaat opleveren:
HTTP/1.1 401 UnauthorizedDate: Tue, 8 Jan 2019 15:47:36 GMTtransfer-encoding: chunkedconnection: close zoals u kunt zien, is het verzoek niet doorgegaan. Om het te laten werken, moet u doorgeven in de OAuth 2.0 access token opgehaald door de Oidc Debugger. Wijs het toegangstoken toe aan een TOKEN variabele in uw shell.
TOKEN=eyJraWQiOiJxOE1QMjFNNHZCVmxOSkxGbFFWNlN...voer het onderstaande commando uit:
curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/hellonu werkt het zoals verwacht! Deze keer ontvangt u het begroetingsbericht als antwoord:
Hello, [email protected]!U kunt zien dat Micronaut zeer weinig code nodig heeft om een veilige REST API aan te maken. Als je de regels code zou tellen, zou je merken dat ~ 24% afhankelijkheden zijn in XML (8 regels), de Java code is slechts 22 regels code, en de beveiliging configuratie duurt 3 regels. Micronaut ‘ s ingebouwde OAuth 2.0 ondersteuning maakt het gemakkelijk te integreren met Okta en ze hebben zelfs een gids voor Okta in hun documentatie.
geweldig! Laten we nu eens kijken hoe u dezelfde app maakt met Quarkus.
Bouw een Java REST API met Quarkus
om uw toepassing te ontwikkelen met Quarkus hebt u alleen Maven nodig geïnstalleerd, er zijn geen andere afhankelijkheden vereist.
laten we beginnen met het maken van uw app! Ga naar de map waarin u het wilt maken en voer het volgende commando uit:
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"het bovenstaande commando maakt een project aan met behulp van de Quarkus Maven plugin. Het zal een bron aanmaken met de naam HelloResource, die verzoeken zal ontvangen op het /hello pad. U voegt ook de JWT-extensie van Quarkus toe aan het project.
zodra u het project aanmaakt, Bewerk src/java/com/okta/rest/quarkus/HelloResource.java en voeg gebruikersinformatie toe aan dehello() methode:
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() + "!"; }}de bovenstaande klasse zal zich op dezelfde manier gedragen als de klasse die u in Micronaut hebt aangemaakt. Het leest de informatie van de gebruiker op basis van het token dat werd gegenereerd in het verzoek en geeft een begroetingsbericht aan de gebruiker die is gevonden.
U hebt Quarkus nog steeds niet geconfigureerd met uw uitgever en sleutels van Okta, dus laten we dat doen.
Bewerk src/main/resources/application.properties en voeg de volgende code toe:
mp.jwt.verify.publickey.location=https://{yourOktaDomain}/oauth2/default/v1/keysmp.jwt.verify.issuer=https://{yourOktaDomain}/oauth2/defaultgereed! De Quarkus-versie van uw toepassing is klaar om te worden getest. Ga naar uw projectmap en voer het volgende commando uit:
./mvnw compile quarkus:devhet bovenstaande commando zal uw toepassing starten.
de eerste stap is ervoor te zorgen dat u een 401 - Unauthorized ontvangt wanneer u niet de juiste referenties gebruikt.
voer het volgende commando uit in de terminal:
curl -X GET -I http://localhost:8080/hellozoals verwacht is het resultaat een HTTP 401-antwoord:
HTTP/1.1 401 Unauthorizedwww-authenticate: Bearer {token}Content-Length: 0Als u hetzelfde verzoek uitvoert, inclusief het token van de Oidc-Debugger, moet het het begroetingsbericht retourneren.
voer het volgende commando uit:
curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/hellohet werkte als een charme! In mijn geval was het resultaat:
Hello, [email protected]!Quarkus heeft nog minder regels code nodig dan Micronaut! Het genereert een app met afhankelijkheden opgenomen, heeft 25 regels van Java-code, en slechts 2 regels van de configuratie. Ja, regels code is een domme vergelijking, maar het laat ook zien hoe deze frameworks vereisen zeer weinig code om veilige apps te ontwikkelen.
twee klaar, nog één te gaan! Nu u de app op Micronaut en Quarkus hebt kunnen implementeren, maken we dezelfde app met Spring Boot.
Bouw een Java REST API met Spring Boot
Spring Boot heeft geen voorwaarden om te beginnen met het maken van uw app, dus laten we beginnen met het maken van het project!
Open uw terminal en voer het volgende commando uit:
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 het bovenstaande commando zal een spring-boot.zipbestand aanmaken met een Spring Boot applicatie die Maven gebruikt. U kunt het bestand uitpakken in eenspring-boot map met het onderstaande commando.
unzip spring-boot.zip -d spring-bootnu implementeert u de controller die de verzoeken zal ontvangen.
Maak een com.okta.rest.controller pakket aan en een HelloController klasse erin:
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() + "!"; }} de configuratie hier is zeer vergelijkbaar met de andere frameworks. Je annoteert de klasse met @RestController om Spring te laten weten dat je aanvragen voor de klasse zult ontvangen. @GetMapping zal HTTP GET-verzoeken ontvangen op het /hello pad. Om de geverifieerde gebruiker op te halen gebruikt u de @AuthenticationPrincipal annotatie.
anders dan de andere frameworks, hoeft u niet op te geven dat dit eindpunt geauthenticeerd is, aangezien Spring deze informatie al regelt vanuit zijn configuraties.
de laatste stap is het toevoegen van de informatie van de uitgever, zodat de Oidc-ondersteuning van Spring Security automatisch de eindpunten kan ontdekken waarmee het moet communiceren.
Bewerk src/main/resources/applications.properties en voeg de volgende configuratie toe:
okta.oauth2.issuer=https://{yourOktaDomain}/oauth2/defaultlaten we het testen! Start uw Spring Boot app met behulp van Maven.
./mvnw spring-boot:runopen een terminal en voer het onderstaande commando:
curl -X GET -I http://localhost:8080/helloHet antwoord is een HTTP-fout 401, omdat je niet onder de token:
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 GMTTest opnieuw, nu het passeren van de token:
curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/helloHet werkte! Net als bij de andere diensten, is het resultaat van dit commando het volgende:
Hello, [email protected]!Spring Boot klokken in ten minste de minste hoeveelheid code vereist: 17 regels Java en slechts 1 regel configuratie! De lente is altijd uitstekend geweest in het gemakkelijker maken van het leven van ontwikkelaars, dus dit komt niet als een verrassing.
dat is het! Je hebt een basis java REST API geà mplementeerd in alle drie frameworks!
laatste gedachten over REST API ‘ s met Java: Micronaut, Quarkus en Spring Boot
als het gaat om het ontwikkelen van uw REST API, deden alle drie frameworks het goed. Met slechts een beetje code en wat configuratie, was je in staat om een veilige applicatie te ontwikkelen met behulp van Okta en OAuth 2.0.
Lente bestaat al vele jaren, het is alom populair en heeft vele kenmerken rond zijn ecosysteem. Persoonlijk geloof ik nog steeds dat het de beste optie is die beschikbaar is bij het programmeren in Java.
Micronaut en Quarkus groeien in populariteit en winnen aan kracht binnen de Java-gemeenschap. Als je met prestatieproblemen wordt geconfronteerd, of misschien als je zin hebt in een verandering, kun je een van hen proberen en zien hoe het gaat.
Performance is het vaakst gemarkeerde vergelijkingspunt tussen deze drie kaders. Als u op zoek bent naar snel opstarten in een serverloze omgeving, of de mogelijkheid om native images te maken met GraalVM, zullen Micronaut en Quarkus waarschijnlijk goed voor u werken. Voor de lol zijn de opstarttijden voor elk van deze apps als volgt (gebaseerd op het gemiddelde van drie pogingen):
- Micronaut: 474ms
- Quarkus: 1132ms
- Spring Boot: 1014ms
Ik heb deze getallen gekregen door de Maven goals voor ontwikkeling van elk framework uit te voeren.
- Micronaut:
./mvnw mn:run - Quarkus:
./mvnw compile quarkus:dev - Spring Boot:
./mvnw spring-boot:run
deze commando ‘ s zijn niet geoptimaliseerd voor snelheid, dus ik verpakte elke toepassing met ./mvnw package en begon ze met java -jar.
- Micronaut: 596ms
- Quarkus: 658ms
- Spring Boot: 1878ms
opmerking: deze nummers zijn berekend op een 2019 MacBook Pro met een 2,4 GHz 8-Core Intel Core i9 CPU en 64 GB RAM. OpenJDK 15 werd gebruikt zonderJAVA_OPTS instelling.
Als u op zoek bent naar nog snellere opstarttijden, kunt u GraalVM gebruiken. In plaats van het uitvoeren van timing tests mezelf, Ik keek naar de documentatie van elk project.
- Micronaut: 12ms volgens het aanmaken van uw eerste Micronaut Graal applicatie.
- Quarkus: 14ms volgens Quarkus en GraalVM: booten Hibernate met supersonische snelheid, subatomaire grootte op InfoQ. De quarkus-documenten vermelden geen opstarttijd.
- Spring Boot: 44ms volgens Spring Graal Native 0.6.0 vrijgegeven.
uiteindelijk kunt u een veilige toepassing productief ontwikkelen, ongeacht de keuze die u maakt.
wilt u de broncode bekijken? Je kunt het vinden op GitHub bij okta-java-rest-api-comparison-example.
wilt u meer weten over Java, REST API’ s en veilige toepassingen? Hier zijn enkele andere berichten van onze blog die u wellicht nuttig kunt vinden:
- kijk hoe GraalVM uw Java omzet in Binaries
- OAuth 2.0 Java Guide: Beveilig uw App in 5 minuten
- Java Microservices met Spring Boot en Spring Cloud
- Hoe ontwikkel je een Quarkus App met Java en Oidc authenticatie
- eenvoudige authenticatie met Spring Security
voor meer berichten zoals deze, Volg @oktadev op Twitter. We publiceren ook regelmatig screencasts op ons YouTube kanaal!
Changelog:
- 23 september 2020: opgewaardeerd naar Micronaut 2.0.2, Quarkus 1.8.1, en Spring Boot 2.3.4. Zie de code wijzigingen in de voorbeeld app op GitHub. Wijzigingen in dit bericht kunnen worden bekeken in oktadeveloper/Okta-blog#423.
- 21 mei 2020: opstarttijden toegevoegd voor
java -jaren draaien met GraalVM. Wijzigingen in dit artikel kunnen worden bekeken in oktadeveloper/okta-blog#304. - 20 mei 2020: opgewaardeerd naar Micronaut 1.3.5, Quarkus 1.4.2, en Spring Boot 2.3.0. Zie de code wijzigingen in de voorbeeld app op GitHub. Wijzigingen aan dit artikel kunnen worden bekeken in oktadeveloper/Okta-blog#301.
- 30 januari 2020: bijgewerkt om Micronaut te optimaliseren op basis van feedback van het Micronaut-team. Ook opnieuw berekende opstarttijden op basis van een gemiddelde van drie pogingen. Zie de code wijzigingen in de voorbeeld app op GitHub. Wijzigingen aan dit artikel kunnen worden bekeken in oktadeveloper/Okta-blog#176.