Observação:

• Este tutorial está disponível em um ambiente de laboratório gratuito fornecido pela Oracle.
• Ele usa valores de exemplo para credenciais, tenancy e compartimentos do Oracle Cloud Infrastructure. Ao concluir seu laboratório, substitua esses valores por valores específicos do seu ambiente de nuvem.

TAREFA 5: Crie uma Imagem Nativa de um Aplicativo Micronaut e Implante no Oracle Cloud

Neste laboratório, você vai aprender a transformar seu aplicativo Java em um executável nativo do Linux com o GraalVM Native Image. Depois disso, você o implantará em uma máquina virtual no Oracle Cloud.

Tempo Estimado: 20 minutos

Conteúdo da Tarefa

Nesta tarefa você:

• Executar um aplicativo Micronaut na JVM no Oracle Cloud
• Crie um executável nativo do Linux do seu aplicativo Micronaut
• Implante seu aplicativo Micronaut como um executável nativo no Oracle Cloud
• Configure o firewall para permitir o tráfego para uma instância da nuvem (opcional)

Etapa 1: Execute um Aplicativo Micronaut na JVM no Oracle Cloud

Nessa etapa, você implantará um aplicativo Micronaut tradicionalmente no JVM (de um arquivo JAR) no Oracle Cloud. Você continuará usando o VS Code em que GraalVM Enterprise 22.0.0 é definido como o JDK padrão.

1. Vá para Terminal, em seguida, Novo Terminal e execute este comando para verificar a versão Java:

   

   java -version
   

   Toda vez que você chamar o comando java, o compilador Graal JIT otimizado, ativado no GraalVM Enterprise por padrão, será aplicado.

2. Você pode empacotar um projeto Java em um arquivo JAR executável e iniciar o aplicativo no Terminal de Código VS ou chamando a ação Executar Principal.

   • Vá para Terminal, Novo Terminal e execute a meta mn:run:

     

     ./mvnw mn:run
     

     Se você estiver usando Gradle, execute a tarefa run:

     

     ./gradlew run
     

   • Como alternativa, localize o arquivo de classe Application.java no VS Code, clique em Executar Principal acima do método principal:

     

     O aplicativo foi iniciado na porta 8080. Observe o tempo gasto para iniciá-lo (espera-se que comece em ~6500ms).

3. Encerre o aplicativo:

   

   CTLR +C
   

Etapa 2: Crie um Executável Nativo do Linux de um Aplicativo Micronaut

Você pode transformar qualquer aplicativo Java em um executável nativo com o GraalVM Native Image. É uma tecnologia de compilação de data futura que permite transformar seu código de bytes Java em um binário nativo independente que não requer a execução de um JDK e que foi projetado para executar em um ambiente de destino específico.

Como já foi mencionado, para conveniência dos usuários, o GraalVM Enterprise 22 é pré-instalado em sua máquina virtual. O mesmo é Native Image, que é adicionado com todas as bibliotecas dependentes (por exemplo, libstdc++-static, glibc, zlib etc.). O utilitário native-image é colocado no diretório de instalação do GraalVM ($JAVA_HOME/bin).

1. Na janela Terminal de Código VS, verifique a versão do Native Image:

   

   native-image --version
   

2. Execute este comando único para criar um executável nativo do Linux:

   • Se você estiver usando o Maven, especifique o formato de empacotamento native-image:

   

   ./mvnw clean package -Dpackaging=native-image
   

   • Se você estiver usando Gradle, execute a tarefa nativeImage:

   

   ./gradlew nativeCompile
   

   Após algum tempo, um executável nativo chamado ocidemo será incorporado ao diretório /target/native-image/. Se você estiver usando Gradle, o executável chamado ocidemo será gravado na pasta /build/native/nativeCompile/.

   Observação: O tempo para criar um executável depende do tamanho e da complexidade do aplicativo e pode levar algum tempo em VMs com baixa tecnologia. Usando as capacidades da instância de VM alocada para este laboratório, o tempo esperado é de aproximadamente 5 minutos.

