redis实践－cluster搭建

redis3开始支持cluster集群模式，解决单点的瓶颈问题，本文以3.0.3为例搭建并测试cluster集群

搭建步骤

一.安装ruby

a) wget https://cache.ruby-lang.org/pub/ruby/2.2/ruby-2.2.3.tar.gz

b) tar -xvzf ruby-2.2.3.tar.gz

c) cd ruby-2.2.3

d) ./configure

e) make

d) make install

二.安装rubygems & ruby redis

a) yum install rubygems

b) gem install redis

上述过程中可能由于gem source问题导致下载失败，可以换成国内的

添加源 gem sources -a http://ruby.taobao.org/

删除源 gem sources --remove http://rubygems.org/

查看源 gem sources -l

三.安装redis

a) wget http://download.redis.io/releases/redis-3.0.3.tar.gz

b) tar -xzvf redis-3.0.3.tar.gz

c) cd redis-3.0.3

d) make

e) make install

四.集群配置

集群10.2.102.7, 10.2.102.8，10.2.102.9相互打通，每台机器部署两个redis实例

a) 在每台机器上建立两个目录

mkdir redis-cluster/7000 redis-cluster/70001

b) 在每个目录下创建配置文件redis.conf，配置如下，其中port值和目录名对应

五.启动

a) 进入每台机器的实例目录，执行

redis-server redis.conf

成功后可以在实例目录下的redis.log中看到如下日志

b) 关联实例创建集群

3台机器6个实例，一主一备将slots切分为3份

                  redis-trib.rb create --replicas 1 10.2.102.7:7000 10.2.102.7:7001 10.2.102.8:7000 10.2.102.8:7001 10.2.102.9:7000 10.2.102.9:7001

               输入 yes 接受主备节点分配

               在每个实例目录下可以看见生成了一份nodes.conf，如下

六.测试

可以通过redis-cli脚本，但须要加上-c参数指定cluster模式连接。用junit代码如下，其中RedisClusterClient是基于JedisCluster的封装：

public class RedisClusterCliTest {
    
    private final static String key_cnt = "key_cnt";
    
    final static Set<HostAndPort> nodes = new HashSet<HostAndPort>();
    static {
        nodes.add(new HostAndPort("10.2.102.7", 7000));
        nodes.add(new HostAndPort("10.2.102.7", 7001));
        //nodes.add(new HostAndPort("10.2.102.8", 7000));
        //nodes.add(new HostAndPort("10.2.102.8", 7001));
        //nodes.add(new HostAndPort("10.2.102.9", 7000));
        //nodes.add(new HostAndPort("10.2.102.9", 7001));
    }
    
    private RedisClusterClient rcc;
    
    @Before
    public void init() {
        rcc = new RedisClusterClient(nodes);
    }
    
    @After
    public void destroy() {
        rcc.close();
    }
    
    @Test
    public void test_set() {
        for (int i = 0; i < 100; ++i) {
            rcc.setex("key" + i, 60 * 10, String.valueOf(i));
        }
    }
    
    @Test
    public void test_get() {
        for (int i = 0; i < 100; ++i) {
            String value = rcc.get("key" + i);
            System.out.println(value);
        }
    }
    
    @Test
    public void test_incr() {
        System.out.println("Before incr : " + rcc.get(key_cnt));
        rcc.incr(key_cnt);
        System.out.println("After incr : " + rcc.get(key_cnt));
    }
    
    @Test
    public void test_incr_multi() {
        long start = Long.parseLong(rcc.get(key_cnt));
        System.out.println("Before incr : " + start + ", " + new Date());
        
        int threadNum = 100;
        int count = 100;
        
        ExecutorService threadPool = Executors.newFixedThreadPool(threadNum, new ThreadFactory(){
            
            AtomicInteger index = new AtomicInteger(0);

            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, "Thread-incr-" + index.incrementAndGet());
            }
            
        });
        
        List<Future<Boolean>> result = new ArrayList<Future<Boolean>>(threadNum);
        for (int i = 0; i < threadNum; ++i) {
            result.add(threadPool.submit(new IncrThread(rcc, key_cnt + i, count)));
        }
        
        for (Future<Boolean> f : result) {
            try {
                if(!f.get()) {
                    System.err.println("Fail ....");
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        
        System.out.println("After incr : " + rcc.get(key_cnt) + ", Except " + (start + count * threadNum) + ", " + new Date());
    }
    
    @Test
    public void test_decr() {
        System.out.println("Before decr : " + rcc.get(key_cnt));
        rcc.decr(key_cnt);
        System.out.println("After decr : " + rcc.get(key_cnt));
    }
    
    
    class IncrThread implements Callable<Boolean> {
        
        RedisClusterClient rcc;
        String key;
        int count;
        
        IncrThread(RedisClusterClient rcc, String key, int count) {
            this.rcc = rcc;
            this.key = key;
            this.count = count;
        }

        @Override
        public Boolean call() {
            for (int i = 0; i < count; ++i) {
                rcc.incr(key);
            }
            return true;
        }
        
    }
    
}

redis实践－cluster搭建

猜你喜欢