Rust程序设计

Rust程序设计

by Jim Blandy, Jason Orendorff, Leonora F. S. Tindall
Released September 2023
Publisher(s): Posts & Telecom Press
ISBN: 9787115621818

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

系统编程为算力世界提供了基石。要编写性能敏感的代码就需要一种新的系统编程语言——让程序员能够掌控内存、CPU时间和其他系统资源，Rust应运而生。Rust将这种掌控力与现代类型系统结合起来，以捕获各种常见错误：小到内存管理，大到线程之间的数据竞争。

本书是Rust领域的经典参考书，三位作者均为资深系统程序员。学完本书，读者就能在构建应用的过程中兼顾性能与安全。具体而言，充分利用Rust的特性，将可预知的性能、安全的内存访问和可靠的并发结合起来，对内存的消耗和处理器的使用进行全面掌控。

本书涉及的主要内容包括：

  • Rust的基本数据类型，以及“所有权”和“借用”的核心概念
  • 语言的基础，包括错误处理、crate与模块、结构体，以及枚举
  • 利用特型和泛型写出既灵活又高效的代码
  • Rust大杀器——闭包、迭代器和异步编程
  • 集合、字符串与文本、输入与输出、并发、宏、不安全代码，以及与外部函数的接口

Table of contents

  1. 封面
  2. 封底
  3. 扉页
  4. 版权页
  5. 版权声明
  6. O’Reilly Media, Inc.介绍
  7. 目录 (1/3)
  8. 目录 (2/3)
  9. 目录 (3/3)
  10. 专家推荐
  11. 译者序
  12. 前言
    1. 读者对象
    2. 写作初衷
    3. 浏览本书
    4. 排版约定
    5. 使用代码示例
    6. O’Reilly在线学习平台（O’Reilly Online Learning）
    7. 联系我们
    8. 致谢
    9. 电子书
  13. 中文版审读致谢
  14. 第1章 系统程序员也能享受美好
    1. 1.1 Rust为你负重前行
    2. 1.2 高效并行编程
    3. 1.3 性能毫不妥协
    4. 1.4 协作无边无界
  15. 第2章 Rust导览
    1. 2.1 rustup与Cargo
    2. 2.2 Rust函数
    3. 2.3 编写与运行单元测试
    4. 2.4 处理命令行参数
    5. 2.5 搭建Web服务器
    6. 2.6 并发
      1. 2.6.1 什么是曼德博集
      2. 2.6.2 解析并配对命令行参数
      3. 2.6.3 从像素到复数的映射
      4. 2.6.4 绘制曼德博集
      5. 2.6.5 写入图像文件
      6. 2.6.6 并发版曼德博程序
      7. 2.6.7 运行曼德博绘图器
      8. 2.6.8 大“安”无形
    7. 2.7 文件系统与命令行工具
      1. 2.7.1 命令行界面
      2. 2.7.2 读写文件
      3. 2.7.3 查找并替换
  16. 第3章 基本数据类型
    1. 3.1 固定宽度的数值类型
      1. 3.1.1 整型
      2. 3.1.2 检查算法、回绕算法、饱和算法和溢出算法
      3. 3.1.3 浮点类型
    2. 3.2 布尔类型
    3. 3.3 字符
    4. 3.4 元组
    5. 3.5 指针类型
      1. 3.5.1 引用
      2. 3.5.2 Box
      3. 3.5.3 裸指针
    6. 3.6 数组、向量和切片
      1. 3.6.1 数组
      2. 3.6.2 向量
      3. 3.6.3 切片
    7. 3.7 字符串类型
      1. 3.7.1 字符串字面量
      2. 3.7.2 字节串
      3. 3.7.3 内存中的字符串
      4. 3.7.4 String
      5. 3.7.5 使用字符串
      6. 3.7.6 其他类似字符串的类型
    8. 3.8 类型别名
    9. 3.9 超越基础
  17. 第4章 所有权与移动
    1. 4.1 所有权
    2. 4.2 移交
      1. 4.2.1 更多移交类操作
      2. 4.2.2 移交与控制流
      3. 4.2.3 移交与索引内容
    3. 4.3 Copy类型：关于移交的例外情况
    4. 4.4 Rc与Arc：共享所有权
  18. 第5章 引用
    1. 5.1 对值的引用
    2. 5.2 使用引用
      1. 5.2.1 Rust引用与C++引用
      2. 5.2.2 对引用变量赋值
      3. 5.2.3 对引用进行引用
      4. 5.2.4 比较引用
      5. 5.2.5 引用永不为空
      6. 5.2.6 借用任意表达式结果值的引用
      7. 5.2.7 对切片和特型对象的引用
    3. 5.3 引用安全
      1. 5.3.1 借用局部变量
      2. 5.3.2 将引用作为函数参数
      3. 5.3.3 把引用传给函数
      4. 5.3.4 返回引用
      5. 5.3.5 包含引用的结构体
      6. 5.3.6 不同的生命周期参数
      7. 5.3.7 省略生命周期参数
    4. 5.4 共享与可变 (1/2)
    5. 5.4 共享与可变 (2/2)
    6. 5.5 应对复杂对象关系
  19. 第6章 表达式
    1. 6.1 表达式语言
    2. 6.2 优先级与结合性
    3. 6.3 块与分号
    4. 6.4 声明
    5. 6.5 if与match
      1. 6.5.1 if let
      2. 6.5.2 循环
    6. 6.6 循环中的控制流
    7. 6.7 return表达式
    8. 6.8 为什么Rust中会有loop
    9. 6.9 函数与方法调用
    10. 6.10 字段与元素
    11. 6.11 引用运算符
    12. 6.12 算术运算符、按位运算符、比较运算符和逻辑运算符
    13. 6.13 赋值
    14. 6.14 类型转换
    15. 6.15 闭包
    16. 6.16 下文展望
  20. 第7章 错误处理
    1. 7.1 panic
      1. 7.1.1 展开调用栈
      2. 7.1.2 中止
    2. 7.2 Result
      1. 7.2.1 捕获错误
      2. 7.2.2 Result类型别名
      3. 7.2.3 打印错误
      4. 7.2.4 传播错误
      5. 7.2.5 处理多种Error类型
      6. 7.2.6 处理“不可能发生”的错误
      7. 7.2.7 忽略错误
      8. 7.2.8 处理main()中的错误
      9. 7.2.9 声明自定义错误类型
      10. 7.2.10 为什么是Result
  21. 第8章 crate与模块
    1. 8.1 crate
      1. 8.1.1 版本
      2. 8.1.2 创建配置文件
    2. 8.2 模块
      1. 8.2.1 嵌套模块
      2. 8.2.2 单独文件中的模块
      3. 8.2.3 路径与导入
      4. 8.2.4 标准库预导入
      5. 8.2.5 公开use声明
      6. 8.2.6 公开结构体字段
      7. 8.2.7 静态变量与常量
    3. 8.3 将程序变成库
    4. 8.4 src/bin目录
    5. 8.5 属性
    6. 8.6 测试与文档
      1. 8.6.1 集成测试
      2. 8.6.2 文档
      3. 8.6.3 文档测试
    7. 8.7 指定依赖项
      1. 8.7.1 版本
      2. 8.7.2 Cargo.lock
    8. 8.8 将crate发布到crates.io
    9. 8.9 工作空间
    10. 8.10 更多好资源
  22. 第9章 结构体
    1. 9.1 具名字段型结构体
    2. 9.2 元组型结构体
    3. 9.3 基元型结构体
    4. 9.4 结构体布局
    5. 9.5 用impl定义方法
      1. 9.5.1 以Box、Rc或Arc形式传入self
      2. 9.5.2 类型关联函数
    6. 9.6 关联常量
    7. 9.7 泛型结构体
    8. 9.8 带生命周期参数的泛型结构体
    9. 9.9 带常量参数的泛型结构体
    10. 9.10 让结构体类型派生自某些公共特型
    11. 9.11 内部可变性
  23. 第10章 枚举与模式
    1. 10.1 枚举
      1. 10.1.1 带数据的枚举
      2. 10.1.2 内存中的枚举
      3. 10.1.3 用枚举表示富数据结构
      4. 10.1.4 泛型枚举
    2. 10.2 模式
      1. 10.2.1 模式中的字面量、变量和通配符
      2. 10.2.2 元组型模式与结构体型模式
      3. 10.2.3 数组型模式与切片型模式
      4. 10.2.4 引用型模式
      5. 10.2.5 匹配守卫
      6. 10.2.6 匹配多种可能性
      7. 10.2.7 使用@模式绑定
      8. 10.2.8 模式能用在哪里
      9. 10.2.9 填充二叉树
    3. 10.3 大局观
  24. 第11章 特型与泛型
    1. 11.1 使用特型
      1. 11.1.1 特型对象
      2. 11.1.2 泛型函数与类型参数
      3. 11.1.3 使用哪一个
    2. 11.2 定义与实现特型
      1. 11.2.1 默认方法
      2. 11.2.2 特型与其他人的类型
      3. 11.2.3 特型中的Self
      4. 11.2.4 子特型
      5. 11.2.5 类型关联函数
    3. 11.3 完全限定的方法调用
    4. 11.4 定义类型之间关系的特型
      1. 11.4.1 关联类型（或迭代器的工作原理）
      2. 11.4.2 泛型特型（或运算符重载的工作原理）
      3. 11.4.3 impl Trait
      4. 11.4.4 关联常量
    5. 11.5 逆向工程求限界
    6. 11.6 以特型为基础
  25. 第12章 运算符重载
    1. 12.1 算术运算符与按位运算符
      1. 12.1.1 一元运算符
      2. 12.1.2 二元运算符
      3. 12.1.3 复合赋值运算符
    2. 12.2 相等性比较
    3. 12.3 有序比较
    4. 12.4 Index与IndexMut
    5. 12.5 其他运算符
  26. 第13章 实用工具特型
    1. 13.1 Drop
    2. 13.2 Sized
    3. 13.3 Clone
    4. 13.4 Copy
    5. 13.5 Deref与DerefMut
    6. 13.6 Default
    7. 13.7 AsRef与AsMut
    8. 13.8 Borrow与BorrowMut
    9. 13.9 From与Into
    10. 13.10 TryFrom与TryInto
    11. 13.11 ToOwned
    12. 13.12 Borrow与ToOwned的实际运用：谦卑的Cow
  27. 第14章 闭包
    1. 14.1 捕获变量
      1. 14.1.1 借用值的闭包
      2. 14.1.2 “窃取值”的闭包
    2. 14.2 函数与闭包的类型
    3. 14.3 闭包性能
    4. 14.4 闭包与安全
      1. 14.4.1 “杀死”闭包
      2. 14.4.2 FnOnce
      3. 14.4.3 FnMut
      4. 14.4.4 对闭包的Copy与Clone
    5. 14.5 回调
    6. 14.6 高效地使用闭包
  28. 第15章 迭代器
    1. 15.1 Iterator特型与IntoIterator特型
    2. 15.2 创建迭代器
      1. 15.2.1 iter方法与iter_mut方法
      2. 15.2.2 IntoIterator的实现
      3. 15.2.3 from_fn与successors
      4. 15.2.4 drain方法
      5. 15.2.5 其他迭代器源
    3. 15.3 迭代器适配器
      1. 15.3.1 map与filter
      2. 15.3.2 filter_map与flat_map
      3. 15.3.3 flatten
      4. 15.3.4 take与take_while
      5. 15.3.5 skip与skip_while
      6. 15.3.6 peekable
      7. 15.3.7 fuse
      8. 15.3.8 可逆迭代器与rev
      9. 15.3.9 inspect
      10. 15.3.10 chain
      11. 15.3.11 enumerate
      12. 15.3.12 zip
      13. 15.3.13 by_ref
      14. 15.3.14 cloned与copied
      15. 15.3.15 cycle
    4. 15.4 消耗迭代器
      1. 15.4.1 简单累加：count、sum和product
      2. 15.4.2 min与max
      3. 15.4.3 max_by与min_by
      4. 15.4.4 max_by_key与min_by_key
      5. 15.4.5 对条目序列进行比较
      6. 15.4.6 any与all
      7. 15.4.7 position、rposition和ExactSizeIterator
      8. 15.4.8 fold与rfold
      9. 15.4.9 try_fold与try_rfold
      10. 15.4.10 nth与nth_back
      11. 15.4.11 last
      12. 15.4.12 find、rfind和find_map
      13. 15.4.13 构建集合：collect与FromIterator
      14. 15.4.14 Extend特型
      15. 15.4.15 partition
      16. 15.4.16 for_each与try_for_each
    5. 15.5 实现自己的迭代器
  29. 第16章 集合
    1. 16.1 概述
    2. 16.2 Vec
      1. 16.2.1 访问元素
      2. 16.2.2 迭代
      3. 16.2.3 扩大向量与收缩向量
      4. 16.2.4 联结
      5. 16.2.5 拆分
      6. 16.2.6 交换
      7. 16.2.7 填充
      8. 16.2.8 排序与搜索
      9. 16.2.9 比较切片
      10. 16.2.10 随机元素
      11. 16.2.11 Rust中不存在失效型错误
    3. 16.3 VecDeque
    4. 16.4 BinaryHeap
    5. 16.5 HashMap与BTreeMap
      1. 16.5.1 条目
      2. 16.5.2 对Map进行迭代
    6. 16.6 HashSet与BTreeSet
      1. 16.6.1 对Set进行迭代
      2. 16.6.2 当相等的值不完全相同时
      3. 16.6.3 针对整个Set的运算
    7. 16.7 哈希
    8. 16.8 使用自定义哈希算法
    9. 16.9 在标准集合之外
  30. 第17章 字符串与文本
    1. 17.1 一些Unicode背景知识
      1. 17.1.1 ASCII、Latin-1和Unicode
      2. 17.1.2 UTF-8编码
      3. 17.1.3 文本方向性
    2. 17.2 字符（char）
      1. 17.2.1 字符分类
      2. 17.2.2 处理数字
      3. 17.2.3 字符大小写转换
      4. 17.2.4 与整数之间的转换
    3. 17.3 String与str
      1. 17.3.1 创建字符串值
      2. 17.3.2 简单探查
      3. 17.3.3 追加文本与插入文本
      4. 17.3.4 移除文本与替换文本
      5. 17.3.5 搜索与迭代的约定
      6. 17.3.6 搜索文本的模式
      7. 17.3.7 搜索与替换
      8. 17.3.8 遍历文本
      9. 17.3.9 修剪
      10. 17.3.10 字符串的大小写转换
      11. 17.3.11 从字符串中解析出其他类型
      12. 17.3.12 将其他类型转换为字符串
      13. 17.3.13 借用其他类似文本的类型
      14. 17.3.14 以UTF-8格式访问文本
      15. 17.3.15 从UTF-8数据生成文本
      16. 17.3.16 推迟分配
      17. 17.3.17 把字符串当作泛型集合
    4. 17.4 格式化各种值
      1. 17.4.1 格式化文本值
      2. 17.4.2 格式化数值
      3. 17.4.3 格式化其他类型
      4. 17.4.4 格式化值以进行调试
      5. 17.4.5 格式化指针以进行调试
      6. 17.4.6 按索引或名称引用参数
      7. 17.4.7 动态宽度与动态精度
      8. 17.4.8 格式化自己的类型
      9. 17.4.9 在自己的代码中使用格式化语言
    5. 17.5 正则表达式
      1. 17.5.1 Regex的基本用法
      2. 17.5.2 惰性构建正则表达式值
    6. 17.6 规范化
      1. 17.6.1 规范化形式
      2. 17.6.2 unicode-normalization crate
  31. 第18章 输入与输出
    1. 18.1 读取器与写入器
      1. 18.1.1 读取器
      2. 18.1.2 缓冲读取器
      3. 18.1.3 读取行
      4. 18.1.4 收集行
      5. 18.1.5 写入器
      6. 18.1.6 文件
      7. 18.1.7 寻址
      8. 18.1.8 其他读取器与写入器类型
      9. 18.1.9 二进制数据、压缩和序列化
    2. 18.2 文件与目录
      1. 18.2.1 OsStr与Path
      2. 18.2.2 Path与PathBuf的方法
      3. 18.2.3 访问文件系统的函数
      4. 18.2.4 读取目录
      5. 18.2.5 特定于平台的特性
    3. 18.3 网络
  32. 第19章 并发
    1. 19.1 分叉与合并并行
      1. 19.1.1 启动与联结
      2. 19.1.2 跨线程错误处理
      3. 19.1.3 跨线程共享不可变数据
      4. 19.1.4 rayon
      5. 19.1.5 重温曼德博集
    2. 19.2 通道
      1. 19.2.1 发送值
      2. 19.2.2 接收值
      3. 19.2.3 运行管道
      4. 19.2.4 通道的特性与性能
      5. 19.2.5 线程安全：Send与Sync
      6. 19.2.6 绝大多数迭代器能通过管道传给通道
      7. 19.2.7 超越管道
    3. 19.3 共享可变状态
      1. 19.3.1 什么是互斥锁
      2. 19.3.2 Mutex
      3. 19.3.3 mut与互斥锁
      4. 19.3.4 为什么互斥锁不是“银弹”
      5. 19.3.5 死锁
      6. 19.3.6 “中毒”的互斥锁
      7. 19.3.7 使用互斥锁的多消费者通道
      8. 19.3.8 读/写锁（RwLock）
      9. 19.3.9 条件变量（Condvar）
      10. 19.3.10 原子化类型
      11. 19.3.11 全局变量
    4. 19.4 在Rust中编写并发代码的一点儿经验
  33. 第20章 异步编程
    1. 20.1 从同步到异步
      1. 20.1.1 Future
      2. 20.1.2 异步函数与await表达式
      3. 20.1.3 从同步代码调用异步函数：block_on
      4. 20.1.4 启动异步任务
      5. 20.1.5 异步块
      6. 20.1.6 从异步块构建异步函数
      7. 20.1.7 在线程池中启动异步任务
      8. 20.1.8 你的Future实现Send了吗
      9. 20.1.9 长时间运行的计算：yield_now与spawn_blocking
      10. 20.1.10 对几种异步设计进行比较
      11. 20.1.11 一个真正的异步HTTP客户端
    2. 20.2 异步客户端与服务器
      1. 20.2.1 Error类型与Result类型
      2. 20.2.2 协议
      3. 20.2.3 获取用户输入：异步流
      4. 20.2.4 发送数据包
      5. 20.2.5 接收数据包：更多异步流
      6. 20.2.6 客户端的main函数
      7. 20.2.7 服务器的main函数
      8. 20.2.8 处理聊天连接：异步互斥锁
      9. 20.2.9 群组表：同步互斥锁
      10. 20.2.10 聊天组：tokio的广播通道
    3. 20.3 原始Future与执行器：Future什么时候值得再次轮询
      1. 20.3.1 调用唤醒器：spawn_blocking
      2. 20.3.2 实现block_on
    4. 20.4 固定（Pin）
      1. 20.4.1 Future生命周期的两个阶段
      2. 20.4.2 固定指针
      3. 20.4.3 Unpin特型
    5. 20.5 异步代码何时有用
  34. 第21章 宏
    1. 21.1 宏基础
      1. 21.1.1 宏展开的基础
      2. 21.1.2 意外后果
      3. 21.1.3 重复
    2. 21.2 内置宏
    3. 21.3 调试宏
    4. 21.4 构建json!宏
      1. 21.4.1 片段类型
      2. 21.4.2 宏中的递归
      3. 21.4.3 将特型与宏一起使用
      4. 21.4.4 作用域界定与卫生宏
      5. 21.4.5 导入宏和导出宏
    5. 21.5 在匹配过程中避免语法错误
    6. 21.6 超越macro_rules!
  35. 第22章 不安全代码
    1. 22.1 不安全因素来自哪里
    2. 22.2 不安全块
    3. 22.3 示例：高效的ASCII字符串类型
    4. 22.4 不安全函数
    5. 22.5 不安全块还是不安全函数
    6. 22.6 未定义行为
    7. 22.7 不安全特型
    8. 22.8 裸指针
      1. 22.8.1 安全地解引用裸指针
      2. 22.8.2 示例：RefWithFlag
      3. 22.8.3 可空指针
      4. 22.8.4 类型大小与对齐方式
      5. 22.8.5 指针运算
      6. 22.8.6 移交入和移交出内存
      7. 22.8.7 示例：GapBuffer (1/2)
      8. 22.8.7 示例：GapBuffer (2/2)
      9. 22.8.8 不安全代码中的panic安全性
    9. 22.9 用联合体重新解释内存
    10. 22.10 匹配联合体
    11. 22.11 借用联合体
  36. 第23章 外部函数
    1. 23.1 寻找共同的数据表示
    2. 23.2 声明外部函数与变量
    3. 23.3 使用库中的函数
    4. 23.4 libgit2的裸接口 (1/2)
    5. 23.4 libgit2的裸接口 (2/2)
    6. 23.5 libgit2的安全接口 (1/2)
    7. 23.5 libgit2的安全接口 (2/2)
    8. 23.6 结论
      1. 作者介绍
      2. 封面介绍
  37. 作者介绍
  38. 封面介绍

