Skapa en containeravbildning från en JAR eller WAR

Artikel
02/04/2025

Kommentar

Basic-, Standard- och Enterprise-planerna kommer att vara inaktuella från och med mitten av mars 2025, med en 3-årig pensionsperiod. Vi rekommenderar att du övergår till Azure Container Apps. Mer information finns i meddelandet om azure Spring Apps-pensionering.

Standardförbrukningen och den dedikerade planen kommer att vara inaktuell från och med den 30 september 2024, med en fullständig avstängning efter sex månader. Vi rekommenderar att du övergår till Azure Container Apps. Mer information finns i Migrera Azure Spring Apps Standard-förbrukning och dedikerad plan till Azure Container Apps.

Den här artikeln gäller för:✅ Basic/Standard ✅ Enterprise

Den här artikeln innehåller vägledning om hur du paketera Java-programmet från en JAR- eller WAR-fil till en containeravbildning.

Med Azure Spring Apps Standard-planen kan du ladda upp en JAR- eller WAR-fil som den automatiskt paketerar till en hanterad containeravbildning. På samma sätt stöder Azure Container Apps och Azure Kubernetes Service (AKS) även distribution av en containerapp direkt från en JAR- eller WAR-fil.

Förutsättningar

Docker.
Ett befintligt containerregister för lagring av containeravbildningar. För Azure Container Registry kan du konfigurera det med hjälp av Azure Portal eller via Azure CLI.

Skapa en containeravbildning

Om du vill skapa en containeravbildning som är konsekvent med den som används i Azure Spring Apps kan du skapa avbildningen själv. Använd följande allmänna steg för att skapa en JAR-fil, WAR-fil eller Java-källkod till en containeravbildning:

Skapa Java-källkoden i en JAR-fil eller en WAR-fil.
Skapa en Dockerfile och utför följande åtgärder:
1. (Endast för WAR-filer) Ladda ned Tomcat och konfigurera det.
2. Kopiera JAR-filen eller WAR-filen till containeravbildningen.
3. Ange startpunkten för containeravbildningen.
Skapa en containeravbildning genom att docker build köra kommandot med Dockerfile som skapades i föregående steg.
Skicka containeravbildningen till ett offentligt eller privat containerregister, så att du kan distribuera den i en Azure Container Apps-miljö eller ett Azure Kubernetes Service-kluster (AKS) senare.

I följande avsnitt beskrivs de här stegen mer detaljerat.

Skapa en JAR-fil

Vi rekommenderar att du använder containeravbildningar för Microsoft Build of OpenJDK om programmet körs smidigt i Azure Spring Apps. Om dina krav ändras kan du välja andra containeravbildningar som passar dina behov bättre.

Använd följande kommando för att fastställa JDK-versionen som används i distributionen som körs i Azure Spring Apps:

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

Följande exempel dockerfile baseras på 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"]

Om du vill skapa containeravbildningen med den här Dockerfile använder du följande kommando:

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

Information om hur du anpassar JVM-alternativ finns i JVM-alternativ.

Skapa en WAR-fil

Innan du skapar en WAR-fil måste du bestämma vilka versioner av JDK och Tomcat som ska användas.

Använd följande kommando för att fastställa vilken Tomcat-version som används i distributionen som körs i Azure Spring Apps:

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

I följande exempel visas en Dockerfile baserat på 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"]

Om du vill skapa containeravbildningen med den här Dockerfile använder du följande kommando:

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

Flerstegsversioner

De två metoder som nämnts tidigare är endast paketversioner. De förlitar sig på ditt lokala byggverktyg för att hantera byggprocessen och paketera resultatet i en JAR- eller WAR-fil.

Om du föredrar att inte installera ett byggverktyg eller JDK på värddatorn, men vill ha konsekventa resultat på olika datorer, kan du använda en alternativ metod genom att definiera flera byggfaser i en Dockerfile. En fas är dedikerad till kompilering och paketering, och en annan fas hanterar bildskapandeprocessen. Mer information finns i Flerstegsversioner.

Azure Container Registry Tasks

Om du har en Azure Container Registry-instans kan du skapa, push-överföra och köra en containeravbildning med hjälp av Azure Container Registry Tasks. Mer information finns i Snabbstart: Skapa och köra en containeravbildning med hjälp av Azure Container Registry Tasks.

Dela via