【云原生|Docker】04-docker的资源限制

news2025/2/26 6:32:36

目录

前言

容器的生命周期 

1.  容器的启动过程

2.  容器的生命周期 

​编辑

内存限制 

1.  内存限制的相关参数

2.  内存限制方式 

2.1  设置-m,--memory，不设置--memory-swap

2.2  设置-m,--memory=a，--memory-swap=b，且b >a

2.3  设置-m,--memory=a，--memory-swap=-1

2.4  内存软限制（设置--memory-reservation）

2.5  OOM killer 

2.6   设置-m=a，--memory-swappiness=0

CPU限制 

1.  cpu限制相关参数

2.  cpu限制方式 

2.1  设置容器可以在哪个CPU上运行 

2.2  cpu权重设置 

Block io限制

1.  限制io的参数 

2.  IO限制操作 

2.1  block IO 权重 

2.2  限制bps和iops

前言

        用户内存限制就是对容器能使用的内存和交换分区的大小作出限制;主机运行若干容器，每个容器都需要cpu、内存以及IO资源，为避免因为单个容器占用过多资源而影响到所有其他容器乃至整个宿主机的性能，因此需要对容器资源进行限制。 

容器的生命周期 

         在说容器的资源限制之前，我们需要补充两点知识点。

1.  容器的启动过程

容器的启动过程说明：

  • 检查本地是否存在指定的镜像，如果没有就从指定的仓库下载
  • 利用镜像启动一个容器
  • 分配一个文件系统，并在只读的镜像层外面挂载一层可读写层
  • 从宿主机配置的网桥接口中桥接一个虚拟接口到容器中去
  • 从地址池配置一个IP给容器
  • 执行用户指定的程序
  • 执行完毕后停止容器

2.  容器的生命周期 

        下面这张图实际上展现了容器的各个状态和操作，比如操作：start，kill，stop等。 

         一个docker host上会运行若干容器，每个容器都需要CPU、内存和 IO 资源。对于 KVM，VMware等虚拟化技术，用户可以控制分配多少 CPU、内存资源给每个虚拟机。对于容器，Docker 也提供了类似的机制避免某个容器因占用太多资源而影响其他容器乃至整个 host 的性能。因此我们需要对容器的内存，cpu，io，磁盘等做适当的限制。

内存限制 

1.  内存限制的相关参数

参数说明

-m,--memory

内存限制，格式是数字加单位，单位可以为 b,k,m,g。最小为4M

--memory-swap

内存+交换分区大小总限制，格式同上，必须比-m设置的值大

--memory-reservation

内存的软性限制，格式同上

--oom-kill-disable

是否阻止 OOM killer 杀死容器，默认没设置

--oom-score-adj

容器被 OOM killer 杀死的优先级，范围是[-1000, 1000]，默认为 0

--memory-swappiness

用于设置容器的虚拟内存控制行为。值为 0~100 之间的整数

--kernel-memory

核心内存限制。格式同上，最小为 4M

 提示：

·  -m，--memory 选项的参数最小为 4 M；

·  --memory-swap不是交换分区，而是内存加交换分区的总大小，所以--memory-swap必须比-m,--memory大；

·  若不设置-m,--memory和--memory-swap，容器默认可用完宿主机所有内存和swap分区。但容器占宿主机所有内存和swap分区超过一段时间后，会被宿主机系统杀死（若没有设置--oom-kill-disable=true）。

2.  内存限制方式 

2.1  设置-m,--memory，不设置--memory-swap

         使用-m或--memory设置一个不小于 4M 的a值，不设置--memory-swap，或将--memory-swap设置为 0。则表示容器能使用的内存大小为 a，能使用的交换分区大小也为 a。因为 Docker 默认容器交换分区的大小和内存相同。若容器中运行一个一直不停申请内存的程序，则该程序最终能使用的内存大小为 2a。

示例： 使用progrium/stress容器来资源测试。 

当设置-m=200m，不设置--memory-swap，则容器最多使用内存大小测试如下： 
Step1：测试内存为200m