Product information

  • Title: Rust程序设计
  • Author(s): Jim Blandy, Jason Orendorff, Leonora F. S. Tindall
  • Release date: September 2023
  • Publisher(s): Posts & Telecom Press
  • ISBN: 9787115621818

You might also like

video

算法精讲视频课程：24篇系列讲座

by 罗伯特·塞奇威克, 凯文·韦恩（Kevin Wayne）

课程简介 这套算法视频讲座涵盖算法和数据结构的基本知识，重点是Java实现的应用以及采用科学方法的性能分析，这些知识是所有程序员都应当认真学习的。 描述 本视频全面讲解基本数据类型、算法和数据结构，重点是Java实现的应用以及采用科学方法的性能分析。本视频的配套书籍是《算法》（第4版）——目前算法领域的畅销教材之一。视频讲座的顺序与书中的章节顺序大致相同，但对部分章节进行了重组，从而从不同的视角帮助读者理解书中内容。 如果你还没有《算法》这本书，欢迎立刻下单，在获得纸质版的同时，可获得全部视频讲座的访问链接。 本书的教师网站还提供以下相关资源： ● 全部Java实现 ● 测试数据 ● 练习题及答案 ● 动态可视化演示 ● 教学PPT …

book

深入淺出代數

by Tracey Pilone, Dan Pilone

『本書從學生們的生活周遭取材，設計了許多優異的範例。所有的範例與概念，全都搭配得恰到好處。』 —Herbert Tracey，羅耀拉大學數學系講師 『《深入淺出代數》是一本極具有吸引力的書籍。在解釋觀念、帶領讀者循序漸進、一步一步解決問題等等方面，本書可說是做的非常出色。』 —Shannon Stewart，數學老師 『本書採用對話的方式來呈現訊息，效果十分具有吸引力，對學習的過程也很有幫助。這種感覺就好像是真的在跟作者直接對話似的。』 —Amanda Borcky 你將從本書學到什麼？ 即使拼命用功成績還是不見好轉，你累了嗎？高中代數絕不能當掉，要不然你的手機就拿不回來了嗎？只要你有心學好代數，《深入淺出代數》這本書就是為你而設計的。本書到處充滿具有吸引力的故事劇情與實際練習，還有真實世界中會遇到的狀況說明。讀完本書之後，不管是自然數、指數、聯立方程式還是多項式圖形，再也沒有什麽能難得倒你了。 這本書為何如此與眾不同？ 我們認為你的時間寶貴，不應該浪費在與新概念周旋不下的窘境之中。運用認知科學與學習理論的最新研究成果，我們精心建構出一段引發多重感知的學習體驗。《深入淺出代數》針對大腦運作而設計，採用了豐富的視覺化風格，至於那些令你昏昏欲睡的冗贅敘述？那就免了吧。

book

Prometheus学习手册

by Brian Brazil

快来使用Prometheus，Prometheus是基于指标的监控系统，为成千上万的组织在生产环境中提供服务。这本实用指南为应用开发人员、系统管理人员和DevOps人员提供了关于Prometheus关键部分的相关介绍，包括基础设施和应用的监控、仪表盘显示、告警、代码测控，以及如何通过导出器获取第三方的指标。 这个开源系统在过去几年中变得流行是有原因的。基于它简单而强大的数据模型和查询语句，Prometheus专注于监控这一件事情并将其做到了极致。本书的作者同时也是Prometheus的开发人员Brian Brazil将会带着你学习 Prometheus配置、节点导出器、 Alertmanager，以及如何对应用和基础设施进行监控。 了解对你的应用程序代码进行测控的位置以及对应的测控量级。 使用标签来区分指标：唯一的键值对。 对Grafana这个流行的仪表盘工具进行介绍。 学习如何使用节点导出器对你的基础设施进行监控。 使用服务发现为你的机器和服务提供不同的监控视角。 在Kubernetes中使用Prometheus，并测试你可以在容器中使用的导出器。 将其他监控系统的数据转换为Prometheus能够识别的格式。

book

流架构

by James Urquhart

现在的软件开发正在拥抱事件和流数据，这不仅优化了技术交互的方式，也优化了业务相互集成的方式，以满足客户的需求，这种现象被称为流，由模式和标准组成。这些模式和标准确定了各方之间通过互联网进行的通信活动和相关数据。 本书探讨了这种演变的关键影响：当事件和数据流帮助你发现新的活动来源以增强现有业务或推动新市场时，究竟会发生什么？哪些技术和架构模式可以帮助你的公司把握流程带来的机会？James Urquhart是VMware全球CTO。他指导企业架构师、软件开发人员和产品经理完成这一过程。 了解当企业、政府和其他机构通过事件和数据流进行整合时，流会带来哪些好处。 通过Wardley Mapping可视化和Promise Theory建模了解流集成的价值链。 了解当今事件驱动系统市场背后的基本概念。 了解当今的集成模式将如何影响未来的实时事件流。 探索为什么公司应该从今天开始构建软件架构，以便在未来几年从流中获得收益。