Condividi tramite

Creare un'immagine del contenitore da un file JAR o WAR

Nota

I piani Basic, Standard ed Enterprise sono entrati in un periodo di ritiro il 17 marzo 2025. Per altre informazioni, vedere l'annuncio di ritiro di Azure Spring Apps.

Questo articolo si applica a:✅ Basic/Standard ✅ Enterprise

Questo articolo fornisce indicazioni su come creare un pacchetto dell'applicazione Java da un file JAR o WAR in un'immagine del contenitore.

Il piano Standard di Azure Spring Apps consente di caricare un file JAR o WAR, che crea automaticamente pacchetti in un'immagine del contenitore gestito. Analogamente, App Azure Container e servizio Azure Kubernetes (servizio Azure Kubernetes) supportano anche la distribuzione di un'app contenitore direttamente da un file JAR o WAR.

Prerequisiti

  • Docker.
  • Registro contenitori esistente per l'archiviazione di immagini del contenitore. Per Registro Azure Container, è possibile configurarla usando il portale di Azure o tramite l'interfaccia della riga di comando di Azure.

Compilare un'immagine del contenitore

Se si vuole creare un'immagine del contenitore coerente con quella usata in Azure Spring Apps, è possibile creare l'immagine manualmente. Per compilare un file JAR, un file WAR o un codice sorgente Java in un'immagine del contenitore, seguire questa procedura generale:

  1. Compilare il codice sorgente Java in un file JAR o in un file WAR.
  2. Creare un Dockerfile ed eseguire le azioni seguenti:
    1. (solo per i file WAR) Scaricare Tomcat e configurarlo.
    2. Copiare il file JAR o il file WAR nell'immagine del contenitore.
    3. Specificare il punto di ingresso dell'immagine del contenitore.
  3. Creare un'immagine del contenitore eseguendo il docker build comando con il Dockerfile creato nel passaggio precedente.
  4. Eseguire il push dell'immagine del contenitore in un registro contenitori pubblico o privato, in modo che sia possibile distribuirlo in un ambiente di App Contenitore di Azure o in un cluster servizio Azure Kubernetes del servizio Azure Kubernetes in un secondo momento.

Le sezioni seguenti descrivono questi passaggi in modo più dettagliato.

Compilare un file JAR

È consigliabile usare immagini contenitore per Microsoft Build di OpenJDK se l'applicazione è in esecuzione senza problemi in Azure Spring Apps. Se i requisiti cambiano, è possibile scegliere altre immagini del contenitore più adatte alle proprie esigenze.

Per determinare la versione di JDK usata nella distribuzione in esecuzione in Azure Spring Apps, usare il comando seguente:

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

Il Dockerfile di esempio seguente si basa su 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"]

Per compilare l'immagine del contenitore con questo Dockerfile, usare il comando seguente:

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

Per informazioni sulla personalizzazione delle opzioni JVM, vedere Opzioni JVM.

Creare un file WAR

Prima di compilare un file WAR, è necessario decidere quali versioni di JDK e Tomcat usare.

Per determinare la versione di Tomcat usata nella distribuzione in esecuzione in Azure Spring Apps, usare il comando seguente:

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

L'esempio seguente illustra un Dockerfile basato su 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"]

Per compilare l'immagine del contenitore con questo Dockerfile, usare il comando seguente:

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> \
    .

Compilazioni in più fasi

I due approcci indicati in precedenza sono compilazioni solo pacchetto. Si basano sullo strumento di compilazione locale per gestire il processo di compilazione e creare un pacchetto del risultato in un file JAR o WAR.

Se si preferisce non installare uno strumento di compilazione o JDK nel computer host, ma si vogliono risultati coerenti in computer diversi, è possibile usare un metodo alternativo definendo più fasi di compilazione in un Dockerfile. Una fase è dedicata alla compilazione e alla creazione di pacchetti e un'altra fase gestisce il processo di compilazione delle immagini. Per altre informazioni, vedere Compilazioni a più fasi.

Attività del Registro Azure Container

Se si dispone di un'istanza di Registro Azure Container, è possibile compilare, eseguire il push ed eseguire un'immagine del contenitore usando Registro Azure Container Attività. Per altre informazioni, vedere Guida introduttiva: Compilare ed eseguire un'immagine del contenitore usando Registro Azure Container Attività.

  • Last updated on