Início rápido: Implante seu primeiro aplicativo Java Native Image nos Aplicativos Spring do Azure

Artigo
02/05/2024

Observação

As primeiras 50 horas de vCPU e os primeiros 100 GB de memória são gratuitos todos os meses. Para obter mais informações, confira Redução de preços – os Aplicativos Spring do Azure fazem mais, custando menos no blog Apps on Azure.

Observação

Azure Spring Apps é o novo nome do serviço Azure Spring Cloud. Embora o serviço tenha um novo nome, você verá o nome antigo em alguns locais por um tempo enquanto trabalhamos para atualizar ativos como capturas de tela, vídeos e diagramas.

Este artigo se aplica a(o):❌ Básico/Standard ✔️ Enterprise

Este início rápido mostra como implantar um aplicativo do Spring Boot nos Aplicativos Spring do Azure como Native Image.

A funcionalidade de Native Image permite compilar aplicativos Java para executáveis autônomos, conhecidos como Native Images. Esses executáveis podem fornecer benefícios significativos, incluindo tempos de inicialização mais rápidos e menor sobrecarga de memória de runtime em comparação com uma JVM (Máquina Virtual Java) tradicional.

O projeto de exemplo é o aplicativo Spring Petclinic. A captura de tela a seguir mostra o aplicativo:

1. Pré-requisitos

Uma assinatura do Azure. Caso não tenha uma assinatura, crie uma conta gratuita antes de começar.
Git.
Kit de Desenvolvimento Java (JDK), versão 17.
CLI do Azure versão 2.45.0 ou superior. Use o seguinte comando para instalar a extensão do Aplicativos Spring do Azure: az extension add --name spring
Se você estiver implantando uma instância de plano Enterprise do Aplicativos Spring do Azure pela primeira vez na assinatura de destino, confira a seção Requisitos em Exibir a oferta de camada Enterprise dos Aplicativos Spring do Azure no Azure Marketplace.

2. Preparar o projeto Spring Petclinic

Use as etapas a seguir para clonar e executar o aplicativo localmente.

Use o seguinte comando para clonar o projeto Spring Petclinic do GitHub:
```
git clone https://github.com/Azure-Samples/spring-petclinic.git
```

Use o seguinte comando para criar o projeto Spring Petclinic:

cd spring-petclinic
./mvnw clean package -DskipTests -Pnative package

Use o seguinte comando para executar o aplicativo Spring Petclinic usando o Maven:
```
java -jar target/spring-petclinic-3.1.0-SNAPSHOT.jar
```
Acesse http://localhost:8080 no navegador para acessar o aplicativo Spring Petclinic.

3. Preparar o ambiente de nuvem

O principal recurso necessário para executar o aplicativo Spring Petclinic é uma instância dos Aplicativos Spring do Azure. Esta seção fornece as etapas para criar o recurso.

3.1. Fornecer nomes para cada recurso

Crie variáveis para manter os nomes dos recursos usando os comandos a seguir. Substitua os espaços reservados pelos seus valores.

export RESOURCE_GROUP=<resource-group-name>
export LOCATION=<location>
export AZURE_SPRING_APPS_NAME=<Azure-Spring-Apps-service-instance-name>
export NATIVE_BUILDER=native-builder
export JAR_APP_NAME=jar-app
export NATIVE_APP_NAME=native-app
export JAR_PATH=target/spring-petclinic-3.1.0-SNAPSHOT.jar

3.2. Criar um novo grupo de recursos

Use as etapas a seguir para criar um novo grupo de recursos:

Use o seguinte comando para fazer logon na CLI do Azure:
```
az login
```
Use o seguinte comando para definir o local padrão:
```
az configure --defaults location=${LOCATION}
```
Use o comando a seguir para listar todas as assinaturas disponíveis e determinar a ID de assinatura a ser usada:
```
az account list --output table
```
Use o comando a seguir para definir a assinatura padrão:
```
az account set --subscription <subscription-ID>
```
Use o comando a seguir para criar um grupo de recursos:
```
az group create --resource-group ${RESOURCE_GROUP}
```
Use o seguinte comando para definir o grupo de recursos recém-criado como o grupo de recursos padrão:
```
az configure --defaults group=${RESOURCE_GROUP}
```

3.3. Criar uma instância do Azure Spring Apps

Os Aplicativos Spring do Azure são usados para hospedar o aplicativo Spring Petclinic. Use as seguintes etapas para criar uma instância dos Aplicativos Spring do Azure e dois aplicativos dentro dela:

Use o seguinte comando para criar uma instância de serviço dos Aplicativos Spring do Azure. Um build de Native Image requer 16 Gi de memória durante o build da imagem, portanto, configure o tamanho do pool de build como S7.
```
az spring create \
    --name ${AZURE_SPRING_APPS_NAME} \
    --sku enterprise \
    --build-pool-size S7
```

Crie um arquivo builder-native.json no diretório atual e adicione o seguinte conteúdo:

{
   "stack": {
     "id": "io.buildpacks.stacks.jammy",
     "version": "tiny"
   },
   "buildpackGroups": [
     {
       "name": "default",
       "buildpacks": [
         {
           "id": "tanzu-buildpacks/java-native-image"
         }
       ]
     }
   ]
 }

Use o seguinte comando para criar um construtor personalizado para criar o aplicativo Native Image:

az spring build-service builder create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_BUILDER} \
    --builder-file builder-native.json

Use o comando a seguir para criar um aplicativo na instância dos Aplicativos Spring do Azure na qual implantar o aplicativo Spring Petclinic como um arquivo JAR. Configure o limite de memória para 1 Gi.
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```
Use o seguinte comando para criar um aplicativo na instância dos Aplicativos Spring do Azure na qual o aplicativo Spring Petclinic será implantado como Native Image:
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```

4. Implantar o aplicativo em Aplicativos Spring do Azure

Agora que o ambiente de nuvem está preparado, os aplicativos estão prontos para serem implantados.

Use o seguinte comando para implantar o aplicativo Spring Petclinic como arquivo JAR:

az spring app deploy \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME} \
    --artifact-path ${JAR_PATH} \
    --build-env BP_JVM_VERSION=17

Use o seguinte comando para implantar o aplicativo Spring Petclinic como Native Image:

az spring app deploy \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --builder ${NATIVE_BUILDER} \
    --build-cpu 8 \
    --build-memory 16Gi \
    --artifact-path ${JAR_PATH} \
    --build-env BP_JVM_VERSION=17 BP_NATIVE_IMAGE=true

5. Validar o aplicativo Native Image

Agora você pode acessar o aplicativo Native Image implantado para ver se ele funciona. Use as etapas a seguir para validar:

Depois que a implantação for concluída, execute o seguinte comando para obter a URL do aplicativo:
```
az spring app show \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --output table
```
Você pode acessar o aplicativo com a URL mostrada na saída como Public Url. A página deve aparecer como você a viu no localhost.
Use o seguinte comando para marcar o log do aplicativo para investigar problemas de implantação:
```
az spring app logs \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME}
```

6. Comparar o desempenho do JAR e do Native Image

As seções a seguir descrevem como comparar o desempenho entre a implantação do JAR e do Native Image.

Hora de inicialização do servidor

Use o seguinte comando para verificar o log Started PetClinicApplication in XXX seconds do aplicativo e obter o tempo de inicialização do servidor para um aplicativo JAR:

az spring app logs \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME}

A hora de inicialização do servidor é de cerca de 25s para um aplicativo JAR.

Use o seguinte comando para verificar o log do aplicativo e obter o tempo de inicialização do servidor para um aplicativo Native Image:

az spring app logs \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME}

O tempo de inicialização do servidor é menor que 0,5s para um aplicativo Native Image.

Uso de memória

Use o seguinte comando para reduzir verticalmente o tamanho da memória para 512 Mi para um aplicativo Native Image:

az spring app scale \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --memory 512Mi

A saída do comando deve mostrar que o aplicativo Native Image foi iniciado com sucesso.

Use o seguinte comando para reduzir verticalmente o tamanho da memória para 512 Mi para o aplicativo JAR:

az spring app scale \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME} \
    --memory 512Mi

A saída do comando deve mostrar que o aplicativo JAR falhou ao iniciar devido à memória insuficiente. A mensagem de saída deve ser semelhante ao exemplo a seguir: Terminating due to java.lang.OutOfMemoryError: Java heap space.

A figura a seguir mostra o uso otimizado de memória para a implantação do Native Image para uma carga de trabalho constante de 400 solicitações por segundo no aplicativo Petclinic. O uso de memória é cerca de 1/5 da memória consumida por sua implantação JAR equivalente.

Os Native Images oferecem tempos de inicialização mais rápidos e sobrecarga de memória de runtime reduzida em comparação com a JVM (Máquina Virtual Java) convencional.

7. Limpar os recursos

Se planejar continuar trabalhando com os tutoriais e inícios rápidos subsequentes, deixe esses recursos onde estão. Quando você não precisar mais dos recursos, exclua-os excluindo o grupo de recursos. Use o seguinte comando para excluir o grupo de recursos:

az group delete --name ${RESOURCE_GROUP}

8. Próximas etapas

Como implantar aplicativos Native Image Java no plano dos Aplicativos Spring do Azure Enterprise

Log do aplicativo estruturado para o Azure Spring Apps

Mapear um domínio personalizado existente para os Aplicativos Spring do Azure

Configurar a CI/CD dos Aplicativos Spring do Azure com o GitHub Actions

Configurar a CI/CD dos Aplicativos Spring do Azure com o Azure DevOps

Usar identidades gerenciadas para aplicativos no Azure Spring Apps

Criar uma conexão de serviço nos Aplicativos Spring do Azure com a CLI do Azure

Execute os aplicativos poliglotas da loja de fitness ACME em Aplicativos Spring do Azure

Monitorar seu aplicativo Native Image do Spring Boot

Para obter mais informações, consulte os seguintes artigos: