No cenário dinâmico do desenvolvimento de software moderno, os microsserviços se tornaram a abordagem arquitetônica preferida. Embora esta metodologia ofereça inúmeras vantagens, ela apresenta desafios. Problemas como grande consumo de memória, tempos de inicialização estendidos e alto uso de CPU geralmente acompanham os serviços tradicionais baseados em JVM. Esses desafios não afetam apenas os aspectos técnicos, mas também têm implicações financeiras que podem afetar significativamente o custo geral de operação e manutenção de soluções de software.

O que é imagem nativa GraalVM?

GraalVM Native Image é um recurso chave do GraalVM, que é um tempo de execução de alto desempenho que fornece suporte para várias linguagens de programação e modos de execução. Especificamente, GraalVM Native Image permite compilar aplicativos Java antecipadamente em executáveis ​​nativos independentes, ignorando a necessidade de uma Java Virtual Machine (JVM) durante o tempo de execução. Essa abordagem inovadora produz arquivos executáveis ​​que apresentam tempos de inicialização quase instantâneos e consumo de memória significativamente reduzido em comparação com suas contrapartes JVM tradicionais. Esses executáveis ​​nativos são meticulosamente elaborados, contendo apenas as classes, métodos e bibliotecas dependentes essenciais, indispensáveis ​​para a funcionalidade do aplicativo. Além de suas proezas técnicas, o GraalVM Native Image surge como uma solução estratégica com implicações de longo alcance. Não só supera desafios técnicos, mas também apresenta argumentos financeiros convincentes. Ao facilitar o desenvolvimento de aplicativos Java nativos da nuvem eficientes, seguros e instantaneamente escalonáveis, o GraalVM se torna fundamental na otimização da utilização de recursos e na promoção da economia. Em essência, desempenha um papel fundamental na elevação do desempenho e da eficiência financeira de soluções de software em ambientes contemporâneos e dinâmicos.

Desafios técnicos e implicações financeiras

1. Grandes pegadas de memória

Impacto técnico
Os serviços tradicionais baseados em JVM geralmente incorrem em sobrecarga substancial de memória devido ao carregamento de classe e aos metadados das classes carregadas.

Caso financeiro
O alto consumo de memória se traduz em maiores custos de infraestrutura. A eliminação de metadados para classes carregadas e outras otimizações do GraalVM leva a um uso mais eficiente de recursos, resultando em possíveis economias de custos.

2. Horários de início estendidos

Impacto técnico
Inicializações a frio em microsserviços podem levar a tempos de resposta mais altos, impactando a experiência do usuário e potencialmente causando degradação do serviço.

Caso financeiro
Tempos de início prolongados não afetam apenas a satisfação do usuário, mas também contribuem para custos operacionais mais elevados. As otimizações do GraalVM, como a eliminação da sobrecarga de carregamento de classe e a pré-geração de heap de imagem durante a construção, reduzem drasticamente os tempos de inicialização, minimizando potencialmente as despesas operacionais.

3. Alto uso da CPU

Impacto técnico
JVMs tradicionais geralmente queimam ciclos de CPU para criação de perfil e compilação Just-In-Time (JIT) durante a inicialização.

Caso financeiro
O uso excessivo da CPU resulta em aumento dos custos de infraestrutura em nuvem. O fato de o GraalVM evitar criação de perfil e sobrecarga de JIT contribui diretamente para a redução do consumo de CPU, traduzindo-se em economia potencial de custos no uso da nuvem.

Resolvendo o problema da partida a frio

Os microsserviços, especialmente em ambientes sem servidor ou em contêineres, muitas vezes enfrentam o problema de inicialização a frio, afetando os tempos de resposta e a experiência do usuário. GraalVM aborda esse desafio implementando diversas otimizações:

1. Sem sobrecarga de carregamento de classe

Aplicativos Java tradicionais dependem do carregamento de classe em tempo de execução para carregar e vincular classes dinamicamente. Este processo introduz sobrecarga, especialmente durante a fase de inicialização. GraalVM minimiza essa sobrecarga por meio de um processo conhecido como compilação estática ou antecipada (AOT). Isso envolve pré-carregar, vincular e iniciar parcialmente todas as classes exigidas pelo aplicativo. Como resultado, não há necessidade de carregamento de classe em tempo de execução durante a inicialização do aplicativo.

2. Eliminação de código interpretado

Java Virtual Machines tradicionais dependem de um modo de execução interpretado antes de aplicar a compilação Just-In-Time (JIT). Isso pode contribuir para atrasos na inicialização e aumento do uso da CPU. Os executáveis ​​nativos não contêm código interpretado, contribuindo ainda mais para tempos de inicialização mais rápidos.

3. Sem sobrecarga de criação de perfil e JIT

GraalVM ignora a necessidade de iniciar o compilador Just-In-Time (JIT), reduzindo o uso da CPU durante a inicialização.

