Sviluppare servizi in Java, incluse le API REST, non è sempre stato facile o produttivo fino all’arrivo della primavera e ha cambiato il panorama. Da allora sono passati molti anni e sono emersi nuovi quadri nella comunità.
Uno di questi framework era Micronaut. È sviluppato da OC, la stessa società dietro Grails, e il loro obiettivo è quello di aiutare gli sviluppatori a creare microservizi e applicazioni serverless.
C’è anche Quarkus, un altro framework che ha guadagnato popolarità nell’ultimo anno. Sviluppato da RedHat, Quarkus promette di fornire avvio veloce e meno utilizzo della memoria, due problemi comuni durante lo sviluppo di servizi REST in Java.
Con tutte queste scelte, c’è una domanda molto importante da porre: quanto è facile creare un servizio con ciascuno di questi tre framework?
In questo tutorial, creerai un’applicazione REST sicura usando Spring, Micronaut e Quarkus per vedere come differiscono l’uno dall’altro e quale meglio si adatta alle tue esigenze.
Sommario
- Prerequisiti per il Tuo Java API REST
- Creare un Okta Account per la Gestione degli Utenti
- creazione di un Token Usando OpenID Connect Debugger
- Costruire un Java API REST con Micronaut
- Sviluppare Il Servizio Java
- Costruire un Java API REST con Quarkus
- Costruire un Java API REST con Molla di Avvio
- considerazioni Finali su Api REST Con Java: Micronaut, Quarkus, e la Primavera di Avvio
Se vuoi, puoi guardare questo tutorial come uno screencast. Prerequisites
- Prerequisiti per la tua API REST Java
- Crea un account Okta per la gestione degli utenti
- Genera token utilizzando OpenID Connect Debugger
- Crea un’API REST Java con Micronaut
- Sviluppa il tuo servizio Java
- Crea un’API REST Java con Quarkus
- Crea un’API REST Java con Spring Boot
- Considerazioni finali sulle API REST Con Java: Micronaut, Quarkus e Spring Boot
Prerequisiti per la tua API REST Java
Questo tutorial utilizza Maven 3+. Assicurarsi che sia installato e disponibile per l’uso prima di continuare. Si può certamente anche usare Gradle, ma YMMV.
Stai per creare app che autenticano le richieste utilizzando OAuth 2.0, protette da un’applicazione Okta. Non hai un account Okta? Non ti preoccupare, ci vuole meno di un minuto per crearne uno nuovo. Non solo, ma Okta supporta standard come JWT, OAuth 2.0 e OIDC. Forniamo supporto per framework ben noti come Java EE, Spring Boot e Spring Security. Diamine, abbiamo anche un plugin Maven che automatizza tutto per voi.
Non c’è bisogno di reinventare la ruota!
Crea un account Okta per la gestione degli utenti
Apri il tuo terminale ed esegui il seguente comando:
mvn com.okta:okta-maven-plugin:registerTi verrà chiesto di inserire le seguenti informazioni:
- Nome
- Cognome
- Azienda
Dopo aver risposto alle domande, riceverai un’e-mail per attivare il tuo nuovo account. Dopo aver attivato il tuo account, esegui il seguente comando:
mvn com.okta:okta-maven-plugin:spring-bootQuesto comando crea un’applicazione per te con auth code flow e Spring Security redirect URI per Okta.
Per ricordare meglio, è possibile creare la stessa applicazione manualmente:
- Vai alla home page degli sviluppatori di Okta e accedi al tuo account.
- Clicca su Applicazioni > Aggiungi applicazione> Web> Avanti.
Vedrai la seguente schermata:
Prima di continuare, apporta le seguenti modifiche all’applicazione:
- URI di reindirizzamento di accesso:
http://localhost:8080/login/oauth2/code/oktahttps://oidcdebugger.com/debug
- tipo di Sovvenzione ammessi
- Codice di Autorizzazione
- Implicita (Ibrido)
L’implicita tipo di sovvenzione (con ID e Token di Accesso consentito controllato) è necessario recuperare un token di accesso nel tuo browser.
I campi non menzionati sopra possono mantenere i loro valori predefiniti.
Dopo averlo terminato, fai clic su Fine. La tua app è pronta!
Il passo successivo è imparare come generare un token valido usandolo.
Genera token utilizzando OpenID Connect Debugger
Okta consente di gestire gli utenti nel cloud utilizzando le sue API. Consente inoltre di proteggere le applicazioni utilizzando OAuth 2.0 e OpenID Connect (aka, OIDC). OAuth 2.0 fornisce un meccanismo per l’autorizzazione delegata, il che significa che non è necessario memorizzare le credenziali dell’utente nell’applicazione. Invece, puoi delegarlo a un provider OAuth 2.0 (Okta, in questo caso). OIDC fornisce un livello di identità in cima a OAuth 2.0 ed è per questo che le aziende come Okta sono chiamati “fornitori di identità”, o IDP.
Hai registrato la tua app con Okta e ora puoi generare un token per accedervi. Uno degli URI di reindirizzamento di accesso che hai registrato è per il sito web OpenID Connect.
Le tue richieste verranno convalidate utilizzando un token. Per generare questo token, si utilizzerà OpenID Connect Debugger. Questo sito vi fornirà un modo semplice per generare le credenziali per gli utenti sulla vostra applicazione Okta.
Vai alhttps://oidcdebugger.com e inserisci le seguenti informazioni:
- Autorizza URI:
https://{yourOktaDomain}/oauth2/default/v1/authorize - Reindirizza URI:
https://oidcdebugger.com/debug - Client ID:
{yourOktaClientId} - Applicazione:
openid email profile - Stato:
dev - Nonce: (mantenere il valore di default)
- tipo di Risposta:
token
È possibile trovare il valore di {yourOktaDomain} in alto a destra del tuo account home page:
Per trovare il tuo Okta Client ID seguire la procedura riportata di seguito:
- Vai a Applicazioni
- Seleziona la mia Web App
- Fai clic su Generale
L’ID client sarà disponibile nella sezione Credenziali client:
Dopo aver completato tutti i campi, fai clic su Invia richiesta. Verrai reindirizzato alla tua pagina di login Okta.
Una volta autenticato con successo, verrai reindirizzato nuovamente al Debugger OIDC, dove potrai vedere il token generato:
Utilizzerai questo token per accedere in modo sicuro ai servizi che stai per creare.
Ora che hai un account Okta e sai come generare token usando la tua applicazione Okta, iniziamo a confrontare i framework!
Crea un’API REST Java con Micronaut
Il primo passo per sviluppare il tuo servizio Micronaut è scaricare SDKMAN!. SDKMAN! è uno strumento per la gestione di versioni parallele di più SDK, che verrà utilizzato per installare il client Micronaut.
È possibile scaricare SDKMAN! eseguendo il seguente comando:
curl -s https://get.sdkman.io | bashOra, è possibile installare Micronaut stesso. Basta eseguire il seguente comando nel terminale:
sdk install micronautAl termine dell’esecuzione del comando, avrai l’ultima versione di Micronaut disponibile sul tuo computer.
Sei pronto per iniziare a sviluppare l’applicazione!
Sviluppa il tuo servizio Java
Vai alla directory in cui vuoi creare la tua applicazione ed esegui il seguente comando:
mn create-app com.okta.rest.app --build maven Questo comando creerà un progetto con la struttura di base di un progetto Micronaut. Micronaut usa Gradle per impostazione predefinita, ma dal momento che stai usando --build maven, userà invece Maven.
Il passo successivo è aggiungere le librerie di sicurezza all’interno del progetto. Modificare il filepom.xml e aggiungere le seguenti dipendenze:
<dependency> <groupId>io.micronaut</groupId> <artifactId>micronaut-security</artifactId></dependency><dependency> <groupId>io.micronaut</groupId> <artifactId>micronaut-security-jwt</artifactId></dependency>Queste dipendenze abiliteranno la sicurezza – in particolare OAuth 2.0 con JWT – all’interno del progetto. Ora che hai tutte le dipendenze in atto, puoi iniziare a creare il tuo endpoint.
Creare la seguente classe 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 annotazione indica di Micronaut che questo componente ricevere richieste nel /hello percorso.
La classe ha un solo metodo, denominato hello(). L’annotazione@Get mostra che il metodo riceverà richieste HTTP GET. Hai bisogno di @Produces perché il tipo di ritorno predefinito di Micronaut è un oggetto JSON. Poiché stai restituendo testo semplice, devi definire esplicitamente queste informazioni nel metodo.
L’ultima annotazione è@Secured. Dice semplicemente Micronaut che questo metodo è accessibile solo agli utenti autenticati.
Ora hai un controller protetto, ma non hai ancora definito la configurazione di sicurezza. Configuriamo Micronaut per connettersi alla tua applicazione Okta.
Rinomina src/main/resources/application.ymlapplication.properties e aggiungere la seguente configurazione di sicurezza:
micronaut.security.enabled=truemicronaut.security.token.jwt.enabled=truemicronaut.security.token.jwt.signatures.jwks.okta.url=https://{yourOktaDomain}/oauth2/default/v1/keysSostituire {yourOktaDomain} con il valore dei vostri Okta conto.
La configurazione sopra abilita la sicurezza usando OAuth 2.0. Dichiari che il tuo client OAuth 2.0 proviene da Okta, specificando l’emittente della tua organizzazione Okta.
Stai anche abilitando l’uso di token Web JSON o JWT. Poiché si desidera leggere le informazioni da Okta, è necessario dichiarare dove è possibile trovare i JWK (set di chiavi Web JSON) per convalidare le firme JWT.
È il momento di testare il vostro servizio! Avviare l’applicazione eseguendo il seguente comando:
./mvnw mn:runCon la tua app in esecuzione, eseguire il seguente comando:
curl -X GET -I http://localhost:8080/helloIl comando di sopra di produrre un risultato simile a questo:
HTTP/1.1 401 UnauthorizedDate: Tue, 8 Jan 2019 15:47:36 GMTtransfer-encoding: chunkedconnection: closeCome si può vedere, la richiesta di non passare attraverso. Per farlo funzionare, è necessario passare il token di accesso OAuth 2.0 recuperato dal debugger OIDC. Assegna il token di accesso a una variabileTOKEN nella shell.
TOKEN=eyJraWQiOiJxOE1QMjFNNHZCVmxOSkxGbFFWNlN...Esegui il comando qui sotto:
curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/helloOra funziona come previsto! Questa volta stai ricevendo il messaggio di saluto come risposta:
Hello, [email protected]!Puoi vedere che Micronaut richiede pochissimo codice per creare un’API REST sicura. Se hai contato le righe di codice, scopriresti che ~24% è dipendenze in XML (8 righe), il codice Java è solo 22 righe di codice e la configurazione di sicurezza richiede 3 righe. Il supporto integrato OAuth 2.0 di Micronaut rende facile l’integrazione con Okta e hanno persino una Guida per Okta nella loro documentazione.
Grande! Ora vediamo come si crea la stessa applicazione utilizzando Quarkus.
Crea un’API REST Java con Quarkus
Per sviluppare la tua applicazione usando Quarkus hai solo bisogno di Maven installato, non ci sono altre dipendenze richieste.
Iniziamo a creare la tua app! Vai alla directory in cui vuoi crearlo ed esegui il seguente comando:
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" Il comando sopra crea un progetto usando il plugin Quarkus Maven. Creerà una risorsa denominata HelloResource, che riceverà richieste sul percorso /hello. Stai anche aggiungendo l’estensione JWT da Quarkus sul progetto.
Una volta creato il progetto, modificare src/java/com/okta/rest/quarkus/HelloResource.java e aggiungere informazioni utente alhello() metodo:
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() + "!"; }}La classe sopra si comporterà allo stesso modo di quella creata in Micronaut. Legge le informazioni dell’utente in base al token generato nella richiesta e restituisce un messaggio di saluto all’utente che viene trovato.
Non hai ancora configurato Quarkus con l’emittente e le chiavi di Okta, quindi facciamolo.
Modificasrc/main/resources/application.propertiese aggiungi il seguente codice:
mp.jwt.verify.publickey.location=https://{yourOktaDomain}/oauth2/default/v1/keysmp.jwt.verify.issuer=https://{yourOktaDomain}/oauth2/defaultFatto! La versione Quarkus dell’applicazione è pronta per essere testata. Vai alla cartella del tuo progetto ed esegui il seguente comando:
./mvnw compile quarkus:devIl comando precedente avvierà l’applicazione.
Il primo passo è assicurarsi di ricevere un 401 - Unauthorized quando non si utilizzano le credenziali corrette.
Eseguire il seguente comando nel terminale:
curl -X GET -I http://localhost:8080/helloCome previsto, il risultato è una risposta HTTP 401:
HTTP/1.1 401 Unauthorizedwww-authenticate: Bearer {token}Content-Length: 0Se si esegue questa stessa richiesta, incluso il token dal Debugger OIDC, dovrebbe restituire il messaggio di saluto.
Esegui il seguente comando:
curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/helloHa funzionato come un incantesimo! Nel mio caso, il risultato è stato:
Hello, [email protected]!Quarkus richiede ancora meno righe di codice di Micronaut! Genera un’app con dipendenze incluse, ha 25 linee di codice Java e solo 2 linee di configurazione. Sì, le righe di codice sono un confronto stupido, ma mostra anche come questi framework richiedono pochissimo codice per sviluppare app sicure.
Due giù, uno per andare! Ora che sei stato in grado di implementare l’app su Micronaut e Quarkus, finiamo creando la stessa app usando Spring Boot.
Crea un’API REST Java con Spring Boot
Spring Boot non ha prerequisiti per iniziare a creare la tua app, quindi iniziamo creando il progetto!
Apri il tuo terminale ed esegui il seguente comando:
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 Il comando sopra creerà un file spring-boot.zip con un’applicazione di avvio a molla che utilizza Maven. È possibile estrarre il file in una directoryspring-boot utilizzando il comando seguente.
unzip spring-boot.zip -d spring-bootOra, implementerai il controller che riceverà le richieste.
Crea un pacchettocom.okta.rest.controller e una classeHelloController al suo interno:
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() + "!"; }} La configurazione qui è molto simile agli altri framework. Annoti la classe con@RestController per far sapere a Spring che riceverai richieste sulla classe. @GetMapping riceverà richieste HTTP GET sul percorso/hello. Per recuperare l’utente autenticato si utilizza l’annotazione @AuthenticationPrincipal.
Diverso dagli altri framework, non è necessario specificare che questo endpoint è autenticato poiché Spring controlla già queste informazioni dalle sue configurazioni.
L’ultimo passaggio consiste nell’aggiungere le informazioni dell’emittente, in modo che il supporto OIDC di Spring Security possa scoprire automaticamente gli endpoint con cui deve comunicare.
Modificasrc/main/resources/applications.propertiese aggiungi la seguente configurazione:
okta.oauth2.issuer=https://{yourOktaDomain}/oauth2/defaultTestiamolo! Inizia la tua app di avvio a molla usando Maven.
./mvnw spring-boot:runQuindi, aprire un terminale ed eseguire il seguente comando:
curl -X GET -I http://localhost:8080/helloLa risposta è un errore HTTP 401, in quanto non comprendono il 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 GMTeseguire nuovamente il Test, ora passa il token:
curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/helloha funzionato! Come per gli altri servizi, il risultato di questo comando è il seguente:
Hello, [email protected]!Spring Boot clocks nella quantità minima di codice richiesta: 17 linee di Java e solo 1 linea di configurazione! La primavera è sempre stata eccellente nel rendere più facile la vita degli sviluppatori, quindi non è una sorpresa.
Questo è tutto! Hai implementato un’API REST Java di base in tutti e tre i framework!
Considerazioni finali sulle API REST Con Java: Micronaut, Quarkus e Spring Boot
Quando si tratta di sviluppare le API REST, tutti e tre i framework hanno svolto bene il lavoro. Con solo un po ‘ di codice e qualche configurazione, sei stato in grado di sviluppare un’applicazione sicura usando Okta e OAuth 2.0.
Primavera è stato intorno per molti anni, è molto popolare, e ha molte caratteristiche intorno al suo ecosistema. Personalmente, credo ancora che sia la migliore opzione disponibile durante la programmazione in Java.
Micronaut e Quarkus stanno crescendo in popolarità e guadagnando slancio all’interno della comunità Java. Se stai affrontando problemi di prestazioni, o forse se stai male per un cambiamento, potresti provare uno di loro e vedere come va.
Le prestazioni sono il punto di confronto più spesso evidenziato tra questi tre framework. Se siete alla ricerca di avvio veloce in un ambiente serverless, o la possibilità di creare immagini native con GraalVM, Micronaut e Quarkus probabilmente funzionerà bene per voi. Solo per divertimento, i tempi di avvio per ciascuna di queste app sono i seguenti (in base alla media di tre tentativi):
- Micronaut: 474ms
- Quarkus: 1132ms
- Spring Boot: 1014ms
Ho ottenuto questi numeri dall’esecuzione degli obiettivi Maven di ogni framework per lo sviluppo.
- Micronaut:
./mvnw mn:run - Quarkus:
./mvnw compile quarkus:dev - Avvio a molla:
./mvnw spring-boot:run
Questi comandi non sono ottimizzati per la velocità, quindi ho impacchettato ogni applicazione con ./mvnw package e li ho avviati con java -jar.
- Micronaut: 596ms
- Quarkus: 658ms
- Spring Boot: 1878ms
NOTA: Questi numeri sono stati calcolati su un MacBook Pro 2019 con una CPU Intel Core i9 a 8 core da 2,4 GHz e 64 GB di RAM. OpenJDK 15 è stato utilizzato senzaJAVA_OPTS impostazione.
Se stai cercando tempi di avvio ancora più veloci, puoi usare GraalVM. Piuttosto che eseguire test di temporizzazione da solo, ho esaminato la documentazione di ogni progetto.
- Micronaut: 12ms in base alla creazione della prima applicazione Micronaut Graal.
- Quarkus: 14ms secondo Quarkus e GraalVM: Avvio ibernato a velocità supersonica, dimensione subatomica su InfoQ. I documenti Quarkus non elencano un tempo di avvio.
- Avvio a molla: 44ms secondo Spring Graal Native 0.6.0 rilasciato.
Alla fine, sarai in grado di sviluppare in modo produttivo un’applicazione sicura, indipendentemente dalla scelta che fai.
Vuoi dare un’occhiata al codice sorgente? Puoi trovarlo su GitHub su okta-java-rest-api-comparison-example.
Vuoi saperne di più su Java, API REST e applicazioni sicure? Qui ci sono alcune altre post dal nostro blog che vi possono essere utili:
- Guarda GraalVM Trasformare il Vostro Java In Binari
- OAuth 2.0 Java Guida: Sicura la Vostra Applicazione in 5 Minuti
- Java Microservices con Molla di Avvio e di Primavera Cloud
- Come Sviluppare un Quarkus Applicazione con Java e OIDC di Autenticazione
- Semplice Autenticazione con Molla di Sicurezza
Per ulteriori posti come questo, segui @oktadev su Twitter. Pubblichiamo regolarmente anche screencast sul nostro canale YouTube!
Changelog:
- 23 settembre 2020: aggiornato a Micronaut 2.0.2, Quarkus 1.8.1 e Spring Boot 2.3.4. Vedi le modifiche al codice nell’app di esempio su GitHub. Le modifiche a questo post possono essere visualizzate in oktadeveloper / okta-blog#423.
- 21 maggio 2020: aggiunti i tempi di avvio per
java -jare in esecuzione con GraalVM. Le modifiche a questo articolo possono essere visualizzate in oktadeveloper / okta-blog#304. - 20 maggio 2020: aggiornato a Micronaut 1.3.5, Quarkus 1.4.2 e Spring Boot 2.3.0. Vedi le modifiche al codice nell’app di esempio su GitHub. Le modifiche a questo articolo possono essere visualizzate in oktadeveloper / okta-blog#301.
- Jan 30, 2020: Aggiornato per ottimizzare Micronaut in base al feedback del team Micronaut. Anche ricalcolato tempi di avvio sulla base di una media di tre tentativi. Vedi le modifiche al codice nell’app di esempio su GitHub. Le modifiche a questo articolo possono essere visualizzate in oktadeveloper / okta-blog#176.