#码力全开·技术π对#​​Bazel的增量构建为何比Make更可靠？​​

# 示例：定义一个简单的 Bazel 构建规则
cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
    deps = ["//lib:mylib"], # 明确声明依赖
)

数据源 → Cloud Pub/Sub (消息队列) → Cloud Functions (处理逻辑) → 目标系统(如BigQuery/Firestore/Storage)

# 创建主题
gcloud pubsub topics create realtime-data-topic

# 创建拉取订阅
gcloud pubsub subscriptions create data-process-sub \
  --topic=realtime-data-topic \
  --ack-deadline=60

# 创建推送订阅（推荐与Cloud Functions集成）
gcloud pubsub subscriptions create data-process-push-sub \
  --topic=realtime-data-topic \
  --push-endpoint=https://REGION-PROJECT_ID.cloudfunctions.net/processFunction \
  --ack-deadline=60

// index.js
const { PubSub } = require('@google-cloud/pubsub');
const pubsub = new PubSub();

exports.processFunction = async (message, context) => {
  try {
    const data = JSON.parse(Buffer.from(message.data, 'base64').toString());
    
    // 实时处理逻辑示例
    const processedData = {
      ...data,
      processedAt: new Date().toISOString(),
      derivedValue: calculateDerivedValue(data)
    };
    
    // 可选：发布到下游主题
    await publishToDownstream(processedData);
    
    console.log(`Processed record ID: ${data.id}`);
    return Promise.resolve();
  } catch (error) {
    console.error('Error:', error);
    return Promise.reject(error);
  }
};

async function publishToDownstream(data) {
  const topic = pubsub.topic('processed-data-topic');
  const messageId = await topic.publish(Buffer.from(JSON.stringify(data)));
  return messageId;
}

function calculateDerivedValue(data) {
  // 业务逻辑计算
  return data.value * 1.1;
}

# 部署处理函数（触发器设置为Pub/Sub）
gcloud functions deploy processFunction \
  --runtime nodejs14 \
  --trigger-topic realtime-data-topic \
  --region us-central1 \
  --entry-point processFunction \
  --timeout 540s \
  --memory 256MB \
  --max-instances 1000

# 设置最大实例数防止超额费用
gcloud functions deploy processFunction \
  --max-instances 100 \  # 控制最大并发
  --min-instances 1 \    # 预热实例
  --concurrency 50       # 单实例并发处理数

# 创建死信主题
gcloud pubsub topics create dead-letter-topic

# 更新订阅配置
gcloud pubsub subscriptions update data-process-push-sub \
  --dead-letter-topic dead-letter-topic \
  --max-delivery-attempts 5

// 在Cloud Function中实现窗口聚合
const windowSize = 60 * 1000; // 1分钟窗口
const windowCache = new Map();

exports.aggregateFunction = async (message, context) => {
  const data = decodeMessage(message);
  const windowKey = Math.floor(Date.now() / windowSize);
  
  if (!windowCache.has(windowKey)) {
    windowCache.set(windowKey, {
      count: 0,
      sum: 0,
      min: Infinity,
      max: -Infinity
    });
    
    // 设置窗口过期
    setTimeout(() => flushWindow(windowKey), windowSize);
  }
  
  const window = windowCache.get(windowKey);
  window.count++;
  window.sum += data.value;
  window.min = Math.min(window.min, data.value);
  window.max = Math.max(window.max, data.value);
};

function flushWindow(windowKey) {
  const stats = windowCache.get(windowKey);
  publishAggregation({
    windowStart: new Date(windowKey * windowSize),
    ...stats,
    avg: stats.sum / stats.count
  });
  windowCache.delete(windowKey);
}

// 使用状态机模式检测特定事件序列
const stateMachines = new Map();

exports.detectPattern = async (message) => {
  const event = decodeMessage(message);
  const machineId = event.userId || event.deviceId;
  
  if (!stateMachines.has(machineId)) {
    stateMachines.set(machineId, initStateMachine());
  }
  
  const machine = stateMachines.get(machineId);
  const nextState = machine.transition(event);
  
  if (nextState === 'PATTERN_COMPLETE') {
    triggerAction(machineId, machine.getContext());
    stateMachines.delete(machineId);
  }
};

# 创建监控告警策略
gcloud alpha monitoring policies create \
  --policy-from-file=alert-policy.json

{
  "displayName": "High Function Errors",
  "conditions": [{
    "conditionThreshold": {
      "filter": "resource.type=\"cloud_function\" AND metric.type=\"cloudfunctions.googleapis.com/function/execution_count\" AND metric.labels.state=\"error\"",
      "comparison": "COMPARISON_GT",
      "thresholdValue": 10,
      "duration": "60s",
      "aggregations": [{
        "alignmentPeriod": "60s",
        "perSeriesAligner": "ALIGN_RATE"
      }]
    }
  }],
  "combiner": "OR",
  "notificationChannels": ["projects/YOUR_PROJECT/notificationChannels/CHANNEL_ID"]
}

# 在Logs Explorer中使用的查询示例
resource.type="cloud_function"
logName="projects/YOUR_PROJECT/logs/cloudfunctions.googleapis.com%2Fcloud-functions"
severity>=ERROR

syntax = "proto3";
message SensorData {
  string device_id = 1;
  double value = 2;
  int64 timestamp = 3;
  map<string, string> metadata = 4;
}

// 指数退避重试逻辑
async function processWithRetry(message, attempts = 0) {
  try {
    return await processMessage(message);
  } catch (error) {
    if (isRetriable(error) && attempts < 3) {
      const delay = Math.pow(2, attempts) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
      return processWithRetry(message, attempts + 1);
    }
    throw error;
  }
}

exports.batchProcessor = async (pubSubMessage, context) => {
  const messages = pubSubMessage.data
    ? [pubSubMessage] 
    : pubSubMessage.map(msg => msg.data);
  
  await Promise.all(messages.map(processSingleMessage));
};

# 设置最小权限的服务账户
gcloud functions add-iam-policy-binding processFunction \
  --member=serviceAccount:processor@project.iam.gserviceaccount.com \
  --role=roles/pubsub.subscriber

设备 → Pub/Sub → 校验/标准化(CF) → 实时警报(CF) → 存储(BigQuery)
                       ↘ 聚合统计(CF) → 监控看板

用户行为 → Pub/Sub → 个性化推荐(CF) → 推送服务
             ↘ 实时计数(CF) → 库存系统
             ↘ 欺诈检测(CF) → 风控系统

游戏客户端 → Pub/Sub → 成就解锁(CF) → 玩家档案
               ↘ 反作弊分析(CF) → 封禁系统
               ↘ 实时排行榜(CF) → 显示服务