Inicio rápido: Implementación de su primera aplicación nativa de imágenes de Java en Azure Spring Apps

Artículo
02/02/2024

Nota:

Las primeras 50 horas de vCPU y 100 GB de memoria al mes son gratuitos. Para más información, consulte el artículo Price Reduction - Azure Spring Apps does more, costs less! ("Reducción de precios: Azure Spring Apps te da más por menos") en el Blog de Apps on Azure.

Nota

Azure Spring Apps es el nuevo nombre del servicio Azure Spring Cloud. Aunque el servicio tiene un nuevo nombre, verá el nombre antiguo en algunos lugares durante un tiempo mientras trabajamos para actualizar recursos, como capturas de pantalla, vídeos y diagramas.

Este artículo se aplica a:❌ Básico o Estándar ✔️ Enterprise

En esta guía de inicio rápido se muestra cómo implementar una aplicación de Spring Boot en Azure Spring Apps como imagen nativa.

La funcionalidad de imágenes nativas le permite compilar aplicaciones Java en ejecutables independientes, conocidos como Imágenes nativas. Estos ejecutables pueden proporcionar ventajas significativas, incluidos tiempos de inicio más rápidos y una menor sobrecarga de memoria en tiempo de ejecución en comparación con una Máquina virtual Java (JVM) tradicional.

El proyecto de ejemplo es la aplicación Spring Petclinic. En la siguiente captura de pantalla se muestra la aplicación:

1. Prerrequisitos

Suscripción a Azure. Si no tiene una suscripción, cree una cuenta gratuita antes de empezar.
Git.
Kit de desarrollo de Java (JDK), versión 17.
CLI de Azure: versión 2.45.0 o superior. Use el siguiente comando para instalar la extensión de Azure Spring Apps: az extension add --name spring
Si va a implementar una instancia de plan Enterprise de Azure Spring Apps por primera vez en la suscripción de destino, consulte la sección Requisitos de la oferta de nivel de servicio Enterprise de Azure Spring Apps en Azure Marketplace.

2. Preparación del proyecto Spring Petclinic

Siga estos pasos para clonar y ejecutar la aplicación localmente.

Use el siguiente comando para clonar el proyecto de Spring Petclinic desde GitHub:
```
git clone https://github.com/Azure-Samples/spring-petclinic.git
```

Use el siguiente comando para compilar el proyecto de Spring Petclinic:

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

Use el siguiente comando para ejecutar la aplicación Spring Petclinic mediante Maven:
```
java -jar target/spring-petclinic-3.1.0-SNAPSHOT.jar
```
Vaya a http://localhost:8080 en el explorador para acceder a la aplicación Spring Petclinic.

3. Preparar el entorno en la nube

El recurso principal necesario para ejecutar la aplicación Spring Petclinic es una instancia de Azure Spring Apps. En esta sección se proporcionan los pasos para crear estos recursos.

3.1. Proporcione nombres para cada recurso

Cree variables para contener los nombres del recurso mediante los siguientes comandos. Asegúrese de reemplazar los marcadores de posición por sus propios 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. Creación de un nuevo grupo de recursos

Use los siguientes pasos para crear un grupo de recursos:

Use el siguiente comando para iniciar sesión en la CLI de Azure:
```
az login
```
Use el siguiente comando para establecer la ubicación predeterminada:
```
az configure --defaults location=${LOCATION}
```
Use el siguiente comando para enumerar todas las suscripciones disponibles y determinar el id. de suscripción que se va a usar:
```
az account list --output table
```
Use el siguiente comando para establecer la suscripción predeterminada:
```
az account set --subscription <subscription-ID>
```
Use el siguiente comando para crear un grupo de recursos:
```
az group create --resource-group ${RESOURCE_GROUP}
```
Use el siguiente comando para establecer el grupo de recursos recién creado como el grupo de recursos predeterminado:
```
az configure --defaults group=${RESOURCE_GROUP}
```

3.3. Creación de una instancia de Azure Spring Apps

Azure Spring Apps se usa para hospedar la aplicación Spring Petclinic. Siga estos pasos para crear una instancia de Azure Spring Apps y dos aplicaciones dentro de ella:

Use el siguiente comando para crear una instancia de servicio de Azure Spring Apps. Una compilación de imagen nativa requiere 16 Gi de memoria durante la compilación de imágenes, por lo que debe configurar el tamaño del grupo de compilación como S7.
```
az spring create \
    --name ${AZURE_SPRING_APPS_NAME} \
    --sku enterprise \
    --build-pool-size S7
```

