activemq的高可用(zookeeper+leveldb)主从集群

最新推荐文章于 2020-06-14 22:08:24 发布
最新推荐文章于 2020-06-14 22:08:24 发布
阅读量952 收藏 1
点赞数 1

一、架构和技术介绍


1、简介


ActiveMQ 是Apache出品，最流行的，能力强劲的开源消息总线。完全支持JMS1.1和J2EE 1.4规范的 JMS Provider实现


2、activemq的特性


  • 多种语言和协议编写客户端。语言: Java, C, C++, C#, Ruby, Perl, Python, PHP。应用协议: OpenWire,Stomp REST,WS Notification,XMPP,AMQP

  • 完全支持JMS1.1和J2EE 1.4规范 (持久化,XA消息,事务)

  • 对Spring的支持,ActiveMQ可以很容易内嵌到使用Spring的系统里面去,而且也支持Spring2.0的特性

  • 通过常见J2EE服务器(如 Geronimo,JBoss 4, GlassFish,WebLogic)的测试,其中通过JCA 1.5 resourceadaptors的配置,可以让ActiveMQ可以自动的部署到任何兼容J2EE1.4商业服务器上

  • 支持多种传送协议:in-VM,TCP,SSL,NIO,UDP,JGroups,JXTA

  • 支持通过JDBC和journal提供高速的消息持久化

  • 从设计上保证了高性能的集群,客户端-服务器,点对点

  • 支持Ajax

  • 支持与Axis的整合

  • 可以很容易得调用内嵌JMS provider,进行测试


二、集群介绍


从 ActiveMQ 5.9 开始，ActiveMQ 的集群实现方式取消了传统的Master-Slave 方式，增加了基于ZooKeeper + LevelDB的 Master-Slave实现方式，其他两种方式目录共享和数据库共享依然存在。 


三种集群方式的对比： 


1、基于共享文件系统（KahaDB，默认）： 


<persistenceAdapter> <kahaDB directory="${activemq.data}/kahadb"/> </persistenceAdapter> 


2、基于 JDBC：

 

<bean id="MySQL-ds" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
      <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
      <property name="url" value="jdbc:mysql://localhost:3306/amq?relaxAutoCommit=true"/>
      <property name="username" value="root"/>
      <property name="password" value="root"/>
      <property name="maxActive" value="20"/>
      <property name="poolPreparedStatements" value="true"/>
</bean>
<persistenceAdapter> 
        <jdbcPersistenceAdapter dataDirectory="${activemq.data}" dataSource="#mysql-ds" createTablesOnStartup="false"/>
</persistenceAdapter>


3、基于可复制的 LevelDB（本文采用这种集群方式）： 


LevelDB 是 Google开发的一套用于持久化数据的高性能类库。LevelDB并不是一种服务,用户需要自 行实现Server。是单进程的服务，能够处理十亿级别规模Key-Value 型数据，占用内存小。 


<persistenceAdapter> 
    <replicatedLevelDB 
           directory="${activemq.data}/leveldb"     replicas="3"   
           bind="tcp://0.0.0.0:62621"   zkAddress="localhost:2181,localhost:2182,localhost:2183" 
           hostname="localhost"    zkPath="/activemq/leveldb-stores"/> 
</persistenceAdapter>


本文主要讲解基于 ZooKeeper 和LevelDB 搭建ActiveMQ 集群。集群仅提供主备方式的高可用集 群功能，避免单点故障，没有负载均衡功能。 


官方文档：http://activemq.apache.org/replicated-leveldb-store.html 


集群原理图：


640?wx_fmt=png


高可用的原理：


使用ZooKeeper（集群）注册所有的ActiveMQ Broker。只有其中的一个Broker 可以提供 服务，被视为Master，其他的Broker 处于待机状态，被视为Slave。


如果Master 因故障而不能提供服务，ZooKeeper会从 Slave中选举出一个 Broker充当 Master。 Slave 连接 Master并同步他们的存储状态，Slave不接受客户端连接。所有的存储操作都将被复制到 连接至 Master 的Slaves。如果 Master 宕了，得到了最新更新的 Slave 会成为 Master。


故障节点在恢复后 会重新加入到集群中并连接 Master 进入Slave 模式。 所有需要同步的disk 的消息操作都将等待存储状态被复制到其他法定节点的操作完成才能完成。


所以，如果你配置了replicas=3，那么法定大小是(3/2)+1=2。Master 将会存储并更新然后等待 (2-1)=1 个Slave存储和更新完成，才汇报 success。至于为什么是 2-1，熟悉 Zookeeper 的应该知道，有一个 node要作为观擦者存在。当一个新的Master 被选中，你需要至少保障一个法定node 在线以能够找到拥有最新 状态的node。


这个node 可以成为新的Master。因此，推荐运行至少3 个replica nodes，以防止一个node失败了，服务中断。（原理与 ZooKeeper 集群的高可用实现方式类似）


1、ActiveMQ集群部署规划：


环境：CentOS 6.5 x64 、JDK8


版本：ActiveMQ 5.13.3


ZooKeeper 集群环境：


192.168.1.81:2181,192.168.1.82:2182,192.168.1.83:2183


2、防火墙打开对应的端口


edu-zk-01:


-A INPUT -m state --state NEW -m tcp -p tcp --dport 8161 -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 51511 -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 62621 -j ACCEPT


edu-zk-02:


-A INPUT -m state --state NEW -m tcp -p tcp --dport 8162 -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 51512 -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 62622 -j ACCEPT


edu-zk-03:


-A INPUT -m state --state NEW -m tcp -p tcp --dport 8163 -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 51513 -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 62623 -j ACCEPT


3、分别在三台主机中创建/home/yxq/activemq目录


# mkdir /home/yxq/activemq


上传 apache-activemq-5.13.3-bin.tar.gz 到/home/yxq/activemq 目录\


4、解压并按节点命名


# cd /home/yxq/activemq 

# tar -xvf apache-activemq-5.13.3-bin.tar.gz

# mv apache-activemq-5.13.3     node-0X    #(X代表节点号 1、2、3，下同)


5、修改管理控制台端口（默认为 8161）可在 conf/jetty.xml 中修改，如下：


node-01 管控台端口：


 

<bean id="jettyPort" class="org.apache.activemq.web.WebConsolePort" init-method="start">

        <!-- the default port number for the web console -->

        <property name="host" value="0.0.0.0"/>

        <property name="port" value="8161"/>

</bean>


 node-02管控台端口：


<bean id="jettyPort" class="org.apache.activemq.web.WebConsolePort" init-method="start">

             <!-- the default port number for the web console -->

        <property name="host" value="0.0.0.0"/>

        <property name="port" value="8162"/>

</bean>


 node-03管控台端口：


<bean id="jettyPort" class="org.apache.activemq.web.WebConsolePort" init-method="start">

             <!-- the default port number for the web console -->

        <property name="host" value="0.0.0.0"/>

        <property name="port" value="8163"/>

</bean>


6、集群配置： 


在 3 个ActiveMQ 节点中配置conf/activemq.xml 中的持久化适配器。修改其中bind、zkAddress、hostname和 zkPath。注意：每个 ActiveMQ 的 BrokerName 必须相同，否则不能加入集群。


所有节点中activemq.xml配置


<broker xmlns="http://activemq.apache.org/schema/core" brokerName="DubboEdu" dataDirectory="${activemq.data}">


node-01 中的持久化配置:


640?wx_fmt=png


node-02 中的持久化配置:


640?wx_fmt=png


node-03 中的持久化配置:



640?wx_fmt=png


修改各节点的消息端口（注意，避免端口冲突）：

node-01 中的消息端口配置:


640?wx_fmt=png


node-02 中的消息端口配置:



640?wx_fmt=png


node-03 中的消息端口配置:



640?wx_fmt=png


7、按顺序启动 3个 ActiveMQ节点：(前提是：   zookeeper集群已经启动)


# /home/yxq/activemq/node-01/bin/activemq start

# /home/yxq/activemq/node-02/bin/activemq start

# /home/yxq/activemq/node-03/bin/activemq start


监听日志：


#  tail -f /home/yxq/activemq/node-01/data/activemq.log 

#  tail -f /home/yxq/activemq/node-02/data/activemq.log 

#  tail -f /home/yxq/activemq/node-03/data/activemq.log 


8、集群的节点状态分析：


zookeeper信息查看工具,下载地址：


https://issues.apache.org/jira/secure/attachment/12436620/ZooInspector.zip


解压，打开：ZooInspector\build\zookeeper-dev-ZooInspector.jar


