云客服系统 400 电话全栈技术方案：基于阿里云架构的设计与实践

┌─────────────────────────────────────────────────────────────────────┐
│                          客户侧（拨打400）                            │
│                        手机 / 固话 / 企业总机                          │
└──────────────────────────────┬──────────────────────────────────────┘
                               │ PSTN / 运营商线路
                               ▼
┌─────────────────────────────────────────────────────────────────────┐
│                      运营商网络 → SIP中继                            │
│              三大运营商 400号码资源 / 数字中继 / SIP中继               │
└──────────────────────────────┬──────────────────────────────────────┘
                               │ SIP协议
                               ▼
┌─────────────────────────────────────────────────────────────────────┐
│                    阿里云接入层（SLB + EIP）                          │
│              负载均衡SLB  →  弹性公网EIP  →  DDoS防护                 │
└──────────────────────────────┬──────────────────────────────────────┘
                               ▼
┌─────────────────────────────────────────────────────────────────────┐
│                    通信层（ACK容器化部署）                             │
│  ┌────────────┐  ┌────────────┐  ┌────────────┐  ┌────────────┐    │
│  │ FreeSWITCH │  │ FreeSWITCH │  │ FreeSWITCH │  │  弹性伸缩组 │    │
│  │   Pod-1    │  │   Pod-2    │  │   Pod-3    │  │  (HPA)     │    │
│  └────────────┘  └────────────┘  └────────────┘  └────────────┘    │
│                        Kafka 事件总线                                │
└──────────────────────────────┬──────────────────────────────────────┘
                               │ 事件 / API
                               ▼
┌─────────────────────────────────────────────────────────────────────┐
│                    业务服务层（微服务架构）                            │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐            │
│  │ 呼叫控制 │  │ 坐席管理 │  │ 智能路由 │  │ IVR引擎  │            │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘            │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐            │
│  │ 工单系统 │  │ 质检系统 │  │ 报表统计 │  │ 知识库   │            │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘            │
└──────────────────────────────┬──────────────────────────────────────┘
                               │
          ┌────────────────────┼────────────────────┐
          ▼                    ▼                    ▼
┌───────────────┐    ┌───────────────┐    ┌───────────────┐
│   数据存储层   │    │   AI能力层     │    │   前端接入层   │
│  RDS / PolarDB │    │  阿里云NLS    │    │  CDN / OSS    │
│  Redis 缓存   │    │  语音识别/合成  │    │  坐席工作台   │
│  OSS 录音存储  │    │  智能质检     │    │  WebSocket    │
│  Elasticsearch│    │  智能路由     │    │  来电弹屏     │
└───────────────┘    └───────────────┘    └───────────────┘

# FreeSWITCH 容器镜像
FROM debian:bullseye-slim
LABEL maintainer="cloud-cs-team"
# 安装依赖
RUN apt-get update && apt-get install -y \
    freeswitch \
    freeswitch-mod-console \
    freeswitch-mod-logfile \
    freeswitch-mod-sofia \
    freeswitch-mod-dialplan-xml \
    freeswitch-mod-commands \
    freeswitch-mod-dptools \
    freeswitch-mod-event-socket \
    freeswitch-mod-json-cdr \
    freeswitch-mod-shout \
    freeswitch-mod-sndfile \
    freeswitch-mod-native-file \
    && rm -rf /var/lib/apt/lists/*
# 复制配置文件
COPY conf/ /etc/freeswitch/
# 复制启动脚本
COPY docker-entrypoint.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/docker-entrypoint.sh
# 暴露端口
# SIP信令端口
EXPOSE 5060/udp
EXPOSE 5060/tcp
# RTP媒体端口范围
EXPOSE 16384-32768/udp
# ESL事件端口
EXPOSE 8021/tcp
# 数据卷
VOLUME ["/etc/freeswitch", "/var/log/freeswitch", "/var/lib/freeswitch/recordings"]
ENTRYPOINT ["docker-entrypoint.sh"]
CMD ["freeswitch", "-nf", "-u", "freeswitch", "-g", "freeswitch"]

apiVersion: apps/v1
kind: Deployment
metadata:
  name: freeswitch
  namespace: cloud-cs
spec:
  replicas: 3
  selector:
    matchLabels:
      app: freeswitch
  template:
    metadata:
      labels:
        app: freeswitch
    spec:
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchExpressions:
                - key: app
                  operator: In
                  values:
                  - freeswitch
              topologyKey: topology.kubernetes.io/zone
      containers:
      - name: freeswitch
        image: registry.cn-beijing.aliyuncs.com/your-org/freeswitch:1.10.9
        ports:
        - name: sip-udp
          containerPort: 5060
          protocol: UDP
        - name: sip-tcp
          containerPort: 5060
          protocol: TCP
        - name: esl
          containerPort: 8021
          protocol: TCP
        - name: rtp-min
          containerPort: 16384
          protocol: UDP
        - name: rtp-max
          containerPort: 32768
          protocol: UDP
        resources:
          requests:
            cpu: "2"
            memory: "4Gi"
          limits:
            cpu: "4"
            memory: "8Gi"
        volumeMounts:
        - name: recordings
          mountPath: /var/lib/freeswitch/recordings
        - name: config
          mountPath: /etc/freeswitch
        env:
        - name: POD_IP
          valueFrom:
            fieldRef:
              fieldPath: status.podIP
      volumes:
      - name: recordings
        emptyDir: {}
      - name: config
        configMap:
          name: freeswitch-config
---
# HPA 弹性伸缩配置
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: freeswitch-hpa
  namespace: cloud-cs
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: freeswitch
  minReplicas: 2
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 60
  - type: Pods
    pods:
      metric:
        name: active_calls
      target:
        type: AverageValue
        averageValue: 50

/**
 * 智能IVR服务
 * 基于阿里云NLS实现语音交互
 */
@Service
public class SmartIVRService {
    
    @Autowired
    private NlsClient nlsClient;
    
    @Autowired
    private FreeSwitchEslClient eslClient;
    
    private static final String WELCOME_PROMPT = 
        "欢迎致电智能客服，请问有什么可以帮您？";
    
    /**
     * 启动智能IVR流程
     */
    public void startIVR(String callUuid, String callerNumber) {
        // 1. 播放欢迎语
        playPrompt(callUuid, WELCOME_PROMPT);
        
        // 2. 启动语音识别，等待用户说话
        startAsrRecognition(callUuid, new NlsListener() {
            @Override
            public void onRecognitionResult(String text) {
                // 3. 识别用户意图
                IntentResult intent = recognizeIntent(text);
                
                // 4. 根据意图执行不同操作
                switch (intent.getIntentType()) {
                    case "business_inquiry":
                        handleBusinessInquiry(callUuid, intent);
                        break;
                    case "after_sales":
                        handleAfterSales(callUuid, intent);
                        break;
                    case "complaint":
                        handleComplaint(callUuid, intent);
                        break;
                    case "human_agent":
                        // 转人工
                        transferToAgent(callUuid, callerNumber);
                        break;
                    default:
                        // 没识别清楚，再问一遍
                        playPrompt(callUuid, "抱歉，我没有听清，请您再说一遍");
                        startAsrRecognition(callUuid, this);
                }
            }
            
            @Override
            public void onError(String errorMsg) {
                // 识别失败，转人工
                transferToAgent(callUuid, callerNumber);
            }
        });
    }
    
    /**
     * 播放语音提示（TTS合成）
     */
    private void playPrompt(String callUuid, String text) {
        // 调用阿里云TTS合成语音
        String audioUrl = nlsClient.synthesize(text, "xiaoyun", "mp3");
        
        // 播放给用户
        eslClient.playAudio(callUuid, audioUrl);
    }
    
    /**
     * 启动实时语音识别
     */
    private void startAsrRecognition(String callUuid, NlsListener listener) {
        // 启动实时语音识别流
        NlsSpeechRecognizer recognizer = nlsClient.createRecognizer(
            callUuid,  // 会话ID
            new SpeechRecognizerListener() {
                @Override
                public void onRecognitionResultChanged(
                        SpeechRecognitionResultChangedEvent event) {
                    // 中间结果，可以用于实时转写展示
                }
                
                @Override
                public void onRecognitionCompleted(
                        SpeechRecognitionCompletedEvent event) {
                    // 最终识别结果
                    listener.onRecognitionResult(event.getRecognizedText());
                }
                
                @Override
                public void onFail(SpeechRecognitionFailEvent event) {
                    listener.onError(event.getErrorMessage());
                }
            }
        );
        
        // 将通话音频桥接到识别流
        eslClient.bridgeAudioToRecognition(callUuid, recognizer);
    }
    
    /**
     * 意图识别（可以对接大模型）
     */
    private IntentResult recognizeIntent(String text) {
        // 方式一：规则匹配（简单场景）
        if (text.contains("咨询") || text.contains("办理") || text.contains("买")) {
            return new IntentResult("business_inquiry", text);
        }
        if (text.contains("售后") || text.contains("维修") || text.contains("退货")) {
            return new IntentResult("after_sales", text);
        }
        if (text.contains("投诉") || text.contains("举报") || text.contains("不满意")) {
            return new IntentResult("complaint", text);
        }
        if (text.contains("人工") || text.contains("客服") || text.contains("转人工")) {
            return new IntentResult("human_agent", text);
        }
        
        // 方式二：调用NLU模型或大模型（复杂场景）
        // IntentResult result = nluService.recognize(text);
        
        return new IntentResult("unknown", text);
    }
    
    /**
     * 转人工坐席
     */
    private void transferToAgent(String callUuid, String callerNumber) {
        // 查询空闲坐席
        Agent agent = agentService.getIdleAgent();
        
        if (agent != null) {
            // 桥接到坐席
            eslClient.bridgeCall(callUuid, agent.getSipUri());
            // 通知坐席来电弹屏
            websocketService.sendCallerPopup(agent.getId(), callerNumber, callUuid);
        } else {
            // 没有空闲坐席，加入排队
            queueService.addToQueue(callUuid, callerNumber);
            playPrompt(callUuid, "客服坐席全忙，请您稍候，我们会尽快为您服务");
        }
    }
}

/**
 * 通话录音服务
 * 基于阿里云OSS实现录音存储、管理、播放
 */
@Service
public class RecordingService {
    
    @Autowired
    private OSS ossClient;
    
    @Value("${aliyun.oss.bucket}")
    private String bucketName;
    
    @Value("${aliyun.oss.endpoint}")
    private String endpoint;
    
    private static final String RECORDING_PREFIX = "call-recordings/";
    
    /**
     * 通话结束后上传录音文件到OSS
     */
    public void uploadRecording(String callId, String localFilePath) {
        String ossKey = buildOssKey(callId, localFilePath);
        
        try {
            // 上传文件
            ossClient.putObject(bucketName, ossKey, new File(localFilePath));
            
            // 设置文件元信息
            ObjectMetadata metadata = new ObjectMetadata();
            metadata.setContentType("audio/mpeg");
            metadata.addUserMetadata("call-id", callId);
            metadata.addUserMetadata("upload-time", 
                LocalDateTime.now().toString());
            
            // 更新数据库
            callRecordService.updateRecordingInfo(callId, 
                "https://" + bucketName + "." + endpoint + "/" + ossKey,
                getFileSize(localFilePath));
            
            // 上传成功后删除本地文件
            Files.deleteIfExists(Paths.get(localFilePath));
            
            log.info("录音上传成功: callId={}, ossKey={}", callId, ossKey);
            
        } catch (Exception e) {
            log.error("录音上传失败: callId={}", callId, e);
            // 失败重试或告警
        }
    }
    
    /**
     * 获取录音播放链接（带签名，安全可控）
     */
    public String getPlayUrl(String callId, long expireSeconds) {
        CallRecord record = callRecordService.getByCallId(callId);
        if (record == null || record.getRecordingUrl() == null) {
            return null;
        }
        
        // 提取ossKey
        String ossKey = extractOssKey(record.getRecordingUrl());
        
        // 生成带签名的临时访问URL
        Date expiration = new Date(System.currentTimeMillis() + expireSeconds * 1000);
        URL signedUrl = ossClient.generatePresignedUrl(
            bucketName, ossKey, expiration);
        
        return signedUrl.toString();
    }
    
    /**
     * 构建OSS存储路径
     * 按日期分层，便于管理和生命周期管理
     */
    private String buildOssKey(String callId, String filePath) {
        String date = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy/MM/dd"));
        String ext = FilenameUtils.getExtension(filePath);
        return RECORDING_PREFIX + date + "/" + callId + "." + ext;
    }
    
    /**
     * 配置OSS生命周期规则（建议在控制台配置）
     * 
     * 30天内：标准存储（频繁访问）
     * 30-180天：低频访问存储（访问较少）
     * 180天-3年：归档存储（几乎不访问，合规留存）
     * 3年以上：删除（根据合规要求调整）
     */
    public void configureLifecycle() {
        // 也可以通过阿里云控制台或Terraform配置
        List<LifecycleRule> rules = new ArrayList<>();
        
        // 30天后转低频
        LifecycleRule rule1 = new LifecycleRule();
        rule1.setId("transition-to-ia-after-30d");
        rule1.setPrefix(RECORDING_PREFIX);
        rule1.setTransitionCount(1);
        rule1.setTransition(0, StorageClass.IA, 30);
        rules.add(rule1);
        
        // 180天后转归档
        LifecycleRule rule2 = new LifecycleRule();
        rule2.setId("transition-to-archive-after-180d");
        rule2.setPrefix(RECORDING_PREFIX);
        rule2.setTransitionCount(1);
        rule2.setTransition(0, StorageClass.Archive, 180);
        rules.add(rule2);
        
        // 3年后删除
        LifecycleRule rule3 = new LifecycleRule();
        rule3.setId("delete-after-3years");
        rule3.setPrefix(RECORDING_PREFIX);
        rule3.setExpirationDays(1095); // 3年
        rules.add(rule3);
        
        SetBucketLifecycleRequest request = 
            new SetBucketLifecycleRequest(bucketName, rules);
        ossClient.setBucketLifecycle(request);
    }
}

/**
 * 来电事件推送服务
 * 基于WebSocket实现实时来电弹屏
 */
@Service
public class CallerPopupService {
    
    @Autowired
    private SimpMessagingTemplate messagingTemplate;
    
    @Autowired
    private CustomerService customerService;
    
    @Autowired
    private AgentService agentService;
    
    /**
     * 处理来电事件，推送给目标坐席
     */
    public void handleIncomingCall(String callId, String callerNumber, 
                                   String targetAgentId) {
        // 1. 查询客户信息
        Customer customer = customerService.findByPhone(callerNumber);
        
        // 2. 查询历史记录
        List<CallRecord> history = callRecordService.
            getRecentCalls(callerNumber, 5);
        
        // 3. 查询待办工单
        List<Ticket> pendingTickets = ticketService.
            getPendingByPhone(callerNumber);
        
        // 4. 构建弹屏数据
        CallerPopupData popupData = CallerPopupData.builder()
            .callId(callId)
            .callerNumber(callerNumber)
            .callTime(LocalDateTime.now())
            .customer(customer)
            .recentCalls(history)
            .pendingTickets(pendingTickets)
            .callType(inferCallType(customer, history))
            .build();
        
        // 5. 通过WebSocket推送给坐席
        messagingTemplate.convertAndSendToUser(
            targetAgentId,
            "/topic/calls/incoming",
            popupData
        );
        
        log.info("来电弹屏已推送: agent={}, caller={}", 
            targetAgentId, callerNumber);
    }
    
    /**
     * 通话结束事件推送
     */
    public void handleCallEnded(String callId, String agentId, 
                                CallSummary summary) {
        messagingTemplate.convertAndSendToUser(
            agentId,
            "/topic/calls/ended",
            CallEndedEvent.builder()
                .callId(callId)
                .duration(summary.getDuration())
                .recordingUrl(summary.getRecordingUrl())
                .suggestedActions(summary.getSuggestedActions())
                .build()
        );
    }
    
    /**
     * 推断来电类型（基于历史和客户信息）
     */
    private String inferCallType(Customer customer, 
                                 List<CallRecord> history) {
        // 简单规则，实际可以用模型预测
        if (history != null && !history.isEmpty()) {
            CallRecord last = history.get(0);
            if ("售后".equals(last.getCategory())) {
                return "售后回访";
            }
        }
        if (customer != null && customer.getLevel() >= 3) {
            return "VIP客户来电";
        }
        return "普通来电";
    }
}

// 来电弹屏组件
<script setup>
import { ref, onMounted, onUnmounted, watch } from 'vue'
import { useWebSocket } from '@vueuse/core'
const visible = ref(false)
const popupData = ref(null)
const ringtone = ref(null)
// WebSocket连接
const { status, data, send } = useWebSocket(
  'wss://your-cs-domain.com/ws/call',
  {
    autoReconnect: true,
    heartbeat: {
      message: 'ping',
      interval: 30000
    }
  }
)
// 监听消息
watch(data, (msg) => {
  if (!msg) return
  
  const event = JSON.parse(msg)
  
  if (event.type === 'incoming_call') {
    // 显示弹屏
    popupData.value = event.data
    visible.value = true
    // 播放铃声
    playRingtone()
  } else if (event.type === 'call_answered') {
    // 停止铃声
    stopRingtone()
  } else if (event.type === 'call_ended') {
    // 通话结束，延迟关闭弹屏
    setTimeout(() => {
      visible.value = false
    }, 5000)
  }
})
function playRingtone() {
  if (!ringtone.value) {
    ringtone.value = new Audio('/sounds/ringtone.mp3')
    ringtone.value.loop = true
  }
  ringtone.value.play().catch(() => {
    // 浏览器可能阻止自动播放
    console.log('铃声播放被阻止')
  })
}
function stopRingtone() {
  if (ringtone.value) {
    ringtone.value.pause()
    ringtone.value.currentTime = 0
  }
}
// 接听
function answerCall() {
  send(JSON.stringify({
    action: 'answer',
    callId: popupData.value.callId
  }))
  stopRingtone()
}
// 挂断
function hangupCall() {
  send(JSON.stringify({
    action: 'hangup',
    callId: popupData.value.callId
  }))
  visible.value = false
  stopRingtone()
}
// 转接
function transferCall(targetAgent) {
  send(JSON.stringify({
    action: 'transfer',
    callId: popupData.value.callId,
    targetAgent: targetAgent
  }))
}
</script>

/**
 * 智能路由服务
 * 根据客户信息、坐席状态、历史记录等，选择最合适的坐席
 */
@Service
public class SmartRoutingService {
    
    @Autowired
    private AgentService agentService;
    
    @Autowired
    private CustomerService customerService;
    
    @Autowired
    private SkillService skillService;
    
    /**
     * 为来电选择最合适的坐席
     */
    public Agent route(String callerNumber, String intent) {
        // 1. 查询客户信息
        Customer customer = customerService.findByPhone(callerNumber);
        
        // 2. 获取所有空闲坐席
        List<Agent> idleAgents = agentService.getIdleAgents();
        
        if (idleAgents.isEmpty()) {
            return null; // 没有空闲坐席，进入排队
        }
        
        // 3. 计算每个坐席的匹配分数
        List<AgentScore> scores = idleAgents.stream()
            .map(agent -> calculateScore(agent, customer, intent))
            .sorted(Comparator.comparing(AgentScore::getScore).reversed())
            .collect(Collectors.toList());
        
        // 4. 返回分数最高的坐席
        return scores.isEmpty() ? null : scores.get(0).getAgent();
    }
    
    /**
     * 计算坐席匹配分数
     */
    private AgentScore calculateScore(Agent agent, 
                                      Customer customer, 
                                      String intent) {
        double score = 0;
        
        // 维度1：技能匹配（权重40%）
        double skillScore = calculateSkillScore(agent, intent);
        score += skillScore * 0.4;
        
        // 维度2：历史服务（权重25%）
        double historyScore = calculateHistoryScore(agent, customer);
        score += historyScore * 0.25;
        
        // 维度3：服务等级（权重20%）
        double levelScore = calculateLevelScore(agent, customer);
        score += levelScore * 0.2;
        
        // 维度4：当前负载（权重15%）
        double loadScore = calculateLoadScore(agent);
        score += loadScore * 0.15;
        
        return new AgentScore(agent, score);
    }
    
    /**
     * 技能匹配分数
     */
    private double calculateSkillScore(Agent agent, String intent) {
        if (intent == null) return 0.5;
        
        Set<String> agentSkills = skillService.getAgentSkills(agent.getId());
        
        // 意图和技能匹配
        if ("business_inquiry".equals(intent) && 
            agentSkills.contains("sales")) {
            return 1.0;
        }
        if ("after_sales".equals(intent) && 
            agentSkills.contains("after_sales")) {
            return 1.0;
        }
        if ("complaint".equals(intent) && 
            agentSkills.contains("complaint")) {
            return 1.0;
        }
        
        // 通用坐席
        if (agentSkills.contains("general")) {
            return 0.6;
        }
        
        return 0.2;
    }
    
    /**
     * 历史服务分数
     * 优先分配给之前服务过的坐席，客户体验更好
     */
    private double calculateHistoryScore(Agent agent, 
                                         Customer customer) {
        if (customer == null) return 0.3;
        
        // 查询该坐席是否服务过这个客户
        int serviceCount = callRecordService.
            countServiceHistory(agent.getId(), customer.getId());
        
        if (serviceCount > 10) {
            return 1.0; // 老熟人，优先分配
        } else if (serviceCount > 0) {
            return 0.7;
        }
        
        return 0.3;
    }
    
    /**
     * 客户等级匹配
     * VIP客户分配给高级坐席
     */
    private double calculateLevelScore(Agent agent, 
                                       Customer customer) {
        if (customer == null) return 0.5;
        
        int customerLevel = customer.getLevel();
        int agentLevel = agent.getLevel();
        
        // 等级匹配度
        int diff = Math.abs(customerLevel - agentLevel);
        if (diff == 0) return 1.0;
        if (diff == 1) return 0.7;
        if (diff == 2) return 0.4;
        return 0.2;
    }
    
    /**
     * 负载均衡
     * 优先分配给当天接电话少的坐席
     */
    private double calculateLoadScore(Agent agent) {
        int todayCalls = agentService.getTodayCallCount(agent.getId());
        
        // 接的越少分数越高
        if (todayCalls < 10) return 1.0;
        if (todayCalls < 30) return 0.7;
        if (todayCalls < 50) return 0.4;
        return 0.2;
    }
}

┌─────────────────────┐
              │   负载均衡SLB        │
              │   （多可用区）       │
              └─────────┬───────────┘
                        │
        ┌───────────────┴───────────────┐
        ▼                               ▼
┌───────────────┐              ┌───────────────┐
│  可用区A      │              │  可用区B      │
│  ┌─────────┐ │              │  ┌─────────┐ │
│  │ FreeSW- │ │              │  │ FreeSW- │ │
│  │ ITCH-1  │ │              │  │ ITCH-2  │ │
│  └─────────┘ │              │  └─────────┘ │
│  ┌─────────┐ │              │  ┌─────────┐ │
│  │ 业务服务 │ │              │  │ 业务服务 │ │
│  └─────────┘ │              │  └─────────┘ │
│  ┌─────────┐ │              │  ┌─────────┐ │
│  │ RDS主库 │ │◄─── 同步 ───►│  │ RDS备库 │ │
│  └─────────┘ │              │  └─────────┘ │
└───────────────┘              └───────────────┘

# sysctl.conf 系统参数优化
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.core.rmem_default = 262144
net.core.wmem_default = 262144
net.core.netdev_max_backlog = 30000
net.ipv4.ip_local_port_range = 1024 65535
fs.file-max = 1000000
# limits.conf
* soft nofile 65535
* hard nofile 65535
* soft nproc 65535
* hard nproc 65535

<!-- freeswitch/conf/autoload_configs/switch.conf.xml -->
<configuration name="switch.conf" description="Core Configuration">
  <settings>
    <!-- 最大会话数 -->
    <param name="max-sessions" value="1000"/>
    <!-- 每秒最大呼叫数 -->
    <param name="sessions-per-second" value="30"/>
    <!-- RTP端口范围 -->
    <param name="rtp-start-port" value="16384"/>
    <param name="rtp-end-port" value="32768"/>
    <!-- 启用媒体优化 -->
    <param name="enable-optimizations" value="true"/>
    <!-- 禁用不必要的模块，减少内存占用 -->
    <param name="disable-modules" value="mod_av,mod_vlc,mod_skypopen"/>
  </settings>
</configuration>