Een Java-app containeriseren

In deze les gaat u een Java-toepassing in een container maken.

Zoals eerder vermeld, worden containers direct boven op het hostbesturingssysteem, kernel en hardware uitgevoerd als gewone systeemprocessen. Containers vereisen minder systeemresources, wat resulteert in een kleinere footprint, minder overhead en snellere opstarttijden van toepassingen. Deze voordelen zijn uitstekende gebruiksvoorbeelden voor het schalen op aanvraag.

Er zijn Windows-containers en Linux-containers. In deze module gebruikt u de veelgebruikte Docker runtime om een Linux-containerimage te bouwen. Vervolgens implementeert u de Linux-containerinstallatiekopie op het hostbesturingssysteem van uw lokale computer. Ten slotte implementeert u de Linux-containerinstallatiekopieën in Azure Kubernetes Service.

Overzicht van Docker

De Docker-runtime wordt gebruikt voor het bouwen, pullen, uitvoeren en pushen van containerinstallatiekopieën, zoals wordt weergegeven in het volgende diagram:

In de volgende tabel wordt elke Docker-opdracht beschreven:

De Java-toepassing klonen

Clone eerst de repository Flight Booking System for Airline Reservations en navigeer naar de projectmap van de Airlines-webapplicatie.

Voer de volgende opdrachten uit:

git clone https://github.com/Azure-Samples/containerize-and-deploy-Java-app-to-Azure.git
cd containerize-and-deploy-Java-app-to-Azure/Project/Airlines

Als u Java en Maven hebt geïnstalleerd, kunt u desgewenst de volgende opdracht uitvoeren in de terminalconsole om inzicht te krijgen in de ervaring van het bouwen van de toepassing zonder Docker. Als u Java en Maven niet hebt geïnstalleerd, kunt u veilig doorgaan naar de volgende sectie, een Docker-bestand maken. In deze sectie gebruikt u Docker om Java en Maven op te halen om de builds namens u uit te voeren.

mvn clean package

Als het proces is geslaagd, heeft Maven het Flight Booking System for Airline Reservations Web Application Archive artifact AirlinesReservationSample-0.0.1-SNAPSHOT.war gebouwd, zoals geïllustreerd door de volgende historische uitvoer. De tijdstempel en duur van uw build kunnen verschillen:

[INFO] Building war: $PROJECT_PATH/containerize-and-deploy-Java-app-to-Azure/Project/Airlines/target/AirlinesReservationSample-0.0.1-SNAPSHOT.war
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  11.776 s
[INFO] Finished at: 2024-11-15T09:33:26+09:00
[INFO] ------------------------------------------------------------------------

Stel dat u een Java-ontwikkelaar bent en u zojuist AirlinesReservationSample-0.0.1-SNAPSHOT.war hebt gebouwd. De volgende stap is waarschijnlijk om samen te werken met de operationele technici om dit artefact te implementeren op een on-premises server of een virtuele machine. De servers en virtuele machines moeten beschikbaar zijn en geconfigureerd met de vereiste afhankelijkheden om de toepassing te starten en uit te voeren. Dit proces is lastig en tijdrovend, vooral wanneer de belasting op uw applicatie toeneemt. Met containers worden deze uitdagingen verholpen.

Een Dockerfile maken

U bent nu klaar om een Dockerfile te maken. Een Dockerfile is een tekstdocument dat alle opdrachten bevat die een gebruiker op de opdrachtregel zou uitvoeren om een containerimage samen te stellen. Een containerimage kan meerdere alleen-lezen bestandssysteemlagen bevatten. Docker kan buildresultaten in de cache opnieuw gebruiken voor ongewijzigde stappen. De lagen bouwen op elkaar af.

Flight Booking System for Airline Reservations moet bijvoorbeeld worden geïmplementeerd en uitgevoerd binnen een toepassingsserver. Een toepassingsserver is niet verpakt in de AirlinesReservationSample-0.0.1-SNAPSHOT.war. Het is een externe afhankelijkheid die nodig is voor de AirlinesReservationSample-0.0.1-SNAPSHOT.war om HTTP-aanvragen uit te voeren, te luisteren naar en te verwerken, gebruikerssessies te beheren en vluchtreserveringen te vergemakkelijken. Als u een traditionele, niet-containerimplementatie hebt gebruikt, installeren en configureren operation engineers een toepassingsserver op een fysieke server of virtuele machine voordat ze de AirlinesReservationSample-0.0.1-SNAPSHOT.war erop implementeren. Deze operationele ingenieurs moeten er ook voor zorgen dat de JDK die op uw computer wordt gebruikt - wat mvn clean package gebruikt om het WAR-bestand te compileren - in feite overeenkomt met dezelfde JRE die door de toepassingsserver wordt gebruikt. Het beheren van deze afhankelijkheden is lastig en tijdrovend.

