2025年最新款Go开发工程师教程【46.6GB】--MK
下载地址：**** Hidden Message *****
【课程目录】
├─00 电子书
│├─01 第1周：go基础知识
││ 01 1. go基本数据类型.html
││ 02 2. 数据类型的转换.html
││ 03 3. 运算符和表达式.html
││ 04 4. 转义符.html
││ 05 5. 输出格式化.html
││
│├─02 第4周 从0开始理解rpc和grpc
││ 01 1. 课程需要用到的开发环境介绍.html
││ 02 2. 安装docker-compose.html
││ 03 3. 安装navicat和mysql.html
││ 04 4. 虚拟环境的安装和配置.html
││ 05 5. go的安装和配置.html
││ 06 6. nodejs的安装和配置.html
││ 07 7. go语言编码规范.html
││ 08 8. 什么是rpc.html
││ 09 9. rpc、http以及restful 之间的区.html
││ 10 10. rpc开发的要素分析.html
││ 11 11. go语言的rpc之hello world.html
││ 12 12. 什么是grpc和protobuf.html
││ 13 13. go的grpc开发体验.html
││ 14 14. grpc的四种数据流.html
││
│├─03 第5周 grpc和protobuf进阶
││ 01 1. protobuf官方文档参考.html
││ 02 2. go控制grpc的metadata.html
││ 03 3. grpc拦截器 - go.html
││ 04 4. token认证.html
││ 05 5. grpc验证器.html
││ 06 6. grpc中的异常处理.html
││
│├─04 第6周 yapi文档管理、gorm详解
││ 01 1. docker安装yapi.html
││ 02 2. 接口数据下载.html
││
│├─05 第7周 gin快速入门
││ 01 gorm是什么.html
││ 02 1. 快速入门.html
││ 03 2. url和路由分组.html
││ 04 3. 获取参数.html
││ 05 4. JSON、ProtoBuf 渲染.html
││ 06 5. 表单验证.html
││ 07 6. 中间件和next函数.html
││ 08 7. 设置静态文件路径和html文件.html
││ 09 8. 优雅重启或停止.html
││
│├─06 第9周 用户服务的web服务
││ 01 1. go 日志库 zap.html
││ 02 2. go的配置文件管理-viper.html
││ 03 3. 自定义验证器.html
││ 04 4. json web token（jwt）详解.html
││ 05 5. jwt集成gin.html
││ 06 6. 浏览器的跨域请求问题.html
││ 07 7. 图形验证码.html
││ 08 8. 阿里云发送短信.html
││ 09 9. redis的安装.html
││
│├─07 第10周 服务注册发现、配置中心、负载均衡
││ 01 1. 什么是服务注册和发现.html
││ 02 2. consul的安装和配置.html
││ 03 3. consul的api接口.html
││ 04 4. go操作consul.html
││ 05 5. grpc下的健康检查.html
││ 06 6. 动态获取可用端口号.html
││ 07 7. 负载均衡策略.html
││ 08 8.常见的负载均衡算法.html
││ 09 9. grpc的负载均衡策略.html
││ 10 10. 为什么需要分布式配置中心.html
││ 11 11. 分布式配置中心选型.html
││ 12 12. nacos的安装和配置.html
││ 13 13. nacos的基本使用.html
││ 14 14. gin集成nacos.html
││
│├─08 第11周 商品微服务的grpc服务
││ 01 1. model定义.html
││ 02 2. protobuf定义.html
││ 03 3. 商品列表页功能.html
││ 04 4. 库存的微服务设计.html
││ 05 5. 商品分类的各个函数.html
││ 06 6. 轮播图的各个handler.html
││ 07 7. 品牌相关的接口.html
││ 08 8. 品牌分类接口.html
││
│├─09 第12周 商品微服务的gin层和oss图片服务
││ 01 1. 商品列表接口.html
││ 02 2. 新建商品.html
││ 03 3. 删除，更新商品.html
││ 04 4. 商品分类接口.html
││ 05 5. 轮播图接口.html
││ 06 6. 品牌分类.html
││ 07 7. oss快速入门.html
││ 08 8. 阿里云oss开发入门.html
││ 09 9. 服务端签名直传.html
││ 10 10. 内网穿透.html
││ 11 11. 项目文档和资源.html
││
│├─10 第13周 库存服务和分布式锁
││ 01 1. 库存服务架构设计.html
││ 02 2. 库存服务表结构.html
││ 03 3. 为什么需要分布式锁.html
││ 04 4. mysql的for update实现悲观锁.html
││ 05 5. 基于redis实现分布式锁.html
││ 06 6. redlock详解.html
││ 07 7. 常见的分布式锁实现方案.html
││
│├─11 第14周 订单和购物车微服务
││ 01 1. 表结构设计和proto文件定义.html
││ 02 2. 支付宝支付的相关链接.html
││ 03 3. 用户操作 - 表结构设计.html
││ 04 4. 用户服务 - proto定义.html
││ 05 5. service代码.html
││ 06 6. userop-web代码.html
││
│├─12 第16周 elasticsearch实现搜索微服务
││ 01 1. 什么是elasticsearch.html
││ 02 2. elasticsearch安装.html
││ 03 3. es中的type、index、mapping.html
││ 04 4. 新建数据.html
││ 05 5. 获取数据.html
││ 06 6. 更新和删除数据.html
││ 07 7. 批量插入和批量查询.html
││ 08 8. query dsl查询.html
││ 09 9. mapping.html
││ 10 10. Elasticsearch Analyze.html
││ 11 11. 分词的重要性.html
││ 12 12. ik分词器安装和配置.html
││ 13 13. es集成到mxshop_srvs.html
││ 14 14. 倒排索引算法 - 扩展文档.html
││
│├─13 第17周 分布式理论基础、分布式事务解决方案
││ 01 1. 事务和分布式事务.html
││ 02 2. 程序出哪些问题会导致数据不一致.html
││ 03 3. CAP和BASE理论.html
││ 04 4. 两_三阶段提交.html
││ 05 5. tcc分布式事务.html
││ 06 6. 基于本地消息表的最终一致性.html
││ 07 7. 基于可靠消息的最终一致性- 最常用.html
││ 08 8. 最大努力通知.html
││ 09 9. mq（message queue）的使用场景.html
││ 10 10. mq技术选型.html
││ 11 11. rocketmq安装和配置.html
││ 12 12. rocketmq的基本概念.html
││ 13 13. rocketmq的消息类型.html
││ 14 14. go操作rocketmq开发环境搭建.html
││ 15 15. 什么是服务雪崩.html
││ 16 16. grpc的超时和重试.html
││ 17 17. 常见的幂等性解决方案.html
││
│├─14 第19周 链路追踪、限流、熔断、降级
││ 01 1. 什么是链路追踪.html
││ 02 2. 链路追踪技术选型.html
││ 03 3. jaeger安装和架构.html
││ 04 4. opentracing解析.html
││ 05 5. grpc下添加jaeger.html
││ 06 6. 熔断、限流技术选型.html
││
│├─15 第20周 api网关、部署
││ 01 1. api网关对比.html
││ 02 2. kong的安装和配置.html
││ 03 3. 配置jwt.html
││ 04 4. 什么是敏捷开发.html
││ 05 5. jenkin的安装和配置.html
││ 06 6. jenkins的插件管理.html
││ 07 7. 部署到远程服务器并运行.html
││ 08 8. jenkins的pipeline参数详解.html
││ 09 9. 定时构建的语法.html
││ 10 10. shell脚本启动go服务.html
││
│├─16 第21周 开发规范和go基础扩展
││ 01 1. 有哪些规范我们应该遵循.html
││ 02 2. git的简单规范.html
││ 03 3. go代码规范.html
││ 04 4. go项目目录规范.html
││ 05 5. 微服务该采用multi-repo还是mono-repo.html
││ 06 6. 微服务的目录结构（ mono-repo）.html
││ 07 7. go代码的检测工具.html
││ 08 8. go中常见的错误.html
││
│├─17 第22周 设计模式和单元测试
││ 01 1. go最常用的设计模式 - 函数选项.html
││ 02 2. 单例模式和懒加载.html
││ 03 3. 测试金字塔.html
││
│├─18 第23周 protoc插件开发、cobra命令行
││ 01 1. protoc调试源码.html
││ 02 2. protoc自定义gin插件.html
││ 03 cobra快速入门.html
││
│├─19 第24周 log日志包设计
││ 01 日志源码.html
││
│├─20 第25周 ast代码生成工具开发
││ 01 错误码.html
││
│├─21 第26周 三层代码结构
││ 01 通用app项目启动.html
││
│├─22 第27周 grpc服务封装更方便的rpc服务
││ 01 host.go源码.html
││
│├─23 第28周 深入grpc的服务注册、负载均衡原理
││ 01 服务发现源码.html
││ 02 负载均衡相关源码.html
││
│├─24 第30周 可观测的终极解决方案
││ 01 opentelemetry.html
││
│├─25 第31周 系统监控核心
││ 01 metric源码.html
││ 02 安装 prometheus、 grafana.html
││
│├─26 34周 通过k8s部署服务
││ 01 docker介绍.html
││ 02 docker 网络相关.html
││ 03 dockerfile.html
││ 04 docker外部数据挂载.html
││ 05 镜像相关操作.html
││ 06 容器相关命令.html
││ 07 安装kubesphere.html
││ 08 k8s技术选型.html
││ 09 kubernets 安装redis.html
││ 10 kubesphere安装mysql.html
││
│├─27 第34+周 devops和k8s
││ 01 jenkinsfile执行docker的坑.html
││ 02 kubesphere的ingress的坑.html
││ 03 k8s中的基础概念 - pod.html
││ 04 k8s的控制器.html
││ 05 课程总结.html
││
│└─28 总结
│ 01 总结.html
│
├─01 阶段一：Go语言基础入门和并发编程
│├─01 Go基础知识入门
││├─01 第1章 2022新版go工程师体系课导学以及Go的发展
│││ 01 1-1 Go开发工程师体系课全新版导学 最近学习.mp4
│││ 02 1-2 go语言介绍 （1450）.mp4
│││
││├─02 第2章 go开发环境搭建
│││ 01 2-1 go的安装 （0842）.mp4
│││ 02 2-2 goland安装和快捷键 （0920）.mp4
│││ 03 2-3 go开发之hello-world （1008）.mp4
│││
││├─03 第3章 变量和常量
│││ 01 3-1 如何定义变量 （1803）.mp4
│││ 02 3-2 常量的定义和使用 （1021）.mp4
│││ 03 3-3 iota的使用细节 （1346）.mp4
│││ 04 3-4 匿名变量的定义和用途 （0345）.mp4
│││ 05 3-5 变量的作用域 （0642）.mp4
│││
││├─04 第4章 go的基础数据类型
│││ 01 4-1 数值、浮点数和字符类型 （1902）.mp4
│││ 02 4-2 基本类型的转换 （1141）.mp4
│││ 03 4-3 format进行格式化转换 （1422）.mp4
│││ 04 4-4 运算符和表达式 （1553）.mp4
│││
││├─05 第5章 字符串基本操作
│││ 01 5-1 rune和字符串长度 （0915）.mp4
│││ 02 5-2 转义符是什么 （0746）.mp4
│││ 03 5-3 格式化输出 （1222）.mp4
│││ 04 5-4 高性能字符串拼接 - strings.builder （0405）.mp4
│││ 05 5-5 字符串的比较 （0259）.mp4
│││ 06 5-6 字符串操作常用方法 （1432）.mp4
│││
││└─06 第6章 条件判断和for循环
││ 01 6-1 if条件判断 （1006）.mp4
││ 02 6-2 for循环基础用法 （0749）.mp4
││ 03 6-3 for循环打印九九乘法表 （0553）.mp4
││ 04 6-4 for range的循环用法 （1335）.mp4
││ 05 6-5 for循环的continue和break语句 （0404）.mp4
││ 06 6-6 goto语句的基本用法 （0630）.mp4
││ 07 6-7 switch语法 （1018）.mp4
││
│├─02 容器，go编程思想
││├─01 第1章 数组、切片和map
│││ 01 1-1 数组的基本用法 （0940）.mp4
│││ 02 1-2 数组的初始化 （0523）.mp4
│││ 03 1-3 多维数组 （0941）.mp4
│││ 04 1-4 切片的定义和赋值 （0713）.mp4
│││ 05 1-5 切片的多种初始化方式 （1043）.mp4
│││ 06 1-6 切片的数据访问 （0603）.mp4
│││ 07 1-7 通过省略号添加多个元素到切片 （0437）.mp4
│││ 08 1-8 切片的元素删除和拷贝 （0849）.mp4
│││ 09 1-9 为什么需要懂切片的原理 （0508）.mp4
│││ 10 1-10 切片的底层存储原理 （2121）.mp4
│││ 11 1-11 map的初始化和赋值 （1219）.mp4
│││ 12 1-12 map进行for循环遍历的坑 （0555）.mp4
│││ 13 1-13 判断map中是否存在元素和删除元素 （0749）.mp4
│││ 14 1-14 list和slice的区别 （0703）.mp4
│││ 15 1-15 list的基本用法 （1300）.mp4
│││
││├─02 第2章 函数
│││ 01 2-1 函数的定义 （1304）.mp4
│││ 02 2-2 函数的可变参数 （0853）.mp4
│││ 03 2-3 函数一等公民特性 （1525）.mp4
│││ 04 2-4 go函数的闭包特性 （0939）.mp4
│││ 05 2-5 defer的应用场景 （1113）.mp4
│││ 06 2-6 go的error设计理念 （0723）.mp4
│││ 07 2-7 如何正确使用recover和panic （1111）.mp4
│││
││├─03 第3章 结构体
│││ 01 3-1 type关键字的用法 （1352）.mp4
│││ 02 3-2 结构体的定义和初始化 （1212）.mp4
│││ 03 3-3 匿名结构体 （0543）.mp4
│││ 04 3-4 结构体嵌套 （0916）.mp4
│││ 05 3-5 结构体定义方法 （1132）.mp4
│││
││├─04 第4章 指针
│││ 01 4-1 指针的定义和使用 （1601）.mp4
│││ 02 4-2 指针的初始化 （0757）.mp4
│││ 03 4-3 通过swap交换指针的值 （1043）.mp4
│││ 04 4-4 nil在go中的细节 （1422）.mp4
│││
││└─05 第5章 接口
││ 01 5-1 什么是鸭子类型 （1138）.mp4
││ 02 5-2 如何定义接口 （0755）.mp4
││ 03 5-3 多接口的实现 （1016）.mp4
││ 04 5-4 通过interface解决动态类型传参 （0903）.mp4
││ 05 5-5 通过switch语句进行类型判断 （0600）.mp4
││ 06 5-6 接口嵌套 （0643）.mp4
││ 07 5-7 接口遇到了slice的常见错误 （0721）.mp4
││
│└─03 Go并发编程和工程管理
│ ├─01 第1章 package和go modules
│ │ 01 1-1 package的定义和导入 最近学习.mp4
│ │ 02 1-2 import各种姿势 （0641）.mp4
│ │ 03 1-3 go.mod文件的下载方式 （0636）.mp4
│ │ 04 1-4 设置GOProxy国内镜像 （0608）.mp4
│ │ 05 1-5 go get、go mod相关命令 （0606）.mp4
│ │ 06 1-6 go mod replace的应用场景 （0708）.mp4
│ │ 07 1-7 go编码规范 （2027）.mp4
│ │
│ ├─02 第2章 单元测试
│ │ 01 2-1 如何写单元测试用例 （0943）.mp4
│ │ 02 2-2 如何跳过耗时的单元测试用例 （0335）.mp4
│ │ 03 2-3 基于表格驱动测试 （0408）.mp4
│ │ 04 2-4 benchmark性能测试 （1016）.mp4
│ │
│ └─03 第3章 并发编程
│ 01 3-1 go并发编程初体验 （2223）.mp4
│ 02 3-2 go的gmp调度原理 （1729）.mp4
│ 03 3-3 通过waitgroup等待协程的执行 （0816）.mp4
│ 04 3-4 通过mutex和atomic完成全局变量的原子操作 （1737）.mp4
│ 05 3-5 RWMutex读写锁 （1615）.mp4
│ 06 3-6 通过channel进行goroutine之间的通信 （1621）.mp4
│ 07 3-7 有缓冲channel和无缓冲channel的应用场景 （0321）.mp4
│ 08 3-8 for range对channel进行遍历 （0728）.mp4
│ 09 3-9 单向channel的应用场景 （1017）.mp4
│ 10 3-10 通过channel实现交叉打印 （0855）.mp4
│ 11 3-11 监控goroutine的执行 （0746）.mp4
│ 12 3-12 select 完成对多个channel的监控 （1643）.mp4
│ 13 3-13 通过context解决goroutine的信息传递 （2120）.mp4
│ 14 3-14 witchvalue、withtimeout的应用场景 （1006）.mp4
│
├─02 阶段二：Go电商项目- 微服务基础
│├─01 从0开始理解rpc和grpc
││├─01 第1章 开发环境搭建
│││ 01 1-1 课程学习前的说明 - 很重要！！ （1015）.mp4
│││ 02 1-2 课程中需要用到的开发环境介绍 （0630）.mp4
│││ 03 1-3 windows中安装centos7虚拟机 （1659）.mp4
│││ 04 1-4 xshell的安装和使用 （0340）.mp4
│││ 05 1-5 git的安装和配置 （0541）.mp4
│││ 06 1-6 docker和docker-compose的安装 （1031）.mp4
│││ 07 1-7 mysql和navicat的安装和配置 （1009）.mp4
│││ 08 1-8 windows下安装nodejs开发环境 （0438）.mp4
│││ 09 1-9 linux下安装和配置nodejs开发环境 （0432）.mp4
│││ 10 1-10 代码提示神器 - kite的安装和配置 （0719）.mp4
│││
││├─02 第2章 rpc核心概念理解
│││ 01 2-1 gopath开发模式和go modules开发模式对比 （2140）.mp4
│││ 02 2-2 go编码规范-1 （2039）.mp4
│││ 03 2-3 go编码规范-2 （1539）.mp4
│││ 04 2-4 什么是rpcrpc开发的挑战是什么-1 （2250）.mp4
│││ 05 2-5 什么是rpcrpc开发的挑战是什么- 2 （2149）.mp4
│││ 06 2-6 通过http完成add服务端的功能 （1635）.mp4
│││ 07 2-7 通过http完成add客户端的功能 （0711）.mp4
│││ 08 2-8 rpc架构技术要点 （0544）.mp4
│││
││├─03 第3章 go内置rpc快速开发
│││ 01 3-1 go快速体验rpc开发 （2259）.mp4
│││ 02 3-2 替换rpc的序列化协议为json （2117）.mp4
│││ 03 3-3 替换rpc的传输协议为http （0929）.mp4
│││ 04 3-4 进一步改造rpc调用的代码-1 （1746）.mp4
│││ 05 3-5 进一步改造rpc调用的代码-2 （1720）.mp4
│││
││└─04 第4章 grpc快速入门
││ 01 4-1 什么是grpc和protobuf （1334）.mp4
││ 02 4-2 grpc开发环境的搭建 （0751）.mp4
││ 03 4-3 goland下配置protobuf插件 （0957）.mp4
││ 04 4-4 protobuf和json的直观对比 （1934）.mp4
││ 05 4-5 为什么我们需要安装protoc和protoc-gen-go （1150）.mp4
││ 06 4-6 go下grpc快速体验 （2446）.mp4
││ 07 4-7 grpc的流模式的定义 （2027）.mp4
││ 08 4-8 grpc的单向流，双向流代码实现 （2240）.mp4
││
│├─02 grpc和protobuf进阶
││└─01 第1章 protobuf和grpc进阶
││ 01 1-1 protobuf的基本类型和默认值 （0955）.mp4
││ 02 1-2 option go_package的作用 （0637）.mp4
││ 03 1-3 proto文件同步时的坑 （1659）.mp4
││ 04 1-4 proto文件中import另一个proto文件 （1049）.mp4
││ 05 1-5 嵌套的message对象 （0817）.mp4
││ 06 1-6 protobuf中的enum枚举类型 （0707）.mp4
││ 07 1-7 map类型 （0511）.mp4
││ 08 1-8 使用protobuf内置的timestamp类型 （0644）.mp4
││ 09 1-9 grpc的metadata机制 （2008）.mp4
││ 10 1-10 grpc拦截器 （2001）.mp4
││ 11 1-11 通过拦截器和metadata实现grpc的auth认证 （1703）.mp4
││ 12 1-12 grpc的验证器 （1436）.mp4
││ 13 1-13 1-12-2grpc的验证器 （1520）.mp4
││ 14 1-14 grpc的状态码 （0716）.mp4
││ 15 1-15 grpc中的错误处理 （0930）.mp4
││ 16 1-16 grpc的超时机制 （0619）.mp4
││ 17 1-17 protoc生成的go的源码里面有什么 （1225）.mp4
││
│├─03 yapi文档管理、gorm详解
││├─01 第1章 项目需求分析
│││ 01 1-1 如何启动电商系统和后台管理系统 （0420）.mp4
│││ 02 1-2 后台管理系统需求 （0514）.mp4
│││ 03 1-3 电商系统需求分析 （0544）.mp4
│││
││├─02 第2章 单体应用到到微服务架构演进
│││ 01 2-1 单体应用如何部署 （1034）.mp4
│││ 02 2-2 单体应用开发痛点 （1346）.mp4
│││ 03 2-3 单体应用的架构演变 （1719）.mp4
│││ 04 2-4 服务拆分变动 （0829）.mp4
│││ 05 2-5 微服务的基本拆分 （0938）.mp4
│││ 06 2-6 分层微服务架构 （1104）.mp4
│││ 07 2-7 微服务需要解决的问题 - 重要！！ （1926）.mp4
│││
││├─03 第3章 yapi的安装和配置
│││ 01 3-1 前后端分离的系统开发演变过程 （0908）.mp4
│││ 02 3-2 接口文档管理之痛 （0701）.mp4
│││ 03 3-3 yapi的安装和配置 （1224）.mp4
│││ 04 3-4 yapi基本功能使用 （1617）.mp4
│││ 05 3-5 接口的导入和导出 （1012）.mp4
│││
││└─04 第4章 gorm快速入门
││ 01 4-1 什么是orm如何正确看待orm （1518）.mp4
││ 02 4-2 gorm连接数据库 （1257）.mp4
││ 03 4-3 快速体验auto migrate功能 （1225）.mp4
││ 04 4-4 gorm的Model的逻辑删除 （0927）.mp4
││ 05 4-5 通过NullString解决不能更新零值的问题 （0810）.mp4
││ 06 4-6 表结构定义细节 （1453）.mp4
││ 07 4-7 通过create方法插入记录 （1322）.mp4
││ 08 4-8 批量插入和通过map插入记录 （1015）.mp4
││ 09 4-9 通过take，first、last获取数据 （1213）.mp4
││ 10 4-10 gorm的基本查询 （1847）.mp4
││ 11 4-11 gorm的更新操作 （0920）.mp4
││ 12 4-12 gorm的软删除细节 （0930）.mp4
││ 13 4-13 表的关联插入 （1459）.mp4
││ 14 4-14 通过preload和joins查询多表 （0809）.mp4
││ 15 4-15 has many关系 （1610）.mp4
││ 16 4-16 gorm处理多对多的关系 （1615）.mp4
││ 17 4-17 gorm的表名自定义、自定义beforecreate逻辑 （1110）.mp4
││
│└─04 gin快速入门
│ └─01 第1章 gin快速入门
│ 01 1-1 gin的helloworld体验 （1045）.mp4
│ 02 1-2 使用New和Default初始化路由器的区别 （0646）.mp4
│ 03 1-3 gin的路由分组 （0758）.mp4
│ 04 1-4 获取url中的变量 （1854）.mp4
│ 05 1-5 获取get和post表单信息 （1816）.mp4
│ 06 1-6 gin返回protobuf （1308）.mp4
│ 07 1-7 登录的表单验证 （1635）.mp4
│ 08 1-8 注册表单的验证 （1433）.mp4
│ 09 1-9 表单验证错误翻译成中文 （1606）.mp4
│ 10 1-10 表单中文翻译的json格式化细节 （0904）.mp4
│ 11 1-11 自定义gin中间件 （1621）.mp4
│ 12 1-12 通过abort终止中间件后续逻辑的执行 （1115）.mp4
│ 13 1-13 gin的中间件原理源码分析 （0922）.mp4
│ 14 1-14 gin返回html （2402）.mp4
│ 15 1-15 加载多个html文件 （1328）.mp4
│ 16 1-16 static静态文件的处理 （0511）.mp4
│ 17 1-17 gin的优雅退出 （1355）.mp4
│
├─03 阶段三：从0到1实现完整的微服务框架
│├─01 用户服务的grpc服务
││└─01 第1章 用户服务-service开发
││ 01 1-1 定义用户表结构 （1310）.mp4
││ 02 1-2 同步表结构 （0628）.mp4
││ 03 1-3 md5加密 （1658）.mp4
││ 04 1-4 md5盐值加密解决用户密码安全问题 （1830）.mp4
││ 05 1-5 定义proto接口 （1511）.mp4
││ 06 1-6 用户列表接口 （1935）.mp4
││ 07 1-7 通过id和mobile查询用户 （0702）.mp4
││ 08 1-8 新建用户 （0732）.mp4
││ 09 1-9 修改用户和校验密码接口 （1005）.mp4
││ 10 1-10 通过flag启动grpc服务 （0835）.mp4
││ 11 1-11 批量生产用户 （0527）.mp4
││ 12 1-12 测试用户微服务接口 （1309）.mp4
││ 13 1-13 课后作业 （0850）.mp4
││
│├─02 用户服务的web服务
││├─01 第1章 web层开发-基础项目架构
│││ 01 1-1 新建项目和目录结构构建 （0502）.mp4
│││ 02 1-2 go高性能日志库 - zap使用 （1429）.mp4
│││ 03 1-3 zap的文件输出 （0835）.mp4
│││ 04 1-4 集成zap和理由初始到gin的启动过程 - 1 （1343）.mp4
│││ 05 1-5 集成zap和理由初始到gin的启动过程 - 2 （1414）.mp4
│││ 06 1-6 gin调用grpc服务-1 （2047）.mp4
│││ 07 1-7 gin调用grpc服务-2 （2237）.mp4
│││ 08 1-8 配置文件 - viper （2409）.mp4
│││ 09 1-9 viper的配置环境开发环境和生产环境隔离 （1825）.mp4
│││ 10 1-10 viper集成到gin的web服务中 （1506）.mp4
│││
││└─02 第2章 web层开发-用户接口开发
││ 01 2-1 表单验证的初始化 （2544）.mp4
││ 02 2-2 自定义mobile验证器 （1252）.mp4
││ 03 2-3 登录逻辑完善 （1108）.mp4
││ 04 2-4 session机制在微服务下的问题 （0811）.mp4
││ 05 2-5 json web token的认证机制 （0957）.mp4
││ 06 2-6 集成jwt到gin中 （1941）.mp4
││ 07 2-7 给url添加登录权限验证 （1428）.mp4
││ 08 2-8 如何解决前后端的跨域问题 （2129）.mp4
││ 09 2-9 获取图片验证码 （2238）.mp4
││ 10 2-10 阿里云发送短信 （2106）.mp4
││ 11 2-11 redis保存验证码 （1906）.mp4
││ 12 2-12 用户注册接口 （2030）.mp4
││
│└─03 服务注册发现、配置中心、负载均衡
│ ├─01 第1章 注册中心-consul
│ │ 01 1-1 什么是服务注册和发现以及技术选型 （1617）.mp4
│ │ 02 1-2 consul的安装和配置 （1634）.mp4
│ │ 03 1-3 服务注册和注销 （1709）.mp4
│ │ 04 1-4 go集成consul （2120）.mp4
│ │ 05 1-5 为grpc服务添加viper和zap （1749）.mp4
│ │ 06 1-6 grpc服务如何进行健康检查 （0513）.mp4
│ │ 07 1-7 将grpc服务注册到consul中 （1257）.mp4
│ │ 08 1-8 gin集成consul （1719）.mp4
│ │ 09 1-9 将用户的grpc连接配置到全局共用 （0917）.mp4
│ │
│ ├─02 第2章 负载均衡
│ │ 01 2-1 动态获取可用端口 （1458）.mp4
│ │ 02 2-2 什么是负载均衡，负载均衡的策略有哪些 （2118）.mp4
│ │ 03 2-3 常用负载均衡算法 （0822）.mp4
│ │ 04 2-4 gin从consul中同步服务信息并进行负载均衡-1 （1602）.mp4
│ │ 05 2-5 grpc从consul中同步服务信息并进行负载均衡-2 （1524）.mp4
│ │ 06 2-6 gin集成grpc的负载均衡 （0632）.mp4
│ │
│ └─03 第3章 分布式配置中心
│ 01 3-1 为什么需要配置中心 （1441）.mp4
│ 02 3-2 配置中心选型-apollo vs nacos （0655）.mp4
│ 03 3-3 nacos的安装 （0514）.mp4
│ 04 3-4 nacos的组、配置集、命名空间 （1514）.mp4
│ 05 3-5 通过api获取nacos的配置以及nacos的配置更新 （2008）.mp4
│ 06 3-6 gin集成nacos （2300）.mp4
│ 07 3-7 service集成nacos （0727）.mp4
│
├─04 阶段四：微服务实现电商系统
│├─01 商品微服务的grpc服务
││└─01 第1章 商品服务-service服务
││ 01 1-1 需求分析-数据库实体分析 （1017）.mp4
││ 02 1-2 需求分析-商品微服务接口分析 （0919）.mp4
││ 03 1-3 商品分类表结构设计应该注意什么 （2112）.mp4
││ 04 1-4 品牌、轮播图表结构设计 （1117）.mp4
││ 05 1-5 商品表结构设计 （1616）.mp4
││ 06 1-6 生成表结构和导入数据 （0700）.mp4
││ 07 1-7 定义proto接口 （1634）.mp4
││ 08 1-8 快速启动grpc服务 （1851）.mp4
││ 09 1-9 品牌列表实现 （2107）.mp4
││ 10 1-10 品牌新建，删除、更新 （1150）.mp4
││ 11 1-11 轮播图的查询、新增、删除和修改 （0330）.mp4
││ 12 1-12 商品分类的列表接口 - 1 （1824）.mp4
││ 13 1-13 商品分类的列表接口 - 2 （1421）.mp4
││ 14 1-14 获取商品分类的子分类 （1504）.mp4
││ 15 1-15 商品分类的新建，删除和更新接口 （0501）.mp4
││ 16 1-16 品牌分类相关接口 （1551）.mp4
││ 17 1-17 商品列表页接口 - 1 （1703）.mp4
││ 18 1-18 商品列表页接口 - 2 （1336）.mp4
││ 19 1-19 商品列表页接口 - 3 （1718）.mp4
││ 20 1-20 批量获取商品信息、商品详情接口 （1149）.mp4
││ 21 1-21 新增、修改和删除商品接口 （0716）.mp4
││
│├─02 商品微服务的gin层和oss图片服务
││├─01 第1章 gin完成商品服务的http接口
│││ 01 1-1 快速将用户的web服务转换成商品的web服务 （1823）.mp4
│││ 02 1-2 商品的列表页接口 - 1 （1421）.mp4
│││ 03 1-3 商品的列表页接口 - 2 （1245）.mp4
│││ 04 1-4 如何设计一个符合go风格的注册中心接口 （2224）.mp4
│││ 05 1-5 gin的退出后的服务注销 （0520）.mp4
│││ 06 1-6 用户的web服务服务注册和优雅退出 （0541）.mp4
│││ 07 1-7 新建商品 （1912）.mp4
│││ 08 1-8 获取商品详情 （0927）.mp4
│││ 09 1-9 商品删除，更新 （1531）.mp4
│││ 10 1-10 商品分类的接口 （2210）.mp4
│││ 11 1-11 轮播图接口和yapi的快速测试 （1546）.mp4
│││ 12 1-12 品牌列表页接口 （0639）.mp4
│││ 13 1-13 品牌分类接口 （1111）.mp4
│││
││└─02 第2章 阿里云的oss服务集成
││ 01 2-1 为什么要使用阿里云oss （0710）.mp4
││ 02 2-2 oss的基本概念介绍 （1042）.mp4
││ 03 2-3 使用代码控制文件上传 （1749）.mp4
││ 04 2-4 前端直传oss的流程 （1415）.mp4
││ 05 2-5 gin集成前端直传文件 （2143）.mp4
││ 06 2-6 为什么我们需要内网穿透 （0850）.mp4
││ 07 2-7 内网穿透技术解决前端直传的回调 （1349）.mp4
││ 08 2-8 将oss集成到gin微服务中 （1456）.mp4
││
│├─03 库存服务和分布式锁
││├─01 第1章 库存服务
│││ 01 1-1 库存服务的重要性 （0743）.mp4
│││ 02 1-2 表结构设计 （1506）.mp4
│││ 03 1-3 proto接口设计 （2245）.mp4
│││ 04 1-4 快速启动库存服务 （0740）.mp4
│││ 05 1-5 设置库存和获取库存接口 （0807）.mp4
│││ 06 1-6 本地数据库事务解决库存扣减的失败问题 （1416）.mp4
│││ 07 1-7 订单超时归还的重要性 （0526）.mp4
│││ 08 1-8 测试库存接口 （2013）.mp4
│││ 09 1-9 为所有的商品添加库存信息 （0339）.mp4
│││
││└─02 第2章 分布式锁
││ 01 2-1 并发场景下的库存扣减不正确的问题 （0822）.mp4
││ 02 2-2 通过锁解决并发的问题 （1607）.mp4
││ 03 2-3 什么是分布式锁 （0736）.mp4
││ 04 2-4 悲观锁机制和mutex有什么关系 （0853）.mp4
││ 05 2-5 mysql的for update语句实现悲观锁 （1353）.mp4
││ 06 2-6 gorm实现for update悲观锁 （0608）.mp4
││ 07 2-7 基于mysql的乐观锁实现原理 （1312）.mp4
││ 08 2-8 gorm实现基于mysql的乐观锁 （1537）.mp4
││ 09 2-9 基于redsync的分布式锁实现同步 （1035）.mp4
││ 10 2-10 redsync集成到库存服务中 （0835）.mp4
││ 11 2-11 redis分布式锁源码解析 - setnx的作用 （1033）.mp4
││ 12 2-12 redis分布式锁源码解析 - 过期时间和延长锁过期时间机制 （1102）.mp4
││ 13 2-13 redis分布式锁源码解析 -如何防止锁被其他的goroutine删除 （0743）.mp4
││ 14 2-14 redis的分布式锁在集群环境之下容易出现的问题 （0723）.mp4
││ 15 2-15 redlock源码分析 （1625）.mp4
││
│├─04 订单和购物车微服务
││├─01 第1章 订单和购物车服务-service
│││ 01 1-1 需求分析 （0828）.mp4
│││ 02 1-2 订单相关表结构设计 （1835）.mp4
│││ 03 1-3 proto接口定义 （2308）.mp4
│││ 04 1-4 启动订单服务 （0401）.mp4
│││ 05 1-5 购物车列表和添加商品到购物车接口 （1525）.mp4
│││ 06 1-6 更新购物车、删除购物车记录接口 （0818）.mp4
│││ 07 1-7 订单列表页接口 （1328）.mp4
│││ 08 1-8 查询订单详情接口 （1608）.mp4
│││ 09 1-9 新建订单的流程分析 （1532）.mp4
│││ 10 1-10 订单微服务连接商品和库存微服务 （0825）.mp4
│││ 11 1-11 调用商品微服务查询商品基本信息 （1225）.mp4
│││ 12 1-12 调用库存微服务扣减库存 （0453）.mp4
│││ 13 1-13 通过mysql本地事务确保订单新建过程的顺利 （2103）.mp4
│││ 14 1-14 更新订单的状态接口 （0649）.mp4
│││ 15 1-15 订单服务接口调试 -1 （1915）.mp4
│││ 16 1-16 订单服务接口调试-2 （1524）.mp4
│││
││└─02 第2章 订单和购物车服务-web层
││ 01 2-1 快速启动订单服务 （2114）.mp4
││ 02 2-2 购物车列表页接口 （1719）.mp4
││ 03 2-3 添加商品到购物车 （1717）.mp4
││ 04 2-4 更新和删除购物车记录 （2529）.mp4
││ 05 2-5 订单列表页 （1932）.mp4
││ 06 2-6 订单详情接口开发和测试 （1225）.mp4
││ 07 2-7 新建订单接口开发和测试 （1124）.mp4
││
│├─05 支付宝支付、用户操作微服务、前后端联调
││├─01 第1章 支付宝支付
│││ 01 1-1 支付宝沙箱环境开发流程 （0543）.mp4
│││ 02 1-2 私钥、公钥的概念以及支付宝如何解决订单的安全性问题 （2009）.mp4
│││ 03 1-3 支付宝的公钥、私钥和回调url配置 （0829）.mp4
│││ 04 1-4 生成支付宝的支付url （1350）.mp4
│││ 05 1-5 gin集成支付宝支付 （1757）.mp4
│││ 06 1-6 支付宝回调通知url逻辑接口 （1854）.mp4
│││
││└─02 第2章 收藏、收货地址、留言服务开发
││ 01 2-1 需求分析 （0434）.mp4
││ 02 2-2 定义用户操作服务的表结构 （0833）.mp4
││ 03 2-3 定义proto接口 （0857）.mp4
││ 04 2-4 启动用户服务 （0521）.mp4
││ 05 2-5 service的handler源码解读 （1727）.mp4
││ 06 2-6 web服务启动 （1352）.mp4
││ 07 2-7 gin的api源码解读 （1919）.mp4
││ 08 2-8 通过yapi测试接口 （1002）.mp4
││
│└─06 elasticsearch实现搜索微服务
│ ├─01 第1章 elasticsearch常用接口
│ │ 01 1-1 我们为什么要用elasticsearch进行搜索_音频 （1342）.mp4
│ │ 02 1-2 安装elasticsearch和kibana （1137）.mp4
│ │ 03 1-3 elasticsearch中的基本概念 （0558）.mp4
│ │ 04 1-4 通过put和post方法添加数据 （1530）.mp4
│ │ 05 1-5 通过url和query body查询数据 （0856）.mp4
│ │ 06 1-6 通过es更新数据的坑 （0737）.mp4
│ │ 07 1-7 通过bulk和mget批量操作数据 （1303）.mp4
│ │ 08 1-8 一个完整的查询api是如何的-match查询 （0943）.mp4
│ │ 09 1-9 es是如何通过倒排索引查询数据的（1：30-2：30 代码小） （1302）.mp4
│ │ 10 1-10 match_phrase进行短语查询 （0446）.mp4
│ │ 11 1-11 通过multi_match指定查询字段权重 （0541）.mp4
│ │ 12 1-12 query_string查询和match_all查询 （0829）.mp4
│ │ 13 1-13 term查询有哪些需要注意的地方 （1232）.mp4
│ │ 14 1-14 range区间查询、exists查询、fuzzy模糊查询 （1224）.mp4
│ │ 15 1-15 bool复合查询- must、must_not、should、filter （0918）.mp4
│ │ 16 1-16 mapping中的keyword和text类型区别 （1417）.mp4
│ │ 17 1-17 match查询原理分析 - analyzer查询过程 （1457）.mp4
│ │ 18 1-18 分词对于elasticsearch为什么很重要 （1509）.mp4
│ │ 19 1-19 ik分词器的安装和使用 （1424）.mp4
│ │ 20 1-20 自定义分词器词库 （0747）.mp4
│ │
│ ├─02 第2章 将elasticsearch集成到项目中
│ │ 01 2-1 go实现match查询 （2227）.mp4
│ │ 02 2-2 将es中的对象转换为struct类型 （0514）.mp4
│ │ 03 2-3 保存数据到es中 （0542）.mp4
│ │ 04 2-4 通过go语言完成mapping的新建 （0508）.mp4
│ │ 05 2-5 有哪些接口需要使用es （0440）.mp4
│ │ 06 2-6 mysql和es分别在系统中的角色是什么 （0934）.mp4
│ │ 07 2-7 建立商品对应的struct和mapping （0824）.mp4
│ │ 08 2-8 启动gin的初始化过程新建index和mapping （1312）.mp4
│ │ 09 2-9 将mysql中的商品数据同步到es中 （1048）.mp4
│ │ 10 2-10 如何通过mysql和es协作完成商品的查询-1 （1425）.mp4
│ │ 11 2-11 如何通过mysql和es协作完成商品的查询-2 （1705）.mp4
│ │ 12 2-12 调试商品列表的es搜索 （0620）.mp4
│ │ 13 2-13 确保商品添加到es中的事务一致性 （1646）.mp4
│ │ 14 2-14 es实现商品的更新和商品的删除 （1245）.mp4
│ │
│ └─03 第3章 前后端联调
│ 01 3-1 项目启动前的url配置 （0757）.mp4
│ 02 3-2 后台管理系统-商品列表页联调 （0919）.mp4
│ 03 3-3 商品详情页联调 （1037）.mp4
│ 04 3-4 新增商品接口联调 （0710）.mp4
│ 05 3-5 商品分类联调 （1729）.mp4
│ 06 3-6 品牌管理联调 （0447）.mp4
│ 07 3-7 联调只读数据 （0755）.mp4
│ 08 3-8 电商系统-商品相关功能联调 （1012）.mp4
│ 09 3-9 登录相关页面功能联调 （0410）.mp4
│
├─05 阶段五：分布式系统核心、微服务的部署
│├─01 分布式理论基础、分布式事务解决方案
││├─01 第1章 电商系统中的库存归还、超时归还、事务等
│││ 01 1-1 为什么订单会有超时机制 最近学习.mp4
│││ 02 1-2 数据库事务的ACID特性 （1403）.mp4
│││ 03 1-3 分布式系统中出现哪些故障会导致数据不一致 （0937）.mp4
│││
││└─02 第2章 cap理论和分布式事务解决方案
││ 01 2-1 cap理论 （1616）.mp4
││ 02 2-2 BASE理论 （1040）.mp4
││ 03 2-3 2pc两阶段提交分布式事务 （1050）.mp4
││ 04 2-4 TCC分布式事务实现方案 （1106）.mp4
││ 05 2-5 TCC分布式事务实现方案 - 订单服务的tcc接口 （1338）.mp4
││ 06 2-6 TCC分布式事务实现方案 - tcc实现难点 （1308）.mp4
││ 07 2-7 基于本地消息的最终一致性方案 （1203）.mp4
││ 08 2-8 基于可靠消息的最终一致性 （1433）.mp4
││ 09 2-9 最大努力通知方案 （1448）.mp4
││
│├─02 学习rocketmq实现幂等性机制等
││├─01 第1章 mq的应用场景和选型
│││ 01 1-1 mq的应用场景 （1611）.mp4
│││ 02 1-2 mq消息队列技术选型 （1301）.mp4
│││
││├─02 第2章 rocketmq快速入门
│││ 01 2-1 rocketmq的安装和配置 （1651）.mp4
│││ 02 2-2 rocketmq的基本概念 （0546）.mp4
│││ 03 2-3 rocketmq的消息类型 （1301）.mp4
│││ 04 2-4 go发送普通消息 （1440）.mp4
│││ 05 2-5 通过pushconsumer消费消息 （1442）.mp4
│││ 06 2-6 为什么要使用延迟消息解决库存超时归还问题 （0859）.mp4
│││ 07 2-7 通过TransactionProducer发送事务消息 （1144）.mp4
│││ 08 2-8 测试rocketmq的事务消息 （0843）.mp4
│││
││├─03 第3章 基于可靠消息的最终一致性、订单超时归还
│││ 01 3-1 订单新建过程中会出现哪些不可控因素导致数据不一致的问题 （1333）.mp4
│││ 02 3-2 先扣减库存和后扣减库存是否能解决分布式事务的问题 （0552）.mp4
│││ 03 3-3 tcc在解决库存扣减中的问题 （0611）.mp4
│││ 04 3-4 基于可靠消息最终一致性方案在库存服务上的不足 （0905）.mp4
│││ 05 3-5 如何通过基于可靠消息实现库存的一致性 （0650）.mp4
│││ 06 3-6 在createorder中发送事务消息 （1029）.mp4
│││ 07 3-7 ExecuteLocalTransaction本地事务的逻辑 （1321）.mp4
│││ 08 3-8 本地事务消息回查应该如何做 （0507）.mp4
│││ 09 3-9 库存扣减服务中表结构的设计 （1137）.mp4
│││ 10 3-10 gorm定义具备嵌套对象的列 （0735）.mp4
│││ 11 3-11 库存服务的sell逻辑修改和归还逻辑重构 （1700）.mp4
│││ 12 3-12 测试库存服务和库存扣减历史记录 （1408）.mp4
│││ 13 3-13 测试rocketmq的事务回查后的库存归还 （1012）.mp4
│││ 14 3-14 在订单服务中发送延时消息解决库存归还的问题 （1600）.mp4
│││ 15 3-15 rocketmq中shutdown造成的坑 （1701）.mp4
│││
││└─04 第4章 实现接口的幂等性
││ 01 4-1 什么是服务雪崩 （1024）.mp4
││ 02 4-2 超时、重试和幂等性机制 （1036）.mp4
││ 03 4-3 哪些情况下需要考虑幂等性问题 （0748）.mp4
││ 04 4-4 使用grpc-middleware实现grpc调用的重试 （1025）.mp4
││ 05 4-5 常用的幂等性解决方案 （1202）.mp4
││
│├─03 链路追踪、限流、熔断、降级
││├─01 第1章 链路追踪技术概述
│││ 01 1-1 为什么我们需要链路追踪 （1232）.mp4
│││ 02 1-2 链路追踪技术选型 （0802）.mp4
│││ 03 1-3 jaeger的安装和架构介绍 （0919）.mp4
│││ 04 1-4 opentracing中的tracer、span、spancontext （1746）.mp4
│││
││├─02 第2章 go集成jaeger
│││ 01 2-1 go通过jaeger-client发送单个span （1616）.mp4
│││ 02 2-2 go发送多级嵌套span （1023）.mp4
│││ 03 2-3 go下通过grpc发送span消息 （1242）.mp4
│││ 04 2-4 gin中添加拦截器实现jaeger注入 （2340）.mp4
│││ 05 2-5 修改grpc_opentracing源码 （1936）.mp4
│││ 06 2-6 配置订单服务的web层逻辑 （0952）.mp4
│││ 07 2-7 grpc集成opentracing的原理 （0708）.mp4
│││ 08 2-8 grpc的server端如何获取客户端的span （2549）.mp4
│││
││└─03 第3章 熔断、限流 - sentinel
││ 01 3-1 什么是限流、熔断和降级 （1618）.mp4
││ 02 3-2 sentinel和hystrix对比 （0604）.mp4
││ 03 3-3 sentinel的qps限流 （2229）.mp4
││ 04 3-4 sentinel的预热和冷启动 （2125）.mp4
││ 05 3-5 sentinel的Throttling配置策略 （0523）.mp4
││ 06 3-6 sentinel的熔断接口 （1059）.mp4
││ 07 3-7 sentinel的熔断接口-基于错误数 （1210）.mp4
││ 08 3-8 sentinel的熔断接口-基于错误率和慢请求 （0805）.mp4
││ 09 3-9 gin集成sentinel实现限流 （1130）.mp4
││
│└─04 api网关、部署
│ ├─01 第1章 kong的安装和配置
│ │ 01 1-1 什么是api网关 （0652）.mp4
│ │ 02 1-2 api网关具备的功能有哪些 （0444）.mp4
│ │ 03 1-3 api网关技术选型 （1011）.mp4
│ │ 04 1-4 kong的安装 （2100）.mp4
│ │
│ ├─02 第2章 kong的配置
│ │ 01 2-1 kong的8001、800和1337端口号的关系 （0746）.mp4
│ │ 02 2-2 基本的路由转发配置 （1018）.mp4
│ │ 03 2-3 kong的service、routes、upstream的请求过程 （0625）.mp4
│ │ 04 2-4 kong集成consul实现服务发现和负载均衡 （0714）.mp4
│ │ 05 2-5 kong配置jwt实现登录校验 （1653）.mp4
│ │ 06 2-6 kong配置反爬和ip黑名单 （0918）.mp4
│ │
│ ├─03 第3章 jenkins入门
│ │ 01 3-1 敏捷开发中的持续集成痛点 （1248）.mp4
│ │ 02 3-2 安装jenkins和关闭防火墙 （1002）.mp4
│ │ 03 3-3 jenkins构建服务器流程 （1035）.mp4
│ │ 04 3-4 安装jenkins常用插件 （0834）.mp4
│ │ 05 3-5 通过free style构建项目 （1414）.mp4
│ │ 06 3-6 将构建服务器上的代码上传到运行服务器 （1520）.mp4
│ │ 07 3-7 通过pipeline实现持续集成 （1617）.mp4
│ │ 08 3-8 通过jenkinsfile管理构建pipeline脚本 （0506）.mp4
│ │ 09 3-9 通过远程和其他工程触发构建 （0643）.mp4
│ │ 10 3-10 定时构建和轮询SCM构建 （0804）.mp4
│ │ 11 3-11 参数化pipeline构建项目 （0457）.mp4
│ │
│ ├─04 第4章 通过jenkins部署服务
│ │ 01 4-1 有哪些服务器我们需要部署 （1052）.mp4
│ │ 02 4-2 前端代码上传到git并启动 （0808）.mp4
│ │ 03 4-3 nginx中部署vuejs （2237）.mp4
│ │ 04 4-4 jenkens部署vuejs项目 （1759）.mp4
│ │ 05 4-5 通过go build构建go微服务 （2202）.mp4
│ │ 06 4-6 发布go项目到远程服务器上 （0815）.mp4
│ │ 07 4-7 通过shell脚本启动gin服务 （1217）.mp4
│ │
│ └─05 第5章 课程总结
│ 01 5-1 课程总结 （2002）.mp4
│
├─06 阶段六：开发规范、设计模式、单元测试
│├─01 开发规范和go基础扩展
││├─01 第1章 开发规范
│││ 01 1-1 开始后续学习前的说明 （0429）.mp4
│││ 02 1-2 课程基本开发工具说明 - 重要！ （0626）.mp4
│││ 03 1-3 项目开发有哪些规范需要注意 （1132）.mp4
│││ 04 1-4 项目开发流程 （1131）.mp4
│││ 05 1-5 git的代码分支管理 （1213）.mp4
│││ 06 1-6 git的commit规范 （0740）.mp4
│││ 07 1-7 go的代码规范简介 （1243）.mp4
│││ 08 1-8 go的项目目录规范 （1128）.mp4
│││ 09 1-9 使用mono-repo还是multi-repo管理项目源码 （1453）.mp4
│││ 10 1-10 微服务的项目目录规范 （0820）.mp4
│││ 11 1-11 go vet 进行代码检测 （0749）.mp4
│││ 12 1-12 golangci-lint进行代码检测 （2015）.mp4
│││
││└─02 第2章 go基础知识扩展
││ 01 2-1 map初始化容易犯的错 （0552）.mp4
││ 02 2-2 常见错误 - 结构体空指针 （0403）.mp4
││ 03 2-3 常见错误 - 使用对循环迭代器变量的引用 （0743）.mp4
││ 04 2-4 什么是泛型 （0349）.mp4
││ 05 2-5 go中如何使用泛型 （0841）.mp4
││ 06 2-6 泛型的常见用法 （0900）.mp4
││ 07 2-7 泛型的错误用法 （0932）.mp4
││
│└─02 设计模式和单元测试
│ ├─01 第1章 设计模式
│ │ 01 1-1 为什么需要函数选项模式 （1030）.mp4
│ │ 02 1-2 kratos和grpc中如何使用函数选项模式的 （0606）.mp4
│ │ 03 1-3 如何实现函数选项模式 （1205）.mp4
│ │ 04 1-4 单例模式和sync.Once原理 （1527）.mp4
│ │ 05 1-5 简单工厂模式 （0838）.mp4
│ │ 06 1-6 抽象工厂模式 （1026）.mp4
│ │ 07 1-7 责任链模式 （0846）.mp4
│ │
│ └─02 第2章 单元测试
│ 01 2-1 测试金字塔是什么 （1323）.mp4
│ 02 2-2 简单回顾一下测试用例 （0853）.mp4
│ 03 2-3 如何写出方便测试的代码 （2212）.mp4
│ 04 2-4 通过gomock进行测试用例编码 （2200）.mp4
│ 05 2-5 通过sqlmock对gorm进行单元测试 （1743）.mp4
│ 06 2-6 通过ExpectExec和assert判断测试结果 （1449）.mp4
│ 07 2-7 如何对grpc、redis和rocketmq等进行测试 （0602）.mp4
│ 08 2-8 go fuzz模糊测试 （1926）.mp4
│ 09 2-9 解决模糊测试发现的bug以及testdata目录用途 （1416）.mp4
│ 10 2-10 通过gomonkey进行单元测试 （2047）.mp4
│ 11 2-11 ginkgo测试框架快速入门 （1708）.mp4
│ 12 2-12 如何将ginkgo和gomonkey、gomock结合使用 （1255）.mp4
│
├─07 阶段七：效率工具开发
│└─01 protoc插件开发、cobra命令行
│ ├─01 第1章 protoc自定义插件
│ │ 01 1-1 工程实践中如何更好的使用proto文件 （2557）.mp4
│ │ 02 1-2 protoc命令如何查询依赖的proto文件 （1255）.mp4
│ │ 03 1-3 protoc执行的插件加载原理是什么 （0647）.mp4
│ │ 04 1-4 proto文件中的package和go_package的作用 （0722）.mp4
│ │ 05 1-5 protoc插件开发原理 （1213）.mp4
│ │ 06 1-6 修改protoreflect源码便于调试 （2049）.mp4
│ │ 07 1-7 gin转发到grpc服务的原理和实现 （2743）.mp4
│ │ 08 1-8 一些细节的处理和纠正 （0445）.mp4
│ │ 09 1-9 go的template实现动态生成代码 （2358）.mp4
│ │ 10 1-10 protoc生成gin的插件 （2333）.mp4
│ │
│ └─02 第2章 命令行开发神器-cobra
│ 01 2-1 不同服务的通用性在哪里 （1501）.mp4
│ 02 2-2 不使用cobra如何完成项目启动参数检查 （0853）.mp4
│ 03 2-3 通过cobra简化项目启动 （0821）.mp4
│ 04 2-4 通过cobra-cli简化开发 （0558）.mp4
│ 05 2-5 为命令添加flag解析 （0326）.mp4
│
├─08 阶段八：深入底层库封装、ast代码生成方案
│├─01 log日志包设计
││└─01 第1章 如何设计日志包
││ 01 1-1 为什么需要自己去设计日志包 （1023）.mp4
││ 02 1-2 go-zero和kratos中日志的处理 （0933）.mp4
││ 03 1-3 全局logger和传递参数的logger的用法 （1010）.mp4
││ 04 1-4 日志包的基本需求 （0851）.mp4
││ 05 1-5 日志debug、info、error等级别的使用场景 （1605）.mp4
││ 06 1-6 日志打印的实践经验 （0555）.mp4
││ 07 1-7 生产环境中的日志系统架构 （0936）.mp4
││ 08 1-8 自定义log的options （2032）.mp4
││ 09 1-9 自定义log接口 （1953）.mp4
││ 10 1-10 自定义的logger是如何实现解耦的 （0731）.mp4
││ 11 1-11 导入已经开发好的log日志包 （0543）.mp4
││
│└─02 ast代码生成工具开发
│ ├─01 第1章 如何设计errors错误包
│ │ 01 1-1 go的error和其他语言的try catch的区别 （2731）.mp4
│ │ 02 1-2 常用的errors、fmt和pkg errors错误处理包 （1115）.mp4
│ │ 03 1-3 使用errors打印调用栈 （0633）.mp4
│ │ 04 1-4 使用wrapf保存和打印error错误栈 （0843）.mp4
│ │ 05 1-5 通过is和as方法判断error的值 （0758）.mp4
│ │ 06 1-6 http响应应该全部返回200还是返回标准的http code （1146）.mp4
│ │ 07 1-7 如何设计错误码更加科学 （1709）.mp4
│ │ 08 1-8 如何自定义错误码 （0643）.mp4
│ │ 09 1-9 errors实现withcode模式和实现code的注册 （2300）.mp4
│ │ 10 1-10 grpc中的error处理 （1519）.mp4
│ │ 11 1-11 自定义的error放入grpc返回造成的不兼容怎么办 （0923）.mp4
│ │ 12 1-12 增加fromerror解决grpc转换为内部error （1445）.mp4
│ │ 13 1-13 kratos中如何处理errors （0607）.mp4
│ │
│ └─02 第2章 通过ast自动生成代码
│ 01 2-1 go的generate自动生成代码 （1549）.mp4
│ 02 2-2 go的ast包能做什么 （0933）.mp4
│ 03 2-3 ast语法树的基本元素 （1143）.mp4
│ 04 2-4 通过ast包解析变量名和变量的注释 （2303）.mp4
│ 05 2-5 将ast生成的源码写入文件中 （0816）.mp4
│ 06 2-6 通过codegen自动生成注册源码 （1201）.mp4
│
├─09 阶段九：自研微服务框架-gmicro
│├─01 三层代码结构
││└─01 第1章 三层代码结构规范
││ 01 1-1 导入common和app包 （0819）.mp4
││ 02 1-2 通过app启动配置文件映射和flag映射 （2206）.mp4
││ 03 1-3 重构app启动项目 （1028）.mp4
││ 04 1-4 app启动的原理 （0551）.mp4
││ 05 1-5 已有代码存在哪些耦合 （0915）.mp4
││ 06 1-6 三层代码结构降低代码耦合 （2123）.mp4
││ 07 1-7 service和data层的解耦 （0938）.mp4
││ 08 1-8 DO、DTO、VO这些概念是什么意思 （1023）.mp4
││ 09 1-9 service层的代码如何做到可测试性 （2447）.mp4
││ 10 1-10 controller层如何减少对service层的依赖 （1115）.mp4
││ 11 1-11 使用copier简化do和dto之间的拷贝 （1043）.mp4
││
│├─02 grpc服务封装更方便的rpc服务
││├─01 第1章 通用微服务框架需求
│││ 01 1-1 为什么我们需要自己开发微服务框架 （1159）.mp4
│││ 02 1-2 微服务框架应该具备的功能 （1250）.mp4
│││ 03 1-3 通过函数选项模式启动app （2233）.mp4
│││ 04 1-4 实现服务注册的抽象 （1449）.mp4
│││ 05 1-5 服务注册的监听实现原理 （1446）.mp4
│││ 06 1-6 如何封装rpc和http服务 （0616）.mp4
│││
││└─02 第2章 开发通用的rpc服务
││ 01 2-1 rpc的server数据模型设计 （1220）.mp4
││ 02 2-2 rpc服务启动过程中的拦截器，rpc接口反射等功能 （2213）.mp4
││ 03 2-3 rpc服务的启动和关闭 （0641）.mp4
││ 04 2-4 实现recover拦截器 （0933）.mp4
││ 05 2-5 service的timeout的拦截器实现原理 （1736）.mp4
││ 06 2-6 app中如何启动gmicro的rpc服务 （1053）.mp4
││ 07 2-7 自定义ServerOptions启动用户服务 （1923）.mp4
││ 08 2-8 启动rpc服务进行调试 （1311）.mp4
││ 09 2-9 通过mock底层的数据返回响应数据 （1559）.mp4
││ 10 2-10 使用gin自动完成rpc服务的api代理 （0832）.mp4
││
│├─03 深入grpc的服务注册、负载均衡原理
││└─01 第1章 服务注册、服务发现和负载均衡
││ 01 1-1 配置服务注册配置 （1014）.mp4
││ 02 1-2 kratos对consul服务注册的封装 （1246）.mp4
││ 03 1-3 将服务注册到consul中 （2108）.mp4
││ 04 1-4 客户端封装的数据结构设计 （1503）.mp4
││ 05 1-5 封装dial方法进行客户端生成 （0900）.mp4
││ 06 1-6 封装client端的timeout拦截器 （1017）.mp4
││ 07 1-7 grpc的服务发现的resolver接口 （0913）.mp4
││ 08 1-8 自定义实现directBuilder实现服务发现 （1520）.mp4
││ 09 1-9 grpc的服务发现和负载均衡的原理 （0909）.mp4
││ 10 1-10 通过WithResolvers显示指定resolver （0928）.mp4
││ 11 1-11 通过观察者模式实现服务发现 （2130）.mp4
││ 12 1-12 测试consul的服务发现功能 （0417）.mp4
││ 13 1-13 grpc的负载均衡架构原理 （1951）.mp4
││ 14 1-14 grpc负载均衡的源码分析 （1149）.mp4
││ 15 1-15 pickfirst和roundrobin源码分析 （0902）.mp4
││ 16 1-16 kratos负载均衡源码解析 （1930）.mp4
││ 17 1-17 负载均衡使用测试 （1250）.mp4
││
│├─04 基于gin封装api服务
││└─01 第1章 基于gin封装通用的restserver
││ 01 1-1 设计restserver的通用结构 （1503）.mp4
││ 02 1-2 通过函数选项模式完成newServer （1300）.mp4
││ 03 1-3 完成restserver的start过程 （2102）.mp4
││ 04 1-4 封装验证翻译器 （1345）.mp4
││ 05 1-5 gmicro在app中分别启动rest和rpc服务 （0942）.mp4
││ 06 1-6 errgroup解决一组task启动的问题 （1308）.mp4
││ 07 1-7 通过errgroup完善restserver和rpcserver的启动 （1457）.mp4
││ 08 1-8 restserver启动并测试 （2115）.mp4
││ 09 1-9 优雅退出如何通知到rpc和rest的server （1000）.mp4
││ 10 1-10 基于restserver封装middleware （0725）.mp4
││ 11 1-11 basic认证、cache认证和jwt认证的需求 （0751）.mp4
││ 12 1-12 如何集成basic、cache和jwt认证服务 （1631）.mp4
││ 13 1-13 basic、cache认证源码解析 （1553）.mp4
││
│├─05 可观测的终极解决方案
││└─01 第1章 opentelemetry实现链路追踪
││ 01 1-1 opentelemetry的前世今生 - 重要！ （1615）.mp4
││ 02 1-2 opentelemetry快速体验 （1509）.mp4
││ 03 1-3 SetAttribute设置链路的属性 （1619）.mp4
││ 04 1-4 open telemetry的系统架构 （1610）.mp4
││ 05 1-5 函数中传递span的context （1406）.mp4
││ 06 1-6 opentelemetry通过http完成span的传输 （2311）.mp4
││ 07 1-7 自定义inject和extract源码 （1635）.mp4
││ 08 1-8 grpc集成opentelemetry （0741）.mp4
││ 09 1-9 otelgrpc源码解读 （0840）.mp4
││ 10 1-10 设计opentelemetry的options （0856）.mp4
││ 11 1-11 gmicro集成opentelemetry （2729）.mp4
││ 12 1-12 log和opentelemetry集成体验 （0647）.mp4
││ 13 1-13 opentelemetry集成log的源码解读 （0651）.mp4
││ 14 1-14 gorm集成opentelemetry （1631）.mp4
││ 15 1-15 gorm集成opentelemetry的源码解读 （0533）.mp4
││ 16 1-16 gin集成opentelemetry （1602）.mp4
││ 17 1-17 go-redis集成opentelemetry （0827）.mp4
││
│└─06 系统监控核心
│ └─01 第1章 监控系统 - prometheus、grafana
│ 01 1-1 监控有哪些指标 （1900）.mp4
│ 02 1-2 prometheus、grafana架构 （1253）.mp4
│ 03 1-3 安装prometheus和node-exporter （0709）.mp4
│ 04 1-4 promql基本语法 （0841）.mp4
│ 05 1-5 grafana的安装和使用 （1301）.mp4
│ 06 1-6 导入grafana的模板 （0537）.mp4
│ 07 1-7 guages和counter指标 （0730）.mp4
│ 08 1-8 histograms指标 （0613）.mp4
│ 09 1-9 gin集成prometheus （1226）.mp4
│ 10 1-10 rpcserver的interceptor集成prometheus （1623）.mp4
│ 11 1-11 rpc的client的interceptor集成prometheus （0538）.mp4
│ 12 1-12 gin集成prometheus （1201）.mp4
│ 13 1-13 测试ginmetrics （0730）.mp4
│
├─10 阶段十：基于gmicro重构项目
│├─01 用户、商品服务重构
││├─01 第1章 重构用户服务
│││ 01 1-1 data层接口设计 （1139）.mp4
│││ 02 1-2 userstore接口的实现 （2305）.mp4
│││ 03 1-3 重构service层接口实现 （0645）.mp4
│││ 04 1-4 重构controller层代码-list和通过id查询用户 （0915）.mp4
│││ 05 1-5 重构controller层代码-通过mobile查询用户 （1245）.mp4
│││ 06 1-6 重构controller层代码-用户更新和密码校验 （1049）.mp4
│││ 07 1-7 底层数据库的链接封装 （1606）.mp4
│││ 08 1-8 mysql的配置和映射启动服务 （1612）.mp4
│││ 09 1-9 mysql配置文件映射启动 （1045）.mp4
│││ 10 1-10 启动服务的bug修复 （0311）.mp4
│││ 11 1-11 用户服务的api层服务初始化 （1008）.mp4
│││ 12 1-12 重构login接口 （1445）.mp4
│││ 13 1-13 用户服务的data层重构 （2103）.mp4
│││ 14 1-14 重构login的service等代码 （1532）.mp4
│││ 15 1-15 完成login的controller层重构 （2009）.mp4
│││ 16 1-16 封装底层的rpc链接 （1628）.mp4
│││ 17 1-17 封装rpc服务的client端tracing拦截器 （1223）.mp4
│││ 18 1-18 重构短信发送逻辑 （1720）.mp4
│││ 19 1-19 基于redis的封装 （2447）.mp4
│││ 20 1-20 重构注册接口 （1945）.mp4
│││ 21 1-21 登录校验 （2056）.mp4
│││ 22 1-22 调试token解析 （1522）.mp4
│││ 23 1-23 更新用户信息接口重构 （0535）.mp4
│││
││└─02 第2章 重构商品服务
││ 01 2-1 定义商品服务的DO模型 （1851）.mp4
││ 02 2-2 重构商品相关的接口 （1217）.mp4
││ 03 2-3 重构商品服务其他接口的data接口 （1123）.mp4
││ 04 2-4 商品列表页重构需求分析 （1057）.mp4
││ 05 2-5 重构商品服务的es接口 （1633）.mp4
││ 06 2-6 重构商品服务的es查询接口 （1058）.mp4
││ 07 2-7 重构service层商品列表页接口 （1443）.mp4
││ 08 2-8 基于事务完成商品的创建 （2218）.mp4
││ 09 2-9 通过canal消费mysql的binlog完成数据最终一致性的方案 （1022）.mp4
││ 10 2-10 通过map-reduce完成并发调用控制 （1641）.mp4
││ 11 2-11 启动goods的service服务 （2903）.mp4
││ 12 2-12 通过工厂模式改造service和data层 （3012）.mp4
││ 13 2-13 启动商品服务 （0923）.mp4
││ 14 2-14 完成controller层的商品列表接口 （0545）.mp4
││ 15 2-15 调试商品列表页接口 （1602）.mp4
││ 16 2-16 gorm打印日志的集成 （0851）.mp4
││ 17 2-17 商品服务的api接口重构-1 （2236）.mp4
││ 18 2-18 商品服务的api接口重构-2 （1418）.mp4
││
│├─02 订单、库存等服务重构
││├─01 第1章 重构库存服务
│││ 01 1-1 api服务的service层重构 （3007）.mp4
│││ 02 1-2 重构库存服务的data层接口实现 （1723）.mp4
│││ 03 1-3 service层重构get和create方法 （0750）.mp4
│││ 04 1-4 库存扣减接口重构 （2416）.mp4
│││ 05 1-5 重构reback库存归还接口 （1657）.mp4
│││
││└─02 第2章 dtm分布式事务框架
││ 01 2-1 saga分布式事务的原理 （2258）.mp4
││ 02 2-2 各种分布式事务的应用场景 （0544）.mp4
││ 03 2-3 dtm的安装 （1027）.mp4
││ 04 2-4 dtm快速体验saga分布式事务 （2509）.mp4
││ 05 2-5 转账服务的saga事务调试 （1756）.mp4
││ 06 2-6 grpc服务的事务编排 （2631）.mp4
││ 07 2-7 基于服务发现完成分布式事务的调度 （1338）.mp4
││ 08 2-8 子事务屏障和gin集成测试 （2549）.mp4
││
│└─03 订单服务重构、wire进行ioc控制
│ ├─01 第1章 订单系统重构
│ │ 01 1-1 订单系统data层数据接口定义 （1543）.mp4
│ │ 02 1-2 实现order和购物车的接口重构 （2906）.mp4
│ │ 03 1-3 完成datafactory的重构 （1509）.mp4
│ │ 04 1-4 订单服务的service层重构 （1045）.mp4
│ │ 05 1-5 通过saga事务重构分布式事务 （2306）.mp4
│ │ 06 1-6 新建订单和补偿接口实现 （1753）.mp4
│ │ 07 1-7 重构controller层的submitorder接口 （2628）.mp4
│ │ 08 1-8 启动订单服务重构 （1732）.mp4
│ │ 09 1-9 调试新建订单接口(上) （2250）.mp4
│ │ 10 1-10 调试新建订单接口(下) （2033）.mp4
│ │
│ └─02 第2章 依赖注入和ioc思想
│ 01 2-1 什么是ioc （3003）.mp4
│ 02 2-2 ioc框架选型 （1109）.mp4
│ 03 2-3 wire快速入门 （1325）.mp4
│ 04 2-4 通过wire重构user的service服务(上) （2236）.mp4
│ 05 2-5 通过wire重构user的service服务(下) （1853）.mp4
│ 06 2-6 通过providerset简化初始化 （0833）.mp4
│ 07 2-7 sentinel集成nacos （3103）.mp4
│ 08 2-8 集成sentinel和nacos （2349）.mp4
│ 09 2-9 调试sentinel集成nacos （1323）.mp4
│
├─11 阶段十一：基于k8s部署项目
│├─01 通过k8s部署服务
││├─01 第1章 docker入门
│││ 01 1-1 docker介绍 （0947）.mp4
│││ 02 1-2 容器化技术 （1708）.mp4
│││ 03 1-3 为什么go是云原生最佳语言 （1101）.mp4
│││ 04 1-4 docker的基本概念-镜像、容器、仓库 （1506）.mp4
│││ 05 1-5 镜像相关的操作命令 （1716）.mp4
│││ 06 1-6 容器相关命令 （2032）.mp4
│││ 07 1-7 docker网络端口映射 （1416）.mp4
│││ 08 1-8 docker外部数据挂载 （1322）.mp4
│││ 09 1-9 docker的环境变量 （1029）.mp4
│││ 10 1-10 最简单的Dockerfile （1439）.mp4
│││ 11 1-11 dockerfile的COPY命令 （1120）.mp4
│││ 12 1-12 制作一个gin服务的镜像 （1520）.mp4
│││ 13 1-13 entrypoint和cms命令的区别 （0826）.mp4
│││ 14 1-14 env、arg和workdir （1608）.mp4
│││
││└─02 第2章 kubesphere部署服务
││ 01 2-1 为什么我们需要k8s （1232）.mp4
││ 02 2-2 k8s系统选型 （0838）.mp4
││ 02 2-2 k8s系统选型 （0838）.zip
││ 03 2-3 云服务器安装docker （0933）.mp4
││ 04 2-4 安装kubesphere （1325）.mp4
││ 05 2-5 kubesphere的工作负载、服务和容器组 （1641）.mp4
││ 06 2-6 创建存储卷和配置 （1141）.mp4
││ 07 2-7 kubesphere部署mysql （1101）.mp4
││ 08 2-8 配置服务允许外部访问 （1611）.mp4
││ 09 2-9 kubesphere安装redis （0731）.mp4
││ 10 2-10 kubesphere安装consul （0526）.mp4
││ 11 2-11 安装nacos （0723）.mp4
││ 12 2-12 安装elasticsearch （1618）.mp4
││ 13 2-13 rocketmq安装-nameserver （0512）.mp4
││ 14 2-14 rocketmq安装-broker （1141）.mp4
││ 15 2-15 安装harbor （1732）.mp4
││ 16 2-16 kubesphere配置harbor镜像仓库 （0827）.mp4
││ 17 2-17 推送本地镜像到harbor并部署 （0923）.mp4
││ 18 2-18 部署jaeger （0618）.mp4
││
│└─02 devops和k8s
│ ├─01 第1章 devops进行持续集成
│ │ 01 1-1 基于docker进行go build构建 （1408）.mp4
│ │ 02 1-2 通过多阶段构建对go镜像瘦身 （1416）.mp4
│ │ 03 1-3 完善多阶段构建的dockerfile （0600）.mp4
│ │ 04 1-4 devops、ci、cd和gitops等概念 （2137）.mp4
│ │ 05 1-5 安装git parameter插件 （1220）.mp4
│ │ 06 1-6 如何构建一个生产环境的镜像 （0632）.mp4
│ │ 07 1-7 pipeline参数化构建 （1945）.mp4
│ │ 08 1-8 编写Dockerfile （0933）.mp4
│ │ 09 1-9 编写jenkinsfile完成docker构建和发布 （1443）.mp4
│ │ 10 1-10 jenkins构建后发布到k8s中 （2333）.mp4
│ │ 11 1-11 对user服务进行ci构建 （1450）.mp4
│ │ 12 1-12 kubesphere部署用户服务 （2330）.mp4
│ │ 13 1-13 修改user服务的配置 （1953）.mp4
│ │ 14 1-14 解决gmicro的ip地址的bug （1122）.mp4
│ │ 15 1-15 测试用户服务 （0634）.mp4
│ │ 16 1-16 k8s的service的负载均衡和本地负载均衡的区别 （1816）.mp4
│ │ 17 1-17 部署admin的api服务 （1139）.mp4
│ │ 18 1-18 通过ingress暴露service （1421）.mp4
│ │
│ └─02 第2章 k8s入门
│ 01 2-1 k8s学习路线 （0855）.mp4
│ 02 2-2 pod是什么 （0923）.mp4
│ 03 2-3 kubectl相关的pods命令 （1653）.mp4
│ 04 2-4 k8s的控制器 - deployment （1853）.mp4
│ 05 2-5 k8s的service （1846）.mp4
│ 06 2-6 k8s的ingress （1049）.mp4
│ 07 2-7 k8s的持久卷 （1212）.mp4
│ 08 2-8 k8s的configmap、secret （0809）.mp4
│ 09 2-9 k8s的架构 （1340）.mp4
│ 10 2-10 课程总结和进一步学习建议 （2112）.mp4
页:
[1]