问题[scalability](dba)

我有一个用例，其中数据是多对多的，需要广泛的查询功能。

参与者和活动

用户/参与者可以注册多个事件。每个事件可以有很多参与者。这是一个多对多的关系。

考虑这样的数据集。

• 每个活动可以有 1000 万用户注册。
• 每个用户最多可以注册 1000 个事件
• 有 1000 个事件正在运行

需要以下查询：

• 查询 1. 获取所有注册活动的 Participants
• 查询 2. 获取参与者注册的所有事件
• 查询 3. 获取参与者即将发生的所有事件

用于处理查询 1和查询 2

EventParticipantTable：（eventId，participantId）：1000 x 10M 记录

这需要搜索 1000 x 10M 记录？

数据集可以根据 eventId 拆分为块，以使其理想地仅扫描 10M 记录，但不确定如何在 PostgreSQL 中处理。

用于处理查询 3

事件表 + EventParticipantTable 加入

这需要两个表的连接，我首先获取即将发生的事件的事件表（基于开始和结束时间戳），并且对于每个匹配的 eventId，需要查找 EventParticipantTable 中是否存在查询的参与者 ID。

这需要搜索 1000 个事件 * (1000 * 10M) 事件参与者表条目？

在这种情况下，每个表 1000 x 10M 记录不是问题吗？

我想试用 Cassandra Cluster。我的主要问题是关于可扩展性。

Cassandra 集群中的每个节点都有相同的数据副本。所以当我总共有 1 TB 并且有 5 个节点时 -> 5TB。

这在某个时候会变得巨大。我如何扩展 Cassandra 以便可以分布存储？我需要再次手动分片吗？

我正在建立一个 SaaS 系统，我们计划为每个客户提供自己的数据库。该系统已经设置好，因此如果负载变得太大，我们可以轻松地扩展到其他服务器；我们希望有成千上万的客户，甚至数以万计的客户。

问题

• 您可以/应该在一台 SQL Server 上拥有的微数据库数量是否有任何实际限制？
• 它会影响服务器的性能吗？
• 拥有 10,000 个每个 100 MB 的数据库，还是一个 1 TB 的数据库更好？

附加信息

当我说“微型数据库”时，我并不是指“微型”；我的意思是我们的目标是成千上万的客户，所以每个单独的数据库只占总数据存储的千分之一或更少。实际上，每个数据库都在 100MB 左右，具体取决于它的使用量。

使用 10,000 个数据库的主要原因是为了可扩展性。事实上，V1 系统有一个数据库，当数据库在负载下紧张时，我们有过一些不舒服的时刻。

它使 CPU、内存、I/O 紧张——以上所有。尽管我们解决了这些问题，但它们让我们意识到，在某些时候，即使拥有世界上最好的索引，如果我们像我们希望的那样成功，我们根本无法将所有数据放在一个大本营' 数据库。所以对于 V2，我们正在分片，所以我们可以在多个数据库服务器之间分配负载。

去年我一直在开发这个分片解决方案。它是每台服务器一个许可证，但无论如何，由于我们在 Azure 上使用虚拟机，因此已经处理好了。现在出现这个问题的原因是因为以前我们只向大型机构提供服务并自己设置每个机构。我们的下一个业务订单是自助服务模式，任何拥有浏览器的人都可以注册并创建自己的数据库。他们的数据库将比大型机构小得多，数量也多得多。

我们尝试了 Azure SQL 数据库弹性池。性能非常令人失望，因此我们切换回常规 VM。

我有一个使用 Azure SQL 数据库的网站，我有一些问题：

1. 缩放过程如何工作？是否有说明它的流程图？
2. 扩展会导致我的网站出现任何停机时间吗？
3. 我可以在扩展过程中将内容写入数据库吗？

我有大量数据，这些数据不断到达。（大约 1000 万行/天，大约 3000 行/10 秒在一天的高峰时间间隔。）

我想将它们存储在 PostgreSQL 数据库中（我使用 PostGis 来处理地理数据，这就是 PostgreSQL 的原因）。

