udvikling af tjenester i Java, inklusive REST API ‘ er, var ikke altid let eller produktiv, før foråret kom og ændrede landskabet. Mange år er gået siden da, og nye rammer er opstået i samfundet.
en af disse rammer var Micronaut. Det er udviklet af OCI, det samme firma bag Grails, og deres mål er at hjælpe udviklere med at skabe mikroservices og serverløse applikationer.
Der er også Kvarkus, en anden ramme, der blev populær i løbet af det sidste år. Udviklet af RedHat lover Kvarkus at levere hurtig opstart og mindre hukommelsesforbrug, to almindelige problemer, når man udvikler REST-tjenester i Java.
med alle disse valg er der et meget vigtigt spørgsmål at stille: hvor nemt er det at oprette en service med hver af disse tre rammer?
i denne vejledning opretter du en sikker HVILEAPPLIKATION ved hjælp af forår, Mikronaut og Kvarkus for at se, hvordan de adskiller sig fra hinanden, og hvilken der bedst passer til dine behov.
Indholdsfortegnelse
- forudsætninger for din Java REST API
- Opret en Okta-konto til brugeradministration
- Generer Tokens ved hjælp af OpenID Connect Debugger
- Opbyg en Java REST API med Micronaut
- Udvikl din Java-tjeneste
- Opbyg en Java REST API med Kvarkus
- Byg en Java REST API med Spring Boot
- endelige tanker om REST API ‘ er med Java: Micronaut, kvarkus og Spring Boot
Hvis du vil, kan du se denne tutorial som en screencast.
- forudsætninger for din Java REST API
- Opret en Okta-konto til brugeradministration
- Generer Tokens ved hjælp af OpenID Connect Debugger
- Byg en Java REST API med Micronaut
- Udvikl din Java-tjeneste
- Byg en Java REST API med Kvarkus
- Byg en Java REST API med Spring Boot
- Endelige tanker om REST API ‘ er med Java: Micronaut, Kvarkus og Spring Boot
forudsætninger for din Java REST API
denne tutorial bruger Maven 3+. Sørg for, at den er installeret og tilgængelig til brug, før du fortsætter. Du kan helt sikkert også bruge Gradle, men YMMV.
Du skal bygge apps, der godkender anmodninger ved hjælp af OAuth 2.0, sikret af en Okta-applikation. Har du ikke en Okta-konto? Bare rolig, det tager mindre end et minut at oprette en ny. Ikke kun det, men Okta understøtter standarder som f.eks. Vi yder støtte til kendte rammer som Java EE, Spring Boot og Spring Security. Heck, vi har endda et Maven-plugin, der automatiserer alt for dig.
der er ingen grund til at genopfinde hjulet!
Opret en Okta-konto til brugeradministration
åbn din terminal, og udfør følgende kommando:
mvn com.okta:okta-maven-plugin:registerdu bliver bedt om at indtaste følgende oplysninger:
- fornavn
- efternavn
- firma
Når du har besvaret spørgsmålene, modtager du en e-mail for at aktivere din helt nye konto. Når du har aktiveret din konto, skal du køre følgende kommando:
mvn com.okta:okta-maven-plugin:spring-bootdenne kommando opretter et program til dig med auth-kodestrøm og Spring Security ‘ s omdirigering URI til Okta.
for at huske det bedre kan du oprette den samme app manuelt:
- gå til Oktas udviklerhjemmeside og log ind på din konto.
- Klik på applikationer >Tilføj applikation>Internet> næste.
du vil se følgende skærmbillede:
før du fortsætter, skal du foretage følgende ændringer i applikationen:
- Login redirect URIs:
http://localhost:8080/login/oauth2/code/oktahttps://oidcdebugger.com/debug
- Grant type tilladt
- autorisationskode
- Implicit (Hybrid)
den implicitte grant type (med id og adgangstoken tilladt markeret) er nødvendigt for at hente et adgangstoken i din bro.ser.
de felter, der ikke er nævnt ovenfor, kan beholde deres standardværdier.
Når du er færdig, skal du klikke på Udført. Din app er klar!
det næste trin er at lære at generere et gyldigt token ved hjælp af det.
Generer Tokens ved hjælp af OpenID Connect Debugger
Okta giver dig mulighed for at administrere dine brugere i skyen ved hjælp af dens API ‘ er. Det giver dig også mulighed for at sikre dine applikationer ved hjælp af OAuth 2.0 og OpenID Connect (aka, OIDC). OAuth 2.0 giver en mekanisme til delegeret godkendelse, hvilket betyder, at du ikke behøver at gemme brugeroplysninger i din ansøgning. I stedet kan du delegere det til en OAuth 2.0-udbyder (Okta, i dette tilfælde). OIDC giver et identitetslag oven på OAuth 2.0, og det er derfor, virksomheder som Okta kaldes “identitetsudbydere” eller IDP ‘ er.
du har registreret din app hos Okta og kan nu generere et token for at få adgang til det. En af de login omdirigere Uri ‘ er du registreret er for OpenID Connect hjemmeside.
dine anmodninger vil blive valideret ved hjælp af et token. For at generere dette token bruger du OpenID Connect Debugger. Denne hjemmeside vil give dig en nem måde at generere legitimationsoplysninger for brugerne på din Okta ansøgning.
gå til https://oidcdebugger.com og udfyld følgende oplysninger:
- autoriser URI:
https://{yourOktaDomain}/oauth2/default/v1/authorize - omdirigere URI:
https://oidcdebugger.com/debug - klient-ID:
{yourOktaClientId} - omfang:
openid email profile - tilstand:
dev - nonce: (behold standardværdien)
- svartype:
token
Du kan finde værdien for {yourOktaDomain} i højre øverste hjørne af din kontos hjemmeside:
Følg nedenstående trin for at finde dit Okta-klient-id:
- gå til applikationer
- vælg Min internetapp
- Klik på Generelt
klient-ID ‘ et vil være tilgængeligt i afsnittet klientoplysninger:
Når du har udfyldt alle felterne, skal du klikke på Send anmodning. Du bliver omdirigeret til din Okta-login-side.
når du har godkendt, bliver du omdirigeret til Oidc Debugger igen, hvor du kan se det genererede token:
du bruger dette token til sikkert at få adgang til de tjenester, du skal bygge.
nu hvor du har en Okta-konto, og du ved, hvordan du genererer tokens ved hjælp af din Okta-applikation, lad os begynde at sammenligne rammerne!
Byg en Java REST API med Micronaut
det første skridt til at udvikle din Micronaut service er at hente SDKMAN!. SDKMAN! er et værktøj til styring af parallelle versioner af flere SDK ‘ er, som du vil bruge til at installere Micronaut-klienten.
Du kan hente SDKMAN! ved at køre følgende kommando:
curl -s https://get.sdkman.io | bashnu Kan du installere Micronaut selv. Kør bare følgende kommando i terminalen:
sdk install micronautnår kommandoen er færdig med at udføre, har du den nyeste Micronaut-version tilgængelig på din computer.
du er klar til at begynde at udvikle programmet!
Udvikl din Java-tjeneste
gå til det Bibliotek, du vil oprette din applikation i, og udfør følgende kommando:
mn create-app com.okta.rest.app --build maven denne kommando opretter et projekt med den grundlæggende struktur i et Micronaut-projekt. Micronaut bruger Gradle som standard, men da du bruger --build maven, vil den bruge Maven i stedet.
det næste trin er at tilføje sikkerhedsbibliotekerne inde i projektet. Rediger pom.xml filen og tilføj følgende afhængigheder:
<dependency> <groupId>io.micronaut</groupId> <artifactId>micronaut-security</artifactId></dependency><dependency> <groupId>io.micronaut</groupId> <artifactId>micronaut-security-jwt</artifactId></dependency>disse afhængigheder vil aktivere sikkerhed – specifikt OAuth 2.0 med JVT – inde i dit projekt. Nu hvor du har alle afhængigheder på plads, kan du begynde at oprette dit slutpunkt.
Opret følgende klasse i 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() + "!"; }}@Controller annotation angiver til Micronaut, at denne komponent vil modtage anmodninger i /hello sti.
klassen har kun en metode, der hedderhello()@Get annotation viser, at metoden vil modtage HTTP GET-anmodninger. Du har brug for @Produces fordi Micronauts standard returtype er et JSON-objekt. Da du returnerer simpel tekst, skal du eksplicit definere disse oplysninger i metoden.
den sidste kommentar er@Secured. Det fortæller simpelthen Micronaut, at denne metode kun er tilgængelig for godkendte brugere.
du har nu en controller, der er sikret, men du har endnu ikke defineret sikkerhedskonfigurationen. Lad os konfigurere Micronaut til at oprette forbindelse til din Okta-applikation.
Omdøbsrc/main/resources/application.yml tilapplication.properties og tilføj følgende sikkerhedskonfiguration:
micronaut.security.enabled=truemicronaut.security.token.jwt.enabled=truemicronaut.security.token.jwt.signatures.jwks.okta.url=https://{yourOktaDomain}/oauth2/default/v1/keys Erstat {yourOktaDomain} med værdien fra din Okta-konto.
konfigurationen ovenfor muliggør sikkerhed ved hjælp af OAuth 2.0. Du erklærer, at din OAuth 2.0-klient kommer fra Okta ved at angive udstederen fra din Okta-organisation.
du aktiverer også brugen af JSON-tokens. Da du vil læse oplysningerne fra Okta, skal du erklære, hvor du kan finde dine JSON-nøglesæt (JSON-nøglesæt) for at validere JVT-signaturer.
det er tid til at teste din service! Start din applikation ved at udføre følgende kommando:
./mvnw mn:runNår din app kører, skal du udføre følgende kommando:
kommandoen ovenfor giver et resultat svarende til denne:
HTTP/1.1 401 UnauthorizedDate: Tue, 8 Jan 2019 15:47:36 GMTtransfer-encoding: chunkedconnection: close som du kan se, gik anmodningen ikke igennem. For at få det til at fungere, skal du passere OAuth 2.0 access token hentet af Oidc Debugger. Tildel adgangstokenet til enTOKEN variabel i din shell.
TOKEN=eyJraWQiOiJxOE1QMjFNNHZCVmxOSkxGbFFWNlN...udfør kommandoen nedenfor:
curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/hellonu fungerer det som forventet! Denne gang modtager du Hilsen som svar:
Hello, [email protected]!Du kan se, at Micronaut kræver meget lidt kode for at oprette en sikker REST API. Hvis du tællede kodelinjerne, ville du opdage, at ~24% er afhængigheder i 8 linjer, Java-koden er kun 22 linjer kode, og sikkerhedskonfigurationen tager 3 linjer. Micronauts indbyggede OAuth 2.0-support gør det nemt at integrere med Okta, og de har endda en Guide til Okta i deres dokumentation.
fantastisk! Lad os nu se, hvordan du opretter den samme app ved hjælp af Kvarkus.
Byg en Java REST API med Kvarkus
for at udvikle din applikation ved hjælp af Kvarkus behøver du kun Maven installeret, der kræves ingen andre afhængigheder.
lad os begynde at oprette din app! Gå til den mappe, du vil oprette den i, og udfør følgende kommando:
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" kommandoen ovenfor opretter et projekt ved hjælp af Kvarkus Maven plugin. Det vil oprette en ressource med navnet HelloResource, som vil modtage anmodninger på /hello sti. Du tilføjer også JVT-udvidelsen fra Kvarkus på projektet.
Når du har oprettet projektet, skal du redigere src/java/com/okta/rest/quarkus/HelloResource.java og tilføje brugeroplysninger til hello() metode:
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() + "!"; }}klassen ovenfor opfører sig på samme måde som den, du oprettede i Micronaut. Den læser brugerens oplysninger baseret på det token, der blev genereret i anmodningen, og returnerer en hilsen til den bruger, der findes.
Du har stadig ikke konfigureret Kvarkus med din udsteder og nøgler fra Okta, så lad os gøre det.
Rediger src/main/resources/application.properties og tilføj følgende kode:
mp.jwt.verify.publickey.location=https://{yourOktaDomain}/oauth2/default/v1/keysmp.jwt.verify.issuer=https://{yourOktaDomain}/oauth2/defaultudført! Kvarkus-versionen af din applikation er klar til at blive testet. Gå til din projektmappe og udfør følgende kommando:
./mvnw compile quarkus:devkommandoen ovenfor starter din applikation.
det første trin er at sikre dig, at du modtager et401 - Unauthorized, når du ikke bruger de korrekte legitimationsoplysninger.
Udfør følgende kommando i terminalen:
curl -X GET -I http://localhost:8080/hellosom forventet er resultatet et HTTP 401-svar:
HTTP/1.1 401 Unauthorizedwww-authenticate: Bearer {token}Content-Length: 0Hvis du udfører den samme anmodning, herunder token fra Oidc Debugger, skal den returnere hilsenmeddelelsen.
Udfør følgende kommando:
curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/hellodet fungerede som en charme! I mit tilfælde var resultatet:
Hello, [email protected]!Kvarkus kræver endnu færre kodelinjer end Micronaut! Det genererer en app med afhængigheder inkluderet, har 25 linjer Java-kode og kun 2 konfigurationslinjer. Ja, kodelinjer er en fjollet sammenligning, men det viser også, hvordan disse rammer kræver meget lidt kode for at udvikle sikre apps.
to ned, en til at gå! Nu hvor du var i stand til at implementere appen på Mikronaut og Kvarkus, lad os afslutte med at oprette den samme app ved hjælp af Spring Boot.
Byg en Java REST API med Spring Boot
Spring Boot har ingen forudsætninger for at begynde at oprette din app, så lad os starte med at oprette projektet!
åbn din terminal og udfør følgende kommando:
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.zipkommandoen ovenfor opretter enspring-boot.zip fil med et Spring Boot-program, der bruger Maven. Du kan udpakke filen i enspring-boot mappe ved hjælp af kommandoen nedenfor.
unzip spring-boot.zip -d spring-bootnu implementerer du den controller, der modtager anmodningerne.
Opret en com.okta.rest.controller pakke og en HelloController klasse i det:
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() + "!"; }}konfigurationen her ligner meget de andre rammer. Du kommenterer klassen med @RestController for at lade foråret vide, at du vil modtage anmodninger på klassen. @GetMappingmodtager HTTP GET-anmodninger på /hello sti. For at hente den godkendte bruger bruger du@AuthenticationPrincipal annotation.
I modsætning til de andre rammer behøver du ikke at angive, at dette slutpunkt er godkendt, da foråret allerede styrer disse oplysninger fra dets konfigurationer.
det sidste trin er at tilføje udstederoplysningerne, så Spring Security ‘ s oidc-support automatisk kan opdage de slutpunkter, den har brug for at kommunikere med.
Rediger src/main/resources/applications.properties og tilføj følgende konfiguration:
okta.oauth2.issuer=https://{yourOktaDomain}/oauth2/defaultlad os teste det! Start din Spring Boot app ved hjælp Maven.
./mvnw spring-boot:runåbn derefter en terminal og udfør kommandoen nedenfor:
svaret er en HTTP 401-fejl, da du ikke inkluderede 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 det igen, nu passerer token:
curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/hellodet virkede! Som med de andre tjenester er resultatet af denne kommando følgende:
Hello, [email protected]!Spring Boot ure i den mindste mængde kode, der kræves: 17 linjer af Java og kun 1 linje af konfiguration! Foråret har altid været fremragende til at gøre udviklernes liv lettere, så det kommer ikke som nogen overraskelse.
det er det! Du har implementeret en grundlæggende Java REST API i alle tre rammer!
Endelige tanker om REST API ‘ er med Java: Micronaut, Kvarkus og Spring Boot
når det kommer til at udvikle din REST API, gjorde alle tre rammer jobbet godt. Med kun en smule kode og en vis konfiguration kunne du udvikle en sikker applikation ved hjælp af Okta og OAuth 2.0.
foråret har eksisteret i mange år, det er meget populært og har mange funktioner omkring sit økosystem. Personligt mener jeg stadig, at det er den bedste mulighed, når man programmerer i Java.
Mikronaut og Kvarkus vokser i popularitet og får fart i Java-samfundet. Hvis du står over for præstationsproblemer, eller måske hvis du har ondt for en ændring, kan du prøve en af dem og se, hvordan det går.
ydeevne er det oftest fremhævede sammenligningspunkt mellem disse tre rammer. Hvis du leder efter hurtig opstart i et serverløst miljø, eller evnen til at oprette indfødte billeder med GraalVM, vil Micronaut og Kvarkus sandsynligvis fungere godt for dig. Bare for sjov er opstartstiderne for hver af disse apps som følger (baseret på gennemsnittet fra tre forsøg):
- Micronaut: 474ms
- Kvarkus: 1132ms
- Spring Boot: 1014ms
Jeg fik disse tal fra at køre hver rammes Maven mål for udvikling.
- Micronaut:
./mvnw mn:run - Kvarkus:
./mvnw compile quarkus:dev - Spring Boot:
./mvnw spring-boot:run
disse kommandoer er ikke optimeret til hastighed, så jeg pakkede hver applikation med ./mvnw package og startede dem med java -jar.
- Micronaut: 596ms
- Kvarkus: 658ms
- Spring Boot: 1878ms
Bemærk: Disse tal blev beregnet på en 2019 MacBook Pro med en 2,4 GS 8-Core Intel Core i9 CPU og 64 GB RAM. OpenJDK 15 blev brugt uden JAVA_OPTS indstilling.
Hvis du leder efter endnu hurtigere opstartstider, kan du bruge GraalVM. I stedet for at køre timingtest selv kiggede jeg på hvert projekts dokumentation.
- Micronaut: 12ms i henhold til oprettelse af din første Micronaut Graal-applikation.
- Kvarkus: 14ms ifølge Kvarkus og GraalVM: opstart dvale ved supersonisk hastighed, Subatomær størrelse på Infok. Kvarkus-dokumenterne viser ikke en opstartstid.
- Spring Boot: 44ms ifølge Spring Graal Native 0.6.0 udgivet.
i sidste ende vil du være i stand til produktivt at udvikle en sikker applikation, uanset hvilket valg du foretager.
vil du kigge på kildekoden? Du kan finde det på GitHub på okta-java-rest-api-sammenligning-eksempel.
vil du lære mere om Java, REST API ‘ er og sikre applikationer? Her er nogle andre indlæg fra vores blog, som du måske finder nyttige:
- se GraalVM gør din Java til binære filer
- OAuth 2.0 Java Guide: sikre din App på 5 minutter
- Java Microservices med Spring Boot og Spring Cloud
- Sådan udvikler du en Kvarkus-App med Java og Oidc-godkendelse
- enkel godkendelse med Spring Security
For flere indlæg som dette en, følg @oktadev på kvidre. Vi offentliggør også regelmæssigt screencasts til vores YouTube-kanal!
Changelog:
- 23. september 2020: opgraderet til Micronaut 2.0.2, Kvarkus 1.8.1 og Spring Boot 2.3.4. Se kodeændringerne i eksempelappen på GitHub. Ændringer til dette indlæg kan ses i oktadeveloper / okta-blog#423.
- 21. maj 2020: tilføjet opstartstider for
java -jarog kører med GraalVM. Ændringer til denne artikel kan ses i oktadeveloper / okta-blog#304. 20. maj 2020: opgraderet til Micronaut 1.3.5, Kvarkus 1.4.2 og Spring Boot 2.3.0. Se kodeændringerne i eksempelappen på GitHub. Ændringer til denne artikel kan ses i oktadeveloper / okta-blog#301. - Jan 30, 2020: opdateret for at optimere Micronaut baseret på feedback fra Micronaut-teamet. Også re-beregnet opstartstider baseret på et gennemsnit på tre forsøg. Se kodeændringerne i eksempelappen på GitHub. Ændringer til denne artikel kan ses i oktadeveloper / okta-blog#176.