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 (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.

Dricks

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 och cpu_period för att avgöra hur många processorer som cpu_quota är tillgängliga för den. I allmänhet identifieras alla värden upp till 1000m millicores som en enda processordator. 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 Runtime.getRuntime().availableProcessors(). Det här värdet kan också användas av några av de samtidiga GC:erna 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.

Dricks

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 det belopp som du tidigare har fastställt. 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