Objektbeholderiser en Java-app

  • 10 minutter

I dette undermodul beholder du et Java-program.

Som tidligere nævnt kører objektbeholdere direkte oven på værtsoperativsystemet, kernen og hardwaren som almindelige systemprocesser. Objektbeholdere kræver færre systemressourcer, hvilket resulterer i et mindre fodaftryk, mindre omkostninger og hurtigere starttider for programmer. Disse fordele er gode anvendelsesområder til skalering efter behov.

Der er Windows-objektbeholdere og Linux-objektbeholdere. I dette modul bruger du den almindeligt anvendte Docker-kørsel til at bygge et Linux-objektbeholderbillede. Du udruller derefter Linux-objektbeholderafbildningen til værtsoperativsystemet på din lokale computer. Endelig udruller du Linux-objektbeholderafbildningen til Azure Kubernetes Service.

Oversigt over Docker

Docker-kørsel bruges til at bygge, trække, køre og pushe objektbeholderbilleder som vist i følgende diagram:

Diagram, der viser Docker-kommandoer.

I følgende tabel beskrives hver Docker-kommando:

Kommandoen Docker Beskrivelse
docker build Opretter et objektbeholderbillede, der består af de instruktioner eller lag, der er nødvendige for, at Docker kan oprette en kørende objektbeholder ud fra et billede. Resultatet af denne kommando er et billede.
docker pull Objektbeholdere initialiseres fra billeder, der hentes fra registre, f.eks. Azure Container Registry. I denne registreringsdatabase hentes Azure Kubernetes Service fra. Resultatet af denne kommando er en netværks-pull af et billede, der forekommer i Azure. Du kan også hente billeder lokalt. Denne indstilling er almindelig, når du opretter billeder, der kræver afhængigheder eller lag, som dit program muligvis har brug for, f.eks. en programserver.
docker run En kørende forekomst af et billede er en objektbeholder, og denne kommando udfører alle de lag, der er nødvendige for at køre og interagere med det aktive objektbeholderprogram. Resultatet af denne kommando er en kørende programproces på værtsoperativsystemet.
docker push Azure Container Registry gemmer billederne, så de er let tilgængelige og netværkslukning for Azure-installationer og -skalering.

Klon Java-programmet

Først skal du klone lageret Flight Booking System for Airline Reservations og navigere til mappen Airlines webprogramprojekt.

Seddel

Hvis oprettelsen af Azure Kubernetes Service er fuldført under din CLI-fane, skal du bruge denne fane. Hvis den stadig kører, skal du åbne en ny fane og navigere til det sted, hvor du foretrækker at klone Flight Booking System for Airline Reservations.

Kør følgende kommandoer:

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

Hvis du har Java og Maven installeret, kan du eventuelt køre følgende kommando i terminalkonsollen for at få en fornemmelse af, hvordan du bygger programmet uden Docker. Hvis du ikke har Java og Maven installeret, kan du trygt gå videre til næste afsnit , Konstruer en Docker-fil. I dette afsnit skal du bruge Docker til at trække Java og Maven ned for at udføre builds på dine vegne.

mvn clean package

Seddel

Vi brugte kommandoen mvn clean package til at illustrere de driftsmæssige udfordringer ved ikke at bruge Docker multistage-builds, som vi dækker næste gang. Igen er dette trin valgfrit. Uanset hvad, kan du trygt fortsætte uden at udføre kommandoen Maven.

Hvis processen lykkedes, byggede Maven Flight Booking System for Airline Reservations Web Application Archive artefaktet AirlinesReservationSample-0.0.1-SNAPSHOT.war, som vist i følgende output:

[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] ------------------------------------------------------------------------

Forestil dig, at du er Java-udvikler, og at du lige har bygget AirlinesReservationSample-0.0.1-SNAPSHOT.war. Dit næste trin er sandsynligvis at arbejde sammen med handlingsteknikerne om at få dette artefakt udrullet på enten en server i det lokale miljø eller en virtuel maskine. Hvis programmet skal starte og køre korrekt, skal serverne og de virtuelle maskiner være tilgængelige og konfigureret med de påkrævede afhængigheder. Denne proces er udfordrende og tidskrævende, især efter behov, når øget belastning rammer dit program. Med objektbeholdere afhjælpes disse udfordringer.

