En el panorama dinámico del desarrollo de software moderno, los microservicios se han convertido en el enfoque arquitectónico preferido. Si bien esta metodología ofrece numerosas ventajas, no está exenta de desafíos. Problemas como grandes ocupaciones de memoria, tiempos de inicio extendidos y uso elevado de CPU suelen acompañar a los servicios tradicionales basados ​​en JVM. Estos desafíos no solo afectan los aspectos técnicos sino que también tienen implicaciones financieras que pueden afectar significativamente el costo general de ejecución y mantenimiento de las soluciones de software.

¿Qué es la imagen nativa de GraalVM?

GraalVM Native Image es una característica clave de GraalVM, que es un tiempo de ejecución de alto rendimiento que brinda soporte para varios lenguajes de programación y modos de ejecución. Específicamente, GraalVM Native Image le permite compilar aplicaciones Java con anticipación en ejecutables nativos independientes, evitando la necesidad de una máquina virtual Java (JVM) durante el tiempo de ejecución. Este enfoque innovador produce archivos ejecutables que presentan tiempos de inicio casi instantáneos y un consumo de memoria significativamente reducido en comparación con sus homólogos JVM tradicionales. Estos ejecutables nativos están meticulosamente diseñados y contienen solo las clases, métodos y bibliotecas dependientes esenciales indispensables para la funcionalidad de la aplicación. Más allá de su destreza técnica, GraalVM Native Image surge como una solución estratégica con implicaciones de gran alcance. No sólo supera los desafíos técnicos sino que también presenta un argumento financiero convincente. Al facilitar el desarrollo de aplicaciones Java nativas en la nube eficientes, seguras e instantáneamente escalables, GraalVM se vuelve fundamental para optimizar la utilización de recursos y fomentar la rentabilidad. En esencia, desempeña un papel fundamental a la hora de elevar el rendimiento y la eficiencia financiera de las soluciones de software en entornos dinámicos y contemporáneos.

Desafíos técnicos e implicaciones financieras

1. Grandes huellas de memoria

Impacto técnico
Los servicios tradicionales basados ​​en JVM a menudo generan una sobrecarga sustancial de memoria debido a la carga de clases y los metadatos de las clases cargadas.

Caso financiero
El alto consumo de memoria se traduce en mayores costos de infraestructura. La eliminación de metadatos de GraalVM para las clases cargadas y otras optimizaciones conduce a un uso más eficiente de los recursos, lo que resulta en posibles ahorros de costos.

2. Horarios de inicio extendidos

Impacto técnico
Los arranques en frío en microservicios pueden generar tiempos de respuesta más altos, lo que afecta la experiencia del usuario y potencialmente provoca una degradación del servicio.

Caso financiero
Los tiempos de inicio extendidos no sólo afectan la satisfacción del usuario sino que también contribuyen a mayores costos operativos. Las optimizaciones de GraalVM, como la eliminación de la sobrecarga de carga de clases y la generación previa del montón de imágenes durante la compilación, reducen drásticamente los tiempos de inicio, minimizando potencialmente los gastos operativos.

3. Uso elevado de CPU

Impacto técnico
Las JVM tradicionales a menudo queman ciclos de CPU para generar perfiles y compilar Just-In-Time (JIT) durante el inicio.

Caso financiero
El uso excesivo de la CPU genera mayores costos de infraestructura en la nube. El hecho de que GraalVM evite la generación de perfiles y la sobrecarga de JIT contribuye directamente a reducir el consumo de CPU, lo que se traduce en posibles ahorros de costos en el uso de la nube.

Abordar el problema del arranque en frío

Los microservicios, especialmente en entornos sin servidor o en contenedores, a menudo enfrentan el problema del arranque en frío, lo que afecta los tiempos de respuesta y la experiencia del usuario. GraalVM aborda este desafío implementando varias optimizaciones:

1. Sin gastos generales de carga de clases

