Nota:

TASK 5: creazione di un'immagine nativa di un'applicazione Micronaut e distribuzione in Oracle Cloud

In questo laboratorio imparerai come trasformare la tua applicazione Java in un eseguibile Linux nativo con l'immagine nativa GraalVM. Una volta eseguita la distribuzione su una virtual machine in Oracle Cloud.

Tempo stimato: 20 minuti

Contenuto task

In questo task sarà possibile:

Passo 1: eseguire un'applicazione Micronaut sulla JVM in Oracle Cloud

In questo passo verrà distribuita un'applicazione Micronaut tradizionalmente sulla JVM (da un file JAR) in Oracle Cloud. Si continuerà a utilizzare il codice VS in cui GraalVM Enterprise 22.0.0 è impostato come JDK predefinito.

  1. Passare a Terminal, quindi a New Terminal ed eseguire questo comando per verificare la versione Java:

    java -version

    Ogni volta che si richiama il comando java, verrà applicato il compilatore GRA, abilitato per impostazione predefinita in GraalVM Enterprise.

  2. È possibile creare il package di un progetto Java in un file JAR eseguibile e avviare l'applicazione dal terminale codice VS o richiamando l'azione Esegui principale.

    • Andare a Terminale, quindi a Nuovo terminale ed eseguire l'obiettivo mn:run.

      ./mvnw mn:run

      Se si utilizza Gradle, eseguire il task run:

      ./gradlew run

    • In alternativa, trovare il file di classe Application.java nel codice VS, fare clic su Esegui principale sopra il metodo principale:

      Esegui azione rapida metodo principale

      L'applicazione viene avviata sulla porta 8080. Annotare il tempo necessario per avviarlo (si prevede che inizi in circa 6500 ms).

  3. Arresta l'applicazione:

    CTLR +C

Passo 2: creare un eseguibile Linux nativo di un'applicazione Micronaut

Puoi trasformare qualsiasi applicazione Java in un eseguibile nativo con l'immagine nativa di GraalVM. Si tratta di una tecnologia di compilazione in anticipo che consente di convertire il tuo bytecode Java in un binario nativo autocontenuto che non richiede l'esecuzione di JDK ed è progettato per eseguire in un ambiente di destinazione specifico.

Come già indicato, per comodità degli utenti, GraalVM Enterprise 22 è preinstallato sulla tua virtual machine. La stessa è l'immagine nativa, aggiunta con tutte le librerie dipendenti (ad esempio, libstdc++-static, glibc, zlib e così via). La utility native-image si trova nella directory di installazione di GraalVM ($JAVA_HOME/bin).

  1. Nella finestra Terminale codice VS verificare la versione dell'immagine nativa:

    native-image --version

  2. Eseguire questo comando singolo per creare un eseguibile Linux nativo:

    • Se si utilizza Maven, specificare il formato di packaging native-image:

    ./mvnw clean package -Dpackaging=native-image
    • Se si utilizza Gradle, eseguire il task nativeImage:

    ./gradlew nativeCompile

    Dopo qualche tempo, un eseguibile nativo denominato ocidemo verrà integrato nella directory /target/native-image/. Se si utilizza Gradle, l'eseguibile denominato ocidemo verrà scritto nella cartella /build/native/nativeCompile/.

    Nota: il tempo necessario per creare un eseguibile dipende dalle dimensioni e dalla complessità dell'applicazione e può richiedere del tempo su VM a basso consumo. Utilizzando la capacità dell'istanza VM allocata per questo laboratorio, il tempo previsto è di circa 5 minuti.

GraalVM Native Image crea un file eseguibile con tutte le classi di applicazioni, le classi di librerie dipendenti, le classi JDK dipendenti e uno snapshot dell'heap dell'applicazione. Sebbene la creazione di un'immagine nativa possa richiedere tempo, i vantaggi includono una riduzione significativa dei tempi di avvio e una riduzione del consumo complessivo di memoria.

Passo 3: distribuisci l'applicazione Micronaut in OCI

Nel passo precedente hai creato un eseguibile Linux nativo dell'applicazione Micronaut. Ora distribuisci questo eseguibile nativo in Oracle Cloud e confronta i tempi di avvio quando esegui la stessa applicazione da un file JAR e come immagine nativa.

Per distribuire l'applicazione come eseguibile nativo, richiamare un file binario generato nel passo precedente:

./target/ocidemo


./build/native/nativeCompile/ocidemo

Prendere nota della velocità di avvio di questo microservizio Micronaut come immagine nativa rispetto a un file JAR al Passo 1 (deve passare da circa 6500 millisecondi a 2500). Il programma si avvia più rapidamente perché il file eseguibile è un file binario auto-contenuto e non richiede un JDK per l'esecuzione, rendendo così facile distribuire le applicazioni. La dimensione dei file è anche abbastanza piccola.

La distribuzione di un microservizio Java come eseguibile nativo contribuisce a raggiungere l'avvio istantaneo, a ridurre il consumo di CPU e memoria, rendendo GraalVM Enterprise un buon candidato per creare applicazioni Java native nel cloud e per le distribuzioni cloud.

L'applicazione è in esecuzione a questo punto, ma per accedervi, ad esempio da un browser, sarà necessario consentire il traffico in entrata alla virtual machine. Arrestare l'applicazione, CTRL+C, e procedere al passo successivo.

Passo 4: configurare il firewall per consentire il traffico sull'istanza cloud (facoltativo)

Per verificare questa applicazione lato server in esecuzione in Oracle Cloud e aprirla in un browser, è necessario assicurarsi che il firewall host consenta il traffico sulla virtual machine.

  1. Tornare alla console cloud, accedere a Computazione, quindi a Istanze.

  2. Dopo aver eseguito il login alla console OCI, passare a Computazione e fare clic su Istanze. Assicurarsi di trovarsi nel compartimento necessario (vedere il task 1, passo 3).

    Trova istanze di computazione

  3. Trovare l'istanza VM (nome che inizia con graal-workshop-...) nella vista principale e aprirla.

  4. Nella sezione VNIC primaria fare clic su Subnet a cui è collegata l'istanza (subnet-01).

  5. Nella pagina della subnet, fare clic su Lista di sicurezza interna.

  6. Premere Aggiungi regola di entrata e inserire i dati seguenti.

    Aggiungi regola di entrata per consentire il traffico in entrata alla porta

    La regola consente al traffico da tutte le origini di utilizzare la porta 8080, in modo che l'applicazione possa essere raggiunta ovunque.

  7. Tornare alla finestra del terminale ed eseguire i comandi seguenti per riavviare il firewall nell'istanza VM in esecuzione.

    sudo firewall-cmd --permanent --add-port=8080/tcp


    sudo systemctl reload firewalld

  8. Riavviare l'applicazione come eseguibile nativo.

    Costruito con Maven:

    ./target/ocidemo

    Costruito con Gradle:

    ./build/native/nativeCompile/ocidemo

  9. Aprire l'applicazione in un browser utilizzando http://<SERVER_IP>:8080/pets per l'endpoint /pet e http://<SERVER_IP>:8080/owners per l'endpoint /owners. In alternativa, dividere la finestra del terminale in VS Code e inviare una richiesta GET con curl:

    curl -i http://<SERVER_IP>:8080/pets

Congratulazioni. Questo laboratorio è stato completato.

Per saperne di più

Per terminare questa sessione, fare clic sul pulsante Fine sessione nella barra degli strumenti.