Nota:

Este tutorial está disponible en un entorno de prácticas gratuitas proporcionado por Oracle.
Utiliza valores de ejemplo para credenciales, arrendamiento y compartimentos de Oracle Cloud Infrastructure. Al finalizar el laboratorio, sustituya estos valores por valores específicos de su entorno en la nube.

TAREA 5: Creación de una imagen nativa de una aplicación Micronaut y despliegue en Oracle Cloud

En este laboratorio, aprenderá a convertir su aplicación Java en un ejecutable nativo de Linux con GraalVM Native Image. Después de eso, lo desplegará en una máquina virtual en Oracle Cloud.

Tiempo estimado: 20 minutos

Contenido de tarea

En esta tarea:

Ejecución de una aplicación Micronaut en JVM en Oracle Cloud
Cree un ejecutable nativo de Linux de su aplicación Micronaut
Despliegue su aplicación Micronaut como un ejecutable nativo en Oracle Cloud
Configure el firewall para permitir el tráfico a una instancia en la nube (opcional).

Paso 1: Ejecución de una aplicación Micronaut en JVM en Oracle Cloud

En este paso, desplegará una aplicación Micronaut tradicionalmente en JVM (desde un archivo JAR) en Oracle Cloud. Continuará utilizando el código VS, donde GraalVM Enterprise 22.0.0 está definido como JDK por defecto.

Vaya a Terminal, New Terminal y ejecute este comando para verificar la versión de Java:
```
java -version
```
Cada vez que llame al comando java, se aplicará el compilador de JIT de Graal optimizado, activado por defecto en GraalVM Enterprise.
Puede empaquetar un proyecto Java en un archivo JAR ejecutable e iniciar la aplicación desde el terminal de código VS o invocando la acción Ejecutar principal.
- Vaya a Terminal, luego a Nuevo terminal y ejecute el objetivo mn:run:
```
./mvnw mn:run
```
  Si utiliza Gradle, ejecute la tarea run:
```
./gradlew run
```
- También puede encontrar el archivo de clase Application.java en el código VS. Haga clic en Ejecutar principal encima del método principal:
  
  La aplicación se inicia en el puerto 8080. Tenga en cuenta el tiempo que se tarda en iniciarlo (se espera que empiece en unos 6500 ms).
Termine la aplicación:
```
CTLR +C
```

Paso 2: Creación de un ejecutable nativo de Linux de una aplicación Micronaut

Puede transformar cualquier aplicación Java en un ejecutable nativo con GraalVM Native Image. Se trata de una tecnología de compilación anticipada que permite convertir el código de byte Java en un binario nativo independiente que no necesita que se ejecute un JDK y que está diseñada para ejecutarse en un entorno de destino específico.

Como ya se ha mencionado, para la comodidad de los usuarios, GraalVM Enterprise 22 está preinstalado en la máquina virtual. Lo mismo ocurre con Native Image, que se agrega con todas las bibliotecas dependientes (por ejemplo, libstdc++-static, glibc, zlib, etc.). La utilidad native-image se coloca en el directorio de instalación de GraalVM ($JAVA_HOME/bin).

En la ventana de terminal de código VS, verifique la versión de Native Image:
```
native-image --version
```
Ejecute este comando único para crear un ejecutable nativo de Linux:
- Si utiliza Maven, especifique el formato de empaquetado native-image:
```
./mvnw clean package -Dpackaging=native-image
```
- Si utiliza Gradle, ejecute la tarea nativeImage:
```
./gradlew nativeCompile
```
Después de algún tiempo, se incorporará un ejecutable nativo denominado ocidemo en el directorio /target/native-image/. Si utiliza Gradle, el ejecutable denominado ocidemo se escribirá en la carpeta /build/native/nativeCompile/.

Nota: El tiempo que se tarda en crear un ejecutable depende del tamaño y la complejidad de la aplicación y puede tardar algún tiempo en usar máquinas virtuales con baja energía. Con las capacidades de la instancia de VM asignada para este laboratorio, el tiempo esperado es de aproximadamente 5 minutos.

