Apache的MaxClients的适当值是多少？

3 年 ago

逸, 科

9 minutes

关于MaxClients和MaxRequestWorkers的提及

请按时间顺序总结有关 Apache 的 MaxClients / MaxRequestWorkers 适当值的言及。敬称略。
如果还有其他重要的网页提到，请告知。

2002/07/23 一志達也（TIS株式会社）:

2002年7月23日，一志達也（TIS株式会社）。

Apache通过构建Web服务器（16）：Apache性能调优实践（2/2）- ＠IT

用于限制进程数的指令是”MaxClients”。该指令用于指定同时可以连接的客户端（严格来说是会话）的数量。
…省略…
通过增加同时连接数来调查CPU、内存状态以及ab显示的性能变化。与此同时，我们还将逐渐增加MaxClients的值，以找到饱和点。

这篇文章是在没有引用参考资料的情况下首次提到 MaxClients 的合适值。虽然还没有给出具体的标准，但提及了如何寻找合适值的方法。

2003年5月23日，埃里克·乔莱和斯塔斯·贝克曼。

实用的mod_perl: 10.1.1. 计算真实内存使用情况

具体介っ细分析了计算最大子进程数量的方法。

2003年10月18日，竹迫良範（株式会社ドリーム・アーツ）

「mod_perl 在 C10K 问题中的应用」Shibuya.pm 技术讲座#4 ※ppt 文件

在《实用mod_perl》一书中，所述的内容已经被形象化了。

2003年12月5日，宮内はじめ至上一种选项。

寻找计算机相关备忘录 – 求解 MaxClients 的适当值 / 适用于图像（静态内容）的服务器

Apache的最大内存消耗量=MaxClients×子进程的内存消耗量+父进程的内存消耗量

所以首先需要求得”子进程的内存消耗量”和”父进程的内存消耗量”。

httpd的SIZE即为”父进程的内存消耗量”，SIZE – SHARE（与父进程共享的部分）即为”子进程的内存消耗量”。

用日语展示了计算公式。

2006年2月1日，ばびー (ID: babie)

Apache + mod_perl – 需要注意MaxClients的值 – 小步前进

MaxClients 应设为”总内存大小 / Apache 子进程单个内存大小”（进行舍入运算）。

在幻灯片中提到的 Apache 的 Shared_RAM_per_Child（子进程的共享内存量）是如何获得的呢？

Shared RAM per Child 可以通过 RSS – SHARE 来准确获取。如果想要确切地知道该值，可以使用 GTop。

经过一段时间后，再次出现了对于MaxClients的讨论的契机。naoya在评论中提到了关于GTop这个话题。

2006年2月2日，高野池。

在/proc/$pid/smaps中可以获取到共享的内存区域。
· 在fork之前分配的内存区域将会是共享的，变为shared_dirty。
· 在fork之后对该区域进行写入操作时，会被复制，变为private_dirty。
· 在fork之后分配的区域不会被共享（理所当然），不会成为shared/private（可能）。
当处于shared状态时，实际的内存不会被消耗，当变为private时会重新分配。

提到可以在/proc/$pid/smaps中获取到共享内存。

计算每个子进程消耗的内存量为“Max_Process_Size – Shared_RAM_per_Child”。

2007年7月8日，椎名淳輔（悠月）。

MaxClients的值 = （服务器总RAM量 – 父Apache进程消耗的内存量）/ 子Apache进程一个的消耗内存量

同时还应满足以下计算式。

子Apache进程一个的消耗内存量 x MaxClients的值 + 父Apache进程消耗内存量 < 服务器总RAM量

2007年10月24日，Moodle。

表演 – MoodleDocs ※日期根据原始英文版本

请正确设置MaxClients指令。请使用以下公式计算设置值（为了保留备用内存空间，使用可用内存的80％）：

MaxClients = 可用总内存 * 80% / Apache进程的最大内存使用量

Apache进程的内存使用量通常为10MB。一般经验法则是，为了获取MaxClients的值，将可用内存容量除以10MB。要找到Apache进程的最大内存使用量，请从shell命令的结果中读取值：

# ps -ylC httpd –sort:rss

作为经验准则，对于计算 MaxClients 合适值的分子部分，建议使用“可用内存的80%”。
此外，还提供了用于确定 Apache 进程的最大内存使用量的命令。

2008年2月12日，伊藤直也（id:naoya）。

通过 Copy on Write 技术共享的内存大小可以通过检查 Linux 进程来获取 – naoya的はてな日记

如果以mod_perl为例，需要考虑在MaxClients设置中考虑共享空间的大小。

我尝试查找在进程的内存空间中有多少采用写时复制（CoW）的共享区域，并且我发现可以通过检查/proc/PID/smaps来实现。

在这个smaps中，可以将每个区域的大小计算出来，并将Shared_Clean和Shared_Dirty的大小进行累加，从而可以得出进程与其他进程共享的内存大小。

对于Perl，有一个名为Linux::Smaps的模块，它可以对/proc/PID/smaps的数据进行编程处理。我利用它编写了一个简单的脚本来查找共享区域的大小。

shared_memory_size.pl
#!/usr/bin/env perl
use strict;
use warnings;
use Linux::Smaps;

@ARGV or die “usage: %0 [pid …]”;

printf “PID\tRSS\tSHARED\n”;

for my $pid (@ARGV) {
my $map = Linux::Smaps->new($pid);
unless ($map) {
warn $!;
next;
}

printf
“%d\t%d\t%d (%d%%)\n”,
$pid,
$map->rss,
$map->shared_dirty + $map->shared_clean,
int((($map->shared_dirty + $map->shared_clean) / $map->rss) * 100)
}

它会查找并显示以给定PID作为参数的进程的共享区域大小。

这是第一次提出利用脚本计算 MaxClients 的基础。
虽然使用 Linux::Smaps 会稍微不方便，但它是大多数相关文章所引用的著名文章。

2008年4月9日（ID：隐藏）

如何在mod_perl中增加与父进程进行写时复制的共享内存。- 关于Perl、备忘录和日记等。

如果有大量访问和需要设置较大的MaxClient，则减少Apache每个进程的内存是很重要的。当然，也可以通过在应用程序中避免加载大型库并将图像转换成Gearmand任务等巧妙的方法来实现，但在Apache父进程和子进程之间尽可能增加Copy on Write的共享内存也是有效的。

将模块放入父进程内存的方法是，在startup.pl中尽可能地使用use。在apache的config中添加以下内容：

PerlRequire /path/to/startup.pl

并在其中列出所使用的应用程序模块。

使用use Hoge();并在后面加上()以阻止函数的导出。这样做就可以增加共享内存。此外，fork是对父进程的复制，所以事先使用use编译源代码可以节省子进程编译的成本，如果将MaxRequestPerChild设置为较小值，并且访问量很大且子进程频繁再fork的系统也可以减轻负载。

2008年5月6日 (id:hogem)

我查了一下Apache的MaxClients的适当值 – 在聪明的博客上。

如果MPM是prefork模式的话，

子进程消耗的内存大小乘以MaxClients小于操作系统的内存容量。

不过，这个计算出来的数字是假设子进程使用的内存没有被共享的情况下的，所以MaxClients应该可以是更大的数值。

(RSS – SHR)乘以MaxClients小于等于操作系统的内存容量。

SHR：共享的内存大小
可以通过top命令的SHR项进行确认。
RSS：进程使用的物理内存大小
可以通过ps或者top命令的RSS项进行确认。

2009年09月10日，広瀬正昭（ID：hirose31）。

「Ficia」与基础设施和Perl相关的等等事项

2009年12月9日，北村聪士。

查询Apache的内存使用量- satooshi@blog

注意事项：

在这个脚本中，我们从/proc/PID/status和/proc/PID/smaps获取数据，并对以下内容进行过滤：

/proc/PID/status
VmPeak
VmSize
VmHWM
VmRSS

/proc/PID/smaps
Rss
Shared_Clean
Shared_Dirty

我们想要调查每个进程的内存使用量。

getmem.sh
#!/bin/sh

#1 个进程名
if [ $# -ne 1 ]; then
exit
fi

# 打印标题
printf “PID\tVmPeak\tVmSize\tVmHWM\tVmRSS\n”

# 获取内存大小
pid=`pgrep $1`

for p in $pid
do
if [ -f /proc/$p/status ]; then
vm=`grep -e ‘^VmPeak:\|VmSize:\|VmHWM:\|VmRSS:’ /proc/$p/status | awk ‘{print $2}’`
printf “%d\t%d\t%d\t%d\t%d\n” $p $vm
fi
done

我们想要调查进程之间共享的内存使用量。

getshmem.sh
#!/bin/sh

# $1 个进程名
if [ $# -ne 1 ]; then
exit
fi

# 打印标题
printf “PID\tRSS\tSHARED\n”

# 获取共享内存大小
pid=`pgrep $1`

for p in $pid
do
if [ -f /proc/$p/smaps ]; then
vm=`grep -e ‘^Rss:\|^Shared_Clean:\|^Shared_Dirty:’ /proc/$p/smaps |
awk ‘
BEGIN {
rss = 0;
clean = 0;
dirty = 0;
}
{
if($1 == “Rss:”) {
rss += $2;
}
else if($1 == “Shared_Clean:”) {
clean += $2;
}
else if($1 == “Shared_Dirty:”) {
dirty += $2;
}
}
END {
per = (rss == 0) ? 0 : (clean+dirty)*100/rss;
printf(“%d\t%d\t%d\n”, rss, clean+dirty, per);
}
‘`

printf “%d\t%d\t%d (%d%%)\n” $p $vm
fi
done

2010年9月1日，长野正大。

专业服务器管理员将Apache的StartServers、(Min|Max)SpareServers和MaxClients设置为相同的原因 – blog.nomadscafe.jp

2010年9月23日，霍利。

用Copy on Write来检查共享的内存使用量。像往常一样，可以使用shell进行操作。如果使用perl，没有安装Linux::Smaps等模块。

smaps.sh
#!/bin/sh

echo -e “进程ID\t虚拟内存(VSZ)\t常驻内存(RSS)\t共享内存(Shared)”
for pid in $@; do
smaps=”/proc/$pid/smaps”
vsz=$(grep -E “^Size” $smaps | awk ‘BEGIN{ num = 0 } { num += $2 } END{ print num }’)
rss=$(grep -E “^Rss” $smaps | awk ‘BEGIN{ num = 0 } { num += $2 } END{ print num }’)
shared=$(grep -E “^Shared” $smaps | awk ‘BEGIN{ num = 0 } { num += $2 } END{ print num }’)
percent=$(echo “scale=2; ($shared / $rss) * 100” | bc | cut -d “.” -f 1)
echo -e “$pid\t${vsz}KB\t${rss}KB\t${shared}KB（占比${percent}%）”
done

通过这个shell脚本，可以暂时输出想要检查的进程在Copy on Write下共享的内存使用量。

尝试在子进程中的数组的一部分（约1/10）写入数据。

大约1/10的数据从Shared_Dirty变为了Private_Dirty。这与脚本只向1/10写入数据几乎一致。

2011年1月15日（ID：友嘿）

Apache调优内存使用量计算 – 心中感慨

准备了一个从”/proc/(pid)/status”中获取内存消耗量并列出的脚本。

memory_size.sh
#!/bin/sh

GREP=”/bin/grep”
AWK=”/bin/awk”
PRINTF=”/usr/bin/printf”

if [ $# -lt 1 ]; then
echo “用法：${0} [pid …]” 1>&2
exit 100
fi

$PRINTF “进程ID\tRSS\t(峰值)\t虚拟内存\t(峰值)\n”

for p in $@
do
status=”/proc/${p}/status”
if [ -f $status ]; then
rsssize=`$GREP ‘^VmRSS:’ $status | $AWK ‘{print $2}’`
rsspeak=`$GREP ‘^VmHWM:’ $status | $AWK ‘{print $2}’`
vmsize=`$GREP ‘^VmSize:’ $status | $AWK ‘{print $2}’`
vmpeak=`$GREP ‘^VmPeak:’ $status | $AWK ‘{print $2}’`
$PRINTF \
“%d\t%d\t(%d)\t%d\t(%d)\n” \
$p \
$rsssize \
$rsspeak \
$vmsize \
$vmpeak
fi
done

for p in `pgrep httpd`; do grep “^VmHWM:” /proc/$p/status |awk ‘{print $2}’; done

然后将数据带入Excel进行处理（丢弃旧进程和新进程数据，计算平均值，预测考虑共享的消耗量）……

2011年3月17日（编号：R-H）

我创建了一个脚本来计算Apache的MaxClient- 网络话题

Apache配置文件中的MaxClients参数可以根据服务器规格等进行计算，因此每次手动计算都很繁琐，因此我编写了一个脚本。

计算方法：
(服务器内存总量) / (httpd使用内存总量 – httpd使用共享内存总量) = MaxClients

源代码：
https://github.com/ryoppy/Get-MaxClients.

2011年5月19日Phize

Apache调优: 计算MaxClients可以设置的上限值 – (DxD)∞

我已经创建了一个可以计算MaxClients上限值的shell脚本。

get_max_clients.sh
#!/bin/bash

_PIDS=(`pgrep httpd`)
_PROC_COUNT=${#_PIDS[@]}

_MEMORY_TOTAL=`free | grep Mem | awk ‘{print $2;};’`
#_MEMORY_FREE=`vmstat -a | awk ‘NR==3{print $4+$5;};’`
_RSS_TOTAL=0
_SHARED_TOTAL=0

for _PID in ${_PIDS[@]}; do
_SMAPS=`cat /proc/$_PID/smaps`
_RSS=`echo “$_SMAPS” | grep Rss | awk ‘{value += $2} END {print value;};’`
_SHARED=`echo “$_SMAPS” | grep Shared | awk ‘{value += $2} END {print value;};’`
_RSS_TOTAL=`expr $_RSS_TOTAL + $_RSS`
_SHARED_TOTAL=`expr $_SHARED_TOTAL + $_SHARED`
done

_RSS_AVERAGE=`expr $_RSS_TOTAL / $_PROC_COUNT`
_SHARED_AVERAGE=`expr $_SHARED_TOTAL / $_PROC_COUNT`
_PROC_MEMORY=`expr $_RSS_AVERAGE – $_SHARED_AVERAGE`
#_MIN_MAX_CLIENTS=`expr $_MEMORY_FREE / $_PROC_MEMORY`
_MAX_MAX_CLIENTS=`expr $_MEMORY_TOTAL / $_PROC_MEMORY`

echo “総メモリ量 / (Rss平均 – 共有平均) = $_MEMORY_TOTAL / ($_RSS_AVERAGE – $_SHARED_AVERAGE)”
#echo “空きメモリ量 / (Rss平均 – 共有平均) = $_MEMORY_FREE / ($_RSS_AVERAGE – $_SHARED_AVERAGE)”
#echo “MaxClients = $_MIN_MAX_CLIENTS ~ $_MAX_MAX_CLIENTS”
echo “MaxClients = $_MAX_MAX_CLIENTS”

exit 0

实际上，由于操作系统和其他进程也使用内存，所以最好使用可用内存量而不是总内存量。

(已注释的部分是使用可用内存量计算MaxClients数量。然而，请注意它没有考虑已启动的Apache进程使用的内存量，因此不完整。)

2011年8月5日（ID：yumatsumo）

进程的写时复制共享内存的大小 – 松本的博客

我写了一个直接读取/proc/PID/smaps文件的脚本。

也就是说，你不需要安装Linux::Smaps也可以使用。(List::Util是核心模块，只要是5.8版本以上就有，所以使用了它。)

shared_memory_size.pl
#!/bin/env perl

use strict;
use warnings;

use List::Util ();

@ARGV or die “使用方法：%0 [pid …]”;

my @output;

foreach my $pid (@ARGV) {
die “无效的进程号 ‘$pid'” if $pid =~ /\D/;
my @smaps = `cat /proc/$pid/smaps`;
die if $? != 0;
my @shared = map { /(\d+)\s+kB/; $1 } grep { /^Shared_(Clean|Dirty)/ } @smaps;
my $shared_total = List::Util::sum(@shared);
my @rss = map { /(\d+)\s+kB/; $1 } grep { /^Rss/ } @smaps;
my $rss_total = List::Util::sum(@rss);
my $parcent = sprintf ‘(%d %%)’, int(($shared_total / $rss_total) * 100);
push @output, [$pid, $rss_total, $parcent];
}

unshift @output, [qw(PID RSS SHARED)];

foreach my $out (@output) {
print join “\t”, @$out;
print “\n”;
}

2012年8月12日，觉觉的iPhone。

30岁的WEB工程师的日记：Apache进程的内存使用量

看起来，我们不能简单地通过查看/proc/(PID)/status的VmHWM来了解每个进程的内存使用量。
当从父进程fork子进程时，子进程会共享父进程的内存空间，因此我们需要考虑共享部分。

由于/proc/(PID)/smaps似乎只允许root用户读取权限，因此我们需要以root用户身份运行以下命令：

echo -e “PID\tPPID\tRSS\tSHARED\tPRIVATE”;ps -ef|grep httpd|grep -v grep|while read line;do args=(${line});echo -ne ${args[1]}”\t”${args[2]}”\t”;cat /proc/${args[1]}/smaps|awk ‘BEGIN{rss=0;shared=0;}/Rss/{rss+=$2;}/Shared/{shared+=$2;}END{printf(“%.1f\t%.1f\t%.1f\n”,rss/1024,shared/1024,(rss-shared)/1024);}’;done

解説如何計算Apache每個進程的記憶體使用量的命令：30歲的WEB工程師的日記

为了使程序结构更易于理解，我在上次介绍的命令中添加了换行符。

echo -e “PID\tPPID\tRSS\tSHARED\tPRIVATE”;
ps -ef
|grep httpd
|grep -v grep
|while read line;
do
args=(${line});
echo -ne ${args[1]}”\t”${args[2]}”\t”;
cat /proc/${args[1]}/smaps
|awk ‘
BEGIN{rss=0;shared=0;}
/Rss/{rss+=$2;}
/Shared/{shared+=$2;}
END{printf(“%.1f\t%.1f\t%.1f\n”,rss/1024,shared/1024,(rss-shared)/1024);}
‘;
done

[第一行] 输出标题行（每列以制表符分隔）
[第二行] 使用ps命令获取进程列表
[第三、四行] 提取包含字符串“httpd”的行（排除grep命令的进程）
[第五、六行] 对获取的结果，逐行执行第七行到第十五行的循环处理
[第七行] 将第三、四行获取的结果以空格为分隔符分割为数组存储
[第八行] 输出进程ID、父进程ID（不换行）
[第九、十、十六行] 读取进程ID对应的smaps文件，并传递给awk命令，执行第十一行到第十四行的处理循环
[第十一行] 在awk命令中初始化变量
[第十二行] 如果包含字符串“Rss”的行，则将值加到变量Rss
[第十三行] 如果包含字符串“Shared”的行，则将值加到变量Shared
[第十四行] 在遍历smaps文件的所有行后，输出变量Rss、变量Shared、变量Rss-变量Shared，并换行输出

2013年3月28日，橋本千尋。

测量Apache（httpd）的内存使用量 – 不完整的尸体

#!/bin/bash

PIDS=`ps axfv | grep httpd | grep -v 'grep' | awk '{print $1}'`
SUM=0
COUNT=0

printf "MEM\tS_Clean\tS_Dirty\tOwn_Memory\n"
for pid in $PIDS
do
  MEM=$(cat /proc/$pid/status | grep 'VmHWM' | awk '{print $2}')
  SC=$(grep Shared_Clean /proc/$pid/smaps | awk 'BEGIN{n=0}{n+=$2}END{print n}')
  SD=$(grep Shared_Dirty /proc/$pid/smaps | awk 'BEGIN{n=0}{n+=$2}END{print n}')
  OWN_MEM=`expr $MEM - \( $SC + $SD \)`
  SUM=`expr $SUM + $OWN_MEM`
  printf "$MEM\t$SC\t$SD\t$OWN_MEM\n"
  COUNT=`expr $COUNT + 1`
done
printf "SUMMARY\t$SUM kb\n"
AVG=`expr $SUM / $COUNT`
printf "AVG\t$AVG kb\n"

2013年10月10日 (hirobanex)

与Apache或派生进程的内存调优相关的笔记和脚本 | hirobanex.net

当我检查apache进程时，需要使用sudo执行，因此我不得不每次都安装Linux::Smaps到System Perl。而且，在我的Ubuntu环境中，最新版本的0.12的06-VmFlags.t测试失败了，很烦人。我想到可以不使用Linux::Smaps，所以我把它脚本化了。

另外，每次都要进行非共享部分的内存使用量乘法运算很麻烦，所以我决定将其显示在右侧。

none_shared_memory_fetcher.pl
#!/usr/bin/env perl
use strict;
use warnings;

@ARGV or die “usage: %0 [pid …]”;

printf “PID\tRSS\tSHARED\tNONE_SHARED\n”;

for my $pid (@ARGV) {
open my $fh, “< /proc/$pid/smaps” or (warn $! and next);
my @rows = <$fh>;
my $rss = mem_size_fetcher(‘Rss’,@rows) or next;
my $shared = mem_size_fetcher(‘Shared_Clean’,@rows) + mem_size_fetcher(‘Shared_Dirty’,@rows);

printf
“%d\t%d\t%d (%d%%)\t%d\n”,
$pid,
$rss,
$shared,
int(($shared / $rss) * 100),
($rss – $shared),
}

sub mem_size_fetcher {
my ($target,@rows) = @_;

my $mem_size = 0;

for my $row (@rows) {
my ($mem) = $row =~ /^$target:\s*(\d+)/i;
$mem_size +=($mem||0);
}

return $mem_size;
}

NONE_SHARED表示子进程独立的内存使用量。

另外，请注意，由于每次请求可能会发生内存泄漏等问题，子进程有增大的趋势，所以需要进行一定数量的请求并在接近MaxRequestsPerChild的进程上计算。

2014年12月23日（@gotyoooo）

圣诞前夜服务器故障的故障排除 – Qiita，让我们早点回家

检查_apache_memory.sh
#!/bin/sh
MEMTOTAL=`grep ‘MemTotal’ /proc/meminfo | awk ‘{print $2}’`
UNIT=`grep ‘MemTotal’ /proc/meminfo | awk ‘{print $3}’`

PARENT_PID=`ps auxw | grep httpd | grep root | grep -v grep | awk ‘{print $2}’`
PARENT_MEM=`grep ‘VmHWM’ /proc/${PARENT_PID}/status | awk ‘{print $2}’`

PID=`ps auxw | grep httpd | grep -v root | awk ‘{print $2}’`
COUNT=0
CHILED_MEM_TOTAL=0
CHILED_MEM_TOTAL_NO_SHARE=0

echo -e “[apache进程内存使用量]”
echo -e “(父进程)”
echo -e “进程ID\t内存”
echo -e “${PARENT_PID}\t${PARENT_MEM}${UNIT}”
echo -e “(子进程)”
echo -e “进程ID\t内存\t共享\t独立”
for pid in $PID
do
PMEM=`grep ‘VmHWM’ /proc/${pid}/status | awk ‘{print $2}’`
SHARE_MEM=`awk ‘BEGIN{shared=0;}/Shared/{shared+=$2;}END{printf(“%d”,shared);}’ /proc/${pid}/smaps`
PRIVATE_MEM=`expr $PMEM – $SHARE_MEM`
CHILED_MEM_TOTAL=`expr $CHILED_MEM_TOTAL + $PMEM`
CHILED_MEM_TOTAL_NO_SHARE=`expr $CHILED_MEM_TOTAL_NO_SHARE + $PRIVATE_MEM`
COUNT=`expr $COUNT + 1`
echo -e “${pid}\t${PMEM}${UNIT}\t${SHARE_MEM}${UNIT}\t${PRIVATE_MEM}${UNIT}”
done

CHILED_MEM_AVE=`expr $CHILED_MEM_TOTAL / $COUNT`
CHILED_MEM_AVE_NO_SHARE=`expr $CHILED_MEM_TOTAL_NO_SHARE / $COUNT`

echo -e “子进程数 \t\t\t: ${COUNT}”
echo -e “子进程内存使用量合计 \t: ${CHILED_MEM_TOTAL} ${UNIT}”
echo -e “子进程内存使用量平均 \t: ${CHILED_MEM_AVE} ${UNIT}”
echo -e “子进程内存使用量合计(不包含共享) \t: ${CHILED_MEM_TOTAL_NO_SHARE} ${UNIT}”
echo -e “子进程内存使用量平均(不包含共享) \t: ${CHILED_MEM_AVE_NO_SHARE} ${UNIT}”

echo “==============================================================”
USE_MEM=`expr $PARENT_MEM + $CHILED_MEM_TOTAL_NO_SHARE`
echo -e “apache内存使用量 \t: ${USE_MEM} ${UNIT}”
echo -e “总内存量 \t\t: ${MEMTOTAL} ${UNIT}”

2016年1月7日，亚马逊 AWS。

在亚马逊 EC2 上对 Apache 进行内存调优。

5.计算以下设置变量 ServerLimit 和 MaxClients（或 Apache 2.4 的情况下为 MaxRequestWorkers）的值。
a. 如果实例的 RAM 超过 4 GB，则通过 Apache 进程的平均 %MEM 值除以 90%。例如，如果平均 %MEM 值为 0.8%，则将 90%（0.9）除以 0.8%（0.008）。
结果为 112.5，在小数点第一位四舍五入为整数。在这种情况下，结果为 112。
b. 如果实例的 RAM 小于等于 4 GB，则通过 Apache 进程的平均 %MEM 值除以 80%。例如，如果平均 %MEM 值为 0.8%，则将 80%（0.8）除以 0.8%（0.008）。
结果为 100。
注意
这些值是基于实例是专用的 web 服务器进行计算的。如果服务器托管其他应用程序，请在执行此计算之前从 90% 或 80% 中减去这些应用程序的总内存使用比例。在 RAM 小于等于 4 GB 的实例上，如果除了 Apache 还运行其他应用程序，则可能会导致性能下降。