Opret en Dockerfile

Du er nu klar til at oprette en Dockerfile. En Dockerfile er et tekstdokument, der indeholder alle de kommandoer, en bruger skal udføre på kommandolinjen for at samle et objektbeholderbillede. Hvert billede er et lag, der kan cachelagres af hensyn til effektiviteten. Lagene bygges oven på hinanden.

Flyreservationssystemet for flyreservationer skal f.eks. udrulles til og køre på en programserver. En programserver er ikke pakket i AirlinesReservationSample-0.0.1-SNAPSHOT.war. Det er en ekstern afhængighed, der kræves for AirlinesReservationSample-0.0.1-SNAPSHOT.war for at køre, lytte efter og behandle HTTP-anmodninger, administrere brugersessioner og lette flyreservationer. Hvis du brugte en traditionel installation uden objektbeholdere, installerede og konfigurerede handlingsteknikere en programserver på en fysisk server eller virtuel maskine, før AirlinesReservationSample-0.0.1-SNAPSHOT.war installeres i den. Disse driftsteknikere skal også sikre, at den JDK, der bruges på din maskine - hvilket er det, der mvn clean package bruges til at kompilere WAR-filen - faktisk svarer til den samme JRE, der bruges af programserveren. Det er udfordrende og tidskrævende at administrere disse afhængigheder.

Med en Dockerfile kan du skrive de instruktioner eller lag, der er nødvendige for at nå dette mål automatisk, ved at lægge de trin, der er nødvendige for at sikre, at Flight Booking System for Airline Reservations har alle de afhængigheder, der er nødvendige for at udrulle til Docker-objektbeholderens kørselstid. Denne løsning er overbevisende, når du arbejder med on-demand-skala med uplanlagte intervaller. Hvert lag bruger Docker-cachen, som indeholder tilstanden for objektbeholderbilledet ved hver instruktionsmilepæl, optimerer beregningstiden og genbruger. Hvis et lag ikke ændres, bruges cachelagrede lag. Almindelige use cases for cachelagrede lag er Java-kørsel, programserver og andre afhængigheder for webprogrammet Flight Booking System for Airline Reservations. Hvis og når en version ændres på et tidligere cachelagret lag, oprettes der en ny cachelagret post.

I følgende diagram vises lagene i et objektbeholderbillede. Når kommandoerne i Dockerfile udføres, oprettes lagene. Det øverste lag er læse-/skrive-flyreservationssystemet for webprogramlaget For flyselskabsreservationer. Dette lag er bygget oven på de tidligere skrivebeskyttede lag.

Diagram, der viser Docker-lagene.

Docker har begrebet flertrinsbuilds, en funktion, der giver dig mulighed for at oprette et mindre objektbeholderbillede med bedre cachelagring og et mindre sikkerhedsaftryk, hvilket muliggør øget optimering og vedligeholdelse af Dockerfile over tid. Du kan f.eks. adskille fasen for objektbeholderopbygning til kompilering og oprettelse af programmet fra fasen til kørsel af programmet. Denne funktion giver dig mulighed for kun at kopiere de artefakter, der genereres under buildet, til billedet af produktionsobjektbeholderen, hvilket reducerer fodaftrykket. Da objektbeholderbilleder cachelagres, kan de cachelagrede billeder genbruges, hvilket reducerer omkostningerne og tidspunktet for download fra netværket, hvis der ikke er nogen ændringer.

Tjenester, der eksponeres i produktionsmiljøet, skal administreres omhyggeligt af hensyn til sikkerheden. Derfor bruger og driver produktionsmiljøet et sikkert objektbeholderbillede. I eksemplet bruges det billede, CBL-Mariner der leveres af Microsoft.

CBL-Mariner Linux er et letvægtsoperativsystem, der kun indeholder de pakker, der er nødvendige for et cloudmiljø. Du kan tilpasse den via brugerdefinerede pakker og værktøjer, så den passer til kravene i dit program. CBL-Mariner gennemgår Azure-valideringstest og er kompatibel med Azure-agenter. Microsoft bygger og tester CBL-Mariner til at drive forskellige use cases, lige fra Azure-tjenester til powering IoT-infrastruktur. Det er den internt anbefalede Linux-distribution til brug sammen med Microsofts cloudtjenester og relaterede produkter.

