Compartir a través de

Compilación de una imagen de contenedor a partir de un JAR o WAR

  • Artículo

Nota:

Los planes de Básico, Estándar y Enterprise quedarán en desuso a partir de mediados de marzo de 2025, con un período de retiro de 3 años. Se recomienda realizar la transición a Azure Container Apps. Para más información, consulte el anuncio de retirada de Azure Spring Apps.

El plan de consumo estándar y dedicado quedará obsoleto a partir del 30 de septiembre de 2024, con un cierre completo al cabo de seis meses. Se recomienda realizar la transición a Azure Container Apps. Para obtener más información, consulte Migrar el plan de consumo y dedicado Azure Spring Apps Standard a Azure Container Apps.

Este artículo se aplica a: Enterprise ✅ Básico/Estándar ✅

En este artículo se proporcionan instrucciones sobre cómo empaquetar la aplicación Java desde un archivo JAR o WAR en una imagen de contenedor.

El plan Estándar de Azure Spring Apps permite cargar un archivo JAR o WAR, que empaqueta automáticamente en una imagen de contenedor administrada. De forma similar, Azure Container Apps y Azure Kubernetes Service (AKS) también admiten la implementación de una aplicación de contenedor directamente desde un archivo JAR o WAR.

Requisitos previos

  • Docker.
  • Un registro de contenedor existente para el almacenamiento de imágenes de contenedor. En el caso de Azure Container Registry, puede configurarlo mediante Azure Portal o mediante la CLI de Azure.

Compilación de una imagen de contenedor

Si desea crear una imagen de contenedor coherente con la que se usa en Azure Spring Apps, puede compilar la imagen usted mismo. Para compilar un archivo JAR, un archivo WAR o un código fuente de Java en una imagen de contenedor, siga estos pasos generales:

  1. Compile el código fuente de Java en un archivo JAR o en un archivo WAR.
  2. Cree un Dockerfile y haga lo siguiente:
    1. (Solo para archivos WAR) Descargue Tomcat y configúrelo.
    2. Copie el archivo JAR o el archivo WAR en la imagen del contenedor.
    3. Especifique el punto de entrada de la imagen de contenedor.
  3. Cree una imagen de contenedor ejecutando el comando docker build con el Dockerfile creado en el paso anterior.
  4. Inserte la imagen de contenedor en un registro de contenedor público o privado, de modo que pueda implementarla en un entorno de Azure Container Apps o en un clúster de Azure Kubernetes Service (AKS) más adelante.

En las siguientes secciones se describen estos pasos con más detalle.

Compilación de un archivo JAR

Se recomienda usar Container images for the Microsoft Build of OpenJDK (Imágenes de contenedor para Microsoft Build of OpenJDK) si la aplicación se ejecuta sin problemas en Azure Spring Apps. Si cambian los requisitos, puede elegir otras imágenes de contenedor que mejor se adapten a sus necesidades.

Para determinar la versión de JDK que se usa en la implementación que se ejecuta en Azure Spring Apps, use el siguiente comando:

az spring app deployment show \
    --app <app-name> \
    --name <deployment-name> \
    --resource-group <resource-group> \
    --service <service-name> \
    --query properties.source.runtimeVersion

El ejemplo siguiente Dockerfile se basa en JDK 17:

# filename: JAR.dockerfile

FROM mcr.microsoft.com/openjdk/jdk:17-mariner

ARG JAR_FILENAME

COPY $JAR_FILENAME /opt/app/app.jar
ENTRYPOINT ["java", "-jar", "/opt/app/app.jar"]

Para compilar la imagen de contenedor con este Dockerfile, use el siguiente comando:

docker build -t <image-name>:<image-tag> \
    -f JAR.dockerfile \
    --build-arg JAR_FILENAME=<path-to-jar> \
    .

Para obtener información sobre cómo personalizar las opciones de JVM, consulte Opciones de JVM.

Compilación de un archivo WAR

Antes de compilar un archivo WAR, debe decidir qué versiones de JDK y Tomcat usar.

Para determinar la versión de JDK que se usa en la implementación que se ejecuta en Azure Spring Apps, use el siguiente comando:

az spring app deployment show \
    --app <app-name> \
    --name <deployment-name> \
    --resource-group <resource-group> \
    --service <service-name> \
    --query properties.source.serverVersion

El ejemplo siguiente muestra un Dockerfile basado en JDK 17:

# filename: WAR.dockerfile

FROM mcr.microsoft.com/openjdk/jdk:17-mariner

ARG TOMCAT_VERSION
ARG TOMCAT_MAJOR_VERSION
ARG WAR_FILENAME
ARG TOMCAT_HOME=/opt/tomcat

# Set up Tomcat
ADD https://archive.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR_VERSION/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz \
    $TOMCAT_HOME/apache-tomcat-$TOMCAT_VERSION.tar.gz
RUN tdnf update -y \
    && tdnf install -y tar \
    && tar -zxf $TOMCAT_HOME/apache-tomcat-$TOMCAT_VERSION.tar.gz -C $TOMCAT_HOME --strip-components 1 \
    && rm $TOMCAT_HOME/apache-tomcat-$TOMCAT_VERSION.tar.gz \
    && rm -r $TOMCAT_HOME/webapps/*

COPY $WAR_FILENAME $TOMCAT_HOME/webapps/app.war
ENTRYPOINT ["/bin/sh", "-c" , "/opt/tomcat/bin/catalina.sh run"]

Para compilar la imagen de contenedor con este Dockerfile, use el siguiente comando:

docker build -t <image-name>:<image-tag> \
    -f WAR.dockerfile \
    --build-arg WAR_FILENAME=<path-to-war> \
    --build-arg TOMCAT_VERSION=<version> \
    --build-arg TOMCAT_MAJOR_VERSION=<major-version> \
    .

Compilaciones de varias fases

Los dos enfoques mencionados anteriormente son compilaciones de solo paquete. Se basan en la herramienta de compilación local para administrar el proceso de compilación y empaquetar el resultado en un archivo JAR o WAR.

Si prefiere no instalar una herramienta de compilación o JDK en el equipo host, pero quiere resultados coherentes en diferentes máquinas, puede usar un método alternativo definiendo varias fases de compilación en un Dockerfile. Una fase está dedicada a la compilación y el empaquetado, y otra fase controla el proceso de creación de imágenes. Para obtener más información, consulte Multi-stage builds (Compilaciones de varias fases).

Azure Container Registry Tasks

Si tiene una instancia de Azure Container Registry, puede compilar, insertar y ejecutar una imagen de contenedor mediante Azure Container Registry Tasks. Para obtener más información, consulte Inicio rápido: Compilación y ejecución de una imagen de contenedor en Azure Container Registry Tasks.