AFSIM分布式仿真最佳实践指南

一、分布式仿真架构设计原则

1.1 分层架构设计

图1：AFSIM分布式仿真推荐架构

┌─────────────────────────────────────────────────────────────────────┐ │ 分布式仿真系统架构 │ ├─────────────────┬─────────────────┬─────────────────┬───────────────┤ │ 应用层 │ 服务层 │ 通信层 │ 资源层 │ ├─────────────────┼─────────────────┼─────────────────┼───────────────┤ │• 仿真想定 │• 实体管理服务 │• HLA/DIS网关 │• 计算节点集群 │ │• 可视化客户端 │• 时间管理服务 │• 消息队列 │• 存储系统 │ │• 分析工具 │• 数据记录服务 │• 数据分发服务 │• 网络基础设施 │ │• 指挥控制界面 │• 资源调度服务 │• 同步服务 │• 安全设备 │ └─────────────────┴─────────────────┴─────────────────┴───────────────┘ │ │ │ └────────────────────┼────────────────────┘ ↓ ┌─────────────────────────────────────────────────────────────────────┐ │ 核心设计原则 │ ├──────────────┬──────────────┬──────────────┬──────────────┬─────────┤ │ 松耦合 │ 高内聚 │ 可扩展 │ 容错性 │ 安全性 │ ├──────────────┼──────────────┼──────────────┼──────────────┼─────────┤ │• 服务化架构 │• 功能模块化 │• 水平扩展 │• 故障隔离 │• 访问控制│ │• 接口标准化 │• 数据本地化 │• 动态负载均衡│• 状态恢复 │• 数据加密│ │• 协议抽象 │• 职责单一 │• 资源池化 │• 心跳检测 │• 审计日志│ └──────────────┴──────────────┴──────────────┴──────────────┴─────────┘

1.2 节点角色划分最佳实践

管理节点（Manager Node）：

• 单一职责：只负责联邦管理和资源调度，不参与仿真计算

• 高可用性：采用主备模式，支持故障自动切换

• 轻量级：最小化资源占用，确保管理功能稳定

计算节点（Compute Node）：

• 功能分区：按实体类型、地理区域或功能模块划分

• 负载均衡：动态分配计算任务，避免热点

• 状态独立：每个节点维护本地实体状态，减少跨节点通信

数据节点（Data Node）：

• 数据本地性：将数据靠近计算节点，减少网络传输

• 缓存策略：实现多级缓存（内存→SSD→HDD）

• 一致性模型：根据需求选择强一致性或最终一致性

网关节点（Gateway Node）：

• 协议转换：支持HLA、DIS、TENA等多种协议

• 流量控制：实现带宽管理和QoS保障

• 安全边界：作为内外网隔离的安全屏障

二、网络通信优化策略

2.1 网络拓扑设计

推荐拓扑：星型+网状混合拓扑

┌─────────────────┐ │ 管理节点 │ │ (主备) │ └────────┬────────┘ │ ┌─────────────────────┼─────────────────────┐ │ │ │ ┌─────┴─────┐ ┌─────┴─────┐ ┌─────┴─────┐ │ 计算集群1 │ │ 计算集群2 │ │ 网关集群 │ │ (区域A) │ │ (区域B) │ │ │ └─────┬─────┘ └─────┬─────┘ └─────┬─────┘ │ │ │ ┌─────┴─────┐ ┌─────┴─────┐ ┌─────┴─────┐ │ 存储节点 │◄────────►│ 存储节点 │◄────────►│外部系统 │ │ (副本1) │ 网状 │ (副本2) │ 网关 │(HLA/DIS) │ └───────────┘ 连接 └───────────┘ 连接 └───────────┘

2.2 通信协议选择矩阵

2.3 网络性能调优

内核参数优化（Linux）：

# /etc/sysctl.conf 优化配置 net.core.rmem_max = 134217728 # 128MB接收缓冲区 net.core.wmem_max = 134217728 # 128MB发送缓冲区 net.ipv4.tcp_rmem = 4096 87380 134217728 net.ipv4.tcp_wmem = 4096 65536 134217728 net.core.netdev_max_backlog = 300000 net.core.somaxconn = 65535 net.ipv4.tcp_max_syn_backlog = 65535 net.ipv4.tcp_syncookies = 1 net.ipv4.tcp_tw_reuse = 1 net.ipv4.tcp_fin_timeout = 30

AFSIM网络配置：

// config/network_config.json { "network": { "transport": { "default_protocol": "udp_multicast", "fallback_protocol": "tcp", "mtu": 1500, "fragment_size": 1400 }, "multicast": { "groups": [ {"address": "239.1.1.1", "port": 5000, "ttl": 32}, {"address": "239.1.1.2", "port": 5001, "ttl": 32} ], "interface": "eth0" }, "qos": { "priority_mapping": { "entity_state": 6, // DSCP 48 (CS6) "weapon_fire": 5, // DSCP 40 (CS5) "detonation": 5, "radio_message": 4, // DSCP 32 (CS4) "log_message": 1 // DSCP 8 (CS1) }, "bandwidth_limit": { "per_node": "100Mbps", "total": "1Gbps" } }, "compression": { "enabled": true, "algorithm": "zstd", "threshold": 1024, // 大于1KB的数据启用压缩 "level": 3 // 压缩级别1-22 } } }

三、数据分发与同步机制

3.1 基于兴趣管理的发布-订阅模式

兴趣区域（Region of Interest, ROI）管理：

// 实体兴趣管理实现示例 class InterestManager { public: void updateEntityInterest(const EntityId& id, const BoundingBox& roi) { // 基于空间分区树（如四叉树/八叉树）管理兴趣区域 spatial_index_.update(id, roi); // 计算需要接收该实体更新的节点列表 auto interested_nodes = calculateInterestedNodes(roi); // 更新发布-订阅关系 pubsub_manager_.updateSubscription(id, interested_nodes); } private: // 空间索引加速兴趣计算 Quadtree<EntityId> spatial_index_; // 发布-订阅管理器 PubSubManager pubsub_manager_; };

数据分发策略矩阵：

3.2 时间同步与一致性保障

混合时间管理策略：

// 时间同步服务实现 class TimeSynchronizationService { public: enum SyncMode { CONSERVATIVE, // 保守同步（确保因果顺序） OPTIMISTIC, // 乐观同步（允许回滚） ADAPTIVE // 自适应同步（动态切换） }; void configure(const TimeConfig& config) { switch(config.mode) { case CONSERVATIVE: // 使用Chandy-Misra算法 setupConservativeSync(); break; case OPTIMISTIC: // 使用Time Warp算法 setupOptimisticSync(); break; case ADAPTIVE: // 基于负载动态选择 setupAdaptiveSync(); break; } } private: // 保守同步实现 void setupConservativeSync() { // 使用空消息(null message)避免死锁 null_message_interval_ = config_.lookahead; // 设置时间窗口 time_window_ = config_.window_size; } // 乐观同步实现 void setupOptimisticSync() { // 配置状态保存间隔 checkpoint_interval_ = config_.checkpoint_interval; // 设置回滚管理器 rollback_manager_.setMaxRollbackSteps(config_.max_rollback); } };

时间同步配置示例：

# config/time_sync.yaml time_management: mode: "adaptive" # conservative, optimistic, adaptive lookahead: 0.1 # 秒，保守同步的前瞻时间 window_size: 0.5 # 秒，时间窗口大小 # 乐观同步配置 optimistic: checkpoint_interval: 1.0 # 检查点间隔（秒） max_rollback_steps: 10 # 最大回滚步数 anti_message_enabled: true # 是否启用反消息 # 自适应策略 adaptive: switch_threshold: 0.8 # 负载阈值（0-1） measurement_interval: 5.0 # 测量间隔（秒） # 全局时间服务 global_time: source: "ntp" # ntp, ptp, internal servers: ["time1.afsim.local", "time2.afsim.local"] sync_interval: 60.0 # 同步间隔（秒） max_offset: 0.001 # 最大允许偏移（秒）

四、负载均衡与资源管理

4.1 动态负载均衡算法

基于多指标的负载评估：

class LoadBalancer { public: struct NodeLoad { double cpu_usage; // CPU使用率（0-1） double memory_usage; // 内存使用率（0-1） double network_io; // 网络IO（MB/s） int entity_count; // 实体数量 double comm_cost; // 通信开销估计 double last_update; // 最后更新时间戳 }; std::string selectBestNode(const Entity& entity) { // 计算各节点的综合负载分数 std::vector<std::pair<std::string, double>> scores; for (const auto& [node_id, load] : node_loads_) { double score = calculateLoadScore(load, entity); scores.emplace_back(node_id, score); } // 选择负载最轻的节点 auto best = std::min_element(scores.begin(), scores.end(), [](const auto& a, const auto& b) { return a.second < b.second; }); return best->first; } private: double calculateLoadScore(const NodeLoad& load, const Entity& entity) { // 加权综合评分 double score = 0.0; // CPU和内存权重较高 score += load.cpu_usage * 0.3; score += load.memory_usage * 0.3; // 实体数量考虑 score += (load.entity_count / 1000.0) * 0.2; // 通信开销（基于实体位置和节点位置） double comm_cost = estimateCommunicationCost(entity, load); score += comm_cost * 0.2; return score; } std::unordered_map<std::string, NodeLoad> node_loads_; };

4.2 资源预留与调度

基于Kubernetes的容器化部署：

# k8s/afsim-deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: afsim-compute-node spec: replicas: 10 selector: matchLabels: app: afsim-compute template: metadata: labels: app: afsim-compute spec: # 节点亲和性：选择高性能节点 affinity: nodeAffinity: requiredDuringSchedulingIgnoredDuringExecution: nodeSelectorTerms: - matchExpressions: - key: node-type operator: In values: ["compute-optimized"] # 资源请求和限制 containers: - name: afsim-compute image: afsim/compute:2.5.0 resources: requests: cpu: "4" memory: "16Gi" hugepages-2Mi: "1Gi" limits: cpu: "8" memory: "32Gi" hugepages-2Mi: "2Gi" # 环境变量配置 env: - name: AFSIM_NODE_ROLE value: "compute" - name: AFSIM_MANAGER_HOST value: "afsim-manager-service" # 健康检查 livenessProbe: tcpSocket: port: 8080 initialDelaySeconds: 30 periodSeconds: 10 # 性能优化配置 securityContext: privileged: false capabilities: add: ["NET_ADMIN", "SYS_NICE"] # 挂载共享存储 volumeMounts: - name: shared-data mountPath: /afsim/data # 初始化容器（准备环境） initContainers: - name: init-volume image: busybox command: ['sh', '-c', 'chown -R 1000:1000 /afsim/data'] volumeMounts: - name: shared-data mountPath: /afsim/data volumes: - name: shared-data persistentVolumeClaim: claimName: afsim-data-pvc

五、容错与高可用性设计

5.1 故障检测与恢复机制

多层次健康检查：

class HealthMonitor { public: struct HealthStatus { enum Level { HEALTHY, // 健康 DEGRADED, // 降级 UNHEALTHY, // 不健康 FAILED // 故障 }; Level level; std::string reason; std::unordered_map<std::string, double> metrics; time_t last_check; }; void checkNodeHealth(const std::string& node_id) { HealthStatus status; // 1. 基础检查（ping） if (!pingNode(node_id)) { status.level = HealthStatus::FAILED; status.reason = "Network unreachable"; reportStatus(node_id, status); return; } // 2. 服务检查（端口） if (!checkServicePorts(node_id)) { status.level = HealthStatus::UNHEALTHY; status.reason = "Service ports not responding"; reportStatus(node_id, status); return; } // 3. 性能检查（资源使用率） auto metrics = collectMetrics(node_id); status.metrics = metrics; if (metrics["cpu"] > 0.9 || metrics["memory"] > 0.9) { status.level = HealthStatus::DEGRADED; status.reason = "High resource usage"; } else if (metrics["response_time"] > 1.0) { // 1秒 status.level = HealthStatus::DEGRADED; status.reason = "High response latency"; } else { status.level = HealthStatus::HEALTHY; status.reason = "All checks passed"; } status.last_check = time(nullptr); reportStatus(node_id, status); } private: // 故障恢复策略 void handleNodeFailure(const std::string& node_id) { // 1. 标记节点为故障 markNodeAsFailed(node_id); // 2. 迁移实体到其他节点 auto entities = getEntitiesOnNode(node_id); for (const auto& entity_id : entities) { auto new_node = load_balancer_.selectBestNode(entity_id); migrateEntity(entity_id, new_node); } // 3. 尝试重启节点 if (restartNode(node_id)) { // 重启成功，重新加入集群 reintegrateNode(node_id); } else { // 重启失败，通知管理员 notifyAdministrator(node_id, "Node restart failed"); } } };

5.2 状态持久化与恢复

检查点（Checkpoint）策略：

class CheckpointManager { public: struct CheckpointConfig { enum Mode { PERIODIC, // 定期检查点 EVENT_DRIVEN, // 事件驱动检查点 HYBRID // 混合模式 }; Mode mode = HYBRID; double interval = 60.0; // 定期检查点间隔（秒） size_t max_checkpoints = 10; // 最大保留检查点数量 bool incremental = true; // 是否使用增量检查点 }; void createCheckpoint(const std::string& checkpoint_id) { // 1. 暂停实体更新 pauseEntityUpdates(); // 2. 保存实体状态 saveEntityStates(checkpoint_id); // 3. 保存消息队列状态 saveMessageQueueState(checkpoint_id); // 4. 保存时间管理状态 saveTimeState(checkpoint_id); // 5. 记录检查点元数据 CheckpointMetadata metadata{ .id = checkpoint_id, .timestamp = getCurrentTime(), .simulation_time = time_manager_.getCurrentTime(), .entity_count = entity_manager_.getEntityCount(), .size = calculateCheckpointSize(checkpoint_id) }; saveMetadata(metadata); // 6. 恢复实体更新 resumeEntityUpdates(); // 7. 清理旧检查点 cleanupOldCheckpoints(); } bool restoreFromCheckpoint(const std::string& checkpoint_id) { // 1. 验证检查点完整性 if (!validateCheckpoint(checkpoint_id)) { return false; } // 2. 停止当前仿真 stopSimulation(); // 3. 加载实体状态 loadEntityStates(checkpoint_id); // 4. 加载消息队列状态 loadMessageQueueState(checkpoint_id); // 5. 加载时间管理状态 loadTimeState(checkpoint_id); // 6. 恢复仿真运行 resumeSimulation(); return true; } private: // 增量检查点实现 void createIncrementalCheckpoint(const std::string& checkpoint_id) { // 基于上一个检查点，只保存变化的部分 auto last_checkpoint = getLatestCheckpoint(); if (last_checkpoint.empty()) { // 第一个检查点，完整保存 createFullCheckpoint(checkpoint_id); return; } // 计算状态差异 auto diff = calculateStateDiff(last_checkpoint); // 保存差异数据 saveStateDiff(checkpoint_id, diff); // 创建差异检查点元数据 CheckpointMetadata metadata{ .id = checkpoint_id, .type = CheckpointType::INCREMENTAL, .base_checkpoint = last_checkpoint, .diff_size = diff.size() }; saveMetadata(metadata); } };

六、性能监控与优化

6.1 全方位监控指标体系

监控指标分类：

6.2 实时性能仪表板

Prometheus + Grafana监控方案：

# monitoring/prometheus-config.yaml global: scrape_interval: 1s evaluation_interval: 10s scrape_configs: - job_name: 'afsim-nodes' static_configs: - targets: ['node1:9090', 'node2:9090', 'node3:9090'] - job_name: 'afsim-manager' static_configs: - targets: ['manager:9090'] - job_name: 'network' static_configs: - targets: ['switch1:9100', 'switch2:9100'] # 自定义指标采集 rule_files: - "afsim_rules.yml"

AFSIM性能指标导出：

class MetricsExporter { public: void exportMetrics() { // 导出到Prometheus格式 auto& registry = prometheus::BuildPrometheusRegistry(); // 实体相关指标 auto& entity_gauge = prometheus::BuildGauge() .Name("afsim_entities_total") .Help("Total number of entities") .Register(registry); entity_gauge.Add({}).Set(entity_manager_.getEntityCount()); // 性能指标 auto& update_duration = prometheus::BuildHistogram() .Name("afsim_update_duration_seconds") .Help("Entity update duration") .Register(registry); auto start = std::chrono::high_resolution_clock::now(); updateEntities(); auto end = std::chrono::high_resolution_clock::now(); std::chrono::duration<double> duration = end - start; update_duration.Add({}).Observe(duration.count()); // 网络指标 auto& messages_sent = prometheus::BuildCounter() .Name("afsim_messages_sent_total") .Help("Total messages sent") .Register(registry); messages_sent.Add({}).Increment(network_manager_.getMessagesSent()); // 启动HTTP服务器暴露指标 prometheus::ExposeMetricsOnPort(9090); } };

6.3 性能瓶颈分析与优化

性能分析工作流：

数据采集 → 指标计算 → 瓶颈识别 → 优化实施 → 效果验证 ↓ ↓ ↓ ↓ ↓ 监控系统 统计分析 根因分析 代码/配置 A/B测试 ↓ ↓ ↓ 优化 ↓ 实时数据 百分位数 热点识别 部署验证 性能对比

常见瓶颈及解决方案：

1. CPU瓶颈

   • 现象：CPU使用率持续高于85%，实体更新延迟增加

   • 分析工具：perf, VTune,火焰图

   • 优化方案：

     // 优化前：频繁的动态内存分配 for (auto& entity : entities) { auto data = new EntityData(); // 每次循环都new process(entity, data); delete data; } // 优化后：使用对象池 static ObjectPool<EntityData> pool(1000); for (auto& entity : entities) { auto data = pool.acquire(); // 从池中获取 process(entity, data); pool.release(data); // 放回池中 }

2. 网络瓶颈

   • 现象：网络带宽使用率超过80%，丢包率增加

   • 分析工具：tcpdump, Wireshark, netstat

   • 优化方案：

     // 优化前：每个实体单独发送状态更新 for (const auto& entity : entities) { sendEntityUpdate(entity); } // 优化后：批量发送和压缩 std::vector<EntityUpdate> batch; batch.reserve(entities.size()); for (const auto& entity : entities) { batch.push_back(createUpdate(entity)); } // 压缩批量数据 auto compressed = compressBatch(batch); sendBatchUpdate(compressed);

3. 内存瓶颈

   • 现象：内存使用率持续增长，频繁GC

   • 分析工具：Valgrind, heaptrack, jemalloc

   • 优化方案：

     // 使用内存池管理频繁分配的对象 class EntityMemoryPool { private: struct Block { std::vector<uint8_t> memory; size_t used = 0; }; std::vector<Block> blocks_; const size_t block_size_ = 1024 * 1024; // 1MB块 public: void* allocate(size_t size) { // 在现有块中查找空闲空间 for (auto& block : blocks_) { if (block.used + size <= block.memory.size()) { void* ptr = block.memory.data() + block.used; block.used += size; return ptr; } } // 分配新块 blocks_.emplace_back(); auto& new_block = blocks_.back(); new_block.memory.resize(std::max(block_size_, size)); new_block.used = size; return new_block.memory.data(); } };

七、安全与访问控制

7.1 多层次安全架构

图2：AFSIM分布式仿真安全架构

┌─────────────────────────────────────────────────────────────┐ │ 安全审计与监控层 │ │ • 操作日志记录 • 异常行为检测 • 合规性检查 │ ├─────────────────────────────────────────────────────────────┤ │ 应用安全层 │ │ • 用户认证授权 • 数据访问控制 • 操作权限管理 │ ├─────────────────────────────────────────────────────────────┤ │ 通信安全层 │ │ • TLS/SSL加密 • 消息签名验证 • 防重放攻击 │ ├─────────────────────────────────────────────────────────────┤ │ 网络安全层 │ │ • 防火墙规则 • VLAN隔离 • 入侵检测系统 │ ├─────────────────────────────────────────────────────────────┤ │ 物理安全层 │ │ • 机房访问控制 • 设备安全加固 • 硬件加密模块 │ └─────────────────────────────────────────────────────────────┘

7.2 基于角色的访问控制（RBAC）

class SecurityManager { public: enum Permission { READ_ENTITY, // 读取实体信息 WRITE_ENTITY, // 修改实体信息 CREATE_ENTITY, // 创建新实体 DELETE_ENTITY, // 删除实体 CONTROL_SIM, // 控制仿真运行 VIEW_SENSITIVE, // 查看敏感数据 EXPORT_DATA, // 导出数据 MANAGE_USERS // 管理用户 }; enum Role { OBSERVER, // 观察者：只读权限 OPERATOR, // 操作员：基本操作权限 ANALYST, // 分析师：数据分析权限 DEVELOPER, // 开发者：开发调试权限 ADMINISTRATOR // 管理员：完全控制权限 }; struct User { std::string username; std::string hashed_password; Role role; std::vector<std::string> groups; time_t last_login; std::string login_ip; }; bool checkPermission(const User& user, Permission permission, const std::string& resource = "") { // 1. 基于角色的权限检查 if (!hasRolePermission(user.role, permission)) { return false; } // 2. 基于资源的访问控制（可选） if (!resource.empty() && !hasResourcePermission(user, resource)) { return false; } // 3. 时间限制检查（如：仅工作日允许） if (!checkTimeRestriction(user)) { return false; } // 4. IP地址限制检查 if (!checkIPRestriction(user)) { return false; } return true; } private: // 角色权限映射 std::unordered_map<Role, std::set<Permission>> role_permissions_ = { {OBSERVER, {READ_ENTITY}}, {OPERATOR, {READ_ENTITY, WRITE_ENTITY, CONTROL_SIM}}, {ANALYST, {READ_ENTITY, VIEW_SENSITIVE, EXPORT_DATA}}, {DEVELOPER, {READ_ENTITY, WRITE_ENTITY, CREATE_ENTITY, DELETE_ENTITY, VIEW_SENSITIVE}}, {ADMINISTRATOR, {READ_ENTITY, WRITE_ENTITY, CREATE_ENTITY, DELETE_ENTITY, CONTROL_SIM, VIEW_SENSITIVE, EXPORT_DATA, MANAGE_USERS}} }; };

7.3 数据传输安全

端到端加密实现：

class SecureCommunication { public: struct SecurityConfig { bool enable_encryption = true; std::string encryption_algorithm = "AES-256-GCM"; bool enable_integrity = true; std::string integrity_algorithm = "HMAC-SHA256"; bool enable_authentication = true; std::string auth_algorithm = "ECDSA-P256"; bool enable_forward_secrecy = true; int key_refresh_interval = 3600; // 密钥刷新间隔（秒） }; std::vector<uint8_t> encryptMessage(const std::vector<uint8_t>& plaintext, const std::string& recipient) { // 1. 生成随机初始化向量（IV） std::vector<uint8_t> iv(12); // GCM推荐12字节IV RAND_bytes(iv.data(), iv.size()); // 2. 获取会话密钥 auto session_key = key_manager_.getSessionKey(recipient); // 3. 加密数据 std::vector<uint8_t> ciphertext(plaintext.size()); std::vector<uint8_t> tag(16); // GCM认证标签 EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new(); EVP_EncryptInit_ex(ctx, EVP_aes_256_gcm(), nullptr, session_key.data(), iv.data()); int len; EVP_EncryptUpdate(ctx, ciphertext.data(), &len, plaintext.data(), plaintext.size()); int final_len; EVP_EncryptFinal_ex(ctx, ciphertext.data() + len, &final_len); EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, 16, tag.data()); EVP_CIPHER_CTX_free(ctx); // 4. 构建安全消息 SecureMessage secure_msg; secure_msg.version = 1; secure_msg.iv = iv; secure_msg.ciphertext = ciphertext; secure_msg.auth_tag = tag; secure_msg.sender_cert = getCertificate(); secure_msg.timestamp = getCurrentTime(); // 5. 序列化消息 return serializeMessage(secure_msg); } private: class KeyManager { public: std::vector<uint8_t> getSessionKey(const std::string& peer) { auto it = session_keys_.find(peer); if (it != session_keys_.end() && !isKeyExpired(it->second.timestamp)) { return it->second.key; } // 生成新的会话密钥 std::vector<uint8_t> new_key(32); // AES-256需要32字节密钥 RAND_bytes(new_key.data(), new_key.size()); session_keys_[peer] = SessionKey{ .key = new_key, .timestamp = getCurrentTime() }; return new_key; } private: struct SessionKey { std::vector<uint8_t> key; time_t timestamp; }; std::unordered_map<std::string, SessionKey> session_keys_; }; KeyManager key_manager_; };

八、部署与运维最佳实践

8.1 自动化部署流水线

基于Ansible的自动化部署：

# deploy/ansible/playbook.yaml --- - name: 部署AFSIM分布式仿真集群 hosts: all vars: afsim_version: "2.5.0" install_dir: "/opt/afsim" data_dir: "/data/afsim" tasks: # 1. 系统准备 - name: 安装系统依赖 apt: name: "{{ item }}" state: present update_cache: yes loop: - build-essential - cmake - git - python3-pip - libboost-all-dev - libqt5core5a - libopenscenegraph-dev # 2. 创建用户和目录 - name: 创建afsim用户 user: name: afsim system: yes shell: /bin/bash - name: 创建安装目录 file: path: "{{ install_dir }}" state: directory owner: afsim group: afsim mode: '0755' # 3. 部署AFSIM二进制文件 - name: 下载AFSIM安装包 get_url: url: "http://repo.afsim.local/{{ afsim_version }}/afsim.tar.gz" dest: "/tmp/afsim.tar.gz" checksum: "sha256:{{ afsim_checksum }}" - name: 解压安装包 unarchive: src: "/tmp/afsim.tar.gz" dest: "{{ install_dir }}" remote_src: yes owner: afsim group: afsim # 4. 配置系统服务 - name: 配置systemd服务 template: src: "templates/afsim.service.j2" dest: "/etc/systemd/system/afsim-{{ inventory_hostname }}.service" owner: root group: root mode: '0644' - name: 重载systemd配置 systemd: daemon_reload: yes # 5. 配置防火墙 - name: 配置防火墙规则 ufw: rule: "{{ item.rule }}" port: "{{ item.port }}" proto: "{{ item.proto }}" loop: - { rule: allow, port: '8080', proto: tcp } # 管理端口 - { rule: allow, port: '5000-5100', proto: udp } # 组播端口 - { rule: allow, port: '9090', proto: tcp } # 监控端口 # 6. 配置监控 - name: 部署监控代理 include_role: name: prometheus_node_exporter # 7. 启动服务 - name: 启动AFSIM服务 systemd: name: "afsim-{{ inventory_hostname }}" state: started enabled: yes # 8. 健康检查 - name: 验证服务状态 uri: url: "http://localhost:8080/health" method: GET status_code: 200 register: health_check until: health_check.status == 200 retries: 10 delay: 5

8.2 监控告警配置

Prometheus告警规则：

# monitoring/alert-rules.yaml groups: - name: afsim_cluster rules: # CPU告警 - alert: HighCPUUsage expr: avg(rate(node_cpu_seconds_total{mode!="idle"}[5m])) by (instance) > 0.85 for: 5m labels: severity: warning annotations: summary: "高CPU使用率 (实例 {{ $labels.instance }})" description: "CPU使用率超过85%持续5分钟" # 内存告警 - alert: HighMemoryUsage expr: (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes > 0.9 for: 5m labels: severity: warning annotations: summary: "高内存使用率 (实例 {{ $labels.instance }})" description: "内存使用率超过90%持续5分钟" # 网络丢包告警 - alert: HighPacketLoss expr: rate(node_network_receive_drop_total[5m]) / rate(node_network_receive_packets_total[5m]) > 0.01 for: 2m labels: severity: critical annotations: summary: "高网络丢包率 (接口 {{ $labels.device }})" description: "网络丢包率超过1%持续2分钟" # 仿真时间滞后告警 - alert: SimulationLagging expr: afsim_wallclock_ratio < 0.9 for: 1m labels: severity: warning annotations: summary: "仿真时间滞后" description: "仿真时间推进速率低于实时速率的90%" # 节点离线告警 - alert: NodeDown expr: up == 0 for: 1m labels: severity: critical annotations: summary: "节点离线 ({{ $labels.instance }})" description: "节点已离线超过1分钟"

8.3 备份与灾难恢复

全量备份策略：

#!/bin/bash # backup/afsim_backup.sh # 备份配置 BACKUP_DIR="/backup/afsim" DATE=$(date +%Y%m%d_%H%M%S) RETENTION_DAYS=30 # 1. 停止仿真服务（可选，建议在维护窗口进行） systemctl stop afsim-* # 2. 备份配置文件 echo "备份配置文件..." tar -czf $BACKUP_DIR/config_$DATE.tar.gz /etc/afsim/ # 3. 备份仿真数据 echo "备份仿真数据..." tar -czf $BACKUP_DIR/data_$DATE.tar.gz /data/afsim/ # 4. 备份数据库（如果有） echo "备份数据库..." pg_dump -U afsim afsim_db > $BACKUP_DIR/db_$DATE.sql gzip $BACKUP_DIR/db_$DATE.sql # 5. 备份检查点 echo "备份检查点..." rsync -av --delete /data/afsim/checkpoints/ $BACKUP_DIR/checkpoints_latest/ # 6. 创建备份清单 echo "创建备份清单..." cat > $BACKUP_DIR/manifest_$DATE.txt << EOF 备份时间: $DATE 备份内容: - 配置文件: config_$DATE.tar.gz - 仿真数据: data_$DATE.tar.gz - 数据库: db_$DATE.sql.gz - 检查点: checkpoints_latest/ 备份大小: $(du -sh $BACKUP_DIR/*_$DATE.* | awk '{print $1}') EOF # 7. 清理旧备份 echo "清理旧备份..." find $BACKUP_DIR -name "