Seddel

Microsoft leverer objektbeholderbilleder, der er bundtet med OpenJDK, herunder Ubuntu, CBL-Marinerog distroless billeder. Billedet distroless har den mindste billedstørrelse, men det er en udfordring at køre Tomcat på det. For at opnå et letvægtsdesign distroless fjerner billedet mange kommandoer og værktøjer, herunder shell, hvilket betyder, at du ikke kan kalde catalina.sh for at starte Tomcat. Billedet distroless er velegnet til kørsel af eksekverbare JAR'er, f.eks. dem, der bruges sammen med Spring Boot eller Quarkus.

I følgende eksempel bruges den samme version af Microsoft Build of OpenJDK i både buildfasen og den endelige fase. Denne fremgangsmåde sikrer, at du opretter kildekoden med den samme version af JDK, som tomcat bruger til tjenesteinstallation, hvilket hjælper med at undgå uventet funktionsmåde på grund af uoverensstemmelse mellem versioner.

På følgende billede vises multistagebuildet, og hvad der sker i hver fase baseret på de kommandoer, der er angivet i Dockerfile:

Diagram, der viser Docker Multistage-buildet.

I fase 0 downloades Og udtrækkes Tomcat til en mappe, der er angivet af en miljøvariabel på et Ubuntu-billede. Variablen TOMCAT_VERSION angiver den version af Tomcat, der skal downloades. Hvis der udgives en ny version af Tomcat, skal du opdatere versionsnummeret, da et nyt billede kun hentes, når versionsnummeret ændres. Ellers bruges det cachelagrede billede. Den tomcat, der er downloadet, kopieres til det endelige fasemiljø til brug.

I fase 1 installeres Maven på et Ubuntu-billede, og de oprettede kildekode- og konfigurationsfiler kopieres over, før maven-projektet bygges. Hvert lag cachelagres, så operativsystemets billede og Maven-billedlag genbruger cachen. Hvis konfigurationsfiler, kildekodefiler eller webmappen opdateres, genopbygges lagene fra ændringerne. Hvis buildet fuldføres uden fejl under kompilering, oprettes der en artefakt med navnet AirlinesReservationSample-0.0.1-SNAPSHOT.war under målmappen . Denne artefakt kopieres til det endelige fasemiljø til brug.

I den sidste fase bruges det sikre CBL-Mariner billede, der leveres af Microsoft, til at kopiere artefakterne til Tomcat- og Java-buildet fra henholdsvis fase 0 og fase 1. En bruger med navnet app ejer alle de filer, der bruges i projektet, og programmet køres også som app brugeren i stedet for at have root rettigheder. Denne konfiguration sikrer, at objektbeholderafbildningen kan betjenes sikkert uden at tildele unødvendige tilladelser. Endelig vises portnummeret 8080, og det catalina.sh script udføres for at starte Tomcat. Når dette køres på din lokale Docker Desktop, kan du få adgang til den via URL-adressen http://localhost:8080/AirlinesReservationSample.

I rodmappen for dit projekt , containerize-and-deploy-Java-app-to-Azure/Project/Airlines skal du bruge følgende kommando til at oprette en fil med navnet Dockerfile:

vi Dockerfile

Føj følgende indhold til dockerfilen, og gem og afslut derefter. Hvis du vil gemme og afslutte, skal du trykke på ESC, skrive :wq!og derefter trykke på Enter.

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

ENV CATALINA_HOME=/usr/local/tomcat

# Configure Tomcat Version (Be sure to use the latest version)
ENV TOMCAT_VERSION=10.1.33

# Install Tomcat and required packages
RUN apt-get update ; \
    apt-get install -y curl ; \
    curl -O https://downloads.apache.org/tomcat/tomcat-10/v${TOMCAT_VERSION}/bin/apache-tomcat-${TOMCAT_VERSION}.tar.gz ; \
    tar xzf apache-tomcat-${TOMCAT_VERSION}.tar.gz ; \
    mv apache-tomcat-${TOMCAT_VERSION} ${CATALINA_HOME} ; \
    rm apache-tomcat-${TOMCAT_VERSION}.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-mariner

