Linux on ttz.pw

Acme.sh申请免费ssl证书

Thu, 04 Jul 2024 09:03:10 +0800

acme.sh 实现了 acme 协议, 可以从 letsencrypt 生成免费的证书.

主要步骤:

安装 acme.sh
生成证书
copy 证书到 nginx/apache 或者其他服务
更新证书
更新 acme.sh
出错怎么办, 如何调试

下面详细介绍.

1. 安装 acme.sh

安装很简单, 一个命令:

curl https://get.acme.sh | sh -s email=my@example.com

普通用户和 root 用户都可以安装使用. 安装过程进行了以下几步:

把 acme.sh 安装到你的 home 目录下:

~/.acme.sh/

并创建一个 shell 的 alias, 例如 .bashrc，方便你的使用: alias acme.sh=~/.acme.sh/acme.sh

自动为你创建 cronjob, 每天 0:00 点自动检测所有的证书, 如果快过期了, 需要更新, 则会自动更新证书.

更高级的安装选项请参考: https://github.com/Neilpang/acme.sh/wiki/How-to-install

安装过程不会污染已有的系统任何功能和文件, 所有的修改都限制在安装目录中: ~/.acme.sh/

2. 生成证书

acme.sh 实现了 acme 协议支持的所有验证协议. 一般有两种方式验证: http 和 dns 验证.

2.0.1. http 方式

需要在你的网站根目录下放置一个文件, 来验证你的域名所有权,完成验证. 然后就可以生成证书了.

acme.sh --issue -d mydomain.com -d www.mydomain.com --webroot /home/wwwroot/mydomain.com/

只需要指定域名, 并指定域名所在的网站根目录. acme.sh 会全自动的生成验证文件, 并放到网站的根目录, 然后自动完成验证. 最后会聪明的删除验证文件. 整个过程没有任何副作用.

如果你用的 apache服务器, acme.sh 还可以智能的从 apache的配置中自动完成验证, 你不需要指定网站根目录:

acme.sh --issue -d mydomain.com --apache

如果你用的 nginx服务器, 或者反代, acme.sh 还可以智能的从 nginx的配置中自动完成验证, 你不需要指定网站根目录:

acme.sh --issue -d mydomain.com --nginx

注意, 无论是 apache 还是 nginx 模式, acme.sh在完成验证之后, 会恢复到之前的状态, 都不会私自更改你本身的配置. 好处是你不用担心配置被搞坏, 也有一个缺点, 你需要自己配置 ssl 的配置, 否则只能成功生成证书, 你的网站还是无法访问https. 但是为了安全, 你还是自己手动改配置吧.

如果你还没有运行任何 web 服务, 80 端口是空闲的, 那么 acme.sh 还能假装自己是一个webserver, 临时听在80 端口, 完成验证:

acme.sh --issue -d mydomain.com --standalone

acme.sh脚本默认ca服务器是zerossl，经常出错，会导致获取证书的时候一直出现：Pending, The CA is processing your order, please just wait.

只需要把ca服务器改成letsencrypt 即可，虽然更改以后还是有概率出现pending，但基本2-3次即可成功

acme.sh --set-default-ca --server letsencrypt

更高级的用法请参考: https://github.com/Neilpang/acme.sh/wiki/How-to-issue-a-cert

2.0.2. 手动 dns 方式

手动在域名上添加一条 txt 解析记录, 验证域名所有权.

这种方式的好处是, 你不需要任何服务器, 不需要任何公网 ip, 只需要 dns 的解析记录即可完成验证. 坏处是，如果不同时配置 Automatic DNS API，使用这种方式 acme.sh 将无法自动更新证书，每次都需要手动再次重新解析验证域名所有权。

acme.sh --issue --dns -d mydomain.com \
 --yes-I-know-dns-manual-mode-enough-go-ahead-please

然后, acme.sh 会生成相应的解析记录显示出来, 你只需要在你的域名管理面板中添加这条 txt 记录即可.

等待解析完成之后, 重新生成证书:

acme.sh --renew -d mydomain.com \
  --yes-I-know-dns-manual-mode-enough-go-ahead-please

注意第二次这里用的是 --renew

dns 方式的真正强大之处在于可以使用域名解析商提供的 api 自动添加 txt 记录完成验证.

acme.sh 目前支持 cloudflare, dnspod, cloudxns, godaddy 以及 ovh 等数十种解析商的自动集成.

以 dnspod 为例, 你需要先登录到 dnspod 账号, 生成你的 api id 和 api key, 都是免费的. 然后:

export DP_Id="1234"

export DP_Key="sADDsdasdgdsf"

acme.sh --issue --dns dns_dp -d aa.com -d www.aa.com

证书就会自动生成了. 这里给出的 api id 和 api key 会被自动记录下来, 将来你在使用 dnspod api 的时候, 就不需要再次指定了. 直接生成就好了:

acme.sh --issue -d mydomain2.com --dns  dns_dp

更详细的 api 用法: https://github.com/Neilpang/acme.sh/blob/master/dnsapi/README.md

3. copy/安装证书

前面证书生成以后, 接下来需要把证书 copy 到真正需要用它的地方.

注意, 默认生成的证书都放在安装目录下: ~/.acme.sh/, 请不要直接使用此目录下的文件, 例如: 不要直接让 nginx/apache 的配置文件使用这下面的文件. 这里面的文件都是内部使用, 而且目录结构可能会变化.

正确的使用方法是使用 --install-cert 命令,并指定目标位置, 然后证书文件会被copy到相应的位置, 例如:

3.1. Apache example:

acme.sh --install-cert -d example.com \
--cert-file      /path/to/certfile/in/apache/cert.pem  \
--key-file       /path/to/keyfile/in/apache/key.pem  \
--fullchain-file /path/to/fullchain/certfile/apache/fullchain.pem \
--reloadcmd     "service apache2 force-reload"

3.2. Nginx example:

acme.sh --install-cert -d example.com \
--key-file       /path/to/keyfile/in/nginx/key.pem  \
--fullchain-file /path/to/fullchain/nginx/cert.pem \
--reloadcmd     "service nginx force-reload"

(一个小提醒, 这里用的是 service nginx force-reload, 不是 service nginx reload, 据测试, reload 并不会重新加载证书, 所以用的 force-reload)

Nginx 的配置 ssl_certificate 使用 /etc/nginx/ssl/fullchain.cer ，而非 /etc/nginx/ssl/<domain>.cer ，否则 SSL Labs 的测试会报 Chain issues Incomplete 错误。

--install-cert命令可以携带很多参数, 来指定目标文件. 并且可以指定 reloadcmd, 当证书更新以后, reloadcmd会被自动调用,让服务器生效.

详细参数请参考: https://github.com/Neilpang/acme.sh#3-install-the-issued-cert-to-apachenginx-etc

值得注意的是, 这里指定的所有参数都会被自动记录下来, 并在将来证书自动更新以后, 被再次自动调用.

4. 查看已安装证书信息

acme.sh --info -d example.com
# 会输出如下内容：
DOMAIN_CONF=/root/.acme.sh/example.com/example.com.conf
Le_Domain=example.com
Le_Alt=no
Le_Webroot=dns_ali
Le_PreHook=
Le_PostHook=
Le_RenewHook=
Le_API=https://acme-v02.api.letsencrypt.org/directory
Le_Keylength=
Le_OrderFinalize=https://acme-v02.api.letsencrypt.org/acme/finalize/23xxxx150/781xxxx4310
Le_LinkOrder=https://acme-v02.api.letsencrypt.org/acme/order/233xxx150/781xxxx4310
Le_LinkCert=https://acme-v02.api.letsencrypt.org/acme/cert/04cbd28xxxxxx349ecaea8d07
Le_CertCreateTime=1649358725
Le_CertCreateTimeStr=Thu Apr  7 19:12:05 UTC 2022
Le_NextRenewTimeStr=Mon Jun  6 19:12:05 UTC 2022
Le_NextRenewTime=1654456325
Le_RealCertPath=
Le_RealCACertPath=
Le_RealKeyPath=/etc/acme/example.com/privkey.pem
Le_ReloadCmd=service nginx force-reload
Le_RealFullChainPath=/etc/acme/example.com/chain.pem

5. 更新证书

目前证书在 60 天以后会自动更新, 你无需任何操作. 今后有可能会缩短这个时间, 不过都是自动的, 你不用关心.

请确保 cronjob 正确安装, 看起来是类似这样的:

crontab  -l

56 * * * * "/root/.acme.sh"/acme.sh --cron --home "/root/.acme.sh" > /dev/null

6. 关于修改ReloadCmd

目前修改ReloadCmd没有专门的命令，可以通过重新安装证书来实现修改reloadCmd的目的。此外，安装证书后，相关信息是保存在~/.acme.sh/example.com/example.conf文件下的，内容就是acme.sh --info -d example.com输出的信息，不过ReloadCmd在文件中使用了Base64编码。理论上可以通过直接修改该文件来修改ReloadCmd，且修改时，无需Base64编码，直接写命令原文acme.sh也可以识别。不过，example.conf文件的位置和内容格式以后可能会改变！example.conf一直都是内部使用, 后面有可能会改为用 sqlite 或者mysql 格式存储. 所以一般不建议自己修改。

7. 更新 acme.sh

目前由于 acme 协议和 letsencrypt CA 都在频繁的更新, 因此 acme.sh 也经常更新以保持同步.

升级 acme.sh 到最新版 :

acme.sh --upgrade

如果你不想手动升级, 可以开启自动升级:

acme.sh --upgrade --auto-upgrade

之后, acme.sh 就会自动保持更新了.

你也可以随时关闭自动更新:

acme.sh --upgrade --auto-upgrade  0

8. 出错怎么办：

请使用 --debug 参数输出详细的调试信息。

例如：

1acme.sh --issue  ......... --debug

要输出更详细的信息：

1acme.sh --issue  .......... --debug 2

常见问题的根本原因：

端口 80 被阻塞如果你的ISP（互联网服务提供商）阻止了端口 80，任何基于 webroot 的认证都将失败。你可以通过从你本地网络外部运行以下命令来测试这一点：
```
1curl -IkL -m20 http://[binanceearn.org]
```

使用 DNS API 的常见错误：

错误1：笨拙的操作 - ~/.acme.sh/account.conf 文件中有换行符如果在输入 API 密钥或私钥时意外地输入了换行符或拼写错误，请检查并确保 ~/.acme.sh/account.conf 文件中的密钥看起来正确。

我仍然看到旧的密钥（从 letsencrypt bot 切换到 .acme.sh 时）必要步骤 - 将 nginx 配置指向基于 acme 的新密钥如果在最终使 DNS 基础认证工作后仍然看到使用旧密钥的情况，您可能需要注释掉 letsencrypt bot 中的旧密钥，并指向新的文件夹：

1# RSA 证书
2
3#ssl_certificate /etc/letsencrypt/live/[binanceearn.org]/fullchain.pem; # 由 Certbot 管理
4
5#ssl_certificate_key /etc/letsencrypt/live/[binanceearn.org]/privkey.pem; # 由 Certbot 管理
6
7ssl_certificate [您的主目录]/.acme.sh/[binanceearn.org]/fullchain.cer;
8
9ssl_certificate_key [您的主目录]/.acme.sh/<binanceearn.org>/[您的域名].key;

我是否需要为 DNS 包含 webroot -w [您的 webroot] ？不需要！如果你的问题是端口 80 访问你的 webroot 文件夹失败，那么你最终会回到这个问题。

以上是关于使用 --debug 参数输出详细调试信息的翻译和解释。

在DNS验证模式下如果debug中出现诸如"timed out"等字样可能是因为GFW拦截了相应请求，需要添加http(s) proxy环境变量。（请按照自己实际设定修改）

export http_proxy="socks5h://localhost:1081" && export https_proxy="socks5h://localhost:1081"

如果是使用docker则完整示例配置如下：

docker run --rm  -it  \
  -v "/etc/acme":/acme.sh  \
  -e "CF_Token=[填入自己的信息]" \
  -e "CF_Account_ID=[填入自己的信息]" \
  -e "CF_Zone_ID=[填入自己的信息]" \
  -e http_proxy="socks5h://[代理A]:1234" \
  -e https_proxy="socks5h://[代理A]:1234" \
  --network container:[代理A]\
  neilpang/acme.sh \
  --issue -d example.com --dns dns_cf --debug

上述例子中使用cloudflare的DNS来签发证书，并通过把acme.sh链接到容器[代理A]，来转发curl请求（请按照自己实际设定修改）

最后, 本文并非完全的使用说明, 还有很多高级的功能, 更高级的用法请参看其他 wiki 页面.

https://github.com/Neilpang/acme.sh/wiki

吞吐量(TPS)、QPS、并发数、响应时间(RT)的概念与QPS计算公式

Tue, 02 Jul 2024 08:37:09 +0800

1. 响应时间(RT)

　　响应时间是指系统对请求作出响应的时间。直观上看，这个指标与人对软件性能的主观感受是非常一致的，因为它完整地记录了整个计算机系统处理请求的时间。由于一个系统通常会提供许多功能，而不同功能的处理逻辑也千差万别，因而不同功能的响应时间也不尽相同，甚至同一功能在不同输入数据的情况下响应时间也不相同。所以，在讨论一个系统的响应时间时，人们通常是指该系统所有功能的平均时间或者所有功能的最大响应时间。当然，往往也需要对每个或每组功能讨论其平均响应时间和最大响应时间。

　　对于单机的没有并发操作的应用系统而言，人们普遍认为响应时间是一个合理且准确的性能指标。需要指出的是，响应时间的绝对值并不能直接反映软件的性能的高低，软件性能的高低实际上取决于用户对该响应时间的接受程度。对于一个游戏软件来说，响应时间小于100毫秒应该是不错的，响应时间在1秒左右可能属于勉强可以接受，如果响应时间达到3秒就完全难以接受了。而对于编译系统来说，完整编译一个较大规模软件的源代码可能需要几十分钟甚至更长时间，但这些响应时间对于用户来说都是可以接受的。

2. 吞吐量(Throughput)

　　吞吐量是指系统在单位时间内处理请求的数量。对于无并发的应用系统而言，吞吐量与响应时间成严格的反比关系，实际上此时吞吐量就是响应时间的倒数。前面已经说过，对于单用户的系统，响应时间（或者系统响应时间和应用延迟时间）可以很好地度量系统的性能，但对于并发系统，通常需要用吞吐量作为性能指标。

　　对于一个多用户的系统，如果只有一个用户使用时系统的平均响应时间是t，当有你n个用户使用时，每个用户看到的响应时间通常并不是n×t，而往往比n×t小很多（当然，在某些特殊情况下也可能比n×t大，甚至大很多）。这是因为处理每个请求需要用到很多资源，由于每个请求的处理过程中有许多不走难以并发执行，这导致在具体的一个时间点，所占资源往往并不多。也就是说在处理单个请求时，在每个时间点都可能有许多资源被闲置，当处理多个请求时，如果资源配置合理，每个用户看到的平均响应时间并不随用户数的增加而线性增加。实际上，不同系统的平均响应时间随用户数增加而增长的速度也不大相同，这也是采用吞吐量来度量并发系统的性能的主要原因。一般而言，吞吐量是一个比较通用的指标，两个具有不同用户数和用户使用模式的系统，如果其最大吞吐量基本一致，则可以判断两个系统的处理能力基本一致。

3. 并发用户数

　　并发用户数是指系统可以同时承载的正常使用系统功能的用户的数量。与吞吐量相比，并发用户数是一个更直观但也更笼统的性能指标。实际上，并发用户数是一个非常不准确的指标，因为用户不同的使用模式会导致不同用户在单位时间发出不同数量的请求。一网站系统为例，假设用户只有注册后才能使用，但注册用户并不是每时每刻都在使用该网站，因此具体一个时刻只有部分注册用户同时在线，在线用户就在浏览网站时会花很多时间阅读网站上的信息，因而具体一个时刻只有部分在线用户同时向系统发出请求。这样，对于网站系统我们会有三个关于用户数的统计数字：注册用户数、在线用户数和同时发请求用户数。由于注册用户可能长时间不登陆网站，使用注册用户数作为性能指标会造成很大的误差。而在线用户数和同事发请求用户数都可以作为性能指标。相比而言，以在线用户作为性能指标更直观些，而以同时发请求用户数作为性能指标更准确些。

4. QPS每秒查询率(Query Per Second)

　　每秒查询率QPS是对一个特定的查询服务器在规定时间内所处理流量多少的衡量标准，在因特网上，作为域名系统服务器的机器的性能经常用每秒查询率来衡量。对应fetches/sec，即每秒的响应请求数，也即是最大吞吐能力。（看来是类似于TPS，只是应用于特定场景的吞吐量）. Qps 基本类似于 Tps，但是不同的是，对于一个页面的一次访问，形成一个 Tps；但一次页面请求，可能产生多次对服务器的请求，服务器对这些请求，就可计入“Qps”之中。

例如，访问一个 Index 页面会请求服务器 3 次，包括一次 html，一次 css，一次 js，那么访问这一个页面就会产生一个“T”，产生三个“Q”。

5. PV（page view）

　　即页面浏览量，通常是衡量一个网络新闻频道或网站甚至一条网络新闻的主要指标。用户每一次对网站中的每个页面访问均被记录 1 次。用户对同一页面的多次刷新，访问量累计。根据这个特性，刷网站的 PV 就很好刷了。与 PV 相关的还有 RV，即重复访问者数量（repeat visitors）。

6. UV 访问数（Unique Visitor）

　　指独立访客访问数，统计 1 天内访问某站点的用户数(以 cookie 为依据)，一台电脑终端为一个访客。可以理解成访问某网站的电脑的数量。网站判断来访电脑的身份是通过来访电脑的 cookies 实现的。如果更换了 IP 后但不清除 cookies，再访问相同网站，该网站的统计中 UV 数是不变的。如果用户不保存 cookies 访问、清除了 cookies 或者更换设备访问，计数会加 1。00:00-24:00 内相同的客户端多次访问只计为 1 个访客。根据这个特性，如果有人让你刷 UV，也很好的刷！

7. IP（Internet Protocol）独立 IP 数

　　是指 1 天内多少个独立的 IP 浏览了页面，即统计不同的 IP 浏览用户数量。同一 IP 不管访问了几个页面，独立 IP 数均为 1；不同的 IP 浏览页面，计数会加 1。IP 是基于用户广域网 IP 地址来区分不同的访问者的，所以，多个用户（多个局域网 IP）在同一个路由器（同一个广域网 IP）内上网，可能被记录为一个独立 IP 访问者。如果用户不断更换 IP，则有可能被多次统计。

8. GVM

　　所谓的 GMV，是 Gross Merchandise Volume 的简称。只要是订单，不管消费者是否付款、卖家是否发货、是否退货，都可放进 GMV 这个“大箩筐”里。电商是很在意 GMV 的，拼多多的优惠券事故，估计就能产生不少 GMV。根据 GMV 的统计方法，如果有人让你帮忙刷 GMV，你就可以一直下单，然后一直退款。

9. QPS 计算规则:

原理：每天80%的访问集中在20%的时间里，这20%时间叫做峰值时间。
公式：( 总PV数 * 80% ) / ( 每天秒数 * 20% ) = 峰值时间每秒请求数(QPS) 。
机器：峰值时间每秒QPS / 单台机器的QPS = 需要的机器。

假设每天500w PV 的在单台机器上，这台机器需要多少QPS？

( 5000000 * 0.8 ) / (86400 * 0.2 ) = 232 (QPS)。

一般需要达到232QPS，因为是峰值。

如果一台机器的QPS是60，需要几台机器来支持？ 232 / 80 = 2.9 = 3

9.1. 聚合报告各项性能指标1. 响应时间(RT)

9.2. 接口性能测试指标一般通过标准：

计算机性能衡量指标TPC、TPCC、TPMC

Mon, 01 Jul 2024 16:28:58 +0800

1. 什么是TPC和tpmC?

1.1. TPC

TPC(Transaction Processing Performance Council，事务处理性能委员会)是由数10家会员公司创建的非盈利组织，总部设在美国。该组织对全世界开放，但迄今为止，绝大多数会员都是美、日、西欧的大公司。TPC的成员主要是计算机软硬件厂家，而非计算机用户，它的功能是制定商务应用基准程序(Benchmark)的标准规范、性能和价格度量，并管理测试结果的发布。

