Java程序在K8S容器部署CPU和Memory资源限制相关设置

简介: 背景在k8s docker环境中执行Java程序,因为我们设置了cpu,memory的limit,所以Java程序执行时JVM的参数没有跟我们设置的参数关联,导致JVM感知到的cpu和memory是我们k8s的work node上的cpu和memory大小。

背景

在k8s docker环境中执行Java程序,因为我们设置了cpu,memory的limit,所以Java程序执行时JVM的参数没有跟我们设置的参数关联,导致JVM感知到的cpu和memory是我们k8s的work node上的cpu和memory大小。这样造成的问题是:当容器中Java程序使用内存超过memory limit时,直接造成Out of Memory错误,从而引起容器重启。JVM很多参数也是很智能的,启动时内存的分配也会根据cpu和memory进行调整,比如GC相关的参数就是动态调整的。如果容器感知到的cpu核数不对,那么对程序的性能也会造成很大的影响。

内存

Java对内存的使用有几个参数可以配置。以前的版本可以用-Xms, -Xmx来分别设置初始化Java堆大小和最大的Java堆大小。但因为Java堆大小并不等于所有可用的内存大小,所以在设置memory limit的时候会加一个值。这样避免Java使用的内存超过分配给容器的最大内存限制。这个增加的值需要一定的经验和测试来获取。

JVM后来提供了UseCGroupMemoryLimitForHeap参数来让JVM自动根据我们提供的内存限制来分配堆的大小。这样也就避免了我们人为去确定应该给堆多大的空间。只要经过测试,确定这个Java程序占用的总共空间就行了。使用方法是在java运行后面加上参数:java -XX:+UnlockExperimentalVMOptions -XX:+UseCGroupMemoryLimitForHeap ⋯

CPU

配了上面的参数,我们还没有完全解决问题。因为JVM GC相关的参数跟CPU处理器核相关联的,可使用的CPU核数越多,分配给GC的线程资源也越多。如果我们不设置正确的CPU核数给容器,那么它看到的就是整个k8s worker node的CPU个数,比如我们限制容器可使用2core,但worker node有32core。那么这个容器会给GC分配很多的线程资源,从而严重影响正常Java线程的运行。

CPU个数对JVM GC的影响

JVM提供了ActiveProcessorCount参数来设置这个值。但这个参数只在java 1.8.0_191以后版本才支持。下面我在笔记本上做了测试(total 8 cores),看看这个参数如何影响GC的参数。

Step1: 写一个hello wold程序。

root@kyle:~# cat Hello.java
public class Hello{
    public static void  main(String[] args){
        System.out.println("hello world");
}

Step2: 编译

root@kyle:~# javac Hello.java

Step3: 不加参数运行

root@kyle:~# java -XX:+PrintFlagsFinal Hello > init.txt
[Global flags]
     intx ActiveProcessorCount                      = -1                                  {product}
    uintx AdaptiveSizeDecrementScaleFactor          = 4                                   {product}
    uintx AdaptiveSizeMajorGCDecayTimeScale         = 10                                  {product}
    uintx AdaptiveSizePausePolicy                   = 0                                   {product}
    uintx AdaptiveSizePolicyCollectionCostMargin    = 50                                  {product}
…

Step4: 加不同参数值运行

root@kyle:~# java -XX:ActiveProcessorCount=1 -XX:+PrintFlagsFinal Hello > p1.txt
root@kyle:~# java -XX:ActiveProcessorCount=2 -XX:+PrintFlagsFinal Hello > p2.txt
root@kyle:~# java -XX:ActiveProcessorCount=4 -XX:+PrintFlagsFinal Hello > p4.txt
root@kyle:~# java -XX:ActiveProcessorCount=8 -XX:+PrintFlagsFinal Hello > p8.txt

Step5: 看看不同参数对GC的影响:
1个处理器跟2个处理器的比较:

 root@kyle:~# diff p1.txt p2.txt
2c2
<      intx ActiveProcessorCount                     := 1                                   {product}
---
>      intx ActiveProcessorCount                     := 2                                   {product}
304c304
<     uintx MarkSweepDeadRatio                        = 5                                   {product}
---
>     uintx MarkSweepDeadRatio                        = 1                                   {product}
311c311
<     uintx MaxHeapFreeRatio                          = 70                                  {manageable}
---
>     uintx MaxHeapFreeRatio                          = 100                                 {manageable}
335,336c335,336
<     uintx MinHeapDeltaBytes                        := 196608                              {product}
<     uintx MinHeapFreeRatio                          = 40                                  {manageable}
---
>     uintx MinHeapDeltaBytes                        := 524288                              {product}
>     uintx MinHeapFreeRatio                          = 0                                   {manageable}
388c388
<     uintx ParallelGCThreads                         = 0                                   {product}
---
>     uintx ParallelGCThreads                         = 2                                   {product}
682,683c682,683
<      bool UseParallelGC                             = false                               {product}
<      bool UseParallelOldGC                          = false                               {product}
---
>      bool UseParallelGC                            := true                                {product}
>      bool UseParallelOldGC                          = true                                {product}

2个处理器跟4个处理器的比较:

root@kyle:~# diff p2.txt p4.txt
2c2
<      intx ActiveProcessorCount                     := 2                                   {product}
---
>      intx ActiveProcessorCount                     := 4                                   {product}
59c59
<      intx CICompilerCount                          := 2                                   {product}
---
>      intx CICompilerCount                          := 3                                   {product}
388c388
<     uintx ParallelGCThreads                         = 2                                   {product}
---
>     uintx ParallelGCThreads                         = 4                                   {product}

4个处理器跟8个处理器的比较:

root@kyle:~# diff p4.txt p8.txt
2c2
<      intx ActiveProcessorCount                     := 4                                   {product}
---
>      intx ActiveProcessorCount                     := 8                                   {product}
59c59
<      intx CICompilerCount                          := 3                                   {product}
---
>      intx CICompilerCount                          := 4                                   {product}
388c388
<     uintx ParallelGCThreads                         = 4                                   {product}
---
>     uintx ParallelGCThreads                         = 8                                   {product}

不加参数跟8个处理器的比较:

root@kyle:~# diff init.txt p8.txt
2c2
<      intx ActiveProcessorCount                      = -1                                  {product}
---
>      intx ActiveProcessorCount                     := 8                                   {product}

从上面比较可以看出,不设这个参数跟设置最大参数(当前系统是8core)是一样的。2,4,8核设置只影响ParallelGCThreads, CICompilerCount。但如果只用1核的话,UseParallelGC,UseParallelOldGC都变为false,同时也会影响其它几个参数。见上面diff p1.txt p2.txt比较结果。

CPU个数对Java程序的影响

CPU个数的设置除了对JVM GC性能产生影响外,对Java的工作线程也会产生影响。以下的代码常用于Java库,它会根据CPU的个数产生工作线程。如果没有正确设置docker中的参数,对实际的程序性能会产生很大的影响。

Runtime.getRuntime().availableProcessors()

以下代码摘自aliyun-log-java-producer库,是根据可用处理器来产生相应个数的IO线程来发送loghub数据。

# ProducerConfig.java:
public class ProducerConfig {
  public static final int DEFAULT_IO_THREAD_COUNT =
      Math.max(Runtime.getRuntime().availableProcessors(), 1);

OpenJDK版本

我们运行以下命令检查JDK的版本。openjdk version "1.8.0_131"以后支持UseCGroupMemoryLimitForHeap参数,"1.8.0_191"以后才支持ActiveProcessorCount这个参数。

root@kyle:~# java -version
openjdk version "1.8.0_191"
OpenJDK Runtime Environment (build 1.8.0_191-8u191-b12-2ubuntu0.16.04.1-b12)
OpenJDK 64-Bit Server VM (build 25.191-b12, mixed mode)

改进方案

如果我们使用的JDK版本支持这2个参数,那么我们只需要在运行Java程序时把这UseCGroupMemoryLimitForHeap参数加上,同时再给ActiveProcessorCount参数赋值实际分配给容器的cpu limit就可以了。如果目前的JDK版本低于1.8.0_191,即不支持ActiveProcessorCount,针对这个情况,有2种方法可以进行:

  1. 建议升级到191以后的版本,然后根据cpu limit配置ActiveProcessorCount。
  2. 不升级jdk版本,直接设置跟ActiveProcessorCount参数相关的GC参数:比如ParallelGCThreads,CICompilerCount。如果是1.8.0_131以前的版本,可以用-Xms, -Xmx参数进行堆空间的大小分配,注意这两个参数只设置了分配给堆的大小,实际的memory limit应该比这个大。这种方案不是一个best practice,毕竟这样没有用到JVM自动适配的一些参数。最关键的,此种方法不能避免很多Java库根据availableProcessors()来做相应逻辑处理。

参考资料

