Uw Java-toepassingen in een container plaatsen

Dit artikel bevat een overzicht van aanbevolen strategieën en instellingen voor het containeriseren van Java-toepassingen. Wanneer u een Java-toepassing in een container plaats, moet u zorgvuldig overwegen hoeveel CPU-tijd de container beschikbaar heeft. Bedenk vervolgens hoeveel geheugen er beschikbaar is in termen van de totale hoeveelheid geheugen en de heapgrootte van de Java Virtual Machine (JVM). In containeromgevingen hebben toepassingen mogelijk toegang tot alle processors en kunnen ze daarom meerdere threads parallel uitvoeren. Het is echter gebruikelijk dat containers een CPU-quotum hebben toegepast dat de toegang tot CPU's kan beperken.

De JVM heeft heuristieken om het aantal 'beschikbare processors' te bepalen op basis van cpu-quotum, wat de prestaties van Java-toepassingen aanzienlijk kan beïnvloeden. Het geheugen dat is toegewezen aan de container zelf en de grootte van het heap-gebied voor de JVM zijn net zo belangrijk als de processors. Deze factoren bepalen het gedrag van de garbagecollector (GC) en de algehele prestaties van het systeem.

Een nieuwe toepassing containeriseren

Wanneer u een Java-workload voor een nieuwe toepassing in een container opneemt, moet u rekening houden met twee dingen bij het nadenken over geheugen:

• Het geheugen dat is toegewezen aan de container zelf.
• De hoeveelheid geheugen die beschikbaar is voor het Java-proces.

Inzicht in de standaard ergonomie van de JVM

Toepassingen hebben een beginpunt en instellingen nodig. De JVM heeft standaard ergonomische waarden met vooraf gedefinieerde waarden die zijn gebaseerd op het aantal beschikbare processors en de hoeveelheid geheugen in het systeem. De standaardwaarden die in de volgende tabellen worden weergegeven, worden gebruikt wanneer de JVM wordt gestart zonder specifieke opstartvlagken of parameters.

In de volgende tabel ziet u de standaard GC die wordt gebruikt voor de beschikbare resources:

In de volgende tabel ziet u de standaard maximale heapgrootte, afhankelijk van de hoeveelheid geheugen die beschikbaar is in de omgeving waarin de JVM wordt uitgevoerd:

De standaard initiële heapgrootte is 1/64 van het beschikbare geheugen. Deze waarden zijn geldig voor OpenJDK 11 en hoger, en voor de meeste distributies, waaronder Microsoft Build van OpenJDK, Azul Zulu, Eclipse Temurin, Oracle OpenJDK en andere.

Containergeheugen bepalen

Kies een geheugenhoeveelheid voor containers die het beste past bij uw werkbelasting, afhankelijk van de behoeften van uw toepassing en de bijbehorende onderscheidende gebruikspatronen. Als uw toepassing bijvoorbeeld grote objectgrafieken maakt, hebt u waarschijnlijk meer geheugen nodig dan u nodig hebt voor toepassingen met veel kleine objectgrafieken.

JVM-heap-geheugen bepalen

Wanneer u JVM-heapgeheugen toewijst, heeft de JVM meer geheugen nodig dan wordt gebruikt voor de JVM-heap. Wanneer u het maximale JVM-heap-geheugen instelt, mag deze nooit gelijk zijn aan de hoeveelheid containergeheugen, omdat dit OOM-fouten (Container Out of Memory) en containercrashes veroorzaakt.

Op OpenJDK 11 en hoger kunt u de grootte van de JVM-heap op de volgende manieren instellen:

Minimale/initiële heapgrootte

Wanneer de omgeving gegarandeerd een bepaalde hoeveelheid geheugen heeft gereserveerd voor een JVM-instantie, zoals in een container, moet u de minimale heap-grootte (of initiële heapgrootte) instellen op dezelfde grootte als de maximale heapgrootte. Deze instelling geeft aan dat de JVM niet de taak moet uitvoeren om geheugen vrij te maken voor het besturingssysteem.

Als u een minimale heap-grootte wilt instellen, gebruikt -Xms u deze voor absolute bedragen of -XX:InitialRAMPercentage voor percentagebedragen.

Bepaal welke GC je moet gebruiken

In het verleden hebt u de hoeveelheid JVM heap-geheugen bepaald waarmee u moet beginnen. De volgende stap is het kiezen van uw GC. De hoeveelheid maximaal JVM-heapgeheugen dat u hebt, is vaak een factor bij het kiezen van uw GC. In de volgende tabel worden de kenmerken van elke GC beschreven.

Bepalen hoeveel CPU-kernen er nodig zijn

Voor andere GC's dan SerialGC raden we twee of meer vCPU-kernen aan, of ten minste 2000m voor cpu_limit Kubernetes. U wordt aangeraden niets minder dan één vCPU-kern te selecteren in containeromgevingen.

Kies een beginpunt

We raden u aan om te beginnen met twee replica's of exemplaren in containerindelingsomgevingen, zoals Kubernetes, OpenShift, Azure Spring Apps, Azure Container Apps en Azure App Service. De volgende tabel bevat een overzicht van de aanbevolen uitgangspunten voor de containerisatie van uw nieuwe Java-toepassing.

Gebruik de volgende JVM-parameters:

-XX:+UseParallelGC -XX:MaxRAMPercentage=75

Een bestaande on-premises toepassing in een container plaatsen

Als uw toepassing al on-premises of op een VIRTUELE machine in de cloud wordt uitgevoerd, wordt u aangeraden te beginnen met de volgende configuratie:

• Dezelfde hoeveelheid geheugen waartoe de toepassing momenteel toegang heeft.
• Hetzelfde aantal CPU's of vCPU-kernen dat de toepassing momenteel beschikbaar heeft.
• Dezelfde JVM-parameters die u momenteel gebruikt.

Als de combinatie van vCPU-kernen of containergeheugen niet beschikbaar is, kiest u het dichtstbijzijnde kerngeheugen, waarbij u de vCPU-kernen en het containergeheugen omhoog rondt.

Volgende stappen

Nu u de algemene aanbevelingen voor het containeriseren van Java-toepassingen begrijpt, gaat u verder met het volgende artikel om een containerisatiebasislijn op te stellen:

• Een basislijn instellen voor in containers geplaatste Java-toepassingen