複数アプリを抱える個人開発者のための Gemini API コントロールプレーン設計

{
  "wallpaper_app": {
    "model": "gemini-3.1-flash",
    "fallback": "gemini-2.5-flash",
    "max_tokens": 1024,
    "rate_limit_per_minute": 30,
    "rollout_percent": 100,
    "budget_jpy_per_day": 800
  },
  "healing_app": {
    "model": "gemini-3.1-flash",
    "fallback": "gemini-2.5-flash",
    "max_tokens": 512,
    "rate_limit_per_minute": 20,
    "rollout_percent": 25,
    "budget_jpy_per_day": 300
  },
  "attraction_app": {
    "model": "gemini-2.5-flash",
    "fallback": "gemini-2.5-flash-lite",
    "max_tokens": 768,
    "rate_limit_per_minute": 15,
    "rollout_percent": 100,
    "budget_jpy_per_day": 200
  }
}

// worker/config.ts
type AppConfig = {
  model: string;
  fallback: string;
  max_tokens: number;
  rate_limit_per_minute: number;
  rollout_percent: number;
  budget_jpy_per_day: number;
};
 
let configCache: { value: Record<string, AppConfig>; expiresAt: number } | null = null;
 
export async function getAppConfig(env: Env, appId: string): Promise<AppConfig> {
  if (configCache && configCache.expiresAt > Date.now()) {
    return configCache.value[appId];
  }
 
  const token = await getRemoteConfigAccessToken(env);
  const res = await fetch(
    `https://firebaseremoteconfig.googleapis.com/v1/projects/${env.GCP_PROJECT}/remoteConfig`,
    { headers: { Authorization: `Bearer ${token}` } }
  );
  const body = await res.json<RemoteConfigResponse>();
  const raw = body.parameters.gemini_app_config.defaultValue.value;
  const parsed = JSON.parse(raw) as Record<string, AppConfig>;
 
  configCache = { value: parsed, expiresAt: Date.now() + 5 * 60 * 1000 };
  return parsed[appId];
}

// worker/router.ts
export async function generate(req: GenerateRequest, env: Env): Promise<GenerateResponse> {
  const cfg = await getAppConfig(env, req.appId);
 
  await assertWithinBudget(env, req.appId, cfg.budget_jpy_per_day);
  await assertRateLimit(env, req.appId, cfg.rate_limit_per_minute);
 
  const useNewModel = hashUser(req.userId) % 100 < cfg.rollout_percent;
  const model = useNewModel ? cfg.model : cfg.fallback;
 
  const t0 = Date.now();
  const result = await callGemini(env, model, req.prompt, cfg.max_tokens);
  const elapsed = Date.now() - t0;
 
  await emitTelemetry(env, {
    app_id: req.appId,
    model_used: model,
    rollout_branch: useNewModel ? "new" : "fallback",
    prompt_tokens: result.usageMetadata.promptTokenCount,
    output_tokens: result.usageMetadata.candidatesTokenCount,
    elapsed_ms: elapsed,
    timestamp: new Date().toISOString(),
  });
 
  return { text: result.text, model };
}

CREATE TABLE gemini_usage (
  timestamp TIMESTAMP NOT NULL,
  app_id STRING NOT NULL,
  model_used STRING NOT NULL,
  rollout_branch STRING NOT NULL,
  prompt_tokens INT64 NOT NULL,
  output_tokens INT64 NOT NULL,
  elapsed_ms INT64 NOT NULL
)
PARTITION BY DATE(timestamp);

SELECT
  DATE(timestamp, "Asia/Tokyo") AS jst_date,
  app_id,
  model_used,
  SUM(prompt_tokens) AS in_tokens,
  SUM(output_tokens) AS out_tokens,
  ROUND(
    SUM(prompt_tokens) / 1000000.0 * p.input_usd_per_1m +
    SUM(output_tokens) / 1000000.0 * p.output_usd_per_1m,
    4
  ) AS usd_estimated
FROM gemini_usage u
JOIN gemini_pricing p USING (model_used)
WHERE timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 30 DAY)
GROUP BY jst_date, app_id, model_used, p.input_usd_per_1m, p.output_usd_per_1m
ORDER BY jst_date DESC, usd_estimated DESC;