GraalVM Native Image crea un archivo ejecutable con todas las clases de aplicaciones, clases de biblioteca dependientes, clases de JDK dependientes y una instantánea de la pila de aplicaciones. Mientras que la creación de una imagen nativa puede llevar algún tiempo, las ventajas incluyen una reducción drástica del tiempo de inicio y un consumo total de memoria reducido.

Paso 3: despliegue de la aplicación Micronaut en OCI

En el paso anterior, creó un ejecutable nativo de Linux de su aplicación Micronaut. Ahora desplegará este ejecutable nativo en Oracle Cloud y comparará los tiempos de inicio al ejecutar la misma aplicación desde un archivo JAR y como una imagen nativa.

Para desplegar la aplicación como un ejecutable nativo, invoque un archivo binario generado en el paso anterior:

Si ha utilizado Maven:

./target/ocidemo

Si ha utilizado Gradle:

./build/native/nativeCompile/ocidemo

Tenga en cuenta cuánto más rápido se tarda en iniciar este microservicio Micronaut como una imagen nativa que desde un archivo JAR en el paso 1 (debe pasar de aproximadamente 6500 milisegundos a 2500). Se inicia más rápido porque el ejecutable es un binario independiente y no requiere que se ejecute un JDK, lo que hace que sea una forma fácil de distribuir las aplicaciones. El tamaño de archivo también es bastante pequeño.

El despliegue de un microservicio Java como ejecutable nativo ayuda a lograr inicio instantáneo, menos consumo de CPU y memoria, lo que convierte a GraalVM Enterprise en un buen candidato para crear aplicaciones Java nativas en la nube y para despliegues en la nube.

La aplicación se está ejecutando correctamente en este punto, pero para acceder a ella, por ejemplo, desde un explorador, deberá permitir el tráfico entrante a la máquina virtual. Termine la aplicación, CTRL+C, y continúe con el siguiente paso.

Paso 4: configure el firewall para permitir el tráfico a su instancia en la nube (opcional)

Para verificar esta aplicación de servidor que se ejecuta en Oracle Cloud y abrirla en un explorador, debe asegurarse de que el firewall del host permite el tráfico a la máquina virtual.

Vuelva a la consola en la nube, vaya a Recursos informáticos y, a continuación, a Instancias.
Cuando se haya conectado a la consola de OCI, vaya a Recursos informáticos y haga clic en Instancias. Asegúrese de que está en el compartimento necesario (consulte la tarea 1, paso 3).
Busque la instancia de VM (nombre que comienza con graal-workshop-...) en la vista principal y ábrala.
En la sección VNIC primaria, haga clic en Subred a la que está asociada la instancia (subnet-01).
En la página de subred, haga clic en Lista de seguridad interna.
Pulse Agregar regla de entrada y rellene los siguientes datos.

La regla permite que el tráfico de todos los orígenes utilice el puerto 8080, de modo que se pueda acceder a la aplicación desde cualquier lugar.
Vuelva a la ventana de terminal y ejecute los siguientes comandos para reiniciar el firewall en la instancia de VM en ejecución.
```
sudo firewall-cmd --permanent --add-port=8080/tcp
```
```
sudo systemctl reload firewalld
```
Reinicie la aplicación como un ejecutable nativo.

Creado con Maven:
```
./target/ocidemo
```
Creado con Gradle:
```
./build/native/nativeCompile/ocidemo
```
Abra la aplicación en un explorador con http://<SERVER_IP>:8080/pets para el punto final /pet y http://<SERVER_IP>:8080/owners para el punto final /owners. También puede dividir la ventana de terminal en el código VS y enviar una solicitud GET con curl:
```
curl -i http://<SERVER_IP>:8080/pets
```

felicitaciones Ha finalizado correctamente esta práctica.

Más información

Disfrute de una experiencia de laboratorio práctica con GraalVM Native Image y empiece a crear aplicaciones Java nativas en la nube ejecutando el laboratorio de inicio rápido de GraalVM Native Image.
Consulte la documentación de GraalVM Enterprise
Vea el vídeo de presentación sobre la creación de aplicaciones multinube sin servidor con Micronaut y GraalVM.

Vídeo para la creación de aplicaciones multinube sin servidor con Micronaut y GraalVM

Para terminar esta sesión, haga clic en el botón End Session de la barra de herramientas.