Met een Dockerfile kunt u de instructies of lagen schrijven die nodig zijn om dit doel automatisch te bereiken door lagen in de stappen te plaatsen die nodig zijn om ervoor te zorgen dat het Flight Booking System voor Luchtvaartmaatschappijen alle afhankelijkheden bevat die nodig zijn om te implementeren in de Docker-containerruntime. Deze oplossing is aantrekkelijk wanneer u werkt met on-demand schaalbaarheid op niet-geplande intervallen. Elke laag maakt gebruik van Docker-cache, die de status van de containerimage bevat op elke instructiemijlpaal, waardoor de rekentijd wordt geoptimaliseerd en hergebruik wordt bevorderd. Als een laag niet wordt gewijzigd, worden lagen in de cache gebruikt. Veelvoorkomende gebruiksvoorbeelden voor lagen in de cache zijn de Java-runtime, toepassingsserver en andere afhankelijkheden voor de webtoepassing Flight Booking System for Airline Reservations. Als en wanneer een versie wordt gewijzigd op een eerder in de cache geplaatste laag, wordt er een nieuwe vermelding in de cache gemaakt.

Een containerimage bevat alleen-lezen bestandssysteemlagen. In dit voorbeeld kopieert het Dockerfile Tomcat en het WAR-bestand Flight Booking System naar de image tijdens de build. Docker voegt een afzonderlijke schrijfbare laag toe wanneer er een container van de image wordt gemaakt. De beschrijfbare laag van elke container registreert zijn eigen bestandssysteemwijzigingen zonder de imagelagen te wijzigen.

Docker heeft het concept van builds met meerdere fasen, een functie waarmee u een kleinere containerinstallatiekopieën kunt maken met betere caching en een kleinere beveiligingsvoetafdruk, waardoor de Dockerfile in de loop van de tijd beter kan worden geoptimaliseerd en onderhouden. U kunt bijvoorbeeld de buildfase van de container scheiden voor het compileren en bouwen van de toepassing van de fase voor het uitvoeren van de toepassing. Met deze functie kunt u alleen de artefacten kopiëren die tijdens de build zijn gegenereerd naar de productiecontainerafbeelding, wat de footprint vermindert. Omdat containerafbeeldingen in de cache worden opgeslagen, kunnen ze opnieuw worden gebruikt als er geen wijzigingen zijn, wat de kosten en tijd voor het downloaden van het netwerk vermindert.

Services die in de productieomgeving worden weergegeven, moeten zorgvuldig worden beheerd voor beveiliging. Daarom gebruikt en voert de productieomgeving een beveiligde containerimage uit. In het voorbeeld wordt een Azure Linux-image van Microsoft gebruikt.

In de laatste fase wordt Microsoft Build van OpenJDK 17 gebruikt op Azure Linux 3.0. De 17-azurelinux tag geeft deze basis expliciet een naam. De oudere 17-mariner tag blijft een compatibiliteitsalias die de Azure Linux-image weerspiegelt. Deze moet niet worden verward met de buiten gebruik gestelde 17-mariner-cm1- en 17-mariner-cm2-images. Zie Microsoft Build van OpenJDK containerimages voor meer informatie.

In het volgende voorbeeld wordt dezelfde versie van Microsoft Build van OpenJDK gebruikt in zowel de buildfase als de laatste fase. Deze aanpak zorgt ervoor dat u de broncode bouwt met dezelfde versie van de JDK die door de service-implementatie van Tomcat wordt gebruikt, waardoor onverwacht gedrag wordt voorkomen als gevolg van niet-overeenkomende versies.

In de volgende afbeelding ziet u de build met meerdere fasen en wat er gebeurt in elke fase op basis van de opdrachten die zijn opgegeven in het Dockerfile:

In fase 0 wordt Tomcat gedownload uit een versiespecifiek Apache-archief, geverifieerd met een SHA-512-controlesom en geëxtraheerd in een map die is opgegeven door een omgevingsvariabele op een Ubuntu-installatiekopie. De TOMCAT_VERSION variabele geeft de release aan en het TOMCAT_SHA512 buildargument geeft de verwachte checksum op. Werk beide waarden bij elkaar bij wanneer u een nieuwere ondersteunde release selecteert. Docker kan de installatielaag in de cache opnieuw gebruiken, terwijl de instructies en invoer ongewijzigd blijven. De Tomcat-installatie wordt gekopieerd naar de laatste faseomgeving voor gebruik.

