zh-Hans: Translate solutions (#392)

README-zh-Hans.md

@@ -1,6 +1,6 @@
 > * 原文地址：[github.com/donnemartin/system-design-primer](https://github.com/donnemartin/system-design-primer)
 > * 译文出自：[掘金翻译计划](https://github.com/xitu/gold-miner)
-> * 译者：[XatMassacrE](https://github.com/XatMassacrE)、[L9m](https://github.com/L9m)、[Airmacho](https://github.com/Airmacho)、[xiaoyusilen](https://github.com/xiaoyusilen)、[jifaxu](https://github.com/jifaxu)
+> * 译者：[XatMassacrE](https://github.com/XatMassacrE)、[L9m](https://github.com/L9m)、[Airmacho](https://github.com/Airmacho)、[xiaoyusilen](https://github.com/xiaoyusilen)、[jifaxu](https://github.com/jifaxu)、[根号三](https://github.com/sqrthree)
 > * 这个 [链接](https://github.com/xitu/system-design-primer/compare/master...donnemartin:master) 用来查看本翻译与英文版是否有差别（如果你没有看到 README.md 发生变化，那就意味着这份翻译文档是最新的）。
 
 *[English](README.md) ∙ [日本語](README-ja.md) ∙ [简体中文](README-zh-Hans.md) ∙ [繁體中文](README-zh-TW.md) | [العَرَبِيَّة‎](https://github.com/donnemartin/system-design-primer/issues/170) ∙ [বাংলা](https://github.com/donnemartin/system-design-primer/issues/220) ∙ [Português do Brasil](https://github.com/donnemartin/system-design-primer/issues/40) ∙ [Deutsch](https://github.com/donnemartin/system-design-primer/issues/186) ∙ [ελληνικά](https://github.com/donnemartin/system-design-primer/issues/130) ∙ [עברית](https://github.com/donnemartin/system-design-primer/issues/272) ∙ [Italiano](https://github.com/donnemartin/system-design-primer/issues/104) ∙ [韓國語](https://github.com/donnemartin/system-design-primer/issues/102) ∙ [فارسی](https://github.com/donnemartin/system-design-primer/issues/110) ∙ [Polski](https://github.com/donnemartin/system-design-primer/issues/68) ∙ [русский язык](https://github.com/donnemartin/system-design-primer/issues/87) ∙ [Español](https://github.com/donnemartin/system-design-primer/issues/136) ∙ [ภาษาไทย](https://github.com/donnemartin/system-design-primer/issues/187) ∙ [Türkçe](https://github.com/donnemartin/system-design-primer/issues/39) ∙ [tiếng Việt](https://github.com/donnemartin/system-design-primer/issues/127) ∙ [Français](https://github.com/donnemartin/system-design-primer/issues/250) | [Add Translation](https://github.com/donnemartin/system-design-primer/issues/28)*
@@ -12,14 +12,6 @@
   <br/>
 </p>
 
-## 翻译
-
-有兴趣参与[翻译](https://github.com/donnemartin/system-design-primer/issues/28)?  以下是正在进行中的翻译:
-
-* [巴西葡萄牙语](https://github.com/donnemartin/system-design-primer/issues/40)
-* [简体中文](https://github.com/donnemartin/system-design-primer/issues/38)
-* [土耳其语](https://github.com/donnemartin/system-design-primer/issues/39)
-
 ## 目的
 
 > 学习如何设计大型系统。
@@ -91,6 +83,7 @@
 * 修复错误
 * 完善章节
 * 添加章节
+* [帮助翻译](https://github.com/donnemartin/system-design-primer/issues/28)
 
 一些还需要完善的内容放在了[正在完善中](#正在完善中)。
 

solutions/system_design/mint/README-zh-Hans.md

@@ -0,0 +1,440 @@
+# 设计 Mint.com
+
+**注意：这个文档中的链接会直接指向[系统设计主题索引](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#系统设计主题索引)中的有关部分，以避免重复的内容。您可以参考链接的相关内容，来了解其总的要点、方案的权衡取舍以及可选的替代方案。**
+
+## 第一步：简述用例与约束条件
+
+> 搜集需求与问题的范围。
+> 提出问题来明确用例与约束条件。
+> 讨论假设。
+
+我们将在没有面试官明确说明问题的情况下，自己定义一些用例以及限制条件。
+
+### 用例
+
+#### 我们将把问题限定在仅处理以下用例的范围中
+
+* **用户** 连接到一个财务账户
+* **服务** 从账户中提取交易
+    * 每日更新
+    * 分类交易
+        * 允许用户手动分类
+        * 不自动重新分类
+    * 按类别分析每月支出
+* **服务** 推荐预算
+    * 允许用户手动设置预算
+    * 当接近或者超出预算时，发送通知
+* **服务** 具有高可用性
+
+#### 非用例范围
+
+* **服务** 执行附加的日志记录和分析
+
+### 限制条件与假设
+
+#### 提出假设
+
+* 网络流量非均匀分布
+* 自动账户日更新只适用于 30 天内活跃的用户
+* 添加或者移除财务账户相对较少
+* 预算通知不需要及时
+* 1000 万用户
+    * 每个用户10个预算类别= 1亿个预算项
+    * 示例类别:
+        * Housing = $1,000
+        * Food = $200
+        * Gas = $100
+    * 卖方确定交易类别
+        * 50000 个卖方
+* 3000 万财务账户
+* 每月 50 亿交易
+* 每月 5 亿读请求
+* 10:1 读写比
+    * Write-heavy，用户每天都进行交易，但是每天很少访问该网站
+
+#### 计算用量
+
+**如果你需要进行粗略的用量计算，请向你的面试官说明。**
+
+* 每次交易的用量:
+    * `user_id` - 8 字节
+    * `created_at` - 5 字节
+    * `seller` - 32 字节
+    * `amount` - 5 字节
+    * Total: ~50 字节
+* 每月产生 250 GB 新的交易内容
+    * 每次交易 50 比特 * 50 亿交易每月
+    * 3年内新的交易内容 9 TB
+    * Assume most are new transactions instead of updates to existing ones
+* 平均每秒产生 2000 次交易
+* 平均每秒产生 200 读请求
+
+便利换算指南：
+
+* 每个月有 250 万秒
+* 每秒一个请求 = 每个月 250 万次请求
+* 每秒 40 个请求 = 每个月 1 亿次请求
+* 每秒 400 个请求 = 每个月 10 亿次请求
+
+## 第二步：概要设计
+
+> 列出所有重要组件以规划概要设计。
+
+![Imgur](http://i.imgur.com/E8klrBh.png)
+
+## 第三步：设计核心组件
+
+> 深入每个核心组件的细节。
+
+### 用例：用户连接到一个财务账户
+
+我们可以将 1000 万用户的信息存储在一个[关系数据库](https://github.com/donnemartin/system-design-primer#relational-database-management-system-rdbms)中。我们应该讨论一下[选择SQL或NoSQL之间的用例和权衡](https://github.com/donnemartin/system-design-primer#sql-or-nosql)了。
+
+* **客户端** 作为一个[反向代理](https://github.com/donnemartin/system-design-primer#reverse-proxy-web-server)，发送请求到 **Web 服务器**
+* **Web 服务器** 转发请求到 **账户API** 服务器
+* **账户API** 服务器将新输入的账户信息更新到 **SQL数据库** 的`accounts`表
+
+**告知你的面试官你准备写多少代码**。
+
+`accounts`表应该具有如下结构：
+
+```
+id int NOT NULL AUTO_INCREMENT
+created_at datetime NOT NULL
+last_update datetime NOT NULL
+account_url varchar(255) NOT NULL
+account_login varchar(32) NOT NULL
+account_password_hash char(64) NOT NULL
+user_id int NOT NULL
+PRIMARY KEY(id)
+FOREIGN KEY(user_id) REFERENCES users(id)
+```
+
+我们将在`id`，`user_id`和`created_at`等字段上创建一个[索引](https://github.com/donnemartin/system-design-primer#use-good-indices)以加速查找（对数时间而不是扫描整个表）并保持数据在内存中。从内存中顺序读取 1 MB数据花费大约250毫秒，而从SSD读取是其4倍，从磁盘读取是其80倍。<sup><a href=https://github.com/donnemartin/system-design-primer#latency-numbers-every-programmer-should-know>1</a></sup>
+
+我们将使用公开的[**REST API**](https://github.com/donnemartin/system-design-primer#representational-state-transfer-rest):
+
+```
+$ curl -X POST --data '{ "user_id": "foo", "account_url": "bar", \
+    "account_login": "baz", "account_password": "qux" }' \
+    https://mint.com/api/v1/account
+```
+
+对于内部通信，我们可以使用[远程过程调用](https://github.com/donnemartin/system-design-primer#remote-procedure-call-rpc)。
+
+接下来，服务从账户中提取交易。
+
+### 用例：服务从账户中提取交易
+
+如下几种情况下，我们会想要从账户中提取信息：
+
+* 用户首次链接账户
+* 用户手动更新账户
+* 为过去 30 天内活跃的用户自动日更新
+
+数据流:
+
+* **客户端**向 **Web服务器** 发送请求
+* **Web服务器** 将请求转发到 **帐户API** 服务器
+* **帐户API** 服务器将job放在 **队列** 中，如 [Amazon SQS](https://aws.amazon.com/sqs/) 或者 [RabbitMQ](https://www.rabbitmq.com/)
+    * 提取交易可能需要一段时间，我们可能希望[与队列异步](https://github.com/donnemartin/system-design-primer#asynchronism)地来做，虽然这会引入额外的复杂度。
+* **交易提取服务** 执行如下操作：
+    * 从 **Queue** 中拉取并从金融机构中提取给定用户的交易，将结果作为原始日志文件存储在 **对象存储区**。
+    * 使用 **分类服务** 来分类每个交易
+    * 使用 **预算服务** 来按类别计算每月总支出
+        * **预算服务** 使用 **通知服务** 让用户知道他们是否接近或者已经超出预算
+    * 更新具有分类交易的 **SQL数据库** 的`transactions`表
+    * 按类别更新 **SQL数据库** `monthly_spending`表的每月总支出
+    * 通过 **通知服务** 提醒用户交易完成
+        * 使用一个 **队列** (没有画出来) 来异步发送通知
+
+`transactions`表应该具有如下结构：
+
+```
+id int NOT NULL AUTO_INCREMENT
+created_at datetime NOT NULL
+seller varchar(32) NOT NULL
+amount decimal NOT NULL
+user_id int NOT NULL
+PRIMARY KEY(id)
+FOREIGN KEY(user_id) REFERENCES users(id)
+```
+
+我们将在 `id`，`user_id`，和 `created_at`字段上创建[索引](https://github.com/donnemartin/system-design-primer#use-good-indices)。
+
+`monthly_spending`表应该具有如下结构：
+
+```
+id int NOT NULL AUTO_INCREMENT
+month_year date NOT NULL
+category varchar(32)
+amount decimal NOT NULL
+user_id int NOT NULL
+PRIMARY KEY(id)
+FOREIGN KEY(user_id) REFERENCES users(id)
+```
+
+我们将在`id`，`user_id`字段上创建[索引](https://github.com/donnemartin/system-design-primer#use-good-indices)。
+
+#### 分类服务
+
+对于 **分类服务**，我们可以生成一个带有最受欢迎卖家的卖家-类别字典。如果我们估计 50000 个卖家，并估计每个条目占用不少于 255 个字节，该字典只需要大约 12 MB内存。
+
+**告知你的面试官你准备写多少代码**。
+
+```python
+class DefaultCategories(Enum):
+
+    HOUSING = 0
+    FOOD = 1
+    GAS = 2
+    SHOPPING = 3
+    ...
+
+seller_category_map = {}
+seller_category_map['Exxon'] = DefaultCategories.GAS
+seller_category_map['Target'] = DefaultCategories.SHOPPING
+...
+```
+
+对于一开始没有在映射中的卖家，我们可以通过评估用户提供的手动类别来进行众包。在 O(1) 时间内，我们可以用堆来快速查找每个卖家的顶端的手动覆盖。
+
+```python
+class Categorizer(object):
+
+    def __init__(self, seller_category_map, self.seller_category_crowd_overrides_map):
+        self.seller_category_map = seller_category_map
+        self.seller_category_crowd_overrides_map = \
+            seller_category_crowd_overrides_map
+
+    def categorize(self, transaction):
+        if transaction.seller in self.seller_category_map:
+            return self.seller_category_map[transaction.seller]
+        elif transaction.seller in self.seller_category_crowd_overrides_map:
+            self.seller_category_map[transaction.seller] = \
+                self.seller_category_crowd_overrides_map[transaction.seller].peek_min()
+            return self.seller_category_map[transaction.seller]
+        return None
+```
+
+交易实现：
+
+```python
+class Transaction(object):
+
+    def __init__(self, created_at, seller, amount):
+        self.timestamp = timestamp
+        self.seller = seller
+        self.amount = amount
+```
+
+### 用例：服务推荐预算
+
+首先，我们可以使用根据收入等级分配每类别金额的通用预算模板。使用这种方法，我们不必存储在约束中标识的 1 亿个预算项目，只需存储用户覆盖的预算项目。如果用户覆盖预算类别，我们可以在
+`TABLE budget_overrides`中存储此覆盖。
+
+```python
+class Budget(object):
+
+    def __init__(self, income):
+        self.income = income
+        self.categories_to_budget_map = self.create_budget_template()
+
+    def create_budget_template(self):
+        return {
+            'DefaultCategories.HOUSING': income * .4,
+            'DefaultCategories.FOOD': income * .2
+            'DefaultCategories.GAS': income * .1,
+            'DefaultCategories.SHOPPING': income * .2
+            ...
+        }
+
+    def override_category_budget(self, category, amount):
+        self.categories_to_budget_map[category] = amount
+```
+
+对于 **预算服务** 而言，我们可以在`transactions`表上运行SQL查询以生成`monthly_spending`聚合表。由于用户通常每个月有很多交易，所以`monthly_spending`表的行数可能会少于总共50亿次交易的行数。
+
+作为替代，我们可以在原始交易文件上运行 **MapReduce** 作业来：
+
+* 分类每个交易
+* 按类别生成每月总支出
+
+对交易文件的运行分析可以显著减少数据库的负载。
+
+如果用户更新类别，我们可以调用 **预算服务** 重新运行分析。
+
+**告知你的面试官你准备写多少代码**.
+
+日志文件格式样例，以tab分割：
+
+```
+user_id   timestamp   seller  amount
+```
+
+**MapReduce** 实现:
+
+```python
+class SpendingByCategory(MRJob):
+
+    def __init__(self, categorizer):
+        self.categorizer = categorizer
+        self.current_year_month = calc_current_year_month()
+        ...
+
+    def calc_current_year_month(self):
+        """返回当前年月"""
+        ...
+
+    def extract_year_month(self, timestamp):
+        """返回时间戳的年，月部分"""
+        ...
+
+    def handle_budget_notifications(self, key, total):
+        """如果接近或超出预算，调用通知API"""
+        ...
+
+    def mapper(self, _, line):
+        """解析每个日志行，提取和转换相关行。
+
+        参数行应为如下形式：
+
+        user_id   timestamp   seller  amount
+
+        使用分类器来将卖家转换成类别，生成如下形式的key-value对：
+
+        (user_id, 2016-01, shopping), 25
+        (user_id, 2016-01, shopping), 100
+        (user_id, 2016-01, gas), 50
+        """
+        user_id, timestamp, seller, amount = line.split('\t')
+        category = self.categorizer.categorize(seller)
+        period = self.extract_year_month(timestamp)
+        if period == self.current_year_month:
+            yield (user_id, period, category), amount
+
+    def reducer(self, key, value):
+        """将每个key对应的值求和。
+
+        (user_id, 2016-01, shopping), 125
+        (user_id, 2016-01, gas), 50
+        """
+        total = sum(values)
+        yield key, sum(values)
+```
+
+## 第四步：设计扩展
+
+> 根据限制条件，找到并解决瓶颈。
+
+![Imgur](http://i.imgur.com/V5q57vU.png)
+
+**重要提示：不要从最初设计直接跳到最终设计中！**
+
+现在你要 1) **基准测试、负载测试**。2) **分析、描述**性能瓶颈。3) 在解决瓶颈问题的同时，评估替代方案、权衡利弊。4) 重复以上步骤。请阅读[「设计一个系统，并将其扩大到为数以百万计的 AWS 用户服务」](../scaling_aws/README.md) 来了解如何逐步扩大初始设计。
+
+讨论初始设计可能遇到的瓶颈及相关解决方案是很重要的。例如加上一个配置多台 **Web 服务器**的**负载均衡器**是否能够解决问题？**CDN**呢？**主从复制**呢？它们各自的替代方案和需要**权衡**的利弊又有什么呢？
+
+我们将会介绍一些组件来完成设计，并解决架构扩张问题。内置的负载均衡器将不做讨论以节省篇幅。
+
+**为了避免重复讨论**，请参考[系统设计主题索引](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#系统设计主题的索引)相关部分来了解其要点、方案的权衡取舍以及可选的替代方案。
+
+* [DNS](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#域名系统)
+* [负载均衡器](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#负载均衡器)
+* [水平拓展](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#水平扩展)
+* [反向代理（web 服务器）](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#反向代理web-服务器)
+* [API 服务（应用层）](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#应用层)
+* [缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#缓存)
+* [关系型数据库管理系统 (RDBMS)](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#关系型数据库管理系统rdbms)
+* [SQL 故障主从切换](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#故障切换)
+* [主从复制](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#主从复制)
+* [异步](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#异步)
+* [一致性模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#一致性模式)
+* [可用性模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#可用性模式)
+
+我们将增加一个额外的用例：**用户** 访问摘要和交易数据。
+
+用户会话，按类别统计的统计信息，以及最近的事务可以放在 **内存缓存**（如 Redis 或 Memcached ）中。
+
+* **客户端** 发送读请求给 **Web 服务器**
+* **Web 服务器** 转发请求到 **读 API** 服务器
+    * 静态内容可通过 **对象存储** 比如缓存在 **CDN** 上的 S3 来服务
+* **读 API** 服务器做如下动作:
+    * 检查 **内存缓存** 的内容
+        * 如果URL在 **内存缓存**中，返回缓存的内容
+        * 否则
+            * 如果URL在 **SQL 数据库**中，获取该内容
+                * 以其内容更新 **内存缓存**
+
+参考 [何时更新缓存](https://github.com/donnemartin/system-design-primer#when-to-update-the-cache) 中权衡和替代的内容。以上方法描述了 [cache-aside缓存模式](https://github.com/donnemartin/system-design-primer#cache-aside).
+
+我们可以使用诸如 Amazon Redshift 或者 Google BigQuery 等数据仓库解决方案，而不是将`monthly_spending`聚合表保留在 **SQL 数据库** 中。
+
+我们可能只想在数据库中存储一个月的`交易`数据，而将其余数据存储在数据仓库或者 **对象存储区** 中。**对象存储区** （如Amazon S3) 能够舒服地解决每月 250 GB新内容的限制。
+
+为了解决每秒 *平均* 2000 次读请求数（峰值时更高），受欢迎的内容的流量应由 **内存缓存** 而不是数据库来处理。 **内存缓存** 也可用于处理不均匀分布的流量和流量尖峰。 只要副本不陷入重复写入的困境，**SQL 读副本** 应该能够处理高速缓存未命中。
+
+*平均* 200 次交易写入每秒（峰值时更高）对于单个 **SQL 写入主-从服务** 来说可能是棘手的。我们可能需要考虑其它的 SQL 性能拓展技术：
+
+* [联合](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#联合)
+* [分片](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#分片)
+* [非规范化](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#非规范化)
+* [SQL 调优](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#sql-调优)
+
+我们也可以考虑将一些数据移至 **NoSQL 数据库**。
+
+## 其它要点
+
+> 是否深入这些额外的主题，取决于你的问题范围和剩下的时间。
+
+#### NoSQL
+
+* [键-值存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#键-值存储)
+* [文档类型存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#文档类型存储)
+* [列型存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#列型存储)
+* [图数据库](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#图数据库)
+* [SQL vs NoSQL](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#sql-还是-nosql)
+
+### 缓存
+
+* 在哪缓存
+    * [客户端缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#客户端缓存)
+    * [CDN 缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#cdn-缓存)
+    * [Web 服务器缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#web-服务器缓存)
+    * [数据库缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#数据库缓存)
+    * [应用缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#应用缓存)
+* 什么需要缓存
+    * [数据库查询级别的缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#数据库查询级别的缓存)
+    * [对象级别的缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#对象级别的缓存)
+* 何时更新缓存
+    * [缓存模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#缓存模式)
+    * [直写模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#直写模式)
+    * [回写模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#回写模式)
+    * [刷新](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#刷新)
+
+### 异步与微服务
+
+* [消息队列](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#消息队列)
+* [任务队列](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#任务队列)
+* [背压](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#背压)
+* [微服务](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#微服务)
+
+### 通信
+
+* 可权衡选择的方案：
+    * 与客户端的外部通信 - [使用 REST 作为 HTTP API](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#表述性状态转移rest)
+    * 服务器内部通信 - [RPC](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#远程过程调用协议rpc)
+* [服务发现](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#服务发现)
+
+### 安全性
+
+请参阅[「安全」](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#安全)一章。
+
+### 延迟数值
+
+请参阅[「每个程序员都应该知道的延迟数」](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#每个程序员都应该知道的延迟数)。
+
+### 持续探讨
+
+* 持续进行基准测试并监控你的系统，以解决他们提出的瓶颈问题。
+* 架构拓展是一个迭代的过程。

solutions/system_design/pastebin/README-zh-Hans.md

@@ -1,6 +1,6 @@
 # 设计 Pastebin.com (或者 Bit.ly)
 
-**Note: 为了避免重复，当前文档直接链接到[系统设计主题](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#系统设计主题的索引)的相关区域，请参考链接内容以获得综合的讨论点、权衡和替代方案。**
+**注意: 为了避免重复，当前文档会直接链接到[系统设计主题](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#系统设计主题的索引)的相关区域，请参考链接内容以获得综合的讨论点、权衡和替代方案。**
 
 **设计 Bit.ly** - 是一个类似的问题，区别是 pastebin 需要存储的是 paste 的内容，而不是原始的未短化的 url。
 

solutions/system_design/query_cache/README-zh-Hans.md

@@ -0,0 +1,306 @@
+# 设计一个键-值缓存来存储最近 web 服务查询的结果
+
+**注意：这个文档中的链接会直接指向[系统设计主题索引](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#系统设计主题的索引)中的有关部分，以避免重复的内容。你可以参考链接的相关内容，来了解其总的要点、方案的权衡取舍以及可选的替代方案。**
+
+## 第一步：简述用例与约束条件
+
+> 搜集需求与问题的范围。
+> 提出问题来明确用例与约束条件。
+> 讨论假设。
+
+我们将在没有面试官明确说明问题的情况下，自己定义一些用例以及限制条件。
+
+### 用例
+
+#### 我们将把问题限定在仅处理以下用例的范围中
+
+* **用户**发送一个搜索请求，命中缓存
+* **用户**发送一个搜索请求，未命中缓存
+* **服务**有着高可用性
+
+### 限制条件与假设
+
+#### 提出假设
+
+* 网络流量不是均匀分布的
+    * 经常被查询的内容应该一直存于缓存中
+    * 需要确定如何规定缓存过期、缓存刷新规则
+* 缓存提供的服务查询速度要快
+* 机器间延迟较低
+* 缓存有内存限制
+    * 需要决定缓存什么、移除什么
+    *  需要缓存百万级的查询
+* 1000 万用户
+* 每个月 100 亿次查询
+
+#### 计算用量
+
+**如果你需要进行粗略的用量计算，请向你的面试官说明。**
+
+* 缓存存储的是键值对有序表，键为 `query`（查询），值为 `results`（结果）。
+    * `query` - 50 字节
+    * `title` - 20 字节
+    * `snippet` - 200 字节
+    * 总计：270 字节
+* 假如 100 亿次查询都是不同的，且全部需要存储，那么每个月需要 2.7 TB 的缓存空间
+    * 单次查询 270 字节 * 每月查询 100 亿次
+    * 假设内存大小有限制，需要决定如何制定缓存过期规则
+* 每秒 4,000 次请求
+
+便利换算指南：
+
+* 每个月有 250 万秒
+* 每秒一个请求 = 每个月 250 万次请求
+* 每秒 40 个请求 = 每个月 1 亿次请求
+* 每秒 400 个请求 = 每个月 10 亿次请求
+
+## 第二步：概要设计
+
+> 列出所有重要组件以规划概要设计。
+
+![Imgur](http://i.imgur.com/KqZ3dSx.png)
+
+## 第三步：设计核心组件
+
+> 深入每个核心组件的细节。
+
+### 用例：用户发送了一次请求，命中了缓存
+
+常用的查询可以由例如 Redis 或者 Memcached 之类的**内存缓存**提供支持，以减少数据读取延迟，并且避免**反向索引服务**以及**文档服务**的过载。从内存读取 1 MB 连续数据大约要花 250 微秒，而从 SSD 读取同样大小的数据要花费 4 倍的时间，从机械硬盘读取需要花费 80 倍以上的时间。<sup><a href=https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#每个程序员都应该知道的延迟数>1</a></sup>
+
+由于缓存容量有限，我们将使用 LRU（近期最少使用算法）来控制缓存的过期。
+
+* **客户端**向运行[反向代理](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#反向代理web-服务器)的 **Web 服务器**发送一个请求
+* 这个 **Web 服务器**将请求转发给**查询 API** 服务
+* **查询 API** 服务将会做这些事情：
+    * 分析查询
+        * 移除多余的内容
+        * 将文本分割成词组
+        * 修正拼写错误
+        * 规范化字母的大小写
+        * 将查询转换为布尔运算
+    * 检测**内存缓存**是否有匹配查询的内容
+        * 如果命中**内存缓存**，**内存缓存**将会做以下事情：
+            * 将缓存入口的位置指向 LRU 链表的头部
+            * 返回缓存内容
+        * 否则，**查询 API** 将会做以下事情：
+            * 使用**反向索引服务**来查找匹配查询的文档
+                * **反向索引服务**对匹配到的结果进行排名，然后返回最符合的结果
+            * 使用**文档服务**返回文章标题与片段
+            * 更新**内存缓存**，存入内容，将**内存缓存**入口位置指向 LRU 链表的头部
+
+#### 缓存的实现
+
+缓存可以使用双向链表实现：新元素将会在头结点加入，过期的元素将会在尾节点被删除。我们使用哈希表以便能够快速查找每个链表节点。
+
+**向你的面试官告知你准备写多少代码**。
+
+实现**查询 API 服务**：
+
+```python
+class QueryApi(object):
+
+    def __init__(self, memory_cache, reverse_index_service):
+        self.memory_cache = memory_cache
+        self.reverse_index_service = reverse_index_service
+
+    def parse_query(self, query):
+        """移除多余内容，将文本分割成词组，修复拼写错误，
+        规范化字母大小写，转换布尔运算。
+        """
+        ...
+
+    def process_query(self, query):
+        query = self.parse_query(query)
+        results = self.memory_cache.get(query)
+        if results is None:
+            results = self.reverse_index_service.process_search(query)
+            self.memory_cache.set(query, results)
+        return results
+```
+
+实现**节点**：
+
+```python
+class Node(object):
+
+    def __init__(self, query, results):
+        self.query = query
+        self.results = results
+```
+
+实现**链表**：
+
+```python
+class LinkedList(object):
+
+    def __init__(self):
+        self.head = None
+        self.tail = None
+
+    def move_to_front(self, node):
+        ...
+
+    def append_to_front(self, node):
+        ...
+
+    def remove_from_tail(self):
+        ...
+```
+
+实现**缓存**：
+
+```python
+class Cache(object):
+
+    def __init__(self, MAX_SIZE):
+        self.MAX_SIZE = MAX_SIZE
+        self.size = 0
+        self.lookup = {}  # key: query, value: node
+        self.linked_list = LinkedList()
+
+    def get(self, query)
+        """从缓存取得存储的内容
+
+        将入口节点位置更新为 LRU 链表的头部。
+        """
+        node = self.lookup[query]
+        if node is None:
+            return None
+        self.linked_list.move_to_front(node)
+        return node.results
+
+    def set(self, results, query):
+        """将所给查询键的结果存在缓存中。
+
+        当更新缓存记录的时候，将它的位置指向 LRU 链表的头部。
+        如果这个记录是新的记录，并且缓存空间已满，应该在加入新记录前
+        删除最老的记录。
+        """
+        node = self.lookup[query]
+        if node is not None:
+            # 键存在于缓存中，更新它对应的值
+            node.results = results
+            self.linked_list.move_to_front(node)
+        else:
+            # 键不存在于缓存中
+            if self.size == self.MAX_SIZE:
+                # 在链表中查找并删除最老的记录
+                self.lookup.pop(self.linked_list.tail.query, None)
+                self.linked_list.remove_from_tail()
+            else:
+                self.size += 1
+            # 添加新的键值对
+            new_node = Node(query, results)
+            self.linked_list.append_to_front(new_node)
+            self.lookup[query] = new_node
+```
+
+#### 何时更新缓存
+
+缓存将会在以下几种情况更新：
+
+* 页面内容发生变化
+* 页面被移除或者加入了新页面
+* 页面的权值发生变动
+
+解决这些问题的最直接的方法，就是为缓存记录设置一个它在被更新前能留在缓存中的最长时间，这个时间简称为存活时间（TTL）。
+
+参考 [「何时更新缓存」](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#何时更新缓存)来了解其权衡取舍及替代方案。以上方法在[缓存模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#缓存模式)一章中详细地进行了描述。
+
+## 第四步：架构扩展
+
+> 根据限制条件，找到并解决瓶颈。
+
+![Imgur](http://i.imgur.com/4j99mhe.png)
+
+**重要提示：不要从最初设计直接跳到最终设计中！**
+
+现在你要 1) **基准测试、负载测试**。2) **分析、描述**性能瓶颈。3) 在解决瓶颈问题的同时，评估替代方案、权衡利弊。4) 重复以上步骤。请阅读[「设计一个系统，并将其扩大到为数以百万计的 AWS 用户服务」](../scaling_aws/README.md) 来了解如何逐步扩大初始设计。
+
+讨论初始设计可能遇到的瓶颈及相关解决方案是很重要的。例如加上一个配置多台 **Web 服务器**的**负载均衡器**是否能够解决问题？**CDN**呢？**主从复制**呢？它们各自的替代方案和需要**权衡**的利弊又有什么呢？
+
+我们将会介绍一些组件来完成设计，并解决架构扩张问题。内置的负载均衡器将不做讨论以节省篇幅。
+
+**为了避免重复讨论**，请参考[系统设计主题索引](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#系统设计主题的索引)相关部分来了解其要点、方案的权衡取舍以及可选的替代方案。
+
+* [DNS](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#域名系统)
+* [负载均衡器](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#负载均衡器)
+* [水平拓展](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#水平扩展)
+* [反向代理（web 服务器）](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#反向代理web-服务器)
+* [API 服务（应用层）](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#应用层)
+* [缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#缓存)
+* [一致性模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#一致性模式)
+* [可用性模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#可用性模式)
+
+### 将内存缓存扩大到多台机器
+
+为了解决庞大的请求负载以及巨大的内存需求，我们将要对架构进行水平拓展。如何在我们的**内存缓存**集群中存储数据呢？我们有以下三个主要可选方案：
+
+* **缓存集群中的每一台机器都有自己的缓存** - 简单，但是它会降低缓存命中率。
+* **缓存集群中的每一台机器都有缓存的拷贝** - 简单，但是它的内存使用效率太低了。
+* **对缓存进行[分片](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#分片)，分别部署在缓存集群中的所有机器中** - 更加复杂，但是它是最佳的选择。我们可以使用哈希，用查询语句 `machine = hash(query)` 来确定哪台机器有需要缓存。当然我们也可以使用[一致性哈希](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#正在完善中)。
+
+## 其它要点
+
+> 是否深入这些额外的主题，取决于你的问题范围和剩下的时间。
+
+### SQL 缩放模式
+
+* [读取复制](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#主从复制)
+* [联合](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#联合)
+* [分片](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#分片)
+* [非规范化](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#非规范化)
+* [SQL 调优](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#sql-调优)
+
+#### NoSQL
+
+* [键-值存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#键-值存储)
+* [文档类型存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#文档类型存储)
+* [列型存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#列型存储)
+* [图数据库](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#图数据库)
+* [SQL vs NoSQL](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#sql-还是-nosql)
+
+### 缓存
+
+* 在哪缓存
+    * [客户端缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#客户端缓存)
+    * [CDN 缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#cdn-缓存)
+    * [Web 服务器缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#web-服务器缓存)
+    * [数据库缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#数据库缓存)
+    * [应用缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#应用缓存)
+* 什么需要缓存
+    * [数据库查询级别的缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#数据库查询级别的缓存)
+    * [对象级别的缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#对象级别的缓存)
+* 何时更新缓存
+    * [缓存模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#缓存模式)
+    * [直写模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#直写模式)
+    * [回写模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#回写模式)
+    * [刷新](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#刷新)
+
+### 异步与微服务
+
+* [消息队列](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#消息队列)
+* [任务队列](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#任务队列)
+* [背压](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#背压)
+* [微服务](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#微服务)
+
+### 通信
+
+* 可权衡选择的方案：
+    * 与客户端的外部通信 - [使用 REST 作为 HTTP API](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#表述性状态转移rest)
+    * 服务器内部通信 - [RPC](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#远程过程调用协议rpc)
+* [服务发现](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#服务发现)
+
+### 安全性
+
+请参阅[「安全」](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#安全)一章。
+
+### 延迟数值
+
+请参阅[「每个程序员都应该知道的延迟数」](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#每个程序员都应该知道的延迟数)。
+
+### 持续探讨
+
+* 持续进行基准测试并监控你的系统，以解决他们提出的瓶颈问题。
+* 架构拓展是一个迭代的过程。

solutions/system_design/sales_rank/README-zh-Hans.md

@@ -0,0 +1,338 @@
+# 为 Amazon 设计分类售卖排行
+
+**注意：这个文档中的链接会直接指向[系统设计主题索引](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#系统设计主题的索引)中的有关部分，以避免重复的内容。你可以参考链接的相关内容，来了解其总的要点、方案的权衡取舍以及可选的替代方案。**
+
+## 第一步：简述用例与约束条件
+
+> 搜集需求与问题的范围。
+> 提出问题来明确用例与约束条件。
+> 讨论假设。
+
+我们将在没有面试官明确说明问题的情况下，自己定义一些用例以及限制条件。
+
+### 用例
+
+#### 我们将把问题限定在仅处理以下用例的范围中
+
+* **服务**根据分类计算过去一周中最受欢迎的商品
+* **用户**通过分类浏览过去一周中最受欢迎的商品
+* **服务**有着高可用性
+
+#### 不在用例范围内的有
+
+* 一般的电商网站
+    * 只为售卖排行榜设计组件
+
+### 限制条件与假设
+
+#### 提出假设
+
+* 网络流量不是均匀分布的
+* 一个商品可能存在于多个分类中
+* 商品不能够更改分类
+* 不会存在如 `foo/bar/baz` 之类的子分类
+* 每小时更新一次结果
+    * 受欢迎的商品越多，就需要更频繁地更新
+* 1000 万个商品
+* 1000 个分类
+* 每个月 10 亿次交易
+* 每个月 1000 亿次读取请求
+* 100:1 的读写比例
+
+#### 计算用量
+
+**如果你需要进行粗略的用量计算，请向你的面试官说明。**
+
+* 每笔交易的用量：
+    * `created_at` - 5 字节
+    * `product_id` - 8 字节
+    * `category_id` - 4 字节
+    * `seller_id` - 8 字节
+    * `buyer_id` - 8 字节
+    * `quantity` - 4 字节
+    * `total_price` - 5 字节
+    * 总计：大约 40 字节
+* 每个月的交易内容会产生 40 GB 的记录
+    * 每次交易 40 字节 * 每个月 10 亿次交易
+    * 3年内产生了 1.44 TB 的新交易内容记录
+    * 假定大多数的交易都是新交易而不是更改以前进行完的交易
+* 平均每秒 400 次交易次数
+* 平均每秒 40,000 次读取请求
+
+便利换算指南：
+
+* 每个月有 250 万秒
+* 每秒一个请求 = 每个月 250 万次请求
+* 每秒 40 个请求 = 每个月 1 亿次请求
+* 每秒 400 个请求 = 每个月 10 亿次请求
+
+## 第二步：概要设计
+
+> 列出所有重要组件以规划概要设计。
+
+![Imgur](http://i.imgur.com/vwMa1Qu.png)
+
+## 第三步：设计核心组件
+
+> 深入每个核心组件的细节。
+
+### 用例：服务需要根据分类计算上周最受欢迎的商品
+
+我们可以在现成的**对象存储**系统（例如 Amazon S3 服务）中存储 **售卖 API** 服务产生的日志文本， 因此不需要我们自己搭建分布式文件系统了。
+
+**向你的面试官告知你准备写多少代码**。
+
+假设下面是一个用 tab 分割的简易的日志记录：
+
+```
+timestamp   product_id  category_id    qty     total_price   seller_id    buyer_id
+t1          product1    category1      2       20.00         1            1
+t2          product1    category2      2       20.00         2            2
+t2          product1    category2      1       10.00         2            3
+t3          product2    category1      3        7.00         3            4
+t4          product3    category2      7        2.00         4            5
+t5          product4    category1      1        5.00         5            6
+...
+```
+
+**售卖排行服务** 需要用到 **MapReduce**，并使用 **售卖 API** 服务进行日志记录，同时将结果写入 **SQL 数据库**中的总表 `sales_rank` 中。我们也可以讨论一下[究竟是用 SQL 还是用 NoSQL](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#sql-还是-nosql)。
+
+我们需要通过以下步骤使用 **MapReduce**：
+
+* **第 1 步** - 将数据转换为 `(category, product_id), sum(quantity)` 的形式
+* **第 2 步** - 执行分布式排序
+
+```python
+class SalesRanker(MRJob):
+
+    def within_past_week(self, timestamp):
+        """如果时间戳属于过去的一周则返回 True，
+        否则返回 False。"""
+        ...
+
+    def mapper(self, _ line):
+        """解析日志的每一行，提取并转换相关行，
+
+        将键值对设定为如下形式：
+
+        (category1, product1), 2
+        (category2, product1), 2
+        (category2, product1), 1
+        (category1, product2), 3
+        (category2, product3), 7
+        (category1, product4), 1
+        """
+        timestamp, product_id, category_id, quantity, total_price, seller_id, \
+            buyer_id = line.split('\t')
+        if self.within_past_week(timestamp):
+            yield (category_id, product_id), quantity
+
+    def reducer(self, key, value):
+        """将每个 key 的值加起来。
+
+        (category1, product1), 2
+        (category2, product1), 3
+        (category1, product2), 3
+        (category2, product3), 7
+        (category1, product4), 1
+        """
+        yield key, sum(values)
+
+    def mapper_sort(self, key, value):
+        """构造 key 以确保正确的排序。
+
+        将键值对转换成如下形式：
+
+        (category1, 2), product1
+        (category2, 3), product1
+        (category1, 3), product2
+        (category2, 7), product3
+        (category1, 1), product4
+
+        MapReduce 的随机排序步骤会将键
+        值的排序打乱，变成下面这样：
+
+        (category1, 1), product4
+        (category1, 2), product1
+        (category1, 3), product2
+        (category2, 3), product1
+        (category2, 7), product3
+        """
+        category_id, product_id = key
+        quantity = value
+        yield (category_id, quantity), product_id
+
+    def reducer_identity(self, key, value):
+        yield key, value
+
+    def steps(self):
+        """ 此处为 map reduce 步骤"""
+        return [
+            self.mr(mapper=self.mapper,
+                    reducer=self.reducer),
+            self.mr(mapper=self.mapper_sort,
+                    reducer=self.reducer_identity),
+        ]
+```
+
+得到的结果将会是如下的排序列，我们将其插入 `sales_rank` 表中：
+
+```
+(category1, 1), product4
+(category1, 2), product1
+(category1, 3), product2
+(category2, 3), product1
+(category2, 7), product3
+```
+
+`sales_rank` 表的数据结构如下：
+
+```
+id int NOT NULL AUTO_INCREMENT
+category_id int NOT NULL
+total_sold int NOT NULL
+product_id int NOT NULL
+PRIMARY KEY(id)
+FOREIGN KEY(category_id) REFERENCES Categories(id)
+FOREIGN KEY(product_id) REFERENCES Products(id)
+```
+
+我们会以 `id`、`category_id` 与 `product_id` 创建一个 [索引](https://github.com/donnemartin/system-design-primer#use-good-indices)以加快查询速度（只需要使用读取日志的时间，不再需要每次都扫描整个数据表）并让数据常驻内存。从内存读取 1 MB 连续数据大约要花 250 微秒，而从 SSD 读取同样大小的数据要花费 4 倍的时间，从机械硬盘读取需要花费 80 倍以上的时间。<sup><a href=https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#每个程序员都应该知道的延迟数>1</a></sup>
+
+### 用例：用户需要根据分类浏览上周中最受欢迎的商品
+
+* **客户端**向运行[反向代理](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#反向代理web-服务器)的 **Web 服务器**发送一个请求
+* 这个 **Web 服务器**将请求转发给**查询 API** 服务
+* The **查询 API** 服务将从 **SQL 数据库**的 `sales_rank` 表中读取数据
+
+我们可以调用一个公共的 [REST API](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#表述性状态转移rest)：
+
+```
+$ curl https://amazon.com/api/v1/popular?category_id=1234
+```
+
+返回：
+
+```
+{
+    "id": "100",
+    "category_id": "1234",
+    "total_sold": "100000",
+    "product_id": "50",
+},
+{
+    "id": "53",
+    "category_id": "1234",
+    "total_sold": "90000",
+    "product_id": "200",
+},
+{
+    "id": "75",
+    "category_id": "1234",
+    "total_sold": "80000",
+    "product_id": "3",
+},
+```
+
+而对于服务器内部的通信，我们可以使用 [RPC](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#远程过程调用协议rpc)。
+
+## 第四步：架构扩展
+
+> 根据限制条件，找到并解决瓶颈。
+
+![Imgur](http://i.imgur.com/MzExP06.png)
+
+**重要提示：不要从最初设计直接跳到最终设计中！**
+
+现在你要 1) **基准测试、负载测试**。2) **分析、描述**性能瓶颈。3) 在解决瓶颈问题的同时，评估替代方案、权衡利弊。4) 重复以上步骤。请阅读[「设计一个系统，并将其扩大到为数以百万计的 AWS 用户服务」](../scaling_aws/README.md) 来了解如何逐步扩大初始设计。
+
+讨论初始设计可能遇到的瓶颈及相关解决方案是很重要的。例如加上一个配置多台 **Web 服务器**的**负载均衡器**是否能够解决问题？**CDN**呢？**主从复制**呢？它们各自的替代方案和需要**权衡**的利弊又有什么呢？
+
+我们将会介绍一些组件来完成设计，并解决架构扩张问题。内置的负载均衡器将不做讨论以节省篇幅。
+
+**为了避免重复讨论**，请参考[系统设计主题索引](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#系统设计主题的索引)相关部分来了解其要点、方案的权衡取舍以及可选的替代方案。
+
+* [DNS](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#域名系统)
+* [负载均衡器](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#负载均衡器)
+* [水平拓展](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#水平扩展)
+* [反向代理（web 服务器）](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#反向代理web-服务器)
+* [API 服务（应用层）](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#应用层)
+* [缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#缓存)
+* [关系型数据库管理系统 (RDBMS)](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#关系型数据库管理系统rdbms)
+* [SQL 故障主从切换](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#故障切换)
+* [主从复制](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#主从复制)
+* [一致性模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#一致性模式)
+* [可用性模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#可用性模式)
+
+**分析数据库** 可以用现成的数据仓储系统，例如使用 Amazon Redshift 或者 Google BigQuery 的解决方案。
+
+当使用数据仓储技术或者**对象存储**系统时，我们只想在数据库中存储有限时间段的数据。Amazon S3 的**对象存储**系统可以很方便地设置每个月限制只允许新增 40 GB 的存储内容。
+
+平均每秒 40,000 次的读取请求（峰值将会更高）, 可以通过扩展 **内存缓存** 来处理热点内容的读取流量，这对于处理不均匀分布的流量和流量峰值也很有用。由于读取量非常大，**SQL Read 副本** 可能会遇到处理缓存未命中的问题，我们可能需要使用额外的 SQL 扩展模式。
+
+平均每秒 400 次写操作（峰值将会更高）可能对于单个 **SQL 写主-从** 模式来说比较很困难，因此同时还需要更多的扩展技术
+
+SQL 缩放模式包括：
+
+* [联合](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#联合)
+* [分片](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#分片)
+* [非规范化](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#非规范化)
+* [SQL 调优](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#sql-调优)
+
+我们也可以考虑将一些数据移至 **NoSQL 数据库**。
+
+## 其它要点
+
+> 是否深入这些额外的主题，取决于你的问题范围和剩下的时间。
+
+#### NoSQL
+
+* [键-值存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#键-值存储)
+* [文档类型存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#文档类型存储)
+* [列型存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#列型存储)
+* [图数据库](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#图数据库)
+* [SQL vs NoSQL](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#sql-还是-nosql)
+
+### 缓存
+
+* 在哪缓存
+    * [客户端缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#客户端缓存)
+    * [CDN 缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#cdn-缓存)
+    * [Web 服务器缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#web-服务器缓存)
+    * [数据库缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#数据库缓存)
+    * [应用缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#应用缓存)
+* 什么需要缓存
+    * [数据库查询级别的缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#数据库查询级别的缓存)
+    * [对象级别的缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#对象级别的缓存)
+* 何时更新缓存
+    * [缓存模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#缓存模式)
+    * [直写模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#直写模式)
+    * [回写模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#回写模式)
+    * [刷新](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#刷新)
+
+### 异步与微服务
+
+* [消息队列](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#消息队列)
+* [任务队列](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#任务队列)
+* [背压](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#背压)
+* [微服务](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#微服务)
+
+### 通信
+
+* 可权衡选择的方案：
+    * 与客户端的外部通信 - [使用 REST 作为 HTTP API](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#表述性状态转移rest)
+    * 服务器内部通信 - [RPC](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#远程过程调用协议rpc)
+* [服务发现](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#服务发现)
+
+### 安全性
+
+请参阅[「安全」](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#安全)一章。
+
+### 延迟数值
+
+请参阅[「每个程序员都应该知道的延迟数」](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#每个程序员都应该知道的延迟数)。
+
+### 持续探讨
+
+* 持续进行基准测试并监控你的系统，以解决他们提出的瓶颈问题。
+* 架构拓展是一个迭代的过程。

solutions/system_design/scaling_aws/README-zh-Hans.md

@@ -0,0 +1,403 @@
+# 在 AWS 上设计支持百万级到千万级用户的系统
+
+**注释：为了避免重复，这篇文章的链接直接关联到 [系统设计主题](https://github.com/donnemartin/system-design-primer#index-of-system-design-topics) 的相关章节。为一讨论要点、折中方案和可选方案做参考。**
+
+## 第 1 步：用例和约束概要
+
+> 收集需求并调查问题。
+> 通过提问清晰用例和约束。
+> 讨论假设。
+
+如果没有面试官提出明确的问题，我们将自己定义一些用例和约束条件。
+
+### 用例
+
+解决这个问题是一个循序渐进的过程：1) **基准/负载 测试**， 2) 瓶颈 **概述**， 3) 当评估可选和折中方案时定位瓶颈，4) 重复，这是向可扩展的设计发展基础设计的好模式。
+
+除非你有 AWS 的背景或者正在申请需要 AWS 知识的相关职位，否则不要求了解 AWS 的相关细节。并且，这个练习中讨论的许多原则可以更广泛地应用于AWS生态系统之外。
+
+#### 我们就处理以下用例讨论这一问题
+
+* **用户** 进行读或写请求
+    * **服务** 进行处理，存储用户数据，然后返回结果
+* **服务** 需要从支持小规模用户开始到百万用户
+    * 在我们演化架构来处理大量的用户和请求时，讨论一般的扩展模式
+* **服务** 高可用
+
+### 约束和假设
+
+#### 状态假设
+
+* 流量不均匀分布
+* 需要关系数据
+* 从一个用户扩展到千万用户
+    * 表示用户量的增长
+        * 用户量+
+        * 用户量++
+        * 用户量+++
+        * ...
+    * 1000 万用户
+    * 每月 10 亿次写入
+    * 每月 1000 亿次读出
+    * 100:1 读写比率
+    * 每次写入 1 KB 内容
+
+#### 计算使用
+
+**向你的面试官厘清你是否应该做粗略的使用计算**
+
+* 1 TB 新内容 / 月
+    * 1 KB 每次写入 * 10 亿 写入 / 月
+    * 36 TB 新内容 / 3 年
+    * 假设大多数写入都是新内容而不是更新已有内容
+* 平均每秒 400 次写入
+* 平均每秒 40,000 次读取
+
+便捷的转换指南：
+
+* 250 万秒 / 月
+* 1 次请求 / 秒 = 250 万次请求 / 月
+* 40 次请求 / 秒 = 1 亿次请求 / 月
+* 400 次请求 / 秒 = 10 亿请求 / 月
+
+## 第 2 步：创建高级设计方案
+
+> 用所有重要组件概述高水平设计
+
+![Imgur](http://i.imgur.com/B8LDKD7.png)
+
+## 第 3 步：设计核心组件
+
+> 深入每个核心组件的细节。
+
+### 用例：用户进行读写请求
+
+#### 目标
+
+* 只有 1-2 个用户时，你只需要基础配置
+    * 为简单起见，只需要一台服务器
+    * 必要时进行纵向扩展
+    * 监控以确定瓶颈
+
+#### 以单台服务器开始
+
+* **Web 服务器** 在 EC2 上
+    * 存储用户数据
+    * [**MySQL 数据库**](https://github.com/donnemartin/system-design-primer#relational-database-management-system-rdbms)
+
+运用 **纵向扩展**：
+
+* 选择一台更大容量的服务器
+* 密切关注指标，确定如何扩大规模
+    * 使用基本监控来确定瓶颈:CPU、内存、IO、网络等
+    * CloudWatch, top, nagios, statsd, graphite等
+* 纵向扩展的代价将变得更昂贵
+* 无冗余/容错
+
+**折中方案, 可选方案, 和其他细节:**
+
+* **纵向扩展** 的可选方案是 [**横向扩展**](https://github.com/donnemartin/system-design-primer#horizontal-scaling)
+
+#### 自 SQL 开始，但认真考虑 NoSQL
+
+约束条件假设需要关系型数据。我们可以开始时在单台服务器上使用 **MySQL 数据库**。
+
+**折中方案, 可选方案, 和其他细节:**
+
+* 查阅 [关系型数据库管理系统 (RDBMS)](https://github.com/donnemartin/system-design-primer#relational-database-management-system-rdbms) 章节
+* 讨论使用 [SQL 或 NoSQL](https://github.com/donnemartin/system-design-primer#sql-or-nosql) 的原因
+
+#### 分配公共静态 IP
+
+* 弹性 IP 提供了一个公共端点，不会在重启时改变 IP。
+* 故障转移时只需要把域名指向新 IP。
+
+#### 使用 DNS 服务
+
+添加 **DNS** 服务，比如 Route 53（[Amazon Route 53](https://aws.amazon.com/cn/route53/) - 译者注），将域映射到实例的公共 IP 中。
+
+**折中方案, 可选方案, 和其他细节:**
+
+* 查阅 [域名系统](https://github.com/donnemartin/system-design-primer#domain-name-system) 章节
+
+#### 安全的 Web 服务器
+
+* 只开放必要的端口
+    * 允许 Web 服务器响应来自以下端口的请求
+        * HTTP 80
+        * HTTPS 443
+        * SSH IP 白名单 22
+    * 防止 Web 服务器启动外链
+
+**折中方案, 可选方案, 和其他细节:**
+
+* 查阅 [安全](https://github.com/donnemartin/system-design-primer#security) 章节
+
+## 第 4 步：扩展设计
+
+> 在给定约束条件下，定义和确认瓶颈。
+
+### 用户+
+
+![Imgur](http://i.imgur.com/rrfjMXB.png)
+
+#### 假设
+
+我们的用户数量开始上升，并且单台服务器的负载上升。**基准/负载测试** 和 **分析** 指出 **MySQL 数据库** 占用越来越多的内存和 CPU 资源，同时用户数据将填满硬盘空间。
+
+目前，我们尚能在纵向扩展时解决这些问题。不幸的是，解决这些问题的代价变得相当昂贵，并且原来的系统并不能允许在 **MySQL 数据库** 和 **Web 服务器** 的基础上进行独立扩展。
+
+#### 目标
+
+* 减轻单台服务器负载并且允许独立扩展
+    * 在 **对象存储** 中单独存储静态内容
+    * 将 **MySQL 数据库** 迁移到单独的服务器上
+* 缺点
+    * 这些变化会增加复杂性，并要求对 **Web服务器** 进行更改，以指向 **对象存储** 和 **MySQL 数据库**
+    * 必须采取额外的安全措施来确保新组件的安全
+    * AWS 的成本也会增加，但应该与自身管理类似系统的成本做比较
+
+#### 独立保存静态内容
+
+* 考虑使用像 S3 这样可管理的 **对象存储** 服务来存储静态内容
+    * 高扩展性和可靠性
+    * 服务器端加密
+* 迁移静态内容到 S3
+    * 用户文件
+    * JS
+    * CSS
+    * 图片
+    * 视频
+
+#### 迁移 MySQL 数据库到独立机器上
+
+* 考虑使用类似 RDS 的服务来管理 **MySQL 数据库**
+    * 简单的管理，扩展
+    * 多个可用区域
+    * 空闲时加密
+
+#### 系统安全
+
+* 在传输和空闲时对数据进行加密
+* 使用虚拟私有云
+    * 为单个 **Web 服务器** 创建一个公共子网，这样就可以发送和接收来自 internet 的流量
+    * 为其他内容创建一个私有子网，禁止外部访问
+    * 在每个组件上只为白名单 IP 打开端口
+* 这些相同的模式应当在新的组件的实现中实践
+
+**折中方案, 可选方案, 和其他细节:**
+
+* 查阅 [安全](https://github.com/donnemartin/system-design-primer#security) 章节
+
+### 用户+++
+
+![Imgur](http://i.imgur.com/raoFTXM.png)
+
+#### 假设
+
+我们的 **基准/负载测试** 和 **性能测试** 显示，在高峰时段，我们的单一 **Web服务器** 存在瓶颈，导致响应缓慢，在某些情况下还会宕机。随着服务的成熟，我们也希望朝着更高的可用性和冗余发展。
+
+#### 目标
+
+* 下面的目标试图用 **Web服务器** 解决扩展问题
+    * 基于 **基准/负载测试** 和 **分析**，你可能只需要实现其中的一两个技术
+* 使用 [**横向扩展**](https://github.com/donnemartin/system-design-primer#horizontal-scaling) 来处理增加的负载和单点故障
+    * 添加 [**负载均衡器**](https://github.com/donnemartin/system-design-primer#load-balancer) 例如 Amazon 的 ELB 或 HAProxy
+        * ELB 是高可用的
+        * 如果你正在配置自己的 **负载均衡器**, 在多个可用区域中设置多台服务器用于 [双活](https://github.com/donnemartin/system-design-primer#active-active) 或 [主被](https://github.com/donnemartin/system-design-primer#active-passive) 将提高可用性
+        * 终止在 **负载平衡器** 上的SSL，以减少后端服务器上的计算负载，并简化证书管理
+    * 在多个可用区域中使用多台 **Web服务器**
+    * 在多个可用区域的 [**主-从 故障转移**](https://github.com/donnemartin/system-design-primer#master-slave-replication) 模式中使用多个 **MySQL** 实例来改进冗余
+* 分离 **Web 服务器** 和 [**应用服务器**](https://github.com/donnemartin/system-design-primer#application-layer)
+    * 独立扩展和配置每一层
+    * **Web 服务器** 可以作为 [**反向代理**](https://github.com/donnemartin/system-design-primer#reverse-proxy-web-server)
+    * 例如, 你可以添加 **应用服务器** 处理 **读 API** 而另外一些处理 **写 API**
+* 将静态（和一些动态）内容转移到 [**内容分发网络 (CDN)**](https://github.com/donnemartin/system-design-primer#content-delivery-network) 例如 CloudFront 以减少负载和延迟
+
+**折中方案, 可选方案, 和其他细节:**
+
+* 查阅以上链接获得更多细节
+
+### 用户+++
+
+![Imgur](http://i.imgur.com/OZCxJr0.png)
+
+**注意：** **内部负载均衡** 不显示以减少混乱
+
+#### 假设
+
+我们的 **性能/负载测试** 和 **性能测试** 显示我们读操作频繁（100:1 的读写比率），并且数据库在高读请求时表现很糟糕。
+
+#### 目标
+
+* 下面的目标试图解决 **MySQL数据库** 的伸缩性问题
+    * * 基于 **基准/负载测试** 和 **分析**，你可能只需要实现其中的一两个技术
+* 将下列数据移动到一个 [**内存缓存**](https://github.com/donnemartin/system-design-primer#cache)，例如弹性缓存，以减少负载和延迟：
+    * **MySQL** 中频繁访问的内容
+        * 首先, 尝试配置 **MySQL 数据库** 缓存以查看是否足以在实现 **内存缓存** 之前缓解瓶颈
+    * 来自 **Web 服务器** 的会话数据
+        * **Web 服务器** 变成无状态的, 允许 **自动伸缩**
+    * 从内存中读取 1 MB 内存需要大约 250 微秒，而从SSD中读取时间要长 4 倍，从磁盘读取的时间要长 80 倍。<sup><a href=https://github.com/donnemartin/system-design-primer#latency-numbers-every-programmer-should-know>1</a></sup>
+* 添加 [**MySQL 读取副本**](https://github.com/donnemartin/system-design-primer#master-slave-replication) 来减少写主线程的负载
+* 添加更多 **Web 服务器** and **应用服务器** 来提高响应
+
+**折中方案, 可选方案, 和其他细节:**
+
+* 查阅以上链接获得更多细节
+
+#### 添加 MySQL 读取副本
+
+* 除了添加和扩展 **内存缓存**，**MySQL 读副本服务器** 也能够帮助缓解在 **MySQL 写主服务器** 的负载。
+* 添加逻辑到 **Web 服务器** 来区分读和写操作
+* 在 **MySQL 读副本服务器** 之上添加 **负载均衡器** （不是为了减少混乱）
+* 大多数服务都是读取负载大于写入负载
+
+**折中方案, 可选方案, 和其他细节:**
+
+* 查阅 [关系型数据库管理系统 (RDBMS)](https://github.com/donnemartin/system-design-primer#relational-database-management-system-rdbms) 章节
+
+### 用户++++
+
+![Imgur](http://i.imgur.com/3X8nmdL.png)
+
+#### 假设
+
+**基准/负载测试** 和 **分析** 显示，在美国，正常工作时间存在流量峰值，当用户离开办公室时，流量骤降。我们认为，可以通过真实负载自动转换服务器数量来降低成本。我们是一家小商店，所以我们希望 DevOps 尽量自动化地进行 **自动伸缩** 和通用操作。
+
+#### 目标
+
+* 根据需要添加 **自动扩展**
+    * 跟踪流量高峰
+    * 通过关闭未使用的实例来降低成本
+* 自动化 DevOps
+    * Chef, Puppet, Ansible 工具等
+* 继续监控指标以解决瓶颈
+    * **主机水平** - 检查一个 EC2 实例
+    * **总水平** - 检查负载均衡器统计数据
+    * **日志分析** - CloudWatch, CloudTrail, Loggly, Splunk, Sumo
+    * **外部站点的性能** - Pingdom or New Relic
+    * **处理通知和事件** - PagerDuty
+    * **错误报告** - Sentry
+
+#### 添加自动扩展
+
+* 考虑使用一个托管服务，比如AWS **自动扩展**
+    * 为每个 **Web 服务器** 创建一个组，并为每个 **应用服务器** 类型创建一个组，将每个组放置在多个可用区域中
+    * 设置最小和最大实例数
+    * 通过 CloudWatch 来扩展或收缩
+        * 可预测负载的简单时间度量
+        * 一段时间内的指标：
+            * CPU 负载
+            * 延迟
+            * 网络流量
+            * 自定义指标
+    * 缺点
+        * 自动扩展会引入复杂性
+        * 可能需要一段时间才能适当扩大规模，以满足增加的需求，或者在需求下降时缩减规模
+
+### 用户+++++
+
+![Imgur](http://i.imgur.com/jj3A5N8.png)
+
+**注释：** **自动伸缩** 组不显示以减少混乱
+
+#### 假设
+
+当服务继续向着限制条件概述的方向发展，我们反复地运行 **基准/负载测试** 和 **分析** 来进一步发现和定位新的瓶颈。
+
+#### 目标
+
+由于问题的约束，我们将继续提出扩展性的问题：
+
+* 如果我们的 **MySQL 数据库** 开始变得过于庞大, 我们可能只考虑把数据在数据库中存储一段有限的时间, 同时在例如 Redshift 这样的数据仓库中存储其余的数据
+    * 像 Redshift 这样的数据仓库能够轻松处理每月 1TB 的新内容
+* 平均每秒 40,000 次的读取请求, 可以通过扩展 **内存缓存** 来处理热点内容的读取流量，这对于处理不均匀分布的流量和流量峰值也很有用
+    * **SQL读取副本** 可能会遇到处理缓存未命中的问题, 我们可能需要使用额外的 SQL 扩展模式
+* 对于单个 **SQL 写主-从** 模式来说，平均每秒 400 次写操作（明显更高）可能会很困难，同时还需要更多的扩展技术
+
+SQL 扩展模型包括：
+
+* [集合](https://github.com/donnemartin/system-design-primer#federation)
+* [分片](https://github.com/donnemartin/system-design-primer#sharding)
+* [反范式](https://github.com/donnemartin/system-design-primer#denormalization)
+* [SQL 调优](https://github.com/donnemartin/system-design-primer#sql-tuning)
+
+为了进一步处理高读和写请求，我们还应该考虑将适当的数据移动到一个 [**NoSQL数据库**](https://github.com/donnemartin/system-design-primer#nosql) ，例如 DynamoDB。
+
+我们可以进一步分离我们的 [**应用服务器**](https://github.com/donnemartin/system-design-primer#application-layer) 以允许独立扩展。不需要实时完成的批处理任务和计算可以通过 Queues 和 Workers 异步完成：
+
+* 以照片服务为例，照片上传和缩略图的创建可以分开进行
+    * **客户端** 上传图片
+    * **应用服务器** 推送一个任务到 **队列** 例如 SQS
+    * EC2 上的 **Worker 服务** 或者 Lambda 从 **队列** 拉取 work，然后：
+        * 创建缩略图
+        * 更新 **数据库**
+        * 在 **对象存储** 中存储缩略图
+
+**折中方案, 可选方案, 和其他细节:**
+
+* 查阅以上链接获得更多细节
+
+## 额外的话题
+
+> 根据问题的范围和剩余时间，还需要深入讨论其他问题。
+
+### SQL 扩展模式
+
+* [读取副本](https://github.com/donnemartin/system-design-primer#master-slave-replication)
+* [集合](https://github.com/donnemartin/system-design-primer#federation)
+* [分区](https://github.com/donnemartin/system-design-primer#sharding)
+* [反规范化](https://github.com/donnemartin/system-design-primer#denormalization)
+* [SQL 调优](https://github.com/donnemartin/system-design-primer#sql-tuning)
+
+#### NoSQL
+
+* [键值存储](https://github.com/donnemartin/system-design-primer#key-value-store)
+* [文档存储](https://github.com/donnemartin/system-design-primer#document-store)
+* [宽表存储](https://github.com/donnemartin/system-design-primer#wide-column-store)
+* [图数据库](https://github.com/donnemartin/system-design-primer#graph-database)
+* [SQL vs NoSQL](https://github.com/donnemartin/system-design-primer#sql-or-nosql)
+
+### 缓存
+
+* 缓存到哪里
+    * [客户端缓存](https://github.com/donnemartin/system-design-primer#client-caching)
+    * [CDN 缓存](https://github.com/donnemartin/system-design-primer#cdn-caching)
+    * [Web 服务缓存](https://github.com/donnemartin/system-design-primer#web-server-caching)
+    * [数据库缓存](https://github.com/donnemartin/system-design-primer#database-caching)
+    * [应用缓存](https://github.com/donnemartin/system-design-primer#application-caching)
+* 缓存什么
+    * [数据库请求层缓存](https://github.com/donnemartin/system-design-primer#caching-at-the-database-query-level)
+    * [对象层缓存](https://github.com/donnemartin/system-design-primer#caching-at-the-object-level)
+* 何时更新缓存
+    * [预留缓存](https://github.com/donnemartin/system-design-primer#cache-aside)
+    * [完全写入](https://github.com/donnemartin/system-design-primer#write-through)
+    * [延迟写 (写回)](https://github.com/donnemartin/system-design-primer#write-behind-write-back)
+    * [事先更新](https://github.com/donnemartin/system-design-primer#refresh-ahead)
+
+### 异步性和微服务
+
+* [消息队列](https://github.com/donnemartin/system-design-primer#message-queues)
+* [任务队列](https://github.com/donnemartin/system-design-primer#task-queues)
+* [回退压力](https://github.com/donnemartin/system-design-primer#back-pressure)
+* [微服务](https://github.com/donnemartin/system-design-primer#microservices)
+
+### 沟通
+
+* 关于折中方案的讨论:
+    * 客户端的外部通讯 - [遵循 REST 的 HTTP APIs](https://github.com/donnemartin/system-design-primer#representational-state-transfer-rest)
+    * 内部通讯 - [RPC](https://github.com/donnemartin/system-design-primer#remote-procedure-call-rpc)
+* [服务探索](https://github.com/donnemartin/system-design-primer#service-discovery)
+
+### 安全性
+
+参考 [安全章节](https://github.com/donnemartin/system-design-primer#security)
+
+### 延迟数字指标
+
+查阅 [每个程序员必懂的延迟数字](https://github.com/donnemartin/system-design-primer#latency-numbers-every-programmer-should-know)
+
+### 正在进行
+
+* 继续基准测试并监控你的系统以解决出现的瓶颈问题
+* 扩展是一个迭代的过程

solutions/system_design/social_graph/README-zh-Hans.md

@@ -0,0 +1,348 @@
+# 为社交网络设计数据结构
+
+**注释：为了避免重复，这篇文章的链接直接关联到 [系统设计主题](https://github.com/donnemartin/system-design-primer#index-of-system-design-topics) 的相关章节。为一讨论要点、折中方案和可选方案做参考。**
+
+## 第 1 步：用例和约束概要
+
+> 收集需求并调查问题。
+> 通过提问清晰用例和约束。
+> 讨论假设。
+
+如果没有面试官提出明确的问题，我们将自己定义一些用例和约束条件。
+
+### 用例
+
+#### 我们就处理以下用例审视这一问题
+
+* **用户** 寻找某人并显示与被寻人之间的最短路径
+* **服务** 高可用
+
+### 约束和假设
+
+#### 状态假设
+
+* 流量分布不均
+    * 某些搜索比别的更热门，同时某些搜索仅执行一次
+* 图数据不适用单一机器
+* 图的边没有权重
+* 1 千万用户
+* 每个用户平均有 50 个朋友
+* 每月 10 亿次朋友搜索
+
+训练使用更传统的系统 - 别用图特有的解决方案例如 [GraphQL](http://graphql.org/) 或图数据库如 [Neo4j](https://neo4j.com/)。
+
+#### 计算使用
+
+**向你的面试官厘清你是否应该做粗略的使用计算**
+
+* 50 亿朋友关系
+    * 1 亿用户 * 平均每人 50 个朋友
+* 每秒 400 次搜索请求
+
+便捷的转换指南：
+
+* 每月 250 万秒
+* 每秒 1 个请求 = 每月 250 万次请求
+* 每秒 40 个请求 = 每月 1 亿次请求
+* 每秒 400 个请求 = 每月 10 亿次请求
+
+## 第 2 步：创建高级设计方案
+
+> 用所有重要组件概述高水平设计
+
+![Imgur](http://i.imgur.com/wxXyq2J.png)
+
+## 第 3 步：设计核心组件
+
+> 深入每个核心组件的细节。
+
+### 用例： 用户搜索某人并查看到被搜人的最短路径
+
+**和你的面试官说清你期望的代码量**
+
+没有百万用户（点）的和十亿朋友关系（边）的限制，我们能够用一般 BFS 方法解决无权重最短路径任务：
+
+```python
+class Graph(Graph):
+
+    def shortest_path(self, source, dest):
+        if source is None or dest is None:
+            return None
+        if source is dest:
+            return [source.key]
+        prev_node_keys = self._shortest_path(source, dest)
+        if prev_node_keys is None:
+            return None
+        else:
+            path_ids = [dest.key]
+            prev_node_key = prev_node_keys[dest.key]
+            while prev_node_key is not None:
+                path_ids.append(prev_node_key)
+                prev_node_key = prev_node_keys[prev_node_key]
+            return path_ids[::-1]
+
+    def _shortest_path(self, source, dest):
+        queue = deque()
+        queue.append(source)
+        prev_node_keys = {source.key: None}
+        source.visit_state = State.visited
+        while queue:
+            node = queue.popleft()
+            if node is dest:
+                return prev_node_keys
+            prev_node = node
+            for adj_node in node.adj_nodes.values():
+                if adj_node.visit_state == State.unvisited:
+                    queue.append(adj_node)
+                    prev_node_keys[adj_node.key] = prev_node.key
+                    adj_node.visit_state = State.visited
+        return None
+```
+
+我们不能在同一台机器上满足所有用户，我们需要通过 **人员服务器** [拆分](https://github.com/donnemartin/system-design-primer#sharding) 用户并且通过 **查询服务** 访问。
+
+* **客户端** 向 **服务器** 发送请求，**服务器** 作为 [反向代理](https://github.com/donnemartin/system-design-primer#reverse-proxy-web-server)
+* **搜索 API** 服务器向 **用户图服务** 转发请求
+* **用户图服务** 有以下功能：
+    * 使用 **查询服务** 找到当前用户信息存储的 **人员服务器**
+    * 找到适当的 **人员服务器** 检索当前用户的 `friend_ids` 列表
+    * 把当前用户作为 `source` 运行 BFS 搜索算法同时 当前用户的 `friend_ids` 作为每个 `adjacent_node` 的 ids
+    * 给定 id 获取 `adjacent_node`:
+        * **用户图服务** 将 **再次** 和 **查询服务** 通讯，最后判断出和给定 id 相匹配的存储 `adjacent_node` 的 **人员服务器**（有待优化）
+
+**和你的面试官说清你应该写的代码量**
+
+**注释**：简易版错误处理执行如下。询问你是否需要编写适当的错误处理方法。
+
+**查询服务** 实现：
+
+```python
+class LookupService(object):
+
+    def __init__(self):
+        self.lookup = self._init_lookup()  # key: person_id, value: person_server
+
+    def _init_lookup(self):
+        ...
+
+    def lookup_person_server(self, person_id):
+        return self.lookup[person_id]
+```
+
+**人员服务器** 实现：
+
+```python
+class PersonServer(object):
+
+    def __init__(self):
+        self.people = {}  # key: person_id, value: person
+
+    def add_person(self, person):
+        ...
+
+    def people(self, ids):
+        results = []
+        for id in ids:
+            if id in self.people:
+                results.append(self.people[id])
+        return results
+```
+
+**用户** 实现：
+
+```python
+class Person(object):
+
+    def __init__(self, id, name, friend_ids):
+        self.id = id
+        self.name = name
+        self.friend_ids = friend_ids
+```
+
+**用户图服务** 实现：
+
+```python
+class UserGraphService(object):
+
+    def __init__(self, lookup_service):
+        self.lookup_service = lookup_service
+
+    def person(self, person_id):
+        person_server = self.lookup_service.lookup_person_server(person_id)
+        return person_server.people([person_id])
+
+    def shortest_path(self, source_key, dest_key):
+        if source_key is None or dest_key is None:
+            return None
+        if source_key is dest_key:
+            return [source_key]
+        prev_node_keys = self._shortest_path(source_key, dest_key)
+        if prev_node_keys is None:
+            return None
+        else:
+            # Iterate through the path_ids backwards, starting at dest_key
+            path_ids = [dest_key]
+            prev_node_key = prev_node_keys[dest_key]
+            while prev_node_key is not None:
+                path_ids.append(prev_node_key)
+                prev_node_key = prev_node_keys[prev_node_key]
+            # Reverse the list since we iterated backwards
+            return path_ids[::-1]
+
+    def _shortest_path(self, source_key, dest_key, path):
+        # Use the id to get the Person
+        source = self.person(source_key)
+        # Update our bfs queue
+        queue = deque()
+        queue.append(source)
+        # prev_node_keys keeps track of each hop from
+        # the source_key to the dest_key
+        prev_node_keys = {source_key: None}
+        # We'll use visited_ids to keep track of which nodes we've
+        # visited, which can be different from a typical bfs where
+        # this can be stored in the node itself
+        visited_ids = set()
+        visited_ids.add(source.id)
+        while queue:
+            node = queue.popleft()
+            if node.key is dest_key:
+                return prev_node_keys
+            prev_node = node
+            for friend_id in node.friend_ids:
+                if friend_id not in visited_ids:
+                    friend_node = self.person(friend_id)
+                    queue.append(friend_node)
+                    prev_node_keys[friend_id] = prev_node.key
+                    visited_ids.add(friend_id)
+        return None
+```
+
+我们用的是公共的 [**REST API**](https://github.com/donnemartin/system-design-primer#representational-state-transfer-rest)：
+
+```
+$ curl https://social.com/api/v1/friend_search?person_id=1234
+```
+
+响应：
+
+```
+{
+    "person_id": "100",
+    "name": "foo",
+    "link": "https://social.com/foo",
+},
+{
+    "person_id": "53",
+    "name": "bar",
+    "link": "https://social.com/bar",
+},
+{
+    "person_id": "1234",
+    "name": "baz",
+    "link": "https://social.com/baz",
+},
+```
+
+内部通信使用 [远端过程调用](https://github.com/donnemartin/system-design-primer#remote-procedure-call-rpc)。
+
+## 第 4 步：扩展设计
+
+> 在给定约束条件下，定义和确认瓶颈。
+
+![Imgur](http://i.imgur.com/cdCv5g7.png)
+
+**重要：别简化从最初设计到最终设计的过程！**
+
+你将要做的是：1) **基准/负载 测试**， 2) 瓶颈 **概述**， 3) 当评估可选和折中方案时定位瓶颈，4) 重复。以 [在 AWS 上设计支持百万级到千万级用户的系统](../scaling_aws/README.md) 为参考迭代地扩展最初设计。
+
+讨论最初设计可能遇到的瓶颈和处理方法十分重要。例如，什么问题可以通过添加多台 **Web 服务器** 作为 **负载均衡** 解决？**CDN**？**主从副本**？每个问题都有哪些替代和 **折中** 方案？
+
+我们即将介绍一些组件来完成设计和解决扩展性问题。内部负载均衡不显示以减少混乱。
+
+**避免重复讨论**，以下网址链接到 [系统设计主题](https://github.com/donnemartin/system-design-primer#index-of-system-design-topics) 相关的主流方案、折中方案和替代方案。
+
+* [DNS](https://github.com/donnemartin/system-design-primer#domain-name-system)
+* [负载均衡](https://github.com/donnemartin/system-design-primer#load-balancer)
+* [横向扩展](https://github.com/donnemartin/system-design-primer#horizontal-scaling)
+* [Web 服务器（反向代理）](https://github.com/donnemartin/system-design-primer#reverse-proxy-web-server)
+* [API 服务器（应用层）](https://github.com/donnemartin/system-design-primer#application-layer)
+* [缓存](https://github.com/donnemartin/system-design-primer#cache)
+* [一致性模式](https://github.com/donnemartin/system-design-primer#consistency-patterns)
+* [可用性模式](https://github.com/donnemartin/system-design-primer#availability-patterns)
+
+解决 **平均** 每秒 400 次请求的限制（峰值），人员数据可以存在例如 Redis 或 Memcached 这样的 **内存** 中以减少响应次数和下游流量通信服务。这尤其在用户执行多次连续查询和查询哪些广泛连接的人时十分有用。从内存中读取 1MB 数据大约要 250 微秒，从 SSD 中读取同样大小的数据时间要长 4 倍，从硬盘要长 80 倍。<sup><a href=https://github.com/donnemartin/system-design-primer#latency-numbers-every-programmer-should-know>1</a></sup>
+
+以下是进一步优化方案：
+
+* 在 **内存** 中存储完整的或部分的BFS遍历加快后续查找
+* 在 **NoSQL 数据库** 中批量离线计算并存储完整的或部分的BFS遍历加快后续查找
+* 在同一台 **人员服务器** 上托管批处理同一批朋友查找减少机器跳转
+    * 通过地理位置 [拆分](https://github.com/donnemartin/system-design-primer#sharding) **人员服务器** 来进一步优化，因为朋友通常住得都比较近
+* 同时进行两个 BFS 查找，一个从 source 开始，一个从 destination 开始，然后合并两个路径
+* 从有庞大朋友圈的人开始找起，这样更有可能减小当前用户和搜索目标之间的 [离散度数](https://en.wikipedia.org/wiki/Six_degrees_of_separation)
+* 在询问用户是否继续查询之前设置基于时间或跳跃数阈值，当在某些案例中搜索耗费时间过长时。
+* 使用类似 [Neo4j](https://neo4j.com/) 的 **图数据库** 或图特定查询语法，例如 [GraphQL](http://graphql.org/)（如果没有禁止使用 **图数据库** 的限制的话）
+
+## 额外的话题
+
+> 根据问题的范围和剩余时间，还需要深入讨论其他问题。
+
+### SQL 扩展模式
+
+* [读取副本](https://github.com/donnemartin/system-design-primer#master-slave-replication)
+* [集合](https://github.com/donnemartin/system-design-primer#federation)
+* [分区](https://github.com/donnemartin/system-design-primer#sharding)
+* [反规范化](https://github.com/donnemartin/system-design-primer#denormalization)
+* [SQL 调优](https://github.com/donnemartin/system-design-primer#sql-tuning)
+
+#### NoSQL
+
+* [键值存储](https://github.com/donnemartin/system-design-primer#key-value-store)
+* [文档存储](https://github.com/donnemartin/system-design-primer#document-store)
+* [宽表存储](https://github.com/donnemartin/system-design-primer#wide-column-store)
+* [图数据库](https://github.com/donnemartin/system-design-primer#graph-database)
+* [SQL vs NoSQL](https://github.com/donnemartin/system-design-primer#sql-or-nosql)
+
+### 缓存
+
+* 缓存到哪里
+    * [客户端缓存](https://github.com/donnemartin/system-design-primer#client-caching)
+    * [CDN 缓存](https://github.com/donnemartin/system-design-primer#cdn-caching)
+    * [Web 服务缓存](https://github.com/donnemartin/system-design-primer#web-server-caching)
+    * [数据库缓存](https://github.com/donnemartin/system-design-primer#database-caching)
+    * [应用缓存](https://github.com/donnemartin/system-design-primer#application-caching)
+* 缓存什么
+    * [数据库请求层缓存](https://github.com/donnemartin/system-design-primer#caching-at-the-database-query-level)
+    * [对象层缓存](https://github.com/donnemartin/system-design-primer#caching-at-the-object-level)
+* 何时更新缓存
+    * [预留缓存](https://github.com/donnemartin/system-design-primer#cache-aside)
+    * [完全写入](https://github.com/donnemartin/system-design-primer#write-through)
+    * [延迟写 (写回)](https://github.com/donnemartin/system-design-primer#write-behind-write-back)
+    * [事先更新](https://github.com/donnemartin/system-design-primer#refresh-ahead)
+
+### 异步性和微服务
+
+* [消息队列](https://github.com/donnemartin/system-design-primer#message-queues)
+* [任务队列](https://github.com/donnemartin/system-design-primer#task-queues)
+* [回退压力](https://github.com/donnemartin/system-design-primer#back-pressure)
+* [微服务](https://github.com/donnemartin/system-design-primer#microservices)
+
+### 沟通
+
+* 关于折中方案的讨论:
+    * 客户端的外部通讯 - [遵循 REST 的 HTTP APIs](https://github.com/donnemartin/system-design-primer#representational-state-transfer-rest)
+    * 内部通讯 - [RPC](https://github.com/donnemartin/system-design-primer#remote-procedure-call-rpc)
+* [服务探索](https://github.com/donnemartin/system-design-primer#service-discovery)
+
+### 安全性
+
+参考 [安全章节](https://github.com/donnemartin/system-design-primer#security)
+
+### 延迟数字指标
+
+查阅 [每个程序员必懂的延迟数字](https://github.com/donnemartin/system-design-primer#latency-numbers-every-programmer-should-know)
+
+### 正在进行
+
+* 继续基准测试并监控你的系统以解决出现的瓶颈问题
+* 扩展是一个迭代的过程

solutions/system_design/twitter/README-zh-Hans.md

@@ -0,0 +1,331 @@
+# 设计推特时间轴与搜索功能
+
+**注意：这个文档中的链接会直接指向[系统设计主题索引](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#系统设计主题的索引)中的有关部分，以避免重复的内容。你可以参考链接的相关内容，来了解其总的要点、方案的权衡取舍以及可选的替代方案。**
+
+**设计 Facebook 的 feed** 与**设计 Facebook 搜索**与此为同一类型问题。
+
+## 第一步：简述用例与约束条件
+
+> 搜集需求与问题的范围。
+> 提出问题来明确用例与约束条件。
+> 讨论假设。
+
+我们将在没有面试官明确说明问题的情况下，自己定义一些用例以及限制条件。
+
+### 用例
+
+#### 我们将把问题限定在仅处理以下用例的范围中
+
+* **用户**发布了一篇推特
+    * **服务**将推特推送给关注者，给他们发送消息通知与邮件
+* **用户**浏览用户时间轴（用户最近的活动）
+* **用户**浏览主页时间轴（用户关注的人最近的活动）
+* **用户**搜索关键词
+* **服务**需要有高可用性
+
+#### 不在用例范围内的有
+
+* **服务**向 Firehose 与其它流数据接口推送推特
+* **服务**根据用户的”是否可见“选项排除推特
+    * 隐藏未关注者的 @回复
+    * 关心”隐藏转发“设置
+* 数据分析
+
+### 限制条件与假设
+
+#### 提出假设
+
+普遍情况
+
+* 网络流量不是均匀分布的
+* 发布推特的速度需要足够快速
+    * 除非有上百万的关注者，否则将推特推送给粉丝的速度要足够快
+* 1 亿个活跃用户
+* 每天新发布 5 亿条推特，每月新发布 150 亿条推特
+    * 平均每条推特需要推送给 5 个人
+    * 每天需要进行 50 亿次推送
+    * 每月需要进行 1500 亿次推送
+* 每月需要处理 2500 亿次读取请求
+* 每月需要处理 100 亿次搜索
+
+时间轴功能
+
+* 浏览时间轴需要足够快
+* 推特的读取负载要大于写入负载
+    * 需要为推特的快速读取进行优化
+* 存入推特是高写入负载功能
+
+搜索功能
+
+* 搜索速度需要足够快
+* 搜索是高负载读取功能
+
+#### 计算用量
+
+**如果你需要进行粗略的用量计算，请向你的面试官说明。**
+
+* 每条推特的大小：
+    * `tweet_id` - 8 字节
+    * `user_id` - 32 字节
+    * `text` - 140 字节
+    * `media` - 平均 10 KB
+    * 总计： 大约 10 KB
+* 每月产生新推特的内容为 150 TB
+    * 每条推特 10 KB  * 每天 5 亿条推特 * 每月 30 天
+    * 3 年产生新推特的内容为 5.4 PB
+* 每秒需要处理 10 万次读取请求
+    * 每个月需要处理 2500 亿次请求 * (每秒 400 次请求 / 每月 10 亿次请求)
+* 每秒发布 6000 条推特
+    * 每月发布 150 亿条推特 * (每秒 400 次请求 / 每月 10 次请求)
+* 每秒推送 6 万条推特
+    * 每月推送 1500 亿条推特 * (每秒 400 次请求 / 每月 10 亿次请求)
+* 每秒 4000 次搜索请求
+
+便利换算指南：
+
+* 每个月有 250 万秒
+* 每秒一个请求 = 每个月 250 万次请求
+* 每秒 40 个请求 = 每个月 1 亿次请求
+* 每秒 400 个请求 = 每个月 10 亿次请求
+
+## 第二步：概要设计
+
+> 列出所有重要组件以规划概要设计。
+
+![Imgur](http://i.imgur.com/48tEA2j.png)
+
+## 第三步：设计核心组件
+
+> 深入每个核心组件的细节。
+
+### 用例：用户发表了一篇推特
+
+我们可以将用户自己发表的推特存储在[关系数据库](https://github.com/donnemartin/system-design-primer#relational-database-management-system-rdbms)中。我们也可以讨论一下[究竟是用 SQL 还是用 NoSQL](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#sql-还是-nosql)。
+
+构建用户主页时间轴（查看关注用户的活动）以及推送推特是件麻烦事。将特推传播给所有关注者（每秒约递送 6 万条推特）这一操作有可能会使传统的[关系数据库](https://github.com/donnemartin/system-design-primer#relational-database-management-system-rdbms)超负载。因此，我们可以使用 **NoSQL 数据库**或**内存数据库**之类的更快的数据存储方式。从内存读取 1 MB 连续数据大约要花 250 微秒，而从 SSD 读取同样大小的数据要花费 4 倍的时间，从机械硬盘读取需要花费 80 倍以上的时间。<sup><a href=https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#每个程序员都应该知道的延迟数>1</a></sup>
+
+我们可以将照片、视频之类的媒体存储于**对象存储**中。
+
+* **客户端**向应用[反向代理](https://github.com/donnemartin/system-design-primer#reverse-proxy-web-server)的**Web 服务器**发送一条推特
+* **Web 服务器**将请求转发给**写 API**服务器
+* **写 API**服务器将推特使用 **SQL 数据库**存储于用户时间轴中
+* **写 API**调用**消息输出服务**，进行以下操作：
+    * 查询**用户 图 服务**找到存储于**内存缓存**中的此用户的粉丝
+    * 将推特存储于**内存缓存**中的**此用户的粉丝的主页时间轴**中
+        * O(n) 复杂度操作：  1000 名粉丝 = 1000 次查找与插入
+    * 将特推存储在**搜索索引服务**中，以加快搜索
+    * 将媒体存储于**对象存储**中
+    * 使用**通知服务**向粉丝发送推送：
+        * 使用**队列**异步推送通知
+
+**向你的面试官告知你准备写多少代码**。
+
+如果我们用 Redis 作为**内存缓存**，那可以用 Redis 原生的 list 作为其数据结构。结构如下：
+
+```
+           tweet n+2                   tweet n+1                   tweet n
+| 8 bytes   8 bytes  1 byte | 8 bytes   8 bytes  1 byte | 8 bytes   8 bytes  1 byte |
+| tweet_id  user_id  meta   | tweet_id  user_id  meta   | tweet_id  user_id  meta   |
+```
+
+新发布的推特将被存储在对应用户（关注且活跃的用户）的主页时间轴的**内存缓存**中。
+
+我们可以调用一个公共的 [REST API](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#表述性状态转移rest)：
+
+```
+$ curl -X POST --data '{ "user_id": "123", "auth_token": "ABC123", \
+    "status": "hello world!", "media_ids": "ABC987" }' \
+    https://twitter.com/api/v1/tweet
+```
+
+返回：
+
+```
+{
+    "created_at": "Wed Sep 05 00:37:15 +0000 2012",
+    "status": "hello world!",
+    "tweet_id": "987",
+    "user_id": "123",
+    ...
+}
+```
+
+而对于服务器内部的通信，我们可以使用 [RPC](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#远程过程调用协议rpc)。
+
+### 用例：用户浏览主页时间轴
+
+* **客户端**向 **Web 服务器**发起一次读取主页时间轴的请求
+* **Web 服务器**将请求转发给**读取 API**服务器
+* **读取 API**服务器调用**时间轴服务**进行以下操作：
+    * 从**内存缓存**读取时间轴数据，其中包括推特 id 与用户 id - O(1)
+    * 通过 [multiget](http://redis.io/commands/mget) 向**推特信息服务**进行查询，以获取相关 id 推特的额外信息 - O(n)
+    * 通过 muiltiget 向**用户信息服务**进行查询，以获取相关 id 用户的额外信息 - O(n)
+
+REST API：
+
+```
+$ curl https://twitter.com/api/v1/home_timeline?user_id=123
+```
+
+返回：
+
+```
+{
+    "user_id": "456",
+    "tweet_id": "123",
+    "status": "foo"
+},
+{
+    "user_id": "789",
+    "tweet_id": "456",
+    "status": "bar"
+},
+{
+    "user_id": "789",
+    "tweet_id": "579",
+    "status": "baz"
+},
+```
+
+### 用例：用户浏览用户时间轴
+
+* **客户端**向**Web 服务器**发起获得用户时间线的请求
+* **Web 服务器**将请求转发给**读取 API**服务器
+* **读取 API**从 **SQL 数据库**中取出用户的时间轴
+
+REST API 与前面的主页时间轴类似，区别只在于取出的推特是由用户自己发送而不是关注人发送。
+
+### 用例：用户搜索关键词
+
+* **客户端**将搜索请求发给**Web 服务器**
+* **Web 服务器**将请求转发给**搜索 API**服务器
+* **搜索 API**调用**搜索服务**进行以下操作：
+    * 对输入进行转换与分词，弄明白需要搜索什么东西
+        * 移除标点等额外内容
+        * 将文本打散为词组
+        * 修正拼写错误
+        * 规范字母大小写
+        * 将查询转换为布尔操作
+    * 查询**搜索集群**（例如[Lucene](https://lucene.apache.org/)）检索结果：
+        * 对集群内的所有服务器进行查询，将有结果的查询进行[发散聚合（Scatter gathers）](https://github.com/donnemartin/system-design-primer#under-development)
+        * 合并取到的条目，进行评分与排序，最终返回结果
+
+REST API：
+
+```
+$ curl https://twitter.com/api/v1/search?query=hello+world
+```
+
+返回结果与前面的主页时间轴类似，只不过返回的是符合查询条件的推特。
+
+## 第四步：架构扩展
+
+> 根据限制条件，找到并解决瓶颈。
+
+![Imgur](http://i.imgur.com/MzExP06.png)
+
+**重要提示：不要从最初设计直接跳到最终设计中！**
+
+现在你要 1) **基准测试、负载测试**。2) **分析、描述**性能瓶颈。3) 在解决瓶颈问题的同时，评估替代方案、权衡利弊。4) 重复以上步骤。请阅读[「设计一个系统，并将其扩大到为数以百万计的 AWS 用户服务」](../scaling_aws/README.md) 来了解如何逐步扩大初始设计。
+
+讨论初始设计可能遇到的瓶颈及相关解决方案是很重要的。例如加上一个配置多台 **Web 服务器**的**负载均衡器**是否能够解决问题？**CDN**呢？**主从复制**呢？它们各自的替代方案和需要**权衡**的利弊又有什么呢？
+
+我们将会介绍一些组件来完成设计，并解决架构扩张问题。内置的负载均衡器将不做讨论以节省篇幅。
+
+**为了避免重复讨论**，请参考[系统设计主题索引](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#系统设计主题的索引)相关部分来了解其要点、方案的权衡取舍以及可选的替代方案。
+
+* [DNS](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#域名系统)
+* [负载均衡器](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#负载均衡器)
+* [水平拓展](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#水平扩展)
+* [反向代理（web 服务器）](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#反向代理web-服务器)
+* [API 服务（应用层）](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#应用层)
+* [缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#缓存)
+* [关系型数据库管理系统 (RDBMS)](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#关系型数据库管理系统rdbms)
+* [SQL 故障主从切换](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#故障切换)
+* [主从复制](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#主从复制)
+* [一致性模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#一致性模式)
+* [可用性模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#可用性模式)
+
+**消息输出服务**有可能成为性能瓶颈。那些有着百万数量关注着的用户可能发一条推特就需要好几分钟才能完成消息输出进程。这有可能使 @回复 这种推特时出现竞争条件，因此需要根据服务时间对此推特进行重排序来降低影响。
+
+我们还可以避免从高关注量的用户输出推特。相反，我们可以通过搜索来找到高关注量用户的推特，并将搜索结果与用户的主页时间轴合并，再根据时间对其进行排序。
+
+此外，还可以通过以下内容进行优化：
+
+* 仅为每个主页时间轴在**内存缓存**中存储数百条推特
+* 仅在**内存缓存**中存储活动用户的主页时间轴
+    * 如果某个用户在过去 30 天都没有产生活动，那我们可以使用 **SQL 数据库**重新构建他的时间轴
+        * 使用**用户 图 服务**来查询并确定用户关注的人
+        * 从 **SQL 数据库**中取出推特，并将它们存入**内存缓存**
+* 仅在**推特信息服务**中存储一个月的推特
+* 仅在**用户信息服务**中存储活动用户的信息
+* **搜索集群**需要将推特保留在内存中，以降低延迟
+
+我们还可以考虑优化 **SQL 数据库** 来解决一些瓶颈问题。
+
+**内存缓存**能减小一些数据库的负载，靠 **SQL Read 副本**已经足够处理缓存未命中情况。我们还可以考虑使用一些额外的 SQL 性能拓展技术。
+
+高容量的写入将淹没单个的 **SQL 写主从**模式，因此需要更多的拓展技术。
+
+* [联合](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#联合)
+* [分片](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#分片)
+* [非规范化](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#非规范化)
+* [SQL 调优](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#sql-调优)
+
+我们也可以考虑将一些数据移至 **NoSQL 数据库**。
+
+## 其它要点
+
+> 是否深入这些额外的主题，取决于你的问题范围和剩下的时间。
+
+#### NoSQL
+
+* [键-值存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#键-值存储)
+* [文档类型存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#文档类型存储)
+* [列型存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#列型存储)
+* [图数据库](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#图数据库)
+* [SQL vs NoSQL](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#sql-还是-nosql)
+
+### 缓存
+
+* 在哪缓存
+    * [客户端缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#客户端缓存)
+    * [CDN 缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#cdn-缓存)
+    * [Web 服务器缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#web-服务器缓存)
+    * [数据库缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#数据库缓存)
+    * [应用缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#应用缓存)
+* 什么需要缓存
+    * [数据库查询级别的缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#数据库查询级别的缓存)
+    * [对象级别的缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#对象级别的缓存)
+* 何时更新缓存
+    * [缓存模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#缓存模式)
+    * [直写模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#直写模式)
+    * [回写模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#回写模式)
+    * [刷新](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#刷新)
+
+### 异步与微服务
+
+* [消息队列](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#消息队列)
+* [任务队列](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#任务队列)
+* [背压](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#背压)
+* [微服务](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#微服务)
+
+### 通信
+
+* 可权衡选择的方案：
+    * 与客户端的外部通信 - [使用 REST 作为 HTTP API](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#表述性状态转移rest)
+    * 服务器内部通信 - [RPC](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#远程过程调用协议rpc)
+* [服务发现](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#服务发现)
+
+### 安全性
+
+请参阅[「安全」](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#安全)一章。
+
+### 延迟数值
+
+请参阅[「每个程序员都应该知道的延迟数」](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#每个程序员都应该知道的延迟数)。
+
+### 持续探讨
+
+* 持续进行基准测试并监控你的系统，以解决他们提出的瓶颈问题。
+* 架构拓展是一个迭代的过程。

solutions/system_design/web_crawler/README-zh-Hans.md

@@ -0,0 +1,356 @@
+# 设计一个网页爬虫
+
+**注意：这个文档中的链接会直接指向[系统设计主题索引](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#系统设计主题的索引)中的有关部分，以避免重复的内容。你可以参考链接的相关内容，来了解其总的要点、方案的权衡取舍以及可选的替代方案。**
+
+## 第一步：简述用例与约束条件
+
+> 把所有需要的东西聚集在一起，审视问题。不停的提问，以至于我们可以明确使用场景和约束。讨论假设。
+
+我们将在没有面试官明确说明问题的情况下，自己定义一些用例以及限制条件。
+
+### 用例
+
+#### 我们把问题限定在仅处理以下用例的范围中
+
+* **服务** 抓取一系列链接：
+    * 生成包含搜索词的网页倒排索引
+    * 生成页面的标题和摘要信息
+        * 页面标题和摘要都是静态的，它们不会根据搜索词改变
+* **用户** 输入搜索词后，可以看到相关的搜索结果列表，列表每一项都包含由网页爬虫生成的页面标题及摘要
+    * 只给该用例绘制出概要组件和交互说明，无需讨论细节
+* **服务** 具有高可用性
+
+#### 无需考虑
+
+* 搜索分析
+* 个性化搜索结果
+* 页面排名
+
+### 限制条件与假设
+
+#### 提出假设
+
+* 搜索流量分布不均
+    * 有些搜索词非常热门，有些则非常冷门
+* 只支持匿名用户
+* 用户很快就能看到搜索结果
+* 网页爬虫不应该陷入死循环
+    * 当爬虫路径包含环的时候，将会陷入死循环
+* 抓取 10 亿个链接
+    * 要定期重新抓取页面以确保新鲜度
+    * 平均每周重新抓取一次，网站越热门，那么重新抓取的频率越高
+        * 每月抓取 40 亿个链接
+    * 每个页面的平均存储大小：500 KB
+        * 简单起见，重新抓取的页面算作新页面
+* 每月搜索量 1000 亿次
+
+用更传统的系统来练习 —— 不要使用 [solr](http://lucene.apache.org/solr/) 、[nutch](http://nutch.apache.org/) 之类的现成系统。
+
+#### 计算用量
+
+**如果你需要进行粗略的用量计算，请向你的面试官说明。**
+
+* 每月存储 2 PB 页面
+    * 每月抓取 40 亿个页面，每个页面 500 KB
+    * 三年存储 72 PB 页面
+* 每秒 1600 次写请求
+* 每秒 40000 次搜索请求
+
+简便换算指南：
+
+* 一个月有 250 万秒
+* 每秒 1 个请求，即每月 250 万个请求
+* 每秒 40 个请求，即每月 1 亿个请求
+* 每秒 400 个请求，即每月 10 亿个请求
+
+## 第二步： 概要设计
+
+> 列出所有重要组件以规划概要设计。
+
+![Imgur](http://i.imgur.com/xjdAAUv.png)
+
+## 第三步：设计核心组件
+
+> 对每一个核心组件进行详细深入的分析。
+
+### 用例：爬虫服务抓取一系列网页
+
+假设我们有一个初始列表 `links_to_crawl`（待抓取链接），它最初基于网站整体的知名度来排序。当然如果这个假设不合理，我们可以使用 [Yahoo](https://www.yahoo.com/)、[DMOZ](http://www.dmoz.org/) 等知名门户网站作为种子链接来进行扩散 。
+
+我们将用表 `crawled_links` （已抓取链接 ）来记录已经处理过的链接以及相应的页面签名。
+
+我们可以将 `links_to_crawl` 和 `crawled_links` 记录在键-值型 **NoSQL 数据库**中。对于 `crawled_links` 中已排序的链接，我们可以使用 [Redis](https://redis.io/) 的有序集合来维护网页链接的排名。我们应当在 [选择 SQL 还是 NoSQL 的问题上，讨论有关使用场景以及利弊 ](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#sql-还是-nosql)。
+
+*  **爬虫服务**按照以下流程循环处理每一个页面链接：
+    * 选取排名最靠前的待抓取链接
+        * 在  **NoSQL 数据库**的 `crawled_links` 中，检查待抓取页面的签名是否与某个已抓取页面的签名相似
+            * 若存在，则降低该页面链接的优先级
+                * 这样做可以避免陷入死循环
+                * 继续（进入下一次循环）
+            * 若不存在，则抓取该链接
+                * 在**倒排索引服务**任务队列中，新增一个生成[倒排索引](https://en.wikipedia.org/wiki/Search_engine_indexing)任务。
+                * 在**文档服务**任务队列中，新增一个生成静态标题和摘要的任务。
+                * 生成页面签名
+                * 在 **NoSQL 数据库**的 `links_to_crawl` 中删除该链接
+                * 在 **NoSQL 数据库**的 `crawled_links` 中插入该链接以及页面签名
+
+**向面试官了解你需要写多少代码**。
+
+`PagesDataStore` 是**爬虫服务**中的一个抽象类，它使用 **NoSQL 数据库**进行存储。
+
+```python
+class PagesDataStore(object):
+
+    def __init__(self, db);
+        self.db = db
+        ...
+
+    def add_link_to_crawl(self, url):
+        """将指定链接加入 `links_to_crawl`。"""
+        ...
+
+    def remove_link_to_crawl(self, url):
+        """从 `links_to_crawl` 中删除指定链接。"""
+        ...
+
+    def reduce_priority_link_to_crawl(self, url)
+        """在 `links_to_crawl` 中降低一个链接的优先级以避免死循环。"""
+        ...
+
+    def extract_max_priority_page(self):
+        """返回 `links_to_crawl` 中优先级最高的链接。"""
+        ...
+
+    def insert_crawled_link(self, url, signature):
+        """将指定链接加入 `crawled_links`。"""
+        ...
+
+    def crawled_similar(self, signature):
+        """判断待抓取页面的签名是否与某个已抓取页面的签名相似。"""
+        ...
+```
+
+`Page` 是**爬虫服务**的一个抽象类，它封装了网页对象，由页面链接、页面内容、子链接和页面签名构成。
+
+```python
+class Page(object):
+
+    def __init__(self, url, contents, child_urls, signature):
+        self.url = url
+        self.contents = contents
+        self.child_urls = child_urls
+        self.signature = signature
+```
+
+`Crawler` 是**爬虫服务**的主类，由`Page` 和 `PagesDataStore` 组成。
+
+```python
+class Crawler(object):
+
+    def __init__(self, data_store, reverse_index_queue, doc_index_queue):
+        self.data_store = data_store
+        self.reverse_index_queue = reverse_index_queue
+        self.doc_index_queue = doc_index_queue
+
+    def create_signature(self, page):
+        """基于页面链接与内容生成签名。"""
+        ...
+
+    def crawl_page(self, page):
+        for url in page.child_urls:
+            self.data_store.add_link_to_crawl(url)
+        page.signature = self.create_signature(page)
+        self.data_store.remove_link_to_crawl(page.url)
+        self.data_store.insert_crawled_link(page.url, page.signature)
+
+    def crawl(self):
+        while True:
+            page = self.data_store.extract_max_priority_page()
+            if page is None:
+                break
+            if self.data_store.crawled_similar(page.signature):
+                self.data_store.reduce_priority_link_to_crawl(page.url)
+            else:
+                self.crawl_page(page)
+```
+
+### 处理重复内容
+
+我们要谨防网页爬虫陷入死循环，这通常会发生在爬虫路径中存在环的情况。
+
+**向面试官了解你需要写多少代码**.
+
+删除重复链接：
+
+* 假设数据量较小，我们可以用类似于 `sort | unique` 的方法。（译注： 先排序，后去重）
+* 假设有 10 亿条数据，我们应该使用 **MapReduce** 来输出只出现 1 次的记录。
+
+```python
+class RemoveDuplicateUrls(MRJob):
+
+    def mapper(self, _, line):
+        yield line, 1
+
+    def reducer(self, key, values):
+        total = sum(values)
+        if total == 1:
+            yield key, total
+```
+
+比起处理重复内容，检测重复内容更为复杂。我们可以基于网页内容生成签名，然后对比两者签名的相似度。可能会用到的算法有 [Jaccard index](https://en.wikipedia.org/wiki/Jaccard_index) 以及 [cosine similarity](https://en.wikipedia.org/wiki/Cosine_similarity)。
+
+### 抓取结果更新策略
+
+要定期重新抓取页面以确保新鲜度。抓取结果应该有个 `timestamp` 字段记录上一次页面抓取时间。每隔一段时间，比如说 1 周，所有页面都需要更新一次。对于热门网站或是内容频繁更新的网站，爬虫抓取间隔可以缩短。
+
+尽管我们不会深入网页数据分析的细节，我们仍然要做一些数据挖掘工作来确定一个页面的平均更新时间，并且根据相关的统计数据来决定爬虫的重新抓取频率。
+
+当然我们也应该根据站长提供的 `Robots.txt` 来控制爬虫的抓取频率。
+
+### 用例：用户输入搜索词后，可以看到相关的搜索结果列表，列表每一项都包含由网页爬虫生成的页面标题及摘要
+
+*  **客户端**向运行[反向代理](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#反向代理web-服务器)的 **Web 服务器**发送一个请求
+* **Web 服务器** 发送请求到 **Query API** 服务器
+* **查询 API** 服务将会做这些事情：
+    * 解析查询参数
+        * 删除 HTML 标记
+        * 将文本分割成词组 （译注： 分词处理）
+        * 修正错别字
+        * 规范化大小写
+        * 将搜索词转换为布尔运算
+    * 使用**倒排索引服务**来查找匹配查询的文档
+        * **倒排索引服务**对匹配到的结果进行排名，然后返回最符合的结果
+    * 使用**文档服务**返回文章标题与摘要
+
+我们使用  [**REST API**](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#表述性状态转移rest) 与客户端通信：
+
+```
+$ curl https://search.com/api/v1/search?query=hello+world
+```
+
+响应内容:
+
+```
+{
+    "title": "foo's title",
+    "snippet": "foo's snippet",
+    "link": "https://foo.com",
+},
+{
+    "title": "bar's title",
+    "snippet": "bar's snippet",
+    "link": "https://bar.com",
+},
+{
+    "title": "baz's title",
+    "snippet": "baz's snippet",
+    "link": "https://baz.com",
+},
+```
+
+对于服务器内部通信，我们可以使用 [远程过程调用协议（RPC）](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#远程过程调用协议rpc)
+
+
+## 第四步：架构扩展
+
+> 根据限制条件，找到并解决瓶颈。
+
+![Imgur](http://i.imgur.com/bWxPtQA.png)
+
+**重要提示：不要直接从最初设计跳到最终设计！**
+
+现在你要 1) **基准测试、负载测试**。2) **分析、描述**性能瓶颈。3) 在解决瓶颈问题的同时，评估替代方案、权衡利弊。4) 重复以上步骤。请阅读[设计一个系统，并将其扩大到为数以百万计的 AWS 用户服务](../scaling_aws/README.md) 来了解如何逐步扩大初始设计。
+
+讨论初始设计可能遇到的瓶颈及相关解决方案是很重要的。例如加上一套配备多台 **Web 服务器**的**负载均衡器**是否能够解决问题？**CDN**呢？**主从复制**呢？它们各自的替代方案和需要**权衡**的利弊又有哪些呢？
+
+我们将会介绍一些组件来完成设计，并解决架构规模扩张问题。内置的负载均衡器将不做讨论以节省篇幅。
+
+**为了避免重复讨论**，请参考[系统设计主题索引](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#系统设计主题的索引)相关部分来了解其要点、方案的权衡取舍以及替代方案。
+
+* [DNS](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#域名系统)
+* [负载均衡器](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#负载均衡器)
+* [水平扩展](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#水平扩展)
+* [Web 服务器（反向代理）](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#反向代理web-服务器)
+* [API 服务器（应用层）](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#应用层)
+* [缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#缓存)
+* [NoSQL](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#nosql)
+* [一致性模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#一致性模式)
+* [可用性模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#可用性模式)
+
+有些搜索词非常热门，有些则非常冷门。热门的搜索词可以通过诸如 Redis 或者 Memcached 之类的**内存缓存**来缩短响应时间，避免**倒排索引服务**以及**文档服务**过载。**内存缓存**同样适用于流量分布不均匀以及流量短时高峰问题。从内存中读取 1 MB  连续数据大约需要 250 微秒，而从 SSD 读取同样大小的数据要花费 4 倍的时间，从机械硬盘读取需要花费 80 倍以上的时间。<sup><a href="https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#每个程序员都应该知道的延迟数">1</a></sup>
+
+
+以下是优化**爬虫服务**的其他建议：
+
+* 为了处理数据大小问题以及网络请求负载，**倒排索引服务**和**文档服务**可能需要大量应用数据分片和数据复制。
+* DNS 查询可能会成为瓶颈，**爬虫服务**最好专门维护一套定期更新的 DNS 查询服务。
+* 借助于[连接池](https://en.wikipedia.org/wiki/Connection_pool)，即同时维持多个开放网络连接，可以提升**爬虫服务**的性能并减少内存使用量。
+    * 改用 [UDP](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#用户数据报协议udp) 协议同样可以提升性能
+* 网络爬虫受带宽影响较大，请确保带宽足够维持高吞吐量。
+
+## 其它要点
+
+> 是否深入这些额外的主题，取决于你的问题范围和剩下的时间。
+
+### SQL 扩展模式
+
+* [读取复制](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#主从复制)
+* [联合](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#联合)
+* [分片](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#分片)
+* [非规范化](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#非规范化)
+* [SQL 调优](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#sql-调优)
+
+#### NoSQL
+
+* [键-值存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#键-值存储)
+* [文档类型存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#文档类型存储)
+* [列型存储](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#列型存储)
+* [图数据库](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#图数据库)
+* [SQL vs NoSQL](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#sql-还是-nosql)
+
+
+### 缓存
+
+* 在哪缓存
+    * [客户端缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#客户端缓存)
+    * [CDN 缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#cdn-缓存)
+    * [Web 服务器缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#web-服务器缓存)
+    * [数据库缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#数据库缓存)
+    * [应用缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#应用缓存)
+* 什么需要缓存
+    * [数据库查询级别的缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#数据库查询级别的缓存)
+    * [对象级别的缓存](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#对象级别的缓存)
+* 何时更新缓存
+    * [缓存模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#缓存模式)
+    * [直写模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#直写模式)
+    * [回写模式](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#回写模式)
+    * [刷新](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#刷新)
+
+### 异步与微服务
+
+* [消息队列](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#消息队列)
+* [任务队列](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#任务队列)
+* [背压](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#背压)
+* [微服务](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#微服务)
+
+### 通信
+
+* 可权衡选择的方案：
+    * 与客户端的外部通信 - [使用 REST 作为 HTTP API](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#表述性状态转移rest)
+    * 内部通信 - [RPC](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#远程过程调用协议rpc)
+* [服务发现](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#服务发现)
+
+
+### 安全性
+
+请参阅[安全](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#安全)。
+
+
+### 延迟数值
+
+请参阅[每个程序员都应该知道的延迟数](https://github.com/donnemartin/system-design-primer/blob/master/README-zh-Hans.md#每个程序员都应该知道的延迟数)。
+
+### 持续探讨
+
+* 持续进行基准测试并监控你的系统，以解决他们提出的瓶颈问题。
+* 架构扩展是一个迭代的过程。