1
func (h *ProductHandler) Get(c *gin.Context) {
2
    id, _ := strconv.ParseInt(c.Param("id"), 10, 64)
3
    ctx := c.Request.Context()
4

5
    // 缓存 → 数据库 → 定价 API
6
    cached, _ := h.redis.Get(ctx, fmt.Sprintf("p:%d", id)).Bytes()
7
    if len(cached) > 0 {
8
        c.Data(http.StatusOK, "application/json", cached)
9
        return
10
    }
11
    product, _ := h.repo.GetByID(ctx, id)
12
    price, _ := h.pricing.Get(ctx, product.SKU)
13
    product.Price = price
14

15
    data, _ := json.Marshal(product)
16
    h.redis.Set(ctx, fmt.Sprintf("p:%d", id), data, 5*time.Minute)
17
    c.JSON(http.StatusOK, product)
18
}

1
@RestController
2
@RequestMapping("/products")
3
public class ProductController {
4
    @GetMapping("/{id}")
5
    public ResponseEntity<ProductDto> get(@PathVariable Long id) {
6
        Cache cache = cacheManager.getCache("products");
7
        ProductDto dto = cache.get(id, ProductDto.class);
8
        if (dto != null) return ResponseEntity.ok(dto);
9
        Product p = repo.findById(id).orElseThrow();
10
        BigDecimal price = pricing.get(p.getSku());
11
        dto = ProductDto.from(p, price);
12
        cache.put(id, dto);
13
        return ResponseEntity.ok(dto);
14
    }
15
}

1
import http from "k6/http";
2
import { check } from "k6";
3

4
export const options = {
5
  scenarios: {
6
    catalog_read: {
7
      executor: "ramping-vus",
8
      startVUs: 0,
9
      stages: [
10
        { duration: "60s", target: 500 },
11
        { duration: "8m", target: 500 },
12
        { duration: "1m", target: 0 },
13
      ],
14
      gracefulRampDown: "30s",
15
    },
16
  },
17
  thresholds: {
18
    http_req_duration: ["p(99)<500"],
19
    http_req_failed: ["rate<0.005"],
20
  },
21
};
22

23
const BASE = __ENV.TARGET || "http://api:8080";
24

25
export default function () {
26
  const id = 1 + (__ITER % 10000);
27
  const res = http.get(`${BASE}/products/${id}`);
28
  check(res, { "status is 200": (r) => r.status === 200 });
29
}

1
version: "3.9"
2
services:
3
  postgres:
4
    image: postgres:16-alpine
5
    environment:
6
      POSTGRES_PASSWORD: bench
7
      POSTGRES_DB: catalog
8
    volumes:
9
      - ./seed.sql:/docker-entrypoint-initdb.d/seed.sql:ro
10
    deploy:
11
      resources:
12
        limits: { cpus: "2.0", memory: 1G }
13
  redis:
14
    image: redis:7-alpine
15
    command: ["redis-server", "--maxmemory", "256mb", "--maxmemory-policy", "allkeys-lru"]
16
    deploy:
17
      resources:
18
        limits: { cpus: "0.5", memory: 320M }
19
  catalog-go:
20
    image: ghcr.io/example/catalog-go:1.24
21
    environment:
22
      DB_DSN: "postgres://postgres:bench@postgres:5432/catalog?sslmode=disable"
23
      REDIS_ADDR: "redis:6379"
24
      GOGC: "100"
25
      GOMEMLIMIT: "512MiB"
26
    ports: ["8080:8080"]
27
    depends_on: [postgres, redis]
28
    deploy:
29
      resources:
30
        limits: { cpus: "2.0", memory: 512M }
31
  catalog-java:
32
    image: ghcr.io/example/catalog-spring:21
33
    environment:
34
      JDK_JAVA_OPTIONS: >-
35
        -Xms512m -Xmx512m -XX:+UseZGC
36
        -XX:+AlwaysPreTouch -XX:+UseStringDeduplication
37
      SPRING_THREADS_VIRTUAL_ENABLED: "true"
38
      SPRING_DATASOURCE_URL: "jdbc:postgresql://postgres:5432/catalog"
39
      SPRING_REDIS_HOST: "redis"
40
    ports: ["8081:8080"]
41
    depends_on: [postgres, redis]
42
    deploy:
43
      resources:
44
        limits: { cpus: "2.0", memory: 768M }

1
#!/usr/bin/env bash
2
set -euo pipefail
3
NAME="${1:?stack name (go|java)}"
4
PORT="${2:?port}"
5
OUT="results/${NAME}-$(date -u +%Y%m%dT%H%M%SZ)"
6
mkdir -p "${OUT}"
7

8
echo "GET http://localhost:${PORT}/products/$((RANDOM % 10000 + 1))" \
9
  | vegeta attack -duration=60s -rate=200 > /dev/null
10

11
jq -nc --argjson n 10000 \
12
  '[range(1; $n)] | map({method:"GET", url:"http://localhost:'"${PORT}"'/products/\(.)"})' \
13
  | vegeta attack -targets=- -rate=2500 -duration=8m -workers=200 \
14
  | tee "${OUT}/raw.bin" \
15
  | vegeta report -type=hist -buckets='[0,5ms,10ms,25ms,50ms,100ms,250ms,500ms]' \
16
  | tee "${OUT}/histogram.txt"
17

18
vegeta report -type=json < "${OUT}/raw.bin" > "${OUT}/summary.json"
19
echo "Wrote ${OUT}/{raw.bin,histogram.txt,summary.json}"

1
groups:
2
  - name: cost_per_rps
3
    interval: 30s
4
    rules:
5
      - record: service:cpu_seconds:rate5m
6
        expr: sum by (service, runtime) (
7
                rate(container_cpu_usage_seconds_total{container!="POD",service!=""}[5m])
8
              )
9
      - record: service:requests:rate5m
10
        expr: sum by (service, runtime) (
11
                rate(http_requests_total{status!~"5.."}[5m])
12
              )
13
      - record: service:fargate_usd_per_vcpu_second
14
        expr: vector(0.04048 / 3600)
15
      - record: service:cost_per_million_requests
16
        expr: (service:cpu_seconds:rate5m * service:fargate_usd_per_vcpu_second * 1e6)
17
              / clamp_min(service:requests:rate5m, 1)
18
      - alert: RuntimeCostRegression
19
        expr: (service:cost_per_million_requests
20
                / on(service) group_left()
21
                avg_over_time(service:cost_per_million_requests[7d])) > 1.25
22
        for: 30m
23
        labels: { severity: warning }
24
        annotations:
25
          summary: "{{ $labels.service }} cost-per-Mreq is 25% above its 7-day baseline"
26
          description: "Likely causes: GC tuning regression, heap leak, or a hot path
27
                        that allocates per request. Check the JFR/pprof flame graph."

1
@BenchmarkMode(Mode.SingleShotTime)
2
@OutputTimeUnit(TimeUnit.MILLISECONDS)
3
@Fork(value = 25, jvmArgs = {"-Xms512m", "-Xmx512m", "-XX:+UseZGC"})
4
@Warmup(iterations = 0)
5
@Measurement(iterations = 1)
6
@State(Scope.Benchmark)
7
public class ColdStartBench {
8
    @Benchmark
9
    public void timeToFirstSuccessfulRequest(Blackhole bh) throws Exception {
10
        long start = System.nanoTime();
11
        Process p = new ProcessBuilder(
12
                "java", "-Xms512m", "-Xmx512m",
13
                "-XX:+UseZGC",
14
                "-jar", "build/libs/catalog-spring.jar")
15
            .redirectErrorStream(true)
16
            .start();
17
        try (HttpClient client = HttpClient.newHttpClient()) {
18
            HttpRequest probe = HttpRequest.newBuilder(
19
                    URI.create("http://localhost:8080/health"))
20
                .timeout(Duration.ofMillis(200))
21
                .build();
22
            while (true) {
23
                try {
24
                    if (client.send(probe, BodyHandlers.discarding()).statusCode() == 200) break;
25
                } catch (Exception ignore) { /* 尚未就绪 */ }
26
                Thread.sleep(25);
27
            }
28
            long elapsedMs = (System.nanoTime() - start) / 1_000_000;
29
            bh.consume(elapsedMs);
30
        } finally {
31
            p.destroy();
32
            p.waitFor(5, TimeUnit.SECONDS);
33
        }
34
    }
35
}