In fase 1 wordt Maven geïnstalleerd op een Ubuntu-installatiekopie en worden de gemaakte broncode en configuratiebestanden gekopieerd voordat het Maven-project wordt gebouwd. Elke laag wordt in de cache opgeslagen, zodat de besturingssysteem- en Maven-imagelagen de cache opnieuw gebruiken. Als configuratiebestanden, broncodebestanden of de webmap worden bijgewerkt, worden de lagen vanaf de wijzigingen opnieuw opgebouwd. Als de build is voltooid zonder fouten tijdens het compileren, wordt een artefact met de naam AirlinesReservationSample-0.0.1-SNAPSHOT.war gegenereerd onder de doelmap . Dit artefact wordt gekopieerd naar de eindfaseomgeving voor gebruik.

In de laatste fase worden de Tomcat- en Java buildartefacten uit respectievelijk fase 0 en fase 1 gekopieerd naar een Microsoft Build van OpenJDK 17-installatiekopie op Azure Linux 3.0. Een gebruiker met de naam app is eigenaar van alle bestanden die in het project worden gebruikt en de toepassing wordt ook uitgevoerd als de app gebruiker in plaats van root bevoegdheden. Deze installatie zorgt ervoor dat de containerafbeelding veilig kan worden uitgevoerd zonder onnodige machtigingen te verlenen. Ten slotte wordt poortnummer 8080 weergegeven en wordt het catalina.sh script uitgevoerd om Tomcat te starten. Wanneer dit wordt uitgevoerd op uw lokale Docker Desktop, kunt u deze openen via de URL http://localhost:8080/AirlinesReservationSample.

Gebruik in containerize-and-deploy-Java-app-to-Azure/Project/Airlines een geïnstalleerde teksteditor om een bestand met de naam Dockerfile te maken. Voeg de volgende inhoud toe en sla het bestand op:

############################################
# Tomcat Intall stage
############################################
FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS tomcat

ENV CATALINA_HOME=/usr/local/tomcat

# Configure the reviewed Tomcat version and checksum
ENV TOMCAT_VERSION=10.1.61
ARG TOMCAT_SHA512=35120a2b1182bac3d55438fbec0dc581d03b0f1c16ce692a930f3bb6a1097cf896b94b389152257071a87cb2928ac8c15f1bad08387c14acc7c17dbc1bb598fb

# Install Tomcat and required packages
RUN apt-get update && \
    apt-get install -y --no-install-recommends curl ca-certificates && \
    curl -fSL \
      "https://archive.apache.org/dist/tomcat/tomcat-10/v${TOMCAT_VERSION}/bin/apache-tomcat-${TOMCAT_VERSION}.tar.gz" \
      -o /tmp/tomcat.tar.gz && \
    echo "${TOMCAT_SHA512}  /tmp/tomcat.tar.gz" | sha512sum -c - && \
    mkdir -p "${CATALINA_HOME}" && \
    tar -xzf /tmp/tomcat.tar.gz --strip-components=1 -C "${CATALINA_HOME}" && \
    rm /tmp/tomcat.tar.gz && \
    apt-get remove --purge -y curl && \
    apt-get autoremove -y && \
    apt-get clean

############################################
# Build stage (Compiles with Java 17)
############################################
FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS build

WORKDIR /build

# Install Maven
RUN apt-get update && apt-get install -y maven && mvn --version

# Copy source code
COPY pom.xml .
COPY src ./src
COPY web ./web

# Build the project
RUN mvn clean package

############################################
# Package final stage
############################################
FROM mcr.microsoft.com/openjdk/jdk:17-azurelinux

# Configure the location of the Tomcat installation
ENV CATALINA_HOME=/usr/local/tomcat
# Configure the path to the Tomcat binaries
ENV PATH=$CATALINA_HOME/bin:$PATH

# This is the user that runs the Tomcat process
USER app

