Redis 分区实现原理

摘要

Redis Partitioning即Redis分区,简单的说就是将数据分布到不同的redis实例中,因此对于每个redis实例所存储的内容仅仅是所有内容的一个子集。分区(Partitioning)不仅仅是Redis中的概念,几乎是所有数据存储系统都会涉及到的概念,这篇文章将会在理解分区基本概念的基础之上进一步了解Redis对分区的支持。

我们为什么要分区

我们为什么要分区?分区的动机是什么?通常来说,Redis分区的好处大致有如下两个方面:

  1. 性能的提升,单机Redis的网络I/O能力和计算资源是有限的,将请求分散到多台机器,充分利用多台机器的计算能力可网络带宽,有助于提高Redis总体的服务能力。
  2. 存储的横向扩展,即使Redis的服务能力能够满足应用需求,但是随着存储数据的增加,单台机器受限于机器本身的存储容量,将数据分散到多台机器上存储使得Redis服务可以横向扩展。

总的来说,分区使得我们本来受限于单台计算机硬件资源的问题不再是问题,存储不够?计算资源不够?带宽不够?我们都可以通过增加机器来解决这些问题。

Redis分区基础

实际应用中有很多分区的具体策略,举个例子,假设我们已经有了一组四个Redis实例分别为R0、R1、R2、R3,另外我们有一批代表用户的键,如:user:1,user:2,……等等,其中“user:”后面的数字代表的是用户的ID,我们要做的事情是把这些键分散存储在这四个不同的Redis实例上。怎么做呢?最简单的一种方式是范围分区(range partitioning),下面我们来看看基于范围分区怎么做。

范围分区

所谓范围分区,就是将一个范围内的key都映射到同一个Redis实例中,加入数据集还是上面提到的用户数据,具体做法如下:

我们可以将用户ID从0到10000的用户数据映射到R0实例,而将用户ID从10001到20000的对象映射到R1实例,依次类推。

这种方法虽然简单,但是在实际应用中是很有效的,不过还是有问题:

  • 我们需要一张表,这张表用来存储用户ID范围到Redis实例的映射关系,比如用户ID0-10000的是映射到R0实例……。
  • 我们不仅需要对这张表进行维护,而且对于每种对象类型我们都需要一个这样的表,比如我们当前存储的是用户信息,如果存储的是订单信息,我们就需要再建一张映射关系表。
  • 如果我们想要存储的数据的key并不能按照范围划分怎么办,比如我们的key是一组uuid,这个时候就不好用范围分区了。

因此,在实际应用中,范围分区并不是很好的选择,不用担心,我们还有更好的方法,接下来认识下哈希分区。

哈希分区

哈希分区跟范围分区相比一个明显的优点是哈希分区适合任何形式的key,而不像范围分区一样需要key的形式为object_name:<id>,而且分区方法也很简单,一个公式就可以表达:

id=hash(key)%N

其中id代表Redis实例的编号,公式描述的是首先根据key和一个hash函数(如crc32函数)计算出一个数值型的值。接着上面的例子,我们的第一个要处理的key是user:1,hash(user:1)的结果是93024922。

然后哈希结果进行取模,取模的目的是计算出一个介于0到3之间的值,因此这个值才可以被映射到我们的一台Redis实例上面。比如93024922%4结果是2,我们就会知道foobar将要被存储在R2上面。

当然除了上面提到的两种分区方法,还有很多其他的方法。比如一种从哈希分区演进而来的consistent hashing分区,相信信息可以参考我的另一篇文章《memcached分布式实现原理》,其已经被redis client和proxies实现了。

不同的分区实现

分区可以在redis软件栈的不同部分被实现,我们来看看下面几种:

客户端实现

客户端实现即key在redis客户端就决定了要被存储在那台Redis实例中,见下图:

客户端实现分区示意图

上面为客户端实现Redis分区的示意图。

代理实现

代理实现即客户端将请求发往代理服务器,代理服务器实现了Redis协议,因此代理服务器可以代理客户端和Redis服务器通信。代理服务器通过配置的分区schema来将客户端的请求转发到正确的Redis实例中,同时将反馈消息返回给客户端。代理实现Redis分区示意图如下:

代理实现Redis分区示意图

Redis和Memcached代理Twemoroxy都实现了代理分区。

查询路由

查询路由是Redis Cluster实现的一种Redis分区方式:

查询路由Redis分区示意图

查询路由的过程中,我们可以将查询请求随机的发送到任意一个Redis实例,这个Redis实例负责将请求转发至正确的Redis实例中。Redis集群实现了一个通过和客户端协作的hybrid来做查询路由。

Redis分区的缺点

尽管Redis分区到现在为止,so far so good,但是Redis分区有一些致命的缺点,这导致一些Redis功能在分区的环境下并不能很好地工作,我们来看看:

  • 多键操作是不被支持的,比如我们将要批量操作的键被映射到了不同的Redis实例中。
  • 多键的Redis事务是不被支持的。
  • 分区的最小粒度是键,因此我们不能将关联到一个键的很大的数据集映射到不同的实例。
  • 当应用分区的时候,数据的处理是非常复杂的,比如我们需要处理多个rdb/aof文件,将分布在不同实例的文件聚集到一起备份。
  • 添加和删除机器是很复杂的,例如Redis集群支持几乎运行时透明的因为增加或减少机器而需要做的rebalancing,然而像客户端和代理分区这种方式是不支持这种功能的。

既然有问题,那么就需要解决方案,这个时候Pre-sharding来了,后面我们会介绍Pre-Sharding。

持久存储用还是缓存

尽管数据分区对于Redis来说无论是数据持久化存储还是缓存,在概念上都是一样的,然而对于数据持久化存储还是有一个很大的限制。当我们使用Redis来作为持久化存储的时候,每一个key必须一直被映射到同一个Redis实例。而当Redis被当做缓存使用的时候,对于这个key,如果一个实例不能用了,这个key还可以被映射到其他的实例中。

Consistent hashing实现通常使得当一个key被映射到的实例不能用的时候将这个key映射到其他实例成为可能。类似,如果增加了一台机器,一部分的key将会被映射到这台新的机器上,我们需要了解的两点如下:

  1. 如果Redis被用来当做缓存,且要求容易增加或删除机器,使用consistent hashing是非常简单的。
  2. 如果Redis被用来当做(持久)存储,一个固定的key到实例的映射是需要的,因此我们不能够再灵活的添加或删除机器。否则,我们需要在增加或删除机器的时候系统能够rebalace,当前Redis Cluster已经支持。