  1. Assign Memory Resources to Containers and Pods
  2. Assign CPU Resources to Containers and Pods
  3. Kubernetes Demystified: Restrictions on Java Application Resources
  4. JVM 对 docker 容器 CPU 限制的兼容
  5. Java SE support for Docker CPU and memory limits
  6. 关于Jvm知识看这一篇就够了
相关实践学习
深入解析Docker容器化技术
Docker是一个开源的应用容器引擎,让开发者可以打包他们的应用以及依赖包到一个可移植的容器中,然后发布到任何流行的Linux机器上,也可以实现虚拟化,容器是完全使用沙箱机制,相互之间不会有任何接口。Docker是世界领先的软件容器平台。开发人员利用Docker可以消除协作编码时“在我的机器上可正常工作”的问题。运维人员利用Docker可以在隔离容器中并行运行和管理应用,获得更好的计算密度。企业利用Docker可以构建敏捷的软件交付管道,以更快的速度、更高的安全性和可靠的信誉为Linux和Windows Server应用发布新功能。 在本套课程中,我们将全面的讲解Docker技术栈,从环境安装到容器、镜像操作以及生产环境如何部署开发的微服务应用。本课程由黑马程序员提供。 &nbsp; &nbsp; 相关的阿里云产品:容器服务 ACK 容器服务 Kubernetes 版(简称 ACK)提供高性能可伸缩的容器应用管理能力,支持企业级容器化应用的全生命周期管理。整合阿里云虚拟化、存储、网络和安全能力,打造云端最佳容器化应用运行环境。 了解产品详情: https://www.aliyun.com/product/kubernetes
相关文章
|
4月前
|
机器学习/深度学习 人工智能 监控
Java与AI模型部署:构建企业级模型服务与生命周期管理平台
随着企业AI模型数量的快速增长,模型部署与生命周期管理成为确保AI应用稳定运行的关键。本文深入探讨如何使用Java生态构建一个企业级的模型服务平台,实现模型的版本控制、A/B测试、灰度发布、监控与回滚。通过集成Spring Boot、Kubernetes、MLflow和监控工具,我们将展示如何构建一个高可用、可扩展的模型服务架构,为大规模AI应用提供坚实的运维基础。
339 0
存储 jenkins 持续交付
659 2
|
7月前
|
安全 JavaScript Java
java Web 项目完整案例实操指南包含从搭建到部署的详细步骤及热门长尾关键词解析的实操指南
本项目为一个完整的JavaWeb应用案例,采用Spring Boot 3、Vue 3、MySQL、Redis等最新技术栈,涵盖前后端分离架构设计、RESTful API开发、JWT安全认证、Docker容器化部署等内容,适合掌握企业级Web项目全流程开发与部署。
603 0
|
7月前
|
Java 应用服务中间件 Docker
java-web部署模式概述
本文总结了现代 Web 开发中 Spring Boot HTTP 接口服务的常见部署模式,包括 Servlet 与 Reactive 模型、内置与外置容器、物理机 / 容器 / 云环境部署及单体与微服务架构,帮助开发者根据实际场景选择合适的方案。
286 25
|
8月前
|
Java 应用服务中间件 Linux
在Java 12环境中配置和部署Apache Tomcat的步骤。
这段部署Tomcat的冒险旅程充满技术挑战,但同时也像游戏一样充满乐趣。它需要你提前准备,仔细执行,并随时准备解决意外情况。成功后,你就可以在这匹强壮的网络野马上,带着你的Java应用,冲向Web开发的璀璨星空。
248 56
|
8月前
|
安全 Java Docker
Docker 部署 Java 应用实战指南与长尾优化方案
本文详细介绍了Docker容器化部署Java应用的最佳实践。首先阐述了采用多阶段构建和精简JRE的镜像优化技术,可将镜像体积减少60%。其次讲解了资源配置、健康检查、启动优化等容器化关键配置,并演示了Spring Boot微服务的多模块构建与Docker Compose编排方案。最后深入探讨了Kubernetes生产部署、监控日志集成、灰度发布策略以及性能调优和安全加固措施,为Java应用的容器化部署提供了完整的解决方案指南。文章还包含大量可落地的代码示例,涵盖从基础到高级的生产环境实践。
452 3
|
10月前
|
前端开发 Java 物联网
智慧班牌源码,采用Java + Spring Boot后端框架,搭配Vue2前端技术,支持SaaS云部署
智慧班牌系统是一款基于信息化与物联网技术的校园管理工具,集成电子屏显示、人脸识别及数据交互功能,实现班级信息展示、智能考勤与家校互通。系统采用Java + Spring Boot后端框架,搭配Vue2前端技术,支持SaaS云部署与私有化定制。核心功能涵盖信息发布、考勤管理、教务处理及数据分析,助力校园文化建设与教学优化。其综合性和可扩展性有效打破数据孤岛,提升交互体验并降低管理成本,适用于日常教学、考试管理和应急场景,为智慧校园建设提供全面解决方案。
586 70
|
11月前
|
Kubernetes 负载均衡 Java
k8s的出现解决了java并发编程胡问题了
Kubernetes通过提供自动化管理、资源管理、服务发现和负载均衡、持续交付等功能,有效地解决了Java并发编程中的许多复杂问题。它不仅简化了线程管理和资源共享,还提供了强大的负载均衡和故障恢复机制,确保应用程序在高并发环境下的高效运行和稳定性。通过合理配置和使用Kubernetes,开发者可以显著提高Java应用程序的性能和可靠性。
222 31
|
12月前
|
存储 IDE Java
java设置栈内存大小
在Java应用中合理设置栈内存大小是确保程序稳定性和性能的重要措施。通过JVM参数 `-Xss`,可以灵活调整栈内存大小,以适应不同的应用场景。本文介绍了设置栈内存大小的方法、应用场景和注意事项,希望能帮助开发者更好地管理Java应用的内存资源。
658 4
|
12月前
|
数据采集 算法 Java
如何在Java爬虫中设置动态延迟以避免API限制
如何在Java爬虫中设置动态延迟以避免API限制

相关产品

  • 容器服务Kubernetes版