Como construir com GraalVM dentro das ações do GitHub

GitHub Actions é uma plataforma CI/CD que permite aos desenvolvedores de projetos no GitHub automatizar seus pipelines de construção, teste e implantação. GraalVM é um Java Development Kit (JDK) avançado com compilação antecipada de imagens nativas. Isso não apenas facilita a produção de executáveis ​​para diferentes plataformas, mas também mantém seu ciclo de desenvolvimento curto e agradável, porque você não precisa executar nenhuma compilação em sua máquina de desenvolvedor ao fazer alterações. Mais de 2.000 projetos de código aberto já estão fazendo isso – você também pode!

O GraalVM JDK está se tornando cada vez mais popular na comunidade Java, não apenas por causa de seu compilador just-in-time (JIT) de alto desempenho, mas também por causa de sua compilação antecipada de imagens nativas. Estruturas de microsserviços Java como Spring, Micronaut, Quarkus e Helidon adicionaram suporte de primeira classe para GraalVM, permitindo que os usuários transformem seus microsserviços em executáveis ​​que são eficientes, rápidos, mais seguros e fáceis de implantar. E a lista de bibliotecas e estruturas Java testadas com Native Image está em constante crescimento.

Muitos usuários estão entusiasmados com o GraalVM porque os executáveis ​​que ele gera ocupam pouco espaço de memória sem comprometer o desempenho, fornecem tempos de inicialização extremamente rápidos, têm segurança aprimorada graças a uma superfície de ataque reduzida, são independentes e também são mais baratos e fáceis de implantar. quando comparado com implantações convencionais baseadas em jlink. GraalVM oferece muitos benefícios para desenvolvedores Java, mas também traz alguns custos.

“Escreva uma vez, execute em qualquer lugar” e compilações lentas

Java ganhou muita popularidade como linguagem de programação devido à sua portabilidade. O GraalVM JDK ainda oferece portabilidade, mas os executáveis ​​nativos que ele gera são específicos da plataforma. Esta pode ser uma diferença óbvia entre a compilação JIT e a compilação antecipada (AOT). Para os desenvolvedores Java, no entanto, é uma mudança de paradigma: em vez de distribuir um arquivo JAR portátil, os desenvolvedores agora precisam gerar e distribuir um executável diferente para cada plataforma em que seu aplicativo é executado. Felizmente, os microsserviços são frequentemente implantados em servidores Linux usando hardware igual ou semelhante. Os desenvolvedores de ferramentas de interface de linha de comando, por outro lado, geralmente desejam fornecer executáveis ​​para usuários de macOS, Linux e Windows.

Tempos de inicialização rápidos são um dos benefícios dos executáveis ​​nativos. Eles apenas iniciam rapidamente porque a compilação AOT muda o trabalho do tempo de execução (quando o aplicativo é executado) para o tempo de construção (quando o aplicativo é compilado). Isso inclui o JDK e a inicialização do aplicativo (o tempo que leva para inicializar a biblioteca padrão do JDK e o aplicativo), o que pode tornar os aplicativos significativamente mais lentos, especialmente quando eles estão em execução curta. (O One Billion Row Challenge demonstrou isso muito bem.) GraalVM, no entanto, precisa analisar estaticamente e compilar AOT não apenas o aplicativo do usuário, mas também suas dependências e a maior parte do JDK do zero. Mesmo que isso aconteça em segundos, ainda não é tão rápido quanto compilar incrementalmente um aplicativo Java com o javac comando.

Compilar um aplicativo após cada alteração (e potencialmente para diversas plataformas diferentes) pode obviamente consumir muito tempo e retardar desnecessariamente o ciclo de desenvolvimento. CI/CD pode ajudar com isso.

Ações do GitHub para o resgate!

GitHub Actions é um dos muitos recursos do GitHub e fornece projetos de código aberto com executores gratuitos hospedados no GitHub. Recentemente, os recursos fornecidos por esses executores foram duplicados e o GitHub também adicionou novos executores M1 macOS.

Para usar GitHub Actions, os usuários só precisam criar um fluxo de trabalho que defina um ou mais trabalhos. Esses trabalhos podem consistir em múltiplas etapas, que por sua vez podem usar as chamadas ações. Você pode encontrar mais de 22.000 ações no GitHub Marketplace, que também inclui uma ação GitHub para GraalVM chamadasetup-graalvm.

A melhor maneira de mostrar como o GraalVM pode ser usado dentro do GitHub Actions é com um exemplo. Comece criando um arquivo main.yml no .github/fluxos de trabalho diretório de um repositório com o seguinte conteúdo:

O exemplo é totalmente independente, define um novo fluxo de trabalho chamado “GraalVM Native Image builds” e usa GraalVM para compilar um aplicativo HelloWorld no macOS, Windows e Ubuntu. O on: (push, pull_request, workflow_dispatch)par chave-valor instrui GitHub Actions a executar o fluxo de trabalho em cada git pushem solicitações pull e manualmente.

Para rodar em plataformas diferentes, defina uma matriz de construção simples. O MacOS 14 fornece os novos executores M1, permitindo aos usuários gerar executáveis ​​nativos para a arquitetura de hardware mais recente da Apple. Para Windows, use o Windows Server 2022 porque a imagem nativa do GraalVM requer o Visual Studio 2022 ou posterior. E para Linux, use Ubuntu 20.04, a versão mais antiga do Ubuntu suportada pelo GitHub, para maximizar a compatibilidade com outros sistemas Linux.