Cree un archivo builder-native.json en el directorio actual y agregue el siguiente contenido:

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

Use el siguiente comando para crear un generador personalizado para compilar la aplicación de imágenes nativas:

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

Use el siguiente comando para crear una aplicación en la instancia de Azure Spring Apps en la que se va a implementar la aplicación Spring Petclinic como un archivo JAR. Configure el límite de memoria en 1 Gi.
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${JAR_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```
Use el siguiente comando para crear una aplicación en la instancia de Azure Spring Apps en la cual implementar la aplicación Spring Petclinic como una imagen nativa:
```
az spring app create \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --cpu 1 \
    --memory 1Gi \
    --assign-endpoint true
```

4. Implementación de la aplicación en Azure Spring Apps

Ahora que el entorno de nube está preparado, las aplicaciones están listas para implementarse.

Use el siguiente comando para implementar la aplicación Spring Petclinic como un archivo 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 el siguiente comando para implementar la aplicación Spring Petclinic como una imagen 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 la aplicación de imagen nativa

Ahora puede acceder a la aplicación de imágenes nativas implementada para ver si funciona. Utilice los pasos siguientes para validarla:

Una vez completada la implementación, puede ejecutar el siguiente comando para obtener la dirección URL de la aplicación:
```
az spring app show \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME} \
    --output table
```
Puede acceder a la aplicación con la dirección URL que se muestra en la salida como Public Url. La página debería aparecer tal y como la vio en localhost.
Use el siguiente comando para comprobar el registro de la aplicación para investigar cualquier problema de implementación:
```
az spring app logs \
    --service ${AZURE_SPRING_APPS_NAME} \
    --name ${NATIVE_APP_NAME}
```

6. Comparación del rendimiento de JAR e imagen nativa

En las secciones siguientes se describe cómo comparar el rendimiento entre la implementación de JAR y la imagen nativa.

Tiempo de inicio del servidor

Use el siguiente comando para comprobar el registro Started PetClinicApplication in XXX seconds de la aplicación para obtener el tiempo de inicio del servidor de una aplicación JAR:

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

El tiempo de inicio del servidor es de aproximadamente 25 s para una aplicación JAR.

Use el siguiente comando para comprobar el registro de la aplicación y obtener el tiempo de inicio del servidor de una aplicación de imágenes nativas:

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

El tiempo de inicio del servidor es inferior a 0,5 s para una aplicación de imagen nativa.

Uso de la memoria

Use el siguiente comando para reducir verticalmente el tamaño de memoria a 512 Mi para una aplicación imágenes nativas:

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

La salida del comando debe mostrar que la aplicación de imágenes nativas se inició correctamente.

Use el siguiente comando para reducir verticalmente el tamaño de memoria a 512 Mi para la aplicación JAR:

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

La salida del comando debe mostrar que la aplicación JAR no se pudo iniciar debido a una memoria insuficiente. El mensaje de salida debe ser similar al del siguiente ejemplo: Terminating due to java.lang.OutOfMemoryError: Java heap space.

En la figura siguiente se muestra el uso de memoria optimizado para la implementación de imágenes nativas para una carga de trabajo constante de 400 solicitudes por segundo en la aplicación Petclinic. El uso de memoria es de aproximadamente 1/5 de la memoria consumida por su implementación JAR equivalente.

Las imágenes nativas ofrecen tiempos de inicio más rápidos y reducen la sobrecarga de memoria en tiempo de ejecución en comparación con la Máquina virtual Java (JVM) convencional.

7. Limpieza de recursos

Si planea seguir trabajando en otros inicios rápidos y tutoriales, considere la posibilidad de dejar estos recursos activos. Cuando ya no necesite los recursos, elimine el grupo de recursos para eliminarlos. Use el comando siguiente para eliminar el grupo de recursos:

az group delete --name ${RESOURCE_GROUP}

8. Pasos siguientes

Cómo implementar aplicaciones de imágenes nativas de Java en el plan de Azure Spring Apps Enterprise

Registro de aplicaciones estructurado para Azure Spring Apps

Asignación de un dominio personalizado existente a Azure Spring Apps

Establecer CI/CD de Azure Spring Apps con Acciones de GitHub

Establecer CI/CD de Azure Spring Apps con Azure DevOps

Uso de identidades administradas para aplicaciones en Azure Spring Apps

Crear una conexión de servicio en Azure Spring Apps con la CLI de Azure

Ejecución de las aplicaciones de la tienda de fitness de ACME políglota en Azure Spring Apps

Supervisión de la aplicación Spring Boot Native Image

Para más información, consulte los siguientes artículos.

Share via