Criar uma imagem de contêiner a partir de um JAR ou WAR

Artigo
02/04/2025

Nota

Os planos Basic, Standard e Enterprise serão preteridos a partir de meados de março de 2025, com um período de aposentadoria de 3 anos. Recomendamos a transição para os Aplicativos de Contêiner do Azure. Para obter mais informações, consulte o anúncio de aposentadoria do Azure Spring Apps.

O plano de consumo padrão e dedicado será preterido a partir de 30 de setembro de 2024, com um desligamento completo após seis meses. Recomendamos a transição para os Aplicativos de Contêiner do Azure. Para obter mais informações, consulte Migrar consumo padrão e plano dedicado do Azure Spring Apps para Aplicativos de Contêiner do Azure.

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

Este artigo fornece orientação sobre como empacotar seu aplicativo Java de um arquivo JAR ou WAR em uma imagem de contêiner.

O plano Azure Spring Apps Standard permite carregar um arquivo JAR ou WAR, que ele empacota automaticamente em uma imagem de contêiner gerenciado. Da mesma forma, os Aplicativos de Contêiner do Azure e o Serviço Kubernetes do Azure (AKS) também oferecem suporte à implantação de um aplicativo de contêiner diretamente de um arquivo JAR ou WAR.

Pré-requisitos

Docker.
Um registro de contêiner existente para armazenamento de imagens de contêiner. Para o Registro de Contêiner do Azure, você pode configurá-lo usando o portal do Azure ou por meio da CLI do Azure.

Criar uma imagem de contêiner

Se quiser criar uma imagem de contêiner consistente com a usada no Azure Spring Apps, você mesmo pode criar a imagem. Para construir um arquivo JAR, um arquivo WAR ou um código-fonte Java em uma imagem de contêiner, use as seguintes etapas gerais:

Construa seu código-fonte Java em um arquivo JAR ou WAR.
Crie um Dockerfile e execute as seguintes ações:
1. (Apenas para ficheiros WAR) Baixe o Tomcat e configure-o.
2. Copie seu arquivo JAR ou WAR para a imagem do contêiner.
3. Especifique o ponto de entrada da imagem do contêiner.
Crie uma imagem de contêiner executando o docker build comando com o Dockerfile criado na etapa anterior.
Envie a imagem do contêiner para um registro de contêiner público ou privado, para que você possa implantá-la em um ambiente de Aplicativos de Contêiner do Azure ou em um cluster do Serviço Kubernetes do Azure (AKS) mais tarde.

As seções a seguir descrevem essas etapas com mais detalhes.

Criar um arquivo JAR

Recomendamos o uso de imagens de contêiner para o Microsoft Build do OpenJDK se seu aplicativo estiver sendo executado sem problemas no Azure Spring Apps. Se seus requisitos mudarem, você poderá escolher outras imagens de contêiner que melhor atendam às suas necessidades.

Para determinar a versão do JDK usada em sua implantação em execução no Azure Spring Apps, use o seguinte comando:

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

O exemplo Dockerfile a seguir é baseado no 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 criar sua imagem de contêiner com este Dockerfile, use o seguinte comando:

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

Para obter informações sobre como personalizar opções da JVM, consulte Opções da JVM.

Criar um arquivo WAR

Antes de criar um arquivo WAR, você precisa decidir quais versões do JDK e do Tomcat usar.

Para determinar a versão do Tomcat usada em sua implantação em execução no Azure Spring Apps, use o seguinte comando:

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

O exemplo a seguir mostra um Dockerfile baseado no 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 criar sua imagem de contêiner com este Dockerfile, use o seguinte 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> \
    .

Compilações em vários estágios

As duas abordagens mencionadas anteriormente são compilações somente de pacote. Eles confiam em sua ferramenta de compilação local para gerenciar o processo de compilação e empacotar o resultado em um arquivo JAR ou WAR.

Se preferir não instalar uma ferramenta de compilação ou JDK na máquina host, mas quiser resultados consistentes em máquinas diferentes, você pode usar um método alternativo definindo vários estágios de compilação em um Dockerfile. Um estágio é dedicado à compilação e empacotamento, e outro estágio lida com o processo de construção de imagem. Para obter mais informações, consulte Compilações de vários estágios.

Tarefas do Azure Container Registry

Se você tiver uma instância do Registro de Contêiner do Azure, poderá criar, enviar por push e executar uma imagem de contêiner usando as Tarefas do Registro de Contêiner do Azure. Para obter mais informações, consulte Guia de início rápido: criar e executar uma imagem de contêiner usando as Tarefas do Registro de Contêiner do Azure.

Partilhar via