我通常先按时间戳过滤这些数据，然后才想根据其他属性选择数据（因此很少需要处理所有数据）。

我的第一种方法是创建一个在时间戳上有索引的表（以启用对时间戳的快速过滤），我每 10 秒将新到达的行插入到表中（大约 500-3000 行）。这种方法在最初几天有效，但之后将数据插入数据库所花费的时间超过了数据到达的速度（所以我想每 10 秒插入一次新数据，但插入时间超过 10 秒）。（原因显然是更新索引。我使用 COPY 插入数据，如这里所推荐的那样。）

我考虑的其他想法如下，但它们使数据处理变得困难：

• 将不断到达的数据放入不同的表中，然后将其复制到完整的表中，例如每天晚上。但是每天拷贝数据的时间会越来越长，所以时间一长就不可持续了。
• 将每天的数据放入不同的表中。但在这种情况下，很难创建具有重叠间隔或包含多天的查询。（我必须联合表格。）但这个解决方案似乎仍然是最好的......
• 在每次插入之前删除索引（如文档中所写），但随着表的增长，重新创建索引需要越来越多的时间，因此它也不是一个可持续的解决方案。

因为数据是连续到达的（时间戳单调递增），如果我不使用DB，我可以将这些数据存储到文件中（例如1个文件/小时），并根据时间戳对这些文件进行二进制搜索，这样就可以了比使用数据库存储数据快得多（不需要索引），而且它的扩展性也很好（我需要插入和查询相同数量的数据的时间是相同的，它不依赖于总数据尺寸）。所以我认为创建一个满足我要求的解决方案并非不可能。

但很明显，这会导致数据库的可用性大大降低，如果没有 PostgreSQL 的功能（例如进一步过滤数据、PostGIS 功能），在其他方面会更糟。

将数据存储在这些文件中并只在处理期间将它们加载到临时表似乎是解决性能问题的另一种可能的解决方案，但我认为查询会慢得多（因为我必须物理复制数据在磁盘上），这似乎是一个丑陋的解决方案。

我还有什么其他选择可以以可持续的方式处理这些数据量（因此选择和插入相同数量的数据的复杂性不取决于总数据量的大小），但仍然可以合理地查询数据简单的？

正如您可以在此处找到水平应用程序缩放的最佳实践，垂直缩放比水平缩放要昂贵得多：

垂直扩展成本呈指数增长，而水平扩展成本是线性的。

为什么会这样？
垂直扩展意味着“为现有机器增加更多功率”，而水平扩展意味着“增加更多机器”。

在我看来，升级现有机器应该更便宜，因为一些部件已经存在，你只需要购买额外的处理器、内存等，而购买全新的机器应该会导致更高的成本。

有一个包含 5 个表的数据库 {MySql} A, BIG, C, D, E。它们的生长因子约为1/ 100/ 1/ 1/ 1。该表具有关于/ /的BIGInsert/Read/Update 请求比率。插入和更新“不能失败”。1102

表“BIG”具有以下数据：

1. 它们在创建它们的同一天是关键的（从ACID观点来看，AC它非常重要），2 天后它的关键性变得越来越小。
2. 它们为其他一些表格（F、G、...）中的统计信息提供了基础。有一些“数据泵”从 , 读取数据并将BIG其写入。数据泵从 上读取大约 100 行，在 上写入大约 1 行，在 上写入 1 行，等等。在该操作之后，可以删除这些行。FGBIGFGBIG

更多数字：对于大表，我预计：高峰日每天约 +2k 行，平均每天约 +0.5k 行。增长是周期性的：（即 mon=+0.5,...,wed=+0.5,sat=+1k,sun=+2k, mon=+0.5,...）因此我会激活清理每周一次的数据（即周一）

数据描述：它们基本上是需要“实时”（最多 1 小时）服务的用户请求。那些服务过的请求标记为已消费后，基本上不需要存储；我只需要对此做一些统计（也许在某一天之后，但不要着急）。

