att utveckla tjänster i Java, inklusive REST API: er, var inte alltid lätt eller produktivt förrän våren kom och förändrade landskapet. Många år har gått sedan dess, och nya ramar har dykt upp i samhället.

en av dessa ramar var Micronaut. Det är utvecklat av OCI, samma företag bakom Grails, och deras mål är att hjälpa utvecklare att skapa mikrotjänster och serverlösa applikationer.

det finns också Quarkus, en annan ram som blev populär under det senaste året. Utvecklad av RedHat lovar Quarkus att leverera snabb start och mindre minnesanvändning, två vanliga problem när man utvecklar REST-tjänster i Java.

med alla dessa val finns det en mycket viktig fråga att ställa: hur lätt är det att skapa en tjänst med var och en av dessa tre ramar?

i den här handledningen skapar du en säker viloprogram med Spring, Micronaut och Quarkus för att se hur de skiljer sig från varandra och vilken som bäst passar dina behov.

Innehållsförteckning

• förutsättningar för din Java REST API
  • skapa ett Okta-konto för användarhantering
  • generera Tokens med OpenID Connect Debugger
• Bygg ett Java REST API med Micronaut
  • utveckla din Java-tjänst
• Bygg ett Java REST API med Quarkus
• Bygg ett Java REST API med Quarkus Spring Boot
• slutliga tankar om REST API: er med Java: micronaut, quarkus och Spring Boot

Om du vill kan du titta på den här handledningen som en screencast.

förutsättningar för din Java REST API

denna handledning använder Maven 3+. Se till att den är installerad och tillgänglig att använda innan du fortsätter. Du kan säkert också använda Gradle, men YMMV.

du ska bygga appar som autentiserar förfrågningar med OAuth 2.0, säkrad av en Okta-applikation. Har du inget okta-konto? Oroa dig inte, det tar mindre än en minut att skapa en ny. Inte bara det, men Okta stöder standarder som JWT, OAuth 2.0 och OIDC. Vi ger stöd för välkända ramar som Java EE, Spring Boot och Spring Security. Heck, vi har även en Maven plugin som automatiserar allt för dig.

det finns inget behov av att återuppfinna hjulet!

skapa ett Okta-konto för användarhantering

öppna din terminal och kör följande kommando:

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

Du kommer att bli ombedd att ange följande information:

• förnamn
• efternamn
• Email
• företag

När du har svarat på frågorna får du ett e-postmeddelande för att aktivera ditt helt nya konto. När du har aktiverat ditt konto kör du följande kommando:

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

det här kommandot skapar ett program för dig med auth-kodflöde och Spring Security ’ s redirect URI för Okta.

för att komma ihåg det bättre kan du skapa samma app manuellt:

• gå till okta: s utvecklarhemsida och logga in på ditt konto.
• Klicka på Program > Lägg till ansökan >Web> nästa.

du ser följande skärm:

innan du fortsätter gör du följande ändringar i programmet:

• logga in omdirigera Uri:
  • http://localhost:8080/login/oauth2/code/okta
  • https://oidcdebugger.com/debug
• Beviljningstyp tillåten
  • auktoriseringskod
  • Implicit (Hybrid)

den implicita bidragstypen (med ID och åtkomst token tillåten kontrollerad) är nödvändig för att hämta en åtkomsttoken i din webbläsare.

fälten som inte nämns ovan kan behålla sina standardvärden.

När du är klar klickar du på Klar. Din app är klar!

nästa steg är att lära sig att skapa en giltig token med den.

generera Tokens med OpenID Connect Debugger

Okta låter dig hantera dina användare i molnet med hjälp av dess API: er. Det låter dig också säkra dina applikationer med OAuth 2.0 och OpenID Connect (aka, OIDC). OAuth 2.0 tillhandahåller en mekanism för delegerad behörighet vilket innebär att du inte behöver lagra användaruppgifter i din ansökan. Istället kan du delegera det till en OAuth 2.0-leverantör (Okta, i det här fallet). OIDC tillhandahåller ett identitetslager ovanpå OAuth 2.0 och det är därför företag som Okta kallas ”identitetsleverantörer” eller IDP.

Du har registrerat din app med Okta och kan nu generera en token för att få tillgång till den. En av de inloggningsredirektörerurier du registrerade är för OpenID Connect-webbplatsen.

dina förfrågningar kommer att valideras med hjälp av en token. För att generera denna token använder du OpenID Connect Debugger. Denna webbplats ger dig ett enkelt sätt att generera referenser för användarna på din Okta-applikation.

gå till https://oidcdebugger.com och fyll i följande information:

• Auktorisera URI: https://{yourOktaDomain}/oauth2/default/v1/authorize
• omdirigera URI: https://oidcdebugger.com/debug
• klient-ID: {yourOktaClientId}
• omfattning: openid email profile
• tillstånd: dev
• nonce: (behåll standardvärdet)
• svarstyp: token

du hittar värdet för {yourOktaDomain} I det övre högra hörnet av ditt konto hemsida:

för att hitta ditt okta-klient-ID följ stegen nedan:

• gå till program
• välj Min webbapp
• Klicka på Allmänt

klient-ID kommer att finnas tillgängligt i avsnittet klientuppgifter:

När du har slutfört alla fält klickar du på Skicka förfrågan. Du kommer att omdirigeras till din okta inloggningssida.

När du har autentiserat, kommer du att omdirigeras till OIDC Debugger igen, där du kan se den genererade token:

du använder denna token för att säkert komma åt de tjänster du ska bygga.

Nu när du har ett okta-konto och du vet hur du genererar tokens med din Okta-applikation, låt oss börja jämföra ramarna!

Bygg ett Java REST API med Micronaut

det första steget för att utveckla din Micronaut-tjänst är att ladda ner SDKMAN!. SDKMAN! är ett verktyg för att hantera parallella versioner av flera SDK, som du använder för att installera Micronaut-klienten.

Du kan ladda ner SDKMAN! genom att köra följande kommando:

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

Nu kan du installera Micronaut själv. Kör bara följande kommando i terminalen:

sdk install micronaut

när kommandot är klart har du den senaste Micronaut-versionen tillgänglig på din dator.

du är redo att börja utveckla programmet!

utveckla din Java-tjänst

gå till katalogen du vill skapa din applikation I och kör följande kommando:

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

detta kommando skapar ett projekt med grundstrukturen för ett Micronaut-projekt. Micronaut använder Gradle som standard, men eftersom du använder --build maven kommer den att använda Maven istället.

nästa steg är att lägga till säkerhetsbiblioteken i projektet. Redigera filen pom.xml och Lägg till följande beroenden:

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

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() + "!"; }}

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

./mvnw mn:run

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

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

TOKEN=eyJraWQiOiJxOE1QMjFNNHZCVmxOSkxGbFFWNlN...

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

Hello, [email protected]!

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"

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() + "!"; }}

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

./mvnw compile quarkus:dev

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

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

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

Hello, [email protected]!

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

unzip spring-boot.zip -d spring-boot

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() + "!"; }}

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

./mvnw spring-boot:run

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

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

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

Hello, [email protected]!