精华内容
下载资源
问答
  • Elasticsearch究竟要设置多少分数?

    万次阅读 多人点赞 2017-09-24 22:34:00
    在构建Elasticsearch集群的初期如果集群分设置不合理,可能在项目的中后期就会出现性能问题。Elasticsearch是一个非常通用的平台,支持各种各样的用例,并且为数据组织和复制策略提供了巨大灵活性。这种灵活性...

    Elasticsearch 最少必要知识实战教程直播回放

    0、引言

    本文翻译自Elasticsearch20170918热乎的官方博客,原作者:Christian Dahlqvist。 在构建Elasticsearch集群的初期如果集群分片设置不合理,可能在项目的中后期就会出现性能问题。

    Elasticsearch是一个非常通用的平台,支持各种各样的用例,并且为数据组织和复制策略提供了巨大灵活性。这种灵活性使得作为ELK新手的你将数据组织成索引和分片变得困难。虽然不一定会在首次启动时出现问题,但由于数据量随时间的推移,可能会导致性能问题。集群所拥有的数据越多,纠正问题就越困难,甚至有时可能需要重新索引大量数据。

    当我们遇到遭遇性能问题的用户时,可以追溯到关于数据索引的数据和群集数量的问题并不罕见。 对于涉及multi-tenancy或使用基于时间的索引的用户尤其如此。 在与用户讨论这个问题时(会议、论坛形式),引申出的一些最常见的问题是:

    1)“我应该有多少个分片?”
    2)“我的分片应该有多大”?
    

    这篇博客文章旨在帮助您回答这些问题,并为使用基于时间的索引的使用案例( 日志记录或安全分析 )提供实用的指导。

    1、什么是分片?

    在开始之前,让我们约定文章中用到的一些概念和术语。
    Elasticsearch中的数据组织成索引。每一个索引由一个或多个分片组成。每个分片是Luncene索引的一个实例,你可以把实例理解成自管理的搜索引擎,用于在Elasticsearch集群中对一部分数据进行索引和处理查询。

    【刷新】当数据写入分片时,它会定期地发布到磁盘上的新的不可变的Lucene段中,此时它可用于查询。——这被称为刷新。更详细的解读请参考:
    http://t.cn/R05e3YR

    【合并】随着分段数(segment)的增长,这些segment被定期地整合到较大的segments。 这个过程被称为合并(merging)。

    由于所有段都是不可变的, 因为新的合并段需要创建,旧的分段将被删除 ,这意味着所使用的磁盘空间通常在索引时会波动。 合并可能资源相当密集,特别是在磁盘I/O方面。

    分片是Elasticsearch在集群周围分发数据的单位。 Elasticsearch在重新平衡数据时 (例如 发生故障后) 移动分片的速度 取决于分片的大小和数量以及网络和磁盘性能。

    提示:避免有非常大的分片,因为大的分片可能会对集群从故障中恢复的能力产生负面影响。 对于多大的分片没有固定的限制,但是分片大小为50GB通常被界定为适用于各种用例的限制

    2、索引有效期( retention period )

    由于段是不可变的,更新文档需要Elasticsearch首先查找现有文档,然后将其标记为已删除,并添加更新的版本。删除文档还需要找到文档并将其标记为已删除。因此,删除的文档将继续占据磁盘空间和一些系统资源,直到它们被合并,这将消耗大量的系统资源。

    Elasticsearch允许从文件系统直接删除完整索引,而不必明确地必须单独删除所有记录。这是迄今为止从Elasticsearch删除数据的最有效的方式。

    ***提示:*尽可能使用基于时间的索引来管理数据。根据保留期(retention period,可以理解成有效期)将数据分组。基于时间的索引还可以轻松地随时间改变主分片和副本分片的数量(以为要生成的下一个索引进行更改)。这简化了适应不断变化的数据量和需求。

    3、索引和分片不是空闲的?

    【集群状态】对于每个Elasticsearch索引,其映射和状态的信息都存储在集群状态。 这些集群状态信息保存在内存中以便快速访问。 因此,如果在集群中拥有大量索引,可能导致大的集群状态(特别是如果映射较大)。 所有更新集群状态操作为了在集群中保证一致性,需要通过单个线程完成,因此更新速度将变慢。

    提示:*为了减少索引数量并避免大的乃至非常庞大的映射,请考虑将相同索引结构的数据存储在相同的索引中*,而不是基于数据的来源将数据分割成独立的索引。 在每个索引的索引数量和映射大小之间找到一个很好的平衡很重要。**

    每个分片都有数据需要保存在内存中并使用堆空间。 这包括在分片级别保存信息的数据结构,也包括在段级别的数据结构,以便定义数据驻留在磁盘上的位置。 这些数据结构的大小不是固定的,并且将根据用例而有所不同。

    然而,段相关开销的一个重要特征是它与分段的大小不成正比。 这意味着与较小的段相比,较大的段的每个数据量具有较少的开销,且这种差异很大。

    【堆内存的重要性】为了能够每个节点存储尽可能多的数据,重要的是尽可能多地管理堆内存使用量并减少其开销。 节点拥有的堆空间越多,它可以处理的数据和分片越多。

    因此,索引和分片从集群的角度看待不是空闲的,因为每个索引和分片都有一定程度的资源开销。

    提示1:小分片会导致小分段(segment),从而增加开销。目的是保持平均分片大小在几GB和几十GB之间。对于具有基于时间的数据的用例,通常看到大小在20GB和40GB之间的分片*。*

    提示2:由于每个分片的开销取决于分段数和大小,通过强制操作迫使较小的段合并成较大的段可以减少开销并提高查询性能。一旦没有更多的数据被写入索引,这应该是理想的。请注意,这是一个消耗资源的(昂贵的)操作,较为理想的处理时段应该在非高峰时段执行。

    提示3:您可以在集群节点上保存的分片数量与您可用的堆内存大小成正比,但这在Elasticsearch中没有的固定限制。 一个很好的经验法则是:确保每个节点的分片数量保持在低于每1GB堆内存对应集群的分片在20-25之间。 因此,具有30GB堆内存的节点最多可以有600-750个分片,但是进一步低于此限制,您可以保持更好。 这通常会帮助群体保持处于健康状态。

    4、分片的大小如何影响性能?

    在Elasticsearch中,每个查询在每个分片的单个线程中执行。然而,可以并行处理多个分片,并可以在相同分片上执行多个查询和聚合。

    【小分片的利弊】这意味着,在不涉及高速缓存时,最小查询延迟将取决于数据、查询的类型、分片的大小。查询大量小分片将使得每个分片的处理速度更快,但是随着更多的任务需要按顺序排队和处理,它不一定要比查询较小数量的更大的分片更快。如果有多个并发查询,则有很多小碎片也会降低查询吞吐量。

    提示:从查询性能角度确定最大分片大小的最佳方法是使用逼真的数据和查询进行基准测试(真实数据而非模拟数据)。 始终使用查询和索引负载进行基准测试,代表节点在生产中需要处理的内容,因为单个查询的优化可能会产生误导性的结果。

    5、如何管理分片大小?

    当使用基于时间的索引时,每个索引传统上都与固定的时间段相关联。 每日索引非常普遍,经常用于持有时间区间短或每日量大的数据。 这些允许数据期限期间以良好的粒度进行管理,并且可以方便地对每天更换调整volumes。

    时间周期长的数据,特别是如果每日不保存每天的索引数据,则通常会使用每周或每月的保存的碎片大小的增加。 这减少了随着时间的流逝需要存储在群集中的索引和碎片数量大小(直译有点费劲此处)。

    提示:如果使用固定期限的时间索引数据,可以根据时间周期预期数据量调整所涵盖的时间范围,以达到目标分片大小。

    【均匀更新&快速变化的索引数据对比】具有固定时间间隔的基于时间的索引在数据量合理预测并且变化缓慢的情况下工作良好。 如果索引率可以快速变化,则很难保持均匀的目标分片大小。

    为了能够更好地处理这种情况,推出了Rollover和Shrink API。 这些增加了如何管理索引和分片的灵活性,尤其适用于基于时间的索引。

    此处省略了 Rollover和Shrink API的介绍。(建议查询官网补齐概念再深入)

    6、结论

    这篇博客文章提供了有关如何在Elasticsearch中最好地管理数据的提示和实用指南。 如果您有兴趣了解更多,推荐阅读Google搜索 “Elasticsearch: the definitive guide” (有点旧,值得阅读)。

    然而,关于如何最好地在索引和分片上分发数据的许多决策将取决于用例细节,有时可能难以确定如何最佳地应用可用的建议。

    文章提及的几个核心建议清单如下,以回答文章开头的提问。

    1) “我应该有多少个分片?”
    答: 每个节点的分片数量保持在低于每1GB堆内存对应集群的分片在20-25之间。
    2) “我的分片应该有多大”?
    答:分片大小为50GB通常被界定为适用于各种用例的限制。
    

    还是读起来有点拗口,一些概念还是不够深入,不能很好的深入浅出的讲解。
    待我实践中更新吧。更多细节,欢迎讨论!

    ——————————————————————————————————
    更多ES相关实战干货经验分享,请扫描下方【铭毅天下】微信公众号二维码关注。
    (每周至少更新一篇!)

    这里写图片描述
    和你一起,死磕Elasticsearch
    ——————————————————————————————————

    2017年09月24日 22:34 于家中床前

    作者:铭毅天下
    转载请标明出处,原文地址:
    http://blog.csdn.net/laoyang360/article/details/78080602
    如果感觉本文对您有帮助,请点击‘喜欢’支持一下,并分享出去,让更多的人受益。您的支持是我坚持写作最大的动力,谢谢!

    展开全文
  • 服务层分——RDB 分新思路

    万次阅读 2019-04-19 09:46:14
    目前国内流行的开源数据库分实现都基于 SQL 的改写、分发与结果归并。但这种实现存在一些无法避免的缺陷,本文试图说明白这些缺陷的由来及提供一个传统数据库分实现的新思路。 流行分框架实现分析 目前国内...

    目前国内流行的开源数据库分片实现都基于 SQL 的改写、分发与结果归并。但这种实现存在一些无法避免的缺陷,本文试图说明白这些缺陷的由来及提供一个传统数据库分片实现的新思路。

    流行分片框架实现分析

    目前国内流行的开源 RDB(Relation Database) 分片框架,无论是在 应用端 进行分片还是利用 中间件 进行分片, 其都基于 SQL 进行,主要的流程是:

    1. 解析上层传入的 SQL
    2. 结合对应的分表分库配置,对传入的 SQL 进行改写并分发到对应的单机数据库上
    3. 获得各个单机数据库的返回结果后,根据原 SQL 归并结果,返回用户原 SQL 期待的结果

    这种实现希望从 SQL 层提供一个屏蔽底层分片逻辑的解决方案,对上层应用来说,只有一个 RDB,这样应用可以 透明地访问多个数据库

    然而,这仅仅只是一个美丽的目标。因种种原因,目前流行的开源 SQL 层分片方案无法提供跟原生数据库一样的功能:

    • ACID 里的 A(原子性)无法保证
    • ACID 里的 C(一致性)可能被打破
    • ACID 里的 I(隔离性)与原生不一致
    • 由于 SQL 解析复杂,性能等考虑,很多数据库 SQL 不支持

    除了上面与原生数据库的差异外,读写分离在基于 SQL 的框架也无法完美实现。

    以下我们浅析一下这类基于 SQL 的分片框架不能达到上面要求的原因。

    一些经过大量魔改的商业数据库中间件能实现与单机数据库一致的 AC 特性,I 特性也能达到 RR(Reapeatable Read)级别,但其实现较为复杂,大量处理逻辑都迁移到了中间件中,也不开源,本文暂不讨论。

    原子性

    分片框架如果要保证跨分片的原子性,有两个选择。

    2PC(Two-phase Commit)

    其利用 WriteAheadLog 及锁之类的阻塞等待机制确保分布式事务的强一致性。

    最终一致

    其不要求多个分布式系统对于某个跨库事务马上达到一致的状态,只要最终某   个时间点达到一致即可。

    若使用 2PC,就像大家都听说的,因其需要同步协调处理数据,维护使用的锁,性能会降低(据说 20% 左右)。

    若存在分片节点宕机的情况,会导致与这个分片相关的事务都变慢(其他分片等待这个宕机分片的反馈,超时才回滚),甚至引起雪崩效应,导致整个集群不可用。

    同时 2PC 实现复杂度也较高,据我了解目前开源的实现中没有提供 2PC 的事务支持。

    最终一致可以实现跨分片大事务的最终的原子性。只要发起方分片能正常运作,那么客户操作就能进行。然而,在 SQL 层实现最终一致是不合适的。

    首先,能否使用最终一致是由 业务决定 的,其跟业务设计强耦合;其次基于 SQL 层做最终一致时要求跨分片的 SQL 必须可重复执行(幂等),如

    update account set account.money=1000;

    而不能是

    update account set account.money 
    = account.money + 1000;

    同时若未达到最终一致的情况下,读取了记录,并依赖于此进行了判断及记录修改的话,则会产生错误的数据。单机数据库 ACID 的意义荡然无存。

    我们至少可以推断出,这类在 SQL 层做的最终一致性 越位 了,在 SQL 层无法优雅的实现最终一致,最终一致是服务层(业务层次)的事情。

    因此开源分片框架基本都不保证 A。为了实现跨库的 Update 操作,基于 SQL 的分片框架们创造了一个概念“弱 XA”。其主要实现流程如下:

    • 执行 A 分片的 SQL

    • 执行 B 分片的 SQL

    • 执行 A 库的提交

    • 执行 B 库的提交

    其可以做到:整体事务 COMMIT 前,若有任何异常,都可完美回滚。

    但其存在的缺陷是:当 A 库提交后,B 库失败的话,整个事务就会处于不一致的状态。

    当然,交易量少的时候,这个出错的概率就比较少。但交易量变多的话,这里总会因为网络抖动等各种原因产生错误。

    一致性

    其实一致性是跟原子性有所关联的,只要原子性没能保证,那么一致性肯定是无法保证的。

    隔离级别

    隔离级别在 SQL92 里定义的是这么四个:脏读、读已提交、可重复读、可序列化。

    它们并非无关痛痒的几个数据库参数。隔离级别不一样,对应的在我们的程序里要实现业务一致性的代码逻辑也不一样。

    然而基于 SQL 的分片框架在跨分片访问时提供的事务隔离级别并非原生数据库里定义的,而是一个新的,未被广泛理解认可的事务隔离级别。

    程序员如果没能领悟这个区别,程序执行过程中很有可能就会出现程序员自己也无法理解的错误。

    SQL 兼容性

    由于 SQL 解析的复杂性及性能等因素,基于 SQL 的分片框架有很多 SQL 的解析是不支持的。并且由于 SQL 解析确实很复杂,对于其声明的支持的 SQL 存在 BUG 的可能性也很大。

    至于具体哪些 SQL 不支持,本文就不再分析,大家可以阅读相关框架文档得知。

    读写分离

    读写分离并非原生数据库里支持的功能,但一个较好的读写分离实现应该是能在读库里跑读事务的。

    然而很多人,认为进行只读操作时,加事务是没意义的。如果有这么认识的人,我觉得可能并没有透彻理解 ACID 中的 I。

    举一个例子,一个界面上,需要展示客户的余额以及他的转账记录。如果余额跟转账记录的查询不在一个 RR 级别的事务里进行的话,那么查询出来的结果就有可能出现余额跟转账记录对不上的情况!

    如果是客户 UI 查询还好,刷新一下就好了。但如果是为了生成对账文件,那不就出现大问题了?

    然而,在基于 SQL 层的分片实现中,是没有办法做到完美的读写分离的。因其无法知道这个事务究竟是读事务,还是写事务,因此在第一条 SQL 执行时无法确定要走读库还是写库。

    因此,在基于 SQL 层的分片框架中的做法基本都是:

    • 若有事务,直接走写库

    • 若无事务,直接走读库,若后续发生了 Update 操作,则线程后续操作都走写库

    由此可见,这种读写分离,是不完善的,要实现 RR 级别的读,只能走主库,或者只能返回一个隔离级别混乱的数据集。

    分片新思路――服务层分片

    正因为基于 SQL 的分片框架提供的 ACID 特性与原生的不一样,所以,在上层应用 SQL 编码过程中,必须明确经过分片框架封装后的 ACID 特性是怎样的,并根据该框架的特性,写出对应调整后的 SQL 才能得到正确可靠的代码逻辑。分片框架的特性一直影响着 SQL 的实际形式。

    因此,基于 SQL 的分片方案对应用层并不透明。

    如果要基于 SQL 层的框架写出正确可靠的代码的话,大多数情况下需要遵循的一条原则是:所有事务(包括读、写)都不能跨库。(某些对隔离级别要求不是很高的业务可以允许读跨库)

    如果要遵循上面的指导原则的话,那么,实际上,大多数情况下,我们需要的分片框架提供的仅仅只是选择一个合适的数据源而已。

    结合之前关于读写分离的分析,如果分片实现改在 Service 层,可以清晰地看到会有以下两点好处:

    • Service 层有明确的读 / 写事务信息,能实现理想的 RR 级别读写分离

    • Service 层的入参里就有供选择分片的信息,无需经过复杂的 SQL 解析就可以选定分片,完成我们对分片框架的绝大多数需求

    基于以上两点好处,本人尝试编写了一个基于 Service 层的分片框架,以下展示本人在 Service 层实现分片的一个框架的使用方法,后续我们将更详细地分析该实现的优缺点。

    基本使用方法

    Service 层

    @Service
    @ShardingContext(dataSourceSet="orderSet",
    shardingKeyEls="[user].userId",
    shardingStrategy="@modUserId",
    generateIdStrategy="@snowflaker",
    generateIdEls="[user].userId")
    public class UserServceImpl {
    @Autowired
    private UserDaoImpl userDao;
    @Transactional
    @SelectDataSource
    public void updateUser(User user){
    userDao.updateUser(user);
    }
    @Transactional
    @SelectDataSource
    @GenerateId
    public void saveUser(User user){
    userDao.saveUser(user);
    }
    @Transactional(readOnly=true)
    @SelectDataSource(keyNameEls="[userId]")
    public User findUser(int userId){
    return userDao.findUser(userId);
    }
    public List<User> findAllUsers(){
    return userDao.findAllUsers();
    }
        public double calcUserAvgAge(){
        List<User> allUsers = userDao.findAllUsers();
        return allUsers.stream().mapToInt(u->u.getAge())
    .average().getAsDouble();
        }

    @ShardingContext 表示当前的 Service 的分片上下文,就是说,如果有选择数据源、Map 到各数据库 Reduce 出结果、生成 ID 等操作时,如果某些参数没有指定,都从这个 ShardingContext 里面的配置取

    @SelectDataSource 表示为该方法内执行的 SQL 根据分片策略选择一个分片数据源,在方法结束返回前,不能更改分片数据源

    @GenerateId 表示生成 ID,并将其赋值到参数的指定位置

    @GenerateId 对应的逻辑会先执行,然后到 @SelectDataSource 然后到 @Transaction

    @Transactional(readOnly=true) 标签指定了事务是只读的,因此框架会根据 readOnly标志自动选择读库(如果有的话)

    从方法 calcUserAvgAge 可以看到在 JDK8 的 LAMBADA 表达式及 Stream 功能下,JAVA 分析处理集合数据变得极为简单,复杂度基本与 SQL 语句一致,这会大大减少我们自行加工分片数据的复杂度。

    DAO 层

    @Component
    public class UserDaoImpl {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    public void updateUser(User user){
    int update = jdbcTemplate.update
    ("UPDATE `user` SET `name`=? WHERE 
    `user_id`=?;",user.getName(),user.getUserId());
    Assert.isTrue(update == 1,"it should be updated!");
    }
    public User findUser(int userId){
    return jdbcTemplate.queryForObject
    ("SELECT * FROM user WHERE user_id = ?", 
    new Object[]{userId}, rowMapper);
    }
    @Transactional
    @MapReduce
    public List<User> findAllUsers(){
    return jdbcTemplate.query
    ("SELECT * FROM user", rowMapper);
    }
    @Transactional(readOnly=true)
    @MapReduce
    public void findAllUsers
    (ReduceResultHolder resultHolder){
       List<User> shardingUsers = jdbcTemplate.query
    ("SELECT * FROM user", rowMapper);
       resultHolder.setShardingResult(shardingUsers);
    }
    }

    @MapReduce 表示该方法将会在每个数据分片都执行一遍,然后进行数据聚合后返回。

    对于聚合前后返回的数据类型一致的方法,调用时可以直接从返回值取得聚合结果。

    对于聚合前后返回的数据类型不一致的方法,需要传入一个对象 ReduceResultHolder,调用完成后,通过该对象获得聚合结果。

    默认情况下,框架会提供一个通用 Reduce 策略,如果是数字则累加返回,如果是Collection 及其子类则合并后返回,如果是 MAP 则也是合并后返回。

    如果该策略不适合,那么用户可自行设计指定 Reduce 策略。

    @Transaction 表示每一个分片执行的 SQL 都处于一个事务中,并不是表示整个聚合操作是一个整体的事务。所以,MapReduce 最好不要进行更新操作(考虑框架层次限制 MapReduce 只允许 ReadOnly 事务,目前仍没有做限制)。

    @MapReduce 执行的操作会在 @Transaction 之前。

    优缺点分析

    针对上述实现,我们可以分析一下如此实现的优缺点。

    优点

    • 框架实现简单,无 SQL 解析改写等复杂逻辑,BUG 理论上更少,也容易排查 BUG

      个人认为这至为重要,至少这个简单的框架在使用者的可控范围内。

    • 全数据库、全 SQL 兼容

      SQL 层分片无法做到。

    • 能完美实现读写分离

      Service 层分片在 Service 开始前就能确定该事务是读事务,整个读事务都在一个读库中完成,隔离级别与数据库一致,能实现完美 RR 级别读写分离。

    • 使用注解完成分片,无业务逻辑入侵

      如果注解也算的入侵的话,那么 Spring 就彻底浸入了我们的业务代码里了。

      使用注解能显式的提醒程序员及 REVIEWER,这是在访问单库还是跨库访问,而不像基于 SQL 的分片,隐式完成了跨库这一不安全的操作。

    • 隔离级别及事务原子性等特征与使用的数据库一致,无额外学习负担,易于写出正确的程序

      框架限制了所有事务都在单库进行。

    • 无额外维护 DBProxy 可用性的负担

    • 无 SQL 解析成本,性能更高

    缺点

    • 跨库查询需要自行进行结果聚合

      • 是劣势也是优势

      • 劣势:需要完成额外的聚合代码

      • 优势:显式提示程序员这是聚合操作,且其能能更好地调优, 使用 JDK8 的 Stream 及 Lambada 表达式,能像写 SQL 一样简单地完成相关集合处理。同时合理设计的代码里,聚合操作应该只存在于少量的非核心操作中,因此不会增加太多的工作量。聚合计算出结果这部分内容实际上是可以上升成 Service 层的逻辑的(若不考虑严格的领域设计模型那一套的话)。

    • 跨库事务需要自行保证

      • 是劣势也是优势

      • 劣势:需要额外自行实现跨库事务

      • 优势:目前所有的开源分片框架实现的跨库事务都有缺陷或者说限制。因此自行采用显式的事务控制,结合业务实现最终一致性或许是更好的选择。可参考使用本人写的另外一个框架 EasyTransaction。

    • 无法实现单库分表

    • 其实,单库分表并不是必须的,这可以用数据原生的表分区来实现,性能一样,使用更便捷

    • 如果你拒绝使用数据库原生的表分区,而使用改写表名的形式做库内分片时,你最好能清楚意义在哪里,而不是想当然。

    结语

    实际上,我对基于 SQL 进行分片的框架并非拒绝,我也衷心佩服对这些开源框架做出贡献的大神们,此文仅仅给大家一些新的分片思路。若本文能给大家一些小小的启发,那么希望大家能帮忙给我的两个项目加加星,感谢。

    服务层分片框架

    分布式柔性事务框架

    展开全文
  • Mongodb分 1. 分(sharding)是指将数据拆分,将其分散存放在不同的机器上的过程。有时也用分区(partitioning)来表示这个概念。将数据分散到不同的机器上,不需要功能强大的大型计算机就可以  存储更多的...

    Mongodb分片

    1. 分片(sharding)是指将数据拆分,将其分散存放在不同的机器上的过程。有时也用分区(partitioning)来表示这个概念。将数据分散到不同的机器上,不需要功能强大的大型计算机就可以

        存储更多的数据,处理更大的负载。

    2. MongoDB支持自动分片(autosharding),可以使数据库架构对应用程序不可见,也可以简化系统管理。对应用程序而言,好像始终在使用一个单机的MongoDB服务器一样。另一方面,

        mongoDB自动处理数据在分片上的分布,也更容易添加和删除分片技术。

    3. 复制与分片的区别:复制时让多台服务器都拥有同样的数据副本,每一台服务器都是其他服务器的镜像,而每一个分片都和其他分片拥有不同的数据子集。

    4. 路由服务器:为了对应用程序隐藏数据库架构的细节,在分片之前要先执行mongos进行一次路由过程。这个路由服务器维护这一个"内容列表",指明了每个分片包含什么数据内容。应用

        程序只需要连接路由服务器,就可以像使用单机一样进行正常的请求了。

    5. 运行sh.status()可以看到集群的状态:分片摘要信心、数据库摘要信息、集合摘要信息。

    6. 要对一个集合分片,首先你要对这个集合的数据库启用分片,执行如下命令:sh.enableSharding("test")

    7. 片键:片键是集合的一个键,MongoDB根据这个键拆分数据。例如:username 。在启用分片之前,先在希望作为片键的键上创建索引:db.users.ensureIndex({"username":1})

    8. 对集合分片:sh.shardCollection("test.users",{"username":1})

    9. 集合被拆分为多个数据块,每个数据块都是集合的一个数据子集。这是按照片键的范围排列的({"username":minValue}-->>{"username":maxValue}指出了每个数据块的范围)。

    10. 包含片键的查询能够直接被发送到目标分片或者是集群分片的一个子集。这样的查询叫做定向查询(targetd query)。有些查询必须被发送到所有分片,这样的查询叫做分散-聚合查询(

          scatter-gather query);mongos将查询分散到所有的分片上,然后经各个分片的查询结果聚集起来。

    11. cluster.stop() 关闭整个集群。

     

    BSON类型

     

    配置分片:

    1. 何时进行分片:决定何时分片是一个值得权衡的问题。通常不必太早分片,因为分片不仅会增加部署的操作复杂度,还要求做出设计决策,而改决策以后很难再改。另外最好也不要在系统

        运行太久之后再分片,因为在一个过载的系统上不停机进行分配是很困难的。

    2. 分片的目的:增加可用的RAM,增加可用磁盘空间,减轻单台服务器的负载,处理单个mongod无法承受的吞吐量。

    3. 一般情况下至少应该创建3个或者以上的分片。

    4. 启动服务器:

        1). 配置服务器:配置服务器相当于集群的大脑,保存着集群和分片的元数据,即各分片包含哪些数据的信息。因此,应该首先建立配置服务器,鉴于它所包含的的数据极端重要性,必须启用

             其日志功能,并确保其数据保存在非易失性驱动器上。每个配置服务器都应该位于单独的物理机上,最好是分布在不同地址位置的机器上。

             a. 启动配置服务器:mongod --configsvr --dbpath  /var/lib/mongodb -f  /var/lib/config/mognd.conf  。需要启动三台配置服务器,且都是可写的。

                 为什么是3台配置服务器?因为我们需要考虑不时之需。但是,也不需要过多的配置服务器,因为配置服务器上的确认操作比较耗时。另外,如果有服务器宕机了,集群源数据就会变成只读的。

                 --configsvr 选项指定mongod为新配置服务器。该选项并非必选项,因为它所做的不过是将mongod的默认监听端口改为27019,并大默认的数据目录改为/data/configdb而已(可以使用

                 --port 和 --dbpath 选项修改这两项配置)。但建议使用--configsvr选项,因为它比价直白地说明了这些配置服务器的用途。

                 配置服务器的1KB相当于200MB知识数据,它保存的真实数据的分布表。由于配置服务器并不需要太多的资源,因此可以将其部署在运行着其他程序的服务器上。 

        2). mongos进程:三个配置服务器均处于运行状态后,启动一个mongos进程供应用程序连接。mongos进程需要配置服务器的地址,所以必须使用--configdb选项启动mongos:

              mongos --configdb config-1:27019,config-2:27019,config-3:27019 -f /var/lib/mongos.conf

              默认情况下,mongos运行在27017端口。mongos本身不保存数据,它会在启动时从配置服务器加载集群数据。

              可以启动任意数量的mongos进程。通常的设置时每个应用程序服务器使用一个mongos进程(与应用服务器运行在同一台机器上)

              每个mongos进程必须按照列表排序,使用相同的配置服务器列表。

        3). 将副本集转换为分片:有两种可能性:已经有一个副本集,或者从零开始建立集群。下例假设我们已经拥有了一个副本集。如果是从零开始的话,可先初始化一个空的副本集,然后按照本例操作。

             a. 告知mongos副本集名称和副本集成员列表:sh.addShard("spock/server-1:27017,server-2:27017,server-4:27017")  mongos能够自动检测到没有包含在副本集成员表中的成员。

             b. 副本集作为分片添加到集群后,就可以将应用程序设置从连接到副本集改为连接到mongos。

             c. 副本集名称spokc被作为分片名称。如果之后希望移除这个分片或者是向这个分片迁移数据,可以使用spock来标志这个分片。

             d. 配置完分片后,必须将客户端设置为将所有请求发送到mongos,而不是副本集。同时配置防火墙规则,以确保客户端不能直接将请求发送到分片。

             e. 有一个--shardsvr选项,与前面介绍的--configsvr选项类似,它也没什么实用性(只是将默认端口改为27018),但在操作中建议使用该选项。

             f. 不建议创建单mongod服务器分片(而不是副本集分片),将单一服务器分片转换为副本集需要停机操作。

        4). 增加集群容量:通过增加分片来增加集群容量。

        5). 数据分片:除非明确指定规则,否则MongoDB不会自动对数据进行拆分。如果有必要,必须明确告知数据库和集合。加入对music数据库中的artists集合按照name进行分片,

              db.enableSharding("music")         对数据库分片是对集合分片的先决条件

              sh.shardCollection("music.artists",{"name":1})   对集合分片,集合会按照name键进行分片。如果是对已存在的集合分片,那么name键上必须有索引,否则会返回错误。

              shardCollection()命令会经集合拆分为多个数据块,这是MongoDB迁移数据的基本单元。命令执行后,MongoDB会均衡的将数据分散到集群的分片上。

    5. MongoDB如何追踪集群数据

        1). MongoDB将文档分组为块(chunk),每个块由给定片键特定范围内的文档组成。一个块只存在于一个分片上,所以MongoDB用一个比较小的表就能够维护跟分片的映射。

        2). 当一个块增长到特定大小时,MongoDB会自动将其拆分为两个较小的块。

        3). 一个常见的误解释同一个块内的数据保存在磁盘的同一片区域。这是不正确的,块并不影响mongod保存集合数据的方式。

        4). 块信息保存在config.chunks集合中。左闭右开。

        5). 可以使用复合片键,工作方式与使用复合索引进行排序一样。

        6). 拆分块:mongos会记录在每个块中插入了多少数据,一旦达到某个阈值,就会检查是否需要对块进行拆分。mongos就会在配置服务器更新这个块的源信息。块拆分中只需要改变块源数据即可,

             而无需进行数据移动。进行拆分时,配置服务器会创建新的块文档,同时修改旧的块范围,拆分完成以后,mongos会重置对原始块的追踪器,同时为新的块创建新的追踪器。

        7). 分片有时可能会找不到任何可用的拆分点,因为合法拆分块方法有限。具有相同片键的文档必须保存在相同的块中。

        8). 如果mongos试图进行拆分时有一个服务器挂了,那么mongos就无法更新源数据。mongos不断重复发起拆分请求却无法进行拆分的过程,叫做拆分风暴。防止拆分风暴的唯一方法是尽可能保证

             配置服务器的可用和健康。也可以重启mongos,重置引入计数器,这样他就不会再处于拆分阈值点了。

        9). 如果mongos进程不断重启,它们的计数器可能永远也不会到达阈值点,因此块的增加不存在最大值,也就无法到达阈值点。

        10). 防止无法拆分的两种方法:一是减少mongos进程的波动,二是使块的大小比实际预期小一些,这样就更容易达到拆分阈值点。

        11). 可以在mongos启动时指定--nosplit选项,从而关闭块的拆分。

    6. 均衡器:均衡器负责数据的迁移。它会周期性地检查分片间是否存在不均衡,如果存在,则会开始块的迁移。虽然均衡器通常被看成单一的实体,但每个mongos有时也会扮演均衡器的角色。

        每隔几秒,mongos就会尝试变身均衡器。如果没有其他可用的均衡器,mongos就会对整个集群加锁,以防止配置服务器对整个集群进行修改,然后做一次均衡。

        mongos成为均衡器后,就会检查每个集合的分块表,从而查看是否有分片达到了均衡阈值。

     

    选择片键

    1. 对集合进行分片时,要选择一或两个字段用于拆分数据,这个键就叫做片键。

    2. 拆分数据最常用的数据分发方式有三种:升序片键、随机分发的片键和基于位置的片键。

        1). 升序片键:升序片键通常有点类似于"date"字段或者是ObjectId,是一种随着时间稳定增长的字段。缺点:例如ObjectId可能会导致接下来的所有的写入操作都在同一块分片上。

        2). 随机分发的片键:随机分发的片键可以是用户名,邮件地址,UDID,MD5散列值或者数据集中其他一些没有规律的键。缺点:MongoDB在随机访问超出RAM大小的数据时效率不高。

        3). 基于位置的片键:基于位置的片键可以是用户的IP、经纬度、或者地址。这里的"位置"比较抽象,不必与实际的物理位置字段相关。

             如果希望特定范围内的块出现在特定的分片中,可以为分片添加tag,然后为块指定相应的tag

    3. 片键策略:

        1). 散列片键:如果追求的是数据加载速度的极致,那么散列片键是最佳选择。散列片键可使其他任何键随机分发,因此,如果打算在大量查询中使用使用升序键,但同时又希望写入数据随机分发的话,

             散列片键会是一个非常好的选择。缺点:无法使用散列片键做指定目标的范围查找。  

             创建步骤: db.users.ensureIndex({"username":"hashed"})   ,   sh.shardCollection("app.users",{"username":"hashed"})

        2). GridFS的散列片键

        3). 流水策略:如果有一些服务器比其他服务器更强大,我们可能希望让这些强大的服务器处理更多的负载。比如说:加入有一个使用SSD的分片能够处理10倍于其他机器的负载。我们可以强制将所有新数据

             插入到SSD,然后让均衡器将旧的块移动到其他分片上。

             a. 为SSD指定一个标签:sh.addShardTag("shard-name","ssd")

             b. 将升序键的当前值一直到正无穷范围的块都指定分布在SSD分片上:sh.addTagRange("dbName.collName",{"_id":ObjectId()},...{"_id":MaxKey},"ssd") 

                 所有插入请求均会路由到这个块上,这个块始终位于标签的ssd的分片上。

             c. 除非修改标签范围,否则从升序键的当前值一直到正无穷都被固定在这个分片上。可以创建一个定时任务每天更新一次标签范围:

                 use config

                 var tag =db.tags.findOne({"ns":"dbName.collName",..."max":{"shardKey":MaxKey}})

                 tag.min.shardKey = ObjectId()

                 db.tags.save(tag)

                 这样前一天的数据就会被移动到其他分片上了。

                 此策略的另一个缺点:需要修改才能进行扩展。如果写请求超出了SSD的处理能力,无法进行负载均衡。

            4). 多热点:写请求分布在集群中时,分片是最高效的。这种技术会创建多个热点(最好在每个分片上都创建几个热点),写请求于是会均衡地分布在集群内,而在单个分片上则是以升序分布的。

                            为了实现这种方式,需使用复合片键。复合片键中的第一个值只是比较粗略的随机值,势也比较低。

    4. 片键规则和指导方针:

        1). 片键限制:片键不可以是数组。文档一旦插入,其片键就无法修改了。要修改文档的片键值,就必须先删除文档。

        2). 片键的势:选择一个值会变化的的键非常重要,即值很多,随着数据量的增大可以分出更多的片键。分片在势比较高的字段上性能更佳。

    5. 控制数据分发

        1). 对多个数据库和集合使用一个集群:通过tag标记,将重要的数据放到性能更好的服务器上,将不重要的数据放在性能一般的服务器上。

        2). 手动分片:如果不希望数据被自动分发,可以关闭均衡器,使用moveChunk命令手动对数据进行迁移。

     

     

    分片管理

    1. 检查集群状态:

        1). 使用sh.status查看集群摘要信息: 块的数量比较多时,sh.status()命令会概述块的状态,而非打印出每个块的相关信息。如需查看所有的块,可使用sh.status(true)命令。

             sh.status()显示的所有信息都来自config数据库。运行sh.status()命令,使用MapReduce获取这一数据。因此,如果启动数据库时指定--noscripting选项,则无法运行sh.status()命令。

        2). 检查配置信息:

             a. 集群相关的所有配置信息都保存在配置服务器上config数据库的集合中。可以直接访问该数据库,不过shell提供了一些辅助函数。

             b. 永远不要直接连接到配置服务器,以防止配置服务器数据被不小心修改或删除。应该先连接到mongos,然后通过config数据库来查询相关信息:use config

                 如果通过mongos操作配置数据,mongos会保证将修改同步到所有配置服务器,也会防止危险的操作发生,如意外删除config数据库等。

             c. 总的来说,不应直接修改config数据库中的任何数据。如果确实修改了某些数据,通常需要重启所有的mongos服务器,才能看到效果。

             d. config中几个关键集合:

                 shards : 跟踪记录集群中所有分片的信息。

                 databases: 跟踪记录集群中所有数据库的信息,不管数据库有没有分片。

                 collections: 跟踪记录所有分片集合的信息(非分片集合信息除外)

                 chunks: 记录集合中所有块的信息。

                 changelog: 跟踪记录集群的操作,因为该集合会记录所有拆分和迁移的操作。

                 tags: 该集合的创建是在为系统配置分片标签时发生的。每个标签都与一个块范围相关联。

                 settings: 该集合含有当前的均衡器设置和块大小的文档信息。通过修改该集合的文档,可开启和关闭均衡器,也可以修改块的大小。注意,应总是连接到mongos修改该集合的值。

    2. 查看网络连接:

        1). 查看连接统计:可以使用connPoolStats命令,查看mongos和mongod之间的连接信息:db.adminCommand({"connPoolStats":1})

                                在一个分片上执行connPoolStats,输出信息中可以看到该分片与其他分片间的连接,包括连接到其他分片做数据迁移的连接。

        2). 限制连接数量: 可在mongos的命令行配置中使用maxConns选项,这样可以限制mongos能够创建的连接数量。可以使用下面公式计算分片能够处理的来自单一mongos连接数量:

                                  maxConns = 20000 - (mongos进程的数量 * 3 ) - (每个副本集的成员数量 * 3 ) - (其他/mongos进程的数量)

                                  MongoDB如果没有安全退出,那些已经打开的套接字很可能没有被关闭。

                                  在出现大量重新连接时,除了重启进程,没有其他特殊有效的方法。

    3. 服务器管理

        1). 添加服务器:使用addShard命令,向集群中添加新的分片

        2). 修改分片的服务器:要修改分片的成员,需直接连接到分片的主服务器上,然后对副本集进行重新配置。集群配置会自动检测更改,并将其更新到config.shards上。

        3). 通常来说,不应从集群中删除分片。执行removeShard命令排除数据和查看排出进度。

        4). 修改配置服务器:修改配置服务器非常困难,而且有风险,通常还需要停机。注意,修改配置服务器前,应做好备份。

                                    首先必须关闭所有mongos进程,然后使用新的--configdb参数重启所有mongos进程。

    4. 数据均衡:

        1). 均衡器:均衡器只使用块的数量,而非数据大小,作为衡量分片间是否均衡的指标。自动均衡总是根据数据集的当前状态来决定数据迁移,而不考虑数据集历史状态。我们可以手动均衡数据集块的数量。

        2). 修改块的大小:块的大小默认为64M,这个大小的块既易于迁移,又不至于导致过多的流失。使用shell连接到mongos,修改config.setting集合,从而完成块大小的修改。

              该设置的有效范围是整个集群:它会影响所有集合的数据库。因此,如需对一个集合使用较小的块,而对另一个集合使用较大的块,比较好的解决方式是取一个折中值(或者将这两个值放到不同的集合中)。

              如果MongoDB频繁进行数据迁移或文档增大,则可能需要增加块的大小。

        3). 迁移块:同一块内的所有数据都位于同一分片上。如该分片的块数量比其他分片多,则MongoDB会将其中的一部分块迁移到其他块数量较少的分片上。移动快的过程叫迁移,MongoDB就是这样在集群中

             实现数据均衡的。可在shell中使用moveChunk辅助函数,手动移动块。

             如果某个块的大小超出了系统指定的最大值,mongos则会拒绝移动这个块。移动之前必须先手动拆分这个块,可以使用splitAt命令对块进行拆分。特大块,无法被拆分。

        4). 特大块:某些片键,值比较少,例如:日期等。可能会形成超出设置的最大块大小的块,这种块成为特大块.

             出现特大块的表现之一是,某个分片的大小增长速度要比其他分片块的多。也可使用sh.status()来检查是否出现了特大块;特大块会存在一个jumbo属性。

             a. 分发特大块,一个复杂的过程

             b. 防止特大块的出现:修改片键,细化片键的粒度

        5). mongos有时无法从配置服务器正确更新配置。如果发现配置有误,mongos的配置过旧或无法找到应有的数据,可以使用flushRouterConfig命令手动刷新所有缓存:db.adminCommand({"flushRouterConfig":1})

             如flushRouterConfig命令没能解决问题,则应重启所有的mongos或者mongod进程,以便清除所有可能的缓存。

    展开全文
  • MongoDB-分片片

    千次阅读 2019-02-24 17:44:34
    MongoDB-分片片键 1.分  分是什么?分就是将数据存储在多个机器上。当数据集超过单台服务器的容量,服务器的内存,磁盘IO都会有问题,即超过单台服务器的性能瓶颈。此时有两种解决方案,垂直扩展和水平...

    MongoDB-分片片键

    1.分片

          分片是什么?分片就是将数据存储在多个机器上。当数据集超过单台服务器的容量,服务器的内存,磁盘IO都会有问题,即超过单台服务器的性能瓶颈。此时有两种解决方案,垂直扩展和水平扩展(分片)。

          垂直扩展就是增加CPU,增加容量,但高性能系统的CPU和容量不成比例,这样扩展成本大,并且有上限。

          水平扩展分片,将数据分发到多个服务器,每个服务器是一个单独的数据库,各个服务器加起来组成一个逻辑数据库,把写压力和操作分流到不同服务器,提高容量和吞吐量。

          MongoDB的文档是无模式的,不固定结构,因此只能进行水平分片。当块超过指定大小或者文档数超过最大文档数,MongoDB尝试分割这个块,若分割成功,把它标记为一个大块避免重复分割。拆分块的关键就是片键,下面介绍常见片键的种类。

    2.片键种类

          片键是文档的一个属性字段或者一个复合索引字段,一旦建立不能改变。片键是分片拆分数据的关键,片键的选择直接影响集群的性能。

          MongoDB首先根据片键划分块chunks当块超过指定大小(默认64M),然后把块分到其他的分片上,片键类型主要有以下几种:

          注意:片键也是查询时常用的一个索引。

    (1) 递增片键

          这类片键比较常见,比如使用时间戳,日期,自增的主键,ObjectId,_id等,此类片键的写入操作集中在一个分片服务器上,写入不具有分散性,这会导致单台服务器压力较大,但分割比较容易,这台服务器可能会成为性能瓶颈。

    递增片键的创建,对foo数据库的bar集合使用timestamp时间戳分片

    mongos> use foo
    mongos> db.bar.ensureIndex({"timestamp":1})
    mongos> sh.enableSharding("foo")
    { "ok" : 1 }
    mongos> sh.shardCollection("foo.bar",{"timestamp":1})
    { "collectionsharded" : "foo.bar", "ok" : 1 }

     (2) 哈希片键

          使用一个哈希索引字段作为片键,优点是使数据在各节点分布比较均匀,数据写入可随机分发到每个分片服务器上,把写入的压力分散到了各个服务器上。但是读也是随机的,可能会命中更多的分片,一般具有随机性的片键(如密码,哈希,MD5)查询隔离性能比较差。

    哈希片键的创建,对GridFS的chunks集合使用files_id哈希分片

    mongos> db.bar.ensureIndex({"files_id":"hashed"})
    mongos> sh.enableSharding("foo")
    { "ok" : 1 }
    mongos> sh.shardCollection("foo.fs.chunks",{"files_id":"hashed"})
    { "collectionsharded" : " foo.fs.chunks ", "ok" : 1 }

     (3) 组合片键

          数据库中没有比较合适的片键供选择,或者是打算使用的片键基数太小(即变化少如星期只有7天可变化),可以选另一个字段使用组合片键,甚至可以添加冗余字段来组合。一般是粗粒度+细粒度进行组合。

    组合片键的创建,对GridFS的chunks集合使用files_id和n组合分片

    mongos> sh.enableSharding("foo")
    { "ok" : 1 }
    mongos> sh.shardCollection("foo.fs.chunks",{"files_id":1, "n":1})
    { "collectionsharded" : " foo.fs.chunks ", "ok" : 1 }

    (4) 标签分片

          数据存储在指定的分片服务器上,可以为分片添加tag标签,然后指定相应的tag,比如让10.*.*.*(T)出现在shard0000上,11.*.*.*(Q)出现在shard0001或shard0002上,就可以使用tag让均衡器指定分发。

    标签分片的创建

    mongos > sh.addShardTag("shard0000", "T")
    mongos > sh.addShardTag("shard0001", "Q")
    mongos > sh.addShardTag("shard0002", "Q")
    mongos> sh.addTagRange("foo.ips",{ "ip": "010.000.000.000 ", … , "ip": "011.000.000.000 "}}, "T")
    mongos> sh.addTagRange("foo.ips",{ "ip": "011.000.000.000 ", … , "ip": "012.000.000.000 "}}, "Q")

     3.片键选择策略

          大致了解了片键的种类,那么怎么选择片键呢?无非从两个方面考虑,数据的查询和写入,最好的效果就是数据查询时能命中更少的分片,数据写入时能够随机的写入每个分片,关键在于如何权衡性能和负载

    如何选择片键主要从下面几个问题考虑:

    (1)首先确定一个经常性查询的字段

    (2)找到影响这些操作性能的关键点

    (3)如果选的字段基数比较小,添加一个粒度细的字段

          怎么选择,如何权衡,跟具体的业务以及数据类型都有关系,具体问题具体分析。

    要更多干货、技术猛料的孩子,快点拿起手机扫码关注我,我在这里等你哦~

                                                           

    展开全文
  • 一生必看的纪录

    万次阅读 多人点赞 2019-10-08 22:18:18
    概要:人生七年》又称作《56up》也是非常多的网友在看过之后,都让自己陷入了一些思考,对人生思考有一定影响力的纪录之一导演从1964年开始第一部,在英国找来了不同阶级的十几个七岁的孩子,有男生和女生。...
  • 最近在做web网盘的系统,网盘最基本的功能便是文件上传,但是文件上传当遇到大文件的时候,在web端按传统方式上传简直是灾难,所以大文件上传可以采用分上传的办法。其主要思路是:1.大文件上传时进行分;2.分...
  • 区块链分:四种跨分交易方案

    万次阅读 2019-03-19 16:13:49
    《合约分执行中的状态问题》一文提到了,跨分合约的难点在于:一个分对于共同访问的状态的修改,需要及时地让另一个分知道,否则就容易出现状态错乱。任何支持合约的分技术,都必须要解决这个问题。目前...
  • IP分

    万次阅读 2020-09-14 23:01:16
    为了使超过此上限的ip数据报能够正常传输,IP引入了“分”和“重组”。 当IP层接收到要发送的IP数据报时,通过查找“转发表”,会判断该数据报应该从那个本地“接口”发送以及MTU是多少。 不同的网络类型,其...
  • 时间

    千次阅读 2018-10-24 19:28:12
    时间是CPU分配给各个线程的时间,因为时间非常短,所以CPU通过不停的切换线程执行,让我们感觉多个线程是同时执行的,时间一般是十几毫秒(ms)。...
  • 首先我们要移除的分之后再次添加此分时会出现添加失败的情况,需要在添加的分上登录进行删除此分之前数据库的历史数据比如testdb,删除分上的数据库之后就可重新添加此分到mongos中 1、...
  • 用Beamer制作幻灯(卷一 基本架构篇)

    万次阅读 多人点赞 2014-02-04 13:03:06
    Latex是很好的排版工具,我们使用Beamer来制作幻灯。 Latex和Office各有千秋,喜欢哪一个可以自行选择。上次看到一句话,你用一个盗版的office来和Latex作比较是极其不道德的。感觉这话说的很对。 废话不多说,...
  • 当我们在使用shard key切分时,默认是Mongos自动分,自动设定切分规则。但是我们也可以手动指定分规则。在后面的一篇博客《MongoDB4.0 Sharded Cluster+Replica Set集群搭建》详细介绍了MongoDB集群的搭建方法,...
  • 来源 | Hackernoon译者| 火火酱责编 | Carol出品|区块链大本营(blockchain_camp) 以太坊是所有区块链中一直与分概念同步的底层平...
  • ....分目前被关注的热度很高,主打分技术的公链被投资机构热捧, 分也和Layer 2的侧链、子链、状态通道等方向一起被列入以太坊官方的扩容方案。 1.2分的原理 分其实是一种传统数据...
  • MyCat分规则之自定义范围分

    千次阅读 2019-09-04 21:06:48
    实现方式:范围分,就是我们自己根据某个字段的数值范围来确定这些数据到底存放在哪一个分上,不过需要我们提前规划好分字段某个范围属于哪个分。切分规则根据文件(autopartition-long.txt)配置的范围来进行...
  • 半导体制冷

    千次阅读 2020-02-01 17:06:09
    电热半导体制冷(组件)利用帕尔贴(Peltier)效应进行制冷。Peltier效应是指电流通过电热偶时,一个节点发热,另外一个节点吸热的现象。这是由法国物理学家Jean Peltier在1834年发现的。 到了1960年左右,出现了...
  • 千次阅读 2017-03-24 13:25:58
    选:动词,可以理解成选。举个例子,有很多芯片挂在同一总线上(像电脑里很多外设都是挂在总线上),但我们有时候需要对其中特定的某个芯片进行数据、地址或命令的独立传输,此时,我们需要有一个信号来告诉挂在...
  • js图片轮播:VCD包装盒个性幻灯实例源码

    万次下载 热门讨论 2014-06-15 19:04:08
    代码为博客实例代码:http://blog.csdn.net/lmj623565791/article/details/31015121 有问题博客中留言
  • 1 MyCat分规则 数据切分中重要的几条原则,其中有几条数据冗余,表分组(Table Group)。 1.1全局表 如果你的业务中有些数据类似于数据字典,比如配置文件的配置,常用业务的配置或数据量不是很大,很少变动...
  • 干货 | 区块链分的理念与挑战,Part-1 在连载中的第一部分,我们讨论了为什么要做区块链分及其他的重要概念。在本文中,我们从更前沿的角度来看分,包含分尚未解决的两大挑战:数据有效性和数据可用性。 ...
  • 千次阅读 2017-11-26 21:19:36
    MyCat分-海量数据存储解决方案1 什么是分简单来说,就是指通过某种特定的条件,将我们存放在同一个数据库中的数据分散存放到多个数据库(主机)上面,以达到分散单台设备负载的效果。 数据的切分(Sharding)...
  • 一、分与副本设置 1、分(shard) Elasticsearch集群允许系统存储的数据量超过单机容量,实现这一目标引入分策略shard。在一个索引index中,数据(document)被分处理(sharding)到多个分上。Elastic...
  • mongodb分

    千次阅读 2020-02-03 14:00:08
    什么是mongodb分,有什么作用? mongodb分就是将大型集合分割到不同的服务器上,它可以自动且均衡的分配数据。它一般是针对特别大的需求,比如一个集合需要非常的大,几百个G。分到10个服务器之后,每个...
  • 内外设(上外设)定义

    千次阅读 2019-12-02 15:45:18
    内、外设是两个概念,内指做成芯片的集成电路内部,简称内;外设是外部设备的简称,是指集成电路芯片外部的设备。集成电路芯片与外部设备的连接一般需要专门的接口电路和总线的连接(包括控制总线路、地址总线...
  • 报文

    千次阅读 2016-05-31 20:12:11
    模块按照SIP+DIP+ID号+PROTO转发。前中后三必须ID号一致,协议一致。1.分配置如下:偏移位:0;字节为838;2.中片配置如下:偏移位:100;*8为800;字节为838;3.尾配置如下:偏移位:200;*8为1600;...
  • 内(上)外设与外外设

    千次阅读 2014-09-18 12:35:57
    内、外设是两个概念,内指做成芯片的集成电路内部,简称内;外设是外部设备的简称,是指集成电路芯片外部的设备。集成电路芯片与外部设备的连接一般需要专门的接口电路和总线的连接(包括控制总线路、地址总线...
  • MySQL的分(二)——MySQL分

    万次阅读 2018-10-18 14:25:34
    第一,了解MySQL分可以更合理地定制分策略,选分字段是要讲科学的。 第二,了解MySQL分以后如果出现故障报错,也有助于问题的排查。 第三,关系到开发过程中的代码调整,做分后的MySQL数据库操作受到...
  • clickhouse 分

    千次阅读 2019-12-19 21:22:00
    我们知道mysql数据库如果想做分,需要使用第三方组件,这是因为mysql在设计之初就没有太多考虑分布式等问题。而clickhouse作为新生代性能之王,分也是必须的功能。基本上从2015年之后的各种数据库也罢,框架也罢...
  • TCP的分和IP分的区别

    千次阅读 2019-04-01 20:46:07
    IP分与重组 在IP首部中,标识、标志、偏移这三部分就是与分的字段。 标识(Identification): 占16位。IP软件在存储器中维持一个计数器,每产生一个数据报,计数器就加1,并将此值赋给标识字段。但这个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 299,834
精华内容 119,933
关键字:

强㢨片