部署信息：部署在 Heroku 上，我会使用 MySql（据说擅长读取）或 Postgres（据说擅长更新？）对此有什么建议吗？

为了有效地管理数据库的可伸缩性，什么是好的选择？数据泵是一个好的解决方案吗？

我在考虑一个内存表BIG，但据说它提供了一个很好的读取比率（就像它是一个缓存），那么插入和更新呢？还有其他选择吗？

我已经在stackoverflow上发布了这个问题，但我认为我可能会在这里得到更好的答案。
我有一个表存储发生在用户身上的数百万个事件：

                                       Table "public.events"
   Column   |           Type           |                         Modifiers                         
------------+--------------------------+-----------------------------------------------------------
 event_id   | integer                  | not null default nextval('events_event_id_seq'::regclass)
 user_id    | bigint                   | 
 event_type | integer                  | 
 ts         | timestamp with time zone | 

event_type 有 5 个不同的值，即数百万用户，每个 event_type 的每个用户的事件数量不同，通常在 1 到 50 之间。

数据样本：

+-----------+----------+-------------+----------------------------+
| event_id  | user_id  | event_type  |         timestamp          |
+-----------+----------+-------------+----------------------------+
|        1  |       1  |          1  | January, 01 2015 00:00:00  |
|        2  |       1  |          1  | January, 10 2015 00:00:00  |
|        3  |       1  |          1  | January, 20 2015 00:00:00  |
|        4  |       1  |          1  | January, 30 2015 00:00:00  |
|        5  |       1  |          1  | February, 10 2015 00:00:00 |
|        6  |       1  |          1  | February, 21 2015 00:00:00 |
|        7  |       1  |          1  | February, 22 2015 00:00:00 |
+-----------+----------+-------------+----------------------------+

对于每个事件，我想获取同一用户的事件数以及事件event_type发生前 30 天内发生的事件数。

它应该如下所示：

+-----------+----------+-------------+-----------------------------+-------+
| event_id  | user_id  | event_type  |         timestamp           | count |
+-----------+----------+-------------+-----------------------------+-------+
|        1  |       1  |          1  | January, 01 2015 00:00:00   |     1 |
|        2  |       1  |          1  | January, 10 2015 00:00:00   |     2 |
|        3  |       1  |          1  | January, 20 2015 00:00:00   |     3 |
|        4  |       1  |          1  | January, 30 2015 00:00:00   |     4 |
|        5  |       1  |          1  | February, 10 2015 00:00:00  |     3 |
|        6  |       1  |          1  | February, 21 2015 00:00:00  |     3 |
|        7  |       1  |          1  | February, 22 2015 00:00:00  |     4 |
+-----------+----------+-------------+-----------------------------+-------+

到目前为止，我成功地使用了两个不同的查询（在 PostgreSQL 9.4.1 上对 1000 行生成的样本进行测试）：

SELECT 
  event_id, user_id,event_type,"timestamp", 
  (
    SELECT count(*) 
    FROM events 
    WHERE timestamp >= e.timestamp - interval '30 days'
    AND timestamp <= e.timestamp
    AND user_id = e.user_id 
    AND event_type = e.event_type
    GROUP BY event_type, user_id
  ) as "count"
FROM events e;

第一次查询的 SQL Fiddle

它工作得很好，特别是因为我有一个关于时间戳的索引：

Index Scan using pk_event_id on events e  (cost=0.28..12018.74 rows=1000 width=24)
SubPlan 1
  ->  GroupAggregate  (cost=4.33..11.97 rows=1 width=20)
        Group Key: events.event_type, events.user_id
        ->  Bitmap Heap Scan on events  (cost=4.33..11.95 rows=1 width=20)
              Recheck Cond: ((""timestamp"" >= (e."timestamp" - '30 days'::interval)) AND ("timestamp" <= e."timestamp"))
              Filter: ((user_id = e.user_id) AND (event_type = e.event_type))
              ->  Bitmap Index Scan on idx_events_timestamp  (cost=0.00..4.33 rows=5 width=0)
                    Index Cond: ((""timestamp"" >= (e."timestamp" - '30 days'::interval)) AND ("timestamp" <= e."timestamp"))