4. Geração de heap de imagem em tempo de construção

O utilitário de imagem nativo do GraalVM permite a execução de processos de inicialização para classes específicas durante o processo de construção. Isso resulta na geração de um heap de imagens que inclui partes pré-inicializadas, acelerando a inicialização do aplicativo.

O utilitário de imagem nativo do Oracle GraalVM demonstrou tempos de inicialização quase 100 vezes mais rápidos do que os aplicativos tradicionais baseados em JVM. O gráfico abaixo ilustra a redução substancial nos requisitos de memória de tempo de execução, mostrando a eficiência do GraalVM em comparação com o HotSpot(Figura 1).

Figura 1 – Executáveis ​​nativos iniciam quase instantaneamente(oracle.com)

Alcançando uma pegada de memória mais enxuta

GraalVM contribui para reduzir o consumo de memória por meio das seguintes otimizações:

1. Sem metadados para classes carregadas

GraalVM evita armazenar metadados para classes carregadas dinamicamente na memória não heap. Durante o processo de construção, as informações de classe necessárias são pré-carregadas e vinculadas, minimizando a necessidade de metadados adicionais em tempo de execução.

2. Sem dados de criação de perfil ou otimizações JIT

Como o bytecode já está em código nativo, o GraalVM elimina a necessidade de coletar dados de perfil para otimizações JIT, reduzindo a sobrecarga de memória.

3. Tecnologia de isolamento

GraalVM apresenta Isolates, uma tecnologia que particiona o heap em "heaps" menores e independentes, aumentando a eficiência, especialmente em cenários de processamento de solicitações.

Em comum, ele consome até x5 vezes menos memória em comparação com a execução em uma JVM(Figura 2)

Figura 2 – Memória de executáveis ​​nativos comparada com Go ou Java HotSpot(oracle.com)

Concluindo, o utilitário de imagem nativo do GraalVM oferece uma solução transformadora para os desafios apresentados pelos microsserviços, abordando o tempo de inicialização, o consumo de memória e as preocupações com o uso da CPU. Ao adotar o GraalVM, os desenvolvedores podem criar aplicativos Java nativos da nuvem que não são apenas eficientes e seguros, mas também fornecem uma experiência de usuário superior.

Java nativo com Quarkus

Para compilar seu serviço Quarkus em uma imagem nativa, vários métodos estão disponíveis. Embora este artigo não se aprofunde no procedimento de construção nativo do Quarkus, ele fornece uma visão geral das etapas essenciais.

Antes de prosseguir com qualquer abordagem para construir uma imagem nativa, é crucial configurar o perfil nativo adequado em seu arquivo pom.xml. Adicione o seguinte perfil:

nativenative

Produzindo um executável nativo com GraalVM instalado

Verifique sua versão do GraalVM usando o seguinte comando:

./gu info native-image

Este comando exibirá a versão instalada do GraalVM:

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

E para criar um executável nativo, use:

./mvnw install -Dnative

Esses comandos geram um binário *-runner no diretório de destino, permitindo que você execute o executável nativo:

./target/*-runner

Criando um executável nativo sem GraalVM instalado

Se a instalação do GraalVM localmente apresenta desafios, uma compilação no contêiner pode ser usada:

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

Este comando inicia a construção dentro de um contêiner Docker e fornece o arquivo de imagem necessário. Você pode então iniciar o aplicativo com:

./target/*-runner

Nos casos em que a construção da imagem nativa se mostra desafiadora, a equipe RedHat fornece uma distribuição especializada do GraalVM projetada para a estrutura Quarkus chamada Mandrel. Mandril simplifica
GraalVM, concentrando-se exclusivamente nos recursos de imagem nativa essenciais para aplicações Quarkus. Para usar o Mandrel, siga estas etapas:

1. Identifique a versão apropriada do Mandrel Repositório do Mandrel

2. Defina a versão do Mandrel em seu arquivo application.properties:
   

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

3.Execute o comando de compilação do Maven:

./mvnw clean install -Pnative

Criando manualmente um contêiner

Para aqueles que preferem o controle manual sobre a criação de contêineres, uma construção Docker de vários estágios pode ser empregada.

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 orquestra uma construção de vários estágios, resultando em uma imagem Docker com seu aplicativo Quarkus. Execute este Dockerfile para produzir a imagem Docker, pronta para executar seu aplicativo Quarkus.

Resumo

GraalVM Native Image é uma tecnologia poderosa que pode revolucionar a maneira como você desenvolve e implanta microsserviços Java. Ao adotar o GraalVM Native Image, você pode criar microsserviços que são:

• Mais rápido
• Mais escalável
• Mais simples de implantar
• Mais econômico

GraalVM Native Image é um facilitador chave do desenvolvimento Java nativo da nuvem e pode ajudá-lo a alcançar o desempenho, escalabilidade e economia de custos que seu negócio exige.