新加坡VPS API服务配置怎么选
来源: 飞翔小编 2026/11/19 14:42:11 浏览量:0
导读:用新加坡VPS搭API服务,瓶颈往往不在核数而在并发排队。这篇讲清API服务的负载特征和真实瓶颈在哪里,内存和流量成本怎么算,验收时该盯哪几个数字,连接池、超时、限流这些常见报错怎么排查,以及什么情况下新加坡机房不该选。价格只引用渠道库真实数据,没有的部分一律写「以官网当日报价为准」。
搜索「新加坡VPS API服务配置怎么选」的人,多半已经买了一台机器,跑起来发现「偶尔卡一下」,或者「压测时 P99 延迟飘到几秒」,但不知道问题出在哪。这篇不讲商家好坏,只讲 API 服务的负载长什么样、瓶颈在哪、配该怎么算。
一、API 服务的瓶颈为什么不在 CPU

很多人的第一反应是「要跑多少核」。这个判断顺序在 API 服务上是错的。
Web 站点和 API 服务的负载曲线完全不同。 Web 站点是「请求少、页面重」——一个页面请求要传几十上百 KB 的 HTML、JS、图片,瓶颈常常落在带宽上。而 API 服务的响应体通常只有几百字节到几 KB,真正的开销是每个请求都要走一遍完整的 TCP 握手、TLS 握手、应用层处理、序列化、返回。
这意味着同样配置的机器,API 服务能承载的并发请求数比 Web 站点高出一个数量级,而内存消耗低得多。典型的 API 服务(Go / Node / Java 微服务)在稳定运行时的内存占用,取决于应用本身的堆大小和连接数,而不是核数。
压垮 API 服务的三件事,按出现频率排序是:
第一,连接数堆积。 每个客户端的每个请求,在服务端都占一个文件描述符和一个内核 socket buffer。经验值是单个长连接的常驻内存开销约 32 KB 到 64 KB。 10000 个连接就是 320 MB 到 640 MB,这部分内存是被「连接数」吃掉的,不是被业务逻辑吃掉的。
第二,数据库连接池打满。 这是一个被严重低估的瓶颈。很多 API 服务的超时不是 CPU 不够,而是所有请求都在排队等数据库连接。 典型表现是:CPU 使用率只有 30%,但接口 P99 延迟已经飙到 5 秒。
# 看数据库连接池的使用情况
mysql -e "SHOW STATUS LIKE 'Threads_connected';"
mysql -e "SHOW VARIABLES LIKE 'max_connections';"
第三,冷启动抖动。 虚拟化环境下的 CPU steal 时间(被宿主机抢走的时间)在繁忙时段会明显上升,表现为平均负载不高但偶尔出现 200 到 500 毫秒的延迟尖刺。这种抖动对 API 服务的伤害远大于对 Web 站点的伤害,因为前端重试会放大它。
# 看 CPU steal 时间
top -bn1 | grep -i "%Cpu"
# 输出里的 st 字段就是 steal,占比持续高于 5% 说明宿主机在抢 CPU
所以选型的第一步不是看配置表,而是先量清楚你的三个业务参数:峰值 QPS、单次请求体大小、是否需要长连接。 这三个参数决定了下面的选型逻辑。
二、内存要多大:把进程开销一项项加起来

API 服务的内存账不靠猜,靠加法。下面这张表是常见组件的单项开销:
| 组件 | 常驻内存 | 说明 |
|---|---|---|
| 操作系统 + 基础服务 | 250–350 MB | 空载底噪,任何配置都要付 |
| 应用程序运行时 | 100–300 MB | Go / Node / Java 各不相同 |
| 每个长连接 | 32–64 KB | 乘以连接数 |
| 数据库连接池 | 每连接 5–20 MB | 取决于查询复杂度 |
| 缓存(Redis 等) | 按数据量 | 通常是总内存的 30% 到 40% |
把它代入几个具体场景:
场景一:内部服务,单机 100 QPS,100 个并发连接。 操作系统 300 MB + 应用 200 MB + 连接数 100 × 48 KB(约 5 MB)+ 数据库连接池 20 × 10 MB(200 MB)= 约 700 MB。1 GB 内存的机器在加上缓存后就该升档了,2 GB 是合理的起点。
场景二:面向公网的 API,1000 QPS,5000 个并发连接。 操作系统 300 MB + 应用 500 MB + 连接数 5000 × 48 KB(约 240 MB)+ 数据库连接池 50 × 15 MB(750 MB)= 约 1.8 GB。4 GB 机器合适,留下的空间放 Redis 缓存和日志缓冲。
场景三:高并发长连接服务(WebSocket、推送),50000 个连接。 操作系统 300 MB + 应用 800 MB + 连接数 50000 × 48 KB(约 2.4 GB)+ 数据库 500 MB = 约 4 GB。8 GB 起步,并且必须做连接数上限控制。
从这三个场景能读出一条规律:连接数才是内存需求的放大器。 单看「我要 1000 QPS」,需要多少内存完全说不准;但「我要 50000 个长连接」这个数字一给出来,内存需求立刻清晰。
这套加法还可以反过来用:给你手上那台机器,反推它能撑多少连接。 假设你有一台 4 GB 内存的机器,按第二节的账,扣掉系统 300 MB、应用 500 MB、数据库连接池 750 MB,剩下 2.4 GB 给连接。按每连接 48 KB 算,是 51200 个连接。再留 20% 余量,安全上限是 4 万个连接左右。 这个数字就是你的容量规划基准线——超过它就该横向扩了。
验证内存估算的方法:
# 看当前进程的常驻内存
ps -o pid,rss,cmd -C 你的进程名 | awk 'NR>1 {printf "%-8s %8.1f MB %s\n", $1, $2/1024, $3}'
# 看当前打开的文件描述符数量(连接数的直接指标)
ls /proc/$(pgrep -f 你的进程名)/fd | wc -l
# 看 socket 状态统计
ss -s
判断是否需要升档的信号:内存占用超过 70%、开始使用 swap、或者文件描述符接近系统上限。 查看系统上限:
ulimit -n
# 常见默认值 1024,API 服务通常要调到 65535 以上
三、流量要买多少:API 的流量算法和网站不同

API 的出站流量很小,但请求数多,这两件事叠起来总流量不一定小。
先算单次请求的流量。一个 JSON 接口的平均响应体按 2 KB 算,加上 TCP 和 TLS 的协议开销,实际按 2.5 KB 估更稳妥。
按 QPS 推算月出站流量:
| 峰值 QPS | 持续时长 | 日出站流量 | 月出站流量 |
|---|---|---|---|
| 10 QPS | 24 小时 | 2.16 GB | 64.8 GB |
| 100 QPS | 24 小时 | 21.6 GB | 648 GB |
| 500 QPS | 24 小时 | 108 GB | 3.24 TB |
| 1000 QPS | 24 小时 | 216 GB | 6.48 TB |
关键假设是「24 小时持续满负荷」。 实际业务通常不是这样——大部分 API 服务是白天忙、晚上闲。 如果你的服务只在每天 8 小时有流量,1000 QPS 的月出站流量是 6.48 TB 的三分之一,约 2.16 TB。
# 实测自己的真实出站流量
sudo awk '$7 ~ /bytes_sent/ {print}' /var/log/nginx/access.log | \
awk '{s+=$2} END {printf "出站总量 %.2f GB\n", s/1073741824}'
# 按小时看流量分布,确认是不是只有部分时段有量
sudo awk '{print substr($4,2,14)}' /var/log/nginx/access.log | \
cut -c1-13 | sort | uniq -c | head -24
测出来的数字比估算的更可靠。 估算只是用来做初筛的。
关于流量的一个常见误解:API 服务「响应小所以流量省」。 这个结论只在 QPS 低的时候成立。1000 QPS 持续一小时的出站流量是 7.78 GB,摊到 30 天里每天也只有 187 GB——听起来不多,但如果你有 10 个 API 实例,流量是乘 10 的。 所以流量这件事必须按「实例数 × 单实例」算。
关于带宽端口:1000 Mbps 对 API 够不够? 算一下:1000 Mbps 端口在 2.5 KB 响应体下,理论上能支撑每秒 50000 个请求。你的 QPS 通常远低于这个数,所以端口速率对 API 服务几乎不是约束条件。 但如果你的接口返回的是大对象(比如列表接口一次返回 100 条记录,每条 2 KB,合计 200 KB),那响应体放大 80 倍,端口开始成为瓶颈。
# 实测响应体大小分布
sudo awk '{print $10}' /var/log/nginx/access.log | \
awk '{if($1>10000) big++; sum+=$1; n++} END {printf "平均 %.0f 字节, 超 10KB 的请求占 %.1f%%\n", sum/n, big/n*100}'
判定:响应体超过 10 KB 的请求占比超过 20%,端口速率就要纳入选型考虑。
还有两笔流量账经常被漏掉:
第一笔,请求体。 上行流量通常不计费,但它同样占用物理端口。一个 100 KB 的上传请求,在 1000 Mbps 端口上会占住 0.8 毫秒。如果你的 API 有文件上传接口,这一项要单独算。
第二笔,错误重试。 客户端在超时后重试,会让实际流量翻倍甚至三倍。这个放大系数要计入规划:
# 统计请求数和实际请求数的比值,看重试放大有多严重
# 正常情况下客户端发起的请求数应等于服务端收到的请求数
sudo awk '{print $9}' /var/log/nginx/access.log | sort | uniq -c | head -10
判定:同一个 URL 的 499 和 504 状态码占比超过 5%,说明重试在放大流量,先修超时问题比升流量额度更划算。
四、CPU 几核够用:把 QPS 换算成核数

