Beholder en Java-app

  • 10 minutter

I denne enheten beholder du et Java-program.

Som nevnt tidligere kjører beholdere direkte over vertsoperativsystemet, kjernen og maskinvaren som vanlige systemprosesser. Beholdere krever færre systemressurser, noe som resulterer i et mindre fotavtrykk, mindre overhead og raskere oppstartstider for programmet. Disse fordelene er store brukstilfeller for skalering ved behov.

Det finnes Windows-beholdere og Linux-beholdere. I denne modulen bruker du den mye brukte Docker-kjøretiden til å bygge et Linux-beholderbilde. Deretter distribuerer du Linux-beholderavbildningen til vertsoperativsystemet på den lokale maskinen. Til slutt distribuerer du Linux-beholderavbildningen til Azure Kubernetes Service.

Docker-oversikt

Docker-kjøretiden brukes til å bygge, trekke, kjøre og sende beholderbilder, som vist i følgende diagram:

Diagram som viser Docker-kommandoer.

Tabellen nedenfor beskriver hver Docker-kommando:

Docker-kommando Beskrivelse
docker build Bygger et beholderbilde som består av instruksjonene eller lagene som kreves for at Docker skal kunne opprette en beholder som kjører fra et bilde. Resultatet av denne kommandoen er et bilde.
docker pull Beholdere initialiseres fra bilder, som hentes fra registre, for eksempel Azure Container Registry. Dette registeret er der Azure Kubernetes Service henter fra. Resultatet av denne kommandoen er en nettverkstrekking av et bilde, som forekommer i Azure. Du kan eventuelt hente bilder lokalt. Dette alternativet er vanlig når du bygger bilder som krever avhengigheter eller lag som programmet kan trenge, for eksempel en programserver.
docker run En kjørende forekomst av et bilde er en beholder, og denne kommandoen utfører alle lagene som kreves for å kjøre og samhandle med det kjørende beholderprogrammet. Resultatet av denne kommandoen er en programprosess som kjører på vertsoperativsystemet.
docker push Azure Container Registry lagrer bildene slik at de er lett tilgjengelige, og nettverket lukkes for Azure-distribusjoner og skalering.

Klone Java-programmet

Først kloner du Flight Booking System for Airline Reservations-repositoriet og navigerer til airlines webprogramprosjektmappen.

Notat

Hvis opprettingen av Azure Kubernetes-tjenesten er ferdig i CLI-fanen, bruker du denne fanen. Hvis den fortsatt kjører, åpner du en ny fane og navigerer til plasseringen der du foretrekker å klone Flight Booking System for Airline Reservations.

Kjø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 installert, kan du også kjøre følgende kommando i terminalkonsollen for å få en følelse av opplevelsen av å bygge programmet uten Docker. Hvis du ikke har Java og Maven installert, kan du trygt gå videre til neste del, konstruere en Docker-fil. I denne delen bruker du Docker til å trekke ned Java og Maven for å utføre byggene på dine vegne.

mvn clean package

Notat

Vi brukte mvn clean package kommandoen til å illustrere de operasjonelle utfordringene ved ikke å bruke Docker flertrinns bygg, som vi dekker neste. Dette trinnet er også valgfritt. Uansett kan du trygt fortsette uten å utføre Maven-kommandoen.

Hvis prosessen var vellykket, bygget Maven Flight Booking System for Airline Reservations Web Application Archive-artefakten AirlinesReservationSample-0.0.1-SNAPSHOT.war, som vist i følgende utdata:

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

Tenk deg at du er en Java-utvikler, og du har nettopp bygget AirlinesReservationSample-0.0.1-SNAPSHOT.war. Det neste trinnet er sannsynligvis å samarbeide med teknikerne for å få denne artefakten distribuert til enten en lokal server eller en virtuell maskin. For at programmet skal starte og kjøre, må servere og virtuelle maskiner være tilgjengelige og konfigurert med de nødvendige avhengighetene. Denne prosessen er utfordrende og tidkrevende, spesielt ved behov når økt belastning treffer programmet. Med beholdere blir disse utfordringene lindret.

