云原生 --> ( 难度等级: [0, 1) || 挂载数据: 无 ) 
├── 云原生初阶-应用开发 --> ( 难度等级: [0.0, 0.1429) || 挂载数据: 无 ) 
│   ├── Serverless --> ( 难度等级: [0.0, 0.0357) || 挂载数据: 无 ) 
│   │   ├── Cloud Events --> ( 难度等级: [0.0, 0.0011) || 挂载数据: 无 ) 
│   │   ├── Serverless Framework --> ( 难度等级: [0.0011, 0.0021) || 挂载数据: 无 ) 
│   │   ├── Serverless Devs --> ( 难度等级: [0.0021, 0.0032) || 挂载数据: 无 ) 
│   │   ├── FaaS Serverless --> ( 难度等级: [0.0032, 0.0042) || 挂载数据: 无 ) 
│   │   │   ├── Nuclio --> ( 难度等级: [0.0032, 0.0033) || 挂载数据: 无 ) 
│   │   │   ├── Kubeless --> ( 难度等级: [0.0033, 0.0035) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubeless概述 --> ( 难度等级: [0.0033, 0.0034) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署Kubeless --> ( 难度等级: [0.0033, 0.0033) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置客户端 --> ( 难度等级: [0.0033, 0.0034) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署函数 --> ( 难度等级: [0.0034, 0.0034) || 挂载数据: 无 ) 
│   │   │   │   │   └── Kubeless UI --> ( 难度等级: [0.0034, 0.0034) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Function --> ( 难度等级: [0.0034, 0.0035) || 挂载数据: blog: 2 ) 
│   │   │   │       ├── 函数部署 --> ( 难度等级: [0.0034, 0.0034) || 挂载数据: 无 ) 
│   │   │   │       ├── 函数调用 --> ( 难度等级: [0.0034, 0.0035) || 挂载数据: 无 ) 
│   │   │   │       └── 自动扩展 --> ( 难度等级: [0.0035, 0.0035) || 挂载数据: blog: 1 ) 
│   │   │   ├── Fission --> ( 难度等级: [0.0035, 0.0037) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署Fission --> ( 难度等级: [0.0035, 0.0035) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署Fission Chart --> ( 难度等级: [0.0035, 0.0035) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 命令行工具 --> ( 难度等级: [0.0035, 0.0035) || 挂载数据: 无 ) 
│   │   │   │   │   └── Hello Fission --> ( 难度等级: [0.0035, 0.0035) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 深入探讨Fission --> ( 难度等级: [0.0035, 0.0036) || 挂载数据: 无 ) 
│   │   │   │   │   └── Environment --> ( 难度等级: [0.0035, 0.0036) || 挂载数据: 无 ) 
│   │   │   │   ├── 执行模式 --> ( 难度等级: [0.0036, 0.0036) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Poolbased模式 --> ( 难度等级: [0.0036, 0.0036) || 挂载数据: 无 ) 
│   │   │   │   │   └── New Deploy模式 --> ( 难度等级: [0.0036, 0.0036) || 挂载数据: 无 ) 
│   │   │   │   └── Workflows --> ( 难度等级: [0.0036, 0.0037) || 挂载数据: 无 ) 
│   │   │   │       ├── Workflows定义 --> ( 难度等级: [0.0036, 0.0036) || 挂载数据: 无 ) 
│   │   │   │       ├── 配置Workflows --> ( 难度等级: [0.0036, 0.0037) || 挂载数据: 无 ) 
│   │   │   │       └── Fortune Whale --> ( 难度等级: [0.0037, 0.0037) || 挂载数据: 无 ) 
│   │   │   ├── OpenFaas --> ( 难度等级: [0.0037, 0.0039) || 挂载数据: 无 ) 
│   │   │   │   ├── 初识OpenFaaS --> ( 难度等级: [0.0037, 0.0037) || 挂载数据: 无 ) 
│   │   │   │   │   └── 图形界面 --> ( 难度等级: [0.0037, 0.0037) || 挂载数据: 无 ) 
│   │   │   │   ├── OpenFaaS函数 --> ( 难度等级: [0.0037, 0.0037) || 挂载数据: blog: 7 ) 
│   │   │   │   │   ├── 抽象方式 --> ( 难度等级: [0.0037, 0.0037) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 函数模板 --> ( 难度等级: [0.0037, 0.0037) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 构建函数 --> ( 难度等级: [0.0037, 0.0037) || 挂载数据: blog: 4 ) 
│   │   │   │   │   └── 推送镜像 --> ( 难度等级: [0.0037, 0.0037) || 挂载数据: 无 ) 
│   │   │   │   ├── Watchdog --> ( 难度等级: [0.0037, 0.0038) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 工作原理 --> ( 难度等级: [0.0037, 0.0037) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置Watchdog --> ( 难度等级: [0.0037, 0.0038) || 挂载数据: blog: 2 ) 
│   │   │   │   │   └── ofwatchdog --> ( 难度等级: [0.0038, 0.0038) || 挂载数据: 无 ) 
│   │   │   │   ├── 监控 --> ( 难度等级: [0.0038, 0.0038) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 监控指标 --> ( 难度等级: [0.0038, 0.0038) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 监控面板 --> ( 难度等级: [0.0038, 0.0038) || 挂载数据: 无 ) 
│   │   │   │   │   └── 监控预警 --> ( 难度等级: [0.0038, 0.0038) || 挂载数据: 无 ) 
│   │   │   │   ├── 弹性扩展 --> ( 难度等级: [0.0038, 0.0038) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 基于Alertmanager扩展 --> ( 难度等级: [0.0038, 0.0038) || 挂载数据: 无 ) 
│   │   │   │   │   └── 基于HPA扩展 --> ( 难度等级: [0.0038, 0.0038) || 挂载数据: 无 ) 
│   │   │   │   └── 函数应用市场 --> ( 难度等级: [0.0038, 0.0039) || 挂载数据: 无 ) 
│   │   │   ├── OpenWhisk --> ( 难度等级: [0.0039, 0.004) || 挂载数据: 无 ) 
│   │   │   │   ├── Hello Whisk --> ( 难度等级: [0.0039, 0.0039) || 挂载数据: 无 ) 
│   │   │   │   ├── 逻辑架构 --> ( 难度等级: [0.0039, 0.0039) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Namespace --> ( 难度等级: [0.0039, 0.0039) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Package --> ( 难度等级: [0.0039, 0.0039) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Action --> ( 难度等级: [0.0039, 0.0039) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── Feed --> ( 难度等级: [0.0039, 0.0039) || 挂载数据: 无 ) 
│   │   │   │   │   └── Rule --> ( 难度等级: [0.0039, 0.0039) || 挂载数据: 无 ) 
│   │   │   │   ├── 系统架构 --> ( 难度等级: [0.0039, 0.0039) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Kubernetes部署 --> ( 难度等级: [0.0039, 0.004) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 准备Kubernetes集群 --> ( 难度等级: [0.0039, 0.0039) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 集群基础设置 --> ( 难度等级: [0.0039, 0.0039) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 创建访问入口 --> ( 难度等级: [0.0039, 0.004) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署组件 --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 加载系统配置 --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 测试集群 --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   │   │   └── 删除集群 --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   │   ├── Helm部署 --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 安装Helm --> ( 难度等级: [0.004, 0.004) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 环境配置 --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署Chart --> ( 难度等级: [0.004, 0.004) || 挂载数据: blog: 4 ) 
│   │   │   │   │   └── 管理应用 --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   │   └── 蛋糕管理服务 --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   │       ├── 开发环境 --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   │       ├── 定义Action --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   │       ├── 创建Package --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   │       ├── 部署Action --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   │       └── 发布API --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   └── Fn Project --> ( 难度等级: [0.004, 0.0042) || 挂载数据: 无 ) 
│   │   ├── 踏上征途 --> ( 难度等级: [0.0042, 0.0053) || 挂载数据: 无 ) 
│   │   ├── 无服务器初探 --> ( 难度等级: [0.0053, 0.0063) || 挂载数据: 无 ) 
│   │   │   ├── 来龙去脉 --> ( 难度等级: [0.0053, 0.0055) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向服务的架构与微服务 --> ( 难度等级: [0.0053, 0.0054) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 从SOA到微服务 --> ( 难度等级: [0.0053, 0.0053) || 挂载数据: 无 ) 
│   │   │   │   │   └── 微服务的价值与挑战 --> ( 难度等级: [0.0053, 0.0054) || 挂载数据: 无 ) 
│   │   │   │   └── 软件设计 --> ( 难度等级: [0.0054, 0.0055) || 挂载数据: 无 ) 
│   │   │   ├── 无服务器架构原则 --> ( 难度等级: [0.0055, 0.0058) || 挂载数据: 无 ) 
│   │   │   │   ├── 根据需要使用计算服务执行代码 --> ( 难度等级: [0.0055, 0.0056) || 挂载数据: 无 ) 
│   │   │   │   ├── 编写单一用途的无状态函数 --> ( 难度等级: [0.0056, 0.0056) || 挂载数据: 无 ) 
│   │   │   │   ├── 设计基于推送的、事件驱动的管道 --> ( 难度等级: [0.0056, 0.0057) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建更厚、更强大的前端 --> ( 难度等级: [0.0057, 0.0057) || 挂载数据: 无 ) 
│   │   │   │   └── 拥抱第三方服务 --> ( 难度等级: [0.0057, 0.0058) || 挂载数据: 无 ) 
│   │   │   ├── 从服务器过渡到服务 --> ( 难度等级: [0.0058, 0.006) || 挂载数据: 无 ) 
│   │   │   └── 无服务器的利与弊 --> ( 难度等级: [0.006, 0.0063) || 挂载数据: 无 ) 
│   │   │       ├── 决策驱动因素 --> ( 难度等级: [0.006, 0.0062) || 挂载数据: 无 ) 
│   │   │       └── 什么时候使用无服务器 --> ( 难度等级: [0.0062, 0.0063) || 挂载数据: blog: 10 ) 
│   │   ├── .架构与模式 --> ( 难度等级: [0.0063, 0.0074) || 挂载数据: 无 ) 
│   │   │   ├── 使用场景 --> ( 难度等级: [0.0063, 0.0067) || 挂载数据: 无 ) 
│   │   │   │   ├── 应用程序后端 --> ( 难度等级: [0.0063, 0.0064) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据处理与操作 --> ( 难度等级: [0.0064, 0.0064) || 挂载数据: 无 ) 
│   │   │   │   ├── 实时分析 --> ( 难度等级: [0.0064, 0.0065) || 挂载数据: 无 ) 
│   │   │   │   ├── 遗留API代理 --> ( 难度等级: [0.0065, 0.0065) || 挂载数据: 无 ) 
│   │   │   │   ├── 计划服务 --> ( 难度等级: [0.0065, 0.0066) || 挂载数据: 无 ) 
│   │   │   │   └── 机器人（Bot）和技能（Skill） . --> ( 难度等级: [0.0066, 0.0067) || 挂载数据: 无 ) 
│   │   │   ├── 架构 --> ( 难度等级: [0.0067, 0.007) || 挂载数据: 无 ) 
│   │   │   │   ├── 计算即后端 --> ( 难度等级: [0.0067, 0.0067) || 挂载数据: 无 ) 
│   │   │   │   ├── 遗留API代理 --> ( 难度等级: [0.0067, 0.0068) || 挂载数据: 无 ) 
│   │   │   │   ├── 混合 --> ( 难度等级: [0.0068, 0.0068) || 挂载数据: 无 ) 
│   │   │   │   ├── GraphQL . --> ( 难度等级: [0.0068, 0.0069) || 挂载数据: 无 ) 
│   │   │   │   ├── 计算即胶水 --> ( 难度等级: [0.0069, 0.0069) || 挂载数据: 无 ) 
│   │   │   │   └── 实时处理 --> ( 难度等级: [0.0069, 0.007) || 挂载数据: 无 ) 
│   │   │   └── 模式 --> ( 难度等级: [0.007, 0.0074) || 挂载数据: 无 ) 
│   │   │       ├── 命令模式 --> ( 难度等级: [0.007, 0.0071) || 挂载数据: 无 ) 
│   │   │       ├── 消息传输模式 --> ( 难度等级: [0.0071, 0.0071) || 挂载数据: blog: 1 ) 
│   │   │       ├── 优先级队列模式 --> ( 难度等级: [0.0071, 0.0072) || 挂载数据: 无 ) 
│   │   │       ├── 扇出模式 --> ( 难度等级: [0.0072, 0.0073) || 挂载数据: 无 ) 
│   │   │       └── 管道和过滤器模式 --> ( 难度等级: [0.0073, 0.0074) || 挂载数据: 无 ) 
│   │   ├── 建立无服务器应用程序 --> ( 难度等级: [0.0074, 0.0084) || 挂载数据: 无 ) 
│   │   │   ├── 小时视频 --> ( 难度等级: [0.0074, 0.0076) || 挂载数据: 无 ) 
│   │   │   │   ├── 总体需求 --> ( 难度等级: [0.0074, 0.0074) || 挂载数据: 无 ) 
│   │   │   │   ├── Amazon Web Services（AWS） --> ( 难度等级: [0.0074, 0.0074) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建第一个Lambda函数 --> ( 难度等级: [0.0074, 0.0074) || 挂载数据: 无 ) 
│   │   │   │   ├── 命名你的Lambda --> ( 难度等级: [0.0074, 0.0074) || 挂载数据: 无 ) 
│   │   │   │   ├── 本地测试 --> ( 难度等级: [0.0074, 0.0075) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署到AWS --> ( 难度等级: [0.0075, 0.0075) || 挂载数据: 无 ) 
│   │   │   │   ├── 连接S3 和Lambda --> ( 难度等级: [0.0075, 0.0075) || 挂载数据: 无 ) 
│   │   │   │   ├── 在AWS中测试 --> ( 难度等级: [0.0075, 0.0075) || 挂载数据: 无 ) 
│   │   │   │   └── 观察日志 --> ( 难度等级: [0.0075, 0.0076) || 挂载数据: 无 ) 
│   │   │   ├── 配置Simple Notification Service --> ( 难度等级: [0.0076, 0.0078) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 连接SNS和S --> ( 难度等级: [0.0076, 0.0076) || 挂载数据: 无 ) 
│   │   │   │   ├── 从SNS接收电子邮件 --> ( 难度等级: [0.0076, 0.0077) || 挂载数据: 无 ) 
│   │   │   │   └── 测试SNS --> ( 难度等级: [0.0077, 0.0078) || 挂载数据: 无 ) 
│   │   │   ├── 设置视频权限 --> ( 难度等级: [0.0078, 0.008) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建第二个函数 --> ( 难度等级: [0.0078, 0.0078) || 挂载数据: 无 ) 
│   │   │   │   ├── 配置与安全 --> ( 难度等级: [0.0078, 0.0079) || 挂载数据: 无 ) 
│   │   │   │   └── 测试第二个函数 --> ( 难度等级: [0.0079, 0.008) || 挂载数据: 无 ) 
│   │   │   ├── 生成元数据 --> ( 难度等级: [0.008, 0.0082) || 挂载数据: 无 ) 
│   │   │   └── 收尾 --> ( 难度等级: [0.0082, 0.0084) || 挂载数据: 无 ) 
│   │   ├── 设置你的云服务 --> ( 难度等级: [0.0084, 0.0095) || 挂载数据: 无 ) 
│   │   │   └── 安全模型和身份管理 --> ( 难度等级: [0.0084, 0.0095) || 挂载数据: 无 ) 
│   │   │       └── 创建和管理IAM用户 --> ( 难度等级: [0.0084, 0.0095) || 挂载数据: 无 ) 
│   │   ├── 深入核心 --> ( 难度等级: [0.0095, 0.0105) || 挂载数据: 无 ) 
│   │   ├── 身份认证和授权 --> ( 难度等级: [0.0105, 0.0116) || 挂载数据: 无 ) 
│   │   │   ├── 无服务器环境中的身份认证 --> ( 难度等级: [0.0105, 0.0108) || 挂载数据: 无 ) 
│   │   │   │   ├── 无服务器方法 --> ( 难度等级: [0.0105, 0.0106) || 挂载数据: 无 ) 
│   │   │   │   ├── Amazon Cognito --> ( 难度等级: [0.0106, 0.0107) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Auth0 --> ( 难度等级: [0.0107, 0.0108) || 挂载数据: 无 ) 
│   │   │   ├── 为 24 小时视频增加身份认证 --> ( 难度等级: [0.0108, 0.011) || 挂载数据: 无 ) 
│   │   │   │   ├── 计划 --> ( 难度等级: [0.0108, 0.0108) || 挂载数据: 无 ) 
│   │   │   │   ├── 直接调用Lambda --> ( 难度等级: [0.0108, 0.0109) || 挂载数据: 无 ) 
│   │   │   │   ├── 小时视频网站 --> ( 难度等级: [0.0109, 0.0109) || 挂载数据: 无 ) 
│   │   │   │   ├── Auth0 配置 --> ( 难度等级: [0.0109, 0.0109) || 挂载数据: 无 ) 
│   │   │   │   ├── 在网站中加入Auth0 --> ( 难度等级: [0.0109, 0.011) || 挂载数据: 无 ) 
│   │   │   │   └── 测试Auth0 的集成 --> ( 难度等级: [0.011, 0.011) || 挂载数据: 无 ) 
│   │   │   ├── 与AWS集成 --> ( 难度等级: [0.011, 0.0113) || 挂载数据: 无 ) 
│   │   │   │   ├── 用户信息Lambda --> ( 难度等级: [0.011, 0.0111) || 挂载数据: 无 ) 
│   │   │   │   ├── API Gateway --> ( 难度等级: [0.0111, 0.0111) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 作为接口的API Gateway --> ( 难度等级: [0.0111, 0.0111) || 挂载数据: blog: 10 ) 
│   │   │   │   │   │   ├── 和AWS服务集成 --> ( 难度等级: [0.0111, 0.0111) || 挂载数据: blog: 10 ) 
│   │   │   │   │   │   └── 脚本 --> ( 难度等级: [0.0111, 0.0111) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 创建资源和方法 --> ( 难度等级: [0.0111, 0.0111) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置方法执行 --> ( 难度等级: [0.0111, 0.0111) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 更新网站 --> ( 难度等级: [0.0111, 0.0111) || 挂载数据: 无 ) 
│   │   │   │   │   └── 优化网关 --> ( 难度等级: [0.0111, 0.0111) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 限制 --> ( 难度等级: [0.0111, 0.0111) || 挂载数据: 无 ) 
│   │   │   │   │       └── 缓存 --> ( 难度等级: [0.0111, 0.0111) || 挂载数据: 无 ) 
│   │   │   │   ├── 映射 --> ( 难度等级: [0.0111, 0.0112) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过API Gateway调用Lambda --> ( 难度等级: [0.0112, 0.0112) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义授权方 --> ( 难度等级: [0.0112, 0.0113) || 挂载数据: 无 ) 
│   │   │   └── 委托令牌 --> ( 难度等级: [0.0113, 0.0116) || 挂载数据: 无 ) 
│   │   │       ├── 真实案例 --> ( 难度等级: [0.0113, 0.0114) || 挂载数据: 无 ) 
│   │   │       └── 开通委托令牌 --> ( 难度等级: [0.0114, 0.0116) || 挂载数据: 无 ) 
│   │   ├── 编排者Lambda --> ( 难度等级: [0.0116, 0.0126) || 挂载数据: 无 ) 
│   │   │   ├── Lambda内幕 --> ( 难度等级: [0.0116, 0.0117) || 挂载数据: 无 ) 
│   │   │   │   ├── 事件模型和源 --> ( 难度等级: [0.0116, 0.0116) || 挂载数据: 无 ) 
│   │   │   │   ├── 推送和拉取事件模型 --> ( 难度等级: [0.0116, 0.0116) || 挂载数据: 无 ) 
│   │   │   │   ├── 并发执行 --> ( 难度等级: [0.0116, 0.0117) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器重用 --> ( 难度等级: [0.0117, 0.0117) || 挂载数据: 无 ) 
│   │   │   │   └── 冷Lambda和暖Lambda --> ( 难度等级: [0.0117, 0.0117) || 挂载数据: blog: 2 ) 
│   │   │   ├── 编程模型 --> ( 难度等级: [0.0117, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数处理程序 --> ( 难度等级: [0.0117, 0.0117) || 挂载数据: 无 ) 
│   │   │   │   ├── 事件对象 --> ( 难度等级: [0.0117, 0.0118) || 挂载数据: 无 ) 
│   │   │   │   ├── 上下文对象 --> ( 难度等级: [0.0118, 0.0118) || 挂载数据: 无 ) 
│   │   │   │   ├── 回调函数 --> ( 难度等级: [0.0118, 0.0118) || 挂载数据: 无 ) 
│   │   │   │   ├── 日志 --> ( 难度等级: [0.0118, 0.0118) || 挂载数据: 无 ) 
│   │   │   │   ├── 代码开发 --> ( 难度等级: [0.0118, 0.0118) || 挂载数据: 无 ) 
│   │   │   │   ├── Handler --> ( 难度等级: [0.0118, 0.0118) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 执行上下文 --> ( 难度等级: [0.0118, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   ├── 日志输出 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   ├── 异常处理 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   │   └── 无状态 --> ( 难度等级: [0.0119, 0.0119) || 挂载数据: 无 ) 
│   │   │   ├── 版本管理、别名和环境变量 --> ( 难度等级: [0.0119, 0.0121) || 挂载数据: 无 ) 
│   │   │   │   ├── 版本管理 --> ( 难度等级: [0.0119, 0.012) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 别名 --> ( 难度等级: [0.012, 0.012) || 挂载数据: 无 ) 
│   │   │   │   └── 环境变量 --> ( 难度等级: [0.012, 0.0121) || 挂载数据: 无 ) 
│   │   │   ├── 使用命令行界面（CLI） --> ( 难度等级: [0.0121, 0.0123) || 挂载数据: 无 ) 
│   │   │   │   └── 调用命令 --> ( 难度等级: [0.0121, 0.0123) || 挂载数据: 无 ) 
│   │   │   ├── Lambda模式 --> ( 难度等级: [0.0123, 0.0124) || 挂载数据: 无 ) 
│   │   │   │   ├── 异步瀑布 --> ( 难度等级: [0.0123, 0.0123) || 挂载数据: 无 ) 
│   │   │   │   ├── 序列与并行 --> ( 难度等级: [0.0123, 0.0123) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用库 --> ( 难度等级: [0.0123, 0.0124) || 挂载数据: 无 ) 
│   │   │   │   └── 把逻辑移到另一个文件中 --> ( 难度等级: [0.0124, 0.0124) || 挂载数据: 无 ) 
│   │   │   └── 测试Lambda函数 . --> ( 难度等级: [0.0124, 0.0126) || 挂载数据: 无 ) 
│   │   │       ├── 在本地测试 --> ( 难度等级: [0.0124, 0.0125) || 挂载数据: 无 ) 
│   │   │       └── 编写测试 --> ( 难度等级: [0.0125, 0.0126) || 挂载数据: 无 ) 
│   │   ├── 拓展架构 --> ( 难度等级: [0.0126, 0.0137) || 挂载数据: 无 ) 
│   │   ├── 存储 . --> ( 难度等级: [0.0137, 0.0147) || 挂载数据: 无 ) 
│   │   │   ├── 更智能的存储 --> ( 难度等级: [0.0137, 0.014) || 挂载数据: 无 ) 
│   │   │   │   ├── 版本控制 --> ( 难度等级: [0.0137, 0.0137) || 挂载数据: 无 ) 
│   │   │   │   ├── 托管静态网站 --> ( 难度等级: [0.0137, 0.0138) || 挂载数据: 无 ) 
│   │   │   │   ├── 存储类别 --> ( 难度等级: [0.0138, 0.0138) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 对象生命周期管理 --> ( 难度等级: [0.0138, 0.0139) || 挂载数据: 无 ) 
│   │   │   │   ├── 转移加速 --> ( 难度等级: [0.0139, 0.0139) || 挂载数据: 无 ) 
│   │   │   │   └── 事件通知 --> ( 难度等级: [0.0139, 0.014) || 挂载数据: 无 ) 
│   │   │   ├── 安全上传 --> ( 难度等级: [0.014, 0.0144) || 挂载数据: 无 ) 
│   │   │   │   ├── 上传策略Lambda --> ( 难度等级: [0.014, 0.0141) || 挂载数据: 无 ) 
│   │   │   │   ├── S3 CORS配置 --> ( 难度等级: [0.0141, 0.0142) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 在网站中上传 --> ( 难度等级: [0.0142, 0.0144) || 挂载数据: blog: 1 ) 
│   │   │   └── 限制对文件的访问 --> ( 难度等级: [0.0144, 0.0147) || 挂载数据: 无 ) 
│   │   │       ├── 禁止公开访问 --> ( 难度等级: [0.0144, 0.0144) || 挂载数据: 无 ) 
│   │   │       ├── 生成预签名URL --> ( 难度等级: [0.0144, 0.0145) || 挂载数据: blog: 1 ) 
│   │   │       ├── 签名URL Lambda --> ( 难度等级: [0.0145, 0.0145) || 挂载数据: blog: 1 ) 
│   │   │       ├── API Gateway设置 --> ( 难度等级: [0.0145, 0.0146) || 挂载数据: 无 ) 
│   │   │       ├── 提升性能 --> ( 难度等级: [0.0146, 0.0146) || 挂载数据: 无 ) 
│   │   │       └── 提升Firebase安全性 --> ( 难度等级: [0.0146, 0.0147) || 挂载数据: 无 ) 
│   │   ├── 数据库 --> ( 难度等级: [0.0147, 0.0158) || 挂载数据: 无 ) 
│   │   │   ├── Firebase简介 --> ( 难度等级: [0.0147, 0.0152) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据结构 --> ( 难度等级: [0.0147, 0.015) || 挂载数据: 无 ) 
│   │   │   │   └── 安全规则 --> ( 难度等级: [0.015, 0.0152) || 挂载数据: 无 ) 
│   │   │   └── 为 24 小时视频添加Firebase --> ( 难度等级: [0.0152, 0.0158) || 挂载数据: 无 ) 
│   │   │       ├── 设置Firebase --> ( 难度等级: [0.0152, 0.0153) || 挂载数据: 无 ) 
│   │   │       ├── 修改转码视频Lambda --> ( 难度等级: [0.0153, 0.0154) || 挂载数据: 无 ) 
│   │   │       ├── Transcode Video Firebase Update函数 --> ( 难度等级: [0.0154, 0.0155) || 挂载数据: 无 ) 
│   │   │       ├── 连接Lambda --> ( 难度等级: [0.0155, 0.0156) || 挂载数据: 无 ) 
│   │   │       ├── 网站 --> ( 难度等级: [0.0156, 0.0157) || 挂载数据: blog: 1 ) 
│   │   │       └── 端到端测试 --> ( 难度等级: [0.0157, 0.0158) || 挂载数据: 无 ) 
│   │   ├── 最后一英里 . --> ( 难度等级: [0.0158, 0.0168) || 挂载数据: 无 ) 
│   │   │   ├── 部署与框架 --> ( 难度等级: [0.0158, 0.016) || 挂载数据: 无 ) 
│   │   │   ├── 迈向更好的微服务 --> ( 难度等级: [0.016, 0.0162) || 挂载数据: 无 ) 
│   │   │   ├── Step Functions --> ( 难度等级: [0.0162, 0.0164) || 挂载数据: 无 ) 
│   │   │   ├── AWS Marketplace --> ( 难度等级: [0.0164, 0.0166) || 挂载数据: 无 ) 
│   │   │   └── 未来之路 --> ( 难度等级: [0.0166, 0.0168) || 挂载数据: 无 ) 
│   │   ├── Serverless基础 --> ( 难度等级: [0.0168, 0.0179) || 挂载数据: 无 ) 
│   │   │   ├── 什么是Serverless --> ( 难度等级: [0.0168, 0.017) || 挂载数据: 无 ) 
│   │   │   │   ├── Serverless技术的发展 --> ( 难度等级: [0.0168, 0.0168) || 挂载数据: blog: 9 ) 
│   │   │   │   ├── Serverless框架和工具 --> ( 难度等级: [0.0168, 0.0168) || 挂载数据: blog: 6 ) 
│   │   │   │   │   ├── Chalice --> ( 难度等级: [0.0168, 0.0168) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Claudia.js --> ( 难度等级: [0.0168, 0.0168) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── Apex --> ( 难度等级: [0.0168, 0.0168) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Spring Cloud Function --> ( 难度等级: [0.0168, 0.0168) || 挂载数据: blog: 10 ) 
│   │   │   │   │   └── AWS SAM --> ( 难度等级: [0.0168, 0.0168) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Serverless后台服务 --> ( 难度等级: [0.0168, 0.0169) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 获取AWS账号 --> ( 难度等级: [0.0169, 0.0169) || 挂载数据: 无 ) 
│   │   │   │   ├── AWS Lambda控制面板 --> ( 难度等级: [0.0169, 0.0169) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 编辑函数 --> ( 难度等级: [0.0169, 0.0169) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试函数 --> ( 难度等级: [0.0169, 0.0169) || 挂载数据: 无 ) 
│   │   │   │   ├── 外部访问 --> ( 难度等级: [0.0169, 0.0169) || 挂载数据: 无 ) 
│   │   │   │   ├── 运维监控 --> ( 难度等级: [0.0169, 0.0169) || 挂载数据: 无 ) 
│   │   │   │   └── 回顾 --> ( 难度等级: [0.0169, 0.017) || 挂载数据: blog: 1 ) 
│   │   │   ├── Serverless带来的价值 --> ( 难度等级: [0.017, 0.0171) || 挂载数据: 无 ) 
│   │   │   ├── Serverless的技术实现 --> ( 难度等级: [0.0171, 0.0173) || 挂载数据: 无 ) 
│   │   │   │   ├── 理念与实现 --> ( 难度等级: [0.0171, 0.0172) || 挂载数据: 无 ) 
│   │   │   │   └── FaaS与BaaS --> ( 难度等级: [0.0172, 0.0173) || 挂载数据: 无 ) 
│   │   │   │       ├── FaaS的架构 --> ( 难度等级: [0.0172, 0.0172) || 挂载数据: blog: 10 ) 
│   │   │   │       ├── 函数的生命周期 --> ( 难度等级: [0.0172, 0.0172) || 挂载数据: 无 ) 
│   │   │   │       ├── 函数工作流 --> ( 难度等级: [0.0172, 0.0172) || 挂载数据: blog: 1 ) 
│   │   │   │       ├── BaaS的价值 --> ( 难度等级: [0.0172, 0.0172) || 挂载数据: blog: 2 ) 
│   │   │   │       └── 广义的Serverless --> ( 难度等级: [0.0172, 0.0173) || 挂载数据: 无 ) 
│   │   │   ├── Serverless应用架构 --> ( 难度等级: [0.0173, 0.0174) || 挂载数据: 无 ) 
│   │   │   │   ├── 传统应用架构 --> ( 难度等级: [0.0173, 0.0173) || 挂载数据: 无 ) 
│   │   │   │   └── Serverless应用架构 --> ( 难度等级: [0.0173, 0.0174) || 挂载数据: blog: 10 ) 
│   │   │   ├── Serverless的技术特点 --> ( 难度等级: [0.0174, 0.0176) || 挂载数据: 无 ) 
│   │   │   ├── Serverless的应用场景 --> ( 难度等级: [0.0176, 0.0177) || 挂载数据: 无 ) 
│   │   │   └── Serverless的局限 --> ( 难度等级: [0.0177, 0.0179) || 挂载数据: 无 ) 
│   │   ├── AWS Lambda --> ( 难度等级: [0.0179, 0.0189) || 挂载数据: 无 ) 
│   │   │   ├── AWS Serverless --> ( 难度等级: [0.0179, 0.018) || 挂载数据: blog: 10 ) 
│   │   │   ├── AWS Lambda概述 --> ( 难度等级: [0.018, 0.0182) || 挂载数据: blog: 10 ) 
│   │   │   ├── 权限控制 --> ( 难度等级: [0.0182, 0.0183) || 挂载数据: 无 ) 
│   │   │   │   ├── IAM --> ( 难度等级: [0.0182, 0.0182) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 策略 --> ( 难度等级: [0.0182, 0.0183) || 挂载数据: 无 ) 
│   │   │   │   └── 角色 --> ( 难度等级: [0.0183, 0.0183) || 挂载数据: 无 ) 
│   │   │   ├── 事件驱动 --> ( 难度等级: [0.0183, 0.0185) || 挂载数据: 无 ) 
│   │   │   │   ├── 事件源 --> ( 难度等级: [0.0183, 0.0184) || 挂载数据: 无 ) 
│   │   │   │   └── 触发模式 --> ( 难度等级: [0.0184, 0.0185) || 挂载数据: 无 ) 
│   │   │   ├── 日志监控 --> ( 难度等级: [0.0185, 0.0186) || 挂载数据: 无 ) 
│   │   │   ├── 开发辅助 --> ( 难度等级: [0.0186, 0.0188) || 挂载数据: 无 ) 
│   │   │   │   └── 标签 --> ( 难度等级: [0.0186, 0.0188) || 挂载数据: 无 ) 
│   │   │   └── 运行限制 --> ( 难度等级: [0.0188, 0.0189) || 挂载数据: 无 ) 
│   │   │       ├── 资源限制 --> ( 难度等级: [0.0188, 0.0188) || 挂载数据: 无 ) 
│   │   │       └── 并发控制 --> ( 难度等级: [0.0188, 0.0189) || 挂载数据: 无 ) 
│   │   ├── Azure Functions --> ( 难度等级: [0.0189, 0.02) || 挂载数据: 无 ) 
│   │   │   ├── Microsoft Azure --> ( 难度等级: [0.0189, 0.0191) || 挂载数据: blog: 1 ) 
│   │   │   ├── Azure Functions概述 --> ( 难度等级: [0.0191, 0.0193) || 挂载数据: 无 ) 
│   │   │   ├── 创建Azure Serverless应用 --> ( 难度等级: [0.0193, 0.0194) || 挂载数据: 无 ) 
│   │   │   │   ├── 注册Azure账号 --> ( 难度等级: [0.0193, 0.0193) || 挂载数据: 无 ) 
│   │   │   │   ├── Azure控制台 --> ( 难度等级: [0.0193, 0.0194) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 调用函数 --> ( 难度等级: [0.0194, 0.0194) || 挂载数据: 无 ) 
│   │   │   ├── Azure Functions命令行 --> ( 难度等级: [0.0194, 0.0196) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装命令行 --> ( 难度等级: [0.0194, 0.0195) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 发布至公有云 --> ( 难度等级: [0.0195, 0.0196) || 挂载数据: 无 ) 
│   │   │   ├── 深入了解Azure Functions --> ( 难度等级: [0.0196, 0.0198) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数应用设置 --> ( 难度等级: [0.0196, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   ├── Trigger与Bindings --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   │   ├── HTTP Trigger --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Cronjob Trigger --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Kafka Trigger --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   │   └── NATS Trigger --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数代理 --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   └── Slot --> ( 难度等级: [0.0197, 0.0198) || 挂载数据: 无 ) 
│   │   │   └── 私有云部署 --> ( 难度等级: [0.0198, 0.02) || 挂载数据: 无 ) 
│   │   ├── 容器技术基础 --> ( 难度等级: [0.02, 0.021) || 挂载数据: 无 ) 
│   │   │   ├── 什么是容器 --> ( 难度等级: [0.02, 0.0202) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器 --> ( 难度等级: [0.02, 0.02) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 容器镜像 --> ( 难度等级: [0.02, 0.0201) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── 镜像仓库 --> ( 难度等级: [0.0201, 0.0202) || 挂载数据: 无 ) 
│   │   │   │   └── 容器编排 --> ( 难度等级: [0.0202, 0.0202) || 挂载数据: 无 ) 
│   │   │   ├── Docker --> ( 难度等级: [0.0202, 0.0205) || 挂载数据: 无 ) 
│   │   │   │   ├── Vagrant --> ( 难度等级: [0.0202, 0.0203) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── VirtualBox --> ( 难度等级: [0.0203, 0.0203) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 安装Docker --> ( 难度等级: [0.0203, 0.0204) || 挂载数据: 无 ) 
│   │   │   │   ├── 运行容器 --> ( 难度等级: [0.0204, 0.0204) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建容器镜像 --> ( 难度等级: [0.0204, 0.0204) || 挂载数据: 无 ) 
│   │   │   │   └── 分享镜像 --> ( 难度等级: [0.0204, 0.0205) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes基础 --> ( 难度等级: [0.0205, 0.0207) || 挂载数据: 无 ) 
│   │   │   │   ├── 命名空间 --> ( 难度等级: [0.0205, 0.0205) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod --> ( 难度等级: [0.0205, 0.0205) || 挂载数据: 无 ) 
│   │   │   │   ├── Service --> ( 难度等级: [0.0205, 0.0206) || 挂载数据: 无 ) 
│   │   │   │   ├── Deployment --> ( 难度等级: [0.0206, 0.0206) || 挂载数据: 无 ) 
│   │   │   │   ├── ReplicaSet --> ( 难度等级: [0.0206, 0.0206) || 挂载数据: 无 ) 
│   │   │   │   ├── 网络 --> ( 难度等级: [0.0206, 0.0207) || 挂载数据: 无 ) 
│   │   │   │   ├── Ingress --> ( 难度等级: [0.0207, 0.0207) || 挂载数据: 无 ) 
│   │   │   │   └── 交互工具 --> ( 难度等级: [0.0207, 0.0207) || 挂载数据: 无 ) 
│   │   │   └── 构建Kubernetes环境 --> ( 难度等级: [0.0207, 0.021) || 挂载数据: 无 ) 
│   │   │       ├── 启动Vagrant Box --> ( 难度等级: [0.0207, 0.0209) || 挂载数据: 无 ) 
│   │   │       └── 修改默认域 --> ( 难度等级: [0.0209, 0.021) || 挂载数据: 无 ) 
│   │   ├── Serverless的落地与展望 --> ( 难度等级: [0.021, 0.0221) || 挂载数据: 无 ) 
│   │   │   ├── Serverless的落地 --> ( 难度等级: [0.021, 0.0213) || 挂载数据: 无 ) 
│   │   │   ├── Serverless平台建设 --> ( 难度等级: [0.0213, 0.0215) || 挂载数据: 无 ) 
│   │   │   │   ├── 公有云 --> ( 难度等级: [0.0213, 0.0214) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 私有云 --> ( 难度等级: [0.0214, 0.0214) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 混合云 --> ( 难度等级: [0.0214, 0.0215) || 挂载数据: 无 ) 
│   │   │   ├── Serverless应用架构转型 --> ( 难度等级: [0.0215, 0.0218) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发模式 --> ( 难度等级: [0.0215, 0.0216) || 挂载数据: 无 ) 
│   │   │   │   ├── 设计原则 --> ( 难度等级: [0.0216, 0.0217) || 挂载数据: 无 ) 
│   │   │   │   └── 迁移与重构 --> ( 难度等级: [0.0217, 0.0218) || 挂载数据: 无 ) 
│   │   │   └── Serverless的未来 --> ( 难度等级: [0.0218, 0.0221) || 挂载数据: 无 ) 
│   │   │       ├── 建立行业规范 --> ( 难度等级: [0.0218, 0.0219) || 挂载数据: 无 ) 
│   │   │       └── 完善工具链 --> ( 难度等级: [0.0219, 0.0221) || 挂载数据: 无 ) 
│   │   ├── 初识Serverless --> ( 难度等级: [0.0221, 0.0231) || 挂载数据: 无 ) 
│   │   │   ├── 优势与劣势 --> ( 难度等级: [0.0221, 0.0224) || 挂载数据: 无 ) 
│   │   │   ├── 影响力和价值 --> ( 难度等级: [0.0224, 0.0228) || 挂载数据: 无 ) 
│   │   │   └── 典型应用场景 --> ( 难度等级: [0.0228, 0.0231) || 挂载数据: 无 ) 
│   │   │       ├── 视频转码服务 --> ( 难度等级: [0.0228, 0.0228) || 挂载数据: 无 ) 
│   │   │       ├── 数据ETL处理服务 --> ( 难度等级: [0.0228, 0.0229) || 挂载数据: 无 ) 
│   │   │       ├── 网站（服务）后端 --> ( 难度等级: [0.0229, 0.023) || 挂载数据: 无 ) 
│   │   │       ├── 人工智能推理预测 --> ( 难度等级: [0.023, 0.023) || 挂载数据: 无 ) 
│   │   │       └── 物联网相关应用 --> ( 难度等级: [0.023, 0.0231) || 挂载数据: 无 ) 
│   │   ├── Serverless入门 --> ( 难度等级: [0.0231, 0.0242) || 挂载数据: 无 ) 
│   │   │   ├── Serverless架构规范 --> ( 难度等级: [0.0231, 0.0234) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数相关规范 --> ( 难度等级: [0.0231, 0.0232) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数生命周期 --> ( 难度等级: [0.0232, 0.0233) || 挂载数据: 无 ) 
│   │   │   │   └── 工作流程 --> ( 难度等级: [0.0233, 0.0234) || 挂载数据: 无 ) 
│   │   │   ├── 事件与规范 --> ( 难度等级: [0.0234, 0.0236) || 挂载数据: 无 ) 
│   │   │   │   ├── 相关术语 --> ( 难度等级: [0.0234, 0.0235) || 挂载数据: 无 ) 
│   │   │   │   └── 上下文属性 --> ( 难度等级: [0.0235, 0.0236) || 挂载数据: 无 ) 
│   │   │   ├── 工业化产品 --> ( 难度等级: [0.0236, 0.0239) || 挂载数据: 无 ) 
│   │   │   │   ├── Google Cloud Function --> ( 难度等级: [0.0236, 0.0238) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 腾讯云SCF --> ( 难度等级: [0.0238, 0.0239) || 挂载数据: blog: 3 ) 
│   │   │   └── 开发运维工具 --> ( 难度等级: [0.0239, 0.0242) || 挂载数据: 无 ) 
│   │   │       ├── CLI命令行工具 --> ( 难度等级: [0.0239, 0.024) || 挂载数据: blog: 1 ) 
│   │   │       └── 插件 --> ( 难度等级: [0.024, 0.0242) || 挂载数据: 无 ) 
│   │   ├── Web与监控告警场景实践 --> ( 难度等级: [0.0242, 0.0252) || 挂载数据: 无 ) 
│   │   │   └── Web后端与应用服务端 --> ( 难度等级: [0.0242, 0.0252) || 挂载数据: 无 ) 
│   │   │       ├── 上传图片加水印 --> ( 难度等级: [0.0242, 0.0245) || 挂载数据: 无 ) 
│   │   │       ├── 用IP地址查天气并在小程序中应用 --> ( 难度等级: [0.0245, 0.0249) || 挂载数据: 无 ) 
│   │   │       └── 简易用户反馈功能与快应用实践 --> ( 难度等级: [0.0249, 0.0252) || 挂载数据: 无 ) 
│   │   ├── 大数据与人工智能场景实践 --> ( 难度等级: [0.0252, 0.0263) || 挂载数据: 无 ) 
│   │   │   ├── 大数据技术之MapReduce的简单实现 --> ( 难度等级: [0.0252, 0.0257) || 挂载数据: blog: 5 ) 
│   │   │   └── 人工智能领域的实践 --> ( 难度等级: [0.0257, 0.0263) || 挂载数据: blog: 1 ) 
│   │   │       ├── 自然语言处理为你的网站赋能 --> ( 难度等级: [0.0257, 0.0259) || 挂载数据: 无 ) 
│   │   │       ├── 智能客服与微信小程序 --> ( 难度等级: [0.0259, 0.026) || 挂载数据: blog: 2 ) 
│   │   │       ├── 简单的车牌识别系统 --> ( 难度等级: [0.026, 0.0261) || 挂载数据: 无 ) 
│   │   │       └── 视觉：对象检测系统 --> ( 难度等级: [0.0261, 0.0263) || 挂载数据: blog: 1 ) 
│   │   ├── 物联网和其他场景实践 --> ( 难度等级: [0.0263, 0.0273) || 挂载数据: 无 ) 
│   │   │   ├── 物联网相关—定制智能音箱小工具 --> ( 难度等级: [0.0263, 0.0268) || 挂载数据: blog: 1 ) 
│   │   │   └── 其他场景实践 --> ( 难度等级: [0.0268, 0.0273) || 挂载数据: 无 ) 
│   │   │       ├── OJ判题机/小程序在线编程系统实现 --> ( 难度等级: [0.0268, 0.027) || 挂载数据: blog: 1 ) 
│   │   │       └── 微信公众号机器人 --> ( 难度等级: [0.027, 0.0273) || 挂载数据: 无 ) 
│   │   ├── Serverless范式 --> ( 难度等级: [0.0273, 0.0284) || 挂载数据: 无 ) 
│   │   │   ├── Serverless架构不仅仅是实时的 --> ( 难度等级: [0.0273, 0.0278) || 挂载数据: 无 ) 
│   │   │   └── Serverless的优缺点 --> ( 难度等级: [0.0278, 0.0284) || 挂载数据: 无 ) 
│   │   ├── 在AWS中构建Serverless应用程序 --> ( 难度等级: [0.0284, 0.0294) || 挂载数据: 无 ) 
│   │   │   ├── AWS Lambda的触发器 --> ( 难度等级: [0.0284, 0.0286) || 挂载数据: 无 ) 
│   │   │   ├── 函数即容器 --> ( 难度等级: [0.0286, 0.0288) || 挂载数据: 无 ) 
│   │   │   ├── 配置函数 --> ( 难度等级: [0.0288, 0.029) || 挂载数据: 无 ) 
│   │   │   ├── Lambda函数的版本控制 --> ( 难度等级: [0.029, 0.0292) || 挂载数据: 无 ) 
│   │   │   └── 创建部署包 --> ( 难度等级: [0.0292, 0.0294) || 挂载数据: 无 ) 
│   │   ├── 设置Serverless架构 --> ( 难度等级: [0.0294, 0.0305) || 挂载数据: 无 ) 
│   │   │   ├── S3触发器 --> ( 难度等级: [0.0294, 0.0297) || 挂载数据: 无 ) 
│   │   │   ├── SNS触发器 --> ( 难度等级: [0.0297, 0.0299) || 挂载数据: 无 ) 
│   │   │   ├── SQS触发器 --> ( 难度等级: [0.0299, 0.0302) || 挂载数据: 无 ) 
│   │   │   └── CloudWatch触发器 --> ( 难度等级: [0.0302, 0.0305) || 挂载数据: 无 ) 
│   │   ├── 部署Serverless API --> ( 难度等级: [0.0305, 0.0315) || 挂载数据: 无 ) 
│   │   │   ├── 设置集成 --> ( 难度等级: [0.0305, 0.0308) || 挂载数据: 无 ) 
│   │   │   ├── 为API部署Lambda函数 --> ( 难度等级: [0.0308, 0.0312) || 挂载数据: 无 ) 
│   │   │   └── 处理身份验证与用户控制 --> ( 难度等级: [0.0312, 0.0315) || 挂载数据: 无 ) 
│   │   ├── 扩展Serverless架构 --> ( 难度等级: [0.0315, 0.0326) || 挂载数据: 无 ) 
│   │   │   ├── 第三方编排工具 --> ( 难度等级: [0.0315, 0.0319) || 挂载数据: 无 ) 
│   │   │   ├── 服务器的创建和终止 --> ( 难度等级: [0.0319, 0.0322) || 挂载数据: 无 ) 
│   │   │   └── 扩展的难点及解决方案 --> ( 难度等级: [0.0322, 0.0326) || 挂载数据: 无 ) 
│   │   ├── AWS Lambda的安全性 --> ( 难度等级: [0.0326, 0.0336) || 挂载数据: 无 ) 
│   │   │   ├── 了解AWS VPC --> ( 难度等级: [0.0326, 0.0328) || 挂载数据: blog: 6 ) 
│   │   │   ├── 了解VPC中的子网 --> ( 难度等级: [0.0328, 0.033) || 挂载数据: 无 ) 
│   │   │   ├── 在私有子网内保护Lambda --> ( 难度等级: [0.033, 0.0332) || 挂载数据: 无 ) 
│   │   │   ├── Lambda函数的访问控制 --> ( 难度等级: [0.0332, 0.0334) || 挂载数据: 无 ) 
│   │   │   └── 在Lambda中使用STS执行安全会话 --> ( 难度等级: [0.0334, 0.0336) || 挂载数据: 无 ) 
│   │   ├── 使用SAM部署Lambda函数 --> ( 难度等级: [0.0336, 0.0347) || 挂载数据: 无 ) 
│   │   │   ├── SAM简介 --> ( 难度等级: [0.0336, 0.0339) || 挂载数据: 无 ) 
│   │   │   ├── 将CloudFormation用于Serverless服务 --> ( 难度等级: [0.0339, 0.0341) || 挂载数据: 无 ) 
│   │   │   ├── 使用SAM进行部署 --> ( 难度等级: [0.0341, 0.0344) || 挂载数据: 无 ) 
│   │   │   └── 了解SAM中的安全性 --> ( 难度等级: [0.0344, 0.0347) || 挂载数据: 无 ) 
│   │   └── 微软Azure Functions简介 --> ( 难度等级: [0.0347, 0.0357) || 挂载数据: 无 ) 
│   │       ├── 微软Azure Functions简介 --> ( 难度等级: [0.0347, 0.0349) || 挂载数据: 无 ) 
│   │       ├── 创建你的第一个Azure Function --> ( 难度等级: [0.0349, 0.0352) || 挂载数据: 无 ) 
│   │       ├── 了解触发器 --> ( 难度等级: [0.0352, 0.0355) || 挂载数据: 无 ) 
│   │       └── 编写微软Azure Functions的最佳实践 --> ( 难度等级: [0.0355, 0.0357) || 挂载数据: 无 ) 
│   ├── 微服务 --> ( 难度等级: [0.0357, 0.0714) || 挂载数据: 无 ) 
│   │   ├── Service Mesh --> ( 难度等级: [0.0357, 0.0362) || 挂载数据: 无 ) 
│   │   │   ├── Istio --> ( 难度等级: [0.0357, 0.0358) || 挂载数据: 无 ) 
│   │   │   ├── Linkerd --> ( 难度等级: [0.0358, 0.0359) || 挂载数据: 无 ) 
│   │   │   ├── Conduit --> ( 难度等级: [0.0359, 0.036) || 挂载数据: 无 ) 
│   │   │   ├── Service Mesh的现状 --> ( 难度等级: [0.036, 0.0361) || 挂载数据: 无 ) 
│   │   │   └── Istio架构分析 --> ( 难度等级: [0.0361, 0.0362) || 挂载数据: 无 ) 
│   │   ├── Framework --> ( 难度等级: [0.0362, 0.0367) || 挂载数据: blog: 2 ) 
│   │   │   ├── Dubbo --> ( 难度等级: [0.0362, 0.0364) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud --> ( 难度等级: [0.0364, 0.0366) || 挂载数据: 无 ) 
│   │   │   │   ├── 简介 --> ( 难度等级: [0.0364, 0.0365) || 挂载数据: 无 ) 
│   │   │   │   └── 常用组件 --> ( 难度等级: [0.0365, 0.0366) || 挂载数据: 无 ) 
│   │   │   └── Tars --> ( 难度等级: [0.0366, 0.0367) || 挂载数据: 无 ) 
│   │   ├── 微服务简介 --> ( 难度等级: [0.0367, 0.0373) || 挂载数据: 无 ) 
│   │   │   ├── 单体架构及其存在的不足 --> ( 难度等级: [0.0367, 0.0369) || 挂载数据: 无 ) 
│   │   │   │   ├── 单体架构简介 --> ( 难度等级: [0.0367, 0.0368) || 挂载数据: 无 ) 
│   │   │   │   ├── 单体架构存在的不足 --> ( 难度等级: [0.0368, 0.0368) || 挂载数据: 无 ) 
│   │   │   │   └── 单体架构使用服务器集群及存在的不足 --> ( 难度等级: [0.0368, 0.0369) || 挂载数据: blog: 2 ) 
│   │   │   ├── 微服务 --> ( 难度等级: [0.0369, 0.037) || 挂载数据: 无 ) 
│   │   │   │   ├── 什么是微服务 --> ( 难度等级: [0.0369, 0.0369) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 微服务的优势 --> ( 难度等级: [0.0369, 0.037) || 挂载数据: 无 ) 
│   │   │   ├── 微服务的不足 --> ( 难度等级: [0.037, 0.0371) || 挂载数据: 无 ) 
│   │   │   │   ├── 微服务的复杂度 --> ( 难度等级: [0.037, 0.037) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式事务 --> ( 难度等级: [0.037, 0.037) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 服务的划分 --> ( 难度等级: [0.037, 0.037) || 挂载数据: 无 ) 
│   │   │   │   └── 服务的部署 --> ( 难度等级: [0.037, 0.0371) || 挂载数据: 无 ) 
│   │   │   ├── 微服务和SOA的关系 --> ( 难度等级: [0.0371, 0.0372) || 挂载数据: blog: 1 ) 
│   │   │   └── 微服务的设计原则 --> ( 难度等级: [0.0372, 0.0373) || 挂载数据: 无 ) 
│   │   ├── Spring Cloud简介 --> ( 难度等级: [0.0373, 0.0378) || 挂载数据: 无 ) 
│   │   │   ├── 微服务应该具备的功能 --> ( 难度等级: [0.0373, 0.0374) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务的注册与发现 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── 服务的负载均衡 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 服务的容错 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务网关 --> ( 难度等级: [0.0373, 0.0374) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 服务网关的实现原理 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 断言工厂 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── After路由断言工厂 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Header断言工厂 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Cookie路由断言工厂 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Host路由断言工厂 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   ├── Method路由断言工厂 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Path路由断言工厂 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── Query路由断言工厂 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 过滤器 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 过滤器的作用 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 过滤器的生命周期 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 网关过滤器 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 全局过滤器 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 限流 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 常见的限流算法 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 服务网关的限流 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 普通方式 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 条件方式 --> ( 难度等级: [0.0373, 0.0373) || 挂载数据: 无 ) 
│   │   │   │   │   └── 服务化 --> ( 难度等级: [0.0373, 0.0374) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 工程介绍 --> ( 难度等级: [0.0373, 0.0374) || 挂载数据: 无 ) 
│   │   │   │   │       └── service-gateway工程详细介绍 --> ( 难度等级: [0.0374, 0.0374) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务配置的统一管理 --> ( 难度等级: [0.0374, 0.0374) || 挂载数据: 无 ) 
│   │   │   │   └── 服务链路追踪 --> ( 难度等级: [0.0374, 0.0374) || 挂载数据: 无 ) 
│   │   │   ├── Dubbo简介 --> ( 难度等级: [0.0374, 0.0375) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes简介 --> ( 难度等级: [0.0375, 0.0377) || 挂载数据: 无 ) 
│   │   │   └── Spring Could与Kubernetes比较 --> ( 难度等级: [0.0377, 0.0378) || 挂载数据: 无 ) 
│   │   ├── 构建微服务的准备 --> ( 难度等级: [0.0378, 0.0383) || 挂载数据: 无 ) 
│   │   │   ├── JDK的安装 --> ( 难度等级: [0.0378, 0.038) || 挂载数据: 无 ) 
│   │   │   │   ├── JDK的下载和安装 --> ( 难度等级: [0.0378, 0.0379) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 环境变量的配置 --> ( 难度等级: [0.0379, 0.038) || 挂载数据: 无 ) 
│   │   │   ├── IDEA的安装 --> ( 难度等级: [0.038, 0.0381) || 挂载数据: 无 ) 
│   │   │   │   ├── IDEA的下载 --> ( 难度等级: [0.038, 0.038) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 用IDEA创建一个Spring Boot工程 --> ( 难度等级: [0.038, 0.0381) || 挂载数据: blog: 2 ) 
│   │   │   └── 构建工具Maven的使用 --> ( 难度等级: [0.0381, 0.0383) || 挂载数据: 无 ) 
│   │   │       ├── Maven简介 --> ( 难度等级: [0.0381, 0.0382) || 挂载数据: 无 ) 
│   │   │       ├── Maven的安装 --> ( 难度等级: [0.0382, 0.0382) || 挂载数据: blog: 2 ) 
│   │   │       ├── Maven的核心概念 --> ( 难度等级: [0.0382, 0.0382) || 挂载数据: 无 ) 
│   │   │       ├── 编写Pom文件 --> ( 难度等级: [0.0382, 0.0383) || 挂载数据: 无 ) 
│   │   │       └── 常用的Maven命令 --> ( 难度等级: [0.0383, 0.0383) || 挂载数据: 无 ) 
│   │   ├── 开发框架Spring Boot --> ( 难度等级: [0.0383, 0.0388) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot简介 --> ( 难度等级: [0.0383, 0.0384) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Boot的特点 --> ( 难度等级: [0.0383, 0.0383) || 挂载数据: blog: 10 ) 
│   │   │   │   └── Spring Boot的优点 --> ( 难度等级: [0.0383, 0.0384) || 挂载数据: blog: 1 ) 
│   │   │   ├── 用IDEA构建Spring Boot工程 --> ( 难度等级: [0.0384, 0.0385) || 挂载数据: 无 ) 
│   │   │   │   ├── 在Spring Boot工程中构建Web程序 --> ( 难度等级: [0.0384, 0.0384) || 挂载数据: blog: 9 ) 
│   │   │   │   └── Spring Boot的测试 --> ( 难度等级: [0.0384, 0.0385) || 挂载数据: blog: 10 ) 
│   │   │   ├── Spring Boot配置文件详解 --> ( 难度等级: [0.0385, 0.0385) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义属性 --> ( 难度等级: [0.0385, 0.0385) || 挂载数据: 无 ) 
│   │   │   │   ├── 将配置文件的属性赋给实体类 --> ( 难度等级: [0.0385, 0.0385) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义配置文件 --> ( 难度等级: [0.0385, 0.0385) || 挂载数据: 无 ) 
│   │   │   │   └── 多个环境的配置文件 --> ( 难度等级: [0.0385, 0.0385) || 挂载数据: 无 ) 
│   │   │   ├── 运行状态监控Actuator --> ( 难度等级: [0.0385, 0.0386) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看运行程序的健康状态 --> ( 难度等级: [0.0385, 0.0385) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看运行程序的Bean --> ( 难度等级: [0.0385, 0.0386) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用Actuator关闭应用程序 --> ( 难度等级: [0.0386, 0.0386) || 挂载数据: 无 ) 
│   │   │   │   └── 使用shell连接Actuator --> ( 难度等级: [0.0386, 0.0386) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot整合JPA --> ( 难度等级: [0.0386, 0.0387) || 挂载数据: blog: 1 ) 
│   │   │   ├── Spring Boot整合Redis --> ( 难度等级: [0.0387, 0.0387) || 挂载数据: 无 ) 
│   │   │   │   ├── Redis简介 --> ( 难度等级: [0.0387, 0.0387) || 挂载数据: 无 ) 
│   │   │   │   ├── Redis的安装 --> ( 难度等级: [0.0387, 0.0387) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 在Spring Boot中使用Redis --> ( 难度等级: [0.0387, 0.0387) || 挂载数据: blog: 10 ) 
│   │   │   └── Spring Boot整合Swagger2，搭建Restful API在线文档 --> ( 难度等级: [0.0387, 0.0388) || 挂载数据: 无 ) 
│   │   ├── 负载均衡Ribbon --> ( 难度等级: [0.0388, 0.0393) || 挂载数据: 无 ) 
│   │   │   ├── RestTemplate简介 --> ( 难度等级: [0.0388, 0.0389) || 挂载数据: blog: 1 ) 
│   │   │   ├── Ribbon简介 --> ( 难度等级: [0.0389, 0.039) || 挂载数据: blog: 1 ) 
│   │   │   ├── 使用RestTemplate和Ribbon来消费服务 --> ( 难度等级: [0.039, 0.0391) || 挂载数据: blog: 10 ) 
│   │   │   ├── LoadBalancerClient简介 --> ( 难度等级: [0.0391, 0.0392) || 挂载数据: 无 ) 
│   │   │   └── 源码解析Ribbon --> ( 难度等级: [0.0392, 0.0393) || 挂载数据: 无 ) 
│   │   ├── 声明式调用Feign --> ( 难度等级: [0.0393, 0.0399) || 挂载数据: 无 ) 
│   │   │   ├── 写一个Feign客户端 --> ( 难度等级: [0.0393, 0.0394) || 挂载数据: 无 ) 
│   │   │   ├── FeignClient详解 --> ( 难度等级: [0.0394, 0.0395) || 挂载数据: 无 ) 
│   │   │   ├── FeignClient的配置 --> ( 难度等级: [0.0395, 0.0396) || 挂载数据: 无 ) 
│   │   │   ├── 从源码的角度讲解Feign的工作原理 --> ( 难度等级: [0.0396, 0.0397) || 挂载数据: 无 ) 
│   │   │   ├── 在Feign中使用HttpClient和OkHttp --> ( 难度等级: [0.0397, 0.0398) || 挂载数据: 无 ) 
│   │   │   └── Feign是如何实现负载均衡的 --> ( 难度等级: [0.0398, 0.0399) || 挂载数据: blog: 8 ) 
│   │   ├── 熔断器Hystrix --> ( 难度等级: [0.0399, 0.0404) || 挂载数据: 无 ) 
│   │   │   ├── Hystrix简介 --> ( 难度等级: [0.0399, 0.0399) || 挂载数据: 无 ) 
│   │   │   ├── Hystrix的设计原则 --> ( 难度等级: [0.0399, 0.04) || 挂载数据: 无 ) 
│   │   │   ├── Hystrix的工作机制 --> ( 难度等级: [0.04, 0.0401) || 挂载数据: 无 ) 
│   │   │   ├── 在Feign上使用熔断器 --> ( 难度等级: [0.0401, 0.0402) || 挂载数据: 无 ) 
│   │   │   ├── 使用Hystrix Dashboard监控熔断器的状态 --> ( 难度等级: [0.0402, 0.0403) || 挂载数据: 无 ) 
│   │   │   │   ├── 在RestTemplate中使用Hystrix Dashboard --> ( 难度等级: [0.0402, 0.0402) || 挂载数据: 无 ) 
│   │   │   │   └── 在Feign中使用Hystrix Dashboard --> ( 难度等级: [0.0402, 0.0403) || 挂载数据: blog: 10 ) 
│   │   │   └── 使用Turbine聚合监控 --> ( 难度等级: [0.0403, 0.0404) || 挂载数据: 无 ) 
│   │   ├── 路由网关Spring Cloud Zuul --> ( 难度等级: [0.0404, 0.0409) || 挂载数据: 无 ) 
│   │   │   └── Zuul的工作原理 --> ( 难度等级: [0.0404, 0.0409) || 挂载数据: blog: 3 ) 
│   │   ├── 配置中心Spring Cloud Config --> ( 难度等级: [0.0409, 0.0414) || 挂载数据: 无 ) 
│   │   │   ├── Config Server从本地读取配置文件 --> ( 难度等级: [0.0409, 0.041) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建Config Server --> ( 难度等级: [0.0409, 0.0409) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 构建Config Client --> ( 难度等级: [0.0409, 0.041) || 挂载数据: blog: 8 ) 
│   │   │   ├── Config Server从远程Git仓库读取配置文件 --> ( 难度等级: [0.041, 0.0411) || 挂载数据: blog: 4 ) 
│   │   │   ├── 构建高可用的Config Server --> ( 难度等级: [0.0411, 0.0412) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建Eureka Server --> ( 难度等级: [0.0411, 0.0411) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 改造Config Server --> ( 难度等级: [0.0411, 0.0412) || 挂载数据: 无 ) 
│   │   │   │   └── 改造Config Client --> ( 难度等级: [0.0412, 0.0412) || 挂载数据: 无 ) 
│   │   │   ├── 使用Spring Cloud Bus刷新配置 --> ( 难度等级: [0.0412, 0.0413) || 挂载数据: 无 ) 
│   │   │   └── 将配置存储在MySQL数据库中 --> ( 难度等级: [0.0413, 0.0414) || 挂载数据: 无 ) 
│   │   │       ├── 改造config-server工程 --> ( 难度等级: [0.0413, 0.0414) || 挂载数据: 无 ) 
│   │   │       └── 初始化数据库 --> ( 难度等级: [0.0414, 0.0414) || 挂载数据: blog: 1 ) 
│   │   ├── 服务链路追踪Spring Cloud Sleuth --> ( 难度等级: [0.0414, 0.0419) || 挂载数据: 无 ) 
│   │   │   ├── 基本术语 --> ( 难度等级: [0.0414, 0.0415) || 挂载数据: 无 ) 
│   │   │   ├── 案例讲解 --> ( 难度等级: [0.0415, 0.0416) || 挂载数据: 无 ) 
│   │   │   │   ├── 启动Zipkin Server --> ( 难度等级: [0.0415, 0.0415) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建服务提供者 --> ( 难度等级: [0.0415, 0.0415) || 挂载数据: 无 ) 
│   │   │   │   └── 构建服务消费者 --> ( 难度等级: [0.0415, 0.0416) || 挂载数据: 无 ) 
│   │   │   ├── 在链路数据中添加自定义数据 --> ( 难度等级: [0.0416, 0.0416) || 挂载数据: 无 ) 
│   │   │   ├── 使用RabbitMQ传输链路数据 --> ( 难度等级: [0.0416, 0.0417) || 挂载数据: 无 ) 
│   │   │   ├── 在MySQL数据库中存储链路数据 --> ( 难度等级: [0.0417, 0.0418) || 挂载数据: 无 ) 
│   │   │   ├── 在ElasticSearch中存储链路数据 --> ( 难度等级: [0.0418, 0.0419) || 挂载数据: 无 ) 
│   │   │   └── 用Kibana展示链路数据 --> ( 难度等级: [0.0419, 0.0419) || 挂载数据: 无 ) 
│   │   ├── 微服务监控Spring Boot Admin --> ( 难度等级: [0.0419, 0.0424) || 挂载数据: 无 ) 
│   │   │   ├── 使用Spring Boot Admin监控Spring Boot应用程序 --> ( 难度等级: [0.0419, 0.0421) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建Spring Boot Admin Server --> ( 难度等级: [0.0419, 0.042) || 挂载数据: 无 ) 
│   │   │   │   └── 创建Spring Boot Admin Client --> ( 难度等级: [0.042, 0.0421) || 挂载数据: blog: 10 ) 
│   │   │   ├── 使用Spring Boot Admin监控Spring Cloud微服务 --> ( 难度等级: [0.0421, 0.0423) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建Admin Server --> ( 难度等级: [0.0421, 0.0422) || 挂载数据: 无 ) 
│   │   │   │   └── 构建Admin Client --> ( 难度等级: [0.0422, 0.0423) || 挂载数据: blog: 3 ) 
│   │   │   └── 在Spring Boot Admin中添加Security和Mail组件 --> ( 难度等级: [0.0423, 0.0424) || 挂载数据: 无 ) 
│   │   │       ├── Spring Boot Admin集成Security组件 --> ( 难度等级: [0.0423, 0.0424) || 挂载数据: 无 ) 
│   │   │       └── Spring Boot Admin集成Mail组件 --> ( 难度等级: [0.0424, 0.0424) || 挂载数据: blog: 1 ) 
│   │   ├── Spring Boot Security详解 --> ( 难度等级: [0.0424, 0.043) || 挂载数据: 无 ) 
│   │   │   ├── Spring Security简介 --> ( 难度等级: [0.0424, 0.0426) || 挂载数据: 无 ) 
│   │   │   │   ├── 什么是Spring Security --> ( 难度等级: [0.0424, 0.0425) || 挂载数据: blog: 10 ) 
│   │   │   │   └── Spring Security提供的安全模块 --> ( 难度等级: [0.0425, 0.0426) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot Security与Spring Security的关系 --> ( 难度等级: [0.0426, 0.0428) || 挂载数据: 无 ) 
│   │   │   └── Spring Boot Security案例详解 --> ( 难度等级: [0.0428, 0.043) || 挂载数据: 无 ) 
│   │   │       ├── 构建Spring Boot Security工程 --> ( 难度等级: [0.0428, 0.0428) || 挂载数据: blog: 10 ) 
│   │   │       ├── 配置Spring Security --> ( 难度等级: [0.0428, 0.0429) || 挂载数据: blog: 10 ) 
│   │   │       ├── 编写相关界面 --> ( 难度等级: [0.0429, 0.0429) || 挂载数据: 无 ) 
│   │   │       ├── Spring Security方法级别上的保护 --> ( 难度等级: [0.0429, 0.0429) || 挂载数据: 无 ) 
│   │   │       └── 从数据库中读取用户的认证信息 --> ( 难度等级: [0.0429, 0.043) || 挂载数据: 无 ) 
│   │   ├── 使用Spring Cloud OAuth2保护微服务系统 --> ( 难度等级: [0.043, 0.0435) || 挂载数据: 无 ) 
│   │   │   ├── 什么是OAuth2 --> ( 难度等级: [0.043, 0.0431) || 挂载数据: 无 ) 
│   │   │   ├── 如何使用Spring OAuth2 --> ( 难度等级: [0.0431, 0.0433) || 挂载数据: 无 ) 
│   │   │   │   ├── OAuth2 Provider --> ( 难度等级: [0.0431, 0.0432) || 挂载数据: 无 ) 
│   │   │   │   └── OAuth2 Client --> ( 难度等级: [0.0432, 0.0433) || 挂载数据: blog: 6 ) 
│   │   │   └── 案例分析 --> ( 难度等级: [0.0433, 0.0435) || 挂载数据: 无 ) 
│   │   │       ├── 编写Eureka Server --> ( 难度等级: [0.0433, 0.0433) || 挂载数据: blog: 10 ) 
│   │   │       ├── 编写Uaa授权服务 --> ( 难度等级: [0.0433, 0.0434) || 挂载数据: 无 ) 
│   │   │       ├── 编写service-hi资源服务 --> ( 难度等级: [0.0434, 0.0434) || 挂载数据: 无 ) 
│   │   │       ├── 案例架构设计 --> ( 难度等级: [0.0434, 0.0434) || 挂载数据: 无 ) 
│   │   │       ├── 编写主Maven工程 --> ( 难度等级: [0.0434, 0.0434) || 挂载数据: 无 ) 
│   │   │       └── 编写user-service资源服务 --> ( 难度等级: [0.0434, 0.0435) || 挂载数据: 无 ) 
│   │   ├── 使用Spring Security OAuth2和JWT保护微服务系统 --> ( 难度等级: [0.0435, 0.044) || 挂载数据: 无 ) 
│   │   │   └── JWT简介 --> ( 难度等级: [0.0435, 0.044) || 挂载数据: 无 ) 
│   │   │       ├── 什么是JWT --> ( 难度等级: [0.0435, 0.0436) || 挂载数据: blog: 10 ) 
│   │   │       ├── JWT的结构 --> ( 难度等级: [0.0436, 0.0437) || 挂载数据: 无 ) 
│   │   │       ├── JWT的应用场景 --> ( 难度等级: [0.0437, 0.0439) || 挂载数据: blog: 2 ) 
│   │   │       └── 如何使用JWT --> ( 难度等级: [0.0439, 0.044) || 挂载数据: 无 ) 
│   │   ├── 使用Spring Cloud构建微服务综合案例 --> ( 难度等级: [0.044, 0.0445) || 挂载数据: 无 ) 
│   │   │   ├── 案例介绍 --> ( 难度等级: [0.044, 0.0442) || 挂载数据: 无 ) 
│   │   │   │   ├── 工程结构 --> ( 难度等级: [0.044, 0.044) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用的技术栈 --> ( 难度等级: [0.044, 0.0441) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 工程架构 --> ( 难度等级: [0.0441, 0.0441) || 挂载数据: 无 ) 
│   │   │   │   └── 功能展示 --> ( 难度等级: [0.0441, 0.0442) || 挂载数据: 无 ) 
│   │   │   ├── 案例详解 --> ( 难度等级: [0.0442, 0.0443) || 挂载数据: 无 ) 
│   │   │   │   ├── 准备工作 --> ( 难度等级: [0.0442, 0.0442) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建主Maven工程 --> ( 难度等级: [0.0442, 0.0442) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建eureka-server工程 --> ( 难度等级: [0.0442, 0.0442) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 构建config-server工程 --> ( 难度等级: [0.0442, 0.0442) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建Zipkin工程 --> ( 难度等级: [0.0442, 0.0442) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建monitoring-service工程 --> ( 难度等级: [0.0442, 0.0443) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建uaa-service工程 --> ( 难度等级: [0.0443, 0.0443) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建gateway-service工程 --> ( 难度等级: [0.0443, 0.0443) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建admin-service工程 --> ( 难度等级: [0.0443, 0.0443) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建user-service工程 --> ( 难度等级: [0.0443, 0.0443) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建blog-service工程 --> ( 难度等级: [0.0443, 0.0443) || 挂载数据: 无 ) 
│   │   │   │   └── 构建log-service工程 --> ( 难度等级: [0.0443, 0.0443) || 挂载数据: 无 ) 
│   │   │   └── 启动源码工程 --> ( 难度等级: [0.0443, 0.0445) || 挂载数据: 无 ) 
│   │   ├── Spring Cloud生态 --> ( 难度等级: [0.0445, 0.045) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud基础：Spring Boot概述 --> ( 难度等级: [0.0445, 0.0447) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot核心特性 --> ( 难度等级: [0.0447, 0.0449) || 挂载数据: 无 ) 
│   │   │   │   ├── Web服务器：WebServer --> ( 难度等级: [0.0447, 0.0447) || 挂载数据: 无 ) 
│   │   │   │   ├── 条件注解：@ConditionalOnXX --> ( 难度等级: [0.0447, 0.0448) || 挂载数据: 无 ) 
│   │   │   │   ├── 工厂加载机制 --> ( 难度等级: [0.0448, 0.0448) || 挂载数据: 无 ) 
│   │   │   │   ├── 配置加载机制 --> ( 难度等级: [0.0448, 0.0448) || 挂载数据: 无 ) 
│   │   │   │   └── Spring Boot Actuator --> ( 难度等级: [0.0448, 0.0449) || 挂载数据: blog: 1 ) 
│   │   │   └── Spring Cloud概述 --> ( 难度等级: [0.0449, 0.045) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud诞生背景 --> ( 难度等级: [0.0449, 0.0449) || 挂载数据: 无 ) 
│   │   │       ├── Netflix OSS --> ( 难度等级: [0.0449, 0.0449) || 挂载数据: blog: 10 ) 
│   │   │       ├── Spring Cloud版本 --> ( 难度等级: [0.0449, 0.045) || 挂载数据: blog: 10 ) 
│   │   │       └── Spring Cloud最新动态 --> ( 难度等级: [0.045, 0.045) || 挂载数据: blog: 10 ) 
│   │   ├── 负载均衡与服务调用 --> ( 难度等级: [0.045, 0.0455) || 挂载数据: 无 ) 
│   │   │   ├── 负载均衡原理 --> ( 难度等级: [0.045, 0.0451) || 挂载数据: blog: 2 ) 
│   │   │   ├── Spring Cloud LoadBalancer负载均衡组件 --> ( 难度等级: [0.0451, 0.0452) || 挂载数据: blog: 1 ) 
│   │   │   ├── Netflix Ribbon负载均衡 --> ( 难度等级: [0.0452, 0.0452) || 挂载数据: 无 ) 
│   │   │   │   ├── RibbonLoadBalancerClient --> ( 难度等级: [0.0452, 0.0452) || 挂载数据: 无 ) 
│   │   │   │   ├── RibbonServer和Server --> ( 难度等级: [0.0452, 0.0452) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── ServerIntrospector --> ( 难度等级: [0.0452, 0.0452) || 挂载数据: 无 ) 
│   │   │   │   ├── ILoadBalancer --> ( 难度等级: [0.0452, 0.0452) || 挂载数据: 无 ) 
│   │   │   │   ├── ServerList --> ( 难度等级: [0.0452, 0.0452) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── ServerListUpdater --> ( 难度等级: [0.0452, 0.0452) || 挂载数据: 无 ) 
│   │   │   │   ├── ServerStats --> ( 难度等级: [0.0452, 0.0452) || 挂载数据: 无 ) 
│   │   │   │   └── Ribbon缓存时间 --> ( 难度等级: [0.0452, 0.0452) || 挂载数据: blog: 10 ) 
│   │   │   ├── Dubbo LoadBalance负载均衡 --> ( 难度等级: [0.0452, 0.0453) || 挂载数据: 无 ) 
│   │   │   ├── OpenFeign：声明式Rest客户端 --> ( 难度等级: [0.0453, 0.0454) || 挂载数据: 无 ) 
│   │   │   │   ├── OpenFeign概述 --> ( 难度等级: [0.0453, 0.0453) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── OpenFeign对JAX-RS的支持 --> ( 难度等级: [0.0453, 0.0453) || 挂载数据: 无 ) 
│   │   │   │   └── OpenFeign底层执行原理 --> ( 难度等级: [0.0453, 0.0454) || 挂载数据: 无 ) 
│   │   │   ├── Dubbo Spring Cloud ：服务调用的新选择 --> ( 难度等级: [0.0454, 0.0454) || 挂载数据: 无 ) 
│   │   │   ├── 再谈路由和负载均衡 --> ( 难度等级: [0.0454, 0.0455) || 挂载数据: 无 ) 
│   │   │   └── 案例：应用流量控制 --> ( 难度等级: [0.0455, 0.0455) || 挂载数据: 无 ) 
│   │   │       ├── 流量控制应用的业务场景 --> ( 难度等级: [0.0455, 0.0455) || 挂载数据: blog: 1 ) 
│   │   │       └── 使用Netflix Ribbon完成应用灰度发布 --> ( 难度等级: [0.0455, 0.0455) || 挂载数据: 无 ) 
│   │   ├── 配置管理 --> ( 难度等级: [0.0455, 0.0461) || 挂载数据: 无 ) 
│   │   │   ├── 配置中心背景概述 --> ( 难度等级: [0.0455, 0.0457) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Config Server/Client --> ( 难度等级: [0.0457, 0.0459) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud Config Server --> ( 难度等级: [0.0457, 0.0458) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Spring Cloud Config Client --> ( 难度等级: [0.0458, 0.0458) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── Spring Cloud Config Client与Service Discovery整合 --> ( 难度等级: [0.0458, 0.0459) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Spring Cloud Config配置动态刷新 --> ( 难度等级: [0.0459, 0.0459) || 挂载数据: blog: 2 ) 
│   │   │   └── 再谈配置动态刷新 --> ( 难度等级: [0.0459, 0.0461) || 挂载数据: 无 ) 
│   │   ├── 熔断器 --> ( 难度等级: [0.0461, 0.0466) || 挂载数据: 无 ) 
│   │   │   ├── 熔断器模式概述 --> ( 难度等级: [0.0461, 0.0462) || 挂载数据: 无 ) 
│   │   │   ├── 手动实现一个断路器 --> ( 难度等级: [0.0462, 0.0462) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义State枚举和Counter计数器类 --> ( 难度等级: [0.0462, 0.0462) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义CircuitBreaker类 --> ( 难度等级: [0.0462, 0.0462) || 挂载数据: 无 ) 
│   │   │   │   └── 使用CircuitBreaker进行场景测试 --> ( 难度等级: [0.0462, 0.0462) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Circuit Breaker的技术演进 --> ( 难度等级: [0.0462, 0.0463) || 挂载数据: 无 ) 
│   │   │   ├── Alib*ba Sentinel --> ( 难度等级: [0.0463, 0.0464) || 挂载数据: 无 ) 
│   │   │   │   ├── Sentinel核心概述 --> ( 难度等级: [0.0463, 0.0463) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud Alib*ba Sentinel --> ( 难度等级: [0.0463, 0.0464) || 挂载数据: 无 ) 
│   │   │   │   ├── Sentinel限流与Dashboard --> ( 难度等级: [0.0464, 0.0464) || 挂载数据: blog: 4 ) 
│   │   │   │   └── Sentinel的高级特性 --> ( 难度等级: [0.0464, 0.0464) || 挂载数据: 无 ) 
│   │   │   ├── Netflix Hystrix --> ( 难度等级: [0.0464, 0.0465) || 挂载数据: 无 ) 
│   │   │   │   ├── Hystrix核心概述 --> ( 难度等级: [0.0464, 0.0464) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud Netflix Hystrix --> ( 难度等级: [0.0464, 0.0465) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── Hystrix限流与Dashboard --> ( 难度等级: [0.0465, 0.0465) || 挂载数据: 无 ) 
│   │   │   │   └── Hystrix的高级特性 --> ( 难度等级: [0.0465, 0.0465) || 挂载数据: 无 ) 
│   │   │   └── Resilience4j --> ( 难度等级: [0.0465, 0.0466) || 挂载数据: 无 ) 
│   │   │       ├── Resilience4j体验 --> ( 难度等级: [0.0465, 0.0465) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud Resilience4j --> ( 难度等级: [0.0465, 0.0466) || 挂载数据: 无 ) 
│   │   │       └── Resilience4j的高级特性 --> ( 难度等级: [0.0466, 0.0466) || 挂载数据: 无 ) 
│   │   ├── Spring生态消息驱动 --> ( 难度等级: [0.0466, 0.0471) || 挂载数据: 无 ) 
│   │   │   ├── 消息中间件概述 --> ( 难度等级: [0.0466, 0.0467) || 挂载数据: 无 ) 
│   │   │   ├── Spring与消息 --> ( 难度等级: [0.0467, 0.0468) || 挂载数据: 无 ) 
│   │   │   │   ├── 消息编程模型的统一 --> ( 难度等级: [0.0467, 0.0468) || 挂载数据: 无 ) 
│   │   │   │   ├── 消息的发送和订阅 --> ( 难度等级: [0.0468, 0.0468) || 挂载数据: blog: 1 ) 
│   │   │   │   └── WebSocket --> ( 难度等级: [0.0468, 0.0468) || 挂载数据: blog: 4 ) 
│   │   │   ├── Spring Integration --> ( 难度等级: [0.0468, 0.047) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Integration核心组件概述 --> ( 难度等级: [0.0468, 0.0469) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Spring Integration核心组件的使用 --> ( 难度等级: [0.0469, 0.047) || 挂载数据: blog: 2 ) 
│   │   │   └── Spring Cloud Stream --> ( 难度等级: [0.047, 0.0471) || 挂载数据: 无 ) 
│   │   │       ├── 使用Spring Cloud Stream发送和接收消息 --> ( 难度等级: [0.047, 0.047) || 挂载数据: blog: 2 ) 
│   │   │       ├── 理解Binder和Binding --> ( 难度等级: [0.047, 0.047) || 挂载数据: 无 ) 
│   │   │       ├── 深入理解Spring Cloud Stream --> ( 难度等级: [0.047, 0.0471) || 挂载数据: blog: 4 ) 
│   │   │       └── Spring Cloud Stream的高级特性 --> ( 难度等级: [0.0471, 0.0471) || 挂载数据: blog: 1 ) 
│   │   ├── 消息总线 --> ( 难度等级: [0.0471, 0.0476) || 挂载数据: 无 ) 
│   │   │   ├── 消息总线概述 --> ( 难度等级: [0.0471, 0.0474) || 挂载数据: 无 ) 
│   │   │   └── 深入理解Spring Cloud Bus --> ( 难度等级: [0.0474, 0.0476) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud Bus的使用 --> ( 难度等级: [0.0474, 0.0474) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud Bus的原理 --> ( 难度等级: [0.0474, 0.0475) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud Bus事件 --> ( 难度等级: [0.0475, 0.0476) || 挂载数据: 无 ) 
│   │   │       └── Spring Cloud Bus源码分析 --> ( 难度等级: [0.0476, 0.0476) || 挂载数据: 无 ) 
│   │   ├── Spring Cloud Data Flow --> ( 难度等级: [0.0476, 0.0481) || 挂载数据: 无 ) 
│   │   │   ├── 批处理/流处理概述 --> ( 难度等级: [0.0476, 0.0477) || 挂载数据: 无 ) 
│   │   │   ├── 流处理案例：信用卡反欺诈系统 --> ( 难度等级: [0.0477, 0.0477) || 挂载数据: 无 ) 
│   │   │   ├── 批处理案例：统计GitHub仓库的各项指标数据 --> ( 难度等级: [0.0477, 0.0478) || 挂载数据: blog: 4 ) 
│   │   │   ├── Spring Cloud Data Flow批处理任务组合 --> ( 难度等级: [0.0478, 0.0478) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Data Flow Shell --> ( 难度等级: [0.0478, 0.0479) || 挂载数据: blog: 4 ) 
│   │   │   ├── Spring Cloud Skipper --> ( 难度等级: [0.0479, 0.048) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Deployer --> ( 难度等级: [0.048, 0.048) || 挂载数据: 无 ) 
│   │   │   │   ├── TaskLauncher接口 --> ( 难度等级: [0.048, 0.048) || 挂载数据: 无 ) 
│   │   │   │   ├── AppDeployer接口 --> ( 难度等级: [0.048, 0.048) || 挂载数据: 无 ) 
│   │   │   │   └── LocalAppDeployer --> ( 难度等级: [0.048, 0.048) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Task --> ( 难度等级: [0.048, 0.0481) || 挂载数据: 无 ) 
│   │   │   │   ├── 体验Spring Cloud Task --> ( 难度等级: [0.048, 0.048) || 挂载数据: 无 ) 
│   │   │   │   ├── 深入理解Spring Cloud Task --> ( 难度等级: [0.048, 0.0481) || 挂载数据: blog: 9 ) 
│   │   │   │   └── Spring Cloud Task Batch --> ( 难度等级: [0.0481, 0.0481) || 挂载数据: 无 ) 
│   │   │   └── Spring Batch --> ( 难度等级: [0.0481, 0.0481) || 挂载数据: 无 ) 
│   │   │       └── Spring Batch核心组件 --> ( 难度等级: [0.0481, 0.0481) || 挂载数据: blog: 4 ) 
│   │   ├── 网关 --> ( 难度等级: [0.0481, 0.0487) || 挂载数据: 无 ) 
│   │   │   ├── API网关概述 --> ( 难度等级: [0.0481, 0.0482) || 挂载数据: 无 ) 
│   │   │   │   ├── API网关的定义、职能与关注点 --> ( 难度等级: [0.0481, 0.0482) || 挂载数据: 无 ) 
│   │   │   │   └── API网关的分类与技术分析 --> ( 难度等级: [0.0482, 0.0482) || 挂载数据: blog: 6 ) 
│   │   │   ├── Netflix Zuul --> ( 难度等级: [0.0482, 0.0483) || 挂载数据: 无 ) 
│   │   │   ├── 非阻塞式的Spring Cloud Gateway --> ( 难度等级: [0.0483, 0.0483) || 挂载数据: 无 ) 
│   │   │   ├── Route路由信息 --> ( 难度等级: [0.0483, 0.0484) || 挂载数据: 无 ) 
│   │   │   ├── Predicate机制 --> ( 难度等级: [0.0484, 0.0485) || 挂载数据: 无 ) 
│   │   │   │   ├── PredicateDefinition和AsyncPredicate --> ( 难度等级: [0.0484, 0.0484) || 挂载数据: 无 ) 
│   │   │   │   ├── RoutePredicateFactory --> ( 难度等级: [0.0484, 0.0484) || 挂载数据: 无 ) 
│   │   │   │   └── 内置RoutePredicateFactory --> ( 难度等级: [0.0484, 0.0485) || 挂载数据: 无 ) 
│   │   │   ├── Filter机制 --> ( 难度等级: [0.0485, 0.0485) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── FilterDefinition和GatewayFilter --> ( 难度等级: [0.0485, 0.0485) || 挂载数据: 无 ) 
│   │   │   │   ├── GlobalFilter --> ( 难度等级: [0.0485, 0.0485) || 挂载数据: 无 ) 
│   │   │   │   ├── 内置GatewayFilterFactory --> ( 难度等级: [0.0485, 0.0485) || 挂载数据: 无 ) 
│   │   │   │   └── 网关内置的GlobalFilter --> ( 难度等级: [0.0485, 0.0485) || 挂载数据: blog: 1 ) 
│   │   │   ├── 整合注册中心和配置中心 --> ( 难度等级: [0.0485, 0.0486) || 挂载数据: 无 ) 
│   │   │   └── GatewayControllerEndpoint --> ( 难度等级: [0.0486, 0.0487) || 挂载数据: 无 ) 
│   │   ├── 综述 --> ( 难度等级: [0.0487, 0.0492) || 挂载数据: 无 ) 
│   │   │   ├── Cloud Native的起源 --> ( 难度等级: [0.0487, 0.0487) || 挂载数据: 无 ) 
│   │   │   ├── Cloud Native的组成 --> ( 难度等级: [0.0487, 0.0488) || 挂载数据: blog: 1 ) 
│   │   │   ├── Cloud Native背后的诉求 --> ( 难度等级: [0.0488, 0.0488) || 挂载数据: 无 ) 
│   │   │   ├── 如何衡量Cloud Native的能力 --> ( 难度等级: [0.0488, 0.0489) || 挂载数据: 无 ) 
│   │   │   ├── Cloud Native的原则 --> ( 难度等级: [0.0489, 0.049) || 挂载数据: 无 ) 
│   │   │   ├── 可用性和可靠性的关系 --> ( 难度等级: [0.049, 0.049) || 挂载数据: 无 ) 
│   │   │   ├── 可用性的衡量标准 --> ( 难度等级: [0.049, 0.0491) || 挂载数据: 无 ) 
│   │   │   └── 什么降低了可用性 --> ( 难度等级: [0.0491, 0.0492) || 挂载数据: 无 ) 
│   │   ├── 微服务架构 --> ( 难度等级: [0.0492, 0.0497) || 挂载数据: blog: 1 ) 
│   │   │   ├── 微服务架构的起源 --> ( 难度等级: [0.0492, 0.0492) || 挂载数据: 无 ) 
│   │   │   ├── 微服务架构实施的先决条件 --> ( 难度等级: [0.0492, 0.0493) || 挂载数据: 无 ) 
│   │   │   │   ├── 研发环境和流程上的转变 --> ( 难度等级: [0.0492, 0.0492) || 挂载数据: 无 ) 
│   │   │   │   └── 拆分前先做好解耦 --> ( 难度等级: [0.0492, 0.0493) || 挂载数据: 无 ) 
│   │   │   ├── 微服务划分模式 --> ( 难度等级: [0.0493, 0.0493) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于业务复杂度选择服务划分方法 --> ( 难度等级: [0.0493, 0.0493) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于数据驱动划分服务 --> ( 难度等级: [0.0493, 0.0493) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 基于领域驱动划分服务 --> ( 难度等级: [0.0493, 0.0493) || 挂载数据: 无 ) 
│   │   │   │   ├── 从已有单体架构中逐步划分服务 --> ( 难度等级: [0.0493, 0.0493) || 挂载数据: 无 ) 
│   │   │   │   ├── 微服务拆分策略 --> ( 难度等级: [0.0493, 0.0493) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 如何衡量服务划分的合理性 --> ( 难度等级: [0.0493, 0.0493) || 挂载数据: 无 ) 
│   │   │   ├── 微服务划分反模式 --> ( 难度等级: [0.0493, 0.0493) || 挂载数据: 无 ) 
│   │   │   ├── 微服务API设计 --> ( 难度等级: [0.0493, 0.0494) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── YXAPI的设计原则 --> ( 难度等级: [0.0493, 0.0493) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务间通信——RPC --> ( 难度等级: [0.0493, 0.0493) || 挂载数据: 无 ) 
│   │   │   │   ├── 序列化——Protobuf --> ( 难度等级: [0.0493, 0.0493) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务间通信——RESTful --> ( 难度等级: [0.0493, 0.0494) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过Swagger实现RESTful --> ( 难度等级: [0.0494, 0.0494) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── HTTP协议的进化——HTTP/2 --> ( 难度等级: [0.0494, 0.0494) || 挂载数据: 无 ) 
│   │   │   │   └── HTTP/2和Protobuf的组合——gRPC --> ( 难度等级: [0.0494, 0.0494) || 挂载数据: 无 ) 
│   │   │   ├── 微服务框架 --> ( 难度等级: [0.0494, 0.0494) || 挂载数据: 无 ) 
│   │   │   ├── 基于Dubbo框架实现微服务 --> ( 难度等级: [0.0494, 0.0495) || 挂载数据: 无 ) 
│   │   │   ├── 基于Spring Cloud框架实现微服务 --> ( 难度等级: [0.0495, 0.0495) || 挂载数据: 无 ) 
│   │   │   ├── 服务发现场景下的ZooKeeper与Etcd --> ( 难度等级: [0.0495, 0.0495) || 挂载数据: blog: 4 ) 
│   │   │   ├── 微服务部署策略 --> ( 难度等级: [0.0495, 0.0496) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务D享数据库 --> ( 难度等级: [0.0495, 0.0496) || 挂载数据: 无 ) 
│   │   │   │   └── 服务D享虚拟机/容器 --> ( 难度等级: [0.0496, 0.0496) || 挂载数据: 无 ) 
│   │   │   ├── 几种常见的微服务架构方案 --> ( 难度等级: [0.0496, 0.0496) || 挂载数据: 无 ) 
│   │   │   │   ├── ZeroC IceGrid微服务架构 --> ( 难度等级: [0.0496, 0.0496) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud微服务架构 --> ( 难度等级: [0.0496, 0.0496) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 基于消息队列的微服务架构 --> ( 难度等级: [0.0496, 0.0496) || 挂载数据: 无 ) 
│   │   │   │   └── Docker Swarm微服务架构 --> ( 难度等级: [0.0496, 0.0496) || 挂载数据: blog: 9 ) 
│   │   │   ├── 深入Kubernetes微服务平台 --> ( 难度等级: [0.0496, 0.0496) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Kubernetes的PaaS平台 --> ( 难度等级: [0.0496, 0.0496) || 挂载数据: blog: 1 ) 
│   │   │   └── 从微服务到Service Mesh --> ( 难度等级: [0.0496, 0.0497) || 挂载数据: blog: 1 ) 
│   │   │       ├── Service Mesh之再见架构 --> ( 难度等级: [0.0496, 0.0497) || 挂载数据: 无 ) 
│   │   │       ├── Envoy核心实践入门 --> ( 难度等级: [0.0497, 0.0497) || 挂载数据: 无 ) 
│   │   │       ├── Istio背后的技术 --> ( 难度等级: [0.0497, 0.0497) || 挂载数据: blog: 1 ) 
│   │   │       └── Istio的架构演变 --> ( 难度等级: [0.0497, 0.0497) || 挂载数据: 无 ) 
│   │   ├── 敏捷基础设施及公共基础服务 --> ( 难度等级: [0.0497, 0.0502) || 挂载数据: 无 ) 
│   │   │   ├── 传统基础设施面临的挑战 --> ( 难度等级: [0.0497, 0.0497) || 挂载数据: 无 ) 
│   │   │   ├── 什么是敏捷基础设施 --> ( 难度等级: [0.0497, 0.0498) || 挂载数据: 无 ) 
│   │   │   ├── 基于容器的敏捷基础设施 --> ( 难度等级: [0.0498, 0.0499) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器VS虚拟机 --> ( 难度等级: [0.0498, 0.0498) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── 安装Docker --> ( 难度等级: [0.0498, 0.0498) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署私有Docker Registry --> ( 难度等级: [0.0498, 0.0498) || 挂载数据: 无 ) 
│   │   │   │   └── 基于docker-compose管理容器 --> ( 难度等级: [0.0498, 0.0499) || 挂载数据: 无 ) 
│   │   │   ├── 基于公共基础服务的平台化 --> ( 难度等级: [0.0499, 0.0499) || 挂载数据: 无 ) 
│   │   │   ├── 监控告警fu务 --> ( 难度等级: [0.0499, 0.05) || 挂载数据: 无 ) 
│   │   │   │   ├── 监控数据采集 --> ( 难度等级: [0.0499, 0.0499) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 监控数据接收模式 --> ( 难度等级: [0.0499, 0.0499) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过时间序列数据库存储监控数据 --> ( 难度等级: [0.0499, 0.05) || 挂载数据: 无 ) 
│   │   │   │   ├── 开源监控系统实现Prometheus --> ( 难度等级: [0.05, 0.05) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 通过Prometheus和Grafana监控服务 --> ( 难度等级: [0.05, 0.05) || 挂载数据: 无 ) 
│   │   │   ├── 分布式消息中间件服务 --> ( 难度等级: [0.05, 0.05) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式消息中间件的作用 --> ( 难度等级: [0.05, 0.05) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 业界常用的分布式消息中间件 --> ( 难度等级: [0.05, 0.05) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Kafka的设计原理 --> ( 难度等级: [0.05, 0.05) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Kafka的数据存储结构 --> ( 难度等级: [0.05, 0.05) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 如何保证Kafka不丢消息 --> ( 难度等级: [0.05, 0.05) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Kafka跨数据中心场景集群部署模式 --> ( 难度等级: [0.05, 0.05) || 挂载数据: 无 ) 
│   │   │   ├── 分布式缓存服务 --> ( 难度等级: [0.05, 0.0501) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式缓存的应用场景 --> ( 难度等级: [0.05, 0.05) || 挂载数据: 无 ) 
│   │   │   │   ├── 业界常用的分布式缓存Memcached --> ( 难度等级: [0.05, 0.0501) || 挂载数据: 无 ) 
│   │   │   │   ├── 业界常用的分布式缓存——Redis --> ( 难度等级: [0.0501, 0.0501) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Redis常用的分布式缓存集群模式 --> ( 难度等级: [0.0501, 0.0501) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Codis实现Redis分布式缓存集群 --> ( 难度等级: [0.0501, 0.0501) || 挂载数据: blog: 3 ) 
│   │   │   ├── 分布式任务调度服务 --> ( 难度等级: [0.0501, 0.0501) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过Tbschedule实现分布式任务调度 --> ( 难度等级: [0.0501, 0.0501) || 挂载数据: 无 ) 
│   │   │   │   └── 通过Elastic-Job实现分布式任务调度 --> ( 难度等级: [0.0501, 0.0501) || 挂载数据: blog: 1 ) 
│   │   │   └── 如何生成分布式ID --> ( 难度等级: [0.0501, 0.0502) || 挂载数据: 无 ) 
│   │   │       ├── UUID --> ( 难度等级: [0.0501, 0.0502) || 挂载数据: 无 ) 
│   │   │       ├── SDwFlake --> ( 难度等级: [0.0502, 0.0502) || 挂载数据: 无 ) 
│   │   │       └── Ticket Server --> ( 难度等级: [0.0502, 0.0502) || 挂载数据: 无 ) 
│   │   ├── 可用性设计 --> ( 难度等级: [0.0502, 0.0507) || 挂载数据: 无 ) 
│   │   │   ├── 逐步切换 --> ( 难度等级: [0.0502, 0.0503) || 挂载数据: 无 ) 
│   │   │   │   ├── 影子测试 --> ( 难度等级: [0.0502, 0.0502) || 挂载数据: 无 ) 
│   │   │   │   ├── 蓝绿部署 --> ( 难度等级: [0.0502, 0.0503) || 挂载数据: 无 ) 
│   │   │   │   └── 灰度发布/金丝雀发布 --> ( 难度等级: [0.0503, 0.0503) || 挂载数据: 无 ) 
│   │   │   ├── 容错设计 --> ( 难度等级: [0.0503, 0.0504) || 挂载数据: 无 ) 
│   │   │   │   ├── 消除单点 --> ( 难度等级: [0.0503, 0.0503) || 挂载数据: 无 ) 
│   │   │   │   ├── 特性开关 --> ( 难度等级: [0.0503, 0.0503) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务分级 --> ( 难度等级: [0.0503, 0.0503) || 挂载数据: 无 ) 
│   │   │   │   ├── 降级设计 --> ( 难度等级: [0.0503, 0.0504) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 超时重试 --> ( 难度等级: [0.0504, 0.0504) || 挂载数据: 无 ) 
│   │   │   │   └── 隔离策略 --> ( 难度等级: [0.0504, 0.0504) || 挂载数据: 无 ) 
│   │   │   ├── 流控设计 --> ( 难度等级: [0.0504, 0.0505) || 挂载数据: 无 ) 
│   │   │   │   ├── 限流算法 --> ( 难度等级: [0.0504, 0.0504) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 流控策略 --> ( 难度等级: [0.0504, 0.0504) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于Guava限流 --> ( 难度等级: [0.0504, 0.0504) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Nginx限流 --> ( 难度等级: [0.0504, 0.0505) || 挂载数据: 无 ) 
│   │   │   ├── 容量预估 --> ( 难度等级: [0.0505, 0.0506) || 挂载数据: 无 ) 
│   │   │   ├── 故障演练 --> ( 难度等级: [0.0506, 0.0506) || 挂载数据: 无 ) 
│   │   │   └── 数据迁移 --> ( 难度等级: [0.0506, 0.0507) || 挂载数据: 无 ) 
│   │   │       ├── 逻辑分离，物理不分离 --> ( 难度等级: [0.0506, 0.0507) || 挂载数据: 无 ) 
│   │   │       └── 物理分离 --> ( 难度等级: [0.0507, 0.0507) || 挂载数据: 无 ) 
│   │   ├── 可扩展性设计 --> ( 难度等级: [0.0507, 0.0512) || 挂载数据: 无 ) 
│   │   │   ├── 横向扩展 --> ( 难度等级: [0.0507, 0.0508) || 挂载数据: 无 ) 
│   │   │   ├── AKF扩展立方体 --> ( 难度等级: [0.0508, 0.0509) || 挂载数据: 无 ) 
│   │   │   ├── 如何扩展长连接 --> ( 难度等级: [0.0509, 0.051) || 挂载数据: 无 ) 
│   │   │   ├── 如何扩展数据库 --> ( 难度等级: [0.051, 0.0511) || 挂载数据: 无 ) 
│   │   │   │   ├── X轴扩展——主从复制集群 --> ( 难度等级: [0.051, 0.0511) || 挂载数据: 无 ) 
│   │   │   │   ├── Y轴扩展——分库、垂直分表 --> ( 难度等级: [0.0511, 0.0511) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Z轴扩展——分片（sharding） --> ( 难度等级: [0.0511, 0.0511) || 挂载数据: 无 ) 
│   │   │   │   ├── 分片扩容（re-sharding） --> ( 难度等级: [0.0511, 0.0511) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 精选案例 --> ( 难度等级: [0.0511, 0.0511) || 挂载数据: 无 ) 
│   │   │   └── 如何扩展数据中心 --> ( 难度等级: [0.0511, 0.0512) || 挂载数据: 无 ) 
│   │   │       ├── 两地三中心和同城多活 --> ( 难度等级: [0.0511, 0.0512) || 挂载数据: 无 ) 
│   │   │       ├── 同城多活 --> ( 难度等级: [0.0512, 0.0512) || 挂载数据: 无 ) 
│   │   │       └── 异地多活 --> ( 难度等级: [0.0512, 0.0512) || 挂载数据: 无 ) 
│   │   ├── 性能设计 --> ( 难度等级: [0.0512, 0.0518) || 挂载数据: 无 ) 
│   │   │   ├── 性能指标 --> ( 难度等级: [0.0512, 0.0513) || 挂载数据: 无 ) 
│   │   │   ├── 如何树立目标 --> ( 难度等级: [0.0513, 0.0514) || 挂载数据: 无 ) 
│   │   │   ├── 如何寻找平衡点 --> ( 难度等级: [0.0514, 0.0514) || 挂载数据: 无 ) 
│   │   │   ├── 如何定位瓶颈点 --> ( 难度等级: [0.0514, 0.0515) || 挂载数据: 无 ) 
│   │   │   ├── 服务通信优化 --> ( 难度等级: [0.0515, 0.0515) || 挂载数据: 无 ) 
│   │   │   │   ├── 同步转异步 --> ( 难度等级: [0.0515, 0.0515) || 挂载数据: 无 ) 
│   │   │   │   ├── 阻塞转非阻塞 --> ( 难度等级: [0.0515, 0.0515) || 挂载数据: 无 ) 
│   │   │   │   └── 序列化 --> ( 难度等级: [0.0515, 0.0515) || 挂载数据: 无 ) 
│   │   │   ├── 通过消息中间件提升写性能 --> ( 难度等级: [0.0515, 0.0516) || 挂载数据: blog: 1 ) 
│   │   │   ├── 通过缓存提升读性能 --> ( 难度等级: [0.0516, 0.0516) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于ConcurrentHashMap实现本地缓存 --> ( 难度等级: [0.0516, 0.0516) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 基于Guava Cache实现本地缓存 --> ( 难度等级: [0.0516, 0.0516) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 缓存的常用模式 --> ( 难度等级: [0.0516, 0.0516) || 挂载数据: 无 ) 
│   │   │   ├── 数据库优化 --> ( 难度等级: [0.0516, 0.0517) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过执行计划分析瓶颈点 --> ( 难度等级: [0.0516, 0.0517) || 挂载数据: 无 ) 
│   │   │   │   ├── 为搜索字段创建索引 --> ( 难度等级: [0.0517, 0.0517) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过慢查询日志分析瓶颈点 --> ( 难度等级: [0.0517, 0.0517) || 挂载数据: 无 ) 
│   │   │   │   └── 通过提升硬件能力优化数据库 --> ( 难度等级: [0.0517, 0.0517) || 挂载数据: 无 ) 
│   │   │   └── 简化设计 --> ( 难度等级: [0.0517, 0.0518) || 挂载数据: 无 ) 
│   │   │       ├── 转移复杂度 --> ( 难度等级: [0.0517, 0.0517) || 挂载数据: 无 ) 
│   │   │       └── 从业务角度优化 --> ( 难度等级: [0.0517, 0.0518) || 挂载数据: 无 ) 
│   │   ├── 一致性设计 --> ( 难度等级: [0.0518, 0.0523) || 挂载数据: 无 ) 
│   │   │   ├── 基础理论 --> ( 难度等级: [0.0518, 0.0518) || 挂载数据: 无 ) 
│   │   │   │   ├── CAP定理 --> ( 难度等级: [0.0518, 0.0518) || 挂载数据: 无 ) 
│   │   │   │   ├── BASE理论 --> ( 难度等级: [0.0518, 0.0518) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Quorum机制（NWR模型） --> ( 难度等级: [0.0518, 0.0518) || 挂载数据: 无 ) 
│   │   │   │   ├── 租约机制（Lease） --> ( 难度等级: [0.0518, 0.0518) || 挂载数据: 无 ) 
│   │   │   │   └── 状态机（Replicated State Machine） --> ( 难度等级: [0.0518, 0.0518) || 挂载数据: blog: 1 ) 
│   │   │   ├── 分布式系统的一致性分类 --> ( 难度等级: [0.0518, 0.0519) || 挂载数据: 无 ) 
│   │   │   │   ├── 以数据为中心的一致性模型 --> ( 难度等级: [0.0518, 0.0519) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 以用户为中心的一致性模型 --> ( 难度等级: [0.0519, 0.0519) || 挂载数据: 无 ) 
│   │   │   │   └── 业界常用的一致性模型 --> ( 难度等级: [0.0519, 0.0519) || 挂载数据: 无 ) 
│   │   │   ├── 如何实现强一致性 --> ( 难度等级: [0.0519, 0.052) || 挂载数据: 无 ) 
│   │   │   │   ├── 两阶段提交 --> ( 难度等级: [0.0519, 0.052) || 挂载数据: 无 ) 
│   │   │   │   └── 三阶段提交（3PC） --> ( 难度等级: [0.052, 0.052) || 挂载数据: blog: 1 ) 
│   │   │   ├── 如何实现Z终一致性 --> ( 难度等级: [0.052, 0.0521) || 挂载数据: 无 ) 
│   │   │   │   ├── 重试机制 --> ( 难度等级: [0.052, 0.052) || 挂载数据: 无 ) 
│   │   │   │   ├── 本地记录日志 --> ( 难度等级: [0.052, 0.0521) || 挂载数据: 无 ) 
│   │   │   │   ├── 可靠事件模式 --> ( 难度等级: [0.0521, 0.0521) || 挂载数据: 无 ) 
│   │   │   │   ├── Saga事务模型 --> ( 难度等级: [0.0521, 0.0521) || 挂载数据: 无 ) 
│   │   │   │   └── TCC事务模型 --> ( 难度等级: [0.0521, 0.0521) || 挂载数据: 无 ) 
│   │   │   ├── 分布式锁 --> ( 难度等级: [0.0521, 0.0522) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于数据库实现悲观锁和乐观锁 --> ( 难度等级: [0.0521, 0.0521) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于ZooKeeper的分布式锁 --> ( 难度等级: [0.0521, 0.0522) || 挂载数据: blog: 7 ) 
│   │   │   │   └── 基于Redis实现分布式锁 --> ( 难度等级: [0.0522, 0.0522) || 挂载数据: blog: 10 ) 
│   │   │   └── 如何保证幂等性 --> ( 难度等级: [0.0522, 0.0523) || 挂载数据: 无 ) 
│   │   │       ├── 幂等令牌（Idempotency Key） --> ( 难度等级: [0.0522, 0.0522) || 挂载数据: 无 ) 
│   │   │       └── 在数据库中实现幂等性 --> ( 难度等级: [0.0522, 0.0523) || 挂载数据: 无 ) 
│   │   ├── 未来值得关注的方向 --> ( 难度等级: [0.0523, 0.0528) || 挂载数据: blog: 1 ) 
│   │   │   └── Serverless --> ( 难度等级: [0.0523, 0.0528) || 挂载数据: 无 ) 
│   │   │       ├── 什么是Serverless --> ( 难度等级: [0.0523, 0.0524) || 挂载数据: 无 ) 
│   │   │       ├── Serverless的现状 --> ( 难度等级: [0.0524, 0.0526) || 挂载数据: 无 ) 
│   │   │       └── Serverless的应用场景 --> ( 难度等级: [0.0526, 0.0528) || 挂载数据: 无 ) 
│   │   ├── 研发流程 --> ( 难度等级: [0.0528, 0.0533) || 挂载数据: 无 ) 
│   │   │   ├── 十二因子 --> ( 难度等级: [0.0528, 0.0529) || 挂载数据: 无 ) 
│   │   │   ├── 自动化测试 --> ( 难度等级: [0.0529, 0.0529) || 挂载数据: 无 ) 
│   │   │   │   ├── 单元测试 --> ( 难度等级: [0.0529, 0.0529) || 挂载数据: 无 ) 
│   │   │   │   ├── TDD --> ( 难度等级: [0.0529, 0.0529) || 挂载数据: 无 ) 
│   │   │   │   └── 提交即意味着可测试 --> ( 难度等级: [0.0529, 0.0529) || 挂载数据: 无 ) 
│   │   │   ├── Code Review --> ( 难度等级: [0.0529, 0.053) || 挂载数据: 无 ) 
│   │   │   │   ├── Code Review的意义 --> ( 难度等级: [0.0529, 0.053) || 挂载数据: 无 ) 
│   │   │   │   ├── Code Review的原则 --> ( 难度等级: [0.053, 0.053) || 挂载数据: blog: 4 ) 
│   │   │   │   └── Code Review的过程 --> ( 难度等级: [0.053, 0.053) || 挂载数据: 无 ) 
│   │   │   ├── 流水线 --> ( 难度等级: [0.053, 0.0531) || 挂载数据: 无 ) 
│   │   │   │   ├── 持续交付 --> ( 难度等级: [0.053, 0.053) || 挂载数据: 无 ) 
│   │   │   │   ├── 持续部署流水线 --> ( 难度等级: [0.053, 0.053) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于开源打造流水线 --> ( 难度等级: [0.053, 0.0531) || 挂载数据: 无 ) 
│   │   │   │   ├── YMX的流水线 --> ( 难度等级: [0.0531, 0.0531) || 挂载数据: 无 ) 
│   │   │   │   └── 开发人员自服务 --> ( 难度等级: [0.0531, 0.0531) || 挂载数据: 无 ) 
│   │   │   ├── 基于数据和反馈持续改进 --> ( 难度等级: [0.0531, 0.0532) || 挂载数据: 无 ) 
│   │   │   ├── 拥抱变化 --> ( 难度等级: [0.0532, 0.0532) || 挂载数据: 无 ) 
│   │   │   └── 代码即设计 --> ( 难度等级: [0.0532, 0.0533) || 挂载数据: 无 ) 
│   │   ├── 团队文化 --> ( 难度等级: [0.0533, 0.0538) || 挂载数据: 无 ) 
│   │   │   ├── 组织结构 --> ( 难度等级: [0.0533, 0.0534) || 挂载数据: 无 ) 
│   │   │   │   ├── 康威定律 --> ( 难度等级: [0.0533, 0.0533) || 挂载数据: 无 ) 
│   │   │   │   ├── 扁平化的组织 --> ( 难度等级: [0.0533, 0.0534) || 挂载数据: 无 ) 
│   │   │   │   ├── D裁的管理方式还是民主的管理方式 --> ( 难度等级: [0.0534, 0.0534) || 挂载数据: 无 ) 
│   │   │   │   └── 民主的团队如何做决策 --> ( 难度等级: [0.0534, 0.0534) || 挂载数据: 无 ) 
│   │   │   ├── 环境氛围 --> ( 难度等级: [0.0534, 0.0536) || 挂载数据: 无 ) 
│   │   │   │   ├── 公开透明的工作环境 --> ( 难度等级: [0.0534, 0.0535) || 挂载数据: 无 ) 
│   │   │   │   ├── 学习型组织 --> ( 难度等级: [0.0535, 0.0535) || 挂载数据: 无 ) 
│   │   │   │   ├── 减少正式的汇报 --> ( 难度等级: [0.0535, 0.0535) || 挂载数据: 无 ) 
│   │   │   │   ├── 高效的会议 --> ( 难度等级: [0.0535, 0.0535) || 挂载数据: 无 ) 
│   │   │   │   └── 量化指标致死 --> ( 难度等级: [0.0535, 0.0536) || 挂载数据: 无 ) 
│   │   │   ├── 管理风格 --> ( 难度等级: [0.0536, 0.0537) || 挂载数据: 无 ) 
│   │   │   │   ├── 下属请假你会拒绝吗 --> ( 难度等级: [0.0536, 0.0536) || 挂载数据: 无 ) 
│   │   │   │   ├── 得到了所有人的认可，说明你并不是一个好的管理者 --> ( 难度等级: [0.0536, 0.0536) || 挂载数据: 无 ) 
│   │   │   │   ├── 尽量避免用自己的权力去做决策 --> ( 难度等级: [0.0536, 0.0536) || 挂载数据: 无 ) 
│   │   │   │   ├── 一屋不扫也可助你“荡平天下” --> ( 难度等级: [0.0536, 0.0537) || 挂载数据: 无 ) 
│   │   │   │   └── 如何留下你想要的人 --> ( 难度等级: [0.0537, 0.0537) || 挂载数据: 无 ) 
│   │   │   └── 经典案例 --> ( 难度等级: [0.0537, 0.0538) || 挂载数据: 无 ) 
│   │   │       ├── Instagram的团队文化 --> ( 难度等级: [0.0537, 0.0538) || 挂载数据: 无 ) 
│   │   │       └── Netflix的团队文化 --> ( 难度等级: [0.0538, 0.0538) || 挂载数据: 无 ) 
│   │   ├── 基础篇 --> ( 难度等级: [0.0538, 0.0543) || 挂载数据: blog: 1 ) 
│   │   │   ├── Service Mesh简介 --> ( 难度等级: [0.0538, 0.0541) || 挂载数据: 无 ) 
│   │   │   │   ├── 微服务架构面临的一些挑战 --> ( 难度等级: [0.0538, 0.0539) || 挂载数据: 无 ) 
│   │   │   │   ├── 技术架构演进 --> ( 难度等级: [0.0539, 0.054) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Service Mesh的功能 --> ( 难度等级: [0.054, 0.054) || 挂载数据: 无 ) 
│   │   │   │   └── 业界Service Mesh产品 --> ( 难度等级: [0.054, 0.0541) || 挂载数据: 无 ) 
│   │   │   │       └── Envoy --> ( 难度等级: [0.054, 0.0541) || 挂载数据: blog: 1 ) 
│   │   │   └── Linkerd入门 --> ( 难度等级: [0.0541, 0.0543) || 挂载数据: 无 ) 
│   │   │       ├── Linkerd架构 --> ( 难度等级: [0.0541, 0.0542) || 挂载数据: 无 ) 
│   │   │       ├── Linkerd主要功能 --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: 无 ) 
│   │   │       ├── 安装Linkerd --> ( 难度等级: [0.0542, 0.0543) || 挂载数据: 无 ) 
│   │   │       │   ├── 环境准备 --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 虚拟机及Docker引擎 --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 服务发现：Consul --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: blog: 10 ) 
│   │   │       │   │   ├── 部署Linkerd --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 部署示例服务 --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 在本地搭建Istio环境 --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: blog: 2 ) 
│   │   │       │   │   │   ├── 安装Kubernetes集群 --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: blog: 1 ) 
│   │   │       │   │   │   ├── 安装Helm --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: blog: 1 ) 
│   │   │       │   │   │   └── 安装Istio --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 在公有云上使用Istio --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: 无 ) 
│   │   │       │   │   └── 尝鲜Istio命令行 --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: 无 ) 
│   │   │       │   ├── 传统安装方式 --> ( 难度等级: [0.0542, 0.0543) || 挂载数据: 无 ) 
│   │   │       │   └── 基于Docker的安装方式 --> ( 难度等级: [0.0543, 0.0543) || 挂载数据: 无 ) 
│   │   │       └── 示例演示 --> ( 难度等级: [0.0543, 0.0543) || 挂载数据: 无 ) 
│   │   │           ├── 示例准备 --> ( 难度等级: [0.0543, 0.0543) || 挂载数据: blog: 1 ) 
│   │   │           │   ├── Weather Forecast简介 --> ( 难度等级: [0.0543, 0.0543) || 挂载数据: 无 ) 
│   │   │           │   └── Weather Forecast部署 --> ( 难度等级: [0.0543, 0.0543) || 挂载数据: 无 ) 
│   │   │           ├── 基于文件的服务发现 --> ( 难度等级: [0.0543, 0.0543) || 挂载数据: 无 ) 
│   │   │           └── 示例演示 --> ( 难度等级: [0.0543, 0.0543) || 挂载数据: 无 ) 
│   │   ├── 中级篇 --> ( 难度等级: [0.0543, 0.0549) || 挂载数据: 无 ) 
│   │   │   ├── 深入浅出Linkerd配置 --> ( 难度等级: [0.0543, 0.0544) || 挂载数据: 无 ) 
│   │   │   │   ├── Linkerd术语 --> ( 难度等级: [0.0543, 0.0544) || 挂载数据: 无 ) 
│   │   │   │   └── Linkerd配置 --> ( 难度等级: [0.0544, 0.0544) || 挂载数据: 无 ) 
│   │   │   │       ├── 配置构成 --> ( 难度等级: [0.0544, 0.0544) || 挂载数据: blog: 10 ) 
│   │   │   │       ├── admin --> ( 难度等级: [0.0544, 0.0544) || 挂载数据: 无 ) 
│   │   │   │       ├── namer --> ( 难度等级: [0.0544, 0.0544) || 挂载数据: 无 ) 
│   │   │   │       ├── router --> ( 难度等级: [0.0544, 0.0544) || 挂载数据: 无 ) 
│   │   │   │       ├── telemetry --> ( 难度等级: [0.0544, 0.0544) || 挂载数据: 无 ) 
│   │   │   │       └── usage --> ( 难度等级: [0.0544, 0.0544) || 挂载数据: 无 ) 
│   │   │   ├── 深入Linkerd数据访问流 --> ( 难度等级: [0.0544, 0.0545) || 挂载数据: 无 ) 
│   │   │   │   ├── dtab详解 --> ( 难度等级: [0.0544, 0.0544) || 挂载数据: 无 ) 
│   │   │   │   │   ├── dtab定义 --> ( 难度等级: [0.0544, 0.0544) || 挂载数据: 无 ) 
│   │   │   │   │   └── dtab路由原理 --> ( 难度等级: [0.0544, 0.0544) || 挂载数据: 无 ) 
│   │   │   │   └── 数据访问流详解 --> ( 难度等级: [0.0544, 0.0545) || 挂载数据: blog: 1 ) 
│   │   │   │       ├── 鉴别 --> ( 难度等级: [0.0544, 0.0545) || 挂载数据: 无 ) 
│   │   │   │       ├── 绑定 --> ( 难度等级: [0.0545, 0.0545) || 挂载数据: 无 ) 
│   │   │   │       ├── 解析 --> ( 难度等级: [0.0545, 0.0545) || 挂载数据: blog: 1 ) 
│   │   │   │       └── 转换 --> ( 难度等级: [0.0545, 0.0545) || 挂载数据: 无 ) 
│   │   │   ├── Linkerd部署模式 --> ( 难度等级: [0.0545, 0.0545) || 挂载数据: 无 ) 
│   │   │   │   ├── Linkerd部署模式 --> ( 难度等级: [0.0545, 0.0545) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Per-host模式 --> ( 难度等级: [0.0545, 0.0545) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Sidecar模式 --> ( 难度等级: [0.0545, 0.0545) || 挂载数据: 无 ) 
│   │   │   │   │   └── Per-host模式和Sidecar模式 --> ( 难度等级: [0.0545, 0.0545) || 挂载数据: 无 ) 
│   │   │   │   └── 配置模型 --> ( 难度等级: [0.0545, 0.0545) || 挂载数据: 无 ) 
│   │   │   │       ├── service-to-linker模型 --> ( 难度等级: [0.0545, 0.0545) || 挂载数据: 无 ) 
│   │   │   │       ├── linker-to-service模型 --> ( 难度等级: [0.0545, 0.0545) || 挂载数据: 无 ) 
│   │   │   │       └── linker-to-linker模型 --> ( 难度等级: [0.0545, 0.0545) || 挂载数据: blog: 6 ) 
│   │   │   ├── Linkerd控制层：Namerd --> ( 难度等级: [0.0545, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   ├── Namerd简介 --> ( 难度等级: [0.0545, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   ├── Namerd配置详解 --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   │   ├── admin配置 --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   │   ├── interface配置 --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   │   ├── storage配置 --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   │   └── namer配置 --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   ├── 连接Linkerd和Namerd --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 准备Namerd配置文件 --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 启动Namerd --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 准备Linkerd配置文件 --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   │   └── 启动Linkerd --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   └── 管理dtab路由 --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │       ├── Namerd API简介 --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │       ├── 通过Namerd API管理dtab --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │       └── 通过namerctl CLI管理dtab --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   ├── 东西向流量控制 --> ( 难度等级: [0.0546, 0.0547) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio东西向流量管理 --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio路由控制 --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   ├── 实现东西向流量转移路由 --> ( 难度等级: [0.0546, 0.0547) || 挂载数据: 无 ) 
│   │   │   │   └── 实现流量镜像及对比分析 --> ( 难度等级: [0.0547, 0.0547) || 挂载数据: 无 ) 
│   │   │   ├── 南北向流量控制 --> ( 难度等级: [0.0547, 0.0547) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio南北向流量管理 --> ( 难度等级: [0.0547, 0.0547) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio网关与K8s Ingress --> ( 难度等级: [0.0547, 0.0547) || 挂载数据: 无 ) 
│   │   │   │   ├── 保护Istio网关流量 --> ( 难度等级: [0.0547, 0.0547) || 挂载数据: 无 ) 
│   │   │   │   ├── 实现入口流量路由的统一管理 --> ( 难度等级: [0.0547, 0.0547) || 挂载数据: 无 ) 
│   │   │   │   └── 实现出口流量路由的统一管理 --> ( 难度等级: [0.0547, 0.0547) || 挂载数据: 无 ) 
│   │   │   ├── 安全 --> ( 难度等级: [0.0547, 0.0548) || 挂载数据: 无 ) 
│   │   │   │   ├── Citadel架构设计 --> ( 难度等级: [0.0547, 0.0547) || 挂载数据: 无 ) 
│   │   │   │   ├── 认证机制 --> ( 难度等级: [0.0547, 0.0548) || 挂载数据: 无 ) 
│   │   │   │   ├── 授权机制 --> ( 难度等级: [0.0548, 0.0548) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用认证策略 --> ( 难度等级: [0.0548, 0.0548) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用双向认证 --> ( 难度等级: [0.0548, 0.0548) || 挂载数据: 无 ) 
│   │   │   │   ├── 消除Privileged容器提升安全性 --> ( 难度等级: [0.0548, 0.0548) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 通过NetworkPolicy增强安全性 --> ( 难度等级: [0.0548, 0.0548) || 挂载数据: 无 ) 
│   │   │   └── Mixer控制与观测 --> ( 难度等级: [0.0548, 0.0549) || 挂载数据: 无 ) 
│   │   │       ├── Mixer架构设计 --> ( 难度等级: [0.0548, 0.0548) || 挂载数据: 无 ) 
│   │   │       ├── 适配器机制 --> ( 难度等级: [0.0548, 0.0548) || 挂载数据: 无 ) 
│   │   │       ├── 使用速率限制策略 --> ( 难度等级: [0.0548, 0.0548) || 挂载数据: 无 ) 
│   │   │       ├── 使用黑白名单策略 --> ( 难度等级: [0.0548, 0.0548) || 挂载数据: 无 ) 
│   │   │       ├── 使用基于Zipkin与Jaeger的分布式跟踪 --> ( 难度等级: [0.0548, 0.0548) || 挂载数据: 无 ) 
│   │   │       ├── 集成度量数据收集 --> ( 难度等级: [0.0548, 0.0549) || 挂载数据: 无 ) 
│   │   │       └── 集成日志数据收集 --> ( 难度等级: [0.0549, 0.0549) || 挂载数据: 无 ) 
│   │   ├── 原理篇 --> ( 难度等级: [0.0549, 0.0554) || 挂载数据: 无 ) 
│   │   │   ├── 你好，Istio --> ( 难度等级: [0.0549, 0.0549) || 挂载数据: 无 ) 
│   │   │   │   └── 通过示例看看Istio能做什么 --> ( 难度等级: [0.0549, 0.0549) || 挂载数据: 无 ) 
│   │   │   ├── Istio架构概述 --> ( 难度等级: [0.0549, 0.055) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio的工作机制 --> ( 难度等级: [0.0549, 0.055) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio的服务模型 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Istio的服务 --> ( 难度等级: [0.055, 0.055) || 挂载数据: blog: 5 ) 
│   │   │   │   │   └── Istio的服务版本 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   └── Istio的主要组件 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-pilot --> ( 难度等级: [0.055, 0.055) || 挂载数据: blog: 2 ) 
│   │   │   │       ├── istio-telemetry --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-policy --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-citadel --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-galley --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-sidecar-injector --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-proxy --> ( 难度等级: [0.055, 0.055) || 挂载数据: blog: 1 ) 
│   │   │   │       └── istio-ingressgateway --> ( 难度等级: [0.055, 0.055) || 挂载数据: blog: 1 ) 
│   │   │   ├── 非侵入的流量治理 --> ( 难度等级: [0.055, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio流量治理的原理 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 服务熔断 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 故障注入 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 延迟注入 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 中断注入 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 灰度发布 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 预先准备：将所有流量都路由到各个服务的v1版本 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 基于流量比例的路由 --> ( 难度等级: [0.055, 0.055) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   ├── 基于请求内容的路由 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 组合条件路由 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 多服务灰度发布 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── TCP服务灰度发布 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 自动化灰度发布 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   │       ├── 正常发布 --> ( 难度等级: [0.055, 0.055) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │       └── 异常发布 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 服务访问入口 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   └── 外部接入服务治理 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio路由规则配置：VirtualService --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 路由规则配置示例 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 路由规则定义 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   ├── HTTP路由（HTTPRoute） --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   ├── TLS路由（TLSRoute） --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   ├── TCP路由（TCPRoute） --> ( 难度等级: [0.055, 0.055) || 挂载数据: blog: 2 ) 
│   │   │   │   │   ├── 三种协议路由规则的对比 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   └── VirtualService的典型应用 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio目标规则配置：DestinationRule --> ( 难度等级: [0.055, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   ├── DestinationRule配置示例 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   ├── DestinationRule规则定义 --> ( 难度等级: [0.055, 0.055) || 挂载数据: 无 ) 
│   │   │   │   │   └── DestinationRule的典型应用 --> ( 难度等级: [0.055, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio服务网关配置：Gateway --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Gateway配置示例 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── Gateway规则定义 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── Gateway的典型应用 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Istio外部服务配置：ServiceEntry --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   ├── ServiceEntry配置示例 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   ├── ServiceEntry规则的定义和用法 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   └── ServiceEntry的典型应用 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   └── Istio代理规则配置：Sidecar --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │       ├── Sidecar配置示例 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │       └── Sidecar规则定义 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   ├── 可扩展的策略和遥测 --> ( 难度等级: [0.0551, 0.0552) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio策略和遥测的原理 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 应用场景 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 工作原理 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: blog: 3 ) 
│   │   │   │   │   ├── 属性 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   └── Mixer的配置模型 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio遥测适配器配置 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Prometheus适配器 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Fluentd适配器 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   ├── StatsD适配器 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Stdio适配器 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Zipkin适配器 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   └── 厂商适配器 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio策略适配器配置 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   ├── List适配器 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── Denier适配器 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Memory Quota适配器 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   │   └── Redis Quota适配器 --> ( 难度等级: [0.0551, 0.0551) || 挂载数据: 无 ) 
│   │   │   │   └── Kubernetes Env适配器配置 --> ( 难度等级: [0.0551, 0.0552) || 挂载数据: 无 ) 
│   │   │   ├── 可插拔的服务安全 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio服务安全的原理 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 认证 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 授权 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 命名空间级别的访问控制 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 服务级别的访问控制 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   │   │   └── 密钥证书管理 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio服务认证配置 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 认证策略配置示例 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 认证策略的定义 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   │   │   ├── TLS访问配置 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   │   │   └── 认证策略的典型应用 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   │   └── Istio服务授权配置 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   │       ├── 授权启用配置 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: blog: 1 ) 
│   │   │   │       ├── 授权策略配置 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   │       └── 授权策略的典型应用 --> ( 难度等级: [0.0552, 0.0552) || 挂载数据: 无 ) 
│   │   │   ├── 透明的Sidecar机制 --> ( 难度等级: [0.0552, 0.0553) || 挂载数据: 无 ) 
│   │   │   │   ├── Sidecar注入 --> ( 难度等级: [0.0552, 0.0553) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Sidecar Injector自动注入的原理 --> ( 难度等级: [0.0552, 0.0553) || 挂载数据: 无 ) 
│   │   │   │   │   └── Sidecar注入的实现 --> ( 难度等级: [0.0553, 0.0553) || 挂载数据: blog: 2 ) 
│   │   │   │   └── Sidecar流量拦截 --> ( 难度等级: [0.0553, 0.0553) || 挂载数据: 无 ) 
│   │   │   │       ├── iptables的基本原理 --> ( 难度等级: [0.0553, 0.0553) || 挂载数据: 无 ) 
│   │   │   │       ├── iptables的规则设置 --> ( 难度等级: [0.0553, 0.0553) || 挂载数据: 无 ) 
│   │   │   │       └── 流量拦截原理 --> ( 难度等级: [0.0553, 0.0553) || 挂载数据: 无 ) 
│   │   │   └── 多集群服务治理 --> ( 难度等级: [0.0553, 0.0554) || 挂载数据: 无 ) 
│   │   │       ├── Istio多集群服务治理 --> ( 难度等级: [0.0553, 0.0553) || 挂载数据: 无 ) 
│   │   │       │   ├── Istio多集群的相关概念 --> ( 难度等级: [0.0553, 0.0553) || 挂载数据: blog: 1 ) 
│   │   │       │   └── Istio多集群服务治理现状 --> ( 难度等级: [0.0553, 0.0553) || 挂载数据: blog: 9 ) 
│   │   │       ├── 多集群模式1：多控制面 --> ( 难度等级: [0.0553, 0.0553) || 挂载数据: 无 ) 
│   │   │       │   ├── 服务DNS解析的原理 --> ( 难度等级: [0.0553, 0.0553) || 挂载数据: blog: 1 ) 
│   │   │       │   └── Gateway连接的原理 --> ( 难度等级: [0.0553, 0.0553) || 挂载数据: 无 ) 
│   │   │       ├── 多集群模式2：VPN直连单控制面 --> ( 难度等级: [0.0553, 0.0554) || 挂载数据: 无 ) 
│   │   │       └── 多集群模式3：集群感知服务路由单控制面 --> ( 难度等级: [0.0554, 0.0554) || 挂载数据: 无 ) 
│   │   ├── 实践篇 --> ( 难度等级: [0.0554, 0.0559) || 挂载数据: 无 ) 
│   │   │   ├── 流量监控 --> ( 难度等级: [0.0554, 0.0555) || 挂载数据: 无 ) 
│   │   │   │   ├── 调用链跟踪 --> ( 难度等级: [0.0554, 0.0554) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 指标监控 --> ( 难度等级: [0.0554, 0.0555) || 挂载数据: 无 ) 
│   │   │   │   │   └── Grafana --> ( 难度等级: [0.0554, 0.0555) || 挂载数据: 无 ) 
│   │   │   │   └── 服务网格监控 --> ( 难度等级: [0.0555, 0.0555) || 挂载数据: 无 ) 
│   │   │   ├── 流量治理 --> ( 难度等级: [0.0555, 0.0556) || 挂载数据: 无 ) 
│   │   │   │   ├── 流量负载均衡 --> ( 难度等级: [0.0555, 0.0555) || 挂载数据: 无 ) 
│   │   │   │   │   ├── ROUND_ROBIN模式 --> ( 难度等级: [0.0555, 0.0555) || 挂载数据: 无 ) 
│   │   │   │   │   └── RANDOM模式 --> ( 难度等级: [0.0555, 0.0555) || 挂载数据: 无 ) 
│   │   │   │   ├── 会话保持 --> ( 难度等级: [0.0555, 0.0555) || 挂载数据: 无 ) 
│   │   │   │   ├── 超时 --> ( 难度等级: [0.0555, 0.0555) || 挂载数据: 无 ) 
│   │   │   │   ├── 重试 --> ( 难度等级: [0.0555, 0.0555) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP重定向 --> ( 难度等级: [0.0555, 0.0556) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP重写 --> ( 难度等级: [0.0556, 0.0556) || 挂载数据: 无 ) 
│   │   │   │   ├── 熔断 --> ( 难度等级: [0.0556, 0.0556) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务隔离 --> ( 难度等级: [0.0556, 0.0556) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用流量策略 --> ( 难度等级: [0.0556, 0.0556) || 挂载数据: 无 ) 
│   │   │   │   ├── 设置负载均衡 --> ( 难度等级: [0.0556, 0.0556) || 挂载数据: 无 ) 
│   │   │   │   ├── 管理连接池 --> ( 难度等级: [0.0556, 0.0556) || 挂载数据: 无 ) 
│   │   │   │   ├── 增强路由规则 --> ( 难度等级: [0.0556, 0.0556) || 挂载数据: 无 ) 
│   │   │   │   ├── 混沌工程之熔断 --> ( 难度等级: [0.0556, 0.0556) || 挂载数据: 无 ) 
│   │   │   │   └── 混沌工程之故障注入 --> ( 难度等级: [0.0556, 0.0556) || 挂载数据: 无 ) 
│   │   │   ├── 服务保护 --> ( 难度等级: [0.0556, 0.0558) || 挂载数据: 无 ) 
│   │   │   │   ├── 网关加密 --> ( 难度等级: [0.0556, 0.0557) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 单向TLS网关 --> ( 难度等级: [0.0556, 0.0557) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 双向TLS网关 --> ( 难度等级: [0.0557, 0.0557) || 挂载数据: 无 ) 
│   │   │   │   │   └── 用SDS加密网关 --> ( 难度等级: [0.0557, 0.0557) || 挂载数据: 无 ) 
│   │   │   │   └── 访问控制 --> ( 难度等级: [0.0557, 0.0558) || 挂载数据: 无 ) 
│   │   │   │       ├── 黑名单 --> ( 难度等级: [0.0557, 0.0557) || 挂载数据: 无 ) 
│   │   │   │       └── 白名单 --> ( 难度等级: [0.0557, 0.0558) || 挂载数据: 无 ) 
│   │   │   └── 多集群管理 --> ( 难度等级: [0.0558, 0.0559) || 挂载数据: 无 ) 
│   │   ├── 架构篇 --> ( 难度等级: [0.0559, 0.0564) || 挂载数据: 无 ) 
│   │   │   ├── 司令官Pilot --> ( 难度等级: [0.0559, 0.056) || 挂载数据: 无 ) 
│   │   │   │   ├── Pilot的架构 --> ( 难度等级: [0.0559, 0.0559) || 挂载数据: 无 ) 
│   │   │   │   │   └── xDS协议 --> ( 难度等级: [0.0559, 0.0559) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Pilot的工作流程 --> ( 难度等级: [0.0559, 0.0559) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Pilot的启动与初始化 --> ( 难度等级: [0.0559, 0.0559) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置规则发现 --> ( 难度等级: [0.0559, 0.0559) || 挂载数据: 无 ) 
│   │   │   │   │   └── Envoy的配置分发 --> ( 难度等级: [0.0559, 0.0559) || 挂载数据: 无 ) 
│   │   │   │   ├── Pilot的插件 --> ( 难度等级: [0.0559, 0.056) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 安全插件 --> ( 难度等级: [0.0559, 0.056) || 挂载数据: blog: 2 ) 
│   │   │   │   │   ├── 健康检查插件 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   │   └── Mixer插件 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   └── Pilot的设计亮点 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │       ├── 三级缓存优化 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │       ├── 去抖动分发 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │       ├── 增量EDS --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │       └── 资源隔离 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   ├── 守护神Mixer --> ( 难度等级: [0.056, 0.0561) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer的整体架构 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer的服务模型 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Template --> ( 难度等级: [0.056, 0.056) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── Adapter --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer的工作流程 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 启动初始化 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 用户配置信息规则处理 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 访问策略的执行 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   │   └── 无侵入遥测 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer的设计亮点 --> ( 难度等级: [0.056, 0.0561) || 挂载数据: 无 ) 
│   │   │   │   └── 如何开发Mixer Adapter --> ( 难度等级: [0.0561, 0.0561) || 挂载数据: 无 ) 
│   │   │   │       ├── Adapter实现概述 --> ( 难度等级: [0.0561, 0.0561) || 挂载数据: 无 ) 
│   │   │   │       ├── 内置式Adapter的开发步骤 --> ( 难度等级: [0.0561, 0.0561) || 挂载数据: 无 ) 
│   │   │   │       ├── 独立进程式Adapter的开发步骤 --> ( 难度等级: [0.0561, 0.0561) || 挂载数据: blog: 1 ) 
│   │   │   │       └── 独立仓库式Adapter的开发步骤 --> ( 难度等级: [0.0561, 0.0561) || 挂载数据: 无 ) 
│   │   │   ├── 安全碉堡Citadel --> ( 难度等级: [0.0561, 0.0562) || 挂载数据: 无 ) 
│   │   │   │   ├── Citadel的架构 --> ( 难度等级: [0.0561, 0.0561) || 挂载数据: 无 ) 
│   │   │   │   └── Citadel的工作流程 --> ( 难度等级: [0.0561, 0.0562) || 挂载数据: 无 ) 
│   │   │   │       ├── 启动初始化 --> ( 难度等级: [0.0561, 0.0561) || 挂载数据: 无 ) 
│   │   │   │       ├── 证书控制器 --> ( 难度等级: [0.0561, 0.0561) || 挂载数据: 无 ) 
│   │   │   │       ├── gRPC服务器 --> ( 难度等级: [0.0561, 0.0561) || 挂载数据: 无 ) 
│   │   │   │       ├── 证书轮换器 --> ( 难度等级: [0.0561, 0.0562) || 挂载数据: 无 ) 
│   │   │   │       └── SDS服务器 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: 无 ) 
│   │   │   ├── 高性能代理Envoy --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的架构 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的特性 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的模块结构 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的线程模型 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的内存管理 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 变量管理 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: 无 ) 
│   │   │   │   │   └── Buffer管理 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Envoy的流量控制 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: 无 ) 
│   │   │   ├── 代理守护进程Pilot-agent --> ( 难度等级: [0.0562, 0.0563) || 挂载数据: 无 ) 
│   │   │   │   └── Pilot-agent的工作流程 --> ( 难度等级: [0.0562, 0.0563) || 挂载数据: 无 ) 
│   │   │   │       ├── Envoy的启动 --> ( 难度等级: [0.0562, 0.0563) || 挂载数据: 无 ) 
│   │   │   │       ├── Envoy的热重启 --> ( 难度等级: [0.0563, 0.0563) || 挂载数据: 无 ) 
│   │   │   │       ├── 守护Envoy --> ( 难度等级: [0.0563, 0.0563) || 挂载数据: 无 ) 
│   │   │   │       └── 优雅退出 --> ( 难度等级: [0.0563, 0.0563) || 挂载数据: 无 ) 
│   │   │   └── 配置中心Galley --> ( 难度等级: [0.0563, 0.0564) || 挂载数据: 无 ) 
│   │   │       ├── Galley的架构 --> ( 难度等级: [0.0563, 0.0564) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── MCP --> ( 难度等级: [0.0563, 0.0564) || 挂载数据: 无 ) 
│   │   │       │   └── MCP API --> ( 难度等级: [0.0564, 0.0564) || 挂载数据: 无 ) 
│   │   │       └── Galley的工作流程 --> ( 难度等级: [0.0564, 0.0564) || 挂载数据: 无 ) 
│   │   │           ├── 启动初始化 --> ( 难度等级: [0.0564, 0.0564) || 挂载数据: 无 ) 
│   │   │           ├── 配置校验 --> ( 难度等级: [0.0564, 0.0564) || 挂载数据: 无 ) 
│   │   │           └── 配置聚合与分发 --> ( 难度等级: [0.0564, 0.0564) || 挂载数据: 无 ) 
│   │   ├── 源码篇 --> ( 难度等级: [0.0564, 0.0569) || 挂载数据: 无 ) 
│   │   │   ├── Pilot源码解析 --> ( 难度等级: [0.0564, 0.0565) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动流程 --> ( 难度等级: [0.0564, 0.0565) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.0565, 0.0565) || 挂载数据: 无 ) 
│   │   │   │       ├── ConfigController --> ( 难度等级: [0.0565, 0.0565) || 挂载数据: 无 ) 
│   │   │   │       ├── ServiceController --> ( 难度等级: [0.0565, 0.0565) || 挂载数据: 无 ) 
│   │   │   │       ├── xDS异步分发 --> ( 难度等级: [0.0565, 0.0565) || 挂载数据: 无 ) 
│   │   │   │       └── 配置更新预处理 --> ( 难度等级: [0.0565, 0.0565) || 挂载数据: 无 ) 
│   │   │   ├── Mixer源码解析 --> ( 难度等级: [0.0565, 0.0566) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动流程 --> ( 难度等级: [0.0565, 0.0566) || 挂载数据: 无 ) 
│   │   │   │   │   ├── runServer通过newServer新建Server对象 --> ( 难度等级: [0.0565, 0.0565) || 挂载数据: 无 ) 
│   │   │   │   │   └── 启动Mixer gRPC Server --> ( 难度等级: [0.0565, 0.0566) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.0566, 0.0566) || 挂载数据: 无 ) 
│   │   │   │       ├── 监听用户的配置 --> ( 难度等级: [0.0566, 0.0566) || 挂载数据: 无 ) 
│   │   │   │       ├── 构建数据模型 --> ( 难度等级: [0.0566, 0.0566) || 挂载数据: 无 ) 
│   │   │   │       ├── Check接口 --> ( 难度等级: [0.0566, 0.0566) || 挂载数据: 无 ) 
│   │   │   │       ├── Report接口 --> ( 难度等级: [0.0566, 0.0566) || 挂载数据: 无 ) 
│   │   │   │       └── 协程池 --> ( 难度等级: [0.0566, 0.0566) || 挂载数据: 无 ) 
│   │   │   ├── Citadel源码解析 --> ( 难度等级: [0.0566, 0.0567) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动流程 --> ( 难度等级: [0.0566, 0.0567) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.0567, 0.0567) || 挂载数据: 无 ) 
│   │   │   │       ├── 证书签发实体IstioCA --> ( 难度等级: [0.0567, 0.0567) || 挂载数据: 无 ) 
│   │   │   │       ├── SecretController的创建和核心原理 --> ( 难度等级: [0.0567, 0.0567) || 挂载数据: 无 ) 
│   │   │   │       └── CA Server的创建和核心原理 --> ( 难度等级: [0.0567, 0.0567) || 挂载数据: 无 ) 
│   │   │   ├── Envoy源码解析 --> ( 难度等级: [0.0567, 0.0568) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的初始化 --> ( 难度等级: [0.0567, 0.0568) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 启动参数bootstrap的初始化 --> ( 难度等级: [0.0567, 0.0567) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Admin API的初始化 --> ( 难度等级: [0.0567, 0.0567) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Worker的初始化 --> ( 难度等级: [0.0567, 0.0567) || 挂载数据: 无 ) 
│   │   │   │   │   ├── CDS的初始化 --> ( 难度等级: [0.0567, 0.0567) || 挂载数据: 无 ) 
│   │   │   │   │   ├── LDS的初始化 --> ( 难度等级: [0.0567, 0.0568) || 挂载数据: 无 ) 
│   │   │   │   │   └── GuardDog的初始化 --> ( 难度等级: [0.0568, 0.0568) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的运行和建立新连接 --> ( 难度等级: [0.0568, 0.0568) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 启动worker --> ( 难度等级: [0.0568, 0.0568) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Listener的加载 --> ( 难度等级: [0.0568, 0.0568) || 挂载数据: 无 ) 
│   │   │   │   │   └── 接收连接 --> ( 难度等级: [0.0568, 0.0568) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Envoy对数据的读取、接收及处理 --> ( 难度等级: [0.0568, 0.0568) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 读取数据 --> ( 难度等级: [0.0568, 0.0568) || 挂载数据: 无 ) 
│   │   │   │   │   └── 接收数据 --> ( 难度等级: [0.0568, 0.0568) || 挂载数据: 无 ) 
│   │   │   │   └── Envoy发送数据到服务端 --> ( 难度等级: [0.0568, 0.0568) || 挂载数据: 无 ) 
│   │   │   │       ├── 匹配路由 --> ( 难度等级: [0.0568, 0.0568) || 挂载数据: 无 ) 
│   │   │   │       ├── 获取连接池 --> ( 难度等级: [0.0568, 0.0568) || 挂载数据: 无 ) 
│   │   │   │       └── 选择上游主机 --> ( 难度等级: [0.0568, 0.0568) || 挂载数据: 无 ) 
│   │   │   └── Galley源码解析 --> ( 难度等级: [0.0568, 0.0569) || 挂载数据: 无 ) 
│   │   │       ├── 进程启动流程 --> ( 难度等级: [0.0568, 0.0569) || 挂载数据: 无 ) 
│   │   │       │   ├── RunServer的启动流程 --> ( 难度等级: [0.0568, 0.0569) || 挂载数据: 无 ) 
│   │   │       │   └── RunValidation Server的启动流程 --> ( 难度等级: [0.0569, 0.0569) || 挂载数据: 无 ) 
│   │   │       └── 关键代码分析 --> ( 难度等级: [0.0569, 0.0569) || 挂载数据: 无 ) 
│   │   │           ├── 配置监听 --> ( 难度等级: [0.0569, 0.0569) || 挂载数据: 无 ) 
│   │   │           └── 配置分发 --> ( 难度等级: [0.0569, 0.0569) || 挂载数据: 无 ) 
│   │   ├── 初级篇 --> ( 难度等级: [0.0569, 0.0575) || 挂载数据: 无 ) 
│   │   │   ├── 快速上手Istio --> ( 难度等级: [0.0569, 0.0572) || 挂载数据: 无 ) 
│   │   │   │   ├── 在MiniKube上搭建Istio环境 --> ( 难度等级: [0.0569, 0.057) || 挂载数据: 无 ) 
│   │   │   │   ├── 在Docker Desktop上搭建Istio环境 --> ( 难度等级: [0.057, 0.0571) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 使用公有云Istio服务 --> ( 难度等级: [0.0571, 0.0571) || 挂载数据: 无 ) 
│   │   │   │   └── 在Istio中部署第一个应用程序 --> ( 难度等级: [0.0571, 0.0572) || 挂载数据: 无 ) 
│   │   │   └── Istio架构剖析 --> ( 难度等级: [0.0572, 0.0575) || 挂载数据: 无 ) 
│   │   │       ├── Istio架构总体结构 --> ( 难度等级: [0.0572, 0.0573) || 挂载数据: 无 ) 
│   │   │       ├── 剖析Istio控制平面 --> ( 难度等级: [0.0573, 0.0574) || 挂载数据: 无 ) 
│   │   │       │   └── Istio Mixer --> ( 难度等级: [0.0573, 0.0574) || 挂载数据: blog: 1 ) 
│   │   │       └── 剖析Istio数据平面 --> ( 难度等级: [0.0574, 0.0575) || 挂载数据: 无 ) 
│   │   │           ├── Envoy代理 --> ( 难度等级: [0.0574, 0.0574) || 挂载数据: 无 ) 
│   │   │           ├── Envoy静态与动态配置 --> ( 难度等级: [0.0574, 0.0574) || 挂载数据: 无 ) 
│   │   │           └── 代理部署 --> ( 难度等级: [0.0574, 0.0575) || 挂载数据: 无 ) 
│   │   ├── 高级篇 --> ( 难度等级: [0.0575, 0.058) || 挂载数据: 无 ) 
│   │   │   ├── Istio的性能分析与运维 --> ( 难度等级: [0.0575, 0.0576) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio功能稳定性 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio性能分析 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Istio组件升级与回滚 --> ( 难度等级: [0.0575, 0.0576) || 挂载数据: 无 ) 
│   │   │   │   └── Pilot运维指南 --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: blog: 9 ) 
│   │   │   ├── Istio的定制与扩展 --> ( 难度等级: [0.0576, 0.0577) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer模板设计 --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   │   ├── 适配器生命周期管理 --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发实现适配器 --> ( 难度等级: [0.0576, 0.0577) || 挂载数据: 无 ) 
│   │   │   │   ├── 编译与打包适配器 --> ( 难度等级: [0.0577, 0.0577) || 挂载数据: 无 ) 
│   │   │   │   └── 扩展EnvoyFilter --> ( 难度等级: [0.0577, 0.0577) || 挂载数据: 无 ) 
│   │   │   ├── Knative：基于Istio的无服务器计算 --> ( 难度等级: [0.0577, 0.0578) || 挂载数据: 无 ) 
│   │   │   │   ├── Knative架构解析 --> ( 难度等级: [0.0577, 0.0577) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于Istio实现Serving组件 --> ( 难度等级: [0.0577, 0.0578) || 挂载数据: 无 ) 
│   │   │   │   ├── Knative Build运行机制 --> ( 难度等级: [0.0578, 0.0578) || 挂载数据: 无 ) 
│   │   │   │   ├── Knative Eventing运行机制 --> ( 难度等级: [0.0578, 0.0578) || 挂载数据: 无 ) 
│   │   │   │   ├── 在Istio上部署Knative --> ( 难度等级: [0.0578, 0.0578) || 挂载数据: 无 ) 
│   │   │   │   └── 开发部署Knative应用 --> ( 难度等级: [0.0578, 0.0578) || 挂载数据: 无 ) 
│   │   │   └── 云原生计算的未来展望 --> ( 难度等级: [0.0578, 0.058) || 挂载数据: blog: 1 ) 
│   │   ├── 什么是架构 --> ( 难度等级: [0.058, 0.0585) || 挂载数据: 无 ) 
│   │   ├── 几个相关概念 --> ( 难度等级: [0.0585, 0.059) || 挂载数据: 无 ) 
│   │   ├── 从软件的生命周期看架构设计 --> ( 难度等级: [0.059, 0.0595) || 挂载数据: 无 ) 
│   │   ├── 架构的形式与特点 --> ( 难度等级: [0.0595, 0.06) || 挂载数据: 无 ) 
│   │   ├── 架构的目标与方法 --> ( 难度等级: [0.06, 0.0606) || 挂载数据: 无 ) 
│   │   ├── 架构的不同风格 --> ( 难度等级: [0.0606, 0.0611) || 挂载数据: 无 ) 
│   │   ├── 微服务领域驱动设计 --> ( 难度等级: [0.0611, 0.0616) || 挂载数据: 无 ) 
│   │   │   ├── 领域驱动设计 --> ( 难度等级: [0.0611, 0.0613) || 挂载数据: 无 ) 
│   │   │   │   ├── 领域驱动设计概览 --> ( 难度等级: [0.0611, 0.0611) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 限界上下文 --> ( 难度等级: [0.0611, 0.0612) || 挂载数据: 无 ) 
│   │   │   │   ├── 上下文映射 --> ( 难度等级: [0.0612, 0.0613) || 挂载数据: 无 ) 
│   │   │   │   └── 领域架构 --> ( 难度等级: [0.0613, 0.0613) || 挂载数据: 无 ) 
│   │   │   └── 微服务的设计 --> ( 难度等级: [0.0613, 0.0616) || 挂载数据: 无 ) 
│   │   │       ├── 限界上下文的边界 --> ( 难度等级: [0.0613, 0.0614) || 挂载数据: 无 ) 
│   │   │       ├── 限界上下文即微服务 --> ( 难度等级: [0.0614, 0.0615) || 挂载数据: 无 ) 
│   │   │       ├── 识别限界上下文 --> ( 难度等级: [0.0615, 0.0615) || 挂载数据: 无 ) 
│   │   │       └── 微服务之间的协作 --> ( 难度等级: [0.0615, 0.0616) || 挂载数据: blog: 10 ) 
│   │   ├── Apache Dubbo框架的原理与实现 --> ( 难度等级: [0.0616, 0.0621) || 挂载数据: blog: 1 ) 
│   │   │   ├── Dubbo框架的选型与使用 --> ( 难度等级: [0.0616, 0.0618) || 挂载数据: 无 ) 
│   │   │   │   ├── Dubbo框架的选型 --> ( 难度等级: [0.0616, 0.0617) || 挂载数据: 无 ) 
│   │   │   │   └── Dubbo框架的使用 --> ( 难度等级: [0.0617, 0.0618) || 挂载数据: blog: 10 ) 
│   │   │   ├── Dubbo框架的原理分析 --> ( 难度等级: [0.0618, 0.0619) || 挂载数据: 无 ) 
│   │   │   │   ├── 总体架构分析 --> ( 难度等级: [0.0618, 0.0618) || 挂载数据: 无 ) 
│   │   │   │   ├── Dubbo Bean的加载 --> ( 难度等级: [0.0618, 0.0618) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Dubbo Extension机制 --> ( 难度等级: [0.0618, 0.0619) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Dubbo消费端 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: 无 ) 
│   │   │   │   ├── Dubbo服务端 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: blog: 3 ) 
│   │   │   │   └── Dubbo的通信机制 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: blog: 1 ) 
│   │   │   └── 基于Dubbo的自动化Mock系统 --> ( 难度等级: [0.0619, 0.0621) || 挂载数据: 无 ) 
│   │   │       ├── Mock模拟系统的产生 --> ( 难度等级: [0.0619, 0.062) || 挂载数据: 无 ) 
│   │   │       ├── Dubbo Mock的使用 --> ( 难度等级: [0.062, 0.062) || 挂载数据: 无 ) 
│   │   │       ├── Dubbo Mock的原理解析 --> ( 难度等级: [0.062, 0.0621) || 挂载数据: blog: 1 ) 
│   │   │       └── 自动化Mock系统的实现 --> ( 难度等级: [0.0621, 0.0621) || 挂载数据: blog: 1 ) 
│   │   ├── Spring Boot/Spring Cloud实践 --> ( 难度等级: [0.0621, 0.0626) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot原理剖析 --> ( 难度等级: [0.0621, 0.0622) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Boot Quick Start --> ( 难度等级: [0.0621, 0.0621) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Spring Boot之SpringApplication --> ( 难度等级: [0.0621, 0.0622) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── spring-boot-loaded模块分析 --> ( 难度等级: [0.0622, 0.0622) || 挂载数据: 无 ) 
│   │   │   │   ├── spring-boot-autoconfigure模块分析 --> ( 难度等级: [0.0622, 0.0622) || 挂载数据: 无 ) 
│   │   │   │   └── Spring Boot Conditional注解分析 --> ( 难度等级: [0.0622, 0.0622) || 挂载数据: blog: 4 ) 
│   │   │   ├── Dubbo Spring Boot Starter --> ( 难度等级: [0.0622, 0.0624) || 挂载数据: 无 ) 
│   │   │   │   ├── Dubbo Spring Boot Starter简介 --> ( 难度等级: [0.0622, 0.0623) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Dubbo Initializr及sample --> ( 难度等级: [0.0623, 0.0623) || 挂载数据: 无 ) 
│   │   │   │   ├── dubbo-spring-boot-autoconfigure模块 --> ( 难度等级: [0.0623, 0.0623) || 挂载数据: 无 ) 
│   │   │   │   └── dubbo-spring-boot-actuator模块 --> ( 难度等级: [0.0623, 0.0624) || 挂载数据: blog: 1 ) 
│   │   │   ├── Spring Cloud栈 --> ( 难度等级: [0.0624, 0.0625) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud技术栈总览 --> ( 难度等级: [0.0624, 0.0624) || 挂载数据: blog: 5 ) 
│   │   │   │   └── spring-cloud-scaffold基础库集合 --> ( 难度等级: [0.0624, 0.0625) || 挂载数据: blog: 1 ) 
│   │   │   └── 基于Maven Archetype的脚手架 --> ( 难度等级: [0.0625, 0.0626) || 挂载数据: 无 ) 
│   │   │       ├── Maven Archetype --> ( 难度等级: [0.0625, 0.0625) || 挂载数据: blog: 10 ) 
│   │   │       ├── 脚手架的搭建 --> ( 难度等级: [0.0625, 0.0626) || 挂载数据: 无 ) 
│   │   │       └── 生成脚手架 --> ( 难度等级: [0.0626, 0.0626) || 挂载数据: 无 ) 
│   │   ├── 微服务稳定性保证的常用手段 --> ( 难度等级: [0.0626, 0.0631) || 挂载数据: 无 ) 
│   │   │   ├── 微服务的稳定性 --> ( 难度等级: [0.0626, 0.0628) || 挂载数据: 无 ) 
│   │   │   ├── 高可用 --> ( 难度等级: [0.0628, 0.063) || 挂载数据: 无 ) 
│   │   │   │   ├── 限流原理与实现 --> ( 难度等级: [0.0628, 0.0629) || 挂载数据: 无 ) 
│   │   │   │   └── 断路器原理与实现 --> ( 难度等级: [0.0629, 0.063) || 挂载数据: 无 ) 
│   │   │   └── 高并发 --> ( 难度等级: [0.063, 0.0631) || 挂载数据: blog: 1 ) 
│   │   │       ├── 异步 --> ( 难度等级: [0.063, 0.0631) || 挂载数据: 无 ) 
│   │   │       └── 缓存 --> ( 难度等级: [0.0631, 0.0631) || 挂载数据: 无 ) 
│   │   ├── 微服务下如何保证事务的一致性 --> ( 难度等级: [0.0631, 0.0637) || 挂载数据: 无 ) 
│   │   │   ├── 从本地事务到分布式事务的演变 --> ( 难度等级: [0.0631, 0.0633) || 挂载数据: 无 ) 
│   │   │   ├── 强一致性解决方案 --> ( 难度等级: [0.0633, 0.0635) || 挂载数据: 无 ) 
│   │   │   │   ├── 二阶段提交协议 --> ( 难度等级: [0.0633, 0.0634) || 挂载数据: 无 ) 
│   │   │   │   └── 三阶段提交协议 --> ( 难度等级: [0.0634, 0.0635) || 挂载数据: 无 ) 
│   │   │   └── 最终一致性解决方案 --> ( 难度等级: [0.0635, 0.0637) || 挂载数据: 无 ) 
│   │   │       ├── TCC模式 --> ( 难度等级: [0.0635, 0.0636) || 挂载数据: 无 ) 
│   │   │       └── 补偿模式 --> ( 难度等级: [0.0636, 0.0637) || 挂载数据: 无 ) 
│   │   ├── 百亿流量微服务网关的设计与实现 --> ( 难度等级: [0.0637, 0.0642) || 挂载数据: 无 ) 
│   │   │   ├── 开源网关的分析与调研 --> ( 难度等级: [0.0637, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── 常见的开源网关介绍 --> ( 难度等级: [0.0637, 0.0638) || 挂载数据: 无 ) 
│   │   │   │   └── 四大开源网关的对比分析 --> ( 难度等级: [0.0638, 0.0639) || 挂载数据: 无 ) 
│   │   │   └── 百亿流量交易系统API网关设计 --> ( 难度等级: [0.0639, 0.0642) || 挂载数据: 无 ) 
│   │   │       └── 业务网关的设计与最佳实践 --> ( 难度等级: [0.0639, 0.0642) || 挂载数据: 无 ) 
│   │   ├── 微服务编排 --> ( 难度等级: [0.0642, 0.0647) || 挂载数据: 无 ) 
│   │   │   ├── Netflix Conductor --> ( 难度等级: [0.0642, 0.0643) || 挂载数据: 无 ) 
│   │   │   ├── Netflix Conductor的架构 --> ( 难度等级: [0.0643, 0.0644) || 挂载数据: 无 ) 
│   │   │   ├── Conductor的使用案例 --> ( 难度等级: [0.0644, 0.0646) || 挂载数据: 无 ) 
│   │   │   └── Netflix Conductor源码分析 --> ( 难度等级: [0.0646, 0.0647) || 挂载数据: 无 ) 
│   │   │       ├── Client层源码分析 --> ( 难度等级: [0.0646, 0.0646) || 挂载数据: blog: 1 ) 
│   │   │       ├── Server端源码分析 --> ( 难度等级: [0.0646, 0.0647) || 挂载数据: 无 ) 
│   │   │       └── core端源码分析 --> ( 难度等级: [0.0647, 0.0647) || 挂载数据: 无 ) 
│   │   ├── 微服务数据抽取与统计 --> ( 难度等级: [0.0647, 0.0652) || 挂载数据: 无 ) 
│   │   │   ├── 案例小故事 --> ( 难度等级: [0.0647, 0.0648) || 挂载数据: 无 ) 
│   │   │   ├── 数据仓库概述 --> ( 难度等级: [0.0648, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   ├── 什么是数据仓库 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据仓库架构 --> ( 难度等级: [0.0648, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据仓库建模方法 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   └── 数据统计 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: blog: 1 ) 
│   │   │   ├── 数据仓库工具Hive --> ( 难度等级: [0.0649, 0.065) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Hive --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Hive数据库 --> ( 难度等级: [0.0649, 0.065) || 挂载数据: blog: 9 ) 
│   │   │   │   └── Hive表 --> ( 难度等级: [0.065, 0.065) || 挂载数据: 无 ) 
│   │   │   ├── 使用Sqoop抽取数据 --> ( 难度等级: [0.065, 0.0651) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Sqoop --> ( 难度等级: [0.065, 0.0651) || 挂载数据: 无 ) 
│   │   │   │   └── 将MySQL表数据导入Hive表 --> ( 难度等级: [0.0651, 0.0651) || 挂载数据: blog: 4 ) 
│   │   │   └── ETL作业调度 --> ( 难度等级: [0.0651, 0.0652) || 挂载数据: blog: 1 ) 
│   │   ├── 微服务双活体系建设 --> ( 难度等级: [0.0652, 0.0657) || 挂载数据: 无 ) 
│   │   │   ├── 系统高可用 --> ( 难度等级: [0.0652, 0.0655) || 挂载数据: 无 ) 
│   │   │   └── 双活数据中心 --> ( 难度等级: [0.0655, 0.0657) || 挂载数据: 无 ) 
│   │   │       ├── 单机房部署 --> ( 难度等级: [0.0655, 0.0656) || 挂载数据: 无 ) 
│   │   │       ├── 双机房部署 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: 无 ) 
│   │   │       └── 基于支付场景的双活体系建设 --> ( 难度等级: [0.0656, 0.0657) || 挂载数据: 无 ) 
│   │   ├── 基于支付场景下的微服务改造与性能优化 --> ( 难度等级: [0.0657, 0.0663) || 挂载数据: 无 ) 
│   │   │   ├── 支付场景的介绍 --> ( 难度等级: [0.0657, 0.0659) || 挂载数据: 无 ) 
│   │   │   ├── 从代码层面提升微服务架构的性能 --> ( 难度等级: [0.0659, 0.0661) || 挂载数据: 无 ) 
│   │   │   │   ├── 从代码和设计的角度看 --> ( 难度等级: [0.0659, 0.066) || 挂载数据: 无 ) 
│   │   │   │   └── 从整体架构的角度看 --> ( 难度等级: [0.066, 0.0661) || 挂载数据: 无 ) 
│   │   │   └── 微服务架构中常见的一些故障分析技巧 --> ( 难度等级: [0.0661, 0.0663) || 挂载数据: 无 ) 
│   │   ├── 遗留系统的微服务架构改造 --> ( 难度等级: [0.0663, 0.0668) || 挂载数据: 无 ) 
│   │   │   ├── 代码分层结构的转变 --> ( 难度等级: [0.0663, 0.0664) || 挂载数据: 无 ) 
│   │   │   ├── 遗留系统的债券与思考 --> ( 难度等级: [0.0664, 0.0665) || 挂载数据: 无 ) 
│   │   │   ├── 从单体系统拆分服务的方法论 --> ( 难度等级: [0.0665, 0.0666) || 挂载数据: 无 ) 
│   │   │   └── 遗留系统的微服务架构改造 --> ( 难度等级: [0.0666, 0.0668) || 挂载数据: 无 ) 
│   │   │       ├── 从代码重构开始 --> ( 难度等级: [0.0666, 0.0667) || 挂载数据: 无 ) 
│   │   │       ├── 拆分服务需要面向服务进行架构设计 --> ( 难度等级: [0.0667, 0.0667) || 挂载数据: 无 ) 
│   │   │       ├── 改造是一个渐进的过程 --> ( 难度等级: [0.0667, 0.0667) || 挂载数据: 无 ) 
│   │   │       ├── 单元测试是基石 --> ( 难度等级: [0.0667, 0.0667) || 挂载数据: 无 ) 
│   │   │       ├── 面向失败的设计 --> ( 难度等级: [0.0667, 0.0667) || 挂载数据: 无 ) 
│   │   │       ├── 前后端分离 --> ( 难度等级: [0.0667, 0.0667) || 挂载数据: blog: 1 ) 
│   │   │       ├── 共享现有数据库 --> ( 难度等级: [0.0667, 0.0667) || 挂载数据: 无 ) 
│   │   │       ├── 灰度发布的必要性 --> ( 难度等级: [0.0667, 0.0668) || 挂载数据: 无 ) 
│   │   │       └── 日志聚合与全链路监控 --> ( 难度等级: [0.0668, 0.0668) || 挂载数据: 无 ) 
│   │   ├── Service Mesh详解 --> ( 难度等级: [0.0668, 0.0673) || 挂载数据: 无 ) 
│   │   │   ├── Service Mesh的背景 --> ( 难度等级: [0.0668, 0.0669) || 挂载数据: 无 ) 
│   │   │   ├── Service Mesh介绍 --> ( 难度等级: [0.0669, 0.067) || 挂载数据: 无 ) 
│   │   │   │   ├── Service Mesh架构 --> ( 难度等级: [0.0669, 0.0669) || 挂载数据: blog: 10 ) 
│   │   │   │   └── Service Mesh能做什么 --> ( 难度等级: [0.0669, 0.067) || 挂载数据: blog: 2 ) 
│   │   │   ├── Service Mesh的价值 --> ( 难度等级: [0.067, 0.0671) || 挂载数据: 无 ) 
│   │   │   ├── Istio详解 --> ( 难度等级: [0.0671, 0.0672) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Istio架构 --> ( 难度等级: [0.0671, 0.0671) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据平面 --> ( 难度等级: [0.0671, 0.0671) || 挂载数据: 无 ) 
│   │   │   │   ├── 控制平面 --> ( 难度等级: [0.0671, 0.0672) || 挂载数据: 无 ) 
│   │   │   │   └── Isito案例 --> ( 难度等级: [0.0672, 0.0672) || 挂载数据: 无 ) 
│   │   │   └── Service Mesh展望 --> ( 难度等级: [0.0672, 0.0673) || 挂载数据: 无 ) 
│   │   ├── 深入理解网络 --> ( 难度等级: [0.0673, 0.0678) || 挂载数据: 无 ) 
│   │   │   ├── 从国际互联网开始 --> ( 难度等级: [0.0673, 0.0674) || 挂载数据: 无 ) 
│   │   │   ├── NIO，一本难念的经 --> ( 难度等级: [0.0674, 0.0675) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 难懂的ByteBuffer --> ( 难度等级: [0.0674, 0.0674) || 挂载数据: 无 ) 
│   │   │   │   ├── 晦涩的“非阻塞” --> ( 难度等级: [0.0674, 0.0674) || 挂载数据: 无 ) 
│   │   │   │   └── 复杂的Reactor模型 --> ( 难度等级: [0.0674, 0.0675) || 挂载数据: 无 ) 
│   │   │   ├── AIO，大道至简的设计与苦涩的现实 --> ( 难度等级: [0.0675, 0.0675) || 挂载数据: 无 ) 
│   │   │   ├── HTTP的前世今生 --> ( 难度等级: [0.0675, 0.0676) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP的设计思路 --> ( 难度等级: [0.0675, 0.0676) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP如何保持状态 --> ( 难度等级: [0.0676, 0.0676) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Session的秘密 --> ( 难度等级: [0.0676, 0.0676) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 再谈Token --> ( 难度等级: [0.0676, 0.0676) || 挂载数据: 无 ) 
│   │   │   │   └── 分布式Session --> ( 难度等级: [0.0676, 0.0676) || 挂载数据: 无 ) 
│   │   │   ├── 分布式系统的基石：TCP/IP --> ( 难度等级: [0.0676, 0.0677) || 挂载数据: blog: 1 ) 
│   │   │   └── 从CDN到SD-WAN --> ( 难度等级: [0.0677, 0.0678) || 挂载数据: 无 ) 
│   │   │       ├── 互联互不通的运营商网络 --> ( 难度等级: [0.0677, 0.0677) || 挂载数据: 无 ) 
│   │   │       ├── 双线机房的出现 --> ( 难度等级: [0.0677, 0.0678) || 挂载数据: 无 ) 
│   │   │       ├── CDN的作用 --> ( 难度等级: [0.0678, 0.0678) || 挂载数据: blog: 2 ) 
│   │   │       └── SD-WAN技术的诞生 --> ( 难度等级: [0.0678, 0.0678) || 挂载数据: 无 ) 
│   │   ├── 分布式系统的经典理论 --> ( 难度等级: [0.0678, 0.0683) || 挂载数据: 无 ) 
│   │   │   ├── 从分布式系统的设计理念说起 --> ( 难度等级: [0.0678, 0.0679) || 挂载数据: 无 ) 
│   │   │   ├── 分布式系统的一致性原理 --> ( 难度等级: [0.0679, 0.068) || 挂载数据: 无 ) 
│   │   │   ├── 分布式系统的基石之ZooKeeper --> ( 难度等级: [0.068, 0.0681) || 挂载数据: 无 ) 
│   │   │   │   ├── ZooKeeper的原理与功能 --> ( 难度等级: [0.068, 0.068) || 挂载数据: blog: 10 ) 
│   │   │   │   └── ZooKeeper的应用场景案例分析 --> ( 难度等级: [0.068, 0.0681) || 挂载数据: blog: 10 ) 
│   │   │   ├── 经典的CAP理论 --> ( 难度等级: [0.0681, 0.0682) || 挂载数据: blog: 2 ) 
│   │   │   ├── BASE准则，一个影响深远的指导思想 --> ( 难度等级: [0.0682, 0.0682) || 挂载数据: 无 ) 
│   │   │   └── 重新认识分布式事务 --> ( 难度等级: [0.0682, 0.0683) || 挂载数据: 无 ) 
│   │   │       ├── 数据库单机事务的实现原理 --> ( 难度等级: [0.0682, 0.0683) || 挂载数据: blog: 1 ) 
│   │   │       ├── 经典的X/OpenDTP事务模型 --> ( 难度等级: [0.0683, 0.0683) || 挂载数据: 无 ) 
│   │   │       └── 互联网中的分布式事务解决方案 --> ( 难度等级: [0.0683, 0.0683) || 挂载数据: blog: 10 ) 
│   │   ├── 聊聊RPC --> ( 难度等级: [0.0683, 0.0688) || 挂载数据: 无 ) 
│   │   │   ├── 从IPC通信说起 --> ( 难度等级: [0.0683, 0.0685) || 挂载数据: 无 ) 
│   │   │   ├── 古老又有生命力的RPC --> ( 难度等级: [0.0685, 0.0686) || 挂载数据: 无 ) 
│   │   │   ├── 从RPC到服务治理框架 --> ( 难度等级: [0.0686, 0.0687) || 挂载数据: 无 ) 
│   │   │   └── 基于ZeroC Ice的微服务架构指南 --> ( 难度等级: [0.0687, 0.0688) || 挂载数据: 无 ) 
│   │   │       ├── ZeroC Ice的前世今生 --> ( 难度等级: [0.0687, 0.0688) || 挂载数据: blog: 2 ) 
│   │   │       ├── ZeroC Ice微服务架构指南 --> ( 难度等级: [0.0688, 0.0688) || 挂载数据: 无 ) 
│   │   │       └── 微服务架构概述 --> ( 难度等级: [0.0688, 0.0688) || 挂载数据: 无 ) 
│   │   │           ├── 微服务架构兴起的原因 --> ( 难度等级: [0.0688, 0.0688) || 挂载数据: 无 ) 
│   │   │           ├── 不得不提的容器技术 --> ( 难度等级: [0.0688, 0.0688) || 挂载数据: 无 ) 
│   │   │           └── 如何全面理解微服务架构 --> ( 难度等级: [0.0688, 0.0688) || 挂载数据: blog: 10 ) 
│   │   ├── 深入浅析内存 --> ( 难度等级: [0.0688, 0.0694) || 挂载数据: 无 ) 
│   │   │   ├── 你所不知道的内存知识 --> ( 难度等级: [0.0688, 0.069) || 挂载数据: 无 ) 
│   │   │   │   ├── 复杂的CPU与单纯的内存 --> ( 难度等级: [0.0688, 0.0689) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 深入理解不一致性内存 --> ( 难度等级: [0.0689, 0.069) || 挂载数据: 无 ) 
│   │   │   ├── 内存计算技术的前世今生 --> ( 难度等级: [0.069, 0.0691) || 挂载数据: 无 ) 
│   │   │   ├── 内存缓存技术分析 --> ( 难度等级: [0.0691, 0.0692) || 挂载数据: 无 ) 
│   │   │   │   ├── 缓存概述 --> ( 难度等级: [0.0691, 0.0691) || 挂载数据: 无 ) 
│   │   │   │   ├── 缓存实现的几种方式 --> ( 难度等级: [0.0691, 0.0692) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Memcache的内存管理技术 --> ( 难度等级: [0.0692, 0.0692) || 挂载数据: blog: 4 ) 
│   │   │   │   └── Redis的独特之处 --> ( 难度等级: [0.0692, 0.0692) || 挂载数据: 无 ) 
│   │   │   └── 内存计算产品分析 --> ( 难度等级: [0.0692, 0.0694) || 挂载数据: blog: 1 ) 
│   │   │       ├── SAP HANA --> ( 难度等级: [0.0692, 0.0693) || 挂载数据: blog: 1 ) 
│   │   │       ├── Hazelcast --> ( 难度等级: [0.0693, 0.0693) || 挂载数据: 无 ) 
│   │   │       └── VoltDB --> ( 难度等级: [0.0693, 0.0694) || 挂载数据: 无 ) 
│   │   ├── 深入解析分布式文件存储 --> ( 难度等级: [0.0694, 0.0699) || 挂载数据: 无 ) 
│   │   │   ├── 数据存储进化史 --> ( 难度等级: [0.0694, 0.0694) || 挂载数据: 无 ) 
│   │   │   ├── 经典的网络文件系统NFS --> ( 难度等级: [0.0694, 0.0695) || 挂载数据: 无 ) 
│   │   │   ├── 高性能计算领域的分布式文件系统 --> ( 难度等级: [0.0695, 0.0696) || 挂载数据: 无 ) 
│   │   │   ├── 企业级分布式文件系统GlusterFS --> ( 难度等级: [0.0696, 0.0697) || 挂载数据: 无 ) 
│   │   │   ├── 创新的Linux分布式存储系统——Ceph --> ( 难度等级: [0.0697, 0.0697) || 挂载数据: blog: 1 ) 
│   │   │   ├── 星际文件系统IPFS --> ( 难度等级: [0.0697, 0.0698) || 挂载数据: 无 ) 
│   │   │   └── 软件定义存储 --> ( 难度等级: [0.0698, 0.0699) || 挂载数据: blog: 1 ) 
│   │   ├── 聊聊分布式计算 --> ( 难度等级: [0.0699, 0.0704) || 挂载数据: 无 ) 
│   │   │   ├── 不得不说的Actor模型 --> ( 难度等级: [0.0699, 0.07) || 挂载数据: 无 ) 
│   │   │   ├── 初识Akka --> ( 难度等级: [0.07, 0.0701) || 挂载数据: 无 ) 
│   │   │   ├── 适用面很广的Storm --> ( 难度等级: [0.0701, 0.0703) || 挂载数据: blog: 2 ) 
│   │   │   └── MapReduce及其引发的新世界 --> ( 难度等级: [0.0703, 0.0704) || 挂载数据: blog: 4 ) 
│   │   ├── 全文检索与消息队列中间件 --> ( 难度等级: [0.0704, 0.0709) || 挂载数据: 无 ) 
│   │   │   ├── 全文检索 --> ( 难度等级: [0.0704, 0.0707) || 挂载数据: 无 ) 
│   │   │   │   ├── Lucene --> ( 难度等级: [0.0704, 0.0705) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Solr --> ( 难度等级: [0.0705, 0.0706) || 挂载数据: 无 ) 
│   │   │   │   └── ElasticSearch --> ( 难度等级: [0.0706, 0.0707) || 挂载数据: blog: 5 ) 
│   │   │   └── 消息队列 --> ( 难度等级: [0.0707, 0.0709) || 挂载数据: blog: 6 ) 
│   │   │       ├── JEE专属的JMS --> ( 难度等级: [0.0707, 0.0707) || 挂载数据: blog: 2 ) 
│   │   │       ├── 生生不息的ActiveMQ --> ( 难度等级: [0.0707, 0.0708) || 挂载数据: blog: 10 ) 
│   │   │       ├── RabbitMQ --> ( 难度等级: [0.0708, 0.0708) || 挂载数据: blog: 10 ) 
│   │   │       └── Kafka --> ( 难度等级: [0.0708, 0.0709) || 挂载数据: blog: 10 ) 
│   │   └── 架构实践 --> ( 难度等级: [0.0709, 0.0714) || 挂载数据: 无 ) 
│   │       ├── 身边购平台实践 --> ( 难度等级: [0.0709, 0.0712) || 挂载数据: blog: 1 ) 
│   │       └── DIY一个有难度的分布式集群 --> ( 难度等级: [0.0712, 0.0714) || 挂载数据: blog: 2 ) 
│   ├── 编程语言 --> ( 难度等级: [0.0714, 0.1071) || 挂载数据: 无 ) 
│   │   ├── Golang --> ( 难度等级: [0.0714, 0.0729) || 挂载数据: 无 ) 
│   │   ├── 入门 --> ( 难度等级: [0.0729, 0.0743) || 挂载数据: 无 ) 
│   │   │   ├── hello，world --> ( 难度等级: [0.0729, 0.073) || 挂载数据: blog: 1 ) 
│   │   │   ├── 命令行参数 --> ( 难度等级: [0.073, 0.0732) || 挂载数据: 无 ) 
│   │   │   ├── 找出重复行 --> ( 难度等级: [0.0732, 0.0734) || 挂载数据: 无 ) 
│   │   │   ├── GIF动画 --> ( 难度等级: [0.0734, 0.0736) || 挂载数据: 无 ) 
│   │   │   ├── 获取一个URL --> ( 难度等级: [0.0736, 0.0737) || 挂载数据: 无 ) 
│   │   │   ├── 并发获取多个URL --> ( 难度等级: [0.0737, 0.0739) || 挂载数据: 无 ) 
│   │   │   ├── 一个Web服务器 --> ( 难度等级: [0.0739, 0.0741) || 挂载数据: 无 ) 
│   │   │   └── 其他内容 --> ( 难度等级: [0.0741, 0.0743) || 挂载数据: 无 ) 
│   │   ├── 程序结构 --> ( 难度等级: [0.0743, 0.0757) || 挂载数据: 无 ) 
│   │   │   ├── 名称 --> ( 难度等级: [0.0743, 0.0745) || 挂载数据: 无 ) 
│   │   │   ├── 声明 --> ( 难度等级: [0.0745, 0.0747) || 挂载数据: 无 ) 
│   │   │   ├── 变量 --> ( 难度等级: [0.0747, 0.0749) || 挂载数据: 无 ) 
│   │   │   │   ├── 短变量声明 --> ( 难度等级: [0.0747, 0.0747) || 挂载数据: 无 ) 
│   │   │   │   ├── 指针 --> ( 难度等级: [0.0747, 0.0748) || 挂载数据: 无 ) 
│   │   │   │   ├── new函数 --> ( 难度等级: [0.0748, 0.0748) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 变量的生命周期 --> ( 难度等级: [0.0748, 0.0749) || 挂载数据: 无 ) 
│   │   │   ├── 赋值 --> ( 难度等级: [0.0749, 0.0751) || 挂载数据: 无 ) 
│   │   │   │   ├── 多重赋值 --> ( 难度等级: [0.0749, 0.075) || 挂载数据: 无 ) 
│   │   │   │   └── 可赋值性 --> ( 难度等级: [0.075, 0.0751) || 挂载数据: 无 ) 
│   │   │   ├── 类型声明 --> ( 难度等级: [0.0751, 0.0753) || 挂载数据: 无 ) 
│   │   │   ├── 包和文件 --> ( 难度等级: [0.0753, 0.0755) || 挂载数据: 无 ) 
│   │   │   │   ├── 导入 --> ( 难度等级: [0.0753, 0.0754) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 远程导入 --> ( 难度等级: [0.0753, 0.0754) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── 命名导入 --> ( 难度等级: [0.0754, 0.0754) || 挂载数据: 无 ) 
│   │   │   │   └── 包初始化 --> ( 难度等级: [0.0754, 0.0755) || 挂载数据: 无 ) 
│   │   │   └── 作用域 --> ( 难度等级: [0.0755, 0.0757) || 挂载数据: 无 ) 
│   │   ├── 基本数据 --> ( 难度等级: [0.0757, 0.0771) || 挂载数据: 无 ) 
│   │   │   ├── 整数 --> ( 难度等级: [0.0757, 0.076) || 挂载数据: 无 ) 
│   │   │   ├── 浮点数 --> ( 难度等级: [0.076, 0.0762) || 挂载数据: 无 ) 
│   │   │   ├── 复数 --> ( 难度等级: [0.0762, 0.0764) || 挂载数据: 无 ) 
│   │   │   ├── 布尔值 --> ( 难度等级: [0.0764, 0.0767) || 挂载数据: 无 ) 
│   │   │   ├── 字符串 --> ( 难度等级: [0.0767, 0.0769) || 挂载数据: 无 ) 
│   │   │   │   ├── 字符串字面量 --> ( 难度等级: [0.0767, 0.0767) || 挂载数据: 无 ) 
│   │   │   │   ├── Unicode --> ( 难度等级: [0.0767, 0.0768) || 挂载数据: 无 ) 
│   │   │   │   ├── UTF-8 --> ( 难度等级: [0.0768, 0.0768) || 挂载数据: 无 ) 
│   │   │   │   ├── 字符串和字节slice --> ( 难度等级: [0.0768, 0.0769) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 字符串和数字的相互转换 --> ( 难度等级: [0.0769, 0.0769) || 挂载数据: 无 ) 
│   │   │   └── 常量 --> ( 难度等级: [0.0769, 0.0771) || 挂载数据: 无 ) 
│   │   │       ├── 常量生成器iota --> ( 难度等级: [0.0769, 0.077) || 挂载数据: 无 ) 
│   │   │       └── 无类型常量 --> ( 难度等级: [0.077, 0.0771) || 挂载数据: 无 ) 
│   │   ├── 复合数据类型 --> ( 难度等级: [0.0771, 0.0786) || 挂载数据: 无 ) 
│   │   │   ├── 数组 --> ( 难度等级: [0.0771, 0.0774) || 挂载数据: 无 ) 
│   │   │   ├── slice --> ( 难度等级: [0.0774, 0.0776) || 挂载数据: 无 ) 
│   │   │   │   ├── append函数 --> ( 难度等级: [0.0774, 0.0775) || 挂载数据: 无 ) 
│   │   │   │   └── slice就地修改 --> ( 难度等级: [0.0775, 0.0776) || 挂载数据: 无 ) 
│   │   │   ├── map --> ( 难度等级: [0.0776, 0.0779) || 挂载数据: blog: 7 ) 
│   │   │   ├── 结构体 --> ( 难度等级: [0.0779, 0.0781) || 挂载数据: 无 ) 
│   │   │   │   ├── 结构体字面量 --> ( 难度等级: [0.0779, 0.0779) || 挂载数据: 无 ) 
│   │   │   │   ├── 结构体比较 --> ( 难度等级: [0.0779, 0.078) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 结构体嵌套和匿名成员 --> ( 难度等级: [0.078, 0.0781) || 挂载数据: 无 ) 
│   │   │   ├── JSON --> ( 难度等级: [0.0781, 0.0783) || 挂载数据: 无 ) 
│   │   │   └── 文本和HTML模板 --> ( 难度等级: [0.0783, 0.0786) || 挂载数据: 无 ) 
│   │   ├── 函数 --> ( 难度等级: [0.0786, 0.08) || 挂载数据: 无 ) 
│   │   │   ├── 函数声明 --> ( 难度等级: [0.0786, 0.0786) || 挂载数据: 无 ) 
│   │   │   ├── 递归 --> ( 难度等级: [0.0786, 0.0787) || 挂载数据: 无 ) 
│   │   │   ├── 多返回值 --> ( 难度等级: [0.0787, 0.0788) || 挂载数据: 无 ) 
│   │   │   ├── 错误 --> ( 难度等级: [0.0788, 0.0788) || 挂载数据: 无 ) 
│   │   │   │   ├── 错误处理策略 --> ( 难度等级: [0.0788, 0.0788) || 挂载数据: 无 ) 
│   │   │   │   └── 文件结束标识 --> ( 难度等级: [0.0788, 0.0788) || 挂载数据: 无 ) 
│   │   │   ├── 函数变量 --> ( 难度等级: [0.0788, 0.0789) || 挂载数据: 无 ) 
│   │   │   ├── 匿名函数 --> ( 难度等级: [0.0789, 0.079) || 挂载数据: 无 ) 
│   │   │   ├── 变长函数 --> ( 难度等级: [0.079, 0.079) || 挂载数据: 无 ) 
│   │   │   ├── 延迟函数调用 --> ( 难度等级: [0.079, 0.0791) || 挂载数据: 无 ) 
│   │   │   ├── 宕机 --> ( 难度等级: [0.0791, 0.0792) || 挂载数据: 无 ) 
│   │   │   ├── 恢复 --> ( 难度等级: [0.0792, 0.0793) || 挂载数据: 无 ) 
│   │   │   ├── 基本语法 --> ( 难度等级: [0.0793, 0.0793) || 挂载数据: 无 ) 
│   │   │   ├── 参数和返回值的内存布局 --> ( 难度等级: [0.0793, 0.0794) || 挂载数据: 无 ) 
│   │   │   ├── 函数中的局部变量 --> ( 难度等级: [0.0794, 0.0795) || 挂载数据: 无 ) 
│   │   │   ├── 调用其他函数 --> ( 难度等级: [0.0795, 0.0795) || 挂载数据: blog: 1 ) 
│   │   │   ├── 宏函数 --> ( 难度等级: [0.0795, 0.0796) || 挂载数据: 无 ) 
│   │   │   ├── 函数调用规范 --> ( 难度等级: [0.0796, 0.0797) || 挂载数据: 无 ) 
│   │   │   ├── 高级汇编语言 --> ( 难度等级: [0.0797, 0.0797) || 挂载数据: 无 ) 
│   │   │   ├── PCDATA和FUNCDATA --> ( 难度等级: [0.0797, 0.0798) || 挂载数据: 无 ) 
│   │   │   ├── 方法函数 --> ( 难度等级: [0.0798, 0.0799) || 挂载数据: 无 ) 
│   │   │   ├── 递归函数： 1到n求和 --> ( 难度等级: [0.0799, 0.0799) || 挂载数据: 无 ) 
│   │   │   └── 闭包函数 --> ( 难度等级: [0.0799, 0.08) || 挂载数据: 无 ) 
│   │   ├── 方法 --> ( 难度等级: [0.08, 0.0814) || 挂载数据: 无 ) 
│   │   │   ├── 方法声明 --> ( 难度等级: [0.08, 0.0802) || 挂载数据: 无 ) 
│   │   │   ├── 指针接收者的方法 --> ( 难度等级: [0.0802, 0.0805) || 挂载数据: 无 ) 
│   │   │   ├── 通过结构体内嵌组成类型 --> ( 难度等级: [0.0805, 0.0807) || 挂载数据: 无 ) 
│   │   │   ├── 方法变量与表达式 --> ( 难度等级: [0.0807, 0.081) || 挂载数据: blog: 1 ) 
│   │   │   ├── 示例：位向量 --> ( 难度等级: [0.081, 0.0812) || 挂载数据: 无 ) 
│   │   │   └── 封装 --> ( 难度等级: [0.0812, 0.0814) || 挂载数据: 无 ) 
│   │   ├── 接口 --> ( 难度等级: [0.0814, 0.0829) || 挂载数据: 无 ) 
│   │   │   ├── 接口即约定 --> ( 难度等级: [0.0814, 0.0815) || 挂载数据: 无 ) 
│   │   │   ├── 接口类型 --> ( 难度等级: [0.0815, 0.0816) || 挂载数据: 无 ) 
│   │   │   ├── 实现接口 --> ( 难度等级: [0.0816, 0.0817) || 挂载数据: 无 ) 
│   │   │   ├── 使用flag.Value来解析参数 --> ( 难度等级: [0.0817, 0.0818) || 挂载数据: 无 ) 
│   │   │   ├── 接口值 --> ( 难度等级: [0.0818, 0.0818) || 挂载数据: 无 ) 
│   │   │   ├── 使用sort.Interface来排序 --> ( 难度等级: [0.0818, 0.0819) || 挂载数据: blog: 2 ) 
│   │   │   ├── http.Handler接口 --> ( 难度等级: [0.0819, 0.082) || 挂载数据: 无 ) 
│   │   │   ├── error接口 --> ( 难度等级: [0.082, 0.0821) || 挂载数据: blog: 2 ) 
│   │   │   ├── 类型断言 --> ( 难度等级: [0.0821, 0.0822) || 挂载数据: 无 ) 
│   │   │   ├── 使用类型断言来识别错误 --> ( 难度等级: [0.0822, 0.0823) || 挂载数据: 无 ) 
│   │   │   ├── 通过接口类型断言来查询特性 --> ( 难度等级: [0.0823, 0.0824) || 挂载数据: 无 ) 
│   │   │   ├── 类型分支 --> ( 难度等级: [0.0824, 0.0824) || 挂载数据: 无 ) 
│   │   │   ├── 一些建议 --> ( 难度等级: [0.0824, 0.0825) || 挂载数据: 无 ) 
│   │   │   ├── 标准库 --> ( 难度等级: [0.0825, 0.0826) || 挂载数据: 无 ) 
│   │   │   │   ├── 文档与源代码 --> ( 难度等级: [0.0825, 0.0825) || 挂载数据: 无 ) 
│   │   │   │   ├── 记录日志 --> ( 难度等级: [0.0825, 0.0826) || 挂载数据: 无 ) 
│   │   │   │   │   ├── log包 --> ( 难度等级: [0.0825, 0.0825) || 挂载数据: blog: 3 ) 
│   │   │   │   │   ├── 定制的日志记录器 --> ( 难度等级: [0.0825, 0.0826) || 挂载数据: blog: 2 ) 
│   │   │   │   │   └── 结论 --> ( 难度等级: [0.0826, 0.0826) || 挂载数据: 无 ) 
│   │   │   │   ├── 编码解码 --> ( 难度等级: [0.0826, 0.0826) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 解码JSON --> ( 难度等级: [0.0826, 0.0826) || 挂载数据: 无 ) 
│   │   │   │   │   └── 编码JSON --> ( 难度等级: [0.0826, 0.0826) || 挂载数据: blog: 2 ) 
│   │   │   │   └── 输入和输出 --> ( 难度等级: [0.0826, 0.0826) || 挂载数据: 无 ) 
│   │   │   │       ├── Writer和Reader接口 --> ( 难度等级: [0.0826, 0.0826) || 挂载数据: 无 ) 
│   │   │   │       ├── 整合并完成工作 --> ( 难度等级: [0.0826, 0.0826) || 挂载数据: blog: 2 ) 
│   │   │   │       └── 简单的curl --> ( 难度等级: [0.0826, 0.0826) || 挂载数据: 无 ) 
│   │   │   ├── 实现 --> ( 难度等级: [0.0826, 0.0827) || 挂载数据: 无 ) 
│   │   │   ├── 方法集 --> ( 难度等级: [0.0827, 0.0828) || 挂载数据: 无 ) 
│   │   │   └── 多态 --> ( 难度等级: [0.0828, 0.0829) || 挂载数据: 无 ) 
│   │   ├── goroutine和通道 --> ( 难度等级: [0.0829, 0.0843) || 挂载数据: 无 ) 
│   │   │   ├── goroutine --> ( 难度等级: [0.0829, 0.0831) || 挂载数据: blog: 1 ) 
│   │   │   ├── 通道 --> ( 难度等级: [0.0831, 0.0834) || 挂载数据: 无 ) 
│   │   │   │   ├── 无缓冲通道 --> ( 难度等级: [0.0831, 0.0832) || 挂载数据: 无 ) 
│   │   │   │   ├── 管道 --> ( 难度等级: [0.0832, 0.0833) || 挂载数据: 无 ) 
│   │   │   │   ├── 单向通道类型 --> ( 难度等级: [0.0833, 0.0834) || 挂载数据: 无 ) 
│   │   │   │   └── 缓冲通道 --> ( 难度等级: [0.0834, 0.0834) || 挂载数据: 无 ) 
│   │   │   ├── 并行循环 --> ( 难度等级: [0.0834, 0.0837) || 挂载数据: 无 ) 
│   │   │   ├── 使用select多路复用 --> ( 难度等级: [0.0837, 0.084) || 挂载数据: 无 ) 
│   │   │   └── 取消 --> ( 难度等级: [0.084, 0.0843) || 挂载数据: 无 ) 
│   │   ├── 使用共享变量实现并发 --> ( 难度等级: [0.0843, 0.0857) || 挂载数据: 无 ) 
│   │   │   ├── 竞态 --> ( 难度等级: [0.0843, 0.0845) || 挂载数据: 无 ) 
│   │   │   ├── 互斥锁：sync.Mutex --> ( 难度等级: [0.0845, 0.0848) || 挂载数据: 无 ) 
│   │   │   ├── 读写互斥锁：sync.RWMutex --> ( 难度等级: [0.0848, 0.085) || 挂载数据: 无 ) 
│   │   │   ├── 内存同步 --> ( 难度等级: [0.085, 0.0852) || 挂载数据: 无 ) 
│   │   │   ├── 延迟初始化：sync.Once --> ( 难度等级: [0.0852, 0.0855) || 挂载数据: 无 ) 
│   │   │   └── 竞态检测器 --> ( 难度等级: [0.0855, 0.0857) || 挂载数据: 无 ) 
│   │   ├── 包和go工具 --> ( 难度等级: [0.0857, 0.0871) || 挂载数据: 无 ) 
│   │   │   ├── 引言 --> ( 难度等级: [0.0857, 0.0859) || 挂载数据: 无 ) 
│   │   │   ├── 导入路径 --> ( 难度等级: [0.0859, 0.0861) || 挂载数据: 无 ) 
│   │   │   ├── 包的声明 --> ( 难度等级: [0.0861, 0.0863) || 挂载数据: 无 ) 
│   │   │   ├── 导入声明 --> ( 难度等级: [0.0863, 0.0865) || 挂载数据: 无 ) 
│   │   │   ├── 空导入 --> ( 难度等级: [0.0865, 0.0867) || 挂载数据: 无 ) 
│   │   │   ├── 包及其命名 --> ( 难度等级: [0.0867, 0.0869) || 挂载数据: 无 ) 
│   │   │   └── go工具 --> ( 难度等级: [0.0869, 0.0871) || 挂载数据: 无 ) 
│   │   │       ├── 工作空间的组织 --> ( 难度等级: [0.0869, 0.087) || 挂载数据: 无 ) 
│   │   │       ├── 包的下载 --> ( 难度等级: [0.087, 0.087) || 挂载数据: 无 ) 
│   │   │       ├── 包的构建 --> ( 难度等级: [0.087, 0.087) || 挂载数据: 无 ) 
│   │   │       ├── 包的文档化 --> ( 难度等级: [0.087, 0.0871) || 挂载数据: 无 ) 
│   │   │       ├── 内部包 --> ( 难度等级: [0.0871, 0.0871) || 挂载数据: 无 ) 
│   │   │       └── 包的查询 --> ( 难度等级: [0.0871, 0.0871) || 挂载数据: 无 ) 
│   │   ├── 测试 --> ( 难度等级: [0.0871, 0.0886) || 挂载数据: 无 ) 
│   │   │   ├── go test工具 --> ( 难度等级: [0.0871, 0.0874) || 挂载数据: 无 ) 
│   │   │   ├── Test函数 --> ( 难度等级: [0.0874, 0.0876) || 挂载数据: 无 ) 
│   │   │   │   ├── 随机测试 --> ( 难度等级: [0.0874, 0.0874) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试命令 --> ( 难度等级: [0.0874, 0.0875) || 挂载数据: 无 ) 
│   │   │   │   ├── 白盒测试 --> ( 难度等级: [0.0875, 0.0875) || 挂载数据: 无 ) 
│   │   │   │   ├── 外部测试包 --> ( 难度等级: [0.0875, 0.0875) || 挂载数据: 无 ) 
│   │   │   │   ├── 编写有效测试 --> ( 难度等级: [0.0875, 0.0876) || 挂载数据: 无 ) 
│   │   │   │   └── 避免脆弱的测试 --> ( 难度等级: [0.0876, 0.0876) || 挂载数据: 无 ) 
│   │   │   ├── 覆盖率 --> ( 难度等级: [0.0876, 0.0879) || 挂载数据: 无 ) 
│   │   │   ├── Benchmark函数 --> ( 难度等级: [0.0879, 0.0881) || 挂载数据: 无 ) 
│   │   │   ├── 性能剖析 --> ( 难度等级: [0.0881, 0.0883) || 挂载数据: 无 ) 
│   │   │   └── Example函数 --> ( 难度等级: [0.0883, 0.0886) || 挂载数据: 无 ) 
│   │   ├── 反射 --> ( 难度等级: [0.0886, 0.09) || 挂载数据: blog: 1 ) 
│   │   │   ├── reflect.Type和reflect.Value --> ( 难度等级: [0.0886, 0.0888) || 挂载数据: 无 ) 
│   │   │   ├── Display：一个递归的值显示器 --> ( 难度等级: [0.0888, 0.089) || 挂载数据: 无 ) 
│   │   │   ├── 使用reflect.Value来设置值 --> ( 难度等级: [0.089, 0.0893) || 挂载数据: blog: 1 ) 
│   │   │   ├── 访问结构体字段标签 --> ( 难度等级: [0.0893, 0.0895) || 挂载数据: 无 ) 
│   │   │   ├── 显示类型的方法 --> ( 难度等级: [0.0895, 0.0898) || 挂载数据: 无 ) 
│   │   │   └── 注意事项 --> ( 难度等级: [0.0898, 0.09) || 挂载数据: 无 ) 
│   │   ├── 低级编程 --> ( 难度等级: [0.09, 0.0914) || 挂载数据: 无 ) 
│   │   │   ├── unsafe.Sizeof、Alignof和Offsetof --> ( 难度等级: [0.09, 0.0905) || 挂载数据: 无 ) 
│   │   │   ├── unsafe.Pointer --> ( 难度等级: [0.0905, 0.091) || 挂载数据: 无 ) 
│   │   │   └── 使用cgo调用C代码 --> ( 难度等级: [0.091, 0.0914) || 挂载数据: 无 ) 
│   │   ├── 关于Go语言的介绍 --> ( 难度等级: [0.0914, 0.0929) || 挂载数据: 无 ) 
│   │   │   ├── 用Go解决现代编程难题 --> ( 难度等级: [0.0914, 0.0921) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发速度 --> ( 难度等级: [0.0914, 0.0916) || 挂载数据: 无 ) 
│   │   │   │   ├── 并发 --> ( 难度等级: [0.0916, 0.0918) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 竞争状态 --> ( 难度等级: [0.0916, 0.0917) || 挂载数据: 无 ) 
│   │   │   │   │   └── 锁住共享资源 --> ( 难度等级: [0.0917, 0.0918) || 挂载数据: 无 ) 
│   │   │   │   │       └── 原子函数 --> ( 难度等级: [0.0917, 0.0918) || 挂载数据: 无 ) 
│   │   │   │   ├── Go语言的类型系统 --> ( 难度等级: [0.0918, 0.092) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 用户定义的类型 --> ( 难度等级: [0.0918, 0.0918) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 类型的本质 --> ( 难度等级: [0.0918, 0.0919) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 内置类型 --> ( 难度等级: [0.0918, 0.0918) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 引用类型 --> ( 难度等级: [0.0918, 0.0919) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   └── 结构类型 --> ( 难度等级: [0.0919, 0.0919) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 嵌入类型 --> ( 难度等级: [0.0919, 0.0919) || 挂载数据: 无 ) 
│   │   │   │   │   └── 公开或未公开的标识符 --> ( 难度等级: [0.0919, 0.092) || 挂载数据: 无 ) 
│   │   │   │   └── 内存管理 --> ( 难度等级: [0.092, 0.0921) || 挂载数据: 无 ) 
│   │   │   └── 你好，Go --> ( 难度等级: [0.0921, 0.0929) || 挂载数据: 无 ) 
│   │   ├── 快速开始一个Go程序 --> ( 难度等级: [0.0929, 0.0943) || 挂载数据: 无 ) 
│   │   │   ├── 程序架构 --> ( 难度等级: [0.0929, 0.0932) || 挂载数据: 无 ) 
│   │   │   ├── main包 --> ( 难度等级: [0.0932, 0.0936) || 挂载数据: 无 ) 
│   │   │   ├── search包 --> ( 难度等级: [0.0936, 0.0939) || 挂载数据: 无 ) 
│   │   │   │   ├── search.go --> ( 难度等级: [0.0936, 0.0937) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── feed.go --> ( 难度等级: [0.0937, 0.0938) || 挂载数据: 无 ) 
│   │   │   │   └── match.go default.go --> ( 难度等级: [0.0938, 0.0939) || 挂载数据: 无 ) 
│   │   │   └── RSS匹配器 --> ( 难度等级: [0.0939, 0.0943) || 挂载数据: 无 ) 
│   │   ├── 打包和工具链 --> ( 难度等级: [0.0943, 0.0957) || 挂载数据: 无 ) 
│   │   │   ├── 包 --> ( 难度等级: [0.0943, 0.0946) || 挂载数据: 无 ) 
│   │   │   │   └── 包名惯例 --> ( 难度等级: [0.0943, 0.0946) || 挂载数据: 无 ) 
│   │   │   ├── 函数init --> ( 难度等级: [0.0946, 0.0949) || 挂载数据: 无 ) 
│   │   │   ├── 进一步介绍Go开发工具 --> ( 难度等级: [0.0949, 0.0951) || 挂载数据: 无 ) 
│   │   │   │   ├── go vet --> ( 难度等级: [0.0949, 0.095) || 挂载数据: 无 ) 
│   │   │   │   ├── Go代码格式化 --> ( 难度等级: [0.095, 0.095) || 挂载数据: 无 ) 
│   │   │   │   └── Go语言的文档 --> ( 难度等级: [0.095, 0.0951) || 挂载数据: blog: 1 ) 
│   │   │   ├── 与其他Go开发者合作 --> ( 难度等级: [0.0951, 0.0954) || 挂载数据: 无 ) 
│   │   │   └── 依赖管理 --> ( 难度等级: [0.0954, 0.0957) || 挂载数据: 无 ) 
│   │   │       ├── 第三方依赖 --> ( 难度等级: [0.0954, 0.0956) || 挂载数据: 无 ) 
│   │   │       └── 对gb的介绍 --> ( 难度等级: [0.0956, 0.0957) || 挂载数据: 无 ) 
│   │   ├── 并发模式 --> ( 难度等级: [0.0957, 0.0971) || 挂载数据: 无 ) 
│   │   │   ├── runner --> ( 难度等级: [0.0957, 0.0962) || 挂载数据: 无 ) 
│   │   │   ├── pool --> ( 难度等级: [0.0962, 0.0967) || 挂载数据: 无 ) 
│   │   │   └── work --> ( 难度等级: [0.0967, 0.0971) || 挂载数据: 无 ) 
│   │   ├── 测试和性能 --> ( 难度等级: [0.0971, 0.0986) || 挂载数据: 无 ) 
│   │   │   ├── 单元测试 --> ( 难度等级: [0.0971, 0.0979) || 挂载数据: 无 ) 
│   │   │   │   ├── 基础单元测试 --> ( 难度等级: [0.0971, 0.0973) || 挂载数据: 无 ) 
│   │   │   │   ├── 表组测试 --> ( 难度等级: [0.0973, 0.0975) || 挂载数据: 无 ) 
│   │   │   │   ├── 模仿调用 --> ( 难度等级: [0.0975, 0.0977) || 挂载数据: 无 ) 
│   │   │   │   └── 测试服务端点 --> ( 难度等级: [0.0977, 0.0979) || 挂载数据: 无 ) 
│   │   │   └── 基准测试 --> ( 难度等级: [0.0979, 0.0986) || 挂载数据: 无 ) 
│   │   ├── Go与Web应用 --> ( 难度等级: [0.0986, 0.1) || 挂载数据: 无 ) 
│   │   │   ├── Go与Web应用 --> ( 难度等级: [0.0986, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用Go语言构建Web应用 --> ( 难度等级: [0.0986, 0.0986) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Go与可扩展Web应用 --> ( 难度等级: [0.0986, 0.0986) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── Go与模块化Web应用 --> ( 难度等级: [0.0986, 0.0986) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Go与可维护的Web应用 --> ( 难度等级: [0.0986, 0.0986) || 挂载数据: 无 ) 
│   │   │   │   │   └── Go与高性能Web应用 --> ( 难度等级: [0.0986, 0.0986) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Web应用的工作原理 --> ( 难度等级: [0.0986, 0.0986) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP简介 --> ( 难度等级: [0.0986, 0.0986) || 挂载数据: 无 ) 
│   │   │   │   ├── Web应用的诞生 --> ( 难度等级: [0.0986, 0.0986) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP请求 --> ( 难度等级: [0.0986, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 幂等的请求方法 --> ( 难度等级: [0.0986, 0.0986) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 浏览器对请求方法的支持 --> ( 难度等级: [0.0986, 0.0986) || 挂载数据: 无 ) 
│   │   │   │   │   └── 请求首部 --> ( 难度等级: [0.0986, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP响应 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 响应状态码 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   └── 响应首部 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   ├── URI --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── HTTP/2简介 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   ├── Web应用的各个组成部分 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 处理器 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 模板引擎 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 处理请求 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── ResponseWriter --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── cookie --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   │       ├── 将cookie发送至浏览器 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   │       ├── 从浏览器里面获取cookie --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: blog: 6 ) 
│   │   │   │   │   │       └── 使用cookie实现闪现消息 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 内容展示 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Go的模板引擎 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 对模板进行语法分析 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   │   └── 执行模板 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 动作 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 条件动作 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 迭代动作 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 设置动作 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   └── 包含动作 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 上下文感知 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 防御XSS攻击 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   │   └── 不对HTML进行转义 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: blog: 5 ) 
│   │   │   │   │   │   ├── 嵌套模板 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 通过块动作定义默认模板 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │   └── 存储数据 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 内存存储 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │       └── 文件存储 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   │           ├── 读取和写入CSV文件 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: blog: 6 ) 
│   │   │   │   │           └── gob包 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   └── Hello Go --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   ├── ChitChat论坛 --> ( 难度等级: [0.0987, 0.0989) || 挂载数据: 无 ) 
│   │   │   │   ├── ChitChat简介 --> ( 难度等级: [0.0987, 0.0987) || 挂载数据: 无 ) 
│   │   │   │   ├── 应用设计 --> ( 难度等级: [0.0987, 0.0988) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据模型 --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: 无 ) 
│   │   │   │   ├── 请求的接收与处理 --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 多路复用器 --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 服务静态文件 --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 创建处理器函数 --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 使用cookie进行访问控制 --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Go的net/http标准库 --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── 使用Go构建服务器 --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: 无 ) 
│   │   │   │   │       ├── Go Web服务器 --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: 无 ) 
│   │   │   │   │       └── 通过HTTPS提供服务 --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── 使用模板生成HTML响应 --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 安装PostgreSQL --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 在Linux或FreeBSD系统上安装 --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在Mac OS X系统上安装 --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: blog: 8 ) 
│   │   │   │   │   └── 在Windows系统上安装 --> ( 难度等级: [0.0988, 0.0988) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 连接数据库 --> ( 难度等级: [0.0988, 0.0989) || 挂载数据: 无 ) 
│   │   │   │   ├── 启动服务器 --> ( 难度等级: [0.0989, 0.0989) || 挂载数据: 无 ) 
│   │   │   │   └── Web应用运作流程回顾 --> ( 难度等级: [0.0989, 0.0989) || 挂载数据: 无 ) 
│   │   │   ├── Web开发简介 --> ( 难度等级: [0.0989, 0.099) || 挂载数据: 无 ) 
│   │   │   ├── 请求路由 --> ( 难度等级: [0.099, 0.0992) || 挂载数据: 无 ) 
│   │   │   │   ├── httprouter --> ( 难度等级: [0.099, 0.0991) || 挂载数据: 无 ) 
│   │   │   │   ├── 原理 --> ( 难度等级: [0.0991, 0.0992) || 挂载数据: 无 ) 
│   │   │   │   └── 压缩检索树创建过程 --> ( 难度等级: [0.0992, 0.0992) || 挂载数据: 无 ) 
│   │   │   ├── 中间件 --> ( 难度等级: [0.0992, 0.0994) || 挂载数据: 无 ) 
│   │   │   │   ├── 代码泥潭 --> ( 难度等级: [0.0992, 0.0992) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用中间件剥离非业务逻辑 --> ( 难度等级: [0.0992, 0.0993) || 挂载数据: 无 ) 
│   │   │   │   ├── 更优雅的中间件写法 --> ( 难度等级: [0.0993, 0.0993) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 哪些事情适合在中间件中做 --> ( 难度等级: [0.0993, 0.0994) || 挂载数据: 无 ) 
│   │   │   ├── 请求校验 --> ( 难度等级: [0.0994, 0.0995) || 挂载数据: 无 ) 
│   │   │   │   ├── 重构请求校验函数 --> ( 难度等级: [0.0994, 0.0994) || 挂载数据: 无 ) 
│   │   │   │   └── 用请求校验器解放体力劳动 --> ( 难度等级: [0.0994, 0.0995) || 挂载数据: 无 ) 
│   │   │   ├── Database和数据库打交道 --> ( 难度等级: [0.0995, 0.0997) || 挂载数据: 无 ) 
│   │   │   │   ├── 从database/sql讲起 --> ( 难度等级: [0.0995, 0.0996) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── 提高生产效率的ORM和 --> ( 难度等级: [0.0996, 0.0996) || 挂载数据: 无 ) 
│   │   │   │   └── 脆弱的数据库 --> ( 难度等级: [0.0996, 0.0997) || 挂载数据: blog: 4 ) 
│   │   │   ├── 服务流量限制 --> ( 难度等级: [0.0997, 0.0998) || 挂载数据: 无 ) 
│   │   │   │   ├── 常见的流量限制手段 --> ( 难度等级: [0.0997, 0.0998) || 挂载数据: 无 ) 
│   │   │   │   └── 服务瓶颈和QoS --> ( 难度等级: [0.0998, 0.0998) || 挂载数据: 无 ) 
│   │   │   └── 灰度发布和A/B测试 --> ( 难度等级: [0.0998, 0.1) || 挂载数据: 无 ) 
│   │   │       ├── 通过分批次部署实现灰度发布 --> ( 难度等级: [0.0998, 0.0999) || 挂载数据: 无 ) 
│   │   │       ├── 通过业务规则进行灰度发布 --> ( 难度等级: [0.0999, 0.0999) || 挂载数据: 无 ) 
│   │   │       └── 如何实现一套灰度发布系统 --> ( 难度等级: [0.0999, 0.1) || 挂载数据: 无 ) 
│   │   ├── 语言基础 --> ( 难度等级: [0.1, 0.1014) || 挂载数据: 无 ) 
│   │   │   ├── Go语言创世纪 --> ( 难度等级: [0.1, 0.1002) || 挂载数据: 无 ) 
│   │   │   │   ├── 来自贝尔实验室特有基因 --> ( 难度等级: [0.1, 0.1001) || 挂载数据: 无 ) 
│   │   │   │   └── 你好，世界 --> ( 难度等级: [0.1001, 0.1002) || 挂载数据: 无 ) 
│   │   │   ├── “Hello， World”的革命 --> ( 难度等级: [0.1002, 0.1005) || 挂载数据: 无 ) 
│   │   │   │   ├── B语言——Ken Thompson， --> ( 难度等级: [0.1002, 0.1003) || 挂载数据: 无 ) 
│   │   │   │   ├── C语言——Dennis Ritchie，1972— --> ( 难度等级: [0.1003, 0.1003) || 挂载数据: 无 ) 
│   │   │   │   ├── Newsqueak——Rob Pike， --> ( 难度等级: [0.1003, 0.1003) || 挂载数据: 无 ) 
│   │   │   │   ├── Alef——Phil Winterbottom， --> ( 难度等级: [0.1003, 0.1004) || 挂载数据: 无 ) 
│   │   │   │   ├── Limbo——Sean Dorward， Phil Winterbottom， Rob Pike， --> ( 难度等级: [0.1004, 0.1004) || 挂载数据: 无 ) 
│   │   │   │   ├── Go语言——2007— --> ( 难度等级: [0.1004, 0.1004) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 你好，世界!——V2. --> ( 难度等级: [0.1004, 0.1005) || 挂载数据: 无 ) 
│   │   │   ├── 面向并发的内存模型 --> ( 难度等级: [0.1005, 0.1007) || 挂载数据: 无 ) 
│   │   │   │   ├── 原子操作 --> ( 难度等级: [0.1005, 0.1005) || 挂载数据: 无 ) 
│   │   │   │   ├── 顺序一致性内存模型 --> ( 难度等级: [0.1005, 0.1006) || 挂载数据: 无 ) 
│   │   │   │   ├── 初始化顺序 --> ( 难度等级: [0.1006, 0.1006) || 挂载数据: 无 ) 
│   │   │   │   ├── Goroutine的创建 --> ( 难度等级: [0.1006, 0.1006) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于通道的通信 --> ( 难度等级: [0.1006, 0.1007) || 挂载数据: 无 ) 
│   │   │   │   └── 不靠谱的同步 --> ( 难度等级: [0.1007, 0.1007) || 挂载数据: 无 ) 
│   │   │   ├── 常见的并发模式 --> ( 难度等级: [0.1007, 0.101) || 挂载数据: 无 ) 
│   │   │   │   ├── 并发版本的“Hello， World” --> ( 难度等级: [0.1007, 0.1007) || 挂载数据: 无 ) 
│   │   │   │   ├── 生产者/消费者模型 --> ( 难度等级: [0.1007, 0.1008) || 挂载数据: 无 ) 
│   │   │   │   ├── 发布/订阅模型 --> ( 难度等级: [0.1008, 0.1008) || 挂载数据: 无 ) 
│   │   │   │   ├── 控制并发数 --> ( 难度等级: [0.1008, 0.1008) || 挂载数据: 无 ) 
│   │   │   │   ├── 赢者为王 --> ( 难度等级: [0.1008, 0.1009) || 挂载数据: 无 ) 
│   │   │   │   ├── 素数筛 --> ( 难度等级: [0.1009, 0.1009) || 挂载数据: 无 ) 
│   │   │   │   ├── 并发的安全退出 --> ( 难度等级: [0.1009, 0.1009) || 挂载数据: 无 ) 
│   │   │   │   └── context包 --> ( 难度等级: [0.1009, 0.101) || 挂载数据: 无 ) 
│   │   │   ├── 错误和异常 --> ( 难度等级: [0.101, 0.1012) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取错误的上下文 --> ( 难度等级: [0.101, 0.101) || 挂载数据: 无 ) 
│   │   │   │   ├── 错误的错误返回 --> ( 难度等级: [0.101, 0.1011) || 挂载数据: 无 ) 
│   │   │   │   └── 剖析异常 --> ( 难度等级: [0.1011, 0.1012) || 挂载数据: blog: 1 ) 
│   │   │   └── 补充说明 --> ( 难度等级: [0.1012, 0.1014) || 挂载数据: 无 ) 
│   │   ├── CGO编程 --> ( 难度等级: [0.1014, 0.1029) || 挂载数据: 无 ) 
│   │   │   ├── 快速入门 --> ( 难度等级: [0.1014, 0.1016) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 最简CGO程序 --> ( 难度等级: [0.1014, 0.1014) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于C标准库函数输出字符串 --> ( 难度等级: [0.1014, 0.1015) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用自己的C函数 --> ( 难度等级: [0.1015, 0.1015) || 挂载数据: 无 ) 
│   │   │   │   ├── C代码的模块化 --> ( 难度等级: [0.1015, 0.1015) || 挂载数据: 无 ) 
│   │   │   │   ├── 用Go重新实现C函数 --> ( 难度等级: [0.1015, 0.1015) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向C接口的Go编程 --> ( 难度等级: [0.1015, 0.1015) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义整数变量 --> ( 难度等级: [0.1015, 0.1015) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义字符串变量 --> ( 难度等级: [0.1015, 0.1015) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义main函数 --> ( 难度等级: [0.1015, 0.1016) || 挂载数据: 无 ) 
│   │   │   │   ├── 特殊字符 --> ( 难度等级: [0.1016, 0.1016) || 挂载数据: 无 ) 
│   │   │   │   └── 没有分号 --> ( 难度等级: [0.1016, 0.1016) || 挂载数据: 无 ) 
│   │   │   ├── CGO基础 --> ( 难度等级: [0.1016, 0.1017) || 挂载数据: 无 ) 
│   │   │   │   ├── import "C"语句 --> ( 难度等级: [0.1016, 0.1016) || 挂载数据: 无 ) 
│   │   │   │   ├── #cgo语句 --> ( 难度等级: [0.1016, 0.1017) || 挂载数据: 无 ) 
│   │   │   │   └── build标志条件编译 --> ( 难度等级: [0.1017, 0.1017) || 挂载数据: blog: 1 ) 
│   │   │   ├── 类型转换 --> ( 难度等级: [0.1017, 0.1019) || 挂载数据: 无 ) 
│   │   │   │   ├── 数值类型 --> ( 难度等级: [0.1017, 0.1018) || 挂载数据: 无 ) 
│   │   │   │   ├── Go字符串和切片 --> ( 难度等级: [0.1018, 0.1018) || 挂载数据: 无 ) 
│   │   │   │   ├── 指针间的转换 --> ( 难度等级: [0.1018, 0.1018) || 挂载数据: 无 ) 
│   │   │   │   ├── 数值和指针的转换 --> ( 难度等级: [0.1018, 0.1019) || 挂载数据: 无 ) 
│   │   │   │   └── 切片间的转换 --> ( 难度等级: [0.1019, 0.1019) || 挂载数据: 无 ) 
│   │   │   ├── 函数调用 --> ( 难度等级: [0.1019, 0.1021) || 挂载数据: 无 ) 
│   │   │   │   ├── Go调用C函数 --> ( 难度等级: [0.1019, 0.1019) || 挂载数据: 无 ) 
│   │   │   │   ├── C函数的返回值 --> ( 难度等级: [0.1019, 0.102) || 挂载数据: 无 ) 
│   │   │   │   ├── void函数的返回值 --> ( 难度等级: [0.102, 0.102) || 挂载数据: 无 ) 
│   │   │   │   └── C调用Go导出函数 --> ( 难度等级: [0.102, 0.1021) || 挂载数据: 无 ) 
│   │   │   ├── 内部机制 --> ( 难度等级: [0.1021, 0.1022) || 挂载数据: 无 ) 
│   │   │   │   ├── CGO生成的中间文件 --> ( 难度等级: [0.1021, 0.1021) || 挂载数据: 无 ) 
│   │   │   │   ├── Go调用C函数 --> ( 难度等级: [0.1021, 0.1022) || 挂载数据: 无 ) 
│   │   │   │   └── C调用Go函数 --> ( 难度等级: [0.1022, 0.1022) || 挂载数据: 无 ) 
│   │   │   ├── CGO内存模型 --> ( 难度等级: [0.1022, 0.1024) || 挂载数据: 无 ) 
│   │   │   │   ├── Go访问C内存 --> ( 难度等级: [0.1022, 0.1023) || 挂载数据: 无 ) 
│   │   │   │   ├── C临时访问传入的Go内存 --> ( 难度等级: [0.1023, 0.1023) || 挂载数据: 无 ) 
│   │   │   │   ├── C长期持有Go指针对象 --> ( 难度等级: [0.1023, 0.1023) || 挂载数据: 无 ) 
│   │   │   │   └── 导出C函数不能返回Go内存 --> ( 难度等级: [0.1023, 0.1024) || 挂载数据: 无 ) 
│   │   │   ├── C++类包装 --> ( 难度等级: [0.1024, 0.1025) || 挂载数据: 无 ) 
│   │   │   │   ├── C++类到Go语言对象 --> ( 难度等级: [0.1024, 0.1024) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Go语言对象到C++类 --> ( 难度等级: [0.1024, 0.1025) || 挂载数据: blog: 3 ) 
│   │   │   │   └── 彻底解放C++的this指针 --> ( 难度等级: [0.1025, 0.1025) || 挂载数据: blog: 2 ) 
│   │   │   ├── 静态库和动态库 --> ( 难度等级: [0.1025, 0.1027) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用C静态库 --> ( 难度等级: [0.1025, 0.1026) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用C动态库 --> ( 难度等级: [0.1026, 0.1026) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 导出C静态库 --> ( 难度等级: [0.1026, 0.1026) || 挂载数据: 无 ) 
│   │   │   │   ├── 导出C动态库 --> ( 难度等级: [0.1026, 0.1027) || 挂载数据: 无 ) 
│   │   │   │   └── 导出非main包的函数 --> ( 难度等级: [0.1027, 0.1027) || 挂载数据: 无 ) 
│   │   │   └── 编译和链接参数 --> ( 难度等级: [0.1027, 0.1029) || 挂载数据: 无 ) 
│   │   │       ├── 编译参数：CFLAGS/CPPFLAGS/CXXFLAGS --> ( 难度等级: [0.1027, 0.1027) || 挂载数据: 无 ) 
│   │   │       ├── 链接参数：LDFLAGS --> ( 难度等级: [0.1027, 0.1028) || 挂载数据: blog: 1 ) 
│   │   │       ├── pkg-config --> ( 难度等级: [0.1028, 0.1028) || 挂载数据: 无 ) 
│   │   │       ├── go get链 --> ( 难度等级: [0.1028, 0.1028) || 挂载数据: 无 ) 
│   │   │       └── 多个非main包中导出C函数 --> ( 难度等级: [0.1028, 0.1029) || 挂载数据: 无 ) 
│   │   ├── Go汇编语言 --> ( 难度等级: [0.1029, 0.1043) || 挂载数据: 无 ) 
│   │   │   ├── 计算机结构 --> ( 难度等级: [0.1029, 0.1031) || 挂载数据: 无 ) 
│   │   │   │   ├── 图灵机和BrainFuck语言 --> ( 难度等级: [0.1029, 0.1029) || 挂载数据: 无 ) 
│   │   │   │   ├── 《人力资源机器》游戏 --> ( 难度等级: [0.1029, 0.103) || 挂载数据: 无 ) 
│   │   │   │   ├── X86-64体系结构 --> ( 难度等级: [0.103, 0.103) || 挂载数据: 无 ) 
│   │   │   │   ├── Go汇编中的伪寄存器 --> ( 难度等级: [0.103, 0.1031) || 挂载数据: 无 ) 
│   │   │   │   └── X86-64指令集 --> ( 难度等级: [0.1031, 0.1031) || 挂载数据: 无 ) 
│   │   │   ├── 控制流 --> ( 难度等级: [0.1031, 0.1034) || 挂载数据: 无 ) 
│   │   │   │   ├── 顺序执行 --> ( 难度等级: [0.1031, 0.1032) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── if/goto跳转 --> ( 难度等级: [0.1032, 0.1033) || 挂载数据: blog: 10 ) 
│   │   │   │   └── for循环 --> ( 难度等级: [0.1033, 0.1034) || 挂载数据: 无 ) 
│   │   │   ├── 汇编语言的威力 --> ( 难度等级: [0.1034, 0.1037) || 挂载数据: 无 ) 
│   │   │   │   ├── 系统调用 --> ( 难度等级: [0.1034, 0.1035) || 挂载数据: 无 ) 
│   │   │   │   ├── 直接调用C函数 --> ( 难度等级: [0.1035, 0.1036) || 挂载数据: 无 ) 
│   │   │   │   └── AVX指令 --> ( 难度等级: [0.1036, 0.1037) || 挂载数据: 无 ) 
│   │   │   ├── 例子：Goroutine ID --> ( 难度等级: [0.1037, 0.104) || 挂载数据: 无 ) 
│   │   │   │   ├── 故意设计没有goid --> ( 难度等级: [0.1037, 0.1038) || 挂载数据: 无 ) 
│   │   │   │   ├── 纯Go方式获取goid --> ( 难度等级: [0.1038, 0.1038) || 挂载数据: 无 ) 
│   │   │   │   ├── 从g结构体获取goid --> ( 难度等级: [0.1038, 0.1039) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取g结构体对应的接口对象 --> ( 难度等级: [0.1039, 0.1039) || 挂载数据: 无 ) 
│   │   │   │   └── goid的应用：局部存储 --> ( 难度等级: [0.1039, 0.104) || 挂载数据: 无 ) 
│   │   │   └── Delve调试器 --> ( 难度等级: [0.104, 0.1043) || 挂载数据: 无 ) 
│   │   │       ├── Delve入门 --> ( 难度等级: [0.104, 0.1041) || 挂载数据: 无 ) 
│   │   │       └── 调试汇编程序 --> ( 难度等级: [0.1041, 0.1043) || 挂载数据: 无 ) 
│   │   ├── RPC和Protobuf --> ( 难度等级: [0.1043, 0.1057) || 挂载数据: 无 ) 
│   │   │   ├── RPC入门 --> ( 难度等级: [0.1043, 0.1045) || 挂载数据: 无 ) 
│   │   │   │   ├── RPC版“Hello， World” --> ( 难度等级: [0.1043, 0.1043) || 挂载数据: 无 ) 
│   │   │   │   ├── 更安全的RPC接口 --> ( 难度等级: [0.1043, 0.1044) || 挂载数据: 无 ) 
│   │   │   │   ├── 跨语言的RPC --> ( 难度等级: [0.1044, 0.1044) || 挂载数据: blog: 1 ) 
│   │   │   │   └── HTTP上的RPC --> ( 难度等级: [0.1044, 0.1045) || 挂载数据: blog: 10 ) 
│   │   │   ├── Protobuf --> ( 难度等级: [0.1045, 0.1046) || 挂载数据: 无 ) 
│   │   │   │   ├── Protobuf入门 --> ( 难度等级: [0.1045, 0.1045) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 定制代码生成插件 --> ( 难度等级: [0.1045, 0.1046) || 挂载数据: 无 ) 
│   │   │   │   └── 自动生成完整的RPC代码 --> ( 难度等级: [0.1046, 0.1046) || 挂载数据: 无 ) 
│   │   │   ├── 玩转RPC --> ( 难度等级: [0.1046, 0.1048) || 挂载数据: 无 ) 
│   │   │   │   ├── 客户端RPC的实现原理 --> ( 难度等级: [0.1046, 0.1047) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 基于RPC实现监视功能 --> ( 难度等级: [0.1047, 0.1047) || 挂载数据: 无 ) 
│   │   │   │   ├── 反向RPC --> ( 难度等级: [0.1047, 0.1048) || 挂载数据: 无 ) 
│   │   │   │   └── 上下文信息 --> ( 难度等级: [0.1048, 0.1048) || 挂载数据: 无 ) 
│   │   │   ├── gRPC入门 --> ( 难度等级: [0.1048, 0.105) || 挂载数据: 无 ) 
│   │   │   │   ├── gRPC技术栈 --> ( 难度等级: [0.1048, 0.1049) || 挂载数据: 无 ) 
│   │   │   │   ├── gRPC入门 --> ( 难度等级: [0.1049, 0.1049) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── gRPC流 --> ( 难度等级: [0.1049, 0.105) || 挂载数据: 无 ) 
│   │   │   │   └── 发布和订阅模式 --> ( 难度等级: [0.105, 0.105) || 挂载数据: 无 ) 
│   │   │   ├── gRPC进阶 --> ( 难度等级: [0.105, 0.1052) || 挂载数据: 无 ) 
│   │   │   │   ├── 证书认证 --> ( 难度等级: [0.105, 0.105) || 挂载数据: 无 ) 
│   │   │   │   ├── Token认证 --> ( 难度等级: [0.105, 0.1051) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── 截取器 --> ( 难度等级: [0.1051, 0.1051) || 挂载数据: 无 ) 
│   │   │   │   └── 和Web服务共存 --> ( 难度等级: [0.1051, 0.1052) || 挂载数据: 无 ) 
│   │   │   ├── gRPC和Protobuf扩展 --> ( 难度等级: [0.1052, 0.1054) || 挂载数据: 无 ) 
│   │   │   │   ├── 验证器 --> ( 难度等级: [0.1052, 0.1052) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── REST接口 --> ( 难度等级: [0.1052, 0.1053) || 挂载数据: 无 ) 
│   │   │   │   └── Nginx --> ( 难度等级: [0.1053, 0.1054) || 挂载数据: blog: 10 ) 
│   │   │   ├── pbgo：基于Protobuf的框架 --> ( 难度等级: [0.1054, 0.1055) || 挂载数据: 无 ) 
│   │   │   │   ├── Protobuf扩展语法 --> ( 难度等级: [0.1054, 0.1054) || 挂载数据: 无 ) 
│   │   │   │   ├── 插件中读取扩展信息 --> ( 难度等级: [0.1054, 0.1054) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成REST代码 --> ( 难度等级: [0.1054, 0.1055) || 挂载数据: 无 ) 
│   │   │   │   └── 启动REST服务 --> ( 难度等级: [0.1055, 0.1055) || 挂载数据: 无 ) 
│   │   │   └── grpcurl工具 --> ( 难度等级: [0.1055, 0.1057) || 挂载数据: 无 ) 
│   │   │       ├── 启动反射服务 --> ( 难度等级: [0.1055, 0.1056) || 挂载数据: 无 ) 
│   │   │       ├── 查看服务列表 --> ( 难度等级: [0.1056, 0.1056) || 挂载数据: 无 ) 
│   │   │       ├── 服务的方法列表 --> ( 难度等级: [0.1056, 0.1056) || 挂载数据: 无 ) 
│   │   │       ├── 获取类型信息 --> ( 难度等级: [0.1056, 0.1057) || 挂载数据: 无 ) 
│   │   │       └── 调用方法 --> ( 难度等级: [0.1057, 0.1057) || 挂载数据: 无 ) 
│   │   └── 分布式系统 --> ( 难度等级: [0.1057, 0.1071) || 挂载数据: 无 ) 
│   │       ├── 分布式ID生成器 --> ( 难度等级: [0.1057, 0.1059) || 挂载数据: 无 ) 
│   │       │   └── worker_id分配 --> ( 难度等级: [0.1057, 0.1059) || 挂载数据: blog: 8 ) 
│   │       ├── 分布式锁 --> ( 难度等级: [0.1059, 0.1061) || 挂载数据: 无 ) 
│   │       │   ├── 进程内加锁 --> ( 难度等级: [0.1059, 0.106) || 挂载数据: 无 ) 
│   │       │   ├── 尝试锁 --> ( 难度等级: [0.106, 0.106) || 挂载数据: 无 ) 
│   │       │   ├── 基于Redis的setnx --> ( 难度等级: [0.106, 0.106) || 挂载数据: 无 ) 
│   │       │   ├── 基于ZooKeeper --> ( 难度等级: [0.106, 0.1061) || 挂载数据: 无 ) 
│   │       │   ├── 基于etcd --> ( 难度等级: [0.1061, 0.1061) || 挂载数据: blog: 1 ) 
│   │       │   └── 如何选择合适的锁 --> ( 难度等级: [0.1061, 0.1061) || 挂载数据: 无 ) 
│   │       ├── 延时任务系统 --> ( 难度等级: [0.1061, 0.1063) || 挂载数据: 无 ) 
│   │       │   ├── 定时器的实现 --> ( 难度等级: [0.1061, 0.1062) || 挂载数据: 无 ) 
│   │       │   ├── 任务分发 --> ( 难度等级: [0.1062, 0.1063) || 挂载数据: 无 ) 
│   │       │   └── 数据再平衡和幂等考量 --> ( 难度等级: [0.1063, 0.1063) || 挂载数据: 无 ) 
│   │       ├── 分布式搜索引擎 --> ( 难度等级: [0.1063, 0.1065) || 挂载数据: 无 ) 
│   │       │   ├── 搜索引擎 --> ( 难度等级: [0.1063, 0.1064) || 挂载数据: blog: 1 ) 
│   │       │   └── 异构数据同步 --> ( 难度等级: [0.1064, 0.1065) || 挂载数据: 无 ) 
│   │       ├── 负载均衡 --> ( 难度等级: [0.1065, 0.1067) || 挂载数据: 无 ) 
│   │       │   ├── 常见的负载均衡思路 --> ( 难度等级: [0.1065, 0.1066) || 挂载数据: 无 ) 
│   │       │   ├── 基于洗牌算法的负载均衡 --> ( 难度等级: [0.1066, 0.1067) || 挂载数据: blog: 10 ) 
│   │       │   └── 负载均衡算法效果验证 --> ( 难度等级: [0.1067, 0.1067) || 挂载数据: 无 ) 
│   │       ├── 分布式配置管理 --> ( 难度等级: [0.1067, 0.1069) || 挂载数据: 无 ) 
│   │       │   ├── 场景举例 --> ( 难度等级: [0.1067, 0.1068) || 挂载数据: 无 ) 
│   │       │   ├── 使用etcd实现配置更新 --> ( 难度等级: [0.1068, 0.1068) || 挂载数据: 无 ) 
│   │       │   ├── 配置膨胀 --> ( 难度等级: [0.1068, 0.1069) || 挂载数据: 无 ) 
│   │       │   ├── 配置版本管理 --> ( 难度等级: [0.1069, 0.1069) || 挂载数据: 无 ) 
│   │       │   └── 客户端容错 --> ( 难度等级: [0.1069, 0.1069) || 挂载数据: 无 ) 
│   │       └── 分布式爬虫 --> ( 难度等级: [0.1069, 0.1071) || 挂载数据: 无 ) 
│   │           ├── 基于colly的单机爬虫 --> ( 难度等级: [0.1069, 0.107) || 挂载数据: 无 ) 
│   │           ├── 分布式爬虫 --> ( 难度等级: [0.107, 0.107) || 挂载数据: blog: 3 ) 
│   │           ├── 结合nats和colly的消息生产 --> ( 难度等级: [0.107, 0.1071) || 挂载数据: 无 ) 
│   │           └── 结合colly的消息消费 --> ( 难度等级: [0.1071, 0.1071) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.1071, 0.1429) || 挂载数据: 无 ) 
├── 云原生初阶-平台开发 --> ( 难度等级: [0.1429, 0.2857) || 挂载数据: 无 ) 
│   ├── 容器 --> ( 难度等级: [0.1429, 0.1714) || 挂载数据: 无 ) 
│   │   ├── Docker --> ( 难度等级: [0.1429, 0.1524) || 挂载数据: 无 ) 
│   │   ├── 基础入门 --> ( 难度等级: [0.1524, 0.1619) || 挂载数据: 无 ) 
│   │   │   ├── 初识Docker与容器 --> ( 难度等级: [0.1524, 0.1536) || 挂载数据: 无 ) 
│   │   │   ├── 核心概念与安装配置 --> ( 难度等级: [0.1536, 0.1548) || 挂载数据: 无 ) 
│   │   │   │   ├── 核心概念 --> ( 难度等级: [0.1536, 0.1539) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 安装Docker引擎 --> ( 难度等级: [0.1539, 0.1542) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Ubuntu环境下安装Docker --> ( 难度等级: [0.1539, 0.1539) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── CentOS环境下安装Docker --> ( 难度等级: [0.1539, 0.154) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── 通过脚本安装 --> ( 难度等级: [0.154, 0.154) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── macOS环境下安装Docker --> ( 难度等级: [0.154, 0.1541) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── Windows环境下安装Docker --> ( 难度等级: [0.1541, 0.1542) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 配置Docker服务 --> ( 难度等级: [0.1542, 0.1545) || 挂载数据: 无 ) 
│   │   │   │   └── 推荐实践环境 --> ( 难度等级: [0.1545, 0.1548) || 挂载数据: 无 ) 
│   │   │   ├── 使用Docker镜像 --> ( 难度等级: [0.1548, 0.156) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取镜像 --> ( 难度等级: [0.1548, 0.1549) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看镜像信息 --> ( 难度等级: [0.1549, 0.1551) || 挂载数据: 无 ) 
│   │   │   │   ├── 搜寻镜像 --> ( 难度等级: [0.1551, 0.1553) || 挂载数据: 无 ) 
│   │   │   │   ├── 删除和清理镜像 --> ( 难度等级: [0.1553, 0.1554) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建镜像 --> ( 难度等级: [0.1554, 0.1556) || 挂载数据: 无 ) 
│   │   │   │   ├── 存出和载入镜像 --> ( 难度等级: [0.1556, 0.1558) || 挂载数据: 无 ) 
│   │   │   │   └── 上传镜像 --> ( 难度等级: [0.1558, 0.156) || 挂载数据: 无 ) 
│   │   │   ├── 操作Docker容器 --> ( 难度等级: [0.156, 0.1571) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建容器 --> ( 难度等级: [0.156, 0.1561) || 挂载数据: 无 ) 
│   │   │   │   ├── 停止容器 --> ( 难度等级: [0.1561, 0.1563) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 进入容器 --> ( 难度等级: [0.1563, 0.1565) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── 删除容器 --> ( 难度等级: [0.1565, 0.1566) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 导入和导出容器 --> ( 难度等级: [0.1566, 0.1568) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看容器 --> ( 难度等级: [0.1568, 0.157) || 挂载数据: 无 ) 
│   │   │   │   └── 其他容器命令 --> ( 难度等级: [0.157, 0.1571) || 挂载数据: 无 ) 
│   │   │   ├── 访问Docker仓库 --> ( 难度等级: [0.1571, 0.1583) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker Hub公共镜像市场 --> ( 难度等级: [0.1571, 0.1575) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 第三方镜像市场 --> ( 难度等级: [0.1575, 0.1579) || 挂载数据: 无 ) 
│   │   │   │   └── 搭建本地私有仓库 --> ( 难度等级: [0.1579, 0.1583) || 挂载数据: blog: 1 ) 
│   │   │   ├── Docker数据管理 --> ( 难度等级: [0.1583, 0.1595) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据卷 --> ( 难度等级: [0.1583, 0.1587) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据卷容器 --> ( 难度等级: [0.1587, 0.1591) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 利用数据卷容器来迁移数据 --> ( 难度等级: [0.1591, 0.1595) || 挂载数据: 无 ) 
│   │   │   ├── 端口映射与容器互联 --> ( 难度等级: [0.1595, 0.1607) || 挂载数据: 无 ) 
│   │   │   │   ├── 端口映射实现容器访问 --> ( 难度等级: [0.1595, 0.1601) || 挂载数据: blog: 3 ) 
│   │   │   │   └── 互联机制实现便捷互访 --> ( 难度等级: [0.1601, 0.1607) || 挂载数据: 无 ) 
│   │   │   └── 使用Dockerfile创建镜像 --> ( 难度等级: [0.1607, 0.1619) || 挂载数据: 无 ) 
│   │   │       ├── 基本结构 --> ( 难度等级: [0.1607, 0.161) || 挂载数据: 无 ) 
│   │   │       ├── 指令说明 --> ( 难度等级: [0.161, 0.1613) || 挂载数据: 无 ) 
│   │   │       │   ├── 配置指令 --> ( 难度等级: [0.161, 0.1612) || 挂载数据: 无 ) 
│   │   │       │   └── 操作指令 --> ( 难度等级: [0.1612, 0.1613) || 挂载数据: blog: 1 ) 
│   │   │       ├── 创建镜像 --> ( 难度等级: [0.1613, 0.1616) || 挂载数据: 无 ) 
│   │   │       │   ├── 命令选项 --> ( 难度等级: [0.1613, 0.1614) || 挂载数据: 无 ) 
│   │   │       │   ├── 选择父镜像 --> ( 难度等级: [0.1614, 0.1615) || 挂载数据: 无 ) 
│   │   │       │   ├── 使用.dockerignore文件 --> ( 难度等级: [0.1615, 0.1615) || 挂载数据: 无 ) 
│   │   │       │   └── 多步骤创建 --> ( 难度等级: [0.1615, 0.1616) || 挂载数据: blog: 5 ) 
│   │   │       └── 最佳实践 --> ( 难度等级: [0.1616, 0.1619) || 挂载数据: 无 ) 
│   │   └── 进阶技能 --> ( 难度等级: [0.1619, 0.1714) || 挂载数据: 无 ) 
│   │       ├── 核心实现技术 --> ( 难度等级: [0.1619, 0.1638) || 挂载数据: 无 ) 
│   │       │   ├── 基本架构 --> ( 难度等级: [0.1619, 0.1623) || 挂载数据: 无 ) 
│   │       │   ├── 命名空间 --> ( 难度等级: [0.1623, 0.1627) || 挂载数据: 无 ) 
│   │       │   ├── 控制组 --> ( 难度等级: [0.1627, 0.163) || 挂载数据: 无 ) 
│   │       │   ├── 联合文件系统 --> ( 难度等级: [0.163, 0.1634) || 挂载数据: 无 ) 
│   │       │   └── Linux网络虚拟化 --> ( 难度等级: [0.1634, 0.1638) || 挂载数据: 无 ) 
│   │       ├── 配置私有仓库 --> ( 难度等级: [0.1638, 0.1657) || 挂载数据: 无 ) 
│   │       │   ├── 安装Docker Registry --> ( 难度等级: [0.1638, 0.1641) || 挂载数据: 无 ) 
│   │       │   ├── 配置TLS证书 --> ( 难度等级: [0.1641, 0.1644) || 挂载数据: 无 ) 
│   │       │   ├── 管理访问权限 --> ( 难度等级: [0.1644, 0.1648) || 挂载数据: 无 ) 
│   │       │   ├── 配置Registry --> ( 难度等级: [0.1648, 0.1651) || 挂载数据: 无 ) 
│   │       │   ├── 批量管理镜像 --> ( 难度等级: [0.1651, 0.1654) || 挂载数据: 无 ) 
│   │       │   └── 使用通知系统 --> ( 难度等级: [0.1654, 0.1657) || 挂载数据: 无 ) 
│   │       ├── 安全防护与配置 --> ( 难度等级: [0.1657, 0.1676) || 挂载数据: 无 ) 
│   │       │   ├── 命名空间隔离的安全 --> ( 难度等级: [0.1657, 0.166) || 挂载数据: 无 ) 
│   │       │   ├── 控制组资源控制的安全 --> ( 难度等级: [0.166, 0.1663) || 挂载数据: 无 ) 
│   │       │   ├── 内核能力机制 --> ( 难度等级: [0.1663, 0.1667) || 挂载数据: 无 ) 
│   │       │   ├── Docker服务端的防护 --> ( 难度等级: [0.1667, 0.167) || 挂载数据: 无 ) 
│   │       │   ├── 更多安全特性的使用 --> ( 难度等级: [0.167, 0.1673) || 挂载数据: 无 ) 
│   │       │   └── 使用第三方检测工具 --> ( 难度等级: [0.1673, 0.1676) || 挂载数据: 无 ) 
│   │       │       ├── Docker Bench --> ( 难度等级: [0.1673, 0.1675) || 挂载数据: 无 ) 
│   │       │       └── clair --> ( 难度等级: [0.1675, 0.1676) || 挂载数据: 无 ) 
│   │       ├── 高级网络功能 --> ( 难度等级: [0.1676, 0.1695) || 挂载数据: 无 ) 
│   │       │   ├── 启动与配置参数 --> ( 难度等级: [0.1676, 0.1679) || 挂载数据: 无 ) 
│   │       │   ├── 配置容器DNS和主机名 --> ( 难度等级: [0.1679, 0.1681) || 挂载数据: 无 ) 
│   │       │   ├── 容器访问控制 --> ( 难度等级: [0.1681, 0.1683) || 挂载数据: 无 ) 
│   │       │   ├── 映射容器端口到宿主主机的实现 --> ( 难度等级: [0.1683, 0.1686) || 挂载数据: 无 ) 
│   │       │   ├── 配置容器网桥 --> ( 难度等级: [0.1686, 0.1688) || 挂载数据: 无 ) 
│   │       │   ├── 自定义网桥 --> ( 难度等级: [0.1688, 0.169) || 挂载数据: 无 ) 
│   │       │   ├── 使用OpenvSwitch网桥 --> ( 难度等级: [0.169, 0.1693) || 挂载数据: 无 ) 
│   │       │   └── 创建一个点到点连接 --> ( 难度等级: [0.1693, 0.1695) || 挂载数据: 无 ) 
│   │       └── libnetwork插件化网络功能 --> ( 难度等级: [0.1695, 0.1714) || 挂载数据: 无 ) 
│   │           ├── 容器网络模型 --> ( 难度等级: [0.1695, 0.1702) || 挂载数据: 无 ) 
│   │           ├── Docker网络命令 --> ( 难度等级: [0.1702, 0.1708) || 挂载数据: 无 ) 
│   │           └── 构建跨主机容器网络 --> ( 难度等级: [0.1708, 0.1714) || 挂载数据: 无 ) 
│   ├── Kubernetes --> ( 难度等级: [0.1714, 0.2) || 挂载数据: 无 ) 
│   │   ├── 管理工具 --> ( 难度等级: [0.1714, 0.1724) || 挂载数据: 无 ) 
│   │   │   ├── Kubelens --> ( 难度等级: [0.1714, 0.1716) || 挂载数据: 无 ) 
│   │   │   ├── Kuboard --> ( 难度等级: [0.1716, 0.1717) || 挂载数据: 无 ) 
│   │   │   ├── K3S --> ( 难度等级: [0.1717, 0.1718) || 挂载数据: 无 ) 
│   │   │   ├── K9S --> ( 难度等级: [0.1718, 0.172) || 挂载数据: 无 ) 
│   │   │   ├── Minikube --> ( 难度等级: [0.172, 0.1721) || 挂载数据: 无 ) 
│   │   │   ├── kubeasz --> ( 难度等级: [0.1721, 0.1722) || 挂载数据: 无 ) 
│   │   │   └── Draft --> ( 难度等级: [0.1722, 0.1724) || 挂载数据: 无 ) 
│   │   ├── Kubernetes入门 --> ( 难度等级: [0.1724, 0.1733) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes是什么 --> ( 难度等级: [0.1724, 0.1727) || 挂载数据: 无 ) 
│   │   │   │   └── Kubernetes的历史 --> ( 难度等级: [0.1724, 0.1727) || 挂载数据: blog: 10 ) 
│   │   │   ├── 从一个简单的例子开始 --> ( 难度等级: [0.1727, 0.173) || 挂载数据: 无 ) 
│   │   │   │   ├── 环境准备 --> ( 难度等级: [0.1727, 0.1727) || 挂载数据: 无 ) 
│   │   │   │   ├── 启动MySQL服务 --> ( 难度等级: [0.1727, 0.1728) || 挂载数据: 无 ) 
│   │   │   │   ├── 启动Tomcat应用 --> ( 难度等级: [0.1728, 0.1729) || 挂载数据: blog: 6 ) 
│   │   │   │   └── 通过浏览器访问网页 --> ( 难度等级: [0.1729, 0.173) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes基本概念和术语 --> ( 难度等级: [0.173, 0.1733) || 挂载数据: 无 ) 
│   │   │       ├── Master --> ( 难度等级: [0.173, 0.173) || 挂载数据: 无 ) 
│   │   │       ├── Node --> ( 难度等级: [0.173, 0.173) || 挂载数据: blog: 4 ) 
│   │   │       ├── Pod --> ( 难度等级: [0.173, 0.173) || 挂载数据: 无 ) 
│   │   │       │   ├── Pod定义详解 --> ( 难度等级: [0.173, 0.173) || 挂载数据: blog: 3 ) 
│   │   │       │   ├── Pod的基本用法 --> ( 难度等级: [0.173, 0.173) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── 静态Pod --> ( 难度等级: [0.173, 0.173) || 挂载数据: 无 ) 
│   │   │       │   ├── Pod容器共享Volume --> ( 难度等级: [0.173, 0.173) || 挂载数据: blog: 4 ) 
│   │   │       │   ├── Pod的配置管理 --> ( 难度等级: [0.173, 0.173) || 挂载数据: 无 ) 
│   │   │       │   ├── 在容器内获取Pod信息（Downward API） --> ( 难度等级: [0.173, 0.173) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── Pod生命周期和重启策略 --> ( 难度等级: [0.173, 0.173) || 挂载数据: 无 ) 
│   │   │       │   ├── Pod健康检查 --> ( 难度等级: [0.173, 0.173) || 挂载数据: blog: 8 ) 
│   │   │       │   ├── 玩转Pod调度 --> ( 难度等级: [0.173, 0.173) || 挂载数据: 无 ) 
│   │   │       │   ├── Init Container（初始化容器） --> ( 难度等级: [0.173, 0.173) || 挂载数据: blog: 2 ) 
│   │   │       │   ├── Pod的升级和回滚 --> ( 难度等级: [0.173, 0.173) || 挂载数据: 无 ) 
│   │   │       │   ├── Pod的扩容和缩容 --> ( 难度等级: [0.173, 0.173) || 挂载数据: 无 ) 
│   │   │       │   ├── 使用StatefulSet搭建MongoDB集群 --> ( 难度等级: [0.173, 0.173) || 挂载数据: blog: 2 ) 
│   │   │       │   ├── Pod定义文件详解 --> ( 难度等级: [0.173, 0.173) || 挂载数据: 无 ) 
│   │   │       │   ├── 基本操作 --> ( 难度等级: [0.173, 0.173) || 挂载数据: 无 ) 
│   │   │       │   ├── 其他设置 --> ( 难度等级: [0.173, 0.173) || 挂载数据: 无 ) 
│   │   │       │   └── Pod调度 --> ( 难度等级: [0.173, 0.173) || 挂载数据: 无 ) 
│   │   │       ├── Label（标签） --> ( 难度等级: [0.173, 0.1731) || 挂载数据: 无 ) 
│   │   │       ├── Replication Controller --> ( 难度等级: [0.1731, 0.1731) || 挂载数据: 无 ) 
│   │   │       ├── Deployment --> ( 难度等级: [0.1731, 0.1731) || 挂载数据: 无 ) 
│   │   │       │   ├── 运行Deployment --> ( 难度等级: [0.1731, 0.1731) || 挂载数据: blog: 4 ) 
│   │   │       │   ├── 命令vs配置文件 --> ( 难度等级: [0.1731, 0.1731) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── Deployment配置文件简介 --> ( 难度等级: [0.1731, 0.1731) || 挂载数据: 无 ) 
│   │   │       │   ├── 伸缩 --> ( 难度等级: [0.1731, 0.1731) || 挂载数据: 无 ) 
│   │   │       │   ├── Failover --> ( 难度等级: [0.1731, 0.1731) || 挂载数据: 无 ) 
│   │   │       │   └── 用label控制Pod的位置 --> ( 难度等级: [0.1731, 0.1731) || 挂载数据: 无 ) 
│   │   │       ├── Horizontal Pod Autoscaler --> ( 难度等级: [0.1731, 0.1731) || 挂载数据: 无 ) 
│   │   │       ├── StatefulSet --> ( 难度等级: [0.1731, 0.1732) || 挂载数据: 无 ) 
│   │   │       │   └── 扩容/缩容StatefulSet --> ( 难度等级: [0.1731, 0.1732) || 挂载数据: blog: 1 ) 
│   │   │       ├── Service（服务） --> ( 难度等级: [0.1732, 0.1732) || 挂载数据: 无 ) 
│   │   │       ├── Volume（存储卷） --> ( 难度等级: [0.1732, 0.1732) || 挂载数据: blog: 1 ) 
│   │   │       ├── Persistent Volume --> ( 难度等级: [0.1732, 0.1732) || 挂载数据: 无 ) 
│   │   │       ├── Namespace（命名空间） --> ( 难度等级: [0.1732, 0.1732) || 挂载数据: blog: 1 ) 
│   │   │       └── Annotation（注解） --> ( 难度等级: [0.1732, 0.1733) || 挂载数据: 无 ) 
│   │   ├── Kubernetes实践指南 --> ( 难度等级: [0.1733, 0.1742) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes安装与配置 --> ( 难度等级: [0.1733, 0.1736) || 挂载数据: 无 ) 
│   │   │   │   ├── 系统要求 --> ( 难度等级: [0.1733, 0.1733) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用kubeadm工具快速安装Kubernetes集群 --> ( 难度等级: [0.1733, 0.1733) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 以二进制文件方式安装Kubernetes集群 --> ( 难度等级: [0.1733, 0.1734) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Kubernetes集群的安全设置 --> ( 难度等级: [0.1734, 0.1734) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Kubernetes集群的网络配置 --> ( 难度等级: [0.1734, 0.1735) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── 内网中的Kubernetes相关配置 --> ( 难度等级: [0.1735, 0.1735) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes的版本升级 --> ( 难度等级: [0.1735, 0.1735) || 挂载数据: blog: 10 ) 
│   │   │   │   └── Kubernetes核心服务配置详解 --> ( 难度等级: [0.1735, 0.1736) || 挂载数据: blog: 6 ) 
│   │   │   ├── kubectl命令行工具用法详解 --> ( 难度等级: [0.1736, 0.1739) || 挂载数据: 无 ) 
│   │   │   │   ├── kubectl用法概述 --> ( 难度等级: [0.1736, 0.1736) || 挂载数据: 无 ) 
│   │   │   │   ├── kubectl子命令详解 --> ( 难度等级: [0.1736, 0.1737) || 挂载数据: 无 ) 
│   │   │   │   ├── kubectl参数列表 --> ( 难度等级: [0.1737, 0.1738) || 挂载数据: 无 ) 
│   │   │   │   ├── kubectl输出格式 --> ( 难度等级: [0.1738, 0.1738) || 挂载数据: 无 ) 
│   │   │   │   └── kubectl操作示例 --> ( 难度等级: [0.1738, 0.1739) || 挂载数据: 无 ) 
│   │   │   └── 深入掌握Service --> ( 难度等级: [0.1739, 0.1742) || 挂载数据: 无 ) 
│   │   │       ├── Service定义详解 --> ( 难度等级: [0.1739, 0.1739) || 挂载数据: blog: 1 ) 
│   │   │       ├── Service基本用法 --> ( 难度等级: [0.1739, 0.174) || 挂载数据: 无 ) 
│   │   │       ├── Headless Service --> ( 难度等级: [0.174, 0.174) || 挂载数据: 无 ) 
│   │   │       ├── 集群外部访问Pod或Service --> ( 难度等级: [0.174, 0.1741) || 挂载数据: blog: 1 ) 
│   │   │       ├── DNS服务搭建指南 --> ( 难度等级: [0.1741, 0.1741) || 挂载数据: 无 ) 
│   │   │       ├── 自定义DNS和上游DNS服务器 --> ( 难度等级: [0.1741, 0.1741) || 挂载数据: 无 ) 
│   │   │       └── Ingress：HTTP 7层路由机制 --> ( 难度等级: [0.1741, 0.1742) || 挂载数据: 无 ) 
│   │   ├── Kubernetes核心原理 --> ( 难度等级: [0.1742, 0.1751) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes API Server原理分析 --> ( 难度等级: [0.1742, 0.1743) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes API Server概述 --> ( 难度等级: [0.1742, 0.1742) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── 独特的Kubernetes Proxy API接口 --> ( 难度等级: [0.1742, 0.1743) || 挂载数据: blog: 2 ) 
│   │   │   │   └── 集群功能模块之间的通信 --> ( 难度等级: [0.1743, 0.1743) || 挂载数据: 无 ) 
│   │   │   ├── Controller Manager原理分析 --> ( 难度等级: [0.1743, 0.1744) || 挂载数据: 无 ) 
│   │   │   │   ├── Node Controller --> ( 难度等级: [0.1743, 0.1743) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── ResourceQuota Controller --> ( 难度等级: [0.1743, 0.1744) || 挂载数据: 无 ) 
│   │   │   │   ├── Namespace Controller --> ( 难度等级: [0.1744, 0.1744) || 挂载数据: blog: 10 ) 
│   │   │   │   └── Service Controller与Endpoint Controller --> ( 难度等级: [0.1744, 0.1744) || 挂载数据: blog: 3 ) 
│   │   │   ├── Scheduler原理分析 --> ( 难度等级: [0.1744, 0.1745) || 挂载数据: 无 ) 
│   │   │   ├── kubelet运行机制分析 --> ( 难度等级: [0.1745, 0.1747) || 挂载数据: 无 ) 
│   │   │   │   ├── 节点管理 --> ( 难度等级: [0.1745, 0.1746) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod管理 --> ( 难度等级: [0.1746, 0.1746) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器健康检查 --> ( 难度等级: [0.1746, 0.1746) || 挂载数据: 无 ) 
│   │   │   │   └── cAdvisor资源监控 --> ( 难度等级: [0.1746, 0.1747) || 挂载数据: 无 ) 
│   │   │   ├── kube-proxy运行机制分析 --> ( 难度等级: [0.1747, 0.1748) || 挂载数据: 无 ) 
│   │   │   ├── 深入分析集群安全机制 --> ( 难度等级: [0.1748, 0.1749) || 挂载数据: 无 ) 
│   │   │   │   ├── API Server认证管理（Authentication） --> ( 难度等级: [0.1748, 0.1748) || 挂载数据: 无 ) 
│   │   │   │   ├── API Server授木又管理（Authorization） --> ( 难度等级: [0.1748, 0.1748) || 挂载数据: 无 ) 
│   │   │   │   ├── Admission Control（准入控制） --> ( 难度等级: [0.1748, 0.1748) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Service Account --> ( 难度等级: [0.1748, 0.1749) || 挂载数据: 无 ) 
│   │   │   │   └── Secret私密凭据 --> ( 难度等级: [0.1749, 0.1749) || 挂载数据: 无 ) 
│   │   │   ├── 网络原理 --> ( 难度等级: [0.1749, 0.175) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes网络模型 --> ( 难度等级: [0.1749, 0.1749) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker的网络基础 --> ( 难度等级: [0.1749, 0.1749) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker的网络实现 --> ( 难度等级: [0.1749, 0.1749) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes的网络实现 --> ( 难度等级: [0.1749, 0.175) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 单主机Docker网络通信 --> ( 难度等级: [0.1749, 0.1749) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Host模式 --> ( 难度等级: [0.1749, 0.1749) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Container模式 --> ( 难度等级: [0.1749, 0.1749) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── None模式 --> ( 难度等级: [0.1749, 0.1749) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Bridge模式 --> ( 难度等级: [0.1749, 0.1749) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 基础网络模型的优缺点分析 --> ( 难度等级: [0.1749, 0.1749) || 挂载数据: 无 ) 
│   │   │   │   │   └── 跨主机Docker网络通信 --> ( 难度等级: [0.1749, 0.175) || 挂载数据: 无 ) 
│   │   │   │   │       ├── Flannel网络方案 --> ( 难度等级: [0.1749, 0.1749) || 挂载数据: blog: 1 ) 
│   │   │   │   │       ├── Calico网络方案 --> ( 难度等级: [0.1749, 0.1749) || 挂载数据: blog: 9 ) 
│   │   │   │   │       └── 网络方案对比分析 --> ( 难度等级: [0.1749, 0.175) || 挂载数据: 无 ) 
│   │   │   │   ├── CNI网络模型 --> ( 难度等级: [0.175, 0.175) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes网络策略 --> ( 难度等级: [0.175, 0.175) || 挂载数据: 无 ) 
│   │   │   │   └── 开源的网络组件 --> ( 难度等级: [0.175, 0.175) || 挂载数据: 无 ) 
│   │   │   └── 共享存储原理 --> ( 难度等级: [0.175, 0.1751) || 挂载数据: 无 ) 
│   │   │       ├── 共享存储机制概述 --> ( 难度等级: [0.175, 0.175) || 挂载数据: 无 ) 
│   │   │       ├── PV详解 --> ( 难度等级: [0.175, 0.175) || 挂载数据: 无 ) 
│   │   │       ├── PVC详解 --> ( 难度等级: [0.175, 0.1751) || 挂载数据: 无 ) 
│   │   │       ├── PV和PVC的生命周期 --> ( 难度等级: [0.1751, 0.1751) || 挂载数据: 无 ) 
│   │   │       └── StorageClass详解 --> ( 难度等级: [0.1751, 0.1751) || 挂载数据: 无 ) 
│   │   ├── Kubernetes开发指南 --> ( 难度等级: [0.1751, 0.176) || 挂载数据: 无 ) 
│   │   │   ├── REST简述 --> ( 难度等级: [0.1751, 0.1754) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes API详解 --> ( 难度等级: [0.1754, 0.1757) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes API概述 --> ( 难度等级: [0.1754, 0.1755) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── API版本 --> ( 难度等级: [0.1755, 0.1755) || 挂载数据: 无 ) 
│   │   │   │   ├── API Groups（API组） --> ( 难度等级: [0.1755, 0.1756) || 挂载数据: 无 ) 
│   │   │   │   ├── API方法说明 --> ( 难度等级: [0.1756, 0.1757) || 挂载数据: blog: 2 ) 
│   │   │   │   └── API响应说明 --> ( 难度等级: [0.1757, 0.1757) || 挂载数据: blog: 1 ) 
│   │   │   └── 使用Java程序访问Kubernetes API --> ( 难度等级: [0.1757, 0.176) || 挂载数据: blog: 10 ) 
│   │   │       ├── Jersey --> ( 难度等级: [0.1757, 0.1758) || 挂载数据: blog: 2 ) 
│   │   │       ├── Fabric8 --> ( 难度等级: [0.1758, 0.1759) || 挂载数据: 无 ) 
│   │   │       └── 使用说明 --> ( 难度等级: [0.1759, 0.176) || 挂载数据: 无 ) 
│   │   ├── Kubernetes运维指南 --> ( 难度等级: [0.176, 0.177) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes集群管理指南 --> ( 难度等级: [0.176, 0.1763) || 挂载数据: 无 ) 
│   │   │   │   ├── Node的管理 --> ( 难度等级: [0.176, 0.1761) || 挂载数据: 无 ) 
│   │   │   │   ├── 更新资源对象的Label --> ( 难度等级: [0.1761, 0.1761) || 挂载数据: 无 ) 
│   │   │   │   ├── Namespace：集群环境共享与隔离 --> ( 难度等级: [0.1761, 0.1761) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes资源管理 --> ( 难度等级: [0.1761, 0.1761) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 资源紧缺时的Pod驱逐机制 --> ( 难度等级: [0.1761, 0.1762) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod Disruption Budget（主动驱逐保护） --> ( 难度等级: [0.1762, 0.1762) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes集群的高可用部署方案 --> ( 难度等级: [0.1762, 0.1762) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── Kubernetes集群监控 --> ( 难度等级: [0.1762, 0.1762) || 挂载数据: blog: 10 ) 
│   │   │   │   │   ├── Weave Scope --> ( 难度等级: [0.1762, 0.1762) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 安装Scope --> ( 难度等级: [0.1762, 0.1762) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 使用Scope --> ( 难度等级: [0.1762, 0.1762) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Heapster --> ( 难度等级: [0.1762, 0.1762) || 挂载数据: blog: 6 ) 
│   │   │   │   │   │   └── 使用 --> ( 难度等级: [0.1762, 0.1762) || 挂载数据: 无 ) 
│   │   │   │   │   └── Prometheus Operator --> ( 难度等级: [0.1762, 0.1762) || 挂载数据: 无 ) 
│   │   │   │   │       ├── Prometheus架构 --> ( 难度等级: [0.1762, 0.1762) || 挂载数据: blog: 10 ) 
│   │   │   │   │       ├── Prometheus Operator架构 --> ( 难度等级: [0.1762, 0.1762) || 挂载数据: blog: 4 ) 
│   │   │   │   │       └── 部署Prometheus Operator --> ( 难度等级: [0.1762, 0.1762) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 集群统一日志管理 --> ( 难度等级: [0.1762, 0.1763) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes审计日志（Audit Log） --> ( 难度等级: [0.1763, 0.1763) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用Web UI（Dashboard）管理集群 --> ( 难度等级: [0.1763, 0.1763) || 挂载数据: blog: 10 ) 
│   │   │   │   └── Helm：Kubernetes应用包管理工具 --> ( 难度等级: [0.1763, 0.1763) || 挂载数据: blog: 8 ) 
│   │   │   ├── Trouble Shooting指导 --> ( 难度等级: [0.1763, 0.1767) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看系统Event事件 --> ( 难度等级: [0.1763, 0.1764) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看容器日志 --> ( 难度等级: [0.1764, 0.1765) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看Kubernetes服务日志 --> ( 难度等级: [0.1765, 0.1766) || 挂载数据: 无 ) 
│   │   │   │   └── 寻求帮助 --> ( 难度等级: [0.1766, 0.1767) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes开发中的新功能 --> ( 难度等级: [0.1767, 0.177) || 挂载数据: 无 ) 
│   │   │       ├── Pod Preset（运行时参数注入策略） --> ( 难度等级: [0.1767, 0.1767) || 挂载数据: 无 ) 
│   │   │       ├── Cluster Federation（集群联邦） --> ( 难度等级: [0.1767, 0.1768) || 挂载数据: 无 ) 
│   │   │       ├── 容器运行时接口（Container Runtime Interface-CRI） --> ( 难度等级: [0.1768, 0.1768) || 挂载数据: blog: 3 ) 
│   │   │       ├── 对GPU的支持 --> ( 难度等级: [0.1768, 0.1769) || 挂载数据: 无 ) 
│   │   │       └── Kubernetes的演进路线（Roadmap）和开发模式 --> ( 难度等级: [0.1769, 0.177) || 挂载数据: blog: 1 ) 
│   │   ├── Kubernetes源码导读 --> ( 难度等级: [0.177, 0.1779) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes源码结构和编译步骤 --> ( 难度等级: [0.177, 0.1771) || 挂载数据: 无 ) 
│   │   │   ├── kube-apiserver进程源码分析 --> ( 难度等级: [0.1771, 0.1772) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.1771, 0.1772) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.1772, 0.1772) || 挂载数据: 无 ) 
│   │   │   ├── kube-controller-manager进程源码分析 --> ( 难度等级: [0.1772, 0.1774) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.1772, 0.1773) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.1773, 0.1774) || 挂载数据: 无 ) 
│   │   │   ├── kube-scheduler进程源码分析 --> ( 难度等级: [0.1774, 0.1775) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.1774, 0.1774) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.1774, 0.1775) || 挂载数据: 无 ) 
│   │   │   ├── kubelet进程源码分析 --> ( 难度等级: [0.1775, 0.1776) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.1775, 0.1776) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.1776, 0.1776) || 挂载数据: 无 ) 
│   │   │   ├── kube-proxy进程源码分析 --> ( 难度等级: [0.1776, 0.1777) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.1776, 0.1777) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.1777, 0.1777) || 挂载数据: 无 ) 
│   │   │   └── kubectl进程源码分析 --> ( 难度等级: [0.1777, 0.1779) || 挂载数据: 无 ) 
│   │   │       ├── kubectl create命令 --> ( 难度等级: [0.1777, 0.1778) || 挂载数据: blog: 3 ) 
│   │   │       └── rolling-update命令 --> ( 难度等级: [0.1778, 0.1779) || 挂载数据: 无 ) 
│   │   ├── 先把Kubernetes跑起来 --> ( 难度等级: [0.1779, 0.1788) || 挂载数据: 无 ) 
│   │   │   ├── 先跑起来 --> ( 难度等级: [0.1779, 0.178) || 挂载数据: 无 ) 
│   │   │   ├── 创建Kubernetes集群 --> ( 难度等级: [0.178, 0.1782) || 挂载数据: 无 ) 
│   │   │   ├── 部署应用 --> ( 难度等级: [0.1782, 0.1783) || 挂载数据: 无 ) 
│   │   │   ├── 访问应用 --> ( 难度等级: [0.1783, 0.1785) || 挂载数据: 无 ) 
│   │   │   ├── Scale应用 --> ( 难度等级: [0.1785, 0.1786) || 挂载数据: 无 ) 
│   │   │   └── 滚动更新 --> ( 难度等级: [0.1786, 0.1788) || 挂载数据: 无 ) 
│   │   ├── 重要概念 --> ( 难度等级: [0.1788, 0.1797) || 挂载数据: 无 ) 
│   │   ├── 部署Kubernetes Cluster --> ( 难度等级: [0.1797, 0.1806) || 挂载数据: 无 ) 
│   │   │   ├── 安装Docker --> ( 难度等级: [0.1797, 0.18) || 挂载数据: 无 ) 
│   │   │   │   ├── 手动安装模式 --> ( 难度等级: [0.1797, 0.1798) || 挂载数据: 无 ) 
│   │   │   │   ├── Ubuntu中自动化安装Docker --> ( 难度等级: [0.1798, 0.1799) || 挂载数据: 无 ) 
│   │   │   │   └── CentOS中自动化安装Docker --> ( 难度等级: [0.1799, 0.18) || 挂载数据: blog: 2 ) 
│   │   │   ├── 安装kubelet、kubeadm和kubectl --> ( 难度等级: [0.18, 0.1803) || 挂载数据: 无 ) 
│   │   │   └── 用kubeadm创建Cluster --> ( 难度等级: [0.1803, 0.1806) || 挂载数据: blog: 1 ) 
│   │   │       ├── 初始化Master --> ( 难度等级: [0.1803, 0.1804) || 挂载数据: 无 ) 
│   │   │       ├── 配置kubectl --> ( 难度等级: [0.1804, 0.1805) || 挂载数据: 无 ) 
│   │   │       ├── 安装Pod网络 --> ( 难度等级: [0.1805, 0.1806) || 挂载数据: 无 ) 
│   │   │       └── 添加k8s-node1 和k8s-node2 --> ( 难度等级: [0.1806, 0.1806) || 挂载数据: 无 ) 
│   │   ├── Kubernetes架构 --> ( 难度等级: [0.1806, 0.1816) || 挂载数据: 无 ) 
│   │   │   ├── Master节点 --> ( 难度等级: [0.1806, 0.1809) || 挂载数据: 无 ) 
│   │   │   ├── Node节点 --> ( 难度等级: [0.1809, 0.1811) || 挂载数据: blog: 1 ) 
│   │   │   ├── 完整的架构图 --> ( 难度等级: [0.1811, 0.1813) || 挂载数据: 无 ) 
│   │   │   └── 用例子把它们串起来 --> ( 难度等级: [0.1813, 0.1816) || 挂载数据: 无 ) 
│   │   ├── 运行应用 --> ( 难度等级: [0.1816, 0.1825) || 挂载数据: 无 ) 
│   │   │   ├── DaemonSet --> ( 难度等级: [0.1816, 0.182) || 挂载数据: 无 ) 
│   │   │   │   ├── kube-flannel-ds --> ( 难度等级: [0.1816, 0.1817) || 挂载数据: 无 ) 
│   │   │   │   ├── kube-proxy --> ( 难度等级: [0.1817, 0.1819) || 挂载数据: 无 ) 
│   │   │   │   └── 运行自己的DaemonSet --> ( 难度等级: [0.1819, 0.182) || 挂载数据: 无 ) 
│   │   │   └── Job --> ( 难度等级: [0.182, 0.1825) || 挂载数据: 无 ) 
│   │   │       ├── Pod失败的情况 --> ( 难度等级: [0.182, 0.1822) || 挂载数据: 无 ) 
│   │   │       ├── Job的并行性 --> ( 难度等级: [0.1822, 0.1823) || 挂载数据: blog: 2 ) 
│   │   │       └── 定时Job --> ( 难度等级: [0.1823, 0.1825) || 挂载数据: 无 ) 
│   │   ├── 通过Service访问Pod --> ( 难度等级: [0.1825, 0.1834) || 挂载数据: 无 ) 
│   │   │   ├── 创建Service --> ( 难度等级: [0.1825, 0.1827) || 挂载数据: 无 ) 
│   │   │   ├── Cluster IP底层实现 --> ( 难度等级: [0.1827, 0.1829) || 挂载数据: blog: 2 ) 
│   │   │   ├── DNS访问Service --> ( 难度等级: [0.1829, 0.1832) || 挂载数据: 无 ) 
│   │   │   └── 外网如何访问Service --> ( 难度等级: [0.1832, 0.1834) || 挂载数据: 无 ) 
│   │   ├── Rolling Update --> ( 难度等级: [0.1834, 0.1843) || 挂载数据: 无 ) 
│   │   │   └── 实践 --> ( 难度等级: [0.1834, 0.1843) || 挂载数据: 无 ) 
│   │   ├── Health Check --> ( 难度等级: [0.1843, 0.1853) || 挂载数据: 无 ) 
│   │   │   ├── 默认的健康检查 --> ( 难度等级: [0.1843, 0.1845) || 挂载数据: 无 ) 
│   │   │   ├── Liveness探测 --> ( 难度等级: [0.1845, 0.1847) || 挂载数据: 无 ) 
│   │   │   ├── Readiness探测 --> ( 难度等级: [0.1847, 0.1849) || 挂载数据: 无 ) 
│   │   │   ├── Health Check在Scale Up中的应用 --> ( 难度等级: [0.1849, 0.1851) || 挂载数据: blog: 2 ) 
│   │   │   └── Health Check在滚动更新中的应用 --> ( 难度等级: [0.1851, 0.1853) || 挂载数据: 无 ) 
│   │   ├── 数据管理 --> ( 难度等级: [0.1853, 0.1862) || 挂载数据: 无 ) 
│   │   │   ├── Volume --> ( 难度等级: [0.1853, 0.1856) || 挂载数据: 无 ) 
│   │   │   │   ├── emptyDir --> ( 难度等级: [0.1853, 0.1854) || 挂载数据: 无 ) 
│   │   │   │   ├── hostPath --> ( 难度等级: [0.1854, 0.1855) || 挂载数据: 无 ) 
│   │   │   │   └── 外部Storage Provider --> ( 难度等级: [0.1855, 0.1856) || 挂载数据: 无 ) 
│   │   │   ├── PersistentVolume & PersistentVolumeClaim --> ( 难度等级: [0.1856, 0.1859) || 挂载数据: 无 ) 
│   │   │   │   ├── NFS PersistentVolume --> ( 难度等级: [0.1856, 0.1857) || 挂载数据: 无 ) 
│   │   │   │   ├── 回收PV --> ( 难度等级: [0.1857, 0.1858) || 挂载数据: 无 ) 
│   │   │   │   └── PV动态供给 --> ( 难度等级: [0.1858, 0.1859) || 挂载数据: 无 ) 
│   │   │   └── 一个数据库例子 --> ( 难度等级: [0.1859, 0.1862) || 挂载数据: 无 ) 
│   │   ├── Secret & Configmap --> ( 难度等级: [0.1862, 0.1871) || 挂载数据: 无 ) 
│   │   │   ├── 创建Secret --> ( 难度等级: [0.1862, 0.1864) || 挂载数据: 无 ) 
│   │   │   ├── 查看Secret --> ( 难度等级: [0.1864, 0.1866) || 挂载数据: 无 ) 
│   │   │   ├── 在Pod中使用Secret --> ( 难度等级: [0.1866, 0.1869) || 挂载数据: 无 ) 
│   │   │   │   ├── Volume方式 --> ( 难度等级: [0.1866, 0.1868) || 挂载数据: 无 ) 
│   │   │   │   └── 环境变量方式 --> ( 难度等级: [0.1868, 0.1869) || 挂载数据: 无 ) 
│   │   │   └── ConfigMap --> ( 难度等级: [0.1869, 0.1871) || 挂载数据: 无 ) 
│   │   ├── Helm—Kubernetes的包管理器 --> ( 难度等级: [0.1871, 0.188) || 挂载数据: 无 ) 
│   │   │   ├── Why Helm --> ( 难度等级: [0.1871, 0.1873) || 挂载数据: 无 ) 
│   │   │   ├── Helm架构 --> ( 难度等级: [0.1873, 0.1876) || 挂载数据: 无 ) 
│   │   │   ├── 安装Helm --> ( 难度等级: [0.1876, 0.1878) || 挂载数据: 无 ) 
│   │   │   │   ├── Helm客户端 --> ( 难度等级: [0.1876, 0.1877) || 挂载数据: blog: 3 ) 
│   │   │   │   └── Tiller服务器 --> ( 难度等级: [0.1877, 0.1878) || 挂载数据: 无 ) 
│   │   │   └── chart详解 --> ( 难度等级: [0.1878, 0.188) || 挂载数据: 无 ) 
│   │   │       ├── chart目录结构 --> ( 难度等级: [0.1878, 0.1878) || 挂载数据: blog: 1 ) 
│   │   │       ├── chart模板 --> ( 难度等级: [0.1878, 0.1879) || 挂载数据: 无 ) 
│   │   │       ├── 再次实践MySQL chart --> ( 难度等级: [0.1879, 0.1879) || 挂载数据: blog: 1 ) 
│   │   │       ├── 升级和回滚release --> ( 难度等级: [0.1879, 0.188) || 挂载数据: 无 ) 
│   │   │       └── 开发自己的chart --> ( 难度等级: [0.188, 0.188) || 挂载数据: 无 ) 
│   │   ├── 网络 --> ( 难度等级: [0.188, 0.1889) || 挂载数据: 无 ) 
│   │   │   ├── 各种网络方案 --> ( 难度等级: [0.188, 0.1885) || 挂载数据: 无 ) 
│   │   │   └── Network Policy --> ( 难度等级: [0.1885, 0.1889) || 挂载数据: 无 ) 
│   │   │       ├── 部署Canal --> ( 难度等级: [0.1885, 0.1887) || 挂载数据: 无 ) 
│   │   │       └── 实践Network Policy --> ( 难度等级: [0.1887, 0.1889) || 挂载数据: blog: 3 ) 
│   │   ├── Kubernetes Dashboard --> ( 难度等级: [0.1889, 0.1899) || 挂载数据: 无 ) 
│   │   │   ├── 安装 --> ( 难度等级: [0.1889, 0.1892) || 挂载数据: 无 ) 
│   │   │   ├── 配置登录权限 --> ( 难度等级: [0.1892, 0.1894) || 挂载数据: 无 ) 
│   │   │   ├── Dashboard界面结构 --> ( 难度等级: [0.1894, 0.1896) || 挂载数据: blog: 7 ) 
│   │   │   └── 典型使用场景 --> ( 难度等级: [0.1896, 0.1899) || 挂载数据: 无 ) 
│   │   │       ├── 部署Deployment --> ( 难度等级: [0.1896, 0.1897) || 挂载数据: 无 ) 
│   │   │       ├── 在线操作 --> ( 难度等级: [0.1897, 0.1897) || 挂载数据: blog: 1 ) 
│   │   │       ├── 查看资源详细信息 --> ( 难度等级: [0.1897, 0.1898) || 挂载数据: 无 ) 
│   │   │       └── 查看Pod日志 --> ( 难度等级: [0.1898, 0.1899) || 挂载数据: 无 ) 
│   │   ├── Kubernetes集群日志管理 --> ( 难度等级: [0.1899, 0.1908) || 挂载数据: 无 ) 
│   │   ├── Docker简介 --> ( 难度等级: [0.1908, 0.1917) || 挂载数据: 无 ) 
│   │   │   ├── 什么是Docker --> ( 难度等级: [0.1908, 0.1911) || 挂载数据: 无 ) 
│   │   │   ├── Docker基本概念 --> ( 难度等级: [0.1911, 0.1914) || 挂载数据: 无 ) 
│   │   │   │   ├── 镜像 --> ( 难度等级: [0.1911, 0.1912) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器 --> ( 难度等级: [0.1912, 0.1913) || 挂载数据: 无 ) 
│   │   │   │   └── 镜像仓库 --> ( 难度等级: [0.1913, 0.1914) || 挂载数据: 无 ) 
│   │   │   └── Docker架构及原理 --> ( 难度等级: [0.1914, 0.1917) || 挂载数据: 无 ) 
│   │   │       ├── Docker架构 --> ( 难度等级: [0.1914, 0.1915) || 挂载数据: 无 ) 
│   │   │       ├── Docker原理 --> ( 难度等级: [0.1915, 0.1916) || 挂载数据: 无 ) 
│   │   │       ├── 容器网络 --> ( 难度等级: [0.1916, 0.1916) || 挂载数据: 无 ) 
│   │   │       └── 容器存储 --> ( 难度等级: [0.1916, 0.1917) || 挂载数据: 无 ) 
│   │   ├── 容器引擎 --> ( 难度等级: [0.1917, 0.1926) || 挂载数据: 无 ) 
│   │   │   ├── 容器引擎实现原理 --> ( 难度等级: [0.1917, 0.1919) || 挂载数据: 无 ) 
│   │   │   ├── 容器生命周期管理 --> ( 难度等级: [0.1919, 0.1921) || 挂载数据: 无 ) 
│   │   │   ├── 容器状态管理 --> ( 难度等级: [0.1921, 0.1923) || 挂载数据: 无 ) 
│   │   │   ├── 访问运行状态容器 --> ( 难度等级: [0.1923, 0.1924) || 挂载数据: 无 ) 
│   │   │   └── 访问容器内容 --> ( 难度等级: [0.1924, 0.1926) || 挂载数据: 无 ) 
│   │   ├── 镜像管理 --> ( 难度等级: [0.1926, 0.1935) || 挂载数据: 无 ) 
│   │   │   ├── Dockerfile及镜像制作 --> ( 难度等级: [0.1926, 0.1928) || 挂载数据: 无 ) 
│   │   │   │   ├── Dockerfile的作用 --> ( 难度等级: [0.1926, 0.1927) || 挂载数据: 无 ) 
│   │   │   │   ├── Dockerfile文件构成 --> ( 难度等级: [0.1927, 0.1927) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 常用命令集 --> ( 难度等级: [0.1927, 0.1928) || 挂载数据: 无 ) 
│   │   │   │   └── 构建镜像 --> ( 难度等级: [0.1928, 0.1928) || 挂载数据: blog: 1 ) 
│   │   │   ├── 镜像基本操作 --> ( 难度等级: [0.1928, 0.193) || 挂载数据: 无 ) 
│   │   │   │   ├── 从镜像仓库下载镜像 --> ( 难度等级: [0.1928, 0.1928) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 将本地镜像上传到镜像仓库 --> ( 难度等级: [0.1928, 0.1929) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 查看本地镜像 --> ( 难度等级: [0.1929, 0.1929) || 挂载数据: 无 ) 
│   │   │   │   ├── 导出和导入本地镜像 --> ( 难度等级: [0.1929, 0.1929) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建镜像 --> ( 难度等级: [0.1929, 0.1929) || 挂载数据: 无 ) 
│   │   │   │   ├── 修改本地镜像标识 --> ( 难度等级: [0.1929, 0.193) || 挂载数据: 无 ) 
│   │   │   │   └── 删除本地镜像 --> ( 难度等级: [0.193, 0.193) || 挂载数据: blog: 3 ) 
│   │   │   ├── Dockerfile优化 --> ( 难度等级: [0.193, 0.1932) || 挂载数据: 无 ) 
│   │   │   │   ├── Dockerfile检查项 --> ( 难度等级: [0.193, 0.1931) || 挂载数据: 无 ) 
│   │   │   │   └── 检查及优化工具 --> ( 难度等级: [0.1931, 0.1932) || 挂载数据: 无 ) 
│   │   │   ├── 操作系统基础镜像制作 --> ( 难度等级: [0.1932, 0.1934) || 挂载数据: 无 ) 
│   │   │   │   ├── 操作系统版本选择 --> ( 难度等级: [0.1932, 0.1932) || 挂载数据: 无 ) 
│   │   │   │   ├── 操作系统参数调整 --> ( 难度等级: [0.1932, 0.1932) || 挂载数据: 无 ) 
│   │   │   │   ├── 确定基础rpm包范围 --> ( 难度等级: [0.1932, 0.1933) || 挂载数据: 无 ) 
│   │   │   │   ├── 确定常用命令范围 --> ( 难度等级: [0.1933, 0.1933) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 操作系统镜像制作过程 --> ( 难度等级: [0.1933, 0.1933) || 挂载数据: blog: 4 ) 
│   │   │   │   └── 系统资源限制配置说明 --> ( 难度等级: [0.1933, 0.1934) || 挂载数据: 无 ) 
│   │   │   └── 容器镜像安全加固 --> ( 难度等级: [0.1934, 0.1935) || 挂载数据: 无 ) 
│   │   │       ├── 容器安全加固规范 --> ( 难度等级: [0.1934, 0.1935) || 挂载数据: 无 ) 
│   │   │       └── 安全检查工具 --> ( 难度等级: [0.1935, 0.1935) || 挂载数据: 无 ) 
│   │   ├── 镜像仓库管理 --> ( 难度等级: [0.1935, 0.1945) || 挂载数据: 无 ) 
│   │   │   ├── Docker Registry --> ( 难度等级: [0.1935, 0.194) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker Hub --> ( 难度等级: [0.1935, 0.1937) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 第三方公共仓库 --> ( 难度等级: [0.1937, 0.1939) || 挂载数据: 无 ) 
│   │   │   │   └── 建立私有镜像仓库 --> ( 难度等级: [0.1939, 0.194) || 挂载数据: 无 ) 
│   │   │   └── Harbor --> ( 难度等级: [0.194, 0.1945) || 挂载数据: 无 ) 
│   │   │       ├── Harbor架构 --> ( 难度等级: [0.194, 0.1941) || 挂载数据: blog: 4 ) 
│   │   │       ├── Harbor的镜像同步机制 --> ( 难度等级: [0.1941, 0.1942) || 挂载数据: 无 ) 
│   │   │       ├── Harbor用户认证 --> ( 难度等级: [0.1942, 0.1944) || 挂载数据: 无 ) 
│   │   │       └── Harbor容器镜像安全扫描 --> ( 难度等级: [0.1944, 0.1945) || 挂载数据: blog: 1 ) 
│   │   ├── Docker相关部署实践 --> ( 难度等级: [0.1945, 0.1954) || 挂载数据: 无 ) 
│   │   │   ├── MySQL Docker部署实践 --> ( 难度等级: [0.1945, 0.1949) || 挂载数据: 无 ) 
│   │   │   │   ├── MySQL简介 --> ( 难度等级: [0.1945, 0.1947) || 挂载数据: blog: 10 ) 
│   │   │   │   └── MySQL容器化操作实践 --> ( 难度等级: [0.1947, 0.1949) || 挂载数据: blog: 2 ) 
│   │   │   └── Docker支持GPU实践 --> ( 难度等级: [0.1949, 0.1954) || 挂载数据: 无 ) 
│   │   │       ├── GPU简介 --> ( 难度等级: [0.1949, 0.1951) || 挂载数据: 无 ) 
│   │   │       ├── CPU与GPU的对比 --> ( 难度等级: [0.1951, 0.1952) || 挂载数据: blog: 2 ) 
│   │   │       └── 通过nvidia-docker使用GPU --> ( 难度等级: [0.1952, 0.1954) || 挂载数据: blog: 1 ) 
│   │   ├── Kubernetes简介 --> ( 难度等级: [0.1954, 0.1963) || 挂载数据: 无 ) 
│   │   │   ├── PaaS简介 --> ( 难度等级: [0.1954, 0.1959) || 挂载数据: 无 ) 
│   │   │   │   ├── 传统PaaS系统 --> ( 难度等级: [0.1954, 0.1956) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 基于Docker的新型PaaS平台 --> ( 难度等级: [0.1956, 0.1959) || 挂载数据: blog: 10 ) 
│   │   │   └── Kubernetes核心概念 --> ( 难度等级: [0.1959, 0.1963) || 挂载数据: 无 ) 
│   │   ├── Pod相关核心技术 --> ( 难度等级: [0.1963, 0.1972) || 挂载数据: 无 ) 
│   │   │   ├── Label --> ( 难度等级: [0.1963, 0.1968) || 挂载数据: 无 ) 
│   │   │   └── 健康检查 --> ( 难度等级: [0.1968, 0.1972) || 挂载数据: 无 ) 
│   │   │       ├── 流程健康检查 --> ( 难度等级: [0.1968, 0.197) || 挂载数据: 无 ) 
│   │   │       └── 应用健康检查 --> ( 难度等级: [0.197, 0.1972) || 挂载数据: 无 ) 
│   │   ├── Kubernetes Service --> ( 难度等级: [0.1972, 0.1982) || 挂载数据: 无 ) 
│   │   │   ├── DNS服务发现机制 --> ( 难度等级: [0.1972, 0.1974) || 挂载数据: 无 ) 
│   │   │   ├── Headless服务 --> ( 难度等级: [0.1974, 0.1976) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes服务 --> ( 难度等级: [0.1976, 0.1978) || 挂载数据: 无 ) 
│   │   │   │   ├── ClusterIP --> ( 难度等级: [0.1976, 0.1977) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── NodePort --> ( 难度等级: [0.1977, 0.1977) || 挂载数据: blog: 1 ) 
│   │   │   │   └── LoadBalancer --> ( 难度等级: [0.1977, 0.1978) || 挂载数据: 无 ) 
│   │   │   ├── 网络策略 --> ( 难度等级: [0.1978, 0.198) || 挂载数据: 无 ) 
│   │   │   └── 完整的Kubernetes服务发布实践 --> ( 难度等级: [0.198, 0.1982) || 挂载数据: 无 ) 
│   │   │       ├── 各Kubernetes集群 --> ( 难度等级: [0.198, 0.198) || 挂载数据: blog: 10 ) 
│   │   │       ├── Ingress服务发布 --> ( 难度等级: [0.198, 0.1981) || 挂载数据: blog: 1 ) 
│   │   │       └── 服务发现 --> ( 难度等级: [0.1981, 0.1982) || 挂载数据: 无 ) 
│   │   ├── Kubernetes存储 --> ( 难度等级: [0.1982, 0.1991) || 挂载数据: 无 ) 
│   │   │   ├── 存储使用场景 --> ( 难度等级: [0.1982, 0.1984) || 挂载数据: 无 ) 
│   │   │   ├── 文件存储的几种形式 --> ( 难度等级: [0.1984, 0.1986) || 挂载数据: 无 ) 
│   │   │   ├── Flex Volume存储管理方案 --> ( 难度等级: [0.1986, 0.1988) || 挂载数据: 无 ) 
│   │   │   │   └── 如何实现灵活存储组件 --> ( 难度等级: [0.1986, 0.1988) || 挂载数据: 无 ) 
│   │   │   └── 标准化容器存储接口CSI --> ( 难度等级: [0.1988, 0.1991) || 挂载数据: 无 ) 
│   │   └── 安全及多租户配额管理 --> ( 难度等级: [0.1991, 0.2) || 挂载数据: 无 ) 
│   │       └── API服务器认证 --> ( 难度等级: [0.1991, 0.2) || 挂载数据: 无 ) 
│   ├── DevOps --> ( 难度等级: [0.2, 0.2286) || 挂载数据: 无 ) 
│   │   ├── 应用中心 --> ( 难度等级: [0.2, 0.2017) || 挂载数据: 无 ) 
│   │   │   ├── Helm Hub --> ( 难度等级: [0.2, 0.2003) || 挂载数据: 无 ) 
│   │   │   ├── Operator Hub --> ( 难度等级: [0.2003, 0.2007) || 挂载数据: 无 ) 
│   │   │   ├── Aliyun App Hub --> ( 难度等级: [0.2007, 0.201) || 挂载数据: blog: 7 ) 
│   │   │   ├── Kubernetes App Hub --> ( 难度等级: [0.201, 0.2013) || 挂载数据: 无 ) 
│   │   │   └── Prometheus Exporter Hub --> ( 难度等级: [0.2013, 0.2017) || 挂载数据: 无 ) 
│   │   ├── 运维 --> ( 难度等级: [0.2017, 0.2034) || 挂载数据: 无 ) 
│   │   │   └── 模板 --> ( 难度等级: [0.2017, 0.2034) || 挂载数据: 无 ) 
│   │   │       ├── YAML --> ( 难度等级: [0.2017, 0.202) || 挂载数据: 无 ) 
│   │   │       ├── Helm --> ( 难度等级: [0.202, 0.2022) || 挂载数据: 无 ) 
│   │   │       ├── KUDO(Kubernetes Universal Declarative Operator) --> ( 难度等级: [0.2022, 0.2025) || 挂载数据: 无 ) 
│   │   │       ├── OAM(Open Application Model) --> ( 难度等级: [0.2025, 0.2028) || 挂载数据: 无 ) 
│   │   │       ├── OpenKruise --> ( 难度等级: [0.2028, 0.2031) || 挂载数据: 无 ) 
│   │   │       └── MetaController --> ( 难度等级: [0.2031, 0.2034) || 挂载数据: 无 ) 
│   │   ├── 监控 --> ( 难度等级: [0.2034, 0.205) || 挂载数据: 无 ) 
│   │   │   ├── Prometheus --> ( 难度等级: [0.2034, 0.2039) || 挂载数据: 无 ) 
│   │   │   ├── Grafana --> ( 难度等级: [0.2039, 0.2045) || 挂载数据: 无 ) 
│   │   │   └── Alertmanager --> ( 难度等级: [0.2045, 0.205) || 挂载数据: 无 ) 
│   │   ├── CI/CD --> ( 难度等级: [0.205, 0.2067) || 挂载数据: blog: 2 ) 
│   │   │   ├── Jenkins --> ( 难度等级: [0.205, 0.2055) || 挂载数据: blog: 2 ) 
│   │   │   ├── Argo --> ( 难度等级: [0.2055, 0.2059) || 挂载数据: 无 ) 
│   │   │   ├── Tekton --> ( 难度等级: [0.2059, 0.2063) || 挂载数据: 无 ) 
│   │   │   └── Drone --> ( 难度等级: [0.2063, 0.2067) || 挂载数据: blog: 1 ) 
│   │   ├── 日志 --> ( 难度等级: [0.2067, 0.2084) || 挂载数据: 无 ) 
│   │   │   ├── ELK --> ( 难度等级: [0.2067, 0.2073) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── ElasticSearch --> ( 难度等级: [0.2067, 0.2069) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── Logstash --> ( 难度等级: [0.2069, 0.2071) || 挂载数据: 无 ) 
│   │   │   │   └── Kibana --> ( 难度等级: [0.2071, 0.2073) || 挂载数据: blog: 1 ) 
│   │   │   ├── EFK --> ( 难度等级: [0.2073, 0.2078) || 挂载数据: 无 ) 
│   │   │   │   ├── ElasticSearch --> ( 难度等级: [0.2073, 0.2075) || 挂载数据: 无 ) 
│   │   │   │   ├── Fluentd --> ( 难度等级: [0.2075, 0.2077) || 挂载数据: 无 ) 
│   │   │   │   └── Kibana --> ( 难度等级: [0.2077, 0.2078) || 挂载数据: 无 ) 
│   │   │   └── Loki --> ( 难度等级: [0.2078, 0.2084) || 挂载数据: 无 ) 
│   │   │       ├── Loki --> ( 难度等级: [0.2078, 0.208) || 挂载数据: 无 ) 
│   │   │       ├── Promtail --> ( 难度等级: [0.208, 0.2082) || 挂载数据: 无 ) 
│   │   │       └── Grafana --> ( 难度等级: [0.2082, 0.2084) || 挂载数据: 无 ) 
│   │   ├── 采集 --> ( 难度等级: [0.2084, 0.2101) || 挂载数据: 无 ) 
│   │   │   ├── Logpilot --> ( 难度等级: [0.2084, 0.209) || 挂载数据: 无 ) 
│   │   │   ├── Fluentbit --> ( 难度等级: [0.209, 0.2095) || 挂载数据: 无 ) 
│   │   │   └── Fluentd --> ( 难度等级: [0.2095, 0.2101) || 挂载数据: 无 ) 
│   │   ├── DevOps介绍 --> ( 难度等级: [0.2101, 0.2118) || 挂载数据: 无 ) 
│   │   │   ├── 敏捷、持续交付和三步法 --> ( 难度等级: [0.2101, 0.2105) || 挂载数据: 无 ) 
│   │   │   │   ├── 制造业价值流 --> ( 难度等级: [0.2101, 0.2102) || 挂载数据: 无 ) 
│   │   │   │   ├── 技术价值流 --> ( 难度等级: [0.2102, 0.2104) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 聚焦于部署前置时间 --> ( 难度等级: [0.2102, 0.2103) || 挂载数据: 无 ) 
│   │   │   │   │   └── 关注返工指标——%C/A --> ( 难度等级: [0.2103, 0.2104) || 挂载数据: 无 ) 
│   │   │   │   └── 三步工作法：DevOps的基础原则 --> ( 难度等级: [0.2104, 0.2105) || 挂载数据: blog: 10 ) 
│   │   │   ├── 第一步：流动原则 --> ( 难度等级: [0.2105, 0.2109) || 挂载数据: 无 ) 
│   │   │   │   ├── 使工作可见 --> ( 难度等级: [0.2105, 0.2106) || 挂载数据: 无 ) 
│   │   │   │   ├── 限制在制品数 --> ( 难度等级: [0.2106, 0.2106) || 挂载数据: 无 ) 
│   │   │   │   ├── 减小批量大小 --> ( 难度等级: [0.2106, 0.2107) || 挂载数据: 无 ) 
│   │   │   │   ├── 减少交接次数 --> ( 难度等级: [0.2107, 0.2108) || 挂载数据: 无 ) 
│   │   │   │   ├── 持续识别和改善约束点 --> ( 难度等级: [0.2108, 0.2109) || 挂载数据: 无 ) 
│   │   │   │   └── 消除价值流中的困境和浪费 --> ( 难度等级: [0.2109, 0.2109) || 挂载数据: 无 ) 
│   │   │   ├── 第二步：反馈原则 --> ( 难度等级: [0.2109, 0.2113) || 挂载数据: 无 ) 
│   │   │   │   ├── 在复杂系统中安全地工作 --> ( 难度等级: [0.2109, 0.2111) || 挂载数据: 无 ) 
│   │   │   │   ├── 在源头保障质量 --> ( 难度等级: [0.2111, 0.2112) || 挂载数据: 无 ) 
│   │   │   │   └── 为下游工作中心而优化 --> ( 难度等级: [0.2112, 0.2113) || 挂载数据: 无 ) 
│   │   │   └── 第三步：持续学习与实验原则 --> ( 难度等级: [0.2113, 0.2118) || 挂载数据: 无 ) 
│   │   │       ├── 建立学习型组织和安全文化 --> ( 难度等级: [0.2113, 0.2114) || 挂载数据: 无 ) 
│   │   │       ├── 将日常工作的改进制度化 --> ( 难度等级: [0.2114, 0.2115) || 挂载数据: 无 ) 
│   │   │       ├── 把局部发现转化为全局优化 --> ( 难度等级: [0.2115, 0.2116) || 挂载数据: 无 ) 
│   │   │       ├── 在日常工作中注入弹性模式 --> ( 难度等级: [0.2116, 0.2117) || 挂载数据: 无 ) 
│   │   │       └── 领导层强化学习文化 --> ( 难度等级: [0.2117, 0.2118) || 挂载数据: blog: 1 ) 
│   │   ├── 从何处开始 --> ( 难度等级: [0.2118, 0.2134) || 挂载数据: 无 ) 
│   │   │   ├── 选择合适的价值流作为切入点 --> ( 难度等级: [0.2118, 0.2122) || 挂载数据: 无 ) 
│   │   │   │   ├── 兼顾记录型系统和交互型系统 --> ( 难度等级: [0.2118, 0.2119) || 挂载数据: 无 ) 
│   │   │   │   ├── 从最乐于创新的团队开始 --> ( 难度等级: [0.2119, 0.212) || 挂载数据: 无 ) 
│   │   │   │   └── 扩大DevOps的范围 --> ( 难度等级: [0.212, 0.2122) || 挂载数据: 无 ) 
│   │   │   ├── 理解、可视化和运用价值流 --> ( 难度等级: [0.2122, 0.2126) || 挂载数据: 无 ) 
│   │   │   │   ├── 确定创造客户价值所需的团队 --> ( 难度等级: [0.2122, 0.2123) || 挂载数据: 无 ) 
│   │   │   │   ├── 针对团队工作绘制价值流图 --> ( 难度等级: [0.2123, 0.2124) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 组建专门的转型团队 --> ( 难度等级: [0.2124, 0.2125) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 拥有共同的目标 --> ( 难度等级: [0.2124, 0.2124) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 保持小跨度的改进计划 --> ( 难度等级: [0.2124, 0.2124) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 为非功能性需求预留20%的开发时间，减少技术债务 --> ( 难度等级: [0.2124, 0.2125) || 挂载数据: 无 ) 
│   │   │   │   │   └── 提高工作的可视化程度 --> ( 难度等级: [0.2125, 0.2125) || 挂载数据: 无 ) 
│   │   │   │   └── 用工具强化预期行为 --> ( 难度等级: [0.2125, 0.2126) || 挂载数据: 无 ) 
│   │   │   ├── 参考康威定律设计组织结构 --> ( 难度等级: [0.2126, 0.213) || 挂载数据: 无 ) 
│   │   │   │   ├── 组织原型 --> ( 难度等级: [0.2126, 0.2127) || 挂载数据: 无 ) 
│   │   │   │   ├── 过度职能导向的危害（“成本优化”） --> ( 难度等级: [0.2127, 0.2127) || 挂载数据: 无 ) 
│   │   │   │   ├── 组建以市场为导向的团队（“速度优化”） --> ( 难度等级: [0.2127, 0.2128) || 挂载数据: 无 ) 
│   │   │   │   ├── 使职能导向有效 --> ( 难度等级: [0.2128, 0.2128) || 挂载数据: 无 ) 
│   │   │   │   ├── 将测试、运维和信息安全融入日常工作 --> ( 难度等级: [0.2128, 0.2129) || 挂载数据: 无 ) 
│   │   │   │   ├── 使团队成员都成为通才 --> ( 难度等级: [0.2129, 0.2129) || 挂载数据: 无 ) 
│   │   │   │   ├── 根据康威定律设定团队边界 --> ( 难度等级: [0.2129, 0.213) || 挂载数据: 无 ) 
│   │   │   │   └── 创建松耦合架构，提高生产力和安全性 --> ( 难度等级: [0.213, 0.213) || 挂载数据: 无 ) 
│   │   │   └── 将运维融入日常开发工作 --> ( 难度等级: [0.213, 0.2134) || 挂载数据: 无 ) 
│   │   │       ├── 创建共享服务，提高开发生产力 --> ( 难度等级: [0.213, 0.2131) || 挂载数据: 无 ) 
│   │   │       ├── 将运维工程师融入服务团队 --> ( 难度等级: [0.2131, 0.2132) || 挂载数据: 无 ) 
│   │   │       ├── 为每个服务团队分派运维联络人 --> ( 难度等级: [0.2132, 0.2133) || 挂载数据: 无 ) 
│   │   │       └── 邀请运维工程师参加开发团队的会议 --> ( 难度等级: [0.2133, 0.2134) || 挂载数据: 无 ) 
│   │   │           ├── 邀请运维工程师参加每日站会 --> ( 难度等级: [0.2133, 0.2134) || 挂载数据: blog: 10 ) 
│   │   │           ├── 邀请运维工程师参加回顾会议 --> ( 难度等级: [0.2134, 0.2134) || 挂载数据: 无 ) 
│   │   │           └── 使用看板图展示运维工作 --> ( 难度等级: [0.2134, 0.2134) || 挂载数据: blog: 2 ) 
│   │   ├── 第一步：流动的技术实践 --> ( 难度等级: [0.2134, 0.2151) || 挂载数据: 无 ) 
│   │   │   ├── 为部署流水线奠定基础 --> ( 难度等级: [0.2134, 0.2138) || 挂载数据: 无 ) 
│   │   │   │   ├── 按需搭建开发环境、测试环境和生产环境 --> ( 难度等级: [0.2134, 0.2135) || 挂载数据: 无 ) 
│   │   │   │   ├── 应用统一的代码仓库 --> ( 难度等级: [0.2135, 0.2136) || 挂载数据: 无 ) 
│   │   │   │   ├── 使基础设施的重建更容易 --> ( 难度等级: [0.2136, 0.2137) || 挂载数据: 无 ) 
│   │   │   │   └── 运行在类生产环境里才算“完成” --> ( 难度等级: [0.2137, 0.2138) || 挂载数据: 无 ) 
│   │   │   ├── 实现快速可靠的自动化测试 --> ( 难度等级: [0.2138, 0.2141) || 挂载数据: 无 ) 
│   │   │   │   ├── 对代码和环境做持续构建、测试和集成 --> ( 难度等级: [0.2138, 0.2139) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建快速可靠的自动化测试套件 --> ( 难度等级: [0.2139, 0.214) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在自动化测试中尽早发现错误 --> ( 难度等级: [0.2139, 0.2139) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 尽可能并行地快速执行测试 --> ( 难度等级: [0.2139, 0.2139) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 先编写自动化测试 --> ( 难度等级: [0.2139, 0.2139) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 尽量将手动测试自动化 --> ( 难度等级: [0.2139, 0.214) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在测试套件中集成性能测试 --> ( 难度等级: [0.214, 0.214) || 挂载数据: 无 ) 
│   │   │   │   │   └── 在测试套件中集成非功能性需求测试 --> ( 难度等级: [0.214, 0.214) || 挂载数据: 无 ) 
│   │   │   │   └── 在部署流水线失败时拉下安灯绳 --> ( 难度等级: [0.214, 0.2141) || 挂载数据: 无 ) 
│   │   │   ├── 应用和实践持续集成 --> ( 难度等级: [0.2141, 0.2145) || 挂载数据: 无 ) 
│   │   │   │   ├── 小批量开发与大批量合并 --> ( 难度等级: [0.2141, 0.2143) || 挂载数据: 无 ) 
│   │   │   │   └── 应用基于主干的开发实践 --> ( 难度等级: [0.2143, 0.2145) || 挂载数据: blog: 3 ) 
│   │   │   ├── 自动化和低风险发布 --> ( 难度等级: [0.2145, 0.2148) || 挂载数据: 无 ) 
│   │   │   │   ├── 自动化部署流程 --> ( 难度等级: [0.2145, 0.2146) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 应用自动化的自助式部署 --> ( 难度等级: [0.2145, 0.2145) || 挂载数据: 无 ) 
│   │   │   │   │   └── 在部署流水线中集成代码部署 --> ( 难度等级: [0.2145, 0.2146) || 挂载数据: 无 ) 
│   │   │   │   └── 将部署与发布解耦 --> ( 难度等级: [0.2146, 0.2148) || 挂载数据: 无 ) 
│   │   │   │       ├── 基于环境的发布模式 --> ( 难度等级: [0.2146, 0.2147) || 挂载数据: 无 ) 
│   │   │   │       └── 基于应用的发布模式更安全 --> ( 难度等级: [0.2147, 0.2148) || 挂载数据: 无 ) 
│   │   │   └── 降低发布风险的架构 --> ( 难度等级: [0.2148, 0.2151) || 挂载数据: 无 ) 
│   │   │       ├── 能提高生产力、可测试性和安全性的架构 --> ( 难度等级: [0.2148, 0.2149) || 挂载数据: 无 ) 
│   │   │       ├── 架构原型：单体架构与微服务 --> ( 难度等级: [0.2149, 0.215) || 挂载数据: 无 ) 
│   │   │       └── 安全地演进企业架构 --> ( 难度等级: [0.215, 0.2151) || 挂载数据: blog: 1 ) 
│   │   ├── 第二步：反馈的技术实践 --> ( 难度等级: [0.2151, 0.2168) || 挂载数据: 无 ) 
│   │   │   ├── 分析遥测数据以更好地预测故障和实现目标 --> ( 难度等级: [0.2151, 0.2155) || 挂载数据: 无 ) 
│   │   │   │   ├── 异常状态的处理和告警 --> ( 难度等级: [0.2151, 0.2153) || 挂载数据: 无 ) 
│   │   │   │   └── 应用异常检测技术 --> ( 难度等级: [0.2153, 0.2155) || 挂载数据: 无 ) 
│   │   │   ├── 应用反馈实现安全部署 --> ( 难度等级: [0.2155, 0.216) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过遥测使部署更安全 --> ( 难度等级: [0.2155, 0.2157) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发和运维共同承担值班工作 --> ( 难度等级: [0.2157, 0.2158) || 挂载数据: 无 ) 
│   │   │   │   ├── 让开发人员跟踪工作对下游的影响 --> ( 难度等级: [0.2158, 0.2159) || 挂载数据: 无 ) 
│   │   │   │   └── 让开发人员自行管理生产服务 --> ( 难度等级: [0.2159, 0.216) || 挂载数据: 无 ) 
│   │   │   ├── 将假设驱动的开发和A/B测试融入日常工作 --> ( 难度等级: [0.216, 0.2164) || 挂载数据: 无 ) 
│   │   │   │   ├── A/B测试简史 --> ( 难度等级: [0.216, 0.2161) || 挂载数据: 无 ) 
│   │   │   │   ├── 在功能测试中集成A/B测试 --> ( 难度等级: [0.2161, 0.2162) || 挂载数据: 无 ) 
│   │   │   │   ├── 在发布中集成A/B测试 --> ( 难度等级: [0.2162, 0.2163) || 挂载数据: 无 ) 
│   │   │   │   └── 在功能规划中集成A/B测试 --> ( 难度等级: [0.2163, 0.2164) || 挂载数据: 无 ) 
│   │   │   └── 建立评审和协作流程以提升当前工作的质量 --> ( 难度等级: [0.2164, 0.2168) || 挂载数据: 无 ) 
│   │   │       ├── 变更审批流程的危险 --> ( 难度等级: [0.2164, 0.2164) || 挂载数据: 无 ) 
│   │   │       ├── “过度控制变更”的潜在危险 --> ( 难度等级: [0.2164, 0.2165) || 挂载数据: 无 ) 
│   │   │       ├── 变更的协调和排程 --> ( 难度等级: [0.2165, 0.2166) || 挂载数据: 无 ) 
│   │   │       ├── 变更的同行评审 --> ( 难度等级: [0.2166, 0.2166) || 挂载数据: 无 ) 
│   │   │       ├── 人工测试和变更冻结的潜在危害 --> ( 难度等级: [0.2166, 0.2167) || 挂载数据: 无 ) 
│   │   │       ├── 利用结对编程改进代码变更 --> ( 难度等级: [0.2167, 0.2167) || 挂载数据: 无 ) 
│   │   │       └── 消除官僚流程 --> ( 难度等级: [0.2167, 0.2168) || 挂载数据: 无 ) 
│   │   ├── 集成信息安全、变更管理和合规性的技术实践 --> ( 难度等级: [0.2168, 0.2185) || 挂载数据: 无 ) 
│   │   │   ├── 将信息安全融入每个人的日常工作 --> ( 难度等级: [0.2168, 0.2176) || 挂载数据: 无 ) 
│   │   │   │   ├── 将安全集成到开发迭代的演示中 --> ( 难度等级: [0.2168, 0.2169) || 挂载数据: 无 ) 
│   │   │   │   ├── 将安全集成到缺陷跟踪和事后分析会议中 --> ( 难度等级: [0.2169, 0.217) || 挂载数据: 无 ) 
│   │   │   │   ├── 将预防性安全控制集成到共享源代码库及共享服务中 --> ( 难度等级: [0.217, 0.217) || 挂载数据: 无 ) 
│   │   │   │   ├── 将安全集成到部署流水线中 --> ( 难度等级: [0.217, 0.2171) || 挂载数据: 无 ) 
│   │   │   │   ├── 保证应用程序的安全性 --> ( 难度等级: [0.2171, 0.2172) || 挂载数据: 无 ) 
│   │   │   │   ├── 确保软件供应链的安全 --> ( 难度等级: [0.2172, 0.2173) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 确保环境的安全 --> ( 难度等级: [0.2173, 0.2173) || 挂载数据: 无 ) 
│   │   │   │   ├── 将信息安全集成到生产环境遥测中 --> ( 难度等级: [0.2173, 0.2174) || 挂载数据: 无 ) 
│   │   │   │   ├── 在应用程序中建立安全遥测系统 --> ( 难度等级: [0.2174, 0.2175) || 挂载数据: 无 ) 
│   │   │   │   ├── 在环境中建立安全遥测系统 --> ( 难度等级: [0.2175, 0.2176) || 挂载数据: 无 ) 
│   │   │   │   └── 保护部署流水线 --> ( 难度等级: [0.2176, 0.2176) || 挂载数据: 无 ) 
│   │   │   └── 保护部署流水线 --> ( 难度等级: [0.2176, 0.2185) || 挂载数据: 无 ) 
│   │   │       ├── 将安全和合规性集成到变更批准流程中 --> ( 难度等级: [0.2176, 0.2178) || 挂载数据: 无 ) 
│   │   │       ├── 将大量低风险变更重新归类为标准变更 --> ( 难度等级: [0.2178, 0.218) || 挂载数据: 无 ) 
│   │   │       ├── 如何处理常规变更 --> ( 难度等级: [0.218, 0.2182) || 挂载数据: 无 ) 
│   │   │       ├── 减少对职责分离的依赖 --> ( 难度等级: [0.2182, 0.2183) || 挂载数据: 无 ) 
│   │   │       └── 确保为审计人员和合规人员留存文档和证据 --> ( 难度等级: [0.2183, 0.2185) || 挂载数据: 无 ) 
│   │   ├── Shell脚本在DevOps下的应用 --> ( 难度等级: [0.2185, 0.2202) || 挂载数据: 无 ) 
│   │   │   ├── Shell编程基础 --> ( 难度等级: [0.2185, 0.2188) || 挂载数据: 无 ) 
│   │   │   │   ├── Shell脚本的基本元素 --> ( 难度等级: [0.2185, 0.2186) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── Shell基础正则表达式 --> ( 难度等级: [0.2186, 0.2186) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Shell特殊字符 --> ( 难度等级: [0.2186, 0.2187) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 变量和运算符 --> ( 难度等级: [0.2187, 0.2188) || 挂载数据: 无 ) 
│   │   │   ├── Shell中的控制流结构 --> ( 难度等级: [0.2188, 0.219) || 挂载数据: 无 ) 
│   │   │   ├── sed的基础用法及实用举例 --> ( 难度等级: [0.219, 0.2193) || 挂载数据: 无 ) 
│   │   │   │   ├── sed的基础语法格式 --> ( 难度等级: [0.219, 0.2192) || 挂载数据: 无 ) 
│   │   │   │   └── sed的用法举例说明 --> ( 难度等级: [0.2192, 0.2193) || 挂载数据: blog: 2 ) 
│   │   │   ├── awk的基础用法及实用案例 --> ( 难度等级: [0.2193, 0.2196) || 挂载数据: 无 ) 
│   │   │   ├── Shell应用于DevOps开发中应掌握的系统知识点 --> ( 难度等级: [0.2196, 0.2199) || 挂载数据: blog: 5 ) 
│   │   │   └── 生产环境下的Shell脚本 --> ( 难度等级: [0.2199, 0.2202) || 挂载数据: 无 ) 
│   │   │       ├── 生产环境下的备份类脚本 --> ( 难度等级: [0.2199, 0.22) || 挂载数据: 无 ) 
│   │   │       ├── 生产环境下的统计类脚本 --> ( 难度等级: [0.22, 0.22) || 挂载数据: 无 ) 
│   │   │       ├── 生产环境下的监控类脚本 --> ( 难度等级: [0.22, 0.2201) || 挂载数据: 无 ) 
│   │   │       └── 生产环境下的运维开发类脚本 --> ( 难度等级: [0.2201, 0.2202) || 挂载数据: blog: 1 ) 
│   │   ├── Python在DevOps与自动化运维中的应用 --> ( 难度等级: [0.2202, 0.2218) || 挂载数据: 无 ) 
│   │   │   ├── Python语言的应用领域 --> ( 难度等级: [0.2202, 0.2204) || 挂载数据: 无 ) 
│   │   │   ├── 选择Python的原因 --> ( 难度等级: [0.2204, 0.2206) || 挂载数据: 无 ) 
│   │   │   ├── Python的版本说明 --> ( 难度等级: [0.2206, 0.2208) || 挂载数据: 无 ) 
│   │   │   ├── Python基础学习工具 --> ( 难度等级: [0.2208, 0.221) || 挂载数据: 无 ) 
│   │   │   │   ├── Python(x,y)简单介绍 --> ( 难度等级: [0.2208, 0.2209) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── IPython详细介绍 --> ( 难度等级: [0.2209, 0.2209) || 挂载数据: blog: 3 ) 
│   │   │   │   └── Sublime Text3简单介绍 --> ( 难度等级: [0.2209, 0.221) || 挂载数据: 无 ) 
│   │   │   ├── Python基础知识进阶 --> ( 难度等级: [0.221, 0.2212) || 挂载数据: 无 ) 
│   │   │   │   ├── 正则表达式应用 --> ( 难度等级: [0.221, 0.221) || 挂载数据: 无 ) 
│   │   │   │   ├── Python程序构成 --> ( 难度等级: [0.221, 0.2211) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 使用Python解析JSON --> ( 难度等级: [0.2211, 0.2211) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Python异常处理与程序调试 --> ( 难度等级: [0.2211, 0.2211) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Python函数 --> ( 难度等级: [0.2211, 0.2211) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Python面向对象 --> ( 难度等级: [0.2211, 0.2212) || 挂载数据: 无 ) 
│   │   │   │   ├── Python多进程 --> ( 难度等级: [0.2212, 0.2212) || 挂载数据: 无 ) 
│   │   │   │   └── Python多线程 --> ( 难度等级: [0.2212, 0.2212) || 挂载数据: blog: 3 ) 
│   │   │   ├── Python经常用到的第三方类库 --> ( 难度等级: [0.2212, 0.2214) || 挂载数据: 无 ) 
│   │   │   ├── 利用Flask设计后端Restful API --> ( 难度等级: [0.2214, 0.2216) || 挂载数据: blog: 1 ) 
│   │   │   └── 工作中的Python脚本分享 --> ( 难度等级: [0.2216, 0.2218) || 挂载数据: 无 ) 
│   │   ├── Vagrant在DevOps环境中的应用 --> ( 难度等级: [0.2218, 0.2235) || 挂载数据: 无 ) 
│   │   │   ├── Vagrant简单介绍 --> ( 难度等级: [0.2218, 0.2222) || 挂载数据: 无 ) 
│   │   │   ├── Vagrant安装 --> ( 难度等级: [0.2222, 0.2225) || 挂载数据: 无 ) 
│   │   │   ├── 使用Vagrant配置本地开发环境 --> ( 难度等级: [0.2225, 0.2229) || 挂载数据: 无 ) 
│   │   │   │   ├── Vagrant的具体安装步骤 --> ( 难度等级: [0.2225, 0.2226) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Vagrant配置文件详解 --> ( 难度等级: [0.2226, 0.2227) || 挂载数据: blog: 2 ) 
│   │   │   │   └── Vagrant常用命令详解 --> ( 难度等级: [0.2227, 0.2229) || 挂载数据: blog: 10 ) 
│   │   │   ├── 使用Vagrant搭建DevOps开发环境 --> ( 难度等级: [0.2229, 0.2232) || 挂载数据: blog: 10 ) 
│   │   │   └── 使用Vagrant搭建分布式环境 --> ( 难度等级: [0.2232, 0.2235) || 挂载数据: 无 ) 
│   │   ├── 自动化部署管理工具Ansible --> ( 难度等级: [0.2235, 0.2252) || 挂载数据: 无 ) 
│   │   │   ├── YAML介绍 --> ( 难度等级: [0.2235, 0.2237) || 挂载数据: 无 ) 
│   │   │   ├── Ansible的安装和配置 --> ( 难度等级: [0.2237, 0.2238) || 挂载数据: 无 ) 
│   │   │   ├── 定义主机与组规则（Inventory） --> ( 难度等级: [0.2238, 0.224) || 挂载数据: 无 ) 
│   │   │   ├── Ansible常用模块介绍 --> ( 难度等级: [0.224, 0.2241) || 挂载数据: blog: 5 ) 
│   │   │   ├── playbook介绍 --> ( 难度等级: [0.2241, 0.2243) || 挂载数据: 无 ) 
│   │   │   ├── Ansible在AWS云平台中的应用 --> ( 难度等级: [0.2243, 0.2244) || 挂载数据: blog: 3 ) 
│   │   │   ├── 角色 --> ( 难度等级: [0.2244, 0.2246) || 挂载数据: 无 ) 
│   │   │   ├── Jinja2过滤器 --> ( 难度等级: [0.2246, 0.2248) || 挂载数据: 无 ) 
│   │   │   ├── Ansible速度优化 --> ( 难度等级: [0.2248, 0.2249) || 挂载数据: 无 ) 
│   │   │   ├── 利用Ansible API提供自动化运维后端 --> ( 难度等级: [0.2249, 0.2251) || 挂载数据: 无 ) 
│   │   │   │   ├── runner API --> ( 难度等级: [0.2249, 0.225) || 挂载数据: 无 ) 
│   │   │   │   ├── playbook API --> ( 难度等级: [0.225, 0.225) || 挂载数据: 无 ) 
│   │   │   │   └── 用Flask封装Ansible提供自动化运维后端 --> ( 难度等级: [0.225, 0.2251) || 挂载数据: blog: 10 ) 
│   │   │   └── Ansible 2.2新增功能 --> ( 难度等级: [0.2251, 0.2252) || 挂载数据: 无 ) 
│   │   ├── 自动化配置管理工具SaltStack --> ( 难度等级: [0.2252, 0.2269) || 挂载数据: 无 ) 
│   │   │   ├── Salt的相关知识点介绍 --> ( 难度等级: [0.2252, 0.2255) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt的优势 --> ( 难度等级: [0.2252, 0.2253) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt的安装 --> ( 难度等级: [0.2253, 0.2253) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt的工作流程 --> ( 难度等级: [0.2253, 0.2254) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Salt配置文件详解 --> ( 难度等级: [0.2254, 0.2255) || 挂载数据: 无 ) 
│   │   │   │   └── Salt的命令格式 --> ( 难度等级: [0.2255, 0.2255) || 挂载数据: blog: 1 ) 
│   │   │   ├── Salt的常用组件 --> ( 难度等级: [0.2255, 0.2259) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt常用的操作目标 --> ( 难度等级: [0.2255, 0.2256) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt常用模块 --> ( 难度等级: [0.2256, 0.2257) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Granis组件 --> ( 难度等级: [0.2257, 0.2257) || 挂载数据: 无 ) 
│   │   │   │   ├── pillar组件 --> ( 难度等级: [0.2257, 0.2258) || 挂载数据: 无 ) 
│   │   │   │   ├── job管理 --> ( 难度等级: [0.2258, 0.2258) || 挂载数据: 无 ) 
│   │   │   │   └── State介绍 --> ( 难度等级: [0.2258, 0.2259) || 挂载数据: 无 ) 
│   │   │   ├── Salt真实案例分享 --> ( 难度等级: [0.2259, 0.2262) || 挂载数据: 无 ) 
│   │   │   │   ├── base环境配置 --> ( 难度等级: [0.2259, 0.2261) || 挂载数据: 无 ) 
│   │   │   │   └── prod环境配置 --> ( 难度等级: [0.2261, 0.2262) || 挂载数据: 无 ) 
│   │   │   ├── Salt多Master搭建 --> ( 难度等级: [0.2262, 0.2266) || 挂载数据: 无 ) 
│   │   │   └── Salt API介绍 --> ( 难度等级: [0.2266, 0.2269) || 挂载数据: 无 ) 
│   │   │       ├── Python API介绍 --> ( 难度等级: [0.2266, 0.2267) || 挂载数据: blog: 4 ) 
│   │   │       └── Restful API介绍 --> ( 难度等级: [0.2267, 0.2269) || 挂载数据: blog: 1 ) 
│   │   └── Docker和Jenkins在DevOps中的应用 --> ( 难度等级: [0.2269, 0.2286) || 挂载数据: 无 ) 
│   │       ├── Docker的基础安装 --> ( 难度等级: [0.2269, 0.2271) || 挂载数据: 无 ) 
│   │       ├── Docker的三大核心概念 --> ( 难度等级: [0.2271, 0.2274) || 挂载数据: 无 ) 
│   │       ├── Docker的基本架构 --> ( 难度等级: [0.2274, 0.2276) || 挂载数据: 无 ) 
│   │       ├── Docker网络实现原理 --> ( 难度等级: [0.2276, 0.2279) || 挂载数据: 无 ) 
│   │       ├── 利用Dockerfile文件技巧打包Docker镜像 --> ( 难度等级: [0.2279, 0.2281) || 挂载数据: 无 ) 
│   │       ├── 利用Docker-Compose编排和管理多容器 --> ( 难度等级: [0.2281, 0.2283) || 挂载数据: 无 ) 
│   │       │   ├── Docker-Compose的基本语法 --> ( 难度等级: [0.2281, 0.2282) || 挂载数据: 无 ) 
│   │       │   └── Docker-Compose常用命令 --> ( 难度等级: [0.2282, 0.2283) || 挂载数据: blog: 10 ) 
│   │       └── 利用Docker搭建Jenkins Master/Slave分布式环境 --> ( 难度等级: [0.2283, 0.2286) || 挂载数据: 无 ) 
│   │           └── Jenkins Master/Slave的详细部署过程 --> ( 难度等级: [0.2283, 0.2286) || 挂载数据: blog: 10 ) 
│   ├── 中间件 --> ( 难度等级: [0.2286, 0.2571) || 挂载数据: 无 ) 
│   │   ├── 缓存 --> ( 难度等级: [0.2286, 0.2381) || 挂载数据: 无 ) 
│   │   │   ├── etcd --> ( 难度等级: [0.2286, 0.2333) || 挂载数据: 无 ) 
│   │   │   └── Redis --> ( 难度等级: [0.2333, 0.2381) || 挂载数据: 无 ) 
│   │   ├── 微服务与配置中心 --> ( 难度等级: [0.2381, 0.2476) || 挂载数据: 无 ) 
│   │   │   └── Nacos --> ( 难度等级: [0.2381, 0.2476) || 挂载数据: blog: 10 ) 
│   │   └── 存储 --> ( 难度等级: [0.2476, 0.2571) || 挂载数据: 无 ) 
│   │       ├── S3标准 --> ( 难度等级: [0.2476, 0.2508) || 挂载数据: 无 ) 
│   │       ├── MinIO --> ( 难度等级: [0.2508, 0.254) || 挂载数据: blog: 4 ) 
│   │       └── Harbor --> ( 难度等级: [0.254, 0.2571) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.2571, 0.2857) || 挂载数据: 无 ) 
├── 云原生中阶-应用开发 --> ( 难度等级: [0.2857, 0.4286) || 挂载数据: 无 ) 
│   ├── Serverless --> ( 难度等级: [0.2857, 0.3333) || 挂载数据: 无 ) 
│   │   └── App Serverless --> ( 难度等级: [0.2857, 0.3333) || 挂载数据: 无 ) 
│   │       └── Knative --> ( 难度等级: [0.2857, 0.3333) || 挂载数据: 无 ) 
│   ├── Microservices微服务 --> ( 难度等级: [0.3333, 0.381) || 挂载数据: 无 ) 
│   │   └── Dapr --> ( 难度等级: [0.3333, 0.381) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.381, 0.4286) || 挂载数据: 无 ) 
├── 云原生中阶-平台开发 --> ( 难度等级: [0.4286, 0.5714) || 挂载数据: 无 ) 
│   ├── Kubernetes --> ( 难度等级: [0.4286, 0.4643) || 挂载数据: 无 ) 
│   │   ├── 边缘计算 --> ( 难度等级: [0.4286, 0.4297) || 挂载数据: 无 ) 
│   │   │   ├── OpenYurt --> ( 难度等级: [0.4286, 0.429) || 挂载数据: 无 ) 
│   │   │   ├── KubeEdge --> ( 难度等级: [0.429, 0.4293) || 挂载数据: blog: 1 ) 
│   │   │   └── Akri --> ( 难度等级: [0.4293, 0.4297) || 挂载数据: 无 ) 
│   │   ├── 集群联邦 --> ( 难度等级: [0.4297, 0.4309) || 挂载数据: 无 ) 
│   │   │   └── Federation --> ( 难度等级: [0.4297, 0.4309) || 挂载数据: 无 ) 
│   │   ├── 发行版 --> ( 难度等级: [0.4309, 0.432) || 挂载数据: 无 ) 
│   │   │   ├── EKS-D --> ( 难度等级: [0.4309, 0.4311) || 挂载数据: 无 ) 
│   │   │   ├── Harvester --> ( 难度等级: [0.4311, 0.4313) || 挂载数据: 无 ) 
│   │   │   ├── OpenShift --> ( 难度等级: [0.4313, 0.4316) || 挂载数据: blog: 4 ) 
│   │   │   ├── k0s --> ( 难度等级: [0.4316, 0.4318) || 挂载数据: 无 ) 
│   │   │   └── Wayne --> ( 难度等级: [0.4318, 0.432) || 挂载数据: 无 ) 
│   │   ├── Kubernetes系统基础 --> ( 难度等级: [0.432, 0.4332) || 挂载数据: 无 ) 
│   │   │   ├── 容器技术概述 --> ( 难度等级: [0.432, 0.4323) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器技术的功用 --> ( 难度等级: [0.432, 0.4321) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 容器简史 --> ( 难度等级: [0.4321, 0.4322) || 挂载数据: 无 ) 
│   │   │   │   └── Docker的功能限制 --> ( 难度等级: [0.4322, 0.4323) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes概述 --> ( 难度等级: [0.4323, 0.4326) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes简史 --> ( 难度等级: [0.4323, 0.4324) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes特性 --> ( 难度等级: [0.4324, 0.4325) || 挂载数据: blog: 3 ) 
│   │   │   │   └── Kubernetes概念和术语 --> ( 难度等级: [0.4325, 0.4326) || 挂载数据: blog: 5 ) 
│   │   │   ├── Kubernetes集群组件 --> ( 难度等级: [0.4326, 0.4329) || 挂载数据: 无 ) 
│   │   │   │   ├── Master组件 --> ( 难度等级: [0.4326, 0.4327) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Node组件 --> ( 难度等级: [0.4327, 0.4328) || 挂载数据: blog: 2 ) 
│   │   │   │   └── 核心附件 --> ( 难度等级: [0.4328, 0.4329) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes网络模型基础 --> ( 难度等级: [0.4329, 0.4332) || 挂载数据: 无 ) 
│   │   │       ├── 网络模型概述 --> ( 难度等级: [0.4329, 0.433) || 挂载数据: 无 ) 
│   │   │       └── 集群上的网络通信 --> ( 难度等级: [0.433, 0.4332) || 挂载数据: 无 ) 
│   │   ├── Kubernetes快速入门 --> ( 难度等级: [0.4332, 0.4343) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes的核心对象 --> ( 难度等级: [0.4332, 0.4335) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod资源对象 --> ( 难度等级: [0.4332, 0.4333) || 挂载数据: 无 ) 
│   │   │   │   ├── Controller --> ( 难度等级: [0.4333, 0.4333) || 挂载数据: 无 ) 
│   │   │   │   ├── Service --> ( 难度等级: [0.4333, 0.4334) || 挂载数据: 无 ) 
│   │   │   │   └── 部署应用程序的主体过程 --> ( 难度等级: [0.4334, 0.4335) || 挂载数据: 无 ) 
│   │   │   ├── 部署Kubernetes集群 --> ( 难度等级: [0.4335, 0.4338) || 挂载数据: 无 ) 
│   │   │   │   ├── kubeadm部署工具 --> ( 难度等级: [0.4335, 0.4335) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 集群运行模式 --> ( 难度等级: [0.4335, 0.4336) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 准备用于实践操作的集群环境 --> ( 难度等级: [0.4336, 0.4337) || 挂载数据: 无 ) 
│   │   │   │   └── 获取集群环境相关的信息 --> ( 难度等级: [0.4337, 0.4338) || 挂载数据: 无 ) 
│   │   │   ├── kubectl使用基础与示例 --> ( 难度等级: [0.4338, 0.434) || 挂载数据: 无 ) 
│   │   │   └── 命令式容器应用编排 --> ( 难度等级: [0.434, 0.4343) || 挂载数据: 无 ) 
│   │   │       ├── 部署应用（Pod） --> ( 难度等级: [0.434, 0.4341) || 挂载数据: 无 ) 
│   │   │       ├── 探查Pod及应用详情 --> ( 难度等级: [0.4341, 0.4342) || 挂载数据: 无 ) 
│   │   │       ├── 部署Service对象 --> ( 难度等级: [0.4342, 0.4342) || 挂载数据: 无 ) 
│   │   │       ├── 扩容和缩容 --> ( 难度等级: [0.4342, 0.4343) || 挂载数据: 无 ) 
│   │   │       └── 修改及删除对象 --> ( 难度等级: [0.4343, 0.4343) || 挂载数据: 无 ) 
│   │   ├── 资源管理基础 --> ( 难度等级: [0.4343, 0.4355) || 挂载数据: 无 ) 
│   │   │   ├── 资源对象及API群组 --> ( 难度等级: [0.4343, 0.4346) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes的资源对象 --> ( 难度等级: [0.4343, 0.4344) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源及其在API中的组织形式 --> ( 难度等级: [0.4344, 0.4345) || 挂载数据: 无 ) 
│   │   │   │   └── 访问Kubernetes REST API --> ( 难度等级: [0.4345, 0.4346) || 挂载数据: 无 ) 
│   │   │   ├── 对象类资源格式 --> ( 难度等级: [0.4346, 0.4348) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源配置清单 --> ( 难度等级: [0.4346, 0.4346) || 挂载数据: 无 ) 
│   │   │   │   ├── metadata嵌套字段 --> ( 难度等级: [0.4346, 0.4347) || 挂载数据: 无 ) 
│   │   │   │   ├── spec和status字段 --> ( 难度等级: [0.4347, 0.4347) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源配置清单格式文档 --> ( 难度等级: [0.4347, 0.4347) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 资源对象管理方式 --> ( 难度等级: [0.4347, 0.4348) || 挂载数据: 无 ) 
│   │   │   ├── kubectl命令与资源管理 --> ( 难度等级: [0.4348, 0.435) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源管理操作概述 --> ( 难度等级: [0.4348, 0.4349) || 挂载数据: 无 ) 
│   │   │   │   └── kubectl的基本用法 --> ( 难度等级: [0.4349, 0.435) || 挂载数据: 无 ) 
│   │   │   ├── 管理名称空间资源 --> ( 难度等级: [0.435, 0.4353) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看名称空间及其资源对象 --> ( 难度等级: [0.435, 0.4351) || 挂载数据: 无 ) 
│   │   │   │   └── 管理Namespace资源 --> ( 难度等级: [0.4351, 0.4353) || 挂载数据: 无 ) 
│   │   │   └── Pod资源的基础管理操作 --> ( 难度等级: [0.4353, 0.4355) || 挂载数据: 无 ) 
│   │   │       ├── 陈述式对象配置管理方式 --> ( 难度等级: [0.4353, 0.4354) || 挂载数据: 无 ) 
│   │   │       └── 声明式对象配置管理方式 --> ( 难度等级: [0.4354, 0.4355) || 挂载数据: 无 ) 
│   │   ├── 管理Pod资源对象 --> ( 难度等级: [0.4355, 0.4366) || 挂载数据: 无 ) 
│   │   │   ├── 管理Pod对象的容器 --> ( 难度等级: [0.4355, 0.4356) || 挂载数据: 无 ) 
│   │   │   │   ├── 镜像及其获取策略 --> ( 难度等级: [0.4355, 0.4355) || 挂载数据: 无 ) 
│   │   │   │   ├── 暴露端口 --> ( 难度等级: [0.4355, 0.4355) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义运行的容器化应用 --> ( 难度等级: [0.4355, 0.4356) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 环境变量 --> ( 难度等级: [0.4356, 0.4356) || 挂载数据: 无 ) 
│   │   │   │   ├── 共享节点的网络名称空间 --> ( 难度等级: [0.4356, 0.4356) || 挂载数据: 无 ) 
│   │   │   │   └── 设置Pod对象的安全上下文 --> ( 难度等级: [0.4356, 0.4356) || 挂载数据: blog: 2 ) 
│   │   │   ├── 标签与标签选择器 --> ( 难度等级: [0.4356, 0.4358) || 挂载数据: 无 ) 
│   │   │   │   ├── 标签概述 --> ( 难度等级: [0.4356, 0.4357) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 管理资源标签 --> ( 难度等级: [0.4357, 0.4357) || 挂载数据: 无 ) 
│   │   │   │   ├── 标签选择器 --> ( 难度等级: [0.4357, 0.4358) || 挂载数据: 无 ) 
│   │   │   │   └── Pod节点选择器nodeSelector --> ( 难度等级: [0.4358, 0.4358) || 挂载数据: 无 ) 
│   │   │   ├── 资源注解 --> ( 难度等级: [0.4358, 0.436) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看资源注解 --> ( 难度等级: [0.4358, 0.4359) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 管理资源注解 --> ( 难度等级: [0.4359, 0.436) || 挂载数据: 无 ) 
│   │   │   ├── Pod对象的生命周期 --> ( 难度等级: [0.436, 0.4361) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod的相位 --> ( 难度等级: [0.436, 0.436) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod的创建过程 --> ( 难度等级: [0.436, 0.436) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod生命周期中的重要行为 --> ( 难度等级: [0.436, 0.4361) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器的重启策略 --> ( 难度等级: [0.4361, 0.4361) || 挂载数据: 无 ) 
│   │   │   │   └── Pod的终止过程 --> ( 难度等级: [0.4361, 0.4361) || 挂载数据: 无 ) 
│   │   │   ├── Pod存活性探测 --> ( 难度等级: [0.4361, 0.4363) || 挂载数据: 无 ) 
│   │   │   │   ├── 设置exec探针 --> ( 难度等级: [0.4361, 0.4362) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 设置HTTP探针 --> ( 难度等级: [0.4362, 0.4362) || 挂载数据: 无 ) 
│   │   │   │   ├── 设置TCP探针 --> ( 难度等级: [0.4362, 0.4363) || 挂载数据: 无 ) 
│   │   │   │   └── 存活性探测行为属性 --> ( 难度等级: [0.4363, 0.4363) || 挂载数据: 无 ) 
│   │   │   ├── Pod就绪性探测 --> ( 难度等级: [0.4363, 0.4365) || 挂载数据: 无 ) 
│   │   │   └── 资源需求及资源限制 --> ( 难度等级: [0.4365, 0.4366) || 挂载数据: 无 ) 
│   │   │       ├── 资源需求 --> ( 难度等级: [0.4365, 0.4365) || 挂载数据: 无 ) 
│   │   │       ├── 资源限制 --> ( 难度等级: [0.4365, 0.4366) || 挂载数据: blog: 1 ) 
│   │   │       ├── 容器的可见资源 --> ( 难度等级: [0.4366, 0.4366) || 挂载数据: blog: 2 ) 
│   │   │       └── Pod的服务质量类别 --> ( 难度等级: [0.4366, 0.4366) || 挂载数据: 无 ) 
│   │   ├── Pod控制器 --> ( 难度等级: [0.4366, 0.4378) || 挂载数据: 无 ) 
│   │   │   ├── 关于Pod控制器 --> ( 难度等级: [0.4366, 0.4368) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod控制器概述 --> ( 难度等级: [0.4366, 0.4367) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 控制器与Pod对象 --> ( 难度等级: [0.4367, 0.4367) || 挂载数据: 无 ) 
│   │   │   │   └── Pod模板资源 --> ( 难度等级: [0.4367, 0.4368) || 挂载数据: 无 ) 
│   │   │   ├── ReplicaSet控制器 --> ( 难度等级: [0.4368, 0.4369) || 挂载数据: 无 ) 
│   │   │   │   ├── ReplicaSet概述 --> ( 难度等级: [0.4368, 0.4368) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建ReplicaSet --> ( 难度等级: [0.4368, 0.4368) || 挂载数据: 无 ) 
│   │   │   │   ├── ReplicaSet管控下的Pod对象 --> ( 难度等级: [0.4368, 0.4369) || 挂载数据: 无 ) 
│   │   │   │   ├── 更新ReplicaSet控制器 --> ( 难度等级: [0.4369, 0.4369) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 删除ReplicaSet控制器资源 --> ( 难度等级: [0.4369, 0.4369) || 挂载数据: blog: 1 ) 
│   │   │   ├── Deployment控制器 --> ( 难度等级: [0.4369, 0.4371) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建Deployment --> ( 难度等级: [0.4369, 0.437) || 挂载数据: 无 ) 
│   │   │   │   ├── 更新策略 --> ( 难度等级: [0.437, 0.437) || 挂载数据: 无 ) 
│   │   │   │   ├── 升级Deployment --> ( 难度等级: [0.437, 0.437) || 挂载数据: 无 ) 
│   │   │   │   ├── 金丝雀发布 --> ( 难度等级: [0.437, 0.437) || 挂载数据: 无 ) 
│   │   │   │   └── 回滚Deployment控制器下的应用发布 --> ( 难度等级: [0.437, 0.4371) || 挂载数据: 无 ) 
│   │   │   ├── DaemonSet控制器 --> ( 难度等级: [0.4371, 0.4372) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建DaemonSet资源对象 --> ( 难度等级: [0.4371, 0.4371) || 挂载数据: 无 ) 
│   │   │   │   └── 更新DaemonSet对象 --> ( 难度等级: [0.4371, 0.4372) || 挂载数据: 无 ) 
│   │   │   ├── Job控制器 --> ( 难度等级: [0.4372, 0.4374) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建Job对象 --> ( 难度等级: [0.4372, 0.4372) || 挂载数据: 无 ) 
│   │   │   │   ├── 并行式Job --> ( 难度等级: [0.4372, 0.4373) || 挂载数据: 无 ) 
│   │   │   │   ├── Job扩容 --> ( 难度等级: [0.4373, 0.4373) || 挂载数据: 无 ) 
│   │   │   │   └── 删除Job --> ( 难度等级: [0.4373, 0.4374) || 挂载数据: 无 ) 
│   │   │   ├── CronJob控制器 --> ( 难度等级: [0.4374, 0.4375) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建CronJob对象 --> ( 难度等级: [0.4374, 0.4374) || 挂载数据: 无 ) 
│   │   │   │   └── CronJob的控制机制 --> ( 难度等级: [0.4374, 0.4375) || 挂载数据: blog: 10 ) 
│   │   │   ├── ReplicationController --> ( 难度等级: [0.4375, 0.4376) || 挂载数据: 无 ) 
│   │   │   └── Pod中断预算 --> ( 难度等级: [0.4376, 0.4378) || 挂载数据: 无 ) 
│   │   ├── 存储卷与数据持久化 --> ( 难度等级: [0.4378, 0.4389) || 挂载数据: 无 ) 
│   │   │   ├── 存储卷概述 --> ( 难度等级: [0.4378, 0.438) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes支持的存储卷类型 --> ( 难度等级: [0.4378, 0.4379) || 挂载数据: 无 ) 
│   │   │   │   └── 存储卷的使用方式 --> ( 难度等级: [0.4379, 0.438) || 挂载数据: 无 ) 
│   │   │   ├── 临时存储卷 --> ( 难度等级: [0.438, 0.4382) || 挂载数据: 无 ) 
│   │   │   │   ├── emptyDir存储卷 --> ( 难度等级: [0.438, 0.4381) || 挂载数据: 无 ) 
│   │   │   │   └── gitRepo存储卷 --> ( 难度等级: [0.4381, 0.4382) || 挂载数据: 无 ) 
│   │   │   ├── 节点存储卷hostPath --> ( 难度等级: [0.4382, 0.4384) || 挂载数据: 无 ) 
│   │   │   ├── 网络存储卷 --> ( 难度等级: [0.4384, 0.4386) || 挂载数据: 无 ) 
│   │   │   │   ├── NFS存储卷 --> ( 难度等级: [0.4384, 0.4384) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── RBD存储卷 --> ( 难度等级: [0.4384, 0.4385) || 挂载数据: 无 ) 
│   │   │   │   ├── GlusterFS存储卷 --> ( 难度等级: [0.4385, 0.4385) || 挂载数据: 无 ) 
│   │   │   │   └── Cinder存储卷 --> ( 难度等级: [0.4385, 0.4386) || 挂载数据: blog: 1 ) 
│   │   │   ├── 持久存储卷 --> ( 难度等级: [0.4386, 0.4387) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建PV --> ( 难度等级: [0.4386, 0.4386) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建PVC --> ( 难度等级: [0.4386, 0.4386) || 挂载数据: 无 ) 
│   │   │   │   ├── 在Pod中使用PVC --> ( 难度等级: [0.4386, 0.4387) || 挂载数据: 无 ) 
│   │   │   │   ├── 存储类 --> ( 难度等级: [0.4387, 0.4387) || 挂载数据: 无 ) 
│   │   │   │   └── PV和PVC的生命周期 --> ( 难度等级: [0.4387, 0.4387) || 挂载数据: 无 ) 
│   │   │   └── downwardAPI存储卷 --> ( 难度等级: [0.4387, 0.4389) || 挂载数据: 无 ) 
│   │   │       ├── 环境变量式元数据注入 --> ( 难度等级: [0.4387, 0.4388) || 挂载数据: 无 ) 
│   │   │       └── 存储卷式元数据注入 --> ( 难度等级: [0.4388, 0.4389) || 挂载数据: blog: 2 ) 
│   │   ├── 配置容器应用：ConfigMap和Secret --> ( 难度等级: [0.4389, 0.4401) || 挂载数据: 无 ) 
│   │   │   ├── 容器化应用配置方式 --> ( 难度等级: [0.4389, 0.4392) || 挂载数据: 无 ) 
│   │   │   ├── 通过命令行参数配置容器应用 --> ( 难度等级: [0.4392, 0.4394) || 挂载数据: 无 ) 
│   │   │   ├── 利用环境变量配置容器应用 --> ( 难度等级: [0.4394, 0.4396) || 挂载数据: 无 ) 
│   │   │   ├── 应用程序配置管理及ConfigMap资源 --> ( 难度等级: [0.4396, 0.4399) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建ConfigMap对象 --> ( 难度等级: [0.4396, 0.4397) || 挂载数据: 无 ) 
│   │   │   │   ├── 向Pod环境变量传递ConfigMap对象键值数据 --> ( 难度等级: [0.4397, 0.4397) || 挂载数据: 无 ) 
│   │   │   │   ├── ConfigMap存储卷 --> ( 难度等级: [0.4397, 0.4398) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器应用重载新配置 --> ( 难度等级: [0.4398, 0.4398) || 挂载数据: 无 ) 
│   │   │   │   └── 使用ConfigMap资源的注意事项 --> ( 难度等级: [0.4398, 0.4399) || 挂载数据: 无 ) 
│   │   │   └── Secret资源 --> ( 难度等级: [0.4399, 0.4401) || 挂载数据: 无 ) 
│   │   │       ├── Secret概述 --> ( 难度等级: [0.4399, 0.4399) || 挂载数据: 无 ) 
│   │   │       ├── 创建Secret资源 --> ( 难度等级: [0.4399, 0.44) || 挂载数据: 无 ) 
│   │   │       ├── Secret存储卷 --> ( 难度等级: [0.44, 0.44) || 挂载数据: blog: 1 ) 
│   │   │       └── imagePullSecret资源对象 --> ( 难度等级: [0.44, 0.4401) || 挂载数据: 无 ) 
│   │   ├── StatefulSet控制器 --> ( 难度等级: [0.4401, 0.4412) || 挂载数据: 无 ) 
│   │   │   ├── StatefulSet概述 --> ( 难度等级: [0.4401, 0.4403) || 挂载数据: 无 ) 
│   │   │   │   ├── Stateful应用和Stateless应用 --> ( 难度等级: [0.4401, 0.4402) || 挂载数据: 无 ) 
│   │   │   │   ├── StatefulSet控制器概述 --> ( 难度等级: [0.4402, 0.4402) || 挂载数据: 无 ) 
│   │   │   │   └── StatefulSet的特性 --> ( 难度等级: [0.4402, 0.4403) || 挂载数据: 无 ) 
│   │   │   ├── StatefulSet基础应用 --> ( 难度等级: [0.4403, 0.4406) || 挂载数据: 无 ) 
│   │   │   │   └── 创建StatefulSet对象 --> ( 难度等级: [0.4403, 0.4406) || 挂载数据: 无 ) 
│   │   │   ├── StatefulSet资源扩缩容 --> ( 难度等级: [0.4406, 0.4408) || 挂载数据: 无 ) 
│   │   │   ├── StatefulSet资源升级 --> ( 难度等级: [0.4408, 0.441) || 挂载数据: 无 ) 
│   │   │   │   ├── 滚动更新 --> ( 难度等级: [0.4408, 0.4408) || 挂载数据: 无 ) 
│   │   │   │   ├── 暂存更新操作 --> ( 难度等级: [0.4408, 0.4409) || 挂载数据: 无 ) 
│   │   │   │   ├── 金丝雀部署 --> ( 难度等级: [0.4409, 0.4409) || 挂载数据: 无 ) 
│   │   │   │   ├── 分段更新 --> ( 难度等级: [0.4409, 0.441) || 挂载数据: 无 ) 
│   │   │   │   └── 其他话题 --> ( 难度等级: [0.441, 0.441) || 挂载数据: 无 ) 
│   │   │   └── 案例：etcd集群 --> ( 难度等级: [0.441, 0.4412) || 挂载数据: 无 ) 
│   │   │       ├── 创建Service资源 --> ( 难度等级: [0.441, 0.4411) || 挂载数据: 无 ) 
│   │   │       └── etcd StatefulSet --> ( 难度等级: [0.4411, 0.4412) || 挂载数据: blog: 10 ) 
│   │   ├── 认证、授权与准入控制 --> ( 难度等级: [0.4412, 0.4424) || 挂载数据: 无 ) 
│   │   │   ├── 访问控制概述 --> ( 难度等级: [0.4412, 0.4415) || 挂载数据: 无 ) 
│   │   │   │   ├── 用户账户与用户组 --> ( 难度等级: [0.4412, 0.4414) || 挂载数据: 无 ) 
│   │   │   │   └── 认证、授权与准入控制基础 --> ( 难度等级: [0.4414, 0.4415) || 挂载数据: blog: 1 ) 
│   │   │   ├── 服务账户管理与应用 --> ( 难度等级: [0.4415, 0.4417) || 挂载数据: 无 ) 
│   │   │   │   ├── Service Account自动化 --> ( 难度等级: [0.4415, 0.4416) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建服务账户 --> ( 难度等级: [0.4416, 0.4416) || 挂载数据: 无 ) 
│   │   │   │   └── 调用imagePullSecret资源对象 --> ( 难度等级: [0.4416, 0.4417) || 挂载数据: 无 ) 
│   │   │   ├── X.509数字证书认证 --> ( 难度等级: [0.4417, 0.4419) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes中的SSL/TLS认证 --> ( 难度等级: [0.4417, 0.4418) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 客户端配置文件kubeconfig --> ( 难度等级: [0.4418, 0.4419) || 挂载数据: 无 ) 
│   │   │   │   └── TLS bootstrapping机制 --> ( 难度等级: [0.4419, 0.4419) || 挂载数据: 无 ) 
│   │   │   ├── 基于角色的访问控制：RBAC --> ( 难度等级: [0.4419, 0.4422) || 挂载数据: 无 ) 
│   │   │   │   ├── RBAC授权插件 --> ( 难度等级: [0.4419, 0.442) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Role和RoleBinding --> ( 难度等级: [0.442, 0.442) || 挂载数据: 无 ) 
│   │   │   │   ├── ClusterRole和ClusterRoleBin-ding --> ( 难度等级: [0.442, 0.4421) || 挂载数据: 无 ) 
│   │   │   │   ├── 聚合型ClusterRole --> ( 难度等级: [0.4421, 0.4421) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向用户的内建ClusterRole --> ( 难度等级: [0.4421, 0.4421) || 挂载数据: 无 ) 
│   │   │   │   └── 其他的内建ClusterRole和ClusterRoleBinding --> ( 难度等级: [0.4421, 0.4422) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes Dashboard --> ( 难度等级: [0.4422, 0.4424) || 挂载数据: 无 ) 
│   │   │       ├── 部署HTTPS通信的Dashboard --> ( 难度等级: [0.4422, 0.4422) || 挂载数据: blog: 10 ) 
│   │   │       ├── 配置token认证 --> ( 难度等级: [0.4422, 0.4423) || 挂载数据: blog: 1 ) 
│   │   │       └── 配置kubeconfig认证 --> ( 难度等级: [0.4423, 0.4424) || 挂载数据: 无 ) 
│   │   ├── 网络模型与网络策略 --> ( 难度等级: [0.4424, 0.4435) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes网络模型及CNI插件 --> ( 难度等级: [0.4424, 0.4427) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker容器的网络模型 --> ( 难度等级: [0.4424, 0.4425) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes网络模型 --> ( 难度等级: [0.4425, 0.4425) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Pod网络的实现方式 --> ( 难度等级: [0.4425, 0.4426) || 挂载数据: 无 ) 
│   │   │   │   └── CNI插件及其常见的实现 --> ( 难度等级: [0.4426, 0.4427) || 挂载数据: 无 ) 
│   │   │   ├── flannel网络插件 --> ( 难度等级: [0.4427, 0.443) || 挂载数据: 无 ) 
│   │   │   │   ├── flannel的配置参数 --> ( 难度等级: [0.4427, 0.4428) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── VxLAN后端和direct routing --> ( 难度等级: [0.4428, 0.4429) || 挂载数据: 无 ) 
│   │   │   │   └── host-gw后端 --> ( 难度等级: [0.4429, 0.443) || 挂载数据: 无 ) 
│   │   │   ├── 网络策略 --> ( 难度等级: [0.443, 0.4433) || 挂载数据: 无 ) 
│   │   │   │   ├── 网络策略概述 --> ( 难度等级: [0.443, 0.443) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署Canal提供网络策略功能 --> ( 难度等级: [0.443, 0.4431) || 挂载数据: 无 ) 
│   │   │   │   ├── 配置网络策略 --> ( 难度等级: [0.4431, 0.4431) || 挂载数据: 无 ) 
│   │   │   │   ├── 管控入站流量 --> ( 难度等级: [0.4431, 0.4431) || 挂载数据: 无 ) 
│   │   │   │   ├── 管控出站流量 --> ( 难度等级: [0.4431, 0.4432) || 挂载数据: 无 ) 
│   │   │   │   ├── 隔离名称空间 --> ( 难度等级: [0.4432, 0.4432) || 挂载数据: 无 ) 
│   │   │   │   └── 网络策略应用案例 --> ( 难度等级: [0.4432, 0.4433) || 挂载数据: 无 ) 
│   │   │   └── Calico网络插件 --> ( 难度等级: [0.4433, 0.4435) || 挂载数据: 无 ) 
│   │   │       ├── Calico工作特性 --> ( 难度等级: [0.4433, 0.4433) || 挂载数据: 无 ) 
│   │   │       ├── Calico系统架构 --> ( 难度等级: [0.4433, 0.4434) || 挂载数据: 无 ) 
│   │   │       ├── Calico部署要点 --> ( 难度等级: [0.4434, 0.4434) || 挂载数据: blog: 1 ) 
│   │   │       ├── 部署Calico提供网络服务和网络策略 --> ( 难度等级: [0.4434, 0.4435) || 挂载数据: 无 ) 
│   │   │       └── 客户端工具calicoctl --> ( 难度等级: [0.4435, 0.4435) || 挂载数据: 无 ) 
│   │   ├── Pod资源调度 --> ( 难度等级: [0.4435, 0.4447) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes调度器概述 --> ( 难度等级: [0.4435, 0.4438) || 挂载数据: 无 ) 
│   │   │   │   ├── 常用的预选策略 --> ( 难度等级: [0.4435, 0.4437) || 挂载数据: 无 ) 
│   │   │   │   └── 常用的优选函数 --> ( 难度等级: [0.4437, 0.4438) || 挂载数据: 无 ) 
│   │   │   ├── 节点亲和调度 --> ( 难度等级: [0.4438, 0.444) || 挂载数据: 无 ) 
│   │   │   │   ├── 节点硬亲和性 --> ( 难度等级: [0.4438, 0.4439) || 挂载数据: 无 ) 
│   │   │   │   └── 节点软亲和性 --> ( 难度等级: [0.4439, 0.444) || 挂载数据: 无 ) 
│   │   │   ├── Pod资源亲和调度 --> ( 难度等级: [0.444, 0.4442) || 挂载数据: 无 ) 
│   │   │   │   ├── 位置拓扑 --> ( 难度等级: [0.444, 0.4441) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod硬亲和调度 --> ( 难度等级: [0.4441, 0.4441) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod软亲和调度 --> ( 难度等级: [0.4441, 0.4442) || 挂载数据: 无 ) 
│   │   │   │   └── Pod反亲和调度 --> ( 难度等级: [0.4442, 0.4442) || 挂载数据: blog: 1 ) 
│   │   │   ├── 污点和容忍度 --> ( 难度等级: [0.4442, 0.4445) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义污点和容忍度 --> ( 难度等级: [0.4442, 0.4443) || 挂载数据: 无 ) 
│   │   │   │   ├── 管理节点的污点 --> ( 难度等级: [0.4443, 0.4444) || 挂载数据: 无 ) 
│   │   │   │   └── Pod对象的容忍度 --> ( 难度等级: [0.4444, 0.4445) || 挂载数据: 无 ) 
│   │   │   └── Pod优选级和抢占式调度 --> ( 难度等级: [0.4445, 0.4447) || 挂载数据: 无 ) 
│   │   ├── Kubernetes系统扩展 --> ( 难度等级: [0.4447, 0.4459) || 挂载数据: 无 ) 
│   │   │   ├── 自定义资源类型（CRD） --> ( 难度等级: [0.4447, 0.4449) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建CRD对象 --> ( 难度等级: [0.4447, 0.4447) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 自定义资源格式验证 --> ( 难度等级: [0.4447, 0.4448) || 挂载数据: 无 ) 
│   │   │   │   ├── 子资源 --> ( 难度等级: [0.4448, 0.4448) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用资源类别 --> ( 难度等级: [0.4448, 0.4449) || 挂载数据: 无 ) 
│   │   │   │   ├── 多版本支持 --> ( 难度等级: [0.4449, 0.4449) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义控制器基础 --> ( 难度等级: [0.4449, 0.4449) || 挂载数据: blog: 4 ) 
│   │   │   ├── 自定义API Server --> ( 难度等级: [0.4449, 0.4452) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义API Server概述 --> ( 难度等级: [0.4449, 0.445) || 挂载数据: blog: 1 ) 
│   │   │   │   └── APIService对象 --> ( 难度等级: [0.445, 0.4452) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes集群高可用 --> ( 难度等级: [0.4452, 0.4454) || 挂载数据: 无 ) 
│   │   │   │   ├── etcd高可用 --> ( 难度等级: [0.4452, 0.4453) || 挂载数据: blog: 10 ) 
│   │   │   │   └── Controller Manager和Scheduler高可用 --> ( 难度等级: [0.4453, 0.4454) || 挂载数据: blog: 4 ) 
│   │   │   ├── Kubernetes的部署模式 --> ( 难度等级: [0.4454, 0.4456) || 挂载数据: 无 ) 
│   │   │   │   ├── 关键组件 --> ( 难度等级: [0.4454, 0.4455) || 挂载数据: 无 ) 
│   │   │   │   └── 常见的部署模式 --> ( 难度等级: [0.4455, 0.4456) || 挂载数据: 无 ) 
│   │   │   └── 容器时代的DevOps概述 --> ( 难度等级: [0.4456, 0.4459) || 挂载数据: 无 ) 
│   │   │       ├── 容器：DevOps协作的基础 --> ( 难度等级: [0.4456, 0.4457) || 挂载数据: blog: 2 ) 
│   │   │       │   ├── 容器隔离等级 --> ( 难度等级: [0.4456, 0.4456) || 挂载数据: 无 ) 
│   │   │       │   ├── 容器编排 --> ( 难度等级: [0.4456, 0.4456) || 挂载数据: blog: 5 ) 
│   │   │       │   ├── 将镜像存储在可信的注册服务器中 --> ( 难度等级: [0.4456, 0.4456) || 挂载数据: 无 ) 
│   │   │       │   ├── 充分利用Docker的构建缓存 --> ( 难度等级: [0.4456, 0.4456) || 挂载数据: 无 ) 
│   │   │       │   ├── 不要使用特权模式运行容器 --> ( 难度等级: [0.4456, 0.4457) || 挂载数据: 无 ) 
│   │   │       │   ├── 使用显式的容器镜像标签 --> ( 难度等级: [0.4457, 0.4457) || 挂载数据: 无 ) 
│   │   │       │   ├── 保持小的容器镜像 --> ( 难度等级: [0.4457, 0.4457) || 挂载数据: 无 ) 
│   │   │       │   ├── 单个容器只运行一个应用 --> ( 难度等级: [0.4457, 0.4457) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── 使用可信镜像仓库中经过验证的镜像 --> ( 难度等级: [0.4457, 0.4457) || 挂载数据: 无 ) 
│   │   │       │   ├── 对镜像进行漏洞扫描 --> ( 难度等级: [0.4457, 0.4457) || 挂载数据: 无 ) 
│   │   │       │   ├── 不要将数据保存在容器中 --> ( 难度等级: [0.4457, 0.4457) || 挂载数据: blog: 2 ) 
│   │   │       │   └── 永远不要在容器中存放密钥和配置 --> ( 难度等级: [0.4457, 0.4457) || 挂载数据: 无 ) 
│   │   │       ├── 泛型端到端容器应用程序生命周期工作流 --> ( 难度等级: [0.4457, 0.4458) || 挂载数据: 无 ) 
│   │   │       └── 基于Kubernetes的DevOps --> ( 难度等级: [0.4458, 0.4459) || 挂载数据: blog: 10 ) 
│   │   ├── 资源指标及HPA控制器 --> ( 难度等级: [0.4459, 0.447) || 挂载数据: 无 ) 
│   │   │   ├── 资源监控及资源指标 --> ( 难度等级: [0.4459, 0.4461) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源监控及Heapster --> ( 难度等级: [0.4459, 0.446) || 挂载数据: 无 ) 
│   │   │   │   └── 新一代监控架构 --> ( 难度等级: [0.446, 0.4461) || 挂载数据: 无 ) 
│   │   │   ├── 资源指标及其应用 --> ( 难度等级: [0.4461, 0.4464) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署metrics-server --> ( 难度等级: [0.4461, 0.4463) || 挂载数据: 无 ) 
│   │   │   │   └── kubectl top命令 --> ( 难度等级: [0.4463, 0.4464) || 挂载数据: 无 ) 
│   │   │   ├── 自定义指标与Prometheus --> ( 难度等级: [0.4464, 0.4467) || 挂载数据: 无 ) 
│   │   │   │   ├── Prometheus概述 --> ( 难度等级: [0.4464, 0.4465) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署Prometheus监控系统 --> ( 难度等级: [0.4465, 0.4466) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义指标适配器k8s-prometheus-adapter --> ( 难度等级: [0.4466, 0.4467) || 挂载数据: 无 ) 
│   │   │   └── 自动弹性缩放 --> ( 难度等级: [0.4467, 0.447) || 挂载数据: 无 ) 
│   │   │       ├── HPA概述 --> ( 难度等级: [0.4467, 0.4468) || 挂载数据: 无 ) 
│   │   │       ├── HPA（v1）控制器 --> ( 难度等级: [0.4468, 0.4469) || 挂载数据: 无 ) 
│   │   │       └── HPA（v2）控制器 --> ( 难度等级: [0.4469, 0.447) || 挂载数据: 无 ) 
│   │   ├── Helm程序包管理器 --> ( 难度等级: [0.447, 0.4482) || 挂载数据: 无 ) 
│   │   │   ├── Helm基础 --> ( 难度等级: [0.447, 0.4474) || 挂载数据: 无 ) 
│   │   │   │   ├── Helm的核心术语 --> ( 难度等级: [0.447, 0.4471) || 挂载数据: 无 ) 
│   │   │   │   ├── Helm架构 --> ( 难度等级: [0.4471, 0.4472) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Helm Client --> ( 难度等级: [0.4472, 0.4472) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Tiller server --> ( 难度等级: [0.4472, 0.4473) || 挂载数据: 无 ) 
│   │   │   │   └── Helm快速入门 --> ( 难度等级: [0.4473, 0.4474) || 挂载数据: blog: 1 ) 
│   │   │   ├── Helm Charts --> ( 难度等级: [0.4474, 0.4478) || 挂载数据: 无 ) 
│   │   │   │   ├── Charts文件组织结构 --> ( 难度等级: [0.4474, 0.4475) || 挂载数据: 无 ) 
│   │   │   │   ├── Chart.yaml文件组织格式 --> ( 难度等级: [0.4475, 0.4475) || 挂载数据: 无 ) 
│   │   │   │   ├── Charts中的依赖关系 --> ( 难度等级: [0.4475, 0.4476) || 挂载数据: 无 ) 
│   │   │   │   ├── 模板和值 --> ( 难度等级: [0.4476, 0.4477) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义Charts --> ( 难度等级: [0.4477, 0.4478) || 挂载数据: 无 ) 
│   │   │   └── Helm实践：部署EFK日志管理系统 --> ( 难度等级: [0.4478, 0.4482) || 挂载数据: 无 ) 
│   │   │       ├── ElasticSearch集群 --> ( 难度等级: [0.4478, 0.4479) || 挂载数据: 无 ) 
│   │   │       ├── 日志采集代理fluentd --> ( 难度等级: [0.4479, 0.448) || 挂载数据: 无 ) 
│   │   │       └── 可视化组件Kibana --> ( 难度等级: [0.448, 0.4482) || 挂载数据: 无 ) 
│   │   ├── 夯实基础：Linux网络虚拟化 --> ( 难度等级: [0.4482, 0.4493) || 挂载数据: 无 ) 
│   │   │   ├── 网络虚拟化基石：network namespace --> ( 难度等级: [0.4482, 0.4483) || 挂载数据: 无 ) 
│   │   │   │   ├── 初识network namespace --> ( 难度等级: [0.4482, 0.4482) || 挂载数据: 无 ) 
│   │   │   │   ├── 配置network namespace --> ( 难度等级: [0.4482, 0.4482) || 挂载数据: 无 ) 
│   │   │   │   └── network namespace API的使用 --> ( 难度等级: [0.4482, 0.4483) || 挂载数据: blog: 4 ) 
│   │   │   ├── 千呼万唤始出来：veth pair --> ( 难度等级: [0.4483, 0.4484) || 挂载数据: 无 ) 
│   │   │   │   └── veth pair内核实现 --> ( 难度等级: [0.4483, 0.4484) || 挂载数据: 无 ) 
│   │   │   ├── 连接你我他：Linux bridge --> ( 难度等级: [0.4484, 0.4485) || 挂载数据: 无 ) 
│   │   │   │   ├── Linux bridge初体验 --> ( 难度等级: [0.4484, 0.4484) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 把IP让给Linux bridge --> ( 难度等级: [0.4484, 0.4485) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 将物理网卡添加到Linux bridge --> ( 难度等级: [0.4485, 0.4485) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Linux bridge在网络虚拟化中的应用 --> ( 难度等级: [0.4485, 0.4485) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 网络接口的混杂模式 --> ( 难度等级: [0.4485, 0.4485) || 挂载数据: 无 ) 
│   │   │   ├── 给用户态一个机会：tun/tap设备 --> ( 难度等级: [0.4485, 0.4487) || 挂载数据: 无 ) 
│   │   │   │   ├── tun/tap设备的工作原理 --> ( 难度等级: [0.4485, 0.4486) || 挂载数据: 无 ) 
│   │   │   │   ├── 利用tun设备部署一个VPN --> ( 难度等级: [0.4486, 0.4486) || 挂载数据: 无 ) 
│   │   │   │   └── tun设备编程 --> ( 难度等级: [0.4486, 0.4487) || 挂载数据: 无 ) 
│   │   │   ├── iptables --> ( 难度等级: [0.4487, 0.4488) || 挂载数据: 无 ) 
│   │   │   │   ├── 祖师爷netfilter --> ( 难度等级: [0.4487, 0.4487) || 挂载数据: 无 ) 
│   │   │   │   ├── iptables的三板斧：table、chain和rule --> ( 难度等级: [0.4487, 0.4487) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── iptables的常规武器 --> ( 难度等级: [0.4487, 0.4487) || 挂载数据: 无 ) 
│   │   │   │   ├── userspace模式 --> ( 难度等级: [0.4487, 0.4487) || 挂载数据: 无 ) 
│   │   │   │   ├── iptables模式 --> ( 难度等级: [0.4487, 0.4487) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── IPVS模式 --> ( 难度等级: [0.4487, 0.4488) || 挂载数据: 无 ) 
│   │   │   │   ├── iptables VS. IPVS --> ( 难度等级: [0.4488, 0.4488) || 挂载数据: 无 ) 
│   │   │   │   └── conntrack --> ( 难度等级: [0.4488, 0.4488) || 挂载数据: blog: 2 ) 
│   │   │   ├── 初识Linux隧道：ipip --> ( 难度等级: [0.4488, 0.4489) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试ipip隧道 --> ( 难度等级: [0.4488, 0.4489) || 挂载数据: 无 ) 
│   │   │   │   └── ipip隧道测试结果复盘 --> ( 难度等级: [0.4489, 0.4489) || 挂载数据: 无 ) 
│   │   │   ├── Linux隧道网络的代表：VXLAN --> ( 难度等级: [0.4489, 0.4491) || 挂载数据: 无 ) 
│   │   │   │   ├── VXLAN协议原理简介 --> ( 难度等级: [0.4489, 0.4489) || 挂载数据: 无 ) 
│   │   │   │   ├── VXLAN组网必要信息 --> ( 难度等级: [0.4489, 0.449) || 挂载数据: 无 ) 
│   │   │   │   ├── VXLAN基本配置命令 --> ( 难度等级: [0.449, 0.449) || 挂载数据: 无 ) 
│   │   │   │   ├── VXLAN网络实践 --> ( 难度等级: [0.449, 0.449) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式控制中心 --> ( 难度等级: [0.449, 0.449) || 挂载数据: 无 ) 
│   │   │   │   └── 自维护VTEP组 --> ( 难度等级: [0.449, 0.4491) || 挂载数据: 无 ) 
│   │   │   ├── 物理网卡的分身术：Macvlan --> ( 难度等级: [0.4491, 0.4492) || 挂载数据: 无 ) 
│   │   │   │   ├── Macvlan五大工作模式解析 --> ( 难度等级: [0.4491, 0.4491) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试使用Macvlan设备 --> ( 难度等级: [0.4491, 0.4491) || 挂载数据: 无 ) 
│   │   │   │   ├── Macvlan的跨机通信 --> ( 难度等级: [0.4491, 0.4491) || 挂载数据: 无 ) 
│   │   │   │   └── Macvlan与overlay对比 --> ( 难度等级: [0.4491, 0.4492) || 挂载数据: blog: 1 ) 
│   │   │   └── Macvlan的救护员：IPvlan --> ( 难度等级: [0.4492, 0.4493) || 挂载数据: 无 ) 
│   │   │       ├── IPvlan简介 --> ( 难度等级: [0.4492, 0.4492) || 挂载数据: 无 ) 
│   │   │       ├── 测试IPvlan --> ( 难度等级: [0.4492, 0.4493) || 挂载数据: 无 ) 
│   │   │       └── Docker IPvlan网络 --> ( 难度等级: [0.4493, 0.4493) || 挂载数据: 无 ) 
│   │   ├── 饮水思源：Docker网络模型简介 --> ( 难度等级: [0.4493, 0.4505) || 挂载数据: 无 ) 
│   │   │   ├── 主角登场：Linux容器 --> ( 难度等级: [0.4493, 0.4495) || 挂载数据: 无 ) 
│   │   │   ├── 打开万花筒：Docker的四大网络模式 --> ( 难度等级: [0.4495, 0.4497) || 挂载数据: 无 ) 
│   │   │   │   ├── bridge模式 --> ( 难度等级: [0.4495, 0.4495) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── host模式 --> ( 难度等级: [0.4495, 0.4496) || 挂载数据: 无 ) 
│   │   │   │   ├── container模式 --> ( 难度等级: [0.4496, 0.4496) || 挂载数据: 无 ) 
│   │   │   │   └── none模式 --> ( 难度等级: [0.4496, 0.4497) || 挂载数据: 无 ) 
│   │   │   ├── 最常用的Docker网络技巧 --> ( 难度等级: [0.4497, 0.4499) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看容器IP --> ( 难度等级: [0.4497, 0.4497) || 挂载数据: 无 ) 
│   │   │   │   ├── 端口映射 --> ( 难度等级: [0.4497, 0.4497) || 挂载数据: 无 ) 
│   │   │   │   ├── 访问外网 --> ( 难度等级: [0.4497, 0.4498) || 挂载数据: 无 ) 
│   │   │   │   ├── DNS和主机名 --> ( 难度等级: [0.4498, 0.4498) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义网络 --> ( 难度等级: [0.4498, 0.4498) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 发布服务 --> ( 难度等级: [0.4498, 0.4499) || 挂载数据: 无 ) 
│   │   │   │   └── docker link：两两互联 --> ( 难度等级: [0.4499, 0.4499) || 挂载数据: blog: 1 ) 
│   │   │   ├── 容器网络的第一个标准：CNM --> ( 难度等级: [0.4499, 0.4501) || 挂载数据: 无 ) 
│   │   │   │   ├── CNM标准 --> ( 难度等级: [0.4499, 0.4499) || 挂载数据: 无 ) 
│   │   │   │   ├── 体验CNM接口 --> ( 难度等级: [0.4499, 0.45) || 挂载数据: 无 ) 
│   │   │   │   ├── Libnetwork --> ( 难度等级: [0.45, 0.45) || 挂载数据: 无 ) 
│   │   │   │   └── Libnetwork扩展 --> ( 难度等级: [0.45, 0.4501) || 挂载数据: 无 ) 
│   │   │   ├── 天生不易：容器组网的挑战 --> ( 难度等级: [0.4501, 0.4503) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器网络挑战综述 --> ( 难度等级: [0.4501, 0.4501) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Docker的解决方案 --> ( 难度等级: [0.4501, 0.4502) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 第三方容器网络插件 --> ( 难度等级: [0.4502, 0.4503) || 挂载数据: 无 ) 
│   │   │   └── 如何做好技术选型：容器组网方案沙场点兵 --> ( 难度等级: [0.4503, 0.4505) || 挂载数据: 无 ) 
│   │   │       ├── 隧道方案 --> ( 难度等级: [0.4503, 0.4503) || 挂载数据: 无 ) 
│   │   │       ├── 路由方案 --> ( 难度等级: [0.4503, 0.4504) || 挂载数据: 无 ) 
│   │   │       ├── 容器网络组网类型 --> ( 难度等级: [0.4504, 0.4504) || 挂载数据: 无 ) 
│   │   │       └── 关于容器网络标准接口 --> ( 难度等级: [0.4504, 0.4505) || 挂载数据: 无 ) 
│   │   ├── 标准的胜利：Kubernetes网络原理与实践 --> ( 难度等级: [0.4505, 0.4516) || 挂载数据: 无 ) 
│   │   │   ├── 容器基础设施的代言人：Kubernetes --> ( 难度等级: [0.4505, 0.4505) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes简介 --> ( 难度等级: [0.4505, 0.4505) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes能做什么 --> ( 难度等级: [0.4505, 0.4505) || 挂载数据: 无 ) 
│   │   │   │   ├── 如何用Kubernetes --> ( 难度等级: [0.4505, 0.4505) || 挂载数据: blog: 4 ) 
│   │   │   │   └── Docker在Kubernetes中的角色 --> ( 难度等级: [0.4505, 0.4505) || 挂载数据: 无 ) 
│   │   │   ├── 终于等到你：Kubernetes网络 --> ( 难度等级: [0.4505, 0.4506) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes网络基础 --> ( 难度等级: [0.4505, 0.4506) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── Kubernetes网络架构综述 --> ( 难度等级: [0.4506, 0.4506) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── Kubernetes主机内组网模型 --> ( 难度等级: [0.4506, 0.4506) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes跨节点组网模型 --> ( 难度等级: [0.4506, 0.4506) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod的hosts文件 --> ( 难度等级: [0.4506, 0.4506) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Pod的hostname --> ( 难度等级: [0.4506, 0.4506) || 挂载数据: 无 ) 
│   │   │   ├── Pod的核心：pause容器 --> ( 难度等级: [0.4506, 0.4507) || 挂载数据: 无 ) 
│   │   │   ├── 打通CNI与Kubernetes：Kubernetes网络驱动 --> ( 难度等级: [0.4507, 0.4508) || 挂载数据: 无 ) 
│   │   │   │   ├── 即将完成历史使命：Kubenet --> ( 难度等级: [0.4507, 0.4507) || 挂载数据: 无 ) 
│   │   │   │   └── 网络生态第一步：CNI --> ( 难度等级: [0.4507, 0.4508) || 挂载数据: blog: 2 ) 
│   │   │   ├── 找到你并不容易：从集群内访问服务 --> ( 难度等级: [0.4508, 0.4508) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes Service详解 --> ( 难度等级: [0.4508, 0.4508) || 挂载数据: 无 ) 
│   │   │   │   ├── Service的三个port --> ( 难度等级: [0.4508, 0.4508) || 挂载数据: 无 ) 
│   │   │   │   ├── 你的服务适合哪种发布形式 --> ( 难度等级: [0.4508, 0.4508) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes Service发现 --> ( 难度等级: [0.4508, 0.4508) || 挂载数据: 无 ) 
│   │   │   │   ├── 特殊的无头Service --> ( 难度等级: [0.4508, 0.4508) || 挂载数据: 无 ) 
│   │   │   │   └── 怎么访问本地服务 --> ( 难度等级: [0.4508, 0.4508) || 挂载数据: 无 ) 
│   │   │   ├── 找到你并不容易：从集群外访问服务 --> ( 难度等级: [0.4508, 0.4509) || 挂载数据: 无 ) 
│   │   │   │   └── Kubernetes Ingress --> ( 难度等级: [0.4508, 0.4509) || 挂载数据: 无 ) 
│   │   │   ├── 你的名字：通过域名访问服务 --> ( 难度等级: [0.4509, 0.451) || 挂载数据: 无 ) 
│   │   │   │   ├── DNS服务基本框架 --> ( 难度等级: [0.4509, 0.4509) || 挂载数据: 无 ) 
│   │   │   │   ├── 域名解析基本原理 --> ( 难度等级: [0.4509, 0.451) || 挂载数据: 无 ) 
│   │   │   │   └── 调试DNS --> ( 难度等级: [0.451, 0.451) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes网络策略：为你的应用保驾护航 --> ( 难度等级: [0.451, 0.4511) || 挂载数据: 无 ) 
│   │   │   │   └── 网络策略应用举例 --> ( 难度等级: [0.451, 0.4511) || 挂载数据: 无 ) 
│   │   │   ├── 前方高能：Kubernetes网络故障定位指南 --> ( 难度等级: [0.4511, 0.4512) || 挂载数据: 无 ) 
│   │   │   │   ├── IP转发和桥接 --> ( 难度等级: [0.4511, 0.4511) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod CIDR冲突 --> ( 难度等级: [0.4511, 0.4511) || 挂载数据: 无 ) 
│   │   │   │   ├── hairpin --> ( 难度等级: [0.4511, 0.4511) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看Pod IP地址 --> ( 难度等级: [0.4511, 0.4511) || 挂载数据: 无 ) 
│   │   │   │   └── 故障排查工具 --> ( 难度等级: [0.4511, 0.4512) || 挂载数据: 无 ) 
│   │   │   ├── 迈向云原生 --> ( 难度等级: [0.4512, 0.4512) || 挂载数据: 无 ) 
│   │   │   │   ├── 找个合理的理由打破巨石应用 --> ( 难度等级: [0.4512, 0.4512) || 挂载数据: 无 ) 
│   │   │   │   ├── 先解耦简单的服务 --> ( 难度等级: [0.4512, 0.4512) || 挂载数据: 无 ) 
│   │   │   │   ├── 学会小规模的运维 --> ( 难度等级: [0.4512, 0.4512) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 使用防损层模式 --> ( 难度等级: [0.4512, 0.4512) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用刀砍模式 --> ( 难度等级: [0.4512, 0.4512) || 挂载数据: 无 ) 
│   │   │   │   ├── 准备一个数据迁移策略 --> ( 难度等级: [0.4512, 0.4512) || 挂载数据: 无 ) 
│   │   │   │   ├── 重写所有模板代码 --> ( 难度等级: [0.4512, 0.4512) || 挂载数据: 无 ) 
│   │   │   │   └── 淘汰老代码 --> ( 难度等级: [0.4512, 0.4512) || 挂载数据: 无 ) 
│   │   │   ├── 确保弹性 --> ( 难度等级: [0.4512, 0.4513) || 挂载数据: 无 ) 
│   │   │   │   ├── 用重试来解决瞬时故障 --> ( 难度等级: [0.4512, 0.4512) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用有限次的重试 --> ( 难度等级: [0.4512, 0.4512) || 挂载数据: 无 ) 
│   │   │   │   ├── 用断路器来处理非瞬时故障 --> ( 难度等级: [0.4512, 0.4513) || 挂载数据: 无 ) 
│   │   │   │   ├── 优雅地降级 --> ( 难度等级: [0.4513, 0.4513) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用隔离模式 --> ( 难度等级: [0.4513, 0.4513) || 挂载数据: 无 ) 
│   │   │   │   ├── 实现健康及就绪检查 --> ( 难度等级: [0.4513, 0.4513) || 挂载数据: 无 ) 
│   │   │   │   ├── 为容器设定CPU和内存限制 --> ( 难度等级: [0.4513, 0.4513) || 挂载数据: 无 ) 
│   │   │   │   └── 实现限速和限流 --> ( 难度等级: [0.4513, 0.4513) || 挂载数据: 无 ) 
│   │   │   ├── 确保安全性 --> ( 难度等级: [0.4513, 0.4514) || 挂载数据: 无 ) 
│   │   │   │   ├── 安全性需求同其他需求一样重要 --> ( 难度等级: [0.4513, 0.4513) || 挂载数据: 无 ) 
│   │   │   │   ├── 在设计时就考虑安全性 --> ( 难度等级: [0.4513, 0.4513) || 挂载数据: 无 ) 
│   │   │   │   ├── 授予最小访问权限 --> ( 难度等级: [0.4513, 0.4513) || 挂载数据: 无 ) 
│   │   │   │   ├── 安全地存储所有密钥 --> ( 难度等级: [0.4513, 0.4513) || 挂载数据: 无 ) 
│   │   │   │   ├── 模糊化数据 --> ( 难度等级: [0.4513, 0.4514) || 挂载数据: 无 ) 
│   │   │   │   ├── 传输数据加密 --> ( 难度等级: [0.4514, 0.4514) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用联合身份管理 --> ( 难度等级: [0.4514, 0.4514) || 挂载数据: 无 ) 
│   │   │   │   └── Kubernetes pod的隔离 --> ( 难度等级: [0.4514, 0.4514) || 挂载数据: 无 ) 
│   │   │   ├── 处理数据 --> ( 难度等级: [0.4514, 0.4515) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用托管数据库和数据分析服务 --> ( 难度等级: [0.4514, 0.4514) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用符合数据需求的存储 --> ( 难度等级: [0.4514, 0.4514) || 挂载数据: 无 ) 
│   │   │   │   ├── 将数据保存在多个地域或可用区中 --> ( 难度等级: [0.4514, 0.4514) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用数据分区和复制以提高扩展性 --> ( 难度等级: [0.4514, 0.4514) || 挂载数据: 无 ) 
│   │   │   │   ├── 避免过度获取及频繁的I/O操作 --> ( 难度等级: [0.4514, 0.4514) || 挂载数据: 无 ) 
│   │   │   │   ├── 不要把业务逻辑放在数据库中执行 --> ( 难度等级: [0.4514, 0.4514) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用类生产环境数据来测试 --> ( 难度等级: [0.4514, 0.4514) || 挂载数据: 无 ) 
│   │   │   │   └── 处理瞬时故障 --> ( 难度等级: [0.4514, 0.4515) || 挂载数据: 无 ) 
│   │   │   ├── 性能和伸缩性 --> ( 难度等级: [0.4515, 0.4515) || 挂载数据: 无 ) 
│   │   │   │   ├── 设计可扩展的无状态服务 --> ( 难度等级: [0.4515, 0.4515) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用平台的自动伸缩功能 --> ( 难度等级: [0.4515, 0.4515) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用缓存 --> ( 难度等级: [0.4515, 0.4515) || 挂载数据: 无 ) 
│   │   │   │   └── 用分区来实现超出服务限制的扩容 --> ( 难度等级: [0.4515, 0.4515) || 挂载数据: blog: 1 ) 
│   │   │   └── 运维 --> ( 难度等级: [0.4515, 0.4516) || 挂载数据: blog: 1 ) 
│   │   │       ├── 部署和发布是两项独立的活动 --> ( 难度等级: [0.4515, 0.4515) || 挂载数据: 无 ) 
│   │   │       ├── 部署的内容要尽量小 --> ( 难度等级: [0.4515, 0.4515) || 挂载数据: 无 ) 
│   │   │       ├── 组件层级的CI/CD定义 --> ( 难度等级: [0.4515, 0.4516) || 挂载数据: 无 ) 
│   │   │       ├── 应用部署的一致性 --> ( 难度等级: [0.4516, 0.4516) || 挂载数据: 无 ) 
│   │   │       ├── 采用零宕机发布 --> ( 难度等级: [0.4516, 0.4516) || 挂载数据: 无 ) 
│   │   │       ├── 不要变更部署后的架构 --> ( 难度等级: [0.4516, 0.4516) || 挂载数据: 无 ) 
│   │   │       ├── 使用容器化构建 --> ( 难度等级: [0.4516, 0.4516) || 挂载数据: 无 ) 
│   │   │       ├── 用代码来描述基础设施 --> ( 难度等级: [0.4516, 0.4516) || 挂载数据: 无 ) 
│   │   │       ├── 使用命名空间来组织Kubernetes中的服务 --> ( 难度等级: [0.4516, 0.4516) || 挂载数据: 无 ) 
│   │   │       ├── 环境间的隔离 --> ( 难度等级: [0.4516, 0.4516) || 挂载数据: 无 ) 
│   │   │       ├── 分隔函数源代码 --> ( 难度等级: [0.4516, 0.4516) || 挂载数据: 无 ) 
│   │   │       └── 关联代码提交和部署 --> ( 难度等级: [0.4516, 0.4516) || 挂载数据: 无 ) 
│   │   ├── 刨根问底：Kubernetes网络实现机制 --> ( 难度等级: [0.4516, 0.4528) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes极客们的日常：DIY一个Ingress Controller --> ( 难度等级: [0.4516, 0.452) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Ingress Controller的通用框架 --> ( 难度等级: [0.4516, 0.4518) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Nginx Ingress Controller详解 --> ( 难度等级: [0.4518, 0.452) || 挂载数据: blog: 2 ) 
│   │   │   ├── 沧海桑田：Kubernetes DNS架构演进之路 --> ( 难度等级: [0.452, 0.4524) || 挂载数据: 无 ) 
│   │   │   │   ├── Kube-dns的工作原理 --> ( 难度等级: [0.452, 0.4521) || 挂载数据: 无 ) 
│   │   │   │   ├── 上位的CoreDNS --> ( 难度等级: [0.4521, 0.4523) || 挂载数据: 无 ) 
│   │   │   │   └── Kube-dns VS. CoreDNS --> ( 难度等级: [0.4523, 0.4524) || 挂载数据: blog: 8 ) 
│   │   │   └── 你的安全我负责：使用Calico提供Kubernetes网络策略 --> ( 难度等级: [0.4524, 0.4528) || 挂载数据: 无 ) 
│   │   │       ├── 部署一个带Calico的Kubernetes集群 --> ( 难度等级: [0.4524, 0.4526) || 挂载数据: blog: 5 ) 
│   │   │       └── 测试Calico网络策略 --> ( 难度等级: [0.4526, 0.4528) || 挂载数据: 无 ) 
│   │   ├── 百花齐放：Kubernetes网络插件生态 --> ( 难度等级: [0.4528, 0.4539) || 挂载数据: 无 ) 
│   │   │   ├── 从入门到放弃：Docker原生网络的不足 --> ( 难度等级: [0.4528, 0.4529) || 挂载数据: 无 ) 
│   │   │   ├── CNI标准的胜出：从此江湖没有CNM --> ( 难度等级: [0.4529, 0.4531) || 挂载数据: 无 ) 
│   │   │   │   └── CNI的工作原理 --> ( 难度等级: [0.4529, 0.4531) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes网络插件鼻祖flannel --> ( 难度等级: [0.4531, 0.4533) || 挂载数据: 无 ) 
│   │   │   │   ├── flannel简介 --> ( 难度等级: [0.4531, 0.4531) || 挂载数据: 无 ) 
│   │   │   │   ├── flannel安装配置 --> ( 难度等级: [0.4531, 0.4532) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── flannel backend详解 --> ( 难度等级: [0.4532, 0.4532) || 挂载数据: blog: 1 ) 
│   │   │   │   └── flannel与etcd --> ( 难度等级: [0.4532, 0.4533) || 挂载数据: blog: 7 ) 
│   │   │   ├── 全能大三层网络插件：Calico --> ( 难度等级: [0.4533, 0.4534) || 挂载数据: 无 ) 
│   │   │   │   ├── Calico简介 --> ( 难度等级: [0.4533, 0.4533) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Calico的隧道模式 --> ( 难度等级: [0.4533, 0.4533) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Calico --> ( 难度等级: [0.4533, 0.4534) || 挂载数据: 无 ) 
│   │   │   │   ├── Calico报文路径 --> ( 难度等级: [0.4534, 0.4534) || 挂载数据: 无 ) 
│   │   │   │   └── Calico使用指南 --> ( 难度等级: [0.4534, 0.4534) || 挂载数据: 无 ) 
│   │   │   ├── Weave：支持数据加密的网络插件 --> ( 难度等级: [0.4534, 0.4536) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave简介 --> ( 难度等级: [0.4534, 0.4535) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave实现原理 --> ( 难度等级: [0.4535, 0.4535) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave安装 --> ( 难度等级: [0.4535, 0.4535) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave网络通信模型 --> ( 难度等级: [0.4535, 0.4536) || 挂载数据: 无 ) 
│   │   │   │   └── Weave的应用示例 --> ( 难度等级: [0.4536, 0.4536) || 挂载数据: 无 ) 
│   │   │   ├── Cilium：为微服务网络连接安全而生 --> ( 难度等级: [0.4536, 0.4538) || 挂载数据: 无 ) 
│   │   │   │   ├── 以API为中心的微服务安全 --> ( 难度等级: [0.4536, 0.4537) || 挂载数据: 无 ) 
│   │   │   │   └── BPF优化的数据平面性能 --> ( 难度等级: [0.4537, 0.4538) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes多网络的先行者：CNI-Genie --> ( 难度等级: [0.4538, 0.4539) || 挂载数据: 无 ) 
│   │   │       ├── CNI-Genie功能速递 --> ( 难度等级: [0.4538, 0.4538) || 挂载数据: blog: 1 ) 
│   │   │       └── 容器多IP --> ( 难度等级: [0.4538, 0.4539) || 挂载数据: blog: 3 ) 
│   │   ├── Kubernetes网络下半场：Istio --> ( 难度等级: [0.4539, 0.4551) || 挂载数据: 无 ) 
│   │   │   ├── 微服务架构的大地震：sidecar模式 --> ( 难度等级: [0.4539, 0.4541) || 挂载数据: 无 ) 
│   │   │   │   ├── 你真的需要Service Mesh吗 --> ( 难度等级: [0.4539, 0.454) || 挂载数据: 无 ) 
│   │   │   │   ├── sidecar模式 --> ( 难度等级: [0.454, 0.454) || 挂载数据: 无 ) 
│   │   │   │   ├── Service Mesh与sidecar --> ( 难度等级: [0.454, 0.4541) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes Service VS. Service Mesh --> ( 难度等级: [0.4541, 0.4541) || 挂载数据: 无 ) 
│   │   │   │   └── Service Mesh典型实现之Linkerd --> ( 难度等级: [0.4541, 0.4541) || 挂载数据: 无 ) 
│   │   │   ├── Istio：引领新一代微服务架构潮流 --> ( 难度等级: [0.4541, 0.4544) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio简介 --> ( 难度等级: [0.4541, 0.4542) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio安装 --> ( 难度等级: [0.4542, 0.4543) || 挂载数据: 无 ) 
│   │   │   │   └── Istio路由规则的实现 --> ( 难度等级: [0.4543, 0.4544) || 挂载数据: 无 ) 
│   │   │   ├── 一切尽在不言中：Istio sidecar透明注入 --> ( 难度等级: [0.4544, 0.4546) || 挂载数据: 无 ) 
│   │   │   │   ├── Init容器 --> ( 难度等级: [0.4544, 0.4544) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── sideca注入示例 --> ( 难度等级: [0.4544, 0.4545) || 挂载数据: 无 ) 
│   │   │   │   ├── 手工注入sidecar --> ( 难度等级: [0.4545, 0.4545) || 挂载数据: 无 ) 
│   │   │   │   ├── 自动注入sidecar --> ( 难度等级: [0.4545, 0.4546) || 挂载数据: 无 ) 
│   │   │   │   └── 从应用容器到sidecar代理的通信 --> ( 难度等级: [0.4546, 0.4546) || 挂载数据: 无 ) 
│   │   │   ├── 不再为iptables脚本所困：Istio CNI插件 --> ( 难度等级: [0.4546, 0.4548) || 挂载数据: 无 ) 
│   │   │   └── 除了微服务，Istio还能做更多 --> ( 难度等级: [0.4548, 0.4551) || 挂载数据: 无 ) 
│   │   ├── 云原生简介 --> ( 难度等级: [0.4551, 0.4562) || 挂载数据: 无 ) 
│   │   │   ├── 分布式系统 --> ( 难度等级: [0.4551, 0.4555) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式系统的误区 --> ( 难度等级: [0.4551, 0.4553) || 挂载数据: blog: 1 ) 
│   │   │   │   └── CAP定理 --> ( 难度等级: [0.4553, 0.4555) || 挂载数据: 无 ) 
│   │   │   ├── 十二要素应用 --> ( 难度等级: [0.4555, 0.4558) || 挂载数据: 无 ) 
│   │   │   └── 可用性和服务等级协议 --> ( 难度等级: [0.4558, 0.4562) || 挂载数据: 无 ) 
│   │   ├── 云原生基础 --> ( 难度等级: [0.4562, 0.4574) || 挂载数据: 无 ) 
│   │   │   ├── 无服务器架构 --> ( 难度等级: [0.4562, 0.4565) || 挂载数据: 无 ) 
│   │   │   ├── 函数计算 --> ( 难度等级: [0.4565, 0.4568) || 挂载数据: 无 ) 
│   │   │   │   ├── 编写单一用途的函数 --> ( 难度等级: [0.4565, 0.4566) || 挂载数据: 无 ) 
│   │   │   │   ├── 避免串联函数 --> ( 难度等级: [0.4566, 0.4566) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数应保持轻量和简单 --> ( 难度等级: [0.4566, 0.4567) || 挂载数据: 无 ) 
│   │   │   │   ├── 实现无状态函数 --> ( 难度等级: [0.4567, 0.4567) || 挂载数据: 无 ) 
│   │   │   │   ├── 分离函数入口和函数的业务逻辑 --> ( 难度等级: [0.4567, 0.4567) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 避免长时间运行的函数 --> ( 难度等级: [0.4567, 0.4568) || 挂载数据: 无 ) 
│   │   │   ├── 从虚拟机到云原生 --> ( 难度等级: [0.4568, 0.4571) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 提升和转变 --> ( 难度等级: [0.4568, 0.4569) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── 应用的现代化改造 --> ( 难度等级: [0.4569, 0.457) || 挂载数据: 无 ) 
│   │   │   │   └── 应用的优化 --> ( 难度等级: [0.457, 0.4571) || 挂载数据: 无 ) 
│   │   │   └── 微服务 --> ( 难度等级: [0.4571, 0.4574) || 挂载数据: 无 ) 
│   │   │       ├── 微服务架构的优势 --> ( 难度等级: [0.4571, 0.4572) || 挂载数据: 无 ) 
│   │   │       └── 微服务架构带来的挑战 --> ( 难度等级: [0.4572, 0.4574) || 挂载数据: 无 ) 
│   │   ├── 云原生应用的设计 --> ( 难度等级: [0.4574, 0.4585) || 挂载数据: 无 ) 
│   │   │   ├── 云原生应用的基础 --> ( 难度等级: [0.4574, 0.4575) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 精益运营 --> ( 难度等级: [0.4574, 0.4574) || 挂载数据: 无 ) 
│   │   │   │   ├── 安全性 --> ( 难度等级: [0.4574, 0.4575) || 挂载数据: 无 ) 
│   │   │   │   └── 可扩展性与成本 --> ( 难度等级: [0.4575, 0.4575) || 挂载数据: blog: 1 ) 
│   │   │   ├── 云原生与传统架构的对比 --> ( 难度等级: [0.4575, 0.4577) || 挂载数据: blog: 10 ) 
│   │   │   ├── API设计与版本控制 --> ( 难度等级: [0.4577, 0.4578) || 挂载数据: 无 ) 
│   │   │   │   ├── API的前后兼容 --> ( 难度等级: [0.4577, 0.4577) || 挂载数据: blog: 3 ) 
│   │   │   │   └── 语义版本号 --> ( 难度等级: [0.4577, 0.4578) || 挂载数据: 无 ) 
│   │   │   ├── 服务间的通信 --> ( 难度等级: [0.4578, 0.4579) || 挂载数据: 无 ) 
│   │   │   │   ├── 通信协议 --> ( 难度等级: [0.4578, 0.4578) || 挂载数据: 无 ) 
│   │   │   │   ├── 消息协议 --> ( 难度等级: [0.4578, 0.4578) || 挂载数据: 无 ) 
│   │   │   │   ├── 序列化的考虑因素 --> ( 难度等级: [0.4578, 0.4578) || 挂载数据: 无 ) 
│   │   │   │   ├── 幂等性 --> ( 难度等级: [0.4578, 0.4578) || 挂载数据: 无 ) 
│   │   │   │   ├── 请求与响应 --> ( 难度等级: [0.4578, 0.4579) || 挂载数据: 无 ) 
│   │   │   │   ├── 发布者与订阅者 --> ( 难度等级: [0.4579, 0.4579) || 挂载数据: 无 ) 
│   │   │   │   ├── 发布者/订阅者模式与请求/响应模式间的选择 --> ( 难度等级: [0.4579, 0.4579) || 挂载数据: 无 ) 
│   │   │   │   ├── 同步与异步 --> ( 难度等级: [0.4579, 0.4579) || 挂载数据: 无 ) 
│   │   │   │   ├── 设计时考虑前后兼容性 --> ( 难度等级: [0.4579, 0.4579) || 挂载数据: 无 ) 
│   │   │   │   ├── 封装好服务避免泄露内部细节 --> ( 难度等级: [0.4579, 0.4579) || 挂载数据: 无 ) 
│   │   │   │   ├── 优先考虑异步通信 --> ( 难度等级: [0.4579, 0.4579) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用高效的序列化技术 --> ( 难度等级: [0.4579, 0.4579) || 挂载数据: 无 ) 
│   │   │   │   ├── 用批处理来提高请求处理的效率 --> ( 难度等级: [0.4579, 0.4579) || 挂载数据: 无 ) 
│   │   │   │   └── 拆分大的消息 --> ( 难度等级: [0.4579, 0.4579) || 挂载数据: 无 ) 
│   │   │   ├── 网关 --> ( 难度等级: [0.4579, 0.4581) || 挂载数据: 无 ) 
│   │   │   │   ├── 路由 --> ( 难度等级: [0.4579, 0.458) || 挂载数据: 无 ) 
│   │   │   │   ├── 聚合 --> ( 难度等级: [0.458, 0.458) || 挂载数据: 无 ) 
│   │   │   │   ├── 卸载 --> ( 难度等级: [0.458, 0.4581) || 挂载数据: 无 ) 
│   │   │   │   └── 网关的实现 --> ( 难度等级: [0.4581, 0.4581) || 挂载数据: 无 ) 
│   │   │   ├── 出口网关 --> ( 难度等级: [0.4581, 0.4582) || 挂载数据: 无 ) 
│   │   │   ├── 服务网格 --> ( 难度等级: [0.4582, 0.4584) || 挂载数据: 无 ) 
│   │   │   └── 架构示例 --> ( 难度等级: [0.4584, 0.4585) || 挂载数据: 无 ) 
│   │   ├── 数据处理 --> ( 难度等级: [0.4585, 0.4597) || 挂载数据: 无 ) 
│   │   │   ├── 数据存储系统 --> ( 难度等级: [0.4585, 0.4587) || 挂载数据: 无 ) 
│   │   │   │   ├── 对象、文件和磁盘 --> ( 难度等级: [0.4585, 0.4586) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据库 --> ( 难度等级: [0.4586, 0.4586) || 挂载数据: 无 ) 
│   │   │   │   ├── 流和队列 --> ( 难度等级: [0.4586, 0.4586) || 挂载数据: 无 ) 
│   │   │   │   ├── 区块链 --> ( 难度等级: [0.4586, 0.4587) || 挂载数据: blog: 3 ) 
│   │   │   │   └── 数据存储的选择 --> ( 难度等级: [0.4587, 0.4587) || 挂载数据: 无 ) 
│   │   │   ├── 多数据存储下的数据 --> ( 难度等级: [0.4587, 0.4589) || 挂载数据: 无 ) 
│   │   │   │   ├── 捕获数据更改 --> ( 难度等级: [0.4587, 0.4588) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 将更改作为事件写入更改日志 --> ( 难度等级: [0.4588, 0.4588) || 挂载数据: 无 ) 
│   │   │   │   ├── 事务监管 --> ( 难度等级: [0.4588, 0.4588) || 挂载数据: 无 ) 
│   │   │   │   ├── 事务回滚 --> ( 难度等级: [0.4588, 0.4589) || 挂载数据: 无 ) 
│   │   │   │   └── 提取、转换和加载 --> ( 难度等级: [0.4589, 0.4589) || 挂载数据: 无 ) 
│   │   │   ├── 客户端访问数据 --> ( 难度等级: [0.4589, 0.4591) || 挂载数据: 无 ) 
│   │   │   │   ├── 受限的客户令牌（代客密钥） --> ( 难度等级: [0.4589, 0.459) || 挂载数据: 无 ) 
│   │   │   │   ├── 细粒度访问控制的数据库服务 --> ( 难度等级: [0.459, 0.459) || 挂载数据: 无 ) 
│   │   │   │   └── GraphQL数据服务 --> ( 难度等级: [0.459, 0.4591) || 挂载数据: 无 ) 
│   │   │   ├── 可快速伸缩的数据 --> ( 难度等级: [0.4591, 0.4593) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据分片 --> ( 难度等级: [0.4591, 0.4592) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据缓存 --> ( 难度等级: [0.4592, 0.4592) || 挂载数据: 无 ) 
│   │   │   │   └── 内容分发网络 --> ( 难度等级: [0.4592, 0.4593) || 挂载数据: 无 ) 
│   │   │   ├── 数据分析 --> ( 难度等级: [0.4593, 0.4595) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 数据流 --> ( 难度等级: [0.4593, 0.4593) || 挂载数据: 无 ) 
│   │   │   │   ├── 批处理 --> ( 难度等级: [0.4593, 0.4594) || 挂载数据: 无 ) 
│   │   │   │   ├── 对象存储上的数据湖 --> ( 难度等级: [0.4594, 0.4594) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据湖和数据仓库 --> ( 难度等级: [0.4594, 0.4594) || 挂载数据: 无 ) 
│   │   │   │   └── 分布式查询引擎 --> ( 难度等级: [0.4594, 0.4595) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes中的数据库 --> ( 难度等级: [0.4595, 0.4597) || 挂载数据: 无 ) 
│   │   │       ├── StatefulSet --> ( 难度等级: [0.4595, 0.4596) || 挂载数据: 无 ) 
│   │   │       └── DaemonSet --> ( 难度等级: [0.4596, 0.4597) || 挂载数据: 无 ) 
│   │   ├── DevOps --> ( 难度等级: [0.4597, 0.4608) || 挂载数据: 无 ) 
│   │   │   ├── 什么是DevOps --> ( 难度等级: [0.4597, 0.4598) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── 协作 --> ( 难度等级: [0.4597, 0.4597) || 挂载数据: 无 ) 
│   │   │   │   ├── 自动化 --> ( 难度等级: [0.4597, 0.4597) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 精益原则和流程 --> ( 难度等级: [0.4597, 0.4598) || 挂载数据: 无 ) 
│   │   │   │   ├── 度量 --> ( 难度等级: [0.4598, 0.4598) || 挂载数据: 无 ) 
│   │   │   │   └── 分享 --> ( 难度等级: [0.4598, 0.4598) || 挂载数据: 无 ) 
│   │   │   ├── 测试 --> ( 难度等级: [0.4598, 0.46) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试替身 --> ( 难度等级: [0.4598, 0.4599) || 挂载数据: 无 ) 
│   │   │   │   ├── 自动化测试金字塔 --> ( 难度等级: [0.4599, 0.4599) || 挂载数据: 无 ) 
│   │   │   │   ├── 不同测试类型的适用时机 --> ( 难度等级: [0.4599, 0.4599) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试节奏 --> ( 难度等级: [0.4599, 0.46) || 挂载数据: 无 ) 
│   │   │   │   └── 在生产环境中测试 --> ( 难度等级: [0.46, 0.46) || 挂载数据: 无 ) 
│   │   │   ├── 开发环境和工具 --> ( 难度等级: [0.46, 0.4602) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发工具 --> ( 难度等级: [0.46, 0.46) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发环境 --> ( 难度等级: [0.46, 0.4601) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── 本地开发环境 --> ( 难度等级: [0.4601, 0.4601) || 挂载数据: 无 ) 
│   │   │   │   ├── 本地开发环境结合远端集群 --> ( 难度等级: [0.4601, 0.4601) || 挂载数据: 无 ) 
│   │   │   │   ├── Skaffold开发工作流 --> ( 难度等级: [0.4601, 0.4601) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 将远端集群路由到本地开发环境 --> ( 难度等级: [0.4601, 0.4601) || 挂载数据: 无 ) 
│   │   │   │   └── 云端开发环境 --> ( 难度等级: [0.4601, 0.4602) || 挂载数据: 无 ) 
│   │   │   ├── 持续集成/持续交付 --> ( 难度等级: [0.4602, 0.4603) || 挂载数据: 无 ) 
│   │   │   │   ├── 源代码管理 --> ( 难度等级: [0.4602, 0.4602) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建阶段 --> ( 难度等级: [0.4602, 0.4602) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试阶段 --> ( 难度等级: [0.4602, 0.4603) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署阶段 --> ( 难度等级: [0.4603, 0.4603) || 挂载数据: 无 ) 
│   │   │   │   ├── 发布阶段 --> ( 难度等级: [0.4603, 0.4603) || 挂载数据: 无 ) 
│   │   │   │   └── 发布后阶段 --> ( 难度等级: [0.4603, 0.4603) || 挂载数据: 无 ) 
│   │   │   ├── 监控 --> ( 难度等级: [0.4603, 0.4605) || 挂载数据: 无 ) 
│   │   │   │   ├── 收集指标 --> ( 难度等级: [0.4603, 0.4604) || 挂载数据: 无 ) 
│   │   │   │   └── 服务的可观测性 --> ( 难度等级: [0.4604, 0.4605) || 挂载数据: 无 ) 
│   │   │   ├── 配置管理 --> ( 难度等级: [0.4605, 0.4607) || 挂载数据: 无 ) 
│   │   │   │   ├── 单一环境变量 --> ( 难度等级: [0.4605, 0.4605) || 挂载数据: 无 ) 
│   │   │   │   ├── 将配置数据放入存储卷中 --> ( 难度等级: [0.4605, 0.4606) || 挂载数据: 无 ) 
│   │   │   │   ├── 密钥保存 --> ( 难度等级: [0.4606, 0.4606) || 挂载数据: 无 ) 
│   │   │   │   └── 部署配置 --> ( 难度等级: [0.4606, 0.4607) || 挂载数据: 无 ) 
│   │   │   └── 持续集成/持续交付流程示例 --> ( 难度等级: [0.4607, 0.4608) || 挂载数据: 无 ) 
│   │   ├── 可移植性 --> ( 难度等级: [0.4608, 0.462) || 挂载数据: 无 ) 
│   │   │   ├── 可移植性的代价 --> ( 难度等级: [0.4608, 0.4614) || 挂载数据: 无 ) 
│   │   │   └── 何时及如何实现可移植性 --> ( 难度等级: [0.4614, 0.462) || 挂载数据: 无 ) 
│   │   │       ├── 标准化的接口 --> ( 难度等级: [0.4614, 0.4615) || 挂载数据: 无 ) 
│   │   │       ├── 共用的服务和功能 --> ( 难度等级: [0.4615, 0.4616) || 挂载数据: 无 ) 
│   │   │       ├── 抽象和分层 --> ( 难度等级: [0.4616, 0.4617) || 挂载数据: 无 ) 
│   │   │       ├── 第三方服务商的托管服务 --> ( 难度等级: [0.4617, 0.4618) || 挂载数据: 无 ) 
│   │   │       ├── 可移植性工具 --> ( 难度等级: [0.4618, 0.4619) || 挂载数据: 无 ) 
│   │   │       └── 把Kubernetes作为可移植性层 --> ( 难度等级: [0.4619, 0.462) || 挂载数据: 无 ) 
│   │   ├── 理论篇（技术进阶） --> ( 难度等级: [0.462, 0.4631) || 挂载数据: 无 ) 
│   │   │   ├── 鸟瞰云上Kubernetes --> ( 难度等级: [0.462, 0.4621) || 挂载数据: 无 ) 
│   │   │   │   ├── 内容概要 --> ( 难度等级: [0.462, 0.462) || 挂载数据: 无 ) 
│   │   │   │   ├── 云资源层 --> ( 难度等级: [0.462, 0.462) || 挂载数据: blog: 2 ) 
│   │   │   │   │   ├── 专有版 --> ( 难度等级: [0.462, 0.462) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 托管版 --> ( 难度等级: [0.462, 0.462) || 挂载数据: 无 ) 
│   │   │   │   │   └── Serverless版 --> ( 难度等级: [0.462, 0.462) || 挂载数据: 无 ) 
│   │   │   │   ├── 单机系统层 --> ( 难度等级: [0.462, 0.4621) || 挂载数据: 无 ) 
│   │   │   │   ├── 集群系统层 --> ( 难度等级: [0.4621, 0.4621) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 专有版 --> ( 难度等级: [0.4621, 0.4621) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 托管版 --> ( 难度等级: [0.4621, 0.4621) || 挂载数据: 无 ) 
│   │   │   │   │   └── Serverless版 --> ( 难度等级: [0.4621, 0.4621) || 挂载数据: 无 ) 
│   │   │   │   └── 功能扩展层 --> ( 难度等级: [0.4621, 0.4621) || 挂载数据: 无 ) 
│   │   │   │       └── 日志 --> ( 难度等级: [0.4621, 0.4621) || 挂载数据: 无 ) 
│   │   │   ├── 认识集群的大脑 --> ( 难度等级: [0.4621, 0.4622) || 挂载数据: 无 ) 
│   │   │   │   ├── 从控制器视角看集群 --> ( 难度等级: [0.4621, 0.4622) || 挂载数据: 无 ) 
│   │   │   │   └── 控制器示例 --> ( 难度等级: [0.4622, 0.4622) || 挂载数据: 无 ) 
│   │   │   │       ├── 服务控制器 --> ( 难度等级: [0.4622, 0.4622) || 挂载数据: blog: 1 ) 
│   │   │   │       └── 路由控制器 --> ( 难度等级: [0.4622, 0.4622) || 挂载数据: 无 ) 
│   │   │   ├── 网络与通信原理 --> ( 难度等级: [0.4622, 0.4623) || 挂载数据: 无 ) 
│   │   │   │   ├── 背景 --> ( 难度等级: [0.4622, 0.4622) || 挂载数据: 无 ) 
│   │   │   │   ├── 阿里云Kubernetes集群网络大图 --> ( 难度等级: [0.4622, 0.4623) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 集群网络搭建 --> ( 难度等级: [0.4623, 0.4623) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 初始阶段 --> ( 难度等级: [0.4623, 0.4623) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 集群阶段 --> ( 难度等级: [0.4623, 0.4623) || 挂载数据: blog: 2 ) 
│   │   │   │   │   ├── 节点阶段 --> ( 难度等级: [0.4623, 0.4623) || 挂载数据: 无 ) 
│   │   │   │   │   └── Pod阶段 --> ( 难度等级: [0.4623, 0.4623) || 挂载数据: 无 ) 
│   │   │   │   └── 通信原理 --> ( 难度等级: [0.4623, 0.4623) || 挂载数据: 无 ) 
│   │   │   ├── 节点伸缩的实现 --> ( 难度等级: [0.4623, 0.4624) || 挂载数据: 无 ) 
│   │   │   │   ├── 节点增加原理 --> ( 难度等级: [0.4623, 0.4624) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 手动添加已有节点 --> ( 难度等级: [0.4623, 0.4623) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 自动添加已有节点 --> ( 难度等级: [0.4623, 0.4623) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 集群扩容 --> ( 难度等级: [0.4623, 0.4624) || 挂载数据: 无 ) 
│   │   │   │   │   └── 自动伸缩 --> ( 难度等级: [0.4624, 0.4624) || 挂载数据: 无 ) 
│   │   │   │   ├── 节点减少原理 --> ( 难度等级: [0.4624, 0.4624) || 挂载数据: 无 ) 
│   │   │   │   └── 节点池原理 --> ( 难度等级: [0.4624, 0.4624) || 挂载数据: 无 ) 
│   │   │   ├── 简洁的服务模型 --> ( 难度等级: [0.4624, 0.4626) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务的本质是什么 --> ( 难度等级: [0.4624, 0.4625) || 挂载数据: 无 ) 
│   │   │   │   ├── 自带通信员 --> ( 难度等级: [0.4625, 0.4625) || 挂载数据: 无 ) 
│   │   │   │   ├── 让服务照进现实 --> ( 难度等级: [0.4625, 0.4625) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Netfilter的实现 --> ( 难度等级: [0.4625, 0.4626) || 挂载数据: 无 ) 
│   │   │   │       ├── 过滤器框架 --> ( 难度等级: [0.4625, 0.4625) || 挂载数据: 无 ) 
│   │   │   │       ├── 节点网络大图 --> ( 难度等级: [0.4625, 0.4625) || 挂载数据: 无 ) 
│   │   │   │       ├── 升级过滤器框架 --> ( 难度等级: [0.4625, 0.4626) || 挂载数据: 无 ) 
│   │   │   │       └── 用自定义链实现服务的反向代理 --> ( 难度等级: [0.4626, 0.4626) || 挂载数据: 无 ) 
│   │   │   ├── 镜像下载自动化 --> ( 难度等级: [0.4626, 0.4627) || 挂载数据: 无 ) 
│   │   │   │   ├── 镜像下载这件小事 --> ( 难度等级: [0.4626, 0.4626) || 挂载数据: 无 ) 
│   │   │   │   ├── 理解OAuth 2.0协议 --> ( 难度等级: [0.4626, 0.4626) || 挂载数据: blog: 10 ) 
│   │   │   │   ├── Docker扮演的角色 --> ( 难度等级: [0.4626, 0.4626) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 整体结构 --> ( 难度等级: [0.4626, 0.4626) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 理解docker login --> ( 难度等级: [0.4626, 0.4626) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── 拉取镜像是怎么回事 --> ( 难度等级: [0.4626, 0.4626) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Kubernetes实现的私有镜像自动拉取 --> ( 难度等级: [0.4626, 0.4626) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 基本功能 --> ( 难度等级: [0.4626, 0.4626) || 挂载数据: 无 ) 
│   │   │   │   │   └── 进阶方式 --> ( 难度等级: [0.4626, 0.4626) || 挂载数据: 无 ) 
│   │   │   │   └── 阿里云实现的ACR credential helper --> ( 难度等级: [0.4626, 0.4627) || 挂载数据: blog: 10 ) 
│   │   │   ├── 日志服务的集成 --> ( 难度等级: [0.4627, 0.4628) || 挂载数据: 无 ) 
│   │   │   │   ├── 日志服务介绍 --> ( 难度等级: [0.4627, 0.4627) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 采集方案介绍 --> ( 难度等级: [0.4627, 0.4627) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 方案简介 --> ( 难度等级: [0.4627, 0.4627) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 运行流程 --> ( 难度等级: [0.4627, 0.4627) || 挂载数据: 无 ) 
│   │   │   │   │   └── 配置方式 --> ( 难度等级: [0.4627, 0.4627) || 挂载数据: 无 ) 
│   │   │   │   └── 核心技术介绍 --> ( 难度等级: [0.4627, 0.4628) || 挂载数据: 无 ) 
│   │   │   │       ├── 背景 --> ( 难度等级: [0.4627, 0.4628) || 挂载数据: 无 ) 
│   │   │   │       ├── 实现方式 --> ( 难度等级: [0.4628, 0.4628) || 挂载数据: 无 ) 
│   │   │   │       └── alibaba-log-controller内部实现 --> ( 难度等级: [0.4628, 0.4628) || 挂载数据: blog: 1 ) 
│   │   │   ├── 集群与存储系统 --> ( 难度等级: [0.4628, 0.4629) || 挂载数据: 无 ) 
│   │   │   │   ├── 从应用的状态谈起 --> ( 难度等级: [0.4628, 0.4628) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 无状态的应用 --> ( 难度等级: [0.4628, 0.4628) || 挂载数据: 无 ) 
│   │   │   │   │   └── 有状态的应用 --> ( 难度等级: [0.4628, 0.4628) || 挂载数据: 无 ) 
│   │   │   │   ├── 基本单元：Pod Volume --> ( 难度等级: [0.4628, 0.4628) || 挂载数据: 无 ) 
│   │   │   │   ├── 核心设计：PVC与PV体系 --> ( 难度等级: [0.4628, 0.4628) || 挂载数据: 无 ) 
│   │   │   │   ├── 与特定存储系统解耦 --> ( 难度等级: [0.4628, 0.4629) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Volume Plugin --> ( 难度等级: [0.4628, 0.4629) || 挂载数据: 无 ) 
│   │   │   │   │   ├── in-tree（内置） Volume Plugin --> ( 难度等级: [0.4629, 0.4629) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── out-of-tree（外置） Volume Plugin --> ( 难度等级: [0.4629, 0.4629) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes CSI管控组件容器化部署 --> ( 难度等级: [0.4629, 0.4629) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Kubernetes的存储 --> ( 难度等级: [0.4629, 0.4629) || 挂载数据: 无 ) 
│   │   │   ├── 流量路由Ingress --> ( 难度等级: [0.4629, 0.463) || 挂载数据: 无 ) 
│   │   │   │   ├── 基本原理 --> ( 难度等级: [0.4629, 0.4629) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 基础用法 --> ( 难度等级: [0.4629, 0.4629) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 配置安全路由 --> ( 难度等级: [0.4629, 0.4629) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 全局配置和局部配置 --> ( 难度等级: [0.4629, 0.4629) || 挂载数据: 无 ) 
│   │   │   │   │   └── 实现原理 --> ( 难度等级: [0.4629, 0.4629) || 挂载数据: 无 ) 
│   │   │   │   ├── 场景化需求 --> ( 难度等级: [0.4629, 0.463) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 多入口访问Ingress --> ( 难度等级: [0.4629, 0.4629) || 挂载数据: 无 ) 
│   │   │   │   │   └── 部署多套Ingress Controller --> ( 难度等级: [0.4629, 0.463) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取客户端真实IP地址 --> ( 难度等级: [0.463, 0.463) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 理解客户端真实IP地址的传递过程 --> ( 难度等级: [0.463, 0.463) || 挂载数据: 无 ) 
│   │   │   │   │   ├── ExternalTrafficPolicy的影响 --> ( 难度等级: [0.463, 0.463) || 挂载数据: 无 ) 
│   │   │   │   │   └── 如何获取客户端真实IP地址 --> ( 难度等级: [0.463, 0.463) || 挂载数据: 无 ) 
│   │   │   │   └── 白名单功能 --> ( 难度等级: [0.463, 0.463) || 挂载数据: 无 ) 
│   │   │   └── 升级设计与实现 --> ( 难度等级: [0.463, 0.4631) || 挂载数据: 无 ) 
│   │   │       ├── 升级预检 --> ( 难度等级: [0.463, 0.4631) || 挂载数据: 无 ) 
│   │   │       │   ├── 核心组件检查项 --> ( 难度等级: [0.463, 0.463) || 挂载数据: 无 ) 
│   │   │       │   └── 前置检查增项 --> ( 难度等级: [0.463, 0.4631) || 挂载数据: 无 ) 
│   │   │       ├── 原地升级与替代升级 --> ( 难度等级: [0.4631, 0.4631) || 挂载数据: 无 ) 
│   │   │       │   ├── 原地升级 --> ( 难度等级: [0.4631, 0.4631) || 挂载数据: 无 ) 
│   │   │       │   └── 替代升级 --> ( 难度等级: [0.4631, 0.4631) || 挂载数据: 无 ) 
│   │   │       └── 升级三部曲 --> ( 难度等级: [0.4631, 0.4631) || 挂载数据: 无 ) 
│   │   │           ├── 升级Master节点 --> ( 难度等级: [0.4631, 0.4631) || 挂载数据: 无 ) 
│   │   │           ├── 升级Worker节点 --> ( 难度等级: [0.4631, 0.4631) || 挂载数据: 无 ) 
│   │   │           └── 核心组件升级 --> ( 难度等级: [0.4631, 0.4631) || 挂载数据: 无 ) 
│   │   └── 实践篇（诊断之美） --> ( 难度等级: [0.4631, 0.4643) || 挂载数据: 无 ) 
│   │       ├── 节点就绪状态异常（一） --> ( 难度等级: [0.4631, 0.4633) || 挂载数据: 无 ) 
│   │       │   ├── Docker栈 --> ( 难度等级: [0.4631, 0.4632) || 挂载数据: 无 ) 
│   │       │   │   ├── docker daemon调用栈分析 --> ( 难度等级: [0.4631, 0.4632) || 挂载数据: 无 ) 
│   │       │   │   └── Containerd调用栈分析 --> ( 难度等级: [0.4632, 0.4632) || 挂载数据: 无 ) 
│   │       │   ├── 什么是D-Bus --> ( 难度等级: [0.4632, 0.4633) || 挂载数据: 无 ) 
│   │       │   │   ├── runC请求D-Bus --> ( 难度等级: [0.4632, 0.4632) || 挂载数据: blog: 1 ) 
│   │       │   │   └── 原因并不在D-Bus --> ( 难度等级: [0.4632, 0.4633) || 挂载数据: 无 ) 
│   │       │   └── Systemd是硬骨头 --> ( 难度等级: [0.4633, 0.4633) || 挂载数据: blog: 2 ) 
│   │       │       ├── “没用”的core dump --> ( 难度等级: [0.4633, 0.4633) || 挂载数据: blog: 1 ) 
│   │       │       ├── 零散的信息 --> ( 难度等级: [0.4633, 0.4633) || 挂载数据: 无 ) 
│   │       │       ├── 代码分析 --> ( 难度等级: [0.4633, 0.4633) || 挂载数据: 无 ) 
│   │       │       └── Live Debugging --> ( 难度等级: [0.4633, 0.4633) || 挂载数据: 无 ) 
│   │       ├── 节点就绪状态异常（二） --> ( 难度等级: [0.4633, 0.4635) || 挂载数据: 无 ) 
│   │       │   ├── 节点状态机 --> ( 难度等级: [0.4633, 0.4634) || 挂载数据: 无 ) 
│   │       │   ├── 就绪三分钟 --> ( 难度等级: [0.4634, 0.4634) || 挂载数据: 无 ) 
│   │       │   ├── 止步不前的PLEG --> ( 难度等级: [0.4634, 0.4634) || 挂载数据: 无 ) 
│   │       │   ├── 无响应的Terwayd --> ( 难度等级: [0.4634, 0.4635) || 挂载数据: 无 ) 
│   │       │   ├── 原因 --> ( 难度等级: [0.4635, 0.4635) || 挂载数据: 无 ) 
│   │       │   └── 修复 --> ( 难度等级: [0.4635, 0.4635) || 挂载数据: 无 ) 
│   │       ├── 命名空间回收机制失效 --> ( 难度等级: [0.4635, 0.4637) || 挂载数据: 无 ) 
│   │       │   ├── 集群管控入口 --> ( 难度等级: [0.4635, 0.4636) || 挂载数据: 无 ) 
│   │       │   ├── 命名空间控制器的行为 --> ( 难度等级: [0.4636, 0.4636) || 挂载数据: 无 ) 
│   │       │   │   ├── 删除收纳盒里的资源 --> ( 难度等级: [0.4636, 0.4636) || 挂载数据: 无 ) 
│   │       │   │   ├── API、Group、Version --> ( 难度等级: [0.4636, 0.4636) || 挂载数据: 无 ) 
│   │       │   │   └── 控制器不能删除命名空间里的资源 --> ( 难度等级: [0.4636, 0.4636) || 挂载数据: 无 ) 
│   │       │   ├── 回到集群管控入口 --> ( 难度等级: [0.4636, 0.4636) || 挂载数据: 无 ) 
│   │       │   ├── 节点与Pod的通信 --> ( 难度等级: [0.4636, 0.4637) || 挂载数据: 无 ) 
│   │       │   └── 集群节点访问云资源 --> ( 难度等级: [0.4637, 0.4637) || 挂载数据: 无 ) 
│   │       ├── 网络安全组加固对与错 --> ( 难度等级: [0.4637, 0.4639) || 挂载数据: 无 ) 
│   │       │   ├── 安全组扮演的角色 --> ( 难度等级: [0.4637, 0.4638) || 挂载数据: 无 ) 
│   │       │   ├── 安全组与集群网络 --> ( 难度等级: [0.4638, 0.4638) || 挂载数据: 无 ) 
│   │       │   └── 怎么管理安全组规则 --> ( 难度等级: [0.4638, 0.4639) || 挂载数据: 无 ) 
│   │       │       ├── 限制集群访问外网 --> ( 难度等级: [0.4638, 0.4639) || 挂载数据: 无 ) 
│   │       │       ├── IDC与集群互访 --> ( 难度等级: [0.4639, 0.4639) || 挂载数据: blog: 1 ) 
│   │       │       └── 使用新的安全组管理节点 --> ( 难度等级: [0.4639, 0.4639) || 挂载数据: 无 ) 
│   │       ├── 网格应用存活状态异常 --> ( 难度等级: [0.4639, 0.4641) || 挂载数据: 无 ) 
│   │       │   ├── 代理与代理的生命周期管理 --> ( 难度等级: [0.4639, 0.4639) || 挂载数据: 无 ) 
│   │       │   ├── 控制面和数据面 --> ( 难度等级: [0.4639, 0.464) || 挂载数据: 无 ) 
│   │       │   ├── 简单的原因 --> ( 难度等级: [0.464, 0.464) || 挂载数据: 无 ) 
│   │       │   └── 阿里云服务网格（ASM）介绍 --> ( 难度等级: [0.464, 0.4641) || 挂载数据: blog: 10 ) 
│   │       └── 网格自签名根证书过期 --> ( 难度等级: [0.4641, 0.4643) || 挂载数据: 无 ) 
│   │           ├── 连续重启的Citadel --> ( 难度等级: [0.4641, 0.4641) || 挂载数据: 无 ) 
│   │           ├── 一般意义上的证书验证 --> ( 难度等级: [0.4641, 0.4642) || 挂载数据: 无 ) 
│   │           ├── 自签名证书验证失败 --> ( 难度等级: [0.4642, 0.4642) || 挂载数据: 无 ) 
│   │           ├── 大神定理 --> ( 难度等级: [0.4642, 0.4642) || 挂载数据: 无 ) 
│   │           ├── Citadel证书体系 --> ( 难度等级: [0.4642, 0.4643) || 挂载数据: 无 ) 
│   │           └── 经验 --> ( 难度等级: [0.4643, 0.4643) || 挂载数据: 无 ) 
│   ├── DevOps --> ( 难度等级: [0.4643, 0.5) || 挂载数据: 无 ) 
│   │   ├── 运维 --> ( 难度等级: [0.4643, 0.4732) || 挂载数据: 无 ) 
│   │   │   └── 配置 --> ( 难度等级: [0.4643, 0.4732) || 挂载数据: 无 ) 
│   │   │       ├── CUE(Cisco Unity Express) --> ( 难度等级: [0.4643, 0.4658) || 挂载数据: blog: 8 ) 
│   │   │       ├── Jsonnet --> ( 难度等级: [0.4658, 0.4673) || 挂载数据: 无 ) 
│   │   │       ├── HCL --> ( 难度等级: [0.4673, 0.4688) || 挂载数据: 无 ) 
│   │   │       ├── BCL --> ( 难度等级: [0.4688, 0.4702) || 挂载数据: 无 ) 
│   │   │       ├── KubeVela --> ( 难度等级: [0.4702, 0.4717) || 挂载数据: 无 ) 
│   │   │       └── Terraform --> ( 难度等级: [0.4717, 0.4732) || 挂载数据: blog: 7 ) 
│   │   ├── API --> ( 难度等级: [0.4732, 0.4821) || 挂载数据: 无 ) 
│   │   │   ├── GraphQL --> ( 难度等级: [0.4732, 0.4762) || 挂载数据: 无 ) 
│   │   │   ├── Swagger UI --> ( 难度等级: [0.4762, 0.4792) || 挂载数据: 无 ) 
│   │   │   └── gRPC --> ( 难度等级: [0.4792, 0.4821) || 挂载数据: 无 ) 
│   │   ├── 诊断 --> ( 难度等级: [0.4821, 0.4911) || 挂载数据: 无 ) 
│   │   │   ├── OpenTracing标准 --> ( 难度等级: [0.4821, 0.4839) || 挂载数据: 无 ) 
│   │   │   ├── SkyWalking --> ( 难度等级: [0.4839, 0.4857) || 挂载数据: 无 ) 
│   │   │   ├── Zipkin --> ( 难度等级: [0.4857, 0.4875) || 挂载数据: 无 ) 
│   │   │   ├── Jaeger --> ( 难度等级: [0.4875, 0.4893) || 挂载数据: 无 ) 
│   │   │   └── Sonobuoy --> ( 难度等级: [0.4893, 0.4911) || 挂载数据: 无 ) 
│   │   └── 质量 --> ( 难度等级: [0.4911, 0.5) || 挂载数据: 无 ) 
│   │       ├── Litmus --> ( 难度等级: [0.4911, 0.4955) || 挂载数据: 无 ) 
│   │       └── Sysbench --> ( 难度等级: [0.4955, 0.5) || 挂载数据: 无 ) 
│   ├── 操作系统 --> ( 难度等级: [0.5, 0.5357) || 挂载数据: 无 ) 
│   │   ├── CoreOS --> ( 难度等级: [0.5, 0.5119) || 挂载数据: blog: 1 ) 
│   │   ├── Alibaba Linux --> ( 难度等级: [0.5119, 0.5238) || 挂载数据: 无 ) 
│   │   └── Tencent Linux --> ( 难度等级: [0.5238, 0.5357) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.5357, 0.5714) || 挂载数据: 无 ) 
├── 云原生高阶-应用开发 --> ( 难度等级: [0.5714, 0.7143) || 挂载数据: 无 ) 
│   ├── Serverless --> ( 难度等级: [0.5714, 0.619) || 挂载数据: 无 ) 
│   │   └── BaaS Serverless --> ( 难度等级: [0.5714, 0.619) || 挂载数据: 无 ) 
│   │       ├── Spring Cloud Connector --> ( 难度等级: [0.5714, 0.5952) || 挂载数据: 无 ) 
│   │       └── Open Service Broker --> ( 难度等级: [0.5952, 0.619) || 挂载数据: 无 ) 
│   ├── 编程语言 --> ( 难度等级: [0.619, 0.6667) || 挂载数据: 无 ) 
│   │   └── Java --> ( 难度等级: [0.619, 0.6667) || 挂载数据: blog: 10 ) 
│   │       ├── 减小镜像 --> ( 难度等级: [0.619, 0.6349) || 挂载数据: 无 ) 
│   │       │   ├── Alpine Portola --> ( 难度等级: [0.619, 0.6243) || 挂载数据: 无 ) 
│   │       │   ├── JDK (version >= 9) --> ( 难度等级: [0.6243, 0.6296) || 挂载数据: 无 ) 
│   │       │   └── Spring Boot (version > 2.3) --> ( 难度等级: [0.6296, 0.6349) || 挂载数据: 无 ) 
│   │       ├── 降低资源占用率 --> ( 难度等级: [0.6349, 0.6508) || 挂载数据: 无 ) 
│   │       │   ├── Project Panama --> ( 难度等级: [0.6349, 0.6429) || 挂载数据: 无 ) 
│   │       │   └── Project Valhalla --> ( 难度等级: [0.6429, 0.6508) || 挂载数据: 无 ) 
│   │       └── 缩短冷启动时间 --> ( 难度等级: [0.6508, 0.6667) || 挂载数据: 无 ) 
│   │           ├── GraalVM --> ( 难度等级: [0.6508, 0.6548) || 挂载数据: blog: 2 ) 
│   │           ├── Quarkus --> ( 难度等级: [0.6548, 0.6587) || 挂载数据: blog: 1 ) 
│   │           ├── Micronaut --> ( 难度等级: [0.6587, 0.6627) || 挂载数据: 无 ) 
│   │           └── Helidon --> ( 难度等级: [0.6627, 0.6667) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.6667, 0.7143) || 挂载数据: 无 ) 
├── 云原生高阶-平台开发 --> ( 难度等级: [0.7143, 0.8571) || 挂载数据: 无 ) 
│   ├── Kubernetes --> ( 难度等级: [0.7143, 0.75) || 挂载数据: 无 ) 
│   │   ├── 接口 --> ( 难度等级: [0.7143, 0.7321) || 挂载数据: 无 ) 
│   │   │   ├── CNI(Container Network Interface) --> ( 难度等级: [0.7143, 0.7202) || 挂载数据: 无 ) 
│   │   │   │   ├── Flannel --> ( 难度等级: [0.7143, 0.715) || 挂载数据: 无 ) 
│   │   │   │   ├── Calico --> ( 难度等级: [0.715, 0.7158) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave --> ( 难度等级: [0.7158, 0.7165) || 挂载数据: 无 ) 
│   │   │   │   ├── OVN(Open Virtual Network) --> ( 难度等级: [0.7165, 0.7173) || 挂载数据: 无 ) 
│   │   │   │   ├── SR-IOV(Single-root Input/Output Virtualization) --> ( 难度等级: [0.7173, 0.718) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Romana --> ( 难度等级: [0.718, 0.7187) || 挂载数据: 无 ) 
│   │   │   │   ├── OpenContrail --> ( 难度等级: [0.7187, 0.7195) || 挂载数据: 无 ) 
│   │   │   │   └── Kuryr --> ( 难度等级: [0.7195, 0.7202) || 挂载数据: 无 ) 
│   │   │   ├── CRI(Container Runtime Interface) --> ( 难度等级: [0.7202, 0.7262) || 挂载数据: 无 ) 
│   │   │   │   └── Frakti --> ( 难度等级: [0.7202, 0.7262) || 挂载数据: 无 ) 
│   │   │   └── CSI(Container Storage Interface) --> ( 难度等级: [0.7262, 0.7321) || 挂载数据: 无 ) 
│   │   │       ├── FlexVolume --> ( 难度等级: [0.7262, 0.7292) || 挂载数据: 无 ) 
│   │   │       └── GlusterFS --> ( 难度等级: [0.7292, 0.7321) || 挂载数据: 无 ) 
│   │   └── PaaS --> ( 难度等级: [0.7321, 0.75) || 挂载数据: 无 ) 
│   │       ├── Cloud Foundry --> ( 难度等级: [0.7321, 0.7366) || 挂载数据: blog: 6 ) 
│   │       ├── Crossplane --> ( 难度等级: [0.7366, 0.7411) || 挂载数据: 无 ) 
│   │       ├── Anthos --> ( 难度等级: [0.7411, 0.7455) || 挂载数据: 无 ) 
│   │       └── KubeSphere --> ( 难度等级: [0.7455, 0.75) || 挂载数据: 无 ) 
│   ├── DevOps --> ( 难度等级: [0.75, 0.7857) || 挂载数据: 无 ) 
│   │   └── 运维 --> ( 难度等级: [0.75, 0.7857) || 挂载数据: 无 ) 
│   │       └── 编程 --> ( 难度等级: [0.75, 0.7857) || 挂载数据: 无 ) 
│   │           ├── Operator --> ( 难度等级: [0.75, 0.7589) || 挂载数据: 无 ) 
│   │           ├── Pulumi --> ( 难度等级: [0.7589, 0.7679) || 挂载数据: 无 ) 
│   │           ├── Ballerina --> ( 难度等级: [0.7679, 0.7768) || 挂载数据: 无 ) 
│   │           └── cdk8s --> ( 难度等级: [0.7768, 0.7857) || 挂载数据: 无 ) 
│   ├── 中间件 --> ( 难度等级: [0.7857, 0.8214) || 挂载数据: 无 ) 
│   │   ├── 数据库 --> ( 难度等级: [0.7857, 0.8036) || 挂载数据: 无 ) 
│   │   │   └── Database Mesh --> ( 难度等级: [0.7857, 0.8036) || 挂载数据: 无 ) 
│   │   └── 大数据 --> ( 难度等级: [0.8036, 0.8214) || 挂载数据: 无 ) 
│   │       ├── Kubeflow --> ( 难度等级: [0.8036, 0.8095) || 挂载数据: 无 ) 
│   │       ├── Fluid --> ( 难度等级: [0.8095, 0.8155) || 挂载数据: 无 ) 
│   │       └── KubeTEE --> ( 难度等级: [0.8155, 0.8214) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.8214, 0.8571) || 挂载数据: 无 ) 
└── 其他 --> ( 难度等级: [0.8571, 1.0) || 挂载数据: 无 ) 
    ├── 其他类别标签问题 --> ( 难度等级: [0.8571, 0.9048) || 挂载数据: 无 ) 
    ├── 应用类问题 --> ( 难度等级: [0.9048, 0.9524) || 挂载数据: 无 ) 
    └── 第三方包问题 --> ( 难度等级: [0.9524, 1.0) || 挂载数据: 无 )