尽管如此，它还是不能很好地扩展，我认为使用窗口函数可能会提高性能：

SELECT toto.event_id,toto.user_id,toto.event_type,toto.lv as time,COUNT(*)
FROM(
    SELECT e.event_id, e.user_id,e.event_type,"timestamp",
    last_value("timestamp") OVER w as lv,
    unnest(array_agg(e."timestamp") OVER w) as agg
    FROM events e
    WINDOW w AS (PARTITION BY e.user_id,e.event_type ORDER BY e."timestamp"
    ROWS UNBOUNDED PRECEDING)) AS toto
WHERE toto.agg >= toto.lv - interval '30 days'
GROUP by event_id,user_id,event_type,lv;

用于第二个查询的 SQL Fiddle

由于我必须使用 unnest 和子查询，因此性能实际上变得更糟：

Sort  (cost=5344.41..5427.74 rows=33333 width=24)
  Sort Key: toto.event_id
  ->  HashAggregate  (cost=2506.99..2840.32 rows=33333 width=24)
        Group Key: toto.event_id, toto.user_id, toto.event_type, toto.lv
        ->  Subquery Scan on toto  (cost=67.83..2090.33 rows=33333 width=24)
              Filter: (toto.agg >= (toto.lv - '30 days'::interval))
              ->  WindowAgg  (cost=67.83..590.33 rows=100000 width=24)
                    ->  Sort  (cost=67.83..70.33 rows=1000 width=24)
                          Sort Key: e.user_id, e.event_type, e."timestamp"
                          ->  Seq Scan on events e  (cost=0.00..18.00 rows=1000 width=24)

我想知道是否可以修改是否只能保留子查询并以某种方式修改窗口框架以仅保留行时间戳之前 30 天或更短的时间戳。您是否认为可以在不切换到 MapReduce 框架的情况下针对非常大的表扩展此查询？

第二次，我想排除重复的事件，即event_type相同的时间戳。

我目前正在学习 MongoDB，所以这个问题的标题可能措辞不佳，但我希望更好地了解 Mongo 的扩展。我对哪种数据库最适合我当前的需求进行了一些研究，目前一个独立的 Mongo 实例可以满足这一点，但我想为未来做计划。

我试图弄清楚扩大 MongoDB 的过程。就我而言，我预见的问题是需要更大服务器的大量文档。我开始查找有关解决此问题的方法的信息，而我能看到的最佳方法是使用 Mongo 的共享功能。唯一的问题是我不明白从独立到分片的过程。是否有可以解释该过程的文档，或者是否有更好的方法来处理这种缩放？

在我学习这个时，任何帮助表示赞赏。

对于具有大量大规模部署实践经验的 DBA 来说，这是一个问题。

• 我们正在尝试构建一个延迟非常低的应用程序。（我们真的想创造最好的用户体验，在这种情况下延迟很重要。）

• 该应用程序基本上是一个查询数据库 (OrientDB) 的 RESTful Node.js 服务器。静态内容/文件托管在其他地方。对象主要在客户端转换为 UI。

• 我们计划使用 Amazon EC2 来托管 Web 服务器和数据库。

• 高可用性也很重要。

• 目前，成本不是主要的决定因素。

你会推荐什么架构？

这里有2个选项，也许还有更多：

• 将 Web 服务器（在本例中为 Node.js）放在与数据库相同的 EC2 实例上。我们将有多个这样的实例来实现可用性和负载平衡。过去，我用它来减少大容量的延迟，但这些系统不必大幅扩展。也是在安置组之前。

• 或者，在与 REST Web 服务器不同的实例上拥有数据库。

背景

数据库大小约为 50 GB，我们需要更好的解决方案。预计流量将在 8 个月内达到该数量的 10 倍（500 GB 数据库）。

它大约是 20% 的写入和 80% 的读取。现在每秒大约有 1000 个查询，而且这个速度还在增加。