NoSQL 与搜索 / 系统课时

构造可重复的测试数据与负载

构造可重复的测试数据与负载

本课建立一套可以反复重放的 Elasticsearch 测试输入:固定索引设置、固定文档内容、固定查询序列和并发度。完成后,你可以在调优前后重新生成同一数据集并施加同一负载,让吞吐与延迟变化具有可比性。

学习目标

  • 用确定性规则生成内容、文档 ID 和时间字段完全一致的数据集。
  • 通过 Bulk API 初始化固定规模的实验索引并验证文档数量。
  • 用固定请求序列、预热次数和并发度产生可重复的查询负载。

固定测试契约

“同样跑 200 次搜索”并不等于同一负载。至少要固定索引名、分片数、文档数、字段映射、请求总量、并发度、查询分布与预热方式;集群节点数、JVM 堆和机器规格也应保持不变,否则结果变化可能来自环境而非调优项。

本课使用独立索引 lab-orders,固定 1 个主分片、0 个副本和 20,000 条文档。这个拓扑只为实验减少变量,不是生产配置建议。每次测量前删除并重建索引,可以避免旧文档、旧映射和历史删除记录污染输入。

生成完全一致的数据集

下面程序只使用 Python 标准库。文档字段由序号通过确定性公式生成,不调用随机数;Bulk action 使用固定 _id,并对 NDJSON 计算 SHA-256。只要程序和文档数不变,数据内容与哈希就应一致。

python
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 后执行:

bash
export ES_URL="https://<HOST>:<PORT>"
export ELASTIC_API_KEY="<API_KEY>"
# 每轮实验都重新生成索引,随后核对 hash 与 count。
python3 prepare_dataset.py

预期输出

text
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 缓存和操作系统页缓存仍会参与,因此前后实验必须使用相同预热规则。

python
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,在每次调优前后都使用相同参数:

bash
# 调优前后必须保持请求总量与并发度一致。
python3 load.py 200 8

预期输出

text
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 配置;修改多个变量后即使结果更好,也很难说明是哪一项产生了作用。

如果测试目标是冷缓存、持续写入或不同查询分布,就应把这些条件明确写进新的测试契约,而不是临时手工操作。可重复测试的核心不是让每轮延迟完全相同,而是让输入、负载与环境约束足够一致,使差异能够归因。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

构造可重复的测试数据与负载

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通