在云函数中调用云托管服务

在云函数中调用云托管服务是实现微服务架构的重要方式，可以让您在云函数中访问部署在云托管平台上的 HTTP 服务，实现服务间的高效通信和功能复用。

应用场景

典型使用场景

• 微服务架构：将不同业务模块部署为独立的云托管服务
• 服务解耦：通过 HTTP API 实现服务间的松耦合通信
• 资源优化：利用云托管的容器化部署和自动扩缩容能力
• 技术栈多样化：云函数和云托管可以使用不同的技术栈
• 长时间任务：将耗时操作委托给云托管服务处理

架构优势

• 弹性扩展：云托管服务可根据负载自动扩缩容
• 技术灵活性：不同服务可使用最适合的技术栈
• 独立部署：各服务可独立开发、测试和部署
• 资源隔离：服务间资源隔离，故障不会相互影响

调用方式概览

📄️ Node.js SDK 调用

在云函数中使用 Node.js SDK 调用云托管服务

📄️ HTTP API 调用

通过标准 HTTP API 调用云托管服务

📄️ 服务发现

了解云托管服务的发现和负载均衡机制

使用 Node.js SDK 调用

Node.js SDK 提供了 callContainer 方法来调用云托管服务，支持完整的 HTTP 请求配置。

基础调用

GET 请求

const tcb = require('@cloudbase/node-sdk');

exports.main = async (event, context) => {
  // 初始化 SDK
  const app = tcb.init({ context });
  
  try {
    // 调用云托管服务的 GET 接口
    const result = await app.callContainer({
      name: 'user-service',        // 云托管服务名
      method: 'GET',               // HTTP 方法
      path: '/api/users/profile',  // 请求路径
      header: {                    // 请求头
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${event.token}`,
        'X-Request-ID': context.request_id
      }
    });
    
    console.log('调用成功:', {
      statusCode: result.statusCode,
      data: result.data,
      requestId: result.requestId
    });
    
    return {
      success: true,
      user: result.data,
      statusCode: result.statusCode
    };
  } catch (error) {
    console.error('调用云托管服务失败:', error);
    return {
      success: false,
      error: error.message,
      code: error.code
    };
  }
};

POST 请求

const tcb = require('@cloudbase/node-sdk');

exports.main = async (event, context) => {
  const app = tcb.init({ context });
  
  try {
    // 调用云托管服务的 POST 接口
    const result = await app.callContainer({
      name: 'order-service',
      method: 'POST',
      path: '/api/orders',
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${event.token}`
      },
      data: {                      // 请求体数据
        userId: event.userId,
        items: event.items,
        totalAmount: event.totalAmount,
        timestamp: Date.now()
      }
    }, {
      timeout: 10000 // 10 秒超时
    });
    
    if (result.statusCode === 201) {
      return {
        success: true,
        order: result.data,
        message: '订单创建成功'
      };
    } else {
      return {
        success: false,
        error: '订单创建失败',
        statusCode: result.statusCode
      };
    }
  } catch (error) {
    console.error('创建订单失败:', error);
    throw error;
  }
};

PUT 请求

const tcb = require('@cloudbase/node-sdk');

exports.main = async (event, context) => {
  const app = tcb.init({ context });
  
  try {
    // 更新用户信息
    const result = await app.callContainer({
      name: 'user-service',
      method: 'PUT',
      path: `/api/users/${event.userId}`,
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${event.token}`
      },
      data: {
        name: event.name,
        email: event.email,
        phone: event.phone,
        updatedAt: new Date().toISOString()
      }
    });
    
    return {
      success: result.statusCode === 200,
      user: result.data,
      statusCode: result.statusCode
    };
  } catch (error) {
    console.error('更新用户信息失败:', error);
    throw error;
  }
};

DELETE 请求

const tcb = require('@cloudbase/node-sdk');

exports.main = async (event, context) => {
  const app = tcb.init({ context });
  
  try {
    // 删除资源
    const result = await app.callContainer({
      name: 'resource-service',
      method: 'DELETE',
      path: `/api/resources/${event.resourceId}`,
      header: {
        'Authorization': `Bearer ${event.token}`,
        'X-User-ID': event.userId
      }
    });
    
    return {
      success: result.statusCode === 204,
      message: result.statusCode === 204 ? '删除成功' : '删除失败',
      statusCode: result.statusCode
    };
  } catch (error) {
    console.error('删除资源失败:', error);
    throw error;
  }
};

高级功能

文件上传处理

const tcb = require('@cloudbase/node-sdk');

exports.main = async (event, context) => {
  const app = tcb.init({ context });
  
  try {
    // 调用文件处理服务
    const result = await app.callContainer({
      name: 'file-service',
      method: 'POST',
      path: '/api/files/process',
      header: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${event.token}`
      },
      data: {
        fileUrl: event.fileUrl,
        processType: event.processType,
        options: {
          quality: 80,
          format: 'webp',
          resize: { width: 800, height: 600 }
        }
      }
    }, {
      timeout: 30000 // 文件处理可能需要更长时间
    });
    
    return {
      success: true,
      processedFile: result.data,
      processingTime: result.header['X-Processing-Time']
    };
  } catch (error) {
    console.error('文件处理失败:', error);
    throw error;
  }
};

批量数据处理

const tcb = require('@cloudbase/node-sdk');

exports.main = async (event, context) => {
  const app = tcb.init({ context });
  
  // 分批处理大量数据
  const batchSize = 100;
  const results = [];
  
  for (let i = 0; i < event.data.length; i += batchSize) {
    const batch = event.data.slice(i, i + batchSize);
    
    try {
      const result = await app.callContainer({
        name: 'data-processor',
        method: 'POST',
        path: '/api/process/batch',
        header: {
          'Content-Type': 'application/json',
          'X-Batch-ID': `batch_${Math.floor(i / batchSize) + 1}`
        },
        data: {
          items: batch,
          batchIndex: Math.floor(i / batchSize),
          totalBatches: Math.ceil(event.data.length / batchSize)
        }
      });
      
      results.push({
        batchIndex: Math.floor(i / batchSize),
        success: true,
        processedCount: result.data.processedCount,
        data: result.data
      });
    } catch (error) {
      console.error(`批次 ${Math.floor(i / batchSize)} 处理失败:`, error);
      results.push({
        batchIndex: Math.floor(i / batchSize),
        success: false,
        error: error.message
      });
    }
  }
  
  return {
    totalBatches: results.length,
    successCount: results.filter(r => r.success).length,
    failedCount: results.filter(r => !r.success).length,
    results: results
  };
};

服务健康检查

const tcb = require('@cloudbase/node-sdk');

exports.main = async (event, context) => {
  const app = tcb.init({ context });
  
  const services = ['user-service', 'order-service', 'payment-service'];
  const healthChecks = [];
  
  // 并发检查所有服务健康状态
  const promises = services.map(async (serviceName) => {
    try {
      const startTime = Date.now();
      const result = await app.callContainer({
        name: serviceName,
        method: 'GET',
        path: '/health',
        header: {
          'User-Agent': 'CloudFunction-HealthCheck/1.0'
        }
      }, {
        timeout: 5000
      });
      
      const responseTime = Date.now() - startTime;
      
      return {
        service: serviceName,
        status: 'healthy',
        statusCode: result.statusCode,
        responseTime: responseTime,
        data: result.data
      };
    } catch (error) {
      return {
        service: serviceName,
        status: 'unhealthy',
        error: error.message,
        code: error.code
      };
    }
  });
  
  const results = await Promise.allSettled(promises);
  
  return {
    timestamp: new Date().toISOString(),
    totalServices: services.length,
    healthyServices: results.filter(r => 
      r.status === 'fulfilled' && r.value.status === 'healthy'
    ).length,
    results: results.map(r => 
      r.status === 'fulfilled' ? r.value : { error: r.reason }
    )
  };
};

使用 HTTP API 调用

除了 Node.js SDK，您也可以使用标准的 HTTP 客户端库来调用云托管服务。

使用 Axios

const axios = require('axios');

exports.main = async (event, context) => {
  // 构建云托管服务的完整 URL
  const serviceUrl = `https://${event.serviceName}-${process.env.TCB_ENV}.service.tcloudbase.com`;
  
  try {
    const response = await axios({
      method: 'POST',
      url: `${serviceUrl}/api/data/analyze`,
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${event.token}`,
        'X-Request-ID': context.request_id
      },
      data: {
        dataset: event.dataset,
        analysisType: event.analysisType,
        parameters: event.parameters
      },
      timeout: 30000
    });
    
    return {
      success: true,
      analysis: response.data,
      statusCode: response.status,
      headers: response.headers
    };
  } catch (error) {
    console.error('数据分析服务调用失败:', error.response?.data || error.message);
    
    return {
      success: false,
      error: error.response?.data?.message || error.message,
      statusCode: error.response?.status,
      code: error.code
    };
  }
};

使用原生 HTTPS 模块

const https = require('https');
const querystring = require('querystring');

exports.main = async (event, context) => {
  const postData = JSON.stringify({
    action: event.action,
    payload: event.payload
  });
  
  const options = {
    hostname: `${event.serviceName}-${process.env.TCB_ENV}.service.tcloudbase.com`,
    port: 443,
    path: '/api/webhook',
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Content-Length': Buffer.byteLength(postData),
      'Authorization': `Bearer ${event.token}`
    }
  };
  
  return new Promise((resolve, reject) => {
    const req = https.request(options, (res) => {
      let data = '';
      
      res.on('data', (chunk) => {
        data += chunk;
      });
      
      res.on('end', () => {
        try {
          const result = JSON.parse(data);
          resolve({
            success: res.statusCode === 200,
            data: result,
            statusCode: res.statusCode,
            headers: res.headers
          });
        } catch (error) {
          reject(new Error(`响应解析失败: ${error.message}`));
        }
      });
    });
    
    req.on('error', (error) => {
      reject(error);
    });
    
    req.write(postData);
    req.end();
  });
};

服务发现与负载均衡

服务注册与发现

const tcb = require('@cloudbase/node-sdk');

// 服务注册表（可以存储在数据库中）
const serviceRegistry = {
  'user-service': {
    instances: [
      { name: 'user-service-v1', weight: 70 },
      { name: 'user-service-v2', weight: 30 }
    ]
  },
  'order-service': {
    instances: [
      { name: 'order-service', weight: 100 }
    ]
  }
};

exports.main = async (event, context) => {
  const app = tcb.init({ context });
  
  // 根据权重选择服务实例
  const serviceName = selectServiceInstance(event.serviceType);
  
  try {
    const result = await app.callContainer({
      name: serviceName,
      method: event.method || 'GET',
      path: event.path,
      header: event.headers,
      data: event.data
    });
    
    return result;
  } catch (error) {
    // 如果调用失败，尝试故障转移
    console.error(`服务 ${serviceName} 调用失败，尝试故障转移`);
    return await fallbackService(event, app);
  }
};

function selectServiceInstance(serviceType) {
  const service = serviceRegistry[serviceType];
  if (!service || !service.instances.length) {
    throw new Error(`服务 ${serviceType} 不存在`);
  }
  
  // 基于权重的负载均衡
  const totalWeight = service.instances.reduce((sum, instance) => sum + instance.weight, 0);
  const random = Math.random() * totalWeight;
  
  let currentWeight = 0;
  for (const instance of service.instances) {
    currentWeight += instance.weight;
    if (random <= currentWeight) {
      return instance.name;
    }
  }
  
  return service.instances[0].name;
}

async function fallbackService(event, app) {
  // 实现故障转移逻辑
  const fallbackServices = ['fallback-service', 'backup-service'];
  
  for (const serviceName of fallbackServices) {
    try {
      const result = await app.callContainer({
        name: serviceName,
        method: event.method || 'GET',
        path: event.path,
        header: event.headers,
        data: event.data
      });
      
      console.log(`故障转移到服务 ${serviceName} 成功`);
      return result;
    } catch (error) {
      console.error(`故障转移服务 ${serviceName} 也失败了:`, error.message);
    }
  }
  
  throw new Error('所有服务都不可用');
}

断路器模式

const tcb = require('@cloudbase/node-sdk');

class CircuitBreaker {
  constructor(serviceName, options = {}) {
    this.serviceName = serviceName;
    this.failureThreshold = options.failureThreshold || 5;
    this.recoveryTimeout = options.recoveryTimeout || 60000;
    this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
    this.failureCount = 0;
    this.lastFailureTime = null;
  }
  
  async call(app, callOptions) {
    if (this.state === 'OPEN') {
      if (Date.now() - this.lastFailureTime > this.recoveryTimeout) {
        this.state = 'HALF_OPEN';
        console.log(`断路器 ${this.serviceName} 进入半开状态`);
      } else {
        throw new Error(`断路器 ${this.serviceName} 处于开启状态`);
      }
    }
    
    try {
      const result = await app.callContainer(callOptions);
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }
  
  onSuccess() {
    this.failureCount = 0;
    this.state = 'CLOSED';
    console.log(`断路器 ${this.serviceName} 重置为关闭状态`);
  }
  
  onFailure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();
    
    if (this.failureCount >= this.failureThreshold) {
      this.state = 'OPEN';
      console.log(`断路器 ${this.serviceName} 开启，失败次数: ${this.failureCount}`);
    }
  }
}

// 为每个服务创建断路器实例
const circuitBreakers = {
  'user-service': new CircuitBreaker('user-service'),
  'order-service': new CircuitBreaker('order-service'),
  'payment-service': new CircuitBreaker('payment-service')
};

exports.main = async (event, context) => {
  const app = tcb.init({ context });
  const breaker = circuitBreakers[event.serviceName];
  
  if (!breaker) {
    throw new Error(`未找到服务 ${event.serviceName} 的断路器`);
  }
  
  try {
    const result = await breaker.call(app, {
      name: event.serviceName,
      method: event.method,
      path: event.path,
      header: event.headers,
      data: event.data
    });
    
    return {
      success: true,
      data: result.data,
      circuitBreakerState: breaker.state
    };
  } catch (error) {
    console.error(`服务调用失败:`, error.message);
    
    return {
      success: false,
      error: error.message,
      circuitBreakerState: breaker.state,
      fallback: await getFallbackResponse(event)
    };
  }
};

async function getFallbackResponse(event) {
  // 返回降级响应
  return {
    message: '服务暂时不可用，请稍后重试',
    timestamp: new Date().toISOString(),
    requestId: event.requestId
  };
}

错误处理和重试

智能重试机制

const tcb = require('@cloudbase/node-sdk');

class RetryHandler {
  constructor(options = {}) {
    this.maxRetries = options.maxRetries || 3;
    this.baseDelay = options.baseDelay || 1000;
    this.maxDelay = options.maxDelay || 10000;
    this.retryableErrors = options.retryableErrors || [
      'TIMEOUT', 'NETWORK_ERROR', 'SERVICE_UNAVAILABLE'
    ];
  }
  
  async execute(fn) {
    let lastError;
    
    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
      try {
        return await fn();
      } catch (error) {
        lastError = error;
        
        if (attempt === this.maxRetries || !this.shouldRetry(error)) {
          throw error;
        }
        
        const delay = this.calculateDelay(attempt);
        console.log(`重试 ${attempt + 1}/${this.maxRetries}，延迟 ${delay}ms`);
        await this.sleep(delay);
      }
    }
    
    throw lastError;
  }
  
  shouldRetry(error) {
    return this.retryableErrors.includes(error.code) ||
           error.message.includes('timeout') ||
           error.message.includes('network');
  }
  
  calculateDelay(attempt) {
    // 指数退避 + 随机抖动
    const exponentialDelay = this.baseDelay * Math.pow(2, attempt);
    const jitter = Math.random() * 0.1 * exponentialDelay;
    return Math.min(exponentialDelay + jitter, this.maxDelay);
  }
  
  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

exports.main = async (event, context) => {
  const app = tcb.init({ context });
  const retryHandler = new RetryHandler({
    maxRetries: 3,
    baseDelay: 1000,
    maxDelay: 8000
  });
  
  try {
    const result = await retryHandler.execute(async () => {
      return await app.callContainer({
        name: event.serviceName,
        method: event.method,
        path: event.path,
        header: event.headers,
        data: event.data
      }, {
        timeout: 10000
      });
    });
    
    return {
      success: true,
      data: result.data,
      statusCode: result.statusCode
    };
  } catch (error) {
    console.error('重试后仍然失败:', error);
    
    return {
      success: false,
      error: error.message,
      code: error.code,
      retryAttempts: retryHandler.maxRetries
    };
  }
};

超时和熔断处理

const tcb = require('@cloudbase/node-sdk');

exports.main = async (event, context) => {
  const app = tcb.init({ context });
  
  // 设置不同类型请求的超时时间
  const timeoutConfig = {
    'quick': 3000,    // 快速查询
    'normal': 10000,  // 普通操作
    'heavy': 30000    // 重型计算
  };
  
  const timeout = timeoutConfig[event.operationType] || 10000;
  
  try {
    // 使用 Promise.race 实现超时控制
    const result = await Promise.race([
      app.callContainer({
        name: event.serviceName,
        method: event.method,
        path: event.path,
        header: {
          ...event.headers,
          'X-Timeout': timeout.toString(),
          'X-Operation-Type': event.operationType
        },
        data: event.data
      }),
      new Promise((_, reject) => 
        setTimeout(() => reject(new Error('请求超时')), timeout)
      )
    ]);
    
    return {
      success: true,
      data: result.data,
      responseTime: Date.now() - context.startTime
    };
  } catch (error) {
    if (error.message === '请求超时') {
      console.error(`请求超时 (${timeout}ms):`, event.serviceName);
      
      // 记录超时事件用于监控
      await recordTimeoutEvent(event.serviceName, timeout);
      
      return {
        success: false,
        error: '服务响应超时',
        timeout: timeout,
        suggestion: '请稍后重试或联系技术支持'
      };
    }
    
    throw error;
  }
};

async function recordTimeoutEvent(serviceName, timeout) {
  // 记录超时事件到监控系统
  console.log('记录超时事件:', {
    service: serviceName,
    timeout: timeout,
    timestamp: new Date().toISOString()
  });
}

性能优化建议

1. 连接池管理

const tcb = require('@cloudbase/node-sdk');

// 全局 SDK 实例，避免重复初始化
const app = tcb.init({ 
  env: tcb.SYMBOL_CURRENT_ENV,
  timeout: 30000
});

// 连接池配置
const connectionPool = {
  maxConnections: 10,
  keepAlive: true,
  keepAliveMsecs: 30000
};

exports.main = async (event, context) => {
  // 复用全局 SDK 实例
  const result = await app.callContainer({
    name: event.serviceName,
    method: event.method,
    path: event.path,
    header: event.headers,
    data: event.data
  });
  
  return result;
};

2. 请求合并和批处理

const tcb = require('@cloudbase/node-sdk');

class RequestBatcher {
  constructor(batchSize = 10, flushInterval = 100) {
    this.batchSize = batchSize;
    this.flushInterval = flushInterval;
    this.queue = [];
    this.timer = null;
  }
  
  async add(request) {
    return new Promise((resolve, reject) => {
      this.queue.push({ request, resolve, reject });
      
      if (this.queue.length >= this.batchSize) {
        this.flush();
      } else if (!this.timer) {
        this.timer = setTimeout(() => this.flush(), this.flushInterval);
      }
    });
  }
  
  async flush() {
    if (this.timer) {
      clearTimeout(this.timer);
      this.timer = null;
    }
    
    if (this.queue.length === 0) return;
    
    const batch = this.queue.splice(0);
    
    try {
      const results = await this.processBatch(batch.map(item => item.request));
      
      batch.forEach((item, index) => {
        item.resolve(results[index]);
      });
    } catch (error) {
      batch.forEach(item => {
        item.reject(error);
      });
    }
  }
  
  async processBatch(requests) {
    const app = tcb.init({ env: tcb.SYMBOL_CURRENT_ENV });
    
    // 将多个请求合并为一个批处理请求
    const result = await app.callContainer({
      name: 'batch-processor',
      method: 'POST',
      path: '/api/batch',
      data: {
        requests: requests,
        batchId: Date.now()
      }
    });
    
    return result.data.results;
  }
}

const batcher = new RequestBatcher(5, 50);

exports.main = async (event, context) => {
  try {
    const result = await batcher.add({
      serviceName: event.serviceName,
      method: event.method,
      path: event.path,
      data: event.data
    });
    
    return {
      success: true,
      data: result
    };
  } catch (error) {
    return {
      success: false,
      error: error.message
    };
  }
};

3. 缓存策略

const tcb = require('@cloudbase/node-sdk');

// 简单的内存缓存
class MemoryCache {
  constructor(ttl = 300000) { // 默认 5 分钟
    this.cache = new Map();
    this.ttl = ttl;
  }
  
  set(key, value) {
    this.cache.set(key, {
      value,
      timestamp: Date.now()
    });
  }
  
  get(key) {
    const item = this.cache.get(key);
    if (!item) return null;
    
    if (Date.now() - item.timestamp > this.ttl) {
      this.cache.delete(key);
      return null;
    }
    
    return item.value;
  }
  
  clear() {
    this.cache.clear();
  }
}

const cache = new MemoryCache(300000); // 5 分钟缓存

exports.main = async (event, context) => {
  const app = tcb.init({ context });
  
  // 生成缓存键
  const cacheKey = `${event.serviceName}_${event.method}_${event.path}_${JSON.stringify(event.data)}`;
  
  // 尝试从缓存获取
  const cachedResult = cache.get(cacheKey);
  if (cachedResult) {
    console.log('缓存命中:', cacheKey);
    return {
      success: true,
      data: cachedResult,
      fromCache: true
    };
  }
  
  try {
    const result = await app.callContainer({
      name: event.serviceName,
      method: event.method,
      path: event.path,
      header: event.headers,
      data: event.data
    });
    
    // 只缓存成功的响应
    if (result.statusCode === 200) {
      cache.set(cacheKey, result.data);
    }
    
    return {
      success: true,
      data: result.data,
      fromCache: false
    };
  } catch (error) {
    console.error('服务调用失败:', error);
    throw error;
  }
};

监控和日志

调用链追踪

const tcb = require('@cloudbase/node-sdk');

exports.main = async (event, context) => {
  const app = tcb.init({ context });
  
  // 生成追踪 ID
  const traceId = event.traceId || `trace_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  const spanId = `span_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  
  console.log('开始调用链追踪:', {
    traceId,
    spanId,
    service: event.serviceName,
    operation: `${event.method} ${event.path}`
  });
  
  const startTime = Date.now();
  
  try {
    const result = await app.callContainer({
      name: event.serviceName,
      method: event.method,
      path: event.path,
      header: {
        ...event.headers,
        'X-Trace-ID': traceId,
        'X-Span-ID': spanId,
        'X-Parent-Span-ID': event.parentSpanId || '',
        'X-Caller': context.function_name
      },
      data: event.data
    });
    
    const duration = Date.now() - startTime;
    
    console.log('调用链完成:', {
      traceId,
      spanId,
      duration: `${duration}ms`,
      statusCode: result.statusCode,
      success: true
    });
    
    return {
      success: true,
      data: result.data,
      tracing: {
        traceId,
        spanId,
        duration
      }
    };
  } catch (error) {
    const duration = Date.now() - startTime;
    
    console.error('调用链失败:', {
      traceId,
      spanId,
      duration: `${duration}ms`,
      error: error.message,
      success: false
    });
    
    throw error;
  }
};

性能监控

const tcb = require('@cloudbase/node-sdk');

class PerformanceMonitor {
  constructor() {
    this.metrics = {
      totalCalls: 0,
      successCalls: 0,
      failedCalls: 0,
      totalResponseTime: 0,
      slowCalls: 0
    };
  }
  
  recordCall(duration, success, isSlowCall = false) {
    this.metrics.totalCalls++;
    this.metrics.totalResponseTime += duration;
    
    if (success) {
      this.metrics.successCalls++;
    } else {
      this.metrics.failedCalls++;
    }
    
    if (isSlowCall) {
      this.metrics.slowCalls++;
    }
  }
  
  getStats() {
    return {
      ...this.metrics,
      successRate: (this.metrics.successCalls / this.metrics.totalCalls * 100).toFixed(2),
      averageResponseTime: (this.metrics.totalResponseTime / this.metrics.totalCalls).toFixed(2),
      slowCallRate: (this.metrics.slowCalls / this.metrics.totalCalls * 100).toFixed(2)
    };
  }
}

const monitor = new PerformanceMonitor();

exports.main = async (event, context) => {
  const app = tcb.init({ context });
  const startTime = Date.now();
  
  try {
    const result = await app.callContainer({
      name: event.serviceName,
      method: event.method,
      path: event.path,
      header: event.headers,
      data: event.data
    });
    
    const duration = Date.now() - startTime;
    const isSlowCall = duration > 5000; // 超过 5 秒认为是慢调用
    
    monitor.recordCall(duration, true, isSlowCall);
    
    // 定期输出统计信息
    if (monitor.metrics.totalCalls % 100 === 0) {
      console.log('性能统计:', monitor.getStats());
    }
    
    return {
      success: true,
      data: result.data,
      performance: {
        responseTime: duration,
        isSlowCall
      }
    };
  } catch (error) {
    const duration = Date.now() - startTime;
    monitor.recordCall(duration, false);
    
    console.error('调用失败:', {
      service: event.serviceName,
      duration: `${duration}ms`,
      error: error.message
    });
    
    throw error;
  }
};

相关文档

• Node.js SDK 云托管调用
• HTTP API 云托管调用
• 云托管服务部署
• 云函数开发指南
• 微服务架构最佳实践