Guia de início rápido: implante seu primeiro aplicativo Java Native Image no Azure Spring Apps

Nota

Os planos Basic, Standarde Enterprise entraram em um período de aposentadoria em 17 de março de 2025. Para obter mais informações, consulte o anúncio de aposentadoria do Azure Spring Apps.

Este artigo aplica-se a: ❎ Basic/Standard ✅ Enterprise

Este guia de início rápido mostra como implantar um aplicativo Spring Boot no Azure Spring Apps como uma imagem nativa.

O recurso Imagem Nativa permite compilar aplicativos Java em executáveis autônomos, conhecidos como Imagens Nativas. Esses executáveis podem fornecer benefícios significativos, incluindo tempos de inicialização mais rápidos e menor sobrecarga de memória de tempo de execução em comparação com uma JVM (Java Virtual Machine) tradicional.

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

1. Pré-requisitos

Uma subscrição do Azure. Se você não tiver uma assinatura, crie uma conta gratuita antes de começar.
Git.
Java Development Kit (JDK), versão 17.
Azure CLI versão 2.45.0 ou superior. Use o seguinte comando para instalar a extensão Azure Spring Apps: az extension add --name spring

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
```
Aceda a http://localhost:8080 no seu navegador para aceder à aplicação Spring Petclinic.

3. Prepare o ambiente de nuvem

O principal recurso necessário para executar o aplicativo Spring Petclinic é uma instância do Azure Spring Apps. 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. Certifique-se de substituir os espaços reservados pelos seus próprios 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 seguintes etapas para criar um novo grupo de recursos:

Use o seguinte comando para entrar 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 para determinar a ID da assinatura a ser usada:
```
az account list --output table
```
Use o seguinte comando para definir a assinatura padrão:
```
az account set --subscription <subscription-ID>
```
Use o seguinte comando 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

O Azure Spring Apps é usado para hospedar o aplicativo Spring Petclinic. Use as seguintes etapas para criar uma instância do Azure Spring Apps e dois aplicativos dentro dela:

Use o comando a seguir para criar uma instância de serviço do Azure Spring Apps. Uma compilação de imagem nativa requer 16 Gi de memória durante a compilação da imagem, portanto, configure o tamanho do pool de compilação 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 do Azure Spring Apps no 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 do Azure Spring Apps no qual implantar o aplicativo Spring Petclinic como uma imagem nativa:

az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true

4. Implantar o aplicativo no Azure Spring Apps

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

Use o seguinte comando para implantar o aplicativo Spring Petclinic como um 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 uma imagem nativa:

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 aplicativo de imagem nativa

Agora você pode acessar o aplicativo Native Image implantado para ver se ele funciona. Utilize os seguintes passos para validar:

Após a conclusão da implantação, você pode executar 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 o URL mostrado na saída como Public Url. A página deve aparecer como a viste no localhost.
Use o seguinte comando para verificar o log do aplicativo para investigar qualquer problema de implantação:
```
az spring app logs \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME}
```

6. Compare o desempenho para JAR e Imagem Nativa

As seções a seguir descrevem como comparar o desempenho entre a implantação do JAR e da Imagem Nativa.

Tempo de inicialização do servidor

Use o seguinte comando para verificar o log Started PetClinicApplication in XXX seconds do aplicativo para 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}

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

Use o seguinte comando para verificar o log do aplicativo para obter o tempo de inicialização do servidor para um aplicativo de Imagem Nativa:

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

O tempo de inicialização do servidor é inferior a 0,5 s para um aplicativo de imagem nativa.

Utilização de memória

Use o seguinte comando para reduzir o tamanho da memória para 512 Mi para um aplicativo de imagem nativa:

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 Imagem Nativa foi iniciado com êxito.

Use o seguinte comando para reduzir 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 de Imagem Nativa para uma carga de trabalho constante de 400 solicitações por segundo no aplicativo Petclinic. A utilização de memória é cerca de 1/5 da memória consumida por uma implementação JAR equivalente.

As imagens nativas oferecem tempos de inicialização mais rápidos e sobrecarga de memória de tempo de execução reduzida quando comparadas à Java Virtual Machine (JVM) convencional.

7. Limpar os recursos

Se planeia continuar a trabalhar com instruções rápidas e tutoriais subsequentes, pode querer deixar esses recursos disponíveis. Quando 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 Java Native Image no plano do Azure Spring Apps Enterprise

Log de aplicativo estruturado para Azure Spring Apps

Mapear um domínio personalizado existente para o Azure Spring Apps

Configurar o Azure Spring Apps CI/CD com ações do GitHub

Configurar o CI/CD do Azure Spring Apps com o Azure DevOps

Usar identidades gerenciadas para aplicativos no Azure Spring Apps

Criar uma conexão de serviço no Azure Spring Apps com a CLI do Azure

Execute os aplicativos poliglotas da loja de fitness ACME no Azure Spring Apps

Monitore seu aplicativo Spring Boot Native Image

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

Exemplos de aplicativos do Azure Spring.
Spring em Azure
Spring Cloud Azure

Feedback

Esta página foi útil?

Last updated on 2025-11-25