[root@clinet ~]# docker run -it -m 200m   progrium/stress --vm 1 --vm-bytes 200m
stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd
stress: dbug: [1] using backoff sleep of 3000us
stress: dbug: [1] --> hogvm worker 1 [7] forked
stress: dbug: [7] allocating 209715200 bytes ...
stress: dbug: [7] touching bytes in strides of 4096 bytes ...
stress: dbug: [7] freed 209715200 bytes
stress: dbug: [7] allocating 209715200 bytes ...
stress: dbug: [7] touching bytes in strides of 4096 bytes ...
stress: dbug: [7] freed 209715200 bytes
stress: dbug: [7] allocating 209715200 bytes ...
stress: dbug: [7] touching bytes in strides of 4096 bytes ...
stress: dbug: [7] freed 209715200 bytes
stress: dbug: [7] allocating 209715200 bytes ...
stress: dbug: [7] touching bytes in strides of 4096 bytes ...

 Step2：测试内存为399m

[root@clinet ~]# 
[root@clinet ~]# docker run -it -m 200m   progrium/stress --vm 1 --vm-bytes 399m
stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd
stress: dbug: [1] using backoff sleep of 3000us
stress: dbug: [1] --> hogvm worker 1 [7] forked
stress: dbug: [7] allocating 418381824 bytes ...
stress: dbug: [7] touching bytes in strides of 4096 bytes ...
stress: dbug: [7] freed 418381824 bytes
stress: dbug: [7] allocating 418381824 bytes ...
stress: dbug: [7] touching bytes in strides of 4096 bytes ...
stress: dbug: [7] freed 418381824 bytes
stress: dbug: [7] allocating 418381824 bytes ...
stress: dbug: [7] touching bytes in strides of 4096 bytes ...

Step3：测试内存为401M

[root@clinet ~]# docker run -it -m 200m   progrium/stress --vm 1 --vm-bytes 401m
stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd
stress: dbug: [1] using backoff sleep of 3000us
stress: dbug: [1] --> hogvm worker 1 [6] forked
stress: dbug: [6] allocating 420478976 bytes ...
stress: dbug: [6] touching bytes in strides of 4096 bytes ...
stress: FAIL: [1] (416) <-- worker 6 got signal 9
stress: WARN: [1] (418) now reaping child worker processes
stress: FAIL: [1] (422) kill error: No such process
stress: FAIL: [1] (452) failed run completed in 0s

 总结：

        使用-m或--memory设置一个不小于 4M 的a值，不设置--memory-swap，或将--memory-swap设置为 0。则表示容器能使用的内存大小为 a，能使用的交换分区大小也为 a。因此容器最大使用的内存数为2a

2.2  设置-m,--memory=a，--memory-swap=b，且b >a

示例： 当设置-m=200m，设置--memory-swap=300m时，此时的swap=100m

Step1：  测试内存为299m（容器正常运行）

[root@clinet ~]# docker run -it -m 200m --memory-swap 300m   progrium/stress --vm 1 --vm-bytes 299m
stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd
stress: dbug: [1] using backoff sleep of 3000us
stress: dbug: [1] --> hogvm worker 1 [6] forked
stress: dbug: [6] allocating 313524224 bytes ...
stress: dbug: [6] touching bytes in strides of 4096 bytes ...
stress: dbug: [6] freed 313524224 bytes
stress: dbug: [6] allocating 313524224 bytes ...
stress: dbug: [6] touching bytes in strides of 4096 bytes ...

step2：测试内存为301时（容器运行异常）

[root@clinet ~]# docker run -it -m 200m --memory-swap 300m   progrium/stress --vm 1 --vm-bytes 301m
stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd
stress: dbug: [1] using backoff sleep of 3000us
stress: dbug: [1] --> hogvm worker 1 [7] forked
stress: dbug: [7] allocating 315621376 bytes ...
stress: dbug: [7] touching bytes in strides of 4096 bytes ...
stress: FAIL: [1] (416) <-- worker 7 got signal 9
stress: WARN: [1] (418) now reaping child worker processes
stress: FAIL: [1] (422) kill error: No such process
stress: FAIL: [1] (452) failed run completed in 0s

   使用-m或--memory设置一个不小于 4M 的a值，且b必须大于a，使用--memory-swap设置一个参数 b。则表示容器能使用的内存大小为 a，能使用的交换分区+内存大小为 b，b-a 即为容器能使用的 swap 分区大小。此时容器最大使用内存为b

