NoSQL 与搜索 / 系统课时
构造可重复的测试数据与负载
构造可重复的测试数据与负载
本课建立一套可以反复重放的 Elasticsearch 测试输入:固定索引设置、固定文档内容、固定查询序列和并发度。完成后,你可以在调优前后重新生成同一数据集并施加同一负载,让吞吐与延迟变化具有可比性。
学习目标
- 用确定性规则生成内容、文档 ID 和时间字段完全一致的数据集。
- 通过 Bulk API 初始化固定规模的实验索引并验证文档数量。
- 用固定请求序列、预热次数和并发度产生可重复的查询负载。
固定测试契约
“同样跑 200 次搜索”并不等于同一负载。至少要固定索引名、分片数、文档数、字段映射、请求总量、并发度、查询分布与预热方式;集群节点数、JVM 堆和机器规格也应保持不变,否则结果变化可能来自环境而非调优项。
本课使用独立索引 lab-orders,固定 1 个主分片、0 个副本和 20,000 条文档。这个拓扑只为实验减少变量,不是生产配置建议。每次测量前删除并重建索引,可以避免旧文档、旧映射和历史删除记录污染输入。
生成完全一致的数据集
下面程序只使用 Python 标准库。文档字段由序号通过确定性公式生成,不调用随机数;Bulk action 使用固定 _id,并对 NDJSON 计算 SHA-256。只要程序和文档数不变,数据内容与哈希就应一致。
import hashlib
import json
import os
import urllib.error
import urllib.request
from datetime import datetime, timedelta, timezone
ES_URL = os.environ["ES_URL"].rstrip("/")
API_KEY = os.environ["ELASTIC_API_KEY"]
INDEX = "lab-orders"
DOCS = 20_000
# HTTP 封装统一认证与错误处理,404 只在清理旧索引时允许。
def request(method, path, body=None, content_type="application/json", allow_404=False):
headers = {"Authorization": f"ApiKey {API_KEY}"}
if body is not None:
headers["Content-Type"] = content_type
req = urllib.request.Request(ES_URL + path, data=body, headers=headers, method=method)
try:
with urllib.request.urlopen(req, timeout=60) as resp:
return resp.status, resp.read()
except urllib.error.HTTPError as exc:
if allow_404 and exc.code == 404:
return exc.code, exc.read()
raise
request("DELETE", f"/{INDEX}", allow_404=True)
# 固定分片、刷新周期与映射,避免索引结构成为隐藏变量。
settings = {
"settings": {
"number_of_shards": 1,
"number_of_replicas": 0,
"refresh_interval": "1s",
},
"mappings": {
"properties": {
"@timestamp": {"type": "date"},
"category": {"type": "keyword"},
"user_id": {"type": "keyword"},
"price_cents": {"type": "integer"},
"quantity": {"type": "short"},
"message": {"type": "text"},
}
},
}
request("PUT", f"/{INDEX}", json.dumps(settings).encode())
categories = ["books", "home", "toys", "sports", "beauty", "electronics"]
base = datetime(2026, 1, 1, tzinfo=timezone.utc)
lines = []
# 每个字段都由 i 推导,因此无需随机种子也能得到相同文档。
for i in range(DOCS):
action = {"index": {"_index": INDEX, "_id": str(i)}}
doc = {
"@timestamp": (base + timedelta(seconds=i * 3)).isoformat().replace("+00:00", "Z"),
"category": categories[i % len(categories)],
"user_id": f"user-{(i * 37) % 1000:04d}",
"price_cents": 1000 + (i * 7919) % 90000,
"quantity": 1 + i % 5,
"message": f"order event {i % 100} category {categories[i % len(categories)]}",
}
lines.append(json.dumps(action, separators=(",", ":"), sort_keys=True))
lines.append(json.dumps(doc, separators=(",", ":"), sort_keys=True))
payload = ("\n".join(lines) + "\n").encode()
digest = hashlib.sha256(payload).hexdigest()
# 单次 Bulk 写入后等待可搜索,再读取 count 做最终验收。
_, bulk_body = request(
"POST",
"/_bulk?refresh=wait_for&filter_path=errors,took",
payload,
"application/x-ndjson",
)
bulk = json.loads(bulk_body)
_, count_body = request("GET", f"/{INDEX}/_count")
count = json.loads(count_body)["count"]
print(f"dataset_sha256={digest}")
print(f"bulk_errors={str(bulk['errors']).lower()} bulk_took_ms={bulk['took']}")
print(f"count={count}")把它保存为 prepare_dataset.py 后执行:
export ES_URL="https://<HOST>:<PORT>"
export ELASTIC_API_KEY="<API_KEY>"
# 每轮实验都重新生成索引,随后核对 hash 与 count。
python3 prepare_dataset.py预期输出
dataset_sha256=<HASH>
bulk_errors=false bulk_took_ms=<VALUE>
count=20000<HASH> 在相同脚本与 DOCS 值下应保持不变,bulk_took_ms 会随机器和当时负载变化。refresh=wait_for 让 Bulk 请求等待本次写入对搜索可见后再返回,避免紧接着查询时看到不完整数据。
施加固定查询负载
测试负载也必须可重放。下面程序固定 20 次预热、总请求数和并发度,并按请求序号循环生成同一组 category 与价格区间。查询 URL 关闭 request cache,避免整个响应直接从请求缓存返回;其他 Elasticsearch 缓存和操作系统页缓存仍会参与,因此前后实验必须使用相同预热规则。
import concurrent.futures
import json
import math
import os
import sys
import time
import urllib.request
ES_URL = os.environ["ES_URL"].rstrip("/")
API_KEY = os.environ["ELASTIC_API_KEY"]
INDEX = "lab-orders"
TOTAL = int(sys.argv[1]) if len(sys.argv) > 1 else 200
CONCURRENCY = int(sys.argv[2]) if len(sys.argv) > 2 else 8
WARMUP = 20
CATEGORIES = ["books", "home", "toys", "sports"]
# 请求序号决定过滤条件,保证每轮出现相同的查询组合。
def search(i):
low = 5_000 + (i % 5) * 10_000
body = {
"size": 0,
"track_total_hits": False,
"query": {
"bool": {
"filter": [
{"term": {"category": CATEGORIES[i % len(CATEGORIES)]}},
{"range": {"price_cents": {"gte": low, "lt": low + 25_000}}},
]
}
},
"aggs": {"avg_price": {"avg": {"field": "price_cents"}}},
}
data = json.dumps(body, separators=(",", ":")).encode()
req = urllib.request.Request(
f"{ES_URL}/{INDEX}/_search?request_cache=false",
data=data,
headers={
"Authorization": f"ApiKey {API_KEY}",
"Content-Type": "application/json",
},
method="POST",
)
started = time.perf_counter()
try:
with urllib.request.urlopen(req, timeout=10) as resp:
resp.read()
return resp.status, (time.perf_counter() - started) * 1000
except Exception:
return 0, (time.perf_counter() - started) * 1000
def percentile(values, ratio):
pos = max(0, math.ceil(len(values) * ratio) - 1)
return values[pos]
# 预热不计入测量,避免第一批连接与缓存建立扭曲统计。
with concurrent.futures.ThreadPoolExecutor(max_workers=CONCURRENCY) as pool:
list(pool.map(search, range(WARMUP)))
started = time.perf_counter()
with concurrent.futures.ThreadPoolExecutor(max_workers=CONCURRENCY) as pool:
results = list(pool.map(search, range(TOTAL)))
elapsed = time.perf_counter() - started
# 延迟分位数只统计 HTTP 200;错误数单独报告,避免失败请求“拉低”延迟。
latencies = sorted(ms for status, ms in results if status == 200)
errors = TOTAL - len(latencies)
if not latencies:
raise SystemExit("all measured requests failed")
print(f"requests={TOTAL} errors={errors} concurrency={CONCURRENCY}")
print(f"elapsed_s={elapsed:.2f} rps={TOTAL / elapsed:.2f}")
print(f"p50_ms={percentile(latencies, 0.50):.2f} p95_ms={percentile(latencies, 0.95):.2f}")保存为 load.py,在每次调优前后都使用相同参数:
# 调优前后必须保持请求总量与并发度一致。
python3 load.py 200 8预期输出
requests=200 errors=0 concurrency=8
elapsed_s=<VALUE> rps=<VALUE>
p50_ms=<VALUE> p95_ms=<VALUE>这些延迟与吞吐值本来就会变化,所以不要把单次数字当结论。至少重复若干轮,记录每轮输出,并同时保存节点 CPU、JVM、线程池和索引统计,才能判断性能变化是否伴随资源代价。
保证调优前后公平
每次实验都重新运行 prepare_dataset.py,先核对 count=20000 和相同的 dataset_sha256,再使用同一个 load.py 参数。一次只修改一个主要变量,例如查询写法、索引设置或 JVM 配置;修改多个变量后即使结果更好,也很难说明是哪一项产生了作用。
如果测试目标是冷缓存、持续写入或不同查询分布,就应把这些条件明确写进新的测试契约,而不是临时手工操作。可重复测试的核心不是让每轮延迟完全相同,而是让输入、负载与环境约束足够一致,使差异能够归因。