# Copy the Tomcat installation from the Tomcat stage
COPY --chown=app:app --from=tomcat ${CATALINA_HOME} ${CATALINA_HOME}
# Copy the Tomcat configuration files
COPY --chown=app:app tomcat-users.xml ${CATALINA_HOME}/conf
# Copy the compiled WAR file from the build stage
COPY --chown=app:app --from=build /build/target/*.war ${CATALINA_HOME}/webapps/AirlinesReservationSample.war

# Expose the default Tomcat port
EXPOSE 8080
# Start Tomcat
CMD ["catalina.sh", "run"]

Het Dockerfile is onderverdeeld in drie fasen, die worden beschreven in de volgende tabellen:

• De Installatiefase van Tomcat:

  Docker-opdracht	Beschrijving
  FROM	FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS tomcat stelt de basisinstallatiekopie in op Microsoft Build van OpenJDK 17 op Ubuntu en noemt deze fase tomcat. Hier is Tomcat geïnstalleerd.
  ENV	ENV CATALINA_HOME=/usr/local/tomcat stelt een omgevingsvariabele in voor de Tomcat-installatiemap.
  ENV	ENV TOMCAT_VERSION=10.1.61 hiermee stelt u de Tomcat-release voor dit voorbeeld vast. Bekijk ondersteunde releases en werk deze samen met TOMCAT_SHA512 indien nodig bij.
  ARG	ARG TOMCAT_SHA512 levert de gepubliceerde SHA-512-controlesom van Apache voor het geselecteerde archief als een buildargument.
  RUN	Installeert curl en CA-certificaten en gebruikt curl -fSL vervolgens om het versiespecifieke Apache-archief te downloaden. -f laat HTTP-fouten falen; -L volgt omleidingen. Het archief wordt geverifieerd met sha512sum -c - voordat het wordt uitgepakt in CATALINA_HOME met --strip-components=1. De && keten stopt bij fouten in plaats van fouten te maskeren tijdens het opschonen. Ten slotte worden het archief en overbodige pakketten verwijderd en wordt de pakketcache opgeschoond.

• De buildfase, die wordt gecompileerd met Java 17:

  Docker-opdracht	Beschrijving
  FROM	FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS build stelt de basisinstallatiekopie in op Microsoft Build van OpenJDK 17 op Ubuntu en noemt deze fase build. Deze fase wordt gebruikt voor het compileren van de Java-toepassing.
  WORKDIR	WORKDIR /build stelt de werkmap in de container /buildin op , waar de broncode wordt gekopieerd en gecompileerd.
  RUN	RUN apt-get update && apt-get install -y maven && mvn --version installeert Maven, een hulpprogramma voor buildautomatisering dat wordt gebruikt voor Java-projecten en controleert de installatie.
  COPY	COPY pom.xml . kopieert het Maven-configuratiebestand naar de werkmap. Dit bestand is essentieel voor het bouwen van het project.
  COPY	COPY src ./src kopieert de broncodemap naar de container. Hier bevindt zich de Java-toepassingscode.
  COPY	COPY web ./web kopieert de map met webresources naar de container. Dit omvat resources voor webtoepassingen die nodig zijn voor de build.
  RUN	RUN mvn clean package voert het Maven-buildproces uit, waarmee de Java-toepassing wordt gecompileerd en verpakt in een WAR-bestand.

• De laatste fase van het pakket:

  Docker-opdracht	Beschrijving
  FROM	FROM mcr.microsoft.com/openjdk/jdk:17-azurelinux stelt de basisimage in op Microsoft Build van OpenJDK 17 op Azure Linux 3.0, die wordt gebruikt voor de uiteindelijke implementatie van de toepassing.
  ENV	ENV CATALINA_HOME=/usr/local/tomcat stelt de omgevingsvariabele voor de Tomcat-installatiemap in, vergelijkbaar met de installatiefase.
  ENV	ENV PATH=$CATALINA_HOME/bin:$PATH voegt de map Tomcat bin toe aan het systeem PATH, zodat Tomcat-opdrachten eenvoudig kunnen worden uitgevoerd.
  USER	USER app geeft de gebruiker op waaronder het Tomcat-proces wordt uitgevoerd, waardoor de beveiliging wordt verbeterd door niet als hoofdgebruiker te worden uitgevoerd.
  COPY	COPY --chown=app:app --from=tomcat ${CATALINA_HOME} ${CATALINA_HOME} kopieert de Tomcat-installatie vanuit de tomcat fase, waarbij het eigendom wordt ingesteld op de app gebruiker.
  COPY	COPY --chown=app:app tomcat-users.xml ${CATALINA_HOME}/conf kopieert het tomcat-gebruikersconfiguratiebestand naar de container, waarbij het eigendom wordt ingesteld op de app gebruiker.
  COPY	COPY --chown=app:app --from=build /build/target/*.war ${CATALINA_HOME}/webapps/AirlinesReservationSample.war kopieert het gecompileerde WAR-bestand van de build fase naar de map Tomcat-web-apps , waarbij het eigendom wordt ingesteld op de app gebruiker.
  EXPOSE	EXPOSE 8080 documenteert dat de toepassing naar verwachting luistert op TCP-poort 8080. Er wordt geen hostpoort gepubliceerd. In de volgende eenheid wordt de poort gepubliceerd met de -p 8080:8080 optie op docker run.
  CMD	CMD ["catalina.sh", "run"] hiermee geeft u de opdracht om Tomcat te starten wanneer de container wordt uitgevoerd.

Zie de Dockerfile-referentie voor meer informatie over dockerfile-constructie.