集群启动后对 ZooKeeper 数据的抓图


640?wx_fmt=png


可以看到ActiveMQ 的有3 个节点，分别是


00000000000，00000000001，00000000002, 


我这里是 00000000005，00000000006，00000000007。


以下第一张图展现了 000000000005的值，可以看到elected 的值是不为空，说明这个节点是Master，


640?wx_fmt=png


其他两个节点是 Slave。



640?wx_fmt=png


640?wx_fmt=png


9.集群可用性测试


ActiveMQ的客户端只能访问Master的Broker,其他处于Slave的Broker不能访问，所以客户端连接的Broker应该使用failover协议(失败转移)


failover:


(tcp://192.168.1.81:51511,tcp://192.168.1.82:51512,tcp://192.168.1.83:51513)?randomize=false


640?wx_fmt=png


当一个ActiveMQ节点挂掉，或者一个Zookeeper节点挂掉，ActiveMQ服务依然正常运转，如果仅剩一个ActiveMQ节点,因为不能选举Master,ActiveMQ不能正常运行:同样的,如果Zookeeper仅剩一个节点活动，不管ActiveMQ各节点存活，ActiveMQ也不能正常提供服务。


(ActiveMQ集群的高可用，依赖于Zookeeper集群的高可用)


10.设置开机启动


#vi /etc/rc.local

su - yxq -c '/home/yxq/activemq/node-01/bin/activemq start'

su - yxq -c '/home/yxq/activemq/node-02/bin/activemq start'

su - yxq -c '/home/yxq/activemq/node-03/bin/activemq start'


或者


生产软链接到 /etc/init.d/ 下


ln -s  /home/yxq/activemq/node-01/bin/activemq   /etc/init.d/


检查 链接的权限是否有执行权限


chmod +x /etc/init.d/activemq


加入管理服务  


chkconfig --add  activemq


设置管理 ON状态   


chkconfig activemq  on


查看 


chkconfig --list activemq

service activemq  start/restart/stop  测试


碰到的问题：


使用service activemq start 提示：


INFO: Loading ‘/etc/default/activemq’

ERROR: Configuration variable JAVA_HOME or JAVACMD is not defined

correctly.

(JAVA_HOME=’ ’ , JAVACMD=’java’)


根据提示的意思是： 无法正确找到 JAVA_HOME 和 JAVACMD


配置服务启动级别和PATH，保证执行启动时，所需执行级别和jdk依赖没有问题


vi  activemq   

# chkconfig 2345 63 67

PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:/yxue/jdk/jdk1.8.0_74/bin:/yxue/jdk/jdk1.8.0_74/jre/bin:/root/bin

export PATH



11.demo例子


maven引入：


        <!--ActiveMQ依赖 -->
        <dependency>
             <groupId>org.apache.activemq</groupId>
             <artifactId>activemq-all</artifactId>
             <version>5.13.3</version>
        </dependency>
        <!-- Spring整合ActiveMQ所需依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>4.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-messaging</artifactId>
            <version>4.1.6.RELEASE</version>
        </dependency>


配置文件:


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:amq="http://activemq.apache.org/schema/core"
       xmlns:jms="http://www.springframework.org/schema/jms"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/jms
        http://www.springframework.org/schema/jms/spring-jms-4.0.xsd
        http://activemq.apache.org/schema/core
        http://activemq.apache.org/schema/core/activemq-core-5.8.0.xsd">

    <!-- ActiveMQ 连接工厂 -->
    <!-- 真正可以产生Connection的ConnectionFactory，由对应的 JMS服务厂商提供-->
    <amq:connectionFactory id="amqConnectionFactory" userName="admin" password="admin" brokerURL="failover:(tcp://192.168.248.129:61616,tcp://192.168.248.128:61616,tcp://192.168.248.127:61616)?randomize=false"   />

    <!-- Spring Caching连接工厂 -->
    <!-- Spring用于管理真正的ConnectionFactory的ConnectionFactory -->
    <bean id="connectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">
        <!-- 目标ConnectionFactory对应真实的可以产生JMS Connection的ConnectionFactory -->
        <property name="targetConnectionFactory" ref="amqConnectionFactory"></property>
        <!-- 同上，同理 -->
        <!-- <constructor-arg ref="amqConnectionFactory" /> -->
        <!-- Session缓存数量 -->
        <property name="sessionCacheSize" value="100" />
    </bean>

    <!-- Spring JmsTemplate 的消息生产者 start-->
    <!-- 定义JmsTemplate的Queue类型 -->
    <bean id="jmsQueueTemplate" class="org.springframework.jms.core.JmsTemplate">
        <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->
        <constructor-arg ref="connectionFactory" />
        <!-- 非pub/sub模型（发布/订阅），即队列模式 -->
        <property name="pubSubDomain" value="false" />
    </bean>

    <!-- 定义JmsTemplate的Topic类型 -->
    <bean id="jmsTopicTemplate" class="org.springframework.jms.core.JmsTemplate">
        <!-- 这个connectionFactory对应的是我们定义的Spring提供的那个ConnectionFactory对象 -->
        <constructor-arg ref="connectionFactory" />
        <!-- pub/sub模型（发布/订阅） -->
        <property name="pubSubDomain" value="true" />
        <!-- 发送模式  DeliveryMode.NON_PERSISTENT=1:非持久 ; DeliveryMode.PERSISTENT=2:持久-->
        <property name="deliveryMode" value="2" />
    </bean>
    <!--Spring JmsTemplate 的消息生产者 end-->

    <!-- 消息消费者 start-->
    <!-- 定义Queue监听器 -->
    <jms:listener-container destination-type="queue" container-type="default" connection-factory="connectionFactory" acknowledge="auto">
        <jms:listener destination="test.queue" ref="queueReceiver1"/>
        <jms:listener destination="test.queue" ref="queueReceiver2"/>
    </jms:listener-container>

    <!-- 定义Topic监听器 -->
    <jms:listener-container destination-type="topic" container-type="default" connection-factory="connectionFactory" acknowledge="auto">
        <jms:listener destination="test.topic" ref="topicReceiver1"/>
        <jms:listener destination="test.topic" ref="topicReceiver2"/>
    </jms:listener-container>
    <!-- 消息消费者 end -->
</beans>


QueueSender:


import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Component;

/**
 * ActiveMQ的消息队列模式
 * 队列消息的生产者，发哦是哪个消息到队列
 */
@Component
public class QueueSender {
    //通过Qualifier来注入对应的Bean
    @Autowired
    @Qualifier("jmsQueueTemplate")
    private JmsTemplate jmsTemplate;
    /**
     * 发送一条消息到指定的队列（目标）
     * @param queueName 队列名称
     * @param message 消息内容
     */
    public void send(String queueName,final String message){
        jmsTemplate.send(queueName, new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(message);
            }
        });
    }
}


