Containerisera dina Java-program

Den här artikeln innehåller en översikt över rekommenderade strategier och inställningar för att containerisera Java-program. När du containeriserar ett Java program bör du noga överväga hur mycket CPU-tid containern har tillgänglig. Fundera sedan på hur mycket minne som är tillgängligt både när det gäller den totala mängden minne och heapstorleken för den Java virtuella datorn (JVM). I containerbaserade miljöer kan program ha åtkomst till alla processorer och därför kunna köra flera trådar parallellt. Det är dock vanligt att containrar har en cpu-kvot som kan begränsa åtkomsten till processorer.

JVM använder heuristik för att fastställa antalet "tillgängliga processorer" baserat på CPU-kvoten, vilket avsevärt kan påverka prestandan för Java program. Det minne som allokeras till själva containern och storleken på heapområdet för JVM är lika viktigt som processorerna. Dessa faktorer avgör beteendet för skräpinsamlaren (GC) och systemets övergripande prestanda.

Containerisera ett nytt program

När du containeriserar en Java arbetsbelastning för ett nytt program bör du tänka på två saker när du tänker på minne:

• Det minne som allokerats till själva containern.
• Mängden minne som är tillgängligt för Java-processen.

Förstå JVM-standardergonom

Program behöver en startpunkt och inställningar. JVM har standardergonom med fördefinierade värden som baseras på antalet tillgängliga processorer och mängden minne i systemet. JVM använder standardvärdena som visas i följande tabeller när du startar den utan specifika startflaggor eller parametrar.

I följande tabell visas standard-GC för tillgängliga resurser:

I följande tabell visas den maximala standardstorleken för heap beroende på hur mycket minne som är tillgängligt i miljön där JVM körs:

Standardstorleken för den initiala heapen är 1/64 tillgängligt minne. Dessa värden är giltiga för OpenJDK 11 och senare – och för de flesta distributioner, inklusive Microsoft Build för OpenJDK, Azul Zulu, Eclipse Temurin, Oracle OpenJDK och andra.

Bestämma minne för container

Välj en containerminnesmängd som passar bäst för din arbetsbelastning, beroende på programmets behov och dess distinkta användningsmönster. Om ditt program till exempel skapar stora objektdiagram behöver du förmodligen mer minne än du skulle behöva för program med många små objektdiagram.

Bestäm JVM heap-minne

När du allokerar JVM-heapminne ska du komma ihåg att JVM behöver mer minne än det belopp som du allokerar för JVM-heapen. Ange inte att det maximala JVM-heapminnet ska vara lika med mängden containerminne. Den här inställningen kan orsaka OOM-fel (out of Memory) och containerkrascher.

I OpenJDK 11 och senare anger du JVM-heapstorleken på något av följande sätt:

Minsta eller ursprungliga storlek på heapen

Om miljön garanterar en viss mängd minne som är reserverat för en JVM-instans, till exempel i en container, anger du den minsta heapstorleken eller den ursprungliga heapstorleken till samma storlek som den maximala heapstorleken. Den här inställningen anger för JVM att den inte ska utföra uppgiften att frigöra minne till operativsystemet.

Om du vill ange en minsta heapstorlek använder du -Xms för absoluta belopp eller -XX:InitialRAMPercentage för procentbelopp.

Avgöra vilken GC som ska användas

Tidigare fastställde du hur mycket JVM-heapminne som ska börja med. Nästa steg är att välja din GC. Den maximala mängden JVM-heapminne som du har påverkar ofta ditt val av GC. I följande tabell beskrivs egenskaperna för varje GC.

Fastställa hur många CPU-kärnor du behöver

För alla andra GC än SerialGC, använd två eller fler vCPU-kärnor – eller minst 2000m för cpu_limit i Kubernetes. Välj inte mindre än en vCPU-kärna i containerbaserade miljöer.

Välj en startpunkt

Börja med två repliker eller instanser i containerorkestreringsmiljöer som Kubernetes, OpenShift, Azure Spring Apps, Azure Container Apps och Azure App Service. I följande tabell sammanfattas de rekommenderade startpunkterna för containeriseringen av ditt nya Java-program.

Använd följande JVM-parametrar:

-XX:+UseParallelGC -XX:MaxRAMPercentage=75

Justera JVM automatiskt med Azure-kommandostartaren för Java

I föregående avsnitt beskrivs hur du väljer JVM-flaggor manuellt baserat på containerminne, CPU-kärnor och arbetsbelastningstyp. Om du inte vill behålla de här inställningarna själv tillämpar Azure-kommandostartaren för Java (jaz) molnbaserade JVM-standardvärden automatiskt.

Azure Command Launcher för Java är ett enkelt verktyg som finns mellan startkommandot och JVM. Den identifierar molnmiljön, inklusive minnes- och CPU-gränser för containern, och väljer sedan de lämpligaste inställningsflaggorna för heapstorlek, val av GC och diagnostik. Den här metoden minskar konfigurationskostnaderna och förbättrar resursanvändningen direkt.

Om du vill använda verktyget ersätter java du kommandot med jaz i startskriptet eller Dockerfile. I stället för att justera JVM-alternativ manuellt:

java -XX:+UseParallelGC -XX:MaxRAMPercentage=75 -jar myapp.jar

Använd jaz:

jaz -jar myapp.jar

Verktyget ingår i containeravbildningarna för Microsoft Build för OpenJDK, så ingen extra installation krävs. Följande Dockerfile använder jaz för att köra ett Java program från en jar fil:

# Use any Microsoft Build of OpenJDK base image
FROM mcr.microsoft.com/openjdk/jdk:25-ubuntu

# Add your application.jar
COPY application.jar /application.jar

# Use jaz to launch your Java application
CMD ["jaz", "-jar", "application.jar"]

Installationsalternativ, miljöer som stöds och konfigurationsinformation finns i Azure Kommandostartare för Java.

Containerisera ett befintligt lokalt program

Om programmet redan körs lokalt eller på en virtuell dator i molnet börjar du med följande konfiguration:

• Samma mängd minne som programmet för närvarande har åtkomst till.
• Samma antal processorer eller vCPU-kärnor som programmet för närvarande har tillgängligt.
• Samma JVM-parametrar som du använder för närvarande.

Om kombinationen av vCPU-kärnor eller containerminne inte är tillgänglig väljer du den närmaste och avrundar vCPU-kärnorna och containerminnet.

Nästa steg

Nu när du förstår de allmänna rekommendationerna för att containerisera Java program fortsätter du till följande artiklar för att upprätta en baslinje för containerisering och förenkla JVM-justering:

• Upprätta en baslinje för containerbaserade Java-program
• Azure Kommandostartsprogram för Java