CPU 该配几核,取决于单请求消耗多少 CPU 时间,而不是取决于 QPS 这个数字本身。
第一步:测你的单请求 CPU 开销。
# 用 wrk 或 hey 做一次基准压测,同时看 CPU 占用
hey -n 10000 -c 50 -m POST \
-H "Content-Type: application/json" \
-d '{"user_id":1}' \
https://你的api域名/v1/endpoint &
# 另一条终端看 CPU
top -bn1 | head -3
第二步:套公式。 1 核 CPU 在满负荷下,每秒能处理的请求数 = 1000 毫秒 ÷ 单请求 CPU 毫秒数。
| 单请求 CPU 开销 | 1 核理论 QPS | 留 30% 余量后 | 4 核可支撑 |
|---|---|---|---|
| 0.2 毫秒 | 5000 | 3500 | 14000 |
| 0.5 毫秒 | 2000 | 1400 | 5600 |
| 1.0 毫秒 | 1000 | 700 | 2800 |
| 2.0 毫秒 | 500 | 350 | 1400 |
| 5.0 毫秒 | 200 | 140 | 560 |
这张表怎么用: 先测出你的单请求 CPU 开销,落在哪一行,就知道需要几核。如果你的接口逻辑较重(比如带 JWT 校验加一次数据库查询),单请求开销通常在 1.5 毫秒级别,单核实际支撑会掉到 500 到 600 QPS。
第三步:校准到真实机器。 上面是理论值,虚拟化环境有损耗。上机后做一次满载实测:
# 4 核机器上起 4 个死循环,看 CPU 能不能跑满 400%
for i in $(seq 1 4); do yes > /dev/null & done
sleep 5
top -bn1 | head -3
kill $(jobs -p)
判定:CPU 总占用能上到接近 400% 说明是真实可用的 4 核;卡在 100% 到 200% 就上不去,说明是共享核。 共享核在 API 服务上的影响比在 Web 站点上大,因为 API 的延迟尖刺会被重试放大。
第四步:确认瓶颈真的不在 CPU。 一个容易混淆的现象:内存不足时 load average 也会涨,因为系统在用 swap,磁盘 I/O 拖慢了整体。区分办法是看 free -m 的 swap 行——如果 swap 在被使用,问题在内存不在 CPU,这时候加核数毫无用处。
第五步:确认核型不是瓶颈。 同样的核数,不同 CPU 的单核性能差距可以到两倍。判断方法是跑一次整数运算基准,看单核的实际吞吐:
# 用整数运算测单核性能(避开浮点单元差异)
sysbench cpu --threads=1 --time=10 --max-prime=20000 run 2>/dev/null | \
grep "events per second"
# 或者用简单的整数循环计时
time bash -c 'x=0; for i in $(seq 1 100000000); do x=$((x+1)); done'
判定:同一个整数基准在两台不同机器上跑,差 1.5 倍以上就说明核型有实质差别。 这时候同样的核数配置在两台机器上的实际吞吐完全不同,选型时不能只看核数。 商品库里的机型只标注核数不标注型号,所以对大多数 API 业务,把注意力放在核数和内存上就够了——除非你要做加解密、压缩、图像处理这类重计算,那种情况下必须问清 CPU 型号。
五、验收标准:API 该盯的六个数字

买之前就把验收标准定死。下面六个数字可以量化到具体数值:
1. 首字节时间(TTFB)小于 300 毫秒。 从客户端发起请求到收到第一个字节。这是最贴近用户感知的指标。
# 测 5 次首字节时间,取中位数
for i in 1 2 3 4 5; do
curl -s -o /dev/null -w "TTFB: %{time_starttransfer}s Total: %{time_total}s\n" \
https://你的api域名/v1/endpoint
done
2. P99 延迟小于 500 毫秒。 平均延迟没有意义,API 的用户抱怨通常来自 P99。压测时用 wrk 或 hey:
# hey 压测 30 秒 200 并发
hey -n 200000 -c 200 -m POST \
-H "Content-Type: application/json" \
-d '{"user_id":1}' \
https://你的api域名/v1/endpoint
3. 错误率低于 0.1%。 压测中如果出现超时或 502,那不是「机器慢」,是「机器扛不住」。
4. 内存占用低于 15%,swap 使用为 0。 API 服务是内存敏感型:
free -m | awk '/Mem:/ {printf "内存占用 %.1f%%\n", $3/$2*100}'
free -m | awk '/Swap:/ {print "Swap 使用:", $3"MB / "$2"MB"}'
判定:内存占用超过 30% 说明该升档;swap 被使用说明已经在丢性能了。
5. CPU steal 低于 5%。 见第一节的 top 命令输出里的 st 字段。
6. 文件描述符使用率低于 60%。
# 当前使用数 vs 系统上限
echo "当前: $(ls /proc/$(pgrep -f 你的进程名)/fd | wc -l) / 上限: $(ulimit -n)"
判定:超过 60% 就要调高 ulimit 并排查连接泄漏。
六、常见报错和排查顺序

报错一:Too many open files。 这是 API 服务最常见的错误,成因有三个:ulimit 太低、连接没关、连接池上限大于系统上限。
# 解决:永久调高限制
echo "* soft nofile 65535" | sudo tee -a /etc/security/limits.conf
echo "* hard nofile 65535" | sudo tee -a /etc/security/limits.conf
sudo systemctl restart 应用服务
# 临时对当前会话生效
ulimit -n 65535
排查顺序:先看应用的连接池配置上限,再看系统 ulimit,最后看有没有忘记 close 的连接。
报错二:Connection refused / 502 Bad Gateway。 通常是后端进程挂了或端口没监听:
# 看进程在不在
ps aux | grep 你的进程名 | grep -v grep
# 看端口有没有在监听
sudo ss -tlnp | grep 你的端口
# 看应用日志的最后 50 行
sudo journalctl -u 你的服务名 -n 50 --no-pager
报错三:context deadline exceeded / 请求超时。 三种可能,按概率排序:
第一种,数据库连接池打满。 看连接数:
mysql -e "SHOW STATUS LIKE 'Threads_connected';"
# 对比 max_connections,如果接近就是它
第二种,下游服务慢。 如果你的接口要调另一个服务,把那个服务的延迟加总算一下。串联三个各 200 毫秒的服务,整体就是 600 毫秒。
第三种,就是机器本身扛不住。 用第五节的 P99 压测法确认。
报错四:Killed process / 进程被 OOM Killer 干掉。
# 确认是不是 OOM
sudo dmesg | grep -i "out of memory" | tail -5
sudo dmesg | grep -i "killed process" | tail -5
这是内存不足的终局表现。 处理顺序是:先减小连接池上限,再关掉不必要的缓存,最后才升配。很多团队一遇到 OOM 就直接升机器,其实把数据库连接池从 200 改成 50 就够了。
报错五:CPU 使用率只有 30%,但接口很慢。 这是第四节说过的坑——内存不足引发 swap,磁盘 I/O 把整机拖慢,load average 跟着涨,但 CPU 显示的是「空闲等待」。查法:
free -m | awk '/Swap:/ {print "Swap 使用:", $3"MB"}'
iostat -x 1 5 | awk '/Average/ {printf "await %.2f ms\n", $10}'
Swap 在用、await 高于 10 毫秒——问题在内存,不在 CPU。
七、常见误区:API 选配置的五个坑