Las aplicaciones Java tradicionales dependen de la carga de clases en tiempo de ejecución para cargar y vincular clases dinámicamente. Este proceso introduce gastos generales, particularmente durante la fase de inicio. GraalVM minimiza esta sobrecarga mediante un proceso conocido como compilación estática o anticipada (AOT). Esto implica precargar, vincular e iniciar parcialmente todas las clases que requiere la aplicación. Como resultado, no es necesario cargar clases en tiempo de ejecución durante el inicio de la aplicación.

2. Eliminación del código interpretado

Las máquinas virtuales Java tradicionales se basan en un modo de ejecución interpretado antes de aplicar la compilación Just-In-Time (JIT). Esto puede contribuir a retrasos en el inicio y a un mayor uso de la CPU. Los ejecutables nativos no contienen código interpretado, lo que contribuye aún más a tiempos de inicio más rápidos.

3. Sin gastos generales de creación de perfiles y JIT

GraalVM evita la necesidad de iniciar el compilador Just-In-Time (JIT), lo que reduce el uso de la CPU durante el inicio.

4. Generación de montón de imágenes en el momento de la compilación

La utilidad de imagen nativa de GraalVM permite la ejecución de procesos de inicialización para clases específicas durante el proceso de construcción. Esto da como resultado la generación de un montón de imágenes que incluye partes preinicializadas, lo que acelera el inicio de la aplicación.

La utilidad de imágenes nativa de Oracle GraalVM ha demostrado tiempos de inicio casi 100 veces más rápidos que las aplicaciones tradicionales basadas en JVM. El siguiente gráfico ilustra la reducción sustancial en los requisitos de memoria de tiempo de ejecución y muestra la eficiencia de GraalVM en comparación con HotSpot (Figura 1).

Figura 1: los ejecutables nativos se inician casi instantáneamente (oracle.com)

Lograr una huella de memoria más eficiente

GraalVM contribuye a reducir el uso de memoria a través de las siguientes optimizaciones:

1. Sin metadatos para clases cargadas

GraalVM evita almacenar metadatos para clases cargadas dinámicamente en la memoria que no es del montón. Durante el proceso de construcción, la información de clase necesaria se carga previamente y se vincula, lo que minimiza la necesidad de metadatos adicionales en tiempo de ejecución.

2. Sin datos de perfiles ni optimizaciones JIT

Dado que el código de bytes ya está en código nativo, GraalVM elimina la necesidad de recopilar datos de perfiles para optimizaciones JIT, lo que reduce la sobrecarga de memoria.

3. Tecnología de aislamiento

GraalVM presenta Isolates, una tecnología que divide el montón en "montones" más pequeños e independientes, lo que mejora la eficiencia, particularmente en escenarios de procesamiento de solicitudes.

En común, consume hasta x5 veces menos memoria en comparación con ejecutarse en una JVM(Figura 2)

Figura 2: memoria de ejecutables nativos en comparación con Go o Java HotSpot (oracle.com)

En conclusión, la utilidad de imágenes nativa de GraalVM ofrece una solución transformadora a los desafíos que plantean los microservicios, abordando las preocupaciones sobre el tiempo de inicio, la huella de memoria y el uso de la CPU. Al adoptar GraalVM, los desarrolladores pueden crear aplicaciones Java nativas de la nube que no solo son eficientes y seguras, sino que también brindan una experiencia de usuario superior.

Java nativo con Quarkus

Para compilar su servicio Quarkus en una imagen nativa, hay varios métodos disponibles. Si bien este artículo no profundizará en el procedimiento de compilación nativa de Quarkus, sí proporciona una descripción general de los pasos esenciales.

Antes de continuar con cualquier método para crear una imagen nativa, es crucial configurar el perfil nativo adecuado en su archivo pom.xml. Añade el siguiente perfil:

nativenative

Produciendo un ejecutable nativo con GraalVM instalado

Comprueba tu versión de GraalVM usando el siguiente comando:

./gu info native-image

Este comando mostrará la versión de GraalVM instalada:

Downloading: Component catalog from www.graalvm.org
Filename : https://github.com/graalvm/graalvm-ce-builds/releases/download/vm-22.3.0/native-image-installable-svm-java19-linux-amd64-22.3.0.jar
Name     : Native Image
ID       : native-image
Version  : 22.3.0
GraalVM  : 22.3.0
Stability: Experimental
Component bundle native-image cannot be installed
        - The same component Native Image (org.graalvm.native-image[22.3.0.0/55b341ca1bca5219aafa8ed7c8a2273b81d184dd600d8261c837fc32d2dedae5]) is already installed in version 22.3.0

Y para crear un ejecutable nativo, use:

./mvnw install -Dnative

Estos comandos generan un binario *-runner en el directorio de destino, lo que le permite ejecutar el ejecutable nativo:

./target/*-runner

Creación de un ejecutable nativo sin GraalVM instalado

Si la instalación de GraalVM localmente plantea desafíos, se puede utilizar una compilación en el contenedor:

./mvnw install -Dnative -Dquarkus.native.container-build=true -Dquarkus.native.builder-image=graalvm

Este comando inicia la compilación dentro de un contenedor Docker y proporciona el archivo de imagen necesario. Luego puede iniciar la aplicación con:

./target/*-runner

En los casos en los que crear la imagen nativa resulta desafiante, el equipo de RedHat proporciona una distribución especializada de GraalVM diseñada para el marco Quarkus llamada Mandrel. Mandril agiliza
GraalVM, centrándose únicamente en las capacidades de imágenes nativas esenciales para las aplicaciones Quarkus. Para usar Mandrel, sigue estos pasos:

1. Identificar la versión de Mandrel adecuada Repositorio de Mandrel

2. Establezca la versión de Mandrel en su archivo application.properties:
   

quarkus.native.builder-image=quay.io/quarkus/ubi-quarkus-mandrel-builder-image:23.0.1.2-Final-java17

3.Ejecute el comando de compilación de Maven:

./mvnw clean install -Pnative

Crear manualmente un contenedor

Para aquellos que prefieren el control manual sobre la creación de contenedores, se puede emplear una compilación Docker de varias etapas.

FROM quay.io/quarkus/ubi-quarkus-mandrel-builder-image:23.0.1.2-Final-java17 AS build
COPY --chown=quarkus:quarkus mvnw /app/mvnw
COPY --chown=quarkus:quarkus .mvn /app/.mvn
COPY --chown=quarkus:quarkus pom.xml /app/
USER quarkus
WORKDIR /app
RUN ./mvnw -B org.apache.maven.plugins:maven-dependency-plugin:3.6.1:go-offline
COPY src /app/src
RUN ./mvnw package -Dnative

FROM quay.io/quarkus/quarkus-micro-image:2.0
WORKDIR /app/
COPY --from=build /app/target/*-runner /app/application

RUN chmod 775 /app /app/application \
  && chown -R 1001 /app \
  && chmod -R "g rwX" /app \
  && chown -R 1001:root /app

EXPOSE 8080
USER 1001

CMD ["./application", "-Dquarkus.http.host=0.0.0.0"]

Este Dockerfile organiza una compilación de varias etapas, lo que da como resultado una imagen de Docker con su aplicación Quarkus. Ejecute este Dockerfile para producir la imagen de Docker, lista para ejecutar su aplicación Quarkus.

Resumen

GraalVM Native Image es una tecnología poderosa que puede revolucionar la forma de desarrollar e implementar microservicios Java. Al adoptar GraalVM Native Image, puede crear microservicios que sean:

• Más rápido
• Más escalable
• Más sencillo de implementar
• Más rentable

GraalVM Native Image es un habilitador clave del desarrollo de Java nativo en la nube y puede ayudarle a lograr el rendimiento, la escalabilidad y el ahorro de costos que exige su negocio.