TopicSender:


import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Component;

/**
 * ActiveMQ的topic/sub模式
 * Topic生产者发送消息到Topic
 */
@Component
public class TopicSender {
    @Autowired
    @Qualifier("jmsTopicTemplate")
    private JmsTemplate jmsTemplate;
    /**
     * 发送一条消息到指定的队列（目标）
     * @param topicName 队列名称
     * @param message 消息内容
     */
    public void send(String topicName,final String message){
        jmsTemplate.send(topicName, new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(message);
            }
        });
    }
}


QueueReceiver1:


import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
import org.springframework.stereotype.Component;

/**
 * 消息队列监听器
 *
 */
@Component
public class QueueReceiver1 implements MessageListener {

    public void onMessage(Message message) {
        try {
            System.out.println("QueueReceiver1接收到消息："+((TextMessage)message).getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}


QueueReceiver2:


import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
import org.springframework.stereotype.Component;

/**
 * 消息队列监听器
 *
 */
@Component
public class QueueReceiver2 implements MessageListener {

    public void onMessage(Message message) {
        try {
            System.out.println("QueueReceiver2接收到消息："+((TextMessage)message).getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}


TopicReceiver1:


import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
import org.springframework.stereotype.Component;

@Component
public class TopicReceiver1 implements MessageListener{

    public void onMessage(Message message) {
        try {
            System.out.println("TopicReceiver1接收到消息:"+((TextMessage)message).getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}


TopicReceiver2:


import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
import org.springframework.stereotype.Component;

@Component
public class TopicReceiver2 implements MessageListener{

    public void onMessage(Message message) {
        try {
            System.out.println("TopicReceiver2接收到消息:"+((TextMessage)message).getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}


ActivemqController调用：


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("activemq")
public class ActivemqController {
    @Autowired
    private QueueSender queueSender;
    @Autowired
    private TopicSender topicSender;

    /**
     * 发送消息到队列
     * Queue队列：仅有一个订阅者会收到消息，消息一旦被处理就不会存在队列中
     * @return String
     */
    @ResponseBody
    @RequestMapping("queueSender")
    public String queueSender(){
        String opt = "suc";
        try {
            queueSender.send("test.queue", "=======queue消息");
        } catch (Exception e) {
            opt = e.getCause().toString();
        }
        return opt;
    }

    @ResponseBody
    @RequestMapping("topicSender")
    public String topoicSender(){
        String opt = "suc";
        try {
            topicSender.send("test.topic", "==========topoic消息");
        } catch (Exception e) {
            opt = e.getCause().toString();
        }
        return opt;
    }
}


转自：csdn

作者：java20150326


陛下...看完奏折，点个赞再走吧！


推荐阅读


技术：jenkins和docker实现自动化构建部署

技术：设计图都不会画，还想做”架构师“？

技术：玩转linux 这些命令就够了 

技术：Kafka、RabbitMQ、RocketMQ等消息中间件的对比

技术：玩转linux 这些命令就够了

技术：30分钟如何学会使用Shiro 


工具：如何通过技术手段 “干掉” 视频APP里讨厌广告？

工具：通过技术手段 “干掉” 视频APP里讨厌的广告之（腾讯视频）


博主11年java开发经验，现从事智能语音工作的研发，关注微信公众号与博主进行技术交流！更过干货资源等你来拿！

640?wx_fmt=jpeg


640?wx_fmt=png

互扯程序
关注
ActiveMQ消息队列主从集群
江晓龙的博客
06-26 1万+
ActiveMQ主从高可用集群，需要使用Zookeeper集群注册所有的ActiveMQ节点，由Zookeeper实现主备切换时的选举，在主从高可用集群中，只有一个ActiveMQ节点处于工作状态，被视为Master节点，其他的ActiveMQ节点处于待机状态，当主节点挂掉后，Zookeeper会通过选举机制将集群中的某个ActiveMQ节点提升为Master，继续提供服务。模拟ActiveMQ主节点宕机，观察是否会由集群中另外的从节点，升级为主节点。每个节点都有单独的通信地址，故障切换后可以直接切换。
ActiveMQ学习笔记04 - 基于LevelDB的高可用
terrymanu的专栏
07-08 3364
ActiveMQ 5.9版本提供了基于LevelDB的高可用方式。
JMS学习(六)-ActiveMQ的高可用性实现
weixin_33896069的博客
07-13 260
原文地址：http://www.cnblogs.com/hapjin/p/5663024.html   一，ActiveMQ高可用性的架构 ActiveMQ的高可用性架构是基于Master/Slave 模型的。ActiveMQ总共提供了四种配置方案来配置HA，其中Shared Nothing Master/Slave 在5.8版本之后不再使用了，并在ActiveMQ5.9版本中引入了基于Zo...
ActiveMQ——3、ActiveMQ高可用与集群搭建
热门推荐
隔壁老王的专栏
12-29 1万+
1. ActiveMQ的高可用原理 使用ZooKeeper（集群）注册所有的ActiveMQ Broker。只有其中的一个Broker可以提供服务，被视为 Master，其他的 Broker 处于待机状态，被视为Slave。如果Master因故障而不能提供服务，Zookeeper会从Slave中选举出一个Broker充当Master。 Slave连接Master并同步他们的存储状态，Slave
JMS之——ActiveMQ高可用+负载均衡集群
冰河的专栏
04-04 1953
一、高可用集群 从ActiveMQ5.9开始，ActiveMQ的集群实现方式取消了传统的Master-Slave方式，增加了基于ZooKeeper+LevelDB的Master-Slave实现方式，其他两种方式目录共享和数据库共享方式依然存在. 1、文件共享（KahaDB） 2、数据库共享 3、
9 ActiveMQ 高可用
linjun20的博客
06-14 338
ActiveMQ 高可用
ActiveMQ与Zookeeper构建levelDB主从集群实战
1. **ActiveMQ主从架构**：在ActiveMQ中，通过Zookeeper实现主从架构，目的是确保高可用性和数据安全性。主节点负责处理所有客户端请求，而从节点实时同步主节点的数据，一旦主节点故障，从节点可以通过Zookeeper的...
Zookeeper+LevelDB实现ActiveMQ集群高可用解析
在本篇文章中，我们将探讨如何使用Zookeeper+LevelDB+ActiveMQ来构建一个高可用的ActiveMQ集群。Zookeeper在这里扮演了关键角色，它是一个分布式协调服务，能够管理ActiveMQ的主从关系，确保在主节点故障时，可以...
ActiveMQ基于zookeeper的主从（levelDB Master/Slave）搭建
08-29
ActiveMQ 基于 ZooKeeper 的主从（LevelDB Master/Slave）搭建 ActiveMQ 是一个流行的开源消息中间件，它提供了高性能、可靠的消息队列服务。在分布式系统中，ActiveMQ 可以作为消息中间件，实时同步数据，避免单...
Zookeeper+ActiveMQ测试.rar
08-09
本示例中的“Zookeeper+ActiveMQ测试.rar”文件包含了一个使用ZooKeeper实现ActiveMQ高可用性和负载均衡集群的实践案例。下面我们将详细探讨这两个组件以及它们如何协同工作。 **ZooKeeper** ZooKeeper是一个分布式...
ActiveMQ+zookeeper实现高可用和负载均衡(代码和测试)
06-29
ActiveMQ+zookeeper实现高可用和负载均衡(代码和测试)
ActiveMQ高可用+负载均衡集群的安装、配置、高可用测试
01-03
ActiveMQ高可用+负载均衡集群的安装、配置、高可用测试
ActiveMQ高可用+负载均衡集群
xiaobai001gonsoni的博客
12-11 2030
一,高可用集群 从ActiveMQ5.9开始，ActiveMQ的集群实现方式取消了传统的Master-Slave方式，增加了基于ZooKeeper+LevelDB的Master-Slave实现方式，其他两种方式目录共享和数据库共享方式依然存在 （1）文件共享（KahaDB）  ( 2 )数据库共享                  
ActiveMQ 高可用集群（基于ZooKeeper + LevelDB）
方亚军的博客
04-23 739
activemq+Zookeper高可用集群方案配置 在高并发、对稳定性要求极高的系统中，高可用的是必不可少的，。从ActiveMQ 5.9开始，ActiveMQ的集群实现方式取消了传统的Master-Slave方式，增加了基于ZooKeeper + LevelDB 的 Master-Slave 实现方式。 ActiveMQ的高可用原理 使用ZooKeeper（集群）注册所有的ActiveMQ ...
ActiveMQ单机部署zookeeper+levelDB集群
zuolj的专栏
11-16 1564
在http://blog.csdn.net/zuolj/article/details/53149015中介绍了ActiveMQ的zookeeper+levelDB的高可用架构。我在单机上部署了一个ActiveMQ基于zookeeper的集群，记录一下部署过程。
ActiveMQ高可用集群安装、配置（zookeeper + LevelDB）
tjsahwj的博客
10-06 281
从ActiveMQ5.9开始，ActiveMQ的集群实现方式取消了传统的Master-Slave方式，增加了基于zookeeper + LevelDB的Master-Slave实现方式，其他两种方式“目录共享”和“数据库共享”依然存在。 三种集群方式的对比： （1）基于共享文件系统（KahaDB，默认） &lt;persistenceAdapter&gt;     &lt;kahaDB di...
Apache ActiveMQ实战(2)-集群
weixin_30379531的博客
07-09 564
ActiveMQ的集群内嵌代理所引发的问题：消息过载管理混乱如何解决这些问题——集群的两种方式：Master slaveBroker clustersActiveMQ的集群有两种方式：MASTER/SLAVE模式Cluster模式Pure Master SlavePure master slave的工作方式：当master broker失效的时候。Slave broker 做出了两种不同的相...
ActiveMQ基于zookeeper+leveldb主从配置
12-09 9117
ActiveMQ基于zookeeper+leveldb主从配置 公司最近正在用ActiveMQ做消息中间件，考虑到网络不稳等情况需要做一个避免单点故障的主从配置，因为暂时业务上没那么大的吞吐，负载均衡没有做，而且新买的服务器还没到，所以先暂时在一台公网机器上做了三个不同的端口的zookeeper+activeMQ的主从复制，特此记录一下，等机器到了还需要从新配置一下。 以下为官网：http://a
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值