误区一,「API 响应小,所以配置可以买小」。 响应小不等于成本低。每次请求的 TCP 握手、TLS 握手、序列化都是实打实的 CPU 开销,而且请求数多意味着连接数多,连接数直接吃内存(第二节的表)。一个日处理千万次请求的 API,内存需求可能比一个日处理十万次请求但返回大文件的 Web 服务还高。
误区二,「加内存不如加核」。 这个判断在两种情况下完全反了:一是应用用了大量内存(第二节的场景二和场景三),二是内存不足导致 swap 已经发生。先看 free -m 的 swap 行,有 swap 在用就加内存,没有 swap 再考虑加核。
误区三,「端口速率对 API 不重要,所以随便选」。 端口速率在响应体大的时候会成为硬约束。第三节那个「响应体超过 10 KB 的请求占比」指标,超过 20% 就必须把端口纳入考虑。 极端情况下,一个 1000 Mbps 端口在返回 200 KB 响应体时,实际 QPS 上限会掉到六百左右。
误区四,「配置越高 API 越快」。 这是完全错误的因果。API 的延迟由网络往返时间、应用处理时间、数据库查询时间三部分组成,服务器配置只影响第二和第三部分,而且只在系统负载接近饱和时才有差别。 一个已经优化到 0.3 毫秒处理的接口,从 2 核升到 8 核,延迟变化在 0.01 毫秒量级,用户完全感知不到。
误区五,「监控装上就行」。 监控能看到问题,不能预防问题。API 服务最少要有这四项告警:
# 内存使用率告警(超过 75% 发通知)
free -m | awk '/Mem:/ {if ($3/$2 > 0.75) print "内存告警:", $3"MB / "$2"MB"}'
# 文件描述符使用率告警
CNT=$(ls /proc/$(pgrep -f 你的进程名)/fd | wc -l)
MAX=$(ulimit -n)
[ "$CNT" -gt $((MAX * 3 / 5)) ] && echo "FD 告警: $CNT / $MAX"
# 连接数告警
ss -s | head -3
误区六,「API 和网站用同一套配置就行」。 这两类业务的负载特征完全不同,混着配是最常见的浪费。具体差在三个地方:
差别一,内存账的构成不同。 网站的内存消耗集中在 PHP worker 和数据库缓存,API 的内存消耗集中在连接数和长连接缓冲。一个跑 PHP 的网站,4 GB 内存的利用率可能只有 15%;一个跑长连接 API 的服务,同样的 4 GB 可能一直跑在 70%。
差别二,端口速率的重要性不同。 网站传的是大页面,端口速率直接决定首屏速度;API 传的是小响应体,端口速率通常不是约束(第三节算过)。给 API 买大端口,往往不如把预算花在内存上。
差别三,扩展方向不同。 网站横向扩展要处理静态资源分发和缓存一致性;API 横向扩展只要保证无状态(第九节)。如果你的 API 还没做过无状态改造,就先别买多台机器——加机器会让「用户在不同节点看到不同数据」的问题立刻暴露出来。
一个判断「该升配还是该优化」的简单办法:把同一份请求用两台不同配置的机器各跑一遍压测,对比 P99。 如果 2 核和 4 核的 P99 差别在 10% 以内,说明瓶颈不在 CPU,加核是浪费;如果差别超过 40%,那就是实打实的 CPU 瓶颈。
八、什么情况下不该选新加坡机房

