云原生_tree.txt

云原生 --> ( 难度等级: [0, 1) || 挂载数据: 无 ) 
├── 云原生初阶-应用开发 --> ( 难度等级: [0.0, 0.1667) || 挂载数据: 无 ) 
│   ├── Serverless --> ( 难度等级: [0.0, 0.0417) || 挂载数据: 无 ) 
│   │   ├── Cloud Events --> ( 难度等级: [0.0, 0.0012) || 挂载数据: 无 ) 
│   │   ├── Serverless Framework --> ( 难度等级: [0.0012, 0.0025) || 挂载数据: 无 ) 
│   │   ├── Serverless Devs --> ( 难度等级: [0.0025, 0.0037) || 挂载数据: 无 ) 
│   │   ├── FaaS Serverless --> ( 难度等级: [0.0037, 0.0049) || 挂载数据: 无 ) 
│   │   │   ├── Nuclio --> ( 难度等级: [0.0037, 0.0039) || 挂载数据: 无 ) 
│   │   │   ├── Kubeless --> ( 难度等级: [0.0039, 0.0041) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubeless概述 --> ( 难度等级: [0.0039, 0.004) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署Kubeless --> ( 难度等级: [0.0039, 0.0039) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置客户端 --> ( 难度等级: [0.0039, 0.0039) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署函数 --> ( 难度等级: [0.0039, 0.004) || 挂载数据: 无 ) 
│   │   │   │   │   └── Kubeless UI --> ( 难度等级: [0.004, 0.004) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Function --> ( 难度等级: [0.004, 0.0041) || 挂载数据: blog: 2 ) 
│   │   │   │       ├── 函数部署 --> ( 难度等级: [0.004, 0.004) || 挂载数据: 无 ) 
│   │   │   │       ├── 函数调用 --> ( 难度等级: [0.004, 0.0041) || 挂载数据: 无 ) 
│   │   │   │       └── 自动扩展 --> ( 难度等级: [0.0041, 0.0041) || 挂载数据: blog: 1 ) 
│   │   │   ├── Fission --> ( 难度等级: [0.0041, 0.0043) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署Fission --> ( 难度等级: [0.0041, 0.0041) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署Fission Chart --> ( 难度等级: [0.0041, 0.0041) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 命令行工具 --> ( 难度等级: [0.0041, 0.0041) || 挂载数据: 无 ) 
│   │   │   │   │   └── Hello Fission --> ( 难度等级: [0.0041, 0.0041) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 深入探讨Fission --> ( 难度等级: [0.0041, 0.0042) || 挂载数据: 无 ) 
│   │   │   │   │   └── Environment --> ( 难度等级: [0.0041, 0.0042) || 挂载数据: 无 ) 
│   │   │   │   ├── 执行模式 --> ( 难度等级: [0.0042, 0.0042) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Poolbased模式 --> ( 难度等级: [0.0042, 0.0042) || 挂载数据: 无 ) 
│   │   │   │   │   └── New Deploy模式 --> ( 难度等级: [0.0042, 0.0042) || 挂载数据: 无 ) 
│   │   │   │   └── Workflows --> ( 难度等级: [0.0042, 0.0043) || 挂载数据: 无 ) 
│   │   │   │       ├── Workflows定义 --> ( 难度等级: [0.0042, 0.0043) || 挂载数据: 无 ) 
│   │   │   │       ├── 配置Workflows --> ( 难度等级: [0.0043, 0.0043) || 挂载数据: 无 ) 
│   │   │   │       └── Fortune Whale --> ( 难度等级: [0.0043, 0.0043) || 挂载数据: 无 ) 
│   │   │   ├── OpenFaas --> ( 难度等级: [0.0043, 0.0045) || 挂载数据: 无 ) 
│   │   │   │   ├── 初识OpenFaaS --> ( 难度等级: [0.0043, 0.0043) || 挂载数据: 无 ) 
│   │   │   │   │   └── 图形界面 --> ( 难度等级: [0.0043, 0.0043) || 挂载数据: 无 ) 
│   │   │   │   ├── OpenFaaS函数 --> ( 难度等级: [0.0043, 0.0044) || 挂载数据: blog: 7 ) 
│   │   │   │   │   ├── 抽象方式 --> ( 难度等级: [0.0043, 0.0043) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 函数模板 --> ( 难度等级: [0.0043, 0.0043) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 构建函数 --> ( 难度等级: [0.0043, 0.0043) || 挂载数据: blog: 4 ) 
│   │   │   │   │   └── 推送镜像 --> ( 难度等级: [0.0043, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   ├── Watchdog --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 工作原理 --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置Watchdog --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: blog: 2 ) 
│   │   │   │   │   └── ofwatchdog --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   ├── 监控 --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 监控指标 --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 监控面板 --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   │   └── 监控预警 --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   ├── 弹性扩展 --> ( 难度等级: [0.0044, 0.0045) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 基于Alertmanager扩展 --> ( 难度等级: [0.0044, 0.0044) || 挂载数据: 无 ) 
│   │   │   │   │   └── 基于HPA扩展 --> ( 难度等级: [0.0044, 0.0045) || 挂载数据: 无 ) 
│   │   │   │   └── 函数应用市场 --> ( 难度等级: [0.0045, 0.0045) || 挂载数据: 无 ) 
│   │   │   ├── OpenWhisk --> ( 难度等级: [0.0045, 0.0047) || 挂载数据: 无 ) 
│   │   │   │   ├── Hello Whisk --> ( 难度等级: [0.0045, 0.0045) || 挂载数据: 无 ) 
│   │   │   │   ├── 逻辑架构 --> ( 难度等级: [0.0045, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Namespace --> ( 难度等级: [0.0045, 0.0045) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Package --> ( 难度等级: [0.0045, 0.0045) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Action --> ( 难度等级: [0.0045, 0.0045) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── Feed --> ( 难度等级: [0.0045, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   └── Rule --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   ├── 系统架构 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Kubernetes部署 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 准备Kubernetes集群 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 集群基础设置 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 创建访问入口 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署组件 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 加载系统配置 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 测试集群 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   └── 删除集群 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   ├── Helm部署 --> ( 难度等级: [0.0046, 0.0047) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 安装Helm --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 环境配置 --> ( 难度等级: [0.0046, 0.0046) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 部署Chart --> ( 难度等级: [0.0046, 0.0047) || 挂载数据: blog: 4 ) 
│   │   │   │   │   └── 管理应用 --> ( 难度等级: [0.0047, 0.0047) || 挂载数据: 无 ) 
│   │   │   │   └── 蛋糕管理服务 --> ( 难度等级: [0.0047, 0.0047) || 挂载数据: 无 ) 
│   │   │   │       ├── 开发环境 --> ( 难度等级: [0.0047, 0.0047) || 挂载数据: 无 ) 
│   │   │   │       ├── 定义Action --> ( 难度等级: [0.0047, 0.0047) || 挂载数据: 无 ) 
│   │   │   │       ├── 创建Package --> ( 难度等级: [0.0047, 0.0047) || 挂载数据: 无 ) 
│   │   │   │       ├── 部署Action --> ( 难度等级: [0.0047, 0.0047) || 挂载数据: 无 ) 
│   │   │   │       └── 发布API --> ( 难度等级: [0.0047, 0.0047) || 挂载数据: 无 ) 
│   │   │   └── Fn Project --> ( 难度等级: [0.0047, 0.0049) || 挂载数据: 无 ) 
│   │   ├── 踏上征途 --> ( 难度等级: [0.0049, 0.0061) || 挂载数据: 无 ) 
│   │   ├── 无服务器初探 --> ( 难度等级: [0.0061, 0.0074) || 挂载数据: 无 ) 
│   │   │   ├── 来龙去脉 --> ( 难度等级: [0.0061, 0.0064) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向服务的架构与微服务 --> ( 难度等级: [0.0061, 0.0063) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 从SOA到微服务 --> ( 难度等级: [0.0061, 0.0062) || 挂载数据: 无 ) 
│   │   │   │   │   └── 微服务的价值与挑战 --> ( 难度等级: [0.0062, 0.0063) || 挂载数据: 无 ) 
│   │   │   │   └── 软件设计 --> ( 难度等级: [0.0063, 0.0064) || 挂载数据: 无 ) 
│   │   │   ├── 无服务器架构原则 --> ( 难度等级: [0.0064, 0.0067) || 挂载数据: 无 ) 
│   │   │   │   ├── 根据需要使用计算服务执行代码 --> ( 难度等级: [0.0064, 0.0065) || 挂载数据: 无 ) 
│   │   │   │   ├── 编写单一用途的无状态函数 --> ( 难度等级: [0.0065, 0.0066) || 挂载数据: 无 ) 
│   │   │   │   ├── 设计基于推送的、事件驱动的管道 --> ( 难度等级: [0.0066, 0.0066) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建更厚、更强大的前端 --> ( 难度等级: [0.0066, 0.0067) || 挂载数据: 无 ) 
│   │   │   │   └── 拥抱第三方服务 --> ( 难度等级: [0.0067, 0.0067) || 挂载数据: 无 ) 
│   │   │   ├── 从服务器过渡到服务 --> ( 难度等级: [0.0067, 0.007) || 挂载数据: 无 ) 
│   │   │   └── 无服务器的利与弊 --> ( 难度等级: [0.007, 0.0074) || 挂载数据: 无 ) 
│   │   │       ├── 决策驱动因素 --> ( 难度等级: [0.007, 0.0072) || 挂载数据: 无 ) 
│   │   │       └── 什么时候使用无服务器 --> ( 难度等级: [0.0072, 0.0074) || 挂载数据: blog: 14 ) 
│   │   ├── .架构与模式 --> ( 难度等级: [0.0074, 0.0086) || 挂载数据: 无 ) 
│   │   │   ├── 使用场景 --> ( 难度等级: [0.0074, 0.0078) || 挂载数据: 无 ) 
│   │   │   │   ├── 应用程序后端 --> ( 难度等级: [0.0074, 0.0074) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据处理与操作 --> ( 难度等级: [0.0074, 0.0075) || 挂载数据: 无 ) 
│   │   │   │   ├── 实时分析 --> ( 难度等级: [0.0075, 0.0076) || 挂载数据: 无 ) 
│   │   │   │   ├── 遗留API代理 --> ( 难度等级: [0.0076, 0.0076) || 挂载数据: 无 ) 
│   │   │   │   ├── 计划服务 --> ( 难度等级: [0.0076, 0.0077) || 挂载数据: 无 ) 
│   │   │   │   └── 机器人（Bot）和技能（Skill） . --> ( 难度等级: [0.0077, 0.0078) || 挂载数据: 无 ) 
│   │   │   ├── 架构 --> ( 难度等级: [0.0078, 0.0082) || 挂载数据: 无 ) 
│   │   │   │   ├── 计算即后端 --> ( 难度等级: [0.0078, 0.0078) || 挂载数据: 无 ) 
│   │   │   │   ├── 遗留API代理 --> ( 难度等级: [0.0078, 0.0079) || 挂载数据: 无 ) 
│   │   │   │   ├── 混合 --> ( 难度等级: [0.0079, 0.008) || 挂载数据: 无 ) 
│   │   │   │   ├── GraphQL . --> ( 难度等级: [0.008, 0.008) || 挂载数据: 无 ) 
│   │   │   │   ├── 计算即胶水 --> ( 难度等级: [0.008, 0.0081) || 挂载数据: 无 ) 
│   │   │   │   └── 实时处理 --> ( 难度等级: [0.0081, 0.0082) || 挂载数据: 无 ) 
│   │   │   └── 模式 --> ( 难度等级: [0.0082, 0.0086) || 挂载数据: 无 ) 
│   │   │       ├── 命令模式 --> ( 难度等级: [0.0082, 0.0083) || 挂载数据: 无 ) 
│   │   │       ├── 消息传输模式 --> ( 难度等级: [0.0083, 0.0083) || 挂载数据: blog: 1 ) 
│   │   │       ├── 优先级队列模式 --> ( 难度等级: [0.0083, 0.0084) || 挂载数据: 无 ) 
│   │   │       ├── 扇出模式 --> ( 难度等级: [0.0084, 0.0085) || 挂载数据: 无 ) 
│   │   │       └── 管道和过滤器模式 --> ( 难度等级: [0.0085, 0.0086) || 挂载数据: 无 ) 
│   │   ├── 建立无服务器应用程序 --> ( 难度等级: [0.0086, 0.0098) || 挂载数据: 无 ) 
│   │   │   ├── 小时视频 --> ( 难度等级: [0.0086, 0.0088) || 挂载数据: 无 ) 
│   │   │   │   ├── 总体需求 --> ( 难度等级: [0.0086, 0.0086) || 挂载数据: 无 ) 
│   │   │   │   ├── Amazon Web Services（AWS） --> ( 难度等级: [0.0086, 0.0086) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建第一个Lambda函数 --> ( 难度等级: [0.0086, 0.0087) || 挂载数据: 无 ) 
│   │   │   │   ├── 命名你的Lambda --> ( 难度等级: [0.0087, 0.0087) || 挂载数据: 无 ) 
│   │   │   │   ├── 本地测试 --> ( 难度等级: [0.0087, 0.0087) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署到AWS --> ( 难度等级: [0.0087, 0.0087) || 挂载数据: 无 ) 
│   │   │   │   ├── 连接S3 和Lambda --> ( 难度等级: [0.0087, 0.0088) || 挂载数据: 无 ) 
│   │   │   │   ├── 在AWS中测试 --> ( 难度等级: [0.0088, 0.0088) || 挂载数据: 无 ) 
│   │   │   │   └── 观察日志 --> ( 难度等级: [0.0088, 0.0088) || 挂载数据: 无 ) 
│   │   │   ├── 配置Simple Notification Service --> ( 难度等级: [0.0088, 0.0091) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 连接SNS和S --> ( 难度等级: [0.0088, 0.0089) || 挂载数据: 无 ) 
│   │   │   │   ├── 从SNS接收电子邮件 --> ( 难度等级: [0.0089, 0.009) || 挂载数据: 无 ) 
│   │   │   │   └── 测试SNS --> ( 难度等级: [0.009, 0.0091) || 挂载数据: 无 ) 
│   │   │   ├── 设置视频权限 --> ( 难度等级: [0.0091, 0.0093) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建第二个函数 --> ( 难度等级: [0.0091, 0.0092) || 挂载数据: 无 ) 
│   │   │   │   ├── 配置与安全 --> ( 难度等级: [0.0092, 0.0092) || 挂载数据: 无 ) 
│   │   │   │   └── 测试第二个函数 --> ( 难度等级: [0.0092, 0.0093) || 挂载数据: 无 ) 
│   │   │   ├── 生成元数据 --> ( 难度等级: [0.0093, 0.0096) || 挂载数据: 无 ) 
│   │   │   └── 收尾 --> ( 难度等级: [0.0096, 0.0098) || 挂载数据: 无 ) 
│   │   ├── 设置你的云服务 --> ( 难度等级: [0.0098, 0.011) || 挂载数据: 无 ) 
│   │   │   └── 安全模型和身份管理 --> ( 难度等级: [0.0098, 0.011) || 挂载数据: 无 ) 
│   │   │       └── 创建和管理IAM用户 --> ( 难度等级: [0.0098, 0.011) || 挂载数据: 无 ) 
│   │   ├── 深入核心 --> ( 难度等级: [0.011, 0.0123) || 挂载数据: 无 ) 
│   │   ├── 身份认证和授权 --> ( 难度等级: [0.0123, 0.0135) || 挂载数据: 无 ) 
│   │   │   ├── 无服务器环境中的身份认证 --> ( 难度等级: [0.0123, 0.0126) || 挂载数据: 无 ) 
│   │   │   │   ├── 无服务器方法 --> ( 难度等级: [0.0123, 0.0124) || 挂载数据: 无 ) 
│   │   │   │   ├── Amazon Cognito --> ( 难度等级: [0.0124, 0.0125) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Auth0 --> ( 难度等级: [0.0125, 0.0126) || 挂载数据: 无 ) 
│   │   │   ├── 为 24 小时视频增加身份认证 --> ( 难度等级: [0.0126, 0.0129) || 挂载数据: 无 ) 
│   │   │   │   ├── 计划 --> ( 难度等级: [0.0126, 0.0126) || 挂载数据: 无 ) 
│   │   │   │   ├── 直接调用Lambda --> ( 难度等级: [0.0126, 0.0127) || 挂载数据: 无 ) 
│   │   │   │   ├── 小时视频网站 --> ( 难度等级: [0.0127, 0.0127) || 挂载数据: 无 ) 
│   │   │   │   ├── Auth0 配置 --> ( 难度等级: [0.0127, 0.0128) || 挂载数据: 无 ) 
│   │   │   │   ├── 在网站中加入Auth0 --> ( 难度等级: [0.0128, 0.0128) || 挂载数据: 无 ) 
│   │   │   │   └── 测试Auth0 的集成 --> ( 难度等级: [0.0128, 0.0129) || 挂载数据: 无 ) 
│   │   │   ├── 与AWS集成 --> ( 难度等级: [0.0129, 0.0132) || 挂载数据: 无 ) 
│   │   │   │   ├── 用户信息Lambda --> ( 难度等级: [0.0129, 0.0129) || 挂载数据: 无 ) 
│   │   │   │   ├── API Gateway --> ( 难度等级: [0.0129, 0.013) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 作为接口的API Gateway --> ( 难度等级: [0.0129, 0.0129) || 挂载数据: blog: 102 ) 
│   │   │   │   │   │   ├── 和AWS服务集成 --> ( 难度等级: [0.0129, 0.0129) || 挂载数据: blog: 39 ) 
│   │   │   │   │   │   └── 脚本 --> ( 难度等级: [0.0129, 0.0129) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 创建资源和方法 --> ( 难度等级: [0.0129, 0.013) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置方法执行 --> ( 难度等级: [0.013, 0.013) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 更新网站 --> ( 难度等级: [0.013, 0.013) || 挂载数据: 无 ) 
│   │   │   │   │   └── 优化网关 --> ( 难度等级: [0.013, 0.013) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 限制 --> ( 难度等级: [0.013, 0.013) || 挂载数据: 无 ) 
│   │   │   │   │       └── 缓存 --> ( 难度等级: [0.013, 0.013) || 挂载数据: 无 ) 
│   │   │   │   ├── 映射 --> ( 难度等级: [0.013, 0.0131) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过API Gateway调用Lambda --> ( 难度等级: [0.0131, 0.0131) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义授权方 --> ( 难度等级: [0.0131, 0.0132) || 挂载数据: 无 ) 
│   │   │   └── 委托令牌 --> ( 难度等级: [0.0132, 0.0135) || 挂载数据: 无 ) 
│   │   │       ├── 真实案例 --> ( 难度等级: [0.0132, 0.0133) || 挂载数据: 无 ) 
│   │   │       └── 开通委托令牌 --> ( 难度等级: [0.0133, 0.0135) || 挂载数据: 无 ) 
│   │   ├── 编排者Lambda --> ( 难度等级: [0.0135, 0.0147) || 挂载数据: 无 ) 
│   │   │   ├── Lambda内幕 --> ( 难度等级: [0.0135, 0.0137) || 挂载数据: 无 ) 
│   │   │   │   ├── 事件模型和源 --> ( 难度等级: [0.0135, 0.0135) || 挂载数据: 无 ) 
│   │   │   │   ├── 推送和拉取事件模型 --> ( 难度等级: [0.0135, 0.0136) || 挂载数据: 无 ) 
│   │   │   │   ├── 并发执行 --> ( 难度等级: [0.0136, 0.0136) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器重用 --> ( 难度等级: [0.0136, 0.0136) || 挂载数据: 无 ) 
│   │   │   │   └── 冷Lambda和暖Lambda --> ( 难度等级: [0.0136, 0.0137) || 挂载数据: blog: 2 ) 
│   │   │   ├── 编程模型 --> ( 难度等级: [0.0137, 0.0139) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数处理程序 --> ( 难度等级: [0.0137, 0.0137) || 挂载数据: 无 ) 
│   │   │   │   ├── 事件对象 --> ( 难度等级: [0.0137, 0.0137) || 挂载数据: 无 ) 
│   │   │   │   ├── 上下文对象 --> ( 难度等级: [0.0137, 0.0137) || 挂载数据: 无 ) 
│   │   │   │   ├── 回调函数 --> ( 难度等级: [0.0137, 0.0138) || 挂载数据: 无 ) 
│   │   │   │   ├── 日志 --> ( 难度等级: [0.0138, 0.0138) || 挂载数据: 无 ) 
│   │   │   │   ├── 代码开发 --> ( 难度等级: [0.0138, 0.0138) || 挂载数据: 无 ) 
│   │   │   │   ├── Handler --> ( 难度等级: [0.0138, 0.0138) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 执行上下文 --> ( 难度等级: [0.0138, 0.0138) || 挂载数据: 无 ) 
│   │   │   │   ├── 日志输出 --> ( 难度等级: [0.0138, 0.0139) || 挂载数据: 无 ) 
│   │   │   │   ├── 异常处理 --> ( 难度等级: [0.0139, 0.0139) || 挂载数据: 无 ) 
│   │   │   │   └── 无状态 --> ( 难度等级: [0.0139, 0.0139) || 挂载数据: 无 ) 
│   │   │   ├── 版本管理、别名和环境变量 --> ( 难度等级: [0.0139, 0.0141) || 挂载数据: 无 ) 
│   │   │   │   ├── 版本管理 --> ( 难度等级: [0.0139, 0.014) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 别名 --> ( 难度等级: [0.014, 0.014) || 挂载数据: 无 ) 
│   │   │   │   └── 环境变量 --> ( 难度等级: [0.014, 0.0141) || 挂载数据: 无 ) 
│   │   │   ├── 使用命令行界面（CLI） --> ( 难度等级: [0.0141, 0.0143) || 挂载数据: 无 ) 
│   │   │   │   └── 调用命令 --> ( 难度等级: [0.0141, 0.0143) || 挂载数据: 无 ) 
│   │   │   ├── Lambda模式 --> ( 难度等级: [0.0143, 0.0145) || 挂载数据: 无 ) 
│   │   │   │   ├── 异步瀑布 --> ( 难度等级: [0.0143, 0.0143) || 挂载数据: 无 ) 
│   │   │   │   ├── 序列与并行 --> ( 难度等级: [0.0143, 0.0144) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用库 --> ( 难度等级: [0.0144, 0.0145) || 挂载数据: 无 ) 
│   │   │   │   └── 把逻辑移到另一个文件中 --> ( 难度等级: [0.0145, 0.0145) || 挂载数据: 无 ) 
│   │   │   └── 测试Lambda函数 . --> ( 难度等级: [0.0145, 0.0147) || 挂载数据: 无 ) 
│   │   │       ├── 在本地测试 --> ( 难度等级: [0.0145, 0.0146) || 挂载数据: 无 ) 
│   │   │       └── 编写测试 --> ( 难度等级: [0.0146, 0.0147) || 挂载数据: 无 ) 
│   │   ├── 拓展架构 --> ( 难度等级: [0.0147, 0.0159) || 挂载数据: 无 ) 
│   │   ├── 存储 . --> ( 难度等级: [0.0159, 0.0172) || 挂载数据: 无 ) 
│   │   │   ├── 更智能的存储 --> ( 难度等级: [0.0159, 0.0163) || 挂载数据: 无 ) 
│   │   │   │   ├── 版本控制 --> ( 难度等级: [0.0159, 0.016) || 挂载数据: 无 ) 
│   │   │   │   ├── 托管静态网站 --> ( 难度等级: [0.016, 0.0161) || 挂载数据: 无 ) 
│   │   │   │   ├── 存储类别 --> ( 难度等级: [0.0161, 0.0161) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 对象生命周期管理 --> ( 难度等级: [0.0161, 0.0162) || 挂载数据: 无 ) 
│   │   │   │   ├── 转移加速 --> ( 难度等级: [0.0162, 0.0163) || 挂载数据: 无 ) 
│   │   │   │   └── 事件通知 --> ( 难度等级: [0.0163, 0.0163) || 挂载数据: 无 ) 
│   │   │   ├── 安全上传 --> ( 难度等级: [0.0163, 0.0167) || 挂载数据: 无 ) 
│   │   │   │   ├── 上传策略Lambda --> ( 难度等级: [0.0163, 0.0165) || 挂载数据: 无 ) 
│   │   │   │   ├── S3 CORS配置 --> ( 难度等级: [0.0165, 0.0166) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 在网站中上传 --> ( 难度等级: [0.0166, 0.0167) || 挂载数据: blog: 1 ) 
│   │   │   └── 限制对文件的访问 --> ( 难度等级: [0.0167, 0.0172) || 挂载数据: 无 ) 
│   │   │       ├── 禁止公开访问 --> ( 难度等级: [0.0167, 0.0168) || 挂载数据: 无 ) 
│   │   │       ├── 生成预签名URL --> ( 难度等级: [0.0168, 0.0169) || 挂载数据: blog: 1 ) 
│   │   │       ├── 签名URL Lambda --> ( 难度等级: [0.0169, 0.017) || 挂载数据: blog: 1 ) 
│   │   │       ├── API Gateway设置 --> ( 难度等级: [0.017, 0.017) || 挂载数据: 无 ) 
│   │   │       ├── 提升性能 --> ( 难度等级: [0.017, 0.0171) || 挂载数据: 无 ) 
│   │   │       └── 提升Firebase安全性 --> ( 难度等级: [0.0171, 0.0172) || 挂载数据: 无 ) 
│   │   ├── 数据库 --> ( 难度等级: [0.0172, 0.0184) || 挂载数据: 无 ) 
│   │   │   ├── Firebase简介 --> ( 难度等级: [0.0172, 0.0178) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据结构 --> ( 难度等级: [0.0172, 0.0175) || 挂载数据: 无 ) 
│   │   │   │   └── 安全规则 --> ( 难度等级: [0.0175, 0.0178) || 挂载数据: 无 ) 
│   │   │   └── 为 24 小时视频添加Firebase --> ( 难度等级: [0.0178, 0.0184) || 挂载数据: 无 ) 
│   │   │       ├── 设置Firebase --> ( 难度等级: [0.0178, 0.0179) || 挂载数据: 无 ) 
│   │   │       ├── 修改转码视频Lambda --> ( 难度等级: [0.0179, 0.018) || 挂载数据: 无 ) 
│   │   │       ├── Transcode Video Firebase Update函数 --> ( 难度等级: [0.018, 0.0181) || 挂载数据: 无 ) 
│   │   │       ├── 连接Lambda --> ( 难度等级: [0.0181, 0.0182) || 挂载数据: 无 ) 
│   │   │       ├── 网站 --> ( 难度等级: [0.0182, 0.0183) || 挂载数据: blog: 1 ) 
│   │   │       └── 端到端测试 --> ( 难度等级: [0.0183, 0.0184) || 挂载数据: 无 ) 
│   │   ├── 最后一英里 . --> ( 难度等级: [0.0184, 0.0196) || 挂载数据: 无 ) 
│   │   │   ├── 部署与框架 --> ( 难度等级: [0.0184, 0.0186) || 挂载数据: 无 ) 
│   │   │   ├── 迈向更好的微服务 --> ( 难度等级: [0.0186, 0.0189) || 挂载数据: 无 ) 
│   │   │   ├── Step Functions --> ( 难度等级: [0.0189, 0.0191) || 挂载数据: 无 ) 
│   │   │   ├── AWS Marketplace --> ( 难度等级: [0.0191, 0.0194) || 挂载数据: 无 ) 
│   │   │   └── 未来之路 --> ( 难度等级: [0.0194, 0.0196) || 挂载数据: 无 ) 
│   │   ├── Serverless基础 --> ( 难度等级: [0.0196, 0.0208) || 挂载数据: 无 ) 
│   │   │   ├── 什么是Serverless --> ( 难度等级: [0.0196, 0.0198) || 挂载数据: 无 ) 
│   │   │   │   ├── Serverless技术的发展 --> ( 难度等级: [0.0196, 0.0196) || 挂载数据: blog: 9 ) 
│   │   │   │   ├── Serverless框架和工具 --> ( 难度等级: [0.0196, 0.0196) || 挂载数据: blog: 6 ) 
│   │   │   │   │   ├── Chalice --> ( 难度等级: [0.0196, 0.0196) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Claudia.js --> ( 难度等级: [0.0196, 0.0196) || 挂载数据: blog: 15 ) 
│   │   │   │   │   ├── Apex --> ( 难度等级: [0.0196, 0.0196) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Spring Cloud Function --> ( 难度等级: [0.0196, 0.0196) || 挂载数据: blog: 17 ) 
│   │   │   │   │   └── AWS SAM --> ( 难度等级: [0.0196, 0.0196) || 挂载数据: blog: 14 ) 
│   │   │   │   ├── Serverless后台服务 --> ( 难度等级: [0.0196, 0.0197) || 挂载数据: blog: 21 ) 
│   │   │   │   ├── 获取AWS账号 --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   ├── AWS Lambda控制面板 --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 编辑函数 --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试函数 --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   ├── 外部访问 --> ( 难度等级: [0.0197, 0.0197) || 挂载数据: 无 ) 
│   │   │   │   ├── 运维监控 --> ( 难度等级: [0.0197, 0.0198) || 挂载数据: 无 ) 
│   │   │   │   └── 回顾 --> ( 难度等级: [0.0198, 0.0198) || 挂载数据: blog: 1 ) 
│   │   │   ├── Serverless带来的价值 --> ( 难度等级: [0.0198, 0.02) || 挂载数据: 无 ) 
│   │   │   ├── Serverless的技术实现 --> ( 难度等级: [0.02, 0.0201) || 挂载数据: 无 ) 
│   │   │   │   ├── 理念与实现 --> ( 难度等级: [0.02, 0.02) || 挂载数据: 无 ) 
│   │   │   │   └── FaaS与BaaS --> ( 难度等级: [0.02, 0.0201) || 挂载数据: 无 ) 
│   │   │   │       ├── FaaS的架构 --> ( 难度等级: [0.02, 0.0201) || 挂载数据: blog: 21 ) 
│   │   │   │       ├── 函数的生命周期 --> ( 难度等级: [0.0201, 0.0201) || 挂载数据: 无 ) 
│   │   │   │       ├── 函数工作流 --> ( 难度等级: [0.0201, 0.0201) || 挂载数据: blog: 1 ) 
│   │   │   │       ├── BaaS的价值 --> ( 难度等级: [0.0201, 0.0201) || 挂载数据: blog: 2 ) 
│   │   │   │       └── 广义的Serverless --> ( 难度等级: [0.0201, 0.0201) || 挂载数据: 无 ) 
│   │   │   ├── Serverless应用架构 --> ( 难度等级: [0.0201, 0.0203) || 挂载数据: 无 ) 
│   │   │   │   ├── 传统应用架构 --> ( 难度等级: [0.0201, 0.0202) || 挂载数据: 无 ) 
│   │   │   │   └── Serverless应用架构 --> ( 难度等级: [0.0202, 0.0203) || 挂载数据: blog: 173 ) 
│   │   │   ├── Serverless的技术特点 --> ( 难度等级: [0.0203, 0.0205) || 挂载数据: 无 ) 
│   │   │   ├── Serverless的应用场景 --> ( 难度等级: [0.0205, 0.0207) || 挂载数据: 无 ) 
│   │   │   └── Serverless的局限 --> ( 难度等级: [0.0207, 0.0208) || 挂载数据: 无 ) 
│   │   ├── AWS Lambda --> ( 难度等级: [0.0208, 0.0221) || 挂载数据: 无 ) 
│   │   │   ├── AWS Serverless --> ( 难度等级: [0.0208, 0.021) || 挂载数据: blog: 133 ) 
│   │   │   ├── AWS Lambda概述 --> ( 难度等级: [0.021, 0.0212) || 挂载数据: blog: 17 ) 
│   │   │   ├── 权限控制 --> ( 难度等级: [0.0212, 0.0214) || 挂载数据: 无 ) 
│   │   │   │   ├── IAM --> ( 难度等级: [0.0212, 0.0212) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 策略 --> ( 难度等级: [0.0212, 0.0213) || 挂载数据: 无 ) 
│   │   │   │   └── 角色 --> ( 难度等级: [0.0213, 0.0214) || 挂载数据: 无 ) 
│   │   │   ├── 事件驱动 --> ( 难度等级: [0.0214, 0.0215) || 挂载数据: 无 ) 
│   │   │   │   ├── 事件源 --> ( 难度等级: [0.0214, 0.0214) || 挂载数据: 无 ) 
│   │   │   │   └── 触发模式 --> ( 难度等级: [0.0214, 0.0215) || 挂载数据: 无 ) 
│   │   │   ├── 日志监控 --> ( 难度等级: [0.0215, 0.0217) || 挂载数据: 无 ) 
│   │   │   ├── 开发辅助 --> ( 难度等级: [0.0217, 0.0219) || 挂载数据: 无 ) 
│   │   │   │   └── 标签 --> ( 难度等级: [0.0217, 0.0219) || 挂载数据: 无 ) 
│   │   │   └── 运行限制 --> ( 难度等级: [0.0219, 0.0221) || 挂载数据: 无 ) 
│   │   │       ├── 资源限制 --> ( 难度等级: [0.0219, 0.022) || 挂载数据: 无 ) 
│   │   │       └── 并发控制 --> ( 难度等级: [0.022, 0.0221) || 挂载数据: 无 ) 
│   │   ├── Azure Functions --> ( 难度等级: [0.0221, 0.0233) || 挂载数据: 无 ) 
│   │   │   ├── Microsoft Azure --> ( 难度等级: [0.0221, 0.0223) || 挂载数据: blog: 1 ) 
│   │   │   ├── Azure Functions概述 --> ( 难度等级: [0.0223, 0.0225) || 挂载数据: 无 ) 
│   │   │   ├── 创建Azure Serverless应用 --> ( 难度等级: [0.0225, 0.0227) || 挂载数据: 无 ) 
│   │   │   │   ├── 注册Azure账号 --> ( 难度等级: [0.0225, 0.0225) || 挂载数据: 无 ) 
│   │   │   │   ├── Azure控制台 --> ( 难度等级: [0.0225, 0.0226) || 挂载数据: blog: 16 ) 
│   │   │   │   └── 调用函数 --> ( 难度等级: [0.0226, 0.0227) || 挂载数据: 无 ) 
│   │   │   ├── Azure Functions命令行 --> ( 难度等级: [0.0227, 0.0229) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装命令行 --> ( 难度等级: [0.0227, 0.0228) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 发布至公有云 --> ( 难度等级: [0.0228, 0.0229) || 挂载数据: 无 ) 
│   │   │   ├── 深入了解Azure Functions --> ( 难度等级: [0.0229, 0.0231) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数应用设置 --> ( 难度等级: [0.0229, 0.0229) || 挂载数据: 无 ) 
│   │   │   │   ├── Trigger与Bindings --> ( 难度等级: [0.0229, 0.023) || 挂载数据: 无 ) 
│   │   │   │   │   ├── HTTP Trigger --> ( 难度等级: [0.0229, 0.0229) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Cronjob Trigger --> ( 难度等级: [0.0229, 0.023) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Kafka Trigger --> ( 难度等级: [0.023, 0.023) || 挂载数据: 无 ) 
│   │   │   │   │   └── NATS Trigger --> ( 难度等级: [0.023, 0.023) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数代理 --> ( 难度等级: [0.023, 0.023) || 挂载数据: 无 ) 
│   │   │   │   └── Slot --> ( 难度等级: [0.023, 0.0231) || 挂载数据: 无 ) 
│   │   │   └── 私有云部署 --> ( 难度等级: [0.0231, 0.0233) || 挂载数据: 无 ) 
│   │   ├── 容器技术基础 --> ( 难度等级: [0.0233, 0.0245) || 挂载数据: 无 ) 
│   │   │   ├── 什么是容器 --> ( 难度等级: [0.0233, 0.0236) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器 --> ( 难度等级: [0.0233, 0.0234) || 挂载数据: blog: 62 ) 
│   │   │   │   ├── 容器镜像 --> ( 难度等级: [0.0234, 0.0234) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── 镜像仓库 --> ( 难度等级: [0.0234, 0.0235) || 挂载数据: 无 ) 
│   │   │   │   └── 容器编排 --> ( 难度等级: [0.0235, 0.0236) || 挂载数据: 无 ) 
│   │   │   ├── Docker --> ( 难度等级: [0.0236, 0.0239) || 挂载数据: 无 ) 
│   │   │   │   ├── Vagrant --> ( 难度等级: [0.0236, 0.0236) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── VirtualBox --> ( 难度等级: [0.0236, 0.0237) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 安装Docker --> ( 难度等级: [0.0237, 0.0237) || 挂载数据: 无 ) 
│   │   │   │   ├── 运行容器 --> ( 难度等级: [0.0237, 0.0238) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建容器镜像 --> ( 难度等级: [0.0238, 0.0238) || 挂载数据: 无 ) 
│   │   │   │   └── 分享镜像 --> ( 难度等级: [0.0238, 0.0239) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes基础 --> ( 难度等级: [0.0239, 0.0242) || 挂载数据: 无 ) 
│   │   │   │   ├── 命名空间 --> ( 难度等级: [0.0239, 0.0239) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod --> ( 难度等级: [0.0239, 0.024) || 挂载数据: 无 ) 
│   │   │   │   ├── Service --> ( 难度等级: [0.024, 0.024) || 挂载数据: 无 ) 
│   │   │   │   ├── Deployment --> ( 难度等级: [0.024, 0.0241) || 挂载数据: 无 ) 
│   │   │   │   ├── ReplicaSet --> ( 难度等级: [0.0241, 0.0241) || 挂载数据: 无 ) 
│   │   │   │   ├── 网络 --> ( 难度等级: [0.0241, 0.0241) || 挂载数据: 无 ) 
│   │   │   │   ├── Ingress --> ( 难度等级: [0.0241, 0.0242) || 挂载数据: 无 ) 
│   │   │   │   └── 交互工具 --> ( 难度等级: [0.0242, 0.0242) || 挂载数据: 无 ) 
│   │   │   └── 构建Kubernetes环境 --> ( 难度等级: [0.0242, 0.0245) || 挂载数据: 无 ) 
│   │   │       ├── 启动Vagrant Box --> ( 难度等级: [0.0242, 0.0244) || 挂载数据: 无 ) 
│   │   │       └── 修改默认域 --> ( 难度等级: [0.0244, 0.0245) || 挂载数据: 无 ) 
│   │   ├── Serverless的落地与展望 --> ( 难度等级: [0.0245, 0.0257) || 挂载数据: 无 ) 
│   │   │   ├── Serverless的落地 --> ( 难度等级: [0.0245, 0.0248) || 挂载数据: 无 ) 
│   │   │   ├── Serverless平台建设 --> ( 难度等级: [0.0248, 0.0251) || 挂载数据: 无 ) 
│   │   │   │   ├── 公有云 --> ( 难度等级: [0.0248, 0.0249) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 私有云 --> ( 难度等级: [0.0249, 0.025) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 混合云 --> ( 难度等级: [0.025, 0.0251) || 挂载数据: 无 ) 
│   │   │   ├── Serverless应用架构转型 --> ( 难度等级: [0.0251, 0.0254) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发模式 --> ( 难度等级: [0.0251, 0.0252) || 挂载数据: 无 ) 
│   │   │   │   ├── 设计原则 --> ( 难度等级: [0.0252, 0.0253) || 挂载数据: 无 ) 
│   │   │   │   └── 迁移与重构 --> ( 难度等级: [0.0253, 0.0254) || 挂载数据: 无 ) 
│   │   │   └── Serverless的未来 --> ( 难度等级: [0.0254, 0.0257) || 挂载数据: 无 ) 
│   │   │       ├── 建立行业规范 --> ( 难度等级: [0.0254, 0.0256) || 挂载数据: 无 ) 
│   │   │       └── 完善工具链 --> ( 难度等级: [0.0256, 0.0257) || 挂载数据: 无 ) 
│   │   ├── 初识Serverless --> ( 难度等级: [0.0257, 0.027) || 挂载数据: 无 ) 
│   │   │   ├── 优势与劣势 --> ( 难度等级: [0.0257, 0.0261) || 挂载数据: 无 ) 
│   │   │   ├── 影响力和价值 --> ( 难度等级: [0.0261, 0.0266) || 挂载数据: 无 ) 
│   │   │   └── 典型应用场景 --> ( 难度等级: [0.0266, 0.027) || 挂载数据: 无 ) 
│   │   │       ├── 视频转码服务 --> ( 难度等级: [0.0266, 0.0266) || 挂载数据: 无 ) 
│   │   │       ├── 数据ETL处理服务 --> ( 难度等级: [0.0266, 0.0267) || 挂载数据: 无 ) 
│   │   │       ├── 网站（服务）后端 --> ( 难度等级: [0.0267, 0.0268) || 挂载数据: 无 ) 
│   │   │       ├── 人工智能推理预测 --> ( 难度等级: [0.0268, 0.0269) || 挂载数据: 无 ) 
│   │   │       └── 物联网相关应用 --> ( 难度等级: [0.0269, 0.027) || 挂载数据: 无 ) 
│   │   ├── Serverless入门 --> ( 难度等级: [0.027, 0.0282) || 挂载数据: 无 ) 
│   │   │   ├── Serverless架构规范 --> ( 难度等级: [0.027, 0.0273) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数相关规范 --> ( 难度等级: [0.027, 0.0271) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数生命周期 --> ( 难度等级: [0.0271, 0.0272) || 挂载数据: 无 ) 
│   │   │   │   └── 工作流程 --> ( 难度等级: [0.0272, 0.0273) || 挂载数据: 无 ) 
│   │   │   ├── 事件与规范 --> ( 难度等级: [0.0273, 0.0276) || 挂载数据: 无 ) 
│   │   │   │   ├── 相关术语 --> ( 难度等级: [0.0273, 0.0274) || 挂载数据: 无 ) 
│   │   │   │   └── 上下文属性 --> ( 难度等级: [0.0274, 0.0276) || 挂载数据: 无 ) 
│   │   │   ├── 工业化产品 --> ( 难度等级: [0.0276, 0.0279) || 挂载数据: 无 ) 
│   │   │   │   ├── Google Cloud Function --> ( 难度等级: [0.0276, 0.0277) || 挂载数据: blog: 68 ) 
│   │   │   │   └── 腾讯云SCF --> ( 难度等级: [0.0277, 0.0279) || 挂载数据: blog: 3 ) 
│   │   │   └── 开发运维工具 --> ( 难度等级: [0.0279, 0.0282) || 挂载数据: 无 ) 
│   │   │       ├── CLI命令行工具 --> ( 难度等级: [0.0279, 0.028) || 挂载数据: blog: 1 ) 
│   │   │       └── 插件 --> ( 难度等级: [0.028, 0.0282) || 挂载数据: 无 ) 
│   │   ├── Web与监控告警场景实践 --> ( 难度等级: [0.0282, 0.0294) || 挂载数据: 无 ) 
│   │   │   └── Web后端与应用服务端 --> ( 难度等级: [0.0282, 0.0294) || 挂载数据: 无 ) 
│   │   │       ├── 上传图片加水印 --> ( 难度等级: [0.0282, 0.0286) || 挂载数据: 无 ) 
│   │   │       ├── 用IP地址查天气并在小程序中应用 --> ( 难度等级: [0.0286, 0.029) || 挂载数据: 无 ) 
│   │   │       └── 简易用户反馈功能与快应用实践 --> ( 难度等级: [0.029, 0.0294) || 挂载数据: 无 ) 
│   │   ├── 大数据与人工智能场景实践 --> ( 难度等级: [0.0294, 0.0306) || 挂载数据: 无 ) 
│   │   │   ├── 大数据技术之MapReduce的简单实现 --> ( 难度等级: [0.0294, 0.03) || 挂载数据: blog: 5 ) 
│   │   │   └── 人工智能领域的实践 --> ( 难度等级: [0.03, 0.0306) || 挂载数据: blog: 1 ) 
│   │   │       ├── 自然语言处理为你的网站赋能 --> ( 难度等级: [0.03, 0.0302) || 挂载数据: 无 ) 
│   │   │       ├── 智能客服与微信小程序 --> ( 难度等级: [0.0302, 0.0303) || 挂载数据: blog: 2 ) 
│   │   │       ├── 简单的车牌识别系统 --> ( 难度等级: [0.0303, 0.0305) || 挂载数据: 无 ) 
│   │   │       └── 视觉：对象检测系统 --> ( 难度等级: [0.0305, 0.0306) || 挂载数据: blog: 1 ) 
│   │   ├── 物联网和其他场景实践 --> ( 难度等级: [0.0306, 0.0319) || 挂载数据: 无 ) 
│   │   │   ├── 物联网相关—定制智能音箱小工具 --> ( 难度等级: [0.0306, 0.0312) || 挂载数据: blog: 1 ) 
│   │   │   └── 其他场景实践 --> ( 难度等级: [0.0312, 0.0319) || 挂载数据: 无 ) 
│   │   │       ├── OJ判题机/小程序在线编程系统实现 --> ( 难度等级: [0.0312, 0.0316) || 挂载数据: blog: 1 ) 
│   │   │       └── 微信公众号机器人 --> ( 难度等级: [0.0316, 0.0319) || 挂载数据: 无 ) 
│   │   ├── Serverless范式 --> ( 难度等级: [0.0319, 0.0331) || 挂载数据: 无 ) 
│   │   │   ├── Serverless架构不仅仅是实时的 --> ( 难度等级: [0.0319, 0.0325) || 挂载数据: 无 ) 
│   │   │   └── Serverless的优缺点 --> ( 难度等级: [0.0325, 0.0331) || 挂载数据: 无 ) 
│   │   ├── 在AWS中构建Serverless应用程序 --> ( 难度等级: [0.0331, 0.0343) || 挂载数据: 无 ) 
│   │   │   ├── AWS Lambda的触发器 --> ( 难度等级: [0.0331, 0.0333) || 挂载数据: 无 ) 
│   │   │   ├── 函数即容器 --> ( 难度等级: [0.0333, 0.0336) || 挂载数据: 无 ) 
│   │   │   ├── 配置函数 --> ( 难度等级: [0.0336, 0.0338) || 挂载数据: 无 ) 
│   │   │   ├── Lambda函数的版本控制 --> ( 难度等级: [0.0338, 0.0341) || 挂载数据: 无 ) 
│   │   │   └── 创建部署包 --> ( 难度等级: [0.0341, 0.0343) || 挂载数据: 无 ) 
│   │   ├── 设置Serverless架构 --> ( 难度等级: [0.0343, 0.0355) || 挂载数据: 无 ) 
│   │   │   ├── S3触发器 --> ( 难度等级: [0.0343, 0.0346) || 挂载数据: 无 ) 
│   │   │   ├── SNS触发器 --> ( 难度等级: [0.0346, 0.0349) || 挂载数据: 无 ) 
│   │   │   ├── SQS触发器 --> ( 难度等级: [0.0349, 0.0352) || 挂载数据: 无 ) 
│   │   │   └── CloudWatch触发器 --> ( 难度等级: [0.0352, 0.0355) || 挂载数据: 无 ) 
│   │   ├── 部署Serverless API --> ( 难度等级: [0.0355, 0.0368) || 挂载数据: 无 ) 
│   │   │   ├── 设置集成 --> ( 难度等级: [0.0355, 0.0359) || 挂载数据: 无 ) 
│   │   │   ├── 为API部署Lambda函数 --> ( 难度等级: [0.0359, 0.0364) || 挂载数据: 无 ) 
│   │   │   └── 处理身份验证与用户控制 --> ( 难度等级: [0.0364, 0.0368) || 挂载数据: 无 ) 
│   │   ├── 扩展Serverless架构 --> ( 难度等级: [0.0368, 0.038) || 挂载数据: 无 ) 
│   │   │   ├── 第三方编排工具 --> ( 难度等级: [0.0368, 0.0372) || 挂载数据: 无 ) 
│   │   │   ├── 服务器的创建和终止 --> ( 难度等级: [0.0372, 0.0376) || 挂载数据: 无 ) 
│   │   │   └── 扩展的难点及解决方案 --> ( 难度等级: [0.0376, 0.038) || 挂载数据: 无 ) 
│   │   ├── AWS Lambda的安全性 --> ( 难度等级: [0.038, 0.0392) || 挂载数据: 无 ) 
│   │   │   ├── 了解AWS VPC --> ( 难度等级: [0.038, 0.0382) || 挂载数据: blog: 6 ) 
│   │   │   ├── 了解VPC中的子网 --> ( 难度等级: [0.0382, 0.0385) || 挂载数据: 无 ) 
│   │   │   ├── 在私有子网内保护Lambda --> ( 难度等级: [0.0385, 0.0387) || 挂载数据: 无 ) 
│   │   │   ├── Lambda函数的访问控制 --> ( 难度等级: [0.0387, 0.039) || 挂载数据: 无 ) 
│   │   │   └── 在Lambda中使用STS执行安全会话 --> ( 难度等级: [0.039, 0.0392) || 挂载数据: 无 ) 
│   │   ├── 使用SAM部署Lambda函数 --> ( 难度等级: [0.0392, 0.0404) || 挂载数据: 无 ) 
│   │   │   ├── SAM简介 --> ( 难度等级: [0.0392, 0.0395) || 挂载数据: 无 ) 
│   │   │   ├── 将CloudFormation用于Serverless服务 --> ( 难度等级: [0.0395, 0.0398) || 挂载数据: 无 ) 
│   │   │   ├── 使用SAM进行部署 --> ( 难度等级: [0.0398, 0.0401) || 挂载数据: 无 ) 
│   │   │   └── 了解SAM中的安全性 --> ( 难度等级: [0.0401, 0.0404) || 挂载数据: 无 ) 
│   │   └── 微软Azure Functions简介 --> ( 难度等级: [0.0404, 0.0417) || 挂载数据: 无 ) 
│   │       ├── 微软Azure Functions简介 --> ( 难度等级: [0.0404, 0.0407) || 挂载数据: 无 ) 
│   │       ├── 创建你的第一个Azure Function --> ( 难度等级: [0.0407, 0.0411) || 挂载数据: 无 ) 
│   │       ├── 了解触发器 --> ( 难度等级: [0.0411, 0.0414) || 挂载数据: 无 ) 
│   │       └── 编写微软Azure Functions的最佳实践 --> ( 难度等级: [0.0414, 0.0417) || 挂载数据: 无 ) 
│   ├── 微服务 --> ( 难度等级: [0.0417, 0.0833) || 挂载数据: 无 ) 
│   │   ├── Service Mesh --> ( 难度等级: [0.0417, 0.0423) || 挂载数据: 无 ) 
│   │   │   ├── Istio --> ( 难度等级: [0.0417, 0.0418) || 挂载数据: 无 ) 
│   │   │   ├── Linkerd --> ( 难度等级: [0.0418, 0.0419) || 挂载数据: 无 ) 
│   │   │   ├── Conduit --> ( 难度等级: [0.0419, 0.042) || 挂载数据: 无 ) 
│   │   │   ├── Service Mesh的现状 --> ( 难度等级: [0.042, 0.0421) || 挂载数据: 无 ) 
│   │   │   └── Istio架构分析 --> ( 难度等级: [0.0421, 0.0423) || 挂载数据: 无 ) 
│   │   ├── Framework --> ( 难度等级: [0.0423, 0.0429) || 挂载数据: blog: 2 ) 
│   │   │   ├── Dubbo --> ( 难度等级: [0.0423, 0.0425) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud --> ( 难度等级: [0.0425, 0.0427) || 挂载数据: 无 ) 
│   │   │   │   ├── 简介 --> ( 难度等级: [0.0425, 0.0426) || 挂载数据: 无 ) 
│   │   │   │   └── 常用组件 --> ( 难度等级: [0.0426, 0.0427) || 挂载数据: 无 ) 
│   │   │   └── Tars --> ( 难度等级: [0.0427, 0.0429) || 挂载数据: 无 ) 
│   │   ├── 微服务简介 --> ( 难度等级: [0.0429, 0.0435) || 挂载数据: 无 ) 
│   │   │   ├── 单体架构及其存在的不足 --> ( 难度等级: [0.0429, 0.043) || 挂载数据: 无 ) 
│   │   │   │   ├── 单体架构简介 --> ( 难度等级: [0.0429, 0.0429) || 挂载数据: 无 ) 
│   │   │   │   ├── 单体架构存在的不足 --> ( 难度等级: [0.0429, 0.043) || 挂载数据: 无 ) 
│   │   │   │   └── 单体架构使用服务器集群及存在的不足 --> ( 难度等级: [0.043, 0.043) || 挂载数据: blog: 2 ) 
│   │   │   ├── 微服务 --> ( 难度等级: [0.043, 0.0431) || 挂载数据: 无 ) 
│   │   │   │   ├── 什么是微服务 --> ( 难度等级: [0.043, 0.0431) || 挂载数据: blog: 123 ) 
│   │   │   │   └── 微服务的优势 --> ( 难度等级: [0.0431, 0.0431) || 挂载数据: 无 ) 
│   │   │   ├── 微服务的不足 --> ( 难度等级: [0.0431, 0.0432) || 挂载数据: 无 ) 
│   │   │   │   ├── 微服务的复杂度 --> ( 难度等级: [0.0431, 0.0431) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式事务 --> ( 难度等级: [0.0431, 0.0432) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 服务的划分 --> ( 难度等级: [0.0432, 0.0432) || 挂载数据: 无 ) 
│   │   │   │   └── 服务的部署 --> ( 难度等级: [0.0432, 0.0432) || 挂载数据: 无 ) 
│   │   │   ├── 微服务和SOA的关系 --> ( 难度等级: [0.0432, 0.0434) || 挂载数据: blog: 1 ) 
│   │   │   └── 微服务的设计原则 --> ( 难度等级: [0.0434, 0.0435) || 挂载数据: 无 ) 
│   │   ├── Spring Cloud简介 --> ( 难度等级: [0.0435, 0.0441) || 挂载数据: 无 ) 
│   │   │   ├── 微服务应该具备的功能 --> ( 难度等级: [0.0435, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务的注册与发现 --> ( 难度等级: [0.0435, 0.0435) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── 服务的负载均衡 --> ( 难度等级: [0.0435, 0.0435) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 服务的容错 --> ( 难度等级: [0.0435, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务网关 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 服务网关的实现原理 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── After路由断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Header断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Cookie路由断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Host路由断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   ├── Method路由断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Path路由断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── Query路由断言工厂 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 过滤器 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 过滤器的作用 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 过滤器的生命周期 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 网关过滤器 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 全局过滤器 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 限流 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 常见的限流算法 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 服务网关的限流 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 普通方式 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 条件方式 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │   └── 服务化 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 工程介绍 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   │       └── service-gateway工程详细介绍 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务配置的统一管理 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   │   └── 服务链路追踪 --> ( 难度等级: [0.0436, 0.0436) || 挂载数据: 无 ) 
│   │   │   ├── Dubbo简介 --> ( 难度等级: [0.0436, 0.0438) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes简介 --> ( 难度等级: [0.0438, 0.0439) || 挂载数据: 无 ) 
│   │   │   └── Spring Could与Kubernetes比较 --> ( 难度等级: [0.0439, 0.0441) || 挂载数据: 无 ) 
│   │   ├── 构建微服务的准备 --> ( 难度等级: [0.0441, 0.0447) || 挂载数据: 无 ) 
│   │   │   ├── JDK的安装 --> ( 难度等级: [0.0441, 0.0443) || 挂载数据: 无 ) 
│   │   │   │   ├── JDK的下载和安装 --> ( 难度等级: [0.0441, 0.0442) || 挂载数据: blog: 11 ) 
│   │   │   │   └── 环境变量的配置 --> ( 难度等级: [0.0442, 0.0443) || 挂载数据: 无 ) 
│   │   │   ├── IDEA的安装 --> ( 难度等级: [0.0443, 0.0445) || 挂载数据: 无 ) 
│   │   │   │   ├── IDEA的下载 --> ( 难度等级: [0.0443, 0.0444) || 挂载数据: blog: 16 ) 
│   │   │   │   └── 用IDEA创建一个Spring Boot工程 --> ( 难度等级: [0.0444, 0.0445) || 挂载数据: blog: 2 ) 
│   │   │   └── 构建工具Maven的使用 --> ( 难度等级: [0.0445, 0.0447) || 挂载数据: 无 ) 
│   │   │       ├── Maven简介 --> ( 难度等级: [0.0445, 0.0445) || 挂载数据: 无 ) 
│   │   │       ├── Maven的安装 --> ( 难度等级: [0.0445, 0.0446) || 挂载数据: blog: 2 ) 
│   │   │       ├── Maven的核心概念 --> ( 难度等级: [0.0446, 0.0446) || 挂载数据: 无 ) 
│   │   │       ├── 编写Pom文件 --> ( 难度等级: [0.0446, 0.0446) || 挂载数据: 无 ) 
│   │   │       └── 常用的Maven命令 --> ( 难度等级: [0.0446, 0.0447) || 挂载数据: 无 ) 
│   │   ├── 开发框架Spring Boot --> ( 难度等级: [0.0447, 0.0453) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot简介 --> ( 难度等级: [0.0447, 0.0448) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Boot的特点 --> ( 难度等级: [0.0447, 0.0447) || 挂载数据: blog: 149 ) 
│   │   │   │   └── Spring Boot的优点 --> ( 难度等级: [0.0447, 0.0448) || 挂载数据: blog: 1 ) 
│   │   │   ├── 用IDEA构建Spring Boot工程 --> ( 难度等级: [0.0448, 0.0449) || 挂载数据: 无 ) 
│   │   │   │   ├── 在Spring Boot工程中构建Web程序 --> ( 难度等级: [0.0448, 0.0448) || 挂载数据: blog: 9 ) 
│   │   │   │   └── Spring Boot的测试 --> ( 难度等级: [0.0448, 0.0449) || 挂载数据: blog: 14 ) 
│   │   │   ├── Spring Boot配置文件详解 --> ( 难度等级: [0.0449, 0.0449) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义属性 --> ( 难度等级: [0.0449, 0.0449) || 挂载数据: 无 ) 
│   │   │   │   ├── 将配置文件的属性赋给实体类 --> ( 难度等级: [0.0449, 0.0449) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义配置文件 --> ( 难度等级: [0.0449, 0.0449) || 挂载数据: 无 ) 
│   │   │   │   └── 多个环境的配置文件 --> ( 难度等级: [0.0449, 0.0449) || 挂载数据: 无 ) 
│   │   │   ├── 运行状态监控Actuator --> ( 难度等级: [0.0449, 0.045) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看运行程序的健康状态 --> ( 难度等级: [0.0449, 0.045) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看运行程序的Bean --> ( 难度等级: [0.045, 0.045) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用Actuator关闭应用程序 --> ( 难度等级: [0.045, 0.045) || 挂载数据: 无 ) 
│   │   │   │   └── 使用shell连接Actuator --> ( 难度等级: [0.045, 0.045) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot整合JPA --> ( 难度等级: [0.045, 0.0451) || 挂载数据: blog: 1 ) 
│   │   │   ├── Spring Boot整合Redis --> ( 难度等级: [0.0451, 0.0452) || 挂载数据: 无 ) 
│   │   │   │   ├── Redis简介 --> ( 难度等级: [0.0451, 0.0451) || 挂载数据: 无 ) 
│   │   │   │   ├── Redis的安装 --> ( 难度等级: [0.0451, 0.0452) || 挂载数据: blog: 53 ) 
│   │   │   │   └── 在Spring Boot中使用Redis --> ( 难度等级: [0.0452, 0.0452) || 挂载数据: blog: 44 ) 
│   │   │   └── Spring Boot整合Swagger2，搭建Restful API在线文档 --> ( 难度等级: [0.0452, 0.0453) || 挂载数据: 无 ) 
│   │   ├── 负载均衡Ribbon --> ( 难度等级: [0.0453, 0.0459) || 挂载数据: 无 ) 
│   │   │   ├── RestTemplate简介 --> ( 难度等级: [0.0453, 0.0454) || 挂载数据: blog: 1 ) 
│   │   │   ├── Ribbon简介 --> ( 难度等级: [0.0454, 0.0455) || 挂载数据: blog: 1 ) 
│   │   │   ├── 使用RestTemplate和Ribbon来消费服务 --> ( 难度等级: [0.0455, 0.0457) || 挂载数据: blog: 10 ) 
│   │   │   ├── LoadBalancerClient简介 --> ( 难度等级: [0.0457, 0.0458) || 挂载数据: 无 ) 
│   │   │   └── 源码解析Ribbon --> ( 难度等级: [0.0458, 0.0459) || 挂载数据: 无 ) 
│   │   ├── 声明式调用Feign --> ( 难度等级: [0.0459, 0.0465) || 挂载数据: 无 ) 
│   │   │   ├── 写一个Feign客户端 --> ( 难度等级: [0.0459, 0.046) || 挂载数据: 无 ) 
│   │   │   ├── FeignClient详解 --> ( 难度等级: [0.046, 0.0461) || 挂载数据: 无 ) 
│   │   │   ├── FeignClient的配置 --> ( 难度等级: [0.0461, 0.0462) || 挂载数据: 无 ) 
│   │   │   ├── 从源码的角度讲解Feign的工作原理 --> ( 难度等级: [0.0462, 0.0463) || 挂载数据: 无 ) 
│   │   │   ├── 在Feign中使用HttpClient和OkHttp --> ( 难度等级: [0.0463, 0.0464) || 挂载数据: 无 ) 
│   │   │   └── Feign是如何实现负载均衡的 --> ( 难度等级: [0.0464, 0.0465) || 挂载数据: blog: 8 ) 
│   │   ├── 熔断器Hystrix --> ( 难度等级: [0.0465, 0.0471) || 挂载数据: 无 ) 
│   │   │   ├── Hystrix简介 --> ( 难度等级: [0.0465, 0.0466) || 挂载数据: 无 ) 
│   │   │   ├── Hystrix的设计原则 --> ( 难度等级: [0.0466, 0.0467) || 挂载数据: 无 ) 
│   │   │   ├── Hystrix的工作机制 --> ( 难度等级: [0.0467, 0.0468) || 挂载数据: 无 ) 
│   │   │   ├── 在Feign上使用熔断器 --> ( 难度等级: [0.0468, 0.0469) || 挂载数据: 无 ) 
│   │   │   ├── 使用Hystrix Dashboard监控熔断器的状态 --> ( 难度等级: [0.0469, 0.047) || 挂载数据: 无 ) 
│   │   │   │   ├── 在RestTemplate中使用Hystrix Dashboard --> ( 难度等级: [0.0469, 0.047) || 挂载数据: 无 ) 
│   │   │   │   └── 在Feign中使用Hystrix Dashboard --> ( 难度等级: [0.047, 0.047) || 挂载数据: blog: 53 ) 
│   │   │   └── 使用Turbine聚合监控 --> ( 难度等级: [0.047, 0.0471) || 挂载数据: 无 ) 
│   │   ├── 路由网关Spring Cloud Zuul --> ( 难度等级: [0.0471, 0.0477) || 挂载数据: 无 ) 
│   │   │   └── Zuul的工作原理 --> ( 难度等级: [0.0471, 0.0477) || 挂载数据: blog: 3 ) 
│   │   ├── 配置中心Spring Cloud Config --> ( 难度等级: [0.0477, 0.0483) || 挂载数据: 无 ) 
│   │   │   ├── Config Server从本地读取配置文件 --> ( 难度等级: [0.0477, 0.0478) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建Config Server --> ( 难度等级: [0.0477, 0.0478) || 挂载数据: blog: 24 ) 
│   │   │   │   └── 构建Config Client --> ( 难度等级: [0.0478, 0.0478) || 挂载数据: blog: 8 ) 
│   │   │   ├── Config Server从远程Git仓库读取配置文件 --> ( 难度等级: [0.0478, 0.0479) || 挂载数据: blog: 4 ) 
│   │   │   ├── 构建高可用的Config Server --> ( 难度等级: [0.0479, 0.0481) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建Eureka Server --> ( 难度等级: [0.0479, 0.048) || 挂载数据: blog: 27 ) 
│   │   │   │   ├── 改造Config Server --> ( 难度等级: [0.048, 0.048) || 挂载数据: 无 ) 
│   │   │   │   └── 改造Config Client --> ( 难度等级: [0.048, 0.0481) || 挂载数据: 无 ) 
│   │   │   ├── 使用Spring Cloud Bus刷新配置 --> ( 难度等级: [0.0481, 0.0482) || 挂载数据: 无 ) 
│   │   │   └── 将配置存储在MySQL数据库中 --> ( 难度等级: [0.0482, 0.0483) || 挂载数据: 无 ) 
│   │   │       ├── 改造config-server工程 --> ( 难度等级: [0.0482, 0.0482) || 挂载数据: 无 ) 
│   │   │       └── 初始化数据库 --> ( 难度等级: [0.0482, 0.0483) || 挂载数据: blog: 1 ) 
│   │   ├── 服务链路追踪Spring Cloud Sleuth --> ( 难度等级: [0.0483, 0.0489) || 挂载数据: 无 ) 
│   │   │   ├── 基本术语 --> ( 难度等级: [0.0483, 0.0484) || 挂载数据: 无 ) 
│   │   │   ├── 案例讲解 --> ( 难度等级: [0.0484, 0.0485) || 挂载数据: 无 ) 
│   │   │   │   ├── 启动Zipkin Server --> ( 难度等级: [0.0484, 0.0484) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建服务提供者 --> ( 难度等级: [0.0484, 0.0485) || 挂载数据: 无 ) 
│   │   │   │   └── 构建服务消费者 --> ( 难度等级: [0.0485, 0.0485) || 挂载数据: 无 ) 
│   │   │   ├── 在链路数据中添加自定义数据 --> ( 难度等级: [0.0485, 0.0486) || 挂载数据: 无 ) 
│   │   │   ├── 使用RabbitMQ传输链路数据 --> ( 难度等级: [0.0486, 0.0487) || 挂载数据: 无 ) 
│   │   │   ├── 在MySQL数据库中存储链路数据 --> ( 难度等级: [0.0487, 0.0487) || 挂载数据: 无 ) 
│   │   │   ├── 在ElasticSearch中存储链路数据 --> ( 难度等级: [0.0487, 0.0488) || 挂载数据: 无 ) 
│   │   │   └── 用Kibana展示链路数据 --> ( 难度等级: [0.0488, 0.0489) || 挂载数据: 无 ) 
│   │   ├── 微服务监控Spring Boot Admin --> ( 难度等级: [0.0489, 0.0495) || 挂载数据: 无 ) 
│   │   │   ├── 使用Spring Boot Admin监控Spring Boot应用程序 --> ( 难度等级: [0.0489, 0.0491) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建Spring Boot Admin Server --> ( 难度等级: [0.0489, 0.049) || 挂载数据: 无 ) 
│   │   │   │   └── 创建Spring Boot Admin Client --> ( 难度等级: [0.049, 0.0491) || 挂载数据: blog: 13 ) 
│   │   │   ├── 使用Spring Boot Admin监控Spring Cloud微服务 --> ( 难度等级: [0.0491, 0.0493) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建Admin Server --> ( 难度等级: [0.0491, 0.0492) || 挂载数据: 无 ) 
│   │   │   │   └── 构建Admin Client --> ( 难度等级: [0.0492, 0.0493) || 挂载数据: blog: 3 ) 
│   │   │   └── 在Spring Boot Admin中添加Security和Mail组件 --> ( 难度等级: [0.0493, 0.0495) || 挂载数据: 无 ) 
│   │   │       ├── Spring Boot Admin集成Security组件 --> ( 难度等级: [0.0493, 0.0494) || 挂载数据: 无 ) 
│   │   │       └── Spring Boot Admin集成Mail组件 --> ( 难度等级: [0.0494, 0.0495) || 挂载数据: blog: 1 ) 
│   │   ├── Spring Boot Security详解 --> ( 难度等级: [0.0495, 0.0501) || 挂载数据: 无 ) 
│   │   │   ├── Spring Security简介 --> ( 难度等级: [0.0495, 0.0497) || 挂载数据: 无 ) 
│   │   │   │   ├── 什么是Spring Security --> ( 难度等级: [0.0495, 0.0496) || 挂载数据: blog: 236 ) 
│   │   │   │   └── Spring Security提供的安全模块 --> ( 难度等级: [0.0496, 0.0497) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot Security与Spring Security的关系 --> ( 难度等级: [0.0497, 0.0499) || 挂载数据: 无 ) 
│   │   │   └── Spring Boot Security案例详解 --> ( 难度等级: [0.0499, 0.0501) || 挂载数据: 无 ) 
│   │   │       ├── 构建Spring Boot Security工程 --> ( 难度等级: [0.0499, 0.05) || 挂载数据: blog: 24 ) 
│   │   │       ├── 配置Spring Security --> ( 难度等级: [0.05, 0.05) || 挂载数据: blog: 16 ) 
│   │   │       ├── 编写相关界面 --> ( 难度等级: [0.05, 0.05) || 挂载数据: 无 ) 
│   │   │       ├── Spring Security方法级别上的保护 --> ( 难度等级: [0.05, 0.0501) || 挂载数据: 无 ) 
│   │   │       └── 从数据库中读取用户的认证信息 --> ( 难度等级: [0.0501, 0.0501) || 挂载数据: 无 ) 
│   │   ├── 使用Spring Cloud OAuth2保护微服务系统 --> ( 难度等级: [0.0501, 0.0507) || 挂载数据: 无 ) 
│   │   │   ├── 什么是OAuth2 --> ( 难度等级: [0.0501, 0.0503) || 挂载数据: 无 ) 
│   │   │   ├── 如何使用Spring OAuth2 --> ( 难度等级: [0.0503, 0.0505) || 挂载数据: 无 ) 
│   │   │   │   ├── OAuth2 Provider --> ( 难度等级: [0.0503, 0.0504) || 挂载数据: 无 ) 
│   │   │   │   └── OAuth2 Client --> ( 难度等级: [0.0504, 0.0505) || 挂载数据: blog: 6 ) 
│   │   │   └── 案例分析 --> ( 难度等级: [0.0505, 0.0507) || 挂载数据: 无 ) 
│   │   │       ├── 编写Eureka Server --> ( 难度等级: [0.0505, 0.0506) || 挂载数据: blog: 34 ) 
│   │   │       ├── 编写Uaa授权服务 --> ( 难度等级: [0.0506, 0.0506) || 挂载数据: 无 ) 
│   │   │       ├── 编写service-hi资源服务 --> ( 难度等级: [0.0506, 0.0506) || 挂载数据: 无 ) 
│   │   │       ├── 案例架构设计 --> ( 难度等级: [0.0506, 0.0507) || 挂载数据: 无 ) 
│   │   │       ├── 编写主Maven工程 --> ( 难度等级: [0.0507, 0.0507) || 挂载数据: 无 ) 
│   │   │       └── 编写user-service资源服务 --> ( 难度等级: [0.0507, 0.0507) || 挂载数据: 无 ) 
│   │   ├── 使用Spring Security OAuth2和JWT保护微服务系统 --> ( 难度等级: [0.0507, 0.0513) || 挂载数据: 无 ) 
│   │   │   └── JWT简介 --> ( 难度等级: [0.0507, 0.0513) || 挂载数据: 无 ) 
│   │   │       ├── 什么是JWT --> ( 难度等级: [0.0507, 0.0509) || 挂载数据: blog: 185 ) 
│   │   │       ├── JWT的结构 --> ( 难度等级: [0.0509, 0.051) || 挂载数据: 无 ) 
│   │   │       ├── JWT的应用场景 --> ( 难度等级: [0.051, 0.0512) || 挂载数据: blog: 2 ) 
│   │   │       └── 如何使用JWT --> ( 难度等级: [0.0512, 0.0513) || 挂载数据: 无 ) 
│   │   ├── 使用Spring Cloud构建微服务综合案例 --> ( 难度等级: [0.0513, 0.0519) || 挂载数据: 无 ) 
│   │   │   ├── 案例介绍 --> ( 难度等级: [0.0513, 0.0515) || 挂载数据: 无 ) 
│   │   │   │   ├── 工程结构 --> ( 难度等级: [0.0513, 0.0514) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用的技术栈 --> ( 难度等级: [0.0514, 0.0514) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 工程架构 --> ( 难度等级: [0.0514, 0.0515) || 挂载数据: 无 ) 
│   │   │   │   └── 功能展示 --> ( 难度等级: [0.0515, 0.0515) || 挂载数据: 无 ) 
│   │   │   ├── 案例详解 --> ( 难度等级: [0.0515, 0.0517) || 挂载数据: 无 ) 
│   │   │   │   ├── 准备工作 --> ( 难度等级: [0.0515, 0.0515) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建主Maven工程 --> ( 难度等级: [0.0515, 0.0516) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建eureka-server工程 --> ( 难度等级: [0.0516, 0.0516) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 构建config-server工程 --> ( 难度等级: [0.0516, 0.0516) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建Zipkin工程 --> ( 难度等级: [0.0516, 0.0516) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建monitoring-service工程 --> ( 难度等级: [0.0516, 0.0516) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建uaa-service工程 --> ( 难度等级: [0.0516, 0.0516) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建gateway-service工程 --> ( 难度等级: [0.0516, 0.0517) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建admin-service工程 --> ( 难度等级: [0.0517, 0.0517) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建user-service工程 --> ( 难度等级: [0.0517, 0.0517) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建blog-service工程 --> ( 难度等级: [0.0517, 0.0517) || 挂载数据: 无 ) 
│   │   │   │   └── 构建log-service工程 --> ( 难度等级: [0.0517, 0.0517) || 挂载数据: 无 ) 
│   │   │   └── 启动源码工程 --> ( 难度等级: [0.0517, 0.0519) || 挂载数据: 无 ) 
│   │   ├── Spring Cloud生态 --> ( 难度等级: [0.0519, 0.0525) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud基础：Spring Boot概述 --> ( 难度等级: [0.0519, 0.0521) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot核心特性 --> ( 难度等级: [0.0521, 0.0523) || 挂载数据: 无 ) 
│   │   │   │   ├── Web服务器：WebServer --> ( 难度等级: [0.0521, 0.0522) || 挂载数据: 无 ) 
│   │   │   │   ├── 条件注解：@ConditionalOnXX --> ( 难度等级: [0.0522, 0.0522) || 挂载数据: 无 ) 
│   │   │   │   ├── 工厂加载机制 --> ( 难度等级: [0.0522, 0.0523) || 挂载数据: 无 ) 
│   │   │   │   ├── 配置加载机制 --> ( 难度等级: [0.0523, 0.0523) || 挂载数据: 无 ) 
│   │   │   │   └── Spring Boot Actuator --> ( 难度等级: [0.0523, 0.0523) || 挂载数据: blog: 1 ) 
│   │   │   └── Spring Cloud概述 --> ( 难度等级: [0.0523, 0.0525) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud诞生背景 --> ( 难度等级: [0.0523, 0.0524) || 挂载数据: 无 ) 
│   │   │       ├── Netflix OSS --> ( 难度等级: [0.0524, 0.0524) || 挂载数据: blog: 15 ) 
│   │   │       ├── Spring Cloud版本 --> ( 难度等级: [0.0524, 0.0525) || 挂载数据: blog: 494 ) 
│   │   │       └── Spring Cloud最新动态 --> ( 难度等级: [0.0525, 0.0525) || 挂载数据: blog: 18 ) 
│   │   ├── 负载均衡与服务调用 --> ( 难度等级: [0.0525, 0.0531) || 挂载数据: 无 ) 
│   │   │   ├── 负载均衡原理 --> ( 难度等级: [0.0525, 0.0526) || 挂载数据: blog: 2 ) 
│   │   │   ├── Spring Cloud LoadBalancer负载均衡组件 --> ( 难度等级: [0.0526, 0.0527) || 挂载数据: blog: 1 ) 
│   │   │   ├── Netflix Ribbon负载均衡 --> ( 难度等级: [0.0527, 0.0528) || 挂载数据: 无 ) 
│   │   │   │   ├── RibbonLoadBalancerClient --> ( 难度等级: [0.0527, 0.0527) || 挂载数据: 无 ) 
│   │   │   │   ├── RibbonServer和Server --> ( 难度等级: [0.0527, 0.0527) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── ServerIntrospector --> ( 难度等级: [0.0527, 0.0527) || 挂载数据: 无 ) 
│   │   │   │   ├── ILoadBalancer --> ( 难度等级: [0.0527, 0.0527) || 挂载数据: 无 ) 
│   │   │   │   ├── ServerList --> ( 难度等级: [0.0527, 0.0527) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── ServerListUpdater --> ( 难度等级: [0.0527, 0.0527) || 挂载数据: 无 ) 
│   │   │   │   ├── ServerStats --> ( 难度等级: [0.0527, 0.0528) || 挂载数据: 无 ) 
│   │   │   │   └── Ribbon缓存时间 --> ( 难度等级: [0.0528, 0.0528) || 挂载数据: blog: 115 ) 
│   │   │   ├── Dubbo LoadBalance负载均衡 --> ( 难度等级: [0.0528, 0.0528) || 挂载数据: 无 ) 
│   │   │   ├── OpenFeign：声明式Rest客户端 --> ( 难度等级: [0.0528, 0.0529) || 挂载数据: 无 ) 
│   │   │   │   ├── OpenFeign概述 --> ( 难度等级: [0.0528, 0.0529) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── OpenFeign对JAX-RS的支持 --> ( 难度等级: [0.0529, 0.0529) || 挂载数据: 无 ) 
│   │   │   │   └── OpenFeign底层执行原理 --> ( 难度等级: [0.0529, 0.0529) || 挂载数据: 无 ) 
│   │   │   ├── Dubbo Spring Cloud ：服务调用的新选择 --> ( 难度等级: [0.0529, 0.053) || 挂载数据: 无 ) 
│   │   │   ├── 再谈路由和负载均衡 --> ( 难度等级: [0.053, 0.0531) || 挂载数据: 无 ) 
│   │   │   └── 案例：应用流量控制 --> ( 难度等级: [0.0531, 0.0531) || 挂载数据: 无 ) 
│   │   │       ├── 流量控制应用的业务场景 --> ( 难度等级: [0.0531, 0.0531) || 挂载数据: blog: 1 ) 
│   │   │       └── 使用Netflix Ribbon完成应用灰度发布 --> ( 难度等级: [0.0531, 0.0531) || 挂载数据: 无 ) 
│   │   ├── 配置管理 --> ( 难度等级: [0.0531, 0.0537) || 挂载数据: 无 ) 
│   │   │   ├── 配置中心背景概述 --> ( 难度等级: [0.0531, 0.0533) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Config Server/Client --> ( 难度等级: [0.0533, 0.0535) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud Config Server --> ( 难度等级: [0.0533, 0.0534) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Spring Cloud Config Client --> ( 难度等级: [0.0534, 0.0534) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── Spring Cloud Config Client与Service Discovery整合 --> ( 难度等级: [0.0534, 0.0535) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Spring Cloud Config配置动态刷新 --> ( 难度等级: [0.0535, 0.0535) || 挂载数据: blog: 2 ) 
│   │   │   └── 再谈配置动态刷新 --> ( 难度等级: [0.0535, 0.0537) || 挂载数据: 无 ) 
│   │   ├── 熔断器 --> ( 难度等级: [0.0537, 0.0543) || 挂载数据: 无 ) 
│   │   │   ├── 熔断器模式概述 --> ( 难度等级: [0.0537, 0.0538) || 挂载数据: 无 ) 
│   │   │   ├── 手动实现一个断路器 --> ( 难度等级: [0.0538, 0.0539) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义State枚举和Counter计数器类 --> ( 难度等级: [0.0538, 0.0539) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义CircuitBreaker类 --> ( 难度等级: [0.0539, 0.0539) || 挂载数据: 无 ) 
│   │   │   │   └── 使用CircuitBreaker进行场景测试 --> ( 难度等级: [0.0539, 0.0539) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Circuit Breaker的技术演进 --> ( 难度等级: [0.0539, 0.054) || 挂载数据: 无 ) 
│   │   │   ├── Alib*ba Sentinel --> ( 难度等级: [0.054, 0.0541) || 挂载数据: 无 ) 
│   │   │   │   ├── Sentinel核心概述 --> ( 难度等级: [0.054, 0.0541) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud Alib*ba Sentinel --> ( 难度等级: [0.0541, 0.0541) || 挂载数据: 无 ) 
│   │   │   │   ├── Sentinel限流与Dashboard --> ( 难度等级: [0.0541, 0.0541) || 挂载数据: blog: 4 ) 
│   │   │   │   └── Sentinel的高级特性 --> ( 难度等级: [0.0541, 0.0541) || 挂载数据: 无 ) 
│   │   │   ├── Netflix Hystrix --> ( 难度等级: [0.0541, 0.0542) || 挂载数据: 无 ) 
│   │   │   │   ├── Hystrix核心概述 --> ( 难度等级: [0.0541, 0.0542) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud Netflix Hystrix --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── Hystrix限流与Dashboard --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: 无 ) 
│   │   │   │   └── Hystrix的高级特性 --> ( 难度等级: [0.0542, 0.0542) || 挂载数据: 无 ) 
│   │   │   └── Resilience4j --> ( 难度等级: [0.0542, 0.0543) || 挂载数据: 无 ) 
│   │   │       ├── Resilience4j体验 --> ( 难度等级: [0.0542, 0.0543) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud Resilience4j --> ( 难度等级: [0.0543, 0.0543) || 挂载数据: 无 ) 
│   │   │       └── Resilience4j的高级特性 --> ( 难度等级: [0.0543, 0.0543) || 挂载数据: 无 ) 
│   │   ├── Spring生态消息驱动 --> ( 难度等级: [0.0543, 0.055) || 挂载数据: 无 ) 
│   │   │   ├── 消息中间件概述 --> ( 难度等级: [0.0543, 0.0545) || 挂载数据: 无 ) 
│   │   │   ├── Spring与消息 --> ( 难度等级: [0.0545, 0.0546) || 挂载数据: 无 ) 
│   │   │   │   ├── 消息编程模型的统一 --> ( 难度等级: [0.0545, 0.0545) || 挂载数据: 无 ) 
│   │   │   │   ├── 消息的发送和订阅 --> ( 难度等级: [0.0545, 0.0546) || 挂载数据: blog: 1 ) 
│   │   │   │   └── WebSocket --> ( 难度等级: [0.0546, 0.0546) || 挂载数据: blog: 4 ) 
│   │   │   ├── Spring Integration --> ( 难度等级: [0.0546, 0.0548) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Integration核心组件概述 --> ( 难度等级: [0.0546, 0.0547) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Spring Integration核心组件的使用 --> ( 难度等级: [0.0547, 0.0548) || 挂载数据: blog: 2 ) 
│   │   │   └── Spring Cloud Stream --> ( 难度等级: [0.0548, 0.055) || 挂载数据: 无 ) 
│   │   │       ├── 使用Spring Cloud Stream发送和接收消息 --> ( 难度等级: [0.0548, 0.0548) || 挂载数据: blog: 2 ) 
│   │   │       ├── 理解Binder和Binding --> ( 难度等级: [0.0548, 0.0549) || 挂载数据: 无 ) 
│   │   │       ├── 深入理解Spring Cloud Stream --> ( 难度等级: [0.0549, 0.0549) || 挂载数据: blog: 4 ) 
│   │   │       └── Spring Cloud Stream的高级特性 --> ( 难度等级: [0.0549, 0.055) || 挂载数据: blog: 1 ) 
│   │   ├── 消息总线 --> ( 难度等级: [0.055, 0.0556) || 挂载数据: 无 ) 
│   │   │   ├── 消息总线概述 --> ( 难度等级: [0.055, 0.0553) || 挂载数据: 无 ) 
│   │   │   └── 深入理解Spring Cloud Bus --> ( 难度等级: [0.0553, 0.0556) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud Bus的使用 --> ( 难度等级: [0.0553, 0.0553) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud Bus的原理 --> ( 难度等级: [0.0553, 0.0554) || 挂载数据: 无 ) 
│   │   │       ├── Spring Cloud Bus事件 --> ( 难度等级: [0.0554, 0.0555) || 挂载数据: 无 ) 
│   │   │       └── Spring Cloud Bus源码分析 --> ( 难度等级: [0.0555, 0.0556) || 挂载数据: 无 ) 
│   │   ├── Spring Cloud Data Flow --> ( 难度等级: [0.0556, 0.0562) || 挂载数据: 无 ) 
│   │   │   ├── 批处理/流处理概述 --> ( 难度等级: [0.0556, 0.0556) || 挂载数据: 无 ) 
│   │   │   ├── 流处理案例：信用卡反欺诈系统 --> ( 难度等级: [0.0556, 0.0557) || 挂载数据: 无 ) 
│   │   │   ├── 批处理案例：统计GitHub仓库的各项指标数据 --> ( 难度等级: [0.0557, 0.0558) || 挂载数据: blog: 4 ) 
│   │   │   ├── Spring Cloud Data Flow批处理任务组合 --> ( 难度等级: [0.0558, 0.0558) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Data Flow Shell --> ( 难度等级: [0.0558, 0.0559) || 挂载数据: blog: 4 ) 
│   │   │   ├── Spring Cloud Skipper --> ( 难度等级: [0.0559, 0.056) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Deployer --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   ├── TaskLauncher接口 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   ├── AppDeployer接口 --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   └── LocalAppDeployer --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   ├── Spring Cloud Task --> ( 难度等级: [0.056, 0.0561) || 挂载数据: 无 ) 
│   │   │   │   ├── 体验Spring Cloud Task --> ( 难度等级: [0.056, 0.056) || 挂载数据: 无 ) 
│   │   │   │   ├── 深入理解Spring Cloud Task --> ( 难度等级: [0.056, 0.0561) || 挂载数据: blog: 9 ) 
│   │   │   │   └── Spring Cloud Task Batch --> ( 难度等级: [0.0561, 0.0561) || 挂载数据: 无 ) 
│   │   │   └── Spring Batch --> ( 难度等级: [0.0561, 0.0562) || 挂载数据: 无 ) 
│   │   │       └── Spring Batch核心组件 --> ( 难度等级: [0.0561, 0.0562) || 挂载数据: blog: 4 ) 
│   │   ├── 网关 --> ( 难度等级: [0.0562, 0.0568) || 挂载数据: 无 ) 
│   │   │   ├── API网关概述 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: 无 ) 
│   │   │   │   ├── API网关的定义、职能与关注点 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: 无 ) 
│   │   │   │   └── API网关的分类与技术分析 --> ( 难度等级: [0.0562, 0.0562) || 挂载数据: blog: 6 ) 
│   │   │   ├── Netflix Zuul --> ( 难度等级: [0.0562, 0.0563) || 挂载数据: 无 ) 
│   │   │   ├── 非阻塞式的Spring Cloud Gateway --> ( 难度等级: [0.0563, 0.0564) || 挂载数据: 无 ) 
│   │   │   ├── Route路由信息 --> ( 难度等级: [0.0564, 0.0565) || 挂载数据: 无 ) 
│   │   │   ├── Predicate机制 --> ( 难度等级: [0.0565, 0.0565) || 挂载数据: 无 ) 
│   │   │   │   ├── PredicateDefinition和AsyncPredicate --> ( 难度等级: [0.0565, 0.0565) || 挂载数据: 无 ) 
│   │   │   │   ├── RoutePredicateFactory --> ( 难度等级: [0.0565, 0.0565) || 挂载数据: 无 ) 
│   │   │   │   └── 内置RoutePredicateFactory --> ( 难度等级: [0.0565, 0.0565) || 挂载数据: 无 ) 
│   │   │   ├── Filter机制 --> ( 难度等级: [0.0565, 0.0566) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── FilterDefinition和GatewayFilter --> ( 难度等级: [0.0565, 0.0566) || 挂载数据: 无 ) 
│   │   │   │   ├── GlobalFilter --> ( 难度等级: [0.0566, 0.0566) || 挂载数据: 无 ) 
│   │   │   │   ├── 内置GatewayFilterFactory --> ( 难度等级: [0.0566, 0.0566) || 挂载数据: 无 ) 
│   │   │   │   └── 网关内置的GlobalFilter --> ( 难度等级: [0.0566, 0.0566) || 挂载数据: blog: 1 ) 
│   │   │   ├── 整合注册中心和配置中心 --> ( 难度等级: [0.0566, 0.0567) || 挂载数据: 无 ) 
│   │   │   └── GatewayControllerEndpoint --> ( 难度等级: [0.0567, 0.0568) || 挂载数据: 无 ) 
│   │   ├── 综述 --> ( 难度等级: [0.0568, 0.0574) || 挂载数据: 无 ) 
│   │   │   ├── Cloud Native的起源 --> ( 难度等级: [0.0568, 0.0568) || 挂载数据: 无 ) 
│   │   │   ├── Cloud Native的组成 --> ( 难度等级: [0.0568, 0.0569) || 挂载数据: blog: 1 ) 
│   │   │   ├── Cloud Native背后的诉求 --> ( 难度等级: [0.0569, 0.057) || 挂载数据: 无 ) 
│   │   │   ├── 如何衡量Cloud Native的能力 --> ( 难度等级: [0.057, 0.0571) || 挂载数据: 无 ) 
│   │   │   ├── Cloud Native的原则 --> ( 难度等级: [0.0571, 0.0571) || 挂载数据: 无 ) 
│   │   │   ├── 可用性和可靠性的关系 --> ( 难度等级: [0.0571, 0.0572) || 挂载数据: 无 ) 
│   │   │   ├── 可用性的衡量标准 --> ( 难度等级: [0.0572, 0.0573) || 挂载数据: 无 ) 
│   │   │   └── 什么降低了可用性 --> ( 难度等级: [0.0573, 0.0574) || 挂载数据: 无 ) 
│   │   ├── 微服务架构 --> ( 难度等级: [0.0574, 0.058) || 挂载数据: blog: 1 ) 
│   │   │   ├── 微服务架构的起源 --> ( 难度等级: [0.0574, 0.0574) || 挂载数据: 无 ) 
│   │   │   ├── 微服务架构实施的先决条件 --> ( 难度等级: [0.0574, 0.0575) || 挂载数据: 无 ) 
│   │   │   │   ├── 研发环境和流程上的转变 --> ( 难度等级: [0.0574, 0.0574) || 挂载数据: 无 ) 
│   │   │   │   └── 拆分前先做好解耦 --> ( 难度等级: [0.0574, 0.0575) || 挂载数据: 无 ) 
│   │   │   ├── 微服务划分模式 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于业务复杂度选择服务划分方法 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于数据驱动划分服务 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 基于领域驱动划分服务 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: 无 ) 
│   │   │   │   ├── 从已有单体架构中逐步划分服务 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: 无 ) 
│   │   │   │   ├── 微服务拆分策略 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 如何衡量服务划分的合理性 --> ( 难度等级: [0.0575, 0.0575) || 挂载数据: 无 ) 
│   │   │   ├── 微服务划分反模式 --> ( 难度等级: [0.0575, 0.0576) || 挂载数据: 无 ) 
│   │   │   ├── 微服务API设计 --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── YXAPI的设计原则 --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务间通信——RPC --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   │   ├── 序列化——Protobuf --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务间通信——RESTful --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过Swagger实现RESTful --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── HTTP协议的进化——HTTP/2 --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   │   └── HTTP/2和Protobuf的组合——gRPC --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   ├── 微服务框架 --> ( 难度等级: [0.0576, 0.0576) || 挂载数据: 无 ) 
│   │   │   ├── 基于Dubbo框架实现微服务 --> ( 难度等级: [0.0576, 0.0577) || 挂载数据: 无 ) 
│   │   │   ├── 基于Spring Cloud框架实现微服务 --> ( 难度等级: [0.0577, 0.0577) || 挂载数据: 无 ) 
│   │   │   ├── 服务发现场景下的ZooKeeper与Etcd --> ( 难度等级: [0.0577, 0.0578) || 挂载数据: blog: 4 ) 
│   │   │   ├── 微服务部署策略 --> ( 难度等级: [0.0578, 0.0578) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务D享数据库 --> ( 难度等级: [0.0578, 0.0578) || 挂载数据: 无 ) 
│   │   │   │   └── 服务D享虚拟机/容器 --> ( 难度等级: [0.0578, 0.0578) || 挂载数据: 无 ) 
│   │   │   ├── 几种常见的微服务架构方案 --> ( 难度等级: [0.0578, 0.0579) || 挂载数据: 无 ) 
│   │   │   │   ├── ZeroC IceGrid微服务架构 --> ( 难度等级: [0.0578, 0.0578) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud微服务架构 --> ( 难度等级: [0.0578, 0.0579) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 基于消息队列的微服务架构 --> ( 难度等级: [0.0579, 0.0579) || 挂载数据: 无 ) 
│   │   │   │   └── Docker Swarm微服务架构 --> ( 难度等级: [0.0579, 0.0579) || 挂载数据: blog: 9 ) 
│   │   │   ├── 深入Kubernetes微服务平台 --> ( 难度等级: [0.0579, 0.0579) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Kubernetes的PaaS平台 --> ( 难度等级: [0.0579, 0.0579) || 挂载数据: blog: 1 ) 
│   │   │   └── 从微服务到Service Mesh --> ( 难度等级: [0.0579, 0.058) || 挂载数据: blog: 1 ) 
│   │   │       ├── Service Mesh之再见架构 --> ( 难度等级: [0.0579, 0.0579) || 挂载数据: 无 ) 
│   │   │       ├── Envoy核心实践入门 --> ( 难度等级: [0.0579, 0.0579) || 挂载数据: 无 ) 
│   │   │       ├── Istio背后的技术 --> ( 难度等级: [0.0579, 0.058) || 挂载数据: blog: 1 ) 
│   │   │       └── Istio的架构演变 --> ( 难度等级: [0.058, 0.058) || 挂载数据: 无 ) 
│   │   ├── 敏捷基础设施及公共基础服务 --> ( 难度等级: [0.058, 0.0586) || 挂载数据: 无 ) 
│   │   │   ├── 传统基础设施面临的挑战 --> ( 难度等级: [0.058, 0.058) || 挂载数据: 无 ) 
│   │   │   ├── 什么是敏捷基础设施 --> ( 难度等级: [0.058, 0.0581) || 挂载数据: 无 ) 
│   │   │   ├── 基于容器的敏捷基础设施 --> ( 难度等级: [0.0581, 0.0582) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器VS虚拟机 --> ( 难度等级: [0.0581, 0.0581) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── 安装Docker --> ( 难度等级: [0.0581, 0.0581) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署私有Docker Registry --> ( 难度等级: [0.0581, 0.0582) || 挂载数据: 无 ) 
│   │   │   │   └── 基于docker-compose管理容器 --> ( 难度等级: [0.0582, 0.0582) || 挂载数据: 无 ) 
│   │   │   ├── 基于公共基础服务的平台化 --> ( 难度等级: [0.0582, 0.0582) || 挂载数据: 无 ) 
│   │   │   ├── 监控告警fu务 --> ( 难度等级: [0.0582, 0.0583) || 挂载数据: 无 ) 
│   │   │   │   ├── 监控数据采集 --> ( 难度等级: [0.0582, 0.0583) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 监控数据接收模式 --> ( 难度等级: [0.0583, 0.0583) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过时间序列数据库存储监控数据 --> ( 难度等级: [0.0583, 0.0583) || 挂载数据: 无 ) 
│   │   │   │   ├── 开源监控系统实现Prometheus --> ( 难度等级: [0.0583, 0.0583) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 通过Prometheus和Grafana监控服务 --> ( 难度等级: [0.0583, 0.0583) || 挂载数据: 无 ) 
│   │   │   ├── 分布式消息中间件服务 --> ( 难度等级: [0.0583, 0.0584) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式消息中间件的作用 --> ( 难度等级: [0.0583, 0.0583) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 业界常用的分布式消息中间件 --> ( 难度等级: [0.0583, 0.0583) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Kafka的设计原理 --> ( 难度等级: [0.0583, 0.0583) || 挂载数据: blog: 38 ) 
│   │   │   │   ├── Kafka的数据存储结构 --> ( 难度等级: [0.0583, 0.0584) || 挂载数据: blog: 36 ) 
│   │   │   │   ├── 如何保证Kafka不丢消息 --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Kafka跨数据中心场景集群部署模式 --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: 无 ) 
│   │   │   ├── 分布式缓存服务 --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式缓存的应用场景 --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: 无 ) 
│   │   │   │   ├── 业界常用的分布式缓存Memcached --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: 无 ) 
│   │   │   │   ├── 业界常用的分布式缓存——Redis --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Redis常用的分布式缓存集群模式 --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Codis实现Redis分布式缓存集群 --> ( 难度等级: [0.0584, 0.0584) || 挂载数据: blog: 3 ) 
│   │   │   ├── 分布式任务调度服务 --> ( 难度等级: [0.0584, 0.0585) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过Tbschedule实现分布式任务调度 --> ( 难度等级: [0.0584, 0.0585) || 挂载数据: 无 ) 
│   │   │   │   └── 通过Elastic-Job实现分布式任务调度 --> ( 难度等级: [0.0585, 0.0585) || 挂载数据: blog: 1 ) 
│   │   │   └── 如何生成分布式ID --> ( 难度等级: [0.0585, 0.0586) || 挂载数据: 无 ) 
│   │   │       ├── UUID --> ( 难度等级: [0.0585, 0.0585) || 挂载数据: 无 ) 
│   │   │       ├── SDwFlake --> ( 难度等级: [0.0585, 0.0586) || 挂载数据: 无 ) 
│   │   │       └── Ticket Server --> ( 难度等级: [0.0586, 0.0586) || 挂载数据: 无 ) 
│   │   ├── 可用性设计 --> ( 难度等级: [0.0586, 0.0592) || 挂载数据: 无 ) 
│   │   │   ├── 逐步切换 --> ( 难度等级: [0.0586, 0.0587) || 挂载数据: 无 ) 
│   │   │   │   ├── 影子测试 --> ( 难度等级: [0.0586, 0.0586) || 挂载数据: 无 ) 
│   │   │   │   ├── 蓝绿部署 --> ( 难度等级: [0.0586, 0.0586) || 挂载数据: 无 ) 
│   │   │   │   └── 灰度发布/金丝雀发布 --> ( 难度等级: [0.0586, 0.0587) || 挂载数据: 无 ) 
│   │   │   ├── 容错设计 --> ( 难度等级: [0.0587, 0.0588) || 挂载数据: 无 ) 
│   │   │   │   ├── 消除单点 --> ( 难度等级: [0.0587, 0.0587) || 挂载数据: 无 ) 
│   │   │   │   ├── 特性开关 --> ( 难度等级: [0.0587, 0.0587) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务分级 --> ( 难度等级: [0.0587, 0.0587) || 挂载数据: 无 ) 
│   │   │   │   ├── 降级设计 --> ( 难度等级: [0.0587, 0.0587) || 挂载数据: blog: 12 ) 
│   │   │   │   ├── 超时重试 --> ( 难度等级: [0.0587, 0.0588) || 挂载数据: 无 ) 
│   │   │   │   └── 隔离策略 --> ( 难度等级: [0.0588, 0.0588) || 挂载数据: 无 ) 
│   │   │   ├── 流控设计 --> ( 难度等级: [0.0588, 0.0589) || 挂载数据: 无 ) 
│   │   │   │   ├── 限流算法 --> ( 难度等级: [0.0588, 0.0588) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 流控策略 --> ( 难度等级: [0.0588, 0.0588) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于Guava限流 --> ( 难度等级: [0.0588, 0.0589) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Nginx限流 --> ( 难度等级: [0.0589, 0.0589) || 挂载数据: 无 ) 
│   │   │   ├── 容量预估 --> ( 难度等级: [0.0589, 0.059) || 挂载数据: 无 ) 
│   │   │   ├── 故障演练 --> ( 难度等级: [0.059, 0.0591) || 挂载数据: 无 ) 
│   │   │   └── 数据迁移 --> ( 难度等级: [0.0591, 0.0592) || 挂载数据: 无 ) 
│   │   │       ├── 逻辑分离，物理不分离 --> ( 难度等级: [0.0591, 0.0591) || 挂载数据: 无 ) 
│   │   │       └── 物理分离 --> ( 难度等级: [0.0591, 0.0592) || 挂载数据: 无 ) 
│   │   ├── 可扩展性设计 --> ( 难度等级: [0.0592, 0.0598) || 挂载数据: 无 ) 
│   │   │   ├── 横向扩展 --> ( 难度等级: [0.0592, 0.0593) || 挂载数据: 无 ) 
│   │   │   ├── AKF扩展立方体 --> ( 难度等级: [0.0593, 0.0594) || 挂载数据: 无 ) 
│   │   │   ├── 如何扩展长连接 --> ( 难度等级: [0.0594, 0.0595) || 挂载数据: 无 ) 
│   │   │   ├── 如何扩展数据库 --> ( 难度等级: [0.0595, 0.0597) || 挂载数据: 无 ) 
│   │   │   │   ├── X轴扩展——主从复制集群 --> ( 难度等级: [0.0595, 0.0596) || 挂载数据: 无 ) 
│   │   │   │   ├── Y轴扩展——分库、垂直分表 --> ( 难度等级: [0.0596, 0.0596) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Z轴扩展——分片（sharding） --> ( 难度等级: [0.0596, 0.0596) || 挂载数据: 无 ) 
│   │   │   │   ├── 分片扩容（re-sharding） --> ( 难度等级: [0.0596, 0.0596) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 精选案例 --> ( 难度等级: [0.0596, 0.0597) || 挂载数据: 无 ) 
│   │   │   └── 如何扩展数据中心 --> ( 难度等级: [0.0597, 0.0598) || 挂载数据: 无 ) 
│   │   │       ├── 两地三中心和同城多活 --> ( 难度等级: [0.0597, 0.0597) || 挂载数据: 无 ) 
│   │   │       ├── 同城多活 --> ( 难度等级: [0.0597, 0.0597) || 挂载数据: 无 ) 
│   │   │       └── 异地多活 --> ( 难度等级: [0.0597, 0.0598) || 挂载数据: 无 ) 
│   │   ├── 性能设计 --> ( 难度等级: [0.0598, 0.0604) || 挂载数据: 无 ) 
│   │   │   ├── 性能指标 --> ( 难度等级: [0.0598, 0.0598) || 挂载数据: 无 ) 
│   │   │   ├── 如何树立目标 --> ( 难度等级: [0.0598, 0.0599) || 挂载数据: 无 ) 
│   │   │   ├── 如何寻找平衡点 --> ( 难度等级: [0.0599, 0.06) || 挂载数据: 无 ) 
│   │   │   ├── 如何定位瓶颈点 --> ( 难度等级: [0.06, 0.0601) || 挂载数据: 无 ) 
│   │   │   ├── 服务通信优化 --> ( 难度等级: [0.0601, 0.0601) || 挂载数据: 无 ) 
│   │   │   │   ├── 同步转异步 --> ( 难度等级: [0.0601, 0.0601) || 挂载数据: 无 ) 
│   │   │   │   ├── 阻塞转非阻塞 --> ( 难度等级: [0.0601, 0.0601) || 挂载数据: 无 ) 
│   │   │   │   └── 序列化 --> ( 难度等级: [0.0601, 0.0601) || 挂载数据: 无 ) 
│   │   │   ├── 通过消息中间件提升写性能 --> ( 难度等级: [0.0601, 0.0602) || 挂载数据: blog: 1 ) 
│   │   │   ├── 通过缓存提升读性能 --> ( 难度等级: [0.0602, 0.0603) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于ConcurrentHashMap实现本地缓存 --> ( 难度等级: [0.0602, 0.0602) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 基于Guava Cache实现本地缓存 --> ( 难度等级: [0.0602, 0.0602) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 缓存的常用模式 --> ( 难度等级: [0.0602, 0.0603) || 挂载数据: 无 ) 
│   │   │   ├── 数据库优化 --> ( 难度等级: [0.0603, 0.0603) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过执行计划分析瓶颈点 --> ( 难度等级: [0.0603, 0.0603) || 挂载数据: 无 ) 
│   │   │   │   ├── 为搜索字段创建索引 --> ( 难度等级: [0.0603, 0.0603) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过慢查询日志分析瓶颈点 --> ( 难度等级: [0.0603, 0.0603) || 挂载数据: 无 ) 
│   │   │   │   └── 通过提升硬件能力优化数据库 --> ( 难度等级: [0.0603, 0.0603) || 挂载数据: 无 ) 
│   │   │   └── 简化设计 --> ( 难度等级: [0.0603, 0.0604) || 挂载数据: 无 ) 
│   │   │       ├── 转移复杂度 --> ( 难度等级: [0.0603, 0.0604) || 挂载数据: 无 ) 
│   │   │       └── 从业务角度优化 --> ( 难度等级: [0.0604, 0.0604) || 挂载数据: 无 ) 
│   │   ├── 一致性设计 --> ( 难度等级: [0.0604, 0.061) || 挂载数据: 无 ) 
│   │   │   ├── 基础理论 --> ( 难度等级: [0.0604, 0.0605) || 挂载数据: 无 ) 
│   │   │   │   ├── CAP定理 --> ( 难度等级: [0.0604, 0.0604) || 挂载数据: 无 ) 
│   │   │   │   ├── BASE理论 --> ( 难度等级: [0.0604, 0.0604) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Quorum机制（NWR模型） --> ( 难度等级: [0.0604, 0.0604) || 挂载数据: 无 ) 
│   │   │   │   ├── 租约机制（Lease） --> ( 难度等级: [0.0604, 0.0605) || 挂载数据: 无 ) 
│   │   │   │   └── 状态机（Replicated State Machine） --> ( 难度等级: [0.0605, 0.0605) || 挂载数据: blog: 1 ) 
│   │   │   ├── 分布式系统的一致性分类 --> ( 难度等级: [0.0605, 0.0606) || 挂载数据: 无 ) 
│   │   │   │   ├── 以数据为中心的一致性模型 --> ( 难度等级: [0.0605, 0.0605) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 以用户为中心的一致性模型 --> ( 难度等级: [0.0605, 0.0606) || 挂载数据: 无 ) 
│   │   │   │   └── 业界常用的一致性模型 --> ( 难度等级: [0.0606, 0.0606) || 挂载数据: 无 ) 
│   │   │   ├── 如何实现强一致性 --> ( 难度等级: [0.0606, 0.0607) || 挂载数据: 无 ) 
│   │   │   │   ├── 两阶段提交 --> ( 难度等级: [0.0606, 0.0606) || 挂载数据: 无 ) 
│   │   │   │   └── 三阶段提交（3PC） --> ( 难度等级: [0.0606, 0.0607) || 挂载数据: blog: 1 ) 
│   │   │   ├── 如何实现Z终一致性 --> ( 难度等级: [0.0607, 0.0608) || 挂载数据: 无 ) 
│   │   │   │   ├── 重试机制 --> ( 难度等级: [0.0607, 0.0607) || 挂载数据: 无 ) 
│   │   │   │   ├── 本地记录日志 --> ( 难度等级: [0.0607, 0.0607) || 挂载数据: 无 ) 
│   │   │   │   ├── 可靠事件模式 --> ( 难度等级: [0.0607, 0.0607) || 挂载数据: 无 ) 
│   │   │   │   ├── Saga事务模型 --> ( 难度等级: [0.0607, 0.0608) || 挂载数据: 无 ) 
│   │   │   │   └── TCC事务模型 --> ( 难度等级: [0.0608, 0.0608) || 挂载数据: 无 ) 
│   │   │   ├── 分布式锁 --> ( 难度等级: [0.0608, 0.0609) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于数据库实现悲观锁和乐观锁 --> ( 难度等级: [0.0608, 0.0608) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于ZooKeeper的分布式锁 --> ( 难度等级: [0.0608, 0.0609) || 挂载数据: blog: 7 ) 
│   │   │   │   └── 基于Redis实现分布式锁 --> ( 难度等级: [0.0609, 0.0609) || 挂载数据: blog: 32 ) 
│   │   │   └── 如何保证幂等性 --> ( 难度等级: [0.0609, 0.061) || 挂载数据: 无 ) 
│   │   │       ├── 幂等令牌（Idempotency Key） --> ( 难度等级: [0.0609, 0.0609) || 挂载数据: 无 ) 
│   │   │       └── 在数据库中实现幂等性 --> ( 难度等级: [0.0609, 0.061) || 挂载数据: 无 ) 
│   │   ├── 未来值得关注的方向 --> ( 难度等级: [0.061, 0.0616) || 挂载数据: blog: 1 ) 
│   │   │   └── Serverless --> ( 难度等级: [0.061, 0.0616) || 挂载数据: 无 ) 
│   │   │       ├── 什么是Serverless --> ( 难度等级: [0.061, 0.0612) || 挂载数据: 无 ) 
│   │   │       ├── Serverless的现状 --> ( 难度等级: [0.0612, 0.0614) || 挂载数据: 无 ) 
│   │   │       └── Serverless的应用场景 --> ( 难度等级: [0.0614, 0.0616) || 挂载数据: 无 ) 
│   │   ├── 研发流程 --> ( 难度等级: [0.0616, 0.0622) || 挂载数据: 无 ) 
│   │   │   ├── 十二因子 --> ( 难度等级: [0.0616, 0.0617) || 挂载数据: 无 ) 
│   │   │   ├── 自动化测试 --> ( 难度等级: [0.0617, 0.0618) || 挂载数据: 无 ) 
│   │   │   │   ├── 单元测试 --> ( 难度等级: [0.0617, 0.0617) || 挂载数据: 无 ) 
│   │   │   │   ├── TDD --> ( 难度等级: [0.0617, 0.0617) || 挂载数据: 无 ) 
│   │   │   │   └── 提交即意味着可测试 --> ( 难度等级: [0.0617, 0.0618) || 挂载数据: 无 ) 
│   │   │   ├── Code Review --> ( 难度等级: [0.0618, 0.0619) || 挂载数据: 无 ) 
│   │   │   │   ├── Code Review的意义 --> ( 难度等级: [0.0618, 0.0618) || 挂载数据: 无 ) 
│   │   │   │   ├── Code Review的原则 --> ( 难度等级: [0.0618, 0.0618) || 挂载数据: blog: 4 ) 
│   │   │   │   └── Code Review的过程 --> ( 难度等级: [0.0618, 0.0619) || 挂载数据: 无 ) 
│   │   │   ├── 流水线 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: 无 ) 
│   │   │   │   ├── 持续交付 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: 无 ) 
│   │   │   │   ├── 持续部署流水线 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于开源打造流水线 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: 无 ) 
│   │   │   │   ├── YMX的流水线 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: 无 ) 
│   │   │   │   └── 开发人员自服务 --> ( 难度等级: [0.0619, 0.0619) || 挂载数据: 无 ) 
│   │   │   ├── 基于数据和反馈持续改进 --> ( 难度等级: [0.0619, 0.062) || 挂载数据: 无 ) 
│   │   │   ├── 拥抱变化 --> ( 难度等级: [0.062, 0.0621) || 挂载数据: 无 ) 
│   │   │   └── 代码即设计 --> ( 难度等级: [0.0621, 0.0622) || 挂载数据: 无 ) 
│   │   ├── 团队文化 --> ( 难度等级: [0.0622, 0.0628) || 挂载数据: 无 ) 
│   │   │   ├── 组织结构 --> ( 难度等级: [0.0622, 0.0623) || 挂载数据: 无 ) 
│   │   │   │   ├── 康威定律 --> ( 难度等级: [0.0622, 0.0622) || 挂载数据: 无 ) 
│   │   │   │   ├── 扁平化的组织 --> ( 难度等级: [0.0622, 0.0623) || 挂载数据: 无 ) 
│   │   │   │   ├── D裁的管理方式还是民主的管理方式 --> ( 难度等级: [0.0623, 0.0623) || 挂载数据: 无 ) 
│   │   │   │   └── 民主的团队如何做决策 --> ( 难度等级: [0.0623, 0.0623) || 挂载数据: 无 ) 
│   │   │   ├── 环境氛围 --> ( 难度等级: [0.0623, 0.0625) || 挂载数据: 无 ) 
│   │   │   │   ├── 公开透明的工作环境 --> ( 难度等级: [0.0623, 0.0624) || 挂载数据: 无 ) 
│   │   │   │   ├── 学习型组织 --> ( 难度等级: [0.0624, 0.0624) || 挂载数据: 无 ) 
│   │   │   │   ├── 减少正式的汇报 --> ( 难度等级: [0.0624, 0.0624) || 挂载数据: 无 ) 
│   │   │   │   ├── 高效的会议 --> ( 难度等级: [0.0624, 0.0625) || 挂载数据: 无 ) 
│   │   │   │   └── 量化指标致死 --> ( 难度等级: [0.0625, 0.0625) || 挂载数据: 无 ) 
│   │   │   ├── 管理风格 --> ( 难度等级: [0.0625, 0.0627) || 挂载数据: 无 ) 
│   │   │   │   ├── 下属请假你会拒绝吗 --> ( 难度等级: [0.0625, 0.0625) || 挂载数据: 无 ) 
│   │   │   │   ├── 得到了所有人的认可，说明你并不是一个好的管理者 --> ( 难度等级: [0.0625, 0.0626) || 挂载数据: 无 ) 
│   │   │   │   ├── 尽量避免用自己的权力去做决策 --> ( 难度等级: [0.0626, 0.0626) || 挂载数据: 无 ) 
│   │   │   │   ├── 一屋不扫也可助你“荡平天下” --> ( 难度等级: [0.0626, 0.0626) || 挂载数据: 无 ) 
│   │   │   │   └── 如何留下你想要的人 --> ( 难度等级: [0.0626, 0.0627) || 挂载数据: 无 ) 
│   │   │   └── 经典案例 --> ( 难度等级: [0.0627, 0.0628) || 挂载数据: 无 ) 
│   │   │       ├── Instagram的团队文化 --> ( 难度等级: [0.0627, 0.0627) || 挂载数据: 无 ) 
│   │   │       └── Netflix的团队文化 --> ( 难度等级: [0.0627, 0.0628) || 挂载数据: 无 ) 
│   │   ├── 基础篇 --> ( 难度等级: [0.0628, 0.0634) || 挂载数据: blog: 1 ) 
│   │   │   ├── Service Mesh简介 --> ( 难度等级: [0.0628, 0.0631) || 挂载数据: 无 ) 
│   │   │   │   ├── 微服务架构面临的一些挑战 --> ( 难度等级: [0.0628, 0.0629) || 挂载数据: 无 ) 
│   │   │   │   ├── 技术架构演进 --> ( 难度等级: [0.0629, 0.063) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Service Mesh的功能 --> ( 难度等级: [0.063, 0.063) || 挂载数据: 无 ) 
│   │   │   │   └── 业界Service Mesh产品 --> ( 难度等级: [0.063, 0.0631) || 挂载数据: 无 ) 
│   │   │   │       └── Envoy --> ( 难度等级: [0.063, 0.0631) || 挂载数据: blog: 1 ) 
│   │   │   └── Linkerd入门 --> ( 难度等级: [0.0631, 0.0634) || 挂载数据: 无 ) 
│   │   │       ├── Linkerd架构 --> ( 难度等级: [0.0631, 0.0632) || 挂载数据: 无 ) 
│   │   │       ├── Linkerd主要功能 --> ( 难度等级: [0.0632, 0.0633) || 挂载数据: 无 ) 
│   │   │       ├── 安装Linkerd --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   ├── 环境准备 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 虚拟机及Docker引擎 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 服务发现：Consul --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: blog: 203 ) 
│   │   │       │   │   ├── 部署Linkerd --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 部署示例服务 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 在本地搭建Istio环境 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: blog: 2 ) 
│   │   │       │   │   │   ├── 安装Kubernetes集群 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: blog: 1 ) 
│   │   │       │   │   │   ├── 安装Helm --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: blog: 1 ) 
│   │   │       │   │   │   └── 安装Istio --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   │   ├── 在公有云上使用Istio --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   │   └── 尝鲜Istio命令行 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   ├── 传统安装方式 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       │   └── 基于Docker的安装方式 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │       └── 示例演示 --> ( 难度等级: [0.0633, 0.0634) || 挂载数据: 无 ) 
│   │   │           ├── 示例准备 --> ( 难度等级: [0.0633, 0.0634) || 挂载数据: blog: 1 ) 
│   │   │           │   ├── Weather Forecast简介 --> ( 难度等级: [0.0633, 0.0633) || 挂载数据: 无 ) 
│   │   │           │   └── Weather Forecast部署 --> ( 难度等级: [0.0633, 0.0634) || 挂载数据: 无 ) 
│   │   │           ├── 基于文件的服务发现 --> ( 难度等级: [0.0634, 0.0634) || 挂载数据: 无 ) 
│   │   │           └── 示例演示 --> ( 难度等级: [0.0634, 0.0634) || 挂载数据: 无 ) 
│   │   ├── 中级篇 --> ( 难度等级: [0.0634, 0.064) || 挂载数据: 无 ) 
│   │   │   ├── 深入浅出Linkerd配置 --> ( 难度等级: [0.0634, 0.0635) || 挂载数据: 无 ) 
│   │   │   │   ├── Linkerd术语 --> ( 难度等级: [0.0634, 0.0634) || 挂载数据: 无 ) 
│   │   │   │   └── Linkerd配置 --> ( 难度等级: [0.0634, 0.0635) || 挂载数据: 无 ) 
│   │   │   │       ├── 配置构成 --> ( 难度等级: [0.0634, 0.0634) || 挂载数据: blog: 13 ) 
│   │   │   │       ├── admin --> ( 难度等级: [0.0634, 0.0635) || 挂载数据: 无 ) 
│   │   │   │       ├── namer --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │       ├── router --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │       ├── telemetry --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │       └── usage --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   ├── 深入Linkerd数据访问流 --> ( 难度等级: [0.0635, 0.0636) || 挂载数据: 无 ) 
│   │   │   │   ├── dtab详解 --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │   │   ├── dtab定义 --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │   │   └── dtab路由原理 --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │   └── 数据访问流详解 --> ( 难度等级: [0.0635, 0.0636) || 挂载数据: blog: 1 ) 
│   │   │   │       ├── 鉴别 --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │       ├── 绑定 --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: 无 ) 
│   │   │   │       ├── 解析 --> ( 难度等级: [0.0635, 0.0635) || 挂载数据: blog: 1 ) 
│   │   │   │       └── 转换 --> ( 难度等级: [0.0635, 0.0636) || 挂载数据: 无 ) 
│   │   │   ├── Linkerd部署模式 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │   ├── Linkerd部署模式 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Per-host模式 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Sidecar模式 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │   │   └── Per-host模式和Sidecar模式 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │   └── 配置模型 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │       ├── service-to-linker模型 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │       ├── linker-to-service模型 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: 无 ) 
│   │   │   │       └── linker-to-linker模型 --> ( 难度等级: [0.0636, 0.0636) || 挂载数据: blog: 6 ) 
│   │   │   ├── Linkerd控制层：Namerd --> ( 难度等级: [0.0636, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   ├── Namerd简介 --> ( 难度等级: [0.0636, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   ├── Namerd配置详解 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   ├── admin配置 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   ├── interface配置 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   ├── storage配置 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   └── namer配置 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   ├── 连接Linkerd和Namerd --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 准备Namerd配置文件 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 启动Namerd --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 准备Linkerd配置文件 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   │   └── 启动Linkerd --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   └── 管理dtab路由 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │       ├── Namerd API简介 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │       ├── 通过Namerd API管理dtab --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │       └── 通过namerctl CLI管理dtab --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   ├── 东西向流量控制 --> ( 难度等级: [0.0637, 0.0638) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio东西向流量管理 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio路由控制 --> ( 难度等级: [0.0637, 0.0637) || 挂载数据: 无 ) 
│   │   │   │   ├── 实现东西向流量转移路由 --> ( 难度等级: [0.0637, 0.0638) || 挂载数据: 无 ) 
│   │   │   │   └── 实现流量镜像及对比分析 --> ( 难度等级: [0.0638, 0.0638) || 挂载数据: 无 ) 
│   │   │   ├── 南北向流量控制 --> ( 难度等级: [0.0638, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio南北向流量管理 --> ( 难度等级: [0.0638, 0.0638) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio网关与K8s Ingress --> ( 难度等级: [0.0638, 0.0638) || 挂载数据: 无 ) 
│   │   │   │   ├── 保护Istio网关流量 --> ( 难度等级: [0.0638, 0.0638) || 挂载数据: 无 ) 
│   │   │   │   ├── 实现入口流量路由的统一管理 --> ( 难度等级: [0.0638, 0.0638) || 挂载数据: 无 ) 
│   │   │   │   └── 实现出口流量路由的统一管理 --> ( 难度等级: [0.0638, 0.0639) || 挂载数据: 无 ) 
│   │   │   ├── 安全 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── Citadel架构设计 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── 认证机制 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── 授权机制 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用认证策略 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用双向认证 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │   │   ├── 消除Privileged容器提升安全性 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 通过NetworkPolicy增强安全性 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │   └── Mixer控制与观测 --> ( 难度等级: [0.0639, 0.064) || 挂载数据: 无 ) 
│   │   │       ├── Mixer架构设计 --> ( 难度等级: [0.0639, 0.0639) || 挂载数据: 无 ) 
│   │   │       ├── 适配器机制 --> ( 难度等级: [0.0639, 0.064) || 挂载数据: 无 ) 
│   │   │       ├── 使用速率限制策略 --> ( 难度等级: [0.064, 0.064) || 挂载数据: 无 ) 
│   │   │       ├── 使用黑白名单策略 --> ( 难度等级: [0.064, 0.064) || 挂载数据: 无 ) 
│   │   │       ├── 使用基于Zipkin与Jaeger的分布式跟踪 --> ( 难度等级: [0.064, 0.064) || 挂载数据: 无 ) 
│   │   │       ├── 集成度量数据收集 --> ( 难度等级: [0.064, 0.064) || 挂载数据: 无 ) 
│   │   │       └── 集成日志数据收集 --> ( 难度等级: [0.064, 0.064) || 挂载数据: 无 ) 
│   │   ├── 原理篇 --> ( 难度等级: [0.064, 0.0646) || 挂载数据: 无 ) 
│   │   │   ├── 你好，Istio --> ( 难度等级: [0.064, 0.0641) || 挂载数据: 无 ) 
│   │   │   │   └── 通过示例看看Istio能做什么 --> ( 难度等级: [0.064, 0.0641) || 挂载数据: 无 ) 
│   │   │   ├── Istio架构概述 --> ( 难度等级: [0.0641, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio的工作机制 --> ( 难度等级: [0.0641, 0.0641) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio的服务模型 --> ( 难度等级: [0.0641, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Istio的服务 --> ( 难度等级: [0.0641, 0.0641) || 挂载数据: blog: 5 ) 
│   │   │   │   │   └── Istio的服务版本 --> ( 难度等级: [0.0641, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   └── Istio的主要组件 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-pilot --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 2 ) 
│   │   │   │       ├── istio-telemetry --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-policy --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-citadel --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-galley --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-sidecar-injector --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │       ├── istio-proxy --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 1 ) 
│   │   │   │       └── istio-ingressgateway --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 1 ) 
│   │   │   ├── 非侵入的流量治理 --> ( 难度等级: [0.0642, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio流量治理的原理 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 服务熔断 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 故障注入 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 延迟注入 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 中断注入 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 灰度发布 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 预先准备：将所有流量都路由到各个服务的v1版本 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 基于流量比例的路由 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   ├── 基于请求内容的路由 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 组合条件路由 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 多服务灰度发布 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── TCP服务灰度发布 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 自动化灰度发布 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   │       ├── 正常发布 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │       └── 异常发布 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 服务访问入口 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   └── 外部接入服务治理 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio路由规则配置：VirtualService --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 路由规则配置示例 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 路由规则定义 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── HTTP路由（HTTPRoute） --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── TLS路由（TLSRoute） --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── TCP路由（TCPRoute） --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 2 ) 
│   │   │   │   │   ├── 三种协议路由规则的对比 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   └── VirtualService的典型应用 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio目标规则配置：DestinationRule --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── DestinationRule配置示例 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── DestinationRule规则定义 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   └── DestinationRule的典型应用 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio服务网关配置：Gateway --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Gateway配置示例 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 16 ) 
│   │   │   │   │   ├── Gateway规则定义 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── Gateway的典型应用 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: blog: 31 ) 
│   │   │   │   ├── Istio外部服务配置：ServiceEntry --> ( 难度等级: [0.0642, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── ServiceEntry配置示例 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   ├── ServiceEntry规则的定义和用法 --> ( 难度等级: [0.0642, 0.0642) || 挂载数据: 无 ) 
│   │   │   │   │   └── ServiceEntry的典型应用 --> ( 难度等级: [0.0642, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   └── Istio代理规则配置：Sidecar --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │       ├── Sidecar配置示例 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │       └── Sidecar规则定义 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   ├── 可扩展的策略和遥测 --> ( 难度等级: [0.0643, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio策略和遥测的原理 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 应用场景 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 工作原理 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: blog: 3 ) 
│   │   │   │   │   ├── 属性 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   └── Mixer的配置模型 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio遥测适配器配置 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Prometheus适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Fluentd适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── StatsD适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Stdio适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Zipkin适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   └── 厂商适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio策略适配器配置 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── List适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: blog: 11 ) 
│   │   │   │   │   ├── Denier适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Memory Quota适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   │   └── Redis Quota适配器 --> ( 难度等级: [0.0643, 0.0643) || 挂载数据: 无 ) 
│   │   │   │   └── Kubernetes Env适配器配置 --> ( 难度等级: [0.0643, 0.0644) || 挂载数据: 无 ) 
│   │   │   ├── 可插拔的服务安全 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio服务安全的原理 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 认证 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 授权 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 命名空间级别的访问控制 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 服务级别的访问控制 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   └── 密钥证书管理 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio服务认证配置 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 认证策略配置示例 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 认证策略的定义 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   ├── TLS访问配置 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   │   └── 认证策略的典型应用 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │   └── Istio服务授权配置 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │       ├── 授权启用配置 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: blog: 1 ) 
│   │   │   │       ├── 授权策略配置 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   │       └── 授权策略的典型应用 --> ( 难度等级: [0.0644, 0.0644) || 挂载数据: 无 ) 
│   │   │   ├── 透明的Sidecar机制 --> ( 难度等级: [0.0644, 0.0645) || 挂载数据: 无 ) 
│   │   │   │   ├── Sidecar注入 --> ( 难度等级: [0.0644, 0.0645) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Sidecar Injector自动注入的原理 --> ( 难度等级: [0.0644, 0.0645) || 挂载数据: 无 ) 
│   │   │   │   │   └── Sidecar注入的实现 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: blog: 2 ) 
│   │   │   │   └── Sidecar流量拦截 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: 无 ) 
│   │   │   │       ├── iptables的基本原理 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: 无 ) 
│   │   │   │       ├── iptables的规则设置 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: 无 ) 
│   │   │   │       └── 流量拦截原理 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: 无 ) 
│   │   │   └── 多集群服务治理 --> ( 难度等级: [0.0645, 0.0646) || 挂载数据: 无 ) 
│   │   │       ├── Istio多集群服务治理 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: 无 ) 
│   │   │       │   ├── Istio多集群的相关概念 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: blog: 1 ) 
│   │   │       │   └── Istio多集群服务治理现状 --> ( 难度等级: [0.0645, 0.0645) || 挂载数据: blog: 9 ) 
│   │   │       ├── 多集群模式1：多控制面 --> ( 难度等级: [0.0645, 0.0646) || 挂载数据: 无 ) 
│   │   │       │   ├── 服务DNS解析的原理 --> ( 难度等级: [0.0645, 0.0646) || 挂载数据: blog: 1 ) 
│   │   │       │   └── Gateway连接的原理 --> ( 难度等级: [0.0646, 0.0646) || 挂载数据: 无 ) 
│   │   │       ├── 多集群模式2：VPN直连单控制面 --> ( 难度等级: [0.0646, 0.0646) || 挂载数据: 无 ) 
│   │   │       └── 多集群模式3：集群感知服务路由单控制面 --> ( 难度等级: [0.0646, 0.0646) || 挂载数据: 无 ) 
│   │   ├── 实践篇 --> ( 难度等级: [0.0646, 0.0652) || 挂载数据: 无 ) 
│   │   │   ├── 流量监控 --> ( 难度等级: [0.0646, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── 调用链跟踪 --> ( 难度等级: [0.0646, 0.0647) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 指标监控 --> ( 难度等级: [0.0647, 0.0647) || 挂载数据: 无 ) 
│   │   │   │   │   └── Grafana --> ( 难度等级: [0.0647, 0.0647) || 挂载数据: 无 ) 
│   │   │   │   └── 服务网格监控 --> ( 难度等级: [0.0647, 0.0648) || 挂载数据: 无 ) 
│   │   │   ├── 流量治理 --> ( 难度等级: [0.0648, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   ├── 流量负载均衡 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   │   ├── ROUND_ROBIN模式 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   │   └── RANDOM模式 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── 会话保持 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── 超时 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── 重试 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP重定向 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP重写 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── 熔断 --> ( 难度等级: [0.0648, 0.0648) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务隔离 --> ( 难度等级: [0.0648, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用流量策略 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   ├── 设置负载均衡 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   ├── 管理连接池 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   ├── 增强路由规则 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   ├── 混沌工程之熔断 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   └── 混沌工程之故障注入 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   ├── 服务保护 --> ( 难度等级: [0.0649, 0.0651) || 挂载数据: 无 ) 
│   │   │   │   ├── 网关加密 --> ( 难度等级: [0.0649, 0.065) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 单向TLS网关 --> ( 难度等级: [0.0649, 0.0649) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 双向TLS网关 --> ( 难度等级: [0.0649, 0.065) || 挂载数据: 无 ) 
│   │   │   │   │   └── 用SDS加密网关 --> ( 难度等级: [0.065, 0.065) || 挂载数据: 无 ) 
│   │   │   │   └── 访问控制 --> ( 难度等级: [0.065, 0.0651) || 挂载数据: 无 ) 
│   │   │   │       ├── 黑名单 --> ( 难度等级: [0.065, 0.065) || 挂载数据: 无 ) 
│   │   │   │       └── 白名单 --> ( 难度等级: [0.065, 0.0651) || 挂载数据: 无 ) 
│   │   │   └── 多集群管理 --> ( 难度等级: [0.0651, 0.0652) || 挂载数据: 无 ) 
│   │   ├── 架构篇 --> ( 难度等级: [0.0652, 0.0658) || 挂载数据: 无 ) 
│   │   │   ├── 司令官Pilot --> ( 难度等级: [0.0652, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   ├── Pilot的架构 --> ( 难度等级: [0.0652, 0.0652) || 挂载数据: 无 ) 
│   │   │   │   │   └── xDS协议 --> ( 难度等级: [0.0652, 0.0652) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Pilot的工作流程 --> ( 难度等级: [0.0652, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Pilot的启动与初始化 --> ( 难度等级: [0.0652, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 配置规则发现 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   │   └── Envoy的配置分发 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   ├── Pilot的插件 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 安全插件 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: blog: 2 ) 
│   │   │   │   │   ├── 健康检查插件 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   │   └── Mixer插件 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   └── Pilot的设计亮点 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │       ├── 三级缓存优化 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │       ├── 去抖动分发 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │       ├── 增量EDS --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │       └── 资源隔离 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   ├── 守护神Mixer --> ( 难度等级: [0.0653, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer的整体架构 --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer的服务模型 --> ( 难度等级: [0.0653, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Template --> ( 难度等级: [0.0653, 0.0653) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── Adapter --> ( 难度等级: [0.0653, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer的工作流程 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 启动初始化 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 用户配置信息规则处理 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 访问策略的执行 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   │   └── 无侵入遥测 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer的设计亮点 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │   └── 如何开发Mixer Adapter --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │       ├── Adapter实现概述 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │       ├── 内置式Adapter的开发步骤 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   │       ├── 独立进程式Adapter的开发步骤 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: blog: 1 ) 
│   │   │   │       └── 独立仓库式Adapter的开发步骤 --> ( 难度等级: [0.0654, 0.0654) || 挂载数据: 无 ) 
│   │   │   ├── 安全碉堡Citadel --> ( 难度等级: [0.0654, 0.0655) || 挂载数据: 无 ) 
│   │   │   │   ├── Citadel的架构 --> ( 难度等级: [0.0654, 0.0655) || 挂载数据: 无 ) 
│   │   │   │   └── Citadel的工作流程 --> ( 难度等级: [0.0655, 0.0655) || 挂载数据: 无 ) 
│   │   │   │       ├── 启动初始化 --> ( 难度等级: [0.0655, 0.0655) || 挂载数据: 无 ) 
│   │   │   │       ├── 证书控制器 --> ( 难度等级: [0.0655, 0.0655) || 挂载数据: 无 ) 
│   │   │   │       ├── gRPC服务器 --> ( 难度等级: [0.0655, 0.0655) || 挂载数据: 无 ) 
│   │   │   │       ├── 证书轮换器 --> ( 难度等级: [0.0655, 0.0655) || 挂载数据: 无 ) 
│   │   │   │       └── SDS服务器 --> ( 难度等级: [0.0655, 0.0655) || 挂载数据: 无 ) 
│   │   │   ├── 高性能代理Envoy --> ( 难度等级: [0.0655, 0.0656) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的架构 --> ( 难度等级: [0.0655, 0.0655) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的特性 --> ( 难度等级: [0.0655, 0.0656) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的模块结构 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的线程模型 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的内存管理 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 变量管理 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: 无 ) 
│   │   │   │   │   └── Buffer管理 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Envoy的流量控制 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: 无 ) 
│   │   │   ├── 代理守护进程Pilot-agent --> ( 难度等级: [0.0656, 0.0657) || 挂载数据: 无 ) 
│   │   │   │   └── Pilot-agent的工作流程 --> ( 难度等级: [0.0656, 0.0657) || 挂载数据: 无 ) 
│   │   │   │       ├── Envoy的启动 --> ( 难度等级: [0.0656, 0.0656) || 挂载数据: 无 ) 
│   │   │   │       ├── Envoy的热重启 --> ( 难度等级: [0.0656, 0.0657) || 挂载数据: 无 ) 
│   │   │   │       ├── 守护Envoy --> ( 难度等级: [0.0657, 0.0657) || 挂载数据: 无 ) 
│   │   │   │       └── 优雅退出 --> ( 难度等级: [0.0657, 0.0657) || 挂载数据: 无 ) 
│   │   │   └── 配置中心Galley --> ( 难度等级: [0.0657, 0.0658) || 挂载数据: 无 ) 
│   │   │       ├── Galley的架构 --> ( 难度等级: [0.0657, 0.0658) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── MCP --> ( 难度等级: [0.0657, 0.0657) || 挂载数据: 无 ) 
│   │   │       │   └── MCP API --> ( 难度等级: [0.0657, 0.0658) || 挂载数据: 无 ) 
│   │   │       └── Galley的工作流程 --> ( 难度等级: [0.0658, 0.0658) || 挂载数据: 无 ) 
│   │   │           ├── 启动初始化 --> ( 难度等级: [0.0658, 0.0658) || 挂载数据: 无 ) 
│   │   │           ├── 配置校验 --> ( 难度等级: [0.0658, 0.0658) || 挂载数据: 无 ) 
│   │   │           └── 配置聚合与分发 --> ( 难度等级: [0.0658, 0.0658) || 挂载数据: 无 ) 
│   │   ├── 源码篇 --> ( 难度等级: [0.0658, 0.0664) || 挂载数据: 无 ) 
│   │   │   ├── Pilot源码解析 --> ( 难度等级: [0.0658, 0.0659) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动流程 --> ( 难度等级: [0.0658, 0.0659) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.0659, 0.0659) || 挂载数据: 无 ) 
│   │   │   │       ├── ConfigController --> ( 难度等级: [0.0659, 0.0659) || 挂载数据: 无 ) 
│   │   │   │       ├── ServiceController --> ( 难度等级: [0.0659, 0.0659) || 挂载数据: 无 ) 
│   │   │   │       ├── xDS异步分发 --> ( 难度等级: [0.0659, 0.0659) || 挂载数据: 无 ) 
│   │   │   │       └── 配置更新预处理 --> ( 难度等级: [0.0659, 0.0659) || 挂载数据: 无 ) 
│   │   │   ├── Mixer源码解析 --> ( 难度等级: [0.0659, 0.0661) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动流程 --> ( 难度等级: [0.0659, 0.066) || 挂载数据: 无 ) 
│   │   │   │   │   ├── runServer通过newServer新建Server对象 --> ( 难度等级: [0.0659, 0.066) || 挂载数据: 无 ) 
│   │   │   │   │   └── 启动Mixer gRPC Server --> ( 难度等级: [0.066, 0.066) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.066, 0.0661) || 挂载数据: 无 ) 
│   │   │   │       ├── 监听用户的配置 --> ( 难度等级: [0.066, 0.066) || 挂载数据: 无 ) 
│   │   │   │       ├── 构建数据模型 --> ( 难度等级: [0.066, 0.066) || 挂载数据: 无 ) 
│   │   │   │       ├── Check接口 --> ( 难度等级: [0.066, 0.066) || 挂载数据: 无 ) 
│   │   │   │       ├── Report接口 --> ( 难度等级: [0.066, 0.0661) || 挂载数据: 无 ) 
│   │   │   │       └── 协程池 --> ( 难度等级: [0.0661, 0.0661) || 挂载数据: 无 ) 
│   │   │   ├── Citadel源码解析 --> ( 难度等级: [0.0661, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动流程 --> ( 难度等级: [0.0661, 0.0661) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.0661, 0.0662) || 挂载数据: 无 ) 
│   │   │   │       ├── 证书签发实体IstioCA --> ( 难度等级: [0.0661, 0.0661) || 挂载数据: 无 ) 
│   │   │   │       ├── SecretController的创建和核心原理 --> ( 难度等级: [0.0661, 0.0662) || 挂载数据: 无 ) 
│   │   │   │       └── CA Server的创建和核心原理 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   ├── Envoy源码解析 --> ( 难度等级: [0.0662, 0.0663) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的初始化 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 启动参数bootstrap的初始化 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Admin API的初始化 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Worker的初始化 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   ├── CDS的初始化 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   ├── LDS的初始化 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   └── GuardDog的初始化 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   ├── Envoy的运行和建立新连接 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 启动worker --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Listener的加载 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: 无 ) 
│   │   │   │   │   └── 接收连接 --> ( 难度等级: [0.0662, 0.0662) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Envoy对数据的读取、接收及处理 --> ( 难度等级: [0.0662, 0.0663) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 读取数据 --> ( 难度等级: [0.0662, 0.0663) || 挂载数据: 无 ) 
│   │   │   │   │   └── 接收数据 --> ( 难度等级: [0.0663, 0.0663) || 挂载数据: 无 ) 
│   │   │   │   └── Envoy发送数据到服务端 --> ( 难度等级: [0.0663, 0.0663) || 挂载数据: 无 ) 
│   │   │   │       ├── 匹配路由 --> ( 难度等级: [0.0663, 0.0663) || 挂载数据: 无 ) 
│   │   │   │       ├── 获取连接池 --> ( 难度等级: [0.0663, 0.0663) || 挂载数据: 无 ) 
│   │   │   │       └── 选择上游主机 --> ( 难度等级: [0.0663, 0.0663) || 挂载数据: 无 ) 
│   │   │   └── Galley源码解析 --> ( 难度等级: [0.0663, 0.0664) || 挂载数据: 无 ) 
│   │   │       ├── 进程启动流程 --> ( 难度等级: [0.0663, 0.0664) || 挂载数据: 无 ) 
│   │   │       │   ├── RunServer的启动流程 --> ( 难度等级: [0.0663, 0.0663) || 挂载数据: 无 ) 
│   │   │       │   └── RunValidation Server的启动流程 --> ( 难度等级: [0.0663, 0.0664) || 挂载数据: 无 ) 
│   │   │       └── 关键代码分析 --> ( 难度等级: [0.0664, 0.0664) || 挂载数据: 无 ) 
│   │   │           ├── 配置监听 --> ( 难度等级: [0.0664, 0.0664) || 挂载数据: 无 ) 
│   │   │           └── 配置分发 --> ( 难度等级: [0.0664, 0.0664) || 挂载数据: 无 ) 
│   │   ├── 初级篇 --> ( 难度等级: [0.0664, 0.067) || 挂载数据: 无 ) 
│   │   │   ├── 快速上手Istio --> ( 难度等级: [0.0664, 0.0667) || 挂载数据: 无 ) 
│   │   │   │   ├── 在MiniKube上搭建Istio环境 --> ( 难度等级: [0.0664, 0.0665) || 挂载数据: 无 ) 
│   │   │   │   ├── 在Docker Desktop上搭建Istio环境 --> ( 难度等级: [0.0665, 0.0666) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 使用公有云Istio服务 --> ( 难度等级: [0.0666, 0.0667) || 挂载数据: 无 ) 
│   │   │   │   └── 在Istio中部署第一个应用程序 --> ( 难度等级: [0.0667, 0.0667) || 挂载数据: 无 ) 
│   │   │   └── Istio架构剖析 --> ( 难度等级: [0.0667, 0.067) || 挂载数据: 无 ) 
│   │   │       ├── Istio架构总体结构 --> ( 难度等级: [0.0667, 0.0668) || 挂载数据: 无 ) 
│   │   │       ├── 剖析Istio控制平面 --> ( 难度等级: [0.0668, 0.0669) || 挂载数据: 无 ) 
│   │   │       │   └── Istio Mixer --> ( 难度等级: [0.0668, 0.0669) || 挂载数据: blog: 1 ) 
│   │   │       └── 剖析Istio数据平面 --> ( 难度等级: [0.0669, 0.067) || 挂载数据: 无 ) 
│   │   │           ├── Envoy代理 --> ( 难度等级: [0.0669, 0.067) || 挂载数据: 无 ) 
│   │   │           ├── Envoy静态与动态配置 --> ( 难度等级: [0.067, 0.067) || 挂载数据: 无 ) 
│   │   │           └── 代理部署 --> ( 难度等级: [0.067, 0.067) || 挂载数据: 无 ) 
│   │   ├── 高级篇 --> ( 难度等级: [0.067, 0.0676) || 挂载数据: 无 ) 
│   │   │   ├── Istio的性能分析与运维 --> ( 难度等级: [0.067, 0.0672) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio功能稳定性 --> ( 难度等级: [0.067, 0.0671) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio性能分析 --> ( 难度等级: [0.0671, 0.0671) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Istio组件升级与回滚 --> ( 难度等级: [0.0671, 0.0671) || 挂载数据: 无 ) 
│   │   │   │   └── Pilot运维指南 --> ( 难度等级: [0.0671, 0.0672) || 挂载数据: blog: 9 ) 
│   │   │   ├── Istio的定制与扩展 --> ( 难度等级: [0.0672, 0.0673) || 挂载数据: 无 ) 
│   │   │   │   ├── Mixer模板设计 --> ( 难度等级: [0.0672, 0.0672) || 挂载数据: 无 ) 
│   │   │   │   ├── 适配器生命周期管理 --> ( 难度等级: [0.0672, 0.0672) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发实现适配器 --> ( 难度等级: [0.0672, 0.0673) || 挂载数据: 无 ) 
│   │   │   │   ├── 编译与打包适配器 --> ( 难度等级: [0.0673, 0.0673) || 挂载数据: 无 ) 
│   │   │   │   └── 扩展EnvoyFilter --> ( 难度等级: [0.0673, 0.0673) || 挂载数据: 无 ) 
│   │   │   ├── Knative：基于Istio的无服务器计算 --> ( 难度等级: [0.0673, 0.0675) || 挂载数据: 无 ) 
│   │   │   │   ├── Knative架构解析 --> ( 难度等级: [0.0673, 0.0674) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于Istio实现Serving组件 --> ( 难度等级: [0.0674, 0.0674) || 挂载数据: 无 ) 
│   │   │   │   ├── Knative Build运行机制 --> ( 难度等级: [0.0674, 0.0674) || 挂载数据: 无 ) 
│   │   │   │   ├── Knative Eventing运行机制 --> ( 难度等级: [0.0674, 0.0674) || 挂载数据: 无 ) 
│   │   │   │   ├── 在Istio上部署Knative --> ( 难度等级: [0.0674, 0.0675) || 挂载数据: 无 ) 
│   │   │   │   └── 开发部署Knative应用 --> ( 难度等级: [0.0675, 0.0675) || 挂载数据: 无 ) 
│   │   │   └── 云原生计算的未来展望 --> ( 难度等级: [0.0675, 0.0676) || 挂载数据: blog: 1 ) 
│   │   ├── 什么是架构 --> ( 难度等级: [0.0676, 0.0682) || 挂载数据: 无 ) 
│   │   ├── 几个相关概念 --> ( 难度等级: [0.0682, 0.0688) || 挂载数据: 无 ) 
│   │   ├── 从软件的生命周期看架构设计 --> ( 难度等级: [0.0688, 0.0694) || 挂载数据: 无 ) 
│   │   ├── 架构的形式与特点 --> ( 难度等级: [0.0694, 0.07) || 挂载数据: 无 ) 
│   │   ├── 架构的目标与方法 --> ( 难度等级: [0.07, 0.0707) || 挂载数据: 无 ) 
│   │   ├── 架构的不同风格 --> ( 难度等级: [0.0707, 0.0713) || 挂载数据: 无 ) 
│   │   ├── 微服务领域驱动设计 --> ( 难度等级: [0.0713, 0.0719) || 挂载数据: 无 ) 
│   │   │   ├── 领域驱动设计 --> ( 难度等级: [0.0713, 0.0716) || 挂载数据: 无 ) 
│   │   │   │   ├── 领域驱动设计概览 --> ( 难度等级: [0.0713, 0.0713) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 限界上下文 --> ( 难度等级: [0.0713, 0.0714) || 挂载数据: 无 ) 
│   │   │   │   ├── 上下文映射 --> ( 难度等级: [0.0714, 0.0715) || 挂载数据: 无 ) 
│   │   │   │   └── 领域架构 --> ( 难度等级: [0.0715, 0.0716) || 挂载数据: 无 ) 
│   │   │   └── 微服务的设计 --> ( 难度等级: [0.0716, 0.0719) || 挂载数据: 无 ) 
│   │   │       ├── 限界上下文的边界 --> ( 难度等级: [0.0716, 0.0716) || 挂载数据: 无 ) 
│   │   │       ├── 限界上下文即微服务 --> ( 难度等级: [0.0716, 0.0717) || 挂载数据: 无 ) 
│   │   │       ├── 识别限界上下文 --> ( 难度等级: [0.0717, 0.0718) || 挂载数据: 无 ) 
│   │   │       └── 微服务之间的协作 --> ( 难度等级: [0.0718, 0.0719) || 挂载数据: blog: 17 ) 
│   │   ├── Apache Dubbo框架的原理与实现 --> ( 难度等级: [0.0719, 0.0725) || 挂载数据: blog: 1 ) 
│   │   │   ├── Dubbo框架的选型与使用 --> ( 难度等级: [0.0719, 0.0721) || 挂载数据: 无 ) 
│   │   │   │   ├── Dubbo框架的选型 --> ( 难度等级: [0.0719, 0.072) || 挂载数据: 无 ) 
│   │   │   │   └── Dubbo框架的使用 --> ( 难度等级: [0.072, 0.0721) || 挂载数据: blog: 101 ) 
│   │   │   ├── Dubbo框架的原理分析 --> ( 难度等级: [0.0721, 0.0723) || 挂载数据: 无 ) 
│   │   │   │   ├── 总体架构分析 --> ( 难度等级: [0.0721, 0.0721) || 挂载数据: 无 ) 
│   │   │   │   ├── Dubbo Bean的加载 --> ( 难度等级: [0.0721, 0.0721) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Dubbo Extension机制 --> ( 难度等级: [0.0721, 0.0722) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Dubbo消费端 --> ( 难度等级: [0.0722, 0.0722) || 挂载数据: 无 ) 
│   │   │   │   ├── Dubbo服务端 --> ( 难度等级: [0.0722, 0.0722) || 挂载数据: blog: 3 ) 
│   │   │   │   └── Dubbo的通信机制 --> ( 难度等级: [0.0722, 0.0723) || 挂载数据: blog: 1 ) 
│   │   │   └── 基于Dubbo的自动化Mock系统 --> ( 难度等级: [0.0723, 0.0725) || 挂载数据: 无 ) 
│   │   │       ├── Mock模拟系统的产生 --> ( 难度等级: [0.0723, 0.0723) || 挂载数据: 无 ) 
│   │   │       ├── Dubbo Mock的使用 --> ( 难度等级: [0.0723, 0.0724) || 挂载数据: 无 ) 
│   │   │       ├── Dubbo Mock的原理解析 --> ( 难度等级: [0.0724, 0.0724) || 挂载数据: blog: 1 ) 
│   │   │       └── 自动化Mock系统的实现 --> ( 难度等级: [0.0724, 0.0725) || 挂载数据: blog: 1 ) 
│   │   ├── Spring Boot/Spring Cloud实践 --> ( 难度等级: [0.0725, 0.0731) || 挂载数据: 无 ) 
│   │   │   ├── Spring Boot原理剖析 --> ( 难度等级: [0.0725, 0.0726) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Boot Quick Start --> ( 难度等级: [0.0725, 0.0725) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Spring Boot之SpringApplication --> ( 难度等级: [0.0725, 0.0725) || 挂载数据: blog: 111 ) 
│   │   │   │   ├── spring-boot-loaded模块分析 --> ( 难度等级: [0.0725, 0.0726) || 挂载数据: 无 ) 
│   │   │   │   ├── spring-boot-autoconfigure模块分析 --> ( 难度等级: [0.0726, 0.0726) || 挂载数据: 无 ) 
│   │   │   │   └── Spring Boot Conditional注解分析 --> ( 难度等级: [0.0726, 0.0726) || 挂载数据: blog: 4 ) 
│   │   │   ├── Dubbo Spring Boot Starter --> ( 难度等级: [0.0726, 0.0728) || 挂载数据: 无 ) 
│   │   │   │   ├── Dubbo Spring Boot Starter简介 --> ( 难度等级: [0.0726, 0.0727) || 挂载数据: blog: 16 ) 
│   │   │   │   ├── Dubbo Initializr及sample --> ( 难度等级: [0.0727, 0.0727) || 挂载数据: 无 ) 
│   │   │   │   ├── dubbo-spring-boot-autoconfigure模块 --> ( 难度等级: [0.0727, 0.0727) || 挂载数据: 无 ) 
│   │   │   │   └── dubbo-spring-boot-actuator模块 --> ( 难度等级: [0.0727, 0.0728) || 挂载数据: blog: 1 ) 
│   │   │   ├── Spring Cloud栈 --> ( 难度等级: [0.0728, 0.0729) || 挂载数据: 无 ) 
│   │   │   │   ├── Spring Cloud技术栈总览 --> ( 难度等级: [0.0728, 0.0728) || 挂载数据: blog: 5 ) 
│   │   │   │   └── spring-cloud-scaffold基础库集合 --> ( 难度等级: [0.0728, 0.0729) || 挂载数据: blog: 1 ) 
│   │   │   └── 基于Maven Archetype的脚手架 --> ( 难度等级: [0.0729, 0.0731) || 挂载数据: 无 ) 
│   │   │       ├── Maven Archetype --> ( 难度等级: [0.0729, 0.073) || 挂载数据: blog: 12 ) 
│   │   │       ├── 脚手架的搭建 --> ( 难度等级: [0.073, 0.073) || 挂载数据: 无 ) 
│   │   │       └── 生成脚手架 --> ( 难度等级: [0.073, 0.0731) || 挂载数据: 无 ) 
│   │   ├── 微服务稳定性保证的常用手段 --> ( 难度等级: [0.0731, 0.0737) || 挂载数据: 无 ) 
│   │   │   ├── 微服务的稳定性 --> ( 难度等级: [0.0731, 0.0733) || 挂载数据: 无 ) 
│   │   │   ├── 高可用 --> ( 难度等级: [0.0733, 0.0735) || 挂载数据: 无 ) 
│   │   │   │   ├── 限流原理与实现 --> ( 难度等级: [0.0733, 0.0734) || 挂载数据: 无 ) 
│   │   │   │   └── 断路器原理与实现 --> ( 难度等级: [0.0734, 0.0735) || 挂载数据: 无 ) 
│   │   │   └── 高并发 --> ( 难度等级: [0.0735, 0.0737) || 挂载数据: blog: 1 ) 
│   │   │       ├── 异步 --> ( 难度等级: [0.0735, 0.0736) || 挂载数据: 无 ) 
│   │   │       └── 缓存 --> ( 难度等级: [0.0736, 0.0737) || 挂载数据: 无 ) 
│   │   ├── 微服务下如何保证事务的一致性 --> ( 难度等级: [0.0737, 0.0743) || 挂载数据: 无 ) 
│   │   │   ├── 从本地事务到分布式事务的演变 --> ( 难度等级: [0.0737, 0.0739) || 挂载数据: 无 ) 
│   │   │   ├── 强一致性解决方案 --> ( 难度等级: [0.0739, 0.0741) || 挂载数据: 无 ) 
│   │   │   │   ├── 二阶段提交协议 --> ( 难度等级: [0.0739, 0.074) || 挂载数据: 无 ) 
│   │   │   │   └── 三阶段提交协议 --> ( 难度等级: [0.074, 0.0741) || 挂载数据: 无 ) 
│   │   │   └── 最终一致性解决方案 --> ( 难度等级: [0.0741, 0.0743) || 挂载数据: 无 ) 
│   │   │       ├── TCC模式 --> ( 难度等级: [0.0741, 0.0742) || 挂载数据: 无 ) 
│   │   │       └── 补偿模式 --> ( 难度等级: [0.0742, 0.0743) || 挂载数据: 无 ) 
│   │   ├── 百亿流量微服务网关的设计与实现 --> ( 难度等级: [0.0743, 0.0749) || 挂载数据: 无 ) 
│   │   │   ├── 开源网关的分析与调研 --> ( 难度等级: [0.0743, 0.0746) || 挂载数据: 无 ) 
│   │   │   │   ├── 常见的开源网关介绍 --> ( 难度等级: [0.0743, 0.0744) || 挂载数据: 无 ) 
│   │   │   │   └── 四大开源网关的对比分析 --> ( 难度等级: [0.0744, 0.0746) || 挂载数据: 无 ) 
│   │   │   └── 百亿流量交易系统API网关设计 --> ( 难度等级: [0.0746, 0.0749) || 挂载数据: 无 ) 
│   │   │       └── 业务网关的设计与最佳实践 --> ( 难度等级: [0.0746, 0.0749) || 挂载数据: 无 ) 
│   │   ├── 微服务编排 --> ( 难度等级: [0.0749, 0.0755) || 挂载数据: 无 ) 
│   │   │   ├── Netflix Conductor --> ( 难度等级: [0.0749, 0.075) || 挂载数据: 无 ) 
│   │   │   ├── Netflix Conductor的架构 --> ( 难度等级: [0.075, 0.0752) || 挂载数据: 无 ) 
│   │   │   ├── Conductor的使用案例 --> ( 难度等级: [0.0752, 0.0753) || 挂载数据: 无 ) 
│   │   │   └── Netflix Conductor源码分析 --> ( 难度等级: [0.0753, 0.0755) || 挂载数据: 无 ) 
│   │   │       ├── Client层源码分析 --> ( 难度等级: [0.0753, 0.0754) || 挂载数据: blog: 1 ) 
│   │   │       ├── Server端源码分析 --> ( 难度等级: [0.0754, 0.0754) || 挂载数据: 无 ) 
│   │   │       └── core端源码分析 --> ( 难度等级: [0.0754, 0.0755) || 挂载数据: 无 ) 
│   │   ├── 微服务数据抽取与统计 --> ( 难度等级: [0.0755, 0.0761) || 挂载数据: 无 ) 
│   │   │   ├── 案例小故事 --> ( 难度等级: [0.0755, 0.0756) || 挂载数据: 无 ) 
│   │   │   ├── 数据仓库概述 --> ( 难度等级: [0.0756, 0.0757) || 挂载数据: 无 ) 
│   │   │   │   ├── 什么是数据仓库 --> ( 难度等级: [0.0756, 0.0756) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据仓库架构 --> ( 难度等级: [0.0756, 0.0757) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据仓库建模方法 --> ( 难度等级: [0.0757, 0.0757) || 挂载数据: 无 ) 
│   │   │   │   └── 数据统计 --> ( 难度等级: [0.0757, 0.0757) || 挂载数据: blog: 1 ) 
│   │   │   ├── 数据仓库工具Hive --> ( 难度等级: [0.0757, 0.0758) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Hive --> ( 难度等级: [0.0757, 0.0758) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Hive数据库 --> ( 难度等级: [0.0758, 0.0758) || 挂载数据: blog: 9 ) 
│   │   │   │   └── Hive表 --> ( 难度等级: [0.0758, 0.0758) || 挂载数据: 无 ) 
│   │   │   ├── 使用Sqoop抽取数据 --> ( 难度等级: [0.0758, 0.076) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Sqoop --> ( 难度等级: [0.0758, 0.0759) || 挂载数据: 无 ) 
│   │   │   │   └── 将MySQL表数据导入Hive表 --> ( 难度等级: [0.0759, 0.076) || 挂载数据: blog: 4 ) 
│   │   │   └── ETL作业调度 --> ( 难度等级: [0.076, 0.0761) || 挂载数据: blog: 1 ) 
│   │   ├── 微服务双活体系建设 --> ( 难度等级: [0.0761, 0.0767) || 挂载数据: 无 ) 
│   │   │   ├── 系统高可用 --> ( 难度等级: [0.0761, 0.0764) || 挂载数据: 无 ) 
│   │   │   └── 双活数据中心 --> ( 难度等级: [0.0764, 0.0767) || 挂载数据: 无 ) 
│   │   │       ├── 单机房部署 --> ( 难度等级: [0.0764, 0.0765) || 挂载数据: 无 ) 
│   │   │       ├── 双机房部署 --> ( 难度等级: [0.0765, 0.0766) || 挂载数据: 无 ) 
│   │   │       └── 基于支付场景的双活体系建设 --> ( 难度等级: [0.0766, 0.0767) || 挂载数据: 无 ) 
│   │   ├── 基于支付场景下的微服务改造与性能优化 --> ( 难度等级: [0.0767, 0.0773) || 挂载数据: 无 ) 
│   │   │   ├── 支付场景的介绍 --> ( 难度等级: [0.0767, 0.0769) || 挂载数据: 无 ) 
│   │   │   ├── 从代码层面提升微服务架构的性能 --> ( 难度等级: [0.0769, 0.0771) || 挂载数据: 无 ) 
│   │   │   │   ├── 从代码和设计的角度看 --> ( 难度等级: [0.0769, 0.077) || 挂载数据: 无 ) 
│   │   │   │   └── 从整体架构的角度看 --> ( 难度等级: [0.077, 0.0771) || 挂载数据: 无 ) 
│   │   │   └── 微服务架构中常见的一些故障分析技巧 --> ( 难度等级: [0.0771, 0.0773) || 挂载数据: 无 ) 
│   │   ├── 遗留系统的微服务架构改造 --> ( 难度等级: [0.0773, 0.0779) || 挂载数据: 无 ) 
│   │   │   ├── 代码分层结构的转变 --> ( 难度等级: [0.0773, 0.0774) || 挂载数据: 无 ) 
│   │   │   ├── 遗留系统的债券与思考 --> ( 难度等级: [0.0774, 0.0776) || 挂载数据: 无 ) 
│   │   │   ├── 从单体系统拆分服务的方法论 --> ( 难度等级: [0.0776, 0.0777) || 挂载数据: 无 ) 
│   │   │   └── 遗留系统的微服务架构改造 --> ( 难度等级: [0.0777, 0.0779) || 挂载数据: 无 ) 
│   │   │       ├── 从代码重构开始 --> ( 难度等级: [0.0777, 0.0778) || 挂载数据: 无 ) 
│   │   │       ├── 拆分服务需要面向服务进行架构设计 --> ( 难度等级: [0.0778, 0.0778) || 挂载数据: 无 ) 
│   │   │       ├── 改造是一个渐进的过程 --> ( 难度等级: [0.0778, 0.0778) || 挂载数据: 无 ) 
│   │   │       ├── 单元测试是基石 --> ( 难度等级: [0.0778, 0.0778) || 挂载数据: 无 ) 
│   │   │       ├── 面向失败的设计 --> ( 难度等级: [0.0778, 0.0778) || 挂载数据: 无 ) 
│   │   │       ├── 前后端分离 --> ( 难度等级: [0.0778, 0.0778) || 挂载数据: blog: 1 ) 
│   │   │       ├── 共享现有数据库 --> ( 难度等级: [0.0778, 0.0779) || 挂载数据: 无 ) 
│   │   │       ├── 灰度发布的必要性 --> ( 难度等级: [0.0779, 0.0779) || 挂载数据: 无 ) 
│   │   │       └── 日志聚合与全链路监控 --> ( 难度等级: [0.0779, 0.0779) || 挂载数据: 无 ) 
│   │   ├── Service Mesh详解 --> ( 难度等级: [0.0779, 0.0785) || 挂载数据: 无 ) 
│   │   │   ├── Service Mesh的背景 --> ( 难度等级: [0.0779, 0.078) || 挂载数据: 无 ) 
│   │   │   ├── Service Mesh介绍 --> ( 难度等级: [0.078, 0.0781) || 挂载数据: 无 ) 
│   │   │   │   ├── Service Mesh架构 --> ( 难度等级: [0.078, 0.0781) || 挂载数据: blog: 212 ) 
│   │   │   │   └── Service Mesh能做什么 --> ( 难度等级: [0.0781, 0.0781) || 挂载数据: blog: 2 ) 
│   │   │   ├── Service Mesh的价值 --> ( 难度等级: [0.0781, 0.0783) || 挂载数据: 无 ) 
│   │   │   ├── Istio详解 --> ( 难度等级: [0.0783, 0.0784) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Istio架构 --> ( 难度等级: [0.0783, 0.0783) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据平面 --> ( 难度等级: [0.0783, 0.0783) || 挂载数据: 无 ) 
│   │   │   │   ├── 控制平面 --> ( 难度等级: [0.0783, 0.0784) || 挂载数据: 无 ) 
│   │   │   │   └── Isito案例 --> ( 难度等级: [0.0784, 0.0784) || 挂载数据: 无 ) 
│   │   │   └── Service Mesh展望 --> ( 难度等级: [0.0784, 0.0785) || 挂载数据: 无 ) 
│   │   ├── 深入理解网络 --> ( 难度等级: [0.0785, 0.0791) || 挂载数据: 无 ) 
│   │   │   ├── 从国际互联网开始 --> ( 难度等级: [0.0785, 0.0786) || 挂载数据: 无 ) 
│   │   │   ├── NIO，一本难念的经 --> ( 难度等级: [0.0786, 0.0787) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 难懂的ByteBuffer --> ( 难度等级: [0.0786, 0.0786) || 挂载数据: 无 ) 
│   │   │   │   ├── 晦涩的“非阻塞” --> ( 难度等级: [0.0786, 0.0787) || 挂载数据: 无 ) 
│   │   │   │   └── 复杂的Reactor模型 --> ( 难度等级: [0.0787, 0.0787) || 挂载数据: 无 ) 
│   │   │   ├── AIO，大道至简的设计与苦涩的现实 --> ( 难度等级: [0.0787, 0.0788) || 挂载数据: 无 ) 
│   │   │   ├── HTTP的前世今生 --> ( 难度等级: [0.0788, 0.0789) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP的设计思路 --> ( 难度等级: [0.0788, 0.0788) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP如何保持状态 --> ( 难度等级: [0.0788, 0.0788) || 挂载数据: blog: 18 ) 
│   │   │   │   ├── Session的秘密 --> ( 难度等级: [0.0788, 0.0789) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 再谈Token --> ( 难度等级: [0.0789, 0.0789) || 挂载数据: 无 ) 
│   │   │   │   └── 分布式Session --> ( 难度等级: [0.0789, 0.0789) || 挂载数据: 无 ) 
│   │   │   ├── 分布式系统的基石：TCP/IP --> ( 难度等级: [0.0789, 0.079) || 挂载数据: blog: 1 ) 
│   │   │   └── 从CDN到SD-WAN --> ( 难度等级: [0.079, 0.0791) || 挂载数据: 无 ) 
│   │   │       ├── 互联互不通的运营商网络 --> ( 难度等级: [0.079, 0.079) || 挂载数据: 无 ) 
│   │   │       ├── 双线机房的出现 --> ( 难度等级: [0.079, 0.0791) || 挂载数据: 无 ) 
│   │   │       ├── CDN的作用 --> ( 难度等级: [0.0791, 0.0791) || 挂载数据: blog: 2 ) 
│   │   │       └── SD-WAN技术的诞生 --> ( 难度等级: [0.0791, 0.0791) || 挂载数据: 无 ) 
│   │   ├── 分布式系统的经典理论 --> ( 难度等级: [0.0791, 0.0797) || 挂载数据: 无 ) 
│   │   │   ├── 从分布式系统的设计理念说起 --> ( 难度等级: [0.0791, 0.0792) || 挂载数据: 无 ) 
│   │   │   ├── 分布式系统的一致性原理 --> ( 难度等级: [0.0792, 0.0793) || 挂载数据: 无 ) 
│   │   │   ├── 分布式系统的基石之ZooKeeper --> ( 难度等级: [0.0793, 0.0794) || 挂载数据: 无 ) 
│   │   │   │   ├── ZooKeeper的原理与功能 --> ( 难度等级: [0.0793, 0.0794) || 挂载数据: blog: 164 ) 
│   │   │   │   └── ZooKeeper的应用场景案例分析 --> ( 难度等级: [0.0794, 0.0794) || 挂载数据: blog: 10 ) 
│   │   │   ├── 经典的CAP理论 --> ( 难度等级: [0.0794, 0.0795) || 挂载数据: blog: 2 ) 
│   │   │   ├── BASE准则，一个影响深远的指导思想 --> ( 难度等级: [0.0795, 0.0796) || 挂载数据: 无 ) 
│   │   │   └── 重新认识分布式事务 --> ( 难度等级: [0.0796, 0.0797) || 挂载数据: 无 ) 
│   │   │       ├── 数据库单机事务的实现原理 --> ( 难度等级: [0.0796, 0.0796) || 挂载数据: blog: 1 ) 
│   │   │       ├── 经典的X/OpenDTP事务模型 --> ( 难度等级: [0.0796, 0.0797) || 挂载数据: 无 ) 
│   │   │       └── 互联网中的分布式事务解决方案 --> ( 难度等级: [0.0797, 0.0797) || 挂载数据: blog: 18 ) 
│   │   ├── 聊聊RPC --> ( 难度等级: [0.0797, 0.0803) || 挂载数据: 无 ) 
│   │   │   ├── 从IPC通信说起 --> ( 难度等级: [0.0797, 0.0799) || 挂载数据: 无 ) 
│   │   │   ├── 古老又有生命力的RPC --> ( 难度等级: [0.0799, 0.08) || 挂载数据: 无 ) 
│   │   │   ├── 从RPC到服务治理框架 --> ( 难度等级: [0.08, 0.0802) || 挂载数据: 无 ) 
│   │   │   └── 基于ZeroC Ice的微服务架构指南 --> ( 难度等级: [0.0802, 0.0803) || 挂载数据: 无 ) 
│   │   │       ├── ZeroC Ice的前世今生 --> ( 难度等级: [0.0802, 0.0802) || 挂载数据: blog: 2 ) 
│   │   │       ├── ZeroC Ice微服务架构指南 --> ( 难度等级: [0.0802, 0.0803) || 挂载数据: 无 ) 
│   │   │       └── 微服务架构概述 --> ( 难度等级: [0.0803, 0.0803) || 挂载数据: 无 ) 
│   │   │           ├── 微服务架构兴起的原因 --> ( 难度等级: [0.0803, 0.0803) || 挂载数据: 无 ) 
│   │   │           ├── 不得不提的容器技术 --> ( 难度等级: [0.0803, 0.0803) || 挂载数据: 无 ) 
│   │   │           └── 如何全面理解微服务架构 --> ( 难度等级: [0.0803, 0.0803) || 挂载数据: blog: 92 ) 
│   │   ├── 深入浅析内存 --> ( 难度等级: [0.0803, 0.0809) || 挂载数据: 无 ) 
│   │   │   ├── 你所不知道的内存知识 --> ( 难度等级: [0.0803, 0.0805) || 挂载数据: 无 ) 
│   │   │   │   ├── 复杂的CPU与单纯的内存 --> ( 难度等级: [0.0803, 0.0804) || 挂载数据: blog: 10 ) 
│   │   │   │   └── 深入理解不一致性内存 --> ( 难度等级: [0.0804, 0.0805) || 挂载数据: 无 ) 
│   │   │   ├── 内存计算技术的前世今生 --> ( 难度等级: [0.0805, 0.0806) || 挂载数据: 无 ) 
│   │   │   ├── 内存缓存技术分析 --> ( 难度等级: [0.0806, 0.0808) || 挂载数据: 无 ) 
│   │   │   │   ├── 缓存概述 --> ( 难度等级: [0.0806, 0.0807) || 挂载数据: 无 ) 
│   │   │   │   ├── 缓存实现的几种方式 --> ( 难度等级: [0.0807, 0.0807) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Memcache的内存管理技术 --> ( 难度等级: [0.0807, 0.0807) || 挂载数据: blog: 4 ) 
│   │   │   │   └── Redis的独特之处 --> ( 难度等级: [0.0807, 0.0808) || 挂载数据: 无 ) 
│   │   │   └── 内存计算产品分析 --> ( 难度等级: [0.0808, 0.0809) || 挂载数据: blog: 1 ) 
│   │   │       ├── SAP HANA --> ( 难度等级: [0.0808, 0.0808) || 挂载数据: blog: 1 ) 
│   │   │       ├── Hazelcast --> ( 难度等级: [0.0808, 0.0809) || 挂载数据: 无 ) 
│   │   │       └── VoltDB --> ( 难度等级: [0.0809, 0.0809) || 挂载数据: 无 ) 
│   │   ├── 深入解析分布式文件存储 --> ( 难度等级: [0.0809, 0.0815) || 挂载数据: 无 ) 
│   │   │   ├── 数据存储进化史 --> ( 难度等级: [0.0809, 0.081) || 挂载数据: 无 ) 
│   │   │   ├── 经典的网络文件系统NFS --> ( 难度等级: [0.081, 0.0811) || 挂载数据: 无 ) 
│   │   │   ├── 高性能计算领域的分布式文件系统 --> ( 难度等级: [0.0811, 0.0812) || 挂载数据: 无 ) 
│   │   │   ├── 企业级分布式文件系统GlusterFS --> ( 难度等级: [0.0812, 0.0813) || 挂载数据: 无 ) 
│   │   │   ├── 创新的Linux分布式存储系统——Ceph --> ( 难度等级: [0.0813, 0.0813) || 挂载数据: blog: 1 ) 
│   │   │   ├── 星际文件系统IPFS --> ( 难度等级: [0.0813, 0.0814) || 挂载数据: 无 ) 
│   │   │   └── 软件定义存储 --> ( 难度等级: [0.0814, 0.0815) || 挂载数据: blog: 1 ) 
│   │   ├── 聊聊分布式计算 --> ( 难度等级: [0.0815, 0.0821) || 挂载数据: 无 ) 
│   │   │   ├── 不得不说的Actor模型 --> ( 难度等级: [0.0815, 0.0817) || 挂载数据: 无 ) 
│   │   │   ├── 初识Akka --> ( 难度等级: [0.0817, 0.0818) || 挂载数据: 无 ) 
│   │   │   ├── 适用面很广的Storm --> ( 难度等级: [0.0818, 0.082) || 挂载数据: blog: 2 ) 
│   │   │   └── MapReduce及其引发的新世界 --> ( 难度等级: [0.082, 0.0821) || 挂载数据: blog: 4 ) 
│   │   ├── 全文检索与消息队列中间件 --> ( 难度等级: [0.0821, 0.0827) || 挂载数据: 无 ) 
│   │   │   ├── 全文检索 --> ( 难度等级: [0.0821, 0.0824) || 挂载数据: 无 ) 
│   │   │   │   ├── Lucene --> ( 难度等级: [0.0821, 0.0822) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Solr --> ( 难度等级: [0.0822, 0.0823) || 挂载数据: 无 ) 
│   │   │   │   └── ElasticSearch --> ( 难度等级: [0.0823, 0.0824) || 挂载数据: blog: 5 ) 
│   │   │   └── 消息队列 --> ( 难度等级: [0.0824, 0.0827) || 挂载数据: blog: 6 ) 
│   │   │       ├── JEE专属的JMS --> ( 难度等级: [0.0824, 0.0825) || 挂载数据: blog: 2 ) 
│   │   │       ├── 生生不息的ActiveMQ --> ( 难度等级: [0.0825, 0.0826) || 挂载数据: blog: 19 ) 
│   │   │       ├── RabbitMQ --> ( 难度等级: [0.0826, 0.0827) || 挂载数据: blog: 14 ) 
│   │   │       └── Kafka --> ( 难度等级: [0.0827, 0.0827) || 挂载数据: blog: 131 ) 
│   │   └── 架构实践 --> ( 难度等级: [0.0827, 0.0833) || 挂载数据: 无 ) 
│   │       ├── 身边购平台实践 --> ( 难度等级: [0.0827, 0.083) || 挂载数据: blog: 1 ) 
│   │       └── DIY一个有难度的分布式集群 --> ( 难度等级: [0.083, 0.0833) || 挂载数据: blog: 2 ) 
│   ├── 编程语言 --> ( 难度等级: [0.0833, 0.125) || 挂载数据: 无 ) 
│   │   ├── Golang --> ( 难度等级: [0.0833, 0.085) || 挂载数据: 无 ) 
│   │   ├── 入门 --> ( 难度等级: [0.085, 0.0867) || 挂载数据: 无 ) 
│   │   │   ├── hello，world --> ( 难度等级: [0.085, 0.0852) || 挂载数据: blog: 1 ) 
│   │   │   ├── 命令行参数 --> ( 难度等级: [0.0852, 0.0854) || 挂载数据: 无 ) 
│   │   │   ├── 找出重复行 --> ( 难度等级: [0.0854, 0.0856) || 挂载数据: 无 ) 
│   │   │   ├── GIF动画 --> ( 难度等级: [0.0856, 0.0858) || 挂载数据: 无 ) 
│   │   │   ├── 获取一个URL --> ( 难度等级: [0.0858, 0.086) || 挂载数据: 无 ) 
│   │   │   ├── 并发获取多个URL --> ( 难度等级: [0.086, 0.0862) || 挂载数据: 无 ) 
│   │   │   ├── 一个Web服务器 --> ( 难度等级: [0.0862, 0.0865) || 挂载数据: 无 ) 
│   │   │   └── 其他内容 --> ( 难度等级: [0.0865, 0.0867) || 挂载数据: 无 ) 
│   │   ├── 程序结构 --> ( 难度等级: [0.0867, 0.0883) || 挂载数据: 无 ) 
│   │   │   ├── 名称 --> ( 难度等级: [0.0867, 0.0869) || 挂载数据: 无 ) 
│   │   │   ├── 声明 --> ( 难度等级: [0.0869, 0.0871) || 挂载数据: 无 ) 
│   │   │   ├── 变量 --> ( 难度等级: [0.0871, 0.0874) || 挂载数据: 无 ) 
│   │   │   │   ├── 短变量声明 --> ( 难度等级: [0.0871, 0.0872) || 挂载数据: 无 ) 
│   │   │   │   ├── 指针 --> ( 难度等级: [0.0872, 0.0873) || 挂载数据: 无 ) 
│   │   │   │   ├── new函数 --> ( 难度等级: [0.0873, 0.0873) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 变量的生命周期 --> ( 难度等级: [0.0873, 0.0874) || 挂载数据: 无 ) 
│   │   │   ├── 赋值 --> ( 难度等级: [0.0874, 0.0876) || 挂载数据: 无 ) 
│   │   │   │   ├── 多重赋值 --> ( 难度等级: [0.0874, 0.0875) || 挂载数据: 无 ) 
│   │   │   │   └── 可赋值性 --> ( 难度等级: [0.0875, 0.0876) || 挂载数据: 无 ) 
│   │   │   ├── 类型声明 --> ( 难度等级: [0.0876, 0.0879) || 挂载数据: 无 ) 
│   │   │   ├── 包和文件 --> ( 难度等级: [0.0879, 0.0881) || 挂载数据: 无 ) 
│   │   │   │   ├── 导入 --> ( 难度等级: [0.0879, 0.088) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 远程导入 --> ( 难度等级: [0.0879, 0.0879) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── 命名导入 --> ( 难度等级: [0.0879, 0.088) || 挂载数据: 无 ) 
│   │   │   │   └── 包初始化 --> ( 难度等级: [0.088, 0.0881) || 挂载数据: 无 ) 
│   │   │   └── 作用域 --> ( 难度等级: [0.0881, 0.0883) || 挂载数据: 无 ) 
│   │   ├── 基本数据 --> ( 难度等级: [0.0883, 0.09) || 挂载数据: 无 ) 
│   │   │   ├── 整数 --> ( 难度等级: [0.0883, 0.0886) || 挂载数据: 无 ) 
│   │   │   ├── 浮点数 --> ( 难度等级: [0.0886, 0.0889) || 挂载数据: 无 ) 
│   │   │   ├── 复数 --> ( 难度等级: [0.0889, 0.0892) || 挂载数据: 无 ) 
│   │   │   ├── 布尔值 --> ( 难度等级: [0.0892, 0.0894) || 挂载数据: 无 ) 
│   │   │   ├── 字符串 --> ( 难度等级: [0.0894, 0.0897) || 挂载数据: 无 ) 
│   │   │   │   ├── 字符串字面量 --> ( 难度等级: [0.0894, 0.0895) || 挂载数据: 无 ) 
│   │   │   │   ├── Unicode --> ( 难度等级: [0.0895, 0.0896) || 挂载数据: 无 ) 
│   │   │   │   ├── UTF-8 --> ( 难度等级: [0.0896, 0.0896) || 挂载数据: 无 ) 
│   │   │   │   ├── 字符串和字节slice --> ( 难度等级: [0.0896, 0.0897) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 字符串和数字的相互转换 --> ( 难度等级: [0.0897, 0.0897) || 挂载数据: 无 ) 
│   │   │   └── 常量 --> ( 难度等级: [0.0897, 0.09) || 挂载数据: 无 ) 
│   │   │       ├── 常量生成器iota --> ( 难度等级: [0.0897, 0.0899) || 挂载数据: 无 ) 
│   │   │       └── 无类型常量 --> ( 难度等级: [0.0899, 0.09) || 挂载数据: 无 ) 
│   │   ├── 复合数据类型 --> ( 难度等级: [0.09, 0.0917) || 挂载数据: 无 ) 
│   │   │   ├── 数组 --> ( 难度等级: [0.09, 0.0903) || 挂载数据: 无 ) 
│   │   │   ├── slice --> ( 难度等级: [0.0903, 0.0906) || 挂载数据: 无 ) 
│   │   │   │   ├── append函数 --> ( 难度等级: [0.0903, 0.0904) || 挂载数据: 无 ) 
│   │   │   │   └── slice就地修改 --> ( 难度等级: [0.0904, 0.0906) || 挂载数据: 无 ) 
│   │   │   ├── map --> ( 难度等级: [0.0906, 0.0908) || 挂载数据: blog: 7 ) 
│   │   │   ├── 结构体 --> ( 难度等级: [0.0908, 0.0911) || 挂载数据: 无 ) 
│   │   │   │   ├── 结构体字面量 --> ( 难度等级: [0.0908, 0.0909) || 挂载数据: 无 ) 
│   │   │   │   ├── 结构体比较 --> ( 难度等级: [0.0909, 0.091) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 结构体嵌套和匿名成员 --> ( 难度等级: [0.091, 0.0911) || 挂载数据: 无 ) 
│   │   │   ├── JSON --> ( 难度等级: [0.0911, 0.0914) || 挂载数据: 无 ) 
│   │   │   └── 文本和HTML模板 --> ( 难度等级: [0.0914, 0.0917) || 挂载数据: 无 ) 
│   │   ├── 函数 --> ( 难度等级: [0.0917, 0.0933) || 挂载数据: 无 ) 
│   │   │   ├── 函数声明 --> ( 难度等级: [0.0917, 0.0917) || 挂载数据: 无 ) 
│   │   │   ├── 递归 --> ( 难度等级: [0.0917, 0.0918) || 挂载数据: 无 ) 
│   │   │   ├── 多返回值 --> ( 难度等级: [0.0918, 0.0919) || 挂载数据: 无 ) 
│   │   │   ├── 错误 --> ( 难度等级: [0.0919, 0.092) || 挂载数据: 无 ) 
│   │   │   │   ├── 错误处理策略 --> ( 难度等级: [0.0919, 0.0919) || 挂载数据: 无 ) 
│   │   │   │   └── 文件结束标识 --> ( 难度等级: [0.0919, 0.092) || 挂载数据: 无 ) 
│   │   │   ├── 函数变量 --> ( 难度等级: [0.092, 0.0921) || 挂载数据: 无 ) 
│   │   │   ├── 匿名函数 --> ( 难度等级: [0.0921, 0.0921) || 挂载数据: 无 ) 
│   │   │   ├── 变长函数 --> ( 难度等级: [0.0921, 0.0922) || 挂载数据: 无 ) 
│   │   │   ├── 延迟函数调用 --> ( 难度等级: [0.0922, 0.0923) || 挂载数据: 无 ) 
│   │   │   ├── 宕机 --> ( 难度等级: [0.0923, 0.0924) || 挂载数据: 无 ) 
│   │   │   ├── 恢复 --> ( 难度等级: [0.0924, 0.0925) || 挂载数据: 无 ) 
│   │   │   ├── 基本语法 --> ( 难度等级: [0.0925, 0.0925) || 挂载数据: 无 ) 
│   │   │   ├── 参数和返回值的内存布局 --> ( 难度等级: [0.0925, 0.0926) || 挂载数据: 无 ) 
│   │   │   ├── 函数中的局部变量 --> ( 难度等级: [0.0926, 0.0927) || 挂载数据: 无 ) 
│   │   │   ├── 调用其他函数 --> ( 难度等级: [0.0927, 0.0928) || 挂载数据: blog: 1 ) 
│   │   │   ├── 宏函数 --> ( 难度等级: [0.0928, 0.0929) || 挂载数据: 无 ) 
│   │   │   ├── 函数调用规范 --> ( 难度等级: [0.0929, 0.0929) || 挂载数据: 无 ) 
│   │   │   ├── 高级汇编语言 --> ( 难度等级: [0.0929, 0.093) || 挂载数据: 无 ) 
│   │   │   ├── PCDATA和FUNCDATA --> ( 难度等级: [0.093, 0.0931) || 挂载数据: 无 ) 
│   │   │   ├── 方法函数 --> ( 难度等级: [0.0931, 0.0932) || 挂载数据: 无 ) 
│   │   │   ├── 递归函数： 1到n求和 --> ( 难度等级: [0.0932, 0.0933) || 挂载数据: 无 ) 
│   │   │   └── 闭包函数 --> ( 难度等级: [0.0933, 0.0933) || 挂载数据: 无 ) 
│   │   ├── 方法 --> ( 难度等级: [0.0933, 0.095) || 挂载数据: 无 ) 
│   │   │   ├── 方法声明 --> ( 难度等级: [0.0933, 0.0936) || 挂载数据: 无 ) 
│   │   │   ├── 指针接收者的方法 --> ( 难度等级: [0.0936, 0.0939) || 挂载数据: 无 ) 
│   │   │   ├── 通过结构体内嵌组成类型 --> ( 难度等级: [0.0939, 0.0942) || 挂载数据: 无 ) 
│   │   │   ├── 方法变量与表达式 --> ( 难度等级: [0.0942, 0.0944) || 挂载数据: blog: 1 ) 
│   │   │   ├── 示例：位向量 --> ( 难度等级: [0.0944, 0.0947) || 挂载数据: 无 ) 
│   │   │   └── 封装 --> ( 难度等级: [0.0947, 0.095) || 挂载数据: 无 ) 
│   │   ├── 接口 --> ( 难度等级: [0.095, 0.0967) || 挂载数据: 无 ) 
│   │   │   ├── 接口即约定 --> ( 难度等级: [0.095, 0.0951) || 挂载数据: 无 ) 
│   │   │   ├── 接口类型 --> ( 难度等级: [0.0951, 0.0952) || 挂载数据: 无 ) 
│   │   │   ├── 实现接口 --> ( 难度等级: [0.0952, 0.0953) || 挂载数据: 无 ) 
│   │   │   ├── 使用flag.Value来解析参数 --> ( 难度等级: [0.0953, 0.0954) || 挂载数据: 无 ) 
│   │   │   ├── 接口值 --> ( 难度等级: [0.0954, 0.0955) || 挂载数据: 无 ) 
│   │   │   ├── 使用sort.Interface来排序 --> ( 难度等级: [0.0955, 0.0956) || 挂载数据: blog: 2 ) 
│   │   │   ├── http.Handler接口 --> ( 难度等级: [0.0956, 0.0957) || 挂载数据: 无 ) 
│   │   │   ├── error接口 --> ( 难度等级: [0.0957, 0.0958) || 挂载数据: blog: 2 ) 
│   │   │   ├── 类型断言 --> ( 难度等级: [0.0958, 0.0959) || 挂载数据: 无 ) 
│   │   │   ├── 使用类型断言来识别错误 --> ( 难度等级: [0.0959, 0.096) || 挂载数据: 无 ) 
│   │   │   ├── 通过接口类型断言来查询特性 --> ( 难度等级: [0.096, 0.0961) || 挂载数据: 无 ) 
│   │   │   ├── 类型分支 --> ( 难度等级: [0.0961, 0.0962) || 挂载数据: 无 ) 
│   │   │   ├── 一些建议 --> ( 难度等级: [0.0962, 0.0963) || 挂载数据: 无 ) 
│   │   │   ├── 标准库 --> ( 难度等级: [0.0963, 0.0964) || 挂载数据: 无 ) 
│   │   │   │   ├── 文档与源代码 --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: 无 ) 
│   │   │   │   ├── 记录日志 --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: 无 ) 
│   │   │   │   │   ├── log包 --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: blog: 3 ) 
│   │   │   │   │   ├── 定制的日志记录器 --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: blog: 2 ) 
│   │   │   │   │   └── 结论 --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: 无 ) 
│   │   │   │   ├── 编码解码 --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 解码JSON --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: 无 ) 
│   │   │   │   │   └── 编码JSON --> ( 难度等级: [0.0963, 0.0963) || 挂载数据: blog: 2 ) 
│   │   │   │   └── 输入和输出 --> ( 难度等级: [0.0963, 0.0964) || 挂载数据: 无 ) 
│   │   │   │       ├── Writer和Reader接口 --> ( 难度等级: [0.0963, 0.0964) || 挂载数据: 无 ) 
│   │   │   │       ├── 整合并完成工作 --> ( 难度等级: [0.0964, 0.0964) || 挂载数据: blog: 2 ) 
│   │   │   │       └── 简单的curl --> ( 难度等级: [0.0964, 0.0964) || 挂载数据: 无 ) 
│   │   │   ├── 实现 --> ( 难度等级: [0.0964, 0.0965) || 挂载数据: 无 ) 
│   │   │   ├── 方法集 --> ( 难度等级: [0.0965, 0.0966) || 挂载数据: 无 ) 
│   │   │   └── 多态 --> ( 难度等级: [0.0966, 0.0967) || 挂载数据: 无 ) 
│   │   ├── goroutine和通道 --> ( 难度等级: [0.0967, 0.0983) || 挂载数据: 无 ) 
│   │   │   ├── goroutine --> ( 难度等级: [0.0967, 0.097) || 挂载数据: blog: 1 ) 
│   │   │   ├── 通道 --> ( 难度等级: [0.097, 0.0973) || 挂载数据: 无 ) 
│   │   │   │   ├── 无缓冲通道 --> ( 难度等级: [0.097, 0.0971) || 挂载数据: 无 ) 
│   │   │   │   ├── 管道 --> ( 难度等级: [0.0971, 0.0972) || 挂载数据: 无 ) 
│   │   │   │   ├── 单向通道类型 --> ( 难度等级: [0.0972, 0.0973) || 挂载数据: 无 ) 
│   │   │   │   └── 缓冲通道 --> ( 难度等级: [0.0973, 0.0973) || 挂载数据: 无 ) 
│   │   │   ├── 并行循环 --> ( 难度等级: [0.0973, 0.0977) || 挂载数据: 无 ) 
│   │   │   ├── 使用select多路复用 --> ( 难度等级: [0.0977, 0.098) || 挂载数据: 无 ) 
│   │   │   └── 取消 --> ( 难度等级: [0.098, 0.0983) || 挂载数据: 无 ) 
│   │   ├── 使用共享变量实现并发 --> ( 难度等级: [0.0983, 0.1) || 挂载数据: 无 ) 
│   │   │   ├── 竞态 --> ( 难度等级: [0.0983, 0.0986) || 挂载数据: 无 ) 
│   │   │   ├── 互斥锁：sync.Mutex --> ( 难度等级: [0.0986, 0.0989) || 挂载数据: 无 ) 
│   │   │   ├── 读写互斥锁：sync.RWMutex --> ( 难度等级: [0.0989, 0.0992) || 挂载数据: 无 ) 
│   │   │   ├── 内存同步 --> ( 难度等级: [0.0992, 0.0994) || 挂载数据: 无 ) 
│   │   │   ├── 延迟初始化：sync.Once --> ( 难度等级: [0.0994, 0.0997) || 挂载数据: 无 ) 
│   │   │   └── 竞态检测器 --> ( 难度等级: [0.0997, 0.1) || 挂载数据: 无 ) 
│   │   ├── 包和go工具 --> ( 难度等级: [0.1, 0.1017) || 挂载数据: 无 ) 
│   │   │   ├── 引言 --> ( 难度等级: [0.1, 0.1002) || 挂载数据: 无 ) 
│   │   │   ├── 导入路径 --> ( 难度等级: [0.1002, 0.1005) || 挂载数据: 无 ) 
│   │   │   ├── 包的声明 --> ( 难度等级: [0.1005, 0.1007) || 挂载数据: 无 ) 
│   │   │   ├── 导入声明 --> ( 难度等级: [0.1007, 0.101) || 挂载数据: 无 ) 
│   │   │   ├── 空导入 --> ( 难度等级: [0.101, 0.1012) || 挂载数据: 无 ) 
│   │   │   ├── 包及其命名 --> ( 难度等级: [0.1012, 0.1014) || 挂载数据: 无 ) 
│   │   │   └── go工具 --> ( 难度等级: [0.1014, 0.1017) || 挂载数据: 无 ) 
│   │   │       ├── 工作空间的组织 --> ( 难度等级: [0.1014, 0.1015) || 挂载数据: 无 ) 
│   │   │       ├── 包的下载 --> ( 难度等级: [0.1015, 0.1015) || 挂载数据: 无 ) 
│   │   │       ├── 包的构建 --> ( 难度等级: [0.1015, 0.1015) || 挂载数据: 无 ) 
│   │   │       ├── 包的文档化 --> ( 难度等级: [0.1015, 0.1016) || 挂载数据: 无 ) 
│   │   │       ├── 内部包 --> ( 难度等级: [0.1016, 0.1016) || 挂载数据: 无 ) 
│   │   │       └── 包的查询 --> ( 难度等级: [0.1016, 0.1017) || 挂载数据: 无 ) 
│   │   ├── 测试 --> ( 难度等级: [0.1017, 0.1033) || 挂载数据: 无 ) 
│   │   │   ├── go test工具 --> ( 难度等级: [0.1017, 0.1019) || 挂载数据: 无 ) 
│   │   │   ├── Test函数 --> ( 难度等级: [0.1019, 0.1022) || 挂载数据: 无 ) 
│   │   │   │   ├── 随机测试 --> ( 难度等级: [0.1019, 0.102) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试命令 --> ( 难度等级: [0.102, 0.102) || 挂载数据: 无 ) 
│   │   │   │   ├── 白盒测试 --> ( 难度等级: [0.102, 0.1021) || 挂载数据: 无 ) 
│   │   │   │   ├── 外部测试包 --> ( 难度等级: [0.1021, 0.1021) || 挂载数据: 无 ) 
│   │   │   │   ├── 编写有效测试 --> ( 难度等级: [0.1021, 0.1022) || 挂载数据: 无 ) 
│   │   │   │   └── 避免脆弱的测试 --> ( 难度等级: [0.1022, 0.1022) || 挂载数据: 无 ) 
│   │   │   ├── 覆盖率 --> ( 难度等级: [0.1022, 0.1025) || 挂载数据: 无 ) 
│   │   │   ├── Benchmark函数 --> ( 难度等级: [0.1025, 0.1028) || 挂载数据: 无 ) 
│   │   │   ├── 性能剖析 --> ( 难度等级: [0.1028, 0.1031) || 挂载数据: 无 ) 
│   │   │   └── Example函数 --> ( 难度等级: [0.1031, 0.1033) || 挂载数据: 无 ) 
│   │   ├── 反射 --> ( 难度等级: [0.1033, 0.105) || 挂载数据: blog: 1 ) 
│   │   │   ├── reflect.Type和reflect.Value --> ( 难度等级: [0.1033, 0.1036) || 挂载数据: 无 ) 
│   │   │   ├── Display：一个递归的值显示器 --> ( 难度等级: [0.1036, 0.1039) || 挂载数据: 无 ) 
│   │   │   ├── 使用reflect.Value来设置值 --> ( 难度等级: [0.1039, 0.1042) || 挂载数据: blog: 1 ) 
│   │   │   ├── 访问结构体字段标签 --> ( 难度等级: [0.1042, 0.1044) || 挂载数据: 无 ) 
│   │   │   ├── 显示类型的方法 --> ( 难度等级: [0.1044, 0.1047) || 挂载数据: 无 ) 
│   │   │   └── 注意事项 --> ( 难度等级: [0.1047, 0.105) || 挂载数据: 无 ) 
│   │   ├── 低级编程 --> ( 难度等级: [0.105, 0.1067) || 挂载数据: 无 ) 
│   │   │   ├── unsafe.Sizeof、Alignof和Offsetof --> ( 难度等级: [0.105, 0.1056) || 挂载数据: 无 ) 
│   │   │   ├── unsafe.Pointer --> ( 难度等级: [0.1056, 0.1061) || 挂载数据: 无 ) 
│   │   │   └── 使用cgo调用C代码 --> ( 难度等级: [0.1061, 0.1067) || 挂载数据: 无 ) 
│   │   ├── 关于Go语言的介绍 --> ( 难度等级: [0.1067, 0.1083) || 挂载数据: 无 ) 
│   │   │   ├── 用Go解决现代编程难题 --> ( 难度等级: [0.1067, 0.1075) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发速度 --> ( 难度等级: [0.1067, 0.1069) || 挂载数据: 无 ) 
│   │   │   │   ├── 并发 --> ( 难度等级: [0.1069, 0.1071) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 竞争状态 --> ( 难度等级: [0.1069, 0.107) || 挂载数据: 无 ) 
│   │   │   │   │   └── 锁住共享资源 --> ( 难度等级: [0.107, 0.1071) || 挂载数据: 无 ) 
│   │   │   │   │       └── 原子函数 --> ( 难度等级: [0.107, 0.1071) || 挂载数据: 无 ) 
│   │   │   │   ├── Go语言的类型系统 --> ( 难度等级: [0.1071, 0.1073) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 用户定义的类型 --> ( 难度等级: [0.1071, 0.1071) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 类型的本质 --> ( 难度等级: [0.1071, 0.1072) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 内置类型 --> ( 难度等级: [0.1071, 0.1072) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 引用类型 --> ( 难度等级: [0.1072, 0.1072) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   └── 结构类型 --> ( 难度等级: [0.1072, 0.1072) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 嵌入类型 --> ( 难度等级: [0.1072, 0.1072) || 挂载数据: 无 ) 
│   │   │   │   │   └── 公开或未公开的标识符 --> ( 难度等级: [0.1072, 0.1073) || 挂载数据: 无 ) 
│   │   │   │   └── 内存管理 --> ( 难度等级: [0.1073, 0.1075) || 挂载数据: 无 ) 
│   │   │   └── 你好，Go --> ( 难度等级: [0.1075, 0.1083) || 挂载数据: 无 ) 
│   │   ├── 快速开始一个Go程序 --> ( 难度等级: [0.1083, 0.11) || 挂载数据: 无 ) 
│   │   │   ├── 程序架构 --> ( 难度等级: [0.1083, 0.1087) || 挂载数据: 无 ) 
│   │   │   ├── main包 --> ( 难度等级: [0.1087, 0.1092) || 挂载数据: 无 ) 
│   │   │   ├── search包 --> ( 难度等级: [0.1092, 0.1096) || 挂载数据: 无 ) 
│   │   │   │   ├── search.go --> ( 难度等级: [0.1092, 0.1093) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── feed.go --> ( 难度等级: [0.1093, 0.1094) || 挂载数据: 无 ) 
│   │   │   │   └── match.go default.go --> ( 难度等级: [0.1094, 0.1096) || 挂载数据: 无 ) 
│   │   │   └── RSS匹配器 --> ( 难度等级: [0.1096, 0.11) || 挂载数据: 无 ) 
│   │   ├── 打包和工具链 --> ( 难度等级: [0.11, 0.1117) || 挂载数据: 无 ) 
│   │   │   ├── 包 --> ( 难度等级: [0.11, 0.1103) || 挂载数据: 无 ) 
│   │   │   │   └── 包名惯例 --> ( 难度等级: [0.11, 0.1103) || 挂载数据: 无 ) 
│   │   │   ├── 函数init --> ( 难度等级: [0.1103, 0.1107) || 挂载数据: 无 ) 
│   │   │   ├── 进一步介绍Go开发工具 --> ( 难度等级: [0.1107, 0.111) || 挂载数据: 无 ) 
│   │   │   │   ├── go vet --> ( 难度等级: [0.1107, 0.1108) || 挂载数据: 无 ) 
│   │   │   │   ├── Go代码格式化 --> ( 难度等级: [0.1108, 0.1109) || 挂载数据: 无 ) 
│   │   │   │   └── Go语言的文档 --> ( 难度等级: [0.1109, 0.111) || 挂载数据: blog: 1 ) 
│   │   │   ├── 与其他Go开发者合作 --> ( 难度等级: [0.111, 0.1113) || 挂载数据: 无 ) 
│   │   │   └── 依赖管理 --> ( 难度等级: [0.1113, 0.1117) || 挂载数据: 无 ) 
│   │   │       ├── 第三方依赖 --> ( 难度等级: [0.1113, 0.1115) || 挂载数据: 无 ) 
│   │   │       └── 对gb的介绍 --> ( 难度等级: [0.1115, 0.1117) || 挂载数据: 无 ) 
│   │   ├── 并发模式 --> ( 难度等级: [0.1117, 0.1133) || 挂载数据: 无 ) 
│   │   │   ├── runner --> ( 难度等级: [0.1117, 0.1122) || 挂载数据: 无 ) 
│   │   │   ├── pool --> ( 难度等级: [0.1122, 0.1128) || 挂载数据: 无 ) 
│   │   │   └── work --> ( 难度等级: [0.1128, 0.1133) || 挂载数据: 无 ) 
│   │   ├── 测试和性能 --> ( 难度等级: [0.1133, 0.115) || 挂载数据: 无 ) 
│   │   │   ├── 单元测试 --> ( 难度等级: [0.1133, 0.1142) || 挂载数据: 无 ) 
│   │   │   │   ├── 基础单元测试 --> ( 难度等级: [0.1133, 0.1135) || 挂载数据: 无 ) 
│   │   │   │   ├── 表组测试 --> ( 难度等级: [0.1135, 0.1137) || 挂载数据: 无 ) 
│   │   │   │   ├── 模仿调用 --> ( 难度等级: [0.1137, 0.114) || 挂载数据: 无 ) 
│   │   │   │   └── 测试服务端点 --> ( 难度等级: [0.114, 0.1142) || 挂载数据: 无 ) 
│   │   │   └── 基准测试 --> ( 难度等级: [0.1142, 0.115) || 挂载数据: 无 ) 
│   │   ├── Go与Web应用 --> ( 难度等级: [0.115, 0.1167) || 挂载数据: 无 ) 
│   │   │   ├── Go与Web应用 --> ( 难度等级: [0.115, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用Go语言构建Web应用 --> ( 难度等级: [0.115, 0.115) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Go与可扩展Web应用 --> ( 难度等级: [0.115, 0.115) || 挂载数据: blog: 259 ) 
│   │   │   │   │   ├── Go与模块化Web应用 --> ( 难度等级: [0.115, 0.115) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Go与可维护的Web应用 --> ( 难度等级: [0.115, 0.115) || 挂载数据: 无 ) 
│   │   │   │   │   └── Go与高性能Web应用 --> ( 难度等级: [0.115, 0.115) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Web应用的工作原理 --> ( 难度等级: [0.115, 0.115) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP简介 --> ( 难度等级: [0.115, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   ├── Web应用的诞生 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP请求 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 幂等的请求方法 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 浏览器对请求方法的支持 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   │   └── 请求首部 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   ├── HTTP响应 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 响应状态码 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   │   └── 响应首部 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   ├── URI --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── HTTP/2简介 --> ( 难度等级: [0.1151, 0.1151) || 挂载数据: 无 ) 
│   │   │   │   ├── Web应用的各个组成部分 --> ( 难度等级: [0.1151, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 处理器 --> ( 难度等级: [0.1151, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 模板引擎 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 处理请求 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── ResponseWriter --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── cookie --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │       ├── 将cookie发送至浏览器 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │       ├── 从浏览器里面获取cookie --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: blog: 6 ) 
│   │   │   │   │   │       └── 使用cookie实现闪现消息 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 内容展示 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Go的模板引擎 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 对模板进行语法分析 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   │   └── 执行模板 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 动作 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 条件动作 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 迭代动作 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 设置动作 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   └── 包含动作 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 上下文感知 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   │   ├── 防御XSS攻击 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: blog: 1 ) 
│   │   │   │   │   │   │   └── 不对HTML进行转义 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: blog: 5 ) 
│   │   │   │   │   │   ├── 嵌套模板 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 通过块动作定义默认模板 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │   └── 存储数据 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │       ├── 内存存储 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │       └── 文件存储 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   │           ├── 读取和写入CSV文件 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: blog: 6 ) 
│   │   │   │   │           └── gob包 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   └── Hello Go --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   ├── ChitChat论坛 --> ( 难度等级: [0.1152, 0.1154) || 挂载数据: 无 ) 
│   │   │   │   ├── ChitChat简介 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   ├── 应用设计 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据模型 --> ( 难度等级: [0.1152, 0.1152) || 挂载数据: 无 ) 
│   │   │   │   ├── 请求的接收与处理 --> ( 难度等级: [0.1152, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 多路复用器 --> ( 难度等级: [0.1152, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 服务静态文件 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 创建处理器函数 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 使用cookie进行访问控制 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Go的net/http标准库 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── 使用Go构建服务器 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │       ├── Go Web服务器 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │       └── 通过HTTPS提供服务 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── 使用模板生成HTML响应 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 安装PostgreSQL --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 在Linux或FreeBSD系统上安装 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在Mac OS X系统上安装 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: blog: 8 ) 
│   │   │   │   │   └── 在Windows系统上安装 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: blog: 21 ) 
│   │   │   │   ├── 连接数据库 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   ├── 启动服务器 --> ( 难度等级: [0.1153, 0.1153) || 挂载数据: 无 ) 
│   │   │   │   └── Web应用运作流程回顾 --> ( 难度等级: [0.1153, 0.1154) || 挂载数据: 无 ) 
│   │   │   ├── Web开发简介 --> ( 难度等级: [0.1154, 0.1156) || 挂载数据: 无 ) 
│   │   │   ├── 请求路由 --> ( 难度等级: [0.1156, 0.1157) || 挂载数据: 无 ) 
│   │   │   │   ├── httprouter --> ( 难度等级: [0.1156, 0.1156) || 挂载数据: 无 ) 
│   │   │   │   ├── 原理 --> ( 难度等级: [0.1156, 0.1157) || 挂载数据: 无 ) 
│   │   │   │   └── 压缩检索树创建过程 --> ( 难度等级: [0.1157, 0.1157) || 挂载数据: 无 ) 
│   │   │   ├── 中间件 --> ( 难度等级: [0.1157, 0.1159) || 挂载数据: 无 ) 
│   │   │   │   ├── 代码泥潭 --> ( 难度等级: [0.1157, 0.1158) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用中间件剥离非业务逻辑 --> ( 难度等级: [0.1158, 0.1158) || 挂载数据: 无 ) 
│   │   │   │   ├── 更优雅的中间件写法 --> ( 难度等级: [0.1158, 0.1159) || 挂载数据: blog: 19 ) 
│   │   │   │   └── 哪些事情适合在中间件中做 --> ( 难度等级: [0.1159, 0.1159) || 挂载数据: 无 ) 
│   │   │   ├── 请求校验 --> ( 难度等级: [0.1159, 0.1161) || 挂载数据: 无 ) 
│   │   │   │   ├── 重构请求校验函数 --> ( 难度等级: [0.1159, 0.116) || 挂载数据: 无 ) 
│   │   │   │   └── 用请求校验器解放体力劳动 --> ( 难度等级: [0.116, 0.1161) || 挂载数据: 无 ) 
│   │   │   ├── Database和数据库打交道 --> ( 难度等级: [0.1161, 0.1163) || 挂载数据: 无 ) 
│   │   │   │   ├── 从database/sql讲起 --> ( 难度等级: [0.1161, 0.1162) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── 提高生产效率的ORM和 --> ( 难度等级: [0.1162, 0.1162) || 挂载数据: 无 ) 
│   │   │   │   └── 脆弱的数据库 --> ( 难度等级: [0.1162, 0.1163) || 挂载数据: blog: 4 ) 
│   │   │   ├── 服务流量限制 --> ( 难度等级: [0.1163, 0.1165) || 挂载数据: 无 ) 
│   │   │   │   ├── 常见的流量限制手段 --> ( 难度等级: [0.1163, 0.1164) || 挂载数据: 无 ) 
│   │   │   │   └── 服务瓶颈和QoS --> ( 难度等级: [0.1164, 0.1165) || 挂载数据: 无 ) 
│   │   │   └── 灰度发布和A/B测试 --> ( 难度等级: [0.1165, 0.1167) || 挂载数据: 无 ) 
│   │   │       ├── 通过分批次部署实现灰度发布 --> ( 难度等级: [0.1165, 0.1165) || 挂载数据: 无 ) 
│   │   │       ├── 通过业务规则进行灰度发布 --> ( 难度等级: [0.1165, 0.1166) || 挂载数据: 无 ) 
│   │   │       └── 如何实现一套灰度发布系统 --> ( 难度等级: [0.1166, 0.1167) || 挂载数据: 无 ) 
│   │   ├── 语言基础 --> ( 难度等级: [0.1167, 0.1183) || 挂载数据: 无 ) 
│   │   │   ├── Go语言创世纪 --> ( 难度等级: [0.1167, 0.1169) || 挂载数据: 无 ) 
│   │   │   │   ├── 来自贝尔实验室特有基因 --> ( 难度等级: [0.1167, 0.1168) || 挂载数据: 无 ) 
│   │   │   │   └── 你好，世界 --> ( 难度等级: [0.1168, 0.1169) || 挂载数据: 无 ) 
│   │   │   ├── “Hello， World”的革命 --> ( 难度等级: [0.1169, 0.1172) || 挂载数据: 无 ) 
│   │   │   │   ├── B语言——Ken Thompson， --> ( 难度等级: [0.1169, 0.117) || 挂载数据: 无 ) 
│   │   │   │   ├── C语言——Dennis Ritchie，1972— --> ( 难度等级: [0.117, 0.117) || 挂载数据: 无 ) 
│   │   │   │   ├── Newsqueak——Rob Pike， --> ( 难度等级: [0.117, 0.1171) || 挂载数据: 无 ) 
│   │   │   │   ├── Alef——Phil Winterbottom， --> ( 难度等级: [0.1171, 0.1171) || 挂载数据: 无 ) 
│   │   │   │   ├── Limbo——Sean Dorward， Phil Winterbottom， Rob Pike， --> ( 难度等级: [0.1171, 0.1171) || 挂载数据: 无 ) 
│   │   │   │   ├── Go语言——2007— --> ( 难度等级: [0.1171, 0.1172) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 你好，世界!——V2. --> ( 难度等级: [0.1172, 0.1172) || 挂载数据: 无 ) 
│   │   │   ├── 面向并发的内存模型 --> ( 难度等级: [0.1172, 0.1175) || 挂载数据: 无 ) 
│   │   │   │   ├── 原子操作 --> ( 难度等级: [0.1172, 0.1173) || 挂载数据: 无 ) 
│   │   │   │   ├── 顺序一致性内存模型 --> ( 难度等级: [0.1173, 0.1173) || 挂载数据: 无 ) 
│   │   │   │   ├── 初始化顺序 --> ( 难度等级: [0.1173, 0.1174) || 挂载数据: 无 ) 
│   │   │   │   ├── Goroutine的创建 --> ( 难度等级: [0.1174, 0.1174) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于通道的通信 --> ( 难度等级: [0.1174, 0.1175) || 挂载数据: 无 ) 
│   │   │   │   └── 不靠谱的同步 --> ( 难度等级: [0.1175, 0.1175) || 挂载数据: 无 ) 
│   │   │   ├── 常见的并发模式 --> ( 难度等级: [0.1175, 0.1178) || 挂载数据: 无 ) 
│   │   │   │   ├── 并发版本的“Hello， World” --> ( 难度等级: [0.1175, 0.1175) || 挂载数据: 无 ) 
│   │   │   │   ├── 生产者/消费者模型 --> ( 难度等级: [0.1175, 0.1176) || 挂载数据: 无 ) 
│   │   │   │   ├── 发布/订阅模型 --> ( 难度等级: [0.1176, 0.1176) || 挂载数据: 无 ) 
│   │   │   │   ├── 控制并发数 --> ( 难度等级: [0.1176, 0.1176) || 挂载数据: 无 ) 
│   │   │   │   ├── 赢者为王 --> ( 难度等级: [0.1176, 0.1177) || 挂载数据: 无 ) 
│   │   │   │   ├── 素数筛 --> ( 难度等级: [0.1177, 0.1177) || 挂载数据: 无 ) 
│   │   │   │   ├── 并发的安全退出 --> ( 难度等级: [0.1177, 0.1177) || 挂载数据: 无 ) 
│   │   │   │   └── context包 --> ( 难度等级: [0.1177, 0.1178) || 挂载数据: 无 ) 
│   │   │   ├── 错误和异常 --> ( 难度等级: [0.1178, 0.1181) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取错误的上下文 --> ( 难度等级: [0.1178, 0.1179) || 挂载数据: 无 ) 
│   │   │   │   ├── 错误的错误返回 --> ( 难度等级: [0.1179, 0.118) || 挂载数据: 无 ) 
│   │   │   │   └── 剖析异常 --> ( 难度等级: [0.118, 0.1181) || 挂载数据: blog: 1 ) 
│   │   │   └── 补充说明 --> ( 难度等级: [0.1181, 0.1183) || 挂载数据: 无 ) 
│   │   ├── CGO编程 --> ( 难度等级: [0.1183, 0.12) || 挂载数据: 无 ) 
│   │   │   ├── 快速入门 --> ( 难度等级: [0.1183, 0.1185) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 最简CGO程序 --> ( 难度等级: [0.1183, 0.1184) || 挂载数据: 无 ) 
│   │   │   │   ├── 基于C标准库函数输出字符串 --> ( 难度等级: [0.1184, 0.1184) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用自己的C函数 --> ( 难度等级: [0.1184, 0.1184) || 挂载数据: 无 ) 
│   │   │   │   ├── C代码的模块化 --> ( 难度等级: [0.1184, 0.1184) || 挂载数据: 无 ) 
│   │   │   │   ├── 用Go重新实现C函数 --> ( 难度等级: [0.1184, 0.1184) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向C接口的Go编程 --> ( 难度等级: [0.1184, 0.1184) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义整数变量 --> ( 难度等级: [0.1184, 0.1185) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义字符串变量 --> ( 难度等级: [0.1185, 0.1185) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义main函数 --> ( 难度等级: [0.1185, 0.1185) || 挂载数据: 无 ) 
│   │   │   │   ├── 特殊字符 --> ( 难度等级: [0.1185, 0.1185) || 挂载数据: 无 ) 
│   │   │   │   └── 没有分号 --> ( 难度等级: [0.1185, 0.1185) || 挂载数据: 无 ) 
│   │   │   ├── CGO基础 --> ( 难度等级: [0.1185, 0.1187) || 挂载数据: 无 ) 
│   │   │   │   ├── import "C"语句 --> ( 难度等级: [0.1185, 0.1186) || 挂载数据: 无 ) 
│   │   │   │   ├── #cgo语句 --> ( 难度等级: [0.1186, 0.1186) || 挂载数据: 无 ) 
│   │   │   │   └── build标志条件编译 --> ( 难度等级: [0.1186, 0.1187) || 挂载数据: blog: 1 ) 
│   │   │   ├── 类型转换 --> ( 难度等级: [0.1187, 0.1189) || 挂载数据: 无 ) 
│   │   │   │   ├── 数值类型 --> ( 难度等级: [0.1187, 0.1187) || 挂载数据: 无 ) 
│   │   │   │   ├── Go字符串和切片 --> ( 难度等级: [0.1187, 0.1188) || 挂载数据: 无 ) 
│   │   │   │   ├── 指针间的转换 --> ( 难度等级: [0.1188, 0.1188) || 挂载数据: 无 ) 
│   │   │   │   ├── 数值和指针的转换 --> ( 难度等级: [0.1188, 0.1189) || 挂载数据: 无 ) 
│   │   │   │   └── 切片间的转换 --> ( 难度等级: [0.1189, 0.1189) || 挂载数据: 无 ) 
│   │   │   ├── 函数调用 --> ( 难度等级: [0.1189, 0.1191) || 挂载数据: 无 ) 
│   │   │   │   ├── Go调用C函数 --> ( 难度等级: [0.1189, 0.1189) || 挂载数据: 无 ) 
│   │   │   │   ├── C函数的返回值 --> ( 难度等级: [0.1189, 0.119) || 挂载数据: 无 ) 
│   │   │   │   ├── void函数的返回值 --> ( 难度等级: [0.119, 0.119) || 挂载数据: 无 ) 
│   │   │   │   └── C调用Go导出函数 --> ( 难度等级: [0.119, 0.1191) || 挂载数据: 无 ) 
│   │   │   ├── 内部机制 --> ( 难度等级: [0.1191, 0.1193) || 挂载数据: 无 ) 
│   │   │   │   ├── CGO生成的中间文件 --> ( 难度等级: [0.1191, 0.1191) || 挂载数据: 无 ) 
│   │   │   │   ├── Go调用C函数 --> ( 难度等级: [0.1191, 0.1192) || 挂载数据: 无 ) 
│   │   │   │   └── C调用Go函数 --> ( 难度等级: [0.1192, 0.1193) || 挂载数据: 无 ) 
│   │   │   ├── CGO内存模型 --> ( 难度等级: [0.1193, 0.1194) || 挂载数据: 无 ) 
│   │   │   │   ├── Go访问C内存 --> ( 难度等级: [0.1193, 0.1193) || 挂载数据: 无 ) 
│   │   │   │   ├── C临时访问传入的Go内存 --> ( 难度等级: [0.1193, 0.1194) || 挂载数据: 无 ) 
│   │   │   │   ├── C长期持有Go指针对象 --> ( 难度等级: [0.1194, 0.1194) || 挂载数据: 无 ) 
│   │   │   │   └── 导出C函数不能返回Go内存 --> ( 难度等级: [0.1194, 0.1194) || 挂载数据: 无 ) 
│   │   │   ├── C++类包装 --> ( 难度等级: [0.1194, 0.1196) || 挂载数据: 无 ) 
│   │   │   │   ├── C++类到Go语言对象 --> ( 难度等级: [0.1194, 0.1195) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Go语言对象到C++类 --> ( 难度等级: [0.1195, 0.1196) || 挂载数据: blog: 3 ) 
│   │   │   │   └── 彻底解放C++的this指针 --> ( 难度等级: [0.1196, 0.1196) || 挂载数据: blog: 2 ) 
│   │   │   ├── 静态库和动态库 --> ( 难度等级: [0.1196, 0.1198) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用C静态库 --> ( 难度等级: [0.1196, 0.1197) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用C动态库 --> ( 难度等级: [0.1197, 0.1197) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 导出C静态库 --> ( 难度等级: [0.1197, 0.1197) || 挂载数据: 无 ) 
│   │   │   │   ├── 导出C动态库 --> ( 难度等级: [0.1197, 0.1198) || 挂载数据: 无 ) 
│   │   │   │   └── 导出非main包的函数 --> ( 难度等级: [0.1198, 0.1198) || 挂载数据: 无 ) 
│   │   │   └── 编译和链接参数 --> ( 难度等级: [0.1198, 0.12) || 挂载数据: 无 ) 
│   │   │       ├── 编译参数：CFLAGS/CPPFLAGS/CXXFLAGS --> ( 难度等级: [0.1198, 0.1199) || 挂载数据: 无 ) 
│   │   │       ├── 链接参数：LDFLAGS --> ( 难度等级: [0.1199, 0.1199) || 挂载数据: blog: 1 ) 
│   │   │       ├── pkg-config --> ( 难度等级: [0.1199, 0.1199) || 挂载数据: 无 ) 
│   │   │       ├── go get链 --> ( 难度等级: [0.1199, 0.12) || 挂载数据: 无 ) 
│   │   │       └── 多个非main包中导出C函数 --> ( 难度等级: [0.12, 0.12) || 挂载数据: 无 ) 
│   │   ├── Go汇编语言 --> ( 难度等级: [0.12, 0.1217) || 挂载数据: 无 ) 
│   │   │   ├── 计算机结构 --> ( 难度等级: [0.12, 0.1203) || 挂载数据: 无 ) 
│   │   │   │   ├── 图灵机和BrainFuck语言 --> ( 难度等级: [0.12, 0.1201) || 挂载数据: 无 ) 
│   │   │   │   ├── 《人力资源机器》游戏 --> ( 难度等级: [0.1201, 0.1201) || 挂载数据: 无 ) 
│   │   │   │   ├── X86-64体系结构 --> ( 难度等级: [0.1201, 0.1202) || 挂载数据: 无 ) 
│   │   │   │   ├── Go汇编中的伪寄存器 --> ( 难度等级: [0.1202, 0.1203) || 挂载数据: 无 ) 
│   │   │   │   └── X86-64指令集 --> ( 难度等级: [0.1203, 0.1203) || 挂载数据: 无 ) 
│   │   │   ├── 控制流 --> ( 难度等级: [0.1203, 0.1207) || 挂载数据: 无 ) 
│   │   │   │   ├── 顺序执行 --> ( 难度等级: [0.1203, 0.1204) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── if/goto跳转 --> ( 难度等级: [0.1204, 0.1206) || 挂载数据: blog: 11 ) 
│   │   │   │   └── for循环 --> ( 难度等级: [0.1206, 0.1207) || 挂载数据: 无 ) 
│   │   │   ├── 汇编语言的威力 --> ( 难度等级: [0.1207, 0.121) || 挂载数据: 无 ) 
│   │   │   │   ├── 系统调用 --> ( 难度等级: [0.1207, 0.1208) || 挂载数据: 无 ) 
│   │   │   │   ├── 直接调用C函数 --> ( 难度等级: [0.1208, 0.1209) || 挂载数据: 无 ) 
│   │   │   │   └── AVX指令 --> ( 难度等级: [0.1209, 0.121) || 挂载数据: 无 ) 
│   │   │   ├── 例子：Goroutine ID --> ( 难度等级: [0.121, 0.1213) || 挂载数据: 无 ) 
│   │   │   │   ├── 故意设计没有goid --> ( 难度等级: [0.121, 0.1211) || 挂载数据: 无 ) 
│   │   │   │   ├── 纯Go方式获取goid --> ( 难度等级: [0.1211, 0.1211) || 挂载数据: 无 ) 
│   │   │   │   ├── 从g结构体获取goid --> ( 难度等级: [0.1211, 0.1212) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取g结构体对应的接口对象 --> ( 难度等级: [0.1212, 0.1213) || 挂载数据: 无 ) 
│   │   │   │   └── goid的应用：局部存储 --> ( 难度等级: [0.1213, 0.1213) || 挂载数据: 无 ) 
│   │   │   └── Delve调试器 --> ( 难度等级: [0.1213, 0.1217) || 挂载数据: 无 ) 
│   │   │       ├── Delve入门 --> ( 难度等级: [0.1213, 0.1215) || 挂载数据: 无 ) 
│   │   │       └── 调试汇编程序 --> ( 难度等级: [0.1215, 0.1217) || 挂载数据: 无 ) 
│   │   ├── RPC和Protobuf --> ( 难度等级: [0.1217, 0.1233) || 挂载数据: 无 ) 
│   │   │   ├── RPC入门 --> ( 难度等级: [0.1217, 0.1219) || 挂载数据: 无 ) 
│   │   │   │   ├── RPC版“Hello， World” --> ( 难度等级: [0.1217, 0.1217) || 挂载数据: 无 ) 
│   │   │   │   ├── 更安全的RPC接口 --> ( 难度等级: [0.1217, 0.1218) || 挂载数据: 无 ) 
│   │   │   │   ├── 跨语言的RPC --> ( 难度等级: [0.1218, 0.1218) || 挂载数据: blog: 1 ) 
│   │   │   │   └── HTTP上的RPC --> ( 难度等级: [0.1218, 0.1219) || 挂载数据: blog: 29 ) 
│   │   │   ├── Protobuf --> ( 难度等级: [0.1219, 0.1221) || 挂载数据: 无 ) 
│   │   │   │   ├── Protobuf入门 --> ( 难度等级: [0.1219, 0.1219) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 定制代码生成插件 --> ( 难度等级: [0.1219, 0.122) || 挂载数据: 无 ) 
│   │   │   │   └── 自动生成完整的RPC代码 --> ( 难度等级: [0.122, 0.1221) || 挂载数据: 无 ) 
│   │   │   ├── 玩转RPC --> ( 难度等级: [0.1221, 0.1223) || 挂载数据: 无 ) 
│   │   │   │   ├── 客户端RPC的实现原理 --> ( 难度等级: [0.1221, 0.1221) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 基于RPC实现监视功能 --> ( 难度等级: [0.1221, 0.1222) || 挂载数据: 无 ) 
│   │   │   │   ├── 反向RPC --> ( 难度等级: [0.1222, 0.1222) || 挂载数据: 无 ) 
│   │   │   │   └── 上下文信息 --> ( 难度等级: [0.1222, 0.1223) || 挂载数据: 无 ) 
│   │   │   ├── gRPC入门 --> ( 难度等级: [0.1223, 0.1225) || 挂载数据: 无 ) 
│   │   │   │   ├── gRPC技术栈 --> ( 难度等级: [0.1223, 0.1223) || 挂载数据: 无 ) 
│   │   │   │   ├── gRPC入门 --> ( 难度等级: [0.1223, 0.1224) || 挂载数据: blog: 13 ) 
│   │   │   │   ├── gRPC流 --> ( 难度等级: [0.1224, 0.1224) || 挂载数据: 无 ) 
│   │   │   │   └── 发布和订阅模式 --> ( 难度等级: [0.1224, 0.1225) || 挂载数据: 无 ) 
│   │   │   ├── gRPC进阶 --> ( 难度等级: [0.1225, 0.1227) || 挂载数据: 无 ) 
│   │   │   │   ├── 证书认证 --> ( 难度等级: [0.1225, 0.1226) || 挂载数据: 无 ) 
│   │   │   │   ├── Token认证 --> ( 难度等级: [0.1226, 0.1226) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── 截取器 --> ( 难度等级: [0.1226, 0.1227) || 挂载数据: 无 ) 
│   │   │   │   └── 和Web服务共存 --> ( 难度等级: [0.1227, 0.1227) || 挂载数据: 无 ) 
│   │   │   ├── gRPC和Protobuf扩展 --> ( 难度等级: [0.1227, 0.1229) || 挂载数据: 无 ) 
│   │   │   │   ├── 验证器 --> ( 难度等级: [0.1227, 0.1228) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── REST接口 --> ( 难度等级: [0.1228, 0.1228) || 挂载数据: 无 ) 
│   │   │   │   └── Nginx --> ( 难度等级: [0.1228, 0.1229) || 挂载数据: blog: 10 ) 
│   │   │   ├── pbgo：基于Protobuf的框架 --> ( 难度等级: [0.1229, 0.1231) || 挂载数据: 无 ) 
│   │   │   │   ├── Protobuf扩展语法 --> ( 难度等级: [0.1229, 0.123) || 挂载数据: 无 ) 
│   │   │   │   ├── 插件中读取扩展信息 --> ( 难度等级: [0.123, 0.123) || 挂载数据: 无 ) 
│   │   │   │   ├── 生成REST代码 --> ( 难度等级: [0.123, 0.1231) || 挂载数据: 无 ) 
│   │   │   │   └── 启动REST服务 --> ( 难度等级: [0.1231, 0.1231) || 挂载数据: 无 ) 
│   │   │   └── grpcurl工具 --> ( 难度等级: [0.1231, 0.1233) || 挂载数据: 无 ) 
│   │   │       ├── 启动反射服务 --> ( 难度等级: [0.1231, 0.1232) || 挂载数据: 无 ) 
│   │   │       ├── 查看服务列表 --> ( 难度等级: [0.1232, 0.1232) || 挂载数据: 无 ) 
│   │   │       ├── 服务的方法列表 --> ( 难度等级: [0.1232, 0.1232) || 挂载数据: 无 ) 
│   │   │       ├── 获取类型信息 --> ( 难度等级: [0.1232, 0.1233) || 挂载数据: 无 ) 
│   │   │       └── 调用方法 --> ( 难度等级: [0.1233, 0.1233) || 挂载数据: 无 ) 
│   │   └── 分布式系统 --> ( 难度等级: [0.1233, 0.125) || 挂载数据: 无 ) 
│   │       ├── 分布式ID生成器 --> ( 难度等级: [0.1233, 0.1236) || 挂载数据: 无 ) 
│   │       │   └── worker_id分配 --> ( 难度等级: [0.1233, 0.1236) || 挂载数据: blog: 8 ) 
│   │       ├── 分布式锁 --> ( 难度等级: [0.1236, 0.1238) || 挂载数据: 无 ) 
│   │       │   ├── 进程内加锁 --> ( 难度等级: [0.1236, 0.1236) || 挂载数据: 无 ) 
│   │       │   ├── 尝试锁 --> ( 难度等级: [0.1236, 0.1237) || 挂载数据: 无 ) 
│   │       │   ├── 基于Redis的setnx --> ( 难度等级: [0.1237, 0.1237) || 挂载数据: 无 ) 
│   │       │   ├── 基于ZooKeeper --> ( 难度等级: [0.1237, 0.1237) || 挂载数据: 无 ) 
│   │       │   ├── 基于etcd --> ( 难度等级: [0.1237, 0.1238) || 挂载数据: blog: 1 ) 
│   │       │   └── 如何选择合适的锁 --> ( 难度等级: [0.1238, 0.1238) || 挂载数据: 无 ) 
│   │       ├── 延时任务系统 --> ( 难度等级: [0.1238, 0.124) || 挂载数据: 无 ) 
│   │       │   ├── 定时器的实现 --> ( 难度等级: [0.1238, 0.1239) || 挂载数据: 无 ) 
│   │       │   ├── 任务分发 --> ( 难度等级: [0.1239, 0.124) || 挂载数据: 无 ) 
│   │       │   └── 数据再平衡和幂等考量 --> ( 难度等级: [0.124, 0.124) || 挂载数据: 无 ) 
│   │       ├── 分布式搜索引擎 --> ( 难度等级: [0.124, 0.1243) || 挂载数据: 无 ) 
│   │       │   ├── 搜索引擎 --> ( 难度等级: [0.124, 0.1242) || 挂载数据: blog: 1 ) 
│   │       │   └── 异构数据同步 --> ( 难度等级: [0.1242, 0.1243) || 挂载数据: 无 ) 
│   │       ├── 负载均衡 --> ( 难度等级: [0.1243, 0.1245) || 挂载数据: 无 ) 
│   │       │   ├── 常见的负载均衡思路 --> ( 难度等级: [0.1243, 0.1244) || 挂载数据: 无 ) 
│   │       │   ├── 基于洗牌算法的负载均衡 --> ( 难度等级: [0.1244, 0.1244) || 挂载数据: blog: 10 ) 
│   │       │   └── 负载均衡算法效果验证 --> ( 难度等级: [0.1244, 0.1245) || 挂载数据: 无 ) 
│   │       ├── 分布式配置管理 --> ( 难度等级: [0.1245, 0.1248) || 挂载数据: 无 ) 
│   │       │   ├── 场景举例 --> ( 难度等级: [0.1245, 0.1246) || 挂载数据: 无 ) 
│   │       │   ├── 使用etcd实现配置更新 --> ( 难度等级: [0.1246, 0.1246) || 挂载数据: 无 ) 
│   │       │   ├── 配置膨胀 --> ( 难度等级: [0.1246, 0.1247) || 挂载数据: 无 ) 
│   │       │   ├── 配置版本管理 --> ( 难度等级: [0.1247, 0.1247) || 挂载数据: 无 ) 
│   │       │   └── 客户端容错 --> ( 难度等级: [0.1247, 0.1248) || 挂载数据: 无 ) 
│   │       └── 分布式爬虫 --> ( 难度等级: [0.1248, 0.125) || 挂载数据: 无 ) 
│   │           ├── 基于colly的单机爬虫 --> ( 难度等级: [0.1248, 0.1248) || 挂载数据: 无 ) 
│   │           ├── 分布式爬虫 --> ( 难度等级: [0.1248, 0.1249) || 挂载数据: blog: 3 ) 
│   │           ├── 结合nats和colly的消息生产 --> ( 难度等级: [0.1249, 0.1249) || 挂载数据: 无 ) 
│   │           └── 结合colly的消息消费 --> ( 难度等级: [0.1249, 0.125) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.125, 0.1667) || 挂载数据: 无 ) 
├── 云原生初阶-平台开发 --> ( 难度等级: [0.1667, 0.3333) || 挂载数据: 无 ) 
│   ├── 容器 --> ( 难度等级: [0.1667, 0.2) || 挂载数据: 无 ) 
│   │   ├── Docker --> ( 难度等级: [0.1667, 0.1778) || 挂载数据: 无 ) 
│   │   ├── 基础入门 --> ( 难度等级: [0.1778, 0.1889) || 挂载数据: 无 ) 
│   │   │   ├── 初识Docker与容器 --> ( 难度等级: [0.1778, 0.1792) || 挂载数据: 无 ) 
│   │   │   ├── 核心概念与安装配置 --> ( 难度等级: [0.1792, 0.1806) || 挂载数据: 无 ) 
│   │   │   │   ├── 核心概念 --> ( 难度等级: [0.1792, 0.1795) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 安装Docker引擎 --> ( 难度等级: [0.1795, 0.1799) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Ubuntu环境下安装Docker --> ( 难度等级: [0.1795, 0.1796) || 挂载数据: blog: 15 ) 
│   │   │   │   │   ├── CentOS环境下安装Docker --> ( 难度等级: [0.1796, 0.1797) || 挂载数据: blog: 13 ) 
│   │   │   │   │   ├── 通过脚本安装 --> ( 难度等级: [0.1797, 0.1797) || 挂载数据: blog: 11 ) 
│   │   │   │   │   ├── macOS环境下安装Docker --> ( 难度等级: [0.1797, 0.1798) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── Windows环境下安装Docker --> ( 难度等级: [0.1798, 0.1799) || 挂载数据: blog: 12 ) 
│   │   │   │   ├── 配置Docker服务 --> ( 难度等级: [0.1799, 0.1802) || 挂载数据: 无 ) 
│   │   │   │   └── 推荐实践环境 --> ( 难度等级: [0.1802, 0.1806) || 挂载数据: 无 ) 
│   │   │   ├── 使用Docker镜像 --> ( 难度等级: [0.1806, 0.1819) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取镜像 --> ( 难度等级: [0.1806, 0.1808) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看镜像信息 --> ( 难度等级: [0.1808, 0.181) || 挂载数据: 无 ) 
│   │   │   │   ├── 搜寻镜像 --> ( 难度等级: [0.181, 0.1812) || 挂载数据: 无 ) 
│   │   │   │   ├── 删除和清理镜像 --> ( 难度等级: [0.1812, 0.1813) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建镜像 --> ( 难度等级: [0.1813, 0.1815) || 挂载数据: 无 ) 
│   │   │   │   ├── 存出和载入镜像 --> ( 难度等级: [0.1815, 0.1817) || 挂载数据: 无 ) 
│   │   │   │   └── 上传镜像 --> ( 难度等级: [0.1817, 0.1819) || 挂载数据: 无 ) 
│   │   │   ├── 操作Docker容器 --> ( 难度等级: [0.1819, 0.1833) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建容器 --> ( 难度等级: [0.1819, 0.1821) || 挂载数据: 无 ) 
│   │   │   │   ├── 停止容器 --> ( 难度等级: [0.1821, 0.1823) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── 进入容器 --> ( 难度等级: [0.1823, 0.1825) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── 删除容器 --> ( 难度等级: [0.1825, 0.1827) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 导入和导出容器 --> ( 难度等级: [0.1827, 0.1829) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看容器 --> ( 难度等级: [0.1829, 0.1831) || 挂载数据: 无 ) 
│   │   │   │   └── 其他容器命令 --> ( 难度等级: [0.1831, 0.1833) || 挂载数据: 无 ) 
│   │   │   ├── 访问Docker仓库 --> ( 难度等级: [0.1833, 0.1847) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker Hub公共镜像市场 --> ( 难度等级: [0.1833, 0.1838) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 第三方镜像市场 --> ( 难度等级: [0.1838, 0.1843) || 挂载数据: 无 ) 
│   │   │   │   └── 搭建本地私有仓库 --> ( 难度等级: [0.1843, 0.1847) || 挂载数据: blog: 1 ) 
│   │   │   ├── Docker数据管理 --> ( 难度等级: [0.1847, 0.1861) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据卷 --> ( 难度等级: [0.1847, 0.1852) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据卷容器 --> ( 难度等级: [0.1852, 0.1856) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 利用数据卷容器来迁移数据 --> ( 难度等级: [0.1856, 0.1861) || 挂载数据: 无 ) 
│   │   │   ├── 端口映射与容器互联 --> ( 难度等级: [0.1861, 0.1875) || 挂载数据: 无 ) 
│   │   │   │   ├── 端口映射实现容器访问 --> ( 难度等级: [0.1861, 0.1868) || 挂载数据: blog: 3 ) 
│   │   │   │   └── 互联机制实现便捷互访 --> ( 难度等级: [0.1868, 0.1875) || 挂载数据: 无 ) 
│   │   │   └── 使用Dockerfile创建镜像 --> ( 难度等级: [0.1875, 0.1889) || 挂载数据: 无 ) 
│   │   │       ├── 基本结构 --> ( 难度等级: [0.1875, 0.1878) || 挂载数据: 无 ) 
│   │   │       ├── 指令说明 --> ( 难度等级: [0.1878, 0.1882) || 挂载数据: 无 ) 
│   │   │       │   ├── 配置指令 --> ( 难度等级: [0.1878, 0.188) || 挂载数据: 无 ) 
│   │   │       │   └── 操作指令 --> ( 难度等级: [0.188, 0.1882) || 挂载数据: blog: 1 ) 
│   │   │       ├── 创建镜像 --> ( 难度等级: [0.1882, 0.1885) || 挂载数据: 无 ) 
│   │   │       │   ├── 命令选项 --> ( 难度等级: [0.1882, 0.1883) || 挂载数据: 无 ) 
│   │   │       │   ├── 选择父镜像 --> ( 难度等级: [0.1883, 0.1884) || 挂载数据: 无 ) 
│   │   │       │   ├── 使用.dockerignore文件 --> ( 难度等级: [0.1884, 0.1885) || 挂载数据: 无 ) 
│   │   │       │   └── 多步骤创建 --> ( 难度等级: [0.1885, 0.1885) || 挂载数据: blog: 5 ) 
│   │   │       └── 最佳实践 --> ( 难度等级: [0.1885, 0.1889) || 挂载数据: 无 ) 
│   │   └── 进阶技能 --> ( 难度等级: [0.1889, 0.2) || 挂载数据: 无 ) 
│   │       ├── 核心实现技术 --> ( 难度等级: [0.1889, 0.1911) || 挂载数据: 无 ) 
│   │       │   ├── 基本架构 --> ( 难度等级: [0.1889, 0.1893) || 挂载数据: 无 ) 
│   │       │   ├── 命名空间 --> ( 难度等级: [0.1893, 0.1898) || 挂载数据: 无 ) 
│   │       │   ├── 控制组 --> ( 难度等级: [0.1898, 0.1902) || 挂载数据: 无 ) 
│   │       │   ├── 联合文件系统 --> ( 难度等级: [0.1902, 0.1907) || 挂载数据: 无 ) 
│   │       │   └── Linux网络虚拟化 --> ( 难度等级: [0.1907, 0.1911) || 挂载数据: 无 ) 
│   │       ├── 配置私有仓库 --> ( 难度等级: [0.1911, 0.1933) || 挂载数据: 无 ) 
│   │       │   ├── 安装Docker Registry --> ( 难度等级: [0.1911, 0.1915) || 挂载数据: 无 ) 
│   │       │   ├── 配置TLS证书 --> ( 难度等级: [0.1915, 0.1919) || 挂载数据: 无 ) 
│   │       │   ├── 管理访问权限 --> ( 难度等级: [0.1919, 0.1922) || 挂载数据: 无 ) 
│   │       │   ├── 配置Registry --> ( 难度等级: [0.1922, 0.1926) || 挂载数据: 无 ) 
│   │       │   ├── 批量管理镜像 --> ( 难度等级: [0.1926, 0.193) || 挂载数据: 无 ) 
│   │       │   └── 使用通知系统 --> ( 难度等级: [0.193, 0.1933) || 挂载数据: 无 ) 
│   │       ├── 安全防护与配置 --> ( 难度等级: [0.1933, 0.1956) || 挂载数据: 无 ) 
│   │       │   ├── 命名空间隔离的安全 --> ( 难度等级: [0.1933, 0.1937) || 挂载数据: 无 ) 
│   │       │   ├── 控制组资源控制的安全 --> ( 难度等级: [0.1937, 0.1941) || 挂载数据: 无 ) 
│   │       │   ├── 内核能力机制 --> ( 难度等级: [0.1941, 0.1944) || 挂载数据: 无 ) 
│   │       │   ├── Docker服务端的防护 --> ( 难度等级: [0.1944, 0.1948) || 挂载数据: 无 ) 
│   │       │   ├── 更多安全特性的使用 --> ( 难度等级: [0.1948, 0.1952) || 挂载数据: 无 ) 
│   │       │   └── 使用第三方检测工具 --> ( 难度等级: [0.1952, 0.1956) || 挂载数据: 无 ) 
│   │       │       ├── Docker Bench --> ( 难度等级: [0.1952, 0.1954) || 挂载数据: 无 ) 
│   │       │       └── clair --> ( 难度等级: [0.1954, 0.1956) || 挂载数据: 无 ) 
│   │       ├── 高级网络功能 --> ( 难度等级: [0.1956, 0.1978) || 挂载数据: 无 ) 
│   │       │   ├── 启动与配置参数 --> ( 难度等级: [0.1956, 0.1958) || 挂载数据: 无 ) 
│   │       │   ├── 配置容器DNS和主机名 --> ( 难度等级: [0.1958, 0.1961) || 挂载数据: 无 ) 
│   │       │   ├── 容器访问控制 --> ( 难度等级: [0.1961, 0.1964) || 挂载数据: 无 ) 
│   │       │   ├── 映射容器端口到宿主主机的实现 --> ( 难度等级: [0.1964, 0.1967) || 挂载数据: 无 ) 
│   │       │   ├── 配置容器网桥 --> ( 难度等级: [0.1967, 0.1969) || 挂载数据: 无 ) 
│   │       │   ├── 自定义网桥 --> ( 难度等级: [0.1969, 0.1972) || 挂载数据: 无 ) 
│   │       │   ├── 使用OpenvSwitch网桥 --> ( 难度等级: [0.1972, 0.1975) || 挂载数据: 无 ) 
│   │       │   └── 创建一个点到点连接 --> ( 难度等级: [0.1975, 0.1978) || 挂载数据: 无 ) 
│   │       └── libnetwork插件化网络功能 --> ( 难度等级: [0.1978, 0.2) || 挂载数据: 无 ) 
│   │           ├── 容器网络模型 --> ( 难度等级: [0.1978, 0.1985) || 挂载数据: 无 ) 
│   │           ├── Docker网络命令 --> ( 难度等级: [0.1985, 0.1993) || 挂载数据: 无 ) 
│   │           └── 构建跨主机容器网络 --> ( 难度等级: [0.1993, 0.2) || 挂载数据: 无 ) 
│   ├── Kubernetes --> ( 难度等级: [0.2, 0.2333) || 挂载数据: 无 ) 
│   │   ├── 管理工具 --> ( 难度等级: [0.2, 0.2011) || 挂载数据: 无 ) 
│   │   │   ├── Kubelens --> ( 难度等级: [0.2, 0.2002) || 挂载数据: 无 ) 
│   │   │   ├── Kuboard --> ( 难度等级: [0.2002, 0.2003) || 挂载数据: 无 ) 
│   │   │   ├── K3S --> ( 难度等级: [0.2003, 0.2005) || 挂载数据: 无 ) 
│   │   │   ├── K9S --> ( 难度等级: [0.2005, 0.2006) || 挂载数据: 无 ) 
│   │   │   ├── Minikube --> ( 难度等级: [0.2006, 0.2008) || 挂载数据: 无 ) 
│   │   │   ├── kubeasz --> ( 难度等级: [0.2008, 0.2009) || 挂载数据: 无 ) 
│   │   │   └── Draft --> ( 难度等级: [0.2009, 0.2011) || 挂载数据: 无 ) 
│   │   ├── Kubernetes入门 --> ( 难度等级: [0.2011, 0.2022) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes是什么 --> ( 难度等级: [0.2011, 0.2014) || 挂载数据: 无 ) 
│   │   │   │   └── Kubernetes的历史 --> ( 难度等级: [0.2011, 0.2014) || 挂载数据: blog: 276 ) 
│   │   │   ├── 从一个简单的例子开始 --> ( 难度等级: [0.2014, 0.2018) || 挂载数据: 无 ) 
│   │   │   │   ├── 环境准备 --> ( 难度等级: [0.2014, 0.2015) || 挂载数据: 无 ) 
│   │   │   │   ├── 启动MySQL服务 --> ( 难度等级: [0.2015, 0.2016) || 挂载数据: 无 ) 
│   │   │   │   ├── 启动Tomcat应用 --> ( 难度等级: [0.2016, 0.2017) || 挂载数据: blog: 6 ) 
│   │   │   │   └── 通过浏览器访问网页 --> ( 难度等级: [0.2017, 0.2018) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes基本概念和术语 --> ( 难度等级: [0.2018, 0.2022) || 挂载数据: 无 ) 
│   │   │       ├── Master --> ( 难度等级: [0.2018, 0.2018) || 挂载数据: 无 ) 
│   │   │       ├── Node --> ( 难度等级: [0.2018, 0.2018) || 挂载数据: blog: 4 ) 
│   │   │       ├── Pod --> ( 难度等级: [0.2018, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── Pod定义详解 --> ( 难度等级: [0.2018, 0.2018) || 挂载数据: blog: 3 ) 
│   │   │       │   ├── Pod的基本用法 --> ( 难度等级: [0.2018, 0.2019) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── 静态Pod --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── Pod容器共享Volume --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: blog: 4 ) 
│   │   │       │   ├── Pod的配置管理 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── 在容器内获取Pod信息（Downward API） --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── Pod生命周期和重启策略 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── Pod健康检查 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: blog: 8 ) 
│   │   │       │   ├── 玩转Pod调度 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── Init Container（初始化容器） --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: blog: 2 ) 
│   │   │       │   ├── Pod的升级和回滚 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── Pod的扩容和缩容 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── 使用StatefulSet搭建MongoDB集群 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: blog: 2 ) 
│   │   │       │   ├── Pod定义文件详解 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── 基本操作 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── 其他设置 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   └── Pod调度 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       ├── Label（标签） --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       ├── Replication Controller --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       ├── Deployment --> ( 难度等级: [0.2019, 0.202) || 挂载数据: 无 ) 
│   │   │       │   ├── 运行Deployment --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: blog: 4 ) 
│   │   │       │   ├── 命令vs配置文件 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── Deployment配置文件简介 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── 伸缩 --> ( 难度等级: [0.2019, 0.2019) || 挂载数据: 无 ) 
│   │   │       │   ├── Failover --> ( 难度等级: [0.2019, 0.202) || 挂载数据: 无 ) 
│   │   │       │   └── 用label控制Pod的位置 --> ( 难度等级: [0.202, 0.202) || 挂载数据: 无 ) 
│   │   │       ├── Horizontal Pod Autoscaler --> ( 难度等级: [0.202, 0.202) || 挂载数据: 无 ) 
│   │   │       ├── StatefulSet --> ( 难度等级: [0.202, 0.202) || 挂载数据: 无 ) 
│   │   │       │   └── 扩容/缩容StatefulSet --> ( 难度等级: [0.202, 0.202) || 挂载数据: blog: 1 ) 
│   │   │       ├── Service（服务） --> ( 难度等级: [0.202, 0.202) || 挂载数据: 无 ) 
│   │   │       ├── Volume（存储卷） --> ( 难度等级: [0.202, 0.2021) || 挂载数据: blog: 1 ) 
│   │   │       ├── Persistent Volume --> ( 难度等级: [0.2021, 0.2021) || 挂载数据: 无 ) 
│   │   │       ├── Namespace（命名空间） --> ( 难度等级: [0.2021, 0.2021) || 挂载数据: blog: 1 ) 
│   │   │       └── Annotation（注解） --> ( 难度等级: [0.2021, 0.2022) || 挂载数据: 无 ) 
│   │   ├── Kubernetes实践指南 --> ( 难度等级: [0.2022, 0.2032) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes安装与配置 --> ( 难度等级: [0.2022, 0.2025) || 挂载数据: 无 ) 
│   │   │   │   ├── 系统要求 --> ( 难度等级: [0.2022, 0.2022) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用kubeadm工具快速安装Kubernetes集群 --> ( 难度等级: [0.2022, 0.2022) || 挂载数据: blog: 27 ) 
│   │   │   │   ├── 以二进制文件方式安装Kubernetes集群 --> ( 难度等级: [0.2022, 0.2023) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Kubernetes集群的安全设置 --> ( 难度等级: [0.2023, 0.2023) || 挂载数据: blog: 11 ) 
│   │   │   │   ├── Kubernetes集群的网络配置 --> ( 难度等级: [0.2023, 0.2024) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── 内网中的Kubernetes相关配置 --> ( 难度等级: [0.2024, 0.2024) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes的版本升级 --> ( 难度等级: [0.2024, 0.2025) || 挂载数据: blog: 30 ) 
│   │   │   │   └── Kubernetes核心服务配置详解 --> ( 难度等级: [0.2025, 0.2025) || 挂载数据: blog: 6 ) 
│   │   │   ├── kubectl命令行工具用法详解 --> ( 难度等级: [0.2025, 0.2029) || 挂载数据: 无 ) 
│   │   │   │   ├── kubectl用法概述 --> ( 难度等级: [0.2025, 0.2026) || 挂载数据: 无 ) 
│   │   │   │   ├── kubectl子命令详解 --> ( 难度等级: [0.2026, 0.2027) || 挂载数据: 无 ) 
│   │   │   │   ├── kubectl参数列表 --> ( 难度等级: [0.2027, 0.2027) || 挂载数据: 无 ) 
│   │   │   │   ├── kubectl输出格式 --> ( 难度等级: [0.2027, 0.2028) || 挂载数据: 无 ) 
│   │   │   │   └── kubectl操作示例 --> ( 难度等级: [0.2028, 0.2029) || 挂载数据: 无 ) 
│   │   │   └── 深入掌握Service --> ( 难度等级: [0.2029, 0.2032) || 挂载数据: 无 ) 
│   │   │       ├── Service定义详解 --> ( 难度等级: [0.2029, 0.2029) || 挂载数据: blog: 1 ) 
│   │   │       ├── Service基本用法 --> ( 难度等级: [0.2029, 0.203) || 挂载数据: 无 ) 
│   │   │       ├── Headless Service --> ( 难度等级: [0.203, 0.203) || 挂载数据: 无 ) 
│   │   │       ├── 集群外部访问Pod或Service --> ( 难度等级: [0.203, 0.2031) || 挂载数据: blog: 1 ) 
│   │   │       ├── DNS服务搭建指南 --> ( 难度等级: [0.2031, 0.2031) || 挂载数据: 无 ) 
│   │   │       ├── 自定义DNS和上游DNS服务器 --> ( 难度等级: [0.2031, 0.2032) || 挂载数据: 无 ) 
│   │   │       └── Ingress：HTTP 7层路由机制 --> ( 难度等级: [0.2032, 0.2032) || 挂载数据: 无 ) 
│   │   ├── Kubernetes核心原理 --> ( 难度等级: [0.2032, 0.2043) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes API Server原理分析 --> ( 难度等级: [0.2032, 0.2034) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes API Server概述 --> ( 难度等级: [0.2032, 0.2033) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── 独特的Kubernetes Proxy API接口 --> ( 难度等级: [0.2033, 0.2033) || 挂载数据: blog: 2 ) 
│   │   │   │   └── 集群功能模块之间的通信 --> ( 难度等级: [0.2033, 0.2034) || 挂载数据: 无 ) 
│   │   │   ├── Controller Manager原理分析 --> ( 难度等级: [0.2034, 0.2035) || 挂载数据: 无 ) 
│   │   │   │   ├── Node Controller --> ( 难度等级: [0.2034, 0.2034) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── ResourceQuota Controller --> ( 难度等级: [0.2034, 0.2034) || 挂载数据: 无 ) 
│   │   │   │   ├── Namespace Controller --> ( 难度等级: [0.2034, 0.2035) || 挂载数据: blog: 13 ) 
│   │   │   │   └── Service Controller与Endpoint Controller --> ( 难度等级: [0.2035, 0.2035) || 挂载数据: blog: 3 ) 
│   │   │   ├── Scheduler原理分析 --> ( 难度等级: [0.2035, 0.2036) || 挂载数据: 无 ) 
│   │   │   ├── kubelet运行机制分析 --> ( 难度等级: [0.2036, 0.2038) || 挂载数据: 无 ) 
│   │   │   │   ├── 节点管理 --> ( 难度等级: [0.2036, 0.2037) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod管理 --> ( 难度等级: [0.2037, 0.2037) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器健康检查 --> ( 难度等级: [0.2037, 0.2037) || 挂载数据: 无 ) 
│   │   │   │   └── cAdvisor资源监控 --> ( 难度等级: [0.2037, 0.2038) || 挂载数据: 无 ) 
│   │   │   ├── kube-proxy运行机制分析 --> ( 难度等级: [0.2038, 0.2039) || 挂载数据: 无 ) 
│   │   │   ├── 深入分析集群安全机制 --> ( 难度等级: [0.2039, 0.204) || 挂载数据: 无 ) 
│   │   │   │   ├── API Server认证管理（Authentication） --> ( 难度等级: [0.2039, 0.2039) || 挂载数据: 无 ) 
│   │   │   │   ├── API Server授木又管理（Authorization） --> ( 难度等级: [0.2039, 0.204) || 挂载数据: 无 ) 
│   │   │   │   ├── Admission Control（准入控制） --> ( 难度等级: [0.204, 0.204) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Service Account --> ( 难度等级: [0.204, 0.204) || 挂载数据: 无 ) 
│   │   │   │   └── Secret私密凭据 --> ( 难度等级: [0.204, 0.204) || 挂载数据: 无 ) 
│   │   │   ├── 网络原理 --> ( 难度等级: [0.204, 0.2042) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes网络模型 --> ( 难度等级: [0.204, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker的网络基础 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker的网络实现 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes的网络实现 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 单主机Docker网络通信 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Host模式 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Container模式 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── None模式 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── Bridge模式 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 基础网络模型的优缺点分析 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │   └── 跨主机Docker网络通信 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   │       ├── Flannel网络方案 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: blog: 1 ) 
│   │   │   │   │       ├── Calico网络方案 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: blog: 9 ) 
│   │   │   │   │       └── 网络方案对比分析 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   ├── CNI网络模型 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes网络策略 --> ( 难度等级: [0.2041, 0.2041) || 挂载数据: 无 ) 
│   │   │   │   └── 开源的网络组件 --> ( 难度等级: [0.2041, 0.2042) || 挂载数据: 无 ) 
│   │   │   └── 共享存储原理 --> ( 难度等级: [0.2042, 0.2043) || 挂载数据: 无 ) 
│   │   │       ├── 共享存储机制概述 --> ( 难度等级: [0.2042, 0.2042) || 挂载数据: 无 ) 
│   │   │       ├── PV详解 --> ( 难度等级: [0.2042, 0.2042) || 挂载数据: 无 ) 
│   │   │       ├── PVC详解 --> ( 难度等级: [0.2042, 0.2042) || 挂载数据: 无 ) 
│   │   │       ├── PV和PVC的生命周期 --> ( 难度等级: [0.2042, 0.2043) || 挂载数据: 无 ) 
│   │   │       └── StorageClass详解 --> ( 难度等级: [0.2043, 0.2043) || 挂载数据: 无 ) 
│   │   ├── Kubernetes开发指南 --> ( 难度等级: [0.2043, 0.2054) || 挂载数据: 无 ) 
│   │   │   ├── REST简述 --> ( 难度等级: [0.2043, 0.2047) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes API详解 --> ( 难度等级: [0.2047, 0.205) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes API概述 --> ( 难度等级: [0.2047, 0.2047) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── API版本 --> ( 难度等级: [0.2047, 0.2048) || 挂载数据: 无 ) 
│   │   │   │   ├── API Groups（API组） --> ( 难度等级: [0.2048, 0.2049) || 挂载数据: 无 ) 
│   │   │   │   ├── API方法说明 --> ( 难度等级: [0.2049, 0.2049) || 挂载数据: blog: 2 ) 
│   │   │   │   └── API响应说明 --> ( 难度等级: [0.2049, 0.205) || 挂载数据: blog: 1 ) 
│   │   │   └── 使用Java程序访问Kubernetes API --> ( 难度等级: [0.205, 0.2054) || 挂载数据: blog: 11 ) 
│   │   │       ├── Jersey --> ( 难度等级: [0.205, 0.2051) || 挂载数据: blog: 2 ) 
│   │   │       ├── Fabric8 --> ( 难度等级: [0.2051, 0.2053) || 挂载数据: 无 ) 
│   │   │       └── 使用说明 --> ( 难度等级: [0.2053, 0.2054) || 挂载数据: 无 ) 
│   │   ├── Kubernetes运维指南 --> ( 难度等级: [0.2054, 0.2065) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes集群管理指南 --> ( 难度等级: [0.2054, 0.2057) || 挂载数据: 无 ) 
│   │   │   │   ├── Node的管理 --> ( 难度等级: [0.2054, 0.2054) || 挂载数据: 无 ) 
│   │   │   │   ├── 更新资源对象的Label --> ( 难度等级: [0.2054, 0.2054) || 挂载数据: 无 ) 
│   │   │   │   ├── Namespace：集群环境共享与隔离 --> ( 难度等级: [0.2054, 0.2055) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes资源管理 --> ( 难度等级: [0.2055, 0.2055) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── 资源紧缺时的Pod驱逐机制 --> ( 难度等级: [0.2055, 0.2055) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod Disruption Budget（主动驱逐保护） --> ( 难度等级: [0.2055, 0.2056) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes集群的高可用部署方案 --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── Kubernetes集群监控 --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: blog: 36 ) 
│   │   │   │   │   ├── Weave Scope --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: 无 ) 
│   │   │   │   │   │   ├── 安装Scope --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: 无 ) 
│   │   │   │   │   │   └── 使用Scope --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Heapster --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: blog: 6 ) 
│   │   │   │   │   │   └── 使用 --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: 无 ) 
│   │   │   │   │   └── Prometheus Operator --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: 无 ) 
│   │   │   │   │       ├── Prometheus架构 --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: blog: 25 ) 
│   │   │   │   │       ├── Prometheus Operator架构 --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: blog: 4 ) 
│   │   │   │   │       └── 部署Prometheus Operator --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 集群统一日志管理 --> ( 难度等级: [0.2056, 0.2056) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes审计日志（Audit Log） --> ( 难度等级: [0.2056, 0.2057) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用Web UI（Dashboard）管理集群 --> ( 难度等级: [0.2057, 0.2057) || 挂载数据: blog: 11 ) 
│   │   │   │   └── Helm：Kubernetes应用包管理工具 --> ( 难度等级: [0.2057, 0.2057) || 挂载数据: blog: 8 ) 
│   │   │   ├── Trouble Shooting指导 --> ( 难度等级: [0.2057, 0.2061) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看系统Event事件 --> ( 难度等级: [0.2057, 0.2058) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看容器日志 --> ( 难度等级: [0.2058, 0.2059) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看Kubernetes服务日志 --> ( 难度等级: [0.2059, 0.206) || 挂载数据: 无 ) 
│   │   │   │   └── 寻求帮助 --> ( 难度等级: [0.206, 0.2061) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes开发中的新功能 --> ( 难度等级: [0.2061, 0.2065) || 挂载数据: 无 ) 
│   │   │       ├── Pod Preset（运行时参数注入策略） --> ( 难度等级: [0.2061, 0.2062) || 挂载数据: 无 ) 
│   │   │       ├── Cluster Federation（集群联邦） --> ( 难度等级: [0.2062, 0.2062) || 挂载数据: 无 ) 
│   │   │       ├── 容器运行时接口（Container Runtime Interface-CRI） --> ( 难度等级: [0.2062, 0.2063) || 挂载数据: blog: 3 ) 
│   │   │       ├── 对GPU的支持 --> ( 难度等级: [0.2063, 0.2064) || 挂载数据: 无 ) 
│   │   │       └── Kubernetes的演进路线（Roadmap）和开发模式 --> ( 难度等级: [0.2064, 0.2065) || 挂载数据: blog: 1 ) 
│   │   ├── Kubernetes源码导读 --> ( 难度等级: [0.2065, 0.2075) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes源码结构和编译步骤 --> ( 难度等级: [0.2065, 0.2066) || 挂载数据: 无 ) 
│   │   │   ├── kube-apiserver进程源码分析 --> ( 难度等级: [0.2066, 0.2068) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.2066, 0.2067) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.2067, 0.2068) || 挂载数据: 无 ) 
│   │   │   ├── kube-controller-manager进程源码分析 --> ( 难度等级: [0.2068, 0.2069) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.2068, 0.2068) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.2068, 0.2069) || 挂载数据: 无 ) 
│   │   │   ├── kube-scheduler进程源码分析 --> ( 难度等级: [0.2069, 0.2071) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.2069, 0.207) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.207, 0.2071) || 挂载数据: 无 ) 
│   │   │   ├── kubelet进程源码分析 --> ( 难度等级: [0.2071, 0.2072) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.2071, 0.2071) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.2071, 0.2072) || 挂载数据: 无 ) 
│   │   │   ├── kube-proxy进程源码分析 --> ( 难度等级: [0.2072, 0.2074) || 挂载数据: 无 ) 
│   │   │   │   ├── 进程启动过程 --> ( 难度等级: [0.2072, 0.2073) || 挂载数据: 无 ) 
│   │   │   │   └── 关键代码分析 --> ( 难度等级: [0.2073, 0.2074) || 挂载数据: 无 ) 
│   │   │   └── kubectl进程源码分析 --> ( 难度等级: [0.2074, 0.2075) || 挂载数据: 无 ) 
│   │   │       ├── kubectl create命令 --> ( 难度等级: [0.2074, 0.2075) || 挂载数据: blog: 3 ) 
│   │   │       └── rolling-update命令 --> ( 难度等级: [0.2075, 0.2075) || 挂载数据: 无 ) 
│   │   ├── 先把Kubernetes跑起来 --> ( 难度等级: [0.2075, 0.2086) || 挂载数据: 无 ) 
│   │   │   ├── 先跑起来 --> ( 难度等级: [0.2075, 0.2077) || 挂载数据: 无 ) 
│   │   │   ├── 创建Kubernetes集群 --> ( 难度等级: [0.2077, 0.2079) || 挂载数据: 无 ) 
│   │   │   ├── 部署应用 --> ( 难度等级: [0.2079, 0.2081) || 挂载数据: 无 ) 
│   │   │   ├── 访问应用 --> ( 难度等级: [0.2081, 0.2082) || 挂载数据: 无 ) 
│   │   │   ├── Scale应用 --> ( 难度等级: [0.2082, 0.2084) || 挂载数据: 无 ) 
│   │   │   └── 滚动更新 --> ( 难度等级: [0.2084, 0.2086) || 挂载数据: 无 ) 
│   │   ├── 重要概念 --> ( 难度等级: [0.2086, 0.2097) || 挂载数据: 无 ) 
│   │   ├── 部署Kubernetes Cluster --> ( 难度等级: [0.2097, 0.2108) || 挂载数据: 无 ) 
│   │   │   ├── 安装Docker --> ( 难度等级: [0.2097, 0.21) || 挂载数据: 无 ) 
│   │   │   │   ├── 手动安装模式 --> ( 难度等级: [0.2097, 0.2098) || 挂载数据: 无 ) 
│   │   │   │   ├── Ubuntu中自动化安装Docker --> ( 难度等级: [0.2098, 0.2099) || 挂载数据: 无 ) 
│   │   │   │   └── CentOS中自动化安装Docker --> ( 难度等级: [0.2099, 0.21) || 挂载数据: blog: 2 ) 
│   │   │   ├── 安装kubelet、kubeadm和kubectl --> ( 难度等级: [0.21, 0.2104) || 挂载数据: 无 ) 
│   │   │   └── 用kubeadm创建Cluster --> ( 难度等级: [0.2104, 0.2108) || 挂载数据: blog: 1 ) 
│   │   │       ├── 初始化Master --> ( 难度等级: [0.2104, 0.2105) || 挂载数据: 无 ) 
│   │   │       ├── 配置kubectl --> ( 难度等级: [0.2105, 0.2106) || 挂载数据: 无 ) 
│   │   │       ├── 安装Pod网络 --> ( 难度等级: [0.2106, 0.2107) || 挂载数据: 无 ) 
│   │   │       └── 添加k8s-node1 和k8s-node2 --> ( 难度等级: [0.2107, 0.2108) || 挂载数据: 无 ) 
│   │   ├── Kubernetes架构 --> ( 难度等级: [0.2108, 0.2118) || 挂载数据: 无 ) 
│   │   │   ├── Master节点 --> ( 难度等级: [0.2108, 0.211) || 挂载数据: 无 ) 
│   │   │   ├── Node节点 --> ( 难度等级: [0.211, 0.2113) || 挂载数据: blog: 1 ) 
│   │   │   ├── 完整的架构图 --> ( 难度等级: [0.2113, 0.2116) || 挂载数据: 无 ) 
│   │   │   └── 用例子把它们串起来 --> ( 难度等级: [0.2116, 0.2118) || 挂载数据: 无 ) 
│   │   ├── 运行应用 --> ( 难度等级: [0.2118, 0.2129) || 挂载数据: 无 ) 
│   │   │   ├── DaemonSet --> ( 难度等级: [0.2118, 0.2124) || 挂载数据: 无 ) 
│   │   │   │   ├── kube-flannel-ds --> ( 难度等级: [0.2118, 0.212) || 挂载数据: 无 ) 
│   │   │   │   ├── kube-proxy --> ( 难度等级: [0.212, 0.2122) || 挂载数据: 无 ) 
│   │   │   │   └── 运行自己的DaemonSet --> ( 难度等级: [0.2122, 0.2124) || 挂载数据: 无 ) 
│   │   │   └── Job --> ( 难度等级: [0.2124, 0.2129) || 挂载数据: 无 ) 
│   │   │       ├── Pod失败的情况 --> ( 难度等级: [0.2124, 0.2125) || 挂载数据: 无 ) 
│   │   │       ├── Job的并行性 --> ( 难度等级: [0.2125, 0.2127) || 挂载数据: blog: 2 ) 
│   │   │       └── 定时Job --> ( 难度等级: [0.2127, 0.2129) || 挂载数据: 无 ) 
│   │   ├── 通过Service访问Pod --> ( 难度等级: [0.2129, 0.214) || 挂载数据: 无 ) 
│   │   │   ├── 创建Service --> ( 难度等级: [0.2129, 0.2132) || 挂载数据: 无 ) 
│   │   │   ├── Cluster IP底层实现 --> ( 难度等级: [0.2132, 0.2134) || 挂载数据: blog: 2 ) 
│   │   │   ├── DNS访问Service --> ( 难度等级: [0.2134, 0.2137) || 挂载数据: 无 ) 
│   │   │   └── 外网如何访问Service --> ( 难度等级: [0.2137, 0.214) || 挂载数据: 无 ) 
│   │   ├── Rolling Update --> ( 难度等级: [0.214, 0.2151) || 挂载数据: 无 ) 
│   │   │   └── 实践 --> ( 难度等级: [0.214, 0.2151) || 挂载数据: 无 ) 
│   │   ├── Health Check --> ( 难度等级: [0.2151, 0.2161) || 挂载数据: 无 ) 
│   │   │   ├── 默认的健康检查 --> ( 难度等级: [0.2151, 0.2153) || 挂载数据: 无 ) 
│   │   │   ├── Liveness探测 --> ( 难度等级: [0.2153, 0.2155) || 挂载数据: 无 ) 
│   │   │   ├── Readiness探测 --> ( 难度等级: [0.2155, 0.2157) || 挂载数据: 无 ) 
│   │   │   ├── Health Check在Scale Up中的应用 --> ( 难度等级: [0.2157, 0.2159) || 挂载数据: blog: 2 ) 
│   │   │   └── Health Check在滚动更新中的应用 --> ( 难度等级: [0.2159, 0.2161) || 挂载数据: 无 ) 
│   │   ├── 数据管理 --> ( 难度等级: [0.2161, 0.2172) || 挂载数据: 无 ) 
│   │   │   ├── Volume --> ( 难度等级: [0.2161, 0.2165) || 挂载数据: 无 ) 
│   │   │   │   ├── emptyDir --> ( 难度等级: [0.2161, 0.2162) || 挂载数据: 无 ) 
│   │   │   │   ├── hostPath --> ( 难度等级: [0.2162, 0.2164) || 挂载数据: 无 ) 
│   │   │   │   └── 外部Storage Provider --> ( 难度等级: [0.2164, 0.2165) || 挂载数据: 无 ) 
│   │   │   ├── PersistentVolume & PersistentVolumeClaim --> ( 难度等级: [0.2165, 0.2168) || 挂载数据: 无 ) 
│   │   │   │   ├── NFS PersistentVolume --> ( 难度等级: [0.2165, 0.2166) || 挂载数据: 无 ) 
│   │   │   │   ├── 回收PV --> ( 难度等级: [0.2166, 0.2167) || 挂载数据: 无 ) 
│   │   │   │   └── PV动态供给 --> ( 难度等级: [0.2167, 0.2168) || 挂载数据: 无 ) 
│   │   │   └── 一个数据库例子 --> ( 难度等级: [0.2168, 0.2172) || 挂载数据: 无 ) 
│   │   ├── Secret & Configmap --> ( 难度等级: [0.2172, 0.2183) || 挂载数据: 无 ) 
│   │   │   ├── 创建Secret --> ( 难度等级: [0.2172, 0.2175) || 挂载数据: 无 ) 
│   │   │   ├── 查看Secret --> ( 难度等级: [0.2175, 0.2177) || 挂载数据: 无 ) 
│   │   │   ├── 在Pod中使用Secret --> ( 难度等级: [0.2177, 0.218) || 挂载数据: 无 ) 
│   │   │   │   ├── Volume方式 --> ( 难度等级: [0.2177, 0.2179) || 挂载数据: 无 ) 
│   │   │   │   └── 环境变量方式 --> ( 难度等级: [0.2179, 0.218) || 挂载数据: 无 ) 
│   │   │   └── ConfigMap --> ( 难度等级: [0.218, 0.2183) || 挂载数据: 无 ) 
│   │   ├── Helm—Kubernetes的包管理器 --> ( 难度等级: [0.2183, 0.2194) || 挂载数据: 无 ) 
│   │   │   ├── Why Helm --> ( 难度等级: [0.2183, 0.2185) || 挂载数据: 无 ) 
│   │   │   ├── Helm架构 --> ( 难度等级: [0.2185, 0.2188) || 挂载数据: 无 ) 
│   │   │   ├── 安装Helm --> ( 难度等级: [0.2188, 0.2191) || 挂载数据: 无 ) 
│   │   │   │   ├── Helm客户端 --> ( 难度等级: [0.2188, 0.219) || 挂载数据: blog: 3 ) 
│   │   │   │   └── Tiller服务器 --> ( 难度等级: [0.219, 0.2191) || 挂载数据: 无 ) 
│   │   │   └── chart详解 --> ( 难度等级: [0.2191, 0.2194) || 挂载数据: 无 ) 
│   │   │       ├── chart目录结构 --> ( 难度等级: [0.2191, 0.2191) || 挂载数据: blog: 1 ) 
│   │   │       ├── chart模板 --> ( 难度等级: [0.2191, 0.2192) || 挂载数据: 无 ) 
│   │   │       ├── 再次实践MySQL chart --> ( 难度等级: [0.2192, 0.2192) || 挂载数据: blog: 1 ) 
│   │   │       ├── 升级和回滚release --> ( 难度等级: [0.2192, 0.2193) || 挂载数据: 无 ) 
│   │   │       └── 开发自己的chart --> ( 难度等级: [0.2193, 0.2194) || 挂载数据: 无 ) 
│   │   ├── 网络 --> ( 难度等级: [0.2194, 0.2204) || 挂载数据: 无 ) 
│   │   │   ├── 各种网络方案 --> ( 难度等级: [0.2194, 0.2199) || 挂载数据: 无 ) 
│   │   │   └── Network Policy --> ( 难度等级: [0.2199, 0.2204) || 挂载数据: 无 ) 
│   │   │       ├── 部署Canal --> ( 难度等级: [0.2199, 0.2202) || 挂载数据: 无 ) 
│   │   │       └── 实践Network Policy --> ( 难度等级: [0.2202, 0.2204) || 挂载数据: blog: 3 ) 
│   │   ├── Kubernetes Dashboard --> ( 难度等级: [0.2204, 0.2215) || 挂载数据: 无 ) 
│   │   │   ├── 安装 --> ( 难度等级: [0.2204, 0.2207) || 挂载数据: 无 ) 
│   │   │   ├── 配置登录权限 --> ( 难度等级: [0.2207, 0.221) || 挂载数据: 无 ) 
│   │   │   ├── Dashboard界面结构 --> ( 难度等级: [0.221, 0.2212) || 挂载数据: blog: 7 ) 
│   │   │   └── 典型使用场景 --> ( 难度等级: [0.2212, 0.2215) || 挂载数据: 无 ) 
│   │   │       ├── 部署Deployment --> ( 难度等级: [0.2212, 0.2213) || 挂载数据: 无 ) 
│   │   │       ├── 在线操作 --> ( 难度等级: [0.2213, 0.2214) || 挂载数据: blog: 1 ) 
│   │   │       ├── 查看资源详细信息 --> ( 难度等级: [0.2214, 0.2214) || 挂载数据: 无 ) 
│   │   │       └── 查看Pod日志 --> ( 难度等级: [0.2214, 0.2215) || 挂载数据: 无 ) 
│   │   ├── Kubernetes集群日志管理 --> ( 难度等级: [0.2215, 0.2226) || 挂载数据: 无 ) 
│   │   ├── Docker简介 --> ( 难度等级: [0.2226, 0.2237) || 挂载数据: 无 ) 
│   │   │   ├── 什么是Docker --> ( 难度等级: [0.2226, 0.2229) || 挂载数据: 无 ) 
│   │   │   ├── Docker基本概念 --> ( 难度等级: [0.2229, 0.2233) || 挂载数据: 无 ) 
│   │   │   │   ├── 镜像 --> ( 难度等级: [0.2229, 0.2231) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器 --> ( 难度等级: [0.2231, 0.2232) || 挂载数据: 无 ) 
│   │   │   │   └── 镜像仓库 --> ( 难度等级: [0.2232, 0.2233) || 挂载数据: 无 ) 
│   │   │   └── Docker架构及原理 --> ( 难度等级: [0.2233, 0.2237) || 挂载数据: 无 ) 
│   │   │       ├── Docker架构 --> ( 难度等级: [0.2233, 0.2234) || 挂载数据: 无 ) 
│   │   │       ├── Docker原理 --> ( 难度等级: [0.2234, 0.2235) || 挂载数据: 无 ) 
│   │   │       ├── 容器网络 --> ( 难度等级: [0.2235, 0.2236) || 挂载数据: 无 ) 
│   │   │       └── 容器存储 --> ( 难度等级: [0.2236, 0.2237) || 挂载数据: 无 ) 
│   │   ├── 容器引擎 --> ( 难度等级: [0.2237, 0.2247) || 挂载数据: 无 ) 
│   │   │   ├── 容器引擎实现原理 --> ( 难度等级: [0.2237, 0.2239) || 挂载数据: 无 ) 
│   │   │   ├── 容器生命周期管理 --> ( 难度等级: [0.2239, 0.2241) || 挂载数据: 无 ) 
│   │   │   ├── 容器状态管理 --> ( 难度等级: [0.2241, 0.2243) || 挂载数据: 无 ) 
│   │   │   ├── 访问运行状态容器 --> ( 难度等级: [0.2243, 0.2245) || 挂载数据: 无 ) 
│   │   │   └── 访问容器内容 --> ( 难度等级: [0.2245, 0.2247) || 挂载数据: 无 ) 
│   │   ├── 镜像管理 --> ( 难度等级: [0.2247, 0.2258) || 挂载数据: 无 ) 
│   │   │   ├── Dockerfile及镜像制作 --> ( 难度等级: [0.2247, 0.2249) || 挂载数据: 无 ) 
│   │   │   │   ├── Dockerfile的作用 --> ( 难度等级: [0.2247, 0.2248) || 挂载数据: 无 ) 
│   │   │   │   ├── Dockerfile文件构成 --> ( 难度等级: [0.2248, 0.2248) || 挂载数据: blog: 13 ) 
│   │   │   │   ├── 常用命令集 --> ( 难度等级: [0.2248, 0.2249) || 挂载数据: 无 ) 
│   │   │   │   └── 构建镜像 --> ( 难度等级: [0.2249, 0.2249) || 挂载数据: blog: 1 ) 
│   │   │   ├── 镜像基本操作 --> ( 难度等级: [0.2249, 0.2252) || 挂载数据: 无 ) 
│   │   │   │   ├── 从镜像仓库下载镜像 --> ( 难度等级: [0.2249, 0.225) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 将本地镜像上传到镜像仓库 --> ( 难度等级: [0.225, 0.225) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 查看本地镜像 --> ( 难度等级: [0.225, 0.225) || 挂载数据: 无 ) 
│   │   │   │   ├── 导出和导入本地镜像 --> ( 难度等级: [0.225, 0.2251) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建镜像 --> ( 难度等级: [0.2251, 0.2251) || 挂载数据: 无 ) 
│   │   │   │   ├── 修改本地镜像标识 --> ( 难度等级: [0.2251, 0.2251) || 挂载数据: 无 ) 
│   │   │   │   └── 删除本地镜像 --> ( 难度等级: [0.2251, 0.2252) || 挂载数据: blog: 3 ) 
│   │   │   ├── Dockerfile优化 --> ( 难度等级: [0.2252, 0.2254) || 挂载数据: 无 ) 
│   │   │   │   ├── Dockerfile检查项 --> ( 难度等级: [0.2252, 0.2253) || 挂载数据: 无 ) 
│   │   │   │   └── 检查及优化工具 --> ( 难度等级: [0.2253, 0.2254) || 挂载数据: 无 ) 
│   │   │   ├── 操作系统基础镜像制作 --> ( 难度等级: [0.2254, 0.2256) || 挂载数据: 无 ) 
│   │   │   │   ├── 操作系统版本选择 --> ( 难度等级: [0.2254, 0.2254) || 挂载数据: 无 ) 
│   │   │   │   ├── 操作系统参数调整 --> ( 难度等级: [0.2254, 0.2254) || 挂载数据: 无 ) 
│   │   │   │   ├── 确定基础rpm包范围 --> ( 难度等级: [0.2254, 0.2255) || 挂载数据: 无 ) 
│   │   │   │   ├── 确定常用命令范围 --> ( 难度等级: [0.2255, 0.2255) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 操作系统镜像制作过程 --> ( 难度等级: [0.2255, 0.2256) || 挂载数据: blog: 4 ) 
│   │   │   │   └── 系统资源限制配置说明 --> ( 难度等级: [0.2256, 0.2256) || 挂载数据: 无 ) 
│   │   │   └── 容器镜像安全加固 --> ( 难度等级: [0.2256, 0.2258) || 挂载数据: 无 ) 
│   │   │       ├── 容器安全加固规范 --> ( 难度等级: [0.2256, 0.2257) || 挂载数据: 无 ) 
│   │   │       └── 安全检查工具 --> ( 难度等级: [0.2257, 0.2258) || 挂载数据: 无 ) 
│   │   ├── 镜像仓库管理 --> ( 难度等级: [0.2258, 0.2269) || 挂载数据: 无 ) 
│   │   │   ├── Docker Registry --> ( 难度等级: [0.2258, 0.2263) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker Hub --> ( 难度等级: [0.2258, 0.226) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 第三方公共仓库 --> ( 难度等级: [0.226, 0.2262) || 挂载数据: 无 ) 
│   │   │   │   └── 建立私有镜像仓库 --> ( 难度等级: [0.2262, 0.2263) || 挂载数据: 无 ) 
│   │   │   └── Harbor --> ( 难度等级: [0.2263, 0.2269) || 挂载数据: 无 ) 
│   │   │       ├── Harbor架构 --> ( 难度等级: [0.2263, 0.2265) || 挂载数据: blog: 4 ) 
│   │   │       ├── Harbor的镜像同步机制 --> ( 难度等级: [0.2265, 0.2266) || 挂载数据: 无 ) 
│   │   │       ├── Harbor用户认证 --> ( 难度等级: [0.2266, 0.2267) || 挂载数据: 无 ) 
│   │   │       └── Harbor容器镜像安全扫描 --> ( 难度等级: [0.2267, 0.2269) || 挂载数据: blog: 1 ) 
│   │   ├── Docker相关部署实践 --> ( 难度等级: [0.2269, 0.228) || 挂载数据: 无 ) 
│   │   │   ├── MySQL Docker部署实践 --> ( 难度等级: [0.2269, 0.2274) || 挂载数据: 无 ) 
│   │   │   │   ├── MySQL简介 --> ( 难度等级: [0.2269, 0.2272) || 挂载数据: blog: 56 ) 
│   │   │   │   └── MySQL容器化操作实践 --> ( 难度等级: [0.2272, 0.2274) || 挂载数据: blog: 2 ) 
│   │   │   └── Docker支持GPU实践 --> ( 难度等级: [0.2274, 0.228) || 挂载数据: 无 ) 
│   │   │       ├── GPU简介 --> ( 难度等级: [0.2274, 0.2276) || 挂载数据: 无 ) 
│   │   │       ├── CPU与GPU的对比 --> ( 难度等级: [0.2276, 0.2278) || 挂载数据: blog: 2 ) 
│   │   │       └── 通过nvidia-docker使用GPU --> ( 难度等级: [0.2278, 0.228) || 挂载数据: blog: 1 ) 
│   │   ├── Kubernetes简介 --> ( 难度等级: [0.228, 0.229) || 挂载数据: 无 ) 
│   │   │   ├── PaaS简介 --> ( 难度等级: [0.228, 0.2285) || 挂载数据: 无 ) 
│   │   │   │   ├── 传统PaaS系统 --> ( 难度等级: [0.228, 0.2282) || 挂载数据: blog: 154 ) 
│   │   │   │   └── 基于Docker的新型PaaS平台 --> ( 难度等级: [0.2282, 0.2285) || 挂载数据: blog: 44 ) 
│   │   │   └── Kubernetes核心概念 --> ( 难度等级: [0.2285, 0.229) || 挂载数据: 无 ) 
│   │   ├── Pod相关核心技术 --> ( 难度等级: [0.229, 0.2301) || 挂载数据: 无 ) 
│   │   │   ├── Label --> ( 难度等级: [0.229, 0.2296) || 挂载数据: 无 ) 
│   │   │   └── 健康检查 --> ( 难度等级: [0.2296, 0.2301) || 挂载数据: 无 ) 
│   │   │       ├── 流程健康检查 --> ( 难度等级: [0.2296, 0.2298) || 挂载数据: 无 ) 
│   │   │       └── 应用健康检查 --> ( 难度等级: [0.2298, 0.2301) || 挂载数据: 无 ) 
│   │   ├── Kubernetes Service --> ( 难度等级: [0.2301, 0.2312) || 挂载数据: 无 ) 
│   │   │   ├── DNS服务发现机制 --> ( 难度等级: [0.2301, 0.2303) || 挂载数据: 无 ) 
│   │   │   ├── Headless服务 --> ( 难度等级: [0.2303, 0.2305) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes服务 --> ( 难度等级: [0.2305, 0.2308) || 挂载数据: 无 ) 
│   │   │   │   ├── ClusterIP --> ( 难度等级: [0.2305, 0.2306) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── NodePort --> ( 难度等级: [0.2306, 0.2307) || 挂载数据: blog: 1 ) 
│   │   │   │   └── LoadBalancer --> ( 难度等级: [0.2307, 0.2308) || 挂载数据: 无 ) 
│   │   │   ├── 网络策略 --> ( 难度等级: [0.2308, 0.231) || 挂载数据: 无 ) 
│   │   │   └── 完整的Kubernetes服务发布实践 --> ( 难度等级: [0.231, 0.2312) || 挂载数据: 无 ) 
│   │   │       ├── 各Kubernetes集群 --> ( 难度等级: [0.231, 0.231) || 挂载数据: blog: 40 ) 
│   │   │       ├── Ingress服务发布 --> ( 难度等级: [0.231, 0.2311) || 挂载数据: blog: 1 ) 
│   │   │       └── 服务发现 --> ( 难度等级: [0.2311, 0.2312) || 挂载数据: 无 ) 
│   │   ├── Kubernetes存储 --> ( 难度等级: [0.2312, 0.2323) || 挂载数据: 无 ) 
│   │   │   ├── 存储使用场景 --> ( 难度等级: [0.2312, 0.2315) || 挂载数据: 无 ) 
│   │   │   ├── 文件存储的几种形式 --> ( 难度等级: [0.2315, 0.2317) || 挂载数据: 无 ) 
│   │   │   ├── Flex Volume存储管理方案 --> ( 难度等级: [0.2317, 0.232) || 挂载数据: 无 ) 
│   │   │   │   └── 如何实现灵活存储组件 --> ( 难度等级: [0.2317, 0.232) || 挂载数据: 无 ) 
│   │   │   └── 标准化容器存储接口CSI --> ( 难度等级: [0.232, 0.2323) || 挂载数据: 无 ) 
│   │   └── 安全及多租户配额管理 --> ( 难度等级: [0.2323, 0.2333) || 挂载数据: 无 ) 
│   │       └── API服务器认证 --> ( 难度等级: [0.2323, 0.2333) || 挂载数据: 无 ) 
│   ├── DevOps --> ( 难度等级: [0.2333, 0.2667) || 挂载数据: 无 ) 
│   │   ├── 应用中心 --> ( 难度等级: [0.2333, 0.2353) || 挂载数据: 无 ) 
│   │   │   ├── Helm Hub --> ( 难度等级: [0.2333, 0.2337) || 挂载数据: 无 ) 
│   │   │   ├── Operator Hub --> ( 难度等级: [0.2337, 0.2341) || 挂载数据: 无 ) 
│   │   │   ├── Aliyun App Hub --> ( 难度等级: [0.2341, 0.2345) || 挂载数据: blog: 7 ) 
│   │   │   ├── Kubernetes App Hub --> ( 难度等级: [0.2345, 0.2349) || 挂载数据: 无 ) 
│   │   │   └── Prometheus Exporter Hub --> ( 难度等级: [0.2349, 0.2353) || 挂载数据: 无 ) 
│   │   ├── 运维 --> ( 难度等级: [0.2353, 0.2373) || 挂载数据: 无 ) 
│   │   │   └── 模板 --> ( 难度等级: [0.2353, 0.2373) || 挂载数据: 无 ) 
│   │   │       ├── YAML --> ( 难度等级: [0.2353, 0.2356) || 挂载数据: 无 ) 
│   │   │       ├── Helm --> ( 难度等级: [0.2356, 0.2359) || 挂载数据: 无 ) 
│   │   │       ├── KUDO(Kubernetes Universal Declarative Operator) --> ( 难度等级: [0.2359, 0.2363) || 挂载数据: 无 ) 
│   │   │       ├── OAM(Open Application Model) --> ( 难度等级: [0.2363, 0.2366) || 挂载数据: 无 ) 
│   │   │       ├── OpenKruise --> ( 难度等级: [0.2366, 0.2369) || 挂载数据: 无 ) 
│   │   │       └── MetaController --> ( 难度等级: [0.2369, 0.2373) || 挂载数据: 无 ) 
│   │   ├── 监控 --> ( 难度等级: [0.2373, 0.2392) || 挂载数据: 无 ) 
│   │   │   ├── Prometheus --> ( 难度等级: [0.2373, 0.2379) || 挂载数据: 无 ) 
│   │   │   ├── Grafana --> ( 难度等级: [0.2379, 0.2386) || 挂载数据: 无 ) 
│   │   │   └── Alertmanager --> ( 难度等级: [0.2386, 0.2392) || 挂载数据: 无 ) 
│   │   ├── CI/CD --> ( 难度等级: [0.2392, 0.2412) || 挂载数据: blog: 2 ) 
│   │   │   ├── Jenkins --> ( 难度等级: [0.2392, 0.2397) || 挂载数据: blog: 2 ) 
│   │   │   ├── Argo --> ( 难度等级: [0.2397, 0.2402) || 挂载数据: 无 ) 
│   │   │   ├── Tekton --> ( 难度等级: [0.2402, 0.2407) || 挂载数据: 无 ) 
│   │   │   └── Drone --> ( 难度等级: [0.2407, 0.2412) || 挂载数据: blog: 1 ) 
│   │   ├── 日志 --> ( 难度等级: [0.2412, 0.2431) || 挂载数据: 无 ) 
│   │   │   ├── ELK --> ( 难度等级: [0.2412, 0.2418) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── ElasticSearch --> ( 难度等级: [0.2412, 0.2414) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── Logstash --> ( 难度等级: [0.2414, 0.2416) || 挂载数据: 无 ) 
│   │   │   │   └── Kibana --> ( 难度等级: [0.2416, 0.2418) || 挂载数据: blog: 1 ) 
│   │   │   ├── EFK --> ( 难度等级: [0.2418, 0.2425) || 挂载数据: 无 ) 
│   │   │   │   ├── ElasticSearch --> ( 难度等级: [0.2418, 0.242) || 挂载数据: 无 ) 
│   │   │   │   ├── Fluentd --> ( 难度等级: [0.242, 0.2423) || 挂载数据: 无 ) 
│   │   │   │   └── Kibana --> ( 难度等级: [0.2423, 0.2425) || 挂载数据: 无 ) 
│   │   │   └── Loki --> ( 难度等级: [0.2425, 0.2431) || 挂载数据: 无 ) 
│   │   │       ├── Loki --> ( 难度等级: [0.2425, 0.2427) || 挂载数据: 无 ) 
│   │   │       ├── Promtail --> ( 难度等级: [0.2427, 0.2429) || 挂载数据: 无 ) 
│   │   │       └── Grafana --> ( 难度等级: [0.2429, 0.2431) || 挂载数据: 无 ) 
│   │   ├── 采集 --> ( 难度等级: [0.2431, 0.2451) || 挂载数据: 无 ) 
│   │   │   ├── Logpilot --> ( 难度等级: [0.2431, 0.2438) || 挂载数据: 无 ) 
│   │   │   ├── Fluentbit --> ( 难度等级: [0.2438, 0.2444) || 挂载数据: 无 ) 
│   │   │   └── Fluentd --> ( 难度等级: [0.2444, 0.2451) || 挂载数据: 无 ) 
│   │   ├── DevOps介绍 --> ( 难度等级: [0.2451, 0.2471) || 挂载数据: 无 ) 
│   │   │   ├── 敏捷、持续交付和三步法 --> ( 难度等级: [0.2451, 0.2456) || 挂载数据: 无 ) 
│   │   │   │   ├── 制造业价值流 --> ( 难度等级: [0.2451, 0.2453) || 挂载数据: 无 ) 
│   │   │   │   ├── 技术价值流 --> ( 难度等级: [0.2453, 0.2454) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 聚焦于部署前置时间 --> ( 难度等级: [0.2453, 0.2453) || 挂载数据: 无 ) 
│   │   │   │   │   └── 关注返工指标——%C/A --> ( 难度等级: [0.2453, 0.2454) || 挂载数据: 无 ) 
│   │   │   │   └── 三步工作法：DevOps的基础原则 --> ( 难度等级: [0.2454, 0.2456) || 挂载数据: blog: 21 ) 
│   │   │   ├── 第一步：流动原则 --> ( 难度等级: [0.2456, 0.2461) || 挂载数据: 无 ) 
│   │   │   │   ├── 使工作可见 --> ( 难度等级: [0.2456, 0.2457) || 挂载数据: 无 ) 
│   │   │   │   ├── 限制在制品数 --> ( 难度等级: [0.2457, 0.2458) || 挂载数据: 无 ) 
│   │   │   │   ├── 减小批量大小 --> ( 难度等级: [0.2458, 0.2458) || 挂载数据: 无 ) 
│   │   │   │   ├── 减少交接次数 --> ( 难度等级: [0.2458, 0.2459) || 挂载数据: 无 ) 
│   │   │   │   ├── 持续识别和改善约束点 --> ( 难度等级: [0.2459, 0.246) || 挂载数据: 无 ) 
│   │   │   │   └── 消除价值流中的困境和浪费 --> ( 难度等级: [0.246, 0.2461) || 挂载数据: 无 ) 
│   │   │   ├── 第二步：反馈原则 --> ( 难度等级: [0.2461, 0.2466) || 挂载数据: 无 ) 
│   │   │   │   ├── 在复杂系统中安全地工作 --> ( 难度等级: [0.2461, 0.2462) || 挂载数据: 无 ) 
│   │   │   │   ├── 在源头保障质量 --> ( 难度等级: [0.2462, 0.2464) || 挂载数据: 无 ) 
│   │   │   │   └── 为下游工作中心而优化 --> ( 难度等级: [0.2464, 0.2466) || 挂载数据: 无 ) 
│   │   │   └── 第三步：持续学习与实验原则 --> ( 难度等级: [0.2466, 0.2471) || 挂载数据: 无 ) 
│   │   │       ├── 建立学习型组织和安全文化 --> ( 难度等级: [0.2466, 0.2467) || 挂载数据: 无 ) 
│   │   │       ├── 将日常工作的改进制度化 --> ( 难度等级: [0.2467, 0.2468) || 挂载数据: 无 ) 
│   │   │       ├── 把局部发现转化为全局优化 --> ( 难度等级: [0.2468, 0.2469) || 挂载数据: 无 ) 
│   │   │       ├── 在日常工作中注入弹性模式 --> ( 难度等级: [0.2469, 0.247) || 挂载数据: 无 ) 
│   │   │       └── 领导层强化学习文化 --> ( 难度等级: [0.247, 0.2471) || 挂载数据: blog: 1 ) 
│   │   ├── 从何处开始 --> ( 难度等级: [0.2471, 0.249) || 挂载数据: 无 ) 
│   │   │   ├── 选择合适的价值流作为切入点 --> ( 难度等级: [0.2471, 0.2475) || 挂载数据: 无 ) 
│   │   │   │   ├── 兼顾记录型系统和交互型系统 --> ( 难度等级: [0.2471, 0.2472) || 挂载数据: 无 ) 
│   │   │   │   ├── 从最乐于创新的团队开始 --> ( 难度等级: [0.2472, 0.2474) || 挂载数据: 无 ) 
│   │   │   │   └── 扩大DevOps的范围 --> ( 难度等级: [0.2474, 0.2475) || 挂载数据: 无 ) 
│   │   │   ├── 理解、可视化和运用价值流 --> ( 难度等级: [0.2475, 0.248) || 挂载数据: 无 ) 
│   │   │   │   ├── 确定创造客户价值所需的团队 --> ( 难度等级: [0.2475, 0.2477) || 挂载数据: 无 ) 
│   │   │   │   ├── 针对团队工作绘制价值流图 --> ( 难度等级: [0.2477, 0.2478) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 组建专门的转型团队 --> ( 难度等级: [0.2478, 0.2479) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 拥有共同的目标 --> ( 难度等级: [0.2478, 0.2478) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 保持小跨度的改进计划 --> ( 难度等级: [0.2478, 0.2479) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 为非功能性需求预留20%的开发时间，减少技术债务 --> ( 难度等级: [0.2479, 0.2479) || 挂载数据: 无 ) 
│   │   │   │   │   └── 提高工作的可视化程度 --> ( 难度等级: [0.2479, 0.2479) || 挂载数据: 无 ) 
│   │   │   │   └── 用工具强化预期行为 --> ( 难度等级: [0.2479, 0.248) || 挂载数据: 无 ) 
│   │   │   ├── 参考康威定律设计组织结构 --> ( 难度等级: [0.248, 0.2485) || 挂载数据: 无 ) 
│   │   │   │   ├── 组织原型 --> ( 难度等级: [0.248, 0.2481) || 挂载数据: 无 ) 
│   │   │   │   ├── 过度职能导向的危害（“成本优化”） --> ( 难度等级: [0.2481, 0.2482) || 挂载数据: 无 ) 
│   │   │   │   ├── 组建以市场为导向的团队（“速度优化”） --> ( 难度等级: [0.2482, 0.2482) || 挂载数据: 无 ) 
│   │   │   │   ├── 使职能导向有效 --> ( 难度等级: [0.2482, 0.2483) || 挂载数据: 无 ) 
│   │   │   │   ├── 将测试、运维和信息安全融入日常工作 --> ( 难度等级: [0.2483, 0.2483) || 挂载数据: 无 ) 
│   │   │   │   ├── 使团队成员都成为通才 --> ( 难度等级: [0.2483, 0.2484) || 挂载数据: 无 ) 
│   │   │   │   ├── 根据康威定律设定团队边界 --> ( 难度等级: [0.2484, 0.2485) || 挂载数据: 无 ) 
│   │   │   │   └── 创建松耦合架构，提高生产力和安全性 --> ( 难度等级: [0.2485, 0.2485) || 挂载数据: 无 ) 
│   │   │   └── 将运维融入日常开发工作 --> ( 难度等级: [0.2485, 0.249) || 挂载数据: 无 ) 
│   │   │       ├── 创建共享服务，提高开发生产力 --> ( 难度等级: [0.2485, 0.2487) || 挂载数据: 无 ) 
│   │   │       ├── 将运维工程师融入服务团队 --> ( 难度等级: [0.2487, 0.2488) || 挂载数据: 无 ) 
│   │   │       ├── 为每个服务团队分派运维联络人 --> ( 难度等级: [0.2488, 0.2489) || 挂载数据: 无 ) 
│   │   │       └── 邀请运维工程师参加开发团队的会议 --> ( 难度等级: [0.2489, 0.249) || 挂载数据: 无 ) 
│   │   │           ├── 邀请运维工程师参加每日站会 --> ( 难度等级: [0.2489, 0.2489) || 挂载数据: blog: 10 ) 
│   │   │           ├── 邀请运维工程师参加回顾会议 --> ( 难度等级: [0.2489, 0.249) || 挂载数据: 无 ) 
│   │   │           └── 使用看板图展示运维工作 --> ( 难度等级: [0.249, 0.249) || 挂载数据: blog: 2 ) 
│   │   ├── 第一步：流动的技术实践 --> ( 难度等级: [0.249, 0.251) || 挂载数据: 无 ) 
│   │   │   ├── 为部署流水线奠定基础 --> ( 难度等级: [0.249, 0.2494) || 挂载数据: 无 ) 
│   │   │   │   ├── 按需搭建开发环境、测试环境和生产环境 --> ( 难度等级: [0.249, 0.2491) || 挂载数据: 无 ) 
│   │   │   │   ├── 应用统一的代码仓库 --> ( 难度等级: [0.2491, 0.2492) || 挂载数据: 无 ) 
│   │   │   │   ├── 使基础设施的重建更容易 --> ( 难度等级: [0.2492, 0.2493) || 挂载数据: 无 ) 
│   │   │   │   └── 运行在类生产环境里才算“完成” --> ( 难度等级: [0.2493, 0.2494) || 挂载数据: 无 ) 
│   │   │   ├── 实现快速可靠的自动化测试 --> ( 难度等级: [0.2494, 0.2498) || 挂载数据: 无 ) 
│   │   │   │   ├── 对代码和环境做持续构建、测试和集成 --> ( 难度等级: [0.2494, 0.2495) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建快速可靠的自动化测试套件 --> ( 难度等级: [0.2495, 0.2497) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在自动化测试中尽早发现错误 --> ( 难度等级: [0.2495, 0.2496) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 尽可能并行地快速执行测试 --> ( 难度等级: [0.2496, 0.2496) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 先编写自动化测试 --> ( 难度等级: [0.2496, 0.2496) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 尽量将手动测试自动化 --> ( 难度等级: [0.2496, 0.2496) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 在测试套件中集成性能测试 --> ( 难度等级: [0.2496, 0.2497) || 挂载数据: 无 ) 
│   │   │   │   │   └── 在测试套件中集成非功能性需求测试 --> ( 难度等级: [0.2497, 0.2497) || 挂载数据: 无 ) 
│   │   │   │   └── 在部署流水线失败时拉下安灯绳 --> ( 难度等级: [0.2497, 0.2498) || 挂载数据: 无 ) 
│   │   │   ├── 应用和实践持续集成 --> ( 难度等级: [0.2498, 0.2502) || 挂载数据: 无 ) 
│   │   │   │   ├── 小批量开发与大批量合并 --> ( 难度等级: [0.2498, 0.25) || 挂载数据: 无 ) 
│   │   │   │   └── 应用基于主干的开发实践 --> ( 难度等级: [0.25, 0.2502) || 挂载数据: blog: 3 ) 
│   │   │   ├── 自动化和低风险发布 --> ( 难度等级: [0.2502, 0.2506) || 挂载数据: 无 ) 
│   │   │   │   ├── 自动化部署流程 --> ( 难度等级: [0.2502, 0.2504) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 应用自动化的自助式部署 --> ( 难度等级: [0.2502, 0.2503) || 挂载数据: 无 ) 
│   │   │   │   │   └── 在部署流水线中集成代码部署 --> ( 难度等级: [0.2503, 0.2504) || 挂载数据: 无 ) 
│   │   │   │   └── 将部署与发布解耦 --> ( 难度等级: [0.2504, 0.2506) || 挂载数据: 无 ) 
│   │   │   │       ├── 基于环境的发布模式 --> ( 难度等级: [0.2504, 0.2505) || 挂载数据: 无 ) 
│   │   │   │       └── 基于应用的发布模式更安全 --> ( 难度等级: [0.2505, 0.2506) || 挂载数据: 无 ) 
│   │   │   └── 降低发布风险的架构 --> ( 难度等级: [0.2506, 0.251) || 挂载数据: 无 ) 
│   │   │       ├── 能提高生产力、可测试性和安全性的架构 --> ( 难度等级: [0.2506, 0.2507) || 挂载数据: 无 ) 
│   │   │       ├── 架构原型：单体架构与微服务 --> ( 难度等级: [0.2507, 0.2508) || 挂载数据: 无 ) 
│   │   │       └── 安全地演进企业架构 --> ( 难度等级: [0.2508, 0.251) || 挂载数据: blog: 1 ) 
│   │   ├── 第二步：反馈的技术实践 --> ( 难度等级: [0.251, 0.2529) || 挂载数据: 无 ) 
│   │   │   ├── 分析遥测数据以更好地预测故障和实现目标 --> ( 难度等级: [0.251, 0.2515) || 挂载数据: 无 ) 
│   │   │   │   ├── 异常状态的处理和告警 --> ( 难度等级: [0.251, 0.2512) || 挂载数据: 无 ) 
│   │   │   │   └── 应用异常检测技术 --> ( 难度等级: [0.2512, 0.2515) || 挂载数据: 无 ) 
│   │   │   ├── 应用反馈实现安全部署 --> ( 难度等级: [0.2515, 0.252) || 挂载数据: 无 ) 
│   │   │   │   ├── 通过遥测使部署更安全 --> ( 难度等级: [0.2515, 0.2516) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发和运维共同承担值班工作 --> ( 难度等级: [0.2516, 0.2517) || 挂载数据: 无 ) 
│   │   │   │   ├── 让开发人员跟踪工作对下游的影响 --> ( 难度等级: [0.2517, 0.2518) || 挂载数据: 无 ) 
│   │   │   │   └── 让开发人员自行管理生产服务 --> ( 难度等级: [0.2518, 0.252) || 挂载数据: 无 ) 
│   │   │   ├── 将假设驱动的开发和A/B测试融入日常工作 --> ( 难度等级: [0.252, 0.2525) || 挂载数据: 无 ) 
│   │   │   │   ├── A/B测试简史 --> ( 难度等级: [0.252, 0.2521) || 挂载数据: 无 ) 
│   │   │   │   ├── 在功能测试中集成A/B测试 --> ( 难度等级: [0.2521, 0.2522) || 挂载数据: 无 ) 
│   │   │   │   ├── 在发布中集成A/B测试 --> ( 难度等级: [0.2522, 0.2523) || 挂载数据: 无 ) 
│   │   │   │   └── 在功能规划中集成A/B测试 --> ( 难度等级: [0.2523, 0.2525) || 挂载数据: 无 ) 
│   │   │   └── 建立评审和协作流程以提升当前工作的质量 --> ( 难度等级: [0.2525, 0.2529) || 挂载数据: 无 ) 
│   │   │       ├── 变更审批流程的危险 --> ( 难度等级: [0.2525, 0.2525) || 挂载数据: 无 ) 
│   │   │       ├── “过度控制变更”的潜在危险 --> ( 难度等级: [0.2525, 0.2526) || 挂载数据: 无 ) 
│   │   │       ├── 变更的协调和排程 --> ( 难度等级: [0.2526, 0.2527) || 挂载数据: 无 ) 
│   │   │       ├── 变更的同行评审 --> ( 难度等级: [0.2527, 0.2527) || 挂载数据: 无 ) 
│   │   │       ├── 人工测试和变更冻结的潜在危害 --> ( 难度等级: [0.2527, 0.2528) || 挂载数据: 无 ) 
│   │   │       ├── 利用结对编程改进代码变更 --> ( 难度等级: [0.2528, 0.2529) || 挂载数据: 无 ) 
│   │   │       └── 消除官僚流程 --> ( 难度等级: [0.2529, 0.2529) || 挂载数据: 无 ) 
│   │   ├── 集成信息安全、变更管理和合规性的技术实践 --> ( 难度等级: [0.2529, 0.2549) || 挂载数据: 无 ) 
│   │   │   ├── 将信息安全融入每个人的日常工作 --> ( 难度等级: [0.2529, 0.2539) || 挂载数据: 无 ) 
│   │   │   │   ├── 将安全集成到开发迭代的演示中 --> ( 难度等级: [0.2529, 0.253) || 挂载数据: 无 ) 
│   │   │   │   ├── 将安全集成到缺陷跟踪和事后分析会议中 --> ( 难度等级: [0.253, 0.2531) || 挂载数据: 无 ) 
│   │   │   │   ├── 将预防性安全控制集成到共享源代码库及共享服务中 --> ( 难度等级: [0.2531, 0.2532) || 挂载数据: 无 ) 
│   │   │   │   ├── 将安全集成到部署流水线中 --> ( 难度等级: [0.2532, 0.2533) || 挂载数据: 无 ) 
│   │   │   │   ├── 保证应用程序的安全性 --> ( 难度等级: [0.2533, 0.2534) || 挂载数据: 无 ) 
│   │   │   │   ├── 确保软件供应链的安全 --> ( 难度等级: [0.2534, 0.2535) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 确保环境的安全 --> ( 难度等级: [0.2535, 0.2536) || 挂载数据: 无 ) 
│   │   │   │   ├── 将信息安全集成到生产环境遥测中 --> ( 难度等级: [0.2536, 0.2537) || 挂载数据: 无 ) 
│   │   │   │   ├── 在应用程序中建立安全遥测系统 --> ( 难度等级: [0.2537, 0.2537) || 挂载数据: 无 ) 
│   │   │   │   ├── 在环境中建立安全遥测系统 --> ( 难度等级: [0.2537, 0.2538) || 挂载数据: 无 ) 
│   │   │   │   └── 保护部署流水线 --> ( 难度等级: [0.2538, 0.2539) || 挂载数据: 无 ) 
│   │   │   └── 保护部署流水线 --> ( 难度等级: [0.2539, 0.2549) || 挂载数据: 无 ) 
│   │   │       ├── 将安全和合规性集成到变更批准流程中 --> ( 难度等级: [0.2539, 0.2541) || 挂载数据: 无 ) 
│   │   │       ├── 将大量低风险变更重新归类为标准变更 --> ( 难度等级: [0.2541, 0.2543) || 挂载数据: 无 ) 
│   │   │       ├── 如何处理常规变更 --> ( 难度等级: [0.2543, 0.2545) || 挂载数据: 无 ) 
│   │   │       ├── 减少对职责分离的依赖 --> ( 难度等级: [0.2545, 0.2547) || 挂载数据: 无 ) 
│   │   │       └── 确保为审计人员和合规人员留存文档和证据 --> ( 难度等级: [0.2547, 0.2549) || 挂载数据: 无 ) 
│   │   ├── Shell脚本在DevOps下的应用 --> ( 难度等级: [0.2549, 0.2569) || 挂载数据: 无 ) 
│   │   │   ├── Shell编程基础 --> ( 难度等级: [0.2549, 0.2552) || 挂载数据: 无 ) 
│   │   │   │   ├── Shell脚本的基本元素 --> ( 难度等级: [0.2549, 0.255) || 挂载数据: blog: 7 ) 
│   │   │   │   ├── Shell基础正则表达式 --> ( 难度等级: [0.255, 0.2551) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Shell特殊字符 --> ( 难度等级: [0.2551, 0.2551) || 挂载数据: blog: 16 ) 
│   │   │   │   └── 变量和运算符 --> ( 难度等级: [0.2551, 0.2552) || 挂载数据: 无 ) 
│   │   │   ├── Shell中的控制流结构 --> ( 难度等级: [0.2552, 0.2556) || 挂载数据: 无 ) 
│   │   │   ├── sed的基础用法及实用举例 --> ( 难度等级: [0.2556, 0.2559) || 挂载数据: 无 ) 
│   │   │   │   ├── sed的基础语法格式 --> ( 难度等级: [0.2556, 0.2557) || 挂载数据: 无 ) 
│   │   │   │   └── sed的用法举例说明 --> ( 难度等级: [0.2557, 0.2559) || 挂载数据: blog: 2 ) 
│   │   │   ├── awk的基础用法及实用案例 --> ( 难度等级: [0.2559, 0.2562) || 挂载数据: 无 ) 
│   │   │   ├── Shell应用于DevOps开发中应掌握的系统知识点 --> ( 难度等级: [0.2562, 0.2565) || 挂载数据: blog: 5 ) 
│   │   │   └── 生产环境下的Shell脚本 --> ( 难度等级: [0.2565, 0.2569) || 挂载数据: 无 ) 
│   │   │       ├── 生产环境下的备份类脚本 --> ( 难度等级: [0.2565, 0.2566) || 挂载数据: 无 ) 
│   │   │       ├── 生产环境下的统计类脚本 --> ( 难度等级: [0.2566, 0.2567) || 挂载数据: 无 ) 
│   │   │       ├── 生产环境下的监控类脚本 --> ( 难度等级: [0.2567, 0.2568) || 挂载数据: 无 ) 
│   │   │       └── 生产环境下的运维开发类脚本 --> ( 难度等级: [0.2568, 0.2569) || 挂载数据: blog: 1 ) 
│   │   ├── Python在DevOps与自动化运维中的应用 --> ( 难度等级: [0.2569, 0.2588) || 挂载数据: 无 ) 
│   │   │   ├── Python语言的应用领域 --> ( 难度等级: [0.2569, 0.2571) || 挂载数据: 无 ) 
│   │   │   ├── 选择Python的原因 --> ( 难度等级: [0.2571, 0.2574) || 挂载数据: 无 ) 
│   │   │   ├── Python的版本说明 --> ( 难度等级: [0.2574, 0.2576) || 挂载数据: 无 ) 
│   │   │   ├── Python基础学习工具 --> ( 难度等级: [0.2576, 0.2578) || 挂载数据: 无 ) 
│   │   │   │   ├── Python(x,y)简单介绍 --> ( 难度等级: [0.2576, 0.2577) || 挂载数据: blog: 23 ) 
│   │   │   │   ├── IPython详细介绍 --> ( 难度等级: [0.2577, 0.2578) || 挂载数据: blog: 3 ) 
│   │   │   │   └── Sublime Text3简单介绍 --> ( 难度等级: [0.2578, 0.2578) || 挂载数据: 无 ) 
│   │   │   ├── Python基础知识进阶 --> ( 难度等级: [0.2578, 0.2581) || 挂载数据: 无 ) 
│   │   │   │   ├── 正则表达式应用 --> ( 难度等级: [0.2578, 0.2579) || 挂载数据: 无 ) 
│   │   │   │   ├── Python程序构成 --> ( 难度等级: [0.2579, 0.2579) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 使用Python解析JSON --> ( 难度等级: [0.2579, 0.2579) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Python异常处理与程序调试 --> ( 难度等级: [0.2579, 0.258) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Python函数 --> ( 难度等级: [0.258, 0.258) || 挂载数据: blog: 156 ) 
│   │   │   │   ├── Python面向对象 --> ( 难度等级: [0.258, 0.258) || 挂载数据: 无 ) 
│   │   │   │   ├── Python多进程 --> ( 难度等级: [0.258, 0.2581) || 挂载数据: 无 ) 
│   │   │   │   └── Python多线程 --> ( 难度等级: [0.2581, 0.2581) || 挂载数据: blog: 3 ) 
│   │   │   ├── Python经常用到的第三方类库 --> ( 难度等级: [0.2581, 0.2583) || 挂载数据: 无 ) 
│   │   │   ├── 利用Flask设计后端Restful API --> ( 难度等级: [0.2583, 0.2586) || 挂载数据: blog: 1 ) 
│   │   │   └── 工作中的Python脚本分享 --> ( 难度等级: [0.2586, 0.2588) || 挂载数据: 无 ) 
│   │   ├── Vagrant在DevOps环境中的应用 --> ( 难度等级: [0.2588, 0.2608) || 挂载数据: 无 ) 
│   │   │   ├── Vagrant简单介绍 --> ( 难度等级: [0.2588, 0.2592) || 挂载数据: 无 ) 
│   │   │   ├── Vagrant安装 --> ( 难度等级: [0.2592, 0.2596) || 挂载数据: 无 ) 
│   │   │   ├── 使用Vagrant配置本地开发环境 --> ( 难度等级: [0.2596, 0.26) || 挂载数据: 无 ) 
│   │   │   │   ├── Vagrant的具体安装步骤 --> ( 难度等级: [0.2596, 0.2597) || 挂载数据: blog: 51 ) 
│   │   │   │   ├── Vagrant配置文件详解 --> ( 难度等级: [0.2597, 0.2599) || 挂载数据: blog: 2 ) 
│   │   │   │   └── Vagrant常用命令详解 --> ( 难度等级: [0.2599, 0.26) || 挂载数据: blog: 187 ) 
│   │   │   ├── 使用Vagrant搭建DevOps开发环境 --> ( 难度等级: [0.26, 0.2604) || 挂载数据: blog: 76 ) 
│   │   │   └── 使用Vagrant搭建分布式环境 --> ( 难度等级: [0.2604, 0.2608) || 挂载数据: 无 ) 
│   │   ├── 自动化部署管理工具Ansible --> ( 难度等级: [0.2608, 0.2627) || 挂载数据: 无 ) 
│   │   │   ├── YAML介绍 --> ( 难度等级: [0.2608, 0.261) || 挂载数据: 无 ) 
│   │   │   ├── Ansible的安装和配置 --> ( 难度等级: [0.261, 0.2611) || 挂载数据: 无 ) 
│   │   │   ├── 定义主机与组规则（Inventory） --> ( 难度等级: [0.2611, 0.2613) || 挂载数据: 无 ) 
│   │   │   ├── Ansible常用模块介绍 --> ( 难度等级: [0.2613, 0.2615) || 挂载数据: blog: 5 ) 
│   │   │   ├── playbook介绍 --> ( 难度等级: [0.2615, 0.2617) || 挂载数据: 无 ) 
│   │   │   ├── Ansible在AWS云平台中的应用 --> ( 难度等级: [0.2617, 0.2619) || 挂载数据: blog: 3 ) 
│   │   │   ├── 角色 --> ( 难度等级: [0.2619, 0.262) || 挂载数据: 无 ) 
│   │   │   ├── Jinja2过滤器 --> ( 难度等级: [0.262, 0.2622) || 挂载数据: 无 ) 
│   │   │   ├── Ansible速度优化 --> ( 难度等级: [0.2622, 0.2624) || 挂载数据: 无 ) 
│   │   │   ├── 利用Ansible API提供自动化运维后端 --> ( 难度等级: [0.2624, 0.2626) || 挂载数据: 无 ) 
│   │   │   │   ├── runner API --> ( 难度等级: [0.2624, 0.2624) || 挂载数据: 无 ) 
│   │   │   │   ├── playbook API --> ( 难度等级: [0.2624, 0.2625) || 挂载数据: 无 ) 
│   │   │   │   └── 用Flask封装Ansible提供自动化运维后端 --> ( 难度等级: [0.2625, 0.2626) || 挂载数据: blog: 10 ) 
│   │   │   └── Ansible 2.2新增功能 --> ( 难度等级: [0.2626, 0.2627) || 挂载数据: 无 ) 
│   │   ├── 自动化配置管理工具SaltStack --> ( 难度等级: [0.2627, 0.2647) || 挂载数据: 无 ) 
│   │   │   ├── Salt的相关知识点介绍 --> ( 难度等级: [0.2627, 0.2631) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt的优势 --> ( 难度等级: [0.2627, 0.2628) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt的安装 --> ( 难度等级: [0.2628, 0.2629) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt的工作流程 --> ( 难度等级: [0.2629, 0.263) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Salt配置文件详解 --> ( 难度等级: [0.263, 0.2631) || 挂载数据: 无 ) 
│   │   │   │   └── Salt的命令格式 --> ( 难度等级: [0.2631, 0.2631) || 挂载数据: blog: 1 ) 
│   │   │   ├── Salt的常用组件 --> ( 难度等级: [0.2631, 0.2635) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt常用的操作目标 --> ( 难度等级: [0.2631, 0.2632) || 挂载数据: 无 ) 
│   │   │   │   ├── Salt常用模块 --> ( 难度等级: [0.2632, 0.2633) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Granis组件 --> ( 难度等级: [0.2633, 0.2633) || 挂载数据: 无 ) 
│   │   │   │   ├── pillar组件 --> ( 难度等级: [0.2633, 0.2634) || 挂载数据: 无 ) 
│   │   │   │   ├── job管理 --> ( 难度等级: [0.2634, 0.2635) || 挂载数据: 无 ) 
│   │   │   │   └── State介绍 --> ( 难度等级: [0.2635, 0.2635) || 挂载数据: 无 ) 
│   │   │   ├── Salt真实案例分享 --> ( 难度等级: [0.2635, 0.2639) || 挂载数据: 无 ) 
│   │   │   │   ├── base环境配置 --> ( 难度等级: [0.2635, 0.2637) || 挂载数据: 无 ) 
│   │   │   │   └── prod环境配置 --> ( 难度等级: [0.2637, 0.2639) || 挂载数据: 无 ) 
│   │   │   ├── Salt多Master搭建 --> ( 难度等级: [0.2639, 0.2643) || 挂载数据: 无 ) 
│   │   │   └── Salt API介绍 --> ( 难度等级: [0.2643, 0.2647) || 挂载数据: 无 ) 
│   │   │       ├── Python API介绍 --> ( 难度等级: [0.2643, 0.2645) || 挂载数据: blog: 4 ) 
│   │   │       └── Restful API介绍 --> ( 难度等级: [0.2645, 0.2647) || 挂载数据: blog: 1 ) 
│   │   └── Docker和Jenkins在DevOps中的应用 --> ( 难度等级: [0.2647, 0.2667) || 挂载数据: 无 ) 
│   │       ├── Docker的基础安装 --> ( 难度等级: [0.2647, 0.265) || 挂载数据: 无 ) 
│   │       ├── Docker的三大核心概念 --> ( 难度等级: [0.265, 0.2653) || 挂载数据: 无 ) 
│   │       ├── Docker的基本架构 --> ( 难度等级: [0.2653, 0.2655) || 挂载数据: 无 ) 
│   │       ├── Docker网络实现原理 --> ( 难度等级: [0.2655, 0.2658) || 挂载数据: 无 ) 
│   │       ├── 利用Dockerfile文件技巧打包Docker镜像 --> ( 难度等级: [0.2658, 0.2661) || 挂载数据: 无 ) 
│   │       ├── 利用Docker-Compose编排和管理多容器 --> ( 难度等级: [0.2661, 0.2664) || 挂载数据: 无 ) 
│   │       │   ├── Docker-Compose的基本语法 --> ( 难度等级: [0.2661, 0.2662) || 挂载数据: 无 ) 
│   │       │   └── Docker-Compose常用命令 --> ( 难度等级: [0.2662, 0.2664) || 挂载数据: blog: 12 ) 
│   │       └── 利用Docker搭建Jenkins Master/Slave分布式环境 --> ( 难度等级: [0.2664, 0.2667) || 挂载数据: 无 ) 
│   │           └── Jenkins Master/Slave的详细部署过程 --> ( 难度等级: [0.2664, 0.2667) || 挂载数据: blog: 31 ) 
│   ├── 中间件 --> ( 难度等级: [0.2667, 0.3) || 挂载数据: 无 ) 
│   │   ├── 缓存 --> ( 难度等级: [0.2667, 0.2778) || 挂载数据: 无 ) 
│   │   │   ├── etcd --> ( 难度等级: [0.2667, 0.2722) || 挂载数据: 无 ) 
│   │   │   └── Redis --> ( 难度等级: [0.2722, 0.2778) || 挂载数据: 无 ) 
│   │   ├── 微服务与配置中心 --> ( 难度等级: [0.2778, 0.2889) || 挂载数据: 无 ) 
│   │   │   └── Nacos --> ( 难度等级: [0.2778, 0.2889) || 挂载数据: blog: 15 ) 
│   │   └── 存储 --> ( 难度等级: [0.2889, 0.3) || 挂载数据: 无 ) 
│   │       ├── S3标准 --> ( 难度等级: [0.2889, 0.2926) || 挂载数据: 无 ) 
│   │       ├── MinIO --> ( 难度等级: [0.2926, 0.2963) || 挂载数据: blog: 4 ) 
│   │       └── Harbor --> ( 难度等级: [0.2963, 0.3) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.3, 0.3333) || 挂载数据: 无 ) 
├── 云原生中阶-应用开发 --> ( 难度等级: [0.3333, 0.5) || 挂载数据: 无 ) 
│   ├── Serverless --> ( 难度等级: [0.3333, 0.3889) || 挂载数据: 无 ) 
│   │   └── App Serverless --> ( 难度等级: [0.3333, 0.3889) || 挂载数据: 无 ) 
│   │       └── Knative --> ( 难度等级: [0.3333, 0.3889) || 挂载数据: 无 ) 
│   ├── Microservices微服务 --> ( 难度等级: [0.3889, 0.4444) || 挂载数据: 无 ) 
│   │   └── Dapr --> ( 难度等级: [0.3889, 0.4444) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.4444, 0.5) || 挂载数据: 无 ) 
├── 云原生中阶-平台开发 --> ( 难度等级: [0.5, 0.6667) || 挂载数据: 无 ) 
│   ├── Kubernetes --> ( 难度等级: [0.5, 0.5417) || 挂载数据: 无 ) 
│   │   ├── 边缘计算 --> ( 难度等级: [0.5, 0.5013) || 挂载数据: 无 ) 
│   │   │   ├── OpenYurt --> ( 难度等级: [0.5, 0.5004) || 挂载数据: 无 ) 
│   │   │   ├── KubeEdge --> ( 难度等级: [0.5004, 0.5009) || 挂载数据: blog: 1 ) 
│   │   │   └── Akri --> ( 难度等级: [0.5009, 0.5013) || 挂载数据: 无 ) 
│   │   ├── 集群联邦 --> ( 难度等级: [0.5013, 0.5027) || 挂载数据: 无 ) 
│   │   │   └── Federation --> ( 难度等级: [0.5013, 0.5027) || 挂载数据: 无 ) 
│   │   ├── 发行版 --> ( 难度等级: [0.5027, 0.504) || 挂载数据: 无 ) 
│   │   │   ├── EKS-D --> ( 难度等级: [0.5027, 0.503) || 挂载数据: 无 ) 
│   │   │   ├── Harvester --> ( 难度等级: [0.503, 0.5032) || 挂载数据: 无 ) 
│   │   │   ├── OpenShift --> ( 难度等级: [0.5032, 0.5035) || 挂载数据: blog: 4 ) 
│   │   │   ├── k0s --> ( 难度等级: [0.5035, 0.5038) || 挂载数据: 无 ) 
│   │   │   └── Wayne --> ( 难度等级: [0.5038, 0.504) || 挂载数据: 无 ) 
│   │   ├── Kubernetes系统基础 --> ( 难度等级: [0.504, 0.5054) || 挂载数据: 无 ) 
│   │   │   ├── 容器技术概述 --> ( 难度等级: [0.504, 0.5044) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器技术的功用 --> ( 难度等级: [0.504, 0.5041) || 挂载数据: blog: 12 ) 
│   │   │   │   ├── 容器简史 --> ( 难度等级: [0.5041, 0.5043) || 挂载数据: 无 ) 
│   │   │   │   └── Docker的功能限制 --> ( 难度等级: [0.5043, 0.5044) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes概述 --> ( 难度等级: [0.5044, 0.5047) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes简史 --> ( 难度等级: [0.5044, 0.5045) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes特性 --> ( 难度等级: [0.5045, 0.5046) || 挂载数据: blog: 3 ) 
│   │   │   │   └── Kubernetes概念和术语 --> ( 难度等级: [0.5046, 0.5047) || 挂载数据: blog: 5 ) 
│   │   │   ├── Kubernetes集群组件 --> ( 难度等级: [0.5047, 0.505) || 挂载数据: 无 ) 
│   │   │   │   ├── Master组件 --> ( 难度等级: [0.5047, 0.5048) || 挂载数据: blog: 3 ) 
│   │   │   │   ├── Node组件 --> ( 难度等级: [0.5048, 0.5049) || 挂载数据: blog: 2 ) 
│   │   │   │   └── 核心附件 --> ( 难度等级: [0.5049, 0.505) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes网络模型基础 --> ( 难度等级: [0.505, 0.5054) || 挂载数据: 无 ) 
│   │   │       ├── 网络模型概述 --> ( 难度等级: [0.505, 0.5052) || 挂载数据: 无 ) 
│   │   │       └── 集群上的网络通信 --> ( 难度等级: [0.5052, 0.5054) || 挂载数据: 无 ) 
│   │   ├── Kubernetes快速入门 --> ( 难度等级: [0.5054, 0.5067) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes的核心对象 --> ( 难度等级: [0.5054, 0.5057) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod资源对象 --> ( 难度等级: [0.5054, 0.5055) || 挂载数据: 无 ) 
│   │   │   │   ├── Controller --> ( 难度等级: [0.5055, 0.5055) || 挂载数据: 无 ) 
│   │   │   │   ├── Service --> ( 难度等级: [0.5055, 0.5056) || 挂载数据: 无 ) 
│   │   │   │   └── 部署应用程序的主体过程 --> ( 难度等级: [0.5056, 0.5057) || 挂载数据: 无 ) 
│   │   │   ├── 部署Kubernetes集群 --> ( 难度等级: [0.5057, 0.506) || 挂载数据: 无 ) 
│   │   │   │   ├── kubeadm部署工具 --> ( 难度等级: [0.5057, 0.5058) || 挂载数据: blog: 6 ) 
│   │   │   │   ├── 集群运行模式 --> ( 难度等级: [0.5058, 0.5059) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 准备用于实践操作的集群环境 --> ( 难度等级: [0.5059, 0.506) || 挂载数据: 无 ) 
│   │   │   │   └── 获取集群环境相关的信息 --> ( 难度等级: [0.506, 0.506) || 挂载数据: 无 ) 
│   │   │   ├── kubectl使用基础与示例 --> ( 难度等级: [0.506, 0.5064) || 挂载数据: 无 ) 
│   │   │   └── 命令式容器应用编排 --> ( 难度等级: [0.5064, 0.5067) || 挂载数据: 无 ) 
│   │   │       ├── 部署应用（Pod） --> ( 难度等级: [0.5064, 0.5065) || 挂载数据: 无 ) 
│   │   │       ├── 探查Pod及应用详情 --> ( 难度等级: [0.5065, 0.5065) || 挂载数据: 无 ) 
│   │   │       ├── 部署Service对象 --> ( 难度等级: [0.5065, 0.5066) || 挂载数据: 无 ) 
│   │   │       ├── 扩容和缩容 --> ( 难度等级: [0.5066, 0.5067) || 挂载数据: 无 ) 
│   │   │       └── 修改及删除对象 --> ( 难度等级: [0.5067, 0.5067) || 挂载数据: 无 ) 
│   │   ├── 资源管理基础 --> ( 难度等级: [0.5067, 0.5081) || 挂载数据: 无 ) 
│   │   │   ├── 资源对象及API群组 --> ( 难度等级: [0.5067, 0.507) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes的资源对象 --> ( 难度等级: [0.5067, 0.5068) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源及其在API中的组织形式 --> ( 难度等级: [0.5068, 0.5069) || 挂载数据: 无 ) 
│   │   │   │   └── 访问Kubernetes REST API --> ( 难度等级: [0.5069, 0.507) || 挂载数据: 无 ) 
│   │   │   ├── 对象类资源格式 --> ( 难度等级: [0.507, 0.5073) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源配置清单 --> ( 难度等级: [0.507, 0.507) || 挂载数据: 无 ) 
│   │   │   │   ├── metadata嵌套字段 --> ( 难度等级: [0.507, 0.5071) || 挂载数据: 无 ) 
│   │   │   │   ├── spec和status字段 --> ( 难度等级: [0.5071, 0.5072) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源配置清单格式文档 --> ( 难度等级: [0.5072, 0.5072) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 资源对象管理方式 --> ( 难度等级: [0.5072, 0.5073) || 挂载数据: 无 ) 
│   │   │   ├── kubectl命令与资源管理 --> ( 难度等级: [0.5073, 0.5075) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源管理操作概述 --> ( 难度等级: [0.5073, 0.5074) || 挂载数据: 无 ) 
│   │   │   │   └── kubectl的基本用法 --> ( 难度等级: [0.5074, 0.5075) || 挂载数据: 无 ) 
│   │   │   ├── 管理名称空间资源 --> ( 难度等级: [0.5075, 0.5078) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看名称空间及其资源对象 --> ( 难度等级: [0.5075, 0.5077) || 挂载数据: 无 ) 
│   │   │   │   └── 管理Namespace资源 --> ( 难度等级: [0.5077, 0.5078) || 挂载数据: 无 ) 
│   │   │   └── Pod资源的基础管理操作 --> ( 难度等级: [0.5078, 0.5081) || 挂载数据: 无 ) 
│   │   │       ├── 陈述式对象配置管理方式 --> ( 难度等级: [0.5078, 0.5079) || 挂载数据: 无 ) 
│   │   │       └── 声明式对象配置管理方式 --> ( 难度等级: [0.5079, 0.5081) || 挂载数据: 无 ) 
│   │   ├── 管理Pod资源对象 --> ( 难度等级: [0.5081, 0.5094) || 挂载数据: 无 ) 
│   │   │   ├── 管理Pod对象的容器 --> ( 难度等级: [0.5081, 0.5083) || 挂载数据: 无 ) 
│   │   │   │   ├── 镜像及其获取策略 --> ( 难度等级: [0.5081, 0.5081) || 挂载数据: 无 ) 
│   │   │   │   ├── 暴露端口 --> ( 难度等级: [0.5081, 0.5081) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义运行的容器化应用 --> ( 难度等级: [0.5081, 0.5082) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 环境变量 --> ( 难度等级: [0.5082, 0.5082) || 挂载数据: 无 ) 
│   │   │   │   ├── 共享节点的网络名称空间 --> ( 难度等级: [0.5082, 0.5082) || 挂载数据: 无 ) 
│   │   │   │   └── 设置Pod对象的安全上下文 --> ( 难度等级: [0.5082, 0.5083) || 挂载数据: blog: 2 ) 
│   │   │   ├── 标签与标签选择器 --> ( 难度等级: [0.5083, 0.5084) || 挂载数据: 无 ) 
│   │   │   │   ├── 标签概述 --> ( 难度等级: [0.5083, 0.5083) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 管理资源标签 --> ( 难度等级: [0.5083, 0.5084) || 挂载数据: 无 ) 
│   │   │   │   ├── 标签选择器 --> ( 难度等级: [0.5084, 0.5084) || 挂载数据: 无 ) 
│   │   │   │   └── Pod节点选择器nodeSelector --> ( 难度等级: [0.5084, 0.5084) || 挂载数据: 无 ) 
│   │   │   ├── 资源注解 --> ( 难度等级: [0.5084, 0.5086) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看资源注解 --> ( 难度等级: [0.5084, 0.5085) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 管理资源注解 --> ( 难度等级: [0.5085, 0.5086) || 挂载数据: 无 ) 
│   │   │   ├── Pod对象的生命周期 --> ( 难度等级: [0.5086, 0.5088) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod的相位 --> ( 难度等级: [0.5086, 0.5087) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod的创建过程 --> ( 难度等级: [0.5087, 0.5087) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod生命周期中的重要行为 --> ( 难度等级: [0.5087, 0.5088) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器的重启策略 --> ( 难度等级: [0.5088, 0.5088) || 挂载数据: 无 ) 
│   │   │   │   └── Pod的终止过程 --> ( 难度等级: [0.5088, 0.5088) || 挂载数据: 无 ) 
│   │   │   ├── Pod存活性探测 --> ( 难度等级: [0.5088, 0.509) || 挂载数据: 无 ) 
│   │   │   │   ├── 设置exec探针 --> ( 难度等级: [0.5088, 0.5089) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 设置HTTP探针 --> ( 难度等级: [0.5089, 0.5089) || 挂载数据: 无 ) 
│   │   │   │   ├── 设置TCP探针 --> ( 难度等级: [0.5089, 0.509) || 挂载数据: 无 ) 
│   │   │   │   └── 存活性探测行为属性 --> ( 难度等级: [0.509, 0.509) || 挂载数据: 无 ) 
│   │   │   ├── Pod就绪性探测 --> ( 难度等级: [0.509, 0.5092) || 挂载数据: 无 ) 
│   │   │   └── 资源需求及资源限制 --> ( 难度等级: [0.5092, 0.5094) || 挂载数据: 无 ) 
│   │   │       ├── 资源需求 --> ( 难度等级: [0.5092, 0.5093) || 挂载数据: 无 ) 
│   │   │       ├── 资源限制 --> ( 难度等级: [0.5093, 0.5093) || 挂载数据: blog: 1 ) 
│   │   │       ├── 容器的可见资源 --> ( 难度等级: [0.5093, 0.5094) || 挂载数据: blog: 2 ) 
│   │   │       └── Pod的服务质量类别 --> ( 难度等级: [0.5094, 0.5094) || 挂载数据: 无 ) 
│   │   ├── Pod控制器 --> ( 难度等级: [0.5094, 0.5108) || 挂载数据: 无 ) 
│   │   │   ├── 关于Pod控制器 --> ( 难度等级: [0.5094, 0.5096) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod控制器概述 --> ( 难度等级: [0.5094, 0.5095) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 控制器与Pod对象 --> ( 难度等级: [0.5095, 0.5095) || 挂载数据: 无 ) 
│   │   │   │   └── Pod模板资源 --> ( 难度等级: [0.5095, 0.5096) || 挂载数据: 无 ) 
│   │   │   ├── ReplicaSet控制器 --> ( 难度等级: [0.5096, 0.5097) || 挂载数据: 无 ) 
│   │   │   │   ├── ReplicaSet概述 --> ( 难度等级: [0.5096, 0.5096) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建ReplicaSet --> ( 难度等级: [0.5096, 0.5096) || 挂载数据: 无 ) 
│   │   │   │   ├── ReplicaSet管控下的Pod对象 --> ( 难度等级: [0.5096, 0.5097) || 挂载数据: 无 ) 
│   │   │   │   ├── 更新ReplicaSet控制器 --> ( 难度等级: [0.5097, 0.5097) || 挂载数据: blog: 101 ) 
│   │   │   │   └── 删除ReplicaSet控制器资源 --> ( 难度等级: [0.5097, 0.5097) || 挂载数据: blog: 1 ) 
│   │   │   ├── Deployment控制器 --> ( 难度等级: [0.5097, 0.5099) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建Deployment --> ( 难度等级: [0.5097, 0.5098) || 挂载数据: 无 ) 
│   │   │   │   ├── 更新策略 --> ( 难度等级: [0.5098, 0.5098) || 挂载数据: 无 ) 
│   │   │   │   ├── 升级Deployment --> ( 难度等级: [0.5098, 0.5098) || 挂载数据: 无 ) 
│   │   │   │   ├── 金丝雀发布 --> ( 难度等级: [0.5098, 0.5099) || 挂载数据: 无 ) 
│   │   │   │   └── 回滚Deployment控制器下的应用发布 --> ( 难度等级: [0.5099, 0.5099) || 挂载数据: 无 ) 
│   │   │   ├── DaemonSet控制器 --> ( 难度等级: [0.5099, 0.5101) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建DaemonSet资源对象 --> ( 难度等级: [0.5099, 0.51) || 挂载数据: 无 ) 
│   │   │   │   └── 更新DaemonSet对象 --> ( 难度等级: [0.51, 0.5101) || 挂载数据: 无 ) 
│   │   │   ├── Job控制器 --> ( 难度等级: [0.5101, 0.5102) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建Job对象 --> ( 难度等级: [0.5101, 0.5101) || 挂载数据: 无 ) 
│   │   │   │   ├── 并行式Job --> ( 难度等级: [0.5101, 0.5102) || 挂载数据: 无 ) 
│   │   │   │   ├── Job扩容 --> ( 难度等级: [0.5102, 0.5102) || 挂载数据: 无 ) 
│   │   │   │   └── 删除Job --> ( 难度等级: [0.5102, 0.5102) || 挂载数据: 无 ) 
│   │   │   ├── CronJob控制器 --> ( 难度等级: [0.5102, 0.5104) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建CronJob对象 --> ( 难度等级: [0.5102, 0.5103) || 挂载数据: 无 ) 
│   │   │   │   └── CronJob的控制机制 --> ( 难度等级: [0.5103, 0.5104) || 挂载数据: blog: 22 ) 
│   │   │   ├── ReplicationController --> ( 难度等级: [0.5104, 0.5106) || 挂载数据: 无 ) 
│   │   │   └── Pod中断预算 --> ( 难度等级: [0.5106, 0.5108) || 挂载数据: 无 ) 
│   │   ├── 存储卷与数据持久化 --> ( 难度等级: [0.5108, 0.5121) || 挂载数据: 无 ) 
│   │   │   ├── 存储卷概述 --> ( 难度等级: [0.5108, 0.511) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes支持的存储卷类型 --> ( 难度等级: [0.5108, 0.5109) || 挂载数据: 无 ) 
│   │   │   │   └── 存储卷的使用方式 --> ( 难度等级: [0.5109, 0.511) || 挂载数据: 无 ) 
│   │   │   ├── 临时存储卷 --> ( 难度等级: [0.511, 0.5112) || 挂载数据: 无 ) 
│   │   │   │   ├── emptyDir存储卷 --> ( 难度等级: [0.511, 0.5111) || 挂载数据: 无 ) 
│   │   │   │   └── gitRepo存储卷 --> ( 难度等级: [0.5111, 0.5112) || 挂载数据: 无 ) 
│   │   │   ├── 节点存储卷hostPath --> ( 难度等级: [0.5112, 0.5114) || 挂载数据: 无 ) 
│   │   │   ├── 网络存储卷 --> ( 难度等级: [0.5114, 0.5116) || 挂载数据: 无 ) 
│   │   │   │   ├── NFS存储卷 --> ( 难度等级: [0.5114, 0.5115) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── RBD存储卷 --> ( 难度等级: [0.5115, 0.5115) || 挂载数据: 无 ) 
│   │   │   │   ├── GlusterFS存储卷 --> ( 难度等级: [0.5115, 0.5116) || 挂载数据: 无 ) 
│   │   │   │   └── Cinder存储卷 --> ( 难度等级: [0.5116, 0.5116) || 挂载数据: blog: 1 ) 
│   │   │   ├── 持久存储卷 --> ( 难度等级: [0.5116, 0.5119) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建PV --> ( 难度等级: [0.5116, 0.5117) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建PVC --> ( 难度等级: [0.5117, 0.5117) || 挂载数据: 无 ) 
│   │   │   │   ├── 在Pod中使用PVC --> ( 难度等级: [0.5117, 0.5118) || 挂载数据: 无 ) 
│   │   │   │   ├── 存储类 --> ( 难度等级: [0.5118, 0.5118) || 挂载数据: 无 ) 
│   │   │   │   └── PV和PVC的生命周期 --> ( 难度等级: [0.5118, 0.5119) || 挂载数据: 无 ) 
│   │   │   └── downwardAPI存储卷 --> ( 难度等级: [0.5119, 0.5121) || 挂载数据: 无 ) 
│   │   │       ├── 环境变量式元数据注入 --> ( 难度等级: [0.5119, 0.512) || 挂载数据: 无 ) 
│   │   │       └── 存储卷式元数据注入 --> ( 难度等级: [0.512, 0.5121) || 挂载数据: blog: 2 ) 
│   │   ├── 配置容器应用：ConfigMap和Secret --> ( 难度等级: [0.5121, 0.5134) || 挂载数据: 无 ) 
│   │   │   ├── 容器化应用配置方式 --> ( 难度等级: [0.5121, 0.5124) || 挂载数据: 无 ) 
│   │   │   ├── 通过命令行参数配置容器应用 --> ( 难度等级: [0.5124, 0.5126) || 挂载数据: 无 ) 
│   │   │   ├── 利用环境变量配置容器应用 --> ( 难度等级: [0.5126, 0.5129) || 挂载数据: 无 ) 
│   │   │   ├── 应用程序配置管理及ConfigMap资源 --> ( 难度等级: [0.5129, 0.5132) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建ConfigMap对象 --> ( 难度等级: [0.5129, 0.513) || 挂载数据: 无 ) 
│   │   │   │   ├── 向Pod环境变量传递ConfigMap对象键值数据 --> ( 难度等级: [0.513, 0.513) || 挂载数据: 无 ) 
│   │   │   │   ├── ConfigMap存储卷 --> ( 难度等级: [0.513, 0.5131) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器应用重载新配置 --> ( 难度等级: [0.5131, 0.5131) || 挂载数据: 无 ) 
│   │   │   │   └── 使用ConfigMap资源的注意事项 --> ( 难度等级: [0.5131, 0.5132) || 挂载数据: 无 ) 
│   │   │   └── Secret资源 --> ( 难度等级: [0.5132, 0.5134) || 挂载数据: 无 ) 
│   │   │       ├── Secret概述 --> ( 难度等级: [0.5132, 0.5132) || 挂载数据: 无 ) 
│   │   │       ├── 创建Secret资源 --> ( 难度等级: [0.5132, 0.5133) || 挂载数据: 无 ) 
│   │   │       ├── Secret存储卷 --> ( 难度等级: [0.5133, 0.5134) || 挂载数据: blog: 1 ) 
│   │   │       └── imagePullSecret资源对象 --> ( 难度等级: [0.5134, 0.5134) || 挂载数据: 无 ) 
│   │   ├── StatefulSet控制器 --> ( 难度等级: [0.5134, 0.5148) || 挂载数据: 无 ) 
│   │   │   ├── StatefulSet概述 --> ( 难度等级: [0.5134, 0.5137) || 挂载数据: 无 ) 
│   │   │   │   ├── Stateful应用和Stateless应用 --> ( 难度等级: [0.5134, 0.5135) || 挂载数据: 无 ) 
│   │   │   │   ├── StatefulSet控制器概述 --> ( 难度等级: [0.5135, 0.5136) || 挂载数据: 无 ) 
│   │   │   │   └── StatefulSet的特性 --> ( 难度等级: [0.5136, 0.5137) || 挂载数据: 无 ) 
│   │   │   ├── StatefulSet基础应用 --> ( 难度等级: [0.5137, 0.514) || 挂载数据: 无 ) 
│   │   │   │   └── 创建StatefulSet对象 --> ( 难度等级: [0.5137, 0.514) || 挂载数据: 无 ) 
│   │   │   ├── StatefulSet资源扩缩容 --> ( 难度等级: [0.514, 0.5142) || 挂载数据: 无 ) 
│   │   │   ├── StatefulSet资源升级 --> ( 难度等级: [0.5142, 0.5145) || 挂载数据: 无 ) 
│   │   │   │   ├── 滚动更新 --> ( 难度等级: [0.5142, 0.5143) || 挂载数据: 无 ) 
│   │   │   │   ├── 暂存更新操作 --> ( 难度等级: [0.5143, 0.5144) || 挂载数据: 无 ) 
│   │   │   │   ├── 金丝雀部署 --> ( 难度等级: [0.5144, 0.5144) || 挂载数据: 无 ) 
│   │   │   │   ├── 分段更新 --> ( 难度等级: [0.5144, 0.5145) || 挂载数据: 无 ) 
│   │   │   │   └── 其他话题 --> ( 难度等级: [0.5145, 0.5145) || 挂载数据: 无 ) 
│   │   │   └── 案例：etcd集群 --> ( 难度等级: [0.5145, 0.5148) || 挂载数据: 无 ) 
│   │   │       ├── 创建Service资源 --> ( 难度等级: [0.5145, 0.5147) || 挂载数据: 无 ) 
│   │   │       └── etcd StatefulSet --> ( 难度等级: [0.5147, 0.5148) || 挂载数据: blog: 126 ) 
│   │   ├── 认证、授权与准入控制 --> ( 难度等级: [0.5148, 0.5161) || 挂载数据: 无 ) 
│   │   │   ├── 访问控制概述 --> ( 难度等级: [0.5148, 0.5151) || 挂载数据: 无 ) 
│   │   │   │   ├── 用户账户与用户组 --> ( 难度等级: [0.5148, 0.5149) || 挂载数据: 无 ) 
│   │   │   │   └── 认证、授权与准入控制基础 --> ( 难度等级: [0.5149, 0.5151) || 挂载数据: blog: 1 ) 
│   │   │   ├── 服务账户管理与应用 --> ( 难度等级: [0.5151, 0.5153) || 挂载数据: 无 ) 
│   │   │   │   ├── Service Account自动化 --> ( 难度等级: [0.5151, 0.5151) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建服务账户 --> ( 难度等级: [0.5151, 0.5152) || 挂载数据: 无 ) 
│   │   │   │   └── 调用imagePullSecret资源对象 --> ( 难度等级: [0.5152, 0.5153) || 挂载数据: 无 ) 
│   │   │   ├── X.509数字证书认证 --> ( 难度等级: [0.5153, 0.5156) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes中的SSL/TLS认证 --> ( 难度等级: [0.5153, 0.5154) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 客户端配置文件kubeconfig --> ( 难度等级: [0.5154, 0.5155) || 挂载数据: 无 ) 
│   │   │   │   └── TLS bootstrapping机制 --> ( 难度等级: [0.5155, 0.5156) || 挂载数据: 无 ) 
│   │   │   ├── 基于角色的访问控制：RBAC --> ( 难度等级: [0.5156, 0.5159) || 挂载数据: 无 ) 
│   │   │   │   ├── RBAC授权插件 --> ( 难度等级: [0.5156, 0.5156) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Role和RoleBinding --> ( 难度等级: [0.5156, 0.5157) || 挂载数据: 无 ) 
│   │   │   │   ├── ClusterRole和ClusterRoleBin-ding --> ( 难度等级: [0.5157, 0.5157) || 挂载数据: 无 ) 
│   │   │   │   ├── 聚合型ClusterRole --> ( 难度等级: [0.5157, 0.5158) || 挂载数据: 无 ) 
│   │   │   │   ├── 面向用户的内建ClusterRole --> ( 难度等级: [0.5158, 0.5158) || 挂载数据: 无 ) 
│   │   │   │   └── 其他的内建ClusterRole和ClusterRoleBinding --> ( 难度等级: [0.5158, 0.5159) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes Dashboard --> ( 难度等级: [0.5159, 0.5161) || 挂载数据: 无 ) 
│   │   │       ├── 部署HTTPS通信的Dashboard --> ( 难度等级: [0.5159, 0.5159) || 挂载数据: blog: 91 ) 
│   │   │       ├── 配置token认证 --> ( 难度等级: [0.5159, 0.516) || 挂载数据: blog: 1 ) 
│   │   │       └── 配置kubeconfig认证 --> ( 难度等级: [0.516, 0.5161) || 挂载数据: 无 ) 
│   │   ├── 网络模型与网络策略 --> ( 难度等级: [0.5161, 0.5175) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes网络模型及CNI插件 --> ( 难度等级: [0.5161, 0.5165) || 挂载数据: 无 ) 
│   │   │   │   ├── Docker容器的网络模型 --> ( 难度等级: [0.5161, 0.5162) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes网络模型 --> ( 难度等级: [0.5162, 0.5163) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Pod网络的实现方式 --> ( 难度等级: [0.5163, 0.5164) || 挂载数据: 无 ) 
│   │   │   │   └── CNI插件及其常见的实现 --> ( 难度等级: [0.5164, 0.5165) || 挂载数据: 无 ) 
│   │   │   ├── flannel网络插件 --> ( 难度等级: [0.5165, 0.5168) || 挂载数据: 无 ) 
│   │   │   │   ├── flannel的配置参数 --> ( 难度等级: [0.5165, 0.5166) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── VxLAN后端和direct routing --> ( 难度等级: [0.5166, 0.5167) || 挂载数据: 无 ) 
│   │   │   │   └── host-gw后端 --> ( 难度等级: [0.5167, 0.5168) || 挂载数据: 无 ) 
│   │   │   ├── 网络策略 --> ( 难度等级: [0.5168, 0.5171) || 挂载数据: 无 ) 
│   │   │   │   ├── 网络策略概述 --> ( 难度等级: [0.5168, 0.5168) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署Canal提供网络策略功能 --> ( 难度等级: [0.5168, 0.5169) || 挂载数据: 无 ) 
│   │   │   │   ├── 配置网络策略 --> ( 难度等级: [0.5169, 0.5169) || 挂载数据: 无 ) 
│   │   │   │   ├── 管控入站流量 --> ( 难度等级: [0.5169, 0.517) || 挂载数据: 无 ) 
│   │   │   │   ├── 管控出站流量 --> ( 难度等级: [0.517, 0.517) || 挂载数据: 无 ) 
│   │   │   │   ├── 隔离名称空间 --> ( 难度等级: [0.517, 0.5171) || 挂载数据: 无 ) 
│   │   │   │   └── 网络策略应用案例 --> ( 难度等级: [0.5171, 0.5171) || 挂载数据: 无 ) 
│   │   │   └── Calico网络插件 --> ( 难度等级: [0.5171, 0.5175) || 挂载数据: 无 ) 
│   │   │       ├── Calico工作特性 --> ( 难度等级: [0.5171, 0.5172) || 挂载数据: 无 ) 
│   │   │       ├── Calico系统架构 --> ( 难度等级: [0.5172, 0.5173) || 挂载数据: 无 ) 
│   │   │       ├── Calico部署要点 --> ( 难度等级: [0.5173, 0.5173) || 挂载数据: blog: 1 ) 
│   │   │       ├── 部署Calico提供网络服务和网络策略 --> ( 难度等级: [0.5173, 0.5174) || 挂载数据: 无 ) 
│   │   │       └── 客户端工具calicoctl --> ( 难度等级: [0.5174, 0.5175) || 挂载数据: 无 ) 
│   │   ├── Pod资源调度 --> ( 难度等级: [0.5175, 0.5188) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes调度器概述 --> ( 难度等级: [0.5175, 0.5177) || 挂载数据: 无 ) 
│   │   │   │   ├── 常用的预选策略 --> ( 难度等级: [0.5175, 0.5176) || 挂载数据: 无 ) 
│   │   │   │   └── 常用的优选函数 --> ( 难度等级: [0.5176, 0.5177) || 挂载数据: 无 ) 
│   │   │   ├── 节点亲和调度 --> ( 难度等级: [0.5177, 0.518) || 挂载数据: 无 ) 
│   │   │   │   ├── 节点硬亲和性 --> ( 难度等级: [0.5177, 0.5179) || 挂载数据: 无 ) 
│   │   │   │   └── 节点软亲和性 --> ( 难度等级: [0.5179, 0.518) || 挂载数据: 无 ) 
│   │   │   ├── Pod资源亲和调度 --> ( 难度等级: [0.518, 0.5183) || 挂载数据: 无 ) 
│   │   │   │   ├── 位置拓扑 --> ( 难度等级: [0.518, 0.5181) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod硬亲和调度 --> ( 难度等级: [0.5181, 0.5181) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod软亲和调度 --> ( 难度等级: [0.5181, 0.5182) || 挂载数据: 无 ) 
│   │   │   │   └── Pod反亲和调度 --> ( 难度等级: [0.5182, 0.5183) || 挂载数据: blog: 1 ) 
│   │   │   ├── 污点和容忍度 --> ( 难度等级: [0.5183, 0.5185) || 挂载数据: 无 ) 
│   │   │   │   ├── 定义污点和容忍度 --> ( 难度等级: [0.5183, 0.5184) || 挂载数据: 无 ) 
│   │   │   │   ├── 管理节点的污点 --> ( 难度等级: [0.5184, 0.5185) || 挂载数据: 无 ) 
│   │   │   │   └── Pod对象的容忍度 --> ( 难度等级: [0.5185, 0.5185) || 挂载数据: 无 ) 
│   │   │   └── Pod优选级和抢占式调度 --> ( 难度等级: [0.5185, 0.5188) || 挂载数据: 无 ) 
│   │   ├── Kubernetes系统扩展 --> ( 难度等级: [0.5188, 0.5202) || 挂载数据: 无 ) 
│   │   │   ├── 自定义资源类型（CRD） --> ( 难度等级: [0.5188, 0.5191) || 挂载数据: 无 ) 
│   │   │   │   ├── 创建CRD对象 --> ( 难度等级: [0.5188, 0.5189) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 自定义资源格式验证 --> ( 难度等级: [0.5189, 0.5189) || 挂载数据: 无 ) 
│   │   │   │   ├── 子资源 --> ( 难度等级: [0.5189, 0.519) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用资源类别 --> ( 难度等级: [0.519, 0.519) || 挂载数据: 无 ) 
│   │   │   │   ├── 多版本支持 --> ( 难度等级: [0.519, 0.519) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义控制器基础 --> ( 难度等级: [0.519, 0.5191) || 挂载数据: blog: 4 ) 
│   │   │   ├── 自定义API Server --> ( 难度等级: [0.5191, 0.5194) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义API Server概述 --> ( 难度等级: [0.5191, 0.5192) || 挂载数据: blog: 1 ) 
│   │   │   │   └── APIService对象 --> ( 难度等级: [0.5192, 0.5194) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes集群高可用 --> ( 难度等级: [0.5194, 0.5196) || 挂载数据: 无 ) 
│   │   │   │   ├── etcd高可用 --> ( 难度等级: [0.5194, 0.5195) || 挂载数据: blog: 14 ) 
│   │   │   │   └── Controller Manager和Scheduler高可用 --> ( 难度等级: [0.5195, 0.5196) || 挂载数据: blog: 4 ) 
│   │   │   ├── Kubernetes的部署模式 --> ( 难度等级: [0.5196, 0.5199) || 挂载数据: 无 ) 
│   │   │   │   ├── 关键组件 --> ( 难度等级: [0.5196, 0.5198) || 挂载数据: 无 ) 
│   │   │   │   └── 常见的部署模式 --> ( 难度等级: [0.5198, 0.5199) || 挂载数据: 无 ) 
│   │   │   └── 容器时代的DevOps概述 --> ( 难度等级: [0.5199, 0.5202) || 挂载数据: 无 ) 
│   │   │       ├── 容器：DevOps协作的基础 --> ( 难度等级: [0.5199, 0.52) || 挂载数据: blog: 2 ) 
│   │   │       │   ├── 容器隔离等级 --> ( 难度等级: [0.5199, 0.5199) || 挂载数据: 无 ) 
│   │   │       │   ├── 容器编排 --> ( 难度等级: [0.5199, 0.5199) || 挂载数据: blog: 5 ) 
│   │   │       │   ├── 将镜像存储在可信的注册服务器中 --> ( 难度等级: [0.5199, 0.5199) || 挂载数据: 无 ) 
│   │   │       │   ├── 充分利用Docker的构建缓存 --> ( 难度等级: [0.5199, 0.5199) || 挂载数据: 无 ) 
│   │   │       │   ├── 不要使用特权模式运行容器 --> ( 难度等级: [0.5199, 0.5199) || 挂载数据: 无 ) 
│   │   │       │   ├── 使用显式的容器镜像标签 --> ( 难度等级: [0.5199, 0.5199) || 挂载数据: 无 ) 
│   │   │       │   ├── 保持小的容器镜像 --> ( 难度等级: [0.5199, 0.5199) || 挂载数据: 无 ) 
│   │   │       │   ├── 单个容器只运行一个应用 --> ( 难度等级: [0.5199, 0.52) || 挂载数据: blog: 1 ) 
│   │   │       │   ├── 使用可信镜像仓库中经过验证的镜像 --> ( 难度等级: [0.52, 0.52) || 挂载数据: 无 ) 
│   │   │       │   ├── 对镜像进行漏洞扫描 --> ( 难度等级: [0.52, 0.52) || 挂载数据: 无 ) 
│   │   │       │   ├── 不要将数据保存在容器中 --> ( 难度等级: [0.52, 0.52) || 挂载数据: blog: 2 ) 
│   │   │       │   └── 永远不要在容器中存放密钥和配置 --> ( 难度等级: [0.52, 0.52) || 挂载数据: 无 ) 
│   │   │       ├── 泛型端到端容器应用程序生命周期工作流 --> ( 难度等级: [0.52, 0.5201) || 挂载数据: 无 ) 
│   │   │       └── 基于Kubernetes的DevOps --> ( 难度等级: [0.5201, 0.5202) || 挂载数据: blog: 31 ) 
│   │   ├── 资源指标及HPA控制器 --> ( 难度等级: [0.5202, 0.5215) || 挂载数据: 无 ) 
│   │   │   ├── 资源监控及资源指标 --> ( 难度等级: [0.5202, 0.5205) || 挂载数据: 无 ) 
│   │   │   │   ├── 资源监控及Heapster --> ( 难度等级: [0.5202, 0.5203) || 挂载数据: 无 ) 
│   │   │   │   └── 新一代监控架构 --> ( 难度等级: [0.5203, 0.5205) || 挂载数据: 无 ) 
│   │   │   ├── 资源指标及其应用 --> ( 难度等级: [0.5205, 0.5208) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署metrics-server --> ( 难度等级: [0.5205, 0.5207) || 挂载数据: 无 ) 
│   │   │   │   └── kubectl top命令 --> ( 难度等级: [0.5207, 0.5208) || 挂载数据: 无 ) 
│   │   │   ├── 自定义指标与Prometheus --> ( 难度等级: [0.5208, 0.5212) || 挂载数据: 无 ) 
│   │   │   │   ├── Prometheus概述 --> ( 难度等级: [0.5208, 0.5209) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署Prometheus监控系统 --> ( 难度等级: [0.5209, 0.5211) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义指标适配器k8s-prometheus-adapter --> ( 难度等级: [0.5211, 0.5212) || 挂载数据: 无 ) 
│   │   │   └── 自动弹性缩放 --> ( 难度等级: [0.5212, 0.5215) || 挂载数据: 无 ) 
│   │   │       ├── HPA概述 --> ( 难度等级: [0.5212, 0.5213) || 挂载数据: 无 ) 
│   │   │       ├── HPA（v1）控制器 --> ( 难度等级: [0.5213, 0.5214) || 挂载数据: 无 ) 
│   │   │       └── HPA（v2）控制器 --> ( 难度等级: [0.5214, 0.5215) || 挂载数据: 无 ) 
│   │   ├── Helm程序包管理器 --> ( 难度等级: [0.5215, 0.5228) || 挂载数据: 无 ) 
│   │   │   ├── Helm基础 --> ( 难度等级: [0.5215, 0.522) || 挂载数据: 无 ) 
│   │   │   │   ├── Helm的核心术语 --> ( 难度等级: [0.5215, 0.5216) || 挂载数据: 无 ) 
│   │   │   │   ├── Helm架构 --> ( 难度等级: [0.5216, 0.5217) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Helm Client --> ( 难度等级: [0.5217, 0.5218) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Tiller server --> ( 难度等级: [0.5218, 0.5219) || 挂载数据: 无 ) 
│   │   │   │   └── Helm快速入门 --> ( 难度等级: [0.5219, 0.522) || 挂载数据: blog: 1 ) 
│   │   │   ├── Helm Charts --> ( 难度等级: [0.522, 0.5224) || 挂载数据: 无 ) 
│   │   │   │   ├── Charts文件组织结构 --> ( 难度等级: [0.522, 0.522) || 挂载数据: 无 ) 
│   │   │   │   ├── Chart.yaml文件组织格式 --> ( 难度等级: [0.522, 0.5221) || 挂载数据: 无 ) 
│   │   │   │   ├── Charts中的依赖关系 --> ( 难度等级: [0.5221, 0.5222) || 挂载数据: 无 ) 
│   │   │   │   ├── 模板和值 --> ( 难度等级: [0.5222, 0.5223) || 挂载数据: 无 ) 
│   │   │   │   └── 自定义Charts --> ( 难度等级: [0.5223, 0.5224) || 挂载数据: 无 ) 
│   │   │   └── Helm实践：部署EFK日志管理系统 --> ( 难度等级: [0.5224, 0.5228) || 挂载数据: 无 ) 
│   │   │       ├── ElasticSearch集群 --> ( 难度等级: [0.5224, 0.5226) || 挂载数据: 无 ) 
│   │   │       ├── 日志采集代理fluentd --> ( 难度等级: [0.5226, 0.5227) || 挂载数据: 无 ) 
│   │   │       └── 可视化组件Kibana --> ( 难度等级: [0.5227, 0.5228) || 挂载数据: 无 ) 
│   │   ├── 夯实基础：Linux网络虚拟化 --> ( 难度等级: [0.5228, 0.5242) || 挂载数据: 无 ) 
│   │   │   ├── 网络虚拟化基石：network namespace --> ( 难度等级: [0.5228, 0.523) || 挂载数据: 无 ) 
│   │   │   │   ├── 初识network namespace --> ( 难度等级: [0.5228, 0.5229) || 挂载数据: 无 ) 
│   │   │   │   ├── 配置network namespace --> ( 难度等级: [0.5229, 0.5229) || 挂载数据: 无 ) 
│   │   │   │   └── network namespace API的使用 --> ( 难度等级: [0.5229, 0.523) || 挂载数据: blog: 4 ) 
│   │   │   ├── 千呼万唤始出来：veth pair --> ( 难度等级: [0.523, 0.5231) || 挂载数据: 无 ) 
│   │   │   │   └── veth pair内核实现 --> ( 难度等级: [0.523, 0.5231) || 挂载数据: 无 ) 
│   │   │   ├── 连接你我他：Linux bridge --> ( 难度等级: [0.5231, 0.5233) || 挂载数据: 无 ) 
│   │   │   │   ├── Linux bridge初体验 --> ( 难度等级: [0.5231, 0.5232) || 挂载数据: blog: 297 ) 
│   │   │   │   ├── 把IP让给Linux bridge --> ( 难度等级: [0.5232, 0.5232) || 挂载数据: blog: 13 ) 
│   │   │   │   ├── 将物理网卡添加到Linux bridge --> ( 难度等级: [0.5232, 0.5232) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Linux bridge在网络虚拟化中的应用 --> ( 难度等级: [0.5232, 0.5233) || 挂载数据: blog: 22 ) 
│   │   │   │   └── 网络接口的混杂模式 --> ( 难度等级: [0.5233, 0.5233) || 挂载数据: 无 ) 
│   │   │   ├── 给用户态一个机会：tun/tap设备 --> ( 难度等级: [0.5233, 0.5234) || 挂载数据: 无 ) 
│   │   │   │   ├── tun/tap设备的工作原理 --> ( 难度等级: [0.5233, 0.5233) || 挂载数据: 无 ) 
│   │   │   │   ├── 利用tun设备部署一个VPN --> ( 难度等级: [0.5233, 0.5234) || 挂载数据: 无 ) 
│   │   │   │   └── tun设备编程 --> ( 难度等级: [0.5234, 0.5234) || 挂载数据: 无 ) 
│   │   │   ├── iptables --> ( 难度等级: [0.5234, 0.5236) || 挂载数据: 无 ) 
│   │   │   │   ├── 祖师爷netfilter --> ( 难度等级: [0.5234, 0.5235) || 挂载数据: 无 ) 
│   │   │   │   ├── iptables的三板斧：table、chain和rule --> ( 难度等级: [0.5235, 0.5235) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── iptables的常规武器 --> ( 难度等级: [0.5235, 0.5235) || 挂载数据: 无 ) 
│   │   │   │   ├── userspace模式 --> ( 难度等级: [0.5235, 0.5235) || 挂载数据: 无 ) 
│   │   │   │   ├── iptables模式 --> ( 难度等级: [0.5235, 0.5235) || 挂载数据: blog: 230 ) 
│   │   │   │   ├── IPVS模式 --> ( 难度等级: [0.5235, 0.5236) || 挂载数据: 无 ) 
│   │   │   │   ├── iptables VS. IPVS --> ( 难度等级: [0.5236, 0.5236) || 挂载数据: 无 ) 
│   │   │   │   └── conntrack --> ( 难度等级: [0.5236, 0.5236) || 挂载数据: blog: 2 ) 
│   │   │   ├── 初识Linux隧道：ipip --> ( 难度等级: [0.5236, 0.5237) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试ipip隧道 --> ( 难度等级: [0.5236, 0.5237) || 挂载数据: 无 ) 
│   │   │   │   └── ipip隧道测试结果复盘 --> ( 难度等级: [0.5237, 0.5237) || 挂载数据: 无 ) 
│   │   │   ├── Linux隧道网络的代表：VXLAN --> ( 难度等级: [0.5237, 0.5239) || 挂载数据: 无 ) 
│   │   │   │   ├── VXLAN协议原理简介 --> ( 难度等级: [0.5237, 0.5238) || 挂载数据: 无 ) 
│   │   │   │   ├── VXLAN组网必要信息 --> ( 难度等级: [0.5238, 0.5238) || 挂载数据: 无 ) 
│   │   │   │   ├── VXLAN基本配置命令 --> ( 难度等级: [0.5238, 0.5238) || 挂载数据: 无 ) 
│   │   │   │   ├── VXLAN网络实践 --> ( 难度等级: [0.5238, 0.5238) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式控制中心 --> ( 难度等级: [0.5238, 0.5239) || 挂载数据: 无 ) 
│   │   │   │   └── 自维护VTEP组 --> ( 难度等级: [0.5239, 0.5239) || 挂载数据: 无 ) 
│   │   │   ├── 物理网卡的分身术：Macvlan --> ( 难度等级: [0.5239, 0.524) || 挂载数据: 无 ) 
│   │   │   │   ├── Macvlan五大工作模式解析 --> ( 难度等级: [0.5239, 0.5239) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试使用Macvlan设备 --> ( 难度等级: [0.5239, 0.524) || 挂载数据: 无 ) 
│   │   │   │   ├── Macvlan的跨机通信 --> ( 难度等级: [0.524, 0.524) || 挂载数据: 无 ) 
│   │   │   │   └── Macvlan与overlay对比 --> ( 难度等级: [0.524, 0.524) || 挂载数据: blog: 1 ) 
│   │   │   └── Macvlan的救护员：IPvlan --> ( 难度等级: [0.524, 0.5242) || 挂载数据: 无 ) 
│   │   │       ├── IPvlan简介 --> ( 难度等级: [0.524, 0.5241) || 挂载数据: 无 ) 
│   │   │       ├── 测试IPvlan --> ( 难度等级: [0.5241, 0.5241) || 挂载数据: 无 ) 
│   │   │       └── Docker IPvlan网络 --> ( 难度等级: [0.5241, 0.5242) || 挂载数据: 无 ) 
│   │   ├── 饮水思源：Docker网络模型简介 --> ( 难度等级: [0.5242, 0.5255) || 挂载数据: 无 ) 
│   │   │   ├── 主角登场：Linux容器 --> ( 难度等级: [0.5242, 0.5244) || 挂载数据: 无 ) 
│   │   │   ├── 打开万花筒：Docker的四大网络模式 --> ( 难度等级: [0.5244, 0.5246) || 挂载数据: 无 ) 
│   │   │   │   ├── bridge模式 --> ( 难度等级: [0.5244, 0.5245) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── host模式 --> ( 难度等级: [0.5245, 0.5245) || 挂载数据: 无 ) 
│   │   │   │   ├── container模式 --> ( 难度等级: [0.5245, 0.5246) || 挂载数据: 无 ) 
│   │   │   │   └── none模式 --> ( 难度等级: [0.5246, 0.5246) || 挂载数据: 无 ) 
│   │   │   ├── 最常用的Docker网络技巧 --> ( 难度等级: [0.5246, 0.5249) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看容器IP --> ( 难度等级: [0.5246, 0.5247) || 挂载数据: 无 ) 
│   │   │   │   ├── 端口映射 --> ( 难度等级: [0.5247, 0.5247) || 挂载数据: 无 ) 
│   │   │   │   ├── 访问外网 --> ( 难度等级: [0.5247, 0.5247) || 挂载数据: 无 ) 
│   │   │   │   ├── DNS和主机名 --> ( 难度等级: [0.5247, 0.5248) || 挂载数据: 无 ) 
│   │   │   │   ├── 自定义网络 --> ( 难度等级: [0.5248, 0.5248) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 发布服务 --> ( 难度等级: [0.5248, 0.5248) || 挂载数据: 无 ) 
│   │   │   │   └── docker link：两两互联 --> ( 难度等级: [0.5248, 0.5249) || 挂载数据: blog: 1 ) 
│   │   │   ├── 容器网络的第一个标准：CNM --> ( 难度等级: [0.5249, 0.5251) || 挂载数据: 无 ) 
│   │   │   │   ├── CNM标准 --> ( 难度等级: [0.5249, 0.5249) || 挂载数据: 无 ) 
│   │   │   │   ├── 体验CNM接口 --> ( 难度等级: [0.5249, 0.525) || 挂载数据: 无 ) 
│   │   │   │   ├── Libnetwork --> ( 难度等级: [0.525, 0.525) || 挂载数据: 无 ) 
│   │   │   │   └── Libnetwork扩展 --> ( 难度等级: [0.525, 0.5251) || 挂载数据: 无 ) 
│   │   │   ├── 天生不易：容器组网的挑战 --> ( 难度等级: [0.5251, 0.5253) || 挂载数据: 无 ) 
│   │   │   │   ├── 容器网络挑战综述 --> ( 难度等级: [0.5251, 0.5252) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── Docker的解决方案 --> ( 难度等级: [0.5252, 0.5252) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 第三方容器网络插件 --> ( 难度等级: [0.5252, 0.5253) || 挂载数据: 无 ) 
│   │   │   └── 如何做好技术选型：容器组网方案沙场点兵 --> ( 难度等级: [0.5253, 0.5255) || 挂载数据: 无 ) 
│   │   │       ├── 隧道方案 --> ( 难度等级: [0.5253, 0.5254) || 挂载数据: 无 ) 
│   │   │       ├── 路由方案 --> ( 难度等级: [0.5254, 0.5254) || 挂载数据: 无 ) 
│   │   │       ├── 容器网络组网类型 --> ( 难度等级: [0.5254, 0.5255) || 挂载数据: 无 ) 
│   │   │       └── 关于容器网络标准接口 --> ( 难度等级: [0.5255, 0.5255) || 挂载数据: 无 ) 
│   │   ├── 标准的胜利：Kubernetes网络原理与实践 --> ( 难度等级: [0.5255, 0.5269) || 挂载数据: 无 ) 
│   │   │   ├── 容器基础设施的代言人：Kubernetes --> ( 难度等级: [0.5255, 0.5256) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes简介 --> ( 难度等级: [0.5255, 0.5256) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes能做什么 --> ( 难度等级: [0.5256, 0.5256) || 挂载数据: 无 ) 
│   │   │   │   ├── 如何用Kubernetes --> ( 难度等级: [0.5256, 0.5256) || 挂载数据: blog: 4 ) 
│   │   │   │   └── Docker在Kubernetes中的角色 --> ( 难度等级: [0.5256, 0.5256) || 挂载数据: 无 ) 
│   │   │   ├── 终于等到你：Kubernetes网络 --> ( 难度等级: [0.5256, 0.5257) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes网络基础 --> ( 难度等级: [0.5256, 0.5256) || 挂载数据: blog: 5 ) 
│   │   │   │   ├── Kubernetes网络架构综述 --> ( 难度等级: [0.5256, 0.5257) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── Kubernetes主机内组网模型 --> ( 难度等级: [0.5257, 0.5257) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes跨节点组网模型 --> ( 难度等级: [0.5257, 0.5257) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod的hosts文件 --> ( 难度等级: [0.5257, 0.5257) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Pod的hostname --> ( 难度等级: [0.5257, 0.5257) || 挂载数据: 无 ) 
│   │   │   ├── Pod的核心：pause容器 --> ( 难度等级: [0.5257, 0.5258) || 挂载数据: 无 ) 
│   │   │   ├── 打通CNI与Kubernetes：Kubernetes网络驱动 --> ( 难度等级: [0.5258, 0.5259) || 挂载数据: 无 ) 
│   │   │   │   ├── 即将完成历史使命：Kubenet --> ( 难度等级: [0.5258, 0.5259) || 挂载数据: 无 ) 
│   │   │   │   └── 网络生态第一步：CNI --> ( 难度等级: [0.5259, 0.5259) || 挂载数据: blog: 2 ) 
│   │   │   ├── 找到你并不容易：从集群内访问服务 --> ( 难度等级: [0.5259, 0.526) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes Service详解 --> ( 难度等级: [0.5259, 0.5259) || 挂载数据: 无 ) 
│   │   │   │   ├── Service的三个port --> ( 难度等级: [0.5259, 0.5259) || 挂载数据: 无 ) 
│   │   │   │   ├── 你的服务适合哪种发布形式 --> ( 难度等级: [0.5259, 0.5259) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes Service发现 --> ( 难度等级: [0.5259, 0.526) || 挂载数据: 无 ) 
│   │   │   │   ├── 特殊的无头Service --> ( 难度等级: [0.526, 0.526) || 挂载数据: 无 ) 
│   │   │   │   └── 怎么访问本地服务 --> ( 难度等级: [0.526, 0.526) || 挂载数据: 无 ) 
│   │   │   ├── 找到你并不容易：从集群外访问服务 --> ( 难度等级: [0.526, 0.5261) || 挂载数据: 无 ) 
│   │   │   │   └── Kubernetes Ingress --> ( 难度等级: [0.526, 0.5261) || 挂载数据: 无 ) 
│   │   │   ├── 你的名字：通过域名访问服务 --> ( 难度等级: [0.5261, 0.5262) || 挂载数据: 无 ) 
│   │   │   │   ├── DNS服务基本框架 --> ( 难度等级: [0.5261, 0.5261) || 挂载数据: 无 ) 
│   │   │   │   ├── 域名解析基本原理 --> ( 难度等级: [0.5261, 0.5261) || 挂载数据: 无 ) 
│   │   │   │   └── 调试DNS --> ( 难度等级: [0.5261, 0.5262) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes网络策略：为你的应用保驾护航 --> ( 难度等级: [0.5262, 0.5263) || 挂载数据: 无 ) 
│   │   │   │   └── 网络策略应用举例 --> ( 难度等级: [0.5262, 0.5263) || 挂载数据: 无 ) 
│   │   │   ├── 前方高能：Kubernetes网络故障定位指南 --> ( 难度等级: [0.5263, 0.5263) || 挂载数据: 无 ) 
│   │   │   │   ├── IP转发和桥接 --> ( 难度等级: [0.5263, 0.5263) || 挂载数据: 无 ) 
│   │   │   │   ├── Pod CIDR冲突 --> ( 难度等级: [0.5263, 0.5263) || 挂载数据: 无 ) 
│   │   │   │   ├── hairpin --> ( 难度等级: [0.5263, 0.5263) || 挂载数据: 无 ) 
│   │   │   │   ├── 查看Pod IP地址 --> ( 难度等级: [0.5263, 0.5263) || 挂载数据: 无 ) 
│   │   │   │   └── 故障排查工具 --> ( 难度等级: [0.5263, 0.5263) || 挂载数据: 无 ) 
│   │   │   ├── 迈向云原生 --> ( 难度等级: [0.5263, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   ├── 找个合理的理由打破巨石应用 --> ( 难度等级: [0.5263, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   ├── 先解耦简单的服务 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   ├── 学会小规模的运维 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 使用防损层模式 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用刀砍模式 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   ├── 准备一个数据迁移策略 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   ├── 重写所有模板代码 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   └── 淘汰老代码 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: 无 ) 
│   │   │   ├── 确保弹性 --> ( 难度等级: [0.5264, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 用重试来解决瞬时故障 --> ( 难度等级: [0.5264, 0.5264) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用有限次的重试 --> ( 难度等级: [0.5264, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 用断路器来处理非瞬时故障 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 优雅地降级 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用隔离模式 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 实现健康及就绪检查 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 为容器设定CPU和内存限制 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   └── 实现限速和限流 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   ├── 确保安全性 --> ( 难度等级: [0.5265, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 安全性需求同其他需求一样重要 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 在设计时就考虑安全性 --> ( 难度等级: [0.5265, 0.5265) || 挂载数据: 无 ) 
│   │   │   │   ├── 授予最小访问权限 --> ( 难度等级: [0.5265, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 安全地存储所有密钥 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 模糊化数据 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 传输数据加密 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用联合身份管理 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   └── Kubernetes pod的隔离 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   ├── 处理数据 --> ( 难度等级: [0.5266, 0.5267) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用托管数据库和数据分析服务 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用符合数据需求的存储 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 将数据保存在多个地域或可用区中 --> ( 难度等级: [0.5266, 0.5266) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用数据分区和复制以提高扩展性 --> ( 难度等级: [0.5266, 0.5267) || 挂载数据: 无 ) 
│   │   │   │   ├── 避免过度获取及频繁的I/O操作 --> ( 难度等级: [0.5267, 0.5267) || 挂载数据: 无 ) 
│   │   │   │   ├── 不要把业务逻辑放在数据库中执行 --> ( 难度等级: [0.5267, 0.5267) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用类生产环境数据来测试 --> ( 难度等级: [0.5267, 0.5267) || 挂载数据: 无 ) 
│   │   │   │   └── 处理瞬时故障 --> ( 难度等级: [0.5267, 0.5267) || 挂载数据: 无 ) 
│   │   │   ├── 性能和伸缩性 --> ( 难度等级: [0.5267, 0.5268) || 挂载数据: 无 ) 
│   │   │   │   ├── 设计可扩展的无状态服务 --> ( 难度等级: [0.5267, 0.5267) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用平台的自动伸缩功能 --> ( 难度等级: [0.5267, 0.5267) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用缓存 --> ( 难度等级: [0.5267, 0.5268) || 挂载数据: 无 ) 
│   │   │   │   └── 用分区来实现超出服务限制的扩容 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: blog: 1 ) 
│   │   │   └── 运维 --> ( 难度等级: [0.5268, 0.5269) || 挂载数据: blog: 1 ) 
│   │   │       ├── 部署和发布是两项独立的活动 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: 无 ) 
│   │   │       ├── 部署的内容要尽量小 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: 无 ) 
│   │   │       ├── 组件层级的CI/CD定义 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: 无 ) 
│   │   │       ├── 应用部署的一致性 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: 无 ) 
│   │   │       ├── 采用零宕机发布 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: 无 ) 
│   │   │       ├── 不要变更部署后的架构 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: 无 ) 
│   │   │       ├── 使用容器化构建 --> ( 难度等级: [0.5268, 0.5268) || 挂载数据: 无 ) 
│   │   │       ├── 用代码来描述基础设施 --> ( 难度等级: [0.5268, 0.5269) || 挂载数据: 无 ) 
│   │   │       ├── 使用命名空间来组织Kubernetes中的服务 --> ( 难度等级: [0.5269, 0.5269) || 挂载数据: 无 ) 
│   │   │       ├── 环境间的隔离 --> ( 难度等级: [0.5269, 0.5269) || 挂载数据: 无 ) 
│   │   │       ├── 分隔函数源代码 --> ( 难度等级: [0.5269, 0.5269) || 挂载数据: 无 ) 
│   │   │       └── 关联代码提交和部署 --> ( 难度等级: [0.5269, 0.5269) || 挂载数据: 无 ) 
│   │   ├── 刨根问底：Kubernetes网络实现机制 --> ( 难度等级: [0.5269, 0.5282) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes极客们的日常：DIY一个Ingress Controller --> ( 难度等级: [0.5269, 0.5273) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Ingress Controller的通用框架 --> ( 难度等级: [0.5269, 0.5271) || 挂载数据: blog: 1 ) 
│   │   │   │   └── Nginx Ingress Controller详解 --> ( 难度等级: [0.5271, 0.5273) || 挂载数据: blog: 2 ) 
│   │   │   ├── 沧海桑田：Kubernetes DNS架构演进之路 --> ( 难度等级: [0.5273, 0.5278) || 挂载数据: 无 ) 
│   │   │   │   ├── Kube-dns的工作原理 --> ( 难度等级: [0.5273, 0.5275) || 挂载数据: 无 ) 
│   │   │   │   ├── 上位的CoreDNS --> ( 难度等级: [0.5275, 0.5276) || 挂载数据: 无 ) 
│   │   │   │   └── Kube-dns VS. CoreDNS --> ( 难度等级: [0.5276, 0.5278) || 挂载数据: blog: 8 ) 
│   │   │   └── 你的安全我负责：使用Calico提供Kubernetes网络策略 --> ( 难度等级: [0.5278, 0.5282) || 挂载数据: 无 ) 
│   │   │       ├── 部署一个带Calico的Kubernetes集群 --> ( 难度等级: [0.5278, 0.528) || 挂载数据: blog: 5 ) 
│   │   │       └── 测试Calico网络策略 --> ( 难度等级: [0.528, 0.5282) || 挂载数据: 无 ) 
│   │   ├── 百花齐放：Kubernetes网络插件生态 --> ( 难度等级: [0.5282, 0.5296) || 挂载数据: 无 ) 
│   │   │   ├── 从入门到放弃：Docker原生网络的不足 --> ( 难度等级: [0.5282, 0.5284) || 挂载数据: 无 ) 
│   │   │   ├── CNI标准的胜出：从此江湖没有CNM --> ( 难度等级: [0.5284, 0.5286) || 挂载数据: 无 ) 
│   │   │   │   └── CNI的工作原理 --> ( 难度等级: [0.5284, 0.5286) || 挂载数据: 无 ) 
│   │   │   ├── Kubernetes网络插件鼻祖flannel --> ( 难度等级: [0.5286, 0.5288) || 挂载数据: 无 ) 
│   │   │   │   ├── flannel简介 --> ( 难度等级: [0.5286, 0.5287) || 挂载数据: 无 ) 
│   │   │   │   ├── flannel安装配置 --> ( 难度等级: [0.5287, 0.5287) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── flannel backend详解 --> ( 难度等级: [0.5287, 0.5288) || 挂载数据: blog: 1 ) 
│   │   │   │   └── flannel与etcd --> ( 难度等级: [0.5288, 0.5288) || 挂载数据: blog: 7 ) 
│   │   │   ├── 全能大三层网络插件：Calico --> ( 难度等级: [0.5288, 0.529) || 挂载数据: 无 ) 
│   │   │   │   ├── Calico简介 --> ( 难度等级: [0.5288, 0.5288) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Calico的隧道模式 --> ( 难度等级: [0.5288, 0.5289) || 挂载数据: 无 ) 
│   │   │   │   ├── 安装Calico --> ( 难度等级: [0.5289, 0.5289) || 挂载数据: 无 ) 
│   │   │   │   ├── Calico报文路径 --> ( 难度等级: [0.5289, 0.529) || 挂载数据: 无 ) 
│   │   │   │   └── Calico使用指南 --> ( 难度等级: [0.529, 0.529) || 挂载数据: 无 ) 
│   │   │   ├── Weave：支持数据加密的网络插件 --> ( 难度等级: [0.529, 0.5292) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave简介 --> ( 难度等级: [0.529, 0.529) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave实现原理 --> ( 难度等级: [0.529, 0.5291) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave安装 --> ( 难度等级: [0.5291, 0.5291) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave网络通信模型 --> ( 难度等级: [0.5291, 0.5291) || 挂载数据: 无 ) 
│   │   │   │   └── Weave的应用示例 --> ( 难度等级: [0.5291, 0.5292) || 挂载数据: 无 ) 
│   │   │   ├── Cilium：为微服务网络连接安全而生 --> ( 难度等级: [0.5292, 0.5294) || 挂载数据: 无 ) 
│   │   │   │   ├── 以API为中心的微服务安全 --> ( 难度等级: [0.5292, 0.5293) || 挂载数据: 无 ) 
│   │   │   │   └── BPF优化的数据平面性能 --> ( 难度等级: [0.5293, 0.5294) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes多网络的先行者：CNI-Genie --> ( 难度等级: [0.5294, 0.5296) || 挂载数据: 无 ) 
│   │   │       ├── CNI-Genie功能速递 --> ( 难度等级: [0.5294, 0.5295) || 挂载数据: blog: 1 ) 
│   │   │       └── 容器多IP --> ( 难度等级: [0.5295, 0.5296) || 挂载数据: blog: 3 ) 
│   │   ├── Kubernetes网络下半场：Istio --> ( 难度等级: [0.5296, 0.5309) || 挂载数据: 无 ) 
│   │   │   ├── 微服务架构的大地震：sidecar模式 --> ( 难度等级: [0.5296, 0.5298) || 挂载数据: 无 ) 
│   │   │   │   ├── 你真的需要Service Mesh吗 --> ( 难度等级: [0.5296, 0.5296) || 挂载数据: 无 ) 
│   │   │   │   ├── sidecar模式 --> ( 难度等级: [0.5296, 0.5297) || 挂载数据: 无 ) 
│   │   │   │   ├── Service Mesh与sidecar --> ( 难度等级: [0.5297, 0.5297) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes Service VS. Service Mesh --> ( 难度等级: [0.5297, 0.5298) || 挂载数据: 无 ) 
│   │   │   │   └── Service Mesh典型实现之Linkerd --> ( 难度等级: [0.5298, 0.5298) || 挂载数据: 无 ) 
│   │   │   ├── Istio：引领新一代微服务架构潮流 --> ( 难度等级: [0.5298, 0.5301) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio简介 --> ( 难度等级: [0.5298, 0.5299) || 挂载数据: 无 ) 
│   │   │   │   ├── Istio安装 --> ( 难度等级: [0.5299, 0.53) || 挂载数据: 无 ) 
│   │   │   │   └── Istio路由规则的实现 --> ( 难度等级: [0.53, 0.5301) || 挂载数据: 无 ) 
│   │   │   ├── 一切尽在不言中：Istio sidecar透明注入 --> ( 难度等级: [0.5301, 0.5304) || 挂载数据: 无 ) 
│   │   │   │   ├── Init容器 --> ( 难度等级: [0.5301, 0.5302) || 挂载数据: blog: 2 ) 
│   │   │   │   ├── sideca注入示例 --> ( 难度等级: [0.5302, 0.5302) || 挂载数据: 无 ) 
│   │   │   │   ├── 手工注入sidecar --> ( 难度等级: [0.5302, 0.5303) || 挂载数据: 无 ) 
│   │   │   │   ├── 自动注入sidecar --> ( 难度等级: [0.5303, 0.5303) || 挂载数据: 无 ) 
│   │   │   │   └── 从应用容器到sidecar代理的通信 --> ( 难度等级: [0.5303, 0.5304) || 挂载数据: 无 ) 
│   │   │   ├── 不再为iptables脚本所困：Istio CNI插件 --> ( 难度等级: [0.5304, 0.5306) || 挂载数据: 无 ) 
│   │   │   └── 除了微服务，Istio还能做更多 --> ( 难度等级: [0.5306, 0.5309) || 挂载数据: 无 ) 
│   │   ├── 云原生简介 --> ( 难度等级: [0.5309, 0.5323) || 挂载数据: 无 ) 
│   │   │   ├── 分布式系统 --> ( 难度等级: [0.5309, 0.5314) || 挂载数据: 无 ) 
│   │   │   │   ├── 分布式系统的误区 --> ( 难度等级: [0.5309, 0.5311) || 挂载数据: blog: 1 ) 
│   │   │   │   └── CAP定理 --> ( 难度等级: [0.5311, 0.5314) || 挂载数据: 无 ) 
│   │   │   ├── 十二要素应用 --> ( 难度等级: [0.5314, 0.5318) || 挂载数据: 无 ) 
│   │   │   └── 可用性和服务等级协议 --> ( 难度等级: [0.5318, 0.5323) || 挂载数据: 无 ) 
│   │   ├── 云原生基础 --> ( 难度等级: [0.5323, 0.5336) || 挂载数据: 无 ) 
│   │   │   ├── 无服务器架构 --> ( 难度等级: [0.5323, 0.5326) || 挂载数据: 无 ) 
│   │   │   ├── 函数计算 --> ( 难度等级: [0.5326, 0.5329) || 挂载数据: 无 ) 
│   │   │   │   ├── 编写单一用途的函数 --> ( 难度等级: [0.5326, 0.5327) || 挂载数据: 无 ) 
│   │   │   │   ├── 避免串联函数 --> ( 难度等级: [0.5327, 0.5327) || 挂载数据: 无 ) 
│   │   │   │   ├── 函数应保持轻量和简单 --> ( 难度等级: [0.5327, 0.5328) || 挂载数据: 无 ) 
│   │   │   │   ├── 实现无状态函数 --> ( 难度等级: [0.5328, 0.5328) || 挂载数据: 无 ) 
│   │   │   │   ├── 分离函数入口和函数的业务逻辑 --> ( 难度等级: [0.5328, 0.5329) || 挂载数据: blog: 1 ) 
│   │   │   │   └── 避免长时间运行的函数 --> ( 难度等级: [0.5329, 0.5329) || 挂载数据: 无 ) 
│   │   │   ├── 从虚拟机到云原生 --> ( 难度等级: [0.5329, 0.5333) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 提升和转变 --> ( 难度等级: [0.5329, 0.533) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── 应用的现代化改造 --> ( 难度等级: [0.533, 0.5332) || 挂载数据: 无 ) 
│   │   │   │   └── 应用的优化 --> ( 难度等级: [0.5332, 0.5333) || 挂载数据: 无 ) 
│   │   │   └── 微服务 --> ( 难度等级: [0.5333, 0.5336) || 挂载数据: 无 ) 
│   │   │       ├── 微服务架构的优势 --> ( 难度等级: [0.5333, 0.5334) || 挂载数据: 无 ) 
│   │   │       └── 微服务架构带来的挑战 --> ( 难度等级: [0.5334, 0.5336) || 挂载数据: 无 ) 
│   │   ├── 云原生应用的设计 --> ( 难度等级: [0.5336, 0.5349) || 挂载数据: 无 ) 
│   │   │   ├── 云原生应用的基础 --> ( 难度等级: [0.5336, 0.5338) || 挂载数据: blog: 103 ) 
│   │   │   │   ├── 精益运营 --> ( 难度等级: [0.5336, 0.5337) || 挂载数据: 无 ) 
│   │   │   │   ├── 安全性 --> ( 难度等级: [0.5337, 0.5337) || 挂载数据: 无 ) 
│   │   │   │   └── 可扩展性与成本 --> ( 难度等级: [0.5337, 0.5338) || 挂载数据: blog: 1 ) 
│   │   │   ├── 云原生与传统架构的对比 --> ( 难度等级: [0.5338, 0.5339) || 挂载数据: blog: 10 ) 
│   │   │   ├── API设计与版本控制 --> ( 难度等级: [0.5339, 0.5341) || 挂载数据: 无 ) 
│   │   │   │   ├── API的前后兼容 --> ( 难度等级: [0.5339, 0.534) || 挂载数据: blog: 3 ) 
│   │   │   │   └── 语义版本号 --> ( 难度等级: [0.534, 0.5341) || 挂载数据: 无 ) 
│   │   │   ├── 服务间的通信 --> ( 难度等级: [0.5341, 0.5343) || 挂载数据: 无 ) 
│   │   │   │   ├── 通信协议 --> ( 难度等级: [0.5341, 0.5341) || 挂载数据: 无 ) 
│   │   │   │   ├── 消息协议 --> ( 难度等级: [0.5341, 0.5341) || 挂载数据: 无 ) 
│   │   │   │   ├── 序列化的考虑因素 --> ( 难度等级: [0.5341, 0.5341) || 挂载数据: 无 ) 
│   │   │   │   ├── 幂等性 --> ( 难度等级: [0.5341, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 请求与响应 --> ( 难度等级: [0.5342, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 发布者与订阅者 --> ( 难度等级: [0.5342, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 发布者/订阅者模式与请求/响应模式间的选择 --> ( 难度等级: [0.5342, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 同步与异步 --> ( 难度等级: [0.5342, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 设计时考虑前后兼容性 --> ( 难度等级: [0.5342, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 封装好服务避免泄露内部细节 --> ( 难度等级: [0.5342, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 优先考虑异步通信 --> ( 难度等级: [0.5342, 0.5342) || 挂载数据: 无 ) 
│   │   │   │   ├── 使用高效的序列化技术 --> ( 难度等级: [0.5342, 0.5343) || 挂载数据: 无 ) 
│   │   │   │   ├── 用批处理来提高请求处理的效率 --> ( 难度等级: [0.5343, 0.5343) || 挂载数据: 无 ) 
│   │   │   │   └── 拆分大的消息 --> ( 难度等级: [0.5343, 0.5343) || 挂载数据: 无 ) 
│   │   │   ├── 网关 --> ( 难度等级: [0.5343, 0.5344) || 挂载数据: 无 ) 
│   │   │   │   ├── 路由 --> ( 难度等级: [0.5343, 0.5343) || 挂载数据: 无 ) 
│   │   │   │   ├── 聚合 --> ( 难度等级: [0.5343, 0.5344) || 挂载数据: 无 ) 
│   │   │   │   ├── 卸载 --> ( 难度等级: [0.5344, 0.5344) || 挂载数据: 无 ) 
│   │   │   │   └── 网关的实现 --> ( 难度等级: [0.5344, 0.5344) || 挂载数据: 无 ) 
│   │   │   ├── 出口网关 --> ( 难度等级: [0.5344, 0.5346) || 挂载数据: 无 ) 
│   │   │   ├── 服务网格 --> ( 难度等级: [0.5346, 0.5348) || 挂载数据: 无 ) 
│   │   │   └── 架构示例 --> ( 难度等级: [0.5348, 0.5349) || 挂载数据: 无 ) 
│   │   ├── 数据处理 --> ( 难度等级: [0.5349, 0.5363) || 挂载数据: 无 ) 
│   │   │   ├── 数据存储系统 --> ( 难度等级: [0.5349, 0.5352) || 挂载数据: 无 ) 
│   │   │   │   ├── 对象、文件和磁盘 --> ( 难度等级: [0.5349, 0.535) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据库 --> ( 难度等级: [0.535, 0.535) || 挂载数据: 无 ) 
│   │   │   │   ├── 流和队列 --> ( 难度等级: [0.535, 0.5351) || 挂载数据: 无 ) 
│   │   │   │   ├── 区块链 --> ( 难度等级: [0.5351, 0.5351) || 挂载数据: blog: 3 ) 
│   │   │   │   └── 数据存储的选择 --> ( 难度等级: [0.5351, 0.5352) || 挂载数据: 无 ) 
│   │   │   ├── 多数据存储下的数据 --> ( 难度等级: [0.5352, 0.5354) || 挂载数据: 无 ) 
│   │   │   │   ├── 捕获数据更改 --> ( 难度等级: [0.5352, 0.5352) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 将更改作为事件写入更改日志 --> ( 难度等级: [0.5352, 0.5353) || 挂载数据: 无 ) 
│   │   │   │   ├── 事务监管 --> ( 难度等级: [0.5353, 0.5353) || 挂载数据: 无 ) 
│   │   │   │   ├── 事务回滚 --> ( 难度等级: [0.5353, 0.5353) || 挂载数据: 无 ) 
│   │   │   │   └── 提取、转换和加载 --> ( 难度等级: [0.5353, 0.5354) || 挂载数据: 无 ) 
│   │   │   ├── 客户端访问数据 --> ( 难度等级: [0.5354, 0.5356) || 挂载数据: 无 ) 
│   │   │   │   ├── 受限的客户令牌（代客密钥） --> ( 难度等级: [0.5354, 0.5355) || 挂载数据: 无 ) 
│   │   │   │   ├── 细粒度访问控制的数据库服务 --> ( 难度等级: [0.5355, 0.5355) || 挂载数据: 无 ) 
│   │   │   │   └── GraphQL数据服务 --> ( 难度等级: [0.5355, 0.5356) || 挂载数据: 无 ) 
│   │   │   ├── 可快速伸缩的数据 --> ( 难度等级: [0.5356, 0.5358) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据分片 --> ( 难度等级: [0.5356, 0.5357) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据缓存 --> ( 难度等级: [0.5357, 0.5358) || 挂载数据: 无 ) 
│   │   │   │   └── 内容分发网络 --> ( 难度等级: [0.5358, 0.5358) || 挂载数据: 无 ) 
│   │   │   ├── 数据分析 --> ( 难度等级: [0.5358, 0.5361) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 数据流 --> ( 难度等级: [0.5358, 0.5359) || 挂载数据: 无 ) 
│   │   │   │   ├── 批处理 --> ( 难度等级: [0.5359, 0.5359) || 挂载数据: 无 ) 
│   │   │   │   ├── 对象存储上的数据湖 --> ( 难度等级: [0.5359, 0.536) || 挂载数据: 无 ) 
│   │   │   │   ├── 数据湖和数据仓库 --> ( 难度等级: [0.536, 0.536) || 挂载数据: 无 ) 
│   │   │   │   └── 分布式查询引擎 --> ( 难度等级: [0.536, 0.5361) || 挂载数据: 无 ) 
│   │   │   └── Kubernetes中的数据库 --> ( 难度等级: [0.5361, 0.5363) || 挂载数据: 无 ) 
│   │   │       ├── StatefulSet --> ( 难度等级: [0.5361, 0.5362) || 挂载数据: 无 ) 
│   │   │       └── DaemonSet --> ( 难度等级: [0.5362, 0.5363) || 挂载数据: 无 ) 
│   │   ├── DevOps --> ( 难度等级: [0.5363, 0.5376) || 挂载数据: 无 ) 
│   │   │   ├── 什么是DevOps --> ( 难度等级: [0.5363, 0.5365) || 挂载数据: blog: 40 ) 
│   │   │   │   ├── 协作 --> ( 难度等级: [0.5363, 0.5363) || 挂载数据: 无 ) 
│   │   │   │   ├── 自动化 --> ( 难度等级: [0.5363, 0.5364) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 精益原则和流程 --> ( 难度等级: [0.5364, 0.5364) || 挂载数据: 无 ) 
│   │   │   │   ├── 度量 --> ( 难度等级: [0.5364, 0.5364) || 挂载数据: 无 ) 
│   │   │   │   └── 分享 --> ( 难度等级: [0.5364, 0.5365) || 挂载数据: 无 ) 
│   │   │   ├── 测试 --> ( 难度等级: [0.5365, 0.5367) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试替身 --> ( 难度等级: [0.5365, 0.5365) || 挂载数据: 无 ) 
│   │   │   │   ├── 自动化测试金字塔 --> ( 难度等级: [0.5365, 0.5366) || 挂载数据: 无 ) 
│   │   │   │   ├── 不同测试类型的适用时机 --> ( 难度等级: [0.5366, 0.5366) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试节奏 --> ( 难度等级: [0.5366, 0.5366) || 挂载数据: 无 ) 
│   │   │   │   └── 在生产环境中测试 --> ( 难度等级: [0.5366, 0.5367) || 挂载数据: 无 ) 
│   │   │   ├── 开发环境和工具 --> ( 难度等级: [0.5367, 0.5369) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发工具 --> ( 难度等级: [0.5367, 0.5367) || 挂载数据: 无 ) 
│   │   │   │   ├── 开发环境 --> ( 难度等级: [0.5367, 0.5367) || 挂载数据: blog: 4 ) 
│   │   │   │   ├── 本地开发环境 --> ( 难度等级: [0.5367, 0.5368) || 挂载数据: 无 ) 
│   │   │   │   ├── 本地开发环境结合远端集群 --> ( 难度等级: [0.5368, 0.5368) || 挂载数据: 无 ) 
│   │   │   │   ├── Skaffold开发工作流 --> ( 难度等级: [0.5368, 0.5368) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 将远端集群路由到本地开发环境 --> ( 难度等级: [0.5368, 0.5368) || 挂载数据: 无 ) 
│   │   │   │   └── 云端开发环境 --> ( 难度等级: [0.5368, 0.5369) || 挂载数据: 无 ) 
│   │   │   ├── 持续集成/持续交付 --> ( 难度等级: [0.5369, 0.5371) || 挂载数据: 无 ) 
│   │   │   │   ├── 源代码管理 --> ( 难度等级: [0.5369, 0.5369) || 挂载数据: 无 ) 
│   │   │   │   ├── 构建阶段 --> ( 难度等级: [0.5369, 0.5369) || 挂载数据: 无 ) 
│   │   │   │   ├── 测试阶段 --> ( 难度等级: [0.5369, 0.537) || 挂载数据: 无 ) 
│   │   │   │   ├── 部署阶段 --> ( 难度等级: [0.537, 0.537) || 挂载数据: 无 ) 
│   │   │   │   ├── 发布阶段 --> ( 难度等级: [0.537, 0.537) || 挂载数据: 无 ) 
│   │   │   │   └── 发布后阶段 --> ( 难度等级: [0.537, 0.5371) || 挂载数据: 无 ) 
│   │   │   ├── 监控 --> ( 难度等级: [0.5371, 0.5373) || 挂载数据: 无 ) 
│   │   │   │   ├── 收集指标 --> ( 难度等级: [0.5371, 0.5372) || 挂载数据: 无 ) 
│   │   │   │   └── 服务的可观测性 --> ( 难度等级: [0.5372, 0.5373) || 挂载数据: 无 ) 
│   │   │   ├── 配置管理 --> ( 难度等级: [0.5373, 0.5374) || 挂载数据: 无 ) 
│   │   │   │   ├── 单一环境变量 --> ( 难度等级: [0.5373, 0.5373) || 挂载数据: 无 ) 
│   │   │   │   ├── 将配置数据放入存储卷中 --> ( 难度等级: [0.5373, 0.5373) || 挂载数据: 无 ) 
│   │   │   │   ├── 密钥保存 --> ( 难度等级: [0.5373, 0.5374) || 挂载数据: 无 ) 
│   │   │   │   └── 部署配置 --> ( 难度等级: [0.5374, 0.5374) || 挂载数据: 无 ) 
│   │   │   └── 持续集成/持续交付流程示例 --> ( 难度等级: [0.5374, 0.5376) || 挂载数据: 无 ) 
│   │   ├── 可移植性 --> ( 难度等级: [0.5376, 0.539) || 挂载数据: 无 ) 
│   │   │   ├── 可移植性的代价 --> ( 难度等级: [0.5376, 0.5383) || 挂载数据: 无 ) 
│   │   │   └── 何时及如何实现可移植性 --> ( 难度等级: [0.5383, 0.539) || 挂载数据: 无 ) 
│   │   │       ├── 标准化的接口 --> ( 难度等级: [0.5383, 0.5384) || 挂载数据: 无 ) 
│   │   │       ├── 共用的服务和功能 --> ( 难度等级: [0.5384, 0.5385) || 挂载数据: 无 ) 
│   │   │       ├── 抽象和分层 --> ( 难度等级: [0.5385, 0.5386) || 挂载数据: 无 ) 
│   │   │       ├── 第三方服务商的托管服务 --> ( 难度等级: [0.5386, 0.5388) || 挂载数据: 无 ) 
│   │   │       ├── 可移植性工具 --> ( 难度等级: [0.5388, 0.5389) || 挂载数据: 无 ) 
│   │   │       └── 把Kubernetes作为可移植性层 --> ( 难度等级: [0.5389, 0.539) || 挂载数据: 无 ) 
│   │   ├── 理论篇（技术进阶） --> ( 难度等级: [0.539, 0.5403) || 挂载数据: 无 ) 
│   │   │   ├── 鸟瞰云上Kubernetes --> ( 难度等级: [0.539, 0.5391) || 挂载数据: 无 ) 
│   │   │   │   ├── 内容概要 --> ( 难度等级: [0.539, 0.539) || 挂载数据: 无 ) 
│   │   │   │   ├── 云资源层 --> ( 难度等级: [0.539, 0.539) || 挂载数据: blog: 2 ) 
│   │   │   │   │   ├── 专有版 --> ( 难度等级: [0.539, 0.539) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 托管版 --> ( 难度等级: [0.539, 0.539) || 挂载数据: 无 ) 
│   │   │   │   │   └── Serverless版 --> ( 难度等级: [0.539, 0.539) || 挂载数据: 无 ) 
│   │   │   │   ├── 单机系统层 --> ( 难度等级: [0.539, 0.5391) || 挂载数据: 无 ) 
│   │   │   │   ├── 集群系统层 --> ( 难度等级: [0.5391, 0.5391) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 专有版 --> ( 难度等级: [0.5391, 0.5391) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 托管版 --> ( 难度等级: [0.5391, 0.5391) || 挂载数据: 无 ) 
│   │   │   │   │   └── Serverless版 --> ( 难度等级: [0.5391, 0.5391) || 挂载数据: 无 ) 
│   │   │   │   └── 功能扩展层 --> ( 难度等级: [0.5391, 0.5391) || 挂载数据: 无 ) 
│   │   │   │       └── 日志 --> ( 难度等级: [0.5391, 0.5391) || 挂载数据: 无 ) 
│   │   │   ├── 认识集群的大脑 --> ( 难度等级: [0.5391, 0.5392) || 挂载数据: 无 ) 
│   │   │   │   ├── 从控制器视角看集群 --> ( 难度等级: [0.5391, 0.5392) || 挂载数据: 无 ) 
│   │   │   │   └── 控制器示例 --> ( 难度等级: [0.5392, 0.5392) || 挂载数据: 无 ) 
│   │   │   │       ├── 服务控制器 --> ( 难度等级: [0.5392, 0.5392) || 挂载数据: blog: 1 ) 
│   │   │   │       └── 路由控制器 --> ( 难度等级: [0.5392, 0.5392) || 挂载数据: 无 ) 
│   │   │   ├── 网络与通信原理 --> ( 难度等级: [0.5392, 0.5394) || 挂载数据: 无 ) 
│   │   │   │   ├── 背景 --> ( 难度等级: [0.5392, 0.5393) || 挂载数据: 无 ) 
│   │   │   │   ├── 阿里云Kubernetes集群网络大图 --> ( 难度等级: [0.5393, 0.5393) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 集群网络搭建 --> ( 难度等级: [0.5393, 0.5393) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 初始阶段 --> ( 难度等级: [0.5393, 0.5393) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 集群阶段 --> ( 难度等级: [0.5393, 0.5393) || 挂载数据: blog: 2 ) 
│   │   │   │   │   ├── 节点阶段 --> ( 难度等级: [0.5393, 0.5393) || 挂载数据: 无 ) 
│   │   │   │   │   └── Pod阶段 --> ( 难度等级: [0.5393, 0.5393) || 挂载数据: 无 ) 
│   │   │   │   └── 通信原理 --> ( 难度等级: [0.5393, 0.5394) || 挂载数据: 无 ) 
│   │   │   ├── 节点伸缩的实现 --> ( 难度等级: [0.5394, 0.5395) || 挂载数据: 无 ) 
│   │   │   │   ├── 节点增加原理 --> ( 难度等级: [0.5394, 0.5394) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 手动添加已有节点 --> ( 难度等级: [0.5394, 0.5394) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 自动添加已有节点 --> ( 难度等级: [0.5394, 0.5394) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 集群扩容 --> ( 难度等级: [0.5394, 0.5394) || 挂载数据: 无 ) 
│   │   │   │   │   └── 自动伸缩 --> ( 难度等级: [0.5394, 0.5394) || 挂载数据: 无 ) 
│   │   │   │   ├── 节点减少原理 --> ( 难度等级: [0.5394, 0.5395) || 挂载数据: 无 ) 
│   │   │   │   └── 节点池原理 --> ( 难度等级: [0.5395, 0.5395) || 挂载数据: 无 ) 
│   │   │   ├── 简洁的服务模型 --> ( 难度等级: [0.5395, 0.5397) || 挂载数据: 无 ) 
│   │   │   │   ├── 服务的本质是什么 --> ( 难度等级: [0.5395, 0.5395) || 挂载数据: 无 ) 
│   │   │   │   ├── 自带通信员 --> ( 难度等级: [0.5395, 0.5396) || 挂载数据: 无 ) 
│   │   │   │   ├── 让服务照进现实 --> ( 难度等级: [0.5396, 0.5396) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Netfilter的实现 --> ( 难度等级: [0.5396, 0.5397) || 挂载数据: 无 ) 
│   │   │   │       ├── 过滤器框架 --> ( 难度等级: [0.5396, 0.5396) || 挂载数据: 无 ) 
│   │   │   │       ├── 节点网络大图 --> ( 难度等级: [0.5396, 0.5396) || 挂载数据: 无 ) 
│   │   │   │       ├── 升级过滤器框架 --> ( 难度等级: [0.5396, 0.5396) || 挂载数据: 无 ) 
│   │   │   │       └── 用自定义链实现服务的反向代理 --> ( 难度等级: [0.5396, 0.5397) || 挂载数据: 无 ) 
│   │   │   ├── 镜像下载自动化 --> ( 难度等级: [0.5397, 0.5398) || 挂载数据: 无 ) 
│   │   │   │   ├── 镜像下载这件小事 --> ( 难度等级: [0.5397, 0.5397) || 挂载数据: 无 ) 
│   │   │   │   ├── 理解OAuth 2.0协议 --> ( 难度等级: [0.5397, 0.5397) || 挂载数据: blog: 76 ) 
│   │   │   │   ├── Docker扮演的角色 --> ( 难度等级: [0.5397, 0.5397) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 整体结构 --> ( 难度等级: [0.5397, 0.5397) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 理解docker login --> ( 难度等级: [0.5397, 0.5397) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── 拉取镜像是怎么回事 --> ( 难度等级: [0.5397, 0.5397) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Kubernetes实现的私有镜像自动拉取 --> ( 难度等级: [0.5397, 0.5398) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 基本功能 --> ( 难度等级: [0.5397, 0.5397) || 挂载数据: 无 ) 
│   │   │   │   │   └── 进阶方式 --> ( 难度等级: [0.5397, 0.5398) || 挂载数据: 无 ) 
│   │   │   │   └── 阿里云实现的ACR credential helper --> ( 难度等级: [0.5398, 0.5398) || 挂载数据: blog: 59 ) 
│   │   │   ├── 日志服务的集成 --> ( 难度等级: [0.5398, 0.5399) || 挂载数据: 无 ) 
│   │   │   │   ├── 日志服务介绍 --> ( 难度等级: [0.5398, 0.5398) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── 采集方案介绍 --> ( 难度等级: [0.5398, 0.5399) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 方案简介 --> ( 难度等级: [0.5398, 0.5398) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 运行流程 --> ( 难度等级: [0.5398, 0.5399) || 挂载数据: 无 ) 
│   │   │   │   │   └── 配置方式 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: 无 ) 
│   │   │   │   └── 核心技术介绍 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: 无 ) 
│   │   │   │       ├── 背景 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: 无 ) 
│   │   │   │       ├── 实现方式 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: 无 ) 
│   │   │   │       └── alibaba-log-controller内部实现 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: blog: 1 ) 
│   │   │   ├── 集群与存储系统 --> ( 难度等级: [0.5399, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   ├── 从应用的状态谈起 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 无状态的应用 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: 无 ) 
│   │   │   │   │   └── 有状态的应用 --> ( 难度等级: [0.5399, 0.5399) || 挂载数据: 无 ) 
│   │   │   │   ├── 基本单元：Pod Volume --> ( 难度等级: [0.5399, 0.54) || 挂载数据: 无 ) 
│   │   │   │   ├── 核心设计：PVC与PV体系 --> ( 难度等级: [0.54, 0.54) || 挂载数据: 无 ) 
│   │   │   │   ├── 与特定存储系统解耦 --> ( 难度等级: [0.54, 0.54) || 挂载数据: 无 ) 
│   │   │   │   │   ├── Volume Plugin --> ( 难度等级: [0.54, 0.54) || 挂载数据: 无 ) 
│   │   │   │   │   ├── in-tree（内置） Volume Plugin --> ( 难度等级: [0.54, 0.54) || 挂载数据: blog: 1 ) 
│   │   │   │   │   └── out-of-tree（外置） Volume Plugin --> ( 难度等级: [0.54, 0.54) || 挂载数据: 无 ) 
│   │   │   │   ├── Kubernetes CSI管控组件容器化部署 --> ( 难度等级: [0.54, 0.54) || 挂载数据: 无 ) 
│   │   │   │   └── 基于Kubernetes的存储 --> ( 难度等级: [0.54, 0.5401) || 挂载数据: 无 ) 
│   │   │   ├── 流量路由Ingress --> ( 难度等级: [0.5401, 0.5402) || 挂载数据: 无 ) 
│   │   │   │   ├── 基本原理 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 基础用法 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 配置安全路由 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 全局配置和局部配置 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   │   └── 实现原理 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   ├── 场景化需求 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: blog: 1 ) 
│   │   │   │   │   ├── 多入口访问Ingress --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   │   └── 部署多套Ingress Controller --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   ├── 获取客户端真实IP地址 --> ( 难度等级: [0.5401, 0.5402) || 挂载数据: 无 ) 
│   │   │   │   │   ├── 理解客户端真实IP地址的传递过程 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   │   ├── ExternalTrafficPolicy的影响 --> ( 难度等级: [0.5401, 0.5401) || 挂载数据: 无 ) 
│   │   │   │   │   └── 如何获取客户端真实IP地址 --> ( 难度等级: [0.5401, 0.5402) || 挂载数据: 无 ) 
│   │   │   │   └── 白名单功能 --> ( 难度等级: [0.5402, 0.5402) || 挂载数据: 无 ) 
│   │   │   └── 升级设计与实现 --> ( 难度等级: [0.5402, 0.5403) || 挂载数据: 无 ) 
│   │   │       ├── 升级预检 --> ( 难度等级: [0.5402, 0.5402) || 挂载数据: 无 ) 
│   │   │       │   ├── 核心组件检查项 --> ( 难度等级: [0.5402, 0.5402) || 挂载数据: 无 ) 
│   │   │       │   └── 前置检查增项 --> ( 难度等级: [0.5402, 0.5402) || 挂载数据: 无 ) 
│   │   │       ├── 原地升级与替代升级 --> ( 难度等级: [0.5402, 0.5403) || 挂载数据: 无 ) 
│   │   │       │   ├── 原地升级 --> ( 难度等级: [0.5402, 0.5403) || 挂载数据: 无 ) 
│   │   │       │   └── 替代升级 --> ( 难度等级: [0.5403, 0.5403) || 挂载数据: 无 ) 
│   │   │       └── 升级三部曲 --> ( 难度等级: [0.5403, 0.5403) || 挂载数据: 无 ) 
│   │   │           ├── 升级Master节点 --> ( 难度等级: [0.5403, 0.5403) || 挂载数据: 无 ) 
│   │   │           ├── 升级Worker节点 --> ( 难度等级: [0.5403, 0.5403) || 挂载数据: 无 ) 
│   │   │           └── 核心组件升级 --> ( 难度等级: [0.5403, 0.5403) || 挂载数据: 无 ) 
│   │   └── 实践篇（诊断之美） --> ( 难度等级: [0.5403, 0.5417) || 挂载数据: 无 ) 
│   │       ├── 节点就绪状态异常（一） --> ( 难度等级: [0.5403, 0.5405) || 挂载数据: 无 ) 
│   │       │   ├── Docker栈 --> ( 难度等级: [0.5403, 0.5404) || 挂载数据: 无 ) 
│   │       │   │   ├── docker daemon调用栈分析 --> ( 难度等级: [0.5403, 0.5404) || 挂载数据: 无 ) 
│   │       │   │   └── Containerd调用栈分析 --> ( 难度等级: [0.5404, 0.5404) || 挂载数据: 无 ) 
│   │       │   ├── 什么是D-Bus --> ( 难度等级: [0.5404, 0.5405) || 挂载数据: 无 ) 
│   │       │   │   ├── runC请求D-Bus --> ( 难度等级: [0.5404, 0.5404) || 挂载数据: blog: 1 ) 
│   │       │   │   └── 原因并不在D-Bus --> ( 难度等级: [0.5404, 0.5405) || 挂载数据: 无 ) 
│   │       │   └── Systemd是硬骨头 --> ( 难度等级: [0.5405, 0.5405) || 挂载数据: blog: 2 ) 
│   │       │       ├── “没用”的core dump --> ( 难度等级: [0.5405, 0.5405) || 挂载数据: blog: 1 ) 
│   │       │       ├── 零散的信息 --> ( 难度等级: [0.5405, 0.5405) || 挂载数据: 无 ) 
│   │       │       ├── 代码分析 --> ( 难度等级: [0.5405, 0.5405) || 挂载数据: 无 ) 
│   │       │       └── Live Debugging --> ( 难度等级: [0.5405, 0.5405) || 挂载数据: 无 ) 
│   │       ├── 节点就绪状态异常（二） --> ( 难度等级: [0.5405, 0.5408) || 挂载数据: 无 ) 
│   │       │   ├── 节点状态机 --> ( 难度等级: [0.5405, 0.5406) || 挂载数据: 无 ) 
│   │       │   ├── 就绪三分钟 --> ( 难度等级: [0.5406, 0.5406) || 挂载数据: 无 ) 
│   │       │   ├── 止步不前的PLEG --> ( 难度等级: [0.5406, 0.5407) || 挂载数据: 无 ) 
│   │       │   ├── 无响应的Terwayd --> ( 难度等级: [0.5407, 0.5407) || 挂载数据: 无 ) 
│   │       │   ├── 原因 --> ( 难度等级: [0.5407, 0.5407) || 挂载数据: 无 ) 
│   │       │   └── 修复 --> ( 难度等级: [0.5407, 0.5408) || 挂载数据: 无 ) 
│   │       ├── 命名空间回收机制失效 --> ( 难度等级: [0.5408, 0.541) || 挂载数据: 无 ) 
│   │       │   ├── 集群管控入口 --> ( 难度等级: [0.5408, 0.5408) || 挂载数据: 无 ) 
│   │       │   ├── 命名空间控制器的行为 --> ( 难度等级: [0.5408, 0.5409) || 挂载数据: 无 ) 
│   │       │   │   ├── 删除收纳盒里的资源 --> ( 难度等级: [0.5408, 0.5408) || 挂载数据: 无 ) 
│   │       │   │   ├── API、Group、Version --> ( 难度等级: [0.5408, 0.5408) || 挂载数据: 无 ) 
│   │       │   │   └── 控制器不能删除命名空间里的资源 --> ( 难度等级: [0.5408, 0.5409) || 挂载数据: 无 ) 
│   │       │   ├── 回到集群管控入口 --> ( 难度等级: [0.5409, 0.5409) || 挂载数据: 无 ) 
│   │       │   ├── 节点与Pod的通信 --> ( 难度等级: [0.5409, 0.5409) || 挂载数据: 无 ) 
│   │       │   └── 集群节点访问云资源 --> ( 难度等级: [0.5409, 0.541) || 挂载数据: 无 ) 
│   │       ├── 网络安全组加固对与错 --> ( 难度等级: [0.541, 0.5412) || 挂载数据: 无 ) 
│   │       │   ├── 安全组扮演的角色 --> ( 难度等级: [0.541, 0.5411) || 挂载数据: 无 ) 
│   │       │   ├── 安全组与集群网络 --> ( 难度等级: [0.5411, 0.5411) || 挂载数据: 无 ) 
│   │       │   └── 怎么管理安全组规则 --> ( 难度等级: [0.5411, 0.5412) || 挂载数据: 无 ) 
│   │       │       ├── 限制集群访问外网 --> ( 难度等级: [0.5411, 0.5412) || 挂载数据: 无 ) 
│   │       │       ├── IDC与集群互访 --> ( 难度等级: [0.5412, 0.5412) || 挂载数据: blog: 1 ) 
│   │       │       └── 使用新的安全组管理节点 --> ( 难度等级: [0.5412, 0.5412) || 挂载数据: 无 ) 
│   │       ├── 网格应用存活状态异常 --> ( 难度等级: [0.5412, 0.5414) || 挂载数据: 无 ) 
│   │       │   ├── 代理与代理的生命周期管理 --> ( 难度等级: [0.5412, 0.5413) || 挂载数据: 无 ) 
│   │       │   ├── 控制面和数据面 --> ( 难度等级: [0.5413, 0.5413) || 挂载数据: 无 ) 
│   │       │   ├── 简单的原因 --> ( 难度等级: [0.5413, 0.5414) || 挂载数据: 无 ) 
│   │       │   └── 阿里云服务网格（ASM）介绍 --> ( 难度等级: [0.5414, 0.5414) || 挂载数据: blog: 10 ) 
│   │       └── 网格自签名根证书过期 --> ( 难度等级: [0.5414, 0.5417) || 挂载数据: 无 ) 
│   │           ├── 连续重启的Citadel --> ( 难度等级: [0.5414, 0.5415) || 挂载数据: 无 ) 
│   │           ├── 一般意义上的证书验证 --> ( 难度等级: [0.5415, 0.5415) || 挂载数据: 无 ) 
│   │           ├── 自签名证书验证失败 --> ( 难度等级: [0.5415, 0.5416) || 挂载数据: 无 ) 
│   │           ├── 大神定理 --> ( 难度等级: [0.5416, 0.5416) || 挂载数据: 无 ) 
│   │           ├── Citadel证书体系 --> ( 难度等级: [0.5416, 0.5416) || 挂载数据: 无 ) 
│   │           └── 经验 --> ( 难度等级: [0.5416, 0.5417) || 挂载数据: 无 ) 
│   ├── DevOps --> ( 难度等级: [0.5417, 0.5833) || 挂载数据: 无 ) 
│   │   ├── 运维 --> ( 难度等级: [0.5417, 0.5521) || 挂载数据: 无 ) 
│   │   │   └── 配置 --> ( 难度等级: [0.5417, 0.5521) || 挂载数据: 无 ) 
│   │   │       ├── CUE(Cisco Unity Express) --> ( 难度等级: [0.5417, 0.5434) || 挂载数据: blog: 8 ) 
│   │   │       ├── Jsonnet --> ( 难度等级: [0.5434, 0.5451) || 挂载数据: 无 ) 
│   │   │       ├── HCL --> ( 难度等级: [0.5451, 0.5469) || 挂载数据: 无 ) 
│   │   │       ├── BCL --> ( 难度等级: [0.5469, 0.5486) || 挂载数据: 无 ) 
│   │   │       ├── KubeVela --> ( 难度等级: [0.5486, 0.5503) || 挂载数据: 无 ) 
│   │   │       └── Terraform --> ( 难度等级: [0.5503, 0.5521) || 挂载数据: blog: 7 ) 
│   │   ├── API --> ( 难度等级: [0.5521, 0.5625) || 挂载数据: 无 ) 
│   │   │   ├── GraphQL --> ( 难度等级: [0.5521, 0.5556) || 挂载数据: 无 ) 
│   │   │   ├── Swagger UI --> ( 难度等级: [0.5556, 0.559) || 挂载数据: 无 ) 
│   │   │   └── gRPC --> ( 难度等级: [0.559, 0.5625) || 挂载数据: 无 ) 
│   │   ├── 诊断 --> ( 难度等级: [0.5625, 0.5729) || 挂载数据: 无 ) 
│   │   │   ├── OpenTracing标准 --> ( 难度等级: [0.5625, 0.5646) || 挂载数据: 无 ) 
│   │   │   ├── SkyWalking --> ( 难度等级: [0.5646, 0.5667) || 挂载数据: 无 ) 
│   │   │   ├── Zipkin --> ( 难度等级: [0.5667, 0.5687) || 挂载数据: 无 ) 
│   │   │   ├── Jaeger --> ( 难度等级: [0.5687, 0.5708) || 挂载数据: 无 ) 
│   │   │   └── Sonobuoy --> ( 难度等级: [0.5708, 0.5729) || 挂载数据: 无 ) 
│   │   └── 质量 --> ( 难度等级: [0.5729, 0.5833) || 挂载数据: 无 ) 
│   │       ├── Litmus --> ( 难度等级: [0.5729, 0.5781) || 挂载数据: 无 ) 
│   │       └── Sysbench --> ( 难度等级: [0.5781, 0.5833) || 挂载数据: 无 ) 
│   ├── 操作系统 --> ( 难度等级: [0.5833, 0.625) || 挂载数据: 无 ) 
│   │   ├── CoreOS --> ( 难度等级: [0.5833, 0.5972) || 挂载数据: blog: 1 ) 
│   │   ├── Alibaba Linux --> ( 难度等级: [0.5972, 0.6111) || 挂载数据: 无 ) 
│   │   └── Tencent Linux --> ( 难度等级: [0.6111, 0.625) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.625, 0.6667) || 挂载数据: 无 ) 
├── 云原生高阶-应用开发 --> ( 难度等级: [0.6667, 0.8333) || 挂载数据: 无 ) 
│   ├── Serverless --> ( 难度等级: [0.6667, 0.7222) || 挂载数据: 无 ) 
│   │   └── BaaS Serverless --> ( 难度等级: [0.6667, 0.7222) || 挂载数据: 无 ) 
│   │       ├── Spring Cloud Connector --> ( 难度等级: [0.6667, 0.6944) || 挂载数据: 无 ) 
│   │       └── Open Service Broker --> ( 难度等级: [0.6944, 0.7222) || 挂载数据: 无 ) 
│   ├── 编程语言 --> ( 难度等级: [0.7222, 0.7778) || 挂载数据: 无 ) 
│   │   └── Java --> ( 难度等级: [0.7222, 0.7778) || 挂载数据: blog: 120 ) 
│   │       ├── 减小镜像 --> ( 难度等级: [0.7222, 0.7407) || 挂载数据: 无 ) 
│   │       │   ├── Alpine Portola --> ( 难度等级: [0.7222, 0.7284) || 挂载数据: 无 ) 
│   │       │   ├── JDK (version >= 9) --> ( 难度等级: [0.7284, 0.7346) || 挂载数据: 无 ) 
│   │       │   └── Spring Boot (version > 2.3) --> ( 难度等级: [0.7346, 0.7407) || 挂载数据: 无 ) 
│   │       ├── 降低资源占用率 --> ( 难度等级: [0.7407, 0.7593) || 挂载数据: 无 ) 
│   │       │   ├── Project Panama --> ( 难度等级: [0.7407, 0.75) || 挂载数据: 无 ) 
│   │       │   └── Project Valhalla --> ( 难度等级: [0.75, 0.7593) || 挂载数据: 无 ) 
│   │       └── 缩短冷启动时间 --> ( 难度等级: [0.7593, 0.7778) || 挂载数据: 无 ) 
│   │           ├── GraalVM --> ( 难度等级: [0.7593, 0.7639) || 挂载数据: blog: 2 ) 
│   │           ├── Quarkus --> ( 难度等级: [0.7639, 0.7685) || 挂载数据: blog: 1 ) 
│   │           ├── Micronaut --> ( 难度等级: [0.7685, 0.7731) || 挂载数据: 无 ) 
│   │           └── Helidon --> ( 难度等级: [0.7731, 0.7778) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.7778, 0.8333) || 挂载数据: 无 ) 
├── 云原生高阶-平台开发 --> ( 难度等级: [0.8333, 1.0) || 挂载数据: 无 ) 
│   ├── Kubernetes --> ( 难度等级: [0.8333, 0.875) || 挂载数据: 无 ) 
│   │   ├── 接口 --> ( 难度等级: [0.8333, 0.8542) || 挂载数据: 无 ) 
│   │   │   ├── CNI(Container Network Interface) --> ( 难度等级: [0.8333, 0.8403) || 挂载数据: 无 ) 
│   │   │   │   ├── Flannel --> ( 难度等级: [0.8333, 0.8342) || 挂载数据: 无 ) 
│   │   │   │   ├── Calico --> ( 难度等级: [0.8342, 0.8351) || 挂载数据: 无 ) 
│   │   │   │   ├── Weave --> ( 难度等级: [0.8351, 0.8359) || 挂载数据: 无 ) 
│   │   │   │   ├── OVN(Open Virtual Network) --> ( 难度等级: [0.8359, 0.8368) || 挂载数据: 无 ) 
│   │   │   │   ├── SR-IOV(Single-root Input/Output Virtualization) --> ( 难度等级: [0.8368, 0.8377) || 挂载数据: blog: 1 ) 
│   │   │   │   ├── Romana --> ( 难度等级: [0.8377, 0.8385) || 挂载数据: 无 ) 
│   │   │   │   ├── OpenContrail --> ( 难度等级: [0.8385, 0.8394) || 挂载数据: 无 ) 
│   │   │   │   └── Kuryr --> ( 难度等级: [0.8394, 0.8403) || 挂载数据: 无 ) 
│   │   │   ├── CRI(Container Runtime Interface) --> ( 难度等级: [0.8403, 0.8472) || 挂载数据: 无 ) 
│   │   │   │   └── Frakti --> ( 难度等级: [0.8403, 0.8472) || 挂载数据: 无 ) 
│   │   │   └── CSI(Container Storage Interface) --> ( 难度等级: [0.8472, 0.8542) || 挂载数据: 无 ) 
│   │   │       ├── FlexVolume --> ( 难度等级: [0.8472, 0.8507) || 挂载数据: 无 ) 
│   │   │       └── GlusterFS --> ( 难度等级: [0.8507, 0.8542) || 挂载数据: 无 ) 
│   │   └── PaaS --> ( 难度等级: [0.8542, 0.875) || 挂载数据: 无 ) 
│   │       ├── Cloud Foundry --> ( 难度等级: [0.8542, 0.8594) || 挂载数据: blog: 6 ) 
│   │       ├── Crossplane --> ( 难度等级: [0.8594, 0.8646) || 挂载数据: 无 ) 
│   │       ├── Anthos --> ( 难度等级: [0.8646, 0.8698) || 挂载数据: 无 ) 
│   │       └── KubeSphere --> ( 难度等级: [0.8698, 0.875) || 挂载数据: 无 ) 
│   ├── DevOps --> ( 难度等级: [0.875, 0.9167) || 挂载数据: 无 ) 
│   │   └── 运维 --> ( 难度等级: [0.875, 0.9167) || 挂载数据: 无 ) 
│   │       └── 编程 --> ( 难度等级: [0.875, 0.9167) || 挂载数据: 无 ) 
│   │           ├── Operator --> ( 难度等级: [0.875, 0.8854) || 挂载数据: 无 ) 
│   │           ├── Pulumi --> ( 难度等级: [0.8854, 0.8958) || 挂载数据: 无 ) 
│   │           ├── Ballerina --> ( 难度等级: [0.8958, 0.9062) || 挂载数据: 无 ) 
│   │           └── cdk8s --> ( 难度等级: [0.9062, 0.9167) || 挂载数据: 无 ) 
│   ├── 中间件 --> ( 难度等级: [0.9167, 0.9583) || 挂载数据: 无 ) 
│   │   ├── 数据库 --> ( 难度等级: [0.9167, 0.9375) || 挂载数据: 无 ) 
│   │   │   └── Database Mesh --> ( 难度等级: [0.9167, 0.9375) || 挂载数据: 无 ) 
│   │   └── 大数据 --> ( 难度等级: [0.9375, 0.9583) || 挂载数据: 无 ) 
│   │       ├── Kubeflow --> ( 难度等级: [0.9375, 0.9444) || 挂载数据: 无 ) 
│   │       ├── Fluid --> ( 难度等级: [0.9444, 0.9514) || 挂载数据: 无 ) 
│   │       └── KubeTEE --> ( 难度等级: [0.9514, 0.9583) || 挂载数据: 无 ) 
│   └── 其他 --> ( 难度等级: [0.9583, 1.0) || 挂载数据: 无 ) 
└── 其他 --> ( 难度等级: [0, 0) || 挂载数据: 无 ) 
    ├── 其他类别标签问题 --> ( 难度等级: [0, 0) || 挂载数据: 无 ) 
    ├── 应用类问题 --> ( 难度等级: [0, 0) || 挂载数据: 无 ) 
    └── 第三方包问题 --> ( 难度等级: [0, 0) || 挂载数据: 无 )