# 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"]

Seddel

Du kan også bruge den Dockerfile_Solution fil i roden af projektet, som indeholder det indhold, du har brug for.

Dockerfile er opdelt i tre faser, som er beskrevet i følgende tabeller:

  • Installationsfasen for Tomcat:

    Kommandoen Docker Beskrivelse
    FROM FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS tomcat angiver basisbilledet til Microsoft Build af OpenJDK 17 på Ubuntu og navngiver denne fase tomcat. Det er her, Tomcat er installeret.
    ENV ENV CATALINA_HOME=/usr/local/tomcat angiver en miljøvariabel for Tomcat-installationsmappen.
    ENV ENV TOMCAT_VERSION=10.1.33 indstiller den version af Tomcat, der skal installeres. Dette bør opdateres til den nyeste version efter behov.
    RUN Kommandoen RUN opdaterer pakkelisten, installerer , downloader curlden angivne version af Tomcat, pakker den ud, flytter den til den angivne mappe og rydder unødvendige filer og pakker op. Dette sikrer, at billedet forbliver let.

  • Fasen Opret, der kompileres med Java 17:

    Kommandoen Docker Beskrivelse
    FROM FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS build angiver basisbilledet til Microsoft Build af OpenJDK 17 på Ubuntu og navngiver denne fase build. Denne fase bruges til kompilering af Java-programmet.
    WORKDIR WORKDIR /build angiver arbejdsmappen i objektbeholderen til /build, hvor kildekoden kopieres og kompileres.
    RUN RUN apt-get update && apt-get install -y maven && mvn --version installerer Maven, som er et værktøj til buildautomatisering, der bruges til Java-projekter, og kontrollerer installationen.
    COPY COPY pom.xml . kopierer konfigurationsfilen Maven til arbejdsmappen. Denne fil er vigtig for at bygge projektet.
    COPY COPY src ./src kopierer kildekodemappen til objektbeholderen. Det er her, Java-programkoden er placeret.
    COPY COPY web ./web kopierer mappen med webressourcer til objektbeholderen. Dette omfatter de webprogramressourcer, der er nødvendige for buildet.
    RUN RUN mvn clean package udfører Maven-buildprocessen, som kompilerer Java-programmet og pakker det i en WAR-fil.

  • Den sidste fase i pakken:

    Kommandoen Docker Beskrivelse
    FROM FROM mcr.microsoft.com/openjdk/jdk:17-mariner angiver basisafbildningen til Microsoft Build af OpenJDK 17 på CBL-Mariner, som bruges til den endelige installation af programmet.
    ENV ENV CATALINA_HOME=/usr/local/tomcat angiver miljøvariablen for Tomcat-installationsmappen på samme måde som installationsfasen.
    ENV ENV PATH=$CATALINA_HOME/bin:$PATH føjer mappen Tomcat bin til systemet PATH, så Det er nemt at køre Tomcat-kommandoer.
    USER USER app angiver den bruger, som Tomcat-processen kører under, hvilket forbedrer sikkerheden ved ikke at køre som rodbruger.
    COPY COPY --chown=app:app --from=tomcat ${CATALINA_HOME} ${CATALINA_HOME} kopierer Tomcat-installationen fra tomcat fasen og angiver ejerskabet til brugeren app .
    COPY COPY --chown=app:app tomcat-users.xml ${CATALINA_HOME}/conf kopierer Tomcat-brugerkonfigurationsfilen til objektbeholderen og angiver ejerskabet til brugeren app .
    COPY COPY --chown=app:app --from=build /build/target/*.war ${CATALINA_HOME}/webapps/AirlinesReservationSample.war kopierer den kompilerede WAR-fil fra build fasen til Mappen Tomcat-webapps og angiver ejerskabet til brugeren app .
    EXPOSE EXPOSE 8080 fremviser port 8080, som er standardporten for Tomcat, hvilket giver ekstern adgang til programmet.
    CMD CMD ["catalina.sh", "run"] angiver den kommando, der starter Tomcat, når objektbeholderen køres.

Du kan få flere oplysninger om Dockerfile-konstruktion under Reference til Dockerfile.