RocketMQ 4.1.0 与 Docker搭建与集群

搭建环境：docker

Centos7
RocketMQ 4.1.0
java 1.8

这里提供 编译好的 (RocketMQ4.1) apache-rocketmq-all.tar.gz 下载

ps：如果你没
apache-rocketmq-all.tar.gz 请在 搭建环境里 （补充 git 和 maven ）

git clone https://github.com/apache/incubator-rocketmq.git mvn clean package install -Prelease-all assembly:assembly -U

－－案例只适合测试学习

docker配置：

容器1:

9876/tcp localhost：9876

10909/tcp localhost：10909

10911/tcp localhost：10911

容器2:

9876/tcp localhost：9879

10909/tcp localhost：10916

10915/tcp localhost：10915

--查询宿主机的ip

例如是 os 系统：

 ifconfig  -a  找到 en0 －》net 192.168.1.7

ps:linux 也是一样

我在docker 挂载的盘在 /sys/fs/cgroup/

1.上传解压【两台机器】

＃ cd ./usr
＃ mkdir rockerMQ
＃ cd ./rockerMQ
＃ tar -zxvf  /sys/fs/cgroup/apache-rocketmq-all.tar.gz
--这里建一个软连接(在最外面)
＃ln -s /usr/rockerMQ rockermq

2.创建存储路径【两台机器】(可以用默认) 

# mkdir /sys/fs/cgroup/store
# mkdir /sys/fs/cgroup/store/commitlog
# mkdir /sys/fs/cgroup/store/consumequeue
# mkdir /sys/fs/cgroup/store/index
# mkdir /sys/fs/cgroup/store/logs

3.修改日志配置文件【两台机器】

# cd /usr/rocketMQ/conf
# sed -i 's#${user.home}#/sys/fs/cgroup/store#g' *.xml
--ps:为了减少冲突
＃cd /usr/rocketMQ/bin
＃sed -i 's/\r//g'  *

ps:  sed -i 's#${user.home}#/sys/fs/cgroup/store#g' *.xml

4.修改启动脚本参数【两台机器】

＃cd /usr/rocketMQ/bin
＃vi runbroker.sh
----修改 JAVA_OPT="${JAVA_OPT} -server -Xms1g -Xmx1g -Xmn512m - XX:PermSize=128m -XX:MaxPermSize=320m
＃vi runserver.sh
----修改JAVA_OPT="${JAVA_OPT} -server -Xms1g -Xmx1g -Xmn512m - XX:PermSize=128m -XX:MaxPermSize=320m

5.RocketMQ配置文件【两台机器】

# cd /usr/rocketMQ/conf/2m-noslave
--修改 容器1
#vi broker-a.properties
--修改 容器2
#vi broker-b.properties
--建议两个容器都改

配置详情：

#所属集群名字
brokerClusterName=DefaultCluster
#broker名字,注意此处不同的配置文件填写的不一样
brokerName=broker-a|broker-b
#0 表示 Master,>0 表示 Slave
brokerId=0
#nameServer地址,分号分割
namesrvAddr=192.168.1.107:9876;192.168.1.107:9879

＃关键对于docker
brokerIP1=192.168.1.107
brokerIP2=192.168.1.107

#在发送消息时,自动创建服务器不存在的topic,默认创建的队列数
defaultTopicQueueNums=4
#是否允许 Broker 自动创建Topic,建议线下开启,线上关闭
autoCreateTopicEnable=true
#是否允许 Broker 自动创建订阅组,建议线下开启,线上关闭
autoCreateSubscriptionGroup=true
#Broker 对外服务的监听端口
listenPort=10911
#删除文件时间点,默认凌晨 4点
deleteWhen=04
#文件保留时间,默认 48 小时
fileReservedTime=120
#commitLog每个文件的大小默认1G
mapedFileSizeCommitLog=1073741824
#ConsumeQueue每个文件默认存30W条,根据业务情况调整
mapedFileSizeConsumeQueue=300000
#destroyMapedFileIntervalForcibly=120000
#redeleteHangedFileInterval=120000
#检测物理文件磁盘空间
diskMaxUsedSpaceRatio=88

#这里是我的 日志配置
#存储路径
storePathRootDir=/sys/fs/cgroup/store
#commitLog 存储路径
storePathCommitLog=/usr/local/rocketmq/store/commitlog
#消费队列存储路径存储路径
storePathConsumeQueue=/sys/fs/cgroup/store/consumequeue
#消息索引存储路径
storePathIndex=/sys/fs/cgroup/store/index
#checkpoint 文件存储路径
storeCheckpoint=/sys/fs/cgroup/store/checkpoint
#abort 文件存储路径
abortFile=/sys/fs/cgroup/store/abort

#限制的消息大小
maxMessageSize=65536
#flushCommitLogLeastPages=4
#flushConsumeQueueLeastPages=2
#flushCommitLogThoroughInterval=10000
#flushConsumeQueueThoroughInterval=60000
#Broker 的角色
#- ASYNC_MASTER 异步复制Master
#- SYNC_MASTER 同步双写Master
#- SLAVE
brokerRole=ASYNC_MASTER
#刷盘方式
#- ASYNC_FLUSH 异步刷盘
#- SYNC_FLUSH 同步刷盘
flushDiskType=ASYNC_FLUSH

#checkTransactionMessageEnable=false
#发消息线程池数量
#sendMessageThreadPoolNums=128
#拉消息线程池数量
#pullMessageThreadPoolNums=128

ps：注意上面 broker

如：容器1：brokerName=broker-a     listenPort＝10911

        容器2：brokerName=broker-b    listenPort＝10915

准备工作完成了～～～

6.启动NameServer【两台机器】 