As etapas do trabalho de construção são as seguintes:

1. Verificar o repositório normalmente é a primeira etapa que você deseja realizar. Para este exemplo, entretanto, isso não é necessário porque o aplicativo HelloWorld está definido em linha no arquivo de fluxo de trabalho.
2. Use o GitHub Action for GraalVM para configurar o Oracle GraalVM para JDK 21, que é então adicionado ao$PATH. Ogithub-token é opcional, mas ajuda a ação a reduzir problemas de limitação de taxa ao conversar com a API do GitHub.native-image-job-reportsé uma das muitas outras opções apoiadas pelas ações. Mais sobre isso mais tarde.
3. Criar umaHelloWorld.java arquivo e compilá-lo com javac. Em vez de executá-lo comjava HelloWorldusar native-image HelloWorld para compilar o aplicativo em um executável nativo. A última linha desta etapa executa o executável. Faça upload do executável nativo como um artefato de cada trabalho. Alternativamente, você também pode fazer uma versão do GitHub — por exemplo, usando esta ação — ou implantar o executável em seu servidor ou serviço de nuvem preferido.

Veja o resultado deste exemplo em ação (sem trocadilhos):

Resumo de construção para o exemplo HelloWorld.

Na guia Ações do seu repositório, você encontrará entradas individuais para cada construção de todos os seus fluxos de trabalho. A captura de tela acima mostra a primeira compilação, quando você criou omain.yml arquivo. Todos os três trabalhos de construção ocorreram em 2 minutos e 13 segundos e produziram três artefatos no total. Esses artefatos podem ser facilmente baixados, transferidos por download e reutilizados em outros fluxos de trabalho ou excluídos do build. Nessa guia, você também pode clicar em qualquer trabalho de build, que fornece mais detalhes, incluindo o log de build.

Log de construção para o trabalho HelloWorld em execução no ubuntu-20.04.

Um log de construção pode ser bastante longo, especialmente para projetos mais complexos. É aqui quenative-image-job-reports opção entra em jogo. Ele instrui setup-graalvmpara produzir um relatório de construção e anexá-lo como um resumo do trabalho. Esses resumos são mostrados abaixo da lista de artefatos no resumo de construção. Aqui está o relatório correspondente para o trabalho em execução ubuntu-20.04:

Crie um relatório para o trabalho HelloWorld em execução no ubuntu-20.04.

O relatório de construção mostra que foram necessários 48 segundos para produzir um executável nativo para o aplicativo HelloWorld. Para isso, o job utilizou o Oracle GraalVM na configuração padrão com nível de otimização 2 (-O2) e otimização guiada por perfil inferida de aprendizado de máquina (PGO). A análise estática encontrou mais de 2.000 tipos acessíveis para o aplicativo HelloWorld, e o tamanho do arquivo executável produzido é de 7,79 MB no total. A compilação usou cerca de 814 MB de memória e foi executada em um dos executores atualizados com 16 GB de memória de sistema e quatro núcleos de CPU. O relatório também fornece muitos links para a documentação com mais informações.

Finalmente, há também uma opção chamadanative-image-pr-reports para gerar relatórios de construção. Em vez de adicioná-los como resumos de trabalhos, eles são adicionados automaticamente como comentários em pull requests. Isso facilita, por exemplo, detectar melhorias ou regressões ao atualizar dependências ou integrar novos recursos.

Configurando Seu Projeto

O exemplo HelloWorld ilustra como o GraalVM pode ser usado dentro do GitHub Actions. Projetos Java do mundo real são normalmente muito mais complexos, mas configurá-los costuma ser surpreendentemente simples, especialmente se você estiver usando uma das estruturas de microsserviços com suporte integrado ao GraalVM. Nesse caso, tudo o que você normalmente precisa fazer é executar um comando Maven ou Gradle para criar o executável nativo:

Se você não usa uma estrutura com suporte ao GraalVM, mas usa Maven ou Gradle, você pode adicionar o plug-in Maven ou o plug-in Gradle para GraalVM Native Build Tools à configuração do seu projeto. Então você deverá ser capaz de construir com os mesmos comandos acima. Os plug-ins também ajudam a testar uma versão nativa do seu aplicativo. Se você criar seu aplicativo manualmente comjavacbasta usarnative-image como um substituto imediato para ojava comando que de outra forma executaria seu aplicativo, como no exemplo HelloWorld.

Conclusão

Se você está tão entusiasmado com o GraalVM quanto muitos outros na comunidade Java, considere configurar pipelines de CI/CD para construir seu aplicativo com GraalVM para você e em diferentes plataformas!

Ao usar GraalVM dentro do GitHub Actions, você pode testar seu executável antes de carregá-lo como um artefato de construção ou implantá-lo diretamente em seu servidor ou serviço de nuvem. Dessa forma, você não precisa executar nenhuma compilação localmente, nem precisa de acesso a máquinas diferentes. E para projetos de código aberto, tanto a nova distribuição Oracle GraalVM quanto o GitHub Actions são de uso gratuito.

Se você tiver alguma sugestão, novas ideias ou casos de uso, sinta-se à vontade para entrar em contato conosco no Slack, GitHub ouX/Twitter.

E agora, feliz construção com GraalVM! 🚀

O post Como construir com GraalVM por dentro das ações do GitHub apareceu pela primeira vez em The New Stack.