Konstruere en Dockerfile

Du er nå klar til å bygge en Dockerfile. En Dockerfile er et tekstdokument som inneholder alle kommandoene en bruker utfører på kommandolinjen for å sette sammen et beholderbilde. Hvert bilde er et lag som kan bufres for effektivitet. Lagene bygger seg oppå hverandre.

Flight Booking System for Airline Reservations må for eksempel distribueres til og kjøres i en programserver. En programserver er ikke pakket inne i AirlinesReservationSample-0.0.1-SNAPSHOT.war. Det er en ekstern avhengighet som trengs for AirlinesReservationSample-0.0.1-SNAPSHOT.war for å kjøre, lytte etter og behandle HTTP-forespørsler, administrere brukerøkter og legge til rette for flybestillinger. Hvis du brukte en tradisjonell, ikke-containerisert distribusjon, installerte og konfigurerte operasjonsteknikere en programserver på en fysisk server eller virtuell maskin før de distribuerte AirlinesReservationSample-0.0.1-SNAPSHOT.war til den. Disse driftsteknikerne må også sørge for at JDK-en som brukes på maskinen – som brukes mvn clean package til å kompilere WAR-filen – faktisk tilsvarer den samme JRE som brukes av programserveren. Det er utfordrende å administrere disse avhengighetene og tidkrevende.

Med en Dockerfile kan du skrive instruksjonene eller lagene som trengs for å oppnå dette målet automatisk, ved å legge lagvis i trinnene som trengs for å sikre at Flight Booking System for Airline Reservations har alle avhengighetene som trengs for å distribuere til Docker-beholderens kjøretid. Denne løsningen er overbevisende når du arbeider med behovsbetinget skala med ikke-planlagte intervaller. Hvert lag bruker Docker-hurtigbufferen, som inneholder statusen for beholderbildet ved hver instruksjonsmilepæl, optimalisering av databehandlingstid og gjenbruk. Hvis et lag ikke endres, brukes bufrede lag. Vanlige brukstilfeller for hurtigbufrede lag er Java-kjøretid, programserver og andre avhengigheter for webprogrammet Flight Booking System for Airline Reservations. Hvis og når en versjon endres på et tidligere bufret lag, opprettes en ny hurtigbufret oppføring.

Diagrammet nedenfor viser lagene i et beholderbilde. Når kommandoene i Dockerfile kjøres, opprettes lagene. Det øverste laget er lese-/skrive Flight Booking System for Airline Reservations web application-laget. Dette laget er bygget oppå de forrige skrivebeskyttede lagene.

Diagram som viser Docker-lagene.

Docker har konseptet med flertrinns bygg, en funksjon som gjør det mulig å opprette et mindre beholderbilde med bedre hurtigbufring og et mindre sikkerhetsfotavtrykk, noe som muliggjør økt optimalisering og vedlikehold av Dockerfile over tid. Du kan for eksempel skille fasen for beholderbygging for kompilering og bygging av programmet fra fasen for å kjøre programmet. Denne funksjonen gjør det mulig å kopiere bare artefaktene som genereres under bygg til produksjonsbeholderbildet, noe som reduserer fotavtrykket. Siden beholderbilder bufres, kan de bufrede bildene brukes på nytt hvis det ikke er noen endringer, noe som reduserer kostnadene og tidspunktet for nedlasting fra nettverket.

Tjenester som eksponeres i produksjonsmiljøet, må administreres nøye for sikkerhet. Derfor bruker og driver produksjonsmiljøet et sikkert beholderbilde. Eksemplet bruker CBL-Mariner bildet fra Microsoft.

CBL-Mariner Linux er et lett operativsystem som bare inneholder pakkene som trengs for et skymiljø. Du kan tilpasse det gjennom egendefinerte pakker og verktøy for å tilpasse kravene til programmet. CBL-Mariner gjennomgår Azure-valideringstester og er kompatibel med Azure-agenter. Microsoft bygger og tester CBL-Mariner for å drive ulike brukstilfeller, alt fra Azure-tjenester til å drive IoT-infrastruktur. Det er den internt anbefalte Linux-distribusjonen for bruk med Microsoft-skytjenester og relaterte produkter.

Notat

Microsoft leverer beholderbilder sammen med OpenJDK, inkludert Ubuntu, CBL-Marinerog distroless bilder. Bildet distroless har den minste bildestørrelsen, men det er utfordrende å kjøre Tomcat. For å oppnå en lett utforming distroless fjerner bildet mange kommandoer og verktøy, inkludert skallet, noe som betyr at du ikke kan kalle catalina.sh for å starte Tomcat. Bildet distroless er egnet for kjøring av kjørbare JAR-er, for eksempel de som brukes med Spring Boot eller Quarkus.

I eksemplet nedenfor brukes samme versjon av Microsoft Build of OpenJDK både i byggefasen og den siste fasen. Denne fremgangsmåten sikrer at du bygger kildekoden med samme versjon av JDK som tjenestedistribusjonen Tomcat bruker, noe som bidrar til å unngå uventet virkemåte på grunn av versjonskonflikter.

Bildet nedenfor viser bygget med flere trinn og hva som skjer i hvert trinn basert på kommandoene som er angitt i Dockerfile:

Diagram som viser Docker-bygget med fleretrinn.

I trinn 0 lastes Tomcat ned og pakkes ut i en katalog som er angitt av en miljøvariabel på et Ubuntu-bilde. Variabelen TOMCAT_VERSION angir hvilken versjon av Tomcat som skal lastes ned. Hvis en ny versjon av Tomcat utgis, bør du oppdatere versjonsnummeret, siden et nytt bilde bare hentes når versjonsnummeret endres. Ellers brukes det bufrede bildet. Tomcat-nedlastingen kopieres til det siste fasemiljøet for bruk.

I trinn 1 installeres Maven på et Ubuntu-bilde, og de opprettede kildekodene og konfigurasjonsfilene kopieres før du bygger Maven-prosjektet. Hvert lag bufres, slik at OS-bildet og Maven-bildelagene bruker hurtigbufferen på nytt. Hvis konfigurasjonsfiler, kildekodefiler eller nettkatalogen oppdateres, bygges lagene fra endringene videre. Hvis bygget fullføres uten feil under kompilering, genereres en artefakt kalt AirlinesReservationSample-0.0.1-SNAPSHOT.war under målkatalogen . Denne artefakten kopieres til det siste fasemiljøet for bruk.

I den siste fasen brukes det sikre CBL-Mariner bildet fra Microsoft til å kopiere tomcat- og Java-byggartefaktene fra henholdsvis trinn 0 og trinn 1. En bruker med navnet app eier alle filer som brukes i prosjektet, og programmet kjøres også som app brukeren i stedet for å ha root rettigheter. Dette oppsettet sikrer at beholderavbildningen kan betjenes på en sikker måte uten å gi unødvendige tillatelser. Til slutt vises portnummer 8080, og det catalina.sh skriptet kjøres for å starte Tomcat. Når dette kjøres på ditt lokale Docker Desktop, kan du få tilgang til det via nettadressen http://localhost:8080/AirlinesReservationSample.

Bruk følgende kommando i rotmappen for prosjektet, containerize-and-deploy-Java-app-to-Azure/Project/Airlines, og bruk følgende kommando til å opprette en fil kalt Dockerfile:

vi Dockerfile

Legg til følgende innhold i Dockerfile, og lagre og avslutt. Hvis du vil lagre og avslutte, trykker du ESC, skriver inn :wq!, og deretter trykker du 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"]

Notat

Du kan også bruke Dockerfile_Solution-filen i roten av prosjektet, som inneholder innholdet du trenger.

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

  • Tomcat-installasjonsfasen:

    Docker-kommando Beskrivelse
    FROM FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS tomcat angir basisbildet til Microsoft Build of OpenJDK 17 på Ubuntu, og navngir denne fasen tomcat. Det er her Tomcat er installert.
    ENV ENV CATALINA_HOME=/usr/local/tomcat angir en miljøvariabel for Tomcat-installasjonskatalogen.
    ENV ENV TOMCAT_VERSION=10.1.33 angir hvilken versjon av Tomcat som skal installeres. Dette bør oppdateres til den nyeste versjonen etter behov.
    RUN Kommandoen RUN oppdaterer pakkelisten, installerer curl, laster ned den angitte versjonen av Tomcat, trekker den ut, flytter den til den angitte katalogen og rydder opp unødvendige filer og pakker. Dette sikrer at bildet forblir lett.

  • Bygg-fasen, som kompileres med Java 17:

    Docker-kommando Beskrivelse
    FROM FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS build angir basisbildet til Microsoft Build of OpenJDK 17 på Ubuntu, og navngir denne fasen build. Denne fasen brukes til å kompilere Java-programmet.
    WORKDIR WORKDIR /build angir arbeidskatalogen i beholderen til /build, der kildekoden kopieres og kompileres.
    RUN RUN apt-get update && apt-get install -y maven && mvn --version installerer Maven, et verktøy for byggautomasjon som brukes til Java-prosjekter, og bekrefter installasjonen.
    COPY COPY pom.xml . kopierer Maven-konfigurasjonsfilen til arbeidskatalogen. Denne filen er viktig for å bygge prosjektet.
    COPY COPY src ./src kopierer kildekodekatalogen til beholderen. Det er her Java-programkoden befinner seg.
    COPY COPY web ./web kopierer nettressurskatalogen til beholderen. Dette inkluderer webprogramressurser som kreves for bygget.
    RUN RUN mvn clean package kjører Maven-byggeprosessen, som kompilerer Java-programmet og pakker det inn i en WAR-fil.

  • Pakkens siste fase:

    Docker-kommando Beskrivelse
    FROM FROM mcr.microsoft.com/openjdk/jdk:17-mariner angir basisbildet til Microsoft Build of OpenJDK 17 på CBL-Mariner, som brukes til den endelige distribusjonen av programmet.
    ENV ENV CATALINA_HOME=/usr/local/tomcat angir miljøvariabelen for Tomcat-installasjonskatalogen, på samme måte som installasjonsfasen.
    ENV ENV PATH=$CATALINA_HOME/bin:$PATH legger til Tomcat-bin-katalogen i systemet PATH, slik at Tomcat-kommandoer enkelt kan kjøres.
    USER USER app angir brukeren der Tomcat-prosessen kjører, noe som forbedrer sikkerheten ved ikke å kjøre som rotbruker.
    COPY COPY --chown=app:app --from=tomcat ${CATALINA_HOME} ${CATALINA_HOME} kopierer Tomcat-installasjonen fra tomcat fasen, og angir eierskapet app til brukeren.
    COPY COPY --chown=app:app tomcat-users.xml ${CATALINA_HOME}/conf kopierer tomcat-brukerkonfigurasjonsfilen til beholderen og angir eierskapet app til brukeren.
    COPY COPY --chown=app:app --from=build /build/target/*.war ${CATALINA_HOME}/webapps/AirlinesReservationSample.war kopierer den kompilerte WAR-filen fra build fasen til Tomcat webapps-katalogen , og angir eierskapet app til brukeren.
    EXPOSE EXPOSE 8080 viser port 8080, standardporten for Tomcat, som gir ekstern tilgang til programmet.
    CMD CMD ["catalina.sh", "run"] angir kommandoen for å starte Tomcat når beholderen kjøres.

Hvis du vil ha mer informasjon om Dockerfile-konstruksjonen, kan du se Dockerfile-referansen.