API 服务的机房选择,取决于调用方在哪里,不取决于服务在哪里。 以下四种情况要重新考虑:
情况一:调用方主要在中国大陆,且对延迟敏感。 新加坡到大陆的地理距离在 2580 公里到 4300 公里之间,物理距离决定延迟下限,机器配置压不下去。替代方案: 把服务部署在离调用方更近的节点;或者用 CDN 和边缘缓存把静态化的 API 响应缓存到就近节点。注意:只有响应内容与请求无关(不依赖用户身份)的 API 才适合缓存,这类接口通常是配置查询、静态数据这类。
情况二:你的服务需要对接中国大陆的支付、短信、地图等第三方接口。 这些接口本身有地域限制和对端网络质量的要求,你的服务器和它们之间的链路质量直接决定成功率,而不是你的处理速度。替代方案: 把对端调用单独部署在一台离对端更近的机器上,通过内网或专线互通。
情况三:你的 API 是给全球用户调用的,且用户分布很广。 单节点在这种场景下必然顾此失彼。替代方案: 单元化部署,每个区域一组,用 DNS 智能解析把用户导向最近的节点。但要诚实地评估:单元化的运维成本对小团队通常不划算,宁可先做好单点的可用性。
情况四:你需要的是「住宅 IP」或「原生 IP」才能通过目标服务的风控。 机房 IDC 段的 IP 在很多第三方 API 上会被直接拒绝。替代方案: 如果你的 API 对接的是自己控制的客户端(不是第三方平台),那么 IP 类型完全不影响,按第二节的内存和第三节的流量算钱就行;如果确实要对接会做 IP 风控的第三方,那要单独确认 IP 类型,这属于选型的另一个维度,不能和性能混在一起谈。
还有一种情况必须提前想清楚:你的 API 是给移动端 App 调用的。 移动端网络环境千差万别——4G、5G、弱网、运营商跨国漫游都存在,这时候接口的 TTFB 稳定性比绝对值更重要。判定方法是把接口放进真实的弱网环境测一次:限制上下行带宽到 1 Mbps、加 300 毫秒延迟、丢包 5%,然后看接口是否还能在超时阈值内返回。
# 用 tc 模拟弱网(Linux 需要 iproute2)
sudo tc qdisc add dev eth0 root netem delay 300ms loss 5%
# 测完之后务必删掉
sudo tc qdisc del dev eth0 root
判定:弱网环境下 P99 超过 1 秒,接口就应该考虑加超时、重试和降级,而不是继续加机器。 加机器只能提升吞吐,提升不了弱网下的单次往返时间。
九、扩展路径:业务涨了怎么加钱

API 服务的扩展有三条路径,按触发条件选:
路径一:纵向升配。 触发条件是 CPU 满载(load average 超过核数)或内存接近上限。但 API 服务的纵向扩展上限受限于单机能处理的最大连接数,超过这个量级必须横向。
路径二:横向加机器。 触发条件是并发连接数或QPS 超出了单机的舒适区。做法的关键是会话状态怎么处理:
upstream api_pool {
least_conn;
server 10.0.0.11:8080 max_fails=3 fail_timeout=30s;
server 10.0.0.12:8080 max_fails=3 fail_timeout=30s;
server 10.0.0.13:8080 max_fails=3 fail_timeout=30s;
keepalive 128;
}
server {
listen 80;
location /api/ {
proxy_pass http://api_pool;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_connect_timeout 5s;
proxy_read_timeout 30s;
}
}
关键点:API 必须设计成无状态的。 如果有本地会话或本地缓存,加机器后就会出现「用户在不同节点上看到不同数据」的问题。会话放 Redis 这样的外部缓存,或者干脆用 JWT 这类自包含令牌。
路径三:加缓存。 这条路径常被忽略,但通常是最便宜的。如果你的接口里有大量只读查询,加一层缓存能把后端 QPS 直接打下来一半以上。
# 统计接口调用频次,找出最值得缓存的接口
sudo awk '{print $7}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -20
缓存要注意缓存击穿——热点 key 过期瞬间会有大量请求同时打到后端。做法是给热点 key 加互斥锁,或者设置随机过期时间:
# 随机过期时间,避免同时过期
EXPIRE=$((300 + RANDOM % 60))
缓存还要注意一致性边界。 缓存的是「多久之后数据可以变得不新鲜」,这个值要按业务定:配置查询类接口可以缓存 5 分钟,库存类接口只能缓存几秒,价格类接口缓存时间超过一次同步周期就会出现纠纷。 定错了缓存时间,用户看到的和实际的不一致,投诉会直接指向你的客服而不是你的架构。
扩展的信号判断:CPU 满载 → 纵向升配;连接数超限 → 横向加机器;后端 QPS 高但单次查询慢 → 加缓存。 三种信号对应三条完全不同的路径,混着做会浪费钱。
最后一条关于扩容后的验证:加完机器一定要重跑一遍第五节的六项验收。 横向扩容之后,P99 有时反而会变差——原因通常是负载均衡策略不合适(比如用轮询而不是最少连接),或者某些节点的本地缓存是空的。扩容后不复验,等于把问题从「不够用」换成了「不均匀」,后者更难查。
按你的情况,下一步该看哪家
上面讲的是判断标准,但多数人最后还是想问一句「那我该买谁」。按你的实际情况对照下面几条,直接去看对应的机型页比继续比价更快:
- 主要访客在国内、在意打开速度:先确认回程线路,再谈配置。看 zenlayer 当前机型与价格
价格与库存以商家页面当日显示为准,下单前建议先确认退款窗口与是否支持按月付费。
十、常见问题

新加坡VPS搭API,最少要什么配置? 内部服务 100 QPS 级别,1 GB 内存起步但建议 2 GB;公网 1000 QPS 级别,4 GB 内存是合理起点。具体用第二节的加法算一遍,别照抄别人的数字。
那到底该买几核? 第四节那张表给了换算方式。但要强调:API 的核数需求通常低于直觉,因为请求的大部分时间花在等数据库和等网络,不在算。一个日处理百万次请求的接口,2 核往往就够,真正卡住你的是连接数和数据库。 这也是为什么第七节的误区二那么重要——先确认瓶颈在哪,再决定加什么。
怎么知道我的接口单请求占多少 CPU? 用 hey 或 wrk 压测时同时看 top 的 %CPU,再用「单核满负荷每秒处理请求数 = 1000 ÷ 单请求 CPU 毫秒」反推。第四节那张表就是干这个用的。
API 服务要不要加缓存? 要,除非你的接口全是写操作。先统计接口调用频次,找出占比最高的那几个只读接口加缓存,通常能立刻把后端 QPS 降一半。
压测的时候 P99 延迟飘高,是机器不够吗? 不一定。先看内存有没有在用 swap(第四节说的,swap 会让 load 涨但 CPU 显示空闲),再看数据库连接池有没有打满。 这两个原因比「机器不够」常见得多。
怎么排查接口超时? 按第六节的顺序:连接池 → 下游服务 → 机器本身。三个环节的耗时加起来才是真实延迟,很多团队只测了自己的服务,忽略了串联调用。
API 的超时该设多少? 这个数字要按「调用方能接受的等待时间」倒推,而不是拍脑袋。服务端超时应略大于下游依赖的总耗时上限,否则服务会先于依赖超时,报出来的错误也就失去了定位价值。 一个三层串联的接口,下游各 500 毫秒,服务端超时应设在 2 秒左右。排查时用这个命令看各层耗时:
# Nginx 侧记录的上游响应时间,看 P95 和 P99
sudo awk '{print $NF}' /var/log/nginx/access.log | grep -oE "[0-9]+\.[0-9]+" | \
sort -n | awk '{a[NR]=$1} END {printf "中位数 %.3f s, P95 %.3f s, P99 %.3f s\n", a[int(NR*0.5)], a[int(NR*0.95)], a[int(NR*0.99)]}'
这个 P99 和第五节的验收标准是同一个数字。 如果实测 P99 超过 500 毫秒而服务端超时设的是 2 秒,说明大部分请求是「慢但没超时」——这种状态最危险,因为它不报错,只是让用户等。
服务器需要装什么安全软件? API 服务至少要做两件事:限制 SSH 登录方式(用密钥、禁用密码),以及对接口做速率限制。 商品库里多个商家提供高防和 DDoS 防护产品,那是给有攻击风险的场景准备的,普通 API 业务先把基础安全做扎实更重要。接口限流的 Nginx 配置:
# /v1/ 路径下每个 IP 每秒最多 20 个请求
limit_req_zone $binary_remote_addr zone=api:10m rate=20r/s;
location /v1/ {
limit_req zone=api burst=40 nodelay;
proxy_pass http://api_pool;
}