＃cd /usr/rocketMQ/bin
＃nohup sh mqnamesrv &

＃jps
＃tail -f -n 500 /sys/fs/cgroup/store/logs/rocketmqlogs/namesrv.log

7.启动BrokerServer 

＃nohup sh mqbroker -c /rocketmq/conf/2m-noslave/broker-a.properties >/dev/null 2>&1 &
--另外一个容器
＃nohup sh mqbroker -c /rocketmq/conf/2m-noslave/broker-b.properties >/dev/null 2>&1 &

＃jps
＃tail -f -n 500 /sys/fs/cgroup/store/logs/rocketmqlogs/broker.log

8.关闭 

＃cd /usr/rocketMQ/bin
＃sh mqshutdown broker
＃sh mqshutdown namers
＃jps

java测试代码：

－－product

import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;

import java.util.concurrent.TimeUnit;

public class Producer {
public static void main(String[] args) throws MQClientException,
InterruptedException {
/**
* 一个应用创建一个Producer，由应用来维护此对象，可以设置为全局对象或者单例<br>
* 注意：ProducerGroupName需要由应用来保证唯一<br>
* ProducerGroup这个概念发送普通的消息时，作用不大，但是发送分布式事务消息时，比较关键，
* 因为服务器会回查这个Group下的任意一个Producer
*/
DefaultMQProducer producer = new DefaultMQProducer("ProducerGroupName");
producer.setNamesrvAddr("192.168.1.7:9876;192.168.1.7:9879");
producer.setInstanceName("Producer");
producer.setVipChannelEnabled(false);

/**
* Producer对象在使用之前必须要调用start初始化，初始化一次即可<br>
* 注意：切记不可以在每次发送消息时，都调用start方法
*/
producer.start();

/**
* 下面这段代码表明一个Producer对象可以发送多个topic，多个tag的消息。
* 注意：send方法是同步调用，只要不抛异常就标识成功。但是发送成功也可会有多种状态，<br>
* 例如消息写入Master成功，但是Slave不成功，这种情况消息属于成功，但是对于个别应用如果对消息可靠性要求极高，<br>
* 需要对这种情况做处理。另外，消息可能会存在发送失败的情况，失败重试由应用来处理。
*/
for (int i = 0; i < 2; i++) {
try {
{
Message msg = new Message("TopicTest1",// topic
"TagA",// tag
"OrderID001",// key
("Hello MetaQ-A"+i).getBytes());// body
SendResult sendResult = producer.send(msg);
System.out.println(sendResult);
}

{
Message msg = new Message("TopicTest2",// topic
"TagB",// tag
"OrderID0034",// key
("Hello MetaQ-B"+i).getBytes());// body
SendResult sendResult = producer.send(msg);
System.out.println(sendResult);
}

{
Message msg = new Message("TopicTest3",// topic
"TagC",// tag
"OrderID061",// key
("Hello MetaQ-C"+i).getBytes());// body
SendResult sendResult = producer.send(msg);
System.out.println(sendResult);
}
} catch (Exception e) {
e.printStackTrace();
}
TimeUnit.MILLISECONDS.sleep(1000);
}

/**
* 应用退出时，要调用shutdown来清理资源，关闭网络连接，从MetaQ服务器上注销自己
* 注意：我们建议应用在JBOSS、Tomcat等容器的退出钩子里调用shutdown方法
*/
producer.shutdown();
}
}

－－Consumer

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.common.message.MessageExt;

import java.util.List;

public class PushConsumer {
/**
* 当前例子是PushConsumer用法，使用方式给用户感觉是消息从RocketMQ服务器推到了应用客户端。<br>
* 但是实际PushConsumer内部是使用长轮询Pull方式从MetaQ服务器拉消息，然后再回调用户Listener方法<br>
*/
public static void main(String[] args) throws InterruptedException,
MQClientException {
/**
* 一个应用创建一个Consumer，由应用来维护此对象，可以设置为全局对象或者单例<br>
* 注意：ConsumerGroupName需要由应用来保证唯一
*/
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(
"ConsumerGroupName");
consumer.setNamesrvAddr("192.168.1.7:9876;192.168.1.7:9879");
consumer.setInstanceName("Consumber");

/**
* 订阅指定topic下tags分别等于TagA或TagC或TagD
*/
consumer.subscribe("TopicTest1", "TagA || TagC || TagD");
/**
* 订阅指定topic下所有消息<br>
* 注意：一个consumer对象可以订阅多个topic
*/
consumer.subscribe("TopicTest2", "*");

consumer.registerMessageListener(new MessageListenerConcurrently() {

/**
* 默认msgs里只有一条消息，可以通过设置consumeMessageBatchMaxSize参数来批量接收消息
*/
@Override
public ConsumeConcurrentlyStatus consumeMessage(
List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
System.out.println(Thread.currentThread().getName()
+ " Receive New Messages: " + msgs.size());

MessageExt msg = msgs.get(0);
if (msg.getTopic().equals("TopicTest1")) {
// 执行TopicTest1的消费逻辑
if (msg.getTags() != null && msg.getTags().equals("TagA")) {
// 执行TagA的消费
System.out.println(new String(msg.getBody()));
} else if (msg.getTags() != null
&& msg.getTags().equals("TagC")) {
// 执行TagC的消费
} else if (msg.getTags() != null
&& msg.getTags().equals("TagD")) {
// 执行TagD的消费
}
} else if (msg.getTopic().equals("TopicTest2")) {
System.out.println(new String(msg.getBody()));
}

return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
}
});

/**
* Consumer对象在使用之前必须要调用start初始化，初始化一次即可<br>
*/
consumer.start();

System.out.println("Consumer Started.");
}
}