O GraalVM Native Image cria um arquivo executável com todas as classes de aplicativo, classes de biblioteca dependentes, classes JDK dependentes e um instantâneo do heap do aplicativo. Embora a criação de uma imagem nativa possa levar algum tempo, os benefícios incluem uma redução drástica no tempo de inicialização e um consumo total de memória reduzido.

Etapa 3: Implante seu Aplicativo Micronaut no OCI

Na etapa anterior, você criou um executável nativo do Linux do seu Aplicativo Micronaut. Agora você implantará esse executável nativo no Oracle Cloud e comparará os tempos de inicialização ao executar o mesmo aplicativo a partir de um arquivo JAR e como uma imagem nativa.

Para implantar seu aplicativo como um executável nativo, chame um arquivo binário gerado na etapa anterior:

• Se você usou o Maven:

./target/ocidemo

• Se você usou Gradle:

./build/native/nativeCompile/ocidemo

Observe quanto mais rápido é necessário iniciar este micronaut microsserviço como uma imagem nativa do que em um arquivo JAR na Etapa 1 (deve saltar de ~6500 milissegundos para 2500). Ele começa mais rápido porque o executável é um binário independente e não requer que um JDK seja executado, o que facilita a distribuição dos aplicativos. O tamanho do arquivo também é muito pequeno.

A implantação de um microsserviço Java como um executável nativo ajuda a alcançar uma inicialização instantânea, reduzir o consumo de CPU e memória, tornando o GraalVM Enterprise um bom candidato à criação de aplicativos Java nativos da nuvem e para implantações em nuvem.

O aplicativo está sendo executado com sucesso neste ponto, mas para acessá-lo, por exemplo, em um browser, você precisará permitir o tráfego de entrada para sua máquina virtual. Encerre o aplicativo, CTRL+C, e vá para a próxima etapa.

Etapa 4: Configure o Firewall para Permitir Tráfego à Sua Instância da Nuvem (Opcional)

Para verificar esse aplicativo do servidor em execução no Oracle Cloud e abri-lo em um browser, certifique-se de que o firewall do host permita o tráfego para sua máquina virtual.

1. Retorne à console de nuvem, navegue até Compute e, em seguida, Instâncias.

2. Quando estiver conectado à Console do OCI, navegue até Compute e clique em Instâncias. Verifique se você está no compartimento necessário (consulte Tarefa 1, etapa 3).

   

3. Localize a instância de VM (nome que começa com graal-workshop-...) na view principal e abra-a.

4. Na seção VNIC Principal, clique na Sub-rede à qual sua instância está anexada (subnet-01).

5. Na página da sub-rede, clique em Lista de Segurança Interna.

6. Pressione Adicionar Regra de Entrada e preencha os seguintes dados.

   

   A regra permite que o tráfego de todas as origens use a porta 8080, para que o aplicativo possa ser acessado de qualquer lugar.

7. Retorne à janela do terminal e execute os comandos a seguir para reiniciar o firewall em sua instância de VM em execução.

   

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

   

   sudo systemctl reload firewalld
   

8. Reinicie o aplicativo como um executável nativo.

   Construído com Maven:

   

   ./target/ocidemo
   

   Construído com Gradle:

   

   ./build/native/nativeCompile/ocidemo
   

9. Abra o aplicativo em um browser usando http://<SERVER_IP>:8080/pets para o ponto final /pet e http://<SERVER_IP>:8080/owners para o ponto final /owners. Como alternativa, divida a janela do terminal no Código VS e envie uma solicitação GET com curl:

   

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

Parabéns! Você concluiu com sucesso este laboratório.

Saiba Mais

• Obtenha experiência prática usando o GraalVM Native Image e comece a criar aplicativos Java nativos em nuvem executando o laboratório GraalVM Native Image Quick Start.

• Verifique a documentação do GraalVM Enterprise

• Leia o vídeo introdutório sobre a criação de aplicativos sem servidor multinuvem com Micronaut e GraalVM.

  Vídeo para criar aplicativos sem servidor multicloud com Micronaut e GraalVM

Para encerrar esta sessão, clique no botão Encerrar sessão na barra de ferramentas.