2.3  设置-m,--memory=a，--memory-swap=-1

         使用-m或--memory设置一个不小于 4M 的a值，使用--memory-swap设置一个参数-1，则表示限制容器能使用的内存大小为 a，且不限制容器使用 swap 分区大小。

 提示：若出现如下提示：

WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.

可打开内核内存限制的操作：

[root@docker docker]#  vi /etc/default/grub                                                                           
GRUB_CMDLINE_LINUX="cgroup_enable=memory swapaccount=1"                                                               
root@docker:~# update-grub		                     #重启系统

 2.4  内存软限制（设置--memory-reservation）

        Memory reservation是一种软性限制，用于节制容器内存使用。使用--memory-reservation设置一个比-m小的值后，虽然容器最多可以使用-m设置的内存大小，但在宿主机内存资源紧张时，在系统的下次内存回收时，系统会回收容器的部分内存页，强迫容器的内存占用回到--memory-reservation设置的值大小。没有设置时（默认情况下）--memory-reservation的值则--memory-reservation和-m的限定的值相同。将它设置为 0 或设置的比-m的参数大等同于没有设置。这种软性机制，它不保证任何时刻容器使用的内存不会超过--memory-reservation限定的值，它只是确保容器不会长时间占用超过--memory-reservation限制的内存大小。        

[root@docker docker]#  docker run -d --name ubuntu_04 -m 2G --memory-reservation 1G ubuntu:16.04                      

#该容器能使用的内存大小为 2G，当宿主机内存资源紧张时，系统会回收1G内存，以便尝试将容器的内存锁紧到 1G 以下。

2.5  OOM killer 

        OOM killer机制指默认情况下，在出现 out-of-memory(OOM) 错误时，系统会杀死容器内的进程来获取更多空闲内存。通过设置--oom-kill-disable选项来禁止 OOM killer 杀死容器内进程。但请确保只有在使用了-m/--memory选项时才使用--oom-kill-disable禁用 OOM killer。如果没有设置-m选项，却禁用了 OOM-killer，可能会造成出现 out-of-memory 错误时，系统通过杀死宿主机进程或获取更改内存。 

2.6   设置-m=a，--memory-swappiness=0

         默认情况下，容器的内核可以交换出一定比例的swap。--memory-swappiness可设置从 0 到 100这个比例。0 表示关闭swap交换。100 表示所有的swap都可以交换。默认情况下，如果不使用--memory-swappiness，则该值从父进程继承而来。

注意：--memory-swappiness=0 表示禁用容器 swap 功能。

 示例：设置-m=200m和--memory-swappiness=0

 Step·：测试内存为199m（容器正常运行）

[root@clinet ~]# docker run -it -m 200m --memory-swappiness 0   progrium/stress --vm 1 --vm-bytes 199m
stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd
stress: dbug: [1] using backoff sleep of 3000us
stress: dbug: [1] --> hogvm worker 1 [6] forked
stress: dbug: [6] allocating 208666624 bytes ...
stress: dbug: [6] touching bytes in strides of 4096 bytes ...
stress: dbug: [6] freed 208666624 bytes
stress: dbug: [6] allocating 208666624 bytes ...
stress: dbug: [6] touching bytes in strides of 4096 bytes ...
stress: dbug: [6] freed 208666624 bytes
stress: dbug: [6] allocating 208666624 bytes ...
stress: dbug: [6] touching bytes in strides of 4096 bytes ...

Step2：测试内存为201m（容器终止运行）

[root@clinet ~]# docker run -it -m 200m --memory-swappiness 0   progrium/stress --vm 1 --vm-bytes 201m
stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd
stress: dbug: [1] using backoff sleep of 3000us
stress: dbug: [1] --> hogvm worker 1 [7] forked
stress: dbug: [7] allocating 210763776 bytes ...
stress: dbug: [7] touching bytes in strides of 4096 bytes ...
stress: FAIL: [1] (416) <-- worker 7 got signal 9
stress: WARN: [1] (418) now reaping child worker processes
stress: FAIL: [1] (422) kill error: No such process
stress: FAIL: [1] (452) failed run completed in 0s

 总结：

        以上多种内存限制方式中，我们一般只使用设置-m=a，--memory-swappiness=0的方式来限制容器内存的使用，此时-m设置的a值，即为容器可使用的最大值。

CPU限制 

1.  cpu限制相关参数

参数说明

--cpuset-cpus="0,3"

允许使用的 CPU 集，值可以为 0-3,0,1

-c,--cpu-shares=0        

CPU 共享权值（相对权重）

--cpu-period=0

限制 CPU CFS 的周期，范围从 100ms~1s，即[1000, 1000000]

--cpu-quota=0

限制 CPU CFS 配额，必须不小于1ms，即 >= 1000

--cpuset-mems=""

允许在上执行的内存节点（MEMs），只对 NUMA 系统有效

2.  cpu限制方式 

2.1  设置容器可以在哪个CPU上运行 

        表示容器中的进程可以在 cpu 1 和 cpu 3 上执行。 

 docker run -d --name ubuntu_07 --cpuset-cpus="1,3" ubuntu:16.04

2.2  cpu权重设置 

        默认情况下，所有的容器得到同等比例的 CPU 周期。在有多个容器竞争 CPU 时可设置每个容器能使用的 CPU 时间比例。这个比例叫作共享权值，通过-c或--cpu-shares设置。Docker 默认每个容器的权值为 1024。不设置或将其设置为 0，都将使用这个默认值。系统会根据每个容器的共享权值和所有容器共享权值和比例来给容器分配 CPU 时间。 

举例：

        假设有三个正在运行的容器，这三个容器中的任务都是 CPU 密集型的。第一个容器的 cpu 共享权值是 1024，其它两个容器的 cpu 共享权值是 512。第一个容器将得到 50% 的 CPU 时间，而其它两个容器就只能各得到 25% 的 CPU 时间了。如果再添加第四个 cpu 共享值为 1024 的容器，每个容器得到的 CPU 时间将重新计算。第一个容器的CPU 时间变为 33%，其它容器分得的 CPU 时间分别为 16.5%、16.5%、33%。

[root@clinet ~]# docker run -d   -c 1024   progrium/stress -c 1
9423b7ae9b21f86ee22f2ab569f8deadef1657a7fcf526791037f10db063bf66
[root@clinet ~]# docker run -d   -c 512   progrium/stress -c 1
ea17c016c1377d75a9af85df6c66181f53e4fef753780cc639a85234adfe89b7
[root@clinet ~]# docker run -d   -c 512   progrium/stress -c 1
cc45e9082c218a6dc7a6405fd2ab4f38203bc78be2bc104f3cd8eccd6578af0d
[root@clinet ~]# docker ps
CONTAINER ID   IMAGE             COMMAND                  CREATED          STATUS          PORTS     NAMES
cc45e9082c21   progrium/stress   "/usr/bin/stress --v…"   22 seconds ago   Up 20 seconds             pedantic_moore
ea17c016c137   progrium/stress   "/usr/bin/stress --v…"   25 seconds ago   Up 24 seconds             pensive_wing
9423b7ae9b21   progrium/stress   "/usr/bin/stress --v…"   31 seconds ago   Up 30 seconds             sleepy_moore
[root@clinet ~]#

         在多核系统上，CPU 时间权值是在所有 CPU 核上计算的。即使某个容器的 CPU 时间限制少于 100%，它也能使用各个 CPU 核的 100% 时间。

例如，假设有一个2核的系统。用-c=512的选项启动容器{C0}，并且该容器只有一个进程，用-c=1024的启动选项为启动容器C1，此时C0也可以是占用100%

[root@clinet ~]# docker run -d   -c 512   progrium/stress -c 1
6bda65f951693eec80455a32db301dbbf0350c1347f9ea70d50d8ac858e8fe56
[root@clinet ~]# docker run -d   -c 1024   progrium/stress -c 1
41e7bc74b2c3dc04c6d45986121ebdd5f93f9f89f1ab805020084cdeb9b86fd2
[root@clinet ~]# docker ps
CONTAINER ID   IMAGE             COMMAND                  CREATED              STATUS              PORTS     NAMES
41e7bc74b2c3   progrium/stress   "/usr/bin/stress --v…"   About a minute ago   Up About a minute             sleepy_raman
6bda65f95169   progrium/stress   "/usr/bin/stress --v…"   About a minute ago   Up About a minute             peaceful_noyce
[root@clinet ~]#

 总结：

        在实际生产中几乎不会设置容器在某个cpu上运行，使用最多的就是通过权重限制cpu的使用。

Block io限制

        Block IO 是另一种可以限制容器使用的资源。Block IO 指的是磁盘的读写，docker 可通过设置权重、限制 bps 和 iops 的方式控制容器读写磁盘的带宽。

1.  限制io的参数 

参数说明
--blkio-weight设置块 IO 权重，可以为容器指定一个 0 到 1000 的值，值越高，表示容器在 IO 资源分配中拥有更高的优先级。默认值为 0，表示不受限制。
--device-read-bps限制设备的读速率，可以为容器中的设备指定一个最大的读速率，单位是字节/秒，例如 --device-read-bps=/dev/sda:1mb 表示限制容器中 /dev/sda 设备的读速率为 1MB/s
--device-write-bps限制设备的写速率，同上
--device-read-iops限制设备的 IOPS（每秒输入操作数），可以为容器中的设备指定一个最大的 IOPS 数量，例如 --device-read-iops=/dev/sda:100 表示限制容器中 /dev/sda 设备的读 IOPS 为 100。
--device-write-iops限制设备的 IOPS（每秒输出操作数），同上

 bps是byte per second，每秒读写的数据量 ；iops是io per second，每秒io的次数。


注意：目前 Block IO 限额只对 direct IO（不使用文件缓存）有效

2.  IO限制操作 

2.1  block IO 权重 

        ubuntu_10容器的读写磁盘的带宽是ubuntu_11的两倍。

[root@docker docker]# docker run -d --name ubuntu_10 --blkio-weight 600 ubuntu:16.04                             
[root@docker docker]# docker run -d --name ubuntu_11 --blkio-weight 300 ubuntu:16.04

 2.2  限制bps和iops

        ubuntu_12容器写 /dev/sda 的速率为 30 MB/s。 

bps：byte per second，每秒读写的数据量。

iops：io per second，每秒 IO 的次数。

[root@docker docker]#docker run -d --name ubuntu_12 --device-write-bps /dev/sda:30MB ubuntu:16.04

        容器常用的资源限制就是上面所说的：1. -m=a，--memory-swappiness=0的方式来限制容器内存的使用；2. 通过-c或--cpu-shares设置权重限制cpu的使用；3.  通过bps和iops和权重限制block io。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/427439.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

本地从0搭建Stable Diffusion WebUI及错误记录

本地从0搭建Stable Diffusion WebUI及错误记录

从0开始搭建本地Stable Diffusion WebUI环境 一.环境配置 1.使用的电脑配置 系统Windows10处理器英特尔 i7内存24GB显卡NVIDIA GTX 1060(6GB) 2.镜像源 阿里云 清华大学 中国科技大学 3.电脑环境变量配置 我的电脑–属性–高级系统设置–系统属性(高级)–环境变量 新建…
阅读更多...
spring框架注解

spring框架注解

3.Spring有哪些常用注解呢&#xff1f; Spring常用注解 Web: Controller&#xff1a;组合注解&#xff08;组合了Component注解&#xff09;&#xff0c;应用在MVC层&#xff08;控制层&#xff09;。 RestController&#xff1a;该注解为一个组合注解&#xff0c;相当于Con…
阅读更多...
首个ChatGPT开发的应用上线；ChatMind思维导图工具；中文提示词大全；Copilot平替 | ShowMeAI日报

首个ChatGPT开发的应用上线；ChatMind思维导图工具；中文提示词大全；Copilot平替 | ShowMeAI日报

&#x1f440;日报&周刊合集 | &#x1f3a1;生产力工具与行业应用大全 | &#x1f9e1; 点赞关注评论拜托啦&#xff01; &#x1f916; 『一本与众不同的AI绘本』ChatGPT 编写故事 Midjourney 绘制插图 作者的女儿特别喜欢迪士尼动画《海洋奇缘》里的主人公莫阿娜&#…
阅读更多...
Mybatis分解式查询

Mybatis分解式查询

目录 一、Mybatis一对多分解式查询 1. 新增持久层接口方法 2. 新增映射文件对应的标签 3. 新增测试方法 4. 运行效果 二、Mybatis一对一分解式查询 1. 新增持久层接口方法 2. 新增映射文件对应的标签 3. 新增测试方法 4. 运行效果 三、Mybatis延迟加载 1. 开启延迟加…
阅读更多...
超实用的十个超级实用事半功倍的Python自动化脚本

超实用的十个超级实用事半功倍的Python自动化脚本

一淘模板 56admin.com在日常的工作学习当中&#xff0c;我们总会遇到各式各样的问题&#xff0c;其中不少的问题都是一遍又一遍简单重复的操作&#xff0c;不妨直接用Python脚本来自动化处理&#xff0c;今天小编就给大家分享十个Python高级脚本&#xff0c;帮助我们减少无谓的…
阅读更多...
【数据结构与算法】栈的实现（附源码）

【数据结构与算法】栈的实现（附源码）

目录 一.栈的概念和结构 二.接口实现 A.初始化 Stackinit 销毁 Stackdestroy 1.Stackinit 2.Stackdestroy B.插入 Stackpush 删除 Stackpop 1.Stackpush 2.Stackpop C.出栈 Stacktop D. 栈的有效元素 Stacksize 判空 Stackempty 1.Stacksize 2.Stackempty …
阅读更多...
Flink进阶篇-CDC 原理、实践和优化采集到Doris中

Flink进阶篇-CDC 原理、实践和优化采集到Doris中

简介 基于doris官方用doris构建实时仓库的思路&#xff0c;从flinkcdc到doris实时数仓的实践。 原文 Apache Flink X Apache Doris 构建极速易用的实时数仓架构 (qq.com) 前提-Flink CDC 原理、实践和优化 CDC 是什么 CDC 是变更数据捕获&#xff08;Change Data Captur…
阅读更多...
Spring《三》DI依赖注入

Spring《三》DI依赖注入

&#x1f34e;道阻且长&#xff0c;行则将至。&#x1f353; 上一篇&#xff1a;Spring《二》bean的实例化与生命周期 下一篇&#xff1a;敬请期待 目录一、setter注入&#x1f349;1.注入引用数据类型2.注入简单数据类型二、构造器注入&#x1f34a;1.注入引用数据类型2.简单数…
阅读更多...
数据挖掘(2.3)--数据预处理

数据挖掘(2.3)--数据预处理

目录 三、数据集成和转换 1.数据集成 2.数据冗余性 2.1 皮尔森相关系数 2.2卡方检验 3.数据转换 四、数据的规约和变换 1.数据归约 2数据离散化 三、数据集成和转换 1.数据集成 数据集成是将不同来源的数据整合并一致地存储起来的过程。 不同来源的数据可能有不同…
阅读更多...
Qt优秀开源项目之十七：QtPromise

Qt优秀开源项目之十七：QtPromise

QtPromise是Promises/A规范的Qt/C实现。该规范的译文见附录。 QtPromise基于Qt5.6及以上版本&#xff0c;当然也包括Qt6。 github地址&#xff1a;https://github.com/simonbrunel/qtpromise 新手导航&#xff1a;Getting Started | QtPromise API手册&#xff1a;API Referenc…
阅读更多...
详解Spring、SpringBoot、SpringCloud三者的联系与区别

详解Spring、SpringBoot、SpringCloud三者的联系与区别

一、Spring二、Spring Boot三、Spring Cloud四、三者的关系一、Spring Spring 是一个轻量级的Java 开发框架&#xff0c;主要依存于SSM 框架&#xff0c;即Spring MVC Spring Mybatis&#xff0c;定位很明确&#xff0c;Spring MVC主要负责view 层的显示&#xff0c;Spring …
阅读更多...
Scala 一文搞定

Scala 一文搞定

第一节&#xff1a;概述为什么学习Scala ?Apache Spark 是专为大规模数据快速实时处理的计算引擎/内存级大数据计算框架。Apache Spark 是由Scala 语言编写。Scala 与Java 关系总结三点:java 编译器与Scala 编译器可以相互使用。Java SDK 的类库可以被Scala使用&#xff0c;Sc…
阅读更多...
理解什么是sql注入攻击 + xss攻击 + cors 攻击

理解什么是sql注入攻击 + xss攻击 + cors 攻击

SQL注入 SQL注入就是通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串&#xff0c;最终达到欺骗服务器执行恶意的SQL命令。 SQL注入攻击的总体思路: 寻找到SQL注入的位置判断服务器类型和后台数据库类型针对不同的服务器和数据库特点进行SQL注入攻击 SQL注入…
阅读更多...
Cookie和Session的工作流程及区别（附代码案例）

Cookie和Session的工作流程及区别（附代码案例）

目录 一、 HTTP协议 1.1 为什么HTTP协议是无状态的&#xff1f; 1.2 在HTTP协议中流式传输和分块传输编码的区别 二、Cookie和Session 2.1 Cookie 2.2 Session 2.3 Cookie和Session的区别 三、servlet中与Cookie和Session相关的API 3.1 HttpServletRequest 类中的相关方…
阅读更多...
CSRF漏洞的概念、利用方式、防御方案

CSRF漏洞的概念、利用方式、防御方案

CSRF漏洞1.CSRF的概念1.1 什么是CSRF&#xff1f;1.2 基本攻击流程2.CSRF攻击实现2.1 靶场练习2.2 CSRFXSS组合拳2.2.1 攻击页面部署2.2.2 构造恶意xss语句&#xff0c;实现重复生效的CSRF3. CSRF攻击的防御**3.1 只使用JSON API****3.2 验证HTTP Referer字段****3.3 在请求地址…
阅读更多...
【Spring源码】Spring事务原理

【Spring源码】Spring事务原理

目录 1、什么是事务 2、Spring事务基本概念 2.1、基础配置 2.1.1、Spring事务的基础配置 2.1.2、Spring事务的传播特性 2.1.3、Spring事务的隔离级别 2.2、基本原理 3、事务嵌套 3.1、PROPAGATION_REQUIRED 3.2、PROPAGATION_REQUIRES_NEW 3.3、PROPAGATION_SUPPORTS…
阅读更多...
【时序论文小集】

【时序论文小集】

目录【2021 NeurIPS】Autoformer: Decomposition Transformers with Auto-Correlation for Long-Term Series Forecasting【2022 ICML】FEDformer: Frequency Enhanced Decomposed Transformer for Long-term Series Forecasting【2023 ICLR】TIMESNET: TEMPORAL 2D-VARIATION …
阅读更多...
【云原生】k8s NetworkPolicy 网络策略是怎么样的

【云原生】k8s NetworkPolicy 网络策略是怎么样的

前言 随着微服务的流行&#xff0c;越来越多的云服务平台需要大量模块之间的网络调用。 在 Kubernetes 中&#xff0c;网络策略(NetworkPolicy)是一种强大的机制&#xff0c;可以控制 Pod 之间和 Pod 与外部网络之间的流量。 Kubernetes 中的 NetworkPolicy 定义了一组规则&…
阅读更多...
FastAPI: 极速开发Python Web应用的未来之星

FastAPI: 极速开发Python Web应用的未来之星

我在工作中经常使用Flask来开发Web应用。但是随着项目规模的增长&#xff0c;我发现自己需要写越来越多的重复代码&#xff0c;同时Flask并没有提供一个良好的数据验证和文档生成工具。 有一天&#xff0c;我听说了一个名为FastAPI的框架&#xff0c;它被誉为是Python Web框架…
阅读更多...
S型加减速速度给定功能块(SCL+ST+梯形图)

S型加减速速度给定功能块(SCL+ST+梯形图)

S型加减速详细算法公式请参看下面博客文章，这里不再赘述： 博途PLC1200/1500PLC S型速度曲线变频器控制应用(SCL完整源代码)_RXXW_Dor的博客-CSDN博客PLC运动控制基础系列之梯形速度曲线，可以参看下面这篇博客：PLC运动控制基础系列之梯形速度曲线_RXXW_Dor的博客-CSDN博客运…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023