TPC的出版物是开放的，可以通过网络获取(http://www.tpc.org)。TPC不给出基准程序的代码，而只给出基准程序的标准规范(Standard Specification)。任何厂家或其它测试者都可以根据规范，最优地构造出自己的系统(测试平台和测试程序)。为保证测试结果的客观性，被测试者(通常是厂家)必须提交给TPC一套完整的报告(Full Disclosure Report)，包括被测系统的详细配置、分类价格和包含五年维护费用在内的总价格。该报告必须由TPC授权的审核员核实(TPC本身并不做审计)。现在全球只有几个审核员，全部在美国。

TPC已经推出了四套基准程序，被称为TPC－A、TPC－B、TPC－C和TPC－D。其中A和B已经过时，不再使用了。TPC－C是在线事务处理(OLTP)的基准程序，TPC－D是决策支持(Decision Support) 的基准程序。TPC即将推TPC－E，作为大型企业(Enterprise)信息服务的基准程序。

1.2. tpmC

tpmC值在国内外被广泛用于衡量计算机系统的事务处理能力。但究竟什么是tpmC值呢?作者曾向一些用户、推销人员乃至某些国外大公司的技术人员问过这个问题，但回答的精确度与tpmC值的流行程度远非相称。tpmC这一度量也常被误写为TPM或TPMC。

TPC-C模拟一个批发商的货物管理环境。该批发公司有N个仓库，每个仓库供应10个地区，其中每个地区为3000名顾客服务。在每个仓库中有10个终端，每一个终端用于一个地区。在运行时，10×N个终端操作员向公司的数据库发出5类请求。由于一个仓库中不可能存储公司所有的货物，有一些请求必须发往其它仓库，因此，数据库在逻辑上是分布的。N是一个可变参数，测试者可以随意改变N，以获得最佳测试效果。

TPC-C使用三种性能和价格度量，其中性能由TPC-C吞吐率衡量，单位是tpmC。tpm是transactions per minute的简称；C指TPC中的C基准程序。它的定义是每分钟内系统处理的新订单个数。要注意的是，在处理新订单的同时，系统还要按表1的要求处理其它4类事务请求。从表1可以看出，新订单请求不可能超出全部事务请求的45％，因此，当一个系统的性能为1000tpmC时，它每分钟实际处理的请求数是2000多个。价格是指系统的总价格，单位是美元，而价格性能比则定义为总价格÷性能，单位是＄/tpmC。

tpmC定义: TPC-C的吞吐量，按有效TPC-C配置期间每分钟处理的平均交易次数测量，至少要运行12分钟。

（吞吐量测试结果以比特/秒或字节/秒表示。）

2. TPCC

2.1. 基准测试

TPCC值被广泛用于衡量C/S环境下,由服务器和客户端构筑的整体系统的性能,它由事物处理性能委员会（TPC，Transaction Processing Corp）制定,TPC为非赢利性国际组织。

TPCC值可以反映出系统的性能价格比。TPCC测试系统每分钟处理的任务数,单位为tpm,(transactions per minute)。系统的总体价格(单位为美元)除以TPCC值,就可以衡量出系统的性价比,系统的性价比值越大,系统的性价比越好。

需要注意的是,TPC-C值描述的是C/S整体系统的性能,它与系统的服务器和客户机的性能都有关系,也就是说,同样的服务器配置不同的客户端将会影响TPCC值,任何厂商和测试者都可以根据TPC提供的测试规范构造出自己最优的系统,当然测试的结果要经过TPC审核。

2.2. 性能测试指标介绍

TPC-C

作为一家非盈利性机构，事务处理性能委员会（TPC）负责定义诸如TPC-C、TPC-H和TPC-W基准测试之类的事务处理与数据库性能基准测试，并依据这些基准测试项目发布客观性能数据。TPC基准测试采用极为严格的运行环境，并且必须在独立审计机构监督下进行。委员会成员包括大多数主要数据库产品厂商以及服务器硬件系统供应商。

相关企业参与TPC基准测试以期在规定运行环境中获得客观性能验证，并通过应用测试过程中所使用的技术开发出更加强健且更具伸缩性的软件产品及硬件设备。

TPC-C是一种旨在衡量联机事务处理（OLTP）系统性能与可伸缩性的行业标准基准测试项目。这种基准测试项目将对包括查询、更新及队列式小批量事务在内的广泛数据库功能进行测试。许多IT专业人员将TPC-C视为衡量“真实”OLTP系统性能的有效指示器。

TPC-C基准测试针对一种模拟订单录入与销售环境测量每分钟商业事务（tpmC）吞吐量。特别值得一提的是，它将专门测量系统在同时执行其它四种事务类型（如支付、订单状态更新、交付及证券级变更）时每分钟所生成的新增订单事务数量。独立审计机构将负责对基准测试结果进行公证，同时，TPC将出据一份全面彻底的测试报告。这份测试报告可以从TPC Web站点(http://www.tpc.org)上获得。

2.3. TPC-C规范概要

TPC-C是专门针对联机交易处理系统（OLTP系统）的，一般情况下我们也把这类系统称为业务处理系统。

TPC-C测试规范中模拟了一个比较复杂并具有代表意义的OLTP应用环境:假设有一个大型商品批发商，它拥有若干个分布在不同区域的商品库；每个仓库负责为10个销售点供货；每个销售点为3000个客户提供服务；每个客户平均一个订单有10项产品;所有订单中约1%的产品在其直接所属的仓库中没有存货，需要由其他区域的仓库来供货。

该系统需要处理的交易为以下几种：

New-Order：客户输入一笔新的订货交易；
Payment:更新客户账户余额以反映其支付状况;
Delivery:发货(模拟批处理交易);
Order-Status:查询客户最近交易的状态；
Stock-Level:查询仓库库存状况，以便能够及时补货。

对于前四种类型的交易，要求响应时间在5秒以内；对于库存状况查询交易，要求响应时间在20秒以内。

2.4. 评测指标

TPC-C测试规范经过两年的研制，于1992年7月发布。几乎所有在OLTP市场提供软硬件平台的厂商都发布了相应的TPC-C测试结果，随着计算机技术的不断发展，这些测试结果也在不断刷新。

TPC-C的测试结果主要有两个指标：

2.4.1. ①流量指标(Throughput，简称tpmC)

按照TPC的定义，流量指标描述了系统在执行Payment、Order-status、Delivery、Stock-Level这四种交易的同时，每分钟可以处理多少个New-Order交易。所有交易的响应时间必须满足TPC-C测试规范的要求。

流量指标值越大越好！

2.4.2. ②性价比(Price/Performance，简称Price/tpmC)

即测试系统价格（指在美国的报价）与流量指标的比值。

性价比越大越好！

3. （TPCC）如何衡量计算机系统的性能和价格

在系统选型时，我们一定不要忘记我们是为特定用户环境中的特定应用选择系统。切忌为了“与国际接轨”而盲目套用“国际通用”的东西。在性能评价领域，越是通用的度量常常越是不准确的。据我所知，美国的一些大用户从不相信任何“国际通用”的度量，而是花相当精力，比如预算的5％，使用自己的应用来测试系统，决定选型。在使用任何一种性能和价格度量时，一定要弄明白该度量的定义，以及它是在什么系统配置和运行环境下得到的，如何解释它的意义等。下面我们由好到差讨论三种方式。

3.1. 在真实环境中运行实际应用

最理想的方式是搞一个试点，要求制造商或系统集成商配合将系统(含平台、软件和操作流程)在一个实际用户点真正试运行一段时间。这样，用户不仅能看到实际性能，也能观察到系统是否稳定可靠、使用是否方便、服务是否周到、配置是否足够、全部价格是否合理。如果一个部门需要购买一批同类的系统，这种方式应列为首选，因为它不仅最精确、稳妥，也常常最有效率，用户还可先租一套系统作为试点。用这种方式得到的度量值常常具有很明确和实际的含义。

3.2. 使用用户定义的基准程序

如果由于某种原因第一种方式不可行，用户可以定义一组含有自己实际应用环境特征的应用基准程序。我举两个例子：近年来，由于R/3软件是应用层软件，SAP公司的基准程序获得了越来越多国外企业的认可；中国税务总局最近也开发了自己的基准程序，以帮助税务系统进行计算机选型。这种方式在中国尤其重要，因为中国的信息系统有其特殊性。

3.3. 使用通用基准程序

如果第1种和第2种方式都不行，则使用如TPC-C之类的通用基准程序，这是不得已的一种近似方法。因此，tpmC值只能用作参考。我们应当注意以下几点：

3.3.1. ①实际应用是否与基准程序相符

绝大多数基准程序都是在美国制订的，而中国的企事业单位与美国的运作方式常常不一样(恐怕也不应该或不可能一样)。在使用TPC－C时，我们应该清楚地知道：我的应用是否符合批发商模式?事务请求是否与表1近似?对响应时间的要求是否满足表1?如果都不是，则tpmC值的参考价值就不太大了。

3.3.2. ②TPC度量的解释

TPC基准程序是用来测系统而不是测主机的，厂家肯定要充分优化他们的被测系统。此处的“系统”包括主机、外设(如硬盘或RAID)、主机端操作系统、数据库软件、客户端计算机及其操作系统、数据库软件和网络连接等。在很多厂家的TPC测试系统中，主机的价格只是系统总价格的1/4或更小，而硬盘的价格有可能占到总价格的1/3以上，因为TPC－C要求被测系统必须保存180天的事务记录。如果同样的主机被用到用户的环境中，厂家报的tpmC值就意义不大，因为用户的实际系统与厂家原来用于TPC测试的系统大不一样。当同样的主机用在不同的系统中时，tpmC值可能有相当大的变化，现在很多用户还没有意识到这一点。

我举一个例子。假设用户希望购买一批同类系统，每一系统至少需要1GB的内存和50GB的硬盘。厂家A、B、C 各报了三个价格相当的系统，tpmC值分别为3000、2800、2600。用户是否应该选厂家A的产品呢?答案是：不一定。厂家用于测试tpmC值的系统与实际提供给用户的系统配置大不一样。tpmC最低的厂家C提供给用户的系统反而有可能性能最好，不论是以实际系统的tpmC值还是以用户的实际应用性能来衡量。

3.3.3. ③TPC测试的成本

TPC－C和TPC－D都是很复杂的基准程序，做一个严格的测试是很消耗资源的，厂家当然不会说出他们花费了多少钱和时间。但据国外知情人士透露，一个厂家做第一个TPC－C测试需要几十万到上百万美元的资金和半年左右的时间投入。因此，很多TPC的度量值都是估计的。由于计算机系统换代频繁，如果用户一定要用通过审核的度量值，就必须多等待半年时间，因此而不能用最先进的系统。中国的厂家通过审核的时间则更长。

综上所述，我们对中国用户(尤其是大用户)在计算机系统的选型方面有如下建议：

最好建立一个真实的试点，因为实际应用环境是检验计算机系统的最好标准。

中国的行业应该建立符合自己实际应用的基准程序和测试标准。中国税务总局的做法值得提倡。国家有关部门应该建立独立的测试中心，制定跨行业、符合中国企事业运作模式的性能测试标准。

“国际通用”的度量可以作为参考值，而不应作为必要条件。尤其是一定要弄清这些流行度量有什么含义，是在什么样的系统环境中测得的，以及基准程序是否符合企业真实的业务流程和运作模式。

4. TPCC计算原则

4.1. 建议

不管是TPC-C还是SPECjbb2000，计算结果都只能作为一个横向比较的参考。在实际应用中，决定系统性能的因素除了硬件、系统软件外，与应用软件的设计也是有很大关系的，此外，基于系统可扩展性的考虑，更多时候也倾向于一次性的采购。

从长远考虑，以政府信息化主管部门的角度考虑，建立一套评估机制是非常有用的，这其中包括：

1、通过对各单位业务系统运行情况的调查，进行历史数据的收集分析，按分类建立基准指标库。收集的信息包括：服务器的配置、并发用户数（每天业务量）、CPU负荷等；

2、由厂商定期提供基准值，更新基准指标库；

有了基准指标库的信息参照，不仅可以用于评估项目建设方案中服务器选型，也可以对各部门进行系统架构设计的优化提供指导。如以下是一些指导原则：

1、数据库服务器选型：采购两台相同配置的小型机，进行虚拟分区和并行处理，以提高系统资源的利用率；日后扩容时采取垂直扩展的方式进行升级；

2、应用服务器：采用负载均衡的方式提高并发处理能力，一般可配置2台以上，每台的硬件配置完全可以不同，应首先考虑使用旧的数据库服务器（利旧），如需采购新的服务器，应采用水平扩展的方式逐步升级；

3、 WEB服务器，可以考虑采用刀片服务器，提高扩展性和可管理性。

5. 参考：某项目计算实例

5.1. 参考1

为了方便计算数据库服务器的造型，我们约定：" 系统同时在线用户数为1500人（U1）；" 平均每个用户每分钟发出2次业务请求（N1）；" 系统发出的业务请求中，更新、查询、统计各占1/3；" 平均每次更新业务产生3个事务（T1）；" 平均每次查询业务产生8个事务（T2）；" 平均每次统计业务产生13个事务（T3）；" 一天内忙时的处理量为平均值的5倍；“经验系数为1.6；(实际工程经验) " 考虑服务器保留30％的冗余；

服务器需要的处理能力为：

**TPC-C=U1N1（T1+T2+T3）/33经验系数/冗余系数 **

则应用服务器的处理性能估算为：

TPC-C= 15002（3+8+13）/351.6/0.7= 274,285 tpmC

数据库服务器关系到整个系统的稳定运行，考虑到高可靠性和高可用性，并注重设备的可扩展性和性价比，系统将配置两台TPC-C值不小于28万的高性能数据库服务器。

5.2. 参考2

以单台服务器性能进行计算，即确保单台服务器工作的时候可以满足系统正常运行的需要；

假设每天有1万人次来窗口办理业务，每人次办理一项业务。即以每日1万笔前台交易为例进行综合系数的推导：

1. 假设每月前台交易数（未来5年内的设计指标）为220,000 （有些业务在月初、月末的处理量比较高，按月统计可以平衡此项差异）;

2. 每日前台交易数=220000/22=10,000 ，即每日 1万笔；3. 忙时处理能力：每日交易的80%在4个小时内完成，即1000080%/4=2000（笔/小时）4. 峰值处理能力：20002=4000（笔/小时），即峰值处理能力为每小时4000笔，或 67笔/分，假设业务人员同时在线为100人，即每人每分钟处理0.7笔）5. 假设每笔交易对应数据库事务数=20，基准TPC指标值对应的比例=8，cpu保留30%的处理能力冗余，计算值与公布值（最优值）的偏差经验值为4 （这几个参数估算的依据不足，更多的是经验值）

则 tpmC值为：

tpmC= 672084/(1-30%)= 61257[颠峰处理能力时（笔/分）每笔交易对应数据库事务数基准TPC指标值对应的比例计算值与公布值（最优值）的偏差经验值/（1- cpu保留30%的处理能力冗余）

倒算出综合系数 = 61257/10000=6.1即数据库服务器tpmC= 每日前台交易数 * 6.1 （实际计算值应不高于该值）

应用服务器的 tpmC = 数据库服务器 tpmC *50% （一般）

应用服务器的 tpmC = 数据库服务器 tpmC *70% （涉及大量计算的，如社保、税务）

5.3. 参考3

当前电信业已进入群雄并起、竞争极端激烈的战国时代,在话音、数据和各种增值服务等领域国内各电信运营商，在高端和低端的不同层次上，展开了大规模的中原逐鹿。在如此复杂的局面下，在众多繁复的业务种类竞争中，如何保证一个电信企业的良好运作，建立一个顺畅的收入现金流至为重要。这也就是为什么电信企业在计费系统上进行了不遗余力的投资。但是，正是业务种类层出不穷的推出、通信模式和接入技术快速进步，使电信计费系统存在着难以满足需要的局面，往往制约了电信的运营和业务的开展。如何建立一套能够满足当前乃至今后一定时间的业务开展，又能够保证安全稳定易管理的电信综合计费系统，是各电信运营商和电信科研单位极为重视的一个课题。下面结合中国网通的计费系统建设经验，为即将建设的计费系统的服务器选型方面提供一些建议和参考。

电信计费系统通常有如下种类的服务器:

接口服务器
认证服务器
计费服务器
采集服务器
数据库服务器
管理工作站等

其中，核心服务器为计费服务器、认证服务器和数据库服务器。在一些小型的计费系统中，接口服务器可以与采集服务器合一，计费服务器可以与认证服务器，甚至与数据库服务器合一,管理工作站也可以不设置专用工作站，而用 WEB 管理方式。

对于这些服务器，用途不同，在不同规模的计费系统方案中的组合也不同，业务规模也对服务器的处理性能、存储性能、开放等性能需求不同。选择适当的服务器，不仅能够充分满足业务开展所雲，而且能够提供为未来业务发展所需的系统扩展能力，这样既保障了运营，又能够节省投资。下面对计费系统的服务器选型、处理性能换算方法提出一些参考建议。

服务器处理性能计算方法

按照电信计费系统的统计经验值，一般每1万用户配置5个终端，通常同时访问数据库的终端数目概率为 20%，每次访问请求需处理1秒，其中平均要完成5个交易，由此需要的服务器处理性能为:

用户数x5x206x5x60/(10000x1)(TpmC)

5.3.1. 选型参考建议

标准化原则

符合 ISO 和 ANSI 标准，符合 SVRV4 标准，符合中国的有关计算机技术标准，选择当今业界较为流行的主要产品

高性能原则

保证所选购的服务器,不仅能够满足运营系统的运行和业务处理的需要,而且能够满足一定时期的业务量增长的需要。采用上面公式，计算出所需的服务器 TpmC 值，比较 IDC 公布的权威测算的厂商服务器 TpmC 值，选择相应的机型。同时，用服务器的市场价/报价除上计算出来的TpmC 值得出单位 TpmC 值的价格，从而选择高性能价格比的服务器。

可靠性原则

可靠性原则是所有选择设备和系统中要考虑的，尤其是在大型的、有大量处理要求的、需要长期运行的系统。

考虑服务器系统的可靠性，不仅要考虑服务器单个节点的可靠性或稳定性，而且要考虑服务器与相关辅助系统之间连接的整体可靠性，如:网络系统、安全系统、远程打印系统等。在必要时，还应考虑对关键服务器采用集群技术，如:双机热备份或集群并行访问的N+n技术，甚至采用可能的完全容错机。

保证系统(硬件和操作系统)在 99.98%的时间内都能够正常运作(包括维修时间),则故障停机时间六个月不得超过 0.5 个小时。服务器需 7x24 小时连续运行，因而要求其具有很高的安全可靠性。系统整机平均无故障时间(MTBF)不低于 80000 小时。

服务器如出现 CPU 损坏或其它机械故障,都能在 20 分钟内由备用的 CPU 和机器自动代替工作，无须人员操作，保证数据完整。

可扩展性原则

保证所选购的服务器具有优秀的可扩展性原则。因为服务器是所有系统处理的核心，要求具有大数据吞吐速率，包括:I/0 速率和网络通讯速率，而且服务器需要能够处理一定时期的业务发展所带来的数据量，需要服务器能够在相应时间对其自身根据业务发展的需要进行相应的升级，如:CPU 型号升级、内存扩大、硬盘扩大、更换网卡、增加终端数目、挂接磁盘阵列或与其他服务器组成对集中数据的并发访问的集群系统等。这都需要所选购的服务器在整体上具有一个良好的可扩充余地。

一般数据库和计费应用服务器在大型计费系统的设计中就会采用集群方式来增加可靠性,其中挂接的磁盘存储系统，根据数据量和投资考虑，可以采用 DAS、NAS 或 SAN 等实现技术。对于 Redius Server 可以依靠 Redius 协议采用双机互备，但不需要专门购买的集群软件。

安全性原则

服务器处理的大都是相关系统的核心数据,其上存放和运行着关键的交易和重要的数据。这些交易和数据对于拥有者来说是一笔重要的资产，他们的安全性就非常敏感服务器的安全性与系统的整体安全性密不可分，如:网络系统的安全、数据加密、密码体制等。服务器需要在其自身，包括软硬件，都应该从安全的角度上设计考虑，在借助于外界的安全设施保障下，更要保证本身的高安全性。

如图中所示的认证服务器(Redius Server)和 AAA Server，保障用户访问的合法性，防火墙和服务器的口令甚至一次性口令系统等则保障着系统和数据的安全,有的系统还采用了数据加密和线路加密等手段。

可管理性原则

服务器既是核心又是系统整体中的一个节点部分,就像网络系统需要进行管理维护一样，也需要对服务器进行有效的管理。这需要服务器的软硬件对标准的管理系统支持,尤其是其上的操作系统，也包括一些重要的系统部件。如 Management Station，它既可以是基于 B/S 结构的专用管理软件系统，也可以是基于SNMP 或 WEB 的通用管理方式的软件系统。

5.3.2. 如何规划和选择数据库服务器?

举例说明，使用 TPC-C进行数据库服务器评估

下面针对 XYZ 行的网上银行业务的需求，我们进行数据库服务器的选型分析。

由于目前 XYZ 行只有 17 个分行开通了网上银行业务，据我们估计，按照目前的客户数量全部分行都开通网上银行业务后，总的客户数量可以达到10万。考虑INTERNET 在我国的迅猛发展,客户数量的年增长率按照 50%计算,那么,3年后的客户数量将达到 10万x(1+50%)3≈34万。

这些客户当中，至少有一半是个人客户，另一半是企业客户。企业客户的交易频率比较高我们按平均每个企业客户每天做 1.5 笔交易计算:个人客户常用的交易是査询、取款、存款，并且每个月还要交电话费，因此我们假定个人客户平均每个月做4次交易;那么，每天的交易量就是:

34万x50%x1.5+34万x50%x(4+30) ≈28万笔

假设网上银行的交易复杂度达到 15，那么，每天的数据库操作数达到:

28 万x15=420 万次

5.3.2.1. 高法诉讼费缴费:

由于诉讼费的增长量不大，我们按年递增率 5%计算。根据 XYZ 总行的统计，全国共 37 家分行，缴费量比较大的分行可以达到 25000 笔每月，占分行总数的 20%:缴费量中等的省可达到15000 笔每月，占分行总数的 30%;缴费量小的省可达到 7000 笔每月，占分行总数的 50%;按个月 20 个工作日计算。这样，三年后每天的交易数量可以达到:

(25000x20%+15000x30%+7000x50%)x37-20x(1+5%)3≈28740笔

我们假设高法诉讼缴费的交易复杂度达到13，那么每天的数据库操作达到:

28740*13=373620 次

5.3.2.2. 整体性能要求:

总的数据库操作次数是:4200000+373620=4573620

假设每天的交易的 80%集中在4小时内发生，那么高峰交易时间内每分钟的数据库联机交易次数为:4573620x80%÷(4x60)≈15250

要为将来陆续加入的应用预留 40%的处理能力;另外,考虑到 CPU 的繁忙时间低于 70%时,系统的性能较好，我们把这个比例定在 65%。所以系统的 TPC-C 值应达到:15250-(1-40%)-65%≈39000

5.3.2.3. 内存容量需求分析

首先根据数据库容量算出所需的数据库缓存大小,再估计出操作系统、系统软件等所需内存,合计即是所需的内存容量

5.3.2.4. 网银数据量分析:

XYZ 总行网上银行系统的数据库由 CIF 信息，交易日志、交易流水三部分组成。

其中:CIF 信息包括企业客户和个人客户信息，企业客户信息平均大小为 20K 左右，个人客户信息平均大小为 5K 左右;每一笔交易都要记交易日志,日志的平均大小为 4K 左右;每一笔转帐交易都要记交易流水，交易流水的大小为2K左右。

这些客户当中，至少有一半是个人客户，另一半是企业客户。企业客户的交易频率比较高，我们按平均每个企业客户每天做 1.5 笔交易计算:个人客户常用的交易是查询、取款、存款，并且每个月还要交电话费，因此我们假定个人客户平均每个月做4次交易;那么，每天的交易量就是:

所有的交易日志和交易流水都要保留三个月。由于个人客户的转帐交易非常少，可以忽略不计;假定企业客户的转帐交易占总交易量的 70%。我们就可以计算网上银行对存储系统容量的要求:

CIF 信息容量=20Kx(34万x50%)+5Kx(34万x50%)=3.25GB+421MB≈4GB

交易日志容量=[34万x50%x1.5+34万x50%x(4÷30)]x4Kx30x3 =277667x4Kx30x3~95GB

交易流水容量=(34万x50%x1.5)x70%x2Kx30x3 ≈30GB

XYZ 网上银行总体数据容量要求:=4GB+95GB+30GB=129GB

5.3.2.5. 高法诉讼费数据量分析:

高法的交易数据按要求要保留三年，每笔交易记录的大小为512字节，总体容量为:(25000x20%+15000x30%+7000x50%)x37x12x3x0.5K≈8.2GB

因此，数据库的总数据量为:129GB+8.2GB=137.2GB

数据库系统在缓存容量达到数据库总容量的5%时性能较好，因此，数据库缓存大小为:6.86GB。

5.3.2.6. 从而计算出系统内存需求为:

AIX操作系统所占的内存 128MB
数据库管理系统所占的内存 256MB
双机热备等系统软件所占的内存 128MB
应用程序所占的内存 256MB
数据库缓存 6.86GB
合理的内存利用率 75% 总计 10GB

5.3.2.7. 存储容量需求分析

除了上述的 XYZ 网上银行系统和高法诉讼费缴费系统的存储容量要求之外，还有异步查询下载服务的存储要求。

异步查询下载服务每隔1小时生成一个下载数据包，每个数据包的大小为 3MB，需要下载的数据包是上午十点生成的数据包，这个数据包需要保存2年，其它数据包只要保存3个月。因此，存储容量为:

23x3Mx30x3+1x3Mx365*2=6GB+2GB=8GB

为避免存储系统成为系统性能的瓶颈，系统存储系统的使用率应小于40%，建议采用镜像方式存储数据，因此总的存储容量为: (137.2GB+8GB)+40%x2=766GB HP 银行参考 TPC-C 测算参考以下吧!!

日峰值交易量，即每天业务高峰时的交易量，根据经验以在2小时内完成日均交易量的 80%为计算依据。

日峰值交易量=日均交易量x80%/2=104000(笔/小时)

月峰值日集中系数，即在每月的最忙日最忙时，其峰值交易量要高于根据上式计算出的平均日峰值交易量,为了使主机能够从容处理每月中的最高峰值交易量,在平均日峰值交易量的基础上考虑一个月峰值日集中系数，根据业务繁忙程度取值 1.5~3，根据###的具体情况，在这里取值1.5 。则:

104000x1.5÷3600 =43(笔/秒)

根据软件的测试结果，软件软件交易处理能力与计算机厂商公布的TPmC值之间的比例关系为1:4。由此，可得出###需主机系统的 TPmC 值:主机系统的处理能力为:43 x4x60=10320TPmC综合以上数值，####系统所需最大处理能力约为 10320TPmC

nightcat 兄，谢了?我也得到一个数据如下:跟据 xx银行提供的数据，目前的业务量为:日均5万笔日均交易量为5万笔。设 M 为每日实际交易量，则M=50,000

设T为每日实际交易时间或实际统计值，我们假设高峰期每日交易量在每天的2小时即 120 分钟内完成:T=120 标准交易指标值TPC-C对应于实际交易值比例为:MO=15:1应保证 50%(M1)的主机 CPU 处理余量，用于系统、数据库、工具软件、监控软件或其它应用系统的使用因此，对应计算得标准 TPC-C 估计值为:

TPC=M x MO/(T xM1)=50000x15/(120x50%)=12500

还应考虑系统业务未来三年的发展，每年增长率按 30%计算，得出的 TPC 值为:

TPC=12500x 1.3 x1.3x1.3=27462.5

5.4. 参考4

服务器系统作为劳动和社会保障各级数据中心的核心设备，提供计算处理服务、网络应用服务、劳动保障业务应用服务和其他服务。根据部省市局域网的逻辑构成，劳动保障信息系统的服务器设备包括数据库服务器、应用服务器、WEB 服务器、DNS 服务器等。服务器的配置应根据各级各类应用的不同规模和特点，并结合处理速度、存储容量、可靠性、系统开放性、性能价格比等因素来进行选择。

数据层服务器作为业务系统的核心，具有业务量大、存储量大等特点。它承担着业务数据的存储和处理任务,因此关键数据库服务器的选择就显得尤为重要。服务器的可靠性和可用性是首要的需求，其次是数据处理能力和安全性，然后是可扩展性和可管理性。为保证劳动保障信息系统持续稳定高效地运行，须保证服务器数据存储系统较高的可靠性、扩展性和灾难恢复能力。

基于RISC 系统的高中端服务器系统是适用于数据库服务器的选择，可根据具体业务需求和投资情况选择双机集群和单服务器系统，应用层服务器承担着业务系统的各类应用服务，主要强调其强大的计算能力，能够处理大量的并发连接处理，并能在用户数增加的情况下保持良好的性能平衡。

除此之外，能够提供连续可用的可靠性，能够适应各种网络环境的扩展能力也是需要考虑的因素。基于 RISC 系统的中低端服务器系统或高中端 PC服务器系统是适合于应用层服务器的选择,可根据具体业务需求和投资情况选择双机集群和单服务器方案。

其他服务器，如WEB 服务器、DNS 服务器等，要根据具体应用和投资要求在可靠性和处理能力等方面综合考虑。可采用中低端PC服务器系统。

下面以省级数据中心交换区数据层服务器为例，详细阐述服务器选型的方法。

省级数据中心交换区数据层服务器中作为社会保险关系异地转移、离退休人员异地数据交换和异地就医数据交换的数据库服务器，支持在职人员社会保险关系跨市转移的信息交换，以及异地领取养老金相关信息(如人员的基本状况、支付标准、生存状况等)的交换，同时保存死亡信息和公共服务信息、临时缓存宏观决策上报数据和基金监管信息。

考虑其作为中央、省、市三级数据中心信息交换的枢纽，所支撑应用的关键性，应采用基于 RISC 系统的高端服务器系统，具体配置要求如下:

5.4.1. 服务器处理能力

为支持本省的异地转移、异地就医和异地领取养老金等业务，需要较高的交易数据处理能力。

TPC 计算如下:

设: 全省参保总人数 C=980 万

交易日平均交易人数比例 a1=1%

每笔交易对应数据库事务数 a2=5

则:每日实际交易量 M= Cxa1xa2

交易日集中交易时间 T=120 分钟

交易日集中期内交易量比例 Ct=80%基准 TPC 指标值对应实际交易值的比例 MO=6:1CPU 处理能力余量 M1=30%-45%，取 35%

3年内每年处理能力增长率 P=30%

根据经验公式TPC=(MxM0xCt/(Tx(1-M1))x(1+30%)3=89,435

服务器选型考虑采用 TPC 值不低于 100,000 的高端服务器系统配置。

内存容量根据经验和类似业务量和环境，内存容量应为 1G/CPUxCPU数，从目前主流硬件厂商的指标来看，TPC 值要达到 100，000，一般需要配置8个CPU，因此内存建议配置 8GB.
总线带宽在高 CPU、大容量内存的配置下，必须要求主机系统总线带宽、/0 总线带宽都达到很高,否则,系统性能将形成瓶颈。
存储容量交换区平均数据量为 164.8GB，峰值数据量为 164.8GBx1.5，考虑 0.2倍的数据库索引和系统占用空间;作 RAID 保护后 60%存储利用率;以后数据增长，需提供 30%的数据扩充能力等因素，总存储容量约为:164.8x1.5x1.2160%170%=706GB，采用 SAN 中的光纤通道阵列作为数据存储.
可靠性、扩展性等

由于作为生产型数据库服务器，支持异地经办业务，属于实时性服务，该服务器系统在可靠性方面要求较高，可靠性必须达到 99.99%以上，提供全年 7x24 的可用性，配置为双机集群方式。系统采用多部件的冗余结构设计，具有高速差错校验和纠错的存储器，并有监控和诊断功能..

综上所述，对于在金保工程建设中服务器的选型，首先需对其业务系统的业务类型、业务复杂度等方面做系统的需求分析，其后根据需求在数据容量、数据处理的强度等方面进行估算，并兼顾服务器的可靠性、扩展性、安全性、可管理性等方面综合考虑，完成最终的产品选型。

5.5. 参考5

本工程合肥节点新建的处理能力以及用户容量规模如表1-1所示:

表1-1 本期工程 MMSC 处理规模

节点名称	用户容量	软件许可要求(MM/s)	软件许可要求(MM/s)	备注备注
合肥	200万	30	80	备注

5.5.1. 主要服务器处理能力

5.5.1.1. MMSC、数据库服务器和计费服务器

通常采用TPC-C指标衡量服务器的在线事务处理能力。TPC-C包括五种不同类型的即时处理或队列处理的并行交易混合，以分钟为单位计算。TPC-C的性能取决于计算机硬件、操作系统、数据库等多种因素。

目前MMS业务允许的消息大小为100KBytes，比短消息大3个数量级，其磁盘I/O，数据库访问所需要的服务器在线事务处理能力需求较高,华为公司经过测试得出不同的基本消息业务流程所需要的处理能力，如下表1-2所示:

单位:tpcC

表1-2 不同消息所需要的处理能力(单位:tpcC)

消息类型	MO	MT	EO	ET	AO	AT	FO	FT	系统保留(tpmC)
MMSC	6.3	7.8	8.6	9.8	8.5	8.2	8.2	8.3	1600
计费服务器	0.5	0.5	0.5	0.5	0.5	0.5	0.5	0.5	400
数据库服务器	0.5	0.5	0.5	0.5	0.5	0.5	0.5	0.5	400

考虑到基本格式转换需求，在EO/MT和MO/MT流程中进行字符集转换，进行字符集转换时相对于基本处理流程系统增加5%的处理能力开销。按本期工程要求，按照所有业务量的25%需要进行字符集转换配置系统。

在应用相关流程中，MMSC将业务请求传送给DSMP进行用户状态/订购信息的鉴权、认证以及批价操作，MMSC业务节点和计费服务器相对于基本业务流程需要增加相应的处理能力开销。

根据华为在广州进行DSMP功能测试的情况，与DSMP互联时增加的开销在13%左右，考虑到在现网业务情况相对复杂，与DSMP互联时业务节点和计费服务器相对于基本业务流程所需增加相应的处理能力开销取为15%。

根据本期工程需求，MMSC与DSMP进行互联时,接口处理能力按照不低于系统标称处理能力的15%业务量作为梦网业务进行考虑。

本期工程新增彩信计数器需求，根据华为公司相关产品的经验进行估计，进行计数器实时采集时，整个系统相对于基本业务流程需要增加5%的处理开销。

综合上述因素，消耗系统处理资源最大的业务流程为AO/FT业务流程，其处理能力要求为:(8.5+8.3)x(1+15%x15%)x(1+5%)=18.04 tpcC，华为MMSC设备选型即以此流程作为配置选型依据:

MMSC服务器

TPMC=每秒消息处理能力x60xTMs=80x60x18.04=86592(tpmC)

计费服务器

TPMC=每秒消息处理能力x60 xTi費x(1+DSMP增加的处理能力)-80x60x1x(1+15%x15%)=4908(tpmC)

Oracle数据库服务器

TPMC=每秒消息处理能力x60-80x60x1=4800(tpmC)

所需要的MMSC业务主机数=TPMC:(单机处理能力一系统保留处理能力)由上面的计算公式可得不同设备的处理能力如表1-3所示。

表1-3 不同设备的处理能力要求(单位:tpmC)

设备	处理能力	考虑 70%的系统利用率
MMSC	85592	122274
计费服务器	4908	7011
数据库服务器	4800	6857
合计	95300	136143
合计(计费和数据库，考虑 30%的冗余)	9708	13869

5.5.2. 配置建议

5.5.2.1. MMSC 业务主机

综合考虑MMSC业务特点，本工程建议选用V440和V490作为MMSC服务节点需要V440(4*1.28GHz)的单机数量计算如下:

86592÷(54612x0.7-1600)=2.36(台)

考虑冗余节点，及MMSC相互之间互备，实际配置4台V440(4*1.28GHz)的小型机，组成2套双机，相互之间互备每台主机所需要的内存为:

9.16÷4-2(系统保留)=4.29(G)

综上，本工程需要选用4CPU、8G的V440四台(2套双机，其中1台单机冗余)，作为4个MMSC业务集群节点，相互之间两两互备。

你会正确估算服务器处理能力吗？

Mon, 01 Jul 2024 16:22:13 +0800

1. 引题

但凡写过技术方案的都知道，在技术方案最终落实到工程实施部署时，必须编制出当前解决方案需要部署的IT设备及环境，包括：需要的网络环境、端口、带宽、组网方式、网络安全保障措施；需配置的服务器设备性能、数量；需配置的存储数据存储设备、容量、存储速率；甚至还需考虑整个系统的备份设备容量、备份I/O数、速率、备份策略等。

严格说来，无论是系统厂商、集成公司、还是研究院、设计公司，在最终提供方案的硬件配置时，都应该以业务需求为依据、适当考虑客户业务的发展趋势和系统冗余，详细估算：当前业务需求对网络带宽、对处理能力、对数据存储容量的指标。因此，本文以自己的项目案例和经验为基础，简述计算机处理能力如何正确估算，供大家参考。

2. 性能评测标准

众所周知，事务处理性能委员会的TPC-C标准，是测算和衡量计算机硬件设备性能的行业标准。随着B/S技术架构的大行其道，SPEC组织专门推出了针对Web服务器响应客户端Web访问请求的性能测算标准，即SPEC web系列。因此，如果是传统的基于事务处理模式的服务器，仍采用TPC-C的方式进行测算；如果是Web服务器，则需要采用SPEC web系列的标准进行测算。然而，很遗憾的看到，很多人在测算服务器性能时完全忽视这两种差别。

2.1. TPC-C标准

TPC-C基准是事务处理委员会建立的一个专门演示在线事务处理性能（OLTP）的性能基准，它的测量方法是为了使客户能够评估不同的在线事务处理系统的性能，这些事务进程于一个可控制的状态下在一个标准的数据库中运行。

TPC-C的事务处理是在一个9个表的数据库上实现的事务处理过程包括：更新、插入、删除、终止，以及对主和次级键的访问，每种事务处理95%的响应时间应小于或等于5秒，其中，库存水平的响应时间可以在60秒以内。TPC-C值表示每分钟处理的标准事务量，单位是tpmC。

2.2. SPEC web标准

SPEC web99，WEB 服务器可以支持的并发接入数。SPEC web99 检测程序模拟客户通过慢Internet 连接，向Web 服务器发送HTTP 工作量请求。

SPEC Web2005，作为SPECweb99的继承者，SPEC web2005延续了SPEC的传统测试的原理，通过多台客户机向服务器发出Http Get请求，请求调用Web服务器上的网页文件，这些文件从数千字节到数兆字节不等。在相同的时间里，服务器回答的请求越多，就表明服务器对客户端的处理能力越强，系统的Web性能就越好。

3. 性能估算公式

3.1. 常见的错误估算方法

在技术方案评审和招投标评标过程中，我常常看到这样的评估服务器处理能力的表格：

示例一： Web 服务器处理能力估算

序号	评估项	性能需求
1	最大并发用户数	500
2	每个连接每小时事务数	600
3	经验系数	1.5
4	应用类型指数	2
5	冗余系数(系统保证 30%冗余)	0.3
6	TPCC	21429

示例二： Web 服务器处理能力估算

序号	评估项	性能需求
1	最大并发用户数	500
2	每个连接每小时事务数	600
3	经验系数	1.5
4	应用类型指数	2
5	冗余系数(系统保证 30%冗余)	0.3
6	TPCC	21429

不知道这种评估方法是从那里开始的，在技术方案文档中，曾多次看到这样的评估模型和表格。即不全是TPC-C的评估方法，又不全是SPEC Web体系的评估方法。

3.2. TPC-C估算公式

TPC-C是用计算机设备在每分钟内所能处理的标准事务的数量来衡量其处理能力的多少；因此，估算一个应用场景对处理能力的需求，本质上就是估算出每类业务处理事务对应的标准tpc-c事务量，然后在适当考虑冗余量。TPC-C的测算结果是每分钟的事务数，单位是tpmc。

TPC-C的通用估算公式如下：

TPC-C = ∑(每分钟业务事务量 * 标准事务量比率)/ (1 — 冗余率)。

例如：某业务系统有2类业务处理事务操作，业务事务1每分钟30000个，每个业务事务1操作相当于0.5个标准tpc-c事务；务事务2每分钟20000个，每个业务事务2操作相当于2个标准tpc-c事务；考虑30%的系统冗余。则该业务应用需要的处理能力为：

服务器处理能力(tpmc) = ((30000 X0.5) + (20000 X 2)) / (1 – 30%) = 78581。

3.3. SPEC Web估算公式

SPEC Web2005标准的衡量结果是一台Web服务器能够有效响应客户端的Web请求的最大极限个数。因此，测算的结果应该是一个Web请求数字，单位是个。

在评估应用服务器的SPEC Web2005值时，通常的方法是通过系统的在线用户，结合其在线率估算出并发用户数，在参照日常业务使用场景中可能发起的http请求来进行估算。

SPEC Web2005的参考估算公式如下：(注意：公式仅供参考，需根据项目的具体情况自行设计估算模型)

Web访问响应能力(SPEC Web2005) = (在线用户数 * 在线率 * 在线用户平均发起http请求数)/ (1 — 冗余率)。

例如：某业务系统的在线用户数为2000，在线率10%，每在线用户平均发起的http请求数为3，考虑30%的系统响应能力冗余。则负责该业务请求的Web服务器的响应能力为：

[Web访问响应能力(个) = 2000 * 10% * 3 / (1 – 30%) = 857]

4. 应用实例

下面以一个实际工程项目的应用服务器(部署Web Service中间件)的性能估算为例进行示范。

应用服务器上运行中间件产品，承担系统的各类业务逻辑组件运行计算，收敛系统用户对数据库服务器的访问请求，集中对外提供应用服务。通过分析，应用服务器性能需求在于：提供Web应用服务、业务逻辑处理。

Web应用服务方面，根据的业务预测数据，应用服务器平均在线并发用户按120估算，并发在线率20%，每用户平均发起3个http链接，考虑30%系统响应冗余能力，参照SPECweb99的评测标准，Web应用服务性能需求：

[Web服务器最大并发连接数=(120×20%×3)/(1 - 30%)= 103]

业务逻辑处理性能方面，主要的应用服务组件性能需求在于：集团数据监测分析、省数据监测分析、业务数据查询。据调研统计，集团数据为每分钟3585 条，省数据平均为每分钟51667条，业务信息查询请求平均为每分钟2151次；集团数据监测分析，每次业务操作约需3个标准tpcc事务，省数据监测分析，每次业务操作约需2个tpcc事务，业务信息查询，每次业务操作约需2个tpcc事务；则系统主机的处理能力需求TPCC值计算如下：

分类	数据项	估算公式	估算结果
集团数据监测分析	每分钟服务过程记录	A1	3585
集团数据监测分析	每次控制器作标准TPCC	A2	5
集团数据监测分析	结果	A3 = A1 * A2	17925
省公司数据监测分析	每分钟分析记录数	B1	51667
省公司数据监测分析	每次控制器作标准TPCC	B2	2
省公司数据监测分析	结果	B2 = B1 * B2	103334
业务信息查询	每分钟服务数据查询请求	C1	2151
业务信息查询	每次操人生标准TPCC	C2	3
业务信息查询	结果	C3 = C1 * C2	6453
汇总	系统软件占用开锁	D0	10000
汇总	结果		137712
汇总	主机CPU处理冗余度	D2	30.00%
汇总	处理能力需求	D3 = D1/(1-D2)196731

蓝队巨献！告警IP全自动封禁平台

Tue, 11 Jun 2024 13:39:35 +0800

1. 作为蓝队成员，你是否在防守过程中常常为以下问题所困扰？

尽管明确指定了防守资产，但封堵人员还是频繁误封生产环境。
安全设备匹配到DNS服务器请求的IOC域名告警时，封堵人员胡乱封禁DNS，导致邮件等需要外联的生产系统崩溃。
封堵人员甚至对127.0.0.1进行封禁，显现出严重的专业知识缺乏。
监测人员每时每刻都需要根据安全设备告警填写封禁IP协同表格，封禁人员也无法实时封禁攻击IP，效率低下。
重复性的工作需要大量人员参与，还必须进行24小时轮班，增加了人力成本和管理复杂度。
防守单位的防火墙等封禁设备性能低下，添加规则既繁琐又易导致系统崩溃。
误封IP后，解禁时需要在多个设备上反复排查搜索，耗费了大量时间和精力。
临时添加白名单IP后，无法有效同步给所有工作组成员。
总是重复封禁相同IP，封禁设备的规则库又容易空间不足，无法满足封禁需求。
封禁设备陈旧，无法支持封禁一定时间后自动解除。
安全厂商自家设备只能和自家设备进行联动，无法也不给适配全部设备，限制了整体防护效果。

2. 解决方案

针对以上问题，我们特此研发了全自动封禁平台（https://github.com/sec-report/SecAutoBan），从此防守不再困难，平台具备以下优势：

智能化防护：自动封禁威胁，减少人为错误，降低人力成本。
高效协同：封禁信息实时同步，确保所有工作组成员及时了解动态。
精确管理：支持对封禁规则进行细粒度控制，自动解除过期封禁，提升封禁设备性能。
兼容性强：能够与不同厂商的安全设备进行联动，构建全面的防护体系。
简化操作：用户友好的界面设计，简化操作流程，降低学习成本。

服务采用分布式设计，由三大模块组成，分别为：告警日志解析处理模块、核心处理模块、IP封禁/解禁模块，每个模块单独运行。

告警模块：负责处理所有来自安全设备的告警信息，并提取其中的IP地址。
核心模块：接收到告警模块传入的IP地址后，进行去重和过滤等处理，以确保只有有效的IP被处理。
封禁模块：接收来自核心模块处理后的IP地址，并进行相应的封禁操作。

具体思维导图如下：

整体封禁流程如下：

3. 安装使用

3.1. 安装核心模块

核心模块采用docker-compose方案一键安装，运行脚本前请先安装docker：

1mkdir SecAutoBan && cd SecAutoBan
2wget https://raw.githubusercontent.com/sec-report/SecAutoBan/main/docker-compose.yml
3wget https://raw.githubusercontent.com/sec-report/SecAutoBan/main/run.sh
4chmod +x run.sh
5./run.sh

Docker全部运行后访问http://127.0.0.1/访问管理后台，初始化管理员账号。

3.2. 新建告警/封禁设备

首先在管理后台添加设备：

添加设备后，复制设备连接Key。（注意：设备连接Key仅显示一次，请妥善保存）

3.3. 配置并运行告警/封禁模块

安装加密依赖，回连平台数据包需要加密：

1pip3 install pycryptodome

模块具体使用方法请跳转至项目文档：https://github.com/sec-report/SecAutoBan

（目前项目中只有python版样例，后续会上新golang等语言样例），根据项目文档配置好模块后，使用python运行即可。

运行告警分析模块：

运行封禁/解封模块：

运行成功后，平台将显示设备已连接：

模块全部运行后，就会有源源不断的报警推送到核心模块中，核心模块处理后会再推送给所有连接平台的封禁模块进行处置。

使用Web端实时查看封禁处置流水：

至此整个系统就全部运行起来了，享受全自动封禁带来的高效和便捷吧～

Linux 笔记整理

Wed, 05 Jun 2024 10:21:49 +0800

1. Linux 常见目录

目录	用途
/	根目录，通常不储存文件
/bin	二进制目录，存放用户级 GNU 工具
/boot	启动目录，存放启动文件
/dev	设备目录
/etc	系统配置文件目录
/home	主目录，Linux 在这里创建用户目录
/lib	库目录，存放系统和应用程序的库文件
/media	媒体目录，可移动媒体设备的常用挂载点
/mnt	挂在目录，另一个常用挂载点
/opt	可选目录，常用于存放第三方软件包和数据文件
/root	root 用户的主目录
/sbin	系统二进制目录，存放 GNU 管理员级工具
/run	运行目录，存放系统运作时的运行时数据
/proc	进程目录，存放现有硬件和当前进程的相关信息
/srv	服务目录，存放本地服务的相关文件
/sys	系统目录，存放系统硬件信息的相关文件
/tmp	临时目录，可以在该目录中创建删除临时工作文件
/usr	用户二进制目录
/var	可变目录

2. 常用命令

pwd：显示 shell 会话当前目录。. 表示当前目录，.. 表示当前文件目录的父目录。
man：查看手册。
cd destination：切换目录。
ls：显示当前目录下的文件和目录。
- -F：区分文件和目录，目录文件名后会添加/。
- -a：将隐藏文件和普通文件及目录一起显示出来。
- -R：递归选项。列出当前目录下包含的子目录中的文件。
- -l：产生长列表格式的输出，包含了目录中每个文件的相关信息：文件类型，权限，硬链接总数，属主的用户名，组名，大小，上次修改时间，文件名或目录名。
- -i：查看文件或目录的 inode 编号。
- --time=atime：显示访问时间。
文件扩展匹配：使用通配符。
- ?：代表一个字符。
- *：代表零个或多个字符。
- []：表示一个字符位置并给出多个可能的选择，也可以指定范围。
- !：将不需要的内容排除。
touch：创建空文件，或改变文件修改时间。
- -a：改变访问时间。
cp source destination：复制文件。
- -i：强制 shell 询问是否需要覆盖已有文件。
- -R：递归地复制整个目录的内容。
ln -s：创建符号链接。
- ln：创建硬链接。
- 符号链接是一个实实在在的文件，它指向存放在虚拟目录结构中某个地方的另一个文件。这两个通过符号链接在一起的文件，彼此的内容并不相同。
- 硬链接会创建独立的虚拟文件，其中包含了原始文件的信息和位置。但是它们从根本上而言是同一个文件。引用硬链接等同于引用了源文件。
mv：移动或重命名文件和目录。重命名、移动不改变 inode 编号和时间戳。
- -i：命令试图覆盖已有文件时得到提示。
rm：删除。
- -i：确认提示。
- -f：强制删除。
- -r：向下进入目录。
mkdir：创建目录。
- -p：同时创建多个目录和子目录。
- rmdir：只删除空目录。
file：查看目录、文件类型和字符编码。
cat：显示文本文件中所有数据。
- -n：给所有行加上行号。
- -b：给有文本的行加上行号。
- -T:用 ^I 替换文中制表符。
more：显示文本文件中的内容，但会在显示每页数据之后停下来。
- less：more 的升级。
tail：显示文件最后几行内容。默认显示文件的末尾 10 行。
- -n：修改所显示的行数。
- -f：在其他进程使用该文件时查看文件的内容，这是实时监测系统日志的绝妙方式。
head：显示文件开头内容，默认显示前 10 行。
- -n：修改所显示的行数。
ps：默认显示运行在当前控制台下的属于当前用户的进程。
top：实时显示进程信息。
kill PID：结束进程，必须为进程的属主或为 root 用户，只支持 PID。
- killall：支持进程名。
mount -t type device directory：挂载媒体设备。
- 默认输出当前系统上挂在的设备列表。
- umount：卸载设备。
df：查看所有挂载磁盘使用情况。
- -h：按用户易读的形式显示。
du：显示某个特定目录（默认情况是当前目录）的磁盘使用情况。
- -c：显示所有已列出文件总的大小。
- -h：按用户易读的形式显示。
sort：按会话指定的默认语言的排序规则对文本文件中的数据进行排序。
- -n：把数字识别成数字而不是字符，并且按值排序。
- -M：按月排序。
- -t：指定字段分隔符。
- -k：指定排序的字段。
- -r：将结构按降序输出。
grep [options] pattern [file]：搜索数据。
- -v：反向搜索，输出不匹配该模式的行。
- -n：显示匹配模式的行所在的行号。
- -c：显示有多少行含有匹配的模式。
- -e：指定多个匹配模式。
gzip：压缩文件
- gzcat：查看压缩过的文本文件的内容。
- gunzip：解压文件。
tar function [option] object：归档数据。
- -cvf：创建一个归档文件。
- -tf：列出内容。
- -xvf：提取内容。
- tar -zxvf filename.tgz：解压 .tgz
jobs：显示出当前运行在后台模式中的所有用户的进程。
- -l：显示命令的 PID。
history：查看最近使用过的命令列表。
- -a：将命令历史记录强制写入 .bash_history 文件。
alias -p：查看一些常用命令的别名。
env / printenv 查看全局变量，printenv 也可以查看个别环境变量。
useradd：添加新用户
- -D：查看默认值。
- -m：创建 HOME目录。
userdel：删除用户信息，不删除文件。
- -r：删除用户的 HOME目录以及邮件目录。
usermod：修改用户帐户的字段。
- -l：修改用户账户的登录名。
- -L：锁定账户。
- -p：修改账户的密码。
- -U：解除锁定。
passwd：修改密码。
- -e：强制用户下次登录时修改密码。

3. 文件权限

3.1. 文件权限符

举例说明：

1-rwxrwxr-x 1 rich rich 4882 2010-09-18 13:58 myprog
2
3# 登录名为 rich 的用户可以读取、写入以及执行这个文件。
4# rich 组的成员也可以读取、写入和执行这个文件。
5# 不属于 rich 组的其他用户只能读取和执行这个文件。

输出的第一个字段是描述文件和目录权限的编码。第一个字符代表对象的类型：

- 代表文件
d 代表目录
l 代表链接
c 代表字符型设备
b 代表块设备
n 代表网络设备

之后有 3 组三字符的编码，每组定义了 3 种访问权限：

r 代表对象是可读的。
w 代表对象是可写的。
x 代表对象是可执行的。

若没有某种权限，则该权限位会出现破折线。

3 组权限对应对象的 3 个安全级别：

对象的属主
对象的属组
系统的其他用户

3.2. Linux 文件权限码

权限	二进制值	八进制值	描述
—	000	0	没有任何权限
–x	001	1	只有执行权限
-w-	010	2	只有写入权限
-wx	011	3	有写入和执行权限
r–	100	4	只有读取权限
r-x	101	5	有读取和执行权限
rw-	110	6	有读取和写入权限
rwx	111	7	有全部权限

3.3. 默认文件权限

umask：设置所创建文件和目录的默认权限。系统默认的八进制的 umask 值是 0022。

1$ umask
20022

第一位代表了一项特别的安全特性。叫做粘着位。

要把 umask 值从对象的全权限值中减掉。对文件来说，全权限值是 666（所有用户都有读和写的权限），而对目录来说，则是 777（所有用户都有读、写、执行权限）。

3.4. 改变权限

chmod options mode file：改变文件和目录的安全性设置，可以使用八进制模式或符号模式进行设置。
- -R：让权限的改变递归地作用到文件和子目录。

3.4.1. 八进制模式

1$ chmod 760 newfile
2$ ls -l newfile
3-rwxrw---- 1 rich   rich   0  Sep 20 19:16 newfile

3.4.2. 符号模式

[ugoa...][+-=][rwxXstugo...]

[ugoa...]

u 代表用户
g 代表组
o 代表其他
a 代表上述所有

[+-=]

+：在现有权限基础上增加权限
-：在现有权限基础上移除权限
=：将权限设置成后面的值

[rwxXstugo...]

X：如果对象是目录或者它已有执行权限，赋予执行权限
s：运行时重新设置 UID 或GID。
t：保留文件或目录。
u：将权限设置为跟属主一样。
g：将权限设置为跟属组一样。
o：将权限设置为跟其他用户一样。

1# 移除属主已有的执行权限
2$ chmod u-x newfile
3$ ls -l newfile
4-rw-rw-r--   1 rich   rich   0  Sep 20 19:16 newfile

3.5. 改变所属关系

chown options owner[.group] file：改变文件的属主，也支持同时改变文件的属主和属组。
- -R：递归地改变子目录和文件的所属关系。
- -h：改变该文件的所有符号链接文件的所属关系。
chgrp：更改文件或目录的默认属组。

4. Vim 编辑器

vim <file_name>：启动 vim 编辑器。
vim + <file_name> : 打开文件并把光标移动到最后一行行首。
vim +<num> file_name : 打开文件并把光标移动到第 num 行的行首。
vim +<word> file_name : 打开文件并把光标移动到 word 第一次出现的位置行的行首，按 n 移动。

4.1. 普通模式

h：左移一个字符。
j：下移一行（文本中的下一行）。
k：上移一行（文本中的上一行）。
l：右移一个字符。
PageDown（Ctrl + F）：下翻一屏。
PageUp（Ctrl + B）：上翻一屏。
G：移到缓冲区的最后一行。
num G：移动到缓冲区中的第 num 行。
gg：移到缓冲区的第一行。

4.1.1. vim 编辑命令

命令	描述
x	删除当前光标所在位置的字符
dd	删除当前光标所在行
dw	删除当前光标所在位置的单词
d$	删除当前光标所在位置至行尾的内容
J	删除当前光标所在行行尾的换行符（拼接行）
u	撤销前一编辑命令
a	在当前光标后追加数据
A	在当前光标所在行行尾追加数据
r char	用 char 替换当前光标所在位置的单个字符
R text	用 text 覆盖当前光标所在位置的数据。直到按下 ESC 键

vim 在删除数据时，实际上会将数据保存在单独的一个寄存器中。可以用 p 命令取回数据。

vim 中复制命令是 y ，可以在 y 后面使用和 d 命令相同的第二字符（yw 表示复制一个单词，y$ 表示复制到行尾。）。在复制文本后，把光标移动刀你想放置文本的地方，输入 p 命令，复制的文本就会出现在该位置。

要输入一个查找字符串，按下斜线（/）键。

4.2. 命令行模式

q：如果未修改缓冲区数据，推出。
q!：取消所有对缓冲区数据的修改并退出。
w filename：将文件保存到另一个文件中。
wq：将缓冲区数据保存到文件中并退出。
替换命令：:s/old/new/
- :s/old/new/g：一行命令替换所有 old。
- :n,ms/old/new/g：替换行号 n 和 m 之间所有 old。
- :%s/old/new/g：替换整个文件中的所有 old。
- :%s/old/new/gc：替换整个文件中的所有 old，但在每次出现时提示。

5. 杂项

访问 Linux 虚拟控制台：Ctrl + Alt + F1 ~ F7
tty : 电传打字机（ teletypewriter ）
/etc/passwd：所有系统用户账户列表以及每个用户的基本配置信息。
只能对处于同一存储媒体的文件创建硬链接。不同储存媒体的文件之间创建链接，只能使用符号链接。
在一行中指定要依次运行一系列命令，只要在命令间加入 ； 号，即通过命令列表实现。
将命令置入后台模式，可以在命令行末尾加上字符 &。
/etc/profile 是系统默认的 bash shell 的主启动文件。
etc/passwd 文件的字段包含如下信息：登陆用户名，用户密码，用户账户的 UID ，用户账户的组 ID 。用户账户的文本描述，用户 HOME 目录的位置，用户的默认 shell。
本地连接虚拟机中的 Ubuntu 时，若出现 ssh: connect to host localhost port 22: Connection refused ，原因是 Ubuntu 没有默认提供 ssh 服务，首先安装 ssh apt-get install openssh-server ，如果安装完后该服务没有自动启动，则手工启动 sudo /etc/init.d/ssh start 。

6. 附

6.1. CentOS 7 使用 yum 更换 epel 仓库

6.1.1. 常规

安装：yum -y install epel-release
卸载：yum -y remove epel-release
查看：yum repolist

6.1.2. 手动安装

针对系统架构选择相应的类型，选择相应的包。

1rpm -vih https://dl.fedoraproject.org/pub/epel/7/x86_64/e/epel-release-7-11.noarch.rpm

或

1cd ~ && wget https://dl.fedoraproject.org/pub/epel/7/x86_64/e/epel-release-7-11.noarch.rpm  <br>rpm -vih epel-release-7-6.noarch.rpm

6.1.3. 查看并更新源

查看：ls -l /etc/yum.repos.d/
两个 epel 的 repo 文件：epel.repo 和 epel-testing.repo
更新：yum clean all && yum makecache

6.2. FirewallD 常用命令

6.2.1. 基本使用

启动： systemctl start firewalld
查看状态： systemctl status firewalld
停止： systemctl disable firewalld
禁用： systemctl stop firewalld

6.2.2. 配置

查看版本： firewall-cmd --version
查看帮助： firewall-cmd --help
显示状态： firewall-cmd --state
查看所有打开的端口： firewall-cmd --zone=public --list-ports
更新防火墙规则： firewall-cmd --reload
查看区域信息: firewall-cmd --get-active-zones
查看指定接口所属区域： firewall-cmd --get-zone-of-interface=eth0
拒绝所有包：firewall-cmd --panic-on
取消拒绝状态： firewall-cmd --panic-off
查看是否拒绝： firewall-cmd --query-panic
禁止被 ping：firewall-cmd --permanent --add-rich-rule='rule protocol value=icmp drop'

6.2.3. 添加删除端口

添加：firewall-cmd --zone=public --add-port=80/tcp --permanent（--permanent 永久生效，没有此参数重启后失效）
重新载入：firewall-cmd --reload
查看：firewall-cmd --zone= public --query-port=80/tcp
删除：firewall-cmd --zone= public --remove-port=80/tcp —permanent

不要开启tcp_tw_recycle

Tue, 04 Jun 2024 16:55:03 +0800

不要开启net/ipv4/tcp_tw_recycle

1. 问题描述

我们把Greenplum搬到了kubernetes上面。Greenplum主控分为master和standby两个容器，分别跑在2个物理机器上，容器网络为NAT(flannel)；为了方便用户访问，我们为每个租户分配了一个virtual ip(物理机器网段)，该地址由keepalived管理，具体实现上我们使用了kube-keepalived-vip，它也以容器的方式跑在kubernetes上，宿主机网络(因为要向宿主机下发virtual ip)，对keepalived本身做了封装：通过configmap传递virtual ip和real server(即master容器的ip地址，rmt50-vip-svc的endpoint)，并生成keepalived的配置文件，然后启动keepalived。keepalived会向内核下发lvs规则，将到virtual ip + 5432(192.168.128.5 5432)的报文走NAT转发给master容器(10.244.3.27 5432)。 configmap:

1apiVersion: v1
2data:
3  192.168.128.5: default/rmt50-vip-svc
4kind: ConfigMap

具体keepalived.conf:

 1vrrp_instance vips {
 2  state BACKUP
 3  interface eno16780032
 4  virtual_router_id 28
 5  priority 100
 6  nopreempt
 7  advert_int 1
 8
 9  track_interface {
10    eno16780032
11  }
12
13  virtual_ipaddress { 
14    192.168.128.5
15  }
16}
17
18# Service: default/rmt50-vip
19virtual_server 192.168.128.5 5432 {
20  delay_loop 5
21  lvs_sched wlc
22  lvs_method NAT
23  persistence_timeout 1800
24  protocol TCP
25  
26  real_server 10.244.3.27 5432 {
27    weight 1
28    TCP_CHECK {
29      connect_port 5432
30      connect_timeout 3
31      retry 1
32      delay_before_retry 3
33    }
34  }
35}

该租户各个容器的地址如下。其中rmt50-master为master容器,rmt50-standby是standby容器，rmt50-vip为vip容器。

1kubectl get pods -o wide|grep rmt50
2rmt50-master              1/1       Running    0          2d        10.244.3.27       s2.adb.g1.com
3rmt50-standby             1/1       Running    0          2d        10.244.1.250      m2.adb.g1.com
4rmt50-vip                 1/1       Running    5          2d        192.168.128.149   s2.adb.g1.com

但实际使用时，发现psql连接virtual ip(192.168.128.5)有一定概率会失败，服务器反馈端口不可达；查看kube-keepalived-vip容器(下面简称vip容器)的日志，发现是TCP_CHECK检测real_server超时后，将real_server从内核lvs表项中删除了(通过ipvsadm -l查看)。

一开始我以为是网络抖动，所以把connection_timeout, retry都调大了一点(retry 1确实有点太严苛了)，之后的确有所改善，但问题并没有根除，如果从另一物理机器(m1)和vip容器上同时去频繁psql连接virtual ip，基本上几分钟就可以复现出来。

2. 定位过程

2.1. 怀疑点1：网络

出现问题时，docker exec进入vip容器，发现ping master容器正常，说明从vip容器到master容器的网络是正常的。由于vip容器和master容器都在同一个物理机器上(s1)，只是vip容器在宿主机网络上，而master容器在flannel网络内；由于宿主机网络有所有的路由，因此从vip容器出来的报文，直接走cni0转发即可，源地址使用cni0的地址，一般来说不太会出问题。

2.2. 怀疑点2：postgre进程故障

在master容器上tcpdump抓包，可以看到vip 容器发过来的syn报文，但是master容器并没有应答，导致syn报文一直重传。如果postgre进程跑飞了会不会造成这个现象呢？在出问题的时候，我strace -p pid了下postgre进程，看到一直在select，说明内核没有上报新socket事件。

其实，根本就不应该怀疑postgre进程。从抓包看到只有收到syn没有应答syn+ack，就可以肯定跟用户态的postgre进程无关了：tcp三次握手完全是内核完成的，只有3次握手结束，内核才会给用户态进程上报事件；用户态最多就是不响应该事件，但不会造成不应答syn+ack。

2.3. 怀疑点3：内核丢包

只有这种可能了。linux内核调试起来比较麻烦，不过可以通过proc来看一些统计信息。

1cat /proc/net/netstat 
2TcpExt: SyncookiesSent SyncookiesRecv SyncookiesFailed EmbryonicRsts PruneCalled RcvPruned OfoPruned OutOfWindowIcmps LockDroppedIcmps ArpFilter TW TWRecycled TWKilled PAWSPassive PAWSActive PAWSEstab DelayedACKs DelayedACKLocked DelayedACKLost ListenOverflows ListenDrops TCPPrequeued TCPDirectCopyFromBacklog TCPDirectCopyFromPrequeue TCPPrequeueDropped TCPHPHits TCPHPHitsToUser TCPPureAcks TCPHPAcks TCPRenoRecovery TCPSackRecovery TCPSACKReneging TCPFACKReorder TCPSACKReorder TCPRenoReorder TCPTSReorder TCPFullUndo TCPPartialUndo TCPDSACKUndo TCPLossUndo TCPLostRetransmit TCPRenoFailures TCPSackFailures TCPLossFailures TCPFastRetrans TCPForwardRetrans TCPSlowStartRetrans TCPTimeouts TCPLossProbes TCPLossProbeRecovery TCPRenoRecoveryFail TCPSackRecoveryFail TCPSchedulerFailed TCPRcvCollapsed TCPDSACKOldSent TCPDSACKOfoSent TCPDSACKRecv TCPDSACKOfoRecv TCPAbortOnData TCPAbortOnClose TCPAbortOnMemory TCPAbortOnTimeout TCPAbortOnLinger TCPAbortFailed TCPMemoryPressures TCPSACKDiscard TCPDSACKIgnoredOld TCPDSACKIgnoredNoUndo TCPSpuriousRTOs TCPMD5NotFound TCPMD5Unexpected TCPSackShifted TCPSackMerged TCPSackShiftFallback TCPBacklogDrop TCPMinTTLDrop TCPDeferAcceptDrop IPReversePathFilter TCPTimeWaitOverflow TCPReqQFullDoCookies TCPReqQFullDrop TCPRetransFail TCPRcvCoalesce TCPOFOQueue TCPOFODrop TCPOFOMerge TCPChallengeACK TCPSYNChallenge TCPFastOpenActive TCPFastOpenActiveFail TCPFastOpenPassive TCPFastOpenPassiveFail TCPFastOpenListenOverflow TCPFastOpenCookieReqd TCPSpuriousRtxHostQueues BusyPollRxPackets TCPAutoCorking TCPFromZeroWindowAdv TCPToZeroWindowAdv TCPWantZeroWindowAdv TCPSynRetrans TCPOrigDataSent TCPHystartTrainDetect TCPHystartTrainCwnd TCPHystartDelayDetect TCPHystartDelayCwnd TCPACKSkippedSynRecv TCPACKSkippedPAWS TCPACKSkippedSeq TCPACKSkippedFinWait2 TCPACKSkippedTimeWait TCPACKSkippedChallenge
3TcpExt: 0 0 118 0 0 0 0 0 1 0 94979 0 960494 0 0 906 343087 1119 5435 0 0 432477 9530 21215128 0 7057137 7 2736264 2582522 0 4 0 1 2 0 0 0 0 6 317 0 0 5 0 92 0 23 1992 1464 713 0 0 4 0 5450 62 1557 0 293509 80 0 12 0 0 0 0 0 782 49 0 0 0 0 171 0 0 0 0 0 0 0 2 1743889 11075 0 69 7 3 0 0 0 0 0 0 174 0 303158 542 542 3641 3021 21292349 27 749 0 0 0 0 0 0 0 0
4IpExt: InNoRoutes InTruncatedPkts InMcastPkts OutMcastPkts InBcastPkts OutBcastPkts InOctets OutOctets InMcastOctets OutMcastOctets InBcastOctets OutBcastOctets InCsumErrors InNoECTPkts InECT1Pkts InECT0Pkts InCEPkts
5IpExt: 3 0 4802567 1188058 6661 0 57132122839 92642737581 189351200 38019672 2189009 0 0 85932763 0 0 0

非常友好的统计信息！

回头还是用go写个小工具format下netstat，这个真的太难看了。我用atom把netstat竖排了下，发现有个ListenDrops计数在出现问题的时候会有变大。呵呵呵，坏人抓到了。

这里可以用我写的netproc来观察net计数的变化，还是比较友好的！

来看内核的这个计数是干啥的。

ListenDrops计数对应内核的LINUX_MIB_LISTENDROPS，走读下代码，可以看到有很多情况该计数会增加，为了区分不同情况，内核会在增加LINUX_MIB_LISTENDROPS的同时增加其他的计数。不慌，我们再看下netstat的信息，有没有发现PAWSPassive的计数跟ListenDrops是一致的？是不是巧合呢？没关系，我们再重复一把，看看netstat的变化。

果然还是一致的。

两次netstat的信息：

1PAWSPassive 3565   3858
2ListenDrops 3565   3858

PAWSPassive对应内核的LINUX_MIB_PAWSPASSIVEREJECTED，它只有一种情况下会出现：

tcp_ipv4.c/tcp_v4_conn_request:

 1int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
 2		/* VJ's idea. We save last timestamp seen
 3		 * from the destination in peer table, when entering
 4		 * state TIME-WAIT, and check against it before
 5		 * accepting new connection request.
 6		 *
 7		 * If "isn" is not zero, this request hit alive
 8		 * timewait bucket, so that all the necessary checks
 9		 * are made in the function processing timewait state.
10		 */
11		if (tmp_opt.saw_tstamp &&
12		    tcp_death_row.sysctl_tw_recycle &&
13		    (dst = inet_csk_route_req(sk, &fl4, req)) != NULL &&
14		    fl4.daddr == saddr) {
15			if (!tcp_peer_is_proven(req, dst, true)) {
16				NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
17				goto drop_and_release;
18			}
19		}
20drop_and_release:
21	dst_release(dst);
22drop_and_free:
23	reqsk_free(req);
24drop:
25	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
26	return 0;

net/ipv4/tcp_metrics.c:

 1bool tcp_peer_is_proven(struct request_sock *req, struct dst_entry *dst, bool paws_check)
 2{
 3	struct tcp_metrics_block *tm;
 4	bool ret;
 5
 6	if (!dst)
 7		return false;
 8
 9	rcu_read_lock();
10	tm = __tcp_get_metrics_req(req, dst);
11	if (paws_check) {
12		if (tm &&
13		    (u32)get_seconds() - tm->tcpm_ts_stamp < TCP_PAWS_MSL &&
14		    (s32)(tm->tcpm_ts - req->ts_recent) > TCP_PAWS_WINDOW)
15			ret = false;
16		else
17			ret = true;
18	}

内核版本为3.10。

简单来说，当开启了tcp_tw_recycle时，kernel会记录每个peer的最后一个报文的时戳，如果记录的该时戳仍然有效(距离当前时间小于TCP_PAWS_MSL)，并且新收到的syn报文的时戳，比kernel记录的该peer的时戳还要小(换句话说，时光倒流了)，那么就认为新收到的syn报文是有问题的(比如是某个在网络上兜兜转转了很久才到目的地址的syn)，从而drop之。

所以我们看到的现象就是，内核收到了新的syn报文，但只是默默drop了(没什么好处理方法，回RST可能误伤)，所以造成了psql连接超时。

3. 解决方法

只要将net.ipv4.tcp_tw_recycle恢复为默认值0即可。

4. 深入理解

4.1. TIME_WAIT是干啥的

先祭出tcp状态机迁移图。做协议栈的都要能默写啊！只有主动关闭连接的一方，才会转移到TIME_WAIT。

TIME_WAIT的主要目的有2个：

避免误收延迟到达的报文

如下图，由于TIME_WAIT的时间被缩短了，造成新建的连接收到了之前延迟到达的报文(5元组是匹配的)。

保证对端已经关闭了连接

如下图，由于TIME_WAIT的时间被缩短了，对端还处于LAST_ACK状态，本端发送的syn报文被直接RST掉了。

4.2. 为什么Greenplum会开启tcp_tw_recycle

为什么内核会开启net.ipv4.tcp_tw_recycle=1呢？网络上有很多资料建议繁忙的服务器开启这个sysctl，Greenplum也在其官网的资料Linux System Settings里提到，linux的/etc/sysctl.conf中应设置net.ipv4.tcp_tw_recycle=1。

开启tcp_tw_recycle的目的是为了减少TIME_WAIT状态的socket连接，从而减少内存、cpu的使用，因为TIME_WAIT状态的socket会快速释放；也可以提高并发连接的规格，因为客户端可以使用的端口号更多了。对比下没有开启recycle的情况，若服务端先关闭连接，socket会停留在TIME_WAIT状态的时间是1个TCP_PAWS_MSL(在linux上是1分钟)，在此时间内，客户端不能再使用刚刚用过的源端口号，否则服务端会直接RST之。

看上去很美好。

4.3. 为什么不要开启tcp_tw_recycle

但人算不如天算，当网络中存在NAT的情况下，开启tcp_tw_recycle会引起上述syn报文被丢弃的问题。我们来看下为什么。

从前面问题定位的过程可以发现，tcp_tw_recycle能够运转，其基础是tcp报文中需要带TIMESTAMP时戳选项。要了解tcp_tw_recycle，必然要先了解下tcp时戳选项。TCP timestamp这篇文章中详细的讲解了时戳，建议先跳转过去看看。

简单来说，TCP协议中有一个很重要的概念：RTO(Retransmission TimeOut)，重传超时时间，RTO是根据RTT(Round Trip Time)来动态调整的。但如何测量RTT呢？

一个办法是计算报文发送时间和对端ack确认的时间差，作为RTT。但由于报文重传、SACK等原因，这样计算出来的RTO可能会偏大，因此一般会选择没有重传的报文来计算。

另一个办法就是使用TIMESTAMP选项。

发送方在发送数据时，将一个timestamp(表示发送时间)放在包里面
接收方在收到数据包后，在对应的ACK包中将收到的timestamp返回给发送方(echo back)
发送发收到ACK包后，用当前时刻now - ACK包中的timestamp就能得到准确的RTT

时戳的值，在linux上是这样定义的：

include/net/tcp.h

1/* TCP timestamps are only 32-bits, this causes a slight
2 * complication on 64-bit systems since we store a snapshot
3 * of jiffies in the buffer control blocks below.  We decided
4 * to use only the low 32-bits of jiffies and hide the ugly
5 * casts with the following macro.
6 */
7#define tcp_time_stamp		((__u32)(jiffies))

jiffies即系统从开机到现在的时钟中断次数。

回到tcp_tw_recycle上来。我们来看下tcp_peer_is_proven这个函数中是怎么判断是否应该丢弃该syn报文的。

1if (tm &&
2		    (u32)get_seconds() - tm->tcpm_ts_stamp < TCP_PAWS_MSL &&
3		    (s32)(tm->tcpm_ts - req->ts_recent) > TCP_PAWS_WINDOW)    //here
4			ret = false;
5		else
6			ret = true;

只要新包的时戳比上次看到的时戳小，就判断报文有问题。可见，同一个peer的时戳，必须要线性增长，否则判断会出错。显然，一般情况下对于同一个客户端，”时戳线性增长”这个前提是满足的，但如果客户端在NAT之后呢？

我们在家里访问外部服务器的时候，家里可能有多台终端，其地址可能是192.168.1.100, 192.168.1.101，但在从家庭路由器出去的时候，会做一次SNAT，将报文的源地址替换为运营商给我们分配的公网地址。对于服务器来说，只能看到该公网地址。但由于2台终端开机的时间不一样，其报文中的TIMESTAMP选项值也不一样。因此，如果192.168.1.100的开机时间比192.168.1.101早，可能会出现192.168.1.100的连接关闭以后，192.168.1.101无法立即建立连接，因为后收到的syn报文的TIME_STAMP的值更小。在服务端来看，时间不可能倒流，那么新来的syn报文可能是个迟到的家伙，因此必然会被drop，192.168.1.101只能等一会才能建立连接(TCP_PAWS_MSL之后)。

如果192.168.1.100在频繁的连接建立、断开，192.168.1.101可能很久都无法连接的上。

4.4. 特殊国情

但我们的环境中，并不符合上述客户端在NAT里面的情况，而是反过来：master容器在NAT里面。

客户端访问virtual ip时，内核会做一次DNAT，将报文目的地址virtual ip转为master的ip，源地址不变。如果之后报文直接走cni0进入master容器，其实不会出现上面的问题：报文源地址是不同的。但由于kubernetes的缘故，报文在POSTROUTING阶段，还是会做一次SNAT(此处应该给生哥掌声)：

1Chain POSTROUTING (policy ACCEPT 6 packets, 360 bytes)
2 pkts bytes target     prot opt in     out     source               destination
36351K  563M KUBE-POSTROUTING  all  --  *      *       0.0.0.0/0            0.0.0.0/0            /* kubernetes postrouting rules */
4    0     0 MASQUERADE  all  --  *      !docker0  172.17.0.0/16        0.0.0.0/0
52601K  177M RETURN     all  --  *      *       10.244.0.0/16        10.244.0.0/16
6 102K 6466K MASQUERADE  all  --  *      *       10.244.0.0/16       !224.0.0.0/4
71248K   86M MASQUERADE  all  --  *      *      !10.244.0.0/16        10.244.0.0/16

即：若报文的源地址和目的地址一个是10.244.0.0/16网段，一个不是，则走MASQUERADE，即做一次SNAT。MASQUERADE表示源地址不静态指定，而是动态选择。

因此，从m1上发出的psql请求，在经过lvs的一次DNAT和POSTROUTING阶段的一次SNAT之后，报文的源地址和目的地址，从192.168.128.158->192.168.128.5，变为了10.244.3.1->10.244.3.27；而从vip容器发出的psql请求，其源地址和目的地址就是10.244.3.1->10.244.3.27。

悲剧就发生了。

由于vip容器所在的机器启动时间要晚一点，因此受害者总是它，也就是我们一开始所描述的vip容器去psql连接master容器超时，但从m1上访问总是没问题的现象。

btw:上面的lvs+iptables实现了FULLNAT的效果，可以不给内核打阿里的补丁。

5. 总结

tcp_tw_recycle这个选项在内核的文档里说明的比较含糊，但是有一句警告：

1Enable fast recycling TIME-WAIT sockets. Default value is 0. It should not be changed without advice/request of technical experts.

意思就是：特殊勤务，请勿靠近。

不过man 7 tcp里倒是挺干脆的提示:

1Enable fast recycling of TIME_WAIT sockets. Enabling this option is not recommended since this causes problems when working with NAT (Network Address Translation).

ref:

Coping with the TCP TIME-WAIT state on busy Linux servers

一个NAT问题引起的思考

TCP timestamp

strongSwan 配置实践

Mon, 03 Jun 2024 16:07:57 +0800

strongSwan，是一个完整的开源 IPsec VPN 解决方案，可以运行在 Linux、Windows 和 Mac OS X 上，此外，它还兼容基于 Android 和 iOS 的产品所支持的 IPsec 功能。

要注意的是，strongSwan 并不对 VPN 上的数据进行加密，而是由运行 strongSwan 的底层操作系统（比如 Linux）进行加密。strongSwan 负责使用网络密钥交换（internet key exchange, IKE）协议帮助同级协商用于对称加密的密钥。strongSwan 支持 IKEv1 和 IKEv2。IKE 允许对等体就加密所使用的加密参数达成一致，然后通过 Diffie-Hellman 密钥交换算法共同商定加密密钥。

IKEv1 于 1998 年发布，因为协议规格含糊不清，前后不一致，可能导致实施时容易受到各种安全攻击而最终受到批评。七年后，IKEv2 的规范发布，其中提出了一个有些简化和更可靠的协议版本。IKEv2 对 NAT 遍历、可扩展认证协议（extensible authentication protocol, EAP）、移动性和多宿主（mobility and multi-homing, MOBIKE）等功能也有更好的支持。

strongSwan 在一个叫 pluto 的服务中实现了 IKEv1，而 IKEv2 则由一个叫 charon 的服务提供。

1. Linux IPsec 支持

在 Linux 中有多个竞争性的 IPsec 协议栈，我们应该看看历史来了解它们之间的关系。1998年开始的 KAME 项目是第一个努力实现 IPv4 和 IPv6 的免费 IPsec 协议栈的项目。该项目的实施是为了 BSD UNIX 系统，但很快就作为 Linux 内核的补丁。大约在同一时间，John Gilmore（电子前沿基金会的创始人之一，因破解 DES 加密而闻名）启动了 FreeS/WAN 项目，旨在将 IPsec 引入 Linux。这也需要给 Linux 内核打补丁。FreeS/WAN 补丁被称为 Kernel IP Security（KLIPS）。

在这两种情况下(KAME 和 KLIPS)，都需要打补丁来允许在用户空间运行的 IKE 服务与内核空间的对应服务进行通信，以安装加密密钥和配置各种加密参数。

IETF 在 RFC 2367 中定义了 PF_KEYv2，作为标准 API，允许用户空间进程在操作系统内核中配置 IPsec。KAME 和 KLIPS 都使用了 PF_KEYv2。为每个内核版本维护 KAME 和 KLIPS 的补丁是很有挑战性的，因此决定在 Linux 2.6 内核系列中把 KAME 作为默认的 IPsec 协议栈。2.6 内核下的 KAME 实现被称为 NETKEY。然而，2.6 内核的特点是修改了协议栈，其中一个新特性是一个叫做 NETLINK 的协议。与 PF_KEYv2 不同，NETLINK 是一个通用的协议，它允许用户空间实体与内核的各个部分交换消息。例如，RT_NETLINK 是一个 NETLINK 扩展，它可以让动态路由进程在内核中安装或删除路由。同样，XFRM_NETLINK 9 允许 IKE 或其他用户进程管理内核中维护的 IPsec 安全关联数据库（Security Association Database, SAD）和安全策略数据库（Security Policy Database, SPD）。

2. 策略路由

strongSwan 使用了一种叫做策略路由的网络功能。这与 SPD 和 IPsec 使用的安全策略不同。正常的 IP 路由是基于 IP 头中的目标 IP 地址字段。启用 IP 转发的主机将为所有前往特定目的地的数据包选择相同的路径。这种情况并不总是可取的。策略路由的一个早期案例是支持不同客户类别的不同 QoS 级别。金牌客户为获得高吞吐量和低延迟服务而付费，而青铜客户则为更便宜的尽力服务而解决。为这些客户选择路由时，除其他外，还需要将源 IP 地址和目的地址作为 IP 路由过程的一部分。

Linux 策略路由的实现需要多个路由表和一个路由策略数据库（RPDB）。你可以通过输入以下命令列出 RPDB 中的策略：

1ip rule show

输出应该显示这样的内容：

10:     from all lookup local
2220:   from all lookup 220
332766: from all lookup main
432767: from all lookup default

最左边的一列显示了分配给同一行的策略路由规则的优先级。可用的规则从最高优先级（0）到最低优先级（32767）进行扫描，第一个匹配的规则会选择路由过程将使用的路由表来查找路由。一旦 RPDB 策略匹配，就会使用指定的表来查找下一跳。如果路由过程无法从规则所指示的路由表计算出数据包的下一跳，则继续处理到 RPDB 中的下一条规则。from 关键字表示对源 IP 地址的选择符，但由于也使用了 all ，所以表示所有数据包都会匹配。默认情况下，strongSwan 会插入一个优先级为 220 的策略规则。当 Ubuntu Linux 启动时，它会设置三个表：本地（id 255）、主（254）和默认（253）。本地路由表包含本地和广播地址的高优先级控制路由。这个表是供内核内部使用的，不应该从用户空间修改。主路由表是在没有指定表时使用的普通表。最后，默认表通常是空的，当没有其他表匹配时使用。

要在表中列出可用的路由（例如，local），使用以下命令之一：

1ip route list table local
2ip route list table 255

id 为 220 的表是由 strongSwan 创建的。它没有像上面三张表那样友好的名字。id 号的选择与 RPDB 中相应规则的优先级相匹配，便于识别策略规则与表之间的联系。所有由 strongSwan 创建的路由都会被插入到表 220 中。

3. 安装

1apt-get install strongswan

strongSwan 的主要配置文件是 /etc/ipsec.conf 和 /etc/ipsec.secrets 。

新版配置范例：https://wiki.strongswan.org/projects/strongswan/wiki/IKEv2Examples

老版配置范例：https://wiki.strongswan.org/projects/strongswan/wiki/IKEv2StrokeExamples

4. 实验环境

服务器 A 和客户机 A 各有一个只连接到 192.168.60.0/24 网络的主机接口。服务器 A 上的接口被分配的 IP 地址为 192.168.60.100 ，客户端 A 上的接口被分配的 IP 地址为 192.168.60.111 。为了使这个例子类似于现实中的例子，我们说服务器 A 和客户端 A 是站点 A 的一部分，站点 A “拥有” 网络192.168.60.0/24 。服务器 A 通过其 NAT 接口为网站 A 提供互联网访问。

相似的，服务器 B 上的网络接口被分配了 IP 地址 192.168.80.100 ，客户端 B 上的接口被分配了 IP 地址 192.168.80.111 。服务器 B 通过其 NAT 接口为 B 站点提供 Internet 访问。

服务器 A 和服务器 B 都有一个只连接到网络的二级主机接口 192.168.70.0/24 。服务器 A 的接口被分配的 IP 地址是 192.168.70.5 ，而服务器 B 的 IP 地址是 192.168.70.6 。您将配置服务器 A 和服务器 B 在 192.168.70.0/24 网络上建立 VPN 服务。

192.168.60.0/24 和 192.168.80.0/24 是私有网络，它们实际上将通过 “公共 “网络 192.168.70.0/24 连接。

5. 带 PSK 认证的 Host-to-Host Transport Mode 配置

Server A 的 ipsec.conf

 1# server A
 2# ipsec.conf - strongSwan IPsec configuration file
 3
 4# basic configuration
 5
 6config setup
 7      # strictcrlpolicy=yes
 8      # uniqueids = no
 9
10conn %default
11      ikelifetime=60m
12      keylife=20m
13      rekeymargin=3m
14      keyingtries=1
15      keyexchange=ikev2
16      mobike=no
17
18conn serverA-to-serverB
19      type=transport
20      authby=secret
21      left=192.168.70.5
22      leftsubnet=192.168.70.0/24
23      leftfirewall=yes
24      right=192.168.70.6
25      rightsubnet=192.168.70.0/24
26      auto=route

Server A 的 ipsec.secret

1# server A
2# This file holds shared secrets or RSA private keys for authentication.
3
4# RSA private key for this host, authenticating it to any other host
5# which knows the public part.
6
7192.168.70.5 192.168.70.6 : PSK "helloworld"

Server B 的 ipsec.conf

 1# server B
 2# ipsec.conf - strongSwan IPsec configuration file
 3
 4# basic configuration
 5
 6config setup
 7      # strictcrlpolicy=yes
 8      # uniqueids = no
 9
10conn %default
11      ikelifetime=60m
12      keylife=20m
13      rekeymargin=3m
14      keyingtries=1
15      keyexchange=ikev2
16      mobike=no
17
18conn serverB-to-serverA
19      type=transport
20      authby=secret
21      left=192.168.70.6
22      leftsubnet=192.168.70.0/24
23      leftfirewall=yes
24      right=192.168.70.5
25      rightsubnet=192.168.70.0/24
26      auto=route

Server B 的 ipsec.secret

1# server B
2# This file holds shared secrets or RSA private keys for authentication.
3
4# RSA private key for this host, authenticating it to any other host
5# which knows the public part.
6
7192.168.70.5 192.168.70.6 : PSK "helloworld"

您也可以在服务器 A 或服务器 B 上输入以下命令，要求 strongSwan 报告建立的连接：

1sudo ipsec statusall

6. 带证书认证的 Host-to-Host Transport Mode 配置

此处省略创建证书的过程。

教程可以参考：https://wiki.strongswan.org/projects/strongswan/wiki/SimpleCA

注意：strongSwan 不知道如何处理单个 PEM 文件中包含的证书链。相反，你需要将根 CA 和中间 CA 的单个证书复制到 strongSwan 的 CA 证书目录中。

Server A 的 ipsec.conf

 1# server A
 2# ipsec.conf - strongSwan IPsec configuration file
 3
 4# basic configuration
 5
 6config setup
 7      # strictcrlpolicy=yes
 8      # uniqueids = no
 9
10conn %default
11      ikelifetime=60m
12      keylife=20m
13      rekeymargin=3m
14      keyingtries=1
15      keyexchange=ikev2
16      mobike=no
17
18conn serverA-to-serverB
19      type=transport
20      left=192.168.70.5
21      leftcert=192.168.70.5.cert.pem
22      leftid=%fromcert
23      leftfirewall=yes
24      right=192.168.70.6
25      rightid="C=CN, ST=Beijing, L=Chaoyang, O=the masses, CN=192.168.70.6"
26      auto=route

Server A 的 ipsec.secret

1# server A
2# This file holds shared secrets or RSA private keys for authentication.
3
4# RSA private key for this host, authenticating it to any other host
5# which knows the public part.
6
7 : RSA 192.168.70.5.key.pem

Server B 的 ipsec.conf

 1# server B
 2# ipsec.conf - strongSwan IPsec configuration file
 3
 4# basic configuration
 5
 6config setup
 7      # strictcrlpolicy=yes
 8      # uniqueids = no
 9
10conn %default
11      ikelifetime=60m
12      keylife=20m
13      rekeymargin=3m
14      keyingtries=1
15      keyexchange=ikev2
16      mobike=no
17
18conn serverB-to-serverA
19      type=transport
20      left=192.168.70.6
21      leftcert=192.168.70.6.cert.pem
22      leftid=%fromcert
23      leftfirewall=yes
24      right=192.168.70.5
25      rightid="C=CN, ST=Beijing, L=Chaoyang, O=the masses, CN=192.168.70.5"
26      auto=route

Server B 的 ipsec.secret

1# server B
2# This file holds shared secrets or RSA private keys for authentication.
3
4# RSA private key for this host, authenticating it to any other host
5# which knows the public part.
6
7 : RSA 192.168.70.6.key.pem

配置完后需要重启强制 strongSwan 读取 CA 证书。

要列出已存在的 CA 证书，请输入命令：

1sudo ipsec listcacerts

7. 带证书认证的 Site-to-Site Tunnel Mode 配置

Server A 的 ipsec.conf

 1# server A
 2# ipsec.conf - strongSwan IPsec configuration file
 3
 4# basic configuration
 5
 6config setup
 7      # strictcrlpolicy=yes
 8      # uniqueids = no
 9
10conn %default
11      ikelifetime=60m
12      keylife=20m
13      rekeymargin=3m
14      keyingtries=1
15      keyexchange=ikev2
16
17conn serverA-to-serverB
18      left=192.168.70.5
19      leftcert=192.168.70.5.cert.pem
20      leftid=%fromcert
21      leftfirewall=yes
22      right=192.168.70.6
23      rightid="C=CN, ST=Beijing, L=Chaoyang, O=the masses, CN=192.168.70.6"
24      auto=route

Server A 的 ipsec.secret

1# server A
2# This file holds shared secrets or RSA private keys for authentication.
3
4# RSA private key for this host, authenticating it to any other host
5# which knows the public part.
6
7 : RSA 192.168.70.5.key.pem

Server B 的 ipsec.conf

 1# server B
 2# ipsec.conf - strongSwan IPsec configuration file
 3
 4# basic configuration
 5
 6config setup
 7      # strictcrlpolicy=yes
 8      # uniqueids = no
 9
10conn %default
11      ikelifetime=60m
12      keylife=20m
13      rekeymargin=3m
14      keyingtries=1
15      keyexchange=ikev2
16
17conn serverB-to-serverA
18      left=192.168.70.6
19      leftcert=192.168.70.6.cert.pem
20      leftid=%fromcert
21      leftfirewall=yes
22      right=192.168.70.5
23      rightid="C=CN, ST=Beijing, L=Chaoyang, O=the masses, CN=192.168.70.5"
24      auto=route

Server B 的 ipsec.secret

1# server B
2# This file holds shared secrets or RSA private keys for authentication.
3
4# RSA private key for this host, authenticating it to any other host
5# which knows the public part.
6
7 : RSA 192.168.70.6.key.pem

8. 带 IP 转发的 Site-to-Site Tunnel Mode 配置

在 Client A 上编辑 /etc/network/interfaces 并添加 gateway 192.168.60.100 。编辑 /etc/resolv.conf 并验证 nameserver 10.0.98.3 是 DNS 服务器。

在 Server A 上输入：

1sudo sysctl -w net.ipv4.ip_forward=1
2sudo sysctl -p
3sudo iptables -t nat -A POSTROUTING -j SNAT -o <interface> --to 10.0.98.100

在 Client B 上编辑 /etc/network/interfaces 并添加 gateway 192.168.80.100 。编辑 /etc/resolv.conf 并验证 nameserver 10.0.99.3 是 DNS 服务器。

在 Server B 上输入：

1sudo sysctl -w net.ipv4.ip_forward=1
2sudo sysctl -p
3sudo iptables -t nat -A POSTROUTING -j SNAT -o <interface> --to 10.0.99.100

Server A 的 ipsec.conf

 1# server A
 2# ipsec.conf - strongSwan IPsec configuration file
 3
 4# basic configuration
 5
 6config setup
 7      # strictcrlpolicy=yes
 8      # uniqueids = no
 9
10conn %default
11      ikelifetime=60m
12      keylife=20m
13      rekeymargin=3m
14      keyingtries=1
15      keyexchange=ikev2
16      mobike=no
17
18conn serverA-to-serverB
19      left=192.168.70.5
20      leftcert=192.168.70.5.cert.pem
21      leftsubnet=192.168.60.0/24
22      leftid=%fromcert
23      leftfirewall=yes
24      right=192.168.70.6
25      rightsubnet=192.168.80.0/24
26      rightid="C=CN, ST=Beijing, L=Chaoyang, O=the masses, CN=192.168.70.6"
27      auto=route

Server A 的 ipsec.secret

1# server A
2# This file holds shared secrets or RSA private keys for authentication.
3
4# RSA private key for this host, authenticating it to any other host
5# which knows the public part.
6
7 : RSA 192.168.70.5.key.pem

Server B 的 ipsec.conf

 1# server B
 2# ipsec.conf - strongSwan IPsec configuration file
 3
 4# basic configuration
 5
 6config setup
 7      # strictcrlpolicy=yes
 8      # uniqueids = no
 9
10conn %default
11      ikelifetime=60m
12      keylife=20m
13      rekeymargin=3m
14      keyingtries=1
15      keyexchange=ikev2
16      mobike=no
17
18conn serverB-to-serverA
19      left=192.168.70.6
20      leftcert=192.168.70.6.cert.pem
21      leftsubnet=192.168.80.0/24
22      leftid=%fromcert
23      leftfirewall=yes
24      right=192.168.70.5
25      rightsubnet=192.168.60.0/24
26      rightid="C=CN, ST=Beijing, L=Chaoyang, O=the masses, CN=192.168.70.5"
27      auto=route

9. iptables 中关于 IPSec 的设置

在默认为 DROP 的规则中，添加：

1# IKE negotiations
2iptables -A INPUT -p udp --sport 500 --dport 500 -j ACCEPT
3iptables -A OUTPUT -p udp --sport 500 --dport 500 -j ACCEPT
4# ESP encrypton and authentication
5iptables -A INPUT -p 50 -j ACCEPT
6iptables -A OUTPUT -p 50 -j ACCEPT

10. 参考

Linux策略性路由应用及分析iproute2

Mon, 03 Jun 2024 10:38:35 +0800

1. 策略性路由

策略性是指对于IP包的路由是以网络管理员根据需要定下的一些策略为主要依据进行路由的。例如我们可以有这样的策略：“所有来直自网A的包，选择X路径；其他选择Y路径”，或者是“所有TOS为A的包选择路径F；其他选者路径K”。

Cisco 的网络操作系统 (Cisco IOS) 从11.0开始就采用新的策略性路由机制。而Linux是在内核2.1开始采用策略性路由机制的。策略性路由机制与传统的路由算法相比主要是引入了多路由表以及规则的概念。

2. 多路由表（multiple Routing Tables）

传统的路由算法是仅使用一张路由表的。但是在有些情形底下，我们是需要使用多路由表的。例如一个子网通过一个路由器与外界相连，路由器与外界有两条线路相连，其中一条的速度比较快，一条的速度比较慢。对于子网内的大多数用户来说对速度并没有特殊的要求，所以可以让他们用比较慢的路由；但是子网内有一些特殊的用户却是对速度的要求比较苛刻，所以他们需要使用速度比较快的路由。如果使用一张路由表上述要求是无法实现的，而如果根据源地址或其它参数，对不同的用户使用不同的路由表，这样就可以大大提高路由器的性能。

3. 规则（rule）

规则是策略性的关键性的新的概念。我们可以用自然语言这样描述规则，例如我门可以指定这样的规则：

规则一：“所有来自192.16.152.24的IP包，使用路由表10，本规则的优先级别是1500”
规则二：“所有的包，使用路由表253，本规则的优先级别是32767”

我们可以看到，规则包含3个要素：

什么样的包，将应用本规则（所谓的SELECTOR，可能是filter更能反映其作用）；
符合本规则的包将对其采取什么动作（ACTION），例如用那个表；
本规则的优先级别。优先级别越高的规则越先匹配（数值越小优先级别越高）。

4. 策略性路由的配置方法

传统的linux下配置路由的工具是route，而实现策略性路由配置的工具是iproute2工具包。这个软件包是由Alexey Kuznetsov开发的，软件包所在的主要网址为ftp://ftp.inr.ac.ru/ip-routing/。

这里简单介绍策略性路由的配置方法，以便能更好理解第二部分的内容。详细的使用方法请参考Alexey Kuznetsov写的 ip-cfref文档。策略性路由的配置主要包括接口地址的配置、路由的配置、规则的配置。

5. 接口地址的配置IP Addr

对于接口的配置可以用下面的命令进行：

1Usage: ip addr [ add | del ] IFADDR dev STRING

例如：

1router># ip addr add 192.168.0.1/24 broadcast 192.168.0.255 label eth0 dev eth0

上面表示，给接口eth0赋予地址192.168.0.1 掩码是255.255.255.0(24代表掩码中1的个数)，广播地址是192.168.0.255

6. 路由的配置IP Route

Linux最多可以支持255张路由表，其中有3张表是内置的：

表255 本地路由表（Local table）本地接口地址，广播地址，已及NAT地址都放在这个表。该路由表由系统自动维护，管理员不能直接修改。
表254 主路由表（Main table）如果没有指明路由所属的表，所有的路由都默认都放在这个表里，一般来说，旧的路由工具（如route）所添加的路由都会加到这个表。一般是普通的路由。
表253 默认路由表（Default table）一般来说默认的路由都放在这张表，但是如果特别指明放的也可以是所有的网关路由。
表 0 保留

路由配置命令的格式如下：

1Usage: ip route list SELECTOR
2ip route { change | del | add | append | replace | monitor } ROUTE

如果想查看路由表的内容，可以通过命令：

1ip route list table table_number

对于路由的操作包括change、del、add 、append 、replace 、 monitor这些。例如添加路由可以用：

1router># ip route add 0/0 via 192.168.0.4 table main
2router># ip route add 192.168.3.0/24 via 192.168.0.3 table 1

第一条命令是向主路由表（main table）即表254添加一条路由，路由的内容是设置192.168.0.4成为网关。

第二条命令代表向路由表1添加一条路由，子网192.168.3.0（子网掩码是255.255.255.0）的网关是192.168.0.3。

在多路由表的路由体系里，所有的路由的操作，例如网路由表添加路由，或者在路由表里寻找特定的路由，需要指明要操作的路由表，所有没有指明路由表，默认是对主路由表（表254）进行操作。而在单表体系里，路由的操作是不用指明路由表的。

7. 规则的配置IP Rule

在Linux里，总共可以定义个优先级的规则，一个优先级别只能有一条规则，即理论上总共可以有条规则。其中有3个规则是默认的。命令用法如下：

1Usage: ip rule [ list | add | del ] SELECTOR ACTION
2SELECTOR := [ from PREFIX ] [ to PREFIX ] [ tos TOS ]
3[ dev STRING ] [ pref NUMBER ]
4ACTION := [ table TABLE_ID ] [ nat ADDRESS ]
5[ prohibit | reject | unreachable ]
6[ flowid CLASSID ]
7TABLE_ID := [ local | main | default | new | NUMBER

首先我们可以看看路由表默认的所有规则：

1root@netmonster# ip rule list
20: from all lookup local
332766: from all lookup main
432767: from all lookup default

其中：

规则0，它是优先级别最高的规则，规则规定，所有的包，都必须首先使用local表（254）进行路由。本规则不能被更改和删除。
规则32766，规定所有的包，使用表main进行路由。本规则可以被更改和删除。
规则32767，规定所有的包，使用表default进行路由。本规则可以被更改和删除。

在默认情况下进行路由时，首先会根据规则0在本地路由表里寻找路由，如果目的地址是本网络，或是广播地址的话，在这里就可以找到合适的路由；如果路由失败，就会匹配下一个不空的规则，在这里只有32766规则，在这里将会在主路由表里寻找路由;如果失败，就会匹配32767规则，即寻找默认路由表。如果失败，路由将失败。重这里可以看出，策略性路由是往前兼容的。

还可以添加规则：

1router># ip rule add [from 0/0] table 1 pref 32800
2router># ip rule add from 192.168.3.112/32 [tos 0x10] table 2 pref 1500 prohibit

第一条命令将向规则链增加一条规则，规则匹配的对象是所有的数据包，动作是选用路由表1的路由，这条规则的优先级是32800。

第二条命令将向规则链增加一条规则，规则匹配的对象是IP为192.168.3.112，tos等于0x10的包，使用路由表2，这条规则的优先级是1500，动作是prohibit。添加以后，我们可以看看系统规则的变化。

1router># ip rule
20: from all lookup local
31500 from 192.168.3.112/32 [tos 0x10] lookup 2
432766: from all lookup main
532767: from all lookup default
632800: from all lookup 1

上面的规则是以源地址为关键字，作为是否匹配的依据的。除了源地址外，还可以用以下的信息：

From – 源地址
To – 目的地址（这里是选择规则时使用，查找路由表时也使用）
Tos – IP包头的TOS（type of sevice）域
Dev – 物理接口
Fwmark – 防火墙参数

采取的动作除了指定表，还可以指定下面的动作：

Table 指明所使用的表
Nat 透明网关
Action prohibit 丢弃该包，并发送 COMM.ADM.PROHIITED的ICMP信息
Reject 单纯丢弃该包
Unreachable丢弃该包，并发送 NET UNREACHABLE的ICMP信息

8. 策略性路由的应用

8.1. 基于源地址选路（ Source-Sensitive Routing）

如果一个网络通过两条线路接入互联网，一条是比较快的ADSL，另外一条是比较慢的普通的调制解调器。这样的话，网络管理员既可以提供无差别的路由服务，也可以根据源地址的不同，使一些特定的地址使用较快的线路，而普通用户则使用较慢的线路，即基于源址的选路。

8.2. 根据服务级别选路（Quality of Service）

网络管理员可以根据IP报头的服务级别域，对于不同的服务要求可以分别对待对于传送速率、吞吐量以及可靠性的有不同要求的数据报根据网络的状况进行不同的路由。

8.3. 节省费用的应用

网络管理员可以根据通信的状况，让一些比较大的阵发性通信使用一些带宽比较高但是比较贵的路径一段短的时间，然后让基本的通信继续使用原来比较便宜的基本线路。例如，管理员知道，某一台主机与一个特定的地址通信通常是伴随着大量的阵发性通信的，那么网络管理员可以安排一些策略，使得这些主机使用特别的路由，这些路由是按需拨号，带宽比较高的线路，通信完成以后就停止使用，而普通的通信则不受影响。这样既提高网络的性能，又能节省费用。

根据网络交通的特征，网络管理员可以在不同的路径之间分配负荷实现负载平衡。

9. Linux下策略性路由的实现–RPDB（Routing　Policy DataBase）

在Linux下，策略性路由是由RPDB实现的。对于RPDB的内部机制的理解，可以加深对于策略性路由使用的理解。这里分析的是linux 2.4.18的RPDB实现的细节。主要的实现文件包括：

fib_hash.c
fib_rules.c
fib_sematic
fib_frontend.c
route.c

RDPB主要由多路由表和规则组成。路由表以及对其的操作和其对外的接口是整个RPDB的核心部分。路由表主要由table，zone，node这些主要的数据结构构成。对路由表的操作主要包含物理的操作以及语义的操作。路由表除了向IP层提供路由寻找的接口以外还必须与几个元素提供接口：与用户的接口（即更改路由）、proc的接口、IP层控制接口、以及和硬件的接口（网络接口的改变会导致路由表内容的改变）。处在RDPB的中心的规则，由规则选取表。IP层并不直接使用路由表，而是通过一个路由适配层,路由适配层提供为IP层提供高性能的路由服务。

9.1. 路由表（Fib Table）

9.1.1. 数据结构：

在整个策略性路由的框架里，路由表是最重要的的数据结构，我们在上面以及对路由表的概念和结构进行了清楚的说明。Linux里通过下面这些主要的数据结构进行实现的。

主要的数据结构	作用	位置
struct fib_table	路由表	ip_fib.h 116
struct fn_hash	路由表的哈希数据	fib_hash.c 104
struct fn_zone	zone域	fib_hash.c 85
struct fib_node	路由节点	fib_hash.c 68
struct fib_info	路由信息	ip_fib.h 57
struct fib_result	路由结果	ip_fib.h 86

数据结构之间的主要关系如下。路由表由路由表号以及路由表的操作函数指针还有表数据组成。这里需要注意的是，路由表结构里并不直接定义zone域，而是通过一个数据指针指向fn_hash。只有当zone里有数据才会连接到fn_zone_list里。（如图）

系统的所有的路由表由数组变量 fib_tables[RT_TABLE_MAX+1]维护，其中系统定义RT_TABLE_MAX为254，也就是说系统最大的路由表为255张，所有的路由表的操作都是对这个数组进行的。。同时系统还定义了三长路由表local_table; *main_table。

9.2. 路由表的操作：

Linux策略路由代码的主要部分是对路由表的操作。对于路由表的操作，物理操作是直观的和易于理解的。对于表的操作不外乎就是添加、删除、更新等的操作。还有一种操作，是所谓的语义操作，语义操作主要是指诸如计算下一条的地址，把节点转换为路由项，寻找指定信息的路由等。

9.2.1. 物理操作(operation)：

路由表的物理操作主要包括如下这些函数：

路由标操作	实现函数	位置
新建路由表删除路由表搜索路由表	fn_hash_lookup	fib_hash.c 269
插入路由到路由表	fn_hash_insert	fib_hash.c 341
删除路由表的路由	fn_hash_delete fn_hash_dump	fib_hash.c 433 fib_hash.c 614
更新路由表的路由	fn_hash_flush	fib_hash.c 729
显示路由表的路由信息	fn_hash_get_info	fib_hash.c 750
选择默认路由	fn_hash_select_default	fib_hash.c 842

9.2.2. 语义操作(semantics operation)：

语义操作并不涉及路由表整体框架的理解，而且，函数名也是不言自明的，所以请大家参考fib_semantics.c。

9.2.3. 接口(front end)

对于路由表接口的理解，关键在于理解那里有IP

首先是路由表于IP层的接口。路由在目前linux的意义上来说，最主要的还是IP层的路由，所以和IP层的的接口是最主要的接口。和ip层的衔接主要是向IP层提供寻找路由、路由控制、寻找指定ip的接口。

1Fil_lookup ip_rt_ioctl fib_frontend.c 286;" f ip_dev_find 145

Inet 路由表还必须提供配置接口，即用户直接操作路由的接口，例如增加和删除一条路由。当然在策略性路由里，还有规则的添加和删除。

1inet_rtm_delroute 351 inet_rtm_newroute 366 inet_check_attr 335

proc 　　在/proc/net/route里显示路由信息。

1fib_get_procinfo

9.2.4. 网络设备（net dev event）

路由是和硬件关联的，当网络设备启动或关闭的时候，必须通知路由表的管理程序，更新路由表的信息。

1fib_disable_ip 567 fib_inetaddr_event 575 fib_netdev_event

9.2.5. 内部维护（ magic）

　　上面我们提到，本地路由表（local table）的维护是由系统自动进行的。也就是说当用户为硬件设置IP地址等的时候，系统自动在本地路由表里添加本地接口地址以及广播地址。

1fib_magic 417 
2fib_add_ifaddr 459 
3fib_del_ifaddr 498

Rule 1、数据结构规则在fib_rules.c的52行里定义为 struct fib_rule。而RPDB里所有的路由是保存在101行的变量fib_rules里的，注意这个变量很关键，它掌管着所有的规则，规则的添加和删除都是对这个变量进行的。

2、系统定义规则： fib_rules被定义以后被赋予了三条默认的规则：默认规则，本地规则以及主规则。

u 本地规则

1local_rule 94 static struct fib_rule local_rule = { 
2    r_next: &main_rule, 
3    /下一条规则是主规则/ 
4    r_clntref: ATOMIC_INIT(2), r_table: RT_TABLE_LOCAL, 
5    /指向本地路由表/ 
6    r_action: RTN_UNICAST, 
7    /动作是返回路由/ 
8};

u 主规则

 1main_rule 86 static struct fib_rule main_rule = { 
 2    r_next: &default_rule,
 3    /下一条规则是默认规则/ 
 4    r_clntref: ATOMIC_INIT(2), 
 5    r_preference: 0x7FFE, 
 6    /默认规则的优先级32766/ 
 7    r_table: RT_TABLE_MAIN, 
 8    /指向主路由表/ 
 9    r_action: RTN_UNICAST, 
10    /动作是返回路由/
11};

u 默认规则

1default rule 79 static struct fib_rule default_rule = { 
2    r_clntref: ATOMIC_INIT(2), 
3    r_preference: 0x7FFF,
4    /默认规则的优先级32767/ 
5    r_table: RT_TABLE_DEFAULT,
6    /指默认路由表/ 
7    r_action: RTN_UNICAST,
8    /动作是返回路由/ 
9};

规则链的链头指向本地规则。

9.3. RPDB的中心函数fib_lookup

现在到了讨论RPDB的实现的的中心函数fib_lookup了。RPDB通过提供接口函数fib_lookup，作为寻找路由的入口点，在这里有必要详细讨论这个函数，下面是源代码：

 1int fib_lookup(const struct rt_key *key, struct fib_result *res)
 2{
 3	int err;
 4	struct fib_rule *r, *policy;
 5	struct fib_table *tb;
 6
 7	u32 daddr = key->dst;
 8	u32 saddr = key->src;
 9
10	read_lock(&fib_rules_lock);
11	for (r = fib_rules; r; r=r->r_next) {/*扫描规则链fib_rules里的每一条规则直到匹配为止*/
12		if (((saddr^r->r_src) & r->r_srcmask) ||
13				((daddr^r->r_dst) & r->r_dstmask) ||
14#ifdef CONFIG_IP_ROUTE_TOS
15				(r->r_tos && r->r_tos != key->tos) ||
16#endif
17#ifdef CONFIG_IP_ROUTE_FWMARK
18				(r->r_fwmark && r->r_fwmark != key->fwmark) ||
19#endif
20				(r->r_ifindex && r->r_ifindex != key->iif))
21			continue;/*以上为判断规则是否匹配，如果不匹配则扫描下一条规则，否则继续*/
22
23
24		switch (r->r_action) {/*好了，开始处理动作了*/
25			case RTN_UNICAST:/*没有设置动作*/
26			case RTN_NAT: /*动作nat ADDRESS*/
27				policy = r;
28				break;
29			case RTN_UNREACHABLE: /*动作unreachable*/
30				read_unlock(&fib_rules_lock);
31				return -ENETUNREACH;
32			default:
33			case RTN_BLACKHOLE:/* 动作reject */
34				read_unlock(&fib_rules_lock);
35				return -EINVAL;
36			case RTN_PROHIBIT:/* 动作prohibit */
37				read_unlock(&fib_rules_lock);
38				return -EACCES;
39		}
40		/*选择路由表*/
41		if ((tb = fib_get_table(r->r_table)) == NULL)
42			continue;
43		路由表里寻找指定的路由*/
44			err = tb->tb_lookup(tb, key, res);
45		if (err == 0) {/*命中目标*/
46			res->r = policy;
47			if (policy)
48				atomic_inc(&policy->r_clntref);
49			read_unlock(&fib_rules_lock);
50			return 0;
51		}
52		if (err < 0 && err != -EAGAIN) {/*路由失败*/
53			read_unlock(&fib_rules_lock);
54			return err;
55		}
56	}
57	read_unlock(&fib_rules_lock);
58	return -ENETUNREACH;
59}

上面的这段代码的思路是非常的清晰的。首先程序从优先级高到低扫描所有的规则，如果规则匹配，处理该规则的动作。如果是普通的路由寻址或者是nat地址转换的换，首先从规则得到路由表，然后对该路由表进行操作。这样RPDB终于清晰的显现出来了。

10. IP层路由适配（IP route）

　　路由表以及规则组成的系统，可以完成路由的管理以及查找的工作，但是为了使得IP层的路由工作更加的高效，linux的路由体系里，route.c里完成大多数IP层与RPDB的适配工作，以及路由缓冲（route cache）的功能。

10.1. 调用接口

　　IP层的路由接口分为发送路由接口以及接收路由接口：

10.1.1. 发送路由接口

　　IP层在发送数据时如果需要进行路由工作的时候，就会调用ip_route_out函数。这个函数在完成一些键值的简单转换以后，就会调用 ip_route_output_key函数，这个函数首先在缓存里寻找路由，如果失败就会调用 ip_route_output_slow，ip_route_output_slow里调用fib_lookup在路由表里寻找路由，如果命中，首先在缓存里添加这个路由，然后返回结果。

1ip_route_out route.h ip_route_output_key route.c 1984; 
2ip_route_output_slow route.c 1690;

10.1.2. 接收路由接口

IP层接到一个数据包以后，如果需要进行路由，就调用函数ip_route_input，ip_route_input现在缓存里寻找，如果失败则 ip_route_inpu调用ip_route_input_slow， ip_route_input_slow里调用fib_lookup在路由表里寻找路由，如果命中，首先在缓存里添加这个路由，然后返回结果。

1ip_route_input_slow route.c 1312;
2f ip_route_input route.c 1622;

f cache 路由缓存保存的是最近使用的路由。当IP在路由表进行路由以后，如果命中就会在路由缓存里增加该路由。同时系统还会定时检查路由缓存里的项目是否失效，如果失效则清除。

让LVS更持久

Mon, 03 Jun 2024 08:43:52 +0800

1. 综述

1. 综述

今天遇到了一个问题，客户端psql在连接Greenplum时，静置一段时间后(大约15分钟)，随便敲一条select * from xxx，psql没返回结果，而是返回了个提示信息：

psql: server closed the connection unexpectedly This probably means the server terminated abnormally before or while processing the request.

看上去是server端把连接关闭了。出问题的时候抓了下包，可以看到client向server发了一个query，但是server直接回了个RST报文，说明的确是server端主动分手关闭的连接。

但是才15分钟，server不应该关闭连接。由于client到server的连接中间还经过了一层lvs，所以我查了下lvs的表项：

1ipvs -l -c
2IPVS connection entries
3pro expire state       source             virtual               destination
4TCP 13:46  ESTABLISHED [client ip]:60718  [server vip]:postgres [docker ip]:postgres
5TCP 26:43  NONE        [client ip]:0      [server vip]:postgres [docker ip]:postgres

如果在client端再query一次，可以看到expire重新刷新为了15:00，query成功；如果client一直静置，可以看到expire一直递减，当expire递减为0时，该ESTABLISHED表项被清除，此时尝试query会失败，client弹出如上错误。

所以问题就比较明确了：LVS的会话表项老化删除后，psql client发过来的请求无人应答(并非连接建立阶段)，直接被kernel RST掉。

那么上面的15分钟是怎么来的呢？我们可以通过如下命令查看。

1ipvsadm -l --timeout
2Timeout (tcp tcpfin udp): 900 120 300

单位是秒，900正好是15分钟。

怎么修改呢？

1.1. ipvsadm设置timeout

可以用ipvsadm设置timeout时间。

1ipvsadm --set 7200 120 300

但ipvsadm有个问题是，如果机器重启了，这个配置也就丢了。当然可以再去写个service来保存，但又有点杀鸡用牛刀的感觉。有没有更好的方法呢？

1.2. keepalived设置lvs_timeouts

更好的做法是继续利用keepalived。读过不要开启tcp_tw_recycle 的同学知道，我们的vip是通过kube-keepalived-vip这个容器来做的，内核的lvs表项也是该容器下发的。

那么keepalived有没有个参数可以配置下，让keepalived启动的时候，告诉内核设置下tcp timeout时间呢？

答案是有的，虽然你可能从来没见有人配置过。

keepalived支持配置 lvs_timeouts (相信我，这可能是第一篇介绍如何配置该参数的blog)，配置方法如下：

1global_defs {
2  vrrp_version 3
3  vrrp_iptables KUBE-KEEPALIVED-VIP
4
5  lvs_timeouts tcp 7200 tcpfin 120 udp 300
6  lvs_sync_daemon <INTERFACE> <VRRP_INSTANCE>
7}

注意一定要配置lvs_sync_daemon ，否则lvs_timeouts不会真正下发给内核lvs。

lvs_timeouts 后面的tcpfin udp两个实际可以不配置。吐槽下，lvs_timeouts在keepalived中没文档介绍如何使用，我是从代码反推的。饶是如此，还是漏了lvs_sync_daemon。

1.3. persistence_timeout的用途

读者可能会问一个问题，平时我们看到的keepalived的persistence_timeout参数是做什么用的？

想一下这个情景：http一般是短连接，客户端a发送请求给了lvs，lvs根据负载均衡策略将请求转发给了realserver 1(rs1)；rs1也正确应答了，一个完整的流程。

紧接着，客户端a又发送了一个http请求给lvs，此时lvs应该转发给rs1还是rs2呢？如果给rs2，那么如果rs1和rs2的数据同步没有做好的话，极有可能会出现时序问题(例如你在rs1处付了款但是rs2不知道让你再付一遍)。

此时比较简单的做法，就是让lvs对于持续一定时间内的client过来的请求，均转发给同一个real server，这个就叫做lvs的persistence，这个时间就叫做persistence_timeout。

默认kube-keepalived-vip容器配置的persistence_timeout时间为1800，即30分钟。细心的读者可能看到文章开始处查看lvs表项时，有一条 NONE 的表项，这条表项就是用来记录persistence的。NONE表项的expire总是不会超过30分钟，expire会随着时间的流逝逐步递减，如果expire减为0，NONE表项会被老化删除掉。

在NONE表项还没有老化之前，所有该client ip的报文，都会被转发到同一个real server；当NONE表项老化之后，再有新的clinet ip过来请求，报文会根据配置的lvs负载均衡策略，重新选择一个real server。

需要注意的是，如果persistence_timeout配置的时间比上面配置的lvs_timeouts时间小，当NONE表项的expire为0超时的时候，如果ESTABLISHED表项还没有超时(expire不为0)，NONE表项会重新进入一个1分钟的老化阶段。这样，同一个client ip的报文还是会转发给同一个real server，防止连接还在的时候，报文被错误的转发给另一个后端。

1.4. 老化与重刷

NONE表项和ESTABLISHED表项的expire时间是怎么重新刷新的呢？

ESTABLISHED表项的expire重刷机制比较简单，只要该链路上有新报文，expire就会重刷重新计时。NONE表项的expire重刷机制不同，它是通过新建连接刷新的。

所以如果ESTABLISHED的连接一直有报文刷新expire的话，如果此时没有新连接建立，NONE表项的expire不会刷新，无论persistence_timeout和lvs_timeouts谁大谁小，都会出现上面的NONE表项1分钟缓刑的情况。

1.5. 应如何取值

那么应该如何配置persistence_timeout呢？你可能看过一些文章说这个超时时间最好配置成跟lvs_timeouts一致，当然这么配没什么问题，但其实二者没有必然的联系，lvs_timeouts想保护的是一个人(单一连接)，而persistence_timeout想保护的是一类人(源自统一client ip的连接)，根据实际情况将二者设置为不同值会更合理一些。

处于负载均衡的考虑，不建议将persistence_timeout配置的太大，这样可能会导致长时间client总是被转发到同一个real server。

而lvs_timeouts建议配置为 >7200。为什么呢？TCP的保活定时器默认时间是2小时，当保活定时器超时时：

如果client还正常跑着，TCP会发送探测报文，该报文刷新lvs ESTABLISHED表项，重置expire，TCP连接、lvs表项均继续存在
如果client已经挂了，此时TCP保活定时器超时，即使没有lvs的存在也会关闭TCP连接；将lvs_timeouts配置为稍大于7200的值，会给用户相同的体验，避免lvs表项太早老化引起用户不满。

Ipvs Connection Timeout

Mon, 03 Jun 2024 08:36:32 +0800

1. Issue

When TCP session is idle for more than 15 mins (900 secs), IPVS connection times out and gets cleared from the connection table.

There are two different timeouts — one for IPVS and another one for TCP.

Default IPVS timeout value:

ipvsadm -l –timeout
Timeout (tcp tcpfin udp): 900 120 300

Default TCP timeout value:

tcp_keepalive_time = 7200 (seconds)
tcp_keepalive_intvl = 75 (seconds)
tcp_keepalive_probes = 9 (number of probes) When IPVS timesout, it clears the connection from the table.

Sample issues:

https://github.com/moby/moby/issues/31208

2. Resolution

To fix the issue, the tcp_keepalive_time has to be set to less than 900 secs. Values between 600 to 800 are optimal.

To set the values are runtime:

1sysctl -w net.ipv4.tcp_keepalive_time=600

The above command is not persistent across reboots. To make the change persistent these values has to be put into the file sysctl.conf.

For the fix to be effective, application should enable the keepalive on the socket.

Example in C/C++:

1` /* Set the option active */ 
2optval = 1; 
3optlen = sizeof(optval); 
4if(setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, &optval, optlen) < 0)

From Linux kernel 4.13 onwards, sysctl default values can be modified per container basis. Container will not inherit changes from the host sysctl modified values.

Python Openpyxl

Fri, 31 May 2024 16:43:51 +0800

1. openpyxl是什么？

openpyxl是一个用于操作Excel文件的Python库，可以通过编写Python代码读取和写入Excel文件，实现对Excel文件的读取、操作和处理。它支持Excel 2007及其以后版本的.xlsx文件格式，并且具有较好的性能和灵活性，可以方便地进行Excel文件的处理和操作。openpyxl可以在Windows、Linux、macOS等多个平台上运行，同时也是一个开源的库

2. Openpyxl 使用步骤

1.安装openpyxl 要使用openpyxl，首先需要安装该库。在命令行中输入以下命令可以安装openpyxl：

1pip install openpyxl

2.导入openpyxl 安装openpyxl后，我们需要在Python脚本中导入它。以下是导入openpyxl的示例代码：

import openpyxl

创建新文件

在第一个示例中，我们使用openpyxl创建一个新的 xlsx 文件。

write_xlsx.py

 1#!/usr/bin/env python
 2
 3from openpyxl import Workbook
 4import time
 5
 6book = Workbook()
 7sheet = book.active
 8
 9sheet['A1'] = 56
10sheet['A2'] = 43
11
12now = time.strftime("%Y-%m-%d")
13sheet['A3'] = now
14
15book.save("sample.xlsx")

在示例中，我们创建一个新的 xlsx 文件。我们将数据写入三个单元格。

1from openpyxl import Workbook

从openpyxl模块，我们导入Workbook类。工作簿是文档所有其他部分的容器。

1book = Workbook()

我们创建一个新的工作簿。始终使用至少一个工作表创建一个工作簿。

1sheet = book.active

我们获得对活动工作表的引用。

1sheet['A1'] = 56
2sheet['A2'] = 43

我们将数值数据写入单元格 A1 和 A2。

1now = time.strftime("%Y-%m-%d")
2sheet['A3'] = now

我们将当前日期写入单元格 A3。

1book.save("sample.xlsx")

我们使用save()方法将内容写入sample.xlsx文件。

2.1. Openpyxl 写入单元格

写入单元格有两种基本方法：使用工作表的键（例如 A1 或 D3），或通过cell()方法使用行和列表示法。

write2cell.py

 1#!/usr/bin/env python
 2
 3from openpyxl import Workbook
 4
 5book = Workbook()
 6sheet = book.active
 7
 8sheet['A1'] = 1
 9sheet.cell(row=2, column=2).value = 2
10
11book.save('write2cell.xlsx')

在示例中，我们将两个值写入两个单元格。

1sheet['A1'] = 1

在这里，我们将数值分配给 A1 单元。

1sheet.cell(row=2, column=2).value = 2

在这一行中，我们用行和列表示法写入单元格 B2。

2.2. Openpyxl 附加值

使用append()方法，我们可以在当前工作表的底部附加一组值。

appending_values.py

 1#!/usr/bin/env python
 2
 3from openpyxl import Workbook
 4
 5book = Workbook()
 6sheet = book.active
 7
 8rows = (
 9    (88, 46, 57),
10    (89, 38, 12),
11    (23, 59, 78),
12    (56, 21, 98),
13    (24, 18, 43),
14    (34, 15, 67)
15)
16
17for row in rows:
18    sheet.append(row)
19
20book.save('appending.xlsx')

在示例中，我们将三列数据附加到当前工作表中。

1rows = (
2    (88, 46, 57),
3    (89, 38, 12),
4    (23, 59, 78),
5    (56, 21, 98),
6    (24, 18, 43),
7    (34, 15, 67)
8)

数据存储在元组的元组中。

1for row in rows:
2    sheet.append(row)

我们逐行浏览容器，并使用append()方法插入数据行。

2.3. OpenPyXL 读取单元格

在下面的示例中，我们从sample.xlsx文件中读取先前写入的数据。

read_cells.py

 1#!/usr/bin/env python
 2
 3import openpyxl
 4
 5book = openpyxl.load_workbook('sample.xlsx')
 6
 7sheet = book.active
 8
 9a1 = sheet['A1']
10a2 = sheet['A2']
11a3 = sheet.cell(row=3, column=1)
12
13print(a1.value)
14print(a2.value) 
15print(a3.value)

该示例加载一个现有的 xlsx 文件并读取三个单元格。

1book = openpyxl.load_workbook('sample.xlsx')

使用load_workbook()方法打开文件。

1a1 = sheet['A1']
2a2 = sheet['A2']
3a3 = sheet.cell(row=3, column=1)

我们读取 A1，A2 和 A3 单元的内容。在第三行中，我们使用cell()方法获取 A3 单元格的值。

1$ ./read_cells.py 
256
343
410/26/16

2.4. OpenPyXL 读取多个单元格

我们有以下数据表：

我们使用范围运算符读取数据。

read_cells2.py

 1#!/usr/bin/env python
 2
 3import openpyxl
 4
 5book = openpyxl.load_workbook('items.xlsx')
 6
 7sheet = book.active
 8
 9cells = sheet['A1': 'B6']
10
11for c1, c2 in cells:
12    print("{0:8} {1:8}".format(c1.value, c2.value))

在示例中，我们使用范围运算从两列读取数据。

1cells = sheet['A1': 'B6']

在这一行中，我们从单元格 A1-B6 中读取数据。

1for c1, c2 in cells:
2    print("{0:8} {1:8}".format(c1.value, c2.value))

format()功能用于在控制台上整洁地输出数据。

1$ ./read_cells2.py 
2Items    Quantity
3coins          23
4chairs          3
5pencils         5
6bottles         8
7books          30

2.5. Openpyxl 按行迭代

iter_rows()方法将工作表中的单元格返回为行。

iterating_by_rows.py

 1#!/usr/bin/env python
 2
 3from openpyxl import Workbook
 4
 5book = Workbook()
 6sheet = book.active
 7
 8rows = (
 9    (88, 46, 57),
10    (89, 38, 12),
11    (23, 59, 78),
12    (56, 21, 98),
13    (24, 18, 43),
14    (34, 15, 67)
15)
16
17for row in rows:
18    sheet.append(row)
19
20for row in sheet.iter_rows(min_row=1, min_col=1, max_row=6, max_col=3):
21    for cell in row:
22        print(cell.value, end=" ")
23    print()    
24
25book.save('iterbyrows.xlsx')

该示例逐行遍历数据。

1for row in sheet.iter_rows(min_row=1, min_col=1, max_row=6, max_col=3):

我们提供了迭代的边界。

1$ ./iterating_by_rows.py 
288 46 57 
389 38 12 
423 59 78 
556 21 98 
624 18 43 
734 15 67

3. Openpyxl 按列迭代

iter_cols()方法将工作表中的单元格作为列返回。

iterating_by_columns.py

 1#!/usr/bin/env python
 2
 3from openpyxl import Workbook
 4
 5book = Workbook()
 6sheet = book.active
 7
 8rows = (
 9    (88, 46, 57),
10    (89, 38, 12),
11    (23, 59, 78),
12    (56, 21, 98),
13    (24, 18, 43),
14    (34, 15, 67)
15)
16
17for row in rows:
18    sheet.append(row)
19
20for row in sheet.iter_cols(min_row=1, min_col=1, max_row=6, max_col=3):
21    for cell in row:
22        print(cell.value, end=" ")
23    print()    
24
25book.save('iterbycols.xlsx')

该示例逐列遍历数据。

1$ ./iterating_by_columns.py 
288 89 23 56 24 34 
346 38 59 21 18 15 
457 12 78 98 43 67

4. Openpyxl 复制工作表

 1import openpyxl
 2
 3workbook = openpyxl.load_workbook('example.xlsx')
 4
 5# 复制工作表
 6copied_sheet = workbook.copy_worksheet(workbook['Sheet1'])
 7copied_sheet.title = 'Copy of Sheet1'
 8
 9# 保存工作簿
10workbook.save('example_with_copy.xlsx')

5. Openpyxl 统计

对于下一个示例，我们需要创建一个包含数字的 xlsx 文件。例如，我们使用RANDBETWEEN()函数在 10 列中创建了 25 行数字。

mystats.py

  1#!/usr/bin/env python
  2
  3import random
  4import openpyxl
  5import statistics as stats
  6
  7# book = openpyxl.Workbook()
  8
  9# sheet = book.active
 10
 11# rows = (
 12
 13# (
 14
 15# random.randint(20, 100),
 16
 17# random.randint(20, 100),
 18
 19# random.randint(20, 100),
 20
 21# random.randint(20, 100),
 22
 23# random.randint(20, 100),
 24
 25# random.randint(20, 100),
 26
 27# ),
 28
 29# (
 30
 31# random.randint(20, 100),
 32
 33# random.randint(20, 100),
 34
 35# random.randint(20, 100),
 36
 37# random.randint(20, 100),
 38
 39# random.randint(20, 100),
 40
 41# random.randint(20, 100),
 42
 43# ),
 44
 45# (
 46
 47# random.randint(20, 100),
 48
 49# random.randint(20, 100),
 50
 51# random.randint(20, 100),
 52
 53# random.randint(20, 100),
 54
 55# random.randint(20, 100),
 56
 57# random.randint(20, 100),
 58
 59# ),
 60
 61# (
 62
 63# random.randint(20, 100),
 64
 65# random.randint(20, 100),
 66
 67# random.randint(20, 100),
 68
 69# random.randint(20, 100),
 70
 71# random.randint(20, 100),
 72
 73# random.randint(20, 100),
 74
 75# ),
 76
 77# (
 78
 79# random.randint(20, 100),
 80
 81# random.randint(20, 100),
 82
 83# random.randint(20, 100),
 84
 85# random.randint(20, 100),
 86
 87# random.randint(20, 100),
 88
 89# random.randint(20, 100),
 90
 91# ),
 92
 93# (
 94
 95# random.randint(20, 100),
 96
 97# random.randint(20, 100),
 98
 99# random.randint(20, 100),
100
101# random.randint(20, 100),
102
103# random.randint(20, 100),
104
105# random.randint(20, 100),
106
107# ),
108
109# (
110
111# random.randint(20, 100),
112
113# random.randint(20, 100),
114
115# random.randint(20, 100),
116
117# random.randint(20, 100),
118
119# random.randint(20, 100),
120
121# random.randint(20, 100),
122
123# ),
124
125# (
126
127# random.randint(20, 100),
128
129# random.randint(20, 100),
130
131# random.randint(20, 100),
132
133# random.randint(20, 100),
134
135# random.randint(20, 100),
136
137# random.randint(20, 100),
138
139# ),
140
141# (
142
143# random.randint(20, 100),
144
145# random.randint(20, 100),
146
147# random.randint(20, 100),
148
149# random.randint(20, 100),
150
151# random.randint(20, 100),
152
153# random.randint(20, 100),
154
155# ),
156
157# (
158
159# random.randint(20, 100),
160
161# random.randint(20, 100),
162
163# random.randint(20, 100),
164
165# random.randint(20, 100),
166
167# random.randint(20, 100),
168
169# random.randint(20, 100),
170
171# ),
172
173# (
174
175# random.randint(20, 100),
176
177# random.randint(20, 100),
178
179# random.randint(20, 100),
180
181# random.randint(20, 100),
182
183# random.randint(20, 100),
184
185# random.randint(20, 100),
186
187# ),
188
189# )
190
191  
192
193# for row in rows:
194
195# sheet.append(row)
196
197# book.save("numbers.xlsx")
198
199book = openpyxl.load_workbook("numbers.xlsx", data_only=True)
200sheet = book.active
201  
202rows = sheet.rows
203values = []
204
205for row in rows:
206for cell in row:
207values.append(cell.value)
208print("Number of values: {0}".format(len(values)))
209print("Sum of values: {0}".format(sum(values)))
210print("Minimum value: {0}".format(min(values)))
211print("Maximum value: {0}".format(max(values)))
212print("Mean: {0}".format(stats.mean(values)))
213print("Median: {0}".format(stats.median(values)))
214print("Standard deviation: {0}".format(stats.stdev(values)))
215print("Variance: {0}".format(stats.variance(values)))

在示例中，我们从工作表中读取所有值并计算一些基本统计信息。

1import statistics as stats

导入statistics模块以提供一些统计功能，例如中值和方差。

1book = openpyxl.load_workbook('numbers.xlsx', data_only=True)

使用data_only选项，我们从单元格而不是公式中获取值。

1rows = sheet.rows

我们得到所有不为空的单元格行。

1for row in rows:
2    for cell in row:
3        values.append(cell.value)

在两个 for 循环中，我们从单元格中形成一个整数值列表。

1print("Number of values: {0}".format(len(values)))
2print("Sum of values: {0}".format(sum(values)))
3print("Minimum value: {0}".format(min(values)))
4print("Maximum value: {0}".format(max(values)))
5print("Mean: {0}".format(stats.mean(values)))
6print("Median: {0}".format(stats.median(values)))
7print("Standard deviation: {0}".format(stats.stdev(values)))
8print("Variance: {0}".format(stats.variance(values)))

我们计算并打印有关值的数学统计信息。一些功能是内置的，其他功能是通过statistics模块导入的。

1$ ./mystats.py 
2Number of values: 312
3Sum of values: 15877
4Minimum value: 0
5Maximum value: 100
6Mean: 50.88782051282051
7Median: 54.0
8Standard deviation: 28.459203819700967
9Variance: 809.9262820512821

5.1. Openpyxl 过滤器&排序数据

工作表具有auto_filter属性，该属性允许设置过滤条件和排序条件。

请注意，Openpyxl 设置了条件，但是我们必须在电子表格应用中应用它们。

filter_sort.py

 1#!/usr/bin/env python
 2
 3from openpyxl import Workbook
 4
 5wb = Workbook()
 6sheet = wb.active
 7
 8data = [
 9    ['Item', 'Colour'],
10    ['pen', 'brown'],
11    ['book', 'black'],
12    ['plate', 'white'],
13    ['chair', 'brown'],
14    ['coin', 'gold'],
15    ['bed', 'brown'],
16    ['notebook', 'white'],
17]
18
19for r in data:
20    sheet.append(r)
21
22sheet.w.ref = 'A1:B8'
23sheet.auto_filter.add_filter_column(1, ['brown', 'white'])
24sheet.auto_filter.add_sort_condition('B2:B8')
25
26wb.save('filtered.xlsx')

在示例中，我们创建一个包含项目及其颜色的工作表。我们设置一个过滤器和一个排序条件。

6. Openpyxl 维度

为了获得那些实际包含数据的单元格，我们可以使用维度。

dimensions.py

 1#!/usr/bin/env python
 2
 3from openpyxl import Workbook
 4
 5book = Workbook()
 6sheet = book.active
 7sheet["A3"] = 39
 8sheet["B3"] = 19
 9sheet["C3"] = 19
10sheet["D3"] = 19
11
12print(sheet.dimensions)
13print("Minimum row: {0}".format(sheet.min_row))
14print("Maximum row: {0}".format(sheet.max_row))
15print("Minimum column: {0}".format(sheet.min_column))
16print("Maximum column: {0}".format(sheet.max_column))
17
18rows = [
19
20(88, 46, 46, 46),
21(89, 38, 38, 38),
22(23, 59, 59, 59),
23(56, 21, 21, 21),
24(24, 18, 18, 18),
25(34, 15, 15, 15),
26]
27
28  
29
30for row in rows:
31
32sheet.append(row)
33
34print(sheet.dimensions)
35print("Minimum row: {0}".format(sheet.min_row))
36print("Maximum row: {0}".format(sheet.max_row))
37print("Minimum column: {0}".format(sheet.min_column))
38print("Maximum column: {0}".format(sheet.max_column))
39
40for c1, c2, c3, c4 in sheet[sheet.dimensions]:
41print(c1.value, c2.value, c3.value, c4.value)
42
43book.save("dimensions.xlsx")

A3:D3
Minimum row: 3
Maximum row: 3
Minimum column: 1
Maximum column: 4

A3:D9
Minimum row: 3
Maximum row: 9
Minimum column: 1
Maximum column: 4
39 19 19 19
88 46 46 46
89 38 38 38
23 59 59 59
56 21 21 21
24 18 18 18
34 15 15 15

该示例计算两列数据的维数。

 1sheet['A3'] = 39
 2sheet['B3'] = 19
 3
 4rows = [
 5    (88, 46),
 6    (89, 38),
 7    (23, 59),
 8    (56, 21),
 9    (24, 18),
10    (34, 15)
11]
12
13for row in rows:
14    sheet.append(row)

我们将数据添加到工作表。请注意，我们从第三行开始添加。

1sheet['A3'] = 39
2sheet['B3'] = 19

1print(sheet.dimensions)

dimensions属性返回非空单元格区域的左上角和右下角单元格。

1print("Minimum row: {0}".format(sheet.min_row))
2print("Maximum row: {0}".format(sheet.max_row))

使用min_row和max_row属性，我们可以获得包含数据的最小和最大行。

1print("Minimum column: {0}".format(sheet.min_column))
2print("Maximum column: {0}".format(sheet.max_column))

1sheet["A3"] = 39
2sheet["B3"] = 19
3sheet["C3"] = 19
4sheet["D3"] = 19
5
6print(sheet.dimensions)
7print("Minimum column: {0}".format(sheet.min_column))
8print("Maximum column: {0}".format(sheet.max_column))s

通过min_column和max_column属性，我们获得了包含数据的最小和最大列。

1for c1, c2 in sheet[sheet.dimensions]:
2    print(c1.value, c2.value)

我们遍历数据并将其打印到控制台。

 1$ ./dimensions.py 
 2A3:B9
 3Minimum row: 3
 4Maximum row: 9
 5Minimum column: 1
 6Maximum column: 2
 739 19
 888 46
 989 38
1023 59
1156 21
1224 18
1334 15

7. Openpyxl 工作表

每个工作簿可以有多个工作表。

让手动创建一张包含这三张纸的工作簿。

sheets.py

 1#!/usr/bin/env python
 2
 3import openpyxl
 4
 5book = openpyxl.load_workbook("sheets.xlsx")
 6print(book.sheetnames)
 7active_sheet = book.active
 8print(type(active_sheet))
 9sheet = book["March"]
10print(sheet.title)

该程序可用于 Excel 工作表。

1print(book.sheetnames)

sheetnames 返回工作簿中可用工作表的名称。

1active_sheet = book.active
2print(type(active_sheet))

我们获取活动表并将其类型打印到终端。

1sheet = book["March"]

我们使用book[“March”]获得对工作表的引用。

1print(sheet.title)

检索到的工作表的标题将打印到终端。

1$ ./sheets.py 
2['January', 'February', 'March']
3
4<class 'openpyxl.worksheet.worksheet.Worksheet'>
5
6March

这是程序的输出。

sheets2.py

 1#!/usr/bin/env python
 2
 3import openpyxl
 4
 5book = openpyxl.load_workbook("sheets.xlsx")
 6book.create_sheet("April")
 7print(book.sheetnames)
 8
 9sheet1 = book["January"]
10book.remove(sheet1)
11print(book.sheetnames)
12  
13book.create_sheet("January", 0)
14print(book.sheetnames)
15book.save("sheets2.xlsx")

在此示例中，我们创建一个新工作表。

1book.create_sheet("April")

使用create_sheet()方法创建一个新工作表。

1print(book.sheetnames)

工作表名称也可以使用sheetnames属性显示。

1book.remove(sheet1)

可以使用remove()方法将工作表删除。

1book.create_sheet("January", 0)

可以在指定位置创建一个新工作表。在我们的例子中，我们在索引为 0 的位置创建一个新工作表。

1$ ./sheets2.py 
2['January', 'February', 'March', 'April']
3['February', 'March', 'April']
4['January', 'February', 'March', 'April']

可以更改工作表的背景颜色。

sheets3.py

 1#!/usr/bin/env python
 2
 3import openpyxl
 4
 5book = openpyxl.load_workbook('sheets.xlsx')
 6
 7sheet = book["March"]
 8sheet.sheet_properties.tabColor = "0072BA"
 9
10book.save('sheets3.xlsx')

该示例修改了标题为“ March”的工作表的背景颜色。

1sheet.sheet_properties.tabColor = "0072BA"

我们将tabColor属性更改为新颜色。第三工作表的背景色已更改为某种蓝色。

7.1. Openpyxl 合并单元格

单元格可以使用merge_cells()方法合并，而可以不使用unmerge_cells()方法合并。当我们合并单元格时，除了左上角的所有单元格都将从工作表中删除。

merging_cells.py

 1#!/usr/bin/env python
 2
 3from openpyxl import Workbook
 4from openpyxl.styles import Alignment
 5
 6book = Workbook()
 7sheet = book.active
 8sheet["A1"] = "Weather"
 9sheet["B1"] = "Temperature"
10sheet["A2"] = "Sunny day"
11sheet["B2"] = "25°C"
12
13sheet.merge_cells('A1:B2')
14
15cell = sheet.cell(row=1, column=1)
16cell.value = 'Sunny day'
17cell.alignment = Alignment(horizontal='center', vertical='center')
18
19book.save('merging.xlsx')

在该示例中，我们合并了四个单元格：A1，B1，A2 和 B2。最后一个单元格中的文本居中。

1from openpyxl.styles import Alignment

为了使文本在最后一个单元格中居中，我们使用了openpyxl.styles模块中的Alignment类。

1sheet.merge_cells('A1:B2')

我们用merge_cells()方法合并四个单元格。

1cell = sheet.cell(row=1, column=1)

我们得到了最后一个单元格。

1cell.value = 'Sunny day'
2cell.alignment = Alignment(horizontal='center', vertical='center')

我们将文本设置为合并的单元格并更新其对齐方式。

8. Openpyxl 冻结窗格

冻结窗格时，在滚动到工作表的另一个区域时，我们会保持工作表的某个区域可见。

freezing.py

 1#!/usr/bin/env python
 2
 3from openpyxl import Workbook
 4from openpyxl.styles import Alignment
 5
 6book = Workbook()
 7sheet = book.active
 8
 9	sheet.freeze_panes = 'B2'
10
11book.save('freezing.xlsx')

该示例通过单元格 B2 冻结窗格。

1sheet.freeze_panes = 'B2'

要冻结窗格，我们使用freeze_panes属性。

9. Openpyxl 公式

下一个示例显示如何使用公式。 openpyxl不进行计算；它将公式写入单元格。

formulas.py

 1#!/usr/bin/env python
 2
 3from openpyxl import Workbook
 4
 5book = Workbook()
 6sheet = book.active
 7
 8rows = (
 9    (34, 26),
10    (88, 36),
11    (24, 29),
12    (15, 22),
13    (56, 13),
14    (76, 18)
15)
16
17for row in rows:
18    sheet.append(row)
19
20cell = sheet.cell(row=7, column=2)
21cell.value = "=SUM(A1:B6)"
22cell.font = cell.font.copy(bold=True)
23
24book.save('formulas.xlsx')

在示例中，我们使用SUM()函数计算所有值的总和，并以粗体显示输出样式。

 1rows = (
 2    (34, 26),
 3    (88, 36),
 4    (24, 29),
 5    (15, 22),
 6    (56, 13),
 7    (76, 18)
 8)
 9
10for row in rows:
11    sheet.append(row)

我们创建两列数据。

1cell = sheet.cell(row=7, column=2)

我们得到显示计算结果的单元格。

1cell.value = "=SUM(A1:B6)"

我们将一个公式写入单元格。

1cell.font = cell.font.copy(bold=True)

我们更改字体样式。

10. OpenPyXL 图片

在下面的示例中，我们显示了如何将图像插入到工作表中。

write_image.py

 1#!/usr/bin/env python
 2
 3from openpyxl import Workbook
 4from openpyxl.drawing.image import Image
 5
 6book = Workbook()
 7sheet = book.active
 8
 9img = Image("icesid.png")
10sheet['A1'] = 'This is Sid'
11
12sheet.add_image(img, 'B2')
13
14book.save("sheet_image.xlsx")

在示例中，我们将图像写到工作表上。

1from openpyxl.drawing.image import Image

我们使用openpyxl.drawing.image模块中的Image类。

1img = Image("icesid.png")

创建一个新的Image类。 icesid.png图像位于当前工作目录中。

1sheet.add_image(img, 'B2')

我们使用add_image()方法添加新图像。

10.1. Openpyxl 图表

openpyxl库支持创建各种图表，包括条形图，折线图，面积图，气泡图，散点图和饼图。

根据文档，openpyxl仅支持在工作表中创建图表。现有工作簿中的图表将丢失。

create_bar_chart.py

 1#!/usr/bin/env python
 2
 3from openpyxl import Workbook
 4from openpyxl.chart import (
 5    Reference,
 6    Series,
 7    BarChart
 8)
 9
10book = Workbook()
11sheet = book.active
12
13rows = [
14    ("USA", 46),
15    ("China", 38),
16    ("UK", 29),
17    ("Russia", 22),
18    ("South Korea", 13),
19    ("Germany", 11)
20]
21
22for row in rows:
23    sheet.append(row)
24
25data = Reference(sheet, min_col=2, min_row=1, max_col=2, max_row=6)
26categs = Reference(sheet, min_col=1, min_row=1, max_row=6)
27
28chart = BarChart()
29chart.add_data(data=data)
30chart.set_categories(categs)
31
32chart.legend = None
33chart.y_axis.majorGridlines = None
34chart.varyColors = True
35chart.title = "Olympic Gold medals in London"
36
37sheet.add_chart(chart, "A8")    
38
39book.save("bar_chart.xlsx")

在此示例中，我们创建了一个条形图，以显示 2012 年伦敦每个国家/地区的奥运金牌数量。

1from openpyxl.chart import (
2    Reference,
3    Series,
4    BarChart
5)

openpyxl.chart模块具有使用图表的工具。

1book = Workbook()
2sheet = book.active

创建一个新的工作簿。

 1rows = [
 2    ("USA", 46),
 3    ("China", 38),
 4    ("UK", 29),
 5    ("Russia", 22),
 6    ("South Korea", 13),
 7    ("Germany", 11)
 8]
 9
10for row in rows:
11    sheet.append(row)

我们创建一些数据并将其添加到活动工作表的单元格中。

1data = Reference(sheet, min_col=2, min_row=1, max_col=2, max_row=6)

对于Reference类，我们引用表中代表数据的行。在我们的案例中，这些是奥运金牌的数量。

1categs = Reference(sheet, min_col=1, min_row=1, max_row=6)

我们创建一个类别轴。类别轴是将数据视为一系列非数字文本标签的轴。在我们的案例中，我们有代表国家名称的文本标签。

1chart = BarChart()
2chart.add_data(data=data)
3chart.set_categories(categs)

我们创建一个条形图并为其设置数据和类别。

1chart.legend = None
2chart.y_axis.majorGridlines = None

使用legend和majorGridlines属性，可以关闭图例和主要网格线。

1chart.varyColors = True

将varyColors设置为True，每个条形都有不同的颜色。

1chart.title = "Olympic Gold medals in London"

为图表设置标题。

1sheet.add_chart(chart, "A8")

使用add_chart()方法将创建的图表添加到工作表中。

10.2. Openpyxl 如何拷贝一个工作表到别一个工作表

 1# importing openpyxl module`
 2
 3mport openpyxl as xl;
 4
 5# opening the source excel file
 6
 7filename ="C:\\Users\\Admin\\Desktop\\trading.xlsx"
 8
 9wb1 = xl.load_workbook(filename)
10
11ws1 = wb1.worksheets[0]
12
13# opening the destination excel file 
14
15filename1 ="C:\\Users\\Admin\\Desktop\\test.xlsx"
16
17wb2 = xl.load_workbook(filename1)
18
19ws2 = wb2.active
20
21# calculate total number of rows and 
22
23# columns in source excel file
24
25mr = ws1.max_row
26
27mc = ws1.max_column
28
29# copying the cell values from source 
30
31# excel file to destination excel file
32
33for i in range (1, mr + 1):
34
35	for j in range (1, mc + 1):
36	
37		# reading cell value from source excel file
38		
39		c = ws1.cell(row = i, column = j)
40		
41		# writing the read value to destination excel file
42		
43		ws2.cell(row = i, column = j).value = c.value
44
45# saving the destination excel file
46
47wb2.save(str(filename1))

如何衡量云硬盘的性能

Thu, 07 Sep 2023 09:46:10 +0800

操作前须知（重要）

警告

本文使用 FIO 作为测试工具，请不要在系统盘上进行 FIO 测试，避免损坏系统重要文件。
为避免底层文件系统元数据损坏导致数据损坏，请不要在业务数据盘上进行测试。请使用测试机器未存放业务数据的云硬盘进行压测，并提前创建快照保障您的数据安全。
请确保/etc/fstab文件配置项中没有被测硬盘的挂载配置，否则将导致云服务器启动失败。

衡量指标

各类云提供的块存储设备根据类型的不同拥有不同的性能和价格，详细信息请参见云硬盘类型。由于不同应用程序的工作负载不同，若未提供足够的 I/O 请求来充分利用云硬盘时，可能无法达到云硬盘的最大性能。

一般使用以下指标衡量云硬盘的性能：

IOPS：每秒读/写次数，单位为次（计数）。存储设备的底层驱动类型决定了不同的 IOPS。
吞吐量：每秒的读写数据量，单位为MB/s。
时延：I/O 操作的发送时间到接收确认所经过的时间，单位为微秒。

测试工具

FIO 是测试磁盘性能的工具，用来对硬件进行压力测试和验证，本文以 FIO 为例。使用 FIO 时，建议配合使用 libaio 的 I/O 引擎进行测试。请参见工具安装完成 FIO 和 libaio 的安装。

测试对象建议

建议在空闲的、未保存重要数据的硬盘上进行 FIO 测试，并在测试完后重新制作被测硬盘的文件系统。
测试硬盘性能时，建议直接测试裸数据盘（如 /dev/vdb）。
测试文件系统性能时，推荐指定具体文件测试（如 /data/file）。

工具安装

本文以 CentOS 7.6 操作系统的云服务器为例。
执行以下命令，查看云硬盘是否4KiB对齐。

1fdisk -lu

如下图所示，若返回结果中的 Start 值能被8整除即是4KiB对齐。否则请完成4KiB对齐后再进行测试。

依次执行以下命令，安装测试工具 FIO 和 libaio。

1yum install libaio libaio-devel fio -y

安装完成后，请参见测试示例开始云硬盘性能测试。

测试示例

不同场景的测试公式基本一致，只有 rw、iodepth 和 bs（block size）三个参数的区别。例如，每个工作负载适合最佳 iodepth 不同，取决于您的特定应用程序对于 IOPS 和延迟的敏感程度。参数说明：

参数名	说明	取值样例
bs	每次请求的块大小。取值包括4k、8k及16k等。	4k
ioengine	I/O 引擎。推荐使用 Linux 的异步 I/O 引擎。	libaio
iodepth	请求的 I/O 队列深度。	1
direct	指定 direct 模式。True（1）表示指定 O_DIRECT 标识符，忽略 I/O 缓存，数据直写。False（0）表示不指定 O_DIRECT 标识符。默认为 True（1）。	1
read	读写模式。取值包括顺序读（read）、顺序写（write）、随机读（randread）、随机写（randwrite）、混合随机读写（randrw）和混合顺序读写（rw，readwrite）。	read
time_based	指定采用时间模式。无需设置该参数值，只要 FIO 基于时间来运行。	N/A
runtime	指定测试时长，即 FIO 运行时长。	100
refill_buffers	FIO 将在每次提交时重新填充 I/O 缓冲区。默认设置是仅在初始时填充并重用该数据。	N/A
norandommap	在进行随机 I/O 时，FIO 将覆盖文件的每个块。若给出此参数，则将选择新的偏移量而不查看 I/O 历史记录。	N/A
randrepeat	随机序列是否可重复，True（1）表示随机序列可重复，False（0）表示随机序列不可重复。默认为 True（1）。	0
group_reporting	多个 job 并发时，打印整个 group 的统计值。	N/A
name	job 的名称。	fio-read
size	I/O 测试的寻址空间。	1G
filename	测试对象，即待测试的磁盘设备名称。	/dev/sdb
numjobs	并发线程数，默认为1。当被测试硬盘性能较高时推荐加大numjobs数（如2或4等）以增加压力。	1

常见用例如下：

bs = 4k iodepth = 1：随机读/写测试，能反映硬盘的时延性能

1fio -bs=4k -ioengine=libaio -iodepth=1 -numjobs=1 -direct=1 -rw=randread -time_based -runtime=600 -refill_buffers -norandommap -randrepeat=0 -group_reporting -name=fio-randread-lat -size=10G -filename=/dev/vdb

执行以下命令，测试硬盘的随机写时延。

注意

执行命令前请务必做好快照。

1fio -bs=4k -ioengine=libaio -iodepth=1 -numjobs=1 -direct=1 -rw=randwrite -time_based -runtime=600 -refill_buffers -norandommap -randrepeat=0 -group_reporting -name=fio-randwrite-lat -size=10G -filename=/dev/vdb

注意

执行命令前请务必做好快照。

1fio -bs=4k -ioengine=libaio -iodepth=1 -numjobs=1 -direct=1 -rw=randrw -time_based -runtime=100 -refill_buffers -norandommap -randrepeat=0 -group_reporting -name=fio-read -size=1G -filename=/dev/vdb

执行以下命令，测试 SSD 云硬盘的顺序读吞吐性能。

1fio -bs=128k -ioengine=libaio -iodepth=32 -numjobs=1 -direct=1 -rw=read -time_based -runtime=600 -refill_buffers -norandommap -randrepeat=0 -group_reporting -name=fio-rw -size=10G -filename=/dev/vdb

测试结果如下图所示：

bs = 4k iodepth = 32：随机读/写测试，能反映硬盘的 IOPS 性能

警告

请不要在系统盘上进行 FIO 测试，避免损坏系统重要文件。
为避免底层文件系统元数据损坏导致数据损坏，请不要在业务数据盘上进行测试。请使用测试机器未存放业务数据的云硬盘进行压测，并提前创建快照保障您的数据安全。
请确保/etc/fstab文件配置项中没有被测硬盘的挂载配置，否则将导致云服务器启动失败。

执行以下命令，测试硬盘的随机读 IOPS。

1fio -bs=4k -ioengine=libaio -iodepth=32 -numjobs=4 -direct=1 -rw=randread -time_based -runtime=600 -refill_buffers -norandommap -randrepeat=0 -group_reporting -name=fio-randread-iops -size=10G -filename=/dev/vdb

执行以下命令，测试硬盘的随机写 IOPS。

注意

执行命令前请务必做好快照。

1fio -bs=4k -ioengine=libaio -iodepth=32 -numjobs=4 -direct=1 -rw=randwrite -time_based -runtime=600 -refill_buffers -norandommap -randrepeat=0 -group_reporting -name=fio-randwrite-iops -size=10G -filename=/dev/vdb

测试 SSD 云硬盘的随机读 IOPS 性能。如下图所示：

网安等保-Linux服务器之最新Ubuntu-22.04-LTS系统内核优化与安全加固配置脚本分享

Wed, 26 Oct 2022 13:33:48 +0800

0x00 前言简述

描述: Ubuntu 22.04 LTS 是Canonical于2022年4月21日发布的操作系统，代号为Jammy Jellyfish（果酱水母）, 其采用GNOME电源配置文件和流线型工作空间过渡，提高优化图形驱动程序上的桌面帧速率，使用新的加密算法迁移到OpenSSL v3以提高安全性,并且为内存安全的系统级编程添加了Rus。

而又由于CentOS发行版在最近几年时内将不在进行维护更新了，所以为了考虑到系统的安全性、可维护性、以及后期运维成本，我们企业内部在2020年时就已经将ubuntu作为主要的服务器系统，所以在我公司新上的业务系统基本采用debian系的发行版服务器来承载基础应用业务，而使用最多当然是Ubuntu此发行版。

现在 Ubuntu 推出了22.04 ，想到原来每次都需要手动一台一台的进行主机安全加固以符合等保要求，所以了节约工作时间提高工作效率，有更多时间进行学习进步，则需要将将我们公司所使用的系统基线镜像进行更新迭代，编写适用于ubuntu 22.04系统的安全加固脚本，并且总结此篇文章并在文章末尾附上自动化安全加固脚本，谢谢大家支持。

此处我依据在我从前编写的 Ubuntu 20.04 系统安全加固脚本中对其根据最新的22.04版本进行更新了等保相关规定策略，以及更新适用最新版本的 Ubuntu，针对脚本进行结构调整，更加方便大家一起参参与维护

想要获取该加固脚本的朋友可以在WX公众号【WeiyiGeek】中回复【ubuntu系统加固】即可获得，或者访问【https://weiyigeek.top/wechat.html?key=ubuntu系统加固】

首发地址: https://mp.weixin.qq.com/s/dO1bV0tfXKn4ZmqlMcUrrQ 实践视频：https://www.bilibili.com/video/BV1fe4y1o7ov

0x01 加固实践

描述: Ubuntu 22.04 主机系统安全加固的 Ubuntu22.04-InitializeReinforce.sh 脚本相关上的使用说明以及实践。

📖 帮助文档描述: 本工具集主要针对于 Ubuntu 22.04 、20.04 LTS 操作系统进行安全加固以及系统初始化操作。

🛠️ 脚本说明:

 1root@Ubuntu-Security:/home/ubuntu/Ubuntu# ./Ubuntu22.04-InitializeReinforce.sh
 2     __          __  _       _  _____           _
 3     \ \        / / (_)     (_)/ ____|         | |
 4     \ \  /\  / /__ _ _   _ _| |  __  ___  ___| | __
 5       \ \/  \/ / _ \ | | | | | | |_ |/ _ \/ _ \ |/ /
 6       \  /\  /  __/ | |_| | | |__| |  __/  __/   <
 7         \/  \/ \___|_|\__, |_|\_____|\___|\___|_|\_\
 8                      __/ |
 9                      |___/
10======================================================================
11@ Desc: Ubuntu 22.04 Security Reinforce and System initialization
12@ Mail bug reports: master@weiyigeek.top or pull request (pr)
13@ Author : WeiyiGeek
14@ Follow me on Blog   : https://blog.weiyigeek.top/
15@ Follow me on Wechat : https://weiyigeek.top/wechat.html?key=欢迎关注
16@ Communication group : https://weiyigeek.top/visit.html
17======================================================================
18
19Usage: ./Ubuntu22.04-InitializeReinforce.sh [--start ] [--network] [--function] [--clear] [--version] [--help]
20Option:
21  --start            Start System initialization and security reinforcement.
22  --network          Configure the system network and DNS resolution server.
23  --function         PCall the specified shell function.
24  --clear            Clear all system logs, cache and backup files.
25  --version          Print version and exit.
26  --help             Print help and exit.
27
28Mail bug reports or suggestions to <master@weiyigeek.top> or pull request (pr).
29current version : 1.0

WARNING: 温馨提示：使用前先请配置机器上网环境,若没有配置请在 Ubuntu22.04.conf 文件中进行网络配置.

运行加固脚本

1./Ubuntu22.04-InitializeReinforce.sh --start

⚛️脚本函数:

描述: 如下脚本将根据参数在 Ubuntu22.04-InitializeReinforce.sh 分别进行调用执行, 也可采用--function参数进行指定调用。

  1❯ grep -r -n  "函数名称" -A 1 *
  2scripts/os-base.sh:26:# 函数名称: base_hostname
  3scripts/os-base.sh-27-# 函数用途: 主机名称设置
  4--
  5scripts/os-base.sh:55:# 函数名称: ubuntu_mirror
  6scripts/os-base.sh-56-# 函数用途: ubuntu 系统主机软件仓库镜像源
  7--
  8scripts/os-base.sh:126:# 函数名称: ubuntu_software
  9scripts/os-base.sh-127-# 函数用途: ubuntu 系统主机内核版本升级以常规软件安装
 10--
 11scripts/os-base.sh:153:# 函数名称: base_timezone
 12scripts/os-base.sh-154-# 函数用途: 主机时间同步校准与时区设置
 13--
 14scripts/os-base.sh:192:# 函数名称: base_banner
 15scripts/os-base.sh-193-# 函数用途: 远程本地登陆主机信息展示
 16--
 17scripts/os-base.sh:345:# 函数名称: base_reboot
 18scripts/os-base.sh-346-# 函数用途: 是否进行重启或者关闭服务器
 19--
 20scripts/os-clean.sh:27:# 函数名称: system_clean
 21scripts/os-clean.sh-28-# 函数用途: 删除安全加固过程临时文件清理为基线镜像做准备
 22--
 23scripts/os-exceptions.sh:26:# 函数名称: problem_usercrond
 24scripts/os-exceptions.sh-27-# 函数用途: 解决普通用户定时任务无法定时执行问题
 25--
 26scripts/os-exceptions.sh:45:# 函数名称: problem_multipath
 27scripts/os-exceptions.sh-46-# 函数用途: 解决 ubuntu multipath add missing path 错误
 28--
 29scripts/os-network.sh:27:# 函数名称: net_config
 30scripts/os-network.sh-28-# 函数用途: 主机IP地址与网关设置
 31--
 32scripts/os-network.sh:70:# 函数名称: net_dns
 33scripts/os-network.sh-71-# 函数用途: 设置主机DNS解析服务器
 34--
 35scripts/os-optimize.sh:27:# 函数名称: optimize_kernel
 36scripts/os-optimize.sh-28-# 函数用途: 系统内核参数的优化配置
 37--
 38scripts/os-optimize.sh:84:# 函数名称: resources_limits
 39scripts/os-optimize.sh-85-# 函数用途: 系统资源文件打开句柄数优化配置
 40--
 41scripts/os-optimize.sh:115:# 函数名称: swap_partition
 42scripts/os-optimize.sh-116-# 函数用途: 创建系统swap分区
 43--
 44scripts/os-security.sh:27:# 函数名称: sec_usercheck
 45scripts/os-security.sh-28-# 函数用途: 用于锁定或者删除多余的系统账户
 46--
 47scripts/os-security.sh:65:# 函数名称: sec_userconfig
 48scripts/os-security.sh-66-# 函数用途: 针对拥有ssh远程登陆权限的用户进行密码口令设置。
 49--
 50scripts/os-security.sh:131:# 函数名称: sec_passpolicy
 51scripts/os-security.sh-132-# 函数用途: 用户密码复杂性策略设置 (密码过期周期0~90、到期前15天提示、密码长度至少12、复杂度设置至少有一个大小写、数字、特殊字符、密码三次不能一样、尝试次数为三次）
 52--
 53scripts/os-security.sh:166:# 函数名称: sec_sshdpolicy
 54scripts/os-security.sh-167-# 函数用途: 系统sshd服务安全策略设置
 55--
 56scripts/os-security.sh:194:# 函数名称: sec_loginpolicy
 57scripts/os-security.sh-195-# 函数用途: 用户登陆安全策略设置
 58--
 59scripts/os-security.sh:230:# 函数名称: sec_historypolicy
 60scripts/os-security.sh-231-# 函数用途: 用户终端执行的历史命令记录安全策略设置
 61--
 62scripts/os-security.sh:261:# 函数名称: sec_grubpolicy
 63scripts/os-security.sh-262-# 函数用途: 系统 GRUB 安全设置防止物理接触从grub菜单中修改密码
 64--
 65scripts/os-security.sh:304:# 函数名称: sec_firewallpolicy
 66scripts/os-security.sh-305-# 函数用途: 系统防火墙策略设置, 建议操作完成后重启计算机.
 67--
 68scripts/os-security.sh:335:# 函数名称: sec_ctrlaltdel
 69scripts/os-security.sh-336-# 函数用途: 禁用 ctrl+alt+del 组合键对系统重启 (必须要配置我曾入过坑)
 70--
 71scripts/os-security.sh:355:# 函数名称: sec_recyclebin
 72scripts/os-security.sh-356-# 函数用途: 设置文件删除回收站别名(防止误删文件)(必须要配置,我曾入过坑)
 73--
 74scripts/os-security.sh:405:# 函数名称: sec_supolicy
 75scripts/os-security.sh-406-# 函数用途: 切换用户日志记录和切换命令更改名称为SU(可选)
 76--
 77scripts/os-security.sh:425:# 函数名称: sec_privilegepolicy
 78scripts/os-security.sh-426-# 函数用途: 系统用户sudo权限与文件目录创建权限策略设置
 79--
 80scripts/os-service.sh:26:# 函数名称: svc_apport
 81scripts/os-service.sh-27-# 函数用途: 禁用烦人的apport错误报告
 82--
 83scripts/os-service.sh:52:# 函数名称: svc_snapd
 84scripts/os-service.sh-53-# 函数用途: 不使用snapd容器的环境下禁用或者卸载多余的snap软件及其服务
 85--
 86scripts/os-service.sh:75:# 函数名称: svc_cloud-init
 87scripts/os-service.sh-76-# 函数用途: 非云的环境下禁用或者卸载多余的cloud-init软件及其服务
 88--
 89scripts/os-service.sh:101:# 函数名称: svc_debugshell
 90scripts/os-service.sh-102-# 函数用途: 在系统启动时禁用debug-shell服务
 91--
 92scripts/os-software.sh:26:# 函数名称: install_chrony
 93scripts/os-software.sh-27-# 函数用途: 安装配置 chrony 时间同步服务器
 94--
 95scripts/os-software.sh:79:# 函数名称: install_java
 96scripts/os-software.sh-80-# 函数用途: 安装配置java环境
 97--
 98scripts/os-software.sh:110:## 函数名称: install_docker
 99scripts/os-software.sh-111-## 函数用途: 在 Ubuntu 主机上安装最新版本的Docker
100--
101scripts/os-software.sh:201:## 函数名称: install_cockercompose
102scripts/os-software.sh-202-## 函数用途: 在 Ubuntu 主机上安装最新版本的Dockercompose

☕ 配置文件:

描述: 在 Ubuntu22.04.conf 配置文件中定义脚本所需的安全策略以及日志、历史记录存放路径, 以模板的初始密码与防火墙配置等，其中最主要的是一定要配置好IP地址，以成功拉取软件仓库中的工具。

 1$ vim Ubuntu22.04.conf
 2# Show  Script Execute result (Y/N)
 3VAR_VERIFY_RESULT=Y
 4
 5# Modify Script vertify timeout (unit s)
 6VAR_VERIFY_TIMEOUT=5
 7
 8# Modify Script run time
 9VAR_RUNDATE=$(date +%Y%m%d-%s)
10
11# Modify Path to logfile.
12LOGFILE=/var/log/weiyigeek-${VAR_RUNDATE}.log
13
14# Modify Path to Backup directory.
15BACKUPDIR=/var/log/.backup/${VAR_RUNDATE}
16
17# Modify Path to history record directory.
18HISTORYDIR=/var/log/.history
19
20# Modify su command execute log file path.
21SU_LOG_FILE=${HISTORYDIR}/su.log
22
23# Modify the hostname
24VAR_HOSTNAME="Ubuntu-Security"
25
26# Modify the IP/MASK and Gateway
27VAR_IP=10.20.172.152/24
28VAR_GATEWAY=10.20.172.1
29
30# Modify the DNS server
31# DNSPod: 119.29.29.29      Alidns: 223.5.5.5 223.6.6.6
32# Google: 8.8.8.8 8.8.4.4   Cloudflare: 1.1.1.1 1.0.0.1
33# Internal : Your intranet domain name resolution server
34VAR_DNS_SERVER=("223.5.5.5" "223.6.6.6")
35
36# Modify the SSHD server
37VAR_SSHD_PORT=20221
38
39# Modify the super user and normal user
40# 建议将密码设置最小长度10（最好设置为12以上，等保要求），数字、大写字母、小写字母、特殊符号，密码包含三种及以上, 且无规律。
41# 温馨提示: 下面设置的密码为初始密码，在系统登陆后会要求更改。
42VAR_SUPER_USER=root
43VAR_SUPER_PASS=R2022.weiyigeek.top
44# normal user
45VAR_USER_NAME=ubuntu
46VAR_USER_PASS=U2022.weiyigeek.top
47# low privilege application users
48VAR_APP_USER=app
49VAR_APP_PASS=A2022.weiyigeek.top
50
51# Modify the NTP server
52VAR_NTP_SERVER=( "ntp.aliyun.com" "ntp.tencent.com" "192.168.10.254")
53
54# Modify the timezone
55VAR_TIMEZONE=Asia/Shanghai
56
57# Modify Password policy
58# 默认密码最大使用为90天、过期前15天提示, 密码最小长度为12
59PASS_MIN_DAYS=1
60PASS_MAX_DAYS=90
61PASS_WARN_AGE=15
62PASS_MIN_LEN=12
63# 默认加密方式为SHA512, 重试次数为3, 新密码与旧密码至少有6个字符不同, 至少包含3种密码类型，不限制密码中包含大写字母、小写字母、数字、特殊符号的最大数量，记住三次旧密码。
64VAR_PASS_ENCRYPT=SHA512
65VAR_PASS_RETRY=3
66VAR_PASS_DIFOK=6
67VAR_PASS_MINCLASS=3
68VAR_PASS_UCREDIT=-1
69VAR_PASS_LCREDIT=-1
70VAR_PASS_DCREDIT=-1
71VAR_PASS_OCREDIT=-1
72VAR_PASS_REMEMBER=3
73
74# 禁止没有主目录的用户登录
75VAR_DEFAULT_HOME=no
76# 删除用户时禁止同步删除用户组
77VAR_USERGROUPS_ENAB=no
78# 启用成功登录的日志记录
79VAR_LOG_OK_LOGINS=yes
80
81# Modify file or Dirctory privilege policy
82VAR_UMASK=022
83
84# Modify user login failed count policy
85# 默认在5分钟之内登陆失败次数超过6次将锁定10分钟,终端超时10分钟
86VAR_LOGIN_FAIL_COUNT=6
87VAR_LOGIN_FAIL_INTERVAL=300
88VAR_LOGIN_LOCK_TIME=600
89VAR_LOGIN_TIMEOUT=300
90
91# Modify history record count policy
92VAR_HISTSIZE=128
93
94# Modify firewall policy tcp or udp port .
95VAR_ALLOW_PORT=("22,80,443,${VAR_SSHD_PORT}/tcp" "53/udp")

🏃 脚本使用

Step 1.上传到需要加固的主机服务器中，此处我上传到ubuntu用户的家目录。

 1OperatingSystem\Security> scp -r .\Ubuntu\ ubuntu@10.20.172.152:~
 2ubuntu@10.20.172.152\'s password:
 3Ubuntu22.04.conf                                                                      100% 2979   976.9KB/s   00:00
 4os-base.sh                                                                            100%   14KB   5.4MB/s   00:00
 5os-clean.sh                                                                           100% 2446     2.1MB/s   00:00
 6os-exceptions.sh                                                                      100% 2634     2.5MB/s   00:00
 7os-info.sh                                                                            100% 1169     1.3MB/s   00:00
 8os-manual.sh                                                                          100% 1860     2.0MB/s   00:00
 9os-network.sh                                                                         100% 3774     1.8MB/s   00:00
10os-optimize.sh                                                                        100% 7752     3.7MB/s   00:00
11os-security.sh                                                                        100% 23KB     5.7MB/s   00:00
12os-service.sh                                                                         100% 3969     2.0MB/s   00:00
13os-software.sh                                                                        100% 8007     3.3MB/s   00:00
14Ubuntu22.04-InitializeReinforce.sh                                                    100% 7989     5.0MB/s   00:00

Step 2.登陆服务器并切换到root用户, 查看 /home/ubuntu 目录下上传的加固版本。

 1$ ssh -p 22 ubuntu@10.20.172.152
 2ubuntu@Ubuntu-Security:~$ tree Ubuntu/
 3Ubuntu/
 4├── Readme.assets
 5│   ├── image-20220823143235577.png
 6│   └── image-20220823143354742.png
 7├── Readme.md
 8├── Ubuntu22.04-InitializeReinforce.sh
 9├── config
10│   └── Ubuntu22.04.conf
11├── example
12│   └── 22.04
13│       ├── 00-custom-header
14│       ├── common-auth
15│       ├── common-password
16│       ├── issue
17│       ├── issue.net
18│       ├── login.defs
19│       ├── profile
20│       ├── resolved.conf
21│       ├── sshd_config
22│       └── su
23└── scripts
24    ├── os-base.sh
25    ├── os-clean.sh
26    ├── os-exceptions.sh
27    ├── os-info.sh
28    ├── os-manual.sh
29    ├── os-network.sh
30    ├── os-optimize.sh
31    ├── os-security.sh
32    ├── os-service.sh
33    └── os-software.sh
34
35ubuntu@Ubuntu-Security:~$ sudo -i

Step 3.切换root用户后进入 /home/ubuntu/Ubuntu，安全加固脚本存放目录，首先将所有的sh文件赋予可执行去那些，其次需要在 Ubuntu22.04.conf 中进行相应配置，最后运行Ubuntu22.04-InitializeReinforce.sh –start即可，最后等待系统重启即可。

cd /home/ubuntu/Ubuntu
chmod +x -R *
Ubuntu22.04-InitializeReinforce.sh  --start

运行加固脚本

Step 4.中途请根据需求输入Y/N，然后等待重启即可，在重启后请注意sshd服务端口更改为20221所以此时你需要指定ssh连接端口。

ssh -p 20221 ubuntu@10.20.172.152  # Ubuntu22.04.conf 定义的 ubuntu 初始化密码，登陆后会提示你进行更改。
su - root  # 只能有ubuntu用户切换到root用户，其它低权限以及app用户无法通过su进行用户切换

加固结果

温馨提示: 如果执行到密码更新策略时，选择输入了(N) 否将不会更新其在Ubuntu22.04.conf脚本中定义的密码。

温馨提示：脚本中默认root密码为R2022.weiyigeek.top。

温馨提示: 防火墙策略只开放了80，443，22，20221等端口。

Linux on ttz.pw

Acme.sh申请免费ssl证书

1. 安装 acme.sh

2. 生成证书

2.0.1. http 方式

2.0.2. 手动 dns 方式

3. copy/安装 证书

3.1. Apache example:

3.2. Nginx example:

4. 查看已安装证书信息

5. 更新证书

6. 关于修改ReloadCmd

7. 更新 acme.sh

8. 出错怎么办：

吞吐量(TPS)、QPS、并发数、响应时间(RT)的概念与QPS计算公式

1. 响应时间(RT)

2. 吞吐量(Throughput)

3. 并发用户数

4. QPS每秒查询率(Query Per Second)

5. PV（page view）

6. UV 访问数（Unique Visitor）

7. IP（Internet Protocol）独立 IP 数

8. GVM

9. QPS 计算规则:

9.1. 聚合报告各项性能指标1. 响应时间(RT)

9.2. 接口性能测试指标一般通过标准：

计算机性能衡量指标TPC、TPCC、TPMC

1. 什么是TPC和tpmC?

1.1. TPC

1.2. tpmC

2. TPCC

2.1. 基准测试

2.2. 性能测试指标介绍

2.3. TPC-C规范概要

2.4. 评测指标

2.4.1. ①流量指标(Throughput，简称tpmC)

2.4.2. ②性价比(Price/Performance，简称Price/tpmC)

3. （TPCC）如何衡量计算机系统的性能和价格

3.1. 在真实环境中运行 实际应用

3.2. 使用用户定义的基准程序

3.3. 使用通用基准程序

3.3.1. ①实际应用是否与基准程序相符

3.3.2. ②TPC度量的解释

3.3.3. ③TPC测试的成本

4. TPCC计算原则

4.1. 建议

5. 参考：某项目计算实例

5.1. 参考1

5.2. 参考2

5.3. 参考3

5.3.1. 选型参考建议

5.3.2. 如何规划和选择数据库服务器?

5.3.2.1. 高法诉讼费缴费:

5.3.2.2. 整体性能要求:

5.3.2.3. 内存容量需求分析

5.3.2.4. 网银数据量分析:

5.3.2.5. 高法诉讼费数据量分析:

5.3.2.6. 从而计算出系统内存需求为:

5.3.2.7. 存储容量需求分析

5.4. 参考4

5.4.1. 服务器处理能力

5.5. 参考5

5.5.1. 主要服务器处理能力

5.5.1.1. MMSC、数据库服务器和计费服务器

5.5.2. 配置建议

5.5.2.1. MMSC 业务主机

你会正确估算服务器处理能力吗？

1. 引题

2. 性能评测标准

2.1. TPC-C标准

2.2. SPEC web标准

3. 性能估算公式

3.1. 常见的错误估算方法

3.2. TPC-C估算公式

3.3. SPEC Web估算公式

4. 应用实例

蓝队巨献！告警IP全自动封禁平台

1. 作为蓝队成员，你是否在防守过程中常常为以下问题所困扰？

2. 解决方案

3. 安装使用

3. copy/安装证书

3.1. 在真实环境中运行实际应用

9. Linux下策略性路由的实现–RPDB（Routing　Policy DataBase）