Pre-Sharding

通过上面的介绍,我们知道Redis分区应用起来是有问题的,除非我们只是使用Redis当做缓存,否则对于增加机器或删除机器是非常麻烦的。

然而,通常我们Redis容量变动在实际应用中是非常常见的,比如今天我需要10台Redis机器,明天可能就需要50台机器了。

鉴于Redis是很轻量级的服务(每个实例仅仅占用1M),对于上面的问题一种简单的解决办法是:

我们可以开启多个Redis实例,尽管是一台物理机器,我们在刚开始的时候也可以开启多个实例。我们可以从中选择一些实例,比如32或64个实例来作为我们的工作集群。当一台物理机器存储不够的时候,我们可以将一般的实例移动到我们的第二台物理机上,依次类对,我们可以保证集群中Redis的实例数不变,又可以达到扩充机器的目的。

怎么移动Redis实例呢?当需要将Redis实例移动到独立的机器上的时候,我们可以通过下面步骤实现:

  1. 在新的物理机上启动一个新的Redis实例。
  2. 将新的物理机作为要移动的那台的slave机器。
  3. 停止客户端。
  4. 更新将要被移动的那台Redis实例的IP地址。
  5. 对于slave机器发送SLAVEOF ON ONE命令。
  6. 使用新的IP启动Redis客户端。
  7. 关闭不再使用的那个Redis实例。

总结

这篇文章在理解Redis分区概念的基础之上又介绍了Redis分区常见的几种实现方式及原理,最后根据实现中遇到的问题引入了Pre-Sharding解决方案。

缓存穿透、并发和失效,来自一线架构师的解决方案

本文作者是易宝支付的架构师程超,他介绍了我们在使用缓存过程中经常会出现的几个问题以及解决方案,包括缓存穿透、缓存并发和缓存失效,内容比较基础,但也很实在,推荐阅读。另外,如果你有其它更好的解决方案,欢迎留言讨论。

我们在用缓存的时候,不管是Redis或者Memcached,基本上会通用遇到以下三个问题:

  • 缓存穿透
  • 缓存并发
  • 缓存失效
缓存穿透

注:上面三个图会有什么问题呢?

我们在项目中使用缓存通常都是先检查缓存中是否存在,如果存在直接返回缓存内容,如果不存在就直接查询数据库然后再缓存查询结果返回。这个时候如果我们查询的某一个数据在缓存中一直不存在,就会造成每一次请求都查询DB,这样缓存就失去了意义,在流量大时,可能DB就挂掉了。

那这种问题有什么好办法解决呢?

要是有人利用不存在的key频繁攻击我们的应用,这就是漏洞。有一个比较巧妙的作法是,可以将这个不存在的key预先设定一个值。比如,”key” , “&&”。

在返回这个&&值的时候,我们的应用就可以认为这是不存在的key,那我们的应用就可以决定是否继续等待继续访问,还是放弃掉这次操作。如果继续等待访问,过一个时间轮询点后,再次请求这个key,如果取到的值不再是&&,则可以认为这时候key有值了,从而避免了透传到数据库,从而把大量的类似请求挡在了缓存之中。

缓存并发

有时候如果网站并发访问高,一个缓存如果失效,可能出现多个进程同时查询DB,同时设置缓存的情况,如果并发确实很大,这也可能造成DB压力过大,还有缓存频繁更新的问题。

我现在的想法是对缓存查询加锁,如果KEY不存在,就加锁,然后查DB入缓存,然后解锁;其他进程如果发现有锁就等待,然后等解锁后返回数据或者进入DB查询。

这种情况和刚才说的预先设定值问题有些类似,只不过利用锁的方式,会造成部分请求等待。

缓存失效

引起这个问题的主要原因还是高并发的时候,平时我们设定一个缓存的过期时间时,可能有一些会设置1分钟啊,5分钟这些,并发很高时可能会出在某一个时间同时生成了很多的缓存,并且过期时间都一样,这个时候就可能引发一当过期时间到后,这些缓存同时失效,请求全部转发到DB,DB可能会压力过重。

那如何解决这些问题呢?

其中的一个简单方案就时讲缓存失效时间分散开,比如我们可以在原有的失效时间基础上增加一个随机值,比如1-5分钟随机,这样每一个缓存的过期时间的重复率就会降低,就很难引发集体失效的事件。

我们讨论的第二个问题时针对同一个缓存,第三个问题时针对很多缓存。

总结

1、缓存穿透:查询一个必然不存在的数据。比如文章表,查询一个不存在的id,每次都会访问DB,如果有人恶意破坏,很可能直接对DB造成影响。

2、缓存失效:如果缓存集中在一段时间内失效,DB的压力凸显。这个没有完美解决办法,但可以分析用户行为,尽量让失效时间点均匀分布。

当发生大量的缓存穿透,例如对某个失效的缓存的大并发访问就造成了缓存雪崩。

精彩问答

问题:如何解决DB和缓存一致性问题?

当修改了数据库后,有没有及时修改缓存。这种问题,以前有过实践,修改数据库成功,而修改缓存失败的情况,最主要就是缓存服务器挂了。而因为网络问题引起的没有及时更新,可以通过重试机制来解决。而缓存服务器挂了,请求首先自然也就无法到达,从而直接访问到数据库。那么我们在修改数据库后,无法修改缓存,这时候可以将这条数据放到数据库中,同时启动一个异步任务定时去检测缓存服务器是否连接成功,一旦连接成功则从数据库中按顺序取出修改数据,依次进行缓存最新值的修改。

问题:问下缓存穿透那块!例如,一个用户查询文章,通过ID查询,按照之前说的,是将缓存的KEY预先设置一个值,,如果通过ID插过来,发现是预先设定的一个值,比如说是“&&”,那之后的继续等待访问是什么意思,这个ID什么时候会真正被附上用户所需要的值呢?

我刚说的主要是咱们常用的后面配置,前台获取的场景。前台无法获取相应的key,则等待,或者放弃。当在后台配置界面上配置了相关key和value之后,那么以前的key &&也自然会被替换掉。你说的那种情况,自然也应该会有一个进程会在某一个时刻,在缓存中设置这个ID,再有新的请求到达的时候,就会获取到最新的ID和value。

问题:其实用Redis的话,那天看到一个不错的例子,双key,有一个当时生成的一个附属key来标识数据修改到期时间,然后快到的时候去重新加载数据,如果觉得key多可以把结束时间放到主key中,附属key起到锁的功能。

这种方案,之前我们实践过。这种方案会产生双份数据,而且需要同时控制附属key与key之间的关系,操作上有一定复杂度。

问题:多级缓存是什么概念呢?

多级缓存就像我今天之前给大家发的文章里面提到了,将Ehcache与Redis做二级缓存,就像我之前写的文章 http://www.jianshu.com/p/2cd6ad416a5a 提到过的。但同样会存在一致性问题,如果我们需要强一致性的话,缓存与数据库同步是会存在时间差的,所以我们在具体开发的过程中,一定要根据场景来具体分析,二级缓存更多的解决是,缓存穿透与程序的健壮性,当集中式缓存出现问题的时候,我们的应用能够继续运行。

配置mongodb 复制集3.2

我们这里讲解的是如何配置mongodb复制集,首先在每一个机器上面安装mongodb,我们是通过yum的方式安装mongodb3.2

1.在文章中添加yum安装的配置文件:

touch /etc/yum.repos.d/mongodb-org-3.2.repo
vim /etc/yum.repos.d/mongodb-org-3.2.repo

打开文件后里面添加内容:

[mongodb-org-3.2]  
name=MongoDB Repository  
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/3.2/x86_64/  
gpgcheck=1  
enabled=1  
gpgkey=https://www.mongodb.org/static/pgp/server-3.2.asc

2.yum安装

sudo yum install -y mongodb-org

其他节点也进行进行上面的步骤,将其他的节点按照上面,进行安装mongodb,安装完成后,都关闭mongodb:

sudo service mongod stop

3. 在每一个mongodb的节点,修改hosts

节点:192.168.220.105  mongo0.example.com

节点:192.168.220.106 mongo1.example.com

vim /etc/hosts

192.168.220.105:在上面打开的文件中添加或修改:

127.0.0.1   localhost mongo0.example.com  
192.168.220.105 mongo0.example.com  
192.168.220.106 mongo1.example.com

192.168.220.106:在上面文件中添加或者修改:

127.0.0.1   localhost mongo1.example.com  
192.168.220.105 mongo0.example.com  
192.168.220.106 mongo1.example.com

 

4. 在每一个mongodb的节点,修改hostname

节点:192.168.220.105  mongo0.example.com

节点:192.168.220.106 mongo1.example.com

192.168.220.105:

sudo hostname mongo0.example.com  
vim   /etc/hostname
#在打开的文件中添加: 
mongo0.example.com

192.168.220.106:

sudo hostname mongo1.example.com  
vim   /etc/hostname 
mongo1.example.com

5.修改mongodb的配置  vim /etc/mongod.conf

进行的修改为: 把bingIp注释掉,因为这一行只让本地访问:

net:  
  port: 27017  
#  bindIp: 127.0.0.1  # Listen to local interface only, comment to listen on all interfaces.

添加复制集配置:

replication:  
   replSetName: rs0

编辑完的内容为:

# mongod.conf

# for documentation of all options, see:
#   http://docs.mongodb.org/manual/reference/configuration-options/

# where to write logging data.
systemLog:
  destination: file
  logAppend: true
  path: /var/log/mongodb/mongod.log

# Where and how to store data.
storage:
  dbPath: /var/lib/mongo
  journal:
    enabled: true
#  engine:
#  mmapv1:
#  wiredTiger:

# how the process runs
processManagement:
  fork: true  # fork and run in background
  pidFilePath: /var/run/mongodb/mongod.pid  # location of pidfile

# network interfaces
net:
  port: 27017
#  bindIp: 127.0.0.1  # Listen to local interface only, comment to listen on all interfaces.

#security:

#operationProfiling:

replication:
   replSetName: rs0
#sharding:

## Enterprise-Only Options

#auditLog:

#snmp:

保存文件后,重启linxu。

添加开机启动

chkconfig mongod on

启动mongodb:

/etc/init.d/mongod restart

 

8.现在有两台linux,现在开始配置,注意,只能进入一台mongodb,其他的mongdb不要配置,启动就好。

在mongo0中:(这个作为主节点)

mongo

执行log如下:

[root@mongo0 ~]# mongo  
MongoDB shell version: 3.2.7  
connecting to: test  
Server has startup warnings:   
2016-06-20T14:10:48.876+0800 I CONTROL  [initandlisten]   
2016-06-20T14:10:48.876+0800 I CONTROL  [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/enabled is 'always'.  
2016-06-20T14:10:48.876+0800 I CONTROL  [initandlisten] **        We suggest setting it to 'never'  
2016-06-20T14:10:48.876+0800 I CONTROL  [initandlisten]   
2016-06-20T14:10:48.876+0800 I CONTROL  [initandlisten] ** WARNING: /sys/kernel/mm/transparent_hugepage/defrag is 'always'.  
2016-06-20T14:10:48.876+0800 I CONTROL  [initandlisten] **        We suggest setting it to 'never'  
2016-06-20T14:10:48.876+0800 I CONTROL  [initandlisten]   
2016-06-20T14:10:48.876+0800 I CONTROL  [initandlisten] ** WARNING: soft rlimits too low. rlimits set to 1024 processes, 64000 files. Number of processes should be at least 32000 : 0.5 times number of files.  
2016-06-20T14:10:48.876+0800 I CONTROL  [initandlisten]

然后初始化:(注意,从节点不要执行rs.initiate()  , 只有主节点执行这个)

rs.initiate()

log如下:

rs.initiate()  
{  
    "info2" : "no configuration specified. Using a default configuration for the set",  
    "me" : "mongo0.example.com:27017",  
    "ok" : 1  
}  
rs0:OTHER>

增加节点:(在主节点中执行,添加从节点,主要从节点的iptables要添加信任,如果是本地,则可以直接关掉iptables,最好是添加ip信任,添加ip信任的方式

/sbin/iptables -I INPUT -p tcp --dport 27017 -j ACCEPT
/etc/rc.d/init.d/iptables save

rs0:OTHER> rs.add("mongo1.example.com:27017");  
{ "ok" : 1 }

rs.config() 查看配置,log如下:

rs0:PRIMARY> rs.config();  
{  
    "_id" : "rs0",  
    "version" : 2,  
    "protocolVersion" : NumberLong(1),  
    "members" : [  
        {  
            "_id" : 0,  
            "host" : "mongo0.example.com:27017",  
            "arbiterOnly" : false,  
            "buildIndexes" : true,  
            "hidden" : false,  
            "priority" : 1,  
            "tags" : {  
                  
            },  
            "slaveDelay" : NumberLong(0),  
            "votes" : 1  
        },  
        {  
            "_id" : 1,  
            "host" : "mongo1.example.com:27017",  
            "arbiterOnly" : false,  
            "buildIndexes" : true,  
            "hidden" : false,  
            "priority" : 1,  
            "tags" : {  
                  
            },  
            "slaveDelay" : NumberLong(0),  
            "votes" : 1  
        }  
    ],  
    "settings" : {  
        "chainingAllowed" : true,  
        "heartbeatIntervalMillis" : 2000,  
        "heartbeatTimeoutSecs" : 10,  
        "electionTimeoutMillis" : 10000,  
        "getLastErrorModes" : {  
              
        },  
        "getLastErrorDefaults" : {  
            "w" : 1,  
            "wtimeout" : 0  
        },  
        "replicaSetId" : ObjectId("5767896cd1595b8f30b7cd4a")  
    }  
}

查看状态:

rs0:PRIMARY> rs.status()

如果后续添加节点,那么,安装完mongodb,设置完成mongodb后,启动mongodb后,设置完成hosts后,直接在主节点中执行添加:

执行log如下:

rs0:PRIMARY> rs.add("mongo2.example.com:27017");
{ "ok" : 1 }
rs0:PRIMARY> rs.status
function () {
    return db._adminCommand("replSetGetStatus");
}
rs0:PRIMARY> rs.status();
{
  "set" : "rs0",
  "date" : ISODate("2016-10-08T02:45:54.068Z"),
  "myState" : 1,
  "term" : NumberLong(19),
  "heartbeatIntervalMillis" : NumberLong(2000),
  "members" : [
    {
      "_id" : 0,
      "name" : "mongo0.example.com:27017",
      "health" : 1,
      "state" : 1,
      "stateStr" : "PRIMARY",
      "uptime" : 1126,
      "optime" : {
        "ts" : Timestamp(1475894744, 1),
        "t" : NumberLong(19)
      },
      "optimeDate" : ISODate("2016-10-08T02:45:44Z"),
      "electionTime" : Timestamp(1475894303, 1),
      "electionDate" : ISODate("2016-10-08T02:38:23Z"),
      "configVersion" : 3,
      "self" : true
    },
    {
      "_id" : 1,
      "name" : "mongo1.example.com:27017",
      "health" : 1,
      "state" : 2,
      "stateStr" : "SECONDARY",
      "uptime" : 617,
      "optime" : {
        "ts" : Timestamp(1475894744, 1),
        "t" : NumberLong(19)
      },
      "optimeDate" : ISODate("2016-10-08T02:45:44Z"),
      "lastHeartbeat" : ISODate("2016-10-08T02:45:52.842Z"),
      "lastHeartbeatRecv" : ISODate("2016-10-08T02:45:52.847Z"),
      "pingMs" : NumberLong(0),
      "syncingTo" : "mongo0.example.com:27017",
      "configVersion" : 3
    },
    {
      "_id" : 2,
      "name" : "mongo2.example.com:27017",
      "health" : 0,
      "state" : 8,
      "stateStr" : "(not reachable/healthy)",
      "uptime" : 0,
      "optime" : {
        "ts" : Timestamp(0, 0),
        "t" : NumberLong(-1)
      },
      "optimeDate" : ISODate("1970-01-01T00:00:00Z"),
      "lastHeartbeat" : ISODate("2016-10-08T02:45:52.842Z"),
      "lastHeartbeatRecv" : ISODate("1970-01-01T00:00:00Z"),
      "pingMs" : NumberLong(0),
      "lastHeartbeatMessage" : "No route to host",
      "configVersion" : -1
    }
  ],
  "ok" : 1
}
rs0:PRIMARY> 

 

 

日志:

rs0:PRIMARY> rs.status()  
{  
    "set" : "rs0",  
    "date" : ISODate("2016-06-20T06:14:17.377Z"),  
    "myState" : 1,  
    "term" : NumberLong(1),  
    "heartbeatIntervalMillis" : NumberLong(2000),  
    "members" : [  
        {  
            "_id" : 0,  
            "name" : "mongo0.example.com:27017",  
            "health" : 1,  
            "state" : 1,  
            "stateStr" : "PRIMARY",  
            "uptime" : 92,  
            "optime" : {  
                "ts" : Timestamp(1466403201, 1),  
                "t" : NumberLong(1)  
            },  
            "optimeDate" : ISODate("2016-06-20T06:13:21Z"),  
            "infoMessage" : "could not find member to sync from",  
            "electionTime" : Timestamp(1466403181, 1),  
            "electionDate" : ISODate("2016-06-20T06:13:01Z"),  
            "configVersion" : 2,  
            "self" : true  
        },  
        {  
            "_id" : 1,  
            "name" : "mongo1.example.com:27017",  
            "health" : 1,  
            "state" : 2,  
            "stateStr" : "SECONDARY",  
            "uptime" : 55,  
            "optime" : {  
                "ts" : Timestamp(1466403201, 1),  
                "t" : NumberLong(1)  
            },  
            "optimeDate" : ISODate("2016-06-20T06:13:21Z"),  
            "lastHeartbeat" : ISODate("2016-06-20T06:14:15.784Z"),  
            "lastHeartbeatRecv" : ISODate("2016-06-20T06:14:14.010Z"),  
            "pingMs" : NumberLong(0),  
            "configVersion" : 2  
        }  
    ],  
    "ok" : 1  
}

如果连接的机器是另外一个机器,也就说不是mongodb复制集中的机器,需要添加host(此处需要说明的是php,如果是和mongodb分开的那么需要在php机器的hosts中添加hosts)

vim  /etc/hosts

192.168.220.105 mongo0.example.com
192.168.220.106 mongo1.example.com

 

在shell 下面链接:(test是数据库的名字,rs0是复制集的名字)

mongo --host rs0/mongo0.example.com:27017,mongo1.example.com:27017 test

在php中连接:

'dsn' => 'mongodb://192.168.220.105:27017/erp,192.168.220.106:27017/erp?replicaSet=rs0&readPreference=primaryPreferred',

备份:

mongodump  -h 192.168.220.60:27500 -d erp -o /terry/erp

恢复:

mongorestore  -h 192.168.220.105:27017 -d erp  /terry/erp

如果在配置复制集过程中出现了问题,无法进行,一般是想重新配置,但有一种比较好的办法,就是删除掉dbPath,在配置文件中dbPath的配置如下:

dbPath: /var/lib/mongo
rm -rf /var/lib/mongo/*

 

其他:

1. 删除mongodb的库,重新启动

mv /var/lib/mongo /var/lib/mongo1  
mkdir /var/lib/mongo  
chown mongod:mongod /var/lib/mongo

2.删除复制集节点:

rs.remove("mongo0.example.com:27017")

3.在副本集的副节点读数据:

db.setSlaveOk()

4.主从切换

进入主mongo  执行:

rs.stepDown(15);

log如下:

rs0:PRIMARY> rs.stepDown(15);
2016-10-08T10:37:25.511+0800 E QUERY    [thread1] Error: error doing query: failed: network error while attempting to run command 'replSetStepDown' on host '127.0.0.1:27017'  :
DB.prototype.runCommand@src/mongo/shell/db.js:135:1
DB.prototype.adminCommand@src/mongo/shell/db.js:153:16
rs.stepDown@src/mongo/shell/utils.js:1181:12
@(shell):1:1

2016-10-08T10:37:25.513+0800 I NETWORK  [thread1] trying reconnect to 127.0.0.1:27017 (127.0.0.1) failed
2016-10-08T10:37:25.525+0800 I NETWORK  [thread1] reconnect 127.0.0.1:27017 (127.0.0.1) ok
rs0:SECONDARY> 
rs0:SECONDARY> 
rs0:SECONDARY> 
rs0:SECONDARY> 
rs0:SECONDARY> 

 

 

参考:

https://gist.github.com/leommoore/309de7c0042ed697ee84

https://docs.mongodb.com/manual/tutorial/install-mongodb-on-red-hat/

https://docs.mongodb.com/manual/tutorial/deploy-replica-set/

https://docs.mongodb.com/manual/reference/configuration-options/

 

 

安装mongodb3.2 复制集

只搞了两个节点的复制集,1:192.168.220.105,2:192.168.220.106
1.安装mongodb

touch /etc/yum.repos.d/mongodb-org-3.2.repo
vim  /etc/yum.repos.d/mongodb-org-3.2.repo

在打开的文件中加入内容:(3.2)

[mongodb-org-3.2]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/3.2/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-3.2.asc

如果安装2.6,则加入内容:

[mongodb-org-2.6]
name=MongoDB 2.6 Repository
baseurl=http://downloads-distro.mongodb.org/repo/redhat/os/x86_64/
gpgcheck=0
enabled=1

开始安装:

sudo yum install -y mongodb-org

 

【问底】徐汉彬:亿级Web系统搭建——单机到分布式集群

本文为转载:
【导读】徐汉彬曾在阿里巴巴和腾讯从事4年多的技术研发工作,负责过日请求量过亿的Web系统升级与重构,目前在小满科技创业,从事SaaS服务技术建设。

大规模流量的网站架构,从来都是慢慢“成长”而来。而这个过程中,会遇到很多问题,在不断解决问题的过程中,Web系统变得越来越大。并且,新的挑战又往往出现在旧的解决方案之上。希望这篇文章能够为技术人员提供一定的参考和帮助。

以下为原文

当一个Web系统从日访问量10万逐步增长到1000万,甚至超过1亿的过程中,Web系统承受的压力会越来越大,在这个过程中,我们会遇 到很多的问题。为了解决这些性能压力带来问题,我们需要在Web系统架构层面搭建多个层次的缓存机制。在不同的压力阶段,我们会遇到不同的问题,通过搭建 不同的服务和架构来解决。

Web负载均衡 

Web负载均衡(Load Balancing),简单地说就是给我们的服务器集群分配“工作任务”,而采用恰当的分配方式,对于保护处于后端的Web服务器来说,非常重要。

负载均衡的策略有很多,我们从简单的讲起哈。

1. HTTP重定向

当用户发来请求的时候,Web服务器通过修改HTTP响应头中的Location标记来返回一个新的url,然后浏览器再继续请求 这个新url,实际上就是页面重定向。通过重定向,来达到“负载均衡”的目标。例如,我们在下载PHP源码包的时候,点击下载链接时,为了解决不同国家和 地域下载速度的问题,它会返回一个离我们近的下载地址。重定向的HTTP返回码是302,如下图:

如果使用PHP代码来实现这个功能,方式如下:

这个重定向非常容易实现,并且可以自定义各种策略。但是,它在大规模访问量下,性能不佳。而且,给用户的体验也不好,实际请求发生重定向,增加了网络延时。

2. 反向代理负载均衡

反向代理服务的核心工作主要是转发HTTP请求,扮演了浏览器端和后台Web服务器中转的角色。因为它工作在HTTP层(应用层),也就是网络七层结构中的第七层,因此也被称为“七层负载均衡”。可以做反向代理的软件很多,比较常见的一种是Nginx。

Nginx是一种非常灵活的反向代理软件,可以自由定制化转发策略,分配服务器流量的权重等。反向代理中,常见的 一个问题,就是Web服务器存储的session数据,因为一般负载均衡的策略都是随机分配请求的。同一个登录用户的请求,无法保证一定分配到相同的 Web机器上,会导致无法找到session的问题。

解决方案主要有两种:

  1. 配置反向代理的转发规则,让同一个用户的请求一定落到同一台机器上(通过分析cookie),复杂的转发规则将会消耗更多的CPU,也增加了代理服务器的负担。
  2. 将session这类的信息,专门用某个独立服务来存储,例如redis/memchache,这个方案是比较推荐的。

反向代理服务,也是可以开启缓存的,如果开启了,会增加反向代理的负担,需要谨慎使用。这种负载均衡策略实现和部 署非常简单,而且性能表现也比较好。但是,它有“单点故障”的问题,如果挂了,会带来很多的麻烦。而且,到了后期Web服务器继续增加,它本身可能成为系 统的瓶颈。

3. IP负载均衡

IP负载均衡服务是工作在网络层(修改IP)和传输层(修改端口,第四层),比起工作在应用层(第七层)性能要高 出非常多。原理是,他是对IP层的数据包的IP地址和端口信息进行修改,达到负载均衡的目的。这种方式,也被称为“四层负载均衡”。常见的负载均衡方式, 是LVS(Linux Virtual Server,Linux虚拟服务),通过IPVS(IP Virtual Server,IP虚拟服务)来实现。

在负载均衡服务器收到客户端的IP包的时候,会修改IP包的目标IP地址或端口,然后原封不动地投递到内部网络中,数据包会流入到实际Web服务器。实际服务器处理完成后,又会将数据包投递回给负载均衡服务器,它再修改目标IP地址为用户IP地址,最终回到客户端。

上述的方式叫LVS-NAT,除此之外,还有LVS-RD(直接路由),LVS-TUN(IP隧道),三者之间都属于LVS的方式,但是有一定的区别,篇幅问题,不赘叙。

IP负载均衡的性能要高出Nginx的反向代理很多,它只处理到传输层为止的数据包,并不做进一步的组包,然后直接转发给实际服务器。不过,它的配置和搭建比较复杂。

4. DNS负载均衡

DNS(Domain Name System)负责域名解析的服务,域名url实际上是服务器的别名,实际映射是一个IP地址,解析过程,就是DNS完成域名到IP的映射。而一个域名是可以配置成对应多个IP的。因此,DNS也就可以作为负载均衡服务。

这种负载均衡策略,配置简单,性能极佳。但是,不能自由定义规则,而且,变更被映射的IP或者机器故障时很麻烦,还存在DNS生效延迟的问题。

5. DNS/GSLB负载均衡

我们常用的CDN(Content Delivery Network,内容分发网络)实现方式,其实就是在同一个域名映射为多IP的基础上更进一步,通过GSLB(Global Server Load Balance,全局负载均衡)按照指定规则映射域名的IP。一般情况下都是按照地理位置,将离用户近的IP返回给用户,减少网络传输中的路由节点之间的跳跃消耗。

图中的“向上寻找”,实际过程是LDNS(Local DNS)先向根域名服务(Root Name Server)获取到顶级根的Name Server(例如.com的),然后得到指定域名的授权DNS,然后再获得实际服务器IP。

CDN在Web系统中,一般情况下是用来解决大小较大的静态资源(html/Js/Css/图片等)的加载问题,让这些比较依赖网络下载的内容,尽可能离用户更近,提升用户体验。

例如,我访问了一张imgcache.gtimg.cn上的图片(腾讯的自建CDN,不使用qq.com域名的原因是防止http请求的时候,带上了多余的cookie信息),我获得的IP是183.60.217.90。

这种方式,和前面的DNS负载均衡一样,不仅性能极佳,而且支持配置多种策略。但是,搭建和维护成本非常高。互联网一线公司,会自建CDN服务,中小型公司一般使用第三方提供的CDN。

 

Web系统的缓存机制的建立和优化

刚刚我们讲完了Web系统的外部网络环境,现在我们开始关注我们Web系统自身的性能问题。我们的Web站点随着访问量的上升,会遇到很多的挑战,解决这些问题不仅仅是扩容机器这么简单,建立和使用合适的缓存机制才是根本。

最开始,我们的Web系统架构可能是这样的,每个环节,都可能只有1台机器。

我们从最根本的数据存储开始看哈。

一、 MySQL数据库内部缓存使用

MySQL的缓存机制,就从先从MySQL内部开始,下面的内容将以最常见的InnoDB存储引擎为主。

1. 建立恰当的索引

最简单的是建立索引,索引在表数据比较大的时候,起到快速检索数据的作用,但是成本也是有的。首 先,占用了一定的磁盘空间,其中组合索引最突出,使用需要谨慎,它产生的索引甚至会比源数据更大。其次,建立索引之后的数据insert/update /delete等操作,因为需要更新原来的索引,耗时会增加。当然,实际上我们的系统从总体来说,是以select查询操作居多,因此,索引的使用仍然对 系统性能有大幅提升的作用。

2. 数据库连接线程池缓存

如果,每一个数据库操作请求都需要创建和销毁连接的话,对数据库来说,无疑也是一种巨大的开销。为了减少这类型的开销,可以在MySQL中配置thread_cache_size来表示保留多少线程用于复用。线程不够的时候,再创建,空闲过多的时候,则销毁。

其实,还有更为激进一点的做法,使用pconnect(数据库长连接),线程一旦创建在 很长时间内都保持着。但是,在访问量比较大,机器比较多的情况下,这种用法很可能会导致“数据库连接数耗尽”,因为建立连接并不回收,最终达到数据库的 max_connections(最大连接数)。因此,长连接的用法通常需要在CGI和MySQL之间实现一个“连接池”服务,控制CGI机器“盲目”创 建连接数。

建立数据库连接池服务,有很多实现的方式,PHP的话,我推荐使用swoole(PHP的一个网络通讯拓展)来实现。

3. Innodb缓存设置(innodb_buffer_pool_size)

innodb_buffer_pool_size这是个用来保存索引和数据的内存缓存区,如果机器是MySQL独占的机器,一般推荐为机器物理内存的80%。在取表数据的场景中,它可以减少磁盘IO。一般来说,这个值设置越大,cache命中率会越高。

4. 分库/分表/分区。

MySQL数据库表一般承受数据量在百万级别,再往上增长,各项性能将会出现大幅度下 降,因此,当我们预见数据量会超过这个量级的时候,建议进行分库/分表/分区等操作。最好的做法,是服务在搭建之初就设计为分库分表的存储模式,从根本上 杜绝中后期的风险。不过,会牺牲一些便利性,例如列表式的查询,同时,也增加了维护的复杂度。不过,到了数据量千万级别或者以上的时候,我们会发现,它们 都是值得的。

二、 MySQL数据库多台服务搭建

1台MySQL机器,实际上是高风险的单点,因为如果它挂了,我们Web服务就不可用 了。而且,随着Web系统访问量继续增加,终于有一天,我们发现1台MySQL服务器无法支撑下去,我们开始需要使用更多的MySQL机器。当引入多台 MySQL机器的时候,很多新的问题又将产生。

1. 建立MySQL主从,从库作为备份

这种做法纯粹为了解决“单点故障”的问题,在主库出故障的时候,切换到从库。不过,这种做法实际上有点浪费资源,因为从库实际上被闲着了。

2. MySQL读写分离,主库写,从库读。

两台数据库做读写分离,主库负责写入类的操作,从库负责读的操作。并且,如果主库发生故障,仍然不影响读的操作,同时也可以将全部读写都临时切换到从库中(需要注意流量,可能会因为流量过大,把从库也拖垮)。

3. 主主互备。

两台MySQL之间互为彼此的从库,同时又是主库。这种方案,既做到了访问量的压力分流,同时也解决了“单点故障”问题。任何一台故障,都还有另外一套可供使用的服务。

不过,这种方案,只能用在两台机器的场景。如果业务拓展还是很快的话,可以选择将业务分离,建立多个主主互备。

三、 MySQL数据库机器之间的数据同步

每当我们解决一个问题,新的问题必然诞生在旧的解决方案上。当我们有多台 MySQL,在业务高峰期,很可能出现两个库之间的数据有延迟的场景。并且,网络和机器负载等,也会影响数据同步的延迟。我们曾经遇到过,在日访问量接近 1亿的特殊场景下,出现,从库数据需要很多天才能同步追上主库的数据。这种场景下,从库基本失去效用了。

于是,解决同步问题,就是我们下一步需要关注的点。

1. MySQL自带多线程同步

MySQL5.6开始支持主库和从库数据同步,走多线程。但是,限制也是比较明 显的,只能以库为单位。MySQL数据同步是通过binlog日志,主库写入到binlog日志的操作,是具有顺序的,尤其当SQL操作中含有对于表结构 的修改等操作,对于后续的SQL语句操作是有影响的。因此,从库同步数据,必须走单进程。

2. 自己实现解析binlog,多线程写入。

以数据库的表为单位,解析binlog多张表同时做数据同步。这样做的话,的确能够加快数据同步的效率,但是,如果表和表之间存在结构关系或者数据依赖的话,则同样存在写入顺序的问题。这种方式,可用于一些比较稳定并且相对独立的数据表。

国内一线互联网公司,大部分都是通过这种方式,来加快数据同步效率。还有更为激 进的做法,是直接解析binlog,忽略以表为单位,直接写入。但是这种做法,实现复杂,使用范围就更受到限制,只能用于一些场景特殊的数据库中(没有表 结构变更,表和表之间没有数据依赖等特殊表)。

四、 在Web服务器和数据库之间建立缓存

实际上,解决大访问量的问题,不能仅仅着眼于数据库层面。根据“二八定 律”,80%的请求只关注在20%的热点数据上。因此,我们应该建立Web服务器和数据库之间的缓存机制。这种机制,可以用磁盘作为缓存,也可以用内存缓 存的方式。通过它们,将大部分的热点数据查询,阻挡在数据库之前。

1. 页面静态化

用户访问网站的某个页面,页面上的大部分内容在很长一段时间内,可能都是没有变 化的。例如一篇新闻报道,一旦发布几乎是不会修改内容的。这样的话,通过CGI生成的静态html页面缓存到Web服务器的磁盘本地。除了第一次,是通过 动态CGI查询数据库获取之外,之后都直接将本地磁盘文件返回给用户。

在Web系统规模比较小的时候,这种做法看似完美。但是,一旦Web系统规模变 大,例如当我有100台的Web服务器的时候。那样这些磁盘文件,将会有100份,这个是资源浪费,也不好维护。这个时候有人会想,可以集中一台服务器存 起来,呵呵,不如看看下面一种缓存方式吧,它就是这样做的。

2. 单台内存缓存

通过页面静态化的例子中,我们可以知道将“缓存”搭建在Web机器本机是不好维护的,会带来更多问题(实际上,通过PHP的apc拓展,可通过Key/value操作Web服务器的本机内存)。因此,我们选择搭建的内存缓存服务,也必须是一个独立的服务。

内存缓存的选择,主要有redis/memcache。从性能上说,两者差别不大,从功能丰富程度上说,Redis更胜一筹。

3. 内存缓存集群

当我们搭建单台内存缓存完毕,我们又会面临单点故障的问题,因此,我们必须将它 变成一个集群。简单的做法,是给他增加一个slave作为备份机器。但是,如果请求量真的很多,我们发现cache命中率不高,需要更多的机器内存呢?因 此,我们更建议将它配置成一个集群。例如,类似redis cluster。

Redis cluster集群内的Redis互为多组主从,同时每个节点都可以接受请求,在拓展集群的时候比较方便。客户端可以向任意一个节点发送请求,如果是它的 “负责”的内容,则直接返回内容。否则,查找实际负责Redis节点,然后将地址告知客户端,客户端重新请求。

对于使用缓存服务的客户端来说,这一切是透明的。

内存缓存服务在切换的时候,是有一定风险的。从A集群切换到B集群的过程中,必 须保证B集群提前做好“预热”(B集群的内存中的热点数据,应该尽量与A集群相同,否则,切换的一瞬间大量请求内容,在B集群的内存缓存中查找不到,流量 直接冲击后端的数据库服务,很可能导致数据库宕机)。

4. 减少数据库“写”

上面的机制,都实现减少数据库的“读”的操作,但是,写的操作也是一个大的压力。写的操作,虽然无法减少,但是可以通过合并请求,来起到减轻压力的效果。这个时候,我们就需要在内存缓存集群和数据库集群之间,建立一个修改同步机制。

先将修改请求生效在cache中,让外界查询显示正常,然后将这些sql修改放入到一个队列中存储起来,队列满或者每隔一段时间,合并为一个请求到数据库中更新数据库。

除了上述通过改变系统架构的方式提升写的性能外,MySQL本身也可以通过配置参数innodb_flush_log_at_trx_commit来调整写入磁盘的策略。如果机器成本允许,从硬件层面解决问题,可以选择老一点的RAID(Redundant Arrays of independent Disks,磁盘列阵)或者比较新的SSD(Solid State Drives,固态硬盘)。

5. NoSQL存储

不管数据库的读还是写,当流量再进一步上涨,终会达到“人力有穷时”的场景。继 续加机器的成本比较高,并且不一定可以真正解决问题的时候。这个时候,部分核心数据,就可以考虑使用NoSQL的数据库。NoSQL存储,大部分都是采用 key-value的方式,这里比较推荐使用上面介绍过Redis,Redis本身是一个内存cache,同时也可以当做一个存储来使用,让它直接将数据 落地到磁盘。

这样的话,我们就将数据库中某些被频繁读写的数据,分离出来,放在我们新搭建的Redis存储集群中,又进一步减轻原来MySQL数据库的压力,同时因为Redis本身是个内存级别的Cache,读写的性能都会大幅度提升。

国内一线互联网公司,架构上采用的解决方案很多是类似于上述方案,不过,使用的cache服务却不一定是Redis,他们会有更丰富的其他选择,甚至根据自身业务特点开发出自己的NoSQL服务。

6. 空节点查询问题

当我们搭建完前面所说的全部服务,认为Web系统已经很强的时候。我们还是那句 话,新的问题还是会来的。空节点查询,是指那些数据库中根本不存在的数据请求。例如,我请求查询一个不存在人员信息,系统会从各级缓存逐级查找,最后查到 到数据库本身,然后才得出查找不到的结论,返回给前端。因为各级cache对它无效,这个请求是非常消耗系统资源的,而如果大量的空节点查询,是可以冲击 到系统服务的。

在我曾经的工作经历中,曾深受其害。因此,为了维护Web系统的稳定性,设计适当的空节点过滤机制,非常有必要。

我们当时采用的方式,就是设计一张简单的记录映射表。将存在的记录存储起来,放入到一台内存cache中,这样的话,如果还有空节点查询,则在缓存这一层就被阻挡了。

 

 

异地部署(地理分布式)

完成了上述架构建设之后,我们的系统是否就已经足够强大了呢?答案当然 是否定的哈,优化是无极限的。Web系统虽然表面上看,似乎比较强大了,但是给予用户的体验却不一定是最好的。因为东北的同学,访问深圳的一个网站服务, 他还是会感到一些网络距离上的慢。这个时候,我们就需要做异地部署,让Web系统离用户更近。

一、 核心集中与节点分散

有玩过大型网游的同学都会知道,网游是有很多个区的,一般都是按照地域 来分,例如广东专区,北京专区。如果一个在广东的玩家,去北京专区玩,那么他会感觉明显比在广东专区卡。实际上,这些大区的名称就已经说明了,它的服务器 所在地,所以,广东的玩家去连接地处北京的服务器,网络当然会比较慢。

当一个系统和服务足够大的时候,就必须开始考虑异地部署的问题了。让你 的服务,尽可能离用户更近。我们前面已经提到了Web的静态资源,可以存放在CDN上,然后通过DNS/GSLB的方式,让静态资源的分散“全国各地”。 但是,CDN只解决的静态资源的问题,没有解决后端庞大的系统服务还只集中在某个固定城市的问题。

这个时候,异地部署就开始了。异地部署一般遵循:核心集中,节点分散。

  • 核心集中:实际部署过程中,总有一部分的数据和服务存在不可部署多套,或者部署多套成本巨大。而对于这些服务和数据,就仍然维持一套,而部署地点选择一个地域比较中心的地方,通过网络内部专线来和各个节点通讯。
  • 节点分散:将一些服务部署为多套,分布在各个城市节点,让用户请求尽可能选择近的节点访问服务。

例如,我们选择在上海部署为核心节点,北京,深圳,武汉,上海为分散节点(上海自己本身也是一个分散节点)。我们的服务架构如图:

需要补充一下的是,上图中上海节点和核心节点是同处于一个机房的,其他分散节点各自独立机房。
国内有很多大型网游,都是大致遵循上述架构。它们会把数据量不大的用户核心账号等放在核心节点,而大部分的网游数据,例如装备、任务等数据和服务放在地区节点里。当然,核心节点和地域节点之间,也有缓存机制。

二、 节点容灾和过载保护

节点容灾是指,某个节点如果发生故障时,我们需要建立一个机制去保证服 务仍然可用。毫无疑问,这里比较常见的容灾方式,是切换到附近城市节点。假如系统的天津节点发生故障,那么我们就将网络流量切换到附近的北京节点上。考虑 到负载均衡,可能需要同时将流量切换到附近的几个地域节点。另一方面,核心节点自身也是需要自己做好容灾和备份的,核心节点一旦故障,就会影响全国服务。

过载保护,指的是一个节点已经达到最大容量,无法继续接接受更多请求了,系统必须有一个保护的机制。一个服务已经满负载,还继续接受新的请求,结果很可能就是宕机,影响整个节点的服务,为了至少保障大部分用户的正常使用,过载保护是必要的。

解决过载保护,一般2个方向:

  • 拒绝服务,检测到满负载之后,就不再接受新的连接请求。例如网游登入中的排队。
  • 分流到其他节点。这种的话,系统实现更为复杂,又涉及到负载均衡的问题。

小结

Web系统会随着访问规模的增长,渐渐地从1台服务器可以满足需求,一直成长为“庞然大物”的大集群。而这个Web系统变大的过程,实际上就是我们解决问题的过程。在不同的阶段,解决不同的问题,而新的问题又诞生在旧的解决方案之上。

系统的优化是没有极限的,软件和系统架构也一直在快速发展,新的方案解决了老的问题,同时也带来新的挑战。

yii2 合并js css的插件。

https://github.com/skeeks-semenov/yii2-assets-auto-compress
今天安装了一下这个插件,用来合并js,css。
下面是我安装的步骤:

composer  require --prefer-dist skeeks/yii2-assets-auto-compress "*"
Running composer as root/super user is highly discouraged as packages, plugins and scripts cannot always be trusted
./composer.json has been updated
Loading composer repositories with package information
Updating dependencies (including require-dev)
  - Installing mrclay/minify (2.3.0)                       
    Downloading: 100%         

  - Installing natxet/cssmin (v3.0.4)
    Downloading: 100%         

  - Installing tedivm/jshrink (v1.1.0)
    Downloading: 100%         

  - Installing skeeks/yii2-assets-auto-compress (1.1.1)
    Downloading: 100%         

mrclay/minify suggests installing tubalmartin/cssmin (Support minify with CSSMin (YUI PHP port))
Writing lock file
Generating autoload files
[root@iZ942k2d5ezZ fecshop]# 

安装完成后,添加配置:

[
    'bootstrap'    => ['assetsAutoCompress'],
    'components'    =>
    [
    //....
        'assetsAutoCompress' =>
        [
            'class'             => '\skeeks\yii2\assetsAuto\AssetsAutoCompressComponent',
            'enabled'           => true,
            'jsCompress'        => true,
            'cssFileCompile'    => true,
            'jsFileCompile'     => true,
        ],
    //....
    ]
]

添加完成后,去我的后台,发现了js都给合并起来放到了页面的底部。

css合并放到了页面的顶部:

<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <meta name="csrf-param" content="_csrf">
    <meta name="csrf-token" content="WnhJLnc3NFoqSAceInFwb2g6IRhBBBkwLUgaeRpjfCILKg5HDVZGIA==">
    <title></title>
    <link href="/assets/css-compress/a4b0c42ec77e84de019e80dabfbbdd26.css?v=1466129605" rel="stylesheet">
</head>

js 放到了页面的底部:

<script src="/assets/js-compress/6e9da28e384e6efd0451dfbc263c3fdd.js?v=1466129605"></script>
<script type="text/javascript">jQuery(window).load(function () {
 $(document).ready(function(){$("#login-captcha-image").click();});
});</script></body>
</html>

不过这种合并js和css的方法,还是会存在一定的问题,就和magento的css和js的合并,有一些插件合并起来还是会报错,我的后台用的是dwz,合并js后,会存在问题,尤其是dwz需要加载一个.xml文件,开启合并后,整体不能用了。

不过对于前台,如果不用一些乱起八糟的js库包,应该问题不大。

总体来说这个js和css合并不是万能,但是还是能解决一部分问题,譬如线上的电商网站等。