Dela via

Containerisera dina Java-program för Kubernetes

  • Artikel

Den här artikeln beskriver hur du containeriserar dina Java-program för distribution på Kubernetes. Vägledning om containerminne, JVM-heapminne, skräpinsamlare (GCs) och vCPU-kärnor finns i Containerize your Java applications.

Fastställa lämplig VM-SKU för Kubernetes-nodpoolen

Avgör om Kubernetes-nodpoolen eller poolerna som är tillgängliga för klustret får plats med det containerminne och de vCPU-kärnor som du tänker använda. Om nodpoolen kan vara värd för programmet fortsätter du. Annars etablerar du en nodpool som är lämplig för mängden containerminne och antalet vCPU-kärnor som du riktar in dig på.

Tänk på att kostnaden för en vm-SKU är proportionell mot antalet kärnor och mängden minne. När du har fastställt startpunkten när det gäller vCPU:er och minne för en containerinstans ska du avgöra om du kan uppfylla programmets behov genom att endast skala horisontellt. För tillförlitliga system som alltid är på måste minst två repliker vara tillgängliga. Skala upp och ut efter behov.

Ange CPU-begäranden och gränser

Om du måste begränsa processorn kontrollerar du att du använder samma värde för både limits och requests i distributionsfilen. JVM justerar inte sin körning dynamiskt, till exempel GC och andra trådpooler. JVM läser endast antalet tillgängliga processorer under starttiden.

Tips

Ange samma värde för CPU-begäranden och CPU-gränser.

containers:
- image: myimage
  name: myapp
  resources:
    limits:
      cpu: "2"
    requests:
      cpu: "2"

Förstå JVM-tillgängliga processorer

När HotSpot JVM i OpenJDK identifierar att den körs i en container använder den värden som cpu_quota och cpu_period för att avgöra hur många processorer som är tillgängliga för den. I allmänhet identifieras alla värden upp till 1000m millicores som en dator med en enda processor. Alla värden mellan 1001m och 2000m identifieras som en dator med dubbla processorer och så vidare. Den här informationen är tillgänglig via API:et Runtime.getRuntime().availableProcessors(). Vissa av de samtidiga GC:erna kan också använda det här värdet för att konfigurera sina trådar. Andra API:er, bibliotek och ramverk kan också använda den här informationen för att konfigurera trådpooler.

Kubernetes CPU-kvoter är relaterade till hur lång tid en process spenderar i processorn, och inte antalet processorer som är tillgängliga för processen. Flertrådade körningar, till exempel JVM, kan fortfarande använda flera processorer samtidigt, med flera trådar. Även om en container har en gräns på en vCPU kan JVM instrueras att se två eller flera tillgängliga processorer.

Om du vill informera JVM om det exakta antalet processorer som ska visas i en Kubernetes-miljö använder du följande JVM-flagga:

-XX:ActiveProcessorCount=N

Ange minnesbegäran och gränser

Ange minnesgränserna till den mängd som du fastställde tidigare. Kontrollera att minnesgränsnumret är containerminnet och INTE JVM-heapminnet.

Tips

Ange minnesbegäranden som är lika med minnesgränserna.

containers:
  - name: myimage
    image: myapp
    resources:
      limits:
        memory: "4Gi"
      requests:
        memory: "4Gi"

Ange JVM-argumenten i distributionsfilen

Kom ihåg att ange JVM-heapminnet till den mängd som du tidigare fastställde. Vi rekommenderar att du skickar det här värdet som en miljövariabel så att du enkelt kan ändra det utan att behöva återskapa containeravbildningen.

containers:
  - name: myimage
    image: myapp
    env:
    - name: JAVA_OPTS
      value: "-XX:+UseParallelGC -XX